yaffs First round of name changes

[yaffs2.git] / yaffs_verify.c

diff --git a/yaffs_verify.c b/yaffs_verify.c
index a600aa6b1e6b3bfe4e07b13463c0cbc73db349ca..b231799cd77815f2ccd3d2086068076de3bf69ac 100644 (file)
--- a/yaffs_verify.c
+++ b/yaffs_verify.c
@@ -18,22 +18,22 @@
 #include "yaffs_getblockinfo.h"
 #include "yaffs_nand.h"
 
 #include "yaffs_getblockinfo.h"
 #include "yaffs_nand.h"
 

-int yaffs_SkipVerification(yaffs_Device *dev)
+int yaffs_skip_verification(yaffs_Device *dev)

 {
        dev=dev;
 {
        dev=dev;

-       return !(yaffs_traceMask & (YAFFS_TRACE_VERIFY | YAFFS_TRACE_VERIFY_FULL));
+       return !(yaffs_trace_mask & (YAFFS_TRACE_VERIFY | YAFFS_TRACE_VERIFY_FULL));

 }
 
 }
 

-static int yaffs_SkipFullVerification(yaffs_Device *dev)
+static int yaffs_skip_full_verification(yaffs_Device *dev)

 {
        dev=dev;
 {
        dev=dev;

-       return !(yaffs_traceMask & (YAFFS_TRACE_VERIFY_FULL));
+       return !(yaffs_trace_mask & (YAFFS_TRACE_VERIFY_FULL));

 }
 
 }
 

-static int yaffs_SkipNANDVerification(yaffs_Device *dev)
+static int yaffs_skip_nand_verification(yaffs_Device *dev)

 {
        dev=dev;
 {
        dev=dev;

-       return !(yaffs_traceMask & (YAFFS_TRACE_VERIFY_NAND));
+       return !(yaffs_trace_mask & (YAFFS_TRACE_VERIFY_NAND));

 }
 
 
 }
 
 


@@ -51,12 +51,12 @@ static const char *blockStateName[] = {
 };
 
 
 };
 
 

-void yaffs_VerifyBlock(yaffs_Device *dev, yaffs_BlockInfo *bi, int n)
+void yaffs_verify_blk(yaffs_Device *dev, yaffs_BlockInfo *bi, int n)

 {
        int actuallyUsed;
        int inUse;
 
 {
        int actuallyUsed;
        int inUse;
 

-       if (yaffs_SkipVerification(dev))
+       if (yaffs_skip_verification(dev))

                return;
 
        /* Report illegal runtime states */
                return;
 
        /* Report illegal runtime states */


@@ -83,7 +83,7 @@ void yaffs_VerifyBlock(yaffs_Device *dev, yaffs_BlockInfo *bi, int n)
 
 
        /* Check chunk bitmap legal */
 
 
        /* Check chunk bitmap legal */

-       inUse = yaffs_CountChunkBits(dev, n);
+       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->pagesInUse)
                T(YAFFS_TRACE_VERIFY, (TSTR("Block %d has inconsistent values pagesInUse %d counted chunk bits %d"TENDSTR),
                        n, bi->pagesInUse, inUse));


@@ -92,9 +92,9 @@ void yaffs_VerifyBlock(yaffs_Device *dev, yaffs_BlockInfo *bi, int n)
 
 
 
 
 
 

-void yaffs_VerifyCollectedBlock(yaffs_Device *dev, yaffs_BlockInfo *bi, int n)
+void yaffs_verify_collected_blk(yaffs_Device *dev, yaffs_BlockInfo *bi, int n)

 {
 {

-       yaffs_VerifyBlock(dev, bi, n);
+       yaffs_verify_blk(dev, bi, n);

 
        /* After collection the block should be in the erased state */
 
 
        /* After collection the block should be in the erased state */
 


@@ -105,20 +105,20 @@ void yaffs_VerifyCollectedBlock(yaffs_Device *dev, yaffs_BlockInfo *bi, int n)
        }
 }
 
        }
 }
 

