yaffs Change tracing to yaffs_trace
authorCharles Manning <cdhmanning@gmail.com>
Fri, 10 Dec 2010 02:15:30 +0000 (15:15 +1300)
committerCharles Manning <cdhmanning@gmail.com>
Fri, 10 Dec 2010 02:15:30 +0000 (15:15 +1300)
Make the tracing a whole lot easier on the eye.

Signed-off-by: Charles Manning <cdhmanning@gmail.com>
28 files changed:
direct/basic-test/yaffs_fileem.c
direct/basic-test/yaffs_fileem2k.c
direct/basic-test/yaffs_norif1.c
direct/basic-test/yaffs_ramdisk.c
direct/basic-test/yaffs_ramem2k.c
direct/yaffsfs.c
direct/ydirectenv.h
direct/yportenv.h
yaffs_allocator.c
yaffs_bitmap.c
yaffs_checkptrw.c
yaffs_getblockinfo.h
yaffs_guts.c
yaffs_mtdif1_multi.c
yaffs_mtdif1_single.c
yaffs_mtdif2_multi.c
yaffs_mtdif2_single.c
yaffs_nand.c
yaffs_packedtags2.c
yaffs_tagscompat.c
yaffs_trace.h
yaffs_verify.c
yaffs_vfs_multi.c
yaffs_vfs_single.c
yaffs_yaffs1.c
yaffs_yaffs2.c
yportenv_multi.h
yportenv_single.h

index 702acbe..66ba93a 100644 (file)
@@ -185,7 +185,9 @@ int yflash_EraseBlockInNAND(struct yaffs_dev *dev, int blockNumber)
        
        if(blockNumber < 0 || blockNumber >= filedisk.nBlocks)
        {
-               T(YAFFS_TRACE_ALWAYS,("Attempt to erase non-existant block %d\n",blockNumber));
+               yaffs_trace(YAFFS_TRACE_ALWAYS,
+                       "Attempt to erase non-existant block %d\n",
+                       blockNumber);
                return YAFFS_FAIL;
        }
        else
index 51c3aa4..52f1e11 100644 (file)
@@ -179,7 +179,7 @@ int yflash2_WriteChunkWithTagsToNAND(struct yaffs_dev *dev,int nand_chunk,const
        int nRead;
        int error;
        
-       T(YAFFS_TRACE_MTD,(TSTR("write chunk %d data %p tags %p" TENDSTR),nand_chunk, data, tags));
+       yaffs_trace(YAFFS_TRACE_MTD, "write chunk %d data %p tags %p",nand_chunk, data, tags);
 
        CheckInit();
        
@@ -396,7 +396,7 @@ int yflash2_ReadChunkWithTagsFromNAND(struct yaffs_dev *dev,int nand_chunk, u8 *
        int retval = YAFFS_OK;
        int nRead;
        
-       T(YAFFS_TRACE_MTD,(TSTR("read chunk %d data %p tags %p" TENDSTR),nand_chunk, data, tags));
+       yaffs_trace(YAFFS_TRACE_MTD,"read chunk %d data %p tags %p",nand_chunk, data, tags);
        
        CheckInit();
        
@@ -543,7 +543,7 @@ int yflash2_EraseBlockInNAND(struct yaffs_dev *dev, int blockNumber)
        
        if(blockNumber < 0 || blockNumber >= filedisk.nBlocks)
        {
-               T(YAFFS_TRACE_ALWAYS,("Attempt to erase non-existant block %d\n",blockNumber));
+               yaffs_trace(YAFFS_TRACE_ALWAYS,"Attempt to erase non-existant block %d",blockNumber);
                return YAFFS_FAIL;
        }
        else
index 7be6295..5394f0e 100644 (file)
@@ -272,7 +272,9 @@ int ynorif1_EraseBlockInNAND(struct yaffs_dev *dev, int blockNumber)
 
        if(blockNumber < 0 || blockNumber >= BLOCKS_IN_DEVICE)
        {
-               T(YAFFS_TRACE_ALWAYS,("Attempt to erase non-existant block %d\n",blockNumber));
+               yaffs_trace(YAFFS_TRACE_ALWAYS,
+                       "Attempt to erase non-existant block %d\n",
+                       blockNumber);
                return YAFFS_FAIL;
        }
        else
index 88fc3a4..5d389b9 100644 (file)
@@ -109,8 +109,9 @@ static int  CheckInit(struct yaffs_dev *dev)
                }
                kfree(ramdisk.block);
                
-               T(YAFFS_TRACE_ALWAYS,("Allocation failed, could only allocate %dMB of %dMB requested.\n",
-                  nAllocated/64,ramdisk.nBlocks * 528));
+               yaffs_trace(YAFFS_TRACE_ALWAYS,
+                       "Allocation failed, could only allocate %dMB of %dMB requested.\n",
+                       nAllocated/64,ramdisk.nBlocks * 528);
                return 0;
        }
        
@@ -212,7 +213,9 @@ int yramdisk_erase(struct yaffs_dev *dev, int blockNumber)
        
        if(blockNumber < 0 || blockNumber >= ramdisk.nBlocks)
        {
-               T(YAFFS_TRACE_ALWAYS,("Attempt to erase non-existant block %d\n",blockNumber));
+               yaffs_trace(YAFFS_TRACE_ALWAYS,
+                       "Attempt to erase non-existant block %d\n",
+                       blockNumber);
                return YAFFS_FAIL;
        }
        else
@@ -231,4 +234,3 @@ int yramdisk_initialise(struct yaffs_dev *dev)
        return YAFFS_OK;
 }
 
-
index 9a857fd..e86760b 100644 (file)
@@ -177,8 +177,9 @@ static int  CheckInit(void)
                }
                kfree(ned.block);
                
-               T(YAFFS_TRACE_ALWAYS,("Allocation failed, could only allocate %dMB of %dMB requested.\n",
-                  nAllocated/64,sizeInMB));
+               yaffs_trace(YAFFS_TRACE_ALWAYS,
+                       "Allocation failed, could only allocate %dMB of %dMB requested.\n",
+                       nAllocated/64,sizeInMB);
                return 0;
        }
        
@@ -292,11 +293,15 @@ int nandemul2k_EraseBlockInNAND(struct yaffs_dev *dev, int blockNumber)
        
        if(blockNumber < 0 || blockNumber >= ned.nBlocks)
        {
-               T(YAFFS_TRACE_ALWAYS,("Attempt to erase non-existant block %d\n",blockNumber));
+               yaffs_trace(YAFFS_TRACE_ALWAYS,
+                       "Attempt to erase non-existant block %d\n",
+                       blockNumber);
        }
        else if(ned.block[blockNumber]->damaged)
        {
-               T(YAFFS_TRACE_ALWAYS,("Attempt to erase damaged block %d\n",blockNumber));
+               yaffs_trace(YAFFS_TRACE_ALWAYS,
+                       "Attempt to erase damaged block %d\n",
+                       blockNumber);
        }
        else
        {
index a9c6b43..e3bc19d 100644 (file)
@@ -2349,7 +2349,7 @@ int yaffs_mount2(const YCHAR *path,int read_only)
                return -1;
        }
 
-       T(YAFFS_TRACE_MOUNT,(TSTR("yaffs: Mounting %s" TENDSTR),path));
+       yaffs_trace(YAFFS_TRACE_MOUNT,"yaffs: Mounting %s",path);
 
        if(yaffsfs_CheckPath(path) < 0){
                yaffsfs_SetError(-ENAMETOOLONG);
index 536ff22..d394c6e 100644 (file)
@@ -60,21 +60,14 @@ void yaffs_qsort(void *aa, size_t n, size_t es,
 
 #define cond_resched()  do {} while(0)
 
-
-
-//#define YINFO(s) YPRINTF(( __FILE__ " %d %s\n",__LINE__,s))
-//#define YALERT(s) YINFO(s)
-
-
-#define TENDSTR "\n"
-#define TSTR(x) x
-#define TCONT(x) x
-#define TOUT(p) printf p
+#define yaffs_trace(msk, fmt, ...) do { \
+       if(yaffs_trace_mask & ((msk) | YAFFS_TRACE_ALWAYS)) \
+               printf("yaffs: " fmt "\n", ##__VA_ARGS__); \
+} while(0)
 
 
 #define YAFFS_LOSTNFOUND_NAME          "lost+found"
 #define YAFFS_LOSTNFOUND_PREFIX                "obj"
-//#define YPRINTF(x) printf x
 
 #include "yaffscfg.h"
 
index 597898e..48e32ea 100644 (file)
 
 #define Y_INLINE inline
 
-/* #define YINFO(s) YPRINTF(( __FILE__ " %d %s\n",__LINE__,s)) */
-/* #define YALERT(s) YINFO(s) */
-
-#define TENDSTR "\n"
-#define TSTR(x) x
-#define TOUT(p) printf p
-
 #define YAFFS_LOSTNFOUND_NAME          "lost+found"
 #define YAFFS_LOSTNFOUND_PREFIX                "obj"
 /* #define YPRINTF(x) printf x */
@@ -68,8 +61,6 @@
 #define YAFFS_ROOT_MODE                        0755
 #define YAFFS_LOSTNFOUND_MODE          0700
 
-#define yaffs_sum_cmp(x, y) ((x) == (y))
-#define strcmp(a, b) strcmp(a, b)
 
 #else
 /* Should have specified a configuration type */
index 9af15c7..f9cd5be 100644 (file)
@@ -153,8 +153,8 @@ static int yaffs_create_tnodes(struct yaffs_dev *dev, int n_tnodes)
        mem = (u8 *) new_tnodes;
 
        if (!new_tnodes) {
-               T(YAFFS_TRACE_ERROR,
-                 (TSTR("yaffs: Could not allocate Tnodes" TENDSTR)));
+               yaffs_trace(YAFFS_TRACE_ERROR,
+                       "yaffs: Could not allocate Tnodes");
                return YAFFS_FAIL;
        }
 
@@ -179,9 +179,8 @@ static int yaffs_create_tnodes(struct yaffs_dev *dev, int n_tnodes)
 
        tnl = kmalloc(sizeof(struct yaffs_tnode_list), GFP_NOFS);
        if (!tnl) {
-               T(YAFFS_TRACE_ERROR,
-                 (TSTR
-                  ("yaffs: Could not add tnodes to management list" TENDSTR)));
+               yaffs_trace(YAFFS_TRACE_ERROR,
+                       "Could not add tnodes to management list");
                return YAFFS_FAIL;
        } else {
                tnl->tnodes = new_tnodes;
@@ -189,7 +188,7 @@ static int yaffs_create_tnodes(struct yaffs_dev *dev, int n_tnodes)
                allocator->alloc_tnode_list = tnl;
        }
 
-       T(YAFFS_TRACE_ALLOCATE, (TSTR("yaffs: Tnodes added" TENDSTR)));
+       yaffs_trace(YAFFS_TRACE_ALLOCATE,"Tnodes added");
 
        return YAFFS_OK;
 }
@@ -301,8 +300,8 @@ static int yaffs_create_free_objs(struct yaffs_dev *dev, int n_obj)
                        kfree(list);
                        list = NULL;
                }
-               T(YAFFS_TRACE_ALLOCATE,
-                 (TSTR("yaffs: Could not allocate more objects" TENDSTR)));
+               yaffs_trace(YAFFS_TRACE_ALLOCATE,
+                       "Could not allocate more objects");
                return YAFFS_FAIL;
        }
 
index 5d1cfb2..9fe4032 100644 (file)
@@ -20,9 +20,9 @@
 static Y_INLINE u8 *yaffs_block_bits(struct yaffs_dev *dev, int blk)
 {
        if (blk < dev->internal_start_block || blk > dev->internal_end_block) {
-               T(YAFFS_TRACE_ERROR,
-                 (TSTR("**>> yaffs: BlockBits block %d is not valid" TENDSTR),
-                  blk));
+               yaffs_trace(YAFFS_TRACE_ERROR,
+                       "BlockBits block %d is not valid",
+                       blk);
                YBUG();
        }
        return dev->chunk_bits +
@@ -33,9 +33,9 @@ void yaffs_verify_chunk_bit_id(struct yaffs_dev *dev, int blk, int chunk)
 {
        if (blk < dev->internal_start_block || blk > dev->internal_end_block ||
            chunk < 0 || chunk >= dev->param.chunks_per_block) {
-               T(YAFFS_TRACE_ERROR,
-                 (TSTR("**>> yaffs: Chunk Id (%d:%d) invalid" TENDSTR),
-                  blk, chunk));
+               yaffs_trace(YAFFS_TRACE_ERROR,
+                       "Chunk Id (%d:%d) invalid",
+                       blk, chunk);
                YBUG();
        }
 }
index 66ce541..4e40f43 100644 (file)
@@ -18,8 +18,8 @@ static int yaffs2_checkpt_space_ok(struct yaffs_dev *dev)
 {
        int blocks_avail = dev->n_erased_blocks - dev->param.n_reserved_blocks;
 
-       T(YAFFS_TRACE_CHECKPOINT,
-         (TSTR("checkpt blocks available = %d" TENDSTR), blocks_avail));
+       yaffs_trace(YAFFS_TRACE_CHECKPOINT,
+               "checkpt blocks_avail = %d", blocks_avail);
 
        return (blocks_avail <= 0) ? 0 : 1;
 }
@@ -30,15 +30,15 @@ static int yaffs_checkpt_erase(struct yaffs_dev *dev)
 
        if (!dev->param.erase_fn)
                return 0;
-       T(YAFFS_TRACE_CHECKPOINT, (TSTR("checking blocks %d to %d" TENDSTR),
-                                  dev->internal_start_block,
-                                  dev->internal_end_block));
+       yaffs_trace(YAFFS_TRACE_CHECKPOINT,
+               "checking blocks %d to %d",
+               dev->internal_start_block, dev->internal_end_block);
 
        for (i = dev->internal_start_block; i <= dev->internal_end_block; i++) {
                struct yaffs_block_info *bi = yaffs_get_block_info(dev, i);
                if (bi->block_state == YAFFS_BLOCK_STATE_CHECKPOINT) {
-                       T(YAFFS_TRACE_CHECKPOINT,
-                         (TSTR("erasing checkpt block %d" TENDSTR), i));
+                       yaffs_trace(YAFFS_TRACE_CHECKPOINT,
+                       "erasing checkpt block %d", i);
 
                        dev->n_erasures++;
 
@@ -65,11 +65,10 @@ static void yaffs2_checkpt_find_erased_block(struct yaffs_dev *dev)
 {
        int i;
        int blocks_avail = dev->n_erased_blocks - dev->param.n_reserved_blocks;
-       T(YAFFS_TRACE_CHECKPOINT,
-         (TSTR
-          ("allocating checkpt block: erased %d reserved %d avail %d next %d "
-           TENDSTR), dev->n_erased_blocks, dev->param.n_reserved_blocks,
-          blocks_avail, dev->checkpt_next_block));
+       yaffs_trace(YAFFS_TRACE_CHECKPOINT,
+               "allocating checkpt block: erased %d reserved %d avail %d next %d ",
+               dev->n_erased_blocks, dev->param.n_reserved_blocks,
+               blocks_avail, dev->checkpt_next_block);
 
        if (dev->checkpt_next_block >= 0 &&
            dev->checkpt_next_block <= dev->internal_end_block &&
@@ -82,14 +81,13 @@ static void yaffs2_checkpt_find_erased_block(struct yaffs_dev *dev)
                        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));
+                               yaffs_trace(YAFFS_TRACE_CHECKPOINT,
+                                       "allocating checkpt block %d", i);
                                return;
                        }
                }
        }
-       T(YAFFS_TRACE_CHECKPOINT, (TSTR("out of checkpt blocks" TENDSTR)));
+       yaffs_trace(YAFFS_TRACE_CHECKPOINT, "out of checkpt blocks");
 
        dev->checkpt_next_block = -1;
        dev->checkpt_cur_block = -1;
@@ -100,9 +98,9 @@ static void yaffs2_checkpt_find_block(struct yaffs_dev *dev)
        int i;
        struct yaffs_ext_tags tags;
 
-       T(YAFFS_TRACE_CHECKPOINT,
-         (TSTR("find next checkpt block: start:  blocks %d next %d" TENDSTR),
-          dev->blocks_in_checkpt, dev->checkpt_next_block));
+       yaffs_trace(YAFFS_TRACE_CHECKPOINT,
+               "find next checkpt block: start:  blocks %d next %d",
+               dev->blocks_in_checkpt, dev->checkpt_next_block);
 
        if (dev->blocks_in_checkpt < dev->checkpt_max_blocks)
                for (i = dev->checkpt_next_block; i <= dev->internal_end_block;
@@ -112,11 +110,10 @@ static void yaffs2_checkpt_find_block(struct yaffs_dev *dev)
 
                        dev->param.read_chunk_tags_fn(dev, realigned_chunk,
                                                      NULL, &tags);
-                       T(YAFFS_TRACE_CHECKPOINT,
-                         (TSTR
-                          ("find next checkpt block: search: block %d oid %d seq %d eccr %d"
-                           TENDSTR), i, tags.obj_id, tags.seq_number,
-                          tags.ecc_result));
+                       yaffs_trace(YAFFS_TRACE_CHECKPOINT,
+                               "find next checkpt block: search: block %d oid %d seq %d eccr %d",
+                               i, tags.obj_id, tags.seq_number,
+                               tags.ecc_result);
 
                        if (tags.seq_number == YAFFS_SEQUENCE_CHECKPOINT_DATA) {
                                /* Right kind of block */
@@ -125,14 +122,13 @@ static void yaffs2_checkpt_find_block(struct yaffs_dev *dev)
                                dev->checkpt_block_list[dev->
                                                        blocks_in_checkpt] = i;
                                dev->blocks_in_checkpt++;
-                               T(YAFFS_TRACE_CHECKPOINT,
-                                 (TSTR("found checkpt block %d" TENDSTR), i));
+                               yaffs_trace(YAFFS_TRACE_CHECKPOINT,
+                                       "found checkpt block %d", i);
                                return;
                        }
                }
 
-       T(YAFFS_TRACE_CHECKPOINT,
-         (TSTR("found no more checkpt blocks" TENDSTR)));
+       yaffs_trace(YAFFS_TRACE_CHECKPOINT, "found no more checkpt blocks");
 
        dev->checkpt_next_block = -1;
        dev->checkpt_cur_block = -1;
@@ -234,11 +230,10 @@ static int yaffs2_checkpt_flush_buffer(struct yaffs_dev *dev)
            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->checkpt_cur_block, dev->checkpt_cur_chunk, tags.obj_id,
-          tags.chunk_id));
+       yaffs_trace(YAFFS_TRACE_CHECKPOINT,
+               "checkpoint wite buffer nand %d(%d:%d) objid %d chId %d",
+               chunk, dev->checkpt_cur_block, dev->checkpt_cur_chunk,
+               tags.obj_id, tags.chunk_id);
 
        realigned_chunk = chunk - dev->chunk_offset;
 
@@ -395,8 +390,8 @@ int yaffs_checkpt_close(struct yaffs_dev *dev)
            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->checkpt_byte_count));
+       yaffs_trace(YAFFS_TRACE_CHECKPOINT,"checkpoint byte count %d",
+               dev->checkpt_byte_count);
 
        if (dev->checkpt_buffer) {
                /* free the buffer */
@@ -412,9 +407,9 @@ int yaffs2_checkpt_invalidate_stream(struct yaffs_dev *dev)
 {
        /* Erase the checkpoint data */
 
-       T(YAFFS_TRACE_CHECKPOINT,
-         (TSTR("checkpoint invalidate of %d blocks" TENDSTR),
-          dev->blocks_in_checkpt));
+       yaffs_trace(YAFFS_TRACE_CHECKPOINT,
+               "checkpoint invalidate of %d blocks",
+               dev->blocks_in_checkpt);
 
        return yaffs_checkpt_erase(dev);
 }
index 108c361..4cef686 100644 (file)
@@ -24,10 +24,9 @@ static Y_INLINE struct yaffs_block_info *yaffs_get_block_info(struct yaffs_dev
                                                              *dev, int blk)
 {
        if (blk < dev->internal_start_block || blk > dev->internal_end_block) {
-               T(YAFFS_TRACE_ERROR,
-                 (TSTR
-                  ("**>> yaffs: get_block_info block %d is not valid" TENDSTR),
-                  blk));
+               yaffs_trace(YAFFS_TRACE_ERROR,
+                       "**>> yaffs: get_block_info block %d is not valid",
+                       blk);
                YBUG();
        }
        return &dev->block_info[blk - dev->internal_start_block];
index 15d0238..b49f018 100644 (file)
@@ -43,7 +43,6 @@
 
 /* Forward declarations */
 
-
 static int yaffs_wr_data_obj(struct yaffs_obj *in, int inode_chunk,
                             const u8 * buffer, int n_bytes, int use_reserve);
 
@@ -165,14 +164,11 @@ u8 *yaffs_get_temp_buffer(struct yaffs_dev * dev, int line_no)
                }
        }
 
-       T(YAFFS_TRACE_BUFFERS,
-         (TSTR("Out of temp buffers at line %d, other held by lines:"),
-          line_no));
+       yaffs_trace(YAFFS_TRACE_BUFFERS,
+               "Out of temp buffers at line %d, other held by lines:",
+               line_no);
        for (i = 0; i < YAFFS_N_TEMP_BUFFERS; i++)
-               T(YAFFS_TRACE_BUFFERS,
-                 (TSTR(" %d "), dev->temp_buffer[i].line));
-
-       T(YAFFS_TRACE_BUFFERS, (TSTR(" " TENDSTR)));
+               yaffs_trace(YAFFS_TRACE_BUFFERS," %d", dev->temp_buffer[i].line);
 
        /*
         * If we got here then we have to allocate an unmanaged one
@@ -199,9 +195,9 @@ void yaffs_release_temp_buffer(struct yaffs_dev *dev, u8 * buffer, int line_no)
 
        if (buffer) {
                /* assume it is an unmanaged one. */
-               T(YAFFS_TRACE_BUFFERS,
-                 (TSTR("Releasing unmanaged temp buffer in line %d" TENDSTR),
-                  line_no));
+               yaffs_trace(YAFFS_TRACE_BUFFERS,
+                 "Releasing unmanaged temp buffer in line %d",
+                  line_no);
                kfree(buffer);
                dev->unmanaged_buffer_deallocs++;
        }
@@ -228,8 +224,8 @@ int yaffs_is_managed_tmp_buffer(struct yaffs_dev *dev, const u8 * buffer)
        if (buffer == dev->checkpt_buffer)
                return 1;
 
-       T(YAFFS_TRACE_ALWAYS,
-         (TSTR("yaffs: unmaged buffer detected.\n" TENDSTR)));
+       yaffs_trace(YAFFS_TRACE_ALWAYS,
+         "yaffs: unmaged buffer detected.");
        return 0;
 }
 
@@ -266,8 +262,7 @@ void yaffs_handle_chunk_error(struct yaffs_dev *dev,
 
                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)));
+                       yaffs_trace(YAFFS_TRACE_ALWAYS, "yaffs: Block struck out");
 
                }
        }
@@ -284,8 +279,8 @@ static void yaffs_handle_chunk_wr_error(struct yaffs_dev *dev, int nand_chunk,
        if (erased_ok) {
                /* Was an actual write failure, so mark the block for retirement  */
                bi->needs_retiring = 1;
-               T(YAFFS_TRACE_ERROR | YAFFS_TRACE_BAD_BLOCKS,
-                 (TSTR("**>> Block %d needs retiring" TENDSTR), flash_block));
+               yaffs_trace(YAFFS_TRACE_ERROR | YAFFS_TRACE_BAD_BLOCKS,
+                 "**>> Block %d needs retiring", flash_block);
        }
 
        /* Delete the chunk */
@@ -349,9 +344,9 @@ static int yaffs_check_chunk_erased(struct yaffs_dev *dev, int nand_chunk)
        if (tags.ecc_result > YAFFS_ECC_RESULT_NO_ERROR)
                retval = YAFFS_FAIL;
 
-       if (!yaffs_check_ff(data, dev->data_bytes_per_chunk) || tags.chunk_used) {
-               T(YAFFS_TRACE_NANDACCESS,
-                 (TSTR("Chunk %d not erased" TENDSTR), nand_chunk));
+       if (!yaffs_check_ff(data, dev->data_bytes_per_chunk) ||
+               tags.chunk_used) {
+               yaffs_trace(YAFFS_TRACE_NANDACCESS, "Chunk %d not erased", nand_chunk);
                retval = YAFFS_FAIL;
        }
 
@@ -408,8 +403,8 @@ static int yaffs_find_alloc_block(struct yaffs_dev *dev)
                /* Hoosterman we've got a problem.
                 * Can't get space to gc
                 */
-               T(YAFFS_TRACE_ERROR,
-                 (TSTR("yaffs tragedy: no more erased blocks" TENDSTR)));
+               yaffs_trace(YAFFS_TRACE_ERROR,
+                 "yaffs tragedy: no more erased blocks" );
 
                return -1;
        }
@@ -430,21 +425,21 @@ static int yaffs_find_alloc_block(struct yaffs_dev *dev)
                        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),
+                       yaffs_trace(YAFFS_TRACE_ALLOCATE,
+                         "Allocated block %d, seq  %d, %d left" ,
                           dev->alloc_block_finder, dev->seq_number,
-                          dev->n_erased_blocks));
+                          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->n_erased_blocks));
+       yaffs_trace(YAFFS_TRACE_ALWAYS,
+               "yaffs tragedy: no more erased blocks, but there should have been %d",
+               dev->n_erased_blocks);
 
        return -1;
 }
+
 static int yaffs_alloc_chunk(struct yaffs_dev *dev, int use_reserver,
                             struct yaffs_block_info **block_ptr)
 {
@@ -463,9 +458,8 @@ static int yaffs_alloc_chunk(struct yaffs_dev *dev, int use_reserver,
        }
 
        if (dev->n_erased_blocks < dev->param.n_reserved_blocks
-           && dev->alloc_page == 0) {
-               T(YAFFS_TRACE_ALLOCATE, (TSTR("Allocating reserve" TENDSTR)));
-       }
+           && dev->alloc_page == 0)
+               yaffs_trace(YAFFS_TRACE_ALLOCATE, "Allocating reserve");
 
        /* Next page please.... */
        if (dev->alloc_block >= 0) {
@@ -492,8 +486,7 @@ static int yaffs_alloc_chunk(struct yaffs_dev *dev, int use_reserver,
                return ret_val;
        }
 
-       T(YAFFS_TRACE_ERROR,
-         (TSTR("!!!!!!!!! Allocator out !!!!!!!!!!!!!!!!!" TENDSTR)));
+       yaffs_trace(YAFFS_TRACE_ERROR, "!!!!!!!!! Allocator out !!!!!!!!!!!!!!!!!" );
 
        return -1;
 }
