yaffs Change tracing to yaffs_trace
[yaffs2.git] / yaffs_verify.c
index fee3a1e..c12894d 100644 (file)
@@ -59,17 +59,17 @@ void yaffs_verify_blk(struct yaffs_dev *dev, struct yaffs_block_info *bi, int n)
 
        /* Report illegal runtime states */
        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));
+               yaffs_trace(YAFFS_TRACE_VERIFY,
+                       "Block %d has undefined state %d",
+                       n, bi->block_state);
 
        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,
-                  block_state_name[bi->block_state]));
+               yaffs_trace(YAFFS_TRACE_VERIFY,
+                       "Block %d has bad run-state %s",
+                       n, block_state_name[bi->block_state]);
        }
 
        /* Check pages in use and soft deletions are legal */
@@ -81,18 +81,16 @@ void yaffs_verify_blk(struct yaffs_dev *dev, struct yaffs_block_info *bi, int n)
            || bi->soft_del_pages < 0
            || bi->soft_del_pages > dev->param.chunks_per_block
            || actually_used < 0 || actually_used > 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));
+               yaffs_trace(YAFFS_TRACE_VERIFY,
+                       "Block %d has illegal values pages_in_used %d soft_del_pages %d",
+                       n, bi->pages_in_use, bi->soft_del_pages);
 
        /* Check chunk bitmap legal */
        in_use = yaffs_count_chunk_bits(dev, n);
        if (in_use != 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, in_use));
+               yaffs_trace(YAFFS_TRACE_VERIFY,
+                       "Block %d has inconsistent values pages_in_use %d counted chunk bits %d",
+                       n, bi->pages_in_use, in_use);
 
 }
 
@@ -105,10 +103,9 @@ void yaffs_verify_collected_blk(struct yaffs_dev *dev,
 
        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->block_state));
+               yaffs_trace(YAFFS_TRACE_ERROR,
+                       "Block %d is in state %d after gc, should be erased",
+                       n, bi->block_state);
        }
 }
 
@@ -133,38 +130,36 @@ void yaffs_verify_blocks(struct yaffs_dev *dev)
                        illegal_states++;
        }
 
-       T(YAFFS_TRACE_VERIFY, (TSTR("" TENDSTR)));
-       T(YAFFS_TRACE_VERIFY, (TSTR("Block summary" TENDSTR)));
+       yaffs_trace(YAFFS_TRACE_VERIFY, "Block summary");
 
-       T(YAFFS_TRACE_VERIFY,
-         (TSTR("%d blocks have illegal states" TENDSTR), illegal_states));
+       yaffs_trace(YAFFS_TRACE_VERIFY,
+               "%d blocks have illegal states",
+               illegal_states);
        if (state_count[YAFFS_BLOCK_STATE_ALLOCATING] > 1)
-               T(YAFFS_TRACE_VERIFY,
-                 (TSTR("Too many allocating blocks" TENDSTR)));
+               yaffs_trace(YAFFS_TRACE_VERIFY,
+                       "Too many allocating blocks");
 
        for (i = 0; i < YAFFS_NUMBER_OF_BLOCK_STATES; i++)
-               T(YAFFS_TRACE_VERIFY,
-                 (TSTR("%s %d blocks" TENDSTR),
-                  block_state_name[i], state_count[i]));
+               yaffs_trace(YAFFS_TRACE_VERIFY,
+                       "%s %d blocks",
+                       block_state_name[i], state_count[i]);
 
        if (dev->blocks_in_checkpt != state_count[YAFFS_BLOCK_STATE_CHECKPOINT])
-               T(YAFFS_TRACE_VERIFY,
-                 (TSTR("Checkpoint block count wrong dev %d count %d" TENDSTR),
-                  dev->blocks_in_checkpt,
-                  state_count[YAFFS_BLOCK_STATE_CHECKPOINT]));
+               yaffs_trace(YAFFS_TRACE_VERIFY,
+                       "Checkpoint block count wrong dev %d count %d",
+                       dev->blocks_in_checkpt,
+                       state_count[YAFFS_BLOCK_STATE_CHECKPOINT]);
 
        if (dev->n_erased_blocks != state_count[YAFFS_BLOCK_STATE_EMPTY])
