自学教程：C++ yaffs_trace函数代码示例

int yaffs_wr_chunk_tags_nand(struct yaffs_dev *dev,				int nand_chunk,				const u8 *buffer, struct yaffs_ext_tags *tags){	int result;	int flash_chunk = nand_chunk - dev->chunk_offset;	dev->n_page_writes++;	if (tags) {		tags->seq_number = dev->seq_number;		tags->chunk_used = 1;		yaffs_trace(YAFFS_TRACE_WRITE,			"Writing chunk %d tags %d %d",			nand_chunk, tags->obj_id, tags->chunk_id);	} else {		yaffs_trace(YAFFS_TRACE_ERROR, "Writing with no tags");		BUG();		return YAFFS_FAIL;	}	if (dev->param.write_chunk_tags_fn)		result = dev->param.write_chunk_tags_fn(dev, flash_chunk,							buffer, tags);	else		result = yaffs_tags_compat_wr(dev, flash_chunk, buffer, tags);	yaffs_summary_add(dev, tags, nand_chunk);	return result;}

int yaffs_wr_chunk_tags_nand(struct yaffs_dev *dev,			     int nand_chunk,			     const u8 * buffer, struct yaffs_ext_tags *tags){	dev->n_page_writes++;	nand_chunk -= dev->chunk_offset;	if (tags) {		tags->seq_number = dev->seq_number;		tags->chunk_used = 1;		if (!yaffs_validate_tags(tags)) {			yaffs_trace(YAFFS_TRACE_ERROR, "Writing uninitialised tags");			YBUG();		}		yaffs_trace(YAFFS_TRACE_WRITE,			"Writing chunk %d tags %d %d",			nand_chunk, tags->obj_id, tags->chunk_id);	} else {		yaffs_trace(YAFFS_TRACE_ERROR, "Writing with no tags");		YBUG();	}	if (dev->param.write_chunk_tags_fn)		return dev->param.write_chunk_tags_fn(dev, nand_chunk, buffer,						      tags);	else		return yaffs_tags_compat_wr(dev, nand_chunk, buffer, tags);}

int yaffs_verify_mtd(struct mtd_info *mtd, int yaffs_version, int inband_tags,		     int tags_9bytes){	if (yaffs_version == 2) {		if ((WRITE_SIZE(mtd) < YAFFS_MIN_YAFFS2_CHUNK_SIZE ||		     mtd->oobsize < YAFFS_MIN_YAFFS2_SPARE_SIZE) &&		    !inband_tags) {			yaffs_trace(YAFFS_TRACE_ALWAYS,				"MTD device does not have the right page sizes"			);			return -1;		}	} else {		if (WRITE_SIZE(mtd) < YAFFS_BYTES_PER_CHUNK ||		    mtd->oobsize != YAFFS_BYTES_PER_SPARE) {			yaffs_trace(YAFFS_TRACE_ALWAYS,				"MTD device does not support have the right page sizes"			);			return -1;		}		if (tags_9bytes && mtd->oobavail < 9) {			yaffs_trace(YAFFS_TRACE_ALWAYS,				    "MTD device does not support 9-byte tags");			return -1;		}	}	return 0;}

static void yaffs2_checkpt_find_erased_block(struct yaffs_dev *dev){	int i;	int blocks_avail = dev->n_erased_blocks - dev->param.n_reserved_blocks;	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 &&	    blocks_avail > 0) {		for (i = dev->checkpt_next_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_EMPTY) {				dev->checkpt_next_block = i + 1;				dev->checkpt_cur_block = i;				yaffs_trace(YAFFS_TRACE_CHECKPOINT,					"allocating checkpt block %d", i);				return;			}		}	}	yaffs_trace(YAFFS_TRACE_CHECKPOINT, "out of checkpt blocks");	dev->checkpt_next_block = -1;	dev->checkpt_cur_block = -1;}

