xref: /openbmc/linux/fs/ubifs/debug.c (revision 060f35a317ef09101b128f399dce7ed13d019461)
1 // SPDX-License-Identifier: GPL-2.0-only
2 /*
3  * This file is part of UBIFS.
4  *
5  * Copyright (C) 2006-2008 Nokia Corporation
6  *
7  * Authors: Artem Bityutskiy (Битюцкий Артём)
8  *          Adrian Hunter
9  */
10 
11 /*
12  * This file implements most of the debugging stuff which is compiled in only
13  * when it is enabled. But some debugging check functions are implemented in
14  * corresponding subsystem, just because they are closely related and utilize
15  * various local functions of those subsystems.
16  */
17 
18 #include <linux/module.h>
19 #include <linux/debugfs.h>
20 #include <linux/math64.h>
21 #include <linux/uaccess.h>
22 #include <linux/random.h>
23 #include <linux/ctype.h>
24 #include "ubifs.h"
25 
26 static DEFINE_SPINLOCK(dbg_lock);
27 
get_key_fmt(int fmt)28 static const char *get_key_fmt(int fmt)
29 {
30 	switch (fmt) {
31 	case UBIFS_SIMPLE_KEY_FMT:
32 		return "simple";
33 	default:
34 		return "unknown/invalid format";
35 	}
36 }
37 
get_key_hash(int hash)38 static const char *get_key_hash(int hash)
39 {
40 	switch (hash) {
41 	case UBIFS_KEY_HASH_R5:
42 		return "R5";
43 	case UBIFS_KEY_HASH_TEST:
44 		return "test";
45 	default:
46 		return "unknown/invalid name hash";
47 	}
48 }
49 
get_key_type(int type)50 static const char *get_key_type(int type)
51 {
52 	switch (type) {
53 	case UBIFS_INO_KEY:
54 		return "inode";
55 	case UBIFS_DENT_KEY:
56 		return "direntry";
57 	case UBIFS_XENT_KEY:
58 		return "xentry";
59 	case UBIFS_DATA_KEY:
60 		return "data";
61 	case UBIFS_TRUN_KEY:
62 		return "truncate";
63 	default:
64 		return "unknown/invalid key";
65 	}
66 }
67 
get_dent_type(int type)68 static const char *get_dent_type(int type)
69 {
70 	switch (type) {
71 	case UBIFS_ITYPE_REG:
72 		return "file";
73 	case UBIFS_ITYPE_DIR:
74 		return "dir";
75 	case UBIFS_ITYPE_LNK:
76 		return "symlink";
77 	case UBIFS_ITYPE_BLK:
78 		return "blkdev";
79 	case UBIFS_ITYPE_CHR:
80 		return "char dev";
81 	case UBIFS_ITYPE_FIFO:
82 		return "fifo";
83 	case UBIFS_ITYPE_SOCK:
84 		return "socket";
85 	default:
86 		return "unknown/invalid type";
87 	}
88 }
89 
dbg_snprintf_key(const struct ubifs_info * c,const union ubifs_key * key,char * buffer,int len)90 const char *dbg_snprintf_key(const struct ubifs_info *c,
91 			     const union ubifs_key *key, char *buffer, int len)
92 {
93 	char *p = buffer;
94 	int type = key_type(c, key);
95 
96 	if (c->key_fmt == UBIFS_SIMPLE_KEY_FMT) {
97 		switch (type) {
98 		case UBIFS_INO_KEY:
99 			len -= snprintf(p, len, "(%lu, %s)",
100 					(unsigned long)key_inum(c, key),
101 					get_key_type(type));
102 			break;
103 		case UBIFS_DENT_KEY:
104 		case UBIFS_XENT_KEY:
105 			len -= snprintf(p, len, "(%lu, %s, %#08x)",
106 					(unsigned long)key_inum(c, key),
107 					get_key_type(type), key_hash(c, key));
108 			break;
109 		case UBIFS_DATA_KEY:
110 			len -= snprintf(p, len, "(%lu, %s, %u)",
111 					(unsigned long)key_inum(c, key),
112 					get_key_type(type), key_block(c, key));
113 			break;
114 		case UBIFS_TRUN_KEY:
115 			len -= snprintf(p, len, "(%lu, %s)",
116 					(unsigned long)key_inum(c, key),
117 					get_key_type(type));
118 			break;
119 		default:
120 			len -= snprintf(p, len, "(bad key type: %#08x, %#08x)",
121 					key->u32[0], key->u32[1]);
122 		}
123 	} else
124 		len -= snprintf(p, len, "bad key format %d", c->key_fmt);
125 	ubifs_assert(c, len > 0);
126 	return p;
127 }
128 
dbg_ntype(int type)129 const char *dbg_ntype(int type)
130 {
131 	switch (type) {
132 	case UBIFS_PAD_NODE:
133 		return "padding node";
134 	case UBIFS_SB_NODE:
135 		return "superblock node";
136 	case UBIFS_MST_NODE:
137 		return "master node";
138 	case UBIFS_REF_NODE:
139 		return "reference node";
140 	case UBIFS_INO_NODE:
141 		return "inode node";
142 	case UBIFS_DENT_NODE:
143 		return "direntry node";
144 	case UBIFS_XENT_NODE:
145 		return "xentry node";
146 	case UBIFS_DATA_NODE:
147 		return "data node";
148 	case UBIFS_TRUN_NODE:
149 		return "truncate node";
150 	case UBIFS_IDX_NODE:
151 		return "indexing node";
152 	case UBIFS_CS_NODE:
153 		return "commit start node";
154 	case UBIFS_ORPH_NODE:
155 		return "orphan node";
156 	case UBIFS_AUTH_NODE:
157 		return "auth node";
158 	default:
159 		return "unknown node";
160 	}
161 }
162 
dbg_gtype(int type)163 static const char *dbg_gtype(int type)
164 {
165 	switch (type) {
166 	case UBIFS_NO_NODE_GROUP:
167 		return "no node group";
168 	case UBIFS_IN_NODE_GROUP:
169 		return "in node group";
170 	case UBIFS_LAST_OF_NODE_GROUP:
171 		return "last of node group";
172 	default:
173 		return "unknown";
174 	}
175 }
176 
dbg_cstate(int cmt_state)177 const char *dbg_cstate(int cmt_state)
178 {
179 	switch (cmt_state) {
180 	case COMMIT_RESTING:
181 		return "commit resting";
182 	case COMMIT_BACKGROUND:
183 		return "background commit requested";
184 	case COMMIT_REQUIRED:
185 		return "commit required";
186 	case COMMIT_RUNNING_BACKGROUND:
187 		return "BACKGROUND commit running";
188 	case COMMIT_RUNNING_REQUIRED:
189 		return "commit running and required";
190 	case COMMIT_BROKEN:
191 		return "broken commit";
192 	default:
193 		return "unknown commit state";
194 	}
195 }
196 
dbg_jhead(int jhead)197 const char *dbg_jhead(int jhead)
198 {
199 	switch (jhead) {
200 	case GCHD:
201 		return "0 (GC)";
202 	case BASEHD:
203 		return "1 (base)";
204 	case DATAHD:
205 		return "2 (data)";
206 	default:
207 		return "unknown journal head";
208 	}
209 }
210 
dump_ch(const struct ubifs_ch * ch)211 static void dump_ch(const struct ubifs_ch *ch)
212 {
213 	pr_err("\tmagic          %#x\n", le32_to_cpu(ch->magic));
214 	pr_err("\tcrc            %#x\n", le32_to_cpu(ch->crc));
215 	pr_err("\tnode_type      %d (%s)\n", ch->node_type,
216 	       dbg_ntype(ch->node_type));
217 	pr_err("\tgroup_type     %d (%s)\n", ch->group_type,
218 	       dbg_gtype(ch->group_type));
219 	pr_err("\tsqnum          %llu\n",
220 	       (unsigned long long)le64_to_cpu(ch->sqnum));
221 	pr_err("\tlen            %u\n", le32_to_cpu(ch->len));
222 }
223 
ubifs_dump_inode(struct ubifs_info * c,const struct inode * inode)224 void ubifs_dump_inode(struct ubifs_info *c, const struct inode *inode)
225 {
226 	const struct ubifs_inode *ui = ubifs_inode(inode);
227 	struct fscrypt_name nm = {0};
228 	union ubifs_key key;
229 	struct ubifs_dent_node *dent, *pdent = NULL;
230 	int count = 2;
231 
232 	pr_err("Dump in-memory inode:");
233 	pr_err("\tinode          %lu\n", inode->i_ino);
234 	pr_err("\tsize           %llu\n",
235 	       (unsigned long long)i_size_read(inode));
236 	pr_err("\tnlink          %u\n", inode->i_nlink);
237 	pr_err("\tuid            %u\n", (unsigned int)i_uid_read(inode));
238 	pr_err("\tgid            %u\n", (unsigned int)i_gid_read(inode));
239 	pr_err("\tatime          %u.%u\n",
240 	       (unsigned int)inode->i_atime.tv_sec,
241 	       (unsigned int)inode->i_atime.tv_nsec);
242 	pr_err("\tmtime          %u.%u\n",
243 	       (unsigned int)inode->i_mtime.tv_sec,
244 	       (unsigned int)inode->i_mtime.tv_nsec);
245 	pr_err("\tctime          %u.%u\n",
246 	       (unsigned int) inode_get_ctime(inode).tv_sec,
247 	       (unsigned int) inode_get_ctime(inode).tv_nsec);
248 	pr_err("\tcreat_sqnum    %llu\n", ui->creat_sqnum);
249 	pr_err("\txattr_size     %u\n", ui->xattr_size);
250 	pr_err("\txattr_cnt      %u\n", ui->xattr_cnt);
251 	pr_err("\txattr_names    %u\n", ui->xattr_names);
252 	pr_err("\tdirty          %u\n", ui->dirty);
253 	pr_err("\txattr          %u\n", ui->xattr);
254 	pr_err("\tbulk_read      %u\n", ui->bulk_read);
255 	pr_err("\tsynced_i_size  %llu\n",
256 	       (unsigned long long)ui->synced_i_size);
257 	pr_err("\tui_size        %llu\n",
258 	       (unsigned long long)ui->ui_size);
259 	pr_err("\tflags          %d\n", ui->flags);
260 	pr_err("\tcompr_type     %d\n", ui->compr_type);
261 	pr_err("\tlast_page_read %lu\n", ui->last_page_read);
262 	pr_err("\tread_in_a_row  %lu\n", ui->read_in_a_row);
263 	pr_err("\tdata_len       %d\n", ui->data_len);
264 
265 	if (!S_ISDIR(inode->i_mode))
266 		return;
267 
268 	pr_err("List of directory entries:\n");
269 	ubifs_assert(c, !mutex_is_locked(&c->tnc_mutex));
270 
271 	lowest_dent_key(c, &key, inode->i_ino);
272 	while (1) {
273 		dent = ubifs_tnc_next_ent(c, &key, &nm);
274 		if (IS_ERR(dent)) {
275 			if (PTR_ERR(dent) != -ENOENT)
276 				pr_err("error %ld\n", PTR_ERR(dent));
277 			break;
278 		}
279 
280 		pr_err("\t%d: inode %llu, type %s, len %d\n",
281 		       count++, (unsigned long long) le64_to_cpu(dent->inum),
282 		       get_dent_type(dent->type),
283 		       le16_to_cpu(dent->nlen));
284 
285 		fname_name(&nm) = dent->name;
286 		fname_len(&nm) = le16_to_cpu(dent->nlen);
287 		kfree(pdent);
288 		pdent = dent;
289 		key_read(c, &dent->key, &key);
290 	}
291 	kfree(pdent);
292 }
293 
ubifs_dump_node(const struct ubifs_info * c,const void * node,int node_len)294 void ubifs_dump_node(const struct ubifs_info *c, const void *node, int node_len)
295 {
296 	int i, n, type, safe_len, max_node_len, min_node_len;
297 	union ubifs_key key;
298 	const struct ubifs_ch *ch = node;
299 	char key_buf[DBG_KEY_BUF_LEN];
300 
301 	/* If the magic is incorrect, just hexdump the first bytes */
302 	if (le32_to_cpu(ch->magic) != UBIFS_NODE_MAGIC) {
303 		pr_err("Not a node, first %zu bytes:", UBIFS_CH_SZ);
304 		print_hex_dump(KERN_ERR, "", DUMP_PREFIX_OFFSET, 32, 1,
305 			       (void *)node, UBIFS_CH_SZ, 1);
306 		return;
307 	}
308 
309 	/* Skip dumping unknown type node */
310 	type = ch->node_type;
311 	if (type < 0 || type >= UBIFS_NODE_TYPES_CNT) {
312 		pr_err("node type %d was not recognized\n", type);
313 		return;
314 	}
315 
316 	spin_lock(&dbg_lock);
317 	dump_ch(node);
318 
319 	if (c->ranges[type].max_len == 0) {
320 		max_node_len = min_node_len = c->ranges[type].len;
321 	} else {
322 		max_node_len = c->ranges[type].max_len;
323 		min_node_len = c->ranges[type].min_len;
324 	}
325 	safe_len = le32_to_cpu(ch->len);
326 	safe_len = safe_len > 0 ? safe_len : 0;
327 	safe_len = min3(safe_len, max_node_len, node_len);
328 	if (safe_len < min_node_len) {
329 		pr_err("node len(%d) is too short for %s, left %d bytes:\n",
330 		       safe_len, dbg_ntype(type),
331 		       safe_len > UBIFS_CH_SZ ?
332 		       safe_len - (int)UBIFS_CH_SZ : 0);
333 		if (safe_len > UBIFS_CH_SZ)
334 			print_hex_dump(KERN_ERR, "", DUMP_PREFIX_OFFSET, 32, 1,
335 				       (void *)node + UBIFS_CH_SZ,
336 				       safe_len - UBIFS_CH_SZ, 0);
337 		goto out_unlock;
338 	}
339 	if (safe_len != le32_to_cpu(ch->len))
340 		pr_err("\ttruncated node length      %d\n", safe_len);
341 
342 	switch (type) {
343 	case UBIFS_PAD_NODE:
344 	{
345 		const struct ubifs_pad_node *pad = node;
346 
347 		pr_err("\tpad_len        %u\n", le32_to_cpu(pad->pad_len));
348 		break;
349 	}
350 	case UBIFS_SB_NODE:
351 	{
352 		const struct ubifs_sb_node *sup = node;
353 		unsigned int sup_flags = le32_to_cpu(sup->flags);
354 
355 		pr_err("\tkey_hash       %d (%s)\n",
356 		       (int)sup->key_hash, get_key_hash(sup->key_hash));
357 		pr_err("\tkey_fmt        %d (%s)\n",
358 		       (int)sup->key_fmt, get_key_fmt(sup->key_fmt));
359 		pr_err("\tflags          %#x\n", sup_flags);
360 		pr_err("\tbig_lpt        %u\n",
361 		       !!(sup_flags & UBIFS_FLG_BIGLPT));
362 		pr_err("\tspace_fixup    %u\n",
363 		       !!(sup_flags & UBIFS_FLG_SPACE_FIXUP));
364 		pr_err("\tmin_io_size    %u\n", le32_to_cpu(sup->min_io_size));
365 		pr_err("\tleb_size       %u\n", le32_to_cpu(sup->leb_size));
366 		pr_err("\tleb_cnt        %u\n", le32_to_cpu(sup->leb_cnt));
367 		pr_err("\tmax_leb_cnt    %u\n", le32_to_cpu(sup->max_leb_cnt));
368 		pr_err("\tmax_bud_bytes  %llu\n",
369 		       (unsigned long long)le64_to_cpu(sup->max_bud_bytes));
370 		pr_err("\tlog_lebs       %u\n", le32_to_cpu(sup->log_lebs));
371 		pr_err("\tlpt_lebs       %u\n", le32_to_cpu(sup->lpt_lebs));
372 		pr_err("\torph_lebs      %u\n", le32_to_cpu(sup->orph_lebs));
373 		pr_err("\tjhead_cnt      %u\n", le32_to_cpu(sup->jhead_cnt));
374 		pr_err("\tfanout         %u\n", le32_to_cpu(sup->fanout));
375 		pr_err("\tlsave_cnt      %u\n", le32_to_cpu(sup->lsave_cnt));
376 		pr_err("\tdefault_compr  %u\n",
377 		       (int)le16_to_cpu(sup->default_compr));
378 		pr_err("\trp_size        %llu\n",
379 		       (unsigned long long)le64_to_cpu(sup->rp_size));
380 		pr_err("\trp_uid         %u\n", le32_to_cpu(sup->rp_uid));
381 		pr_err("\trp_gid         %u\n", le32_to_cpu(sup->rp_gid));
382 		pr_err("\tfmt_version    %u\n", le32_to_cpu(sup->fmt_version));
383 		pr_err("\ttime_gran      %u\n", le32_to_cpu(sup->time_gran));
384 		pr_err("\tUUID           %pUB\n", sup->uuid);
385 		break;
386 	}
387 	case UBIFS_MST_NODE:
388 	{
389 		const struct ubifs_mst_node *mst = node;
390 
391 		pr_err("\thighest_inum   %llu\n",
392 		       (unsigned long long)le64_to_cpu(mst->highest_inum));
393 		pr_err("\tcommit number  %llu\n",
394 		       (unsigned long long)le64_to_cpu(mst->cmt_no));
395 		pr_err("\tflags          %#x\n", le32_to_cpu(mst->flags));
396 		pr_err("\tlog_lnum       %u\n", le32_to_cpu(mst->log_lnum));
397 		pr_err("\troot_lnum      %u\n", le32_to_cpu(mst->root_lnum));
398 		pr_err("\troot_offs      %u\n", le32_to_cpu(mst->root_offs));
399 		pr_err("\troot_len       %u\n", le32_to_cpu(mst->root_len));
400 		pr_err("\tgc_lnum        %u\n", le32_to_cpu(mst->gc_lnum));
401 		pr_err("\tihead_lnum     %u\n", le32_to_cpu(mst->ihead_lnum));
402 		pr_err("\tihead_offs     %u\n", le32_to_cpu(mst->ihead_offs));
403 		pr_err("\tindex_size     %llu\n",
404 		       (unsigned long long)le64_to_cpu(mst->index_size));
405 		pr_err("\tlpt_lnum       %u\n", le32_to_cpu(mst->lpt_lnum));
406 		pr_err("\tlpt_offs       %u\n", le32_to_cpu(mst->lpt_offs));
407 		pr_err("\tnhead_lnum     %u\n", le32_to_cpu(mst->nhead_lnum));
408 		pr_err("\tnhead_offs     %u\n", le32_to_cpu(mst->nhead_offs));
409 		pr_err("\tltab_lnum      %u\n", le32_to_cpu(mst->ltab_lnum));
410 		pr_err("\tltab_offs      %u\n", le32_to_cpu(mst->ltab_offs));
411 		pr_err("\tlsave_lnum     %u\n", le32_to_cpu(mst->lsave_lnum));
412 		pr_err("\tlsave_offs     %u\n", le32_to_cpu(mst->lsave_offs));
413 		pr_err("\tlscan_lnum     %u\n", le32_to_cpu(mst->lscan_lnum));
414 		pr_err("\tleb_cnt        %u\n", le32_to_cpu(mst->leb_cnt));
415 		pr_err("\tempty_lebs     %u\n", le32_to_cpu(mst->empty_lebs));
416 		pr_err("\tidx_lebs       %u\n", le32_to_cpu(mst->idx_lebs));
417 		pr_err("\ttotal_free     %llu\n",
418 		       (unsigned long long)le64_to_cpu(mst->total_free));
419 		pr_err("\ttotal_dirty    %llu\n",
420 		       (unsigned long long)le64_to_cpu(mst->total_dirty));
421 		pr_err("\ttotal_used     %llu\n",
422 		       (unsigned long long)le64_to_cpu(mst->total_used));
423 		pr_err("\ttotal_dead     %llu\n",
424 		       (unsigned long long)le64_to_cpu(mst->total_dead));
425 		pr_err("\ttotal_dark     %llu\n",
426 		       (unsigned long long)le64_to_cpu(mst->total_dark));
427 		break;
428 	}
429 	case UBIFS_REF_NODE:
430 	{
431 		const struct ubifs_ref_node *ref = node;
432 
433 		pr_err("\tlnum           %u\n", le32_to_cpu(ref->lnum));
434 		pr_err("\toffs           %u\n", le32_to_cpu(ref->offs));
435 		pr_err("\tjhead          %u\n", le32_to_cpu(ref->jhead));
436 		break;
437 	}
438 	case UBIFS_INO_NODE:
439 	{
440 		const struct ubifs_ino_node *ino = node;
441 
442 		key_read(c, &ino->key, &key);
443 		pr_err("\tkey            %s\n",
444 		       dbg_snprintf_key(c, &key, key_buf, DBG_KEY_BUF_LEN));
445 		pr_err("\tcreat_sqnum    %llu\n",
446 		       (unsigned long long)le64_to_cpu(ino->creat_sqnum));
447 		pr_err("\tsize           %llu\n",
448 		       (unsigned long long)le64_to_cpu(ino->size));
449 		pr_err("\tnlink          %u\n", le32_to_cpu(ino->nlink));
450 		pr_err("\tatime          %lld.%u\n",
451 		       (long long)le64_to_cpu(ino->atime_sec),
452 		       le32_to_cpu(ino->atime_nsec));
453 		pr_err("\tmtime          %lld.%u\n",
454 		       (long long)le64_to_cpu(ino->mtime_sec),
455 		       le32_to_cpu(ino->mtime_nsec));
456 		pr_err("\tctime          %lld.%u\n",
457 		       (long long)le64_to_cpu(ino->ctime_sec),
458 		       le32_to_cpu(ino->ctime_nsec));
459 		pr_err("\tuid            %u\n", le32_to_cpu(ino->uid));
460 		pr_err("\tgid            %u\n", le32_to_cpu(ino->gid));
461 		pr_err("\tmode           %u\n", le32_to_cpu(ino->mode));
462 		pr_err("\tflags          %#x\n", le32_to_cpu(ino->flags));
463 		pr_err("\txattr_cnt      %u\n", le32_to_cpu(ino->xattr_cnt));
464 		pr_err("\txattr_size     %u\n", le32_to_cpu(ino->xattr_size));
465 		pr_err("\txattr_names    %u\n", le32_to_cpu(ino->xattr_names));
466 		pr_err("\tcompr_type     %#x\n",
467 		       (int)le16_to_cpu(ino->compr_type));
468 		pr_err("\tdata len       %u\n", le32_to_cpu(ino->data_len));
469 		break;
470 	}
471 	case UBIFS_DENT_NODE:
472 	case UBIFS_XENT_NODE:
473 	{
474 		const struct ubifs_dent_node *dent = node;
475 		int nlen = le16_to_cpu(dent->nlen);
476 
477 		key_read(c, &dent->key, &key);
478 		pr_err("\tkey            %s\n",
479 		       dbg_snprintf_key(c, &key, key_buf, DBG_KEY_BUF_LEN));
480 		pr_err("\tinum           %llu\n",
481 		       (unsigned long long)le64_to_cpu(dent->inum));
482 		pr_err("\ttype           %d\n", (int)dent->type);
483 		pr_err("\tnlen           %d\n", nlen);
484 		pr_err("\tname           ");
485 
486 		if (nlen > UBIFS_MAX_NLEN ||
487 		    nlen > safe_len - UBIFS_DENT_NODE_SZ)
488 			pr_err("(bad name length, not printing, bad or corrupted node)");
489 		else {
490 			for (i = 0; i < nlen && dent->name[i]; i++)
491 				pr_cont("%c", isprint(dent->name[i]) ?
492 					dent->name[i] : '?');
493 		}
494 		pr_cont("\n");
495 
496 		break;
497 	}
498 	case UBIFS_DATA_NODE:
499 	{
500 		const struct ubifs_data_node *dn = node;
501 
502 		key_read(c, &dn->key, &key);
503 		pr_err("\tkey            %s\n",
504 		       dbg_snprintf_key(c, &key, key_buf, DBG_KEY_BUF_LEN));
505 		pr_err("\tsize           %u\n", le32_to_cpu(dn->size));
506 		pr_err("\tcompr_typ      %d\n",
507 		       (int)le16_to_cpu(dn->compr_type));
508 		pr_err("\tdata size      %u\n",
509 		       le32_to_cpu(ch->len) - (unsigned int)UBIFS_DATA_NODE_SZ);
510 		pr_err("\tdata (length = %d):\n",
511 		       safe_len - (int)UBIFS_DATA_NODE_SZ);
512 		print_hex_dump(KERN_ERR, "\t", DUMP_PREFIX_OFFSET, 32, 1,
513 			       (void *)&dn->data,
514 			       safe_len - (int)UBIFS_DATA_NODE_SZ, 0);
515 		break;
516 	}
517 	case UBIFS_TRUN_NODE:
518 	{
519 		const struct ubifs_trun_node *trun = node;
520 
521 		pr_err("\tinum           %u\n", le32_to_cpu(trun->inum));
522 		pr_err("\told_size       %llu\n",
523 		       (unsigned long long)le64_to_cpu(trun->old_size));
524 		pr_err("\tnew_size       %llu\n",
525 		       (unsigned long long)le64_to_cpu(trun->new_size));
526 		break;
527 	}
528 	case UBIFS_IDX_NODE:
529 	{
530 		const struct ubifs_idx_node *idx = node;
531 		int max_child_cnt = (safe_len - UBIFS_IDX_NODE_SZ) /
532 				    (ubifs_idx_node_sz(c, 1) -
533 				    UBIFS_IDX_NODE_SZ);
534 
535 		n = min_t(int, le16_to_cpu(idx->child_cnt), max_child_cnt);
536 		pr_err("\tchild_cnt      %d\n", (int)le16_to_cpu(idx->child_cnt));
537 		pr_err("\tlevel          %d\n", (int)le16_to_cpu(idx->level));
538 		pr_err("\tBranches:\n");
539 
540 		for (i = 0; i < n && i < c->fanout; i++) {
541 			const struct ubifs_branch *br;
542 
543 			br = ubifs_idx_branch(c, idx, i);
544 			key_read(c, &br->key, &key);
545 			pr_err("\t%d: LEB %d:%d len %d key %s\n",
546 			       i, le32_to_cpu(br->lnum), le32_to_cpu(br->offs),
547 			       le32_to_cpu(br->len),
548 			       dbg_snprintf_key(c, &key, key_buf,
549 						DBG_KEY_BUF_LEN));
550 		}
551 		break;
552 	}
553 	case UBIFS_CS_NODE:
554 		break;
555 	case UBIFS_ORPH_NODE:
556 	{
557 		const struct ubifs_orph_node *orph = node;
558 
559 		pr_err("\tcommit number  %llu\n",
560 		       (unsigned long long)
561 				le64_to_cpu(orph->cmt_no) & LLONG_MAX);
562 		pr_err("\tlast node flag %llu\n",
563 		       (unsigned long long)(le64_to_cpu(orph->cmt_no)) >> 63);
564 		n = (safe_len - UBIFS_ORPH_NODE_SZ) >> 3;
565 		pr_err("\t%d orphan inode numbers:\n", n);
566 		for (i = 0; i < n; i++)
567 			pr_err("\t  ino %llu\n",
568 			       (unsigned long long)le64_to_cpu(orph->inos[i]));
569 		break;
570 	}
571 	case UBIFS_AUTH_NODE:
572 	{
573 		break;
574 	}
575 	default:
576 		pr_err("node type %d was not recognized\n", type);
577 	}
578 
579 out_unlock:
580 	spin_unlock(&dbg_lock);
581 }
582 
ubifs_dump_budget_req(const struct ubifs_budget_req * req)583 void ubifs_dump_budget_req(const struct ubifs_budget_req *req)
584 {
585 	spin_lock(&dbg_lock);
586 	pr_err("Budgeting request: new_ino %d, dirtied_ino %d\n",
587 	       req->new_ino, req->dirtied_ino);
588 	pr_err("\tnew_ino_d   %d, dirtied_ino_d %d\n",
589 	       req->new_ino_d, req->dirtied_ino_d);
590 	pr_err("\tnew_page    %d, dirtied_page %d\n",
591 	       req->new_page, req->dirtied_page);
592 	pr_err("\tnew_dent    %d, mod_dent     %d\n",
593 	       req->new_dent, req->mod_dent);
594 	pr_err("\tidx_growth  %d\n", req->idx_growth);
595 	pr_err("\tdata_growth %d dd_growth     %d\n",
596 	       req->data_growth, req->dd_growth);
597 	spin_unlock(&dbg_lock);
598 }
599 
ubifs_dump_lstats(const struct ubifs_lp_stats * lst)600 void ubifs_dump_lstats(const struct ubifs_lp_stats *lst)
601 {
602 	spin_lock(&dbg_lock);
603 	pr_err("(pid %d) Lprops statistics: empty_lebs %d, idx_lebs  %d\n",
604 	       current->pid, lst->empty_lebs, lst->idx_lebs);
605 	pr_err("\ttaken_empty_lebs %d, total_free %lld, total_dirty %lld\n",
606 	       lst->taken_empty_lebs, lst->total_free, lst->total_dirty);
607 	pr_err("\ttotal_used %lld, total_dark %lld, total_dead %lld\n",
608 	       lst->total_used, lst->total_dark, lst->total_dead);
609 	spin_unlock(&dbg_lock);
610 }
611 
ubifs_dump_budg(struct ubifs_info * c,const struct ubifs_budg_info * bi)612 void ubifs_dump_budg(struct ubifs_info *c, const struct ubifs_budg_info *bi)
613 {
614 	int i;
615 	struct rb_node *rb;
616 	struct ubifs_bud *bud;
617 	struct ubifs_gced_idx_leb *idx_gc;
618 	long long available, outstanding, free;
619 
620 	spin_lock(&c->space_lock);
621 	spin_lock(&dbg_lock);
622 	pr_err("(pid %d) Budgeting info: data budget sum %lld, total budget sum %lld\n",
623 	       current->pid, bi->data_growth + bi->dd_growth,
624 	       bi->data_growth + bi->dd_growth + bi->idx_growth);
625 	pr_err("\tbudg_data_growth %lld, budg_dd_growth %lld, budg_idx_growth %lld\n",
626 	       bi->data_growth, bi->dd_growth, bi->idx_growth);
627 	pr_err("\tmin_idx_lebs %d, old_idx_sz %llu, uncommitted_idx %lld\n",
628 	       bi->min_idx_lebs, bi->old_idx_sz, bi->uncommitted_idx);
629 	pr_err("\tpage_budget %d, inode_budget %d, dent_budget %d\n",
630 	       bi->page_budget, bi->inode_budget, bi->dent_budget);
631 	pr_err("\tnospace %u, nospace_rp %u\n", bi->nospace, bi->nospace_rp);
632 	pr_err("\tdark_wm %d, dead_wm %d, max_idx_node_sz %d\n",
633 	       c->dark_wm, c->dead_wm, c->max_idx_node_sz);
634 
635 	if (bi != &c->bi)
636 		/*
637 		 * If we are dumping saved budgeting data, do not print
638 		 * additional information which is about the current state, not
639 		 * the old one which corresponded to the saved budgeting data.
640 		 */
641 		goto out_unlock;
642 
643 	pr_err("\tfreeable_cnt %d, calc_idx_sz %lld, idx_gc_cnt %d\n",
644 	       c->freeable_cnt, c->calc_idx_sz, c->idx_gc_cnt);
645 	pr_err("\tdirty_pg_cnt %ld, dirty_zn_cnt %ld, clean_zn_cnt %ld\n",
646 	       atomic_long_read(&c->dirty_pg_cnt),
647 	       atomic_long_read(&c->dirty_zn_cnt),
648 	       atomic_long_read(&c->clean_zn_cnt));
649 	pr_err("\tgc_lnum %d, ihead_lnum %d\n", c->gc_lnum, c->ihead_lnum);
650 
651 	/* If we are in R/O mode, journal heads do not exist */
652 	if (c->jheads)
653 		for (i = 0; i < c->jhead_cnt; i++)
654 			pr_err("\tjhead %s\t LEB %d\n",
655 			       dbg_jhead(c->jheads[i].wbuf.jhead),
656 			       c->jheads[i].wbuf.lnum);
657 	for (rb = rb_first(&c->buds); rb; rb = rb_next(rb)) {
658 		bud = rb_entry(rb, struct ubifs_bud, rb);
659 		pr_err("\tbud LEB %d\n", bud->lnum);
660 	}
661 	list_for_each_entry(bud, &c->old_buds, list)
662 		pr_err("\told bud LEB %d\n", bud->lnum);
663 	list_for_each_entry(idx_gc, &c->idx_gc, list)
664 		pr_err("\tGC'ed idx LEB %d unmap %d\n",
665 		       idx_gc->lnum, idx_gc->unmap);
666 	pr_err("\tcommit state %d\n", c->cmt_state);
667 
668 	/* Print budgeting predictions */
669 	available = ubifs_calc_available(c, c->bi.min_idx_lebs);
670 	outstanding = c->bi.data_growth + c->bi.dd_growth;
671 	free = ubifs_get_free_space_nolock(c);
672 	pr_err("Budgeting predictions:\n");
673 	pr_err("\tavailable: %lld, outstanding %lld, free %lld\n",
674 	       available, outstanding, free);
675 out_unlock:
676 	spin_unlock(&dbg_lock);
677 	spin_unlock(&c->space_lock);
678 }
679 
ubifs_dump_lprop(const struct ubifs_info * c,const struct ubifs_lprops * lp)680 void ubifs_dump_lprop(const struct ubifs_info *c, const struct ubifs_lprops *lp)
681 {
682 	int i, spc, dark = 0, dead = 0;
683 	struct rb_node *rb;
684 	struct ubifs_bud *bud;
685 
686 	spc = lp->free + lp->dirty;
687 	if (spc < c->dead_wm)
688 		dead = spc;
689 	else
690 		dark = ubifs_calc_dark(c, spc);
691 
692 	if (lp->flags & LPROPS_INDEX)
693 		pr_err("LEB %-7d free %-8d dirty %-8d used %-8d free + dirty %-8d flags %#x (",
694 		       lp->lnum, lp->free, lp->dirty, c->leb_size - spc, spc,
695 		       lp->flags);
696 	else
697 		pr_err("LEB %-7d free %-8d dirty %-8d used %-8d free + dirty %-8d dark %-4d dead %-4d nodes fit %-3d flags %#-4x (",
698 		       lp->lnum, lp->free, lp->dirty, c->leb_size - spc, spc,
699 		       dark, dead, (int)(spc / UBIFS_MAX_NODE_SZ), lp->flags);
700 
701 	if (lp->flags & LPROPS_TAKEN) {
702 		if (lp->flags & LPROPS_INDEX)
703 			pr_cont("index, taken");
704 		else
705 			pr_cont("taken");
706 	} else {
707 		const char *s;
708 
709 		if (lp->flags & LPROPS_INDEX) {
710 			switch (lp->flags & LPROPS_CAT_MASK) {
711 			case LPROPS_DIRTY_IDX:
712 				s = "dirty index";
713 				break;
714 			case LPROPS_FRDI_IDX:
715 				s = "freeable index";
716 				break;
717 			default:
718 				s = "index";
719 			}
720 		} else {
721 			switch (lp->flags & LPROPS_CAT_MASK) {
722 			case LPROPS_UNCAT:
723 				s = "not categorized";
724 				break;
725 			case LPROPS_DIRTY:
726 				s = "dirty";
727 				break;
728 			case LPROPS_FREE:
729 				s = "free";
730 				break;
731 			case LPROPS_EMPTY:
732 				s = "empty";
733 				break;
734 			case LPROPS_FREEABLE:
735 				s = "freeable";
736 				break;
737 			default:
738 				s = NULL;
739 				break;
740 			}
741 		}
742 		pr_cont("%s", s);
743 	}
744 
745 	for (rb = rb_first((struct rb_root *)&c->buds); rb; rb = rb_next(rb)) {
746 		bud = rb_entry(rb, struct ubifs_bud, rb);
747 		if (bud->lnum == lp->lnum) {
748 			int head = 0;
749 			for (i = 0; i < c->jhead_cnt; i++) {
750 				/*
751 				 * Note, if we are in R/O mode or in the middle
752 				 * of mounting/re-mounting, the write-buffers do
753 				 * not exist.
754 				 */
755 				if (c->jheads &&
756 				    lp->lnum == c->jheads[i].wbuf.lnum) {
757 					pr_cont(", jhead %s", dbg_jhead(i));
758 					head = 1;
759 				}
760 			}
761 			if (!head)
762 				pr_cont(", bud of jhead %s",
763 				       dbg_jhead(bud->jhead));
764 		}
765 	}
766 	if (lp->lnum == c->gc_lnum)
767 		pr_cont(", GC LEB");
768 	pr_cont(")\n");
769 }
770 
ubifs_dump_lprops(struct ubifs_info * c)771 void ubifs_dump_lprops(struct ubifs_info *c)
772 {
773 	int lnum, err;
774 	struct ubifs_lprops lp;
775 	struct ubifs_lp_stats lst;
776 
777 	pr_err("(pid %d) start dumping LEB properties\n", current->pid);
778 	ubifs_get_lp_stats(c, &lst);
779 	ubifs_dump_lstats(&lst);
780 
781 	for (lnum = c->main_first; lnum < c->leb_cnt; lnum++) {
782 		err = ubifs_read_one_lp(c, lnum, &lp);
783 		if (err) {
784 			ubifs_err(c, "cannot read lprops for LEB %d", lnum);
785 			continue;
786 		}
787 
788 		ubifs_dump_lprop(c, &lp);
789 	}
790 	pr_err("(pid %d) finish dumping LEB properties\n", current->pid);
791 }
792 
ubifs_dump_lpt_info(struct ubifs_info * c)793 void ubifs_dump_lpt_info(struct ubifs_info *c)
794 {
795 	int i;
796 
797 	spin_lock(&dbg_lock);
798 	pr_err("(pid %d) dumping LPT information\n", current->pid);
799 	pr_err("\tlpt_sz:        %lld\n", c->lpt_sz);
800 	pr_err("\tpnode_sz:      %d\n", c->pnode_sz);
801 	pr_err("\tnnode_sz:      %d\n", c->nnode_sz);
802 	pr_err("\tltab_sz:       %d\n", c->ltab_sz);
803 	pr_err("\tlsave_sz:      %d\n", c->lsave_sz);
804 	pr_err("\tbig_lpt:       %u\n", c->big_lpt);
805 	pr_err("\tlpt_hght:      %d\n", c->lpt_hght);
806 	pr_err("\tpnode_cnt:     %d\n", c->pnode_cnt);
807 	pr_err("\tnnode_cnt:     %d\n", c->nnode_cnt);
808 	pr_err("\tdirty_pn_cnt:  %d\n", c->dirty_pn_cnt);
809 	pr_err("\tdirty_nn_cnt:  %d\n", c->dirty_nn_cnt);
810 	pr_err("\tlsave_cnt:     %d\n", c->lsave_cnt);
811 	pr_err("\tspace_bits:    %d\n", c->space_bits);
812 	pr_err("\tlpt_lnum_bits: %d\n", c->lpt_lnum_bits);
813 	pr_err("\tlpt_offs_bits: %d\n", c->lpt_offs_bits);
814 	pr_err("\tlpt_spc_bits:  %d\n", c->lpt_spc_bits);
815 	pr_err("\tpcnt_bits:     %d\n", c->pcnt_bits);
816 	pr_err("\tlnum_bits:     %d\n", c->lnum_bits);
817 	pr_err("\tLPT root is at %d:%d\n", c->lpt_lnum, c->lpt_offs);
818 	pr_err("\tLPT head is at %d:%d\n",
819 	       c->nhead_lnum, c->nhead_offs);
820 	pr_err("\tLPT ltab is at %d:%d\n", c->ltab_lnum, c->ltab_offs);
821 	if (c->big_lpt)
822 		pr_err("\tLPT lsave is at %d:%d\n",
823 		       c->lsave_lnum, c->lsave_offs);
824 	for (i = 0; i < c->lpt_lebs; i++)
825 		pr_err("\tLPT LEB %d free %d dirty %d tgc %d cmt %d\n",
826 		       i + c->lpt_first, c->ltab[i].free, c->ltab[i].dirty,
827 		       c->ltab[i].tgc, c->ltab[i].cmt);
828 	spin_unlock(&dbg_lock);
829 }
830 
ubifs_dump_leb(const struct ubifs_info * c,int lnum)831 void ubifs_dump_leb(const struct ubifs_info *c, int lnum)
832 {
833 	struct ubifs_scan_leb *sleb;
834 	struct ubifs_scan_node *snod;
835 	void *buf;
836 
837 	pr_err("(pid %d) start dumping LEB %d\n", current->pid, lnum);
838 
839 	buf = __vmalloc(c->leb_size, GFP_NOFS);
840 	if (!buf) {
841 		ubifs_err(c, "cannot allocate memory for dumping LEB %d", lnum);
842 		return;
843 	}
844 
845 	sleb = ubifs_scan(c, lnum, 0, buf, 0);
846 	if (IS_ERR(sleb)) {
847 		ubifs_err(c, "scan error %d", (int)PTR_ERR(sleb));
848 		goto out;
849 	}
850 
851 	pr_err("LEB %d has %d nodes ending at %d\n", lnum,
852 	       sleb->nodes_cnt, sleb->endpt);
853 
854 	list_for_each_entry(snod, &sleb->nodes, list) {
855 		cond_resched();
856 		pr_err("Dumping node at LEB %d:%d len %d\n", lnum,
857 		       snod->offs, snod->len);
858 		ubifs_dump_node(c, snod->node, c->leb_size - snod->offs);
859 	}
860 
861 	pr_err("(pid %d) finish dumping LEB %d\n", current->pid, lnum);
862 	ubifs_scan_destroy(sleb);
863 
864 out:
865 	vfree(buf);
866 	return;
867 }
868 
ubifs_dump_znode(const struct ubifs_info * c,const struct ubifs_znode * znode)869 void ubifs_dump_znode(const struct ubifs_info *c,
870 		      const struct ubifs_znode *znode)
871 {
872 	int n;
873 	const struct ubifs_zbranch *zbr;
874 	char key_buf[DBG_KEY_BUF_LEN];
875 
876 	spin_lock(&dbg_lock);
877 	if (znode->parent)
878 		zbr = &znode->parent->zbranch[znode->iip];
879 	else
880 		zbr = &c->zroot;
881 
882 	pr_err("znode %p, LEB %d:%d len %d parent %p iip %d level %d child_cnt %d flags %lx\n",
883 	       znode, zbr->lnum, zbr->offs, zbr->len, znode->parent, znode->iip,
884 	       znode->level, znode->child_cnt, znode->flags);
885 
886 	if (znode->child_cnt <= 0 || znode->child_cnt > c->fanout) {
887 		spin_unlock(&dbg_lock);
888 		return;
889 	}
890 
891 	pr_err("zbranches:\n");
892 	for (n = 0; n < znode->child_cnt; n++) {
893 		zbr = &znode->zbranch[n];
894 		if (znode->level > 0)
895 			pr_err("\t%d: znode %p LEB %d:%d len %d key %s\n",
896 			       n, zbr->znode, zbr->lnum, zbr->offs, zbr->len,
897 			       dbg_snprintf_key(c, &zbr->key, key_buf,
898 						DBG_KEY_BUF_LEN));
899 		else
900 			pr_err("\t%d: LNC %p LEB %d:%d len %d key %s\n",
901 			       n, zbr->znode, zbr->lnum, zbr->offs, zbr->len,
902 			       dbg_snprintf_key(c, &zbr->key, key_buf,
903 						DBG_KEY_BUF_LEN));
904 	}
905 	spin_unlock(&dbg_lock);
906 }
907 
ubifs_dump_heap(struct ubifs_info * c,struct ubifs_lpt_heap * heap,int cat)908 void ubifs_dump_heap(struct ubifs_info *c, struct ubifs_lpt_heap *heap, int cat)
909 {
910 	int i;
911 
912 	pr_err("(pid %d) start dumping heap cat %d (%d elements)\n",
913 	       current->pid, cat, heap->cnt);
914 	for (i = 0; i < heap->cnt; i++) {
915 		struct ubifs_lprops *lprops = heap->arr[i];
916 
917 		pr_err("\t%d. LEB %d hpos %d free %d dirty %d flags %d\n",
918 		       i, lprops->lnum, lprops->hpos, lprops->free,
919 		       lprops->dirty, lprops->flags);
920 	}
921 	pr_err("(pid %d) finish dumping heap\n", current->pid);
922 }
923 
ubifs_dump_pnode(struct ubifs_info * c,struct ubifs_pnode * pnode,struct ubifs_nnode * parent,int iip)924 void ubifs_dump_pnode(struct ubifs_info *c, struct ubifs_pnode *pnode,
925 		      struct ubifs_nnode *parent, int iip)
926 {
927 	int i;
928 
929 	pr_err("(pid %d) dumping pnode:\n", current->pid);
930 	pr_err("\taddress %zx parent %zx cnext %zx\n",
931 	       (size_t)pnode, (size_t)parent, (size_t)pnode->cnext);
932 	pr_err("\tflags %lu iip %d level %d num %d\n",
933 	       pnode->flags, iip, pnode->level, pnode->num);
934 	for (i = 0; i < UBIFS_LPT_FANOUT; i++) {
935 		struct ubifs_lprops *lp = &pnode->lprops[i];
936 
937 		pr_err("\t%d: free %d dirty %d flags %d lnum %d\n",
938 		       i, lp->free, lp->dirty, lp->flags, lp->lnum);
939 	}
940 }
941 
ubifs_dump_tnc(struct ubifs_info * c)942 void ubifs_dump_tnc(struct ubifs_info *c)
943 {
944 	struct ubifs_znode *znode;
945 	int level;
946 
947 	pr_err("\n");
948 	pr_err("(pid %d) start dumping TNC tree\n", current->pid);
949 	if (c->zroot.znode) {
950 		znode = ubifs_tnc_levelorder_next(c, c->zroot.znode, NULL);
951 		level = znode->level;
952 		pr_err("== Level %d ==\n", level);
953 		while (znode) {
954 			if (level != znode->level) {
955 				level = znode->level;
956 				pr_err("== Level %d ==\n", level);
957 			}
958 			ubifs_dump_znode(c, znode);
959 			znode = ubifs_tnc_levelorder_next(c, c->zroot.znode, znode);
960 		}
961 	} else {
962 		pr_err("empty TNC tree in memory\n");
963 	}
964 	pr_err("(pid %d) finish dumping TNC tree\n", current->pid);
965 }
966 
dump_znode(struct ubifs_info * c,struct ubifs_znode * znode,void * priv)967 static int dump_znode(struct ubifs_info *c, struct ubifs_znode *znode,
968 		      void *priv)
969 {
970 	ubifs_dump_znode(c, znode);
971 	return 0;
972 }
973 
974 /**
975  * ubifs_dump_index - dump the on-flash index.
976  * @c: UBIFS file-system description object
977  *
978  * This function dumps whole UBIFS indexing B-tree, unlike 'ubifs_dump_tnc()'
979  * which dumps only in-memory znodes and does not read znodes which from flash.
980  */
ubifs_dump_index(struct ubifs_info * c)981 void ubifs_dump_index(struct ubifs_info *c)
982 {
983 	dbg_walk_index(c, NULL, dump_znode, NULL);
984 }
985 
986 /**
987  * dbg_save_space_info - save information about flash space.
988  * @c: UBIFS file-system description object
989  *
990  * This function saves information about UBIFS free space, dirty space, etc, in
991  * order to check it later.
992  */
dbg_save_space_info(struct ubifs_info * c)993 void dbg_save_space_info(struct ubifs_info *c)
994 {
995 	struct ubifs_debug_info *d = c->dbg;
996 	int freeable_cnt;
997 
998 	spin_lock(&c->space_lock);
999 	memcpy(&d->saved_lst, &c->lst, sizeof(struct ubifs_lp_stats));
1000 	memcpy(&d->saved_bi, &c->bi, sizeof(struct ubifs_budg_info));
1001 	d->saved_idx_gc_cnt = c->idx_gc_cnt;
1002 
1003 	/*
1004 	 * We use a dirty hack here and zero out @c->freeable_cnt, because it
1005 	 * affects the free space calculations, and UBIFS might not know about
1006 	 * all freeable eraseblocks. Indeed, we know about freeable eraseblocks
1007 	 * only when we read their lprops, and we do this only lazily, upon the
1008 	 * need. So at any given point of time @c->freeable_cnt might be not
1009 	 * exactly accurate.
1010 	 *
1011 	 * Just one example about the issue we hit when we did not zero
1012 	 * @c->freeable_cnt.
1013 	 * 1. The file-system is mounted R/O, c->freeable_cnt is %0. We save the
1014 	 *    amount of free space in @d->saved_free
1015 	 * 2. We re-mount R/W, which makes UBIFS to read the "lsave"
1016 	 *    information from flash, where we cache LEBs from various
1017 	 *    categories ('ubifs_remount_fs()' -> 'ubifs_lpt_init()'
1018 	 *    -> 'lpt_init_wr()' -> 'read_lsave()' -> 'ubifs_lpt_lookup()'
1019 	 *    -> 'ubifs_get_pnode()' -> 'update_cats()'
1020 	 *    -> 'ubifs_add_to_cat()').
1021 	 * 3. Lsave contains a freeable eraseblock, and @c->freeable_cnt
1022 	 *    becomes %1.
1023 	 * 4. We calculate the amount of free space when the re-mount is
1024 	 *    finished in 'dbg_check_space_info()' and it does not match
1025 	 *    @d->saved_free.
1026 	 */
1027 	freeable_cnt = c->freeable_cnt;
1028 	c->freeable_cnt = 0;
1029 	d->saved_free = ubifs_get_free_space_nolock(c);
1030 	c->freeable_cnt = freeable_cnt;
1031 	spin_unlock(&c->space_lock);
1032 }
1033 
1034 /**
1035  * dbg_check_space_info - check flash space information.
1036  * @c: UBIFS file-system description object
1037  *
1038  * This function compares current flash space information with the information
1039  * which was saved when the 'dbg_save_space_info()' function was called.
1040  * Returns zero if the information has not changed, and %-EINVAL if it has
1041  * changed.
1042  */
dbg_check_space_info(struct ubifs_info * c)1043 int dbg_check_space_info(struct ubifs_info *c)
1044 {
1045 	struct ubifs_debug_info *d = c->dbg;
1046 	struct ubifs_lp_stats lst;
1047 	long long free;
1048 	int freeable_cnt;
1049 
1050 	spin_lock(&c->space_lock);
1051 	freeable_cnt = c->freeable_cnt;
1052 	c->freeable_cnt = 0;
1053 	free = ubifs_get_free_space_nolock(c);
1054 	c->freeable_cnt = freeable_cnt;
1055 	spin_unlock(&c->space_lock);
1056 
1057 	if (free != d->saved_free) {
1058 		ubifs_err(c, "free space changed from %lld to %lld",
1059 			  d->saved_free, free);
1060 		goto out;
1061 	}
1062 
1063 	return 0;
1064 
1065 out:
1066 	ubifs_msg(c, "saved lprops statistics dump");
1067 	ubifs_dump_lstats(&d->saved_lst);
1068 	ubifs_msg(c, "saved budgeting info dump");
1069 	ubifs_dump_budg(c, &d->saved_bi);
1070 	ubifs_msg(c, "saved idx_gc_cnt %d", d->saved_idx_gc_cnt);
1071 	ubifs_msg(c, "current lprops statistics dump");
1072 	ubifs_get_lp_stats(c, &lst);
1073 	ubifs_dump_lstats(&lst);
1074 	ubifs_msg(c, "current budgeting info dump");
1075 	ubifs_dump_budg(c, &c->bi);
1076 	dump_stack();
1077 	return -EINVAL;
1078 }
1079 
1080 /**
1081  * dbg_check_synced_i_size - check synchronized inode size.
1082  * @c: UBIFS file-system description object
1083  * @inode: inode to check
1084  *
1085  * If inode is clean, synchronized inode size has to be equivalent to current
1086  * inode size. This function has to be called only for locked inodes (@i_mutex
1087  * has to be locked). Returns %0 if synchronized inode size if correct, and
1088  * %-EINVAL if not.
1089  */
dbg_check_synced_i_size(const struct ubifs_info * c,struct inode * inode)1090 int dbg_check_synced_i_size(const struct ubifs_info *c, struct inode *inode)
1091 {
1092 	int err = 0;
1093 	struct ubifs_inode *ui = ubifs_inode(inode);
1094 
1095 	if (!dbg_is_chk_gen(c))
1096 		return 0;
1097 	if (!S_ISREG(inode->i_mode))
1098 		return 0;
1099 
1100 	mutex_lock(&ui->ui_mutex);
1101 	spin_lock(&ui->ui_lock);
1102 	if (ui->ui_size != ui->synced_i_size && !ui->dirty) {
1103 		ubifs_err(c, "ui_size is %lld, synced_i_size is %lld, but inode is clean",
1104 			  ui->ui_size, ui->synced_i_size);
1105 		ubifs_err(c, "i_ino %lu, i_mode %#x, i_size %lld", inode->i_ino,
1106 			  inode->i_mode, i_size_read(inode));
1107 		dump_stack();
1108 		err = -EINVAL;
1109 	}
1110 	spin_unlock(&ui->ui_lock);
1111 	mutex_unlock(&ui->ui_mutex);
1112 	return err;
1113 }
1114 
1115 /*
1116  * dbg_check_dir - check directory inode size and link count.
1117  * @c: UBIFS file-system description object
1118  * @dir: the directory to calculate size for
1119  * @size: the result is returned here
1120  *
1121  * This function makes sure that directory size and link count are correct.
1122  * Returns zero in case of success and a negative error code in case of
1123  * failure.
1124  *
1125  * Note, it is good idea to make sure the @dir->i_mutex is locked before
1126  * calling this function.
1127  */
dbg_check_dir(struct ubifs_info * c,const struct inode * dir)1128 int dbg_check_dir(struct ubifs_info *c, const struct inode *dir)
1129 {
1130 	unsigned int nlink = 2;
1131 	union ubifs_key key;
1132 	struct ubifs_dent_node *dent, *pdent = NULL;
1133 	struct fscrypt_name nm = {0};
1134 	loff_t size = UBIFS_INO_NODE_SZ;
1135 
1136 	if (!dbg_is_chk_gen(c))
1137 		return 0;
1138 
1139 	if (!S_ISDIR(dir->i_mode))
1140 		return 0;
1141 
1142 	lowest_dent_key(c, &key, dir->i_ino);
1143 	while (1) {
1144 		int err;
1145 
1146 		dent = ubifs_tnc_next_ent(c, &key, &nm);
1147 		if (IS_ERR(dent)) {
1148 			err = PTR_ERR(dent);
1149 			if (err == -ENOENT)
1150 				break;
1151 			kfree(pdent);
1152 			return err;
1153 		}
1154 
1155 		fname_name(&nm) = dent->name;
1156 		fname_len(&nm) = le16_to_cpu(dent->nlen);
1157 		size += CALC_DENT_SIZE(fname_len(&nm));
1158 		if (dent->type == UBIFS_ITYPE_DIR)
1159 			nlink += 1;
1160 		kfree(pdent);
1161 		pdent = dent;
1162 		key_read(c, &dent->key, &key);
1163 	}
1164 	kfree(pdent);
1165 
1166 	if (i_size_read(dir) != size) {
1167 		ubifs_err(c, "directory inode %lu has size %llu, but calculated size is %llu",
1168 			  dir->i_ino, (unsigned long long)i_size_read(dir),
1169 			  (unsigned long long)size);
1170 		ubifs_dump_inode(c, dir);
1171 		dump_stack();
1172 		return -EINVAL;
1173 	}
1174 	if (dir->i_nlink != nlink) {
1175 		ubifs_err(c, "directory inode %lu has nlink %u, but calculated nlink is %u",
1176 			  dir->i_ino, dir->i_nlink, nlink);
1177 		ubifs_dump_inode(c, dir);
1178 		dump_stack();
1179 		return -EINVAL;
1180 	}
1181 
1182 	return 0;
1183 }
1184 
1185 /**
1186  * dbg_check_key_order - make sure that colliding keys are properly ordered.
1187  * @c: UBIFS file-system description object
1188  * @zbr1: first zbranch
1189  * @zbr2: following zbranch
1190  *
1191  * In UBIFS indexing B-tree colliding keys has to be sorted in binary order of
1192  * names of the direntries/xentries which are referred by the keys. This
1193  * function reads direntries/xentries referred by @zbr1 and @zbr2 and makes
1194  * sure the name of direntry/xentry referred by @zbr1 is less than
1195  * direntry/xentry referred by @zbr2. Returns zero if this is true, %1 if not,
1196  * and a negative error code in case of failure.
1197  */
dbg_check_key_order(struct ubifs_info * c,struct ubifs_zbranch * zbr1,struct ubifs_zbranch * zbr2)1198 static int dbg_check_key_order(struct ubifs_info *c, struct ubifs_zbranch *zbr1,
1199 			       struct ubifs_zbranch *zbr2)
1200 {
1201 	int err, nlen1, nlen2, cmp;
1202 	struct ubifs_dent_node *dent1, *dent2;
1203 	union ubifs_key key;
1204 	char key_buf[DBG_KEY_BUF_LEN];
1205 
1206 	ubifs_assert(c, !keys_cmp(c, &zbr1->key, &zbr2->key));
1207 	dent1 = kmalloc(UBIFS_MAX_DENT_NODE_SZ, GFP_NOFS);
1208 	if (!dent1)
1209 		return -ENOMEM;
1210 	dent2 = kmalloc(UBIFS_MAX_DENT_NODE_SZ, GFP_NOFS);
1211 	if (!dent2) {
1212 		err = -ENOMEM;
1213 		goto out_free;
1214 	}
1215 
1216 	err = ubifs_tnc_read_node(c, zbr1, dent1);
1217 	if (err)
1218 		goto out_free;
1219 	err = ubifs_validate_entry(c, dent1);
1220 	if (err)
1221 		goto out_free;
1222 
1223 	err = ubifs_tnc_read_node(c, zbr2, dent2);
1224 	if (err)
1225 		goto out_free;
1226 	err = ubifs_validate_entry(c, dent2);
1227 	if (err)
1228 		goto out_free;
1229 
1230 	/* Make sure node keys are the same as in zbranch */
1231 	err = 1;
1232 	key_read(c, &dent1->key, &key);
1233 	if (keys_cmp(c, &zbr1->key, &key)) {
1234 		ubifs_err(c, "1st entry at %d:%d has key %s", zbr1->lnum,
1235 			  zbr1->offs, dbg_snprintf_key(c, &key, key_buf,
1236 						       DBG_KEY_BUF_LEN));
1237 		ubifs_err(c, "but it should have key %s according to tnc",
1238 			  dbg_snprintf_key(c, &zbr1->key, key_buf,
1239 					   DBG_KEY_BUF_LEN));
1240 		ubifs_dump_node(c, dent1, UBIFS_MAX_DENT_NODE_SZ);
1241 		goto out_free;
1242 	}
1243 
1244 	key_read(c, &dent2->key, &key);
1245 	if (keys_cmp(c, &zbr2->key, &key)) {
1246 		ubifs_err(c, "2nd entry at %d:%d has key %s", zbr1->lnum,
1247 			  zbr1->offs, dbg_snprintf_key(c, &key, key_buf,
1248 						       DBG_KEY_BUF_LEN));
1249 		ubifs_err(c, "but it should have key %s according to tnc",
1250 			  dbg_snprintf_key(c, &zbr2->key, key_buf,
1251 					   DBG_KEY_BUF_LEN));
1252 		ubifs_dump_node(c, dent2, UBIFS_MAX_DENT_NODE_SZ);
1253 		goto out_free;
1254 	}
1255 
1256 	nlen1 = le16_to_cpu(dent1->nlen);
1257 	nlen2 = le16_to_cpu(dent2->nlen);
1258 
1259 	cmp = memcmp(dent1->name, dent2->name, min_t(int, nlen1, nlen2));
1260 	if (cmp < 0 || (cmp == 0 && nlen1 < nlen2)) {
1261 		err = 0;
1262 		goto out_free;
1263 	}
1264 	if (cmp == 0 && nlen1 == nlen2)
1265 		ubifs_err(c, "2 xent/dent nodes with the same name");
1266 	else
1267 		ubifs_err(c, "bad order of colliding key %s",
1268 			  dbg_snprintf_key(c, &key, key_buf, DBG_KEY_BUF_LEN));
1269 
1270 	ubifs_msg(c, "first node at %d:%d\n", zbr1->lnum, zbr1->offs);
1271 	ubifs_dump_node(c, dent1, UBIFS_MAX_DENT_NODE_SZ);
1272 	ubifs_msg(c, "second node at %d:%d\n", zbr2->lnum, zbr2->offs);
1273 	ubifs_dump_node(c, dent2, UBIFS_MAX_DENT_NODE_SZ);
1274 
1275 out_free:
1276 	kfree(dent2);
1277 	kfree(dent1);
1278 	return err;
1279 }
1280 
1281 /**
1282  * dbg_check_znode - check if znode is all right.
1283  * @c: UBIFS file-system description object
1284  * @zbr: zbranch which points to this znode
1285  *
1286  * This function makes sure that znode referred to by @zbr is all right.
1287  * Returns zero if it is, and %-EINVAL if it is not.
1288  */
dbg_check_znode(struct ubifs_info * c,struct ubifs_zbranch * zbr)1289 static int dbg_check_znode(struct ubifs_info *c, struct ubifs_zbranch *zbr)
1290 {
1291 	struct ubifs_znode *znode = zbr->znode;
1292 	struct ubifs_znode *zp = znode->parent;
1293 	int n, err, cmp;
1294 
1295 	if (znode->child_cnt <= 0 || znode->child_cnt > c->fanout) {
1296 		err = 1;
1297 		goto out;
1298 	}
1299 	if (znode->level < 0) {
1300 		err = 2;
1301 		goto out;
1302 	}
1303 	if (znode->iip < 0 || znode->iip >= c->fanout) {
1304 		err = 3;
1305 		goto out;
1306 	}
1307 
1308 	if (zbr->len == 0)
1309 		/* Only dirty zbranch may have no on-flash nodes */
1310 		if (!ubifs_zn_dirty(znode)) {
1311 			err = 4;
1312 			goto out;
1313 		}
1314 
1315 	if (ubifs_zn_dirty(znode)) {
1316 		/*
1317 		 * If znode is dirty, its parent has to be dirty as well. The
1318 		 * order of the operation is important, so we have to have
1319 		 * memory barriers.
1320 		 */
1321 		smp_mb();
1322 		if (zp && !ubifs_zn_dirty(zp)) {
1323 			/*
1324 			 * The dirty flag is atomic and is cleared outside the
1325 			 * TNC mutex, so znode's dirty flag may now have
1326 			 * been cleared. The child is always cleared before the
1327 			 * parent, so we just need to check again.
1328 			 */
1329 			smp_mb();
1330 			if (ubifs_zn_dirty(znode)) {
1331 				err = 5;
1332 				goto out;
1333 			}
1334 		}
1335 	}
1336 
1337 	if (zp) {
1338 		const union ubifs_key *min, *max;
1339 
1340 		if (znode->level != zp->level - 1) {
1341 			err = 6;
1342 			goto out;
1343 		}
1344 
1345 		/* Make sure the 'parent' pointer in our znode is correct */
1346 		err = ubifs_search_zbranch(c, zp, &zbr->key, &n);
1347 		if (!err) {
1348 			/* This zbranch does not exist in the parent */
1349 			err = 7;
1350 			goto out;
1351 		}
1352 
1353 		if (znode->iip >= zp->child_cnt) {
1354 			err = 8;
1355 			goto out;
1356 		}
1357 
1358 		if (znode->iip != n) {
1359 			/* This may happen only in case of collisions */
1360 			if (keys_cmp(c, &zp->zbranch[n].key,
1361 				     &zp->zbranch[znode->iip].key)) {
1362 				err = 9;
1363 				goto out;
1364 			}
1365 			n = znode->iip;
1366 		}
1367 
1368 		/*
1369 		 * Make sure that the first key in our znode is greater than or
1370 		 * equal to the key in the pointing zbranch.
1371 		 */
1372 		min = &zbr->key;
1373 		cmp = keys_cmp(c, min, &znode->zbranch[0].key);
1374 		if (cmp == 1) {
1375 			err = 10;
1376 			goto out;
1377 		}
1378 
1379 		if (n + 1 < zp->child_cnt) {
1380 			max = &zp->zbranch[n + 1].key;
1381 
1382 			/*
1383 			 * Make sure the last key in our znode is less or
1384 			 * equivalent than the key in the zbranch which goes
1385 			 * after our pointing zbranch.
1386 			 */
1387 			cmp = keys_cmp(c, max,
1388 				&znode->zbranch[znode->child_cnt - 1].key);
1389 			if (cmp == -1) {
1390 				err = 11;
1391 				goto out;
1392 			}
1393 		}
1394 	} else {
1395 		/* This may only be root znode */
1396 		if (zbr != &c->zroot) {
1397 			err = 12;
1398 			goto out;
1399 		}
1400 	}
1401 
1402 	/*
1403 	 * Make sure that next key is greater or equivalent then the previous
1404 	 * one.
1405 	 */
1406 	for (n = 1; n < znode->child_cnt; n++) {
1407 		cmp = keys_cmp(c, &znode->zbranch[n - 1].key,
1408 			       &znode->zbranch[n].key);
1409 		if (cmp > 0) {
1410 			err = 13;
1411 			goto out;
1412 		}
1413 		if (cmp == 0) {
1414 			/* This can only be keys with colliding hash */
1415 			if (!is_hash_key(c, &znode->zbranch[n].key)) {
1416 				err = 14;
1417 				goto out;
1418 			}
1419 
1420 			if (znode->level != 0 || c->replaying)
1421 				continue;
1422 
1423 			/*
1424 			 * Colliding keys should follow binary order of
1425 			 * corresponding xentry/dentry names.
1426 			 */
1427 			err = dbg_check_key_order(c, &znode->zbranch[n - 1],
1428 						  &znode->zbranch[n]);
1429 			if (err < 0)
1430 				return err;
1431 			if (err) {
1432 				err = 15;
1433 				goto out;
1434 			}
1435 		}
1436 	}
1437 
1438 	for (n = 0; n < znode->child_cnt; n++) {
1439 		if (!znode->zbranch[n].znode &&
1440 		    (znode->zbranch[n].lnum == 0 ||
1441 		     znode->zbranch[n].len == 0)) {
1442 			err = 16;
1443 			goto out;
1444 		}
1445 
1446 		if (znode->zbranch[n].lnum != 0 &&
1447 		    znode->zbranch[n].len == 0) {
1448 			err = 17;
1449 			goto out;
1450 		}
1451 
1452 		if (znode->zbranch[n].lnum == 0 &&
1453 		    znode->zbranch[n].len != 0) {
1454 			err = 18;
1455 			goto out;
1456 		}
1457 
1458 		if (znode->zbranch[n].lnum == 0 &&
1459 		    znode->zbranch[n].offs != 0) {
1460 			err = 19;
1461 			goto out;
1462 		}
1463 
1464 		if (znode->level != 0 && znode->zbranch[n].znode)
1465 			if (znode->zbranch[n].znode->parent != znode) {
1466 				err = 20;
1467 				goto out;
1468 			}
1469 	}
1470 
1471 	return 0;
1472 
1473 out:
1474 	ubifs_err(c, "failed, error %d", err);
1475 	ubifs_msg(c, "dump of the znode");
1476 	ubifs_dump_znode(c, znode);
1477 	if (zp) {
1478 		ubifs_msg(c, "dump of the parent znode");
1479 		ubifs_dump_znode(c, zp);
1480 	}
1481 	dump_stack();
1482 	return -EINVAL;
1483 }
1484 
1485 /**
1486  * dbg_check_tnc - check TNC tree.
1487  * @c: UBIFS file-system description object
1488  * @extra: do extra checks that are possible at start commit
1489  *
1490  * This function traverses whole TNC tree and checks every znode. Returns zero
1491  * if everything is all right and %-EINVAL if something is wrong with TNC.
1492  */
dbg_check_tnc(struct ubifs_info * c,int extra)1493 int dbg_check_tnc(struct ubifs_info *c, int extra)
1494 {
1495 	struct ubifs_znode *znode;
1496 	long clean_cnt = 0, dirty_cnt = 0;
1497 	int err, last;
1498 
1499 	if (!dbg_is_chk_index(c))
1500 		return 0;
1501 
1502 	ubifs_assert(c, mutex_is_locked(&c->tnc_mutex));
1503 	if (!c->zroot.znode)
1504 		return 0;
1505 
1506 	znode = ubifs_tnc_postorder_first(c->zroot.znode);
1507 	while (1) {
1508 		struct ubifs_znode *prev;
1509 		struct ubifs_zbranch *zbr;
1510 
1511 		if (!znode->parent)
1512 			zbr = &c->zroot;
1513 		else
1514 			zbr = &znode->parent->zbranch[znode->iip];
1515 
1516 		err = dbg_check_znode(c, zbr);
1517 		if (err)
1518 			return err;
1519 
1520 		if (extra) {
1521 			if (ubifs_zn_dirty(znode))
1522 				dirty_cnt += 1;
1523 			else
1524 				clean_cnt += 1;
1525 		}
1526 
1527 		prev = znode;
1528 		znode = ubifs_tnc_postorder_next(c, znode);
1529 		if (!znode)
1530 			break;
1531 
1532 		/*
1533 		 * If the last key of this znode is equivalent to the first key
1534 		 * of the next znode (collision), then check order of the keys.
1535 		 */
1536 		last = prev->child_cnt - 1;
1537 		if (prev->level == 0 && znode->level == 0 && !c->replaying &&
1538 		    !keys_cmp(c, &prev->zbranch[last].key,
1539 			      &znode->zbranch[0].key)) {
1540 			err = dbg_check_key_order(c, &prev->zbranch[last],
1541 						  &znode->zbranch[0]);
1542 			if (err < 0)
1543 				return err;
1544 			if (err) {
1545 				ubifs_msg(c, "first znode");
1546 				ubifs_dump_znode(c, prev);
1547 				ubifs_msg(c, "second znode");
1548 				ubifs_dump_znode(c, znode);
1549 				return -EINVAL;
1550 			}
1551 		}
1552 	}
1553 
1554 	if (extra) {
1555 		if (clean_cnt != atomic_long_read(&c->clean_zn_cnt)) {
1556 			ubifs_err(c, "incorrect clean_zn_cnt %ld, calculated %ld",
1557 				  atomic_long_read(&c->clean_zn_cnt),
1558 				  clean_cnt);
1559 			return -EINVAL;
1560 		}
1561 		if (dirty_cnt != atomic_long_read(&c->dirty_zn_cnt)) {
1562 			ubifs_err(c, "incorrect dirty_zn_cnt %ld, calculated %ld",
1563 				  atomic_long_read(&c->dirty_zn_cnt),
1564 				  dirty_cnt);
1565 			return -EINVAL;
1566 		}
1567 	}
1568 
1569 	return 0;
1570 }
1571 
1572 /**
1573  * dbg_walk_index - walk the on-flash index.
1574  * @c: UBIFS file-system description object
1575  * @leaf_cb: called for each leaf node
1576  * @znode_cb: called for each indexing node
1577  * @priv: private data which is passed to callbacks
1578  *
1579  * This function walks the UBIFS index and calls the @leaf_cb for each leaf
1580  * node and @znode_cb for each indexing node. Returns zero in case of success
1581  * and a negative error code in case of failure.
1582  *
1583  * It would be better if this function removed every znode it pulled to into
1584  * the TNC, so that the behavior more closely matched the non-debugging
1585  * behavior.
1586  */
dbg_walk_index(struct ubifs_info * c,dbg_leaf_callback leaf_cb,dbg_znode_callback znode_cb,void * priv)1587 int dbg_walk_index(struct ubifs_info *c, dbg_leaf_callback leaf_cb,
1588 		   dbg_znode_callback znode_cb, void *priv)
1589 {
1590 	int err;
1591 	struct ubifs_zbranch *zbr;
1592 	struct ubifs_znode *znode, *child;
1593 
1594 	mutex_lock(&c->tnc_mutex);
1595 	/* If the root indexing node is not in TNC - pull it */
1596 	if (!c->zroot.znode) {
1597 		c->zroot.znode = ubifs_load_znode(c, &c->zroot, NULL, 0);
1598 		if (IS_ERR(c->zroot.znode)) {
1599 			err = PTR_ERR(c->zroot.znode);
1600 			c->zroot.znode = NULL;
1601 			goto out_unlock;
1602 		}
1603 	}
1604 
1605 	/*
1606 	 * We are going to traverse the indexing tree in the postorder manner.
1607 	 * Go down and find the leftmost indexing node where we are going to
1608 	 * start from.
1609 	 */
1610 	znode = c->zroot.znode;
1611 	while (znode->level > 0) {
1612 		zbr = &znode->zbranch[0];
1613 		child = zbr->znode;
1614 		if (!child) {
1615 			child = ubifs_load_znode(c, zbr, znode, 0);
1616 			if (IS_ERR(child)) {
1617 				err = PTR_ERR(child);
1618 				goto out_unlock;
1619 			}
1620 		}
1621 
1622 		znode = child;
1623 	}
1624 
1625 	/* Iterate over all indexing nodes */
1626 	while (1) {
1627 		int idx;
1628 
1629 		cond_resched();
1630 
1631 		if (znode_cb) {
1632 			err = znode_cb(c, znode, priv);
1633 			if (err) {
1634 				ubifs_err(c, "znode checking function returned error %d",
1635 					  err);
1636 				ubifs_dump_znode(c, znode);
1637 				goto out_dump;
1638 			}
1639 		}
1640 		if (leaf_cb && znode->level == 0) {
1641 			for (idx = 0; idx < znode->child_cnt; idx++) {
1642 				zbr = &znode->zbranch[idx];
1643 				err = leaf_cb(c, zbr, priv);
1644 				if (err) {
1645 					ubifs_err(c, "leaf checking function returned error %d, for leaf at LEB %d:%d",
1646 						  err, zbr->lnum, zbr->offs);
1647 					goto out_dump;
1648 				}
1649 			}
1650 		}
1651 
1652 		if (!znode->parent)
1653 			break;
1654 
1655 		idx = znode->iip + 1;
1656 		znode = znode->parent;
1657 		if (idx < znode->child_cnt) {
1658 			/* Switch to the next index in the parent */
1659 			zbr = &znode->zbranch[idx];
1660 			child = zbr->znode;
1661 			if (!child) {
1662 				child = ubifs_load_znode(c, zbr, znode, idx);
1663 				if (IS_ERR(child)) {
1664 					err = PTR_ERR(child);
1665 					goto out_unlock;
1666 				}
1667 				zbr->znode = child;
1668 			}
1669 			znode = child;
1670 		} else
1671 			/*
1672 			 * This is the last child, switch to the parent and
1673 			 * continue.
1674 			 */
1675 			continue;
1676 
1677 		/* Go to the lowest leftmost znode in the new sub-tree */
1678 		while (znode->level > 0) {
1679 			zbr = &znode->zbranch[0];
1680 			child = zbr->znode;
1681 			if (!child) {
1682 				child = ubifs_load_znode(c, zbr, znode, 0);
1683 				if (IS_ERR(child)) {
1684 					err = PTR_ERR(child);
1685 					goto out_unlock;
1686 				}
1687 				zbr->znode = child;
1688 			}
1689 			znode = child;
1690 		}
1691 	}
1692 
1693 	mutex_unlock(&c->tnc_mutex);
1694 	return 0;
1695 
1696 out_dump:
1697 	if (znode->parent)
1698 		zbr = &znode->parent->zbranch[znode->iip];
1699 	else
1700 		zbr = &c->zroot;
1701 	ubifs_msg(c, "dump of znode at LEB %d:%d", zbr->lnum, zbr->offs);
1702 	ubifs_dump_znode(c, znode);
1703 out_unlock:
1704 	mutex_unlock(&c->tnc_mutex);
1705 	return err;
1706 }
1707 
1708 /**
1709  * add_size - add znode size to partially calculated index size.
1710  * @c: UBIFS file-system description object
1711  * @znode: znode to add size for
1712  * @priv: partially calculated index size
1713  *
1714  * This is a helper function for 'dbg_check_idx_size()' which is called for
1715  * every indexing node and adds its size to the 'long long' variable pointed to
1716  * by @priv.
1717  */
add_size(struct ubifs_info * c,struct ubifs_znode * znode,void * priv)1718 static int add_size(struct ubifs_info *c, struct ubifs_znode *znode, void *priv)
1719 {
1720 	long long *idx_size = priv;
1721 	int add;
1722 
1723 	add = ubifs_idx_node_sz(c, znode->child_cnt);
1724 	add = ALIGN(add, 8);
1725 	*idx_size += add;
1726 	return 0;
1727 }
1728 
1729 /**
1730  * dbg_check_idx_size - check index size.
1731  * @c: UBIFS file-system description object
1732  * @idx_size: size to check
1733  *
1734  * This function walks the UBIFS index, calculates its size and checks that the
1735  * size is equivalent to @idx_size. Returns zero in case of success and a
1736  * negative error code in case of failure.
1737  */
dbg_check_idx_size(struct ubifs_info * c,long long idx_size)1738 int dbg_check_idx_size(struct ubifs_info *c, long long idx_size)
1739 {
1740 	int err;
1741 	long long calc = 0;
1742 
1743 	if (!dbg_is_chk_index(c))
1744 		return 0;
1745 
1746 	err = dbg_walk_index(c, NULL, add_size, &calc);
1747 	if (err) {
1748 		ubifs_err(c, "error %d while walking the index", err);
1749 		return err;
1750 	}
1751 
1752 	if (calc != idx_size) {
1753 		ubifs_err(c, "index size check failed: calculated size is %lld, should be %lld",
1754 			  calc, idx_size);
1755 		dump_stack();
1756 		return -EINVAL;
1757 	}
1758 
1759 	return 0;
1760 }
1761 
1762 /**
1763  * struct fsck_inode - information about an inode used when checking the file-system.
1764  * @rb: link in the RB-tree of inodes
1765  * @inum: inode number
1766  * @mode: inode type, permissions, etc
1767  * @nlink: inode link count
1768  * @xattr_cnt: count of extended attributes
1769  * @references: how many directory/xattr entries refer this inode (calculated
1770  *              while walking the index)
1771  * @calc_cnt: for directory inode count of child directories
1772  * @size: inode size (read from on-flash inode)
1773  * @xattr_sz: summary size of all extended attributes (read from on-flash
1774  *            inode)
1775  * @calc_sz: for directories calculated directory size
1776  * @calc_xcnt: count of extended attributes
1777  * @calc_xsz: calculated summary size of all extended attributes
1778  * @xattr_nms: sum of lengths of all extended attribute names belonging to this
1779  *             inode (read from on-flash inode)
1780  * @calc_xnms: calculated sum of lengths of all extended attribute names
1781  */
1782 struct fsck_inode {
1783 	struct rb_node rb;
1784 	ino_t inum;
1785 	umode_t mode;
1786 	unsigned int nlink;
1787 	unsigned int xattr_cnt;
1788 	int references;
1789 	int calc_cnt;
1790 	long long size;
1791 	unsigned int xattr_sz;
1792 	long long calc_sz;
1793 	long long calc_xcnt;
1794 	long long calc_xsz;
1795 	unsigned int xattr_nms;
1796 	long long calc_xnms;
1797 };
1798 
1799 /**
1800  * struct fsck_data - private FS checking information.
1801  * @inodes: RB-tree of all inodes (contains @struct fsck_inode objects)
1802  */
1803 struct fsck_data {
1804 	struct rb_root inodes;
1805 };
1806 
1807 /**
1808  * add_inode - add inode information to RB-tree of inodes.
1809  * @c: UBIFS file-system description object
1810  * @fsckd: FS checking information
1811  * @ino: raw UBIFS inode to add
1812  *
1813  * This is a helper function for 'check_leaf()' which adds information about
1814  * inode @ino to the RB-tree of inodes. Returns inode information pointer in
1815  * case of success and a negative error code in case of failure.
1816  */
add_inode(struct ubifs_info * c,struct fsck_data * fsckd,struct ubifs_ino_node * ino)1817 static struct fsck_inode *add_inode(struct ubifs_info *c,
1818 				    struct fsck_data *fsckd,
1819 				    struct ubifs_ino_node *ino)
1820 {
1821 	struct rb_node **p, *parent = NULL;
1822 	struct fsck_inode *fscki;
1823 	ino_t inum = key_inum_flash(c, &ino->key);
1824 	struct inode *inode;
1825 	struct ubifs_inode *ui;
1826 
1827 	p = &fsckd->inodes.rb_node;
1828 	while (*p) {
1829 		parent = *p;
1830 		fscki = rb_entry(parent, struct fsck_inode, rb);
1831 		if (inum < fscki->inum)
1832 			p = &(*p)->rb_left;
1833 		else if (inum > fscki->inum)
1834 			p = &(*p)->rb_right;
1835 		else
1836 			return fscki;
1837 	}
1838 
1839 	if (inum > c->highest_inum) {
1840 		ubifs_err(c, "too high inode number, max. is %lu",
1841 			  (unsigned long)c->highest_inum);
1842 		return ERR_PTR(-EINVAL);
1843 	}
1844 
1845 	fscki = kzalloc(sizeof(struct fsck_inode), GFP_NOFS);
1846 	if (!fscki)
1847 		return ERR_PTR(-ENOMEM);
1848 
1849 	inode = ilookup(c->vfs_sb, inum);
1850 
1851 	fscki->inum = inum;
1852 	/*
1853 	 * If the inode is present in the VFS inode cache, use it instead of
1854 	 * the on-flash inode which might be out-of-date. E.g., the size might
1855 	 * be out-of-date. If we do not do this, the following may happen, for
1856 	 * example:
1857 	 *   1. A power cut happens
1858 	 *   2. We mount the file-system R/O, the replay process fixes up the
1859 	 *      inode size in the VFS cache, but on on-flash.
1860 	 *   3. 'check_leaf()' fails because it hits a data node beyond inode
1861 	 *      size.
1862 	 */
1863 	if (!inode) {
1864 		fscki->nlink = le32_to_cpu(ino->nlink);
1865 		fscki->size = le64_to_cpu(ino->size);
1866 		fscki->xattr_cnt = le32_to_cpu(ino->xattr_cnt);
1867 		fscki->xattr_sz = le32_to_cpu(ino->xattr_size);
1868 		fscki->xattr_nms = le32_to_cpu(ino->xattr_names);
1869 		fscki->mode = le32_to_cpu(ino->mode);
1870 	} else {
1871 		ui = ubifs_inode(inode);
1872 		fscki->nlink = inode->i_nlink;
1873 		fscki->size = inode->i_size;
1874 		fscki->xattr_cnt = ui->xattr_cnt;
1875 		fscki->xattr_sz = ui->xattr_size;
1876 		fscki->xattr_nms = ui->xattr_names;
1877 		fscki->mode = inode->i_mode;
1878 		iput(inode);
1879 	}
1880 
1881 	if (S_ISDIR(fscki->mode)) {
1882 		fscki->calc_sz = UBIFS_INO_NODE_SZ;
1883 		fscki->calc_cnt = 2;
1884 	}
1885 
1886 	rb_link_node(&fscki->rb, parent, p);
1887 	rb_insert_color(&fscki->rb, &fsckd->inodes);
1888 
1889 	return fscki;
1890 }
1891 
1892 /**
1893  * search_inode - search inode in the RB-tree of inodes.
1894  * @fsckd: FS checking information
1895  * @inum: inode number to search
1896  *
1897  * This is a helper function for 'check_leaf()' which searches inode @inum in
1898  * the RB-tree of inodes and returns an inode information pointer or %NULL if
1899  * the inode was not found.
1900  */
search_inode(struct fsck_data * fsckd,ino_t inum)1901 static struct fsck_inode *search_inode(struct fsck_data *fsckd, ino_t inum)
1902 {
1903 	struct rb_node *p;
1904 	struct fsck_inode *fscki;
1905 
1906 	p = fsckd->inodes.rb_node;
1907 	while (p) {
1908 		fscki = rb_entry(p, struct fsck_inode, rb);
1909 		if (inum < fscki->inum)
1910 			p = p->rb_left;
1911 		else if (inum > fscki->inum)
1912 			p = p->rb_right;
1913 		else
1914 			return fscki;
1915 	}
1916 	return NULL;
1917 }
1918 
1919 /**
1920  * read_add_inode - read inode node and add it to RB-tree of inodes.
1921  * @c: UBIFS file-system description object
1922  * @fsckd: FS checking information
1923  * @inum: inode number to read
1924  *
1925  * This is a helper function for 'check_leaf()' which finds inode node @inum in
1926  * the index, reads it, and adds it to the RB-tree of inodes. Returns inode
1927  * information pointer in case of success and a negative error code in case of
1928  * failure.
1929  */
read_add_inode(struct ubifs_info * c,struct fsck_data * fsckd,ino_t inum)1930 static struct fsck_inode *read_add_inode(struct ubifs_info *c,
1931 					 struct fsck_data *fsckd, ino_t inum)
1932 {
1933 	int n, err;
1934 	union ubifs_key key;
1935 	struct ubifs_znode *znode;
1936 	struct ubifs_zbranch *zbr;
1937 	struct ubifs_ino_node *ino;
1938 	struct fsck_inode *fscki;
1939 
1940 	fscki = search_inode(fsckd, inum);
1941 	if (fscki)
1942 		return fscki;
1943 
1944 	ino_key_init(c, &key, inum);
1945 	err = ubifs_lookup_level0(c, &key, &znode, &n);
1946 	if (!err) {
1947 		ubifs_err(c, "inode %lu not found in index", (unsigned long)inum);
1948 		return ERR_PTR(-ENOENT);
1949 	} else if (err < 0) {
1950 		ubifs_err(c, "error %d while looking up inode %lu",
1951 			  err, (unsigned long)inum);
1952 		return ERR_PTR(err);
1953 	}
1954 
1955 	zbr = &znode->zbranch[n];
1956 	if (zbr->len < UBIFS_INO_NODE_SZ) {
1957 		ubifs_err(c, "bad node %lu node length %d",
1958 			  (unsigned long)inum, zbr->len);
1959 		return ERR_PTR(-EINVAL);
1960 	}
1961 
1962 	ino = kmalloc(zbr->len, GFP_NOFS);
1963 	if (!ino)
1964 		return ERR_PTR(-ENOMEM);
1965 
1966 	err = ubifs_tnc_read_node(c, zbr, ino);
1967 	if (err) {
1968 		ubifs_err(c, "cannot read inode node at LEB %d:%d, error %d",
1969 			  zbr->lnum, zbr->offs, err);
1970 		kfree(ino);
1971 		return ERR_PTR(err);
1972 	}
1973 
1974 	fscki = add_inode(c, fsckd, ino);
1975 	kfree(ino);
1976 	if (IS_ERR(fscki)) {
1977 		ubifs_err(c, "error %ld while adding inode %lu node",
1978 			  PTR_ERR(fscki), (unsigned long)inum);
1979 		return fscki;
1980 	}
1981 
1982 	return fscki;
1983 }
1984 
1985 /**
1986  * check_leaf - check leaf node.
1987  * @c: UBIFS file-system description object
1988  * @zbr: zbranch of the leaf node to check
1989  * @priv: FS checking information
1990  *
1991  * This is a helper function for 'dbg_check_filesystem()' which is called for
1992  * every single leaf node while walking the indexing tree. It checks that the
1993  * leaf node referred from the indexing tree exists, has correct CRC, and does
1994  * some other basic validation. This function is also responsible for building
1995  * an RB-tree of inodes - it adds all inodes into the RB-tree. It also
1996  * calculates reference count, size, etc for each inode in order to later
1997  * compare them to the information stored inside the inodes and detect possible
1998  * inconsistencies. Returns zero in case of success and a negative error code
1999  * in case of failure.
2000  */
check_leaf(struct ubifs_info * c,struct ubifs_zbranch * zbr,void * priv)2001 static int check_leaf(struct ubifs_info *c, struct ubifs_zbranch *zbr,
2002 		      void *priv)
2003 {
2004 	ino_t inum;
2005 	void *node;
2006 	struct ubifs_ch *ch;
2007 	int err, type = key_type(c, &zbr->key);
2008 	struct fsck_inode *fscki;
2009 
2010 	if (zbr->len < UBIFS_CH_SZ) {
2011 		ubifs_err(c, "bad leaf length %d (LEB %d:%d)",
2012 			  zbr->len, zbr->lnum, zbr->offs);
2013 		return -EINVAL;
2014 	}
2015 
2016 	node = kmalloc(zbr->len, GFP_NOFS);
2017 	if (!node)
2018 		return -ENOMEM;
2019 
2020 	err = ubifs_tnc_read_node(c, zbr, node);
2021 	if (err) {
2022 		ubifs_err(c, "cannot read leaf node at LEB %d:%d, error %d",
2023 			  zbr->lnum, zbr->offs, err);
2024 		goto out_free;
2025 	}
2026 
2027 	/* If this is an inode node, add it to RB-tree of inodes */
2028 	if (type == UBIFS_INO_KEY) {
2029 		fscki = add_inode(c, priv, node);
2030 		if (IS_ERR(fscki)) {
2031 			err = PTR_ERR(fscki);
2032 			ubifs_err(c, "error %d while adding inode node", err);
2033 			goto out_dump;
2034 		}
2035 		goto out;
2036 	}
2037 
2038 	if (type != UBIFS_DENT_KEY && type != UBIFS_XENT_KEY &&
2039 	    type != UBIFS_DATA_KEY) {
2040 		ubifs_err(c, "unexpected node type %d at LEB %d:%d",
2041 			  type, zbr->lnum, zbr->offs);
2042 		err = -EINVAL;
2043 		goto out_free;
2044 	}
2045 
2046 	ch = node;
2047 	if (le64_to_cpu(ch->sqnum) > c->max_sqnum) {
2048 		ubifs_err(c, "too high sequence number, max. is %llu",
2049 			  c->max_sqnum);
2050 		err = -EINVAL;
2051 		goto out_dump;
2052 	}
2053 
2054 	if (type == UBIFS_DATA_KEY) {
2055 		long long blk_offs;
2056 		struct ubifs_data_node *dn = node;
2057 
2058 		ubifs_assert(c, zbr->len >= UBIFS_DATA_NODE_SZ);
2059 
2060 		/*
2061 		 * Search the inode node this data node belongs to and insert
2062 		 * it to the RB-tree of inodes.
2063 		 */
2064 		inum = key_inum_flash(c, &dn->key);
2065 		fscki = read_add_inode(c, priv, inum);
2066 		if (IS_ERR(fscki)) {
2067 			err = PTR_ERR(fscki);
2068 			ubifs_err(c, "error %d while processing data node and trying to find inode node %lu",
2069 				  err, (unsigned long)inum);
2070 			goto out_dump;
2071 		}
2072 
2073 		/* Make sure the data node is within inode size */
2074 		blk_offs = key_block_flash(c, &dn->key);
2075 		blk_offs <<= UBIFS_BLOCK_SHIFT;
2076 		blk_offs += le32_to_cpu(dn->size);
2077 		if (blk_offs > fscki->size) {
2078 			ubifs_err(c, "data node at LEB %d:%d is not within inode size %lld",
2079 				  zbr->lnum, zbr->offs, fscki->size);
2080 			err = -EINVAL;
2081 			goto out_dump;
2082 		}
2083 	} else {
2084 		int nlen;
2085 		struct ubifs_dent_node *dent = node;
2086 		struct fsck_inode *fscki1;
2087 
2088 		ubifs_assert(c, zbr->len >= UBIFS_DENT_NODE_SZ);
2089 
2090 		err = ubifs_validate_entry(c, dent);
2091 		if (err)
2092 			goto out_dump;
2093 
2094 		/*
2095 		 * Search the inode node this entry refers to and the parent
2096 		 * inode node and insert them to the RB-tree of inodes.
2097 		 */
2098 		inum = le64_to_cpu(dent->inum);
2099 		fscki = read_add_inode(c, priv, inum);
2100 		if (IS_ERR(fscki)) {
2101 			err = PTR_ERR(fscki);
2102 			ubifs_err(c, "error %d while processing entry node and trying to find inode node %lu",
2103 				  err, (unsigned long)inum);
2104 			goto out_dump;
2105 		}
2106 
2107 		/* Count how many direntries or xentries refers this inode */
2108 		fscki->references += 1;
2109 
2110 		inum = key_inum_flash(c, &dent->key);
2111 		fscki1 = read_add_inode(c, priv, inum);
2112 		if (IS_ERR(fscki1)) {
2113 			err = PTR_ERR(fscki1);
2114 			ubifs_err(c, "error %d while processing entry node and trying to find parent inode node %lu",
2115 				  err, (unsigned long)inum);
2116 			goto out_dump;
2117 		}
2118 
2119 		nlen = le16_to_cpu(dent->nlen);
2120 		if (type == UBIFS_XENT_KEY) {
2121 			fscki1->calc_xcnt += 1;
2122 			fscki1->calc_xsz += CALC_DENT_SIZE(nlen);
2123 			fscki1->calc_xsz += CALC_XATTR_BYTES(fscki->size);
2124 			fscki1->calc_xnms += nlen;
2125 		} else {
2126 			fscki1->calc_sz += CALC_DENT_SIZE(nlen);
2127 			if (dent->type == UBIFS_ITYPE_DIR)
2128 				fscki1->calc_cnt += 1;
2129 		}
2130 	}
2131 
2132 out:
2133 	kfree(node);
2134 	return 0;
2135 
2136 out_dump:
2137 	ubifs_msg(c, "dump of node at LEB %d:%d", zbr->lnum, zbr->offs);
2138 	ubifs_dump_node(c, node, zbr->len);
2139 out_free:
2140 	kfree(node);
2141 	return err;
2142 }
2143 
2144 /**
2145  * free_inodes - free RB-tree of inodes.
2146  * @fsckd: FS checking information
2147  */
free_inodes(struct fsck_data * fsckd)2148 static void free_inodes(struct fsck_data *fsckd)
2149 {
2150 	struct fsck_inode *fscki, *n;
2151 
2152 	rbtree_postorder_for_each_entry_safe(fscki, n, &fsckd->inodes, rb)
2153 		kfree(fscki);
2154 }
2155 
2156 /**
2157  * check_inodes - checks all inodes.
2158  * @c: UBIFS file-system description object
2159  * @fsckd: FS checking information
2160  *
2161  * This is a helper function for 'dbg_check_filesystem()' which walks the
2162  * RB-tree of inodes after the index scan has been finished, and checks that
2163  * inode nlink, size, etc are correct. Returns zero if inodes are fine,
2164  * %-EINVAL if not, and a negative error code in case of failure.
2165  */
check_inodes(struct ubifs_info * c,struct fsck_data * fsckd)2166 static int check_inodes(struct ubifs_info *c, struct fsck_data *fsckd)
2167 {
2168 	int n, err;
2169 	union ubifs_key key;
2170 	struct ubifs_znode *znode;
2171 	struct ubifs_zbranch *zbr;
2172 	struct ubifs_ino_node *ino;
2173 	struct fsck_inode *fscki;
2174 	struct rb_node *this = rb_first(&fsckd->inodes);
2175 
2176 	while (this) {
2177 		fscki = rb_entry(this, struct fsck_inode, rb);
2178 		this = rb_next(this);
2179 
2180 		if (S_ISDIR(fscki->mode)) {
2181 			/*
2182 			 * Directories have to have exactly one reference (they
2183 			 * cannot have hardlinks), although root inode is an
2184 			 * exception.
2185 			 */
2186 			if (fscki->inum != UBIFS_ROOT_INO &&
2187 			    fscki->references != 1) {
2188 				ubifs_err(c, "directory inode %lu has %d direntries which refer it, but should be 1",
2189 					  (unsigned long)fscki->inum,
2190 					  fscki->references);
2191 				goto out_dump;
2192 			}
2193 			if (fscki->inum == UBIFS_ROOT_INO &&
2194 			    fscki->references != 0) {
2195 				ubifs_err(c, "root inode %lu has non-zero (%d) direntries which refer it",
2196 					  (unsigned long)fscki->inum,
2197 					  fscki->references);
2198 				goto out_dump;
2199 			}
2200 			if (fscki->calc_sz != fscki->size) {
2201 				ubifs_err(c, "directory inode %lu size is %lld, but calculated size is %lld",
2202 					  (unsigned long)fscki->inum,
2203 					  fscki->size, fscki->calc_sz);
2204 				goto out_dump;
2205 			}
2206 			if (fscki->calc_cnt != fscki->nlink) {
2207 				ubifs_err(c, "directory inode %lu nlink is %d, but calculated nlink is %d",
2208 					  (unsigned long)fscki->inum,
2209 					  fscki->nlink, fscki->calc_cnt);
2210 				goto out_dump;
2211 			}
2212 		} else {
2213 			if (fscki->references != fscki->nlink) {
2214 				ubifs_err(c, "inode %lu nlink is %d, but calculated nlink is %d",
2215 					  (unsigned long)fscki->inum,
2216 					  fscki->nlink, fscki->references);
2217 				goto out_dump;
2218 			}
2219 		}
2220 		if (fscki->xattr_sz != fscki->calc_xsz) {
2221 			ubifs_err(c, "inode %lu has xattr size %u, but calculated size is %lld",
2222 				  (unsigned long)fscki->inum, fscki->xattr_sz,
2223 				  fscki->calc_xsz);
2224 			goto out_dump;
2225 		}
2226 		if (fscki->xattr_cnt != fscki->calc_xcnt) {
2227 			ubifs_err(c, "inode %lu has %u xattrs, but calculated count is %lld",
2228 				  (unsigned long)fscki->inum,
2229 				  fscki->xattr_cnt, fscki->calc_xcnt);
2230 			goto out_dump;
2231 		}
2232 		if (fscki->xattr_nms != fscki->calc_xnms) {
2233 			ubifs_err(c, "inode %lu has xattr names' size %u, but calculated names' size is %lld",
2234 				  (unsigned long)fscki->inum, fscki->xattr_nms,
2235 				  fscki->calc_xnms);
2236 			goto out_dump;
2237 		}
2238 	}
2239 
2240 	return 0;
2241 
2242 out_dump:
2243 	/* Read the bad inode and dump it */
2244 	ino_key_init(c, &key, fscki->inum);
2245 	err = ubifs_lookup_level0(c, &key, &znode, &n);
2246 	if (!err) {
2247 		ubifs_err(c, "inode %lu not found in index",
2248 			  (unsigned long)fscki->inum);
2249 		return -ENOENT;
2250 	} else if (err < 0) {
2251 		ubifs_err(c, "error %d while looking up inode %lu",
2252 			  err, (unsigned long)fscki->inum);
2253 		return err;
2254 	}
2255 
2256 	zbr = &znode->zbranch[n];
2257 	ino = kmalloc(zbr->len, GFP_NOFS);
2258 	if (!ino)
2259 		return -ENOMEM;
2260 
2261 	err = ubifs_tnc_read_node(c, zbr, ino);
2262 	if (err) {
2263 		ubifs_err(c, "cannot read inode node at LEB %d:%d, error %d",
2264 			  zbr->lnum, zbr->offs, err);
2265 		kfree(ino);
2266 		return err;
2267 	}
2268 
2269 	ubifs_msg(c, "dump of the inode %lu sitting in LEB %d:%d",
2270 		  (unsigned long)fscki->inum, zbr->lnum, zbr->offs);
2271 	ubifs_dump_node(c, ino, zbr->len);
2272 	kfree(ino);
2273 	return -EINVAL;
2274 }
2275 
2276 /**
2277  * dbg_check_filesystem - check the file-system.
2278  * @c: UBIFS file-system description object
2279  *
2280  * This function checks the file system, namely:
2281  * o makes sure that all leaf nodes exist and their CRCs are correct;
2282  * o makes sure inode nlink, size, xattr size/count are correct (for all
2283  *   inodes).
2284  *
2285  * The function reads whole indexing tree and all nodes, so it is pretty
2286  * heavy-weight. Returns zero if the file-system is consistent, %-EINVAL if
2287  * not, and a negative error code in case of failure.
2288  */
dbg_check_filesystem(struct ubifs_info * c)2289 int dbg_check_filesystem(struct ubifs_info *c)
2290 {
2291 	int err;
2292 	struct fsck_data fsckd;
2293 
2294 	if (!dbg_is_chk_fs(c))
2295 		return 0;
2296 
2297 	fsckd.inodes = RB_ROOT;
2298 	err = dbg_walk_index(c, check_leaf, NULL, &fsckd);
2299 	if (err)
2300 		goto out_free;
2301 
2302 	err = check_inodes(c, &fsckd);
2303 	if (err)
2304 		goto out_free;
2305 
2306 	free_inodes(&fsckd);
2307 	return 0;
2308 
2309 out_free:
2310 	ubifs_err(c, "file-system check failed with error %d", err);
2311 	dump_stack();
2312 	free_inodes(&fsckd);
2313 	return err;
2314 }
2315 
2316 /**
2317  * dbg_check_data_nodes_order - check that list of data nodes is sorted.
2318  * @c: UBIFS file-system description object
2319  * @head: the list of nodes ('struct ubifs_scan_node' objects)
2320  *
2321  * This function returns zero if the list of data nodes is sorted correctly,
2322  * and %-EINVAL if not.
2323  */
dbg_check_data_nodes_order(struct ubifs_info * c,struct list_head * head)2324 int dbg_check_data_nodes_order(struct ubifs_info *c, struct list_head *head)
2325 {
2326 	struct list_head *cur;
2327 	struct ubifs_scan_node *sa, *sb;
2328 
2329 	if (!dbg_is_chk_gen(c))
2330 		return 0;
2331 
2332 	for (cur = head->next; cur->next != head; cur = cur->next) {
2333 		ino_t inuma, inumb;
2334 		uint32_t blka, blkb;
2335 
2336 		cond_resched();
2337 		sa = container_of(cur, struct ubifs_scan_node, list);
2338 		sb = container_of(cur->next, struct ubifs_scan_node, list);
2339 
2340 		if (sa->type != UBIFS_DATA_NODE) {
2341 			ubifs_err(c, "bad node type %d", sa->type);
2342 			ubifs_dump_node(c, sa->node, c->leb_size - sa->offs);
2343 			return -EINVAL;
2344 		}
2345 		if (sb->type != UBIFS_DATA_NODE) {
2346 			ubifs_err(c, "bad node type %d", sb->type);
2347 			ubifs_dump_node(c, sb->node, c->leb_size - sb->offs);
2348 			return -EINVAL;
2349 		}
2350 
2351 		inuma = key_inum(c, &sa->key);
2352 		inumb = key_inum(c, &sb->key);
2353 
2354 		if (inuma < inumb)
2355 			continue;
2356 		if (inuma > inumb) {
2357 			ubifs_err(c, "larger inum %lu goes before inum %lu",
2358 				  (unsigned long)inuma, (unsigned long)inumb);
2359 			goto error_dump;
2360 		}
2361 
2362 		blka = key_block(c, &sa->key);
2363 		blkb = key_block(c, &sb->key);
2364 
2365 		if (blka > blkb) {
2366 			ubifs_err(c, "larger block %u goes before %u", blka, blkb);
2367 			goto error_dump;
2368 		}
2369 		if (blka == blkb) {
2370 			ubifs_err(c, "two data nodes for the same block");
2371 			goto error_dump;
2372 		}
2373 	}
2374 
2375 	return 0;
2376 
2377 error_dump:
2378 	ubifs_dump_node(c, sa->node, c->leb_size - sa->offs);
2379 	ubifs_dump_node(c, sb->node, c->leb_size - sb->offs);
2380 	return -EINVAL;
2381 }
2382 
2383 /**
2384  * dbg_check_nondata_nodes_order - check that list of data nodes is sorted.
2385  * @c: UBIFS file-system description object
2386  * @head: the list of nodes ('struct ubifs_scan_node' objects)
2387  *
2388  * This function returns zero if the list of non-data nodes is sorted correctly,
2389  * and %-EINVAL if not.
2390  */
dbg_check_nondata_nodes_order(struct ubifs_info * c,struct list_head * head)2391 int dbg_check_nondata_nodes_order(struct ubifs_info *c, struct list_head *head)
2392 {
2393 	struct list_head *cur;
2394 	struct ubifs_scan_node *sa, *sb;
2395 
2396 	if (!dbg_is_chk_gen(c))
2397 		return 0;
2398 
2399 	for (cur = head->next; cur->next != head; cur = cur->next) {
2400 		ino_t inuma, inumb;
2401 		uint32_t hasha, hashb;
2402 
2403 		cond_resched();
2404 		sa = container_of(cur, struct ubifs_scan_node, list);
2405 		sb = container_of(cur->next, struct ubifs_scan_node, list);
2406 
2407 		if (sa->type != UBIFS_INO_NODE && sa->type != UBIFS_DENT_NODE &&
2408 		    sa->type != UBIFS_XENT_NODE) {
2409 			ubifs_err(c, "bad node type %d", sa->type);
2410 			ubifs_dump_node(c, sa->node, c->leb_size - sa->offs);
2411 			return -EINVAL;
2412 		}
2413 		if (sb->type != UBIFS_INO_NODE && sb->type != UBIFS_DENT_NODE &&
2414 		    sb->type != UBIFS_XENT_NODE) {
2415 			ubifs_err(c, "bad node type %d", sb->type);
2416 			ubifs_dump_node(c, sb->node, c->leb_size - sb->offs);
2417 			return -EINVAL;
2418 		}
2419 
2420 		if (sa->type != UBIFS_INO_NODE && sb->type == UBIFS_INO_NODE) {
2421 			ubifs_err(c, "non-inode node goes before inode node");
2422 			goto error_dump;
2423 		}
2424 
2425 		if (sa->type == UBIFS_INO_NODE && sb->type != UBIFS_INO_NODE)
2426 			continue;
2427 
2428 		if (sa->type == UBIFS_INO_NODE && sb->type == UBIFS_INO_NODE) {
2429 			/* Inode nodes are sorted in descending size order */
2430 			if (sa->len < sb->len) {
2431 				ubifs_err(c, "smaller inode node goes first");
2432 				goto error_dump;
2433 			}
2434 			continue;
2435 		}
2436 
2437 		/*
2438 		 * This is either a dentry or xentry, which should be sorted in
2439 		 * ascending (parent ino, hash) order.
2440 		 */
2441 		inuma = key_inum(c, &sa->key);
2442 		inumb = key_inum(c, &sb->key);
2443 
2444 		if (inuma < inumb)
2445 			continue;
2446 		if (inuma > inumb) {
2447 			ubifs_err(c, "larger inum %lu goes before inum %lu",
2448 				  (unsigned long)inuma, (unsigned long)inumb);
2449 			goto error_dump;
2450 		}
2451 
2452 		hasha = key_block(c, &sa->key);
2453 		hashb = key_block(c, &sb->key);
2454 
2455 		if (hasha > hashb) {
2456 			ubifs_err(c, "larger hash %u goes before %u",
2457 				  hasha, hashb);
2458 			goto error_dump;
2459 		}
2460 	}
2461 
2462 	return 0;
2463 
2464 error_dump:
2465 	ubifs_msg(c, "dumping first node");
2466 	ubifs_dump_node(c, sa->node, c->leb_size - sa->offs);
2467 	ubifs_msg(c, "dumping second node");
2468 	ubifs_dump_node(c, sb->node, c->leb_size - sb->offs);
2469 	return -EINVAL;
2470 }
2471 
chance(unsigned int n,unsigned int out_of)2472 static inline int chance(unsigned int n, unsigned int out_of)
2473 {
2474 	return !!(get_random_u32_below(out_of) + 1 <= n);
2475 
2476 }
2477 
power_cut_emulated(struct ubifs_info * c,int lnum,int write)2478 static int power_cut_emulated(struct ubifs_info *c, int lnum, int write)
2479 {
2480 	struct ubifs_debug_info *d = c->dbg;
2481 
2482 	ubifs_assert(c, dbg_is_tst_rcvry(c));
2483 
2484 	if (!d->pc_cnt) {
2485 		/* First call - decide delay to the power cut */
2486 		if (chance(1, 2)) {
2487 			unsigned long delay;
2488 
2489 			if (chance(1, 2)) {
2490 				d->pc_delay = 1;
2491 				/* Fail within 1 minute */
2492 				delay = get_random_u32_below(60000);
2493 				d->pc_timeout = jiffies;
2494 				d->pc_timeout += msecs_to_jiffies(delay);
2495 				ubifs_warn(c, "failing after %lums", delay);
2496 			} else {
2497 				d->pc_delay = 2;
2498 				delay = get_random_u32_below(10000);
2499 				/* Fail within 10000 operations */
2500 				d->pc_cnt_max = delay;
2501 				ubifs_warn(c, "failing after %lu calls", delay);
2502 			}
2503 		}
2504 
2505 		d->pc_cnt += 1;
2506 	}
2507 
2508 	/* Determine if failure delay has expired */
2509 	if (d->pc_delay == 1 && time_before(jiffies, d->pc_timeout))
2510 			return 0;
2511 	if (d->pc_delay == 2 && d->pc_cnt++ < d->pc_cnt_max)
2512 			return 0;
2513 
2514 	if (lnum == UBIFS_SB_LNUM) {
2515 		if (write && chance(1, 2))
2516 			return 0;
2517 		if (chance(19, 20))
2518 			return 0;
2519 		ubifs_warn(c, "failing in super block LEB %d", lnum);
2520 	} else if (lnum == UBIFS_MST_LNUM || lnum == UBIFS_MST_LNUM + 1) {
2521 		if (chance(19, 20))
2522 			return 0;
2523 		ubifs_warn(c, "failing in master LEB %d", lnum);
2524 	} else if (lnum >= UBIFS_LOG_LNUM && lnum <= c->log_last) {
2525 		if (write && chance(99, 100))
2526 			return 0;
2527 		if (chance(399, 400))
2528 			return 0;
2529 		ubifs_warn(c, "failing in log LEB %d", lnum);
2530 	} else if (lnum >= c->lpt_first && lnum <= c->lpt_last) {
2531 		if (write && chance(7, 8))
2532 			return 0;
2533 		if (chance(19, 20))
2534 			return 0;
2535 		ubifs_warn(c, "failing in LPT LEB %d", lnum);
2536 	} else if (lnum >= c->orph_first && lnum <= c->orph_last) {
2537 		if (write && chance(1, 2))
2538 			return 0;
2539 		if (chance(9, 10))
2540 			return 0;
2541 		ubifs_warn(c, "failing in orphan LEB %d", lnum);
2542 	} else if (lnum == c->ihead_lnum) {
2543 		if (chance(99, 100))
2544 			return 0;
2545 		ubifs_warn(c, "failing in index head LEB %d", lnum);
2546 	} else if (c->jheads && lnum == c->jheads[GCHD].wbuf.lnum) {
2547 		if (chance(9, 10))
2548 			return 0;
2549 		ubifs_warn(c, "failing in GC head LEB %d", lnum);
2550 	} else if (write && !RB_EMPTY_ROOT(&c->buds) &&
2551 		   !ubifs_search_bud(c, lnum)) {
2552 		if (chance(19, 20))
2553 			return 0;
2554 		ubifs_warn(c, "failing in non-bud LEB %d", lnum);
2555 	} else if (c->cmt_state == COMMIT_RUNNING_BACKGROUND ||
2556 		   c->cmt_state == COMMIT_RUNNING_REQUIRED) {
2557 		if (chance(999, 1000))
2558 			return 0;
2559 		ubifs_warn(c, "failing in bud LEB %d commit running", lnum);
2560 	} else {
2561 		if (chance(9999, 10000))
2562 			return 0;
2563 		ubifs_warn(c, "failing in bud LEB %d commit not running", lnum);
2564 	}
2565 
2566 	d->pc_happened = 1;
2567 	ubifs_warn(c, "========== Power cut emulated ==========");
2568 	dump_stack();
2569 	return 1;
2570 }
2571 
corrupt_data(const struct ubifs_info * c,const void * buf,unsigned int len)2572 static int corrupt_data(const struct ubifs_info *c, const void *buf,
2573 			unsigned int len)
2574 {
2575 	unsigned int from, to, ffs = chance(1, 2);
2576 	unsigned char *p = (void *)buf;
2577 
2578 	from = get_random_u32_below(len);
2579 	/* Corruption span max to end of write unit */
2580 	to = min(len, ALIGN(from + 1, c->max_write_size));
2581 
2582 	ubifs_warn(c, "filled bytes %u-%u with %s", from, to - 1,
2583 		   ffs ? "0xFFs" : "random data");
2584 
2585 	if (ffs)
2586 		memset(p + from, 0xFF, to - from);
2587 	else
2588 		get_random_bytes(p + from, to - from);
2589 
2590 	return to;
2591 }
2592 
dbg_leb_write(struct ubifs_info * c,int lnum,const void * buf,int offs,int len)2593 int dbg_leb_write(struct ubifs_info *c, int lnum, const void *buf,
2594 		  int offs, int len)
2595 {
2596 	int err, failing;
2597 
2598 	if (dbg_is_power_cut(c))
2599 		return -EROFS;
2600 
2601 	failing = power_cut_emulated(c, lnum, 1);
2602 	if (failing) {
2603 		len = corrupt_data(c, buf, len);
2604 		ubifs_warn(c, "actually write %d bytes to LEB %d:%d (the buffer was corrupted)",
2605 			   len, lnum, offs);
2606 	}
2607 	err = ubi_leb_write(c->ubi, lnum, buf, offs, len);
2608 	if (err)
2609 		return err;
2610 	if (failing)
2611 		return -EROFS;
2612 	return 0;
2613 }
2614 
dbg_leb_change(struct ubifs_info * c,int lnum,const void * buf,int len)2615 int dbg_leb_change(struct ubifs_info *c, int lnum, const void *buf,
2616 		   int len)
2617 {
2618 	int err;
2619 
2620 	if (dbg_is_power_cut(c))
2621 		return -EROFS;
2622 	if (power_cut_emulated(c, lnum, 1))
2623 		return -EROFS;
2624 	err = ubi_leb_change(c->ubi, lnum, buf, len);
2625 	if (err)
2626 		return err;
2627 	if (power_cut_emulated(c, lnum, 1))
2628 		return -EROFS;
2629 	return 0;
2630 }
2631 
dbg_leb_unmap(struct ubifs_info * c,int lnum)2632 int dbg_leb_unmap(struct ubifs_info *c, int lnum)
2633 {
2634 	int err;
2635 
2636 	if (dbg_is_power_cut(c))
2637 		return -EROFS;
2638 	if (power_cut_emulated(c, lnum, 0))
2639 		return -EROFS;
2640 	err = ubi_leb_unmap(c->ubi, lnum);
2641 	if (err)
2642 		return err;
2643 	if (power_cut_emulated(c, lnum, 0))
2644 		return -EROFS;
2645 	return 0;
2646 }
2647 
dbg_leb_map(struct ubifs_info * c,int lnum)2648 int dbg_leb_map(struct ubifs_info *c, int lnum)
2649 {
2650 	int err;
2651 
2652 	if (dbg_is_power_cut(c))
2653 		return -EROFS;
2654 	if (power_cut_emulated(c, lnum, 0))
2655 		return -EROFS;
2656 	err = ubi_leb_map(c->ubi, lnum);
2657 	if (err)
2658 		return err;
2659 	if (power_cut_emulated(c, lnum, 0))
2660 		return -EROFS;
2661 	return 0;
2662 }
2663 
2664 /*
2665  * Root directory for UBIFS stuff in debugfs. Contains sub-directories which
2666  * contain the stuff specific to particular file-system mounts.
2667  */
2668 static struct dentry *dfs_rootdir;
2669 
dfs_file_open(struct inode * inode,struct file * file)2670 static int dfs_file_open(struct inode *inode, struct file *file)
2671 {
2672 	file->private_data = inode->i_private;
2673 	return nonseekable_open(inode, file);
2674 }
2675 
2676 /**
2677  * provide_user_output - provide output to the user reading a debugfs file.
2678  * @val: boolean value for the answer
2679  * @u: the buffer to store the answer at
2680  * @count: size of the buffer
2681  * @ppos: position in the @u output buffer
2682  *
2683  * This is a simple helper function which stores @val boolean value in the user
2684  * buffer when the user reads one of UBIFS debugfs files. Returns amount of
2685  * bytes written to @u in case of success and a negative error code in case of
2686  * failure.
2687  */
provide_user_output(int val,char __user * u,size_t count,loff_t * ppos)2688 static int provide_user_output(int val, char __user *u, size_t count,
2689 			       loff_t *ppos)
2690 {
2691 	char buf[3];
2692 
2693 	if (val)
2694 		buf[0] = '1';
2695 	else
2696 		buf[0] = '0';
2697 	buf[1] = '\n';
2698 	buf[2] = 0x00;
2699 
2700 	return simple_read_from_buffer(u, count, ppos, buf, 2);
2701 }
2702 
dfs_file_read(struct file * file,char __user * u,size_t count,loff_t * ppos)2703 static ssize_t dfs_file_read(struct file *file, char __user *u, size_t count,
2704 			     loff_t *ppos)
2705 {
2706 	struct dentry *dent = file->f_path.dentry;
2707 	struct ubifs_info *c = file->private_data;
2708 	struct ubifs_debug_info *d = c->dbg;
2709 	int val;
2710 
2711 	if (dent == d->dfs_chk_gen)
2712 		val = d->chk_gen;
2713 	else if (dent == d->dfs_chk_index)
2714 		val = d->chk_index;
2715 	else if (dent == d->dfs_chk_orph)
2716 		val = d->chk_orph;
2717 	else if (dent == d->dfs_chk_lprops)
2718 		val = d->chk_lprops;
2719 	else if (dent == d->dfs_chk_fs)
2720 		val = d->chk_fs;
2721 	else if (dent == d->dfs_tst_rcvry)
2722 		val = d->tst_rcvry;
2723 	else if (dent == d->dfs_ro_error)
2724 		val = c->ro_error;
2725 	else
2726 		return -EINVAL;
2727 
2728 	return provide_user_output(val, u, count, ppos);
2729 }
2730 
2731 /**
2732  * interpret_user_input - interpret user debugfs file input.
2733  * @u: user-provided buffer with the input
2734  * @count: buffer size
2735  *
2736  * This is a helper function which interpret user input to a boolean UBIFS
2737  * debugfs file. Returns %0 or %1 in case of success and a negative error code
2738  * in case of failure.
2739  */
interpret_user_input(const char __user * u,size_t count)2740 static int interpret_user_input(const char __user *u, size_t count)
2741 {
2742 	size_t buf_size;
2743 	char buf[8];
2744 
2745 	buf_size = min_t(size_t, count, (sizeof(buf) - 1));
2746 	if (copy_from_user(buf, u, buf_size))
2747 		return -EFAULT;
2748 
2749 	if (buf[0] == '1')
2750 		return 1;
2751 	else if (buf[0] == '0')
2752 		return 0;
2753 
2754 	return -EINVAL;
2755 }
2756 
dfs_file_write(struct file * file,const char __user * u,size_t count,loff_t * ppos)2757 static ssize_t dfs_file_write(struct file *file, const char __user *u,
2758 			      size_t count, loff_t *ppos)
2759 {
2760 	struct ubifs_info *c = file->private_data;
2761 	struct ubifs_debug_info *d = c->dbg;
2762 	struct dentry *dent = file->f_path.dentry;
2763 	int val;
2764 
2765 	if (file->f_path.dentry == d->dfs_dump_lprops) {
2766 		ubifs_dump_lprops(c);
2767 		return count;
2768 	}
2769 	if (file->f_path.dentry == d->dfs_dump_budg) {
2770 		ubifs_dump_budg(c, &c->bi);
2771 		return count;
2772 	}
2773 	if (file->f_path.dentry == d->dfs_dump_tnc) {
2774 		mutex_lock(&c->tnc_mutex);
2775 		ubifs_dump_tnc(c);
2776 		mutex_unlock(&c->tnc_mutex);
2777 		return count;
2778 	}
2779 
2780 	val = interpret_user_input(u, count);
2781 	if (val < 0)
2782 		return val;
2783 
2784 	if (dent == d->dfs_chk_gen)
2785 		d->chk_gen = val;
2786 	else if (dent == d->dfs_chk_index)
2787 		d->chk_index = val;
2788 	else if (dent == d->dfs_chk_orph)
2789 		d->chk_orph = val;
2790 	else if (dent == d->dfs_chk_lprops)
2791 		d->chk_lprops = val;
2792 	else if (dent == d->dfs_chk_fs)
2793 		d->chk_fs = val;
2794 	else if (dent == d->dfs_tst_rcvry)
2795 		d->tst_rcvry = val;
2796 	else if (dent == d->dfs_ro_error)
2797 		c->ro_error = !!val;
2798 	else
2799 		return -EINVAL;
2800 
2801 	return count;
2802 }
2803 
2804 static const struct file_operations dfs_fops = {
2805 	.open = dfs_file_open,
2806 	.read = dfs_file_read,
2807 	.write = dfs_file_write,
2808 	.owner = THIS_MODULE,
2809 	.llseek = no_llseek,
2810 };
2811 
2812 /**
2813  * dbg_debugfs_init_fs - initialize debugfs for UBIFS instance.
2814  * @c: UBIFS file-system description object
2815  *
2816  * This function creates all debugfs files for this instance of UBIFS.
2817  *
2818  * Note, the only reason we have not merged this function with the
2819  * 'ubifs_debugging_init()' function is because it is better to initialize
2820  * debugfs interfaces at the very end of the mount process, and remove them at
2821  * the very beginning of the mount process.
2822  */
dbg_debugfs_init_fs(struct ubifs_info * c)2823 void dbg_debugfs_init_fs(struct ubifs_info *c)
2824 {
2825 	int n;
2826 	const char *fname;
2827 	struct ubifs_debug_info *d = c->dbg;
2828 
2829 	n = snprintf(d->dfs_dir_name, UBIFS_DFS_DIR_LEN + 1, UBIFS_DFS_DIR_NAME,
2830 		     c->vi.ubi_num, c->vi.vol_id);
2831 	if (n > UBIFS_DFS_DIR_LEN) {
2832 		/* The array size is too small */
2833 		return;
2834 	}
2835 
2836 	fname = d->dfs_dir_name;
2837 	d->dfs_dir = debugfs_create_dir(fname, dfs_rootdir);
2838 
2839 	fname = "dump_lprops";
2840 	d->dfs_dump_lprops = debugfs_create_file(fname, S_IWUSR, d->dfs_dir, c,
2841 						 &dfs_fops);
2842 
2843 	fname = "dump_budg";
2844 	d->dfs_dump_budg = debugfs_create_file(fname, S_IWUSR, d->dfs_dir, c,
2845 					       &dfs_fops);
2846 
2847 	fname = "dump_tnc";
2848 	d->dfs_dump_tnc = debugfs_create_file(fname, S_IWUSR, d->dfs_dir, c,
2849 					      &dfs_fops);
2850 
2851 	fname = "chk_general";
2852 	d->dfs_chk_gen = debugfs_create_file(fname, S_IRUSR | S_IWUSR,
2853 					     d->dfs_dir, c, &dfs_fops);
2854 
2855 	fname = "chk_index";
2856 	d->dfs_chk_index = debugfs_create_file(fname, S_IRUSR | S_IWUSR,
2857 					       d->dfs_dir, c, &dfs_fops);
2858 
2859 	fname = "chk_orphans";
2860 	d->dfs_chk_orph = debugfs_create_file(fname, S_IRUSR | S_IWUSR,
2861 					      d->dfs_dir, c, &dfs_fops);
2862 
2863 	fname = "chk_lprops";
2864 	d->dfs_chk_lprops = debugfs_create_file(fname, S_IRUSR | S_IWUSR,
2865 						d->dfs_dir, c, &dfs_fops);
2866 
2867 	fname = "chk_fs";
2868 	d->dfs_chk_fs = debugfs_create_file(fname, S_IRUSR | S_IWUSR,
2869 					    d->dfs_dir, c, &dfs_fops);
2870 
2871 	fname = "tst_recovery";
2872 	d->dfs_tst_rcvry = debugfs_create_file(fname, S_IRUSR | S_IWUSR,
2873 					       d->dfs_dir, c, &dfs_fops);
2874 
2875 	fname = "ro_error";
2876 	d->dfs_ro_error = debugfs_create_file(fname, S_IRUSR | S_IWUSR,
2877 					      d->dfs_dir, c, &dfs_fops);
2878 }
2879 
2880 /**
2881  * dbg_debugfs_exit_fs - remove all debugfs files.
2882  * @c: UBIFS file-system description object
2883  */
dbg_debugfs_exit_fs(struct ubifs_info * c)2884 void dbg_debugfs_exit_fs(struct ubifs_info *c)
2885 {
2886 	debugfs_remove_recursive(c->dbg->dfs_dir);
2887 }
2888 
2889 struct ubifs_global_debug_info ubifs_dbg;
2890 
2891 static struct dentry *dfs_chk_gen;
2892 static struct dentry *dfs_chk_index;
2893 static struct dentry *dfs_chk_orph;
2894 static struct dentry *dfs_chk_lprops;
2895 static struct dentry *dfs_chk_fs;
2896 static struct dentry *dfs_tst_rcvry;
2897 
dfs_global_file_read(struct file * file,char __user * u,size_t count,loff_t * ppos)2898 static ssize_t dfs_global_file_read(struct file *file, char __user *u,
2899 				    size_t count, loff_t *ppos)
2900 {
2901 	struct dentry *dent = file->f_path.dentry;
2902 	int val;
2903 
2904 	if (dent == dfs_chk_gen)
2905 		val = ubifs_dbg.chk_gen;
2906 	else if (dent == dfs_chk_index)
2907 		val = ubifs_dbg.chk_index;
2908 	else if (dent == dfs_chk_orph)
2909 		val = ubifs_dbg.chk_orph;
2910 	else if (dent == dfs_chk_lprops)
2911 		val = ubifs_dbg.chk_lprops;
2912 	else if (dent == dfs_chk_fs)
2913 		val = ubifs_dbg.chk_fs;
2914 	else if (dent == dfs_tst_rcvry)
2915 		val = ubifs_dbg.tst_rcvry;
2916 	else
2917 		return -EINVAL;
2918 
2919 	return provide_user_output(val, u, count, ppos);
2920 }
2921 
dfs_global_file_write(struct file * file,const char __user * u,size_t count,loff_t * ppos)2922 static ssize_t dfs_global_file_write(struct file *file, const char __user *u,
2923 				     size_t count, loff_t *ppos)
2924 {
2925 	struct dentry *dent = file->f_path.dentry;
2926 	int val;
2927 
2928 	val = interpret_user_input(u, count);
2929 	if (val < 0)
2930 		return val;
2931 
2932 	if (dent == dfs_chk_gen)
2933 		ubifs_dbg.chk_gen = val;
2934 	else if (dent == dfs_chk_index)
2935 		ubifs_dbg.chk_index = val;
2936 	else if (dent == dfs_chk_orph)
2937 		ubifs_dbg.chk_orph = val;
2938 	else if (dent == dfs_chk_lprops)
2939 		ubifs_dbg.chk_lprops = val;
2940 	else if (dent == dfs_chk_fs)
2941 		ubifs_dbg.chk_fs = val;
2942 	else if (dent == dfs_tst_rcvry)
2943 		ubifs_dbg.tst_rcvry = val;
2944 	else
2945 		return -EINVAL;
2946 
2947 	return count;
2948 }
2949 
2950 static const struct file_operations dfs_global_fops = {
2951 	.read = dfs_global_file_read,
2952 	.write = dfs_global_file_write,
2953 	.owner = THIS_MODULE,
2954 	.llseek = no_llseek,
2955 };
2956 
2957 /**
2958  * dbg_debugfs_init - initialize debugfs file-system.
2959  *
2960  * UBIFS uses debugfs file-system to expose various debugging knobs to
2961  * user-space. This function creates "ubifs" directory in the debugfs
2962  * file-system.
2963  */
dbg_debugfs_init(void)2964 void dbg_debugfs_init(void)
2965 {
2966 	const char *fname;
2967 
2968 	fname = "ubifs";
2969 	dfs_rootdir = debugfs_create_dir(fname, NULL);
2970 
2971 	fname = "chk_general";
2972 	dfs_chk_gen = debugfs_create_file(fname, S_IRUSR | S_IWUSR, dfs_rootdir,
2973 					  NULL, &dfs_global_fops);
2974 
2975 	fname = "chk_index";
2976 	dfs_chk_index = debugfs_create_file(fname, S_IRUSR | S_IWUSR,
2977 					    dfs_rootdir, NULL, &dfs_global_fops);
2978 
2979 	fname = "chk_orphans";
2980 	dfs_chk_orph = debugfs_create_file(fname, S_IRUSR | S_IWUSR,
2981 					   dfs_rootdir, NULL, &dfs_global_fops);
2982 
2983 	fname = "chk_lprops";
2984 	dfs_chk_lprops = debugfs_create_file(fname, S_IRUSR | S_IWUSR,
2985 					     dfs_rootdir, NULL, &dfs_global_fops);
2986 
2987 	fname = "chk_fs";
2988 	dfs_chk_fs = debugfs_create_file(fname, S_IRUSR | S_IWUSR, dfs_rootdir,
2989 					 NULL, &dfs_global_fops);
2990 
2991 	fname = "tst_recovery";
2992 	dfs_tst_rcvry = debugfs_create_file(fname, S_IRUSR | S_IWUSR,
2993 					    dfs_rootdir, NULL, &dfs_global_fops);
2994 }
2995 
2996 /**
2997  * dbg_debugfs_exit - remove the "ubifs" directory from debugfs file-system.
2998  */
dbg_debugfs_exit(void)2999 void dbg_debugfs_exit(void)
3000 {
3001 	debugfs_remove_recursive(dfs_rootdir);
3002 }
3003 
ubifs_assert_failed(struct ubifs_info * c,const char * expr,const char * file,int line)3004 void ubifs_assert_failed(struct ubifs_info *c, const char *expr,
3005 			 const char *file, int line)
3006 {
3007 	ubifs_err(c, "UBIFS assert failed: %s, in %s:%u", expr, file, line);
3008 
3009 	switch (c->assert_action) {
3010 		case ASSACT_PANIC:
3011 		BUG();
3012 		break;
3013 
3014 		case ASSACT_RO:
3015 		ubifs_ro_mode(c, -EINVAL);
3016 		break;
3017 
3018 		case ASSACT_REPORT:
3019 		default:
3020 		dump_stack();
3021 		break;
3022 
3023 	}
3024 }
3025 
3026 /**
3027  * ubifs_debugging_init - initialize UBIFS debugging.
3028  * @c: UBIFS file-system description object
3029  *
3030  * This function initializes debugging-related data for the file system.
3031  * Returns zero in case of success and a negative error code in case of
3032  * failure.
3033  */
ubifs_debugging_init(struct ubifs_info * c)3034 int ubifs_debugging_init(struct ubifs_info *c)
3035 {
3036 	c->dbg = kzalloc(sizeof(struct ubifs_debug_info), GFP_KERNEL);
3037 	if (!c->dbg)
3038 		return -ENOMEM;
3039 
3040 	return 0;
3041 }
3042 
3043 /**
3044  * ubifs_debugging_exit - free debugging data.
3045  * @c: UBIFS file-system description object
3046  */
ubifs_debugging_exit(struct ubifs_info * c)3047 void ubifs_debugging_exit(struct ubifs_info *c)
3048 {
3049 	kfree(c->dbg);
3050 }
3051