@@ -580,9 +573,9 @@ static int yaffs_write_new_chunk(struct yaffs_dev *dev,
                if (!bi->skip_erased_check) {
                        erased_ok = yaffs_check_chunk_erased(dev, chunk);
                        if (erased_ok != YAFFS_OK) {
-                               T(YAFFS_TRACE_ERROR,
-                                 (TSTR("**>> yaffs chunk %d was not erased"
-                                       TENDSTR), chunk));
+                               yaffs_trace(YAFFS_TRACE_ERROR,
+                                 "**>> yaffs chunk %d was not erased",
+                                 chunk);
 
                                /* If not erased, delete this one,
                                 * skip rest of block and
@@ -618,10 +611,9 @@ static int yaffs_write_new_chunk(struct yaffs_dev *dev,
                chunk = -1;
 
        if (attempts > 1) {
-               T(YAFFS_TRACE_ERROR,
-                 (TSTR("**>> yaffs write required %d attempts" TENDSTR),
-                  attempts));
-
+               yaffs_trace(YAFFS_TRACE_ERROR,
+                       "**>> yaffs write required %d attempts",
+                       attempts);
                dev->n_retired_writes += (attempts - 1);
        }
 
@@ -642,10 +634,9 @@ static void yaffs_retire_block(struct yaffs_dev *dev, int flash_block)
 
        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), flash_block));
+                       yaffs_trace(YAFFS_TRACE_ALWAYS,
+                               "yaffs: Failed to mark bad and erase block %d",
+                               flash_block);
                } else {
                        struct yaffs_ext_tags tags;
                        int chunk_id =
@@ -660,11 +651,9 @@ static void yaffs_retire_block(struct yaffs_dev *dev, int flash_block)
                                                           dev->chunk_offset,
                                                           buffer,
                                                           &tags) != YAFFS_OK)
-                               T(YAFFS_TRACE_ALWAYS,
-                                 (TSTR
-                                  ("yaffs: Failed to "
-                                   TCONT("write bad block marker to block %d")
-                                   TENDSTR), flash_block));
+                               yaffs_trace(YAFFS_TRACE_ALWAYS,
+                                       "yaffs: Failed to write bad block marker to block %d",
+                                       flash_block);
 
                        yaffs_release_temp_buffer(dev, buffer, __LINE__);
                }
@@ -922,8 +911,7 @@ struct yaffs_tnode *yaffs_add_find_tnode_0(struct yaffs_dev *dev,
                                file_struct->top = tn;
                                file_struct->top_level++;
                        } else {
-                               T(YAFFS_TRACE_ERROR,
-                                 (TSTR("yaffs: no more tnodes" TENDSTR)));
+                               yaffs_trace(YAFFS_TRACE_ERROR, "yaffs: no more tnodes");
                                return NULL;
                        }
                }
@@ -1098,10 +1086,9 @@ int yaffs_put_chunk_in_file(struct yaffs_obj *in, int inode_chunk,
                 * If it is not during Scanning then something went wrong!
                 */
                if (!in_scan) {
-                       T(YAFFS_TRACE_ERROR,
-                         (TSTR
-                          ("yaffs tragedy:attempt to put data chunk into a non-file"
-                           TENDSTR)));
+                       yaffs_trace(YAFFS_TRACE_ERROR,
+                               "yaffs tragedy:attempt to put data chunk into a non-file"
+                               );
                        YBUG();
                }
 
@@ -1157,10 +1144,9 @@ int yaffs_put_chunk_in_file(struct yaffs_obj *in, int inode_chunk,
                        if (existing_cunk <= 0) {
                                /*Hoosterman - how did this happen? */
 
-                               T(YAFFS_TRACE_ERROR,
-                                 (TSTR
-                                  ("yaffs tragedy: existing chunk < 0 in scan"
-                                   TENDSTR)));
+                               yaffs_trace(YAFFS_TRACE_ERROR,
+                                       "yaffs tragedy: existing chunk < 0 in scan"
+                                       );
 
                        }
 
@@ -1207,7 +1193,7 @@ static void yaffs_soft_del_chunk(struct yaffs_dev *dev, int chunk)
        struct yaffs_block_info *the_block;
        unsigned block_no;
 
-       T(YAFFS_TRACE_DELETION, (TSTR("soft delete chunk %d" TENDSTR), chunk));
+       yaffs_trace(YAFFS_TRACE_DELETION, "soft delete chunk %d", chunk);
 
        block_no = chunk / dev->param.chunks_per_block;
        the_block = yaffs_get_block_info(dev, block_no);
@@ -1304,18 +1290,16 @@ static void yaffs_remove_obj_from_dir(struct yaffs_obj *obj)
 void yaffs_add_obj_to_dir(struct yaffs_obj *directory, struct yaffs_obj *obj)
 {
        if (!directory) {
-               T(YAFFS_TRACE_ALWAYS,
-                 (TSTR
-                  ("tragedy: Trying to add an object to a null pointer directory"
-                   TENDSTR)));
+               yaffs_trace(YAFFS_TRACE_ALWAYS,
+                       "tragedy: Trying to add an object to a null pointer directory"
+                       );
                YBUG();
                return;
        }
        if (directory->variant_type != YAFFS_OBJECT_TYPE_DIRECTORY) {
-               T(YAFFS_TRACE_ALWAYS,
-                 (TSTR
-                  ("tragedy: Trying to add an object to a non-directory"
-                   TENDSTR)));
+               yaffs_trace(YAFFS_TRACE_ALWAYS,
+                       "tragedy: Trying to add an object to a non-directory"
+                       );
                YBUG();
        }
 
@@ -1356,10 +1340,9 @@ static int yaffs_change_obj_name(struct yaffs_obj *obj,
                new_dir = obj->parent;  /* use the old directory */
 
        if (new_dir->variant_type != YAFFS_OBJECT_TYPE_DIRECTORY) {
-               T(YAFFS_TRACE_ALWAYS,
-                 (TSTR
-                  ("tragedy: yaffs_change_obj_name: new_dir is not a directory"
-                   TENDSTR)));
+               yaffs_trace(YAFFS_TRACE_ALWAYS,
+                       "tragedy: yaffs_change_obj_name: new_dir is not a directory"
+                       );
                YBUG();
        }
 
@@ -1471,14 +1454,11 @@ static void yaffs_flush_file_cache(struct yaffs_obj *obj)
 
                } while (cache && chunk_written > 0);
 
-               if (cache) {
+               if (cache)
                        /* Hoosterman, disk full while writing cache out. */
-                       T(YAFFS_TRACE_ERROR,
-                         (TSTR
-                          ("yaffs tragedy: no space during cache write"
-                           TENDSTR)));
+                       yaffs_trace(YAFFS_TRACE_ERROR,
+                               "yaffs tragedy: no space during cache write");
 
-               }
        }
 
 }
@@ -1675,8 +1655,8 @@ static void yaffs_free_obj(struct yaffs_obj *obj)
 {
        struct yaffs_dev *dev = obj->my_dev;
 
-       T(YAFFS_TRACE_OS,
-         (TSTR("FreeObject %p inode %p" TENDSTR), obj, obj->my_inode));
+       yaffs_trace(YAFFS_TRACE_OS, "FreeObject %p inode %p",
+               obj, obj->my_inode);
 
        if (!obj)
                YBUG();
@@ -1733,13 +1713,14 @@ static void yaffs_soft_del_file(struct yaffs_obj *obj)
        if (obj->deleted &&
            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 */
+                       /* Empty file with no duplicate object headers,
+                        * just delete it immediately */
                        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->obj_id));
+                       yaffs_trace(YAFFS_TRACE_TRACING,
+                               "yaffs: Deleting empty file %d",
+                               obj->obj_id);
                        yaffs_generic_obj_del(obj);
                } else {
                        yaffs_soft_del_worker(obj,
@@ -2143,9 +2124,9 @@ static void yaffs_update_parent(struct yaffs_obj *obj)
 
                if (list_empty(link)) {
                        list_add(link, &dev->dirty_dirs);
-                       T(YAFFS_TRACE_BACKGROUND,
-                         (TSTR("Added object %d to dirty directories" TENDSTR),
-                          obj->obj_id));
+                       yaffs_trace(YAFFS_TRACE_BACKGROUND,
+                         "Added object %d to dirty directories",
+                          obj->obj_id);
                }
 
        } else {
@@ -2160,7 +2141,7 @@ void yaffs_update_dirty_dirs(struct yaffs_dev *dev)
        struct yaffs_dir_var *d_s;
        union yaffs_obj_var *o_v;
 
-       T(YAFFS_TRACE_BACKGROUND, (TSTR("Update dirty directories" TENDSTR)));
+       yaffs_trace(YAFFS_TRACE_BACKGROUND, "Update dirty directories");
 
        while (!list_empty(&dev->dirty_dirs)) {
                link = dev->dirty_dirs.next;
@@ -2170,8 +2151,8 @@ void yaffs_update_dirty_dirs(struct yaffs_dev *dev)
                o_v = list_entry(d_s, union yaffs_obj_var, dir_variant);
                obj = list_entry(o_v, struct yaffs_obj, variant);
 
-               T(YAFFS_TRACE_BACKGROUND,
-                 (TSTR("Update directory %d" TENDSTR), obj->obj_id));
+               yaffs_trace(YAFFS_TRACE_BACKGROUND, "Update directory %d",
+                       obj->obj_id);
 
                if (obj->dirty)
                        yaffs_update_oh(obj, NULL, 0, 0, 0, NULL);
@@ -2390,10 +2371,10 @@ void yaffs_block_became_dirty(struct yaffs_dev *dev, int block_no)
         * If the block has had a data failure, then retire it.
         */
 
-       T(YAFFS_TRACE_GC | YAFFS_TRACE_ERASE,
-         (TSTR("yaffs_block_became_dirty block %d state %d %s" TENDSTR),
-          block_no, bi->block_state,
-          (bi->needs_retiring) ? "needs retiring" : ""));
+       yaffs_trace(YAFFS_TRACE_GC | YAFFS_TRACE_ERASE,
+               "yaffs_block_became_dirty block %d state %d %s",
+               block_no, bi->block_state,
+               (bi->needs_retiring) ? "needs retiring" : "");
 
        yaffs2_clear_oldest_dirty_seq(dev, bi);
 
@@ -2414,8 +2395,8 @@ void yaffs_block_became_dirty(struct yaffs_dev *dev, int block_no)
                erased_ok = yaffs_erase_block(dev, block_no);
                if (!erased_ok) {
                        dev->n_erase_failures++;
-                       T(YAFFS_TRACE_ERROR | YAFFS_TRACE_BAD_BLOCKS,
-                         (TSTR("**>> Erasure failed %d" TENDSTR), block_no));
+                       yaffs_trace(YAFFS_TRACE_ERROR | YAFFS_TRACE_BAD_BLOCKS,
+                         "**>> Erasure failed %d", block_no);
                }
        }
 
@@ -2426,10 +2407,9 @@ void yaffs_block_became_dirty(struct yaffs_dev *dev, int block_no)
                for (i = 0; i < dev->param.chunks_per_block; i++) {
                        if (!yaffs_check_chunk_erased
                            (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), block_no, i));
+                               yaffs_trace(YAFFS_TRACE_ERROR,
+                                       ">>Block %d erasure supposedly OK, but chunk %d not erased",
+                                       block_no, i);
                        }
                }
        }
@@ -2442,18 +2422,18 @@ void yaffs_block_became_dirty(struct yaffs_dev *dev, int block_no)
                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->skip_erased_check = 1;      /* 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), block_no));
+               yaffs_trace(YAFFS_TRACE_ERASE,
+                       "Erased block %d", block_no);
        } else {
-               dev->n_free_chunks -= dev->param.chunks_per_block;      /* We lost a block of free space */
-
+               /* We lost a block of free space */
+               dev->n_free_chunks -= dev->param.chunks_per_block;
                yaffs_retire_block(dev, block_no);
-               T(YAFFS_TRACE_ERROR | YAFFS_TRACE_BAD_BLOCKS,
-                 (TSTR("**>> Block %d retired" TENDSTR), block_no));
+               yaffs_trace(YAFFS_TRACE_ERROR | YAFFS_TRACE_BAD_BLOCKS,
+                       "**>> Block %d retired", block_no);
        }
 }
 
@@ -2481,11 +2461,10 @@ static int yaffs_gc_block(struct yaffs_dev *dev, int block, int whole_block)
 
        is_checkpt_block = (bi->block_state == YAFFS_BLOCK_STATE_CHECKPOINT);
 
-       T(YAFFS_TRACE_TRACING,
-         (TSTR
-          ("Collecting block %d, in use %d, shrink %d, whole_block %d"
-           TENDSTR), block, bi->pages_in_use, bi->has_shrink_hdr,
-          whole_block));
+       yaffs_trace(YAFFS_TRACE_TRACING,
+               "Collecting block %d, in use %d, shrink %d, whole_block %d",
+               block, bi->pages_in_use, bi->has_shrink_hdr,
+               whole_block);
 
        /*yaffs_verify_free_chunks(dev); */
 
@@ -2497,10 +2476,9 @@ static int yaffs_gc_block(struct yaffs_dev *dev, int block, int whole_block)
        dev->gc_disable = 1;
 
        if (is_checkpt_block || !yaffs_still_some_chunks(dev, block)) {
-               T(YAFFS_TRACE_TRACING,
-                 (TSTR
-                  ("Collecting block %d that has no chunks in use" TENDSTR),
-                  block));
+               yaffs_trace(YAFFS_TRACE_TRACING,
+                       "Collecting block %d that has no chunks in use",
+                       block);
                yaffs_block_became_dirty(dev, block);
        } else {
 
@@ -2531,11 +2509,10 @@ static int yaffs_gc_block(struct yaffs_dev *dev, int block, int whole_block)
 
                                object = yaffs_find_by_number(dev, tags.obj_id);
 
-                               T(YAFFS_TRACE_GC_DETAIL,
-                                 (TSTR
-                                  ("Collecting chunk in block %d, %d %d %d "
-                                   TENDSTR), dev->gc_chunk, tags.obj_id,
-                                  tags.chunk_id, tags.n_bytes));
+                               yaffs_trace(YAFFS_TRACE_GC_DETAIL,
+                                       "Collecting chunk in block %d, %d %d %d ",
+                                       dev->gc_chunk, tags.obj_id,
+                                       tags.chunk_id, tags.n_bytes);
 
                                if (object && !yaffs_skip_verification(dev)) {
                                        if (tags.chunk_id == 0)
@@ -2550,22 +2527,21 @@ static int yaffs_gc_block(struct yaffs_dev *dev, int block, int whole_block)
                                                     NULL);
 
                                        if (old_chunk != matching_chunk)
-                                               T(YAFFS_TRACE_ERROR,
-                                                 (TSTR
-                                                  ("gc: page in gc mismatch: %d %d %d %d"
-                                                   TENDSTR), old_chunk,
-                                                  matching_chunk, tags.obj_id,
-                                                  tags.chunk_id));
+                                               yaffs_trace(YAFFS_TRACE_ERROR,
+                                                       "gc: page in gc mismatch: %d %d %d %d",
+                                                       old_chunk,
+                                                       matching_chunk,
+                                                       tags.obj_id,
+                                                       tags.chunk_id);
 
                                }
 
                                if (!object) {
-                                       T(YAFFS_TRACE_ERROR,
-                                         (TSTR
-                                          ("page %d in gc has no object: %d %d %d "
-                                           TENDSTR), old_chunk,
-                                          tags.obj_id, tags.chunk_id,
-                                          tags.n_bytes));
+                                       yaffs_trace(YAFFS_TRACE_ERROR,
+                                               "page %d in gc has no object: %d %d %d ",
+                                               old_chunk,
+                                               tags.obj_id, tags.chunk_id,
+                                               tags.n_bytes);
                                }
 
                                if (object &&
@@ -2715,10 +2691,9 @@ static int yaffs_gc_block(struct yaffs_dev *dev, int block, int whole_block)
                                                 object->variant.
                                                 file_variant.top);
                                object->variant.file_variant.top = NULL;
-                               T(YAFFS_TRACE_GC,
-                                 (TSTR
-                                  ("yaffs: About to finally delete object %d"
-                                   TENDSTR), object->obj_id));
+                               yaffs_trace(YAFFS_TRACE_GC,
+                                       "yaffs: About to finally delete object %d",
+                                       object->obj_id);
                                yaffs_generic_obj_del(object);
                                object->my_dev->n_deleted_files--;
                        }
@@ -2726,12 +2701,10 @@ static int yaffs_gc_block(struct yaffs_dev *dev, int block, int whole_block)
                }
 
                chunks_after = yaffs_get_erased_chunks(dev);
-               if (chunks_before >= chunks_after) {
-                       T(YAFFS_TRACE_GC,
-                         (TSTR
-                          ("gc did not increase free chunks before %d after %d"
-                           TENDSTR), chunks_before, chunks_after));
-               }
+               if (chunks_before >= chunks_after)
+                       yaffs_trace(YAFFS_TRACE_GC,
+                               "gc did not increase free chunks before %d after %d",
+                               chunks_before, chunks_after);
                dev->gc_block = 0;
                dev->gc_chunk = 0;
                dev->n_clean_ups = 0;
@@ -2874,12 +2847,11 @@ static unsigned yaffs_find_gc_block(struct yaffs_dev *dev,
        }
 
        if (selected) {
-               T(YAFFS_TRACE_GC,
-                 (TSTR
-                  ("GC Selected block %d with %d free, prioritised:%d"
-                   TENDSTR), selected,
-                  dev->param.chunks_per_block - dev->gc_pages_in_use,
-                  prioritised));
+               yaffs_trace(YAFFS_TRACE_GC,
+                       "GC Selected block %d with %d free, prioritised:%d",
+                       selected,
+                       dev->param.chunks_per_block - dev->gc_pages_in_use,
+                       prioritised);
 
                dev->n_gc_blocks++;
                if (background)
@@ -2892,12 +2864,11 @@ static unsigned yaffs_find_gc_block(struct yaffs_dev *dev,
                        dev->refresh_skip--;
        } else {
                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->gc_block_finder, dev->gc_not_done, threshold,
-                  dev->gc_dirtiest, dev->gc_pages_in_use,
-                  dev->oldest_dirty_block, background ? " bg" : ""));
+               yaffs_trace(YAFFS_TRACE_GC,
+                       "GC none: finder %d skip %d threshold %d dirtiest %d using %d oldest %d%s",
+                       dev->gc_block_finder, dev->gc_not_done, threshold,
+                       dev->gc_dirtiest, dev->gc_pages_in_use,
+                       dev->oldest_dirty_block, background ? " bg" : "");
        }
 
        return selected;
@@ -2983,21 +2954,19 @@ static int yaffs_check_gc(struct yaffs_dev *dev, int background)
                        if (!aggressive)
                                dev->passive_gc_count++;
 
-                       T(YAFFS_TRACE_GC,
-                         (TSTR
-                          ("yaffs: GC n_erased_blocks %d aggressive %d"
-                           TENDSTR), dev->n_erased_blocks, aggressive));
+                       yaffs_trace(YAFFS_TRACE_GC,
+                               "yaffs: GC n_erased_blocks %d aggressive %d",
+                               dev->n_erased_blocks, aggressive);
 
                        gc_ok = yaffs_gc_block(dev, dev->gc_block, aggressive);
                }
 
                if (dev->n_erased_blocks < (dev->param.n_reserved_blocks)
                    && dev->gc_block > 0) {
-                       T(YAFFS_TRACE_GC,
-                         (TSTR
-                          ("yaffs: GC !!!no reclaim!!! n_erased_blocks %d after try %d block %d"
-                           TENDSTR), dev->n_erased_blocks, max_tries,
-                          dev->gc_block));
+                       yaffs_trace(YAFFS_TRACE_GC,
+                               "yaffs: GC !!!no reclaim!!! n_erased_blocks %d after try %d block %d",
+                               dev->n_erased_blocks, max_tries,
+                               dev->gc_block);
                }
        } while ((dev->n_erased_blocks < dev->param.n_reserved_blocks) &&
                 (dev->gc_block > 0) && (max_tries < 2));
@@ -3014,7 +2983,7 @@ int yaffs_bg_gc(struct yaffs_dev *dev, unsigned urgency)
 {
        int erased_chunks = dev->n_erased_blocks * dev->param.chunks_per_block;
 
-       T(YAFFS_TRACE_BACKGROUND, (TSTR("Background gc %u" TENDSTR), urgency));
+       yaffs_trace(YAFFS_TRACE_BACKGROUND, "Background gc %u", urgency);
 
        yaffs_check_gc(dev, 1);
        return erased_chunks > dev->n_free_chunks / 2;
@@ -3030,9 +2999,9 @@ static int yaffs_rd_data_obj(struct yaffs_obj *in, int inode_chunk, u8 * buffer)
                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),
-                  nand_chunk));
+               yaffs_trace(YAFFS_TRACE_NANDACCESS,
+                       "Chunk %d not found zero instead",
+                       nand_chunk);
                /* get sane (zero) data if you read a hole */
                memset(buffer, 0, in->my_dev->data_bytes_per_chunk);
                return 0;
@@ -3056,15 +3025,16 @@ void yaffs_chunk_del(struct yaffs_dev *dev, int chunk_id, int mark_flash,
        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), chunk_id));
+               yaffs_trace(YAFFS_TRACE_VERIFY,
+                       "Deleting invalid chunk %d", 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, chunk_id));
+       yaffs_trace(YAFFS_TRACE_DELETION,
+               "line %d delete of chunk %d",
+               lyn, chunk_id);
 
        if (!dev->param.is_yaffs2 && mark_flash &&
            bi->block_state != YAFFS_BLOCK_STATE_COLLECTING) {
@@ -3140,9 +3110,9 @@ static int yaffs_wr_data_obj(struct yaffs_obj *in, int inode_chunk,
        new_tags.n_bytes = n_bytes;
 
        if (n_bytes < 1 || n_bytes > dev->param.total_bytes_per_chunk) {
-               T(YAFFS_TRACE_ERROR,
-                 (TSTR("Writing %d bytes to chunk!!!!!!!!!" TENDSTR),
-                  n_bytes));
+               yaffs_trace(YAFFS_TRACE_ERROR,
+                 "Writing %d bytes to chunk!!!!!!!!!",
+                  n_bytes);
                YBUG();
        }
 
@@ -3330,7 +3300,8 @@ static void yaffs_load_name_from_oh(struct yaffs_dev *dev, YCHAR * name,
 #ifdef CONFIG_YAFFS_AUTO_UNICODE
        if (dev->param.auto_unicode) {
                if (*oh_name) {
-                       /* It is an ASCII name, so do an ASCII to unicode conversion */
+                       /* It is an ASCII name, do an ASCII to
+                        * unicode conversion */
                        const char *ascii_oh_name = (const char *)oh_name;
                        int n = buff_size - 1;
                        while (n > 0 && *ascii_oh_name) {
@@ -3422,7 +3393,7 @@ int yaffs_update_oh(struct yaffs_obj *in, const YCHAR * name, int force,
 
        strcpy(old_name, _Y("silly old name"));
 
-       if (!in->fake || in == dev->root_dir || /* The root_dir should also be saved */
+       if (!in->fake || in == dev->root_dir ||
            force || xmod) {
 
                yaffs_check_gc(dev, 0);
@@ -3680,10 +3651,9 @@ int yaffs_do_file_wr(struct yaffs_obj *in, const u8 * buffer, loff_t offset,
 
                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), (int)offset, chunk, start));
+                       yaffs_trace(YAFFS_TRACE_ERROR,
+                               "AddrToChunk of offset %d gives chunk %d start %d",
+                               (int)offset, chunk, start);
                }
                chunk++;        /* File pos to chunk in file offset */
 
@@ -3867,10 +3837,9 @@ static void yaffs_prune_chunks(struct yaffs_obj *in, int new_size)
                            || chunk_id >=
                            ((dev->internal_end_block +
                              1) * dev->param.chunks_per_block)) {
-                               T(YAFFS_TRACE_ALWAYS,
-                                 (TSTR
-                                  ("Found daft chunk_id %d for %d" TENDSTR),
-                                  chunk_id, i));
+                               yaffs_trace(YAFFS_TRACE_ALWAYS,
+                                       "Found daft chunk_id %d for %d",
+                                       chunk_id, i);
                        } else {
                                in->n_data_chunks--;
                                yaffs_chunk_del(dev, chunk_id, 1, __LINE__);
@@ -3894,7 +3863,7 @@ void yaffs_resize_file_down(struct yaffs_obj *obj, loff_t new_size)
                int last_chunk = 1 + new_full;
                u8 *local_buffer = yaffs_get_temp_buffer(dev, __LINE__);
 
-               /* Got to read and rewrite the last chunk with its new size and zero pad */
+               /* Rewrite the last chunk with its new size and zero pad */
                yaffs_rd_data_obj(obj, last_chunk, local_buffer);
                memset(local_buffer + new_partial, 0,
                       dev->data_bytes_per_chunk - new_partial);
@@ -3989,9 +3958,9 @@ static int yaffs_unlink_file_if_needed(struct yaffs_obj *in)
                ret_val =
                    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->obj_id));
+               yaffs_trace(YAFFS_TRACE_TRACING,
+                       "yaffs: immediate deletion of file %d",
+                       in->obj_id);
                in->deleted = 1;
                in->my_dev->n_deleted_files++;
                if (dev->param.disable_soft_del || dev->param.is_yaffs2)
@@ -4084,10 +4053,9 @@ int yaffs_del_obj(struct yaffs_obj *obj)
                break;
        case YAFFS_OBJECT_TYPE_DIRECTORY:
                if (!list_empty(&obj->variant.dir_variant.dirty)) {
-                       T(YAFFS_TRACE_BACKGROUND,
-                         (TSTR
-                          ("Remove object %d from dirty directories" TENDSTR),
-                          obj->obj_id));
+                       yaffs_trace(YAFFS_TRACE_BACKGROUND,
+                               "Remove object %d from dirty directories",
+                               obj->obj_id);
                        list_del_init(&obj->variant.dir_variant.dirty);
                }
                return yaffs_del_dir(obj);
@@ -4450,10 +4418,9 @@ static void yaffs_fix_hanging_objs(struct yaffs_dev *dev)
                                                hanging = 1;
                                }
                                if (hanging) {
-                                       T(YAFFS_TRACE_SCAN,
-                                         (TSTR
-                                          ("Hanging object %d moved to lost and found"
-                                           TENDSTR), obj->obj_id));
+                                       yaffs_trace(YAFFS_TRACE_SCAN,
+                                               "Hanging object %d moved to lost and found",
+                                               obj->obj_id);
                                        yaffs_add_obj_to_dir(dev->lost_n_found,
                                                             obj);
                                }
@@ -4480,9 +4447,9 @@ static void yaffs_del_dir_contents(struct yaffs_obj *dir)
                        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->obj_id));
+                       yaffs_trace(YAFFS_TRACE_SCAN,
+                               "Deleting lost_found object %d",
+                               obj->obj_id);
 
                        /* Need to use UnlinkObject since Delete would not handle
                         * hardlinked objects correctly.
@@ -4513,16 +4480,16 @@ struct yaffs_obj *yaffs_find_by_name(struct yaffs_obj *directory,
                return NULL;
 
        if (!directory) {
-               T(YAFFS_TRACE_ALWAYS,
-                 (TSTR
-                  ("tragedy: yaffs_find_by_name: null pointer directory"
-                   TENDSTR)));
+               yaffs_trace(YAFFS_TRACE_ALWAYS,
+                       "tragedy: yaffs_find_by_name: null pointer directory"
+                       );
                YBUG();
                return NULL;
        }
        if (directory->variant_type != YAFFS_OBJECT_TYPE_DIRECTORY) {
-               T(YAFFS_TRACE_ALWAYS,
-                 (TSTR("tragedy: yaffs_find_by_name: non-directory" TENDSTR)));
+               yaffs_trace(YAFFS_TRACE_ALWAYS,
+                       "tragedy: yaffs_find_by_name: non-directory"
+                       );
                YBUG();
        }
 
@@ -4798,13 +4765,14 @@ int yaffs_guts_initialise(struct yaffs_dev *dev)
        unsigned x;
        int bits;
 
-       T(YAFFS_TRACE_TRACING,
-         (TSTR("yaffs: yaffs_guts_initialise()" TENDSTR)));
+       yaffs_trace(YAFFS_TRACE_TRACING, "yaffs: yaffs_guts_initialise()" );
 
        /* Check stuff that must be set */
 
        if (!dev) {
-               T(YAFFS_TRACE_ALWAYS, (TSTR("yaffs: Need a device" TENDSTR)));
+               yaffs_trace(YAFFS_TRACE_ALWAYS,
+                       "yaffs: Need a device"
+                       );
                return YAFFS_FAIL;
        }
 
@@ -4825,18 +4793,29 @@ int yaffs_guts_initialise(struct yaffs_dev *dev)
 
        /* Check geometry parameters. */
 
-       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, inband_tags %d "
-                   TENDSTR), dev->param.total_bytes_per_chunk,
-                  dev->param.is_yaffs2 ? "2" : "", dev->param.inband_tags));
+       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 */
+               yaffs_trace(YAFFS_TRACE_ALWAYS,
+                       "NAND geometry problems: chunk size %d, type is yaffs%s, inband_tags %d ",
+                       dev->param.total_bytes_per_chunk,
+                       dev->param.is_yaffs2 ? "2" : "",
+                       dev->param.inband_tags);
                return YAFFS_FAIL;
        }
 
        if (yaffs_init_nand(dev) != YAFFS_OK) {
-               T(YAFFS_TRACE_ALWAYS,
-                 (TSTR("yaffs: InitialiseNAND failed" TENDSTR)));
+               yaffs_trace(YAFFS_TRACE_ALWAYS, "InitialiseNAND failed");
                return YAFFS_FAIL;
        }
 
