3050 lines · c
1// SPDX-License-Identifier: GPL-2.0-only2/*3 * This file is part of UBIFS.4 *5 * Copyright (C) 2006-2008 Nokia Corporation6 *7 * Authors: Artem Bityutskiy (Битюцкий Артём)8 * Adrian Hunter9 */10 11/*12 * This file implements most of the debugging stuff which is compiled in only13 * when it is enabled. But some debugging check functions are implemented in14 * corresponding subsystem, just because they are closely related and utilize15 * 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 26static DEFINE_SPINLOCK(dbg_lock);27 28static 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 38static 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 50static 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 68static 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 90const 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 } else124 len -= snprintf(p, len, "bad key format %d", c->key_fmt);125 ubifs_assert(c, len > 0);126 return p;127}128 129const 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 163static 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 177const 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 197const 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 211static 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 224void 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_get_atime_sec(inode),241 (unsigned int) inode_get_atime_nsec(inode));242 pr_err("\tmtime %u.%u\n",243 (unsigned int) inode_get_mtime_sec(inode),244 (unsigned int) inode_get_mtime_nsec(inode));245 pr_err("\tctime %u.%u\n",246 (unsigned int) inode_get_ctime_sec(inode),247 (unsigned int) inode_get_ctime_nsec(inode));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 294void 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 579out_unlock:580 spin_unlock(&dbg_lock);581}582 583void 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 600void 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 612void 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 print638 * additional information which is about the current state, not639 * 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);675out_unlock:676 spin_unlock(&dbg_lock);677 spin_unlock(&c->space_lock);678}679 680void 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 else690 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 else697 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 else705 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 middle752 * of mounting/re-mounting, the write-buffers do753 * 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 771void 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 793void 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 831void 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 864out:865 vfree(buf);866 return;867}868 869void 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 else880 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 else900 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 908void 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 924void 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 942void 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 znode = ubifs_tnc_levelorder_next(c, c->zroot.znode, NULL);950 level = znode->level;951 pr_err("== Level %d ==\n", level);952 while (znode) {953 if (level != znode->level) {954 level = znode->level;955 pr_err("== Level %d ==\n", level);956 }957 ubifs_dump_znode(c, znode);958 znode = ubifs_tnc_levelorder_next(c, c->zroot.znode, znode);959 }960 pr_err("(pid %d) finish dumping TNC tree\n", current->pid);961}962 963static int dump_znode(struct ubifs_info *c, struct ubifs_znode *znode,964 void *priv)965{966 ubifs_dump_znode(c, znode);967 return 0;968}969 970/**971 * ubifs_dump_index - dump the on-flash index.972 * @c: UBIFS file-system description object973 *974 * This function dumps whole UBIFS indexing B-tree, unlike 'ubifs_dump_tnc()'975 * which dumps only in-memory znodes and does not read znodes which from flash.976 */977void ubifs_dump_index(struct ubifs_info *c)978{979 dbg_walk_index(c, NULL, dump_znode, NULL);980}981 982/**983 * dbg_save_space_info - save information about flash space.984 * @c: UBIFS file-system description object985 *986 * This function saves information about UBIFS free space, dirty space, etc, in987 * order to check it later.988 */989void dbg_save_space_info(struct ubifs_info *c)990{991 struct ubifs_debug_info *d = c->dbg;992 int freeable_cnt;993 994 spin_lock(&c->space_lock);995 memcpy(&d->saved_lst, &c->lst, sizeof(struct ubifs_lp_stats));996 memcpy(&d->saved_bi, &c->bi, sizeof(struct ubifs_budg_info));997 d->saved_idx_gc_cnt = c->idx_gc_cnt;998 999 /*1000 * We use a dirty hack here and zero out @c->freeable_cnt, because it1001 * affects the free space calculations, and UBIFS might not know about1002 * all freeable eraseblocks. Indeed, we know about freeable eraseblocks1003 * only when we read their lprops, and we do this only lazily, upon the1004 * need. So at any given point of time @c->freeable_cnt might be not1005 * exactly accurate.1006 *1007 * Just one example about the issue we hit when we did not zero1008 * @c->freeable_cnt.1009 * 1. The file-system is mounted R/O, c->freeable_cnt is %0. We save the1010 * amount of free space in @d->saved_free1011 * 2. We re-mount R/W, which makes UBIFS to read the "lsave"1012 * information from flash, where we cache LEBs from various1013 * categories ('ubifs_remount_fs()' -> 'ubifs_lpt_init()'1014 * -> 'lpt_init_wr()' -> 'read_lsave()' -> 'ubifs_lpt_lookup()'1015 * -> 'ubifs_get_pnode()' -> 'update_cats()'1016 * -> 'ubifs_add_to_cat()').1017 * 3. Lsave contains a freeable eraseblock, and @c->freeable_cnt1018 * becomes %1.1019 * 4. We calculate the amount of free space when the re-mount is1020 * finished in 'dbg_check_space_info()' and it does not match1021 * @d->saved_free.1022 */1023 freeable_cnt = c->freeable_cnt;1024 c->freeable_cnt = 0;1025 d->saved_free = ubifs_get_free_space_nolock(c);1026 c->freeable_cnt = freeable_cnt;1027 spin_unlock(&c->space_lock);1028}1029 1030/**1031 * dbg_check_space_info - check flash space information.1032 * @c: UBIFS file-system description object1033 *1034 * This function compares current flash space information with the information1035 * which was saved when the 'dbg_save_space_info()' function was called.1036 * Returns zero if the information has not changed, and %-EINVAL if it has1037 * changed.1038 */1039int dbg_check_space_info(struct ubifs_info *c)1040{1041 struct ubifs_debug_info *d = c->dbg;1042 struct ubifs_lp_stats lst;1043 long long free;1044 int freeable_cnt;1045 1046 spin_lock(&c->space_lock);1047 freeable_cnt = c->freeable_cnt;1048 c->freeable_cnt = 0;1049 free = ubifs_get_free_space_nolock(c);1050 c->freeable_cnt = freeable_cnt;1051 spin_unlock(&c->space_lock);1052 1053 if (free != d->saved_free) {1054 ubifs_err(c, "free space changed from %lld to %lld",1055 d->saved_free, free);1056 goto out;1057 }1058 1059 return 0;1060 1061out:1062 ubifs_msg(c, "saved lprops statistics dump");1063 ubifs_dump_lstats(&d->saved_lst);1064 ubifs_msg(c, "saved budgeting info dump");1065 ubifs_dump_budg(c, &d->saved_bi);1066 ubifs_msg(c, "saved idx_gc_cnt %d", d->saved_idx_gc_cnt);1067 ubifs_msg(c, "current lprops statistics dump");1068 ubifs_get_lp_stats(c, &lst);1069 ubifs_dump_lstats(&lst);1070 ubifs_msg(c, "current budgeting info dump");1071 ubifs_dump_budg(c, &c->bi);1072 dump_stack();1073 return -EINVAL;1074}1075 1076/**1077 * dbg_check_synced_i_size - check synchronized inode size.1078 * @c: UBIFS file-system description object1079 * @inode: inode to check1080 *1081 * If inode is clean, synchronized inode size has to be equivalent to current1082 * inode size. This function has to be called only for locked inodes (@i_mutex1083 * has to be locked). Returns %0 if synchronized inode size if correct, and1084 * %-EINVAL if not.1085 */1086int dbg_check_synced_i_size(const struct ubifs_info *c, struct inode *inode)1087{1088 int err = 0;1089 struct ubifs_inode *ui = ubifs_inode(inode);1090 1091 if (!dbg_is_chk_gen(c))1092 return 0;1093 if (!S_ISREG(inode->i_mode))1094 return 0;1095 1096 mutex_lock(&ui->ui_mutex);1097 spin_lock(&ui->ui_lock);1098 if (ui->ui_size != ui->synced_i_size && !ui->dirty) {1099 ubifs_err(c, "ui_size is %lld, synced_i_size is %lld, but inode is clean",1100 ui->ui_size, ui->synced_i_size);1101 ubifs_err(c, "i_ino %lu, i_mode %#x, i_size %lld", inode->i_ino,1102 inode->i_mode, i_size_read(inode));1103 dump_stack();1104 err = -EINVAL;1105 }1106 spin_unlock(&ui->ui_lock);1107 mutex_unlock(&ui->ui_mutex);1108 return err;1109}1110 1111/*1112 * dbg_check_dir - check directory inode size and link count.1113 * @c: UBIFS file-system description object1114 * @dir: the directory to calculate size for1115 * @size: the result is returned here1116 *1117 * This function makes sure that directory size and link count are correct.1118 * Returns zero in case of success and a negative error code in case of1119 * failure.1120 *1121 * Note, it is good idea to make sure the @dir->i_mutex is locked before1122 * calling this function.1123 */1124int dbg_check_dir(struct ubifs_info *c, const struct inode *dir)1125{1126 unsigned int nlink = 2;1127 union ubifs_key key;1128 struct ubifs_dent_node *dent, *pdent = NULL;1129 struct fscrypt_name nm = {0};1130 loff_t size = UBIFS_INO_NODE_SZ;1131 1132 if (!dbg_is_chk_gen(c))1133 return 0;1134 1135 if (!S_ISDIR(dir->i_mode))1136 return 0;1137 1138 lowest_dent_key(c, &key, dir->i_ino);1139 while (1) {1140 int err;1141 1142 dent = ubifs_tnc_next_ent(c, &key, &nm);1143 if (IS_ERR(dent)) {1144 err = PTR_ERR(dent);1145 if (err == -ENOENT)1146 break;1147 kfree(pdent);1148 return err;1149 }1150 1151 fname_name(&nm) = dent->name;1152 fname_len(&nm) = le16_to_cpu(dent->nlen);1153 size += CALC_DENT_SIZE(fname_len(&nm));1154 if (dent->type == UBIFS_ITYPE_DIR)1155 nlink += 1;1156 kfree(pdent);1157 pdent = dent;1158 key_read(c, &dent->key, &key);1159 }1160 kfree(pdent);1161 1162 if (i_size_read(dir) != size) {1163 ubifs_err(c, "directory inode %lu has size %llu, but calculated size is %llu",1164 dir->i_ino, (unsigned long long)i_size_read(dir),1165 (unsigned long long)size);1166 ubifs_dump_inode(c, dir);1167 dump_stack();1168 return -EINVAL;1169 }1170 if (dir->i_nlink != nlink) {1171 ubifs_err(c, "directory inode %lu has nlink %u, but calculated nlink is %u",1172 dir->i_ino, dir->i_nlink, nlink);1173 ubifs_dump_inode(c, dir);1174 dump_stack();1175 return -EINVAL;1176 }1177 1178 return 0;1179}1180 1181/**1182 * dbg_check_key_order - make sure that colliding keys are properly ordered.1183 * @c: UBIFS file-system description object1184 * @zbr1: first zbranch1185 * @zbr2: following zbranch1186 *1187 * In UBIFS indexing B-tree colliding keys has to be sorted in binary order of1188 * names of the direntries/xentries which are referred by the keys. This1189 * function reads direntries/xentries referred by @zbr1 and @zbr2 and makes1190 * sure the name of direntry/xentry referred by @zbr1 is less than1191 * direntry/xentry referred by @zbr2. Returns zero if this is true, %1 if not,1192 * and a negative error code in case of failure.1193 */1194static int dbg_check_key_order(struct ubifs_info *c, struct ubifs_zbranch *zbr1,1195 struct ubifs_zbranch *zbr2)1196{1197 int err, nlen1, nlen2, cmp;1198 struct ubifs_dent_node *dent1, *dent2;1199 union ubifs_key key;1200 char key_buf[DBG_KEY_BUF_LEN];1201 1202 ubifs_assert(c, !keys_cmp(c, &zbr1->key, &zbr2->key));1203 dent1 = kmalloc(UBIFS_MAX_DENT_NODE_SZ, GFP_NOFS);1204 if (!dent1)1205 return -ENOMEM;1206 dent2 = kmalloc(UBIFS_MAX_DENT_NODE_SZ, GFP_NOFS);1207 if (!dent2) {1208 err = -ENOMEM;1209 goto out_free;1210 }1211 1212 err = ubifs_tnc_read_node(c, zbr1, dent1);1213 if (err)1214 goto out_free;1215 err = ubifs_validate_entry(c, dent1);1216 if (err)1217 goto out_free;1218 1219 err = ubifs_tnc_read_node(c, zbr2, dent2);1220 if (err)1221 goto out_free;1222 err = ubifs_validate_entry(c, dent2);1223 if (err)1224 goto out_free;1225 1226 /* Make sure node keys are the same as in zbranch */1227 err = 1;1228 key_read(c, &dent1->key, &key);1229 if (keys_cmp(c, &zbr1->key, &key)) {1230 ubifs_err(c, "1st entry at %d:%d has key %s", zbr1->lnum,1231 zbr1->offs, dbg_snprintf_key(c, &key, key_buf,1232 DBG_KEY_BUF_LEN));1233 ubifs_err(c, "but it should have key %s according to tnc",1234 dbg_snprintf_key(c, &zbr1->key, key_buf,1235 DBG_KEY_BUF_LEN));1236 ubifs_dump_node(c, dent1, UBIFS_MAX_DENT_NODE_SZ);1237 goto out_free;1238 }1239 1240 key_read(c, &dent2->key, &key);1241 if (keys_cmp(c, &zbr2->key, &key)) {1242 ubifs_err(c, "2nd entry at %d:%d has key %s", zbr1->lnum,1243 zbr1->offs, dbg_snprintf_key(c, &key, key_buf,1244 DBG_KEY_BUF_LEN));1245 ubifs_err(c, "but it should have key %s according to tnc",1246 dbg_snprintf_key(c, &zbr2->key, key_buf,1247 DBG_KEY_BUF_LEN));1248 ubifs_dump_node(c, dent2, UBIFS_MAX_DENT_NODE_SZ);1249 goto out_free;1250 }1251 1252 nlen1 = le16_to_cpu(dent1->nlen);1253 nlen2 = le16_to_cpu(dent2->nlen);1254 1255 cmp = memcmp(dent1->name, dent2->name, min_t(int, nlen1, nlen2));1256 if (cmp < 0 || (cmp == 0 && nlen1 < nlen2)) {1257 err = 0;1258 goto out_free;1259 }1260 if (cmp == 0 && nlen1 == nlen2)1261 ubifs_err(c, "2 xent/dent nodes with the same name");1262 else1263 ubifs_err(c, "bad order of colliding key %s",1264 dbg_snprintf_key(c, &key, key_buf, DBG_KEY_BUF_LEN));1265 1266 ubifs_msg(c, "first node at %d:%d\n", zbr1->lnum, zbr1->offs);1267 ubifs_dump_node(c, dent1, UBIFS_MAX_DENT_NODE_SZ);1268 ubifs_msg(c, "second node at %d:%d\n", zbr2->lnum, zbr2->offs);1269 ubifs_dump_node(c, dent2, UBIFS_MAX_DENT_NODE_SZ);1270 1271out_free:1272 kfree(dent2);1273 kfree(dent1);1274 return err;1275}1276 1277/**1278 * dbg_check_znode - check if znode is all right.1279 * @c: UBIFS file-system description object1280 * @zbr: zbranch which points to this znode1281 *1282 * This function makes sure that znode referred to by @zbr is all right.1283 * Returns zero if it is, and %-EINVAL if it is not.1284 */1285static int dbg_check_znode(struct ubifs_info *c, struct ubifs_zbranch *zbr)1286{1287 struct ubifs_znode *znode = zbr->znode;1288 struct ubifs_znode *zp = znode->parent;1289 int n, err, cmp;1290 1291 if (znode->child_cnt <= 0 || znode->child_cnt > c->fanout) {1292 err = 1;1293 goto out;1294 }1295 if (znode->level < 0) {1296 err = 2;1297 goto out;1298 }1299 if (znode->iip < 0 || znode->iip >= c->fanout) {1300 err = 3;1301 goto out;1302 }1303 1304 if (zbr->len == 0)1305 /* Only dirty zbranch may have no on-flash nodes */1306 if (!ubifs_zn_dirty(znode)) {1307 err = 4;1308 goto out;1309 }1310 1311 if (ubifs_zn_dirty(znode)) {1312 /*1313 * If znode is dirty, its parent has to be dirty as well. The1314 * order of the operation is important, so we have to have1315 * memory barriers.1316 */1317 smp_mb();1318 if (zp && !ubifs_zn_dirty(zp)) {1319 /*1320 * The dirty flag is atomic and is cleared outside the1321 * TNC mutex, so znode's dirty flag may now have1322 * been cleared. The child is always cleared before the1323 * parent, so we just need to check again.1324 */1325 smp_mb();1326 if (ubifs_zn_dirty(znode)) {1327 err = 5;1328 goto out;1329 }1330 }1331 }1332 1333 if (zp) {1334 const union ubifs_key *min, *max;1335 1336 if (znode->level != zp->level - 1) {1337 err = 6;1338 goto out;1339 }1340 1341 /* Make sure the 'parent' pointer in our znode is correct */1342 err = ubifs_search_zbranch(c, zp, &zbr->key, &n);1343 if (!err) {1344 /* This zbranch does not exist in the parent */1345 err = 7;1346 goto out;1347 }1348 1349 if (znode->iip >= zp->child_cnt) {1350 err = 8;1351 goto out;1352 }1353 1354 if (znode->iip != n) {1355 /* This may happen only in case of collisions */1356 if (keys_cmp(c, &zp->zbranch[n].key,1357 &zp->zbranch[znode->iip].key)) {1358 err = 9;1359 goto out;1360 }1361 n = znode->iip;1362 }1363 1364 /*1365 * Make sure that the first key in our znode is greater than or1366 * equal to the key in the pointing zbranch.1367 */1368 min = &zbr->key;1369 cmp = keys_cmp(c, min, &znode->zbranch[0].key);1370 if (cmp == 1) {1371 err = 10;1372 goto out;1373 }1374 1375 if (n + 1 < zp->child_cnt) {1376 max = &zp->zbranch[n + 1].key;1377 1378 /*1379 * Make sure the last key in our znode is less or1380 * equivalent than the key in the zbranch which goes1381 * after our pointing zbranch.1382 */1383 cmp = keys_cmp(c, max,1384 &znode->zbranch[znode->child_cnt - 1].key);1385 if (cmp == -1) {1386 err = 11;1387 goto out;1388 }1389 }1390 } else {1391 /* This may only be root znode */1392 if (zbr != &c->zroot) {1393 err = 12;1394 goto out;1395 }1396 }1397 1398 /*1399 * Make sure that next key is greater or equivalent then the previous1400 * one.1401 */1402 for (n = 1; n < znode->child_cnt; n++) {1403 cmp = keys_cmp(c, &znode->zbranch[n - 1].key,1404 &znode->zbranch[n].key);1405 if (cmp > 0) {1406 err = 13;1407 goto out;1408 }1409 if (cmp == 0) {1410 /* This can only be keys with colliding hash */1411 if (!is_hash_key(c, &znode->zbranch[n].key)) {1412 err = 14;1413 goto out;1414 }1415 1416 if (znode->level != 0 || c->replaying)1417 continue;1418 1419 /*1420 * Colliding keys should follow binary order of1421 * corresponding xentry/dentry names.1422 */1423 err = dbg_check_key_order(c, &znode->zbranch[n - 1],1424 &znode->zbranch[n]);1425 if (err < 0)1426 return err;1427 if (err) {1428 err = 15;1429 goto out;1430 }1431 }1432 }1433 1434 for (n = 0; n < znode->child_cnt; n++) {1435 if (!znode->zbranch[n].znode &&1436 (znode->zbranch[n].lnum == 0 ||1437 znode->zbranch[n].len == 0)) {1438 err = 16;1439 goto out;1440 }1441 1442 if (znode->zbranch[n].lnum != 0 &&1443 znode->zbranch[n].len == 0) {1444 err = 17;1445 goto out;1446 }1447 1448 if (znode->zbranch[n].lnum == 0 &&1449 znode->zbranch[n].len != 0) {1450 err = 18;1451 goto out;1452 }1453 1454 if (znode->zbranch[n].lnum == 0 &&1455 znode->zbranch[n].offs != 0) {1456 err = 19;1457 goto out;1458 }1459 1460 if (znode->level != 0 && znode->zbranch[n].znode)1461 if (znode->zbranch[n].znode->parent != znode) {1462 err = 20;1463 goto out;1464 }1465 }1466 1467 return 0;1468 1469out:1470 ubifs_err(c, "failed, error %d", err);1471 ubifs_msg(c, "dump of the znode");1472 ubifs_dump_znode(c, znode);1473 if (zp) {1474 ubifs_msg(c, "dump of the parent znode");1475 ubifs_dump_znode(c, zp);1476 }1477 dump_stack();1478 return -EINVAL;1479}1480 1481/**1482 * dbg_check_tnc - check TNC tree.1483 * @c: UBIFS file-system description object1484 * @extra: do extra checks that are possible at start commit1485 *1486 * This function traverses whole TNC tree and checks every znode. Returns zero1487 * if everything is all right and %-EINVAL if something is wrong with TNC.1488 */1489int dbg_check_tnc(struct ubifs_info *c, int extra)1490{1491 struct ubifs_znode *znode;1492 long clean_cnt = 0, dirty_cnt = 0;1493 int err, last;1494 1495 if (!dbg_is_chk_index(c))1496 return 0;1497 1498 ubifs_assert(c, mutex_is_locked(&c->tnc_mutex));1499 if (!c->zroot.znode)1500 return 0;1501 1502 znode = ubifs_tnc_postorder_first(c->zroot.znode);1503 while (1) {1504 struct ubifs_znode *prev;1505 struct ubifs_zbranch *zbr;1506 1507 if (!znode->parent)1508 zbr = &c->zroot;1509 else1510 zbr = &znode->parent->zbranch[znode->iip];1511 1512 err = dbg_check_znode(c, zbr);1513 if (err)1514 return err;1515 1516 if (extra) {1517 if (ubifs_zn_dirty(znode))1518 dirty_cnt += 1;1519 else1520 clean_cnt += 1;1521 }1522 1523 prev = znode;1524 znode = ubifs_tnc_postorder_next(c, znode);1525 if (!znode)1526 break;1527 1528 /*1529 * If the last key of this znode is equivalent to the first key1530 * of the next znode (collision), then check order of the keys.1531 */1532 last = prev->child_cnt - 1;1533 if (prev->level == 0 && znode->level == 0 && !c->replaying &&1534 !keys_cmp(c, &prev->zbranch[last].key,1535 &znode->zbranch[0].key)) {1536 err = dbg_check_key_order(c, &prev->zbranch[last],1537 &znode->zbranch[0]);1538 if (err < 0)1539 return err;1540 if (err) {1541 ubifs_msg(c, "first znode");1542 ubifs_dump_znode(c, prev);1543 ubifs_msg(c, "second znode");1544 ubifs_dump_znode(c, znode);1545 return -EINVAL;1546 }1547 }1548 }1549 1550 if (extra) {1551 if (clean_cnt != atomic_long_read(&c->clean_zn_cnt)) {1552 ubifs_err(c, "incorrect clean_zn_cnt %ld, calculated %ld",1553 atomic_long_read(&c->clean_zn_cnt),1554 clean_cnt);1555 return -EINVAL;1556 }1557 if (dirty_cnt != atomic_long_read(&c->dirty_zn_cnt)) {1558 ubifs_err(c, "incorrect dirty_zn_cnt %ld, calculated %ld",1559 atomic_long_read(&c->dirty_zn_cnt),1560 dirty_cnt);1561 return -EINVAL;1562 }1563 }1564 1565 return 0;1566}1567 1568/**1569 * dbg_walk_index - walk the on-flash index.1570 * @c: UBIFS file-system description object1571 * @leaf_cb: called for each leaf node1572 * @znode_cb: called for each indexing node1573 * @priv: private data which is passed to callbacks1574 *1575 * This function walks the UBIFS index and calls the @leaf_cb for each leaf1576 * node and @znode_cb for each indexing node. Returns zero in case of success1577 * and a negative error code in case of failure.1578 *1579 * It would be better if this function removed every znode it pulled to into1580 * the TNC, so that the behavior more closely matched the non-debugging1581 * behavior.1582 */1583int dbg_walk_index(struct ubifs_info *c, dbg_leaf_callback leaf_cb,1584 dbg_znode_callback znode_cb, void *priv)1585{1586 int err;1587 struct ubifs_zbranch *zbr;1588 struct ubifs_znode *znode, *child;1589 1590 mutex_lock(&c->tnc_mutex);1591 /* If the root indexing node is not in TNC - pull it */1592 if (!c->zroot.znode) {1593 c->zroot.znode = ubifs_load_znode(c, &c->zroot, NULL, 0);1594 if (IS_ERR(c->zroot.znode)) {1595 err = PTR_ERR(c->zroot.znode);1596 c->zroot.znode = NULL;1597 goto out_unlock;1598 }1599 }1600 1601 /*1602 * We are going to traverse the indexing tree in the postorder manner.1603 * Go down and find the leftmost indexing node where we are going to1604 * start from.1605 */1606 znode = c->zroot.znode;1607 while (znode->level > 0) {1608 zbr = &znode->zbranch[0];1609 child = zbr->znode;1610 if (!child) {1611 child = ubifs_load_znode(c, zbr, znode, 0);1612 if (IS_ERR(child)) {1613 err = PTR_ERR(child);1614 goto out_unlock;1615 }1616 }1617 1618 znode = child;1619 }1620 1621 /* Iterate over all indexing nodes */1622 while (1) {1623 int idx;1624 1625 cond_resched();1626 1627 if (znode_cb) {1628 err = znode_cb(c, znode, priv);1629 if (err) {1630 ubifs_err(c, "znode checking function returned error %d",1631 err);1632 ubifs_dump_znode(c, znode);1633 goto out_dump;1634 }1635 }1636 if (leaf_cb && znode->level == 0) {1637 for (idx = 0; idx < znode->child_cnt; idx++) {1638 zbr = &znode->zbranch[idx];1639 err = leaf_cb(c, zbr, priv);1640 if (err) {1641 ubifs_err(c, "leaf checking function returned error %d, for leaf at LEB %d:%d",1642 err, zbr->lnum, zbr->offs);1643 goto out_dump;1644 }1645 }1646 }1647 1648 if (!znode->parent)1649 break;1650 1651 idx = znode->iip + 1;1652 znode = znode->parent;1653 if (idx < znode->child_cnt) {1654 /* Switch to the next index in the parent */1655 zbr = &znode->zbranch[idx];1656 child = zbr->znode;1657 if (!child) {1658 child = ubifs_load_znode(c, zbr, znode, idx);1659 if (IS_ERR(child)) {1660 err = PTR_ERR(child);1661 goto out_unlock;1662 }1663 zbr->znode = child;1664 }1665 znode = child;1666 } else1667 /*1668 * This is the last child, switch to the parent and1669 * continue.1670 */1671 continue;1672 1673 /* Go to the lowest leftmost znode in the new sub-tree */1674 while (znode->level > 0) {1675 zbr = &znode->zbranch[0];1676 child = zbr->znode;1677 if (!child) {1678 child = ubifs_load_znode(c, zbr, znode, 0);1679 if (IS_ERR(child)) {1680 err = PTR_ERR(child);1681 goto out_unlock;1682 }1683 zbr->znode = child;1684 }1685 znode = child;1686 }1687 }1688 1689 mutex_unlock(&c->tnc_mutex);1690 return 0;1691 1692out_dump:1693 if (znode->parent)1694 zbr = &znode->parent->zbranch[znode->iip];1695 else1696 zbr = &c->zroot;1697 ubifs_msg(c, "dump of znode at LEB %d:%d", zbr->lnum, zbr->offs);1698 ubifs_dump_znode(c, znode);1699out_unlock:1700 mutex_unlock(&c->tnc_mutex);1701 return err;1702}1703 1704/**1705 * add_size - add znode size to partially calculated index size.1706 * @c: UBIFS file-system description object1707 * @znode: znode to add size for1708 * @priv: partially calculated index size1709 *1710 * This is a helper function for 'dbg_check_idx_size()' which is called for1711 * every indexing node and adds its size to the 'long long' variable pointed to1712 * by @priv.1713 */1714static int add_size(struct ubifs_info *c, struct ubifs_znode *znode, void *priv)1715{1716 long long *idx_size = priv;1717 int add;1718 1719 add = ubifs_idx_node_sz(c, znode->child_cnt);1720 add = ALIGN(add, 8);1721 *idx_size += add;1722 return 0;1723}1724 1725/**1726 * dbg_check_idx_size - check index size.1727 * @c: UBIFS file-system description object1728 * @idx_size: size to check1729 *1730 * This function walks the UBIFS index, calculates its size and checks that the1731 * size is equivalent to @idx_size. Returns zero in case of success and a1732 * negative error code in case of failure.1733 */1734int dbg_check_idx_size(struct ubifs_info *c, long long idx_size)1735{1736 int err;1737 long long calc = 0;1738 1739 if (!dbg_is_chk_index(c))1740 return 0;1741 1742 err = dbg_walk_index(c, NULL, add_size, &calc);1743 if (err) {1744 ubifs_err(c, "error %d while walking the index", err);1745 goto out_err;1746 }1747 1748 if (calc != idx_size) {1749 ubifs_err(c, "index size check failed: calculated size is %lld, should be %lld",1750 calc, idx_size);1751 dump_stack();1752 err = -EINVAL;1753 goto out_err;1754 }1755 1756 return 0;1757 1758out_err:1759 ubifs_destroy_tnc_tree(c);1760 return err;1761}1762 1763/**1764 * struct fsck_inode - information about an inode used when checking the file-system.1765 * @rb: link in the RB-tree of inodes1766 * @inum: inode number1767 * @mode: inode type, permissions, etc1768 * @nlink: inode link count1769 * @xattr_cnt: count of extended attributes1770 * @references: how many directory/xattr entries refer this inode (calculated1771 * while walking the index)1772 * @calc_cnt: for directory inode count of child directories1773 * @size: inode size (read from on-flash inode)1774 * @xattr_sz: summary size of all extended attributes (read from on-flash1775 * inode)1776 * @calc_sz: for directories calculated directory size1777 * @calc_xcnt: count of extended attributes1778 * @calc_xsz: calculated summary size of all extended attributes1779 * @xattr_nms: sum of lengths of all extended attribute names belonging to this1780 * inode (read from on-flash inode)1781 * @calc_xnms: calculated sum of lengths of all extended attribute names1782 */1783struct fsck_inode {1784 struct rb_node rb;1785 ino_t inum;1786 umode_t mode;1787 unsigned int nlink;1788 unsigned int xattr_cnt;1789 int references;1790 int calc_cnt;1791 long long size;1792 unsigned int xattr_sz;1793 long long calc_sz;1794 long long calc_xcnt;1795 long long calc_xsz;1796 unsigned int xattr_nms;1797 long long calc_xnms;1798};1799 1800/**1801 * struct fsck_data - private FS checking information.1802 * @inodes: RB-tree of all inodes (contains @struct fsck_inode objects)1803 */1804struct fsck_data {1805 struct rb_root inodes;1806};1807 1808/**1809 * add_inode - add inode information to RB-tree of inodes.1810 * @c: UBIFS file-system description object1811 * @fsckd: FS checking information1812 * @ino: raw UBIFS inode to add1813 *1814 * This is a helper function for 'check_leaf()' which adds information about1815 * inode @ino to the RB-tree of inodes. Returns inode information pointer in1816 * case of success and a negative error code in case of failure.1817 */1818static struct fsck_inode *add_inode(struct ubifs_info *c,1819 struct fsck_data *fsckd,1820 struct ubifs_ino_node *ino)1821{1822 struct rb_node **p, *parent = NULL;1823 struct fsck_inode *fscki;1824 ino_t inum = key_inum_flash(c, &ino->key);1825 struct inode *inode;1826 struct ubifs_inode *ui;1827 1828 p = &fsckd->inodes.rb_node;1829 while (*p) {1830 parent = *p;1831 fscki = rb_entry(parent, struct fsck_inode, rb);1832 if (inum < fscki->inum)1833 p = &(*p)->rb_left;1834 else if (inum > fscki->inum)1835 p = &(*p)->rb_right;1836 else1837 return fscki;1838 }1839 1840 if (inum > c->highest_inum) {1841 ubifs_err(c, "too high inode number, max. is %lu",1842 (unsigned long)c->highest_inum);1843 return ERR_PTR(-EINVAL);1844 }1845 1846 fscki = kzalloc(sizeof(struct fsck_inode), GFP_NOFS);1847 if (!fscki)1848 return ERR_PTR(-ENOMEM);1849 1850 inode = ilookup(c->vfs_sb, inum);1851 1852 fscki->inum = inum;1853 /*1854 * If the inode is present in the VFS inode cache, use it instead of1855 * the on-flash inode which might be out-of-date. E.g., the size might1856 * be out-of-date. If we do not do this, the following may happen, for1857 * example:1858 * 1. A power cut happens1859 * 2. We mount the file-system R/O, the replay process fixes up the1860 * inode size in the VFS cache, but on on-flash.1861 * 3. 'check_leaf()' fails because it hits a data node beyond inode1862 * size.1863 */1864 if (!inode) {1865 fscki->nlink = le32_to_cpu(ino->nlink);1866 fscki->size = le64_to_cpu(ino->size);1867 fscki->xattr_cnt = le32_to_cpu(ino->xattr_cnt);1868 fscki->xattr_sz = le32_to_cpu(ino->xattr_size);1869 fscki->xattr_nms = le32_to_cpu(ino->xattr_names);1870 fscki->mode = le32_to_cpu(ino->mode);1871 } else {1872 ui = ubifs_inode(inode);1873 fscki->nlink = inode->i_nlink;1874 fscki->size = inode->i_size;1875 fscki->xattr_cnt = ui->xattr_cnt;1876 fscki->xattr_sz = ui->xattr_size;1877 fscki->xattr_nms = ui->xattr_names;1878 fscki->mode = inode->i_mode;1879 iput(inode);1880 }1881 1882 if (S_ISDIR(fscki->mode)) {1883 fscki->calc_sz = UBIFS_INO_NODE_SZ;1884 fscki->calc_cnt = 2;1885 }1886 1887 rb_link_node(&fscki->rb, parent, p);1888 rb_insert_color(&fscki->rb, &fsckd->inodes);1889 1890 return fscki;1891}1892 1893/**1894 * search_inode - search inode in the RB-tree of inodes.1895 * @fsckd: FS checking information1896 * @inum: inode number to search1897 *1898 * This is a helper function for 'check_leaf()' which searches inode @inum in1899 * the RB-tree of inodes and returns an inode information pointer or %NULL if1900 * the inode was not found.1901 */1902static struct fsck_inode *search_inode(struct fsck_data *fsckd, ino_t inum)1903{1904 struct rb_node *p;1905 struct fsck_inode *fscki;1906 1907 p = fsckd->inodes.rb_node;1908 while (p) {1909 fscki = rb_entry(p, struct fsck_inode, rb);1910 if (inum < fscki->inum)1911 p = p->rb_left;1912 else if (inum > fscki->inum)1913 p = p->rb_right;1914 else1915 return fscki;1916 }1917 return NULL;1918}1919 1920/**1921 * read_add_inode - read inode node and add it to RB-tree of inodes.1922 * @c: UBIFS file-system description object1923 * @fsckd: FS checking information1924 * @inum: inode number to read1925 *1926 * This is a helper function for 'check_leaf()' which finds inode node @inum in1927 * the index, reads it, and adds it to the RB-tree of inodes. Returns inode1928 * information pointer in case of success and a negative error code in case of1929 * failure.1930 */1931static struct fsck_inode *read_add_inode(struct ubifs_info *c,1932 struct fsck_data *fsckd, ino_t inum)1933{1934 int n, err;1935 union ubifs_key key;1936 struct ubifs_znode *znode;1937 struct ubifs_zbranch *zbr;1938 struct ubifs_ino_node *ino;1939 struct fsck_inode *fscki;1940 1941 fscki = search_inode(fsckd, inum);1942 if (fscki)1943 return fscki;1944 1945 ino_key_init(c, &key, inum);1946 err = ubifs_lookup_level0(c, &key, &znode, &n);1947 if (!err) {1948 ubifs_err(c, "inode %lu not found in index", (unsigned long)inum);1949 return ERR_PTR(-ENOENT);1950 } else if (err < 0) {1951 ubifs_err(c, "error %d while looking up inode %lu",1952 err, (unsigned long)inum);1953 return ERR_PTR(err);1954 }1955 1956 zbr = &znode->zbranch[n];1957 if (zbr->len < UBIFS_INO_NODE_SZ) {1958 ubifs_err(c, "bad node %lu node length %d",1959 (unsigned long)inum, zbr->len);1960 return ERR_PTR(-EINVAL);1961 }1962 1963 ino = kmalloc(zbr->len, GFP_NOFS);1964 if (!ino)1965 return ERR_PTR(-ENOMEM);1966 1967 err = ubifs_tnc_read_node(c, zbr, ino);1968 if (err) {1969 ubifs_err(c, "cannot read inode node at LEB %d:%d, error %d",1970 zbr->lnum, zbr->offs, err);1971 kfree(ino);1972 return ERR_PTR(err);1973 }1974 1975 fscki = add_inode(c, fsckd, ino);1976 kfree(ino);1977 if (IS_ERR(fscki)) {1978 ubifs_err(c, "error %ld while adding inode %lu node",1979 PTR_ERR(fscki), (unsigned long)inum);1980 return fscki;1981 }1982 1983 return fscki;1984}1985 1986/**1987 * check_leaf - check leaf node.1988 * @c: UBIFS file-system description object1989 * @zbr: zbranch of the leaf node to check1990 * @priv: FS checking information1991 *1992 * This is a helper function for 'dbg_check_filesystem()' which is called for1993 * every single leaf node while walking the indexing tree. It checks that the1994 * leaf node referred from the indexing tree exists, has correct CRC, and does1995 * some other basic validation. This function is also responsible for building1996 * an RB-tree of inodes - it adds all inodes into the RB-tree. It also1997 * calculates reference count, size, etc for each inode in order to later1998 * compare them to the information stored inside the inodes and detect possible1999 * inconsistencies. Returns zero in case of success and a negative error code2000 * in case of failure.2001 */2002static int check_leaf(struct ubifs_info *c, struct ubifs_zbranch *zbr,2003 void *priv)2004{2005 ino_t inum;2006 void *node;2007 struct ubifs_ch *ch;2008 int err, type = key_type(c, &zbr->key);2009 struct fsck_inode *fscki;2010 2011 if (zbr->len < UBIFS_CH_SZ) {2012 ubifs_err(c, "bad leaf length %d (LEB %d:%d)",2013 zbr->len, zbr->lnum, zbr->offs);2014 return -EINVAL;2015 }2016 2017 node = kmalloc(zbr->len, GFP_NOFS);2018 if (!node)2019 return -ENOMEM;2020 2021 err = ubifs_tnc_read_node(c, zbr, node);2022 if (err) {2023 ubifs_err(c, "cannot read leaf node at LEB %d:%d, error %d",2024 zbr->lnum, zbr->offs, err);2025 goto out_free;2026 }2027 2028 /* If this is an inode node, add it to RB-tree of inodes */2029 if (type == UBIFS_INO_KEY) {2030 fscki = add_inode(c, priv, node);2031 if (IS_ERR(fscki)) {2032 err = PTR_ERR(fscki);2033 ubifs_err(c, "error %d while adding inode node", err);2034 goto out_dump;2035 }2036 goto out;2037 }2038 2039 if (type != UBIFS_DENT_KEY && type != UBIFS_XENT_KEY &&2040 type != UBIFS_DATA_KEY) {2041 ubifs_err(c, "unexpected node type %d at LEB %d:%d",2042 type, zbr->lnum, zbr->offs);2043 err = -EINVAL;2044 goto out_free;2045 }2046 2047 ch = node;2048 if (le64_to_cpu(ch->sqnum) > c->max_sqnum) {2049 ubifs_err(c, "too high sequence number, max. is %llu",2050 c->max_sqnum);2051 err = -EINVAL;2052 goto out_dump;2053 }2054 2055 if (type == UBIFS_DATA_KEY) {2056 long long blk_offs;2057 struct ubifs_data_node *dn = node;2058 2059 ubifs_assert(c, zbr->len >= UBIFS_DATA_NODE_SZ);2060 2061 /*2062 * Search the inode node this data node belongs to and insert2063 * it to the RB-tree of inodes.2064 */2065 inum = key_inum_flash(c, &dn->key);2066 fscki = read_add_inode(c, priv, inum);2067 if (IS_ERR(fscki)) {2068 err = PTR_ERR(fscki);2069 ubifs_err(c, "error %d while processing data node and trying to find inode node %lu",2070 err, (unsigned long)inum);2071 goto out_dump;2072 }2073 2074 /* Make sure the data node is within inode size */2075 blk_offs = key_block_flash(c, &dn->key);2076 blk_offs <<= UBIFS_BLOCK_SHIFT;2077 blk_offs += le32_to_cpu(dn->size);2078 if (blk_offs > fscki->size) {2079 ubifs_err(c, "data node at LEB %d:%d is not within inode size %lld",2080 zbr->lnum, zbr->offs, fscki->size);2081 err = -EINVAL;2082 goto out_dump;2083 }2084 } else {2085 int nlen;2086 struct ubifs_dent_node *dent = node;2087 struct fsck_inode *fscki1;2088 2089 ubifs_assert(c, zbr->len >= UBIFS_DENT_NODE_SZ);2090 2091 err = ubifs_validate_entry(c, dent);2092 if (err)2093 goto out_dump;2094 2095 /*2096 * Search the inode node this entry refers to and the parent2097 * inode node and insert them to the RB-tree of inodes.2098 */2099 inum = le64_to_cpu(dent->inum);2100 fscki = read_add_inode(c, priv, inum);2101 if (IS_ERR(fscki)) {2102 err = PTR_ERR(fscki);2103 ubifs_err(c, "error %d while processing entry node and trying to find inode node %lu",2104 err, (unsigned long)inum);2105 goto out_dump;2106 }2107 2108 /* Count how many direntries or xentries refers this inode */2109 fscki->references += 1;2110 2111 inum = key_inum_flash(c, &dent->key);2112 fscki1 = read_add_inode(c, priv, inum);2113 if (IS_ERR(fscki1)) {2114 err = PTR_ERR(fscki1);2115 ubifs_err(c, "error %d while processing entry node and trying to find parent inode node %lu",2116 err, (unsigned long)inum);2117 goto out_dump;2118 }2119 2120 nlen = le16_to_cpu(dent->nlen);2121 if (type == UBIFS_XENT_KEY) {2122 fscki1->calc_xcnt += 1;2123 fscki1->calc_xsz += CALC_DENT_SIZE(nlen);2124 fscki1->calc_xsz += CALC_XATTR_BYTES(fscki->size);2125 fscki1->calc_xnms += nlen;2126 } else {2127 fscki1->calc_sz += CALC_DENT_SIZE(nlen);2128 if (dent->type == UBIFS_ITYPE_DIR)2129 fscki1->calc_cnt += 1;2130 }2131 }2132 2133out:2134 kfree(node);2135 return 0;2136 2137out_dump:2138 ubifs_msg(c, "dump of node at LEB %d:%d", zbr->lnum, zbr->offs);2139 ubifs_dump_node(c, node, zbr->len);2140out_free:2141 kfree(node);2142 return err;2143}2144 2145/**2146 * free_inodes - free RB-tree of inodes.2147 * @fsckd: FS checking information2148 */2149static void free_inodes(struct fsck_data *fsckd)2150{2151 struct fsck_inode *fscki, *n;2152 2153 rbtree_postorder_for_each_entry_safe(fscki, n, &fsckd->inodes, rb)2154 kfree(fscki);2155}2156 2157/**2158 * check_inodes - checks all inodes.2159 * @c: UBIFS file-system description object2160 * @fsckd: FS checking information2161 *2162 * This is a helper function for 'dbg_check_filesystem()' which walks the2163 * RB-tree of inodes after the index scan has been finished, and checks that2164 * inode nlink, size, etc are correct. Returns zero if inodes are fine,2165 * %-EINVAL if not, and a negative error code in case of failure.2166 */2167static int check_inodes(struct ubifs_info *c, struct fsck_data *fsckd)2168{2169 int n, err;2170 union ubifs_key key;2171 struct ubifs_znode *znode;2172 struct ubifs_zbranch *zbr;2173 struct ubifs_ino_node *ino;2174 struct fsck_inode *fscki;2175 struct rb_node *this = rb_first(&fsckd->inodes);2176 2177 while (this) {2178 fscki = rb_entry(this, struct fsck_inode, rb);2179 this = rb_next(this);2180 2181 if (S_ISDIR(fscki->mode)) {2182 /*2183 * Directories have to have exactly one reference (they2184 * cannot have hardlinks), although root inode is an2185 * exception.2186 */2187 if (fscki->inum != UBIFS_ROOT_INO &&2188 fscki->references != 1) {2189 ubifs_err(c, "directory inode %lu has %d direntries which refer it, but should be 1",2190 (unsigned long)fscki->inum,2191 fscki->references);2192 goto out_dump;2193 }2194 if (fscki->inum == UBIFS_ROOT_INO &&2195 fscki->references != 0) {2196 ubifs_err(c, "root inode %lu has non-zero (%d) direntries which refer it",2197 (unsigned long)fscki->inum,2198 fscki->references);2199 goto out_dump;2200 }2201 if (fscki->calc_sz != fscki->size) {2202 ubifs_err(c, "directory inode %lu size is %lld, but calculated size is %lld",2203 (unsigned long)fscki->inum,2204 fscki->size, fscki->calc_sz);2205 goto out_dump;2206 }2207 if (fscki->calc_cnt != fscki->nlink) {2208 ubifs_err(c, "directory inode %lu nlink is %d, but calculated nlink is %d",2209 (unsigned long)fscki->inum,2210 fscki->nlink, fscki->calc_cnt);2211 goto out_dump;2212 }2213 } else {2214 if (fscki->references != fscki->nlink) {2215 ubifs_err(c, "inode %lu nlink is %d, but calculated nlink is %d",2216 (unsigned long)fscki->inum,2217 fscki->nlink, fscki->references);2218 goto out_dump;2219 }2220 }2221 if (fscki->xattr_sz != fscki->calc_xsz) {2222 ubifs_err(c, "inode %lu has xattr size %u, but calculated size is %lld",2223 (unsigned long)fscki->inum, fscki->xattr_sz,2224 fscki->calc_xsz);2225 goto out_dump;2226 }2227 if (fscki->xattr_cnt != fscki->calc_xcnt) {2228 ubifs_err(c, "inode %lu has %u xattrs, but calculated count is %lld",2229 (unsigned long)fscki->inum,2230 fscki->xattr_cnt, fscki->calc_xcnt);2231 goto out_dump;2232 }2233 if (fscki->xattr_nms != fscki->calc_xnms) {2234 ubifs_err(c, "inode %lu has xattr names' size %u, but calculated names' size is %lld",2235 (unsigned long)fscki->inum, fscki->xattr_nms,2236 fscki->calc_xnms);2237 goto out_dump;2238 }2239 }2240 2241 return 0;2242 2243out_dump:2244 /* Read the bad inode and dump it */2245 ino_key_init(c, &key, fscki->inum);2246 err = ubifs_lookup_level0(c, &key, &znode, &n);2247 if (!err) {2248 ubifs_err(c, "inode %lu not found in index",2249 (unsigned long)fscki->inum);2250 return -ENOENT;2251 } else if (err < 0) {2252 ubifs_err(c, "error %d while looking up inode %lu",2253 err, (unsigned long)fscki->inum);2254 return err;2255 }2256 2257 zbr = &znode->zbranch[n];2258 ino = kmalloc(zbr->len, GFP_NOFS);2259 if (!ino)2260 return -ENOMEM;2261 2262 err = ubifs_tnc_read_node(c, zbr, ino);2263 if (err) {2264 ubifs_err(c, "cannot read inode node at LEB %d:%d, error %d",2265 zbr->lnum, zbr->offs, err);2266 kfree(ino);2267 return err;2268 }2269 2270 ubifs_msg(c, "dump of the inode %lu sitting in LEB %d:%d",2271 (unsigned long)fscki->inum, zbr->lnum, zbr->offs);2272 ubifs_dump_node(c, ino, zbr->len);2273 kfree(ino);2274 return -EINVAL;2275}2276 2277/**2278 * dbg_check_filesystem - check the file-system.2279 * @c: UBIFS file-system description object2280 *2281 * This function checks the file system, namely:2282 * o makes sure that all leaf nodes exist and their CRCs are correct;2283 * o makes sure inode nlink, size, xattr size/count are correct (for all2284 * inodes).2285 *2286 * The function reads whole indexing tree and all nodes, so it is pretty2287 * heavy-weight. Returns zero if the file-system is consistent, %-EINVAL if2288 * not, and a negative error code in case of failure.2289 */2290int dbg_check_filesystem(struct ubifs_info *c)2291{2292 int err;2293 struct fsck_data fsckd;2294 2295 if (!dbg_is_chk_fs(c))2296 return 0;2297 2298 fsckd.inodes = RB_ROOT;2299 err = dbg_walk_index(c, check_leaf, NULL, &fsckd);2300 if (err)2301 goto out_free;2302 2303 err = check_inodes(c, &fsckd);2304 if (err)2305 goto out_free;2306 2307 free_inodes(&fsckd);2308 return 0;2309 2310out_free:2311 ubifs_err(c, "file-system check failed with error %d", err);2312 dump_stack();2313 free_inodes(&fsckd);2314 return err;2315}2316 2317/**2318 * dbg_check_data_nodes_order - check that list of data nodes is sorted.2319 * @c: UBIFS file-system description object2320 * @head: the list of nodes ('struct ubifs_scan_node' objects)2321 *2322 * This function returns zero if the list of data nodes is sorted correctly,2323 * and %-EINVAL if not.2324 */2325int dbg_check_data_nodes_order(struct ubifs_info *c, struct list_head *head)2326{2327 struct list_head *cur;2328 struct ubifs_scan_node *sa, *sb;2329 2330 if (!dbg_is_chk_gen(c))2331 return 0;2332 2333 for (cur = head->next; cur->next != head; cur = cur->next) {2334 ino_t inuma, inumb;2335 uint32_t blka, blkb;2336 2337 cond_resched();2338 sa = container_of(cur, struct ubifs_scan_node, list);2339 sb = container_of(cur->next, struct ubifs_scan_node, list);2340 2341 if (sa->type != UBIFS_DATA_NODE) {2342 ubifs_err(c, "bad node type %d", sa->type);2343 ubifs_dump_node(c, sa->node, c->leb_size - sa->offs);2344 return -EINVAL;2345 }2346 if (sb->type != UBIFS_DATA_NODE) {2347 ubifs_err(c, "bad node type %d", sb->type);2348 ubifs_dump_node(c, sb->node, c->leb_size - sb->offs);2349 return -EINVAL;2350 }2351 2352 inuma = key_inum(c, &sa->key);2353 inumb = key_inum(c, &sb->key);2354 2355 if (inuma < inumb)2356 continue;2357 if (inuma > inumb) {2358 ubifs_err(c, "larger inum %lu goes before inum %lu",2359 (unsigned long)inuma, (unsigned long)inumb);2360 goto error_dump;2361 }2362 2363 blka = key_block(c, &sa->key);2364 blkb = key_block(c, &sb->key);2365 2366 if (blka > blkb) {2367 ubifs_err(c, "larger block %u goes before %u", blka, blkb);2368 goto error_dump;2369 }2370 if (blka == blkb) {2371 ubifs_err(c, "two data nodes for the same block");2372 goto error_dump;2373 }2374 }2375 2376 return 0;2377 2378error_dump:2379 ubifs_dump_node(c, sa->node, c->leb_size - sa->offs);2380 ubifs_dump_node(c, sb->node, c->leb_size - sb->offs);2381 return -EINVAL;2382}2383 2384/**2385 * dbg_check_nondata_nodes_order - check that list of data nodes is sorted.2386 * @c: UBIFS file-system description object2387 * @head: the list of nodes ('struct ubifs_scan_node' objects)2388 *2389 * This function returns zero if the list of non-data nodes is sorted correctly,2390 * and %-EINVAL if not.2391 */2392int dbg_check_nondata_nodes_order(struct ubifs_info *c, struct list_head *head)2393{2394 struct list_head *cur;2395 struct ubifs_scan_node *sa, *sb;2396 2397 if (!dbg_is_chk_gen(c))2398 return 0;2399 2400 for (cur = head->next; cur->next != head; cur = cur->next) {2401 ino_t inuma, inumb;2402 uint32_t hasha, hashb;2403 2404 cond_resched();2405 sa = container_of(cur, struct ubifs_scan_node, list);2406 sb = container_of(cur->next, struct ubifs_scan_node, list);2407 2408 if (sa->type != UBIFS_INO_NODE && sa->type != UBIFS_DENT_NODE &&2409 sa->type != UBIFS_XENT_NODE) {2410 ubifs_err(c, "bad node type %d", sa->type);2411 ubifs_dump_node(c, sa->node, c->leb_size - sa->offs);2412 return -EINVAL;2413 }2414 if (sb->type != UBIFS_INO_NODE && sb->type != UBIFS_DENT_NODE &&2415 sb->type != UBIFS_XENT_NODE) {2416 ubifs_err(c, "bad node type %d", sb->type);2417 ubifs_dump_node(c, sb->node, c->leb_size - sb->offs);2418 return -EINVAL;2419 }2420 2421 if (sa->type != UBIFS_INO_NODE && sb->type == UBIFS_INO_NODE) {2422 ubifs_err(c, "non-inode node goes before inode node");2423 goto error_dump;2424 }2425 2426 if (sa->type == UBIFS_INO_NODE && sb->type != UBIFS_INO_NODE)2427 continue;2428 2429 if (sa->type == UBIFS_INO_NODE && sb->type == UBIFS_INO_NODE) {2430 /* Inode nodes are sorted in descending size order */2431 if (sa->len < sb->len) {2432 ubifs_err(c, "smaller inode node goes first");2433 goto error_dump;2434 }2435 continue;2436 }2437 2438 /*2439 * This is either a dentry or xentry, which should be sorted in2440 * ascending (parent ino, hash) order.2441 */2442 inuma = key_inum(c, &sa->key);2443 inumb = key_inum(c, &sb->key);2444 2445 if (inuma < inumb)2446 continue;2447 if (inuma > inumb) {2448 ubifs_err(c, "larger inum %lu goes before inum %lu",2449 (unsigned long)inuma, (unsigned long)inumb);2450 goto error_dump;2451 }2452 2453 hasha = key_block(c, &sa->key);2454 hashb = key_block(c, &sb->key);2455 2456 if (hasha > hashb) {2457 ubifs_err(c, "larger hash %u goes before %u",2458 hasha, hashb);2459 goto error_dump;2460 }2461 }2462 2463 return 0;2464 2465error_dump:2466 ubifs_msg(c, "dumping first node");2467 ubifs_dump_node(c, sa->node, c->leb_size - sa->offs);2468 ubifs_msg(c, "dumping second node");2469 ubifs_dump_node(c, sb->node, c->leb_size - sb->offs);2470 return -EINVAL;2471}2472 2473static inline int chance(unsigned int n, unsigned int out_of)2474{2475 return !!(get_random_u32_below(out_of) + 1 <= n);2476 2477}2478 2479static int power_cut_emulated(struct ubifs_info *c, int lnum, int write)2480{2481 struct ubifs_debug_info *d = c->dbg;2482 2483 ubifs_assert(c, dbg_is_tst_rcvry(c));2484 2485 if (!d->pc_cnt) {2486 /* First call - decide delay to the power cut */2487 if (chance(1, 2)) {2488 unsigned long delay;2489 2490 if (chance(1, 2)) {2491 d->pc_delay = 1;2492 /* Fail within 1 minute */2493 delay = get_random_u32_below(60000);2494 d->pc_timeout = jiffies;2495 d->pc_timeout += msecs_to_jiffies(delay);2496 ubifs_warn(c, "failing after %lums", delay);2497 } else {2498 d->pc_delay = 2;2499 delay = get_random_u32_below(10000);2500 /* Fail within 10000 operations */2501 d->pc_cnt_max = delay;2502 ubifs_warn(c, "failing after %lu calls", delay);2503 }2504 }2505 2506 d->pc_cnt += 1;2507 }2508 2509 /* Determine if failure delay has expired */2510 if (d->pc_delay == 1 && time_before(jiffies, d->pc_timeout))2511 return 0;2512 if (d->pc_delay == 2 && d->pc_cnt++ < d->pc_cnt_max)2513 return 0;2514 2515 if (lnum == UBIFS_SB_LNUM) {2516 if (write && chance(1, 2))2517 return 0;2518 if (chance(19, 20))2519 return 0;2520 ubifs_warn(c, "failing in super block LEB %d", lnum);2521 } else if (lnum == UBIFS_MST_LNUM || lnum == UBIFS_MST_LNUM + 1) {2522 if (chance(19, 20))2523 return 0;2524 ubifs_warn(c, "failing in master LEB %d", lnum);2525 } else if (lnum >= UBIFS_LOG_LNUM && lnum <= c->log_last) {2526 if (write && chance(99, 100))2527 return 0;2528 if (chance(399, 400))2529 return 0;2530 ubifs_warn(c, "failing in log LEB %d", lnum);2531 } else if (lnum >= c->lpt_first && lnum <= c->lpt_last) {2532 if (write && chance(7, 8))2533 return 0;2534 if (chance(19, 20))2535 return 0;2536 ubifs_warn(c, "failing in LPT LEB %d", lnum);2537 } else if (lnum >= c->orph_first && lnum <= c->orph_last) {2538 if (write && chance(1, 2))2539 return 0;2540 if (chance(9, 10))2541 return 0;2542 ubifs_warn(c, "failing in orphan LEB %d", lnum);2543 } else if (lnum == c->ihead_lnum) {2544 if (chance(99, 100))2545 return 0;2546 ubifs_warn(c, "failing in index head LEB %d", lnum);2547 } else if (c->jheads && lnum == c->jheads[GCHD].wbuf.lnum) {2548 if (chance(9, 10))2549 return 0;2550 ubifs_warn(c, "failing in GC head LEB %d", lnum);2551 } else if (write && !RB_EMPTY_ROOT(&c->buds) &&2552 !ubifs_search_bud(c, lnum)) {2553 if (chance(19, 20))2554 return 0;2555 ubifs_warn(c, "failing in non-bud LEB %d", lnum);2556 } else if (c->cmt_state == COMMIT_RUNNING_BACKGROUND ||2557 c->cmt_state == COMMIT_RUNNING_REQUIRED) {2558 if (chance(999, 1000))2559 return 0;2560 ubifs_warn(c, "failing in bud LEB %d commit running", lnum);2561 } else {2562 if (chance(9999, 10000))2563 return 0;2564 ubifs_warn(c, "failing in bud LEB %d commit not running", lnum);2565 }2566 2567 d->pc_happened = 1;2568 ubifs_warn(c, "========== Power cut emulated ==========");2569 dump_stack();2570 return 1;2571}2572 2573static int corrupt_data(const struct ubifs_info *c, const void *buf,2574 unsigned int len)2575{2576 unsigned int from, to, ffs = chance(1, 2);2577 unsigned char *p = (void *)buf;2578 2579 from = get_random_u32_below(len);2580 /* Corruption span max to end of write unit */2581 to = min(len, ALIGN(from + 1, c->max_write_size));2582 2583 ubifs_warn(c, "filled bytes %u-%u with %s", from, to - 1,2584 ffs ? "0xFFs" : "random data");2585 2586 if (ffs)2587 memset(p + from, 0xFF, to - from);2588 else2589 get_random_bytes(p + from, to - from);2590 2591 return to;2592}2593 2594int dbg_leb_write(struct ubifs_info *c, int lnum, const void *buf,2595 int offs, int len)2596{2597 int err, failing;2598 2599 if (dbg_is_power_cut(c))2600 return -EROFS;2601 2602 failing = power_cut_emulated(c, lnum, 1);2603 if (failing) {2604 len = corrupt_data(c, buf, len);2605 ubifs_warn(c, "actually write %d bytes to LEB %d:%d (the buffer was corrupted)",2606 len, lnum, offs);2607 }2608 err = ubi_leb_write(c->ubi, lnum, buf, offs, len);2609 if (err)2610 return err;2611 if (failing)2612 return -EROFS;2613 return 0;2614}2615 2616int dbg_leb_change(struct ubifs_info *c, int lnum, const void *buf,2617 int len)2618{2619 int err;2620 2621 if (dbg_is_power_cut(c))2622 return -EROFS;2623 if (power_cut_emulated(c, lnum, 1))2624 return -EROFS;2625 err = ubi_leb_change(c->ubi, lnum, buf, len);2626 if (err)2627 return err;2628 if (power_cut_emulated(c, lnum, 1))2629 return -EROFS;2630 return 0;2631}2632 2633int dbg_leb_unmap(struct ubifs_info *c, int lnum)2634{2635 int err;2636 2637 if (dbg_is_power_cut(c))2638 return -EROFS;2639 if (power_cut_emulated(c, lnum, 0))2640 return -EROFS;2641 err = ubi_leb_unmap(c->ubi, lnum);2642 if (err)2643 return err;2644 if (power_cut_emulated(c, lnum, 0))2645 return -EROFS;2646 return 0;2647}2648 2649int dbg_leb_map(struct ubifs_info *c, int lnum)2650{2651 int err;2652 2653 if (dbg_is_power_cut(c))2654 return -EROFS;2655 if (power_cut_emulated(c, lnum, 0))2656 return -EROFS;2657 err = ubi_leb_map(c->ubi, lnum);2658 if (err)2659 return err;2660 if (power_cut_emulated(c, lnum, 0))2661 return -EROFS;2662 return 0;2663}2664 2665/*2666 * Root directory for UBIFS stuff in debugfs. Contains sub-directories which2667 * contain the stuff specific to particular file-system mounts.2668 */2669static struct dentry *dfs_rootdir;2670 2671static int dfs_file_open(struct inode *inode, struct file *file)2672{2673 file->private_data = inode->i_private;2674 return nonseekable_open(inode, file);2675}2676 2677/**2678 * provide_user_output - provide output to the user reading a debugfs file.2679 * @val: boolean value for the answer2680 * @u: the buffer to store the answer at2681 * @count: size of the buffer2682 * @ppos: position in the @u output buffer2683 *2684 * This is a simple helper function which stores @val boolean value in the user2685 * buffer when the user reads one of UBIFS debugfs files. Returns amount of2686 * bytes written to @u in case of success and a negative error code in case of2687 * failure.2688 */2689static int provide_user_output(int val, char __user *u, size_t count,2690 loff_t *ppos)2691{2692 char buf[3];2693 2694 if (val)2695 buf[0] = '1';2696 else2697 buf[0] = '0';2698 buf[1] = '\n';2699 buf[2] = 0x00;2700 2701 return simple_read_from_buffer(u, count, ppos, buf, 2);2702}2703 2704static ssize_t dfs_file_read(struct file *file, char __user *u, size_t count,2705 loff_t *ppos)2706{2707 struct dentry *dent = file->f_path.dentry;2708 struct ubifs_info *c = file->private_data;2709 struct ubifs_debug_info *d = c->dbg;2710 int val;2711 2712 if (dent == d->dfs_chk_gen)2713 val = d->chk_gen;2714 else if (dent == d->dfs_chk_index)2715 val = d->chk_index;2716 else if (dent == d->dfs_chk_orph)2717 val = d->chk_orph;2718 else if (dent == d->dfs_chk_lprops)2719 val = d->chk_lprops;2720 else if (dent == d->dfs_chk_fs)2721 val = d->chk_fs;2722 else if (dent == d->dfs_tst_rcvry)2723 val = d->tst_rcvry;2724 else if (dent == d->dfs_ro_error)2725 val = c->ro_error;2726 else2727 return -EINVAL;2728 2729 return provide_user_output(val, u, count, ppos);2730}2731 2732/**2733 * interpret_user_input - interpret user debugfs file input.2734 * @u: user-provided buffer with the input2735 * @count: buffer size2736 *2737 * This is a helper function which interpret user input to a boolean UBIFS2738 * debugfs file. Returns %0 or %1 in case of success and a negative error code2739 * in case of failure.2740 */2741static int interpret_user_input(const char __user *u, size_t count)2742{2743 size_t buf_size;2744 char buf[8];2745 2746 buf_size = min_t(size_t, count, (sizeof(buf) - 1));2747 if (copy_from_user(buf, u, buf_size))2748 return -EFAULT;2749 2750 if (buf[0] == '1')2751 return 1;2752 else if (buf[0] == '0')2753 return 0;2754 2755 return -EINVAL;2756}2757 2758static ssize_t dfs_file_write(struct file *file, const char __user *u,2759 size_t count, loff_t *ppos)2760{2761 struct ubifs_info *c = file->private_data;2762 struct ubifs_debug_info *d = c->dbg;2763 struct dentry *dent = file->f_path.dentry;2764 int val;2765 2766 if (file->f_path.dentry == d->dfs_dump_lprops) {2767 ubifs_dump_lprops(c);2768 return count;2769 }2770 if (file->f_path.dentry == d->dfs_dump_budg) {2771 ubifs_dump_budg(c, &c->bi);2772 return count;2773 }2774 if (file->f_path.dentry == d->dfs_dump_tnc) {2775 mutex_lock(&c->tnc_mutex);2776 ubifs_dump_tnc(c);2777 mutex_unlock(&c->tnc_mutex);2778 return count;2779 }2780 2781 val = interpret_user_input(u, count);2782 if (val < 0)2783 return val;2784 2785 if (dent == d->dfs_chk_gen)2786 d->chk_gen = val;2787 else if (dent == d->dfs_chk_index)2788 d->chk_index = val;2789 else if (dent == d->dfs_chk_orph)2790 d->chk_orph = val;2791 else if (dent == d->dfs_chk_lprops)2792 d->chk_lprops = val;2793 else if (dent == d->dfs_chk_fs)2794 d->chk_fs = val;2795 else if (dent == d->dfs_tst_rcvry)2796 d->tst_rcvry = val;2797 else if (dent == d->dfs_ro_error)2798 c->ro_error = !!val;2799 else2800 return -EINVAL;2801 2802 return count;2803}2804 2805static const struct file_operations dfs_fops = {2806 .open = dfs_file_open,2807 .read = dfs_file_read,2808 .write = dfs_file_write,2809 .owner = THIS_MODULE,2810};2811 2812/**2813 * dbg_debugfs_init_fs - initialize debugfs for UBIFS instance.2814 * @c: UBIFS file-system description object2815 *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 the2819 * 'ubifs_debugging_init()' function is because it is better to initialize2820 * debugfs interfaces at the very end of the mount process, and remove them at2821 * the very beginning of the mount process.2822 */2823void 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, 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 object2883 */2884void dbg_debugfs_exit_fs(struct ubifs_info *c)2885{2886 debugfs_remove_recursive(c->dbg->dfs_dir);2887}2888 2889struct ubifs_global_debug_info ubifs_dbg;2890 2891static struct dentry *dfs_chk_gen;2892static struct dentry *dfs_chk_index;2893static struct dentry *dfs_chk_orph;2894static struct dentry *dfs_chk_lprops;2895static struct dentry *dfs_chk_fs;2896static struct dentry *dfs_tst_rcvry;2897 2898static 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 else2917 return -EINVAL;2918 2919 return provide_user_output(val, u, count, ppos);2920}2921 2922static 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 else2945 return -EINVAL;2946 2947 return count;2948}2949 2950static const struct file_operations dfs_global_fops = {2951 .read = dfs_global_file_read,2952 .write = dfs_global_file_write,2953 .owner = THIS_MODULE,2954};2955 2956/**2957 * dbg_debugfs_init - initialize debugfs file-system.2958 *2959 * UBIFS uses debugfs file-system to expose various debugging knobs to2960 * user-space. This function creates "ubifs" directory in the debugfs2961 * file-system.2962 */2963void dbg_debugfs_init(void)2964{2965 const char *fname;2966 2967 fname = "ubifs";2968 dfs_rootdir = debugfs_create_dir(fname, NULL);2969 2970 fname = "chk_general";2971 dfs_chk_gen = debugfs_create_file(fname, S_IRUSR | S_IWUSR, dfs_rootdir,2972 NULL, &dfs_global_fops);2973 2974 fname = "chk_index";2975 dfs_chk_index = debugfs_create_file(fname, S_IRUSR | S_IWUSR,2976 dfs_rootdir, NULL, &dfs_global_fops);2977 2978 fname = "chk_orphans";2979 dfs_chk_orph = debugfs_create_file(fname, S_IRUSR | S_IWUSR,2980 dfs_rootdir, NULL, &dfs_global_fops);2981 2982 fname = "chk_lprops";2983 dfs_chk_lprops = debugfs_create_file(fname, S_IRUSR | S_IWUSR,2984 dfs_rootdir, NULL, &dfs_global_fops);2985 2986 fname = "chk_fs";2987 dfs_chk_fs = debugfs_create_file(fname, S_IRUSR | S_IWUSR, dfs_rootdir,2988 NULL, &dfs_global_fops);2989 2990 fname = "tst_recovery";2991 dfs_tst_rcvry = debugfs_create_file(fname, S_IRUSR | S_IWUSR,2992 dfs_rootdir, NULL, &dfs_global_fops);2993}2994 2995/**2996 * dbg_debugfs_exit - remove the "ubifs" directory from debugfs file-system.2997 */2998void dbg_debugfs_exit(void)2999{3000 debugfs_remove_recursive(dfs_rootdir);3001}3002 3003void ubifs_assert_failed(struct ubifs_info *c, const char *expr,3004 const char *file, int line)3005{3006 ubifs_err(c, "UBIFS assert failed: %s, in %s:%u", expr, file, line);3007 3008 switch (c->assert_action) {3009 case ASSACT_PANIC:3010 BUG();3011 break;3012 3013 case ASSACT_RO:3014 ubifs_ro_mode(c, -EINVAL);3015 break;3016 3017 case ASSACT_REPORT:3018 default:3019 dump_stack();3020 break;3021 3022 }3023}3024 3025/**3026 * ubifs_debugging_init - initialize UBIFS debugging.3027 * @c: UBIFS file-system description object3028 *3029 * This function initializes debugging-related data for the file system.3030 * Returns zero in case of success and a negative error code in case of3031 * failure.3032 */3033int ubifs_debugging_init(struct ubifs_info *c)3034{3035 c->dbg = kzalloc(sizeof(struct ubifs_debug_info), GFP_KERNEL);3036 if (!c->dbg)3037 return -ENOMEM;3038 3039 return 0;3040}3041 3042/**3043 * ubifs_debugging_exit - free debugging data.3044 * @c: UBIFS file-system description object3045 */3046void ubifs_debugging_exit(struct ubifs_info *c)3047{3048 kfree(c->dbg);3049}3050