static int yaffs_create_tnodes(struct yaffs_dev *dev, int n_tnodes){	struct yaffs_allocator *allocator =	    (struct yaffs_allocator *)dev->allocator;	int i;	struct yaffs_tnode *new_tnodes;	u8 *mem;	struct yaffs_tnode *curr;	struct yaffs_tnode *next;	struct yaffs_tnode_list *tnl;	if (!allocator) {		YBUG();		return YAFFS_FAIL;	}	if (n_tnodes < 1)		return YAFFS_OK;		new_tnodes = kmalloc(n_tnodes * dev->tnode_size, GFP_NOFS);	mem = (u8 *) new_tnodes;	if (!new_tnodes) {		yaffs_trace(YAFFS_TRACE_ERROR,			"yaffs: Could not allocate Tnodes");		return YAFFS_FAIL;	}		for (i = 0; i < n_tnodes - 1; i++) {		curr = (struct yaffs_tnode *)&mem[i * dev->tnode_size];		next = (struct yaffs_tnode *)&mem[(i + 1) * dev->tnode_size];		curr->internal[0] = next;	}	curr = (struct yaffs_tnode *)&mem[(n_tnodes - 1) * dev->tnode_size];	curr->internal[0] = allocator->free_tnodes;	allocator->free_tnodes = (struct yaffs_tnode *)mem;	allocator->n_free_tnodes += n_tnodes;	allocator->n_tnodes_created += n_tnodes;	tnl = kmalloc(sizeof(struct yaffs_tnode_list), GFP_NOFS);	if (!tnl) {		yaffs_trace(YAFFS_TRACE_ERROR,			"Could not add tnodes to management list");		return YAFFS_FAIL;	} else {		tnl->tnodes = new_tnodes;		tnl->next = allocator->alloc_tnode_list;		allocator->alloc_tnode_list = tnl;	}	yaffs_trace(YAFFS_TRACE_ALLOCATE,"Tnodes added");	return YAFFS_OK;}

static void yaffs2_checkpt_find_block(struct yaffs_dev *dev){	int i;	struct yaffs_ext_tags tags;	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;		     i++) {			int chunk = i * dev->param.chunks_per_block;			enum yaffs_block_state state;			u32 seq;			dev->param.query_block_fn(dev,						apply_block_offset(dev, i),						&state, &seq);			if (state == YAFFS_BLOCK_STATE_DEAD)				continue;			dev->param.read_chunk_tags_fn(dev,					apply_chunk_offset(dev, chunk),					NULL, &tags);			yaffs_trace(YAFFS_TRACE_CHECKPOINT,				"find next checkpt block: search: block %d state %d oid %d seq %d eccr %d",				i, (int) state,				tags.obj_id, tags.seq_number,				tags.ecc_result);			if (tags.seq_number != YAFFS_SEQUENCE_CHECKPOINT_DATA)				continue;			/* Right kind of block */			dev->checkpt_next_block = tags.obj_id;			dev->checkpt_cur_block = i;			dev->checkpt_block_list[dev->blocks_in_checkpt] = i;			dev->blocks_in_checkpt++;			yaffs_trace(YAFFS_TRACE_CHECKPOINT,				"found checkpt block %d", i);			return;		}	yaffs_trace(YAFFS_TRACE_CHECKPOINT, "found no more checkpt blocks");	dev->checkpt_next_block = -1;	dev->checkpt_cur_block = -1;}

