Lines Matching refs:pnode
335 * ubifs_pack_pnode - pack all the bit fields of a pnode.
338 * @pnode: pnode to pack
341 struct ubifs_pnode *pnode)
349 pack_bits(c, &addr, &pos, pnode->num, c->pcnt_bits);
351 pack_bits(c, &addr, &pos, pnode->lprops[i].free >> 3,
353 pack_bits(c, &addr, &pos, pnode->lprops[i].dirty >> 3,
355 if (pnode->lprops[i].flags & LPROPS_INDEX)
503 * @pnode: pnode for which to add dirt
505 static void add_pnode_dirt(struct ubifs_info *c, struct ubifs_pnode *pnode)
507 ubifs_add_lpt_dirt(c, pnode->parent->nbranch[pnode->iip].lnum,
562 * calc_pnode_num_from_parent - calculate pnode number.
567 * The pnode number is a number that uniquely identifies a pnode and can be used
568 * easily to traverse the tree from the root to that pnode.
570 * This function calculates and returns the pnode number based on the parent's
604 struct ubifs_pnode *pnode = NULL;
628 pnode = kzalloc(sizeof(struct ubifs_pnode), GFP_KERNEL);
633 if (!pnode || !nnode || !buf || !ltab || !lsave) {
655 * The first pnode contains the LEB properties for the LEBs that contain
660 pnode->lprops[0].free = c->leb_size - iopos;
661 pnode->lprops[0].dirty = iopos - node_sz;
662 pnode->lprops[0].flags = LPROPS_INDEX;
666 pnode->lprops[1].free = c->leb_size - iopos;
667 pnode->lprops[1].dirty = iopos - node_sz;
670 pnode->lprops[i].free = c->leb_size;
672 /* Add first pnode */
673 ubifs_pack_pnode(c, p, pnode);
680 pnode->num += 1;
682 /* Reset pnode values for remaining pnodes */
683 pnode->lprops[0].free = c->leb_size;
684 pnode->lprops[0].dirty = 0;
685 pnode->lprops[0].flags = 0;
687 pnode->lprops[1].free = c->leb_size;
688 pnode->lprops[1].dirty = 0;
711 ubifs_pack_pnode(c, p, pnode);
720 * which means the pnode number can be used easily to traverse
721 * down the tree to the corresponding pnode.
723 pnode->num += 1;
867 kfree(pnode);
872 * update_cats - add LEB properties of a pnode to LEB category lists and heaps.
874 * @pnode: pnode
876 * When a pnode is loaded into memory, the LEB properties it contains are added,
879 static void update_cats(struct ubifs_info *c, struct ubifs_pnode *pnode)
884 int cat = pnode->lprops[i].flags & LPROPS_CAT_MASK;
885 int lnum = pnode->lprops[i].lnum;
889 ubifs_add_to_cat(c, &pnode->lprops[i], cat);
894 * replace_cats - add LEB properties of a pnode to LEB category lists and heaps.
896 * @old_pnode: pnode copied
897 * @new_pnode: pnode copy
899 * During commit it is sometimes necessary to copy a pnode
967 * unpack_pnode - unpack a pnode.
969 * @buf: buffer containing packed pnode to unpack
970 * @pnode: pnode structure to fill
975 struct ubifs_pnode *pnode)
984 pnode->num = ubifs_unpack_bits(c, &addr, &pos, c->pcnt_bits);
986 struct ubifs_lprops * const lprops = &pnode->lprops[i];
1140 * validate_pnode - validate a pnode.
1142 * @pnode: pnode to validate
1148 static int validate_pnode(const struct ubifs_info *c, struct ubifs_pnode *pnode,
1156 if (pnode->num != num)
1160 int free = pnode->lprops[i].free;
1161 int dirty = pnode->lprops[i].dirty;
1175 * set_pnode_lnum - set LEB numbers on a pnode.
1177 * @pnode: pnode to update
1180 * based on the pnode number.
1183 struct ubifs_pnode *pnode)
1187 lnum = (pnode->num << UBIFS_LPT_FANOUT_SHIFT) + c->main_first;
1191 pnode->lprops[i].lnum = lnum++;
1264 * read_pnode - read a pnode from flash and link it to the tree in memory.
1274 struct ubifs_pnode *pnode = NULL;
1281 pnode = kzalloc(sizeof(struct ubifs_pnode), GFP_NOFS);
1282 if (!pnode)
1287 * This pnode was not written which just means that the LEB
1288 * properties in it describe empty LEBs. We make the pnode as
1294 pnode->num = calc_pnode_num_from_parent(c, parent, iip);
1296 struct ubifs_lprops * const lprops = &pnode->lprops[i];
1305 err = unpack_pnode(c, buf, pnode);
1309 err = validate_pnode(c, pnode, parent, iip);
1313 pnode->num = calc_pnode_num_from_parent(c, parent, iip);
1314 branch->pnode = pnode;
1315 pnode->parent = parent;
1316 pnode->iip = iip;
1317 set_pnode_lnum(c, pnode);
1322 ubifs_err(c, "error %d reading pnode at %d:%d", err, lnum, offs);
1323 ubifs_dump_pnode(c, pnode, parent, iip);
1326 kfree(pnode);
1422 * ubifs_get_pnode - get a pnode.
1427 * This function returns a pointer to the pnode on success or a negative error
1434 struct ubifs_pnode *pnode;
1438 pnode = branch->pnode;
1439 if (pnode)
1440 return pnode;
1444 update_cats(c, branch->pnode);
1445 return branch->pnode;
1449 * ubifs_pnode_lookup - lookup a pnode in the LPT.
1451 * @i: pnode number (0 to (main_lebs - 1) / UBIFS_LPT_FANOUT)
1453 * This function returns a pointer to the pnode on success or a negative
1491 struct ubifs_pnode *pnode;
1494 pnode = ubifs_pnode_lookup(c, i >> UBIFS_LPT_FANOUT_SHIFT);
1495 if (IS_ERR(pnode))
1496 return ERR_CAST(pnode);
1499 pnode->lprops[iip].free, pnode->lprops[iip].dirty,
1500 pnode->lprops[iip].flags);
1501 return &pnode->lprops[iip];
1556 * dirty_cow_pnode - ensure a pnode is not being committed.
1558 * @pnode: pnode to check
1560 * Returns dirtied pnode on success or negative error code on failure.
1563 struct ubifs_pnode *pnode)
1567 if (!test_bit(COW_CNODE, &pnode->flags)) {
1568 /* pnode is not being committed */
1569 if (!test_and_set_bit(DIRTY_CNODE, &pnode->flags)) {
1571 add_pnode_dirt(c, pnode);
1573 return pnode;
1576 /* pnode is being committed, so copy it */
1577 p = kmemdup(pnode, sizeof(struct ubifs_pnode), GFP_NOFS);
1584 replace_cats(c, pnode, p);
1586 ubifs_assert(c, !test_bit(OBSOLETE_CNODE, &pnode->flags));
1587 __set_bit(OBSOLETE_CNODE, &pnode->flags);
1590 add_pnode_dirt(c, pnode);
1591 pnode->parent->nbranch[p->iip].pnode = p;
1607 struct ubifs_pnode *pnode;
1631 pnode = ubifs_get_pnode(c, nnode, iip);
1632 if (IS_ERR(pnode))
1633 return ERR_CAST(pnode);
1634 pnode = dirty_cow_pnode(c, pnode);
1635 if (IS_ERR(pnode))
1636 return ERR_CAST(pnode);
1639 pnode->lprops[iip].free, pnode->lprops[iip].dirty,
1640 pnode->lprops[iip].flags);
1641 ubifs_assert(c, test_bit(DIRTY_CNODE, &pnode->flags));
1642 return &pnode->lprops[iip];
1709 struct ubifs_pnode *pnode;
1714 pnode = ubifs_get_pnode(c, nn, i);
1715 if (IS_ERR(pnode)) {
1716 err = PTR_ERR(pnode);
1720 ubifs_pack_pnode(c, buf, pnode);
1918 * @pnode: where to keep a pnode
1923 * @ptr.pnode: ditto for pnode
1929 struct ubifs_pnode pnode;
1935 struct ubifs_pnode *pnode;
2000 * scan_get_pnode - for the scan, get a pnode from either the tree or flash.
2002 * @path: where to put the pnode
2003 * @parent: parent of the pnode
2004 * @iip: index in parent of the pnode
2006 * This function returns a pointer to the pnode on success or a negative error
2014 struct ubifs_pnode *pnode;
2019 pnode = branch->pnode;
2020 if (pnode) {
2022 path->ptr.pnode = pnode;
2023 return pnode;
2025 pnode = &path->pnode;
2027 path->ptr.pnode = pnode;
2028 memset(pnode, 0, sizeof(struct ubifs_pnode));
2031 * This pnode was not written which just means that the LEB
2032 * properties in it describe empty LEBs. We make the pnode as
2038 pnode->num = calc_pnode_num_from_parent(c, parent, iip);
2040 struct ubifs_lprops * const lprops = &pnode->lprops[i];
2053 err = unpack_pnode(c, buf, pnode);
2057 err = validate_pnode(c, pnode, parent, iip);
2061 pnode->num = calc_pnode_num_from_parent(c, parent, iip);
2062 pnode->parent = parent;
2063 pnode->iip = iip;
2064 set_pnode_lnum(c, pnode);
2065 return pnode;
2083 struct ubifs_pnode *pnode;
2109 /* Descend to the pnode containing start_lnum */
2123 pnode = scan_get_pnode(c, path + h, nnode, iip);
2124 if (IS_ERR(pnode)) {
2125 err = PTR_ERR(pnode);
2132 struct ubifs_lprops *lprops = &pnode->lprops[iip];
2165 pnode = kmemdup(&path[h].pnode, sz, GFP_NOFS);
2166 if (!pnode) {
2170 parent = pnode->parent;
2171 parent->nbranch[pnode->iip].pnode = pnode;
2172 path[h].ptr.pnode = pnode;
2174 update_cats(c, pnode);
2204 /* Next lprops is in the same pnode */
2208 /* We need to get the next pnode. Go up until we can go right */
2209 iip = pnode->iip;
2220 /* Descend to the pnode */
2230 pnode = scan_get_pnode(c, path + h, nnode, iip);
2231 if (IS_ERR(pnode)) {
2232 err = PTR_ERR(pnode);
2243 * dbg_chk_pnode - check a pnode.
2245 * @pnode: pnode to check
2246 * @col: pnode column
2250 static int dbg_chk_pnode(struct ubifs_info *c, struct ubifs_pnode *pnode,
2255 if (pnode->num != col) {
2256 ubifs_err(c, "pnode num %d expected %d parent num %d iip %d",
2257 pnode->num, col, pnode->parent->num, pnode->iip);
2261 struct ubifs_lprops *lp, *lprops = &pnode->lprops[i];
2262 int lnum = (pnode->num << UBIFS_LPT_FANOUT_SHIFT) + i +
2374 * @cnode: next cnode (nnode or pnode) to check
2420 struct ubifs_pnode *pnode;
2422 /* cnode is a pnode */
2423 pnode = (struct ubifs_pnode *)cnode;
2424 err = dbg_chk_pnode(c, pnode, col);