UBIFS: introduce LPT dump function (2ba5f7ae) · Commits · e / devices / android_kernel_teracube_emerald

fs/ubifs/debug.c

+18 −10

Original line number	Diff line number	Diff line
		@@ -646,7 +646,8 @@ void dbg_dump_lprops(struct ubifs_info *c)
		struct ubifs_lprops lp;
		struct ubifs_lp_stats lst;

		printk(KERN_DEBUG "(pid %d) Dumping LEB properties\n", current->pid);
		printk(KERN_DEBUG "(pid %d) start dumping LEB properties\n",
		current->pid);
		ubifs_get_lp_stats(c, &lst);
		dbg_dump_lstats(&lst);

		@@ -657,6 +658,8 @@ void dbg_dump_lprops(struct ubifs_info *c)

		dbg_dump_lprop(c, &lp);
		}
		printk(KERN_DEBUG "(pid %d) finish dumping LEB properties\n",
		current->pid);
		}

		void dbg_dump_lpt_info(struct ubifs_info *c)
		@@ -664,6 +667,7 @@ void dbg_dump_lpt_info(struct ubifs_info *c)
		int i;

		spin_lock(&dbg_lock);
		printk(KERN_DEBUG "(pid %d) dumping LPT information\n", current->pid);
		printk(KERN_DEBUG "\tlpt_sz: %lld\n", c->lpt_sz);
		printk(KERN_DEBUG "\tpnode_sz: %d\n", c->pnode_sz);
		printk(KERN_DEBUG "\tnnode_sz: %d\n", c->nnode_sz);
		@@ -704,8 +708,8 @@ void dbg_dump_leb(const struct ubifs_info *c, int lnum)
		if (dbg_failure_mode)
		return;

		printk(KERN_DEBUG "(pid %d) Dumping LEB %d\n", current->pid, lnum);

		printk(KERN_DEBUG "(pid %d) start dumping LEB %d\n",
		current->pid, lnum);
		sleb = ubifs_scan(c, lnum, 0, c->dbg->buf);
		if (IS_ERR(sleb)) {
		ubifs_err("scan error %d", (int)PTR_ERR(sleb));
		@@ -722,6 +726,8 @@ void dbg_dump_leb(const struct ubifs_info *c, int lnum)
		dbg_dump_node(c, snod->node);
		}

		printk(KERN_DEBUG "(pid %d) finish dumping LEB %d\n",
		current->pid, lnum);
		ubifs_scan_destroy(sleb);
		return;
		}
		@@ -769,7 +775,7 @@ void dbg_dump_heap(struct ubifs_info c, struct ubifs_lpt_heap heap, int cat)
		{
		int i;

		printk(KERN_DEBUG "(pid %d) Dumping heap cat %d (%d elements)\n",
		printk(KERN_DEBUG "(pid %d) start dumping heap cat %d (%d elements)\n",
		current->pid, cat, heap->cnt);
		for (i = 0; i < heap->cnt; i++) {
		struct ubifs_lprops *lprops = heap->arr[i];
		@@ -778,6 +784,7 @@ void dbg_dump_heap(struct ubifs_info c, struct ubifs_lpt_heap heap, int cat)
		"flags %d\n", i, lprops->lnum, lprops->hpos,
		lprops->free, lprops->dirty, lprops->flags);
		}
		printk(KERN_DEBUG "(pid %d) finish dumping heap\n", current->pid);
		}

		void dbg_dump_pnode(struct ubifs_info c, struct ubifs_pnode pnode,
		@@ -785,7 +792,7 @@ void dbg_dump_pnode(struct ubifs_info c, struct ubifs_pnode pnode,
		{
		int i;

		printk(KERN_DEBUG "(pid %d) Dumping pnode:\n", current->pid);
		printk(KERN_DEBUG "(pid %d) dumping pnode:\n", current->pid);
		printk(KERN_DEBUG "\taddress %zx parent %zx cnext %zx\n",
		(size_t)pnode, (size_t)parent, (size_t)pnode->cnext);
		printk(KERN_DEBUG "\tflags %lu iip %d level %d num %d\n",
		@@ -804,7 +811,7 @@ void dbg_dump_tnc(struct ubifs_info *c)
		int level;

		printk(KERN_DEBUG "\n");
		printk(KERN_DEBUG "(pid %d) Dumping the TNC tree\n", current->pid);
		printk(KERN_DEBUG "(pid %d) start dumping TNC tree\n", current->pid);
		znode = ubifs_tnc_levelorder_next(c->zroot.znode, NULL);
		level = znode->level;
		printk(KERN_DEBUG "== Level %d ==\n", level);
		@@ -816,8 +823,7 @@ void dbg_dump_tnc(struct ubifs_info *c)
		dbg_dump_znode(c, znode);
		znode = ubifs_tnc_levelorder_next(c->zroot.znode, znode);
		}

		printk(KERN_DEBUG "\n");
		printk(KERN_DEBUG "(pid %d) finish dumping TNC tree\n", current->pid);
		}

		static int dump_znode(struct ubifs_info c, struct ubifs_znode znode,
		@@ -992,7 +998,8 @@ static int dbg_check_key_order(struct ubifs_info c, struct ubifs_zbranch zbr1,
		ubifs_err("1st entry at %d:%d has key %s", zbr1->lnum,
		zbr1->offs, DBGKEY(&key));
		ubifs_err("but it should have key %s according to tnc",
		DBGKEY(&zbr1->key)); dbg_dump_node(c, dent1);
		DBGKEY(&zbr1->key));
		dbg_dump_node(c, dent1);
		goto out_free;
		}

		@@ -1001,7 +1008,8 @@ static int dbg_check_key_order(struct ubifs_info c, struct ubifs_zbranch zbr1,
		ubifs_err("2nd entry at %d:%d has key %s", zbr1->lnum,
		zbr1->offs, DBGKEY(&key));
		ubifs_err("but it should have key %s according to tnc",
		DBGKEY(&zbr2->key)); dbg_dump_node(c, dent2);
		DBGKEY(&zbr2->key));
		dbg_dump_node(c, dent2);
		goto out_free;
		}

fs/ubifs/debug.h

+25 −20

Original line number	Diff line number	Diff line
		@@ -270,6 +270,8 @@ const char dbg_get_key_dump(const struct ubifs_info c,
		const union ubifs_key *key);
		void dbg_dump_inode(const struct ubifs_info c, const struct inode inode);
		void dbg_dump_node(const struct ubifs_info c, const void node);
		void dbg_dump_lpt_node(const struct ubifs_info c, void node, int lnum,
		int offs);
		void dbg_dump_budget_req(const struct ubifs_budget_req *req);
		void dbg_dump_lstats(const struct ubifs_lp_stats *lst);
		void dbg_dump_budg(struct ubifs_info *c);
		@@ -284,6 +286,7 @@ void dbg_dump_pnode(struct ubifs_info c, struct ubifs_pnode pnode,
		struct ubifs_nnode *parent, int iip);
		void dbg_dump_tnc(struct ubifs_info *c);
		void dbg_dump_index(struct ubifs_info *c);
		void dbg_dump_lpt_lebs(const struct ubifs_info *c);

		/* Checking helper functions */
		typedef int (dbg_leaf_callback)(struct ubifs_info c,
		@@ -419,6 +422,7 @@ void dbg_debugfs_exit_fs(struct ubifs_info *c);
		#define dbg_get_key_dump(c, key) ({})
		#define dbg_dump_inode(c, inode) ({})
		#define dbg_dump_node(c, node) ({})
		#define dbg_dump_lpt_node(c, node, lnum, offs) ({})
		#define dbg_dump_budget_req(req) ({})
		#define dbg_dump_lstats(lst) ({})
		#define dbg_dump_budg(c) ({})
		@@ -431,6 +435,7 @@ void dbg_debugfs_exit_fs(struct ubifs_info *c);
		#define dbg_dump_pnode(c, pnode, parent, iip) ({})
		#define dbg_dump_tnc(c) ({})
		#define dbg_dump_index(c) ({})
		#define dbg_dump_lpt_lebs(c) ({})

		#define dbg_walk_index(c, leaf_cb, znode_cb, priv) 0
		#define dbg_old_index_check_init(c, zroot) 0

fs/ubifs/lpt.c

+14 −13

Original line number	Diff line number	Diff line
		@@ -557,7 +557,7 @@ static int calc_nnode_num(int row, int col)
		* This function calculates and returns the nnode number based on the parent's
		* nnode number and the index in parent.
		*/
		static int calc_nnode_num_from_parent(struct ubifs_info *c,
		static int calc_nnode_num_from_parent(const struct ubifs_info *c,
		struct ubifs_nnode *parent, int iip)
		{
		int num, shft;
		@@ -582,7 +582,7 @@ static int calc_nnode_num_from_parent(struct ubifs_info *c,
		* This function calculates and returns the pnode number based on the parent's
		* nnode number and the index in parent.
		*/
		static int calc_pnode_num_from_parent(struct ubifs_info *c,
		static int calc_pnode_num_from_parent(const struct ubifs_info *c,
		struct ubifs_nnode *parent, int iip)
		{
		int i, n = c->lpt_hght - 1, pnum = parent->num, num = 0;
		@@ -965,7 +965,7 @@ static int check_lpt_type(uint8_t *addr, int pos, int type)
		*
		* This function returns %0 on success and a negative error code on failure.
		*/
		static int unpack_pnode(struct ubifs_info c, void buf,
		static int unpack_pnode(const struct ubifs_info c, void buf,
		struct ubifs_pnode *pnode)
		{
		uint8_t *addr = buf + UBIFS_LPT_CRC_BYTES;
		@@ -995,14 +995,14 @@ static int unpack_pnode(struct ubifs_info c, void buf,
		}

		/**
		* unpack_nnode - unpack a nnode.
		* ubifs_unpack_nnode - unpack a nnode.
		* @c: UBIFS file-system description object
		* @buf: buffer containing packed nnode to unpack
		* @nnode: nnode structure to fill
		*
		* This function returns %0 on success and a negative error code on failure.
		*/
		static int unpack_nnode(struct ubifs_info c, void buf,
		int ubifs_unpack_nnode(const struct ubifs_info c, void buf,
		struct ubifs_nnode *nnode)
		{
		uint8_t *addr = buf + UBIFS_LPT_CRC_BYTES;
		@@ -1035,7 +1035,7 @@ static int unpack_nnode(struct ubifs_info c, void buf,
		*
		* This function returns %0 on success and a negative error code on failure.
		*/
		static int unpack_ltab(struct ubifs_info c, void buf)
		static int unpack_ltab(const struct ubifs_info c, void buf)
		{
		uint8_t *addr = buf + UBIFS_LPT_CRC_BYTES;
		int i, pos = 0, err;
		@@ -1067,7 +1067,7 @@ static int unpack_ltab(struct ubifs_info c, void buf)
		*
		* This function returns %0 on success and a negative error code on failure.
		*/
		static int unpack_lsave(struct ubifs_info c, void buf)
		static int unpack_lsave(const struct ubifs_info c, void buf)
		{
		uint8_t *addr = buf + UBIFS_LPT_CRC_BYTES;
		int i, pos = 0, err;
		@@ -1095,7 +1095,7 @@ static int unpack_lsave(struct ubifs_info c, void buf)
		*
		* This function returns %0 on success and a negative error code on failure.
		*/
		static int validate_nnode(struct ubifs_info c, struct ubifs_nnode nnode,
		static int validate_nnode(const struct ubifs_info c, struct ubifs_nnode nnode,
		struct ubifs_nnode *parent, int iip)
		{
		int i, lvl, max_offs;
		@@ -1139,7 +1139,7 @@ static int validate_nnode(struct ubifs_info c, struct ubifs_nnode nnode,
		*
		* This function returns %0 on success and a negative error code on failure.
		*/
		static int validate_pnode(struct ubifs_info c, struct ubifs_pnode pnode,
		static int validate_pnode(const struct ubifs_info c, struct ubifs_pnode pnode,
		struct ubifs_nnode *parent, int iip)
		{
		int i;
		@@ -1173,7 +1173,8 @@ static int validate_pnode(struct ubifs_info c, struct ubifs_pnode pnode,
		* This function calculates the LEB numbers for the LEB properties it contains
		* based on the pnode number.
		*/
		static void set_pnode_lnum(struct ubifs_info c, struct ubifs_pnode pnode)
		static void set_pnode_lnum(const struct ubifs_info *c,
		struct ubifs_pnode *pnode)
		{
		int i, lnum;

		@@ -1226,7 +1227,7 @@ int ubifs_read_nnode(struct ubifs_info c, struct ubifs_nnode parent, int iip)
		err = ubi_read(c->ubi, lnum, buf, offs, c->nnode_sz);
		if (err)
		goto out;
		err = unpack_nnode(c, buf, nnode);
		err = ubifs_unpack_nnode(c, buf, nnode);
		if (err)
		goto out;
		}
		@@ -1815,7 +1816,7 @@ static struct ubifs_nnode scan_get_nnode(struct ubifs_info c,
		c->nnode_sz);
		if (err)
		return ERR_PTR(err);
		err = unpack_nnode(c, buf, nnode);
		err = ubifs_unpack_nnode(c, buf, nnode);
		if (err)
		return ERR_PTR(err);
		}

fs/ubifs/lpt_commit.c

+126 −5

Original line number	Diff line number	Diff line
		@@ -320,6 +320,7 @@ static int layout_cnodes(struct ubifs_info *c)
		dbg_err("LPT out of space at LEB %d:%d needing %d, done_ltab %d, "
		"done_lsave %d", lnum, offs, len, done_ltab, done_lsave);
		dbg_dump_lpt_info(c);
		dbg_dump_lpt_lebs(c);
		dump_stack();
		return err;
		}
		@@ -549,6 +550,7 @@ static int write_cnodes(struct ubifs_info *c)
		dbg_err("LPT out of space mismatch at LEB %d:%d needing %d, done_ltab "
		"%d, done_lsave %d", lnum, offs, len, done_ltab, done_lsave);
		dbg_dump_lpt_info(c);
		dbg_dump_lpt_lebs(c);
		dump_stack();
		return err;
		}
		@@ -1027,7 +1029,7 @@ static int make_node_dirty(struct ubifs_info *c, int node_type, int node_num,
		* @c: UBIFS file-system description object
		* @node_type: LPT node type
		*/
		static int get_lpt_node_len(struct ubifs_info *c, int node_type)
		static int get_lpt_node_len(const struct ubifs_info *c, int node_type)
		{
		switch (node_type) {
		case UBIFS_LPT_NNODE:
		@@ -1048,7 +1050,7 @@ static int get_lpt_node_len(struct ubifs_info *c, int node_type)
		* @buf: buffer
		* @len: length of buffer
		*/
		static int get_pad_len(struct ubifs_info c, uint8_t buf, int len)
		static int get_pad_len(const struct ubifs_info c, uint8_t buf, int len)
		{
		int offs, pad_len;

		@@ -1065,7 +1067,8 @@ static int get_pad_len(struct ubifs_info c, uint8_t buf, int len)
		* @buf: buffer
		* @node_num: node number is returned here
		*/
		static int get_lpt_node_type(struct ubifs_info c, uint8_t buf, int *node_num)
		static int get_lpt_node_type(const struct ubifs_info c, uint8_t buf,
		int *node_num)
		{
		uint8_t *addr = buf + UBIFS_LPT_CRC_BYTES;
		int pos = 0, node_type;
		@@ -1083,7 +1086,7 @@ static int get_lpt_node_type(struct ubifs_info c, uint8_t buf, int *node_num)
		*
		* This function returns %1 if the buffer contains a node or %0 if it does not.
		*/
		static int is_a_node(struct ubifs_info c, uint8_t buf, int len)
		static int is_a_node(const struct ubifs_info c, uint8_t buf, int len)
		{
		uint8_t *addr = buf + UBIFS_LPT_CRC_BYTES;
		int pos = 0, node_type, node_len;
		@@ -1107,7 +1110,6 @@ static int is_a_node(struct ubifs_info c, uint8_t buf, int len)
		return 1;
		}


		/**
		* lpt_gc_lnum - garbage collect a LPT LEB.
		* @c: UBIFS file-system description object
		@@ -1724,6 +1726,7 @@ int dbg_chk_lpt_free_spc(struct ubifs_info *c)
		dbg_err("LPT space error: free %lld lpt_sz %lld",
		free, c->lpt_sz);
		dbg_dump_lpt_info(c);
		dbg_dump_lpt_lebs(c);
		dump_stack();
		return -EINVAL;
		}
		@@ -1808,6 +1811,7 @@ int dbg_chk_lpt_sz(struct ubifs_info *c, int action, int len)
		}
		if (err) {
		dbg_dump_lpt_info(c);
		dbg_dump_lpt_lebs(c);
		dump_stack();
		}
		d->chk_lpt_sz2 = d->chk_lpt_sz;
		@@ -1825,4 +1829,121 @@ int dbg_chk_lpt_sz(struct ubifs_info *c, int action, int len)
		}
		}

		/**
		* dbg_dump_lpt_leb - dump an LPT LEB.
		* @c: UBIFS file-system description object
		* @lnum: LEB number to dump
		*
		* This function dumps an LEB from LPT area. Nodes in this area are very
		* different to nodes in the main area (e.g., they do not have common headers,
		* they do not have 8-byte alignments, etc), so we have a separate function to
		* dump LPT area LEBs. Note, LPT has to be locked by the coller.
		*/
		static void dump_lpt_leb(const struct ubifs_info *c, int lnum)
		{
		int err, len = c->leb_size, node_type, node_num, node_len, offs;
		void *buf = c->dbg->buf;

		printk(KERN_DEBUG "(pid %d) start dumping LEB %d\n",
		current->pid, lnum);
		err = ubi_read(c->ubi, lnum, buf, 0, c->leb_size);
		if (err) {
		ubifs_err("cannot read LEB %d, error %d", lnum, err);
		return;
		}
		while (1) {
		offs = c->leb_size - len;
		if (!is_a_node(c, buf, len)) {
		int pad_len;

		pad_len = get_pad_len(c, buf, len);
		if (pad_len) {
		printk(KERN_DEBUG "LEB %d:%d, pad %d bytes\n",
		lnum, offs, pad_len);
		buf += pad_len;
		len -= pad_len;
		continue;
		}
		if (len)
		printk(KERN_DEBUG "LEB %d:%d, free %d bytes\n",
		lnum, offs, len);
		break;
		}

		node_type = get_lpt_node_type(c, buf, &node_num);
		switch (node_type) {
		case UBIFS_LPT_PNODE:
		{
		node_len = c->pnode_sz;
		if (c->big_lpt)
		printk(KERN_DEBUG "LEB %d:%d, pnode num %d\n",
		lnum, offs, node_num);
		else
		printk(KERN_DEBUG "LEB %d:%d, pnode\n",
		lnum, offs);
		break;
		}
		case UBIFS_LPT_NNODE:
		{
		int i;
		struct ubifs_nnode nnode;

		node_len = c->nnode_sz;
		if (c->big_lpt)
		printk(KERN_DEBUG "LEB %d:%d, nnode num %d, ",
		lnum, offs, node_num);
		else
		printk(KERN_DEBUG "LEB %d:%d, nnode, ",
		lnum, offs);
		err = ubifs_unpack_nnode(c, buf, &nnode);
		for (i = 0; i < UBIFS_LPT_FANOUT; i++) {
		printk("%d:%d", nnode.nbranch[i].lnum,
		nnode.nbranch[i].offs);
		if (i != UBIFS_LPT_FANOUT - 1)
		printk(", ");
		}
		printk("\n");
		break;
		}
		case UBIFS_LPT_LTAB:
		node_len = c->ltab_sz;
		printk(KERN_DEBUG "LEB %d:%d, ltab\n",
		lnum, offs);
		break;
		case UBIFS_LPT_LSAVE:
		node_len = c->lsave_sz;
		printk(KERN_DEBUG "LEB %d:%d, lsave len\n", lnum, offs);
		break;
		default:
		ubifs_err("LPT node type %d not recognized", node_type);
		return;
		}

		buf += node_len;
		len -= node_len;
		}

		printk(KERN_DEBUG "(pid %d) finish dumping LEB %d\n",
		current->pid, lnum);
		}

		/**
		* dbg_dump_lpt_lebs - dump LPT lebs.
		* @c: UBIFS file-system description object
		*
		* This function dumps all LPT LEBs. The caller has to make sure the LPT is
		* locked.
		*/
		void dbg_dump_lpt_lebs(const struct ubifs_info *c)
		{
		int i;

		printk(KERN_DEBUG "(pid %d) start dumping all LPT LEBs\n",
		current->pid);
		for (i = 0; i < c->lpt_lebs; i++)
		dump_lpt_leb(c, i + c->lpt_first);
		printk(KERN_DEBUG "(pid %d) finish dumping all LPT LEBs\n",
		current->pid);
		}

		#endif /* CONFIG_UBIFS_FS_DEBUG */

fs/ubifs/ubifs.h

+3 −0

Original line number	Diff line number	Diff line
		@@ -1622,6 +1622,9 @@ void ubifs_add_lpt_dirt(struct ubifs_info *c, int lnum, int dirty);
		void ubifs_add_nnode_dirt(struct ubifs_info c, struct ubifs_nnode nnode);
		uint32_t ubifs_unpack_bits(uint8_t *addr, int pos, int nrbits);
		struct ubifs_nnode ubifs_first_nnode(struct ubifs_info c, int *hght);
		/* Needed only in debugging code in lpt_commit.c */
		int ubifs_unpack_nnode(const struct ubifs_info c, void buf,
		struct ubifs_nnode *nnode);

		/* lpt_commit.c */
		int ubifs_lpt_start_commit(struct ubifs_info *c);