-               T(YAFFS_TRACE_VERIFY,
-                 (TSTR("Erased block count wrong dev %d count %d" TENDSTR),
-                  dev->n_erased_blocks, state_count[YAFFS_BLOCK_STATE_EMPTY]));
+               yaffs_trace(YAFFS_TRACE_VERIFY,
+                       "Erased block count wrong dev %d count %d",
+                       dev->n_erased_blocks,
+                       state_count[YAFFS_BLOCK_STATE_EMPTY]);
 
        if (state_count[YAFFS_BLOCK_STATE_COLLECTING] > 1)
-               T(YAFFS_TRACE_VERIFY,
-                 (TSTR("Too many collecting blocks %d (max is 1)" TENDSTR),
-                  state_count[YAFFS_BLOCK_STATE_COLLECTING]));
-
-       T(YAFFS_TRACE_VERIFY, (TSTR("" TENDSTR)));
-
+               yaffs_trace(YAFFS_TRACE_VERIFY,
+                       "Too many collecting blocks %d (max is 1)",
+                       state_count[YAFFS_BLOCK_STATE_COLLECTING]);
 }
 
 /*
@@ -178,22 +173,22 @@ void yaffs_verify_oh(struct yaffs_obj *obj, struct yaffs_obj_hdr *oh,
                return;
 
        if (!(tags && obj && oh)) {
-               T(YAFFS_TRACE_VERIFY,
-                 (TSTR("Verifying object header tags %p obj %p oh %p" TENDSTR),
-                  tags, obj, oh));
+               yaffs_trace(YAFFS_TRACE_VERIFY,
+                       "Verifying object header tags %p obj %p oh %p",
+                       tags, obj, oh);
                return;
        }
 
        if (oh->type <= YAFFS_OBJECT_TYPE_UNKNOWN ||
            oh->type > YAFFS_OBJECT_TYPE_MAX)
-               T(YAFFS_TRACE_VERIFY,
-                 (TSTR("Obj %d header type is illegal value 0x%x" TENDSTR),
-                  tags->obj_id, oh->type));
+               yaffs_trace(YAFFS_TRACE_VERIFY,
+                       "Obj %d header type is illegal value 0x%x",
+                       tags->obj_id, oh->type);
 
        if (tags->obj_id != obj->obj_id)
-               T(YAFFS_TRACE_VERIFY,
-                 (TSTR("Obj %d header mismatch obj_id %d" TENDSTR),
-                  tags->obj_id, obj->obj_id));
+               yaffs_trace(YAFFS_TRACE_VERIFY,
+                       "Obj %d header mismatch obj_id %d",
+                       tags->obj_id, obj->obj_id);
 
        /*
         * Check that the object's parent ids match if parent_check requested.
@@ -202,28 +197,28 @@ void yaffs_verify_oh(struct yaffs_obj *obj, struct yaffs_obj_hdr *oh,
         */
 
        if (parent_check && tags->obj_id > 1 && !obj->parent)
-               T(YAFFS_TRACE_VERIFY,
-                 (TSTR
-                  ("Obj %d header mismatch parent_id %d obj->parent is NULL"
-                   TENDSTR), tags->obj_id, oh->parent_obj_id));
+               yaffs_trace(YAFFS_TRACE_VERIFY,
+                       "Obj %d header mismatch parent_id %d obj->parent is NULL",
+                       tags->obj_id, oh->parent_obj_id);
 
        if (parent_check && obj->parent &&
            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 parent_id %d parent_obj_id %d"
-                   TENDSTR), tags->obj_id, oh->parent_obj_id,
-                  obj->parent->obj_id));
+               yaffs_trace(YAFFS_TRACE_VERIFY,
+                       "Obj %d header mismatch parent_id %d parent_obj_id %d",
+                       tags->obj_id, oh->parent_obj_id,
+                       obj->parent->obj_id);
 
        if (tags->obj_id > 1 && oh->name[0] == 0)       /* Null name */