@@ -4851,16 +4830,14 @@ int yaffs_guts_initialise(struct yaffs_dev *dev)
        /* Got the right mix of functions? */
        if (!yaffs_check_dev_fns(dev)) {
                /* Function missing */
-               T(YAFFS_TRACE_ALWAYS,
-                 (TSTR
-                  ("yaffs: device function(s) missing or wrong\n" TENDSTR)));
+               yaffs_trace(YAFFS_TRACE_ALWAYS,
+                       "device function(s) missing or wrong");
 
                return YAFFS_FAIL;
        }
 
        if (dev->is_mounted) {
-               T(YAFFS_TRACE_ALWAYS,
-                 (TSTR("yaffs: device already mounted\n" TENDSTR)));
+               yaffs_trace(YAFFS_TRACE_ALWAYS, "device already mounted");
                return YAFFS_FAIL;
        }
 
@@ -4927,8 +4904,7 @@ int yaffs_guts_initialise(struct yaffs_dev *dev)
                 * the chunk group size > chunks per block.
                 * This can be remedied by using larger "virtual blocks".
                 */
-               T(YAFFS_TRACE_ALWAYS,
-                 (TSTR("yaffs: chunk group too large\n" TENDSTR)));
+               yaffs_trace(YAFFS_TRACE_ALWAYS, "chunk group too large");
 
                return YAFFS_FAIL;
        }
@@ -5020,10 +4996,9 @@ int yaffs_guts_initialise(struct yaffs_dev *dev)
                if (dev->param.is_yaffs2) {
                        if (yaffs2_checkpt_restore(dev)) {
                                yaffs_check_obj_details_loaded(dev->root_dir);
-                               T(YAFFS_TRACE_CHECKPOINT | YAFFS_TRACE_MOUNT,
-                                 (TSTR
-                                  ("yaffs: restored from checkpoint"
-                                   TENDSTR)));
+                               yaffs_trace(YAFFS_TRACE_CHECKPOINT | YAFFS_TRACE_MOUNT,
+                                       "yaffs: restored from checkpoint"
+                                       );
                        } else {
 
                                /* Clean up the mess caused by an aborted checkpoint load
@@ -5065,8 +5040,8 @@ int yaffs_guts_initialise(struct yaffs_dev *dev)
 
        if (init_failed) {
                /* Clean up the mess */
-               T(YAFFS_TRACE_TRACING,
-                 (TSTR("yaffs: yaffs_guts_initialise() aborted.\n" TENDSTR)));
+               yaffs_trace(YAFFS_TRACE_TRACING,
+                 "yaffs: yaffs_guts_initialise() aborted.");
 
                yaffs_deinitialise(dev);
                return YAFFS_FAIL;
@@ -5088,8 +5063,8 @@ int yaffs_guts_initialise(struct yaffs_dev *dev)
        if (!dev->is_checkpointed && dev->blocks_in_checkpt > 0)
                yaffs2_checkpt_invalidate(dev);
 
-       T(YAFFS_TRACE_TRACING,
-         (TSTR("yaffs: yaffs_guts_initialise() done.\n" TENDSTR)));
+       yaffs_trace(YAFFS_TRACE_TRACING,
+         "yaffs: yaffs_guts_initialise() done.");
        return YAFFS_OK;
 
 }
index c3ea8c9..603dc97 100644 (file)
@@ -137,9 +137,9 @@ int nandmtd1_write_chunk_tags(struct yaffs_dev *dev,
 
        retval = mtd->write_oob(mtd, addr, &ops);
        if (retval) {
-               T(YAFFS_TRACE_MTD,
-                 (TSTR("write_oob failed, chunk %d, mtd error %d" TENDSTR),
-                  nand_chunk, retval));
+               yaffs_trace(YAFFS_TRACE_MTD,
+                       "write_oob failed, chunk %d, mtd error %d",
+                       nand_chunk, retval);
        }
        return retval ? YAFFS_FAIL : YAFFS_OK;
 }
@@ -198,11 +198,10 @@ int nandmtd1_read_chunk_tags(struct yaffs_dev *dev,
         * Check status and determine ECC result.
         */
        retval = mtd->read_oob(mtd, addr, &ops);
-       if (retval) {
-               T(YAFFS_TRACE_MTD,
-                 (TSTR("read_oob failed, chunk %d, mtd error %d" TENDSTR),
-                  nand_chunk, retval));
-       }
+       if (retval)
+               yaffs_trace(YAFFS_TRACE_MTD,
+                       "read_oob failed, chunk %d, mtd error %d",
+                       nand_chunk, retval);
 
        switch (retval) {
        case 0:
@@ -286,8 +285,7 @@ int nandmtd1_mark_block_bad(struct yaffs_dev *dev, int block_no)
        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), block_no));
+       yaffs_trace(YAFFS_TRACE_BAD_BLOCKS, "marking block %d bad", block_no);
 
        retval = mtd->block_markbad(mtd, (loff_t) blocksize * block_no);
        return (retval) ? YAFFS_FAIL : YAFFS_OK;
@@ -304,10 +302,9 @@ static int nandmtd1_test_prerequists(struct mtd_info *mtd)
        int oobavail = mtd->ecclayout->oobavail;
 
        if (oobavail < YTAG1_SIZE) {
-               T(YAFFS_TRACE_ERROR,
-                 (TSTR
-                  ("mtd device has only %d bytes for tags, need %d" TENDSTR),
-                  oobavail, YTAG1_SIZE));
+               yaffs_trace(YAFFS_TRACE_ERROR,
+                       "mtd device has only %d bytes for tags, need %d",
+                       oobavail, YTAG1_SIZE);
                return YAFFS_FAIL;
        }
        return YAFFS_OK;
@@ -342,8 +339,9 @@ int nandmtd1_query_block(struct yaffs_dev *dev, int block_no,
        retval = nandmtd1_read_chunk_tags(dev, chunk_num, NULL, &etags);
        etags.block_bad = (mtd->block_isbad) (mtd, addr);
        if (etags.block_bad) {
-               T(YAFFS_TRACE_BAD_BLOCKS,
-                 (TSTR("block %d is marked bad" TENDSTR), block_no));
+               yaffs_trace(YAFFS_TRACE_BAD_BLOCKS,
+                       "block %d is marked bad",
+                       block_no);
                state = YAFFS_BLOCK_STATE_DEAD;
        } else if (etags.ecc_result != YAFFS_ECC_RESULT_NO_ERROR) {
                /* bad tags, need to look more closely */
index a0bc04f..5108369 100644 (file)
@@ -111,9 +111,9 @@ int nandmtd1_write_chunk_tags(struct yaffs_dev *dev,
 
        retval = mtd->write_oob(mtd, addr, &ops);
        if (retval) {
-               T(YAFFS_TRACE_MTD,
-                 (TSTR("write_oob failed, chunk %d, mtd error %d" TENDSTR),
-                  nand_chunk, retval));
+               yaffs_trace(YAFFS_TRACE_MTD,
+                       "write_oob failed, chunk %d, mtd error %d",
+                       nand_chunk, retval);
        }
        return retval ? YAFFS_FAIL : YAFFS_OK;
 }
@@ -167,9 +167,9 @@ int nandmtd1_read_chunk_tags(struct yaffs_dev *dev,
         */
        retval = mtd->read_oob(mtd, addr, &ops);
        if (retval) {
-               T(YAFFS_TRACE_MTD,
-                 (TSTR("read_oob failed, chunk %d, mtd error %d" TENDSTR),
-                  nand_chunk, retval));
+               yaffs_trace(YAFFS_TRACE_MTD,
+                       "read_oob failed, chunk %d, mtd error %d",
+                       nand_chunk, retval);
        }
 
        switch (retval) {
@@ -254,8 +254,8 @@ int nandmtd1_mark_block_bad(struct yaffs_dev *dev, int block_no)
        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), block_no));
+       yaffs_trace(YAFFS_TRACE_BAD_BLOCKS,
+               "marking block %d bad", block_no);
 
        retval = mtd->block_markbad(mtd, (loff_t) blocksize * block_no);
        return (retval) ? YAFFS_FAIL : YAFFS_OK;
@@ -272,10 +272,9 @@ static int nandmtd1_test_prerequists(struct mtd_info *mtd)
        int oobavail = mtd->ecclayout->oobavail;
 
        if (oobavail < YTAG1_SIZE) {
-               T(YAFFS_TRACE_ERROR,
-                 (TSTR
-                  ("mtd device has only %d bytes for tags, need %d" TENDSTR),
-                  oobavail, YTAG1_SIZE));
+               yaffs_trace(YAFFS_TRACE_ERROR,
+                       "mtd device has only %d bytes for tags, need %d",
+                       oobavail, YTAG1_SIZE);
                return YAFFS_FAIL;
        }
        return YAFFS_OK;
@@ -310,8 +309,8 @@ int nandmtd1_query_block(struct yaffs_dev *dev, int block_no,
        retval = nandmtd1_read_chunk_tags(dev, chunk_num, NULL, &etags);
        etags.block_bad = (mtd->block_isbad) (mtd, addr);
        if (etags.block_bad) {
-               T(YAFFS_TRACE_BAD_BLOCKS,
-                 (TSTR("block %d is marked bad" TENDSTR), block_no));
+               yaffs_trace(YAFFS_TRACE_BAD_BLOCKS,
+                       "block %d is marked bad", block_no);
                state = YAFFS_BLOCK_STATE_DEAD;
        } else if (etags.ecc_result != YAFFS_ECC_RESULT_NO_ERROR) {
                /* bad tags, need to look more closely */
index 26609f7..9dcccb8 100644 (file)
@@ -51,10 +51,9 @@ int nandmtd2_write_chunk_tags(struct yaffs_dev *dev, int nand_chunk,
        void *packed_tags_ptr =
            dev->param.no_tags_ecc ? (void *)&pt.t : (void *)&pt;
 
-       T(YAFFS_TRACE_MTD,
-         (TSTR
-          ("nandmtd2_write_chunk_tags chunk %d data %p tags %p"
-           TENDSTR), nand_chunk, data, tags));
+       yaffs_trace(YAFFS_TRACE_MTD,
+               "nandmtd2_write_chunk_tags chunk %d data %p tags %p",
+               nand_chunk, data, tags);
 
        addr = ((loff_t) nand_chunk) * dev->param.total_bytes_per_chunk;
 
@@ -122,10 +121,9 @@ int nandmtd2_read_chunk_tags(struct yaffs_dev *dev, int nand_chunk,
        void *packed_tags_ptr =
            dev->param.no_tags_ecc ? (void *)&pt.t : (void *)&pt;
 
-       T(YAFFS_TRACE_MTD,
-         (TSTR
-          ("nandmtd2_read_chunk_tags chunk %d data %p tags %p"
-           TENDSTR), nand_chunk, data, tags));
+       yaffs_trace(YAFFS_TRACE_MTD,
+               "nandmtd2_read_chunk_tags chunk %d data %p tags %p",
+               nand_chunk, data, tags);
 
        if (dev->param.inband_tags) {
 
@@ -170,8 +168,8 @@ int nandmtd2_read_chunk_tags(struct yaffs_dev *dev, int nand_chunk,
                if (tags) {
                        struct yaffs_packed_tags2_tags_only *pt2tp;
                        pt2tp =
-                           (struct yaffs_packed_tags2_tags_only *)&data[dev->
-                                                                        data_bytes_per_chunk];
+                               (struct yaffs_packed_tags2_tags_only *)
+                               &data[dev->data_bytes_per_chunk];
                        yaffs_unpack_tags2_tags_only(tags, pt2tp);
                }
        } else {
@@ -206,8 +204,9 @@ int nandmtd2_mark_block_bad(struct yaffs_dev *dev, int block_no)
 {
        struct mtd_info *mtd = yaffs_dev_to_mtd(dev);
        int retval;
-       T(YAFFS_TRACE_MTD,
-         (TSTR("nandmtd2_mark_block_bad %d" TENDSTR), block_no));
+       yaffs_trace(YAFFS_TRACE_MTD,
+               "nandmtd2_mark_block_bad %d",
+               block_no);
 
        retval =
            mtd->block_markbad(mtd,
@@ -227,14 +226,14 @@ int nandmtd2_query_block(struct yaffs_dev *dev, int block_no,
        struct mtd_info *mtd = yaffs_dev_to_mtd(dev);
        int retval;
 
-       T(YAFFS_TRACE_MTD, (TSTR("nandmtd2_query_block %d" TENDSTR), block_no));
+       yaffs_trace(YAFFS_TRACE_MTD, "nandmtd2_query_block %d", block_no);
        retval =
            mtd->block_isbad(mtd,
                             block_no * dev->param.chunks_per_block *
                             dev->param.total_bytes_per_chunk);
 
        if (retval) {
-               T(YAFFS_TRACE_MTD, (TSTR("block is bad" TENDSTR)));
+               yaffs_trace(YAFFS_TRACE_MTD, "block is bad");
 
                *state = YAFFS_BLOCK_STATE_DEAD;
                *seq_number = 0;
@@ -251,11 +250,13 @@ int nandmtd2_query_block(struct yaffs_dev *dev, int block_no,
                        *state = YAFFS_BLOCK_STATE_EMPTY;
                }
        }
-       T(YAFFS_TRACE_MTD,
-         (TSTR("block is bad seq %d state %d" TENDSTR), *seq_number, *state));
+       yaffs_trace(YAFFS_TRACE_MTD,
+               "block is bad seq %d state %d",
+               *seq_number, *state);
 
        if (retval == 0)
                return YAFFS_OK;
        else
                return YAFFS_FAIL;
 }
+
index 0835078..d1643df 100644 (file)
@@ -47,10 +47,9 @@ int nandmtd2_write_chunk_tags(struct yaffs_dev *dev, int nand_chunk,
        void *packed_tags_ptr =
            dev->param.no_tags_ecc ? (void *)&pt.t : (void *)&pt;
 
-       T(YAFFS_TRACE_MTD,
-         (TSTR
-          ("nandmtd2_write_chunk_tags chunk %d data %p tags %p"
-           TENDSTR), nand_chunk, data, tags));
+       yaffs_trace(YAFFS_TRACE_MTD,
+               "nandmtd2_write_chunk_tags chunk %d data %p tags %p",
+               nand_chunk, data, tags);
 
        addr = ((loff_t) nand_chunk) * dev->param.total_bytes_per_chunk;
 
@@ -104,10 +103,9 @@ int nandmtd2_read_chunk_tags(struct yaffs_dev *dev, int nand_chunk,
        void *packed_tags_ptr =
            dev->param.no_tags_ecc ? (void *)&pt.t : (void *)&pt;
 
-       T(YAFFS_TRACE_MTD,
-         (TSTR
-          ("nandmtd2_read_chunk_tags chunk %d data %p tags %p"
-           TENDSTR), nand_chunk, data, tags));
+       yaffs_trace(YAFFS_TRACE_MTD,
+               "nandmtd2_read_chunk_tags chunk %d data %p tags %p",
+               nand_chunk, data, tags);
 
        if (dev->param.inband_tags) {
 
@@ -171,8 +169,8 @@ int nandmtd2_mark_block_bad(struct yaffs_dev *dev, int block_no)
 {
        struct mtd_info *mtd = yaffs_dev_to_mtd(dev);
        int retval;
-       T(YAFFS_TRACE_MTD,
-         (TSTR("nandmtd2_mark_block_bad %d" TENDSTR), block_no));
+       yaffs_trace(YAFFS_TRACE_MTD,
+               "nandmtd2_mark_block_bad %d", block_no);
 
        retval =
            mtd->block_markbad(mtd,
@@ -192,14 +190,14 @@ int nandmtd2_query_block(struct yaffs_dev *dev, int block_no,
        struct mtd_info *mtd = yaffs_dev_to_mtd(dev);
        int retval;
 
-       T(YAFFS_TRACE_MTD, (TSTR("nandmtd2_query_block %d" TENDSTR), block_no));
+       yaffs_trace(YAFFS_TRACE_MTD, "nandmtd2_query_block %d", block_no);
        retval =
            mtd->block_isbad(mtd,
                             block_no * dev->param.chunks_per_block *
                             dev->param.total_bytes_per_chunk);
 
        if (retval) {
-               T(YAFFS_TRACE_MTD, (TSTR("block is bad" TENDSTR)));
+               yaffs_trace(YAFFS_TRACE_MTD, "block is bad");
 
                *state = YAFFS_BLOCK_STATE_DEAD;
                *seq_number = 0;
@@ -216,11 +214,12 @@ int nandmtd2_query_block(struct yaffs_dev *dev, int block_no,
                        *state = YAFFS_BLOCK_STATE_EMPTY;
                }
        }
-       T(YAFFS_TRACE_MTD,
-         (TSTR("block is bad seq %d state %d" TENDSTR), *seq_number, *state));
+       yaffs_trace(YAFFS_TRACE_MTD,
+               "block is bad seq %d state %d", *seq_number, *state);
 
        if (retval == 0)
                return YAFFS_OK;
        else
                return YAFFS_FAIL;
 }
+
index 84ab0f0..e816cab 100644 (file)
@@ -63,15 +63,14 @@ int yaffs_wr_chunk_tags_nand(struct yaffs_dev *dev,
                tags->seq_number = dev->seq_number;
                tags->chunk_used = 1;
                if (!yaffs_validate_tags(tags)) {
-                       T(YAFFS_TRACE_ERROR,
-                         (TSTR("Writing uninitialised tags" TENDSTR)));
+                       yaffs_trace(YAFFS_TRACE_ERROR, "Writing uninitialised tags");
                        YBUG();
                }
-               T(YAFFS_TRACE_WRITE,
-                 (TSTR("Writing chunk %d tags %d %d" TENDSTR), nand_chunk,
-                  tags->obj_id, tags->chunk_id));
+               yaffs_trace(YAFFS_TRACE_WRITE,
+                       "Writing chunk %d tags %d %d",
+                       nand_chunk, tags->obj_id, tags->chunk_id);
        } else {
-               T(YAFFS_TRACE_ERROR, (TSTR("Writing with no tags" TENDSTR)));
+               yaffs_trace(YAFFS_TRACE_ERROR, "Writing with no tags");
                YBUG();
        }
 
index 6c12aed..8e7fea3 100644 (file)
@@ -41,9 +41,9 @@
 static void yaffs_dump_packed_tags2_tags_only(const struct
                                              yaffs_packed_tags2_tags_only *ptt)
 {
-       T(YAFFS_TRACE_MTD,
-         (TSTR("packed tags obj %d chunk %d byte %d seq %d" TENDSTR),
-          ptt->obj_id, ptt->chunk_id, ptt->n_bytes, ptt->seq_number));
+       yaffs_trace(YAFFS_TRACE_MTD,
+               "packed tags obj %d chunk %d byte %d seq %d",
+               ptt->obj_id, ptt->chunk_id, ptt->n_bytes, ptt->seq_number);
 }
 
 static void yaffs_dump_packed_tags2(const struct yaffs_packed_tags2 *pt)
@@ -53,12 +53,11 @@ static void yaffs_dump_packed_tags2(const struct yaffs_packed_tags2 *pt)
 
 static void yaffs_dump_tags2(const struct 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->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));
+       yaffs_trace(YAFFS_TRACE_MTD,
+               "ext.tags eccres %d blkbad %d chused %d obj %d chunk%d byte %d del %d ser %d seq %d",
+               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);
 
 }
 
index a35e0f3..7578075 100644 (file)
@@ -132,9 +132,9 @@ static int yaffs_wr_nand(struct yaffs_dev *dev,
                         struct yaffs_spare *spare)
 {
        if (nand_chunk < dev->param.start_block * dev->param.chunks_per_block) {
-               T(YAFFS_TRACE_ERROR,
-                 (TSTR("**>> yaffs chunk %d is not valid" TENDSTR),
-                  nand_chunk));
+               yaffs_trace(YAFFS_TRACE_ERROR,
+                       "**>> yaffs chunk %d is not valid",
+                       nand_chunk);
                return YAFFS_FAIL;
        }
 
@@ -175,30 +175,26 @@ static int yaffs_rd_chunk_nand(struct yaffs_dev *dev,
                                              calc_ecc);
 
                        if (ecc_result1 > 0) {
-                               T(YAFFS_TRACE_ERROR,
-                                 (TSTR
-                                  ("**>>yaffs ecc error fix performed on chunk %d:0"
-                                   TENDSTR), nand_chunk));
+                               yaffs_trace(YAFFS_TRACE_ERROR,
+                                       "**>>yaffs ecc error fix performed on chunk %d:0",
+                                       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), nand_chunk));
+                               yaffs_trace(YAFFS_TRACE_ERROR,
+                                       "**>>yaffs ecc error unfixed on chunk %d:0",
+                                       nand_chunk);
                                dev->n_ecc_unfixed++;
                        }
 
                        if (ecc_result2 > 0) {
-                               T(YAFFS_TRACE_ERROR,
-                                 (TSTR
-                                  ("**>>yaffs ecc error fix performed on chunk %d:1"
-                                   TENDSTR), nand_chunk));
+                               yaffs_trace(YAFFS_TRACE_ERROR,
+                                       "**>>yaffs ecc error fix performed on chunk %d:1",
+                                       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), nand_chunk));
+                               yaffs_trace(YAFFS_TRACE_ERROR,
+                                       "**>>yaffs ecc error unfixed on chunk %d:1",
+                                       nand_chunk);
                                dev->n_ecc_unfixed++;
                        }
 
@@ -227,27 +223,23 @@ static int yaffs_rd_chunk_nand(struct yaffs_dev *dev,
                memcpy(spare, &nspare, sizeof(struct yaffs_spare));
                if (data && correct_errors) {
                        if (nspare.eccres1 > 0) {
-                               T(YAFFS_TRACE_ERROR,
-                                 (TSTR
-                                  ("**>>mtd ecc error fix performed on chunk %d:0"
-                                   TENDSTR), nand_chunk));
+                               yaffs_trace(YAFFS_TRACE_ERROR,
+                                       "**>>mtd ecc error fix performed on chunk %d:0",
+                                       nand_chunk);
                        } else if (nspare.eccres1 < 0) {
-                               T(YAFFS_TRACE_ERROR,
-                                 (TSTR
-                                  ("**>>mtd ecc error unfixed on chunk %d:0"
-                                   TENDSTR), nand_chunk));
+                               yaffs_trace(YAFFS_TRACE_ERROR,
+                                       "**>>mtd ecc error unfixed on chunk %d:0",
+                                       nand_chunk);
                        }
 
                        if (nspare.eccres2 > 0) {
-                               T(YAFFS_TRACE_ERROR,
-                                 (TSTR
-                                  ("**>>mtd ecc error fix performed on chunk %d:1"
-                                   TENDSTR), nand_chunk));
+                               yaffs_trace(YAFFS_TRACE_ERROR,
+                                       "**>>mtd ecc error fix performed on chunk %d:1",
+                                       nand_chunk);
                        } else if (nspare.eccres2 < 0) {
-                               T(YAFFS_TRACE_ERROR,
-                                 (TSTR
-                                  ("**>>mtd ecc error unfixed on chunk %d:1"
-                                   TENDSTR), nand_chunk));
+                               yaffs_trace(YAFFS_TRACE_ERROR,
+                                       "**>>mtd ecc error unfixed on chunk %d:1",
+                                       nand_chunk);
                        }
 
                        if (nspare.eccres1 || nspare.eccres2) {
@@ -279,8 +271,9 @@ static void yaffs_handle_rd_data_error(struct yaffs_dev *dev, int nand_chunk)
        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), flash_block));
+       yaffs_trace(YAFFS_TRACE_ERROR | YAFFS_TRACE_BAD_BLOCKS,
+               "**>>Block %d marked for retirement",
+               flash_block);
 
        /* TODO:
         * Just do a garbage collection on the affected block
index 8f632ff..6273dbf 100644 (file)
@@ -54,6 +54,4 @@ extern unsigned int yaffs_wr_attempts;
 #define YAFFS_TRACE_BUG                        0x80000000
 #define YAFFS_TRACE_ALWAYS             0xF0000000
 
-#define T(mask, p) do { if ((mask) & (yaffs_trace_mask | YAFFS_TRACE_ALWAYS)) TOUT(p); } while (0)
-
 #endif
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;
 }
+
index 074a285..85df2d7 100644 (file)
@@ -507,14 +507,14 @@ static unsigned yaffs_gc_control_callback(struct yaffs_dev *dev)
 
 static void yaffs_gross_lock(struct yaffs_dev *dev)
 {
-       T(YAFFS_TRACE_LOCK, (TSTR("yaffs locking %p\n"), current));
+       yaffs_trace(YAFFS_TRACE_LOCK, "yaffs locking %p", current);
        mutex_lock(&(yaffs_dev_to_lc(dev)->gross_lock));
-       T(YAFFS_TRACE_LOCK, (TSTR("yaffs locked %p\n"), current));
+       yaffs_trace(YAFFS_TRACE_LOCK, "yaffs locked %p", current);
 }
 
 static void yaffs_gross_unlock(struct yaffs_dev *dev)
 {
-       T(YAFFS_TRACE_LOCK, (TSTR("yaffs unlocking %p\n"), current));
+       yaffs_trace(YAFFS_TRACE_LOCK, "yaffs unlocking %p", current);
        mutex_unlock(&(yaffs_dev_to_lc(dev)->gross_lock));
 }
 
@@ -793,9 +793,8 @@ static struct dentry *yaffs_lookup(struct inode *dir, struct dentry *dentry)
        if (current != yaffs_dev_to_lc(dev)->readdir_process)
                yaffs_gross_lock(dev);
 
-       T(YAFFS_TRACE_OS,
-         (TSTR("yaffs_lookup for %d:%s\n"),
-          yaffs_inode_to_obj(dir)->obj_id, dentry->d_name.name));
+       yaffs_trace(YAFFS_TRACE_OS,"yaffs_lookup for %d:%s",
+               yaffs_inode_to_obj(dir)->obj_id, dentry->d_name.name);
 
        obj = yaffs_find_by_name(yaffs_inode_to_obj(dir), dentry->d_name.name);
 
@@ -806,26 +805,12 @@ static struct dentry *yaffs_lookup(struct inode *dir, struct dentry *dentry)
                yaffs_gross_unlock(dev);
 
        if (obj) {
-               T(YAFFS_TRACE_OS,
-                 (TSTR("yaffs_lookup found %d\n"), obj->obj_id));
+               yaffs_trace(YAFFS_TRACE_OS,
+                       "yaffs_lookup found %d", obj->obj_id);
 
                inode = yaffs_get_inode(dir->i_sb, obj->yst_mode, 0, obj);
-
-               if (inode) {
-                       T(YAFFS_TRACE_OS, (TSTR("yaffs_loookup dentry \n")));
-/* #if 0 asserted by NCB for 2.5/6 compatability - falls through to
- * d_add even if NULL inode */
-#if 0
-                       /*dget(dentry); // try to solve directory bug */
-                       d_add(dentry, inode);
-
-                       /* return dentry; */
-                       return NULL;
-#endif
-               }
-
        } else {
-               T(YAFFS_TRACE_OS, (TSTR("yaffs_lookup not found\n")));
+               yaffs_trace(YAFFS_TRACE_OS, "yaffs_lookup not found");
 
        }
 
@@ -843,9 +828,9 @@ static struct dentry *yaffs_lookup(struct inode *dir, struct dentry *dentry)
  */
 static void yaffs_put_inode(struct inode *inode)
 {
-       T(YAFFS_TRACE_OS,
-         (TSTR("yaffs_put_inode: ino %d, count %d\n"), (int)inode->i_ino,
-          atomic_read(&inode->i_count)));
+       yaffs_trace(YAFFS_TRACE_OS,
+               "yaffs_put_inode: ino %d, count %d"),
+               (int)inode->i_ino, atomic_read(&inode->i_count);
 
 }
 #endif
@@ -878,10 +863,10 @@ static void yaffs_evict_inode(struct inode *inode)
 
        obj = yaffs_inode_to_obj(inode);
 
-       T(YAFFS_TRACE_OS,
-         (TSTR("yaffs_evict_inode: ino %d, count %d %s\n"), (int)inode->i_ino,
-          atomic_read(&inode->i_count),
-          obj ? "object exists" : "null object"));
+       yaffs_trace(YAFFS_TRACE_OS,
+               "yaffs_evict_inode: ino %d, count %d %s",
+               (int)inode->i_ino, atomic_read(&inode->i_count),
+               obj ? "object exists" : "null object"));
 
        if (!inode->i_nlink && !is_bad_inode(inode))
                deleteme = 1;
@@ -900,7 +885,6 @@ static void yaffs_evict_inode(struct inode *inode)
                yaffs_unstitch_obj(inode, obj);
                yaffs_gross_unlock(dev);
        }
-
 }
 #else
 
@@ -918,10 +902,10 @@ static void yaffs_clear_inode(struct inode *inode)
 
        obj = yaffs_inode_to_obj(inode);
 
-       T(YAFFS_TRACE_OS,
-         (TSTR("yaffs_clear_inode: ino %d, count %d %s\n"), (int)inode->i_ino,
-          atomic_read(&inode->i_count),
-          obj ? "object exists" : "null object"));
+       yaffs_trace(YAFFS_TRACE_OS,
+               "yaffs_clear_inode: ino %d, count %d %s",
+               (int)inode->i_ino, atomic_read(&inode->i_count),
+               obj ? "object exists" : "null object");
 
        if (obj) {
                dev = obj->my_dev;
@@ -942,10 +926,10 @@ static void yaffs_delete_inode(struct inode *inode)
        struct yaffs_obj *obj = yaffs_inode_to_obj(inode);
        struct yaffs_dev *dev;
 
-       T(YAFFS_TRACE_OS,
-         (TSTR("yaffs_delete_inode: ino %d, count %d %s\n"), (int)inode->i_ino,
-          atomic_read(&inode->i_count),
-          obj ? "object exists" : "null object"));
+       yaffs_trace(YAFFS_TRACE_OS,
+               "yaffs_delete_inode: ino %d, count %d %s",
+               (int)inode->i_ino, atomic_read(&inode->i_count),
+               obj ? "object exists" : "null object");
 
        if (obj) {
                dev = obj->my_dev;
@@ -970,9 +954,10 @@ static int yaffs_file_flush(struct file *file)
 
        struct yaffs_dev *dev = obj->my_dev;
 
-       T(YAFFS_TRACE_OS,
-         (TSTR("yaffs_file_flush object %d (%s)\n"), obj->obj_id,
-          obj->dirty ? "dirty" : "clean"));
+       yaffs_trace(YAFFS_TRACE_OS,
+               "yaffs_file_flush object %d (%s)",
+               obj->obj_id,
+               obj->dirty ? "dirty" : "clean");
 
        yaffs_gross_lock(dev);
 
@@ -993,10 +978,10 @@ static int yaffs_readpage_nolock(struct file *f, struct page *pg)
 
        struct yaffs_dev *dev;
 
-       T(YAFFS_TRACE_OS,
-         (TSTR("yaffs_readpage_nolock at %08x, size %08x\n"),
-          (unsigned)(pg->index << PAGE_CACHE_SHIFT),
-          (unsigned)PAGE_CACHE_SIZE));
+       yaffs_trace(YAFFS_TRACE_OS,
+               "yaffs_readpage_nolock at %08x, size %08x",
+               (unsigned)(pg->index << PAGE_CACHE_SHIFT),
+               (unsigned)PAGE_CACHE_SIZE);
 
        obj = yaffs_dentry_to_obj(f->f_dentry);
 
@@ -1033,7 +1018,7 @@ static int yaffs_readpage_nolock(struct file *f, struct page *pg)
        flush_dcache_page(pg);
        kunmap(pg);
 
-       T(YAFFS_TRACE_OS, (TSTR("yaffs_readpage_nolock done\n")));
+       yaffs_trace(YAFFS_TRACE_OS, "yaffs_readpage_nolock done");
        return ret;
 }
 
@@ -1048,9 +1033,9 @@ static int yaffs_readpage(struct file *f, struct page *pg)
 {
        int ret;
 
-       T(YAFFS_TRACE_OS, (TSTR("yaffs_readpage\n")));
+       yaffs_trace(YAFFS_TRACE_OS, "yaffs_readpage");
        ret = yaffs_readpage_unlock(f, pg);
-       T(YAFFS_TRACE_OS, (TSTR("yaffs_readpage done\n")));
+       yaffs_trace(YAFFS_TRACE_OS, "yaffs_readpage done");
        return ret;
 }
 
@@ -1087,13 +1072,12 @@ static int yaffs_writepage(struct page *page)
                n_bytes = i_size & (PAGE_CACHE_SIZE - 1);
 
                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),
-                          (unsigned)inode->i_size));
-                       T(YAFFS_TRACE_OS,
-                         (TSTR("                -> don't care!!\n")));
+                       yaffs_trace(YAFFS_TRACE_OS,
+                               "yaffs_writepage at %08x, inode size = %08x!!",
+                               (unsigned)(page->index << PAGE_CACHE_SHIFT),
+                               (unsigned)inode->i_size);
+                       yaffs_trace(YAFFS_TRACE_OS,
+                               "                -> don't care!!");
 
                        zero_user_segment(page, 0, PAGE_CACHE_SIZE);
                        set_page_writeback(page);
@@ -1114,21 +1098,21 @@ static int yaffs_writepage(struct page *page)
        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), n_bytes));
