Make the tracing a whole lot easier on the eye.
Signed-off-by: Charles Manning <cdhmanning@gmail.com>
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
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();
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();
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
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
}
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;
}
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
return YAFFS_OK;
}
-
}
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;
}
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
{
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);
#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"
#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 */
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;
}
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;
allocator->alloc_tnode_list = tnl;
}
- T(YAFFS_TRACE_ALLOCATE, (TSTR("yaffs: Tnodes added" TENDSTR)));
+ yaffs_trace(YAFFS_TRACE_ALLOCATE,"Tnodes added");
return YAFFS_OK;
}
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;
}
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 +
{
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();
}
}
{
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;
}
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++;
{
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 &&
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;
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;
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 */
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;
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;
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 */
{
/* 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);
}
*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];
/* Forward declarations */
-
static int yaffs_wr_data_obj(struct yaffs_obj *in, int inode_chunk,
const u8 * buffer, int n_bytes, int use_reserve);
}
}
- 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
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++;
}
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;
}
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");
}
}
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 */
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;
}
/* 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;
}
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)
{
}
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) {
return ret_val;
}
- T(YAFFS_TRACE_ERROR,
- (TSTR("!!!!!!!!! Allocator out !!!!!!!!!!!!!!!!!" TENDSTR)));
+ yaffs_trace(YAFFS_TRACE_ERROR, "!!!!!!!!! Allocator out !!!!!!!!!!!!!!!!!" );
return -1;
}
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
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);
}
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 =
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__);
}
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;
}
}
* 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();
}
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"
+ );
}
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);
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();
}
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();
}
} 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");
- }
}
}
{
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();
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,
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 {
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;
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);
* 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);
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);
}
}
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);
}
}
}
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);
}
}
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); */
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 {
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)
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 &&
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--;
}
}
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;
}
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)
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;
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));
{
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;
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;
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) {
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();
}
#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) {
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);
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 */
|| 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__);
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);
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)
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);
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);
}
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.
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();
}
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;
}
/* 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;
}
/* 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;
}
* 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;
}
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
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;
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;
}
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;
}
* 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:
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;
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;
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 */
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;
}
*/
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) {
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;
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;
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 */
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;
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) {
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 {
{
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,
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;
*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;
}
+
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;
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) {
{
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,
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;
*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;
}
+
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();
}
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)
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);
}
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;
}
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++;
}
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) {
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
#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
/* 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 */
|| 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);
}
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);
}
}
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]);
}
/*
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.
*/
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)
/* 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);
}
}
}
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;
/* 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) {
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;
}
}
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;
}
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();
}
}
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();
}
}
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();
}
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);
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++;
}
}
in = in;
return YAFFS_OK;
}
+
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));
}
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);
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");
}
*/
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
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;
yaffs_unstitch_obj(inode, obj);
yaffs_gross_unlock(dev);
}
-
}
#else
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;
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;
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);
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);
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;
}
{
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;
}
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);
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);
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);
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) {
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);
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);
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;
}
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 */
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");
}
}
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))
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;
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));
}
}
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);
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,
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);
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;
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,
#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;
}
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;
}
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;
}
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);
}
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;
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;
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);
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);
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;
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);
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);
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,
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))
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;
}
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);
}
- 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;
}
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;
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;
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;
}
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;
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;
}
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;
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;
}
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);
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);
}
}
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) ||
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;
{
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);
{
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);
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)
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);
{
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);
{
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;
}
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)
/* 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
!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 {
!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;
}
}
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;
}
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));
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);
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);
}
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;
}
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;
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);
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);
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);
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);
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));
}
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)
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))
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;
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;
}
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;
}
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);
}
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;
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);
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);
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;
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);
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");
}
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;
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);
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);
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,
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))
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;
}
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);
}
- 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;
}
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;
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;
}
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;
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;
}
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;
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;
}
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;
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;
}
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);
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,
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);
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);
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;
{
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;
}
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);
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;
}
{
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;
}
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);
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);
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);
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) {
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;
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));
}
}
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);
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);
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);
}
}
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) ||
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;
{
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);
{
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);
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 */
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");
}
}
{
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);
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)
/* 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
!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 {
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;
}
}
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));
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);
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);
}
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;
}
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;
}
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);
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);
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__);
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;
}
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;
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);
}
* 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;
}
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;
}
}
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;
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;
}
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);
}
- 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;
}
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,
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;
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;
}
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);
}
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))
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);
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;
}
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);
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;
}
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;
}
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;
}
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) {
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();
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;
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;
* 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);
}
}
}
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++;
(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++;
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;
}
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 ||
* 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;
}
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;
}
#define MTD_VERSION(a, b, c) (((a) << 16) + ((b) << 8) + (c))
-#if defined CONFIG_YAFFS_WINCE
-
-#include "ywinceenv.h"
-
-#elif defined __KERNEL__
-
#include "moduleconfig.h"
-/* Linux kernel */
-
#include <linux/version.h>
#define MTD_VERSION_CODE LINUX_VERSION_CODE
#define Y_INLINE __inline__
+#define yaffs_trace(msk, fmt, ...) do { \
+ if(yaffs_trace_mask & ((msk) | YAFFS_TRACE_ALWAYS)) \
+ printk(KERN_DEBUG "yaffs: " fmt "\n", ##__VA_ARGS__); \
+} while(0)
+
#define YAFFS_LOSTNFOUND_NAME "lost+found"
#define YAFFS_LOSTNFOUND_PREFIX "obj"
#define Y_TIME_CONVERT(x) (x)
#endif
-#define yaffs_sum_cmp(x, y) ((x) == (y))
-#define strcmp(a, b) strcmp(a, b)
-
-#define TENDSTR "\n"
-#define TSTR(x) KERN_DEBUG x
-#define TCONT(x) x
-#define TOUT(p) printk p
-
#define compile_time_assertion(assertion) \
({ int x = __builtin_choose_expr(assertion, 0, (void)0); (void) x; })
-#elif defined CONFIG_YAFFS_DIRECT
-
-#define MTD_VERSION_CODE MTD_VERSION(2, 6, 22)
-
-/* Direct interface */
-#include "ydirectenv.h"
-
-#elif defined CONFIG_YAFFS_UTIL
-
-/* Stuff for YAFFS utilities */
-
-#include "stdlib.h"
-#include "stdio.h"
-#include "string.h"
-
-#define kmalloc(x) malloc(x)
-#define kfree(x) free(x)
-#define kmalloc_ALT(x) malloc(x)
-#define kfree_ALT(x) free(x)
-
-#define YCHAR char
-#define YUCHAR unsigned char
-#define _Y(x) x
-#define strcat(a, b) strcat(a, b)
-#define strcpy(a, b) strcpy(a, b)
-#define strncpy(a, b, c) strncpy(a, b, c)
-#define strnlen(s,m) strnlen(s,m)
-#define sprintf sprintf
-#define yaffs_toupper(a) toupper(a)
-
-#define Y_INLINE inline
-
-/* #define YINFO(s) YPRINTF(( __FILE__ " %d %s\n",__LINE__,s)) */
-/* #define YALERT(s) YINFO(s) */
-
-#define TENDSTR "\n"
-#define TSTR(x) x
-#define TOUT(p) printf p
-
-#define YAFFS_LOSTNFOUND_NAME "lost+found"
-#define YAFFS_LOSTNFOUND_PREFIX "obj"
-/* #define YPRINTF(x) printf x */
-
-#define YAFFS_ROOT_MODE 0755
-#define YAFFS_LOSTNFOUND_MODE 0700
-
-#define yaffs_sum_cmp(x, y) ((x) == (y))
-#define strcmp(a, b) strcmp(a, b)
-
-#else
-/* Should have specified a configuration type */
-#error Unknown configuration
-
-#endif
-
-#if defined(CONFIG_YAFFS_DIRECT) || defined(CONFIG_YAFFS_WINCE)
-
-#ifdef CONFIG_YAFFSFS_PROVIDE_VALUES
-
-#ifndef O_RDONLY
-#define O_RDONLY 00
-#endif
-
-#ifndef O_WRONLY
-#define O_WRONLY 01
-#endif
-
-#ifndef O_RDWR
-#define O_RDWR 02
-#endif
-
-#ifndef O_CREAT
-#define O_CREAT 0100
-#endif
-
-#ifndef O_EXCL
-#define O_EXCL 0200
-#endif
-
-#ifndef O_TRUNC
-#define O_TRUNC 01000
-#endif
-
-#ifndef O_APPEND
-#define O_APPEND 02000
-#endif
-
-#ifndef SEEK_SET
-#define SEEK_SET 0
-#endif
-
-#ifndef SEEK_CUR
-#define SEEK_CUR 1
-#endif
-
-#ifndef SEEK_END
-#define SEEK_END 2
-#endif
-
-#ifndef EBUSY
-#define EBUSY 16
-#endif
-
-#ifndef ENODEV
-#define ENODEV 19
-#endif
-
-#ifndef EINVAL
-#define EINVAL 22
-#endif
-
-#ifndef ENFILE
-#define ENFILE 23
-#endif
-
-#ifndef EBADF
-#define EBADF 9
-#endif
-
-#ifndef EACCES
-#define EACCES 13
-#endif
-
-#ifndef EXDEV
-#define EXDEV 18
-#endif
-
-#ifndef ENOENT
-#define ENOENT 2
-#endif
-
-#ifndef ENOSPC
-#define ENOSPC 28
-#endif
-
-#ifndef ERANGE
-#define ERANGE 34
-#endif
-
-#ifndef ENODATA
-#define ENODATA 61
-#endif
-
-#ifndef ENOTEMPTY
-#define ENOTEMPTY 39
-#endif
-
-#ifndef ENAMETOOLONG
-#define ENAMETOOLONG 36
-#endif
-
-#ifndef ENOMEM
-#define ENOMEM 12
-#endif
-
-#ifndef EEXIST
-#define EEXIST 17
-#endif
-
-#ifndef ENOTDIR
-#define ENOTDIR 20
-#endif
-
-#ifndef EISDIR
-#define EISDIR 21
-#endif
-
-// Mode flags
-
-#ifndef S_IFMT
-#define S_IFMT 0170000
-#endif
-
-#ifndef S_IFLNK
-#define S_IFLNK 0120000
-#endif
-
-#ifndef S_IFDIR
-#define S_IFDIR 0040000
-#endif
-
-#ifndef S_IFREG
-#define S_IFREG 0100000
-#endif
-
-#ifndef S_IREAD
-#define S_IREAD 0000400
-#endif
-
-#ifndef S_IWRITE
-#define S_IWRITE 0000200
-#endif
-
-#ifndef S_IEXEC
-#define S_IEXEC 0000100
-#endif
-
-#ifndef XATTR_CREATE
-#define XATTR_CREATE 1
-#endif
-
-#ifndef XATTR_REPLACE
-#define XATTR_REPLACE 2
-#endif
-
-#ifndef R_OK
-#define R_OK 4
-#define W_OK 2
-#define X_OK 1
-#define F_OK 0
-#endif
-
-#else
-#include <errno.h>
-#include <sys/stat.h>
-#include <fcntl.h>
-#endif
-
-#endif
#ifndef Y_DUMP_STACK
-#define Y_DUMP_STACK() do { } while (0)
+#define Y_DUMP_STACK() dump_stack()
#endif
#ifndef YBUG
#define YBUG() do {\
- T(YAFFS_TRACE_BUG,\
- (TSTR("==>> yaffs bug: " __FILE__ " %d" TENDSTR),\
- __LINE__));\
+ yaffs_trace(YAFFS_TRACE_BUG,\
+ "bug " __FILE__ " %d",\
+ __LINE__);\
Y_DUMP_STACK();\
} while (0)
#endif
#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
projects / yaffs2.git / commitdiff