yaffs Change tracing to yaffs_trace

Make the tracing a whole lot easier on the eye.

Signed-off-by: Charles Manning <cdhmanning@gmail.com>

28 files changed, 1151 insertions, 1520 deletions

diff --git a/direct/basic-test/yaffs_fileem.c b/direct/basic-test/yaffs_fileem.c
index 702acbe..66ba93a 100644
--- a/direct/basic-test/yaffs_fileem.c
+++ b/direct/basic-test/yaffs_fileem.c
@@ -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
diff --git a/direct/basic-test/yaffs_fileem2k.c b/direct/basic-test/yaffs_fileem2k.c
index 51c3aa4..52f1e11 100644
--- a/direct/basic-test/yaffs_fileem2k.c
+++ b/direct/basic-test/yaffs_fileem2k.c
@@ -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
diff --git a/direct/basic-test/yaffs_norif1.c b/direct/basic-test/yaffs_norif1.c
index 7be6295..5394f0e 100644
--- a/direct/basic-test/yaffs_norif1.c
+++ b/direct/basic-test/yaffs_norif1.c
@@ -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
diff --git a/direct/basic-test/yaffs_ramdisk.c b/direct/basic-test/yaffs_ramdisk.c
index 88fc3a4..5d389b9 100644
--- a/direct/basic-test/yaffs_ramdisk.c
+++ b/direct/basic-test/yaffs_ramdisk.c
@@ -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;
 }
 
-
diff --git a/direct/basic-test/yaffs_ramem2k.c b/direct/basic-test/yaffs_ramem2k.c
index 9a857fd..e86760b 100644
--- a/direct/basic-test/yaffs_ramem2k.c
+++ b/direct/basic-test/yaffs_ramem2k.c
@@ -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
 	{
diff --git a/direct/yaffsfs.c b/direct/yaffsfs.c
index a9c6b43..e3bc19d 100644
--- a/direct/yaffsfs.c
+++ b/direct/yaffsfs.c
@@ -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);
diff --git a/direct/ydirectenv.h b/direct/ydirectenv.h
index 536ff22..d394c6e 100644
--- a/direct/ydirectenv.h
+++ b/direct/ydirectenv.h
@@ -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"
 
diff --git a/direct/yportenv.h b/direct/yportenv.h
index 597898e..48e32ea 100644
--- a/direct/yportenv.h
+++ b/direct/yportenv.h
@@ -54,13 +54,6 @@
 
 #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 */
diff --git a/yaffs_allocator.c b/yaffs_allocator.c
index 9af15c7..f9cd5be 100644
--- a/yaffs_allocator.c
+++ b/yaffs_allocator.c
@@ -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;
 	}
 
diff --git a/yaffs_bitmap.c b/yaffs_bitmap.c
index 5d1cfb2..9fe4032 100644
--- a/yaffs_bitmap.c
+++ b/yaffs_bitmap.c
@@ -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();
 	}
 }
diff --git a/yaffs_checkptrw.c b/yaffs_checkptrw.c
index 66ce541..4e40f43 100644
--- a/yaffs_checkptrw.c
+++ b/yaffs_checkptrw.c
@@ -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);
 }
diff --git a/yaffs_getblockinfo.h b/yaffs_getblockinfo.h
index 108c361..4cef686 100644
--- a/yaffs_getblockinfo.h
+++ b/yaffs_getblockinfo.h
@@ -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];
diff --git a/yaffs_guts.c b/yaffs_guts.c
index 15d0238..b49f018 100644
--- a/yaffs_guts.c
+++ b/yaffs_guts.c
@@ -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;
 
 }
diff --git a/yaffs_mtdif1_multi.c b/yaffs_mtdif1_multi.c
index c3ea8c9..603dc97 100644
--- a/yaffs_mtdif1_multi.c
+++ b/yaffs_mtdif1_multi.c
@@ -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 */
diff --git a/yaffs_mtdif1_single.c b/yaffs_mtdif1_single.c
index a0bc04f..5108369 100644
--- a/yaffs_mtdif1_single.c
+++ b/yaffs_mtdif1_single.c
@@ -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 */
diff --git a/yaffs_mtdif2_multi.c b/yaffs_mtdif2_multi.c
index 26609f7..9dcccb8 100644
--- a/yaffs_mtdif2_multi.c
+++ b/yaffs_mtdif2_multi.c
@@ -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;
 }
+
diff --git a/yaffs_mtdif2_single.c b/yaffs_mtdif2_single.c
index 0835078..d1643df 100644
--- a/yaffs_mtdif2_single.c
+++ b/yaffs_mtdif2_single.c
@@ -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;
 }
+
diff --git a/yaffs_nand.c b/yaffs_nand.c
index 84ab0f0..e816cab 100644
--- a/yaffs_nand.c
+++ b/yaffs_nand.c
@@ -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();
 	}
 
diff --git a/yaffs_packedtags2.c b/yaffs_packedtags2.c
index 6c12aed..8e7fea3 100644
--- a/yaffs_packedtags2.c
+++ b/yaffs_packedtags2.c
@@ -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);
 
 }
 
diff --git a/yaffs_tagscompat.c b/yaffs_tagscompat.c
index a35e0f3..7578075 100644
--- a/yaffs_tagscompat.c
+++ b/yaffs_tagscompat.c
@@ -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
diff --git a/yaffs_trace.h b/yaffs_trace.h
index 8f632ff..6273dbf 100644
--- a/yaffs_trace.h
+++ b/yaffs_trace.h
@@ -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
diff --git a/yaffs_verify.c b/yaffs_verify.c
index fee3a1e..c12894d 100644
--- a/yaffs_verify.c
+++ b/yaffs_verify.c
@@ -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;
 }
+
diff --git a/yaffs_vfs_multi.c b/yaffs_vfs_multi.c
index 074a285..85df2d7 100644
--- a/yaffs_vfs_multi.c
+++ b/yaffs_vfs_multi.c
@@ -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);
 
diff --git a/yaffs_vfs_single.c b/yaffs_vfs_single.c
index df333cc..d5b8753 100644
--- a/yaffs_vfs_single.c
+++ b/yaffs_vfs_single.c
@@ -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);
 
diff --git a/yaffs_yaffs1.c b/yaffs_yaffs1.c
index 4d10096..9eb6030 100644
--- a/yaffs_yaffs1.c
+++ b/yaffs_yaffs1.c
@@ -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;
 }
diff --git a/yaffs_yaffs2.c b/yaffs_yaffs2.c
index 87733fd..33397af 100644
--- a/yaffs_yaffs2.c
+++ b/yaffs_yaffs2.c
@@ -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;
 }
diff --git a/yportenv_multi.h b/yportenv_multi.h
index 79c7462..e536796 100644
--- a/yportenv_multi.h
+++ b/yportenv_multi.h
@@ -24,16 +24,8 @@
 
 #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
 
@@ -61,6 +53,11 @@
 
 #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"
 
@@ -76,246 +73,19 @@
 #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
diff --git a/yportenv_single.h b/yportenv_single.h
index 378b73a..4710c2b 100644
--- a/yportenv_single.h
+++ b/yportenv_single.h
@@ -47,26 +47,27 @@
 #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