static void yaffs_dump_packed_tags2_tags_only(const struct					      yaffs_packed_tags2_tags_only *ptt){	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 int yflash2_EraseBlock(struct yaffs_dev *dev, int block_no){	int i;	int h;	CheckInit();	if(block_no < 0 || block_no >= filedisk.nBlocks)	{		yaffs_trace(YAFFS_TRACE_ALWAYS,"Attempt to erase non-existant block %d",block_no);		return YAFFS_FAIL;	}	else	{		u8 pg[PAGE_SIZE];		int syz = PAGE_SIZE;		int pos;		memset(pg,0xff,syz);		h = filedisk.handle[(block_no / ( BLOCKS_PER_HANDLE))];		lseek(h,((block_no % BLOCKS_PER_HANDLE) * dev->param.chunks_per_block) * PAGE_SIZE,SEEK_SET);		for(i = 0; i < dev->param.chunks_per_block; i++)		{			write(h,pg,PAGE_SIZE);		}		pos = lseek(h, 0,SEEK_CUR);		return YAFFS_OK;	}}

static 	int yaffs_mtd_write(struct yaffs_dev *dev, int nand_chunk,				   const u8 *data, int data_len,				   const u8 *oob, int oob_len){	struct mtd_info *mtd = yaffs_dev_to_mtd(dev);	loff_t addr;	struct mtd_oob_ops ops;	int retval;	addr = ((loff_t) nand_chunk) * dev->param.total_bytes_per_chunk;	memset(&ops, 0, sizeof(ops));	ops.mode = MTD_OPS_AUTO_OOB;	ops.len = (data) ? data_len : 0;	ops.ooblen = oob_len;	ops.datbuf = (u8 *)data;	ops.oobbuf = (u8 *)oob;#if (LINUX_VERSION_CODE >= KERNEL_VERSION(3, 3, 0))	retval = mtd_write_oob(mtd, addr, &ops);#else	retval = mtd->write_oob(mtd, addr, &ops);#endif	if (retval) {		yaffs_trace(YAFFS_TRACE_MTD,			"write_oob failed, chunk %d, mtd error %d",			nand_chunk, retval);	}	return retval ? YAFFS_FAIL : YAFFS_OK;}

static int yaffs_mtd_read(struct yaffs_dev *dev, int nand_chunk,				   u8 *data, int data_len,				   u8 *oob, int oob_len,				   enum yaffs_ecc_result *ecc_result){	struct mtd_info *mtd = yaffs_dev_to_mtd(dev);	loff_t addr;	struct mtd_oob_ops ops;	int retval;	addr = ((loff_t) nand_chunk) * dev->param.total_bytes_per_chunk;	memset(&ops, 0, sizeof(ops));	ops.mode = MTD_OPS_AUTO_OOB;	ops.len = (data) ? data_len : 0;	ops.ooblen = oob_len;	ops.datbuf = data;	ops.oobbuf = oob;#if (MTD_VERSION_CODE < MTD_VERSION(2, 6, 20))	/* In MTD 2.6.18 to 2.6.19 nand_base.c:nand_do_read_oob() has a bug;	 * help it out with ops.len = ops.ooblen when ops.datbuf == NULL.	 */	ops.len = (ops.datbuf) ? ops.len : ops.ooblen;#endif	/* Read page and oob using MTD.	 * Check status and determine ECC result.	 */	retval = mtd_read_oob(mtd, addr, &ops);	if (retval)		yaffs_trace(YAFFS_TRACE_MTD,			"read_oob failed, chunk %d, mtd error %d",			nand_chunk, retval);	switch (retval) {	case 0:		/* no error */		if(ecc_result)			*ecc_result = YAFFS_ECC_RESULT_NO_ERROR;		break;	case -EUCLEAN:		/* MTD's ECC fixed the data */		if(ecc_result)			*ecc_result = YAFFS_ECC_RESULT_FIXED;		dev->n_ecc_fixed++;		break;	case -EBADMSG:	default:		/* MTD's ECC could not fix the data */		dev->n_ecc_unfixed++;		if(ecc_result)			*ecc_result = YAFFS_ECC_RESULT_UNFIXED;		return YAFFS_FAIL;	}	return YAFFS_OK;}

int nandmtd2_query_block(struct yaffs_dev *dev, int block_no,			 enum yaffs_block_state *state, u32 * seq_number){	struct mtd_info *mtd = yaffs_dev_to_mtd(dev);	int retval;	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) {		yaffs_trace(YAFFS_TRACE_MTD, "block is bad");		*state = YAFFS_BLOCK_STATE_DEAD;		*seq_number = 0;	} else {		struct yaffs_ext_tags t;		nandmtd2_read_chunk_tags(dev, block_no *					 dev->param.chunks_per_block, NULL, &t);		if (t.chunk_used) {			*seq_number = t.seq_number;			*state = YAFFS_BLOCK_STATE_NEEDS_SCANNING;		} else {			*seq_number = 0;			*state = YAFFS_BLOCK_STATE_EMPTY;		}				/*if ecc unfixed, set the block empty. This block will be erased when allocate.*/		if(t.ecc_result == YAFFS_ECC_RESULT_UNFIXED)		{			printk("yaffsdebug : unfixed ecc error when scan block, seqnum:0x%x/n",t.seq_number);			*seq_number = 0;			*state = YAFFS_BLOCK_STATE_EMPTY;		}	}	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;}

static void yaffs_dump_tags2(const struct yaffs_ext_tags *t){	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);}

static int yaffs2_checkpt_space_ok(struct yaffs_dev *dev){	int blocks_avail = dev->n_erased_blocks - dev->param.n_reserved_blocks;	yaffs_trace(YAFFS_TRACE_CHECKPOINT,		"checkpt blocks_avail = %d", blocks_avail);	return (blocks_avail <= 0) ? 0 : 1;}

int yaffs2_checkpt_invalidate_stream(struct yaffs_dev *dev){	/* Erase the checkpoint data */	yaffs_trace(YAFFS_TRACE_CHECKPOINT,		"checkpoint invalidate of %d blocks",		dev->blocks_in_checkpt);	return yaffs_checkpt_erase(dev);}

void yaffs_verify_chunk_bit_id(struct yaffs_dev *dev, int blk, int chunk){	if (blk < dev->internal_start_block || blk > dev->internal_end_block ||	    chunk < 0 || chunk >= dev->param.chunks_per_block) {		yaffs_trace(YAFFS_TRACE_ERROR,			"Chunk Id (%d:%d) invalid",			blk, chunk);		BUG();	}}

/* Write a chunk (page) of data to NAND. * * Caller always provides ExtendedTags data which are converted to a more * compact (packed) form for storage in NAND.  A mini-ECC runs over the * contents of the tags meta-data; used to valid the tags when read. * *  - Pack ExtendedTags to packed_tags1 form *  - Compute mini-ECC for packed_tags1 *  - Write data and packed tags to NAND. * * Note: Due to the use of the packed_tags1 meta-data which does not include * a full sequence number (as found in the larger packed_tags2 form) it is * necessary for Yaffs to re-write a chunk/page (just once) to mark it as * discarded and dirty.  This is not ideal: newer NAND parts are supposed * to be written just once.  When Yaffs performs this operation, this * function is called with a NULL data pointer -- calling MTD write_oob * without data is valid usage (2.6.17). * * Any underlying MTD error results in YAFFS_FAIL. * Returns YAFFS_OK or YAFFS_FAIL. */int nandmtd1_write_chunk_tags(struct yaffs_dev *dev,			      int nand_chunk, const u8 *data,			      const struct yaffs_ext_tags *etags){	struct mtd_info *mtd = yaffs_dev_to_mtd(dev);	int chunk_bytes = dev->data_bytes_per_chunk;	loff_t addr = ((loff_t) nand_chunk) * chunk_bytes;	struct mtd_oob_ops ops;	struct yaffs_packed_tags1 pt1;	int retval;	/* we assume that packed_tags1 and struct yaffs_tags are compatible */	compile_time_assertion(sizeof(struct yaffs_packed_tags1) == 12);	compile_time_assertion(sizeof(struct yaffs_tags) == 8);	yaffs_pack_tags1(&pt1, etags);	yaffs_calc_tags_ecc((struct yaffs_tags *)&pt1);	/* When deleting a chunk, the upper layer provides only skeletal	 * etags, one with is_deleted set.  However, we need to update the	 * tags, not erase them completely.  So we use the NAND write property	 * that only zeroed-bits stick and set tag bytes to all-ones and	 * zero just the (not) deleted bit.	 */	if(dev->param.tags_9bytes) {        	((u8 *) &pt1)[8] = 0xff;        	if (etags->is_deleted) {		        memset(&pt1, 0xff, 8);		        /* zero page_status byte to indicate deleted */		        ((u8 *) &pt1)[8] = 0;                }        } else {        	if (etags->is_deleted) {	        	memset(&pt1, 0xff, 8);	        	/* clear delete status bit to indicate deleted */	        	pt1.deleted = 0;                }        }	memset(&ops, 0, sizeof(ops));	ops.mode = MTD_OPS_AUTO_OOB;	ops.len = (data) ? chunk_bytes : 0;	ops.ooblen = dev->param.tags_9bytes ? 9 : 8;	ops.datbuf = (u8 *) data;	ops.oobbuf = (u8 *) &pt1;	retval = mtd->write_oob(mtd, addr, &ops);	if (retval) {		yaffs_trace(YAFFS_TRACE_MTD,			"write_oob failed, chunk %d, mtd error %d",			nand_chunk, retval);	}	return retval ? YAFFS_FAIL : YAFFS_OK;}

/* Mark a block bad. * * This is a persistant state. * Use of this function should be rare. * * Returns YAFFS_OK or YAFFS_FAIL. */int nandmtd1_mark_block_bad(struct yaffs_dev *dev, int block_no){	struct mtd_info *mtd = yaffs_dev_to_mtd(dev);	int blocksize = dev->param.chunks_per_block * dev->data_bytes_per_chunk;	int retval;	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;}

static inline u8 *yaffs_block_bits(struct yaffs_dev *dev, int blk){	if (blk < dev->internal_start_block || blk > dev->internal_end_block) {		yaffs_trace(YAFFS_TRACE_ERROR,			"BlockBits block %d is not valid",			blk);		BUG();	}	return dev->chunk_bits +	    (dev->chunk_bit_stride * (blk - dev->internal_start_block));}

static int yaffs_mtd_check_bad(struct yaffs_dev *dev, int block_no){	struct mtd_info *mtd = yaffs_dev_to_mtd(dev);	int blocksize = dev->param.chunks_per_block * dev->param.total_bytes_per_chunk;	int retval;	yaffs_trace(YAFFS_TRACE_BAD_BLOCKS, "checking block %d bad", block_no);	retval = mtd_block_isbad(mtd, (loff_t) blocksize * block_no);	return (retval) ? YAFFS_FAIL : YAFFS_OK;}

static int yaffs_tags_marshall_query_block(struct yaffs_dev *dev, int block_no,			       enum yaffs_block_state *state,			       u32 *seq_number){	int retval;	yaffs_trace(YAFFS_TRACE_MTD, "yaffs_tags_marshall_query_block %d",			block_no);	retval = dev->drv.drv_check_bad_fn(dev, block_no);	if (retval== YAFFS_FAIL) {		yaffs_trace(YAFFS_TRACE_MTD, "block is bad");		*state = YAFFS_BLOCK_STATE_DEAD;		*seq_number = 0;	} else {		struct yaffs_ext_tags t;		yaffs_tags_marshall_read(dev,				    block_no * dev->param.chunks_per_block,				    NULL, &t);		if (t.chunk_used) {			*seq_number = t.seq_number;			*state = YAFFS_BLOCK_STATE_NEEDS_SCAN;		} else {			*seq_number = 0;			*state = YAFFS_BLOCK_STATE_EMPTY;		}	}	yaffs_trace(YAFFS_TRACE_MTD,		"block query returns  seq %d state %d",		*seq_number, *state);	if (retval == 0)		return YAFFS_OK;	else		return YAFFS_FAIL;}

/* NB For use with inband tags.... * We assume that the data buffer is of size total_bytes_per_chunk so that we can also * use it to load the tags. */int nandmtd2_write_chunk_tags(struct yaffs_dev *dev, int nand_chunk,			      const u8 * data,			      const struct yaffs_ext_tags *tags){	struct mtd_info *mtd = yaffs_dev_to_mtd(dev);	struct mtd_oob_ops ops;	int retval = 0;	loff_t addr;	struct yaffs_packed_tags2 pt;	int packed_tags_size =	    dev->param.no_tags_ecc ? sizeof(pt.t) : sizeof(pt);	void *packed_tags_ptr =	    dev->param.no_tags_ecc ? (void *)&pt.t : (void *)&pt;	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;	/* For yaffs2 writing there must be both data and tags.	 * If we're using inband tags, then the tags are stuffed into	 * the end of the data buffer.	 */	if (!data || !tags)		BUG();	else if (dev->param.inband_tags) {		struct yaffs_packed_tags2_tags_only *pt2tp;		pt2tp =		    (struct yaffs_packed_tags2_tags_only *)(data +							    dev->							    data_bytes_per_chunk);		yaffs_pack_tags2_tags_only(pt2tp, tags);	} else {		yaffs_pack_tags2(&pt, tags, !dev->param.no_tags_ecc);        }	ops.mode = MTD_OOB_AUTO;	ops.ooblen = (dev->param.inband_tags) ? 0 : packed_tags_size;	ops.len = dev->param.total_bytes_per_chunk;	ops.ooboffs = 0;	ops.datbuf = (u8 *) data;	ops.oobbuf = (dev->param.inband_tags) ? NULL : packed_tags_ptr;	retval = mtd->write_oob(mtd, addr, &ops);	if (retval == 0)		return YAFFS_OK;	else		return YAFFS_FAIL;}

static int yaffs_create_free_objs(struct yaffs_dev *dev, int n_obj){	struct yaffs_allocator *allocator = dev->allocator;	int i;	struct yaffs_obj *new_objs;	struct yaffs_obj_list *list;	if (!allocator) {		YBUG();		return YAFFS_FAIL;	}	if (n_obj < 1)		return YAFFS_OK;		new_objs = kmalloc(n_obj * sizeof(struct yaffs_obj), GFP_NOFS);	list = kmalloc(sizeof(struct yaffs_obj_list), GFP_NOFS);	if (!new_objs || !list) {		if (new_objs) {			kfree(new_objs);			new_objs = NULL;		}		if (list) {			kfree(list);			list = NULL;		}		yaffs_trace(YAFFS_TRACE_ALLOCATE,			"Could not allocate more objects");		return YAFFS_FAIL;	}		for (i = 0; i < n_obj - 1; i++) {		new_objs[i].siblings.next =		    (struct list_head *)(&new_objs[i + 1]);	}	new_objs[n_obj - 1].siblings.next = (void *)allocator->free_objs;	allocator->free_objs = new_objs;	allocator->n_free_objects += n_obj;	allocator->n_obj_created += n_obj;		list->objects = new_objs;	list->next = allocator->allocated_obj_list;	allocator->allocated_obj_list = list;	return YAFFS_OK;}

static void yaffs2_checkpt_find_block(struct yaffs_dev *dev){	int i;	struct yaffs_ext_tags tags;	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;		     i++) {			int chunk = i * dev->param.chunks_per_block;			int realigned_chunk = chunk - dev->chunk_offset;			dev->param.read_chunk_tags_fn(dev, realigned_chunk,						      NULL, &tags);			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_next_block = tags.obj_id;				dev->checkpt_cur_block = i;				dev->checkpt_block_list[dev->							blocks_in_checkpt] = i;				dev->blocks_in_checkpt++;				yaffs_trace(YAFFS_TRACE_CHECKPOINT,					"found checkpt block %d", i);				return;			}		}	yaffs_trace(YAFFS_TRACE_CHECKPOINT, "found no more checkpt blocks");	dev->checkpt_next_block = -1;	dev->checkpt_cur_block = -1;}

