fs/ubifs/lpt_commit.c

24  * first_dirty_cnode - find first dirty cnode.
28  * This function returns the first dirty cnode or %NULL if there is not one.
55  * next_dirty_cnode - find next dirty cnode.
59  * This function returns the next dirty cnode or %NULL if there is not one.
83  * get_cnodes_to_commit - create list of dirty cnodes to commit.
127  * @dirty: amount of dirty space to add
129 static void upd_ltab(struct ubifs_info *c, int lnum, int free, int dirty)
131 	dbg_lp("LEB %d free %d dirty %d to %d +%d",
133 	       c->ltab[lnum - c->lpt_first].dirty, free, dirty);
136 	c->ltab[lnum - c->lpt_first].dirty += dirty;
544  * next_pnode_to_dirty - find next pnode to dirty.
548  * This function returns the next pnode to dirty or %NULL if there are no more
610  * add_pnode_dirt - add dirty space to LPT LEB properties.
621  * do_make_pnode_dirty - mark a pnode dirty.
623  * @pnode: pnode to mark dirty
633 		/* Mark parent and ancestors dirty too */
647  * make_tree_dirty - mark the entire LEB properties tree dirty.
691 		else if (c->ltab[i].free + c->ltab[i].dirty == c->leb_size)
704  * LPT trivial garbage collection is where a LPT LEB contains only dirty and
715 		if (c->ltab[i].dirty > 0 &&
716 		    c->ltab[i].free + c->ltab[i].dirty == c->leb_size) {
719 			c->ltab[i].dirty = 0;
729  * LPT trivial garbage collection is where a LPT LEB contains only dirty and
755  * most important to least important): empty, freeable, freeable index, dirty
756  * index, dirty or free. Upon mount, we read this list of LEB numbers and bring
846  * make_nnode_dirty - find a nnode and, if found, make it dirty.
848  * @node_num: nnode number of nnode to make dirty
855  * dirty.  The dirty nodes are written next commit, after which the LEB is free
880 		/* Mark parent and ancestors dirty too */
895  * make_pnode_dirty - find a pnode and, if found, make it dirty.
897  * @node_num: pnode number of pnode to make dirty
904  * dirty.  The dirty nodes are written next commit, after which the LEB is free
926  * make_ltab_dirty - make ltab node dirty.
934  * dirty.  The dirty nodes are written next commit, after which the LEB is free
951  * make_lsave_dirty - make lsave node dirty.
959  * dirty.  The dirty nodes are written next commit, after which the LEB is free
976  * make_node_dirty - make node dirty.
986  * dirty.  The dirty nodes are written next commit, after which the LEB is free
1100  * in the LEB being garbage-collected as dirty.  The dirty nodes are written
1152 	int i, lnum = -1, dirty = 0;
1158 		    c->ltab[i].free + c->ltab[i].dirty == c->leb_size)
1160 		if (c->ltab[i].dirty > dirty) {
1161 			dirty = c->ltab[i].dirty;
1176  * This function "freezes" all currently dirty LEB properties and does not
1198 		 * ubifs_lpt_post_commit() by marking nodes dirty. That
1471  * dbg_is_nnode_dirty - determine if a nnode is dirty.
1506  * dbg_is_pnode_dirty - determine if a pnode is dirty.
1535  * dbg_is_ltab_dirty - determine if a ltab node is dirty.
1548  * dbg_is_lsave_dirty - determine if a lsave node is dirty.
1561  * dbg_is_node_dirty - determine if a node is dirty.
1592 	int err, len = c->leb_size, dirty = 0, node_type, node_num, node_len;
1619 				dirty += pad_len;
1633 			if (dirty != c->ltab[i].dirty) {
1634 				ubifs_err(c, "invalid dirty space in LEB %d (dirty %d, expected %d)",
1635 					  lnum, dirty, c->ltab[i].dirty);
1644 			dirty += node_len;
1655  * dbg_check_ltab - check the free and dirty space in the ltab.
1759 			ubifs_err(c, "dirty pnodes %d exceed max %d",
1764 			ubifs_err(c, "dirty nnodes %d exceed max %d",