fs/ubifs/tnc.c

57 		if (old_idx->lnum < o->lnum)
59 		else if (old_idx->lnum > o->lnum)
78  * @lnum: LEB number of obsoleted index node
98 static int insert_old_idx(struct ubifs_info *c, int lnum, int offs)
105 	old_idx->lnum = lnum;
126 			return insert_old_idx(c, zbr->lnum, zbr->offs);
129 			return insert_old_idx(c, c->zroot.lnum,
151 			err = insert_old_idx(c, zbr->lnum, zbr->offs);
154 			zbr->lnum = 0;
160 			err = insert_old_idx(c, c->zroot.lnum, c->zroot.offs);
163 			c->zroot.lnum = 0;
216  * @lnum: LEB number of index node
221 static int add_idx_dirt(struct ubifs_info *c, int lnum, int dirt)
224 	return ubifs_add_dirt(c, lnum, dirt);
256 	zbr->lnum = 0;
283 			err = add_idx_dirt(c, zbr->lnum, zbr->len);
302 		old_idx->lnum = zbr->lnum;
305 		err = add_idx_dirt(c, zbr->lnum, zbr->len);
482 	int lnum = zbr->lnum;
488 	dbg_io("LEB %d:%d, %s, length %d", lnum, offs, dbg_ntype(type), len);
490 	err = ubifs_leb_read(c, lnum, buf, offs, len, 1);
493 			  type, lnum, offs, err);
517 		ubifs_bad_hash(c, buf, zbr->hash, lnum, offs);
539 	dbg_tnck(key, "LEB %d:%d, key ", zbr->lnum, zbr->offs);
553 			zbr->lnum, zbr->offs, zbr->len);
1030 		o_znode->zbranch[o_n].lnum, o_znode->zbranch[o_n].offs,
1040  * @lnum: LEB number of dent to match
1043  * This function returns %1 if @lnum:@offs matches, and %0 otherwise.
1045 static int matches_position(struct ubifs_zbranch *zbr, int lnum, int offs)
1047 	if (zbr->lnum == lnum && zbr->offs == offs)
1059  * @lnum: LEB number of dent node to match
1064  * flash address of the right node is known (@lnum:@offs) which makes it much
1067  * resolved, %0 if @lnum:@offs is not found and @zn and @n are set to the
1073 				      int lnum, int offs)
1080 	if (matches_position(&znode->zbranch[nn], lnum, offs))
1092 		if (matches_position(&znode->zbranch[nn], lnum, offs)) {
1112 		if (matches_position(&znode->zbranch[nn], lnum, offs))
1432  * @lnum: LEB number
1435  * This function determines if @lnum may have been garbage collected since
1439 static int maybe_leb_gced(struct ubifs_info *c, int lnum, int gc_seq1)
1459 	/* Finally we can check lnum */
1460 	if (gced_lnum == lnum)
1470  * @lnum: LEB number is returned here
1476  * case of failure. The node location can be returned in @lnum and @offs.
1479 		     void *node, int *lnum, int *offs)
1496 	if (lnum) {
1497 		*lnum = zt->lnum;
1517 	if (ubifs_get_wbuf(c, zbr.lnum)) {
1524 	if (err <= 0 || maybe_leb_gced(c, zbr.lnum, gc_seq1)) {
1554 	int n, err = 0, lnum = -1, offs;
1579 		lnum = znode->zbranch[n].lnum;
1599 		if (lnum < 0) {
1601 			lnum = zbr->lnum;
1613 			if (zbr->lnum != lnum || zbr->offs != offs)
1679  * @lnum: LEB number from which to read
1684 static int read_wbuf(struct ubifs_wbuf *wbuf, void *buf, int len, int lnum,
1690 	dbg_io("LEB %d:%d, length %d", lnum, offs, len);
1691 	ubifs_assert(c, wbuf && lnum >= 0 && lnum < c->leb_cnt && offs >= 0);
1696 	overlap = (lnum == wbuf->lnum && offs + len > wbuf->offs);
1700 		return ubifs_leb_read(c, lnum, buf, offs, len, 0);
1714 		return ubifs_leb_read(c, lnum, buf, offs, rlen, 0);
1740 	err = ubifs_check_node(c, buf, zbr->len, zbr->lnum, zbr->offs, 0, 0);
1748 		ubifs_bad_hash(c, buf, zbr->hash, zbr->lnum, zbr->offs);
1762 			  zbr->lnum, zbr->offs);
1773 	ubifs_err(c, "bad node at LEB %d:%d", zbr->lnum, zbr->offs);
1791 	int lnum = bu->zbranch[0].lnum, offs = bu->zbranch[0].offs, len, err, i;
1803 	wbuf = ubifs_get_wbuf(c, lnum);
1805 		err = read_wbuf(wbuf, bu->buf, len, lnum, offs);
1807 		err = ubifs_leb_read(c, lnum, bu->buf, offs, len, 0);
1810 	if (maybe_leb_gced(c, lnum, bu->gc_seq))
1815 			  lnum, offs, err);
2100 	 * if they are split we add their lnum/offs to the old_idx tree.
2256 		zbr->lnum = 0;
2279 	zi->zbranch[0].lnum = c->zroot.lnum;
2285 	c->zroot.lnum = 0;
2302  * @lnum: LEB number of node
2311 int ubifs_tnc_add(struct ubifs_info *c, const union ubifs_key *key, int lnum,
2318 	dbg_tnck(key, "%d:%d, len %d, key ", lnum, offs, len);
2324 		zbr.lnum = lnum;
2334 		err = ubifs_add_dirt(c, zbr->lnum, zbr->len);
2335 		zbr->lnum = lnum;
2354  * @lnum: LEB number of node
2363 		      int old_lnum, int old_offs, int lnum, int offs, int len)
2370 		 old_offs, lnum, offs, len);
2381 		if (zbr->lnum == old_lnum && zbr->offs == old_offs) {
2383 			err = ubifs_add_dirt(c, zbr->lnum, zbr->len);
2386 			zbr->lnum = lnum;
2411 				err = ubifs_add_dirt(c, zbr->lnum,
2415 				zbr->lnum = lnum;
2423 		err = ubifs_add_dirt(c, lnum, len);
2437  * @lnum: LEB number of node
2447 		     int lnum, int offs, int len, const u8 *hash,
2454 	dbg_tnck(key, "LEB %d:%d, key ", lnum, offs);
2486 			err = ubifs_add_dirt(c, zbr->lnum, zbr->len);
2487 			zbr->lnum = lnum;
2499 		zbr.lnum = lnum;
2554 	err = ubifs_add_dirt(c, zbr->lnum, zbr->len);
2621 				err = insert_old_idx(c, c->zroot.lnum,
2626 			c->zroot.lnum = zbr->lnum;
2867 			err = ubifs_add_dirt(c, znode->zbranch[i].lnum,
3203  * @lnum: index node LEB number
3207  * address @lnum:@offs. It looks up the indexing tree by pulling all indexing
3213  * dirty znode which still refers the same @lnum:@offs. This function is clever
3218  * (indexed by @lnum:@offs).
3225 					int lnum, int offs)
3247 	if (c->zroot.lnum == lnum && c->zroot.offs == offs)
3278 	if (znode->zbranch[n].lnum == lnum && znode->zbranch[n].offs == offs)
3303 		if (znode->zbranch[n].lnum == lnum &&
3325 		if (znode->zbranch[n].lnum == lnum &&
3340  * @lnum: LEB number of index node
3353 		       int lnum, int offs)
3357 	znode = lookup_znode(c, key, level, lnum, offs);
3370  * @lnum: node LEB number
3380 			       int lnum, int offs)
3393 	if (lnum == zbr->lnum && offs == zbr->offs)
3413 		if (lnum == zbr->lnum && offs == zbr->offs)
3429 		if (lnum == zbr->lnum && offs == zbr->offs)
3440  * @lnum: node LEB number
3450 		       int lnum, int offs, int is_idx)
3456 		err = is_idx_node_in_tnc(c, key, level, lnum, offs);
3468 		err = is_leaf_node_in_tnc(c, key, lnum, offs);
3480  * @lnum: index node LEB number
3490 			 int lnum, int offs)
3496 	znode = lookup_znode(c, key, level, lnum, offs);