struct mtd_info * yaffs_get_mtd_device(dev_t sdev){	struct mtd_info *mtd;	mtd = yaffs_get_mtd_device(sdev);	/* Check it's an mtd device..... */	if (MAJOR(sdev) != MTD_BLOCK_MAJOR)		return NULL;	/* This isn't an mtd device */	/* Check it's NAND */	if (mtd->type != MTD_NANDFLASH) {		yaffs_trace(YAFFS_TRACE_ALWAYS,			"yaffs: MTD device is not NAND it's type %d",			mtd->type);		return NULL;	}	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)	yaffs_trace(YAFFS_TRACE_OS, " size %u", mtd->size);#else	yaffs_trace(YAFFS_TRACE_OS, " size %lld", mtd->size);#endif	return mtd;}

static 	int yaffs_mtd_write(struct yaffs_dev *dev, int nand_chunk,				   const u8 *data, int data_len,				   const u8 *oob, int oob_len){	struct mtd_info *mtd = yaffs_dev_to_mtd(dev);	loff_t addr;	struct mtd_oob_ops ops;	int retval;	yaffs_trace(YAFFS_TRACE_MTD,			"yaffs_mtd_write(%p, %d, %p, %d, %p, %d)/n",			dev, nand_chunk, data, data_len, oob, oob_len);	if (!data || !data_len) {		data = NULL;		data_len = 0;	}	if (!oob || !oob_len) {		oob = NULL;		oob_len = 0;	}	addr = ((loff_t) nand_chunk) * dev->param.total_bytes_per_chunk;	memset(&ops, 0, sizeof(ops));	ops.mode = MTD_OPS_AUTO_OOB;	ops.len = (data) ? data_len : 0;	ops.ooblen = oob_len;	ops.datbuf = (u8 *)data;	ops.oobbuf = (u8 *)oob;	retval = mtd_write_oob(mtd, addr, &ops);	if (retval) {		yaffs_trace(YAFFS_TRACE_MTD,			"write_oob failed, chunk %d, mtd error %d",			nand_chunk, retval);	}	return retval ? YAFFS_FAIL : YAFFS_OK;}

int nandmtd2_query_block(struct yaffs_dev *dev, int block_no,			 enum yaffs_block_state *state, u32 *seq_number){	struct mtd_info *mtd = yaffs_dev_to_mtd(dev);	int retval;	yaffs_trace(YAFFS_TRACE_MTD, "nandmtd2_query_block %d", block_no);	retval =	    mtd->block_isbad(mtd,			      ((loff_t)block_no) * dev->param.chunks_per_block *			     dev->param.total_bytes_per_chunk);	if (retval) {		yaffs_trace(YAFFS_TRACE_MTD, "block is bad");		*state = YAFFS_BLOCK_STATE_DEAD;		*seq_number = 0;	} else {		struct yaffs_ext_tags t;		nandmtd2_read_chunk_tags(dev, block_no *					 dev->param.chunks_per_block, NULL, &t);		if (t.chunk_used) {			*seq_number = t.seq_number;			*state = YAFFS_BLOCK_STATE_NEEDS_SCAN;		} else {			*seq_number = 0;			*state = YAFFS_BLOCK_STATE_EMPTY;		}	}	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;}