Lines Matching defs:znode
17 * tree. If a znode is not in memory, we read it from flash while still having
113 * insert_old_idx_znode - record a znode obsoleted since last commit start.
115 * @znode: znode of obsoleted index node
119 int insert_old_idx_znode(struct ubifs_info *c, struct ubifs_znode *znode)
121 if (znode->parent) {
124 zbr = &znode->parent->zbranch[znode->iip];
135 * ins_clr_old_idx_znode - record a znode obsoleted since last commit start.
137 * @znode: znode of obsoleted index node
142 struct ubifs_znode *znode)
146 if (znode->parent) {
149 zbr = &znode->parent->zbranch[znode->iip];
191 * copy_znode - copy a dirty znode.
193 * @znode: znode to copy
195 * A dirty znode being committed may not be changed, so it is copied.
198 struct ubifs_znode *znode)
202 zn = kmemdup(znode, c->max_znode_sz, GFP_NOFS);
214 * add_idx_dirt - add dirt due to a dirty znode.
228 * replace_znode - replace old znode with new znode.
230 * @new_zn: new znode
231 * @old_zn: old znode
232 * @zbr: the branch of parent znode
234 * Replace old znode with new znode in TNC.
250 if (child->znode)
251 child->znode->parent = new_zn;
255 zbr->znode = new_zn;
264 * dirty_cow_znode - ensure a znode is not being committed.
266 * @zbr: branch of znode to check
268 * Returns dirtied znode on success or negative error code on failure.
273 struct ubifs_znode *znode = zbr->znode;
277 if (!ubifs_zn_cow(znode)) {
278 /* znode is not being committed */
279 if (!test_and_set_bit(DIRTY_ZNODE, &znode->flags)) {
287 return znode;
290 zn = copy_znode(c, znode);
314 replace_znode(c, zn, znode, zbr);
611 * get_znode - get a TNC znode that may not be loaded yet.
613 * @znode: parent znode
614 * @n: znode branch slot number
616 * This function returns the znode or a negative error code.
619 struct ubifs_znode *znode, int n)
623 zbr = &znode->zbranch[n];
624 if (zbr->znode)
625 znode = zbr->znode;
627 znode = ubifs_load_znode(c, zbr, znode, n);
628 return znode;
634 * @zn: znode is passed and returned here
635 * @n: znode branch slot number is passed and returned here
642 struct ubifs_znode *znode = *zn;
646 if (nn < znode->child_cnt) {
653 zp = znode->parent;
656 nn = znode->iip + 1;
657 znode = zp;
658 if (nn < znode->child_cnt) {
659 znode = get_znode(c, znode, nn);
660 if (IS_ERR(znode))
661 return PTR_ERR(znode);
662 while (znode->level != 0) {
663 znode = get_znode(c, znode, 0);
664 if (IS_ERR(znode))
665 return PTR_ERR(znode);
671 *zn = znode;
679 * @zn: znode is returned here
680 * @n: znode branch slot number is passed and returned here
687 struct ubifs_znode *znode = *zn;
697 zp = znode->parent;
700 nn = znode->iip - 1;
701 znode = zp;
703 znode = get_znode(c, znode, nn);
704 if (IS_ERR(znode))
705 return PTR_ERR(znode);
706 while (znode->level != 0) {
707 nn = znode->child_cnt - 1;
708 znode = get_znode(c, znode, nn);
709 if (IS_ERR(znode))
710 return PTR_ERR(znode);
712 nn = znode->child_cnt - 1;
716 *zn = znode;
725 * @zn: znode is returned here
763 * like to insert, but inserting in this znode
768 * znode zp
773 * znode za | | znode zb
778 * The lookup finds Key2 in znode zb. Lets say
782 * znode za at slot n = 1. But that is invalid
784 * be inserted into znode zb.
815 struct ubifs_znode *znode = *zn;
819 err = tnc_next(c, &znode, &nn);
824 if (keys_cmp(c, &znode->zbranch[nn].key, key))
826 err = matches_name(c, &znode->zbranch[nn], nm);
831 *zn = znode;
907 * @zn: znode is returned here
931 struct ubifs_znode *o_znode = NULL, *znode = *zn;
934 cmp = fallible_matches_name(c, &znode->zbranch[nn], nm);
940 o_znode = znode;
999 *zn = znode;
1002 err = tnc_next(c, &znode, &nn);
1007 if (keys_cmp(c, &znode->zbranch[nn].key, key))
1009 err = fallible_matches_name(c, &znode->zbranch[nn], nm);
1014 *zn = znode;
1019 o_znode = znode;
1057 * @zn: znode is passed and returned here
1075 struct ubifs_znode *znode;
1078 znode = *zn;
1080 if (matches_position(&znode->zbranch[nn], lnum, offs))
1085 err = tnc_prev(c, &znode, &nn);
1090 if (keys_cmp(c, &znode->zbranch[nn].key, key))
1092 if (matches_position(&znode->zbranch[nn], lnum, offs)) {
1093 *zn = znode;
1100 znode = *zn;
1103 err = tnc_next(c, &znode, &nn);
1108 if (keys_cmp(c, &znode->zbranch[nn].key, key))
1110 *zn = znode;
1112 if (matches_position(&znode->zbranch[nn], lnum, offs))
1118 * dirty_cow_bottom_up - dirty a znode and its ancestors.
1120 * @znode: znode to dirty
1122 * If we do not have a unique key that resides in a znode, then we cannot
1123 * dirty that znode from the top down (i.e. by using lookup_level0_dirty)
1128 struct ubifs_znode *znode)
1133 ubifs_assert(c, c->zroot.znode);
1134 ubifs_assert(c, znode);
1135 if (c->zroot.znode->level > BOTTOM_UP_HEIGHT) {
1137 c->bottom_up_buf = kmalloc_array(c->zroot.znode->level,
1144 if (c->zroot.znode->level) {
1149 zp = znode->parent;
1152 n = znode->iip;
1153 ubifs_assert(c, p < c->zroot.znode->level);
1155 if (!zp->cnext && ubifs_zn_dirty(znode))
1157 znode = zp;
1165 zp = znode->parent;
1170 znode = dirty_cow_znode(c, zbr);
1172 ubifs_assert(c, znode == c->zroot.znode);
1173 znode = dirty_cow_znode(c, &c->zroot);
1175 if (IS_ERR(znode) || !p)
1178 ubifs_assert(c, path[p - 1] < znode->child_cnt);
1179 znode = znode->zbranch[path[p - 1]].znode;
1182 return znode;
1186 * ubifs_lookup_level0 - search for zero-level znode.
1189 * @zn: znode is returned here
1190 * @n: znode branch slot number is returned here
1192 * This function looks up the TNC tree and search for zero-level znode which
1193 * refers key @key. The found zero-level znode is returned in @zn. There are 3
1195 * o exact match, i.e. the found zero-level znode contains key @key, then %1
1197 * o not exact match, which means that zero-level znode does not contain
1211 struct ubifs_znode *znode;
1217 znode = c->zroot.znode;
1218 if (unlikely(!znode)) {
1219 znode = ubifs_load_znode(c, &c->zroot, NULL, 0);
1220 if (IS_ERR(znode))
1221 return PTR_ERR(znode);
1224 znode->time = time;
1229 exact = ubifs_search_zbranch(c, znode, key, n);
1231 if (znode->level == 0)
1236 zbr = &znode->zbranch[*n];
1238 if (zbr->znode) {
1239 znode->time = time;
1240 znode = zbr->znode;
1244 /* znode is not in TNC cache, load it from the media */
1245 znode = ubifs_load_znode(c, zbr, znode, *n);
1246 if (IS_ERR(znode))
1247 return PTR_ERR(znode);
1250 *zn = znode;
1252 dbg_tnc("found %d, lvl %d, n %d", exact, znode->level, *n);
1280 * children of current znode. For example, this happens if we split a
1281 * znode like this: | 3 | 5 | 5 | 6 | 7 |, which results in something
1292 * if we changed the leftmost key of the parent znode, the garbage
1299 err = tnc_prev(c, &znode, n);
1301 dbg_tnc("found 0, lvl %d, n -1", znode->level);
1307 if (keys_cmp(c, key, &znode->zbranch[*n].key)) {
1308 dbg_tnc("found 0, lvl %d, n -1", znode->level);
1313 dbg_tnc("found 1, lvl %d, n %d", znode->level, *n);
1314 *zn = znode;
1319 * lookup_level0_dirty - search for zero-level znode dirtying.
1322 * @zn: znode is returned here
1323 * @n: znode branch slot number is returned here
1325 * This function looks up the TNC tree and search for zero-level znode which
1326 * refers key @key. The found zero-level znode is returned in @zn. There are 3
1328 * o exact match, i.e. the found zero-level znode contains key @key, then %1
1330 * o not exact match, which means that zero-level znode does not contain @key
1337 * znode are marked as dirty.
1347 struct ubifs_znode *znode;
1352 znode = c->zroot.znode;
1353 if (unlikely(!znode)) {
1354 znode = ubifs_load_znode(c, &c->zroot, NULL, 0);
1355 if (IS_ERR(znode))
1356 return PTR_ERR(znode);
1359 znode = dirty_cow_znode(c, &c->zroot);
1360 if (IS_ERR(znode))
1361 return PTR_ERR(znode);
1363 znode->time = time;
1368 exact = ubifs_search_zbranch(c, znode, key, n);
1370 if (znode->level == 0)
1375 zbr = &znode->zbranch[*n];
1377 if (zbr->znode) {
1378 znode->time = time;
1379 znode = dirty_cow_znode(c, zbr);
1380 if (IS_ERR(znode))
1381 return PTR_ERR(znode);
1385 /* znode is not in TNC cache, load it from the media */
1386 znode = ubifs_load_znode(c, zbr, znode, *n);
1387 if (IS_ERR(znode))
1388 return PTR_ERR(znode);
1389 znode = dirty_cow_znode(c, zbr);
1390 if (IS_ERR(znode))
1391 return PTR_ERR(znode);
1394 *zn = znode;
1396 dbg_tnc("found %d, lvl %d, n %d", exact, znode->level, *n);
1404 err = tnc_prev(c, &znode, n);
1407 dbg_tnc("found 0, lvl %d, n -1", znode->level);
1412 if (keys_cmp(c, key, &znode->zbranch[*n].key)) {
1414 dbg_tnc("found 0, lvl %d, n -1", znode->level);
1418 if (znode->cnext || !ubifs_zn_dirty(znode)) {
1419 znode = dirty_cow_bottom_up(c, znode);
1420 if (IS_ERR(znode))
1421 return PTR_ERR(znode);
1424 dbg_tnc("found 1, lvl %d, n %d", znode->level, *n);
1425 *zn = znode;
1482 struct ubifs_znode *znode;
1487 found = ubifs_lookup_level0(c, key, &znode, &n);
1495 zt = &znode->zbranch[n];
1513 zbr = znode->zbranch[n];
1557 struct ubifs_znode *znode;
1565 err = ubifs_lookup_level0(c, &bu->key, &znode, &n);
1570 len = znode->zbranch[n].len;
1577 bu->zbranch[bu->cnt++] = znode->zbranch[n];
1579 lnum = znode->zbranch[n].lnum;
1580 offs = ALIGN(znode->zbranch[n].offs + len, 8);
1588 err = tnc_next(c, &znode, &n);
1591 zbr = &znode->zbranch[n];
1850 struct ubifs_znode *znode;
1854 found = ubifs_lookup_level0(c, key, &znode, &n);
1865 err = resolve_collision(c, key, &znode, &n, nm);
1866 dbg_tnc("rc returned %d, znode %p, n %d", err, znode, n);
1874 err = tnc_read_hashed_node(c, &znode->zbranch[n], node);
1925 struct ubifs_znode *znode = *zn;
1930 err = tnc_next(c, &znode, n);
1936 zbr = &znode->zbranch[*n];
1950 *zn = znode;
1954 err = tnc_next(c, &znode, n);
1964 struct ubifs_znode *znode;
1972 err = ubifs_lookup_level0(c, &start_key, &znode, &n);
1976 err = search_dh_cookie(c, key, dent, cookie, &znode, &n, err);
2027 * @znode: znode to correct parent znodes for
2034 struct ubifs_znode *znode)
2038 ubifs_assert(c, znode->parent);
2039 ubifs_assert(c, znode->iip == 0);
2041 key = &znode->zbranch[0].key;
2042 key1 = &znode->parent->zbranch[0].key;
2046 znode = znode->parent;
2047 znode->alt = 1;
2048 if (!znode->parent || znode->iip)
2050 key1 = &znode->parent->zbranch[0].key;
2055 * insert_zbranch - insert a zbranch into a znode.
2057 * @znode: znode into which to insert
2062 * znode's array of zbranches and keeps zbranches consolidated, so when a new
2063 * zbranch has to be inserted to the @znode->zbranches[]' array at the @n-th
2066 static void insert_zbranch(struct ubifs_info *c, struct ubifs_znode *znode,
2071 ubifs_assert(c, ubifs_zn_dirty(znode));
2073 if (znode->level) {
2074 for (i = znode->child_cnt; i > n; i--) {
2075 znode->zbranch[i] = znode->zbranch[i - 1];
2076 if (znode->zbranch[i].znode)
2077 znode->zbranch[i].znode->iip = i;
2079 if (zbr->znode)
2080 zbr->znode->iip = n;
2082 for (i = znode->child_cnt; i > n; i--)
2083 znode->zbranch[i] = znode->zbranch[i - 1];
2085 znode->zbranch[n] = *zbr;
2086 znode->child_cnt += 1;
2090 * this znode may have changed. If this znode is subsequently split
2093 * happens, then it will no longer be possible to find this znode in the
2103 znode->alt = 1;
2109 * @znode: znode to insert into
2113 * This function inserts a new node described by @zbr into znode @znode. If
2114 * znode does not have a free slot for new zbranch, it is split. Parent znodes
2118 static int tnc_insert(struct ubifs_info *c, struct ubifs_znode *znode,
2129 zp = znode->parent;
2130 if (znode->child_cnt < c->fanout) {
2132 dbg_tnck(key, "inserted at %d level %d, key ", n, znode->level);
2134 insert_zbranch(c, znode, zbr, n);
2137 if (n == 0 && zp && znode->iip == 0)
2138 correct_parent_keys(c, znode);
2144 * Unfortunately, @znode does not have more empty slots and we have to
2147 dbg_tnck(key, "splitting level %d, key ", znode->level);
2149 if (znode->alt)
2151 * We can no longer be sure of finding this znode by key, so we
2154 ins_clr_old_idx_znode(c, znode);
2160 zn->level = znode->level;
2163 if (znode->level == 0 && key_type(c, key) == UBIFS_DATA_KEY) {
2166 key1 = &znode->zbranch[n - 1].key;
2177 key1 = &znode->zbranch[0].key;
2180 key1 = &znode->zbranch[n].key;
2185 zi = znode;
2206 /* Insert into existing znode */
2207 zi = znode;
2211 /* Insert into new znode */
2216 zbr->znode->parent = zn;
2225 znode->child_cnt = keep;
2231 zn->zbranch[i] = znode->zbranch[keep + i];
2234 if (zn->zbranch[i].znode) {
2235 zn->zbranch[i].znode->parent = zn;
2236 zn->zbranch[i].znode->iip = i;
2245 /* Insert new znode (produced by spitting) into the parent */
2247 if (n == 0 && zi == znode && znode->iip == 0)
2248 correct_parent_keys(c, znode);
2251 n = znode->iip + 1;
2255 zbr->znode = zn;
2259 znode = zp;
2264 /* We have to split root znode */
2265 dbg_tnc("creating new zroot at level %d", znode->level + 1);
2272 zi->level = znode->level + 1;
2277 zi->zbranch[0].key = znode->zbranch[0].key;
2278 zi->zbranch[0].znode = znode;
2283 zi->zbranch[1].znode = zn;
2288 c->zroot.znode = zi;
2292 znode->parent = zi;
2293 znode->iip = 0;
2315 struct ubifs_znode *znode;
2319 found = lookup_level0_dirty(c, key, &znode, &n);
2323 zbr.znode = NULL;
2329 err = tnc_insert(c, znode, &zbr, n + 1);
2331 struct ubifs_zbranch *zbr = &znode->zbranch[n];
2366 struct ubifs_znode *znode;
2371 found = lookup_level0_dirty(c, key, &znode, &n);
2378 struct ubifs_zbranch *zbr = &znode->zbranch[n];
2391 found = resolve_collision_directly(c, key, &znode, &n,
2393 dbg_tnc("rc returned %d, znode %p, n %d, LEB %d:%d",
2394 found, znode, n, old_lnum, old_offs);
2401 /* Ensure the znode is dirtied */
2402 if (znode->cnext || !ubifs_zn_dirty(znode)) {
2403 znode = dirty_cow_bottom_up(c, znode);
2404 if (IS_ERR(znode)) {
2405 err = PTR_ERR(znode);
2409 zbr = &znode->zbranch[n];
2451 struct ubifs_znode *znode;
2455 found = lookup_level0_dirty(c, key, &znode, &n);
2463 found = fallible_resolve_collision(c, key, &znode, &n,
2466 found = resolve_collision(c, key, &znode, &n, nm);
2467 dbg_tnc("rc returned %d, znode %p, n %d", found, znode, n);
2473 /* Ensure the znode is dirtied */
2474 if (znode->cnext || !ubifs_zn_dirty(znode)) {
2475 znode = dirty_cow_bottom_up(c, znode);
2476 if (IS_ERR(znode)) {
2477 err = PTR_ERR(znode);
2483 struct ubifs_zbranch *zbr = &znode->zbranch[n];
2498 zbr.znode = NULL;
2504 err = tnc_insert(c, znode, &zbr, n + 1);
2532 * tnc_delete - delete a znode form TNC.
2534 * @znode: znode to delete from
2537 * This function deletes a leaf node from @n-th slot of @znode. Returns zero in
2540 static int tnc_delete(struct ubifs_info *c, struct ubifs_znode *znode, int n)
2547 ubifs_assert(c, znode->level == 0);
2549 dbg_tnck(&znode->zbranch[n].key, "deleting key ");
2551 zbr = &znode->zbranch[n];
2556 ubifs_dump_znode(c, znode);
2561 for (i = n; i < znode->child_cnt - 1; i++)
2562 znode->zbranch[i] = znode->zbranch[i + 1];
2563 znode->child_cnt -= 1;
2565 if (znode->child_cnt > 0)
2569 * This was the last zbranch, we have to delete this znode from the
2574 ubifs_assert(c, !ubifs_zn_obsolete(znode));
2575 ubifs_assert(c, ubifs_zn_dirty(znode));
2577 zp = znode->parent;
2578 n = znode->iip;
2582 err = insert_old_idx_znode(c, znode);
2586 if (znode->cnext) {
2587 __set_bit(OBSOLETE_ZNODE, &znode->flags);
2591 kfree(znode);
2592 znode = zp;
2593 } while (znode->child_cnt == 1); /* while removing last child */
2595 /* Remove from znode, entry n - 1 */
2596 znode->child_cnt -= 1;
2597 ubifs_assert(c, znode->level != 0);
2598 for (i = n; i < znode->child_cnt; i++) {
2599 znode->zbranch[i] = znode->zbranch[i + 1];
2600 if (znode->zbranch[i].znode)
2601 znode->zbranch[i].znode->iip = i;
2608 if (!znode->parent) {
2609 while (znode->child_cnt == 1 && znode->level != 0) {
2610 zp = znode;
2611 zbr = &znode->zbranch[0];
2612 znode = get_znode(c, znode, 0);
2613 if (IS_ERR(znode))
2614 return PTR_ERR(znode);
2615 znode = dirty_cow_znode(c, zbr);
2616 if (IS_ERR(znode))
2617 return PTR_ERR(znode);
2618 znode->parent = NULL;
2619 znode->iip = 0;
2629 c->zroot.znode = znode;
2656 struct ubifs_znode *znode;
2660 found = lookup_level0_dirty(c, key, &znode, &n);
2666 err = tnc_delete(c, znode, n);
2687 struct ubifs_znode *znode;
2691 err = lookup_level0_dirty(c, key, &znode, &n);
2697 err = fallible_resolve_collision(c, key, &znode, &n,
2700 err = resolve_collision(c, key, &znode, &n, nm);
2701 dbg_tnc("rc returned %d, znode %p, n %d", err, znode, n);
2705 /* Ensure the znode is dirtied */
2706 if (znode->cnext || !ubifs_zn_dirty(znode)) {
2707 znode = dirty_cow_bottom_up(c, znode);
2708 if (IS_ERR(znode)) {
2709 err = PTR_ERR(znode);
2713 err = tnc_delete(c, znode, n);
2736 struct ubifs_znode *znode;
2744 err = lookup_level0_dirty(c, key, &znode, &n);
2748 zbr = &znode->zbranch[n];
2765 err = ubifs_lookup_level0(c, &start_key, &znode, &n);
2769 err = search_dh_cookie(c, key, dent, cookie, &znode, &n, err);
2774 if (znode->cnext || !ubifs_zn_dirty(znode)) {
2775 znode = dirty_cow_bottom_up(c, znode);
2776 if (IS_ERR(znode)) {
2777 err = PTR_ERR(znode);
2781 err = tnc_delete(c, znode, n);
2825 struct ubifs_znode *znode;
2830 /* Find first level 0 znode that contains keys to remove */
2831 err = ubifs_lookup_level0(c, from_key, &znode, &n);
2838 err = tnc_next(c, &znode, &n);
2845 key = &znode->zbranch[n].key;
2852 /* Ensure the znode is dirtied */
2853 if (znode->cnext || !ubifs_zn_dirty(znode)) {
2854 znode = dirty_cow_bottom_up(c, znode);
2855 if (IS_ERR(znode)) {
2856 err = PTR_ERR(znode);
2862 for (i = n + 1, k = 0; i < znode->child_cnt; i++, k++) {
2863 key = &znode->zbranch[i].key;
2866 lnc_free(&znode->zbranch[i]);
2867 err = ubifs_add_dirt(c, znode->zbranch[i].lnum,
2868 znode->zbranch[i].len);
2870 ubifs_dump_znode(c, znode);
2876 for (i = n + 1 + k; i < znode->child_cnt; i++)
2877 znode->zbranch[i - k] = znode->zbranch[i];
2878 znode->child_cnt -= k;
2882 err = tnc_delete(c, znode, n);
2993 struct ubifs_znode *znode;
3002 err = ubifs_lookup_level0(c, key, &znode, &n);
3010 err = fallible_resolve_collision(c, key, &znode, &n,
3013 err = resolve_collision(c, key, &znode, &n, nm);
3014 dbg_tnc("rc returned %d, znode %p, n %d",
3015 err, znode, n);
3021 err = tnc_next(c, &znode, &n);
3033 * tree and @znode/@n variables contain the closest
3036 err = tnc_next(c, &znode, &n);
3042 zbr = &znode->zbranch[n];
3089 struct ubifs_znode *znode = cnext;
3092 if (ubifs_zn_obsolete(znode))
3093 kfree(znode);
3094 else if (!ubifs_zn_cow(znode)) {
3096 * Don't forget to update clean znode count after
3098 * count while closing tnc. Non-obsolete znode could
3101 * for each dirty znode before committing, and it is
3102 * cleared as long as the znode become clean, so we
3103 * can statistic clean znode count according to this
3126 * left_znode - get the znode to the left.
3128 * @znode: znode
3130 * This function returns a pointer to the znode to the left of @znode or NULL if
3134 struct ubifs_znode *znode)
3136 int level = znode->level;
3139 int n = znode->iip - 1;
3142 znode = znode->parent;
3143 if (!znode)
3147 znode = get_znode(c, znode, n);
3148 if (IS_ERR(znode))
3149 return znode;
3150 while (znode->level != level) {
3151 n = znode->child_cnt - 1;
3152 znode = get_znode(c, znode, n);
3153 if (IS_ERR(znode))
3154 return znode;
3159 return znode;
3163 * right_znode - get the znode to the right.
3165 * @znode: znode
3167 * This function returns a pointer to the znode to the right of @znode or NULL
3171 struct ubifs_znode *znode)
3173 int level = znode->level;
3176 int n = znode->iip + 1;
3179 znode = znode->parent;
3180 if (!znode)
3182 if (n < znode->child_cnt) {
3184 znode = get_znode(c, znode, n);
3185 if (IS_ERR(znode))
3186 return znode;
3187 while (znode->level != level) {
3188 znode = get_znode(c, znode, 0);
3189 if (IS_ERR(znode))
3190 return znode;
3195 return znode;
3213 * dirty znode which still refers the same @lnum:@offs. This function is clever
3216 * Note, if a znode was deleted or changed too much, then this function will
3220 * This function returns a pointer to the znode found or %NULL if it is not
3227 struct ubifs_znode *znode, *zn;
3239 /* Get the root znode */
3240 znode = c->zroot.znode;
3241 if (!znode) {
3242 znode = ubifs_load_znode(c, &c->zroot, NULL, 0);
3243 if (IS_ERR(znode))
3244 return znode;
3248 return znode;
3250 if (level >= znode->level)
3253 ubifs_search_zbranch(c, znode, key, &n);
3256 * We reached a znode where the leftmost key is greater
3263 znode = left_znode(c, znode);
3264 if (!znode)
3266 if (IS_ERR(znode))
3267 return znode;
3268 ubifs_search_zbranch(c, znode, key, &n);
3271 if (znode->level == level + 1)
3273 znode = get_znode(c, znode, n);
3274 if (IS_ERR(znode))
3275 return znode;
3278 if (znode->zbranch[n].lnum == lnum && znode->zbranch[n].offs == offs)
3279 return get_znode(c, znode, n);
3287 zn = znode;
3295 znode = left_znode(c, znode);
3296 if (!znode)
3298 if (IS_ERR(znode))
3299 return znode;
3300 n = znode->child_cnt - 1;
3303 if (znode->zbranch[n].lnum == lnum &&
3304 znode->zbranch[n].offs == offs)
3305 return get_znode(c, znode, n);
3307 if (keys_cmp(c, &znode->zbranch[n].key, key) < 0)
3311 znode = zn;
3316 if (++n >= znode->child_cnt) {
3317 znode = right_znode(c, znode);
3318 if (!znode)
3320 if (IS_ERR(znode))
3321 return znode;
3325 if (znode->zbranch[n].lnum == lnum &&
3326 znode->zbranch[n].offs == offs)
3327 return get_znode(c, znode, n);
3329 if (keys_cmp(c, &znode->zbranch[n].key, key) > 0)
3344 * if the index node is referred to in the TNC and the corresponding znode is
3346 * znode is clean, and a negative error code in case of failure.
3355 struct ubifs_znode *znode;
3357 znode = lookup_znode(c, key, level, lnum, offs);
3358 if (!znode)
3360 if (IS_ERR(znode))
3361 return PTR_ERR(znode);
3363 return ubifs_zn_dirty(znode) ? 1 : 2;
3383 struct ubifs_znode *znode, *zn;
3387 found = ubifs_lookup_level0(c, key, &znode, &n);
3392 zbr = &znode->zbranch[n];
3401 zn = znode;
3405 err = tnc_prev(c, &znode, &n);
3410 if (keys_cmp(c, key, &znode->zbranch[n].key))
3412 zbr = &znode->zbranch[n];
3417 znode = zn;
3420 err = tnc_next(c, &znode, &n);
3426 if (keys_cmp(c, key, &znode->zbranch[n].key))
3428 zbr = &znode->zbranch[n];
3447 * the corresponding znode is clean or has not been loaded.
3492 struct ubifs_znode *znode;
3496 znode = lookup_znode(c, key, level, lnum, offs);
3497 if (!znode)
3499 if (IS_ERR(znode)) {
3500 err = PTR_ERR(znode);
3503 znode = dirty_cow_bottom_up(c, znode);
3504 if (IS_ERR(znode)) {
3505 err = PTR_ERR(znode);
3530 struct ubifs_znode *znode;
3543 err = ubifs_lookup_level0(c, &from_key, &znode, &n);
3552 err = tnc_next(c, &znode, &n);
3561 key = &znode->zbranch[n].key;