-       T(YAFFS_TRACE_OS,
-         (TSTR("writepag0: obj = %05x, ino = %05x\n"),
-          (int)obj->variant.file_variant.file_size, (int)inode->i_size));
+       yaffs_trace(YAFFS_TRACE_OS,
+               "yaffs_writepage at %08x, size %08x",
+               (unsigned)(page->index << PAGE_CACHE_SHIFT), n_bytes);
+       yaffs_trace(YAFFS_TRACE_OS,
+               "writepag0: obj = %05x, ino = %05x",
+               (int)obj->variant.file_variant.file_size, (int)inode->i_size);
 
        n_written = yaffs_wr_file(obj, buffer,
                                  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.file_variant.file_size, (int)inode->i_size));
+       yaffs_trace(YAFFS_TRACE_OS,
+               "writepag1: obj = %05x, ino = %05x",
+               (int)obj->variant.file_variant.file_size, (int)inode->i_size);
 
        yaffs_gross_unlock(dev);
 
@@ -1164,9 +1148,9 @@ static int yaffs_write_begin(struct file *filp, struct address_space *mapping,
                ret = -ENOMEM;
                goto out;
        }
-       T(YAFFS_TRACE_OS,
-         (TSTR("start yaffs_write_begin index %d(%x) uptodate %d\n"),
-          (int)index, (int)index, Page_Uptodate(pg) ? 1 : 0));
+       yaffs_trace(YAFFS_TRACE_OS,
+               "start yaffs_write_begin index %d(%x) uptodate %d",
+               (int)index, (int)index, Page_Uptodate(pg) ? 1 : 0);
 
        /* Get fs space */
        space_held = yaffs_hold_space(filp);
