1*83d290c5STom Rini // SPDX-License-Identifier: GPL-2.0+
29eefe2a2SStefan Roese /*
39eefe2a2SStefan Roese * This file is part of UBIFS.
49eefe2a2SStefan Roese *
59eefe2a2SStefan Roese * Copyright (C) 2006-2008 Nokia Corporation.
69eefe2a2SStefan Roese *
79eefe2a2SStefan Roese * Authors: Adrian Hunter
89eefe2a2SStefan Roese * Artem Bityutskiy (Битюцкий Артём)
99eefe2a2SStefan Roese */
109eefe2a2SStefan Roese
119eefe2a2SStefan Roese /*
129eefe2a2SStefan Roese * This file contains miscelanious TNC-related functions shared betweend
139eefe2a2SStefan Roese * different files. This file does not form any logically separate TNC
149eefe2a2SStefan Roese * sub-system. The file was created because there is a lot of TNC code and
159eefe2a2SStefan Roese * putting it all in one file would make that file too big and unreadable.
169eefe2a2SStefan Roese */
179eefe2a2SStefan Roese
18ff94bc40SHeiko Schocher #ifdef __UBOOT__
19ff94bc40SHeiko Schocher #include <linux/err.h>
20ff94bc40SHeiko Schocher #endif
219eefe2a2SStefan Roese #include "ubifs.h"
229eefe2a2SStefan Roese
239eefe2a2SStefan Roese /**
249eefe2a2SStefan Roese * ubifs_tnc_levelorder_next - next TNC tree element in levelorder traversal.
259eefe2a2SStefan Roese * @zr: root of the subtree to traverse
269eefe2a2SStefan Roese * @znode: previous znode
279eefe2a2SStefan Roese *
289eefe2a2SStefan Roese * This function implements levelorder TNC traversal. The LNC is ignored.
299eefe2a2SStefan Roese * Returns the next element or %NULL if @znode is already the last one.
309eefe2a2SStefan Roese */
ubifs_tnc_levelorder_next(struct ubifs_znode * zr,struct ubifs_znode * znode)319eefe2a2SStefan Roese struct ubifs_znode *ubifs_tnc_levelorder_next(struct ubifs_znode *zr,
329eefe2a2SStefan Roese struct ubifs_znode *znode)
339eefe2a2SStefan Roese {
349eefe2a2SStefan Roese int level, iip, level_search = 0;
359eefe2a2SStefan Roese struct ubifs_znode *zn;
369eefe2a2SStefan Roese
379eefe2a2SStefan Roese ubifs_assert(zr);
389eefe2a2SStefan Roese
399eefe2a2SStefan Roese if (unlikely(!znode))
409eefe2a2SStefan Roese return zr;
419eefe2a2SStefan Roese
429eefe2a2SStefan Roese if (unlikely(znode == zr)) {
439eefe2a2SStefan Roese if (znode->level == 0)
449eefe2a2SStefan Roese return NULL;
459eefe2a2SStefan Roese return ubifs_tnc_find_child(zr, 0);
469eefe2a2SStefan Roese }
479eefe2a2SStefan Roese
489eefe2a2SStefan Roese level = znode->level;
499eefe2a2SStefan Roese
509eefe2a2SStefan Roese iip = znode->iip;
519eefe2a2SStefan Roese while (1) {
529eefe2a2SStefan Roese ubifs_assert(znode->level <= zr->level);
539eefe2a2SStefan Roese
549eefe2a2SStefan Roese /*
559eefe2a2SStefan Roese * First walk up until there is a znode with next branch to
569eefe2a2SStefan Roese * look at.
579eefe2a2SStefan Roese */
589eefe2a2SStefan Roese while (znode->parent != zr && iip >= znode->parent->child_cnt) {
599eefe2a2SStefan Roese znode = znode->parent;
609eefe2a2SStefan Roese iip = znode->iip;
619eefe2a2SStefan Roese }
629eefe2a2SStefan Roese
639eefe2a2SStefan Roese if (unlikely(znode->parent == zr &&
649eefe2a2SStefan Roese iip >= znode->parent->child_cnt)) {
659eefe2a2SStefan Roese /* This level is done, switch to the lower one */
669eefe2a2SStefan Roese level -= 1;
679eefe2a2SStefan Roese if (level_search || level < 0)
689eefe2a2SStefan Roese /*
699eefe2a2SStefan Roese * We were already looking for znode at lower
709eefe2a2SStefan Roese * level ('level_search'). As we are here
719eefe2a2SStefan Roese * again, it just does not exist. Or all levels
729eefe2a2SStefan Roese * were finished ('level < 0').
739eefe2a2SStefan Roese */
749eefe2a2SStefan Roese return NULL;
759eefe2a2SStefan Roese
769eefe2a2SStefan Roese level_search = 1;
779eefe2a2SStefan Roese iip = -1;
789eefe2a2SStefan Roese znode = ubifs_tnc_find_child(zr, 0);
799eefe2a2SStefan Roese ubifs_assert(znode);
809eefe2a2SStefan Roese }
819eefe2a2SStefan Roese
829eefe2a2SStefan Roese /* Switch to the next index */
839eefe2a2SStefan Roese zn = ubifs_tnc_find_child(znode->parent, iip + 1);
849eefe2a2SStefan Roese if (!zn) {
859eefe2a2SStefan Roese /* No more children to look at, we have walk up */
869eefe2a2SStefan Roese iip = znode->parent->child_cnt;
879eefe2a2SStefan Roese continue;
889eefe2a2SStefan Roese }
899eefe2a2SStefan Roese
909eefe2a2SStefan Roese /* Walk back down to the level we came from ('level') */
919eefe2a2SStefan Roese while (zn->level != level) {
929eefe2a2SStefan Roese znode = zn;
939eefe2a2SStefan Roese zn = ubifs_tnc_find_child(zn, 0);
949eefe2a2SStefan Roese if (!zn) {
959eefe2a2SStefan Roese /*
969eefe2a2SStefan Roese * This path is not too deep so it does not
979eefe2a2SStefan Roese * reach 'level'. Try next path.
989eefe2a2SStefan Roese */
999eefe2a2SStefan Roese iip = znode->iip;
1009eefe2a2SStefan Roese break;
1019eefe2a2SStefan Roese }
1029eefe2a2SStefan Roese }
1039eefe2a2SStefan Roese
1049eefe2a2SStefan Roese if (zn) {
1059eefe2a2SStefan Roese ubifs_assert(zn->level >= 0);
1069eefe2a2SStefan Roese return zn;
1079eefe2a2SStefan Roese }
1089eefe2a2SStefan Roese }
1099eefe2a2SStefan Roese }
1109eefe2a2SStefan Roese
1119eefe2a2SStefan Roese /**
1129eefe2a2SStefan Roese * ubifs_search_zbranch - search znode branch.
1139eefe2a2SStefan Roese * @c: UBIFS file-system description object
1149eefe2a2SStefan Roese * @znode: znode to search in
1159eefe2a2SStefan Roese * @key: key to search for
1169eefe2a2SStefan Roese * @n: znode branch slot number is returned here
1179eefe2a2SStefan Roese *
1189eefe2a2SStefan Roese * This is a helper function which search branch with key @key in @znode using
1199eefe2a2SStefan Roese * binary search. The result of the search may be:
1209eefe2a2SStefan Roese * o exact match, then %1 is returned, and the slot number of the branch is
1219eefe2a2SStefan Roese * stored in @n;
1229eefe2a2SStefan Roese * o no exact match, then %0 is returned and the slot number of the left
1239eefe2a2SStefan Roese * closest branch is returned in @n; the slot if all keys in this znode are
1249eefe2a2SStefan Roese * greater than @key, then %-1 is returned in @n.
1259eefe2a2SStefan Roese */
ubifs_search_zbranch(const struct ubifs_info * c,const struct ubifs_znode * znode,const union ubifs_key * key,int * n)1269eefe2a2SStefan Roese int ubifs_search_zbranch(const struct ubifs_info *c,
1279eefe2a2SStefan Roese const struct ubifs_znode *znode,
1289eefe2a2SStefan Roese const union ubifs_key *key, int *n)
1299eefe2a2SStefan Roese {
1309eefe2a2SStefan Roese int beg = 0, end = znode->child_cnt, uninitialized_var(mid);
1319eefe2a2SStefan Roese int uninitialized_var(cmp);
1329eefe2a2SStefan Roese const struct ubifs_zbranch *zbr = &znode->zbranch[0];
1339eefe2a2SStefan Roese
1349eefe2a2SStefan Roese ubifs_assert(end > beg);
1359eefe2a2SStefan Roese
1369eefe2a2SStefan Roese while (end > beg) {
1379eefe2a2SStefan Roese mid = (beg + end) >> 1;
1389eefe2a2SStefan Roese cmp = keys_cmp(c, key, &zbr[mid].key);
1399eefe2a2SStefan Roese if (cmp > 0)
1409eefe2a2SStefan Roese beg = mid + 1;
1419eefe2a2SStefan Roese else if (cmp < 0)
1429eefe2a2SStefan Roese end = mid;
1439eefe2a2SStefan Roese else {
1449eefe2a2SStefan Roese *n = mid;
1459eefe2a2SStefan Roese return 1;
1469eefe2a2SStefan Roese }
1479eefe2a2SStefan Roese }
1489eefe2a2SStefan Roese
1499eefe2a2SStefan Roese *n = end - 1;
1509eefe2a2SStefan Roese
1519eefe2a2SStefan Roese /* The insert point is after *n */
1529eefe2a2SStefan Roese ubifs_assert(*n >= -1 && *n < znode->child_cnt);
1539eefe2a2SStefan Roese if (*n == -1)
1549eefe2a2SStefan Roese ubifs_assert(keys_cmp(c, key, &zbr[0].key) < 0);
1559eefe2a2SStefan Roese else
1569eefe2a2SStefan Roese ubifs_assert(keys_cmp(c, key, &zbr[*n].key) > 0);
1579eefe2a2SStefan Roese if (*n + 1 < znode->child_cnt)
1589eefe2a2SStefan Roese ubifs_assert(keys_cmp(c, key, &zbr[*n + 1].key) < 0);
1599eefe2a2SStefan Roese
1609eefe2a2SStefan Roese return 0;
1619eefe2a2SStefan Roese }
1629eefe2a2SStefan Roese
1639eefe2a2SStefan Roese /**
1649eefe2a2SStefan Roese * ubifs_tnc_postorder_first - find first znode to do postorder tree traversal.
1659eefe2a2SStefan Roese * @znode: znode to start at (root of the sub-tree to traverse)
1669eefe2a2SStefan Roese *
1679eefe2a2SStefan Roese * Find the lowest leftmost znode in a subtree of the TNC tree. The LNC is
1689eefe2a2SStefan Roese * ignored.
1699eefe2a2SStefan Roese */
ubifs_tnc_postorder_first(struct ubifs_znode * znode)1709eefe2a2SStefan Roese struct ubifs_znode *ubifs_tnc_postorder_first(struct ubifs_znode *znode)
1719eefe2a2SStefan Roese {
1729eefe2a2SStefan Roese if (unlikely(!znode))
1739eefe2a2SStefan Roese return NULL;
1749eefe2a2SStefan Roese
1759eefe2a2SStefan Roese while (znode->level > 0) {
1769eefe2a2SStefan Roese struct ubifs_znode *child;
1779eefe2a2SStefan Roese
1789eefe2a2SStefan Roese child = ubifs_tnc_find_child(znode, 0);
1799eefe2a2SStefan Roese if (!child)
1809eefe2a2SStefan Roese return znode;
1819eefe2a2SStefan Roese znode = child;
1829eefe2a2SStefan Roese }
1839eefe2a2SStefan Roese
1849eefe2a2SStefan Roese return znode;
1859eefe2a2SStefan Roese }
1869eefe2a2SStefan Roese
1879eefe2a2SStefan Roese /**
1889eefe2a2SStefan Roese * ubifs_tnc_postorder_next - next TNC tree element in postorder traversal.
1899eefe2a2SStefan Roese * @znode: previous znode
1909eefe2a2SStefan Roese *
1919eefe2a2SStefan Roese * This function implements postorder TNC traversal. The LNC is ignored.
1929eefe2a2SStefan Roese * Returns the next element or %NULL if @znode is already the last one.
1939eefe2a2SStefan Roese */
ubifs_tnc_postorder_next(struct ubifs_znode * znode)1949eefe2a2SStefan Roese struct ubifs_znode *ubifs_tnc_postorder_next(struct ubifs_znode *znode)
1959eefe2a2SStefan Roese {
1969eefe2a2SStefan Roese struct ubifs_znode *zn;
1979eefe2a2SStefan Roese
1989eefe2a2SStefan Roese ubifs_assert(znode);
1999eefe2a2SStefan Roese if (unlikely(!znode->parent))
2009eefe2a2SStefan Roese return NULL;
2019eefe2a2SStefan Roese
2029eefe2a2SStefan Roese /* Switch to the next index in the parent */
2039eefe2a2SStefan Roese zn = ubifs_tnc_find_child(znode->parent, znode->iip + 1);
2049eefe2a2SStefan Roese if (!zn)
2059eefe2a2SStefan Roese /* This is in fact the last child, return parent */
2069eefe2a2SStefan Roese return znode->parent;
2079eefe2a2SStefan Roese
2089eefe2a2SStefan Roese /* Go to the first znode in this new subtree */
2099eefe2a2SStefan Roese return ubifs_tnc_postorder_first(zn);
2109eefe2a2SStefan Roese }
2119eefe2a2SStefan Roese
2129eefe2a2SStefan Roese /**
213ff94bc40SHeiko Schocher * ubifs_destroy_tnc_subtree - destroy all znodes connected to a subtree.
214ff94bc40SHeiko Schocher * @znode: znode defining subtree to destroy
215ff94bc40SHeiko Schocher *
216ff94bc40SHeiko Schocher * This function destroys subtree of the TNC tree. Returns number of clean
217ff94bc40SHeiko Schocher * znodes in the subtree.
218ff94bc40SHeiko Schocher */
ubifs_destroy_tnc_subtree(struct ubifs_znode * znode)219ff94bc40SHeiko Schocher long ubifs_destroy_tnc_subtree(struct ubifs_znode *znode)
220ff94bc40SHeiko Schocher {
221ff94bc40SHeiko Schocher struct ubifs_znode *zn = ubifs_tnc_postorder_first(znode);
222ff94bc40SHeiko Schocher long clean_freed = 0;
223ff94bc40SHeiko Schocher int n;
224ff94bc40SHeiko Schocher
225ff94bc40SHeiko Schocher ubifs_assert(zn);
226ff94bc40SHeiko Schocher while (1) {
227ff94bc40SHeiko Schocher for (n = 0; n < zn->child_cnt; n++) {
228ff94bc40SHeiko Schocher if (!zn->zbranch[n].znode)
229ff94bc40SHeiko Schocher continue;
230ff94bc40SHeiko Schocher
231ff94bc40SHeiko Schocher if (zn->level > 0 &&
232ff94bc40SHeiko Schocher !ubifs_zn_dirty(zn->zbranch[n].znode))
233ff94bc40SHeiko Schocher clean_freed += 1;
234ff94bc40SHeiko Schocher
235ff94bc40SHeiko Schocher cond_resched();
236ff94bc40SHeiko Schocher kfree(zn->zbranch[n].znode);
237ff94bc40SHeiko Schocher }
238ff94bc40SHeiko Schocher
239ff94bc40SHeiko Schocher if (zn == znode) {
240ff94bc40SHeiko Schocher if (!ubifs_zn_dirty(zn))
241ff94bc40SHeiko Schocher clean_freed += 1;
242ff94bc40SHeiko Schocher kfree(zn);
243ff94bc40SHeiko Schocher return clean_freed;
244ff94bc40SHeiko Schocher }
245ff94bc40SHeiko Schocher
246ff94bc40SHeiko Schocher zn = ubifs_tnc_postorder_next(zn);
247ff94bc40SHeiko Schocher }
248ff94bc40SHeiko Schocher }
249ff94bc40SHeiko Schocher
250ff94bc40SHeiko Schocher /**
2519eefe2a2SStefan Roese * read_znode - read an indexing node from flash and fill znode.
2529eefe2a2SStefan Roese * @c: UBIFS file-system description object
2539eefe2a2SStefan Roese * @lnum: LEB of the indexing node to read
2549eefe2a2SStefan Roese * @offs: node offset
2559eefe2a2SStefan Roese * @len: node length
2569eefe2a2SStefan Roese * @znode: znode to read to
2579eefe2a2SStefan Roese *
2589eefe2a2SStefan Roese * This function reads an indexing node from the flash media and fills znode
2599eefe2a2SStefan Roese * with the read data. Returns zero in case of success and a negative error
2609eefe2a2SStefan Roese * code in case of failure. The read indexing node is validated and if anything
2619eefe2a2SStefan Roese * is wrong with it, this function prints complaint messages and returns
2629eefe2a2SStefan Roese * %-EINVAL.
2639eefe2a2SStefan Roese */
read_znode(struct ubifs_info * c,int lnum,int offs,int len,struct ubifs_znode * znode)2649eefe2a2SStefan Roese static int read_znode(struct ubifs_info *c, int lnum, int offs, int len,
2659eefe2a2SStefan Roese struct ubifs_znode *znode)
2669eefe2a2SStefan Roese {
2679eefe2a2SStefan Roese int i, err, type, cmp;
2689eefe2a2SStefan Roese struct ubifs_idx_node *idx;
2699eefe2a2SStefan Roese
2709eefe2a2SStefan Roese idx = kmalloc(c->max_idx_node_sz, GFP_NOFS);
2719eefe2a2SStefan Roese if (!idx)
2729eefe2a2SStefan Roese return -ENOMEM;
2739eefe2a2SStefan Roese
2749eefe2a2SStefan Roese err = ubifs_read_node(c, idx, UBIFS_IDX_NODE, len, lnum, offs);
2759eefe2a2SStefan Roese if (err < 0) {
2769eefe2a2SStefan Roese kfree(idx);
2779eefe2a2SStefan Roese return err;
2789eefe2a2SStefan Roese }
2799eefe2a2SStefan Roese
2809eefe2a2SStefan Roese znode->child_cnt = le16_to_cpu(idx->child_cnt);
2819eefe2a2SStefan Roese znode->level = le16_to_cpu(idx->level);
2829eefe2a2SStefan Roese
2839eefe2a2SStefan Roese dbg_tnc("LEB %d:%d, level %d, %d branch",
2849eefe2a2SStefan Roese lnum, offs, znode->level, znode->child_cnt);
2859eefe2a2SStefan Roese
2869eefe2a2SStefan Roese if (znode->child_cnt > c->fanout || znode->level > UBIFS_MAX_LEVELS) {
2870195a7bbSHeiko Schocher ubifs_err(c, "current fanout %d, branch count %d",
2889eefe2a2SStefan Roese c->fanout, znode->child_cnt);
2890195a7bbSHeiko Schocher ubifs_err(c, "max levels %d, znode level %d",
2909eefe2a2SStefan Roese UBIFS_MAX_LEVELS, znode->level);
2919eefe2a2SStefan Roese err = 1;
2929eefe2a2SStefan Roese goto out_dump;
2939eefe2a2SStefan Roese }
2949eefe2a2SStefan Roese
2959eefe2a2SStefan Roese for (i = 0; i < znode->child_cnt; i++) {
2969eefe2a2SStefan Roese const struct ubifs_branch *br = ubifs_idx_branch(c, idx, i);
2979eefe2a2SStefan Roese struct ubifs_zbranch *zbr = &znode->zbranch[i];
2989eefe2a2SStefan Roese
2999eefe2a2SStefan Roese key_read(c, &br->key, &zbr->key);
3009eefe2a2SStefan Roese zbr->lnum = le32_to_cpu(br->lnum);
3019eefe2a2SStefan Roese zbr->offs = le32_to_cpu(br->offs);
3029eefe2a2SStefan Roese zbr->len = le32_to_cpu(br->len);
3039eefe2a2SStefan Roese zbr->znode = NULL;
3049eefe2a2SStefan Roese
3059eefe2a2SStefan Roese /* Validate branch */
3069eefe2a2SStefan Roese
3079eefe2a2SStefan Roese if (zbr->lnum < c->main_first ||
3089eefe2a2SStefan Roese zbr->lnum >= c->leb_cnt || zbr->offs < 0 ||
3099eefe2a2SStefan Roese zbr->offs + zbr->len > c->leb_size || zbr->offs & 7) {
3100195a7bbSHeiko Schocher ubifs_err(c, "bad branch %d", i);
3119eefe2a2SStefan Roese err = 2;
3129eefe2a2SStefan Roese goto out_dump;
3139eefe2a2SStefan Roese }
3149eefe2a2SStefan Roese
3159eefe2a2SStefan Roese switch (key_type(c, &zbr->key)) {
3169eefe2a2SStefan Roese case UBIFS_INO_KEY:
3179eefe2a2SStefan Roese case UBIFS_DATA_KEY:
3189eefe2a2SStefan Roese case UBIFS_DENT_KEY:
3199eefe2a2SStefan Roese case UBIFS_XENT_KEY:
3209eefe2a2SStefan Roese break;
3219eefe2a2SStefan Roese default:
3220195a7bbSHeiko Schocher ubifs_err(c, "bad key type at slot %d: %d",
323ff94bc40SHeiko Schocher i, key_type(c, &zbr->key));
3249eefe2a2SStefan Roese err = 3;
3259eefe2a2SStefan Roese goto out_dump;
3269eefe2a2SStefan Roese }
3279eefe2a2SStefan Roese
3289eefe2a2SStefan Roese if (znode->level)
3299eefe2a2SStefan Roese continue;
3309eefe2a2SStefan Roese
3319eefe2a2SStefan Roese type = key_type(c, &zbr->key);
3329eefe2a2SStefan Roese if (c->ranges[type].max_len == 0) {
3339eefe2a2SStefan Roese if (zbr->len != c->ranges[type].len) {
3340195a7bbSHeiko Schocher ubifs_err(c, "bad target node (type %d) length (%d)",
3359eefe2a2SStefan Roese type, zbr->len);
3360195a7bbSHeiko Schocher ubifs_err(c, "have to be %d", c->ranges[type].len);
3379eefe2a2SStefan Roese err = 4;
3389eefe2a2SStefan Roese goto out_dump;
3399eefe2a2SStefan Roese }
3409eefe2a2SStefan Roese } else if (zbr->len < c->ranges[type].min_len ||
3419eefe2a2SStefan Roese zbr->len > c->ranges[type].max_len) {
3420195a7bbSHeiko Schocher ubifs_err(c, "bad target node (type %d) length (%d)",
3439eefe2a2SStefan Roese type, zbr->len);
3440195a7bbSHeiko Schocher ubifs_err(c, "have to be in range of %d-%d",
3459eefe2a2SStefan Roese c->ranges[type].min_len,
3469eefe2a2SStefan Roese c->ranges[type].max_len);
3479eefe2a2SStefan Roese err = 5;
3489eefe2a2SStefan Roese goto out_dump;
3499eefe2a2SStefan Roese }
3509eefe2a2SStefan Roese }
3519eefe2a2SStefan Roese
3529eefe2a2SStefan Roese /*
3539eefe2a2SStefan Roese * Ensure that the next key is greater or equivalent to the
3549eefe2a2SStefan Roese * previous one.
3559eefe2a2SStefan Roese */
3569eefe2a2SStefan Roese for (i = 0; i < znode->child_cnt - 1; i++) {
3579eefe2a2SStefan Roese const union ubifs_key *key1, *key2;
3589eefe2a2SStefan Roese
3599eefe2a2SStefan Roese key1 = &znode->zbranch[i].key;
3609eefe2a2SStefan Roese key2 = &znode->zbranch[i + 1].key;
3619eefe2a2SStefan Roese
3629eefe2a2SStefan Roese cmp = keys_cmp(c, key1, key2);
3639eefe2a2SStefan Roese if (cmp > 0) {
3640195a7bbSHeiko Schocher ubifs_err(c, "bad key order (keys %d and %d)", i, i + 1);
3659eefe2a2SStefan Roese err = 6;
3669eefe2a2SStefan Roese goto out_dump;
3679eefe2a2SStefan Roese } else if (cmp == 0 && !is_hash_key(c, key1)) {
3689eefe2a2SStefan Roese /* These can only be keys with colliding hash */
3690195a7bbSHeiko Schocher ubifs_err(c, "keys %d and %d are not hashed but equivalent",
3709eefe2a2SStefan Roese i, i + 1);
3719eefe2a2SStefan Roese err = 7;
3729eefe2a2SStefan Roese goto out_dump;
3739eefe2a2SStefan Roese }
3749eefe2a2SStefan Roese }
3759eefe2a2SStefan Roese
3769eefe2a2SStefan Roese kfree(idx);
3779eefe2a2SStefan Roese return 0;
3789eefe2a2SStefan Roese
3799eefe2a2SStefan Roese out_dump:
3800195a7bbSHeiko Schocher ubifs_err(c, "bad indexing node at LEB %d:%d, error %d", lnum, offs, err);
381ff94bc40SHeiko Schocher ubifs_dump_node(c, idx);
3829eefe2a2SStefan Roese kfree(idx);
3839eefe2a2SStefan Roese return -EINVAL;
3849eefe2a2SStefan Roese }
3859eefe2a2SStefan Roese
3869eefe2a2SStefan Roese /**
3879eefe2a2SStefan Roese * ubifs_load_znode - load znode to TNC cache.
3889eefe2a2SStefan Roese * @c: UBIFS file-system description object
3899eefe2a2SStefan Roese * @zbr: znode branch
3909eefe2a2SStefan Roese * @parent: znode's parent
3919eefe2a2SStefan Roese * @iip: index in parent
3929eefe2a2SStefan Roese *
3939eefe2a2SStefan Roese * This function loads znode pointed to by @zbr into the TNC cache and
3949eefe2a2SStefan Roese * returns pointer to it in case of success and a negative error code in case
3959eefe2a2SStefan Roese * of failure.
3969eefe2a2SStefan Roese */
ubifs_load_znode(struct ubifs_info * c,struct ubifs_zbranch * zbr,struct ubifs_znode * parent,int iip)3979eefe2a2SStefan Roese struct ubifs_znode *ubifs_load_znode(struct ubifs_info *c,
3989eefe2a2SStefan Roese struct ubifs_zbranch *zbr,
3999eefe2a2SStefan Roese struct ubifs_znode *parent, int iip)
4009eefe2a2SStefan Roese {
4019eefe2a2SStefan Roese int err;
4029eefe2a2SStefan Roese struct ubifs_znode *znode;
4039eefe2a2SStefan Roese
4049eefe2a2SStefan Roese ubifs_assert(!zbr->znode);
4059eefe2a2SStefan Roese /*
4069eefe2a2SStefan Roese * A slab cache is not presently used for znodes because the znode size
4079eefe2a2SStefan Roese * depends on the fanout which is stored in the superblock.
4089eefe2a2SStefan Roese */
4099eefe2a2SStefan Roese znode = kzalloc(c->max_znode_sz, GFP_NOFS);
4109eefe2a2SStefan Roese if (!znode)
4119eefe2a2SStefan Roese return ERR_PTR(-ENOMEM);
4129eefe2a2SStefan Roese
4139eefe2a2SStefan Roese err = read_znode(c, zbr->lnum, zbr->offs, zbr->len, znode);
4149eefe2a2SStefan Roese if (err)
4159eefe2a2SStefan Roese goto out;
4169eefe2a2SStefan Roese
417ff94bc40SHeiko Schocher atomic_long_inc(&c->clean_zn_cnt);
418ff94bc40SHeiko Schocher
419ff94bc40SHeiko Schocher /*
420ff94bc40SHeiko Schocher * Increment the global clean znode counter as well. It is OK that
421ff94bc40SHeiko Schocher * global and per-FS clean znode counters may be inconsistent for some
422ff94bc40SHeiko Schocher * short time (because we might be preempted at this point), the global
423ff94bc40SHeiko Schocher * one is only used in shrinker.
424ff94bc40SHeiko Schocher */
425ff94bc40SHeiko Schocher atomic_long_inc(&ubifs_clean_zn_cnt);
426ff94bc40SHeiko Schocher
4279eefe2a2SStefan Roese zbr->znode = znode;
4289eefe2a2SStefan Roese znode->parent = parent;
4299eefe2a2SStefan Roese znode->time = get_seconds();
4309eefe2a2SStefan Roese znode->iip = iip;
4319eefe2a2SStefan Roese
4329eefe2a2SStefan Roese return znode;
4339eefe2a2SStefan Roese
4349eefe2a2SStefan Roese out:
4359eefe2a2SStefan Roese kfree(znode);
4369eefe2a2SStefan Roese return ERR_PTR(err);
4379eefe2a2SStefan Roese }
4389eefe2a2SStefan Roese
4399eefe2a2SStefan Roese /**
4409eefe2a2SStefan Roese * ubifs_tnc_read_node - read a leaf node from the flash media.
4419eefe2a2SStefan Roese * @c: UBIFS file-system description object
4429eefe2a2SStefan Roese * @zbr: key and position of the node
4439eefe2a2SStefan Roese * @node: node is returned here
4449eefe2a2SStefan Roese *
4459eefe2a2SStefan Roese * This function reads a node defined by @zbr from the flash media. Returns
4469eefe2a2SStefan Roese * zero in case of success or a negative negative error code in case of
4479eefe2a2SStefan Roese * failure.
4489eefe2a2SStefan Roese */
ubifs_tnc_read_node(struct ubifs_info * c,struct ubifs_zbranch * zbr,void * node)4499eefe2a2SStefan Roese int ubifs_tnc_read_node(struct ubifs_info *c, struct ubifs_zbranch *zbr,
4509eefe2a2SStefan Roese void *node)
4519eefe2a2SStefan Roese {
4529eefe2a2SStefan Roese union ubifs_key key1, *key = &zbr->key;
4539eefe2a2SStefan Roese int err, type = key_type(c, key);
454ff94bc40SHeiko Schocher struct ubifs_wbuf *wbuf;
4559eefe2a2SStefan Roese
456ff94bc40SHeiko Schocher /*
457ff94bc40SHeiko Schocher * 'zbr' has to point to on-flash node. The node may sit in a bud and
458ff94bc40SHeiko Schocher * may even be in a write buffer, so we have to take care about this.
459ff94bc40SHeiko Schocher */
460ff94bc40SHeiko Schocher wbuf = ubifs_get_wbuf(c, zbr->lnum);
461ff94bc40SHeiko Schocher if (wbuf)
462ff94bc40SHeiko Schocher err = ubifs_read_node_wbuf(wbuf, node, type, zbr->len,
463ff94bc40SHeiko Schocher zbr->lnum, zbr->offs);
464ff94bc40SHeiko Schocher else
465ff94bc40SHeiko Schocher err = ubifs_read_node(c, node, type, zbr->len, zbr->lnum,
466ff94bc40SHeiko Schocher zbr->offs);
4679eefe2a2SStefan Roese
4689eefe2a2SStefan Roese if (err) {
469ff94bc40SHeiko Schocher dbg_tnck(key, "key ");
4709eefe2a2SStefan Roese return err;
4719eefe2a2SStefan Roese }
4729eefe2a2SStefan Roese
4739eefe2a2SStefan Roese /* Make sure the key of the read node is correct */
4749eefe2a2SStefan Roese key_read(c, node + UBIFS_KEY_OFFSET, &key1);
4759eefe2a2SStefan Roese if (!keys_eq(c, key, &key1)) {
4760195a7bbSHeiko Schocher ubifs_err(c, "bad key in node at LEB %d:%d",
4779eefe2a2SStefan Roese zbr->lnum, zbr->offs);
478ff94bc40SHeiko Schocher dbg_tnck(key, "looked for key ");
479ff94bc40SHeiko Schocher dbg_tnck(&key1, "but found node's key ");
480ff94bc40SHeiko Schocher ubifs_dump_node(c, node);
4819eefe2a2SStefan Roese return -EINVAL;
4829eefe2a2SStefan Roese }
4839eefe2a2SStefan Roese
4849eefe2a2SStefan Roese return 0;
4859eefe2a2SStefan Roese }
486