JFFS2_DBG_READINODE("the node has no data.\n"); 
dbg_readinode("the node has no data.\n"); 
static inline int read_dnode(struct jffs2_sb_info *c, struct jffs2_raw_node_ref *ref,			     struct jffs2_raw_inode *rd, struct rb_root *tnp, int rdlen,			     uint32_t *latest_mctime, uint32_t *mctime_ver){	struct jffs2_tmp_dnode_info *tn;	uint32_t len, csize;	int ret = 1;		/* Obsoleted. This cannot happen, surely? dwmw2 20020308 */	BUG_ON(ref_obsolete(ref));	tn = jffs2_alloc_tmp_dnode_info();	if (!tn) {		JFFS2_ERROR("failed to allocate tn (%d bytes).\n", sizeof(*tn));		return -ENOMEM;	}	tn->partial_crc = 0;	csize = je32_to_cpu(rd->csize);		/* If we've never checked the CRCs on this node, check them now */	if (ref_flags(ref) == REF_UNCHECKED) {		uint32_t crc;		crc = crc32(0, rd, sizeof(*rd) - 8);		if (unlikely(crc != je32_to_cpu(rd->node_crc))) {			JFFS2_NOTICE("header CRC failed on node at %#08x: read %#08x, calculated %#08x\n",					ref_offset(ref), je32_to_cpu(rd->node_crc), crc);			goto free_out;		}				/* Sanity checks */		if (unlikely(je32_to_cpu(rd->offset) > je32_to_cpu(rd->isize)) ||		    unlikely(PAD(je32_to_cpu(rd->csize) + sizeof(*rd)) != PAD(je32_to_cpu(rd->totlen)))) {				JFFS2_WARNING("inode node header CRC is corrupted at %#08x\n", ref_offset(ref));				jffs2_dbg_dump_node(c, ref_offset(ref));			goto free_out;		}		if (jffs2_is_writebuffered(c) && csize != 0) {			/* At this point we are supposed to check the data CRC			 * of our unchecked node. But thus far, we do not			 * know whether the node is valid or obsolete. To			 * figure this out, we need to walk all the nodes of			 * the inode and build the inode fragtree. We don't			 * want to spend time checking data of nodes which may			 * later be found to be obsolete. So we put off the full			 * data CRC checking until we have read all the inode			 * nodes and have started building the fragtree.			 *			 * The fragtree is being built starting with nodes			 * having the highest version number, so we'll be able			 * to detect whether a node is valid (i.e., it is not			 * overlapped by a node with higher version) or not.			 * And we'll be able to check only those nodes, which			 * are not obsolete.			 *			 * Of course, this optimization only makes sense in case			 * of NAND flashes (or other flashes whith			 * !jffs2_can_mark_obsolete()), since on NOR flashes			 * nodes are marked obsolete physically.			 *			 * Since NAND flashes (or other flashes with			 * jffs2_is_writebuffered(c)) are anyway read by			 * fractions of c->wbuf_pagesize, and we have just read			 * the node header, it is likely that the starting part			 * of the node data is also read when we read the			 * header. So we don't mind to check the CRC of the			 * starting part of the data of the node now, and check			 * the second part later (in jffs2_check_node_data()).			 * Of course, we will not need to re-read and re-check			 * the NAND page which we have just read. This is why we			 * read the whole NAND page at jffs2_get_inode_nodes(),			 * while we needed only the node header.			 */			unsigned char *buf;			/* 'buf' will point to the start of data */			buf = (unsigned char *)rd + sizeof(*rd);			/* len will be the read data length */			len = min_t(uint32_t, rdlen - sizeof(*rd), csize);			tn->partial_crc = crc32(0, buf, len);			JFFS2_DBG_READINODE("Calculates CRC (%#08x) for %d bytes, csize %d\n", tn->partial_crc, len, csize);			/* If we actually calculated the whole data CRC			 * and it is wrong, drop the node. */			if (len >= csize && unlikely(tn->partial_crc != je32_to_cpu(rd->data_crc))) {				JFFS2_NOTICE("wrong data CRC in data node at 0x%08x: read %#08x, calculated %#08x.\n",					ref_offset(ref), tn->partial_crc, je32_to_cpu(rd->data_crc));				goto free_out;			}		} else if (csize == 0) {			/*			 * We checked the header CRC. If the node has no data, adjust			 * the space accounting now. For other nodes this will be done			 * later either when the node is marked obsolete or when its			 * data is checked.			 */			struct jffs2_eraseblock *jeb;			JFFS2_DBG_READINODE("the node has no data.\n");			jeb = &c->blocks[ref->flash_offset / c->sector_size];			len = ref_totlen(c, jeb, ref);			spin_lock(&c->erase_completion_lock);			jeb->used_size += len;			jeb->unchecked_size -= len;			c->used_size += len;			c->unchecked_size -= len;			ref->flash_offset = ref_offset(ref) | REF_NORMAL;			spin_unlock(&c->erase_completion_lock);		}	}	tn->fn = jffs2_alloc_full_dnode();	if (!tn->fn) {		JFFS2_ERROR("alloc fn failed\n");		ret = -ENOMEM;		goto free_out;	}		tn->version = je32_to_cpu(rd->version);	tn->fn->ofs = je32_to_cpu(rd->offset);	tn->data_crc = je32_to_cpu(rd->data_crc);	tn->csize = csize;	tn->fn->raw = ref;		/* There was a bug where we wrote hole nodes out with	   csize/dsize swapped. Deal with it */	if (rd->compr == JFFS2_COMPR_ZERO && !je32_to_cpu(rd->dsize) && csize)		tn->fn->size = csize;	else // normal case...		tn->fn->size = je32_to_cpu(rd->dsize);	JFFS2_DBG_READINODE("dnode @%08x: ver %u, offset %#04x, dsize %#04x, csize %#04x\n",		  ref_offset(ref), je32_to_cpu(rd->version), je32_to_cpu(rd->offset), je32_to_cpu(rd->dsize), csize);		jffs2_add_tn_to_tree(tn, tnp);	return 0;free_out:	jffs2_free_tmp_dnode_info(tn);	return ret;}
10457	/local/tlutelli/issta_data/temp/c/2005_temp/2005/10457/733802d974e5af42acb7cd61b16c0ce6dd03b7ed/readinode.c/clean/fs/jffs2/readinode.c