@@ -1185,13 +1169,13 @@ static int yaffs_write_begin(struct file *filp, struct address_space *mapping,
                goto out;
 
        /* Happy path return */
-       T(YAFFS_TRACE_OS, (TSTR("end yaffs_write_begin - ok\n")));
+       yaffs_trace(YAFFS_TRACE_OS, "end yaffs_write_begin - ok");
 
        return 0;
 
 out:
-       T(YAFFS_TRACE_OS,
-         (TSTR("end yaffs_write_begin fail returning %d\n"), ret));
+       yaffs_trace(YAFFS_TRACE_OS,
+               "end yaffs_write_begin fail returning %d", ret);
        if (space_held)
                yaffs_release_space(filp);
        if (pg) {
@@ -1206,7 +1190,7 @@ out:
 static int yaffs_prepare_write(struct file *f, struct page *pg,
                               unsigned offset, unsigned to)
 {
-       T(YAFFS_TRACE_OS, (TSTR("yaffs_prepair_write\n")));
+       yaffs_trace(YAFFS_TRACE_OS, "yaffs_prepair_write");
 
        if (!Page_Uptodate(pg))
                return yaffs_readpage_nolock(f, pg);
@@ -1226,19 +1210,17 @@ static int yaffs_write_end(struct file *filp, struct address_space *mapping,
        kva = kmap(pg);
        addr = kva + offset_into_page;
 
-       T(YAFFS_TRACE_OS,
-         ("yaffs_write_end addr %p pos %x n_bytes %d\n",
-          addr, (unsigned)pos, copied));
+       yaffs_trace(YAFFS_TRACE_OS,
+               "yaffs_write_end addr %p pos %x n_bytes %d",
+               addr, (unsigned)pos, copied);
 
        ret = yaffs_file_write(filp, addr, copied, &pos);
 
        if (ret != copied) {
-               T(YAFFS_TRACE_OS,
-                 (TSTR("yaffs_write_end not same size ret %d  copied %d\n"),
-                  ret, copied));
+               yaffs_trace(YAFFS_TRACE_OS,
+                       "yaffs_write_end not same size ret %d  copied %d",
+                       ret, copied);
                SetPageError(pg);
-       } else {
-               /* Nothing */
        }
 
        kunmap(pg);
@@ -1267,27 +1249,23 @@ 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 n_bytes %d\n"),
-          saddr, spos, n_bytes));
+       yaffs_trace(YAFFS_TRACE_OS,
+               "yaffs_commit_write addr %x pos %x n_bytes %d",
+               saddr, spos, n_bytes);
 
        n_written = yaffs_file_write(f, addr, n_bytes, &pos);
 
        if (n_written != n_bytes) {
-               T(YAFFS_TRACE_OS,
-                 (TSTR
-                  ("yaffs_commit_write not same size n_written %d  n_bytes %d\n"),
-                  n_written, n_bytes));
+               yaffs_trace(YAFFS_TRACE_OS,
+                       "yaffs_commit_write not same size n_written %d  n_bytes %d",
+                       n_written, n_bytes);
                SetPageError(pg);
-       } else {
-               /* Nothing */
        }
-
        kunmap(pg);
 
-       T(YAFFS_TRACE_OS,
-         (TSTR("yaffs_commit_write returning %d\n"),
-          n_written == n_bytes ? 0 : n_written));
+       yaffs_trace(YAFFS_TRACE_OS,
+               "yaffs_commit_write returning %d",
+               n_written == n_bytes ? 0 : n_written);
 
        return n_written == n_bytes ? 0 : n_written;
 }
@@ -1359,11 +1337,10 @@ static void yaffs_fill_inode_from_obj(struct inode *inode,
 
                inode->i_nlink = yaffs_get_obj_link_count(obj);
 
-               T(YAFFS_TRACE_OS,
-                 (TSTR
-                  ("yaffs_fill_inode mode %x uid %d gid %d size %d count %d\n"),
-                  inode->i_mode, inode->i_uid, inode->i_gid,
-                  (int)inode->i_size, atomic_read(&inode->i_count)));
+               yaffs_trace(YAFFS_TRACE_OS,
+                       "yaffs_fill_inode mode %x uid %d gid %d size %d count %d",
+                       inode->i_mode, inode->i_uid, inode->i_gid,
+                       (int)inode->i_size, atomic_read(&inode->i_count));
 
                switch (obj->yst_mode & S_IFMT) {
                default:        /* fifo, device or socket */
@@ -1395,8 +1372,8 @@ static void yaffs_fill_inode_from_obj(struct inode *inode,
                obj->my_inode = inode;
 
        } else {
-               T(YAFFS_TRACE_OS,
-                 (TSTR("yaffs_fill_inode invalid parameters\n")));
+               yaffs_trace(YAFFS_TRACE_OS,
+                       "yaffs_fill_inode invalid parameters");
        }
 
 }
@@ -1407,21 +1384,21 @@ struct inode *yaffs_get_inode(struct super_block *sb, int mode, int dev,
        struct inode *inode;
 
        if (!sb) {
-               T(YAFFS_TRACE_OS,
-                 (TSTR("yaffs_get_inode for NULL super_block!!\n")));
+               yaffs_trace(YAFFS_TRACE_OS,
+                       "yaffs_get_inode for NULL super_block!!");
                return NULL;
 
        }
 
        if (!obj) {
-               T(YAFFS_TRACE_OS,
-                 (TSTR("yaffs_get_inode for NULL object!!\n")));
+               yaffs_trace(YAFFS_TRACE_OS,
+                       "yaffs_get_inode for NULL object!!");
                return NULL;
 
        }
 
-       T(YAFFS_TRACE_OS,
-         (TSTR("yaffs_get_inode for object %d\n"), obj->obj_id));
+       yaffs_trace(YAFFS_TRACE_OS,
+               "yaffs_get_inode for object %d", obj->obj_id);
 
        inode = Y_IGET(sb, obj->obj_id);
        if (IS_ERR(inode))
@@ -1456,21 +1433,20 @@ static ssize_t yaffs_file_write(struct file *f, const char *buf, size_t n,
                ipos = *pos;
 
        if (!obj)
-               T(YAFFS_TRACE_OS,
-                 (TSTR("yaffs_file_write: hey obj is null!\n")));
+               yaffs_trace(YAFFS_TRACE_OS,
+                       "yaffs_file_write: hey obj is null!");
        else
-               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->obj_id, ipos, ipos));
+               yaffs_trace(YAFFS_TRACE_OS,
+                       "yaffs_file_write about to write writing %u(%x) bytes to object %d at %d(%x)",
+                       (unsigned)n, (unsigned)n, obj->obj_id, ipos, ipos);
 
        n_written = yaffs_wr_file(obj, buf, ipos, n, 0);
 
        yaffs_touch_super(dev);
 
-       T(YAFFS_TRACE_OS,
-         (TSTR("yaffs_file_write: %d(%x) bytes written\n"),
-          (unsigned)n, (unsigned)n));
+       yaffs_trace(YAFFS_TRACE_OS,
+               "yaffs_file_write: %d(%x) bytes written",
+               (unsigned)n, (unsigned)n);
 
        if (n_written > 0) {
                ipos += n_written;
@@ -1479,9 +1455,9 @@ static ssize_t yaffs_file_write(struct file *f, const char *buf, size_t n,
                        inode->i_size = ipos;
                        inode->i_blocks = (ipos + 511) >> 9;
 
-                       T(YAFFS_TRACE_OS,
-                         (TSTR("yaffs_file_write size updated to %d bytes, "
-                               "%d blocks\n"), ipos, (int)(inode->i_blocks)));
+                       yaffs_trace(YAFFS_TRACE_OS,
+                               "yaffs_file_write size updated to %d bytes, %d blocks",
+                               ipos, (int)(inode->i_blocks));
                }
 
        }
@@ -1554,13 +1530,13 @@ static int yaffs_readdir(struct file *f, void *dirent, filldir_t filldir)
                goto out;
        }
 
-       T(YAFFS_TRACE_OS,
-         (TSTR("yaffs_readdir: starting at %d\n"), (int)offset));
+       yaffs_trace(YAFFS_TRACE_OS,
+               "yaffs_readdir: starting at %d", (int)offset);
 
        if (offset == 0) {
-               T(YAFFS_TRACE_OS,
-                 (TSTR("yaffs_readdir: entry . ino %d \n"),
-                  (int)inode->i_ino));
+               yaffs_trace(YAFFS_TRACE_OS,
+                       "yaffs_readdir: entry . ino %d",
+                       (int)inode->i_ino);
                yaffs_gross_unlock(dev);
                if (filldir(dirent, ".", 1, offset, inode->i_ino, DT_DIR) < 0) {
                        yaffs_gross_lock(dev);
@@ -1571,9 +1547,9 @@ static int yaffs_readdir(struct file *f, void *dirent, filldir_t filldir)
                f->f_pos++;
        }
        if (offset == 1) {
-               T(YAFFS_TRACE_OS,
-                 (TSTR("yaffs_readdir: entry .. ino %d \n"),
-                  (int)f->f_dentry->d_parent->d_inode->i_ino));
+               yaffs_trace(YAFFS_TRACE_OS,
+                       "yaffs_readdir: entry .. ino %d",
+                       (int)f->f_dentry->d_parent->d_inode->i_ino);
                yaffs_gross_unlock(dev);
                if (filldir(dirent, "..", 2, offset,
                            f->f_dentry->d_parent->d_inode->i_ino,
@@ -1604,9 +1580,9 @@ static int yaffs_readdir(struct file *f, void *dirent, filldir_t filldir)
                        int this_type = yaffs_get_obj_type(l);
 
                        yaffs_get_obj_name(l, name, YAFFS_MAX_NAME_LENGTH + 1);
-                       T(YAFFS_TRACE_OS,
-                         (TSTR("yaffs_readdir: %s inode %d\n"),
-                          name, yaffs_get_obj_inode(l)));
+                       yaffs_trace(YAFFS_TRACE_OS,
+                               "yaffs_readdir: %s inode %d",
+                               name, yaffs_get_obj_inode(l));
 
                        yaffs_gross_unlock(dev);
 
@@ -1668,18 +1644,18 @@ static int yaffs_mknod(struct inode *dir, struct dentry *dentry, int mode,
                mode |= S_ISGID;
 
        if (parent) {
-               T(YAFFS_TRACE_OS,
-                 (TSTR("yaffs_mknod: parent object %d type %d\n"),
-                  parent->obj_id, parent->variant_type));
+               yaffs_trace(YAFFS_TRACE_OS,
+                       "yaffs_mknod: parent object %d type %d",
+                       parent->obj_id, parent->variant_type);
        } else {
-               T(YAFFS_TRACE_OS,
-                 (TSTR("yaffs_mknod: could not get parent object\n")));
+               yaffs_trace(YAFFS_TRACE_OS,
+                       "yaffs_mknod: could not get parent object");
                return -EPERM;
        }
 
-       T(YAFFS_TRACE_OS, (TSTR("yaffs_mknod: making oject for %s, "
-                               "mode %x dev %x\n"),
-                          dentry->d_name.name, mode, rdev));
+       yaffs_trace(YAFFS_TRACE_OS,
+               "yaffs_mknod: making oject for %s, mode %x dev %x",
+               dentry->d_name.name, mode, rdev);
 
        dev = parent->my_dev;
 
@@ -1688,7 +1664,7 @@ static int yaffs_mknod(struct inode *dir, struct dentry *dentry, int mode,
        switch (mode & S_IFMT) {
        default:
                /* Special (socket, fifo, device...) */
-               T(YAFFS_TRACE_OS, (TSTR("yaffs_mknod: making special\n")));
+               yaffs_trace(YAFFS_TRACE_OS, "yaffs_mknod: making special");
 #if (LINUX_VERSION_CODE > KERNEL_VERSION(2, 5, 0))
                obj =
                    yaffs_create_special(parent, dentry->d_name.name, mode, uid,
@@ -1700,17 +1676,17 @@ static int yaffs_mknod(struct inode *dir, struct dentry *dentry, int mode,
 #endif
                break;
        case S_IFREG:           /* file          */
-               T(YAFFS_TRACE_OS, (TSTR("yaffs_mknod: making file\n")));
+               yaffs_trace(YAFFS_TRACE_OS, "yaffs_mknod: making file");
                obj = yaffs_create_file(parent, dentry->d_name.name, mode, uid,
                                        gid);
                break;
        case S_IFDIR:           /* directory */
-               T(YAFFS_TRACE_OS, (TSTR("yaffs_mknod: making directory\n")));
+               yaffs_trace(YAFFS_TRACE_OS, "yaffs_mknod: making directory");
                obj = yaffs_create_dir(parent, dentry->d_name.name, mode,
                                       uid, gid);
                break;
        case S_IFLNK:           /* symlink */
-               T(YAFFS_TRACE_OS, (TSTR("yaffs_mknod: making symlink\n")));
+               yaffs_trace(YAFFS_TRACE_OS, "yaffs_mknod: making symlink");
                obj = NULL;     /* Do we ever get here? */
                break;
        }
@@ -1722,13 +1698,13 @@ static int yaffs_mknod(struct inode *dir, struct dentry *dentry, int mode,
                inode = yaffs_get_inode(dir->i_sb, mode, rdev, obj);
                d_instantiate(dentry, inode);
                update_dir_time(dir);
-               T(YAFFS_TRACE_OS,
-                 (TSTR("yaffs_mknod created object %d count = %d\n"),
-                  obj->obj_id, atomic_read(&inode->i_count)));
+               yaffs_trace(YAFFS_TRACE_OS,
+                       "yaffs_mknod created object %d count = %d",
+                       obj->obj_id, atomic_read(&inode->i_count));
                error = 0;
                yaffs_fill_inode_from_obj(dir, parent);
        } else {
-               T(YAFFS_TRACE_OS, (TSTR("yaffs_mknod failed making object\n")));
+               yaffs_trace(YAFFS_TRACE_OS, "yaffs_mknod failed making object");
                error = -ENOMEM;
        }
 
@@ -1738,7 +1714,7 @@ static int yaffs_mknod(struct inode *dir, struct dentry *dentry, int mode,
 static int yaffs_mkdir(struct inode *dir, struct dentry *dentry, int mode)
 {
        int ret_val;
-       T(YAFFS_TRACE_OS, (TSTR("yaffs_mkdir\n")));
+       yaffs_trace(YAFFS_TRACE_OS, "yaffs_mkdir");
        ret_val = yaffs_mknod(dir, dentry, mode | S_IFDIR, 0);
        return ret_val;
 }
@@ -1750,7 +1726,7 @@ static int yaffs_create(struct inode *dir, struct dentry *dentry, int mode,
 static int yaffs_create(struct inode *dir, struct dentry *dentry, int mode)
 #endif
 {
-       T(YAFFS_TRACE_OS, (TSTR("yaffs_create\n")));
+       yaffs_trace(YAFFS_TRACE_OS, "yaffs_create");
        return yaffs_mknod(dir, dentry, mode | S_IFREG, 0);
 }
 
@@ -1761,9 +1737,8 @@ static int yaffs_unlink(struct inode *dir, struct dentry *dentry)
        struct yaffs_dev *dev;
        struct yaffs_obj *obj;
 
-       T(YAFFS_TRACE_OS,
-         (TSTR("yaffs_unlink %d:%s\n"),
-          (int)(dir->i_ino), dentry->d_name.name));
+       yaffs_trace(YAFFS_TRACE_OS, "yaffs_unlink %d:%s",
+               (int)(dir->i_ino), dentry->d_name.name);
        obj = yaffs_inode_to_obj(dir);
        dev = obj->my_dev;
 
@@ -1794,7 +1769,7 @@ static int yaffs_link(struct dentry *old_dentry, struct inode *dir,
        struct yaffs_obj *link = NULL;
        struct yaffs_dev *dev;
 
-       T(YAFFS_TRACE_OS, (TSTR("yaffs_link\n")));
+       yaffs_trace(YAFFS_TRACE_OS, "yaffs_link");
 
        obj = yaffs_inode_to_obj(inode);
        dev = obj->my_dev;
@@ -1810,10 +1785,10 @@ static int yaffs_link(struct dentry *old_dentry, struct inode *dir,
                old_dentry->d_inode->i_nlink = yaffs_get_obj_link_count(obj);
                d_instantiate(dentry, old_dentry->d_inode);
                atomic_inc(&old_dentry->d_inode->i_count);
-               T(YAFFS_TRACE_OS,
-                 (TSTR("yaffs_link link count %d i_count %d\n"),
-                  old_dentry->d_inode->i_nlink,
-                  atomic_read(&old_dentry->d_inode->i_count)));
+               yaffs_trace(YAFFS_TRACE_OS,
+                       "yaffs_link link count %d i_count %d",
+                       old_dentry->d_inode->i_nlink,
+                       atomic_read(&old_dentry->d_inode->i_count));
        }
 
        yaffs_gross_unlock(dev);
@@ -1835,7 +1810,7 @@ static int yaffs_symlink(struct inode *dir, struct dentry *dentry,
        gid_t gid =
            (dir->i_mode & S_ISGID) ? dir->i_gid : YCRED(current)->fsgid;
 
-       T(YAFFS_TRACE_OS, (TSTR("yaffs_symlink\n")));
+       yaffs_trace(YAFFS_TRACE_OS, "yaffs_symlink");
 
        dev = yaffs_inode_to_obj(dir)->my_dev;
        yaffs_gross_lock(dev);
@@ -1849,10 +1824,10 @@ static int yaffs_symlink(struct inode *dir, struct dentry *dentry,
                inode = yaffs_get_inode(dir->i_sb, obj->yst_mode, 0, obj);
                d_instantiate(dentry, inode);
                update_dir_time(dir);
-               T(YAFFS_TRACE_OS, (TSTR("symlink created OK\n")));
+               yaffs_trace(YAFFS_TRACE_OS, "symlink created OK");
                return 0;
        } else {
-               T(YAFFS_TRACE_OS, (TSTR("symlink not created\n")));
+               yaffs_trace(YAFFS_TRACE_OS, "symlink not created");
        }
 
        return -ENOMEM;
@@ -1876,7 +1851,8 @@ static int yaffs_sync_object(struct file *file, struct dentry *dentry,
 
        dev = obj->my_dev;
 
-       T(YAFFS_TRACE_OS | YAFFS_TRACE_SYNC, (TSTR("yaffs_sync_object\n")));
+       yaffs_trace(YAFFS_TRACE_OS | YAFFS_TRACE_SYNC,
+               "yaffs_sync_object");
        yaffs_gross_lock(dev);
        yaffs_flush_file(obj, 1, datasync);
        yaffs_gross_unlock(dev);
@@ -1895,7 +1871,7 @@ static int yaffs_rename(struct inode *old_dir, struct dentry *old_dentry,
        int ret_val = YAFFS_FAIL;
        struct yaffs_obj *target;
 
-       T(YAFFS_TRACE_OS, (TSTR("yaffs_rename\n")));
+       yaffs_trace(YAFFS_TRACE_OS, "yaffs_rename");
        dev = yaffs_inode_to_obj(old_dir)->my_dev;
 
        yaffs_gross_lock(dev);
@@ -1907,12 +1883,12 @@ static int yaffs_rename(struct inode *old_dir, struct dentry *old_dentry,
        if (target && target->variant_type == YAFFS_OBJECT_TYPE_DIRECTORY &&
            !list_empty(&target->variant.dir_variant.children)) {
 
-               T(YAFFS_TRACE_OS, (TSTR("target is non-empty dir\n")));
+               yaffs_trace(YAFFS_TRACE_OS, "target is non-empty dir");
 
                ret_val = YAFFS_FAIL;
        } else {
                /* Now does unlinking internally using shadowing mechanism */
-               T(YAFFS_TRACE_OS, (TSTR("calling yaffs_rename_obj\n")));
+               yaffs_trace(YAFFS_TRACE_OS, "calling yaffs_rename_obj");
 
                ret_val = yaffs_rename_obj(yaffs_inode_to_obj(old_dir),
                                           old_dentry->d_name.name,
@@ -1942,9 +1918,9 @@ static int yaffs_setattr(struct dentry *dentry, struct iattr *attr)
        int error = 0;
        struct yaffs_dev *dev;
 
-       T(YAFFS_TRACE_OS,
-         (TSTR("yaffs_setattr of object %d\n"),
-          yaffs_inode_to_obj(inode)->obj_id));
+       yaffs_trace(YAFFS_TRACE_OS,
+               "yaffs_setattr of object %d",
+               yaffs_inode_to_obj(inode)->obj_id);
 
        /* Fail if a requested resize >= 2GB */
        if (attr->ia_valid & ATTR_SIZE && (attr->ia_size >> 31))
@@ -1956,7 +1932,7 @@ static int yaffs_setattr(struct dentry *dentry, struct iattr *attr)
                int result;
                if (!error) {
                        error = yaffs_vfs_setattr(inode, attr);
-                       T(YAFFS_TRACE_OS, (TSTR("inode_setattr called\n")));
+                       yaffs_trace(YAFFS_TRACE_OS, "inode_setattr called");
                        if (attr->ia_valid & ATTR_SIZE) {
                                yaffs_vfs_setsize(inode, attr->ia_size);
                                inode->i_blocks = (inode->i_size + 511) >> 9;
@@ -1964,9 +1940,10 @@ static int yaffs_setattr(struct dentry *dentry, struct iattr *attr)
                }
                dev = yaffs_inode_to_obj(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)));
+                       yaffs_trace(YAFFS_TRACE_OS,
+                               "resize to %d(%x)",
+                               (int)(attr->ia_size),
+                               (int)(attr->ia_size));
                }
                yaffs_gross_lock(dev);
                result = yaffs_set_attribs(yaffs_inode_to_obj(inode), attr);
@@ -1979,7 +1956,7 @@ static int yaffs_setattr(struct dentry *dentry, struct iattr *attr)
 
        }
 
-       T(YAFFS_TRACE_OS, (TSTR("yaffs_setattr done returning %d\n"), error));
+       yaffs_trace(YAFFS_TRACE_OS, "yaffs_setattr done returning %d", error);
 
        return error;
 }
@@ -1993,7 +1970,7 @@ static int yaffs_setxattr(struct dentry *dentry, const char *name,
        struct yaffs_dev *dev;
        struct yaffs_obj *obj = yaffs_inode_to_obj(inode);
 
-       T(YAFFS_TRACE_OS, (TSTR("yaffs_setxattr of object %d\n"), obj->obj_id));
+       yaffs_trace(YAFFS_TRACE_OS, "yaffs_setxattr of object %d", obj->obj_id);
 
        if (error == 0) {
                int result;
@@ -2007,21 +1984,22 @@ static int yaffs_setxattr(struct dentry *dentry, const char *name,
                yaffs_gross_unlock(dev);
 
        }
-       T(YAFFS_TRACE_OS, (TSTR("yaffs_setxattr done returning %d\n"), error));
+       yaffs_trace(YAFFS_TRACE_OS, "yaffs_setxattr done returning %d", error);
 
        return error;
 }
 
-static ssize_t yaffs_getxattr(struct dentry * dentry, const char *name, void *buff,
-                      size_t size)
+static ssize_t yaffs_getxattr(struct dentry * dentry, const char *name,
+                       void *buff, size_t size)
 {
        struct inode *inode = dentry->d_inode;
        int error = 0;
        struct yaffs_dev *dev;
        struct yaffs_obj *obj = yaffs_inode_to_obj(inode);
 
-       T(YAFFS_TRACE_OS,
-         (TSTR("yaffs_getxattr \"%s\" from object %d\n"), name, obj->obj_id));
+       yaffs_trace(YAFFS_TRACE_OS,
+               "yaffs_getxattr \"%s\" from object %d",
+               name, obj->obj_id);
 
        if (error == 0) {
                dev = obj->my_dev;
@@ -2030,7 +2008,7 @@ static ssize_t yaffs_getxattr(struct dentry * dentry, const char *name, void *bu
                yaffs_gross_unlock(dev);
 
        }
-       T(YAFFS_TRACE_OS, (TSTR("yaffs_getxattr done returning %d\n"), error));
+       yaffs_trace(YAFFS_TRACE_OS, "yaffs_getxattr done returning %d", error);
 
        return error;
 }
@@ -2042,8 +2020,8 @@ static int yaffs_removexattr(struct dentry *dentry, const char *name)
        struct yaffs_dev *dev;
        struct yaffs_obj *obj = yaffs_inode_to_obj(inode);
 
-       T(YAFFS_TRACE_OS,
-         (TSTR("yaffs_removexattr of object %d\n"), obj->obj_id));
+       yaffs_trace(YAFFS_TRACE_OS,
+               "yaffs_removexattr of object %d", obj->obj_id);
 
        if (error == 0) {
                int result;
@@ -2057,8 +2035,8 @@ static int yaffs_removexattr(struct dentry *dentry, const char *name)
                yaffs_gross_unlock(dev);
 
        }
-       T(YAFFS_TRACE_OS,
-         (TSTR("yaffs_removexattr done returning %d\n"), error));
+       yaffs_trace(YAFFS_TRACE_OS,
+               "yaffs_removexattr done returning %d", error);
 
        return error;
 }
@@ -2070,8 +2048,8 @@ static ssize_t yaffs_listxattr(struct dentry * dentry, char *buff, size_t size)
        struct yaffs_dev *dev;
        struct yaffs_obj *obj = yaffs_inode_to_obj(inode);
 
-       T(YAFFS_TRACE_OS,
-         (TSTR("yaffs_listxattr of object %d\n"), obj->obj_id));
+       yaffs_trace(YAFFS_TRACE_OS,
+               "yaffs_listxattr of object %d", obj->obj_id);
 
        if (error == 0) {
                dev = obj->my_dev;
@@ -2080,7 +2058,8 @@ static ssize_t yaffs_listxattr(struct dentry * dentry, char *buff, size_t size)
                yaffs_gross_unlock(dev);
 
        }
-       T(YAFFS_TRACE_OS, (TSTR("yaffs_listxattr done returning %d\n"), error));
+       yaffs_trace(YAFFS_TRACE_OS,
+               "yaffs_listxattr done returning %d", error);
 
        return error;
 }
@@ -2102,7 +2081,7 @@ static int yaffs_statfs(struct super_block *sb, struct statfs *buf)
        struct yaffs_dev *dev = yaffs_super_to_dev(sb);
 #endif
 
-       T(YAFFS_TRACE_OS, (TSTR("yaffs_statfs\n")));
+       yaffs_trace(YAFFS_TRACE_OS, "yaffs_statfs");
 
        yaffs_gross_lock(dev);
 
@@ -2168,8 +2147,9 @@ static void yaffs_flush_inodes(struct super_block *sb)
        list_for_each_entry(iptr, &sb->s_inodes, i_sb_list) {
                obj = yaffs_inode_to_obj(iptr);
                if (obj) {
-                       T(YAFFS_TRACE_OS, (TSTR("flushing obj %d\n"),
-                                          obj->obj_id));
+                       yaffs_trace(YAFFS_TRACE_OS,
+                               "flushing obj %d",
+                               obj->obj_id);
                        yaffs_flush_file(obj, 1, 0);
                }
        }
@@ -2218,12 +2198,12 @@ static int yaffs_do_sync_fs(struct super_block *sb, int request_checkpoint)
        unsigned gc_urgent = yaffs_bg_gc_urgency(dev);
        int do_checkpoint;
 
-       T(YAFFS_TRACE_OS | YAFFS_TRACE_SYNC | YAFFS_TRACE_BACKGROUND,
-         (TSTR("yaffs_do_sync_fs: gc-urgency %d %s %s%s\n"),
-          gc_urgent,
-          sb->s_dirt ? "dirty" : "clean",
-          request_checkpoint ? "checkpoint requested" : "no checkpoint",
-          oneshot_checkpoint ? " one-shot" : ""));
+       yaffs_trace(YAFFS_TRACE_OS | YAFFS_TRACE_SYNC | YAFFS_TRACE_BACKGROUND,
+               "yaffs_do_sync_fs: gc-urgency %d %s %s%s",
+               gc_urgent,
+               sb->s_dirt ? "dirty" : "clean",
+               request_checkpoint ? "checkpoint requested" : "no checkpoint",
+               oneshot_checkpoint ? " one-shot" : "");
 
        yaffs_gross_lock(dev);
        do_checkpoint = ((request_checkpoint && !gc_urgent) ||
@@ -2272,14 +2252,14 @@ static int yaffs_bg_thread_fn(void *data)
        int gc_result;
        struct timer_list timer;
 
-       T(YAFFS_TRACE_BACKGROUND,
-         (TSTR("yaffs_background starting for dev %p\n"), (void *)dev));
+       yaffs_trace(YAFFS_TRACE_BACKGROUND,
+               "yaffs_background starting for dev %p", (void *)dev);
 
 #ifdef YAFFS_COMPILE_FREEZER
        set_freezable();
 #endif
        while (context->bg_running) {
-               T(YAFFS_TRACE_BACKGROUND, (TSTR("yaffs_background\n")));
+               yaffs_trace(YAFFS_TRACE_BACKGROUND, "yaffs_background");
 
                if (kthread_should_stop())
                        break;
@@ -2397,9 +2377,9 @@ static int yaffs_write_super(struct super_block *sb)
 {
        unsigned request_checkpoint = (yaffs_auto_checkpoint >= 2);
 
-       T(YAFFS_TRACE_OS | YAFFS_TRACE_SYNC | YAFFS_TRACE_BACKGROUND,
-         (TSTR("yaffs_write_super%s\n"),
-          request_checkpoint ? " checkpt" : ""));
+       yaffs_trace(YAFFS_TRACE_OS | YAFFS_TRACE_SYNC | YAFFS_TRACE_BACKGROUND,
+               "yaffs_write_super %s",
+               request_checkpoint ? " checkpt" : "");
 
        yaffs_do_sync_fs(sb, request_checkpoint);
 
@@ -2416,8 +2396,8 @@ static int yaffs_sync_fs(struct super_block *sb)
 {
        unsigned request_checkpoint = (yaffs_auto_checkpoint >= 1);
 
-       T(YAFFS_TRACE_OS | YAFFS_TRACE_SYNC,
-         (TSTR("yaffs_sync_fs%s\n"), request_checkpoint ? " checkpt" : ""));
+       yaffs_trace(YAFFS_TRACE_OS | YAFFS_TRACE_SYNC,
+               "yaffs_sync_fs%s", request_checkpoint ? " checkpt" : "");
 
        yaffs_do_sync_fs(sb, request_checkpoint);
 
@@ -2432,7 +2412,7 @@ static struct inode *yaffs_iget(struct super_block *sb, unsigned long ino)
        struct yaffs_obj *obj;
        struct yaffs_dev *dev = yaffs_super_to_dev(sb);
 
-       T(YAFFS_TRACE_OS, (TSTR("yaffs_iget for %lu\n"), ino));
+       yaffs_trace(YAFFS_TRACE_OS, "yaffs_iget for %lu", ino);
 
        inode = iget_locked(sb, ino);
        if (!inode)
@@ -2469,8 +2449,8 @@ static void yaffs_read_inode(struct inode *inode)
        struct yaffs_obj *obj;
        struct yaffs_dev *dev = yaffs_super_to_dev(inode->i_sb);
 
-       T(YAFFS_TRACE_OS,
-         (TSTR("yaffs_read_inode for %d\n"), (int)inode->i_ino));
+       yaffs_trace(YAFFS_TRACE_OS,
+               "yaffs_read_inode for %d", (int)inode->i_ino);
 
        if (current != yaffs_dev_to_lc(dev)->readdir_process)
                yaffs_gross_lock(dev);
@@ -2492,13 +2472,13 @@ static void yaffs_put_super(struct super_block *sb)
 {
        struct yaffs_dev *dev = yaffs_super_to_dev(sb);
 
-       T(YAFFS_TRACE_OS, (TSTR("yaffs_put_super\n")));
+       yaffs_trace(YAFFS_TRACE_OS, "yaffs_put_super");
 
-       T(YAFFS_TRACE_OS | YAFFS_TRACE_BACKGROUND,
-         (TSTR("Shutting down yaffs background thread\n")));
+       yaffs_trace(YAFFS_TRACE_OS | YAFFS_TRACE_BACKGROUND,
+               "Shutting down yaffs background thread");
        yaffs_bg_stop(dev);
-       T(YAFFS_TRACE_OS | YAFFS_TRACE_BACKGROUND,
-         (TSTR("yaffs background thread shut down\n")));
+       yaffs_trace(YAFFS_TRACE_OS | YAFFS_TRACE_BACKGROUND,
+               "yaffs background thread shut down");
 
        yaffs_gross_lock(dev);
 
@@ -2537,7 +2517,7 @@ static void yaffs_touch_super(struct yaffs_dev *dev)
 {
        struct super_block *sb = yaffs_dev_to_lc(dev)->super;
 
-       T(YAFFS_TRACE_OS, (TSTR("yaffs_touch_super() sb = %p\n"), sb));
+       yaffs_trace(YAFFS_TRACE_OS, "yaffs_touch_super() sb = %p", sb);
        if (sb)
                sb->s_dirt = 1;
 }
@@ -2679,14 +2659,15 @@ static struct super_block *yaffs_internal_read_super(int yaffs_version,
        sb->s_blocksize = PAGE_CACHE_SIZE;
        sb->s_blocksize_bits = PAGE_CACHE_SHIFT;
 
-       T(YAFFS_TRACE_OS,
-         (TSTR("yaffs_read_super: Using yaffs%d\n"), yaffs_version));
-       T(YAFFS_TRACE_OS,
-         (TSTR("yaffs_read_super: block size %d\n"), (int)(sb->s_blocksize)));
+       yaffs_trace(YAFFS_TRACE_OS,
+               "yaffs_read_super: Using yaffs%d", yaffs_version);
+       yaffs_trace(YAFFS_TRACE_OS,
+               "yaffs_read_super: block size %d", (int)(sb->s_blocksize));
 
-       T(YAFFS_TRACE_ALWAYS,
-         (TSTR("yaffs: Attempting MTD mount of %u.%u,\"%s\"\n"),
-          MAJOR(sb->s_dev), MINOR(sb->s_dev), yaffs_devname(sb, devname_buf)));
+       yaffs_trace(YAFFS_TRACE_ALWAYS,
+               "yaffs: Attempting MTD mount of %u.%u,\"%s\"",
+               MAJOR(sb->s_dev), MINOR(sb->s_dev),
+               yaffs_devname(sb, devname_buf));
 
        /* Check it's an mtd device..... */
        if (MAJOR(sb->s_dev) != MTD_BLOCK_MAJOR)
@@ -2695,46 +2676,46 @@ static struct super_block *yaffs_internal_read_super(int yaffs_version,
        /* Get the device */
        mtd = get_mtd_device(NULL, MINOR(sb->s_dev));
        if (!mtd) {
-               T(YAFFS_TRACE_ALWAYS,
-                 (TSTR("yaffs: MTD device #%u doesn't appear to exist\n"),
-                  MINOR(sb->s_dev)));
+               yaffs_trace(YAFFS_TRACE_ALWAYS,
+                       "yaffs: MTD device #%u doesn't appear to exist",
+                       MINOR(sb->s_dev));
                return NULL;
        }
        /* Check it's NAND */
        if (mtd->type != MTD_NANDFLASH) {
-               T(YAFFS_TRACE_ALWAYS,
-                 (TSTR("yaffs: MTD device is not NAND it's type %d\n"),
-                  mtd->type));
+               yaffs_trace(YAFFS_TRACE_ALWAYS,
+                       "yaffs: MTD device is not NAND it's type %d",
+                       mtd->type);
                return NULL;
        }
 
-       T(YAFFS_TRACE_OS, (TSTR(" erase %p\n"), mtd->erase));
-       T(YAFFS_TRACE_OS, (TSTR(" read %p\n"), mtd->read));
-       T(YAFFS_TRACE_OS, (TSTR(" write %p\n"), mtd->write));
-       T(YAFFS_TRACE_OS, (TSTR(" readoob %p\n"), mtd->read_oob));
-       T(YAFFS_TRACE_OS, (TSTR(" writeoob %p\n"), mtd->write_oob));
-       T(YAFFS_TRACE_OS, (TSTR(" block_isbad %p\n"), mtd->block_isbad));
-       T(YAFFS_TRACE_OS, (TSTR(" block_markbad %p\n"), mtd->block_markbad));
-       T(YAFFS_TRACE_OS, (TSTR(" %s %d\n"), WRITE_SIZE_STR, WRITE_SIZE(mtd)));
-       T(YAFFS_TRACE_OS, (TSTR(" oobsize %d\n"), mtd->oobsize));
-       T(YAFFS_TRACE_OS, (TSTR(" erasesize %d\n"), mtd->erasesize));
+       yaffs_trace(YAFFS_TRACE_OS, " erase %p", mtd->erase);
+       yaffs_trace(YAFFS_TRACE_OS, " read %p", mtd->read);
+       yaffs_trace(YAFFS_TRACE_OS, " write %p", mtd->write);
+       yaffs_trace(YAFFS_TRACE_OS, " readoob %p", mtd->read_oob);
+       yaffs_trace(YAFFS_TRACE_OS, " writeoob %p", mtd->write_oob);
+       yaffs_trace(YAFFS_TRACE_OS, " block_isbad %p", mtd->block_isbad);
+       yaffs_trace(YAFFS_TRACE_OS, " block_markbad %p", mtd->block_markbad);
+       yaffs_trace(YAFFS_TRACE_OS, " %s %d", WRITE_SIZE_STR, WRITE_SIZE(mtd));
+       yaffs_trace(YAFFS_TRACE_OS, " oobsize %d", mtd->oobsize);
+       yaffs_trace(YAFFS_TRACE_OS, " erasesize %d", mtd->erasesize);
 #if LINUX_VERSION_CODE < KERNEL_VERSION(2, 6, 29)
-       T(YAFFS_TRACE_OS, (TSTR(" size %u\n"), mtd->size));
+       yaffs_trace(YAFFS_TRACE_OS, " size %u", mtd->size);
 #else
-       T(YAFFS_TRACE_OS, (TSTR(" size %lld\n"), mtd->size));
+       yaffs_trace(YAFFS_TRACE_OS, " size %lld", mtd->size);
 #endif
 
 #ifdef CONFIG_YAFFS_AUTO_YAFFS2
 
        if (yaffs_version == 1 && WRITE_SIZE(mtd) >= 2048) {
-               T(YAFFS_TRACE_ALWAYS, (TSTR("yaffs: auto selecting yaffs2\n")));
+               yaffs_trace(YAFFS_TRACE_ALWAYS, "auto selecting yaffs2");
                yaffs_version = 2;
        }
 
        /* Added NCB 26/5/2006 for completeness */
        if (yaffs_version == 2 && !options.inband_tags
            && WRITE_SIZE(mtd) == 512) {
-               T(YAFFS_TRACE_ALWAYS, (TSTR("yaffs: auto selecting yaffs1\n")));
+               yaffs_trace(YAFFS_TRACE_ALWAYS, "auto selecting yaffs1");
                yaffs_version = 1;
        }
 #endif
@@ -2750,18 +2731,18 @@ static struct super_block *yaffs_internal_read_super(int yaffs_version,
                    !mtd->write_ecc ||
                    !mtd->read_ecc || !mtd->read_oob || !mtd->write_oob) {
 #endif
-                       T(YAFFS_TRACE_ALWAYS,
-                         (TSTR("yaffs: MTD device does not support required "
-                               "functions\n")));
+                       yaffs_trace(YAFFS_TRACE_ALWAYS,
+                               "MTD device does not support required functions"
+                       );
                        return NULL;
                }
 
                if ((WRITE_SIZE(mtd) < YAFFS_MIN_YAFFS2_CHUNK_SIZE ||
                     mtd->oobsize < YAFFS_MIN_YAFFS2_SPARE_SIZE) &&
                    !options.inband_tags) {
-                       T(YAFFS_TRACE_ALWAYS,
-                         (TSTR("yaffs: MTD device does not have the "
-                               "right page sizes\n")));
+                       yaffs_trace(YAFFS_TRACE_ALWAYS,
+                               "MTD device does not have the right page sizes"
+                       );
                        return NULL;
                }
        } else {
@@ -2773,17 +2754,17 @@ static struct super_block *yaffs_internal_read_super(int yaffs_version,
                    !mtd->write_ecc ||
                    !mtd->read_ecc || !mtd->read_oob || !mtd->write_oob) {
 #endif
-                       T(YAFFS_TRACE_ALWAYS,
-                         (TSTR("yaffs: MTD device does not support required "
-                               "functions\n")));
+                       yaffs_trace(YAFFS_TRACE_ALWAYS,
+                               "MTD device does not support required functions"
+                       );
                        return NULL;
                }
 
                if (WRITE_SIZE(mtd) < YAFFS_BYTES_PER_CHUNK ||
                    mtd->oobsize != YAFFS_BYTES_PER_SPARE) {
-                       T(YAFFS_TRACE_ALWAYS,
-                         (TSTR("yaffs: MTD device does not support have the "
-                               "right page sizes\n")));
+                       yaffs_trace(YAFFS_TRACE_ALWAYS,
+                               "MTD device does not support have the right page sizes"
+                       );
                        return NULL;
                }
        }
@@ -2796,7 +2777,8 @@ static struct super_block *yaffs_internal_read_super(int yaffs_version,
        if (!read_only && !(mtd->flags & MTD_WRITEABLE)) {
                read_only = 1;
                printk(KERN_INFO
-                      "yaffs: mtd is read only, setting superblock read only");
+                      "yaffs: mtd is read only, setting superblock read only\n"
+               );
                sb->s_flags |= MS_RDONLY;
        }
 
@@ -2814,9 +2796,9 @@ static struct super_block *yaffs_internal_read_super(int yaffs_version,
 
        if (!dev) {
                /* Deep shit could not allocate device structure */
-               T(YAFFS_TRACE_ALWAYS,
-                 (TSTR("yaffs_read_super: Failed trying to allocate "
-                       "struct yaffs_dev. \n")));
+               yaffs_trace(YAFFS_TRACE_ALWAYS,
+                       "yaffs_read_super: Failed trying to allocate struct yaffs_dev."
+               );
                return NULL;
        }
        memset(dev, 0, sizeof(struct yaffs_dev));
@@ -2975,9 +2957,9 @@ static struct super_block *yaffs_internal_read_super(int yaffs_version,
 
        err = yaffs_guts_initialise(dev);
 
-       T(YAFFS_TRACE_OS,
-         (TSTR("yaffs_read_super: guts initialised %s\n"),
-          (err == YAFFS_OK) ? "OK" : "FAILED"));
+       yaffs_trace(YAFFS_TRACE_OS, 
+               "yaffs_read_super: guts initialised %s",
+               (err == YAFFS_OK) ? "OK" : "FAILED");
 
        if (err == YAFFS_OK)
                yaffs_bg_start(dev);
@@ -2998,11 +2980,11 @@ static struct super_block *yaffs_internal_read_super(int yaffs_version,
        inode->i_op = &yaffs_dir_inode_operations;
        inode->i_fop = &yaffs_dir_operations;
 
-       T(YAFFS_TRACE_OS, (TSTR("yaffs_read_super: got root inode\n")));
+       yaffs_trace(YAFFS_TRACE_OS, "yaffs_read_super: got root inode");
 
        root = d_alloc_root(inode);
 
-       T(YAFFS_TRACE_OS, (TSTR("yaffs_read_super: d_alloc_root done\n")));
+       yaffs_trace(YAFFS_TRACE_OS, "yaffs_read_super: d_alloc_root done");
 
        if (!root) {
                iput(inode);
@@ -3010,11 +2992,11 @@ static struct super_block *yaffs_internal_read_super(int yaffs_version,
        }
        sb->s_root = root;
        sb->s_dirt = !dev->is_checkpointed;
-       T(YAFFS_TRACE_ALWAYS,
-         (TSTR("yaffs_read_super: is_checkpointed %d\n"),
-          dev->is_checkpointed));
+       yaffs_trace(YAFFS_TRACE_ALWAYS,
+               "yaffs_read_super: is_checkpointed %d",
+               dev->is_checkpointed);
 
-       T(YAFFS_TRACE_OS, (TSTR("yaffs_read_super: done\n")));
+       yaffs_trace(YAFFS_TRACE_OS, "yaffs_read_super: done");
        return sb;
 }
 
@@ -3115,36 +3097,27 @@ static struct proc_dir_entry *my_proc_entry;
 
 static char *yaffs_dump_dev_part0(char *buf, struct yaffs_dev *dev)
 {
-       buf +=
-           sprintf(buf, "start_block.......... %d\n", dev->param.start_block);
-       buf += sprintf(buf, "end_block............ %d\n", dev->param.end_block);
-       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);
-
+       struct yaffs_param *param = &dev->param;
+
+       buf += sprintf(buf, "start_block.......... %d\n", param->start_block);
+       buf += sprintf(buf, "end_block............ %d\n", param->end_block);
+       buf += sprintf(buf, "total_bytes_per_chunk %d\n",
+                               param->total_bytes_per_chunk);
+       buf += sprintf(buf, "use_nand_ecc......... %d\n", param->use_nand_ecc);
+       buf += sprintf(buf, "no_tags_ecc.......... %d\n", param->no_tags_ecc);
+       buf += sprintf(buf, "is_yaffs2............ %d\n", param->is_yaffs2);
+       buf += sprintf(buf, "inband_tags.......... %d\n", param->inband_tags);
+       buf += sprintf(buf, "empty_lost_n_found... %d\n",
+                               param->empty_lost_n_found);
+       buf += sprintf(buf, "disable_lazy_load.... %d\n",
+                               param->disable_lazy_load);
+       buf += sprintf(buf, "refresh_period....... %d\n",
+                               param->refresh_period);
+       buf += sprintf(buf, "n_caches............. %d\n", param->n_caches);
+       buf += sprintf(buf, "n_reserved_blocks.... %d\n",
+                               param->n_reserved_blocks);
+       buf += sprintf(buf, "always_check_erased.. %d\n",
+                               param->always_check_erased);
        buf += sprintf(buf, "\n");
 
        return buf;
@@ -3152,14 +3125,13 @@ static char *yaffs_dump_dev_part0(char *buf, struct yaffs_dev *dev)
 
 static char *yaffs_dump_dev_part1(char *buf, struct yaffs_dev *dev)
 {
-       buf +=
-           sprintf(buf, "data_bytes_per_chunk. %d\n",
-                   dev->data_bytes_per_chunk);
+       buf += sprintf(buf, "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, "blocks_in_checkpt.... %d\n",
+                               dev->blocks_in_checkpt);
        buf += sprintf(buf, "\n");
        buf += sprintf(buf, "n_tnodes............. %d\n", dev->n_tnodes);
        buf += sprintf(buf, "n_obj................ %d\n", dev->n_obj);
@@ -3170,27 +3142,26 @@ static char *yaffs_dump_dev_part1(char *buf, struct yaffs_dev *dev)
        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, "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, "n_retired_blocks..... %u\n", dev->n_retired_blocks);
+       buf += sprintf(buf, "n_retired_writes..... %u\n",
+                               dev->n_retired_writes);
+       buf += sprintf(buf, "n_retired_blocks..... %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, "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, "n_unlinked_files..... %u\n",
+                               dev->n_unlinked_files);
        buf += sprintf(buf, "refresh_count........ %u\n", dev->refresh_count);
        buf += sprintf(buf, "n_bg_deletions....... %u\n", dev->n_bg_deletions);
 
@@ -3416,13 +3387,13 @@ static int __init init_yaffs_fs(void)
        int error = 0;
        struct file_system_to_install *fsinst;
 
-       T(YAFFS_TRACE_ALWAYS,
-         (TSTR("yaffs built " __DATE__ " " __TIME__ " Installing. \n")));
+       yaffs_trace(YAFFS_TRACE_ALWAYS,
+               "yaffs built " __DATE__ " " __TIME__ " Installing.");
 
 #ifdef CONFIG_YAFFS_ALWAYS_CHECK_CHUNK_ERASED
-       T(YAFFS_TRACE_ALWAYS,
-         (TSTR
-          (" \n\n\n\nYAFFS-WARNING CONFIG_YAFFS_ALWAYS_CHECK_CHUNK_ERASED selected.\n\n\n\n")));
+       yaffs_trace(YAFFS_TRACE_ALWAYS,
+               " \n\n\n\nYAFFS-WARNING CONFIG_YAFFS_ALWAYS_CHECK_CHUNK_ERASED selected.\n\n\n\n"
+       );
 #endif
 
        mutex_init(&yaffs_context_lock);
@@ -3471,8 +3442,8 @@ static void __exit exit_yaffs_fs(void)
 
        struct file_system_to_install *fsinst;
 
-       T(YAFFS_TRACE_ALWAYS,
-         (TSTR("yaffs built " __DATE__ " " __TIME__ " removing. \n")));
+       yaffs_trace(YAFFS_TRACE_ALWAYS,
+               "yaffs built " __DATE__ " " __TIME__ " removing.");
 
        remove_proc_entry("yaffs", YPROC_ROOT);
 
index df333cc..d5b8753 100644 (file)
@@ -123,14 +123,14 @@ static unsigned yaffs_gc_control_callback(struct yaffs_dev *dev)
 
 static void yaffs_gross_lock(struct yaffs_dev *dev)
 {
-       T(YAFFS_TRACE_LOCK, (TSTR("yaffs locking %p\n"), current));
+       yaffs_trace(YAFFS_TRACE_LOCK, "yaffs locking %p", current);
        mutex_lock(&(yaffs_dev_to_lc(dev)->gross_lock));
-       T(YAFFS_TRACE_LOCK, (TSTR("yaffs locked %p\n"), current));
+       yaffs_trace(YAFFS_TRACE_LOCK, "yaffs locked %p", current);
 }
 
 static void yaffs_gross_unlock(struct yaffs_dev *dev)
 {
-       T(YAFFS_TRACE_LOCK, (TSTR("yaffs unlocking %p\n"), current));
+       yaffs_trace(YAFFS_TRACE_LOCK, "yaffs unlocking %p", current);
        mutex_unlock(&(yaffs_dev_to_lc(dev)->gross_lock));
 }
 
@@ -143,7 +143,7 @@ static struct inode *yaffs_iget(struct super_block *sb, unsigned long ino)
        struct yaffs_obj *obj;
        struct yaffs_dev *dev = yaffs_super_to_dev(sb);
 
-       T(YAFFS_TRACE_OS, (TSTR("yaffs_iget for %lu\n"), ino));
+       yaffs_trace(YAFFS_TRACE_OS, "yaffs_iget for %lu", ino);
 
        inode = iget_locked(sb, ino);
        if (!inode)
@@ -174,21 +174,22 @@ struct inode *yaffs_get_inode(struct super_block *sb, int mode, int dev,
        struct inode *inode;
 
        if (!sb) {
-               T(YAFFS_TRACE_OS,
-                 (TSTR("yaffs_get_inode for NULL super_block!!\n")));
+               yaffs_trace(YAFFS_TRACE_OS,
+                       "yaffs_get_inode for NULL super_block!!");
                return NULL;
 
        }
 
        if (!obj) {
-               T(YAFFS_TRACE_OS,
-                 (TSTR("yaffs_get_inode for NULL object!!\n")));
+               yaffs_trace(YAFFS_TRACE_OS,
+                       "yaffs_get_inode for NULL object!!");
                return NULL;
 
        }
 
-       T(YAFFS_TRACE_OS,
-         (TSTR("yaffs_get_inode for object %d\n"), obj->obj_id));
+       yaffs_trace(YAFFS_TRACE_OS,
+               "yaffs_get_inode for object %d",
+               obj->obj_id);
 
        inode = yaffs_iget(sb, obj->obj_id);
        if (IS_ERR(inode))
@@ -220,18 +221,18 @@ static int yaffs_mknod(struct inode *dir, struct dentry *dentry, int mode,
                mode |= S_ISGID;
 
        if (parent) {
-               T(YAFFS_TRACE_OS,
-                 (TSTR("yaffs_mknod: parent object %d type %d\n"),
-                  parent->obj_id, parent->variant_type));
+               yaffs_trace(YAFFS_TRACE_OS,
+                       "yaffs_mknod: parent object %d type %d",
+                       parent->obj_id, parent->variant_type);
        } else {
-               T(YAFFS_TRACE_OS,
-                 (TSTR("yaffs_mknod: could not get parent object\n")));
+               yaffs_trace(YAFFS_TRACE_OS,
+                       "yaffs_mknod: could not get parent object");
                return -EPERM;
        }
 
-       T(YAFFS_TRACE_OS, (TSTR("yaffs_mknod: making oject for %s, "
-                               "mode %x dev %x\n"),
-                          dentry->d_name.name, mode, rdev));
+       yaffs_trace(YAFFS_TRACE_OS,
+               "yaffs_mknod: making oject for %s, mode %x dev %x",
+               dentry->d_name.name, mode, rdev);
 
        dev = parent->my_dev;
 
@@ -240,23 +241,23 @@ static int yaffs_mknod(struct inode *dir, struct dentry *dentry, int mode,
        switch (mode & S_IFMT) {
        default:
                /* Special (socket, fifo, device...) */
-               T(YAFFS_TRACE_OS, (TSTR("yaffs_mknod: making special\n")));
+               yaffs_trace(YAFFS_TRACE_OS, "yaffs_mknod: making special");
                obj =
                    yaffs_create_special(parent, dentry->d_name.name, mode, uid,
                                         gid, old_encode_dev(rdev));
                break;
        case S_IFREG:           /* file          */
-               T(YAFFS_TRACE_OS, (TSTR("yaffs_mknod: making file\n")));
+               yaffs_trace(YAFFS_TRACE_OS, "yaffs_mknod: making file");
                obj = yaffs_create_file(parent, dentry->d_name.name, mode, uid,
                                        gid);
                break;
        case S_IFDIR:           /* directory */
-               T(YAFFS_TRACE_OS, (TSTR("yaffs_mknod: making directory\n")));
+               yaffs_trace(YAFFS_TRACE_OS, "yaffs_mknod: making directory");
                obj = yaffs_create_dir(parent, dentry->d_name.name, mode,
                                       uid, gid);
                break;
        case S_IFLNK:           /* symlink */
-               T(YAFFS_TRACE_OS, (TSTR("yaffs_mknod: making symlink\n")));
+               yaffs_trace(YAFFS_TRACE_OS, "yaffs_mknod: making symlink");
                obj = NULL;     /* Do we ever get here? */
                break;
        }
@@ -268,13 +269,13 @@ static int yaffs_mknod(struct inode *dir, struct dentry *dentry, int mode,
                inode = yaffs_get_inode(dir->i_sb, mode, rdev, obj);
                d_instantiate(dentry, inode);
                update_dir_time(dir);
-               T(YAFFS_TRACE_OS,
-                 (TSTR("yaffs_mknod created object %d count = %d\n"),
-                  obj->obj_id, atomic_read(&inode->i_count)));
+               yaffs_trace(YAFFS_TRACE_OS,
+                       "yaffs_mknod created object %d count = %d",
+                       obj->obj_id, atomic_read(&inode->i_count));
                error = 0;
                yaffs_fill_inode_from_obj(dir, parent);
        } else {
-               T(YAFFS_TRACE_OS, (TSTR("yaffs_mknod failed making object\n")));
+               yaffs_trace(YAFFS_TRACE_OS, "yaffs_mknod failed making object");
                error = -ENOMEM;
        }
 
@@ -283,16 +284,12 @@ static int yaffs_mknod(struct inode *dir, struct dentry *dentry, int mode,
 
 static int yaffs_mkdir(struct inode *dir, struct dentry *dentry, int mode)
 {
-       int ret_val;
-       T(YAFFS_TRACE_OS, (TSTR("yaffs_mkdir\n")));
-       ret_val = yaffs_mknod(dir, dentry, mode | S_IFDIR, 0);
-       return ret_val;
+       return yaffs_mknod(dir, dentry, mode | S_IFDIR, 0);
 }
 
 static int yaffs_create(struct inode *dir, struct dentry *dentry, int mode,
                        struct nameidata *n)
 {
-       T(YAFFS_TRACE_OS, (TSTR("yaffs_create\n")));
        return yaffs_mknod(dir, dentry, mode | S_IFREG, 0);
 }
 
@@ -304,7 +301,7 @@ static int yaffs_link(struct dentry *old_dentry, struct inode *dir,
        struct yaffs_obj *link = NULL;
        struct yaffs_dev *dev;
 
-       T(YAFFS_TRACE_OS, (TSTR("yaffs_link\n")));
+       yaffs_trace(YAFFS_TRACE_OS, "yaffs_link");
 
        obj = yaffs_inode_to_obj(inode);
        dev = obj->my_dev;
@@ -320,10 +317,10 @@ static int yaffs_link(struct dentry *old_dentry, struct inode *dir,
                old_dentry->d_inode->i_nlink = yaffs_get_obj_link_count(obj);
                d_instantiate(dentry, old_dentry->d_inode);
                atomic_inc(&old_dentry->d_inode->i_count);
-               T(YAFFS_TRACE_OS,
-                 (TSTR("yaffs_link link count %d i_count %d\n"),
-                  old_dentry->d_inode->i_nlink,
-                  atomic_read(&old_dentry->d_inode->i_count)));
+               yaffs_trace(YAFFS_TRACE_OS,
+                       "yaffs_link link count %d i_count %d",
+                       old_dentry->d_inode->i_nlink,
+                       atomic_read(&old_dentry->d_inode->i_count));
        }
 
        yaffs_gross_unlock(dev);
@@ -345,7 +342,7 @@ static int yaffs_symlink(struct inode *dir, struct dentry *dentry,
        gid_t gid =
            (dir->i_mode & S_ISGID) ? dir->i_gid : current->cred->fsgid;
 
-       T(YAFFS_TRACE_OS, (TSTR("yaffs_symlink\n")));
+       yaffs_trace(YAFFS_TRACE_OS, "yaffs_symlink");
 
        dev = yaffs_inode_to_obj(dir)->my_dev;
        yaffs_gross_lock(dev);
@@ -359,10 +356,10 @@ static int yaffs_symlink(struct inode *dir, struct dentry *dentry,
                inode = yaffs_get_inode(dir->i_sb, obj->yst_mode, 0, obj);
                d_instantiate(dentry, inode);
                update_dir_time(dir);
-               T(YAFFS_TRACE_OS, (TSTR("symlink created OK\n")));
+               yaffs_trace(YAFFS_TRACE_OS, "symlink created OK");
                return 0;
        } else {
-               T(YAFFS_TRACE_OS, (TSTR("symlink not created\n")));
+               yaffs_trace(YAFFS_TRACE_OS, "symlink not created");
        }
 
        return -ENOMEM;
@@ -379,9 +376,9 @@ static struct dentry *yaffs_lookup(struct inode *dir, struct dentry *dentry,
        if (current != yaffs_dev_to_lc(dev)->readdir_process)
                yaffs_gross_lock(dev);
 
-       T(YAFFS_TRACE_OS,
-         (TSTR("yaffs_lookup for %d:%s\n"),
-          yaffs_inode_to_obj(dir)->obj_id, dentry->d_name.name));
+       yaffs_trace(YAFFS_TRACE_OS,
+               "yaffs_lookup for %d:%s",
+               yaffs_inode_to_obj(dir)->obj_id, dentry->d_name.name);
 
        obj = yaffs_find_by_name(yaffs_inode_to_obj(dir), dentry->d_name.name);
 
@@ -392,20 +389,20 @@ static struct dentry *yaffs_lookup(struct inode *dir, struct dentry *dentry,
                yaffs_gross_unlock(dev);
 
        if (obj) {
-               T(YAFFS_TRACE_OS,
-                 (TSTR("yaffs_lookup found %d\n"), obj->obj_id));
+               yaffs_trace(YAFFS_TRACE_OS,
+                       "yaffs_lookup found %d", obj->obj_id);
 
                inode = yaffs_get_inode(dir->i_sb, obj->yst_mode, 0, obj);
 
                if (inode) {
-                       T(YAFFS_TRACE_OS, (TSTR("yaffs_loookup dentry \n")));
+                       yaffs_trace(YAFFS_TRACE_OS, "yaffs_loookup dentry");
                        d_add(dentry, inode);
                        /* return dentry; */
                        return NULL;
                }
 
        } else {
-               T(YAFFS_TRACE_OS, (TSTR("yaffs_lookup not found\n")));
+               yaffs_trace(YAFFS_TRACE_OS, "yaffs_lookup not found");
 
        }
 
@@ -421,9 +418,9 @@ static int yaffs_unlink(struct inode *dir, struct dentry *dentry)
        struct yaffs_dev *dev;
        struct yaffs_obj *obj;
 
-       T(YAFFS_TRACE_OS,
-         (TSTR("yaffs_unlink %d:%s\n"),
-          (int)(dir->i_ino), dentry->d_name.name));
+       yaffs_trace(YAFFS_TRACE_OS,
+               "yaffs_unlink %d:%s",
+               (int)(dir->i_ino), dentry->d_name.name);
        obj = yaffs_inode_to_obj(dir);
        dev = obj->my_dev;
 
@@ -454,7 +451,7 @@ static int yaffs_sync_object(struct file *file, int datasync)
 
        dev = obj->my_dev;
 
-       T(YAFFS_TRACE_OS | YAFFS_TRACE_SYNC, (TSTR("yaffs_sync_object\n")));
+       yaffs_trace(YAFFS_TRACE_OS | YAFFS_TRACE_SYNC, "yaffs_sync_object");
        yaffs_gross_lock(dev);
        yaffs_flush_file(obj, 1, datasync);
        yaffs_gross_unlock(dev);
@@ -472,7 +469,7 @@ static int yaffs_rename(struct inode *old_dir, struct dentry *old_dentry,
        int ret_val = YAFFS_FAIL;
        struct yaffs_obj *target;
 
-       T(YAFFS_TRACE_OS, (TSTR("yaffs_rename\n")));
+       yaffs_trace(YAFFS_TRACE_OS, "yaffs_rename");
        dev = yaffs_inode_to_obj(old_dir)->my_dev;
 
        yaffs_gross_lock(dev);
@@ -484,12 +481,12 @@ static int yaffs_rename(struct inode *old_dir, struct dentry *old_dentry,
        if (target && target->variant_type == YAFFS_OBJECT_TYPE_DIRECTORY &&
            !list_empty(&target->variant.dir_variant.children)) {
 
-               T(YAFFS_TRACE_OS, (TSTR("target is non-empty dir\n")));
+               yaffs_trace(YAFFS_TRACE_OS, "target is non-empty dir");
 
                ret_val = YAFFS_FAIL;
        } else {
                /* Now does unlinking internally using shadowing mechanism */
-               T(YAFFS_TRACE_OS, (TSTR("calling yaffs_rename_obj\n")));
+               yaffs_trace(YAFFS_TRACE_OS, "calling yaffs_rename_obj");
 
                ret_val = yaffs_rename_obj(yaffs_inode_to_obj(old_dir),
                                           old_dentry->d_name.name,
@@ -519,9 +516,9 @@ static int yaffs_setattr(struct dentry *dentry, struct iattr *attr)
        int error = 0;
        struct yaffs_dev *dev;
 
-       T(YAFFS_TRACE_OS,
-         (TSTR("yaffs_setattr of object %d\n"),
-          yaffs_inode_to_obj(inode)->obj_id));
+       yaffs_trace(YAFFS_TRACE_OS,
+               "yaffs_setattr of object %d",
+               yaffs_inode_to_obj(inode)->obj_id);
 
        /* Fail if a requested resize >= 2GB */
        if (attr->ia_valid & ATTR_SIZE && (attr->ia_size >> 31))
@@ -533,7 +530,7 @@ static int yaffs_setattr(struct dentry *dentry, struct iattr *attr)
                int result;
                if (!error) {
                        setattr_copy(inode, attr);
-                       T(YAFFS_TRACE_OS, (TSTR("inode_setattr called\n")));
+                       yaffs_trace(YAFFS_TRACE_OS, "inode_setattr called");
                        if (attr->ia_valid & ATTR_SIZE) {
                                truncate_setsize(inode, attr->ia_size);
                                inode->i_blocks = (inode->i_size + 511) >> 9;
@@ -541,9 +538,9 @@ static int yaffs_setattr(struct dentry *dentry, struct iattr *attr)
                }
                dev = yaffs_inode_to_obj(inode)->my_dev;
                if (attr->ia_valid & ATTR_SIZE) {
-                       T(YAFFS_TRACE_OS, (TSTR("resize to %d(%x)\n"),
+                       yaffs_trace(YAFFS_TRACE_OS, "resize to %d(%x)",
                                           (int)(attr->ia_size),
-                                          (int)(attr->ia_size)));
+                                          (int)(attr->ia_size));
                }
                yaffs_gross_lock(dev);
                result = yaffs_set_attribs(yaffs_inode_to_obj(inode), attr);
@@ -556,7 +553,7 @@ static int yaffs_setattr(struct dentry *dentry, struct iattr *attr)
 
        }
 
-       T(YAFFS_TRACE_OS, (TSTR("yaffs_setattr done returning %d\n"), error));
+       yaffs_trace(YAFFS_TRACE_OS, "yaffs_setattr done returning %d", error);
 
        return error;
 }
@@ -570,7 +567,7 @@ static int yaffs_setxattr(struct dentry *dentry, const char *name,
        struct yaffs_dev *dev;
        struct yaffs_obj *obj = yaffs_inode_to_obj(inode);
 
-       T(YAFFS_TRACE_OS, (TSTR("yaffs_setxattr of object %d\n"), obj->obj_id));
+       yaffs_trace(YAFFS_TRACE_OS, "yaffs_setxattr of object %d", obj->obj_id);
 
        if (error == 0) {
                int result;
@@ -584,7 +581,7 @@ static int yaffs_setxattr(struct dentry *dentry, const char *name,
                yaffs_gross_unlock(dev);
 
        }
-       T(YAFFS_TRACE_OS, (TSTR("yaffs_setxattr done returning %d\n"), error));
+       yaffs_trace(YAFFS_TRACE_OS, "yaffs_setxattr done returning %d", error);
 
        return error;
 }
@@ -597,8 +594,9 @@ static ssize_t yaffs_getxattr(struct dentry * dentry, const char *name, void *bu
        struct yaffs_dev *dev;
        struct yaffs_obj *obj = yaffs_inode_to_obj(inode);
 
-       T(YAFFS_TRACE_OS,
-         (TSTR("yaffs_getxattr \"%s\" from object %d\n"), name, obj->obj_id));
+       yaffs_trace(YAFFS_TRACE_OS,
+               "yaffs_getxattr \"%s\" from object %d",
+               name, obj->obj_id);
 
        if (error == 0) {
                dev = obj->my_dev;
@@ -607,7 +605,7 @@ static ssize_t yaffs_getxattr(struct dentry * dentry, const char *name, void *bu
                yaffs_gross_unlock(dev);
 
        }
-       T(YAFFS_TRACE_OS, (TSTR("yaffs_getxattr done returning %d\n"), error));
+       yaffs_trace(YAFFS_TRACE_OS, "yaffs_getxattr done returning %d", error);
 
        return error;
 }
@@ -619,8 +617,8 @@ static int yaffs_removexattr(struct dentry *dentry, const char *name)
        struct yaffs_dev *dev;
        struct yaffs_obj *obj = yaffs_inode_to_obj(inode);
 
-       T(YAFFS_TRACE_OS,
-         (TSTR("yaffs_removexattr of object %d\n"), obj->obj_id));
+       yaffs_trace(YAFFS_TRACE_OS,
+               "yaffs_removexattr of object %d", obj->obj_id);
 
        if (error == 0) {
                int result;
@@ -634,8 +632,8 @@ static int yaffs_removexattr(struct dentry *dentry, const char *name)
                yaffs_gross_unlock(dev);
 
        }
-       T(YAFFS_TRACE_OS,
-         (TSTR("yaffs_removexattr done returning %d\n"), error));
+       yaffs_trace(YAFFS_TRACE_OS,
+               "yaffs_removexattr done returning %d", error);
 
        return error;
 }
@@ -647,8 +645,8 @@ static ssize_t yaffs_listxattr(struct dentry * dentry, char *buff, size_t size)
        struct yaffs_dev *dev;
        struct yaffs_obj *obj = yaffs_inode_to_obj(inode);
 
-       T(YAFFS_TRACE_OS,
-         (TSTR("yaffs_listxattr of object %d\n"), obj->obj_id));
+       yaffs_trace(YAFFS_TRACE_OS,
+               "yaffs_listxattr of object %d", obj->obj_id);
 
        if (error == 0) {
                dev = obj->my_dev;
@@ -657,7 +655,8 @@ static ssize_t yaffs_listxattr(struct dentry * dentry, char *buff, size_t size)
                yaffs_gross_unlock(dev);
 
        }
-       T(YAFFS_TRACE_OS, (TSTR("yaffs_listxattr done returning %d\n"), error));
+       yaffs_trace(YAFFS_TRACE_OS,
+               "yaffs_listxattr done returning %d", error);
 
        return error;
 }
@@ -823,13 +822,13 @@ static int yaffs_readdir(struct file *f, void *dirent, filldir_t filldir)
                goto out;
        }
 
-       T(YAFFS_TRACE_OS,
-         (TSTR("yaffs_readdir: starting at %d\n"), (int)offset));
+       yaffs_trace(YAFFS_TRACE_OS,
+               "yaffs_readdir: starting at %d", (int)offset);
 
        if (offset == 0) {
-               T(YAFFS_TRACE_OS,
-                 (TSTR("yaffs_readdir: entry . ino %d \n"),
-                  (int)inode->i_ino));
+               yaffs_trace(YAFFS_TRACE_OS,
+                       "yaffs_readdir: entry . ino %d",
+                       (int)inode->i_ino);
                yaffs_gross_unlock(dev);
                if (filldir(dirent, ".", 1, offset, inode->i_ino, DT_DIR) < 0) {
                        yaffs_gross_lock(dev);
@@ -840,9 +839,9 @@ static int yaffs_readdir(struct file *f, void *dirent, filldir_t filldir)
                f->f_pos++;
        }
        if (offset == 1) {
-               T(YAFFS_TRACE_OS,
-                 (TSTR("yaffs_readdir: entry .. ino %d \n"),
-                  (int)f->f_dentry->d_parent->d_inode->i_ino));
+               yaffs_trace(YAFFS_TRACE_OS,
+                       "yaffs_readdir: entry .. ino %d",
+                       (int)f->f_dentry->d_parent->d_inode->i_ino);
                yaffs_gross_unlock(dev);
                if (filldir(dirent, "..", 2, offset,
                            f->f_dentry->d_parent->d_inode->i_ino,
@@ -873,9 +872,9 @@ static int yaffs_readdir(struct file *f, void *dirent, filldir_t filldir)
                        int this_type = yaffs_get_obj_type(l);
 
                        yaffs_get_obj_name(l, name, YAFFS_MAX_NAME_LENGTH + 1);
-                       T(YAFFS_TRACE_OS,
-                         (TSTR("yaffs_readdir: %s inode %d\n"),
-                          name, yaffs_get_obj_inode(l)));
+                       yaffs_trace(YAFFS_TRACE_OS,
+                               "yaffs_readdir: %s inode %d",
+                               name, yaffs_get_obj_inode(l));
 
                        yaffs_gross_unlock(dev);
 
@@ -918,9 +917,9 @@ static int yaffs_file_flush(struct file *file, fl_owner_t id)
 
        struct yaffs_dev *dev = obj->my_dev;
 
-       T(YAFFS_TRACE_OS,
-         (TSTR("yaffs_file_flush object %d (%s)\n"), obj->obj_id,
-          obj->dirty ? "dirty" : "clean"));
+       yaffs_trace(YAFFS_TRACE_OS,
+               "yaffs_file_flush object %d (%s)",
+               obj->obj_id, obj->dirty ? "dirty" : "clean");
 
        yaffs_gross_lock(dev);
 
@@ -1091,10 +1090,11 @@ static void yaffs_evict_inode(struct inode *inode)
 
        obj = yaffs_inode_to_obj(inode);
 
-       T(YAFFS_TRACE_OS,
-         (TSTR("yaffs_evict_inode: ino %d, count %d %s\n"), (int)inode->i_ino,
-          atomic_read(&inode->i_count),
-          obj ? "object exists" : "null object"));
+       yaffs_trace(YAFFS_TRACE_OS,
+               "yaffs_evict_inode: ino %d, count %d %s",
+               (int)inode->i_ino,
+               atomic_read(&inode->i_count),
+               obj ? "object exists" : "null object");
 
        if (!inode->i_nlink && !is_bad_inode(inode))
                deleteme = 1;
@@ -1120,7 +1120,7 @@ static void yaffs_touch_super(struct yaffs_dev *dev)
 {
        struct super_block *sb = yaffs_dev_to_lc(dev)->super;
 
-       T(YAFFS_TRACE_OS, (TSTR("yaffs_touch_super() sb = %p\n"), sb));
+       yaffs_trace(YAFFS_TRACE_OS, "yaffs_touch_super() sb = %p", sb);
        if (sb)
                sb->s_dirt = 1;
 }
@@ -1135,10 +1135,10 @@ static int yaffs_readpage_nolock(struct file *f, struct page *pg)
 
        struct yaffs_dev *dev;
 
-       T(YAFFS_TRACE_OS,
-         (TSTR("yaffs_readpage_nolock at %08x, size %08x\n"),
-          (unsigned)(pg->index << PAGE_CACHE_SHIFT),
-          (unsigned)PAGE_CACHE_SIZE));
+       yaffs_trace(YAFFS_TRACE_OS,
+               "yaffs_readpage_nolock at %08x, size %08x",
+               (unsigned)(pg->index << PAGE_CACHE_SHIFT),
+               (unsigned)PAGE_CACHE_SIZE);
 
        obj = yaffs_dentry_to_obj(f->f_dentry);
 
@@ -1170,7 +1170,7 @@ static int yaffs_readpage_nolock(struct file *f, struct page *pg)
        flush_dcache_page(pg);
        kunmap(pg);
 
-       T(YAFFS_TRACE_OS, (TSTR("yaffs_readpage_nolock done\n")));
+       yaffs_trace(YAFFS_TRACE_OS, "yaffs_readpage_nolock done");
        return ret;
 }
 
@@ -1185,9 +1185,9 @@ static int yaffs_readpage(struct file *f, struct page *pg)
 {
        int ret;
 
-       T(YAFFS_TRACE_OS, (TSTR("yaffs_readpage\n")));
+       yaffs_trace(YAFFS_TRACE_OS, "yaffs_readpage");
        ret = yaffs_readpage_unlock(f, pg);
-       T(YAFFS_TRACE_OS, (TSTR("yaffs_readpage done\n")));
+       yaffs_trace(YAFFS_TRACE_OS, "yaffs_readpage done");
        return ret;
 }
 
@@ -1220,13 +1220,12 @@ static int yaffs_writepage(struct page *page, struct writeback_control *wbc)
                n_bytes = i_size & (PAGE_CACHE_SIZE - 1);
 
                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),
-                          (unsigned)inode->i_size));
-                       T(YAFFS_TRACE_OS,
-                         (TSTR("                -> don't care!!\n")));
+                       yaffs_trace(YAFFS_TRACE_OS,
+                               "yaffs_writepage at %08x, inode size = %08x!!!",
+                               (unsigned)(page->index << PAGE_CACHE_SHIFT),
+                               (unsigned)inode->i_size);
+                       yaffs_trace(YAFFS_TRACE_OS,
+                         "                -> don't care!!");
 
                        zero_user_segment(page, 0, PAGE_CACHE_SIZE);
                        set_page_writeback(page);
@@ -1247,21 +1246,21 @@ static int yaffs_writepage(struct page *page, struct writeback_control *wbc)
        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), n_bytes));
-       T(YAFFS_TRACE_OS,
-         (TSTR("writepag0: obj = %05x, ino = %05x\n"),
-          (int)obj->variant.file_variant.file_size, (int)inode->i_size));
+       yaffs_trace(YAFFS_TRACE_OS,
+               "yaffs_writepage at %08x, size %08x",
+               (unsigned)(page->index << PAGE_CACHE_SHIFT), n_bytes);
+       yaffs_trace(YAFFS_TRACE_OS,
+               "writepag0: obj = %05x, ino = %05x",
+               (int)obj->variant.file_variant.file_size, (int)inode->i_size);
 
        n_written = yaffs_wr_file(obj, buffer,
                                  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.file_variant.file_size, (int)inode->i_size));
+       yaffs_trace(YAFFS_TRACE_OS,
+               "writepag1: obj = %05x, ino = %05x",
+               (int)obj->variant.file_variant.file_size, (int)inode->i_size);
 
        yaffs_gross_unlock(dev);
 
@@ -1333,9 +1332,9 @@ static int yaffs_write_begin(struct file *filp, struct address_space *mapping,
                ret = -ENOMEM;
                goto out;
        }
-       T(YAFFS_TRACE_OS,
-         (TSTR("start yaffs_write_begin index %d(%x) uptodate %d\n"),
-          (int)index, (int)index, Page_Uptodate(pg) ? 1 : 0));
+       yaffs_trace(YAFFS_TRACE_OS,
+               "start yaffs_write_begin index %d(%x) uptodate %d",
+               (int)index, (int)index, Page_Uptodate(pg) ? 1 : 0);
 
        /* Get fs space */
        space_held = yaffs_hold_space(filp);
@@ -1354,13 +1353,13 @@ static int yaffs_write_begin(struct file *filp, struct address_space *mapping,
                goto out;
 
        /* Happy path return */
-       T(YAFFS_TRACE_OS, (TSTR("end yaffs_write_begin - ok\n")));
+       yaffs_trace(YAFFS_TRACE_OS, "end yaffs_write_begin - ok");
 
        return 0;
 
 out:
-       T(YAFFS_TRACE_OS,
-         (TSTR("end yaffs_write_begin fail returning %d\n"), ret));
+       yaffs_trace(YAFFS_TRACE_OS,
+               "end yaffs_write_begin fail returning %d", ret);
        if (space_held)
                yaffs_release_space(filp);
        if (pg) {
@@ -1392,21 +1391,20 @@ static ssize_t yaffs_file_write(struct file *f, const char *buf, size_t n,
                ipos = *pos;
 
        if (!obj)
-               T(YAFFS_TRACE_OS,
-                 (TSTR("yaffs_file_write: hey obj is null!\n")));
+               yaffs_trace(YAFFS_TRACE_OS,
+                       "yaffs_file_write: hey obj is null!");
        else
-               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->obj_id, ipos, ipos));
+               yaffs_trace(YAFFS_TRACE_OS,
+                       "yaffs_file_write about to write writing %u(%x) bytes to object %d at %d(%x)",
+                       (unsigned)n, (unsigned)n, obj->obj_id, ipos, ipos);
 
        n_written = yaffs_wr_file(obj, buf, ipos, n, 0);
 
        yaffs_touch_super(dev);
 
-       T(YAFFS_TRACE_OS,
-         (TSTR("yaffs_file_write: %d(%x) bytes written\n"),
-          (unsigned)n, (unsigned)n));
+       yaffs_trace(YAFFS_TRACE_OS,
+               "yaffs_file_write: %d(%x) bytes written",
+               (unsigned)n, (unsigned)n);
 
        if (n_written > 0) {
                ipos += n_written;
@@ -1415,9 +1413,9 @@ static ssize_t yaffs_file_write(struct file *f, const char *buf, size_t n,
                        inode->i_size = ipos;
                        inode->i_blocks = (ipos + 511) >> 9;
 
-                       T(YAFFS_TRACE_OS,
-                         (TSTR("yaffs_file_write size updated to %d bytes, "
-                               "%d blocks\n"), ipos, (int)(inode->i_blocks)));
+                       yaffs_trace(YAFFS_TRACE_OS,
+                               "yaffs_file_write size updated to %d bytes, %d blocks",
+                               ipos, (int)(inode->i_blocks));
                }
 
        }
@@ -1436,19 +1434,17 @@ static int yaffs_write_end(struct file *filp, struct address_space *mapping,
        kva = kmap(pg);
        addr = kva + offset_into_page;
 
-       T(YAFFS_TRACE_OS,
-         ("yaffs_write_end addr %p pos %x n_bytes %d\n",
-          addr, (unsigned)pos, copied));
+       yaffs_trace(YAFFS_TRACE_OS,
+               "yaffs_write_end addr %p pos %x n_bytes %d",
+               addr, (unsigned)pos, copied);
 
        ret = yaffs_file_write(filp, addr, copied, &pos);
 
        if (ret != copied) {
-               T(YAFFS_TRACE_OS,
-                 (TSTR("yaffs_write_end not same size ret %d  copied %d\n"),
-                  ret, copied));
+               yaffs_trace(YAFFS_TRACE_OS,
+                       "yaffs_write_end not same size ret %d  copied %d",
+                       ret, copied);
                SetPageError(pg);
-       } else {
-               /* Nothing */
        }
 
        kunmap(pg);
@@ -1464,7 +1460,7 @@ static int yaffs_statfs(struct dentry *dentry, struct kstatfs *buf)
        struct yaffs_dev *dev = yaffs_dentry_to_obj(dentry)->my_dev;
        struct super_block *sb = dentry->d_sb;
 
-       T(YAFFS_TRACE_OS, (TSTR("yaffs_statfs\n")));
+       yaffs_trace(YAFFS_TRACE_OS, "yaffs_statfs");
 
        yaffs_gross_lock(dev);
 
@@ -1530,8 +1526,8 @@ static void yaffs_flush_inodes(struct super_block *sb)
        list_for_each_entry(iptr, &sb->s_inodes, i_sb_list) {
                obj = yaffs_inode_to_obj(iptr);
                if (obj) {
-                       T(YAFFS_TRACE_OS, (TSTR("flushing obj %d\n"),
-                                          obj->obj_id));
+                       yaffs_trace(YAFFS_TRACE_OS,
+                               "flushing obj %d", obj->obj_id);
                        yaffs_flush_file(obj, 1, 0);
                }
        }
@@ -1580,12 +1576,12 @@ static int yaffs_do_sync_fs(struct super_block *sb, int request_checkpoint)
        unsigned gc_urgent = yaffs_bg_gc_urgency(dev);
        int do_checkpoint;
 
-       T(YAFFS_TRACE_OS | YAFFS_TRACE_SYNC | YAFFS_TRACE_BACKGROUND,
-         (TSTR("yaffs_do_sync_fs: gc-urgency %d %s %s%s\n"),
-          gc_urgent,
-          sb->s_dirt ? "dirty" : "clean",
-          request_checkpoint ? "checkpoint requested" : "no checkpoint",
-          oneshot_checkpoint ? " one-shot" : ""));
+       yaffs_trace(YAFFS_TRACE_OS | YAFFS_TRACE_SYNC | YAFFS_TRACE_BACKGROUND,
+               "yaffs_do_sync_fs: gc-urgency %d %s %s%s",
+               gc_urgent,
+               sb->s_dirt ? "dirty" : "clean",
+               request_checkpoint ? "checkpoint requested" : "no checkpoint",
+               oneshot_checkpoint ? " one-shot" : "");
 
        yaffs_gross_lock(dev);
        do_checkpoint = ((request_checkpoint && !gc_urgent) ||
@@ -1632,12 +1628,12 @@ static int yaffs_bg_thread_fn(void *data)
        int gc_result;
        struct timer_list timer;
 
-       T(YAFFS_TRACE_BACKGROUND,
-         (TSTR("yaffs_background starting for dev %p\n"), (void *)dev));
+       yaffs_trace(YAFFS_TRACE_BACKGROUND,
+               "yaffs_background starting for dev %p", (void *)dev);
 
        set_freezable();
        while (context->bg_running) {
-               T(YAFFS_TRACE_BACKGROUND, (TSTR("yaffs_background\n")));
+               yaffs_trace(YAFFS_TRACE_BACKGROUND, "yaffs_background");
 
                if (kthread_should_stop())
                        break;
@@ -1731,9 +1727,9 @@ static void yaffs_write_super(struct super_block *sb)
 {
        unsigned request_checkpoint = (yaffs_auto_checkpoint >= 2);
 
-       T(YAFFS_TRACE_OS | YAFFS_TRACE_SYNC | YAFFS_TRACE_BACKGROUND,
-         (TSTR("yaffs_write_super%s\n"),
-          request_checkpoint ? " checkpt" : ""));
+       yaffs_trace(YAFFS_TRACE_OS | YAFFS_TRACE_SYNC | YAFFS_TRACE_BACKGROUND,
+               "yaffs_write_super%s",
+               request_checkpoint ? " checkpt" : "");
 
        yaffs_do_sync_fs(sb, request_checkpoint);
 
@@ -1743,8 +1739,8 @@ static int yaffs_sync_fs(struct super_block *sb, int wait)
 {
        unsigned request_checkpoint = (yaffs_auto_checkpoint >= 1);
 
-       T(YAFFS_TRACE_OS | YAFFS_TRACE_SYNC,
-         (TSTR("yaffs_sync_fs%s\n"), request_checkpoint ? " checkpt" : ""));
+       yaffs_trace(YAFFS_TRACE_OS | YAFFS_TRACE_SYNC,
+               "yaffs_sync_fs%s", request_checkpoint ? " checkpt" : "");
 
        yaffs_do_sync_fs(sb, request_checkpoint);
 
@@ -1923,11 +1919,10 @@ static void yaffs_fill_inode_from_obj(struct inode *inode,
 
                inode->i_nlink = yaffs_get_obj_link_count(obj);
 
-               T(YAFFS_TRACE_OS,
-                 (TSTR
-                  ("yaffs_fill_inode mode %x uid %d gid %d size %d count %d\n"),
-                  inode->i_mode, inode->i_uid, inode->i_gid,
-                  (int)inode->i_size, atomic_read(&inode->i_count)));
+               yaffs_trace(YAFFS_TRACE_OS,
+                       "yaffs_fill_inode mode %x uid %d gid %d size %d count %d",
+                       inode->i_mode, inode->i_uid, inode->i_gid,
+                       (int)inode->i_size, atomic_read(&inode->i_count));
 
                switch (obj->yst_mode & S_IFMT) {
                default:        /* fifo, device or socket */
@@ -1954,8 +1949,8 @@ static void yaffs_fill_inode_from_obj(struct inode *inode,
                obj->my_inode = inode;
 
        } else {
-               T(YAFFS_TRACE_OS,
-                 (TSTR("yaffs_fill_inode invalid parameters\n")));
+               yaffs_trace(YAFFS_TRACE_OS,
+                       "yaffs_fill_inode invalid parameters");
        }
 }
 
@@ -1963,13 +1958,13 @@ static void yaffs_put_super(struct super_block *sb)
 {
        struct yaffs_dev *dev = yaffs_super_to_dev(sb);
 
-       T(YAFFS_TRACE_OS, (TSTR("yaffs_put_super\n")));
+       yaffs_trace(YAFFS_TRACE_OS, "yaffs_put_super");
 
-       T(YAFFS_TRACE_OS | YAFFS_TRACE_BACKGROUND,
-         (TSTR("Shutting down yaffs background thread\n")));
+       yaffs_trace(YAFFS_TRACE_OS | YAFFS_TRACE_BACKGROUND,
+               "Shutting down yaffs background thread");
        yaffs_bg_stop(dev);
-       T(YAFFS_TRACE_OS | YAFFS_TRACE_BACKGROUND,
-         (TSTR("yaffs background thread shut down\n")));
+       yaffs_trace(YAFFS_TRACE_OS | YAFFS_TRACE_BACKGROUND,
+               "yaffs background thread shut down");
 
        yaffs_gross_lock(dev);
 
@@ -2069,14 +2064,15 @@ static struct super_block *yaffs_internal_read_super(int yaffs_version,
        sb->s_blocksize = PAGE_CACHE_SIZE;
        sb->s_blocksize_bits = PAGE_CACHE_SHIFT;
 
-       T(YAFFS_TRACE_OS,
-         (TSTR("yaffs_read_super: Using yaffs%d\n"), yaffs_version));
-       T(YAFFS_TRACE_OS,
-         (TSTR("yaffs_read_super: block size %d\n"), (int)(sb->s_blocksize)));
+       yaffs_trace(YAFFS_TRACE_OS,
+               "yaffs_read_super: Using yaffs%d", yaffs_version);
+       yaffs_trace(YAFFS_TRACE_OS,
+               "yaffs_read_super: block size %d", (int)(sb->s_blocksize));
 
-       T(YAFFS_TRACE_ALWAYS,
-         (TSTR("yaffs: Attempting MTD mount of %u.%u,\"%s\"\n"),
-          MAJOR(sb->s_dev), MINOR(sb->s_dev), yaffs_devname(sb, devname_buf)));
+       yaffs_trace(YAFFS_TRACE_ALWAYS,
+               "Attempting MTD mount of %u.%u,\"%s\"",
+               MAJOR(sb->s_dev), MINOR(sb->s_dev),
+               yaffs_devname(sb, devname_buf));
 
        /* Check it's an mtd device..... */
        if (MAJOR(sb->s_dev) != MTD_BLOCK_MAJOR)
@@ -2085,42 +2081,42 @@ static struct super_block *yaffs_internal_read_super(int yaffs_version,
        /* Get the device */
        mtd = get_mtd_device(NULL, MINOR(sb->s_dev));
        if (!mtd) {
-               T(YAFFS_TRACE_ALWAYS,
-                 (TSTR("yaffs: MTD device #%u doesn't appear to exist\n"),
-                  MINOR(sb->s_dev)));
+               yaffs_trace(YAFFS_TRACE_ALWAYS,
+                       "MTD device #%u doesn't appear to exist",
+                       MINOR(sb->s_dev));
                return NULL;
        }
        /* Check it's NAND */
        if (mtd->type != MTD_NANDFLASH) {
-               T(YAFFS_TRACE_ALWAYS,
-                 (TSTR("yaffs: MTD device is not NAND it's type %d\n"),
-                  mtd->type));
+               yaffs_trace(YAFFS_TRACE_ALWAYS,
+                       "MTD device is not NAND it's type %d",
+                       mtd->type);
                return NULL;
        }
 
-       T(YAFFS_TRACE_OS, (TSTR(" erase %p\n"), mtd->erase));
-       T(YAFFS_TRACE_OS, (TSTR(" read %p\n"), mtd->read));
-       T(YAFFS_TRACE_OS, (TSTR(" write %p\n"), mtd->write));
-       T(YAFFS_TRACE_OS, (TSTR(" readoob %p\n"), mtd->read_oob));
-       T(YAFFS_TRACE_OS, (TSTR(" writeoob %p\n"), mtd->write_oob));
-       T(YAFFS_TRACE_OS, (TSTR(" block_isbad %p\n"), mtd->block_isbad));
-       T(YAFFS_TRACE_OS, (TSTR(" block_markbad %p\n"), mtd->block_markbad));
-       T(YAFFS_TRACE_OS, (TSTR(" %s %d\n"), WRITE_SIZE_STR, WRITE_SIZE(mtd)));
-       T(YAFFS_TRACE_OS, (TSTR(" oobsize %d\n"), mtd->oobsize));
-       T(YAFFS_TRACE_OS, (TSTR(" erasesize %d\n"), mtd->erasesize));
-       T(YAFFS_TRACE_OS, (TSTR(" size %lld\n"), mtd->size));
+       yaffs_trace(YAFFS_TRACE_OS, " erase %p", mtd->erase);
+       yaffs_trace(YAFFS_TRACE_OS, " read %p", mtd->read);
+       yaffs_trace(YAFFS_TRACE_OS, " write %p", mtd->write);
+       yaffs_trace(YAFFS_TRACE_OS, " readoob %p", mtd->read_oob);
+       yaffs_trace(YAFFS_TRACE_OS, " writeoob %p", mtd->write_oob);
+       yaffs_trace(YAFFS_TRACE_OS, " block_isbad %p", mtd->block_isbad);
+       yaffs_trace(YAFFS_TRACE_OS, " block_markbad %p", mtd->block_markbad);
+       yaffs_trace(YAFFS_TRACE_OS, " %s %d", WRITE_SIZE_STR, WRITE_SIZE(mtd));
+       yaffs_trace(YAFFS_TRACE_OS, " oobsize %d", mtd->oobsize);
+       yaffs_trace(YAFFS_TRACE_OS, " erasesize %d", mtd->erasesize);
+       yaffs_trace(YAFFS_TRACE_OS, " size %lld", mtd->size);
 
 #ifdef CONFIG_YAFFS_AUTO_YAFFS2
 
        if (yaffs_version == 1 && WRITE_SIZE(mtd) >= 2048) {
-               T(YAFFS_TRACE_ALWAYS, (TSTR("yaffs: auto selecting yaffs2\n")));
+               yaffs_trace(YAFFS_TRACE_ALWAYS, "auto selecting yaffs2");
                yaffs_version = 2;
        }
 
        /* Added NCB 26/5/2006 for completeness */
        if (yaffs_version == 2 && !options.inband_tags
            && WRITE_SIZE(mtd) == 512) {
-               T(YAFFS_TRACE_ALWAYS, (TSTR("yaffs: auto selecting yaffs1\n")));
+               yaffs_trace(YAFFS_TRACE_ALWAYS, "auto selecting yaffs1");
                yaffs_version = 1;
        }
 #endif
@@ -2132,18 +2128,16 @@ static struct super_block *yaffs_internal_read_super(int yaffs_version,
                    !mtd->block_markbad ||
                    !mtd->read ||
                    !mtd->write || !mtd->read_oob || !mtd->write_oob) {
-                       T(YAFFS_TRACE_ALWAYS,
-                         (TSTR("yaffs: MTD device does not support required "
-                               "functions\n")));
+                       yaffs_trace(YAFFS_TRACE_ALWAYS,
+                               "MTD device does not support required functions");
                        return NULL;
                }
 
                if ((WRITE_SIZE(mtd) < YAFFS_MIN_YAFFS2_CHUNK_SIZE ||
                     mtd->oobsize < YAFFS_MIN_YAFFS2_SPARE_SIZE) &&
                    !options.inband_tags) {
-                       T(YAFFS_TRACE_ALWAYS,
-                         (TSTR("yaffs: MTD device does not have the "
-                               "right page sizes\n")));
+                       yaffs_trace(YAFFS_TRACE_ALWAYS,
+                               "MTD device does not have the right page sizes");
                        return NULL;
                }
        } else {
@@ -2151,17 +2145,15 @@ static struct super_block *yaffs_internal_read_super(int yaffs_version,
                if (!mtd->erase ||
                    !mtd->read ||
                    !mtd->write || !mtd->read_oob || !mtd->write_oob) {
-                       T(YAFFS_TRACE_ALWAYS,
-                         (TSTR("yaffs: MTD device does not support required "
-                               "functions\n")));
+                       yaffs_trace(YAFFS_TRACE_ALWAYS,
+                               "MTD device does not support required functions");
                        return NULL;
                }
 
                if (WRITE_SIZE(mtd) < YAFFS_BYTES_PER_CHUNK ||
                    mtd->oobsize != YAFFS_BYTES_PER_SPARE) {
-                       T(YAFFS_TRACE_ALWAYS,
-                         (TSTR("yaffs: MTD device does not support have the "
-                               "right page sizes\n")));
+                       yaffs_trace(YAFFS_TRACE_ALWAYS,
+                               "MTD device does not support have the right page sizes");
                        return NULL;
                }
        }
@@ -2192,9 +2184,8 @@ static struct super_block *yaffs_internal_read_super(int yaffs_version,
 
        if (!dev) {
                /* Deep shit could not allocate device structure */
-               T(YAFFS_TRACE_ALWAYS,
-                 (TSTR("yaffs_read_super: Failed trying to allocate "
-                       "struct yaffs_dev. \n")));
+               yaffs_trace(YAFFS_TRACE_ALWAYS,
+                       "yaffs_read_super failed trying to allocate yaffs_dev");
                return NULL;
        }
        memset(dev, 0, sizeof(struct yaffs_dev));
@@ -2335,9 +2326,9 @@ static struct super_block *yaffs_internal_read_super(int yaffs_version,
 
        err = yaffs_guts_initialise(dev);
 
-       T(YAFFS_TRACE_OS,
-         (TSTR("yaffs_read_super: guts initialised %s\n"),
-          (err == YAFFS_OK) ? "OK" : "FAILED"));
+       yaffs_trace(YAFFS_TRACE_OS,
+               "yaffs_read_super: guts initialised %s",
+               (err == YAFFS_OK) ? "OK" : "FAILED");
 
        if (err == YAFFS_OK)
                yaffs_bg_start(dev);
@@ -2358,11 +2349,11 @@ static struct super_block *yaffs_internal_read_super(int yaffs_version,
        inode->i_op = &yaffs_dir_inode_operations;
        inode->i_fop = &yaffs_dir_operations;
 
-       T(YAFFS_TRACE_OS, (TSTR("yaffs_read_super: got root inode\n")));
+       yaffs_trace(YAFFS_TRACE_OS, "yaffs_read_super: got root inode");
 
        root = d_alloc_root(inode);
 
-       T(YAFFS_TRACE_OS, (TSTR("yaffs_read_super: d_alloc_root done\n")));
+       yaffs_trace(YAFFS_TRACE_OS, "yaffs_read_super: d_alloc_root done");
 
        if (!root) {
                iput(inode);
@@ -2370,11 +2361,11 @@ static struct super_block *yaffs_internal_read_super(int yaffs_version,
        }
        sb->s_root = root;
        sb->s_dirt = !dev->is_checkpointed;
-       T(YAFFS_TRACE_ALWAYS,
-         (TSTR("yaffs_read_super: is_checkpointed %d\n"),
-          dev->is_checkpointed));
+       yaffs_trace(YAFFS_TRACE_ALWAYS,
+               "yaffs_read_super: is_checkpointed %d",
+               dev->is_checkpointed);
 
-       T(YAFFS_TRACE_OS, (TSTR("yaffs_read_super: done\n")));
+       yaffs_trace(YAFFS_TRACE_OS, "yaffs_read_super: done");
        return sb;
 }
 
@@ -2430,40 +2421,27 @@ static struct proc_dir_entry *my_proc_entry;
 
 static char *yaffs_dump_dev_part0(char *buf, struct yaffs_dev *dev)
 {
-       buf +=
-           sprintf(buf, "start_block........... %d\n", dev->param.start_block);
-       buf +=
-           sprintf(buf, "end_block............. %d\n", dev->param.end_block);
-       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");
+       struct yaffs_param *param = &dev->param;
+       buf += sprintf(buf, "start_block........... %d\n", param->start_block);
+       buf += sprintf(buf, "end_block............. %d\n", param->end_block);
+       buf += sprintf(buf, "total_bytes_per_chunk. %d\n",
+                       param->total_bytes_per_chunk);
+       buf += sprintf(buf, "use_nand_ecc.......... %d\n",
+                       param->use_nand_ecc);
+       buf += sprintf(buf, "no_tags_ecc........... %d\n", param->no_tags_ecc);
+       buf += sprintf(buf, "is_yaffs2............. %d\n", param->is_yaffs2);
+       buf += sprintf(buf, "inband_tags........... %d\n", param->inband_tags);
+       buf += sprintf(buf, "empty_lost_n_found.... %d\n",
+                       param->empty_lost_n_found);
+       buf += sprintf(buf, "disable_lazy_load..... %d\n",
+                       param->disable_lazy_load);
+       buf += sprintf(buf, "refresh_period........ %d\n",
+                       param->refresh_period);
+       buf += sprintf(buf, "n_caches.............. %d\n", param->n_caches);
+       buf += sprintf(buf, "n_reserved_blocks..... %d\n",
+                       param->n_reserved_blocks);
+       buf += sprintf(buf, "always_check_erased... %d\n",
+                       param->always_check_erased);
 
        return buf;
 }
@@ -2735,13 +2713,12 @@ static int __init init_yaffs_fs(void)
        int error = 0;
        struct file_system_to_install *fsinst;
 
-       T(YAFFS_TRACE_ALWAYS,
-         (TSTR("yaffs built " __DATE__ " " __TIME__ " Installing. \n")));
+       yaffs_trace(YAFFS_TRACE_ALWAYS,
+               "yaffs built " __DATE__ " " __TIME__ " Installing.");
 
 #ifdef CONFIG_YAFFS_ALWAYS_CHECK_CHUNK_ERASED
-       T(YAFFS_TRACE_ALWAYS,
-         (TSTR
-          (" \n\n\n\nYAFFS-WARNING CONFIG_YAFFS_ALWAYS_CHECK_CHUNK_ERASED selected.\n\n\n\n")));
+       yaffs_trace(YAFFS_TRACE_ALWAYS,
+               "\n\nYAFFS-WARNING CONFIG_YAFFS_ALWAYS_CHECK_CHUNK_ERASED selected.\n\n\n");
 #endif
 
        mutex_init(&yaffs_context_lock);
@@ -2791,8 +2768,8 @@ static void __exit exit_yaffs_fs(void)
 
        struct file_system_to_install *fsinst;
 
-       T(YAFFS_TRACE_ALWAYS,
-         (TSTR("yaffs built " __DATE__ " " __TIME__ " removing. \n")));
+       yaffs_trace(YAFFS_TRACE_ALWAYS,
+               "yaffs built " __DATE__ " " __TIME__ " removing.");
 
        remove_proc_entry("yaffs", YPROC_ROOT);
 
index 4d10096..9eb6030 100644 (file)
@@ -42,9 +42,9 @@ int yaffs1_scan(struct yaffs_dev *dev)
 
        u8 *chunk_data;
 
-       T(YAFFS_TRACE_SCAN,
-         (TSTR("yaffs1_scan starts  intstartblk %d intendblk %d..." TENDSTR),
-          dev->internal_start_block, dev->internal_end_block));
+       yaffs_trace(YAFFS_TRACE_SCAN,
+               "yaffs1_scan starts  intstartblk %d intendblk %d...",
+               dev->internal_start_block, dev->internal_end_block);
 
        chunk_data = yaffs_get_temp_buffer(dev, __LINE__);
 
@@ -66,16 +66,15 @@ int yaffs1_scan(struct yaffs_dev *dev)
                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, seq_number));
+               yaffs_trace(YAFFS_TRACE_SCAN_DEBUG,
+                       "Block scanning block %d state %d seq %d",
+                       blk, state, seq_number);
 
                if (state == YAFFS_BLOCK_STATE_DEAD) {
-                       T(YAFFS_TRACE_BAD_BLOCKS,
-                         (TSTR("block %d is bad" TENDSTR), blk));
+                       yaffs_trace(YAFFS_TRACE_BAD_BLOCKS,
+                               "block %d is bad", blk);
                } else if (state == YAFFS_BLOCK_STATE_EMPTY) {
-                       T(YAFFS_TRACE_SCAN_DEBUG,
-                         (TSTR("Block empty " TENDSTR)));
+                       yaffs_trace(YAFFS_TRACE_SCAN_DEBUG, "Block empty ");
                        dev->n_erased_blocks++;
                        dev->n_free_chunks += dev->param.chunks_per_block;
                }
@@ -124,10 +123,9 @@ int yaffs1_scan(struct yaffs_dev *dev)
                                        dev->n_erased_blocks++;
                                } else {
                                        /* this is the block being allocated from */
-                                       T(YAFFS_TRACE_SCAN,
-                                         (TSTR
-                                          (" Allocating from %d %d" TENDSTR),
-                                          blk, c));
+                                       yaffs_trace(YAFFS_TRACE_SCAN,
+                                               " Allocating from %d %d",
+                                               blk, c);
                                        state = YAFFS_BLOCK_STATE_ALLOCATING;
                                        dev->alloc_block = blk;
                                        dev->alloc_page = c;
@@ -226,11 +224,10 @@ int yaffs1_scan(struct yaffs_dev *dev)
                                                fixer->obj_id = tags.obj_id;
                                                fixer->shadowed_id =
                                                    oh->shadows_obj;
-                                               T(YAFFS_TRACE_SCAN,
-                                                 (TSTR
-                                                  (" Shadow fixer: %d shadows %d"
-                                                   TENDSTR), fixer->obj_id,
-                                                  fixer->shadowed_id));
+                                               yaffs_trace(YAFFS_TRACE_SCAN,
+                                                       " Shadow fixer: %d shadows %d",
+                                                       fixer->obj_id,
+                                                       fixer->shadowed_id);
 
                                        }
 
@@ -308,10 +305,9 @@ int yaffs1_scan(struct yaffs_dev *dev)
                                                 * We're trying to use a non-directory as a directory
                                                 */
 
-                                               T(YAFFS_TRACE_ERROR,
-                                                 (TSTR
-                                                  ("yaffs tragedy: attempting to use non-directory as a directory in scan. Put in lost+found."
-                                                   TENDSTR)));
+                                               yaffs_trace(YAFFS_TRACE_ERROR,
+                                                       "yaffs tragedy: attempting to use non-directory as a directory in scan. Put in lost+found."
+                                                       );
                                                parent = dev->lost_n_found;
                                        }
 
@@ -431,7 +427,7 @@ int yaffs1_scan(struct yaffs_dev *dev)
        if (alloc_failed)
                return YAFFS_FAIL;
 
-       T(YAFFS_TRACE_SCAN, (TSTR("yaffs1_scan ends" TENDSTR)));
+       yaffs_trace(YAFFS_TRACE_SCAN, "yaffs1_scan ends");
 
        return YAFFS_OK;
 }
index 87733fd..33397af 100644 (file)
@@ -186,10 +186,9 @@ u32 yaffs2_find_refresh_block(struct yaffs_dev * dev)
        }
 
        if (oldest > 0) {
-               T(YAFFS_TRACE_GC,
-                 (TSTR
-                  ("GC refresh count %d selected block %d with seq_number %d"
-                   TENDSTR), dev->refresh_count, oldest, oldest_seq));
+               yaffs_trace(YAFFS_TRACE_GC,
+                       "GC refresh count %d selected block %d with seq_number %d",
+                       dev->refresh_count, oldest, oldest_seq);
        }
 
        return oldest;
@@ -402,12 +401,10 @@ static int taffs2_checkpt_obj_to_obj(struct yaffs_obj *obj,
        struct yaffs_obj *parent;
 
        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->obj_id,
-                                     cp->variant_type, cp->hdr_chunk,
-                                     obj->variant_type));
+               yaffs_trace(YAFFS_TRACE_ERROR,
+                       "Checkpoint read object %d type %d chunk %d does not match existing object type %d",
+                       cp->obj_id, cp->variant_type, cp->hdr_chunk,
+                       obj->variant_type);
                return 0;
        }
 
@@ -422,13 +419,11 @@ static int taffs2_checkpt_obj_to_obj(struct yaffs_obj *obj,
 
        if (parent) {
                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->obj_id, cp->parent_id,
-                          cp->variant_type, cp->hdr_chunk,
-                          parent->variant_type));
+                       yaffs_trace(YAFFS_TRACE_ALWAYS,
+                               "Checkpoint read object %d parent %d type %d chunk %d Parent type, %d, not directory",
+                               cp->obj_id, cp->parent_id,
+                               cp->variant_type, cp->hdr_chunk,
+                               parent->variant_type);
                        return 0;
                }
                yaffs_add_obj_to_dir(parent, obj);
@@ -552,9 +547,9 @@ static int yaffs2_rd_checkpt_tnodes(struct yaffs_obj *obj)
 
        }
 
-       T(YAFFS_TRACE_CHECKPOINT,
-         (TSTR("Checkpoint read tnodes %d records, last %d. ok %d" TENDSTR),
-          nread, base_chunk, ok));
+       yaffs_trace(YAFFS_TRACE_CHECKPOINT,
+               "Checkpoint read tnodes %d records, last %d. ok %d",
+               nread, base_chunk, ok);
 
        return ok ? 1 : 0;
 }
@@ -580,11 +575,10 @@ static int yaffs2_wr_checkpt_objs(struct yaffs_dev *dev)
                                        yaffs2_obj_checkpt_obj(&cp, obj);
                                        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.obj_id, cp.parent_id,
-                                          cp.variant_type, cp.hdr_chunk, obj));
+                                       yaffs_trace(YAFFS_TRACE_CHECKPOINT,
+                                               "Checkpoint write object %d parent %d type %d chunk %d obj addr %p",
+                                               cp.obj_id, cp.parent_id,
+                                               cp.variant_type, cp.hdr_chunk, obj);
 
                                        ok = (yaffs2_checkpt_wr
                                              (dev, &cp,
@@ -621,17 +615,16 @@ static int yaffs2_rd_checkpt_objs(struct yaffs_dev *dev)
        while (ok && !done) {
                ok = (yaffs2_checkpt_rd(dev, &cp, sizeof(cp)) == sizeof(cp));
                if (cp.struct_type != sizeof(cp)) {
-                       T(YAFFS_TRACE_CHECKPOINT,
-                         (TSTR("struct size %d instead of %d ok %d" TENDSTR),
-                          cp.struct_type, (int)sizeof(cp), ok));
+                       yaffs_trace(YAFFS_TRACE_CHECKPOINT,
+                               "struct size %d instead of %d ok %d",
+                               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.obj_id, cp.parent_id, cp.variant_type,
-                  cp.hdr_chunk));
+               yaffs_trace(YAFFS_TRACE_CHECKPOINT,
+                       "Checkpoint read object %d parent %d type %d chunk %d ",
+                       cp.obj_id, cp.parent_id, cp.variant_type,
+                       cp.hdr_chunk);
 
                if (ok && cp.obj_id == ~0) {
                        done = 1;
@@ -704,8 +697,8 @@ static int yaffs2_wr_checkpt_data(struct yaffs_dev *dev)
        int ok = 1;
 
        if (!yaffs2_checkpt_required(dev)) {
-               T(YAFFS_TRACE_CHECKPOINT,
-                 (TSTR("skipping checkpoint write" TENDSTR)));
+               yaffs_trace(YAFFS_TRACE_CHECKPOINT,
+                       "skipping checkpoint write");
                ok = 0;
        }
 
@@ -713,23 +706,23 @@ static int yaffs2_wr_checkpt_data(struct yaffs_dev *dev)
                ok = yaffs2_checkpt_open(dev, 1);
 
        if (ok) {
-               T(YAFFS_TRACE_CHECKPOINT,
-                 (TSTR("write checkpoint validity" TENDSTR)));
+               yaffs_trace(YAFFS_TRACE_CHECKPOINT,
+                       "write checkpoint validity");
                ok = yaffs2_wr_checkpt_validity_marker(dev, 1);
        }
        if (ok) {
-               T(YAFFS_TRACE_CHECKPOINT,
-                 (TSTR("write checkpoint device" TENDSTR)));
+               yaffs_trace(YAFFS_TRACE_CHECKPOINT,
+                       "write checkpoint device");
                ok = yaffs2_wr_checkpt_dev(dev);
        }
        if (ok) {
-               T(YAFFS_TRACE_CHECKPOINT,
-                 (TSTR("write checkpoint objects" TENDSTR)));
+               yaffs_trace(YAFFS_TRACE_CHECKPOINT,
+                       "write checkpoint objects");
                ok = yaffs2_wr_checkpt_objs(dev);
        }
        if (ok) {
-               T(YAFFS_TRACE_CHECKPOINT,
-                 (TSTR("write checkpoint validity" TENDSTR)));
+               yaffs_trace(YAFFS_TRACE_CHECKPOINT,
+                       "write checkpoint validity");
                ok = yaffs2_wr_checkpt_validity_marker(dev, 0);
        }
 
@@ -755,39 +748,39 @@ static int yaffs2_rd_checkpt_data(struct yaffs_dev *dev)
                ok = 0;
 
        if (ok && dev->param.skip_checkpt_rd) {
-               T(YAFFS_TRACE_CHECKPOINT,
-                 (TSTR("skipping checkpoint read" TENDSTR)));
+               yaffs_trace(YAFFS_TRACE_CHECKPOINT,
+                       "skipping checkpoint read");
                ok = 0;
        }
 
        if (ok)
-               ok = yaffs2_checkpt_open(dev, 0);       /* open for read */
+               ok = yaffs2_checkpt_open(dev, 0); /* open for read */
 
        if (ok) {
-               T(YAFFS_TRACE_CHECKPOINT,
-                 (TSTR("read checkpoint validity" TENDSTR)));
+               yaffs_trace(YAFFS_TRACE_CHECKPOINT,
+                       "read checkpoint validity");
                ok = yaffs2_rd_checkpt_validity_marker(dev, 1);
        }
        if (ok) {
-               T(YAFFS_TRACE_CHECKPOINT,
-                 (TSTR("read checkpoint device" TENDSTR)));
+               yaffs_trace(YAFFS_TRACE_CHECKPOINT,
+                       "read checkpoint device");
                ok = yaffs2_rd_checkpt_dev(dev);
        }
        if (ok) {
-               T(YAFFS_TRACE_CHECKPOINT,
-                 (TSTR("read checkpoint objects" TENDSTR)));
+               yaffs_trace(YAFFS_TRACE_CHECKPOINT,
+                       "read checkpoint objects");
                ok = yaffs2_rd_checkpt_objs(dev);
        }
        if (ok) {
-               T(YAFFS_TRACE_CHECKPOINT,
-                 (TSTR("read checkpoint validity" TENDSTR)));
+               yaffs_trace(YAFFS_TRACE_CHECKPOINT,
+                       "read checkpoint validity");
                ok = yaffs2_rd_checkpt_validity_marker(dev, 0);
        }
 
        if (ok) {
                ok = yaffs2_rd_checkpt_sum(dev);
-               T(YAFFS_TRACE_CHECKPOINT,
-                 (TSTR("read checkpoint checksum %d" TENDSTR), ok));
+               yaffs_trace(YAFFS_TRACE_CHECKPOINT,
+                       "read checkpoint checksum %d", ok);
        }
 
        if (!yaffs_checkpt_close(dev))
@@ -815,9 +808,9 @@ void yaffs2_checkpt_invalidate(struct yaffs_dev *dev)
 int yaffs_checkpoint_save(struct yaffs_dev *dev)
 {
 
-       T(YAFFS_TRACE_CHECKPOINT,
-         (TSTR("save entry: is_checkpointed %d" TENDSTR),
-          dev->is_checkpointed));
+       yaffs_trace(YAFFS_TRACE_CHECKPOINT,
+               "save entry: is_checkpointed %d",
+               dev->is_checkpointed);
 
        yaffs_verify_objects(dev);
        yaffs_verify_blocks(dev);
@@ -828,9 +821,9 @@ int yaffs_checkpoint_save(struct yaffs_dev *dev)
                yaffs2_wr_checkpt_data(dev);
        }
 
-       T(YAFFS_TRACE_CHECKPOINT | YAFFS_TRACE_MOUNT,
-         (TSTR("save exit: is_checkpointed %d" TENDSTR),
-          dev->is_checkpointed));
+       yaffs_trace(YAFFS_TRACE_CHECKPOINT | YAFFS_TRACE_MOUNT,
+               "save exit: is_checkpointed %d",
+               dev->is_checkpointed);
 
        return dev->is_checkpointed;
 }
@@ -838,9 +831,9 @@ int yaffs_checkpoint_save(struct yaffs_dev *dev)
 int yaffs2_checkpt_restore(struct yaffs_dev *dev)
 {
        int retval;
-       T(YAFFS_TRACE_CHECKPOINT,
-         (TSTR("restore entry: is_checkpointed %d" TENDSTR),
-          dev->is_checkpointed));
+       yaffs_trace(YAFFS_TRACE_CHECKPOINT,
+               "restore entry: is_checkpointed %d",
+               dev->is_checkpointed);
 
        retval = yaffs2_rd_checkpt_data(dev);
 
@@ -850,9 +843,9 @@ int yaffs2_checkpt_restore(struct yaffs_dev *dev)
                yaffs_verify_free_chunks(dev);
        }
 
-       T(YAFFS_TRACE_CHECKPOINT,
-         (TSTR("restore exit: is_checkpointed %d" TENDSTR),
-          dev->is_checkpointed));
+       yaffs_trace(YAFFS_TRACE_CHECKPOINT,
+               "restore exit: is_checkpointed %d",
+               dev->is_checkpointed);
 
        return retval;
 }
@@ -994,10 +987,9 @@ int yaffs2_scan_backwards(struct yaffs_dev *dev)
        struct yaffs_block_index *block_index = NULL;
        int alt_block_index = 0;
 
-       T(YAFFS_TRACE_SCAN,
-         (TSTR
-          ("yaffs2_scan_backwards starts  intstartblk %d intendblk %d..."
-           TENDSTR), dev->internal_start_block, dev->internal_end_block));
+       yaffs_trace(YAFFS_TRACE_SCAN,
+               "yaffs2_scan_backwards starts  intstartblk %d intendblk %d...",
+               dev->internal_start_block, dev->internal_end_block);
 
        dev->seq_number = YAFFS_LOWEST_SEQUENCE_NUMBER;
 
@@ -1011,10 +1003,9 @@ int yaffs2_scan_backwards(struct yaffs_dev *dev)
        }
 
        if (!block_index) {
-               T(YAFFS_TRACE_SCAN,
-                 (TSTR
-                  ("yaffs2_scan_backwards() could not allocate block index!"
-                   TENDSTR)));
+               yaffs_trace(YAFFS_TRACE_SCAN,
+                       "yaffs2_scan_backwards() could not allocate block index!"
+                       );
                return YAFFS_FAIL;
        }
 
@@ -1040,19 +1031,18 @@ int yaffs2_scan_backwards(struct yaffs_dev *dev)
                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, seq_number));
+               yaffs_trace(YAFFS_TRACE_SCAN_DEBUG,
+                       "Block scanning block %d state %d seq %d",
+                       blk, state, seq_number);
 
                if (state == YAFFS_BLOCK_STATE_CHECKPOINT) {
                        dev->blocks_in_checkpt++;
 
                } else if (state == YAFFS_BLOCK_STATE_DEAD) {
-                       T(YAFFS_TRACE_BAD_BLOCKS,
-                         (TSTR("block %d is bad" TENDSTR), blk));
+                       yaffs_trace(YAFFS_TRACE_BAD_BLOCKS,
+                               "block %d is bad", blk);
                } else if (state == YAFFS_BLOCK_STATE_EMPTY) {
-                       T(YAFFS_TRACE_SCAN_DEBUG,
-                         (TSTR("Block empty " TENDSTR)));
+                       yaffs_trace(YAFFS_TRACE_SCAN_DEBUG, "Block empty ");
                        dev->n_erased_blocks++;
                        dev->n_free_chunks += dev->param.chunks_per_block;
                } else if (state == YAFFS_BLOCK_STATE_NEEDS_SCANNING) {
@@ -1070,18 +1060,16 @@ int yaffs2_scan_backwards(struct yaffs_dev *dev)
                                        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, seq_number));
+                               yaffs_trace(YAFFS_TRACE_SCAN,
+                                       "Block scanning block %d has bad sequence number %d",
+                                       blk, seq_number);
 
                        }
                }
                bi++;
        }
 
-       T(YAFFS_TRACE_SCAN,
-         (TSTR("%d blocks to be sorted..." TENDSTR), n_to_scan));
+       yaffs_trace(YAFFS_TRACE_SCAN, "%d blocks to be sorted...", n_to_scan);
 
        cond_resched();
 
@@ -1091,13 +1079,12 @@ int yaffs2_scan_backwards(struct yaffs_dev *dev)
 
        cond_resched();
 
-       T(YAFFS_TRACE_SCAN, (TSTR("...done" TENDSTR)));
+       yaffs_trace(YAFFS_TRACE_SCAN, "...done");
 
        /* Now scan the blocks looking at the data. */
        start_iter = 0;
        end_iter = n_to_scan - 1;
-       T(YAFFS_TRACE_SCAN_DEBUG,
-         (TSTR("%d blocks to be scanned" TENDSTR), n_to_scan));
+       yaffs_trace(YAFFS_TRACE_SCAN_DEBUG, "%d blocks to scan", n_to_scan);
 
        /* For each block.... backwards */
        for (block_iter = end_iter; !alloc_failed && block_iter >= start_iter;
@@ -1157,10 +1144,9 @@ int yaffs2_scan_backwards(struct yaffs_dev *dev)
                                                    bi->seq_number) {
                                                        /* this is the block being allocated from */
 
-                                                       T(YAFFS_TRACE_SCAN,
-                                                         (TSTR
-                                                          (" Allocating from %d %d"
-                                                           TENDSTR), blk, c));
+                                                       yaffs_trace(YAFFS_TRACE_SCAN,
+                                                               " Allocating from %d %d",
+                                                               blk, c);
 
                                                        state =
                                                            YAFFS_BLOCK_STATE_ALLOCATING;
@@ -1174,10 +1160,9 @@ int yaffs2_scan_backwards(struct yaffs_dev *dev)
                                                         * the current allocation block.
                                                         */
 
-                                                       T(YAFFS_TRACE_SCAN,
-                                                         (TSTR
-                                                          ("Partially written block %d detected"
-                                                           TENDSTR), blk));
+                                                       yaffs_trace(YAFFS_TRACE_SCAN,
+                                                               "Partially written block %d detected",
+                                                               blk);
                                                }
                                        }
                                }
@@ -1185,10 +1170,9 @@ int yaffs2_scan_backwards(struct yaffs_dev *dev)
                                dev->n_free_chunks++;
 
                        } 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));
+                               yaffs_trace(YAFFS_TRACE_SCAN,
+                                       " Unfixed ECC in chunk(%d:%d), chunk ignored",
+                                       blk, c);
 
                                dev->n_free_chunks++;
 
@@ -1197,11 +1181,10 @@ int yaffs2_scan_backwards(struct yaffs_dev *dev)
                                   (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, chunk_id = %d, n_bytes = %d, ignored"
-                                   TENDSTR), blk, c, tags.obj_id,
-                                  tags.chunk_id, tags.n_bytes));
+                               yaffs_trace(YAFFS_TRACE_SCAN,
+                                       "Chunk (%d:%d) with bad tags:obj = %d, chunk_id = %d, n_bytes = %d, ignored",
+                                       blk, c, tags.obj_id,
+                                       tags.chunk_id, tags.n_bytes);
 
                                dev->n_free_chunks++;
 
@@ -1318,10 +1301,9 @@ int yaffs2_scan_backwards(struct yaffs_dev *dev)
 
                                if (!in) {
                                        /* TODO Hoosterman we have a problem! */
-                                       T(YAFFS_TRACE_ERROR,
-                                         (TSTR
-                                          ("yaffs tragedy: Could not make object for object  %d at chunk %d during scan"
-                                           TENDSTR), tags.obj_id, chunk));
+                                       yaffs_trace(YAFFS_TRACE_ERROR,
+                                               "yaffs tragedy: Could not make object for object  %d at chunk %d during scan",
+                                               tags.obj_id, chunk);
                                        continue;
                                }
 
@@ -1391,16 +1373,12 @@ int yaffs2_scan_backwards(struct yaffs_dev *dev)
 
                                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.extra_obj_type,
-                                          in->variant_type, tags.obj_id,
-                                          chunk));
+                                       yaffs_trace(YAFFS_TRACE_ERROR,
+                                               "yaffs tragedy: Bad object type, %d != %d, for object %d at chunk %d during scan",
+                                               oh ?
+                                               oh->type : tags.extra_obj_type,
+                                               in->variant_type, tags.obj_id,
+                                               chunk);
 
                                if (!in->valid &&
                                    (tags.obj_id == YAFFS_OBJECTID_ROOT ||
@@ -1485,10 +1463,9 @@ int yaffs2_scan_backwards(struct yaffs_dev *dev)
                                                 * We're trying to use a non-directory as a directory
                                                 */
 
-                                               T(YAFFS_TRACE_ERROR,
-                                                 (TSTR
-                                                  ("yaffs tragedy: attempting to use non-directory as a directory in scan. Put in lost+found."
-                                                   TENDSTR)));
+                                               yaffs_trace(YAFFS_TRACE_ERROR,
+                                                       "yaffs tragedy: attempting to use non-directory as a directory in scan. Put in lost+found."
+                                                       );
                                                parent = dev->lost_n_found;
                                        }
 
@@ -1615,7 +1592,7 @@ int yaffs2_scan_backwards(struct yaffs_dev *dev)
        if (alloc_failed)
                return YAFFS_FAIL;
 
-       T(YAFFS_TRACE_SCAN, (TSTR("yaffs2_scan_backwards ends" TENDSTR)));
+       yaffs_trace(YAFFS_TRACE_SCAN, "yaffs2_scan_backwards ends");
 
        return YAFFS_OK;
 }
index 79c7462..e536796 100644 (file)
 
 #define MTD_VERSION(a, b, c) (((a) << 16) + ((b) << 8) + (c))
 
-#if defined CONFIG_YAFFS_WINCE
-
-#include "ywinceenv.h"
-
-#elif defined __KERNEL__
-
 #include "moduleconfig.h"
 
-/* Linux kernel */
-
 #include <linux/version.h>
 #define MTD_VERSION_CODE LINUX_VERSION_CODE
 
 
 #define Y_INLINE __inline__
 
+#define yaffs_trace(msk, fmt, ...) do { \
+       if(yaffs_trace_mask & ((msk) | YAFFS_TRACE_ALWAYS)) \
+               printk(KERN_DEBUG "yaffs: " fmt "\n", ##__VA_ARGS__); \
+} while(0)
+
 #define YAFFS_LOSTNFOUND_NAME          "lost+found"
 #define YAFFS_LOSTNFOUND_PREFIX                "obj"
 
 #define Y_TIME_CONVERT(x) (x)
 #endif
 
-#define yaffs_sum_cmp(x, y) ((x) == (y))
-#define strcmp(a, b) strcmp(a, b)
-
-#define TENDSTR "\n"
-#define TSTR(x) KERN_DEBUG x
-#define TCONT(x) x
-#define TOUT(p) printk p
-
 #define compile_time_assertion(assertion) \
        ({ int x = __builtin_choose_expr(assertion, 0, (void)0); (void) x; })
 
-#elif defined CONFIG_YAFFS_DIRECT
-
-#define MTD_VERSION_CODE MTD_VERSION(2, 6, 22)
-
-/* Direct interface */
-#include "ydirectenv.h"
-
-#elif defined CONFIG_YAFFS_UTIL
-
-/* Stuff for YAFFS utilities */
-
-#include "stdlib.h"
-#include "stdio.h"
-#include "string.h"
-
-#define kmalloc(x) malloc(x)
-#define kfree(x)   free(x)
-#define kmalloc_ALT(x) malloc(x)
-#define kfree_ALT(x) free(x)
-
-#define YCHAR char
-#define YUCHAR unsigned char
-#define _Y(x)     x
-#define strcat(a, b)     strcat(a, b)
-#define strcpy(a, b)     strcpy(a, b)
-#define strncpy(a, b, c) strncpy(a, b, c)
-#define strnlen(s,m)          strnlen(s,m)
-#define sprintf               sprintf
-#define yaffs_toupper(a)       toupper(a)
-
-#define Y_INLINE inline
-
-/* #define YINFO(s) YPRINTF(( __FILE__ " %d %s\n",__LINE__,s)) */
-/* #define YALERT(s) YINFO(s) */
-
-#define TENDSTR "\n"
-#define TSTR(x) x
-#define TOUT(p) printf p
-
-#define YAFFS_LOSTNFOUND_NAME          "lost+found"
-#define YAFFS_LOSTNFOUND_PREFIX                "obj"
-/* #define YPRINTF(x) printf x */
-
-#define YAFFS_ROOT_MODE                        0755
-#define YAFFS_LOSTNFOUND_MODE          0700
-
-#define yaffs_sum_cmp(x, y) ((x) == (y))
-#define strcmp(a, b) strcmp(a, b)
-
-#else
-/* Should have specified a configuration type */
-#error Unknown configuration
-
-#endif
-
-#if defined(CONFIG_YAFFS_DIRECT) || defined(CONFIG_YAFFS_WINCE)
-
-#ifdef CONFIG_YAFFSFS_PROVIDE_VALUES
-
-#ifndef O_RDONLY
-#define O_RDONLY        00
-#endif
-
-#ifndef O_WRONLY
-#define O_WRONLY       01
-#endif
-
-#ifndef O_RDWR
-#define O_RDWR         02
-#endif
-
-#ifndef O_CREAT
-#define O_CREAT        0100
-#endif
-
-#ifndef O_EXCL
-#define O_EXCL         0200
-#endif
-
-#ifndef O_TRUNC
-#define O_TRUNC                01000
-#endif
-
-#ifndef O_APPEND
-#define O_APPEND       02000
-#endif
-
-#ifndef SEEK_SET
-#define SEEK_SET       0
-#endif
-
-#ifndef SEEK_CUR
-#define SEEK_CUR       1
-#endif
-
-#ifndef SEEK_END
-#define SEEK_END       2
-#endif
-
-#ifndef EBUSY
-#define EBUSY  16
-#endif
-
-#ifndef ENODEV
-#define ENODEV 19
-#endif
-
-#ifndef EINVAL
-#define EINVAL 22
-#endif
-
-#ifndef ENFILE
-#define ENFILE 23
-#endif
-
-#ifndef EBADF
-#define EBADF  9
-#endif
-
-#ifndef EACCES
-#define EACCES 13
-#endif
-
-#ifndef EXDEV
-#define EXDEV  18
-#endif
-
-#ifndef ENOENT
-#define ENOENT 2
-#endif
-
-#ifndef ENOSPC
-#define ENOSPC 28
-#endif
-
-#ifndef ERANGE
-#define ERANGE 34
-#endif
-
-#ifndef ENODATA
-#define ENODATA 61
-#endif
-
-#ifndef ENOTEMPTY
-#define ENOTEMPTY 39
-#endif
-
-#ifndef ENAMETOOLONG
-#define ENAMETOOLONG 36
-#endif
-
-#ifndef ENOMEM
-#define ENOMEM 12
-#endif
-
-#ifndef EEXIST
-#define EEXIST 17
-#endif
-
-#ifndef ENOTDIR
-#define ENOTDIR 20
-#endif
-
-#ifndef EISDIR
-#define EISDIR 21
-#endif
-
-// Mode flags
-
-#ifndef S_IFMT
-#define S_IFMT         0170000
-#endif
-
-#ifndef S_IFLNK
-#define S_IFLNK                0120000
-#endif
-
-#ifndef S_IFDIR
-#define S_IFDIR                0040000
-#endif
-
-#ifndef S_IFREG
-#define S_IFREG                0100000
-#endif
-
-#ifndef S_IREAD
-#define S_IREAD                0000400
-#endif
-
-#ifndef S_IWRITE
-#define        S_IWRITE        0000200
-#endif
-
-#ifndef S_IEXEC
-#define        S_IEXEC 0000100
-#endif
-
-#ifndef XATTR_CREATE
-#define XATTR_CREATE 1
-#endif
-
-#ifndef XATTR_REPLACE
-#define XATTR_REPLACE 2
-#endif
-
-#ifndef R_OK
-#define R_OK   4
-#define W_OK   2
-#define X_OK   1
-#define F_OK   0
-#endif
-
-#else
-#include <errno.h>
-#include <sys/stat.h>
-#include <fcntl.h>
-#endif
-
-#endif
 
 #ifndef Y_DUMP_STACK
-#define Y_DUMP_STACK() do { } while (0)
+#define Y_DUMP_STACK() dump_stack()
 #endif
 
 #ifndef YBUG
 #define YBUG() do {\
-       T(YAFFS_TRACE_BUG,\
-               (TSTR("==>> yaffs bug: " __FILE__ " %d" TENDSTR),\
-               __LINE__));\
+       yaffs_trace(YAFFS_TRACE_BUG,\
+               "bug " __FILE__ " %d",\
+               __LINE__);\
        Y_DUMP_STACK();\
 } while (0)
 #endif
index 378b73a..4710c2b 100644 (file)
 #define Y_CURRENT_TIME CURRENT_TIME.tv_sec
 #define Y_TIME_CONVERT(x) (x).tv_sec
 
-
-#define TENDSTR "\n"
-#define TSTR(x) KERN_DEBUG x
-#define TCONT(x) x
-#define TOUT(p) printk p
-
 #define compile_time_assertion(assertion) \
        ({ int x = __builtin_choose_expr(assertion, 0, (void)0); (void) x; })
 
+
 #ifndef Y_DUMP_STACK
-#define Y_DUMP_STACK() do { } while (0)
+#define Y_DUMP_STACK() dump_stack()
+
 #endif
+#define yaffs_trace(msk, fmt, ...) do { \
+       if(yaffs_trace_mask & ((msk) | YAFFS_TRACE_ALWAYS)) \
+               printk(KERN_DEBUG "yaffs: " fmt "\n", ##__VA_ARGS__); \
+} while(0)
 
 #ifndef YBUG
 #define YBUG() do {\
-       T(YAFFS_TRACE_BUG,\
-               (TSTR("==>> yaffs bug: " __FILE__ " %d" TENDSTR),\
-               __LINE__));\
+       yaffs_trace(YAFFS_TRACE_BUG,\
+               "bug " __FILE__ " %d",\
+               __LINE__);\
        Y_DUMP_STACK();\
 } while (0)
 #endif
 
+
 #endif