Lines Matching defs:znode
17 * tree. If a znode is not in memory, we read it from flash while still having
112 * insert_old_idx_znode - record a znode obsoleted since last commit start.
114 * @znode: znode of obsoleted index node
118 int insert_old_idx_znode(struct ubifs_info *c, struct ubifs_znode *znode)
120 if (znode->parent) {
123 zbr = &znode->parent->zbranch[znode->iip];
134 * ins_clr_old_idx_znode - record a znode obsoleted since last commit start.
136 * @znode: znode of obsoleted index node
141 struct ubifs_znode *znode)
145 if (znode->parent) {
148 zbr = &znode->parent->zbranch[znode->iip];
190 * copy_znode - copy a dirty znode.
192 * @znode: znode to copy
194 * A dirty znode being committed may not be changed, so it is copied.
197 struct ubifs_znode *znode)
201 zn = kmemdup(znode, c->max_znode_sz, GFP_NOFS);
213 * add_idx_dirt - add dirt due to a dirty znode.
227 * replace_znode - replace old znode with new znode.
229 * @new_zn: new znode
230 * @old_zn: old znode
231 * @zbr: the branch of parent znode
233 * Replace old znode with new znode in TNC.
249 if (child->znode)
250 child->znode->parent = new_zn;
254 zbr->znode = new_zn;
263 * dirty_cow_znode - ensure a znode is not being committed.
265 * @zbr: branch of znode to check
267 * Returns dirtied znode on success or negative error code on failure.
272 struct ubifs_znode *znode = zbr->znode;
276 if (!ubifs_zn_cow(znode)) {
277 /* znode is not being committed */
278 if (!test_and_set_bit(DIRTY_ZNODE, &znode->flags)) {
286 return znode;
289 zn = copy_znode(c, znode);
313 replace_znode(c, zn, znode, zbr);
610 * get_znode - get a TNC znode that may not be loaded yet.
612 * @znode: parent znode
613 * @n: znode branch slot number
615 * This function returns the znode or a negative error code.
618 struct ubifs_znode *znode, int n)
622 zbr = &znode->zbranch[n];
623 if (zbr->znode)
624 znode = zbr->znode;
626 znode = ubifs_load_znode(c, zbr, znode, n);
627 return znode;
633 * @zn: znode is passed and returned here
634 * @n: znode branch slot number is passed and returned here
641 struct ubifs_znode *znode = *zn;
645 if (nn < znode->child_cnt) {
652 zp = znode->parent;
655 nn = znode->iip + 1;
656 znode = zp;
657 if (nn < znode->child_cnt) {
658 znode = get_znode(c, znode, nn);
659 if (IS_ERR(znode))
660 return PTR_ERR(znode);
661 while (znode->level != 0) {
662 znode = get_znode(c, znode, 0);
663 if (IS_ERR(znode))
664 return PTR_ERR(znode);
670 *zn = znode;
678 * @zn: znode is returned here
679 * @n: znode branch slot number is passed and returned here
686 struct ubifs_znode *znode = *zn;
696 zp = znode->parent;
699 nn = znode->iip - 1;
700 znode = zp;
702 znode = get_znode(c, znode, nn);
703 if (IS_ERR(znode))
704 return PTR_ERR(znode);
705 while (znode->level != 0) {
706 nn = znode->child_cnt - 1;
707 znode = get_znode(c, znode, nn);
708 if (IS_ERR(znode))
709 return PTR_ERR(znode);
711 nn = znode->child_cnt - 1;
715 *zn = znode;
724 * @zn: znode is returned here
762 * like to insert, but inserting in this znode
767 * znode zp
772 * znode za | | znode zb
777 * The lookup finds Key2 in znode zb. Lets say
781 * znode za at slot n = 1. But that is invalid
783 * be inserted into znode zb.
814 struct ubifs_znode *znode = *zn;
818 err = tnc_next(c, &znode, &nn);
823 if (keys_cmp(c, &znode->zbranch[nn].key, key))
825 err = matches_name(c, &znode->zbranch[nn], nm);
830 *zn = znode;
906 * @zn: znode is returned here
930 struct ubifs_znode *o_znode = NULL, *znode = *zn;
933 cmp = fallible_matches_name(c, &znode->zbranch[nn], nm);
939 o_znode = znode;
998 *zn = znode;
1001 err = tnc_next(c, &znode, &nn);
1006 if (keys_cmp(c, &znode->zbranch[nn].key, key))
1008 err = fallible_matches_name(c, &znode->zbranch[nn], nm);
1013 *zn = znode;
1018 o_znode = znode;
1056 * @zn: znode is passed and returned here
1074 struct ubifs_znode *znode;
1077 znode = *zn;
1079 if (matches_position(&znode->zbranch[nn], lnum, offs))
1084 err = tnc_prev(c, &znode, &nn);
1089 if (keys_cmp(c, &znode->zbranch[nn].key, key))
1091 if (matches_position(&znode->zbranch[nn], lnum, offs)) {
1092 *zn = znode;
1099 znode = *zn;
1102 err = tnc_next(c, &znode, &nn);
1107 if (keys_cmp(c, &znode->zbranch[nn].key, key))
1109 *zn = znode;
1111 if (matches_position(&znode->zbranch[nn], lnum, offs))
1117 * dirty_cow_bottom_up - dirty a znode and its ancestors.
1119 * @znode: znode to dirty
1121 * If we do not have a unique key that resides in a znode, then we cannot
1122 * dirty that znode from the top down (i.e. by using lookup_level0_dirty)
1127 struct ubifs_znode *znode)
1132 ubifs_assert(c, c->zroot.znode);
1133 ubifs_assert(c, znode);
1134 if (c->zroot.znode->level > BOTTOM_UP_HEIGHT) {
1136 c->bottom_up_buf = kmalloc_array(c->zroot.znode->level,
1143 if (c->zroot.znode->level) {
1148 zp = znode->parent;
1151 n = znode->iip;
1152 ubifs_assert(c, p < c->zroot.znode->level);
1154 if (!zp->cnext && ubifs_zn_dirty(znode))
1156 znode = zp;
1164 zp = znode->parent;
1169 znode = dirty_cow_znode(c, zbr);
1171 ubifs_assert(c, znode == c->zroot.znode);
1172 znode = dirty_cow_znode(c, &c->zroot);
1174 if (IS_ERR(znode) || !p)
1177 ubifs_assert(c, path[p - 1] < znode->child_cnt);
1178 znode = znode->zbranch[path[p - 1]].znode;
1181 return znode;
1185 * ubifs_lookup_level0 - search for zero-level znode.
1188 * @zn: znode is returned here
1189 * @n: znode branch slot number is returned here
1191 * This function looks up the TNC tree and search for zero-level znode which
1192 * refers key @key. The found zero-level znode is returned in @zn. There are 3
1194 * o exact match, i.e. the found zero-level znode contains key @key, then %1
1196 * o not exact match, which means that zero-level znode does not contain
1210 struct ubifs_znode *znode;
1216 znode = c->zroot.znode;
1217 if (unlikely(!znode)) {
1218 znode = ubifs_load_znode(c, &c->zroot, NULL, 0);
1219 if (IS_ERR(znode))
1220 return PTR_ERR(znode);
1223 znode->time = time;
1228 exact = ubifs_search_zbranch(c, znode, key, n);
1230 if (znode->level == 0)
1235 zbr = &znode->zbranch[*n];
1237 if (zbr->znode) {
1238 znode->time = time;
1239 znode = zbr->znode;
1243 /* znode is not in TNC cache, load it from the media */
1244 znode = ubifs_load_znode(c, zbr, znode, *n);
1245 if (IS_ERR(znode))
1246 return PTR_ERR(znode);
1249 *zn = znode;
1251 dbg_tnc("found %d, lvl %d, n %d", exact, znode->level, *n);
1279 * children of current znode. For example, this happens if we split a
1280 * znode like this: | 3 | 5 | 5 | 6 | 7 |, which results in something
1291 * if we changed the leftmost key of the parent znode, the garbage
1298 err = tnc_prev(c, &znode, n);
1300 dbg_tnc("found 0, lvl %d, n -1", znode->level);
1306 if (keys_cmp(c, key, &znode->zbranch[*n].key)) {
1307 dbg_tnc("found 0, lvl %d, n -1", znode->level);
1312 dbg_tnc("found 1, lvl %d, n %d", znode->level, *n);
1313 *zn = znode;
1318 * lookup_level0_dirty - search for zero-level znode dirtying.
1321 * @zn: znode is returned here
1322 * @n: znode branch slot number is returned here
1324 * This function looks up the TNC tree and search for zero-level znode which
1325 * refers key @key. The found zero-level znode is returned in @zn. There are 3
1327 * o exact match, i.e. the found zero-level znode contains key @key, then %1
1329 * o not exact match, which means that zero-level znode does not contain @key
1336 * znode are marked as dirty.
1346 struct ubifs_znode *znode;
1351 znode = c->zroot.znode;
1352 if (unlikely(!znode)) {
1353 znode = ubifs_load_znode(c, &c->zroot, NULL, 0);
1354 if (IS_ERR(znode))
1355 return PTR_ERR(znode);
1358 znode = dirty_cow_znode(c, &c->zroot);
1359 if (IS_ERR(znode))
1360 return PTR_ERR(znode);
1362 znode->time = time;
1367 exact = ubifs_search_zbranch(c, znode, key, n);
1369 if (znode->level == 0)
1374 zbr = &znode->zbranch[*n];
1376 if (zbr->znode) {
1377 znode->time = time;
1378 znode = dirty_cow_znode(c, zbr);
1379 if (IS_ERR(znode))
1380 return PTR_ERR(znode);
1384 /* znode is not in TNC cache, load it from the media */
1385 znode = ubifs_load_znode(c, zbr, znode, *n);
1386 if (IS_ERR(znode))
1387 return PTR_ERR(znode);
1388 znode = dirty_cow_znode(c, zbr);
1389 if (IS_ERR(znode))
1390 return PTR_ERR(znode);
1393 *zn = znode;
1395 dbg_tnc("found %d, lvl %d, n %d", exact, znode->level, *n);
1403 err = tnc_prev(c, &znode, n);
1406 dbg_tnc("found 0, lvl %d, n -1", znode->level);
1411 if (keys_cmp(c, key, &znode->zbranch[*n].key)) {
1413 dbg_tnc("found 0, lvl %d, n -1", znode->level);
1417 if (znode->cnext || !ubifs_zn_dirty(znode)) {
1418 znode = dirty_cow_bottom_up(c, znode);
1419 if (IS_ERR(znode))
1420 return PTR_ERR(znode);
1423 dbg_tnc("found 1, lvl %d, n %d", znode->level, *n);
1424 *zn = znode;
1481 struct ubifs_znode *znode;
1486 found = ubifs_lookup_level0(c, key, &znode, &n);
1494 zt = &znode->zbranch[n];
1512 zbr = znode->zbranch[n];
1556 struct ubifs_znode *znode;
1564 err = ubifs_lookup_level0(c, &bu->key, &znode, &n);
1569 len = znode->zbranch[n].len;
1576 bu->zbranch[bu->cnt++] = znode->zbranch[n];
1578 lnum = znode->zbranch[n].lnum;
1579 offs = ALIGN(znode->zbranch[n].offs + len, 8);
1587 err = tnc_next(c, &znode, &n);
1590 zbr = &znode->zbranch[n];
1849 struct ubifs_znode *znode;
1853 found = ubifs_lookup_level0(c, key, &znode, &n);
1864 err = resolve_collision(c, key, &znode, &n, nm);
1865 dbg_tnc("rc returned %d, znode %p, n %d", err, znode, n);
1873 err = tnc_read_hashed_node(c, &znode->zbranch[n], node);
1924 struct ubifs_znode *znode = *zn;
1929 err = tnc_next(c, &znode, n);
1935 zbr = &znode->zbranch[*n];
1949 *zn = znode;
1953 err = tnc_next(c, &znode, n);
1963 struct ubifs_znode *znode;
1971 err = ubifs_lookup_level0(c, &start_key, &znode, &n);
1975 err = search_dh_cookie(c, key, dent, cookie, &znode, &n, err);
2026 * @znode: znode to correct parent znodes for
2033 struct ubifs_znode *znode)
2037 ubifs_assert(c, znode->parent);
2038 ubifs_assert(c, znode->iip == 0);
2040 key = &znode->zbranch[0].key;
2041 key1 = &znode->parent->zbranch[0].key;
2045 znode = znode->parent;
2046 znode->alt = 1;
2047 if (!znode->parent || znode->iip)
2049 key1 = &znode->parent->zbranch[0].key;
2054 * insert_zbranch - insert a zbranch into a znode.
2056 * @znode: znode into which to insert
2061 * znode's array of zbranches and keeps zbranches consolidated, so when a new
2062 * zbranch has to be inserted to the @znode->zbranches[]' array at the @n-th
2065 static void insert_zbranch(struct ubifs_info *c, struct ubifs_znode *znode,
2070 ubifs_assert(c, ubifs_zn_dirty(znode));
2072 if (znode->level) {
2073 for (i = znode->child_cnt; i > n; i--) {
2074 znode->zbranch[i] = znode->zbranch[i - 1];
2075 if (znode->zbranch[i].znode)
2076 znode->zbranch[i].znode->iip = i;
2078 if (zbr->znode)
2079 zbr->znode->iip = n;
2081 for (i = znode->child_cnt; i > n; i--)
2082 znode->zbranch[i] = znode->zbranch[i - 1];
2084 znode->zbranch[n] = *zbr;
2085 znode->child_cnt += 1;
2089 * this znode may have changed. If this znode is subsequently split
2092 * happens, then it will no longer be possible to find this znode in the
2102 znode->alt = 1;
2108 * @znode: znode to insert into
2112 * This function inserts a new node described by @zbr into znode @znode. If
2113 * znode does not have a free slot for new zbranch, it is split. Parent znodes
2117 static int tnc_insert(struct ubifs_info *c, struct ubifs_znode *znode,
2128 zp = znode->parent;
2129 if (znode->child_cnt < c->fanout) {
2131 dbg_tnck(key, "inserted at %d level %d, key ", n, znode->level);
2133 insert_zbranch(c, znode, zbr, n);
2136 if (n == 0 && zp && znode->iip == 0)
2137 correct_parent_keys(c, znode);
2143 * Unfortunately, @znode does not have more empty slots and we have to
2146 dbg_tnck(key, "splitting level %d, key ", znode->level);
2148 if (znode->alt)
2150 * We can no longer be sure of finding this znode by key, so we
2153 ins_clr_old_idx_znode(c, znode);
2159 zn->level = znode->level;
2162 if (znode->level == 0 && key_type(c, key) == UBIFS_DATA_KEY) {
2165 key1 = &znode->zbranch[n - 1].key;
2176 key1 = &znode->zbranch[0].key;
2179 key1 = &znode->zbranch[n].key;
2184 zi = znode;
2205 /* Insert into existing znode */
2206 zi = znode;
2210 /* Insert into new znode */
2215 zbr->znode->parent = zn;
2224 znode->child_cnt = keep;
2230 zn->zbranch[i] = znode->zbranch[keep + i];
2233 if (zn->zbranch[i].znode) {
2234 zn->zbranch[i].znode->parent = zn;
2235 zn->zbranch[i].znode->iip = i;
2244 /* Insert new znode (produced by spitting) into the parent */
2246 if (n == 0 && zi == znode && znode->iip == 0)
2247 correct_parent_keys(c, znode);
2250 n = znode->iip + 1;
2254 zbr->znode = zn;
2258 znode = zp;
2263 /* We have to split root znode */
2264 dbg_tnc("creating new zroot at level %d", znode->level + 1);
2271 zi->level = znode->level + 1;
2276 zi->zbranch[0].key = znode->zbranch[0].key;
2277 zi->zbranch[0].znode = znode;
2282 zi->zbranch[1].znode = zn;
2287 c->zroot.znode = zi;
2291 znode->parent = zi;
2292 znode->iip = 0;
2314 struct ubifs_znode *znode;
2318 found = lookup_level0_dirty(c, key, &znode, &n);
2322 zbr.znode = NULL;
2328 err = tnc_insert(c, znode, &zbr, n + 1);
2330 struct ubifs_zbranch *zbr = &znode->zbranch[n];
2365 struct ubifs_znode *znode;
2370 found = lookup_level0_dirty(c, key, &znode, &n);
2377 struct ubifs_zbranch *zbr = &znode->zbranch[n];
2390 found = resolve_collision_directly(c, key, &znode, &n,
2392 dbg_tnc("rc returned %d, znode %p, n %d, LEB %d:%d",
2393 found, znode, n, old_lnum, old_offs);
2400 /* Ensure the znode is dirtied */
2401 if (znode->cnext || !ubifs_zn_dirty(znode)) {
2402 znode = dirty_cow_bottom_up(c, znode);
2403 if (IS_ERR(znode)) {
2404 err = PTR_ERR(znode);
2408 zbr = &znode->zbranch[n];
2450 struct ubifs_znode *znode;
2454 found = lookup_level0_dirty(c, key, &znode, &n);
2462 found = fallible_resolve_collision(c, key, &znode, &n,
2465 found = resolve_collision(c, key, &znode, &n, nm);
2466 dbg_tnc("rc returned %d, znode %p, n %d", found, znode, n);
2472 /* Ensure the znode is dirtied */
2473 if (znode->cnext || !ubifs_zn_dirty(znode)) {
2474 znode = dirty_cow_bottom_up(c, znode);
2475 if (IS_ERR(znode)) {
2476 err = PTR_ERR(znode);
2482 struct ubifs_zbranch *zbr = &znode->zbranch[n];
2497 zbr.znode = NULL;
2503 err = tnc_insert(c, znode, &zbr, n + 1);
2531 * tnc_delete - delete a znode form TNC.
2533 * @znode: znode to delete from
2536 * This function deletes a leaf node from @n-th slot of @znode. Returns zero in
2539 static int tnc_delete(struct ubifs_info *c, struct ubifs_znode *znode, int n)
2546 ubifs_assert(c, znode->level == 0);
2548 dbg_tnck(&znode->zbranch[n].key, "deleting key ");
2550 zbr = &znode->zbranch[n];
2555 ubifs_dump_znode(c, znode);
2560 for (i = n; i < znode->child_cnt - 1; i++)
2561 znode->zbranch[i] = znode->zbranch[i + 1];
2562 znode->child_cnt -= 1;
2564 if (znode->child_cnt > 0)
2568 * This was the last zbranch, we have to delete this znode from the
2573 ubifs_assert(c, !ubifs_zn_obsolete(znode));
2574 ubifs_assert(c, ubifs_zn_dirty(znode));
2576 zp = znode->parent;
2577 n = znode->iip;
2581 err = insert_old_idx_znode(c, znode);
2585 if (znode->cnext) {
2586 __set_bit(OBSOLETE_ZNODE, &znode->flags);
2590 kfree(znode);
2591 znode = zp;
2592 } while (znode->child_cnt == 1); /* while removing last child */
2594 /* Remove from znode, entry n - 1 */
2595 znode->child_cnt -= 1;
2596 ubifs_assert(c, znode->level != 0);
2597 for (i = n; i < znode->child_cnt; i++) {
2598 znode->zbranch[i] = znode->zbranch[i + 1];
2599 if (znode->zbranch[i].znode)
2600 znode->zbranch[i].znode->iip = i;
2607 if (!znode->parent) {
2608 while (znode->child_cnt == 1 && znode->level != 0) {
2609 zp = znode;
2610 zbr = &znode->zbranch[0];
2611 znode = get_znode(c, znode, 0);
2612 if (IS_ERR(znode))
2613 return PTR_ERR(znode);
2614 znode = dirty_cow_znode(c, zbr);
2615 if (IS_ERR(znode))
2616 return PTR_ERR(znode);
2617 znode->parent = NULL;
2618 znode->iip = 0;
2628 c->zroot.znode = znode;
2655 struct ubifs_znode *znode;
2659 found = lookup_level0_dirty(c, key, &znode, &n);
2665 err = tnc_delete(c, znode, n);
2686 struct ubifs_znode *znode;
2690 err = lookup_level0_dirty(c, key, &znode, &n);
2696 err = fallible_resolve_collision(c, key, &znode, &n,
2699 err = resolve_collision(c, key, &znode, &n, nm);
2700 dbg_tnc("rc returned %d, znode %p, n %d", err, znode, n);
2704 /* Ensure the znode is dirtied */
2705 if (znode->cnext || !ubifs_zn_dirty(znode)) {
2706 znode = dirty_cow_bottom_up(c, znode);
2707 if (IS_ERR(znode)) {
2708 err = PTR_ERR(znode);
2712 err = tnc_delete(c, znode, n);
2735 struct ubifs_znode *znode;
2743 err = lookup_level0_dirty(c, key, &znode, &n);
2747 zbr = &znode->zbranch[n];
2764 err = ubifs_lookup_level0(c, &start_key, &znode, &n);
2768 err = search_dh_cookie(c, key, dent, cookie, &znode, &n, err);
2773 if (znode->cnext || !ubifs_zn_dirty(znode)) {
2774 znode = dirty_cow_bottom_up(c, znode);
2775 if (IS_ERR(znode)) {
2776 err = PTR_ERR(znode);
2780 err = tnc_delete(c, znode, n);
2824 struct ubifs_znode *znode;
2829 /* Find first level 0 znode that contains keys to remove */
2830 err = ubifs_lookup_level0(c, from_key, &znode, &n);
2837 err = tnc_next(c, &znode, &n);
2844 key = &znode->zbranch[n].key;
2851 /* Ensure the znode is dirtied */
2852 if (znode->cnext || !ubifs_zn_dirty(znode)) {
2853 znode = dirty_cow_bottom_up(c, znode);
2854 if (IS_ERR(znode)) {
2855 err = PTR_ERR(znode);
2861 for (i = n + 1, k = 0; i < znode->child_cnt; i++, k++) {
2862 key = &znode->zbranch[i].key;
2865 lnc_free(&znode->zbranch[i]);
2866 err = ubifs_add_dirt(c, znode->zbranch[i].lnum,
2867 znode->zbranch[i].len);
2869 ubifs_dump_znode(c, znode);
2875 for (i = n + 1 + k; i < znode->child_cnt; i++)
2876 znode->zbranch[i - k] = znode->zbranch[i];
2877 znode->child_cnt -= k;
2881 err = tnc_delete(c, znode, n);
2992 struct ubifs_znode *znode;
3001 err = ubifs_lookup_level0(c, key, &znode, &n);
3009 err = fallible_resolve_collision(c, key, &znode, &n,
3012 err = resolve_collision(c, key, &znode, &n, nm);
3013 dbg_tnc("rc returned %d, znode %p, n %d",
3014 err, znode, n);
3020 err = tnc_next(c, &znode, &n);
3032 * tree and @znode/@n variables contain the closest
3035 err = tnc_next(c, &znode, &n);
3041 zbr = &znode->zbranch[n];
3088 struct ubifs_znode *znode = cnext;
3091 if (ubifs_zn_obsolete(znode))
3092 kfree(znode);
3093 else if (!ubifs_zn_cow(znode)) {
3095 * Don't forget to update clean znode count after
3097 * count while closing tnc. Non-obsolete znode could
3100 * for each dirty znode before committing, and it is
3101 * cleared as long as the znode become clean, so we
3102 * can statistic clean znode count according to this
3118 if (c->zroot.znode) {
3122 freed = ubifs_destroy_tnc_subtree(c, c->zroot.znode);
3132 * left_znode - get the znode to the left.
3134 * @znode: znode
3136 * This function returns a pointer to the znode to the left of @znode or NULL if
3140 struct ubifs_znode *znode)
3142 int level = znode->level;
3145 int n = znode->iip - 1;
3148 znode = znode->parent;
3149 if (!znode)
3153 znode = get_znode(c, znode, n);
3154 if (IS_ERR(znode))
3155 return znode;
3156 while (znode->level != level) {
3157 n = znode->child_cnt - 1;
3158 znode = get_znode(c, znode, n);
3159 if (IS_ERR(znode))
3160 return znode;
3165 return znode;
3169 * right_znode - get the znode to the right.
3171 * @znode: znode
3173 * This function returns a pointer to the znode to the right of @znode or NULL
3177 struct ubifs_znode *znode)
3179 int level = znode->level;
3182 int n = znode->iip + 1;
3185 znode = znode->parent;
3186 if (!znode)
3188 if (n < znode->child_cnt) {
3190 znode = get_znode(c, znode, n);
3191 if (IS_ERR(znode))
3192 return znode;
3193 while (znode->level != level) {
3194 znode = get_znode(c, znode, 0);
3195 if (IS_ERR(znode))
3196 return znode;
3201 return znode;
3219 * dirty znode which still refers the same @lnum:@offs. This function is clever
3222 * Note, if a znode was deleted or changed too much, then this function will
3226 * This function returns a pointer to the znode found or %NULL if it is not
3233 struct ubifs_znode *znode, *zn;
3245 /* Get the root znode */
3246 znode = c->zroot.znode;
3247 if (!znode) {
3248 znode = ubifs_load_znode(c, &c->zroot, NULL, 0);
3249 if (IS_ERR(znode))
3250 return znode;
3254 return znode;
3256 if (level >= znode->level)
3259 ubifs_search_zbranch(c, znode, key, &n);
3262 * We reached a znode where the leftmost key is greater
3269 znode = left_znode(c, znode);
3270 if (!znode)
3272 if (IS_ERR(znode))
3273 return znode;
3274 ubifs_search_zbranch(c, znode, key, &n);
3277 if (znode->level == level + 1)
3279 znode = get_znode(c, znode, n);
3280 if (IS_ERR(znode))
3281 return znode;
3284 if (znode->zbranch[n].lnum == lnum && znode->zbranch[n].offs == offs)
3285 return get_znode(c, znode, n);
3293 zn = znode;
3301 znode = left_znode(c, znode);
3302 if (!znode)
3304 if (IS_ERR(znode))
3305 return znode;
3306 n = znode->child_cnt - 1;
3309 if (znode->zbranch[n].lnum == lnum &&
3310 znode->zbranch[n].offs == offs)
3311 return get_znode(c, znode, n);
3313 if (keys_cmp(c, &znode->zbranch[n].key, key) < 0)
3317 znode = zn;
3322 if (++n >= znode->child_cnt) {
3323 znode = right_znode(c, znode);
3324 if (!znode)
3326 if (IS_ERR(znode))
3327 return znode;
3331 if (znode->zbranch[n].lnum == lnum &&
3332 znode->zbranch[n].offs == offs)
3333 return get_znode(c, znode, n);
3335 if (keys_cmp(c, &znode->zbranch[n].key, key) > 0)
3350 * if the index node is referred to in the TNC and the corresponding znode is
3352 * znode is clean, and a negative error code in case of failure.
3361 struct ubifs_znode *znode;
3363 znode = lookup_znode(c, key, level, lnum, offs);
3364 if (!znode)
3366 if (IS_ERR(znode))
3367 return PTR_ERR(znode);
3369 return ubifs_zn_dirty(znode) ? 1 : 2;
3389 struct ubifs_znode *znode, *zn;
3393 found = ubifs_lookup_level0(c, key, &znode, &n);
3398 zbr = &znode->zbranch[n];
3407 zn = znode;
3411 err = tnc_prev(c, &znode, &n);
3416 if (keys_cmp(c, key, &znode->zbranch[n].key))
3418 zbr = &znode->zbranch[n];
3423 znode = zn;
3426 err = tnc_next(c, &znode, &n);
3432 if (keys_cmp(c, key, &znode->zbranch[n].key))
3434 zbr = &znode->zbranch[n];
3453 * the corresponding znode is clean or has not been loaded.
3498 struct ubifs_znode *znode;
3502 znode = lookup_znode(c, key, level, lnum, offs);
3503 if (!znode)
3505 if (IS_ERR(znode)) {
3506 err = PTR_ERR(znode);
3509 znode = dirty_cow_bottom_up(c, znode);
3510 if (IS_ERR(znode)) {
3511 err = PTR_ERR(znode);
3536 struct ubifs_znode *znode;
3549 err = ubifs_lookup_level0(c, &from_key, &znode, &n);
3558 err = tnc_next(c, &znode, &n);
3567 key = &znode->zbranch[n].key;