-void yaffs_VerifyBlocks(yaffs_Device *dev)
+void yaffs_verify_blocks(yaffs_Device *dev)

 {
        int i;
        int nBlocksPerState[YAFFS_NUMBER_OF_BLOCK_STATES];
        int nIllegalBlockStates = 0;
 
 {
        int i;
        int nBlocksPerState[YAFFS_NUMBER_OF_BLOCK_STATES];
        int nIllegalBlockStates = 0;
 

-       if (yaffs_SkipVerification(dev))
+       if (yaffs_skip_verification(dev))

                return;
 
        memset(nBlocksPerState, 0, sizeof(nBlocksPerState));
 
        for (i = dev->internalStartBlock; i <= dev->internalEndBlock; i++) {
                return;
 
        memset(nBlocksPerState, 0, sizeof(nBlocksPerState));
 
        for (i = dev->internalStartBlock; i <= dev->internalEndBlock; i++) {

-               yaffs_BlockInfo *bi = yaffs_GetBlockInfo(dev, i);
-               yaffs_VerifyBlock(dev, bi, i);
+               yaffs_BlockInfo *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->blockState < YAFFS_NUMBER_OF_BLOCK_STATES)
                        nBlocksPerState[bi->blockState]++;


@@ -161,9 +161,9 @@ void yaffs_VerifyBlocks(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.
  */
  * 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_VerifyObjectHeader(yaffs_Object *obj, yaffs_ObjectHeader *oh, yaffs_ExtendedTags *tags, int parentCheck)
+void yaffs_verify_oh(yaffs_Object *obj, yaffs_ObjectHeader *oh, yaffs_ExtendedTags *tags, int parentCheck)

 {
 {

-       if (obj && yaffs_SkipVerification(obj->myDev))
+       if (obj && yaffs_skip_verification(obj->myDev))

                return;
 
        if (!(tags && obj && oh)) {
                return;
 
        if (!(tags && obj && oh)) {


@@ -218,7 +218,7 @@ void yaffs_VerifyObjectHeader(yaffs_Object *obj, yaffs_ObjectHeader *oh, yaffs_E
 
 #if 0
 /* Not being used, but don't want to throw away yet */
 
 #if 0
 /* Not being used, but don't want to throw away yet */

-int yaffs_VerifyTnodeWorker(yaffs_Object *obj, yaffs_Tnode *tn,
+int yaffs_verify_tnode_worker(yaffs_Object *obj, yaffs_Tnode *tn,

                                        __u32 level, int chunkOffset)
 {
        int i;
                                        __u32 level, int chunkOffset)
 {
        int i;


@@ -230,7 +230,7 @@ int yaffs_VerifyTnodeWorker(yaffs_Object *obj, yaffs_Tnode *tn,
 
                        for (i = 0; i < YAFFS_NTNODES_INTERNAL && ok; i++) {
                                if (tn->internal[i]) {
 
                        for (i = 0; i < YAFFS_NTNODES_INTERNAL && ok; i++) {
                                if (tn->internal[i]) {

-                                       ok = yaffs_VerifyTnodeWorker(obj,
+                                       ok = yaffs_verify_tnode_worker(obj,

                                                        tn->internal[i],
                                                        level - 1,
                                                        (chunkOffset<<YAFFS_TNODES_INTERNAL_BITS) + i);
                                                        tn->internal[i],
                                                        level - 1,
                                                        (chunkOffset<<YAFFS_TNODES_INTERNAL_BITS) + i);


@@ -243,11 +243,11 @@ int yaffs_VerifyTnodeWorker(yaffs_Object *obj, yaffs_Tnode *tn,
                        chunkOffset <<=  YAFFS_TNODES_LEVEL0_BITS;
 
                        for (i = 0; i < YAFFS_NTNODES_LEVEL0; i++) {
                        chunkOffset <<=  YAFFS_TNODES_LEVEL0_BITS;
 
                        for (i = 0; i < YAFFS_NTNODES_LEVEL0; i++) {

-                               __u32 theChunk = yaffs_GetChunkGroupBase(dev, tn, 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)); */
 
                                if (theChunk > 0) {
                                        /* T(~0,(TSTR("verifying (%d:%d) %d"TENDSTR),tags.objectId,tags.chunkId,theChunk)); */

-                                       yaffs_ReadChunkWithTagsFromNAND(dev, theChunk, NULL, &tags);
+                                       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,
                                        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,


@@ -265,7 +265,7 @@ int yaffs_VerifyTnodeWorker(yaffs_Object *obj, yaffs_Tnode *tn,
 
 #endif
 
 
 #endif
 

-void yaffs_VerifyFile(yaffs_Object *obj)
+void yaffs_verify_file(yaffs_Object *obj)

 {
        int requiredTallness;
        int actualTallness;
 {
        int requiredTallness;
        int actualTallness;


@@ -280,7 +280,7 @@ void yaffs_VerifyFile(yaffs_Object *obj)
        if (!obj)
                return;
 
        if (!obj)
                return;
 

-       if (yaffs_SkipVerification(obj->myDev))
+       if (yaffs_skip_verification(obj->myDev))

                return;
 
        dev = obj->myDev;
                return;
 
        dev = obj->myDev;


@@ -302,17 +302,17 @@ void yaffs_VerifyFile(yaffs_Object *obj)
         * checking the tags for every chunk match.
         */
 
         * checking the tags for every chunk match.
         */
 

-       if (yaffs_SkipNANDVerification(dev))
+       if (yaffs_skip_nand_verification(dev))

                return;
 
        for (i = 1; i <= lastChunk; i++) {
                return;
 
        for (i = 1; i <= lastChunk; i++) {

-               tn = yaffs_FindLevel0Tnode(dev, &obj->variant.fileVariant, i);
+               tn = yaffs_find_tnode_0(dev, &obj->variant.fileVariant, i);

 
                if (tn) {
 
                if (tn) {

-                       __u32 theChunk = yaffs_GetChunkGroupBase(dev, tn, i);
+                       __u32 theChunk = yaffs_get_group_base(dev, tn, i);

                        if (theChunk > 0) {
                                /* T(~0,(TSTR("verifying (%d:%d) %d"TENDSTR),objectId,i,theChunk)); */
                        if (theChunk > 0) {
                                /* T(~0,(TSTR("verifying (%d:%d) %d"TENDSTR),objectId,i,theChunk)); */

-                               yaffs_ReadChunkWithTagsFromNAND(dev, theChunk, NULL, &tags);
+                               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,
                                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,


@@ -324,29 +324,29 @@ void yaffs_VerifyFile(yaffs_Object *obj)
 }
 
 
 }
 
 

-void yaffs_VerifyHardLink(yaffs_Object *obj)
+void yaffs_verify_link(yaffs_Object *obj)

 {
 {

-       if (obj && yaffs_SkipVerification(obj->myDev))
+       if (obj && yaffs_skip_verification(obj->myDev))

                return;
 
        /* Verify sane equivalent object */
 }
 
                return;
 
        /* Verify sane equivalent object */
 }
 

-void yaffs_VerifySymlink(yaffs_Object *obj)
+void yaffs_verify_symlink(yaffs_Object *obj)

 {
 {

-       if (obj && yaffs_SkipVerification(obj->myDev))
+       if (obj && yaffs_skip_verification(obj->myDev))

                return;
 
        /* Verify symlink string */
 }
 
                return;
 
        /* Verify symlink string */
 }
 

-void yaffs_VerifySpecial(yaffs_Object *obj)
+void yaffs_verify_special(yaffs_Object *obj)

 {
 {

-       if (obj && yaffs_SkipVerification(obj->myDev))
+       if (obj && yaffs_skip_verification(obj->myDev))

                return;
 }
 
                return;
 }
 

-void yaffs_VerifyObject(yaffs_Object *obj)
+void yaffs_verify_obj(yaffs_Object *obj)

 {
        yaffs_Device *dev;
 
 {
        yaffs_Device *dev;
 


@@ -366,7 +366,7 @@ void yaffs_VerifyObject(yaffs_Object *obj)
 
        dev = obj->myDev;
 
 
        dev = obj->myDev;
 

-       if (yaffs_SkipVerification(dev))
+       if (yaffs_skip_verification(dev))

                return;
 
        /* Check sane object header chunk */
                return;
 
        /* Check sane object header chunk */


@@ -377,7 +377,7 @@ void yaffs_VerifyObject(yaffs_Object *obj)
        chunkInRange = (((unsigned)(obj->hdrChunk)) >= chunkMin && ((unsigned)(obj->hdrChunk)) <= chunkMax);
        chunkIdOk = chunkInRange || (obj->hdrChunk == 0);
        chunkValid = chunkInRange &&
        chunkInRange = (((unsigned)(obj->hdrChunk)) >= chunkMin && ((unsigned)(obj->hdrChunk)) <= chunkMax);
        chunkIdOk = chunkInRange || (obj->hdrChunk == 0);
        chunkValid = chunkInRange &&

-                       yaffs_CheckChunkBit(dev,
+                       yaffs_check_chunk_bit(dev,

                                        obj->hdrChunk / dev->param.nChunksPerBlock,
                                        obj->hdrChunk % dev->param.nChunksPerBlock);
        chunkShouldNotBeDeleted = chunkInRange && !chunkValid;
                                        obj->hdrChunk / dev->param.nChunksPerBlock,
                                        obj->hdrChunk % dev->param.nChunksPerBlock);
        chunkShouldNotBeDeleted = chunkInRange && !chunkValid;


@@ -391,19 +391,19 @@ void yaffs_VerifyObject(yaffs_Object *obj)
                        chunkShouldNotBeDeleted ? ",marked as deleted" : ""));
        }
 
                        chunkShouldNotBeDeleted ? ",marked as deleted" : ""));
        }
 

-       if (chunkValid && !yaffs_SkipNANDVerification(dev)) {
+       if (chunkValid && !yaffs_skip_nand_verification(dev)) {

                yaffs_ExtendedTags tags;
                yaffs_ObjectHeader *oh;
                yaffs_ExtendedTags tags;
                yaffs_ObjectHeader *oh;

-               __u8 *buffer = yaffs_GetTempBuffer(dev, __LINE__);
+               __u8 *buffer = yaffs_get_temp_buffer(dev, __LINE__);

 
                oh = (yaffs_ObjectHeader *)buffer;
 
 
                oh = (yaffs_ObjectHeader *)buffer;
 

-               yaffs_ReadChunkWithTagsFromNAND(dev, obj->hdrChunk, buffer,
+               yaffs_rd_chunk_tags_nand(dev, obj->hdrChunk, buffer,

                                &tags);
 
                                &tags);
 

-               yaffs_VerifyObjectHeader(obj, oh, &tags, 1);
+               yaffs_verify_oh(obj, oh, &tags, 1);

 
 

-               yaffs_ReleaseTempBuffer(dev, buffer, __LINE__);
+               yaffs_release_temp_buffer(dev, buffer, __LINE__);

        }
 
        /* Verify it has a parent */
        }
 
        /* Verify it has a parent */


@@ -423,19 +423,19 @@ void yaffs_VerifyObject(yaffs_Object *obj)
 
        switch (obj->variantType) {
        case YAFFS_OBJECT_TYPE_FILE:
 
        switch (obj->variantType) {
        case YAFFS_OBJECT_TYPE_FILE:

-               yaffs_VerifyFile(obj);
+               yaffs_verify_file(obj);

                break;
        case YAFFS_OBJECT_TYPE_SYMLINK:
                break;
        case YAFFS_OBJECT_TYPE_SYMLINK:

-               yaffs_VerifySymlink(obj);
+               yaffs_verify_symlink(obj);

                break;
        case YAFFS_OBJECT_TYPE_DIRECTORY:
                break;
        case YAFFS_OBJECT_TYPE_DIRECTORY:

-               yaffs_VerifyDirectory(obj);
+               yaffs_verify_dir(obj);

                break;
        case YAFFS_OBJECT_TYPE_HARDLINK:
                break;
        case YAFFS_OBJECT_TYPE_HARDLINK:

-               yaffs_VerifyHardLink(obj);
+               yaffs_verify_link(obj);

                break;
        case YAFFS_OBJECT_TYPE_SPECIAL:
                break;
        case YAFFS_OBJECT_TYPE_SPECIAL:

-               yaffs_VerifySpecial(obj);
+               yaffs_verify_special(obj);

                break;
        case YAFFS_OBJECT_TYPE_UNKNOWN:
        default:
                break;
        case YAFFS_OBJECT_TYPE_UNKNOWN:
        default:


@@ -446,13 +446,13 @@ void yaffs_VerifyObject(yaffs_Object *obj)
        }
 }
 
        }
 }
 

-void yaffs_VerifyObjects(yaffs_Device *dev)
+void yaffs_verify_objects(yaffs_Device *dev)

 {
        yaffs_Object *obj;
        int i;
        struct ylist_head *lh;
 
 {
        yaffs_Object *obj;
        int i;
        struct ylist_head *lh;
 

-       if (yaffs_SkipVerification(dev))
+       if (yaffs_skip_verification(dev))

                return;
 
        /* Iterate through the objects in each hash entry */
                return;
 
        /* Iterate through the objects in each hash entry */


@@ -461,14 +461,14 @@ void yaffs_VerifyObjects(yaffs_Device *dev)
                ylist_for_each(lh, &dev->objectBucket[i].list) {
                        if (lh) {
                                obj = ylist_entry(lh, yaffs_Object, hashLink);
                ylist_for_each(lh, &dev->objectBucket[i].list) {
                        if (lh) {
                                obj = ylist_entry(lh, yaffs_Object, hashLink);

-                               yaffs_VerifyObject(obj);
+                               yaffs_verify_obj(obj);

                        }
                }
        }
 }
 
 
                        }
                }
        }
 }
 
 

-void yaffs_VerifyObjectInDirectory(yaffs_Object *obj)
+void yaffs_verify_obj_in_dir(yaffs_Object *obj)

 {
        struct ylist_head *lh;
        yaffs_Object *listObj;
 {
        struct ylist_head *lh;
        yaffs_Object *listObj;


@@ -481,7 +481,7 @@ void yaffs_VerifyObjectInDirectory(yaffs_Object *obj)
                return;
        }
 
                return;
        }
 

-       if (yaffs_SkipVerification(obj->myDev))
+       if (yaffs_skip_verification(obj->myDev))

                return;
 
        if (!obj->parent) {
                return;
 
        if (!obj->parent) {


@@ -500,7 +500,7 @@ void yaffs_VerifyObjectInDirectory(yaffs_Object *obj)
        ylist_for_each(lh, &obj->parent->variant.directoryVariant.children) {
                if (lh) {
                        listObj = ylist_entry(lh, yaffs_Object, siblings);
        ylist_for_each(lh, &obj->parent->variant.directoryVariant.children) {
                if (lh) {
                        listObj = ylist_entry(lh, yaffs_Object, siblings);

-                       yaffs_VerifyObject(listObj);
+                       yaffs_verify_obj(listObj);

                        if (obj == listObj)
                                count++;
                }
                        if (obj == listObj)
                                count++;
                }


@@ -512,7 +512,7 @@ void yaffs_VerifyObjectInDirectory(yaffs_Object *obj)
        }
 }
 
        }
 }
 

-void yaffs_VerifyDirectory(yaffs_Object *directory)
+void yaffs_verify_dir(yaffs_Object *directory)

 {
        struct ylist_head *lh;
        yaffs_Object *listObj;
 {
        struct ylist_head *lh;
        yaffs_Object *listObj;


@@ -522,7 +522,7 @@ void yaffs_VerifyDirectory(yaffs_Object *directory)
                return;
        }
 
                return;
        }
 

-       if (yaffs_SkipFullVerification(directory->myDev))
+       if (yaffs_skip_full_verification(directory->myDev))

                return;
 
        if (directory->variantType != YAFFS_OBJECT_TYPE_DIRECTORY) {
                return;
 
        if (directory->variantType != YAFFS_OBJECT_TYPE_DIRECTORY) {


@@ -539,22 +539,22 @@ void yaffs_VerifyDirectory(yaffs_Object *directory)
                                T(YAFFS_TRACE_ALWAYS, (TSTR("Object in directory list has wrong parent %p" TENDSTR), listObj->parent));
                                YBUG();
                        }
                                T(YAFFS_TRACE_ALWAYS, (TSTR("Object in directory list has wrong parent %p" TENDSTR), listObj->parent));
                                YBUG();
                        }

-                       yaffs_VerifyObjectInDirectory(listObj);
+                       yaffs_verify_obj_in_dir(listObj);

                }
        }
 }
 
                }
        }
 }
 

-static int yaffs_freeVerificationFailures;
+static int yaffs_free_verification_failures;

 
 

-void yaffs_VerifyFreeChunks(yaffs_Device *dev)
+void yaffs_verify_free_chunks(yaffs_Device *dev)

 {
        int counted;
        int difference;
 
 {
        int counted;
        int difference;
 

-       if (yaffs_SkipVerification(dev))
+       if (yaffs_skip_verification(dev))

                return;
 
                return;
 

-       counted = yaffs_CountFreeChunks(dev);
+       counted = yaffs_count_free_chunks(dev);

 
        difference = dev->nFreeChunks - counted;
 
 
        difference = dev->nFreeChunks - counted;
 


@@ -562,11 +562,11 @@ void yaffs_VerifyFreeChunks(yaffs_Device *dev)
                T(YAFFS_TRACE_ALWAYS,
                  (TSTR("Freechunks verification failure %d %d %d" TENDSTR),
                   dev->nFreeChunks, counted, difference));
                T(YAFFS_TRACE_ALWAYS,
                  (TSTR("Freechunks verification failure %d %d %d" TENDSTR),
                   dev->nFreeChunks, counted, difference));

-               yaffs_freeVerificationFailures++;
+               yaffs_free_verification_failures++;

        }
 }
 
        }
 }
 

-int yaffs_VerifyFileSanity(yaffs_Object *in)
+int yaffs_verify_file_sane(yaffs_Object *in)

 {
 #if 0
        int chunk;
 {
 #if 0
        int chunk;


@@ -589,21 +589,21 @@ int yaffs_VerifyFileSanity(yaffs_Object *in)
            (fSize + in->myDev->nDataBytesPerChunk - 1) / in->myDev->nDataBytesPerChunk;
 
        for (chunk = 1; chunk <= nChunks; chunk++) {
            (fSize + in->myDev->nDataBytesPerChunk - 1) / in->myDev->nDataBytesPerChunk;
 
        for (chunk = 1; chunk <= nChunks; chunk++) {

-               tn = yaffs_FindLevel0Tnode(in->myDev, &in->variant.fileVariant,
+               tn = yaffs_find_tnode_0(in->myDev, &in->variant.fileVariant,

                                           chunk);
 
                if (tn) {
 
                                           chunk);
 
                if (tn) {
 

-                       theChunk = yaffs_GetChunkGroupBase(dev, tn, chunk);
+                       theChunk = yaffs_get_group_base(dev, tn, chunk);

 
 

-                       if (yaffs_CheckChunkBits
+                       if (yaffs_check_chunk_bits

                            (dev, theChunk / dev->param.nChunksPerBlock,
                             theChunk % dev->param.nChunksPerBlock)) {
 
                            (dev, theChunk / dev->param.nChunksPerBlock,
                             theChunk % dev->param.nChunksPerBlock)) {
 

-                               yaffs_ReadChunkTagsFromNAND(in->myDev, theChunk,
+                               yaffs_rd_chunk_tags_nand(in->myDev, theChunk,

                                                            tags,
                                                            &chunkDeleted);
                                                            tags,
                                                            &chunkDeleted);

-                               if (yaffs_TagsMatch
+                               if (yaffs_tags_match

                                    (tags, in->objectId, chunk, chunkDeleted)) {
                                        /* found it; */
 
                                    (tags, in->objectId, chunk, chunkDeleted)) {
                                        /* found it; */