-               T(YAFFS_TRACE_VERIFY,
-                 (TSTR("Obj %d header name is NULL" TENDSTR), obj->obj_id));
+               yaffs_trace(YAFFS_TRACE_VERIFY,
+                       "Obj %d header name is NULL",
+                       obj->obj_id);
 
        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->obj_id));
+               yaffs_trace(YAFFS_TRACE_VERIFY,
+                       "Obj %d header name is 0xFF",
+                       obj->obj_id);
 }
 
 void yaffs_verify_file(struct yaffs_obj *obj)
@@ -276,13 +271,11 @@ void yaffs_verify_file(struct yaffs_obj *obj)
                                /* T(~0,(TSTR("verifying (%d:%d) %d"TENDSTR),obj_id,i,the_chunk)); */
                                yaffs_rd_chunk_tags_nand(dev, the_chunk, NULL,
                                                         &tags);
-                               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, the_chunk,
-                                          tags.obj_id, tags.chunk_id));
-                               }
+                               if (tags.obj_id != obj_id || tags.chunk_id != i)
+                               yaffs_trace(YAFFS_TRACE_VERIFY,
+                                       "Object %d chunk_id %d NAND mismatch chunk %d tags (%d:%d)",
+                                        obj_id, i, the_chunk,
+                                        tags.obj_id, tags.chunk_id);
                        }
                }
        }
@@ -348,13 +341,12 @@ void yaffs_verify_obj(struct yaffs_obj *obj)
                                  obj->hdr_chunk % dev->param.chunks_per_block);
        chunk_wrongly_deleted = chunk_in_range && !chunk_valid;
 
-       if (!obj->fake && (!chunk_id_ok || chunk_wrongly_deleted)) {
-               T(YAFFS_TRACE_VERIFY,
-                 (TSTR("Obj %d has chunk_id %d %s %s" TENDSTR),
-                  obj->obj_id, obj->hdr_chunk,
-                  chunk_id_ok ? "" : ",out of range",
-                  chunk_wrongly_deleted ? ",marked as deleted" : ""));
-       }
+       if (!obj->fake && (!chunk_id_ok || chunk_wrongly_deleted))
+               yaffs_trace(YAFFS_TRACE_VERIFY,
+                       "Obj %d has chunk_id %d %s %s",
+                       obj->obj_id, obj->hdr_chunk,
+                       chunk_id_ok ? "" : ",out of range",
+                       chunk_wrongly_deleted ? ",marked as deleted" : "");
 
        if (chunk_valid && !yaffs_skip_nand_verification(dev)) {
                struct yaffs_ext_tags tags;
@@ -372,18 +364,17 @@ void yaffs_verify_obj(struct yaffs_obj *obj)
 
        /* Verify it has a parent */
        if (obj && !obj->fake && (!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->obj_id, obj->parent));
+               yaffs_trace(YAFFS_TRACE_VERIFY,
+                       "Obj %d has parent pointer %p which does not look like an object",
+                       obj->obj_id, obj->parent);
        }
 
        /* Verify parent is a 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->obj_id, obj->parent->variant_type));
+               yaffs_trace(YAFFS_TRACE_VERIFY,
+                       "Obj %d's parent is not a directory (type %d)",
+                       obj->obj_id, obj->parent->variant_type);
        }
 
        switch (obj->variant_type) {
@@ -404,9 +395,9 @@ void yaffs_verify_obj(struct yaffs_obj *obj)
                break;
        case YAFFS_OBJECT_TYPE_UNKNOWN:
        default:
-               T(YAFFS_TRACE_VERIFY,
-                 (TSTR("Obj %d has illegaltype %d" TENDSTR),
-                  obj->obj_id, obj->variant_type));
+               yaffs_trace(YAFFS_TRACE_VERIFY,
+                       "Obj %d has illegaltype %d",
+                  obj->obj_id, obj->variant_type);
                break;
        }
 }
@@ -441,7 +432,7 @@ void yaffs_verify_obj_in_dir(struct yaffs_obj *obj)
        int count = 0;
 
        if (!obj) {
-               T(YAFFS_TRACE_ALWAYS, (TSTR("No object to verify" TENDSTR)));
+               yaffs_trace(YAFFS_TRACE_ALWAYS, "No object to verify");
                YBUG();
                return;
        }
@@ -450,15 +441,13 @@ void yaffs_verify_obj_in_dir(struct yaffs_obj *obj)
                return;
 
        if (!obj->parent) {
-               T(YAFFS_TRACE_ALWAYS,
-                 (TSTR("Object does not have parent" TENDSTR)));
+               yaffs_trace(YAFFS_TRACE_ALWAYS, "Object does not have parent" );
                YBUG();
                return;
        }
 
        if (obj->parent->variant_type != YAFFS_OBJECT_TYPE_DIRECTORY) {
-               T(YAFFS_TRACE_ALWAYS,
-                 (TSTR("Parent is not directory" TENDSTR)));
+               yaffs_trace(YAFFS_TRACE_ALWAYS, "Parent is not directory");
                YBUG();
        }
 
@@ -474,8 +463,9 @@ void yaffs_verify_obj_in_dir(struct yaffs_obj *obj)
        }
 
        if (count != 1) {
-               T(YAFFS_TRACE_ALWAYS,
-                 (TSTR("Object in directory %d times" TENDSTR), count));
+               yaffs_trace(YAFFS_TRACE_ALWAYS,
+                       "Object in directory %d times",
+                       count);
                YBUG();
        }
 }
@@ -494,9 +484,9 @@ void yaffs_verify_dir(struct yaffs_obj *directory)
                return;
 
        if (directory->variant_type != YAFFS_OBJECT_TYPE_DIRECTORY) {
-               T(YAFFS_TRACE_ALWAYS,
-                 (TSTR("Directory has wrong type: %d" TENDSTR),
-                  directory->variant_type));
+               yaffs_trace(YAFFS_TRACE_ALWAYS,
+                       "Directory has wrong type: %d",
+                       directory->variant_type);
                YBUG();
        }
 
@@ -506,10 +496,9 @@ void yaffs_verify_dir(struct yaffs_obj *directory)
                if (lh) {
                        list_obj = list_entry(lh, struct yaffs_obj, siblings);
                        if (list_obj->parent != directory) {
-                               T(YAFFS_TRACE_ALWAYS,
-                                 (TSTR
-                                  ("Object in directory list has wrong parent %p"
-                                   TENDSTR), list_obj->parent));
+                               yaffs_trace(YAFFS_TRACE_ALWAYS,
+                                       "Object in directory list has wrong parent %p",
+                                       list_obj->parent);
                                YBUG();
                        }
                        yaffs_verify_obj_in_dir(list_obj);
@@ -532,9 +521,9 @@ void yaffs_verify_free_chunks(struct yaffs_dev *dev)
        difference = dev->n_free_chunks - counted;
 
        if (difference) {
-               T(YAFFS_TRACE_ALWAYS,
-                 (TSTR("Freechunks verification failure %d %d %d" TENDSTR),
-                  dev->n_free_chunks, counted, difference));
+               yaffs_trace(YAFFS_TRACE_ALWAYS,
+                       "Freechunks verification failure %d %d %d",
+                       dev->n_free_chunks, counted, difference);
                yaffs_free_verification_failures++;
        }
 }
@@ -544,3 +533,4 @@ int yaffs_verify_file_sane(struct yaffs_obj *in)
        in = in;
        return YAFFS_OK;
 }
+