linux/fs/ubifs/debug.c
<<
>>
Prefs
   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
  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        } else
 124                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->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->i_ctime.tv_sec,
 247               (unsigned int)inode->i_ctime.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
 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 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);
 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        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
 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        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
 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 object
 973 *
 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 object
 985 *
 986 * This function saves information about UBIFS free space, dirty space, etc, in
 987 * 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 it
1001         * affects the free space calculations, and UBIFS might not know about
1002         * all freeable eraseblocks. Indeed, we know about freeable eraseblocks
1003         * only when we read their lprops, and we do this only lazily, upon the
1004         * need. So at any given point of time @c->freeable_cnt might be not
1005         * exactly accurate.
1006         *
1007         * Just one example about the issue we hit when we did not zero
1008         * @c->freeable_cnt.
1009         * 1. The file-system is mounted R/O, c->freeable_cnt is %0. We save the
1010         *    amount of free space in @d->saved_free
1011         * 2. We re-mount R/W, which makes UBIFS to read the "lsave"
1012         *    information from flash, where we cache LEBs from various
1013         *    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_cnt
1018         *    becomes %1.
1019         * 4. We calculate the amount of free space when the re-mount is
1020         *    finished in 'dbg_check_space_info()' and it does not match
1021         *    @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 object
1033 *
1034 * This function compares current flash space information with the information
1035 * 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 has
1037 * 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 object
1079 * @inode: inode to check
1080 *
1081 * If inode is clean, synchronized inode size has to be equivalent to current
1082 * inode size. This function has to be called only for locked inodes (@i_mutex
1083 * has to be locked). Returns %0 if synchronized inode size if correct, and
1084 * %-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 object
1114 * @dir: the directory to calculate size for
1115 * @size: the result is returned here
1116 *
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 of
1119 * failure.
1120 *
1121 * Note, it is good idea to make sure the @dir->i_mutex is locked before
1122 * 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 object
1184 * @zbr1: first zbranch
1185 * @zbr2: following zbranch
1186 *
1187 * In UBIFS indexing B-tree colliding keys has to be sorted in binary order of
1188 * names of the direntries/xentries which are referred by the keys. This
1189 * function reads direntries/xentries referred by @zbr1 and @zbr2 and makes
1190 * sure the name of direntry/xentry referred by @zbr1 is less than
1191 * 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        else
1263                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 object
1280 * @zbr: zbranch which points to this znode
1281 *
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. The
1314                 * order of the operation is important, so we have to have
1315                 * memory barriers.
1316                 */
1317                smp_mb();
1318                if (zp && !ubifs_zn_dirty(zp)) {
1319                        /*
1320                         * The dirty flag is atomic and is cleared outside the
1321                         * TNC mutex, so znode's dirty flag may now have
1322                         * been cleared. The child is always cleared before the
1323                         * 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 or
1366                 * 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 or
1380                         * equivalent than the key in the zbranch which goes
1381                         * 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 previous
1400         * 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 of
1421                         * 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 object
1484 * @extra: do extra checks that are possible at start commit
1485 *
1486 * This function traverses whole TNC tree and checks every znode. Returns zero
1487 * 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                else
1510                        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                        else
1520                                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 key
1530                 * 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 object
1571 * @leaf_cb: called for each leaf node
1572 * @znode_cb: called for each indexing node
1573 * @priv: private data which is passed to callbacks
1574 *
1575 * This function walks the UBIFS index and calls the @leaf_cb for each leaf
1576 * node and @znode_cb for each indexing node. Returns zero in case of success
1577 * and a negative error code in case of failure.
1578 *
1579 * It would be better if this function removed every znode it pulled to into
1580 * the TNC, so that the behavior more closely matched the non-debugging
1581 * 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 to
1604         * 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                } else
1667                        /*
1668                         * This is the last child, switch to the parent and
1669                         * 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        else
1696                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 object
1707 * @znode: znode to add size for
1708 * @priv: partially calculated index size
1709 *
1710 * This is a helper function for 'dbg_check_idx_size()' which is called for
1711 * every indexing node and adds its size to the 'long long' variable pointed to
1712 * 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 object
1728 * @idx_size: size to check
1729 *
1730 * This function walks the UBIFS index, calculates its size and checks that the
1731 * size is equivalent to @idx_size. Returns zero in case of success and a
1732 * 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                return 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                return -EINVAL;
1753        }
1754
1755        return 0;
1756}
1757
1758/**
1759 * struct fsck_inode - information about an inode used when checking the file-system.
1760 * @rb: link in the RB-tree of inodes
1761 * @inum: inode number
1762 * @mode: inode type, permissions, etc
1763 * @nlink: inode link count
1764 * @xattr_cnt: count of extended attributes
1765 * @references: how many directory/xattr entries refer this inode (calculated
1766 *              while walking the index)
1767 * @calc_cnt: for directory inode count of child directories
1768 * @size: inode size (read from on-flash inode)
1769 * @xattr_sz: summary size of all extended attributes (read from on-flash
1770 *            inode)
1771 * @calc_sz: for directories calculated directory size
1772 * @calc_xcnt: count of extended attributes
1773 * @calc_xsz: calculated summary size of all extended attributes
1774 * @xattr_nms: sum of lengths of all extended attribute names belonging to this
1775 *             inode (read from on-flash inode)
1776 * @calc_xnms: calculated sum of lengths of all extended attribute names
1777 */
1778struct fsck_inode {
1779        struct rb_node rb;
1780        ino_t inum;
1781        umode_t mode;
1782        unsigned int nlink;
1783        unsigned int xattr_cnt;
1784        int references;
1785        int calc_cnt;
1786        long long size;
1787        unsigned int xattr_sz;
1788        long long calc_sz;
1789        long long calc_xcnt;
1790        long long calc_xsz;
1791        unsigned int xattr_nms;
1792        long long calc_xnms;
1793};
1794
1795/**
1796 * struct fsck_data - private FS checking information.
1797 * @inodes: RB-tree of all inodes (contains @struct fsck_inode objects)
1798 */
1799struct fsck_data {
1800        struct rb_root inodes;
1801};
1802
1803/**
1804 * add_inode - add inode information to RB-tree of inodes.
1805 * @c: UBIFS file-system description object
1806 * @fsckd: FS checking information
1807 * @ino: raw UBIFS inode to add
1808 *
1809 * This is a helper function for 'check_leaf()' which adds information about
1810 * inode @ino to the RB-tree of inodes. Returns inode information pointer in
1811 * case of success and a negative error code in case of failure.
1812 */
1813static struct fsck_inode *add_inode(struct ubifs_info *c,
1814                                    struct fsck_data *fsckd,
1815                                    struct ubifs_ino_node *ino)
1816{
1817        struct rb_node **p, *parent = NULL;
1818        struct fsck_inode *fscki;
1819        ino_t inum = key_inum_flash(c, &ino->key);
1820        struct inode *inode;
1821        struct ubifs_inode *ui;
1822
1823        p = &fsckd->inodes.rb_node;
1824        while (*p) {
1825                parent = *p;
1826                fscki = rb_entry(parent, struct fsck_inode, rb);
1827                if (inum < fscki->inum)
1828                        p = &(*p)->rb_left;
1829                else if (inum > fscki->inum)
1830                        p = &(*p)->rb_right;
1831                else
1832                        return fscki;
1833        }
1834
1835        if (inum > c->highest_inum) {
1836                ubifs_err(c, "too high inode number, max. is %lu",
1837                          (unsigned long)c->highest_inum);
1838                return ERR_PTR(-EINVAL);
1839        }
1840
1841        fscki = kzalloc(sizeof(struct fsck_inode), GFP_NOFS);
1842        if (!fscki)
1843                return ERR_PTR(-ENOMEM);
1844
1845        inode = ilookup(c->vfs_sb, inum);
1846
1847        fscki->inum = inum;
1848        /*
1849         * If the inode is present in the VFS inode cache, use it instead of
1850         * the on-flash inode which might be out-of-date. E.g., the size might
1851         * be out-of-date. If we do not do this, the following may happen, for
1852         * example:
1853         *   1. A power cut happens
1854         *   2. We mount the file-system R/O, the replay process fixes up the
1855         *      inode size in the VFS cache, but on on-flash.
1856         *   3. 'check_leaf()' fails because it hits a data node beyond inode
1857         *      size.
1858         */
1859        if (!inode) {
1860                fscki->nlink = le32_to_cpu(ino->nlink);
1861                fscki->size = le64_to_cpu(ino->size);
1862                fscki->xattr_cnt = le32_to_cpu(ino->xattr_cnt);
1863                fscki->xattr_sz = le32_to_cpu(ino->xattr_size);
1864                fscki->xattr_nms = le32_to_cpu(ino->xattr_names);
1865                fscki->mode = le32_to_cpu(ino->mode);
1866        } else {
1867                ui = ubifs_inode(inode);
1868                fscki->nlink = inode->i_nlink;
1869                fscki->size = inode->i_size;
1870                fscki->xattr_cnt = ui->xattr_cnt;
1871                fscki->xattr_sz = ui->xattr_size;
1872                fscki->xattr_nms = ui->xattr_names;
1873                fscki->mode = inode->i_mode;
1874                iput(inode);
1875        }
1876
1877        if (S_ISDIR(fscki->mode)) {
1878                fscki->calc_sz = UBIFS_INO_NODE_SZ;
1879                fscki->calc_cnt = 2;
1880        }
1881
1882        rb_link_node(&fscki->rb, parent, p);
1883        rb_insert_color(&fscki->rb, &fsckd->inodes);
1884
1885        return fscki;
1886}
1887
1888/**
1889 * search_inode - search inode in the RB-tree of inodes.
1890 * @fsckd: FS checking information
1891 * @inum: inode number to search
1892 *
1893 * This is a helper function for 'check_leaf()' which searches inode @inum in
1894 * the RB-tree of inodes and returns an inode information pointer or %NULL if
1895 * the inode was not found.
1896 */
1897static struct fsck_inode *search_inode(struct fsck_data *fsckd, ino_t inum)
1898{
1899        struct rb_node *p;
1900        struct fsck_inode *fscki;
1901
1902        p = fsckd->inodes.rb_node;
1903        while (p) {
1904                fscki = rb_entry(p, struct fsck_inode, rb);
1905                if (inum < fscki->inum)
1906                        p = p->rb_left;
1907                else if (inum > fscki->inum)
1908                        p = p->rb_right;
1909                else
1910                        return fscki;
1911        }
1912        return NULL;
1913}
1914
1915/**
1916 * read_add_inode - read inode node and add it to RB-tree of inodes.
1917 * @c: UBIFS file-system description object
1918 * @fsckd: FS checking information
1919 * @inum: inode number to read
1920 *
1921 * This is a helper function for 'check_leaf()' which finds inode node @inum in
1922 * the index, reads it, and adds it to the RB-tree of inodes. Returns inode
1923 * information pointer in case of success and a negative error code in case of
1924 * failure.
1925 */
1926static struct fsck_inode *read_add_inode(struct ubifs_info *c,
1927                                         struct fsck_data *fsckd, ino_t inum)
1928{
1929        int n, err;
1930        union ubifs_key key;
1931        struct ubifs_znode *znode;
1932        struct ubifs_zbranch *zbr;
1933        struct ubifs_ino_node *ino;
1934        struct fsck_inode *fscki;
1935
1936        fscki = search_inode(fsckd, inum);
1937        if (fscki)
1938                return fscki;
1939
1940        ino_key_init(c, &key, inum);
1941        err = ubifs_lookup_level0(c, &key, &znode, &n);
1942        if (!err) {
1943                ubifs_err(c, "inode %lu not found in index", (unsigned long)inum);
1944                return ERR_PTR(-ENOENT);
1945        } else if (err < 0) {
1946                ubifs_err(c, "error %d while looking up inode %lu",
1947                          err, (unsigned long)inum);
1948                return ERR_PTR(err);
1949        }
1950
1951        zbr = &znode->zbranch[n];
1952        if (zbr->len < UBIFS_INO_NODE_SZ) {
1953                ubifs_err(c, "bad node %lu node length %d",
1954                          (unsigned long)inum, zbr->len);
1955                return ERR_PTR(-EINVAL);
1956        }
1957
1958        ino = kmalloc(zbr->len, GFP_NOFS);
1959        if (!ino)
1960                return ERR_PTR(-ENOMEM);
1961
1962        err = ubifs_tnc_read_node(c, zbr, ino);
1963        if (err) {
1964                ubifs_err(c, "cannot read inode node at LEB %d:%d, error %d",
1965                          zbr->lnum, zbr->offs, err);
1966                kfree(ino);
1967                return ERR_PTR(err);
1968        }
1969
1970        fscki = add_inode(c, fsckd, ino);
1971        kfree(ino);
1972        if (IS_ERR(fscki)) {
1973                ubifs_err(c, "error %ld while adding inode %lu node",
1974                          PTR_ERR(fscki), (unsigned long)inum);
1975                return fscki;
1976        }
1977
1978        return fscki;
1979}
1980
1981/**
1982 * check_leaf - check leaf node.
1983 * @c: UBIFS file-system description object
1984 * @zbr: zbranch of the leaf node to check
1985 * @priv: FS checking information
1986 *
1987 * This is a helper function for 'dbg_check_filesystem()' which is called for
1988 * every single leaf node while walking the indexing tree. It checks that the
1989 * leaf node referred from the indexing tree exists, has correct CRC, and does
1990 * some other basic validation. This function is also responsible for building
1991 * an RB-tree of inodes - it adds all inodes into the RB-tree. It also
1992 * calculates reference count, size, etc for each inode in order to later
1993 * compare them to the information stored inside the inodes and detect possible
1994 * inconsistencies. Returns zero in case of success and a negative error code
1995 * in case of failure.
1996 */
1997static int check_leaf(struct ubifs_info *c, struct ubifs_zbranch *zbr,
1998                      void *priv)
1999{
2000        ino_t inum;
2001        void *node;
2002        struct ubifs_ch *ch;
2003        int err, type = key_type(c, &zbr->key);
2004        struct fsck_inode *fscki;
2005
2006        if (zbr->len < UBIFS_CH_SZ) {
2007                ubifs_err(c, "bad leaf length %d (LEB %d:%d)",
2008                          zbr->len, zbr->lnum, zbr->offs);
2009                return -EINVAL;
2010        }
2011
2012        node = kmalloc(zbr->len, GFP_NOFS);
2013        if (!node)
2014                return -ENOMEM;
2015
2016        err = ubifs_tnc_read_node(c, zbr, node);
2017        if (err) {
2018                ubifs_err(c, "cannot read leaf node at LEB %d:%d, error %d",
2019                          zbr->lnum, zbr->offs, err);
2020                goto out_free;
2021        }
2022
2023        /* If this is an inode node, add it to RB-tree of inodes */
2024        if (type == UBIFS_INO_KEY) {
2025                fscki = add_inode(c, priv, node);
2026                if (IS_ERR(fscki)) {
2027                        err = PTR_ERR(fscki);
2028                        ubifs_err(c, "error %d while adding inode node", err);
2029                        goto out_dump;
2030                }
2031                goto out;
2032        }
2033
2034        if (type != UBIFS_DENT_KEY && type != UBIFS_XENT_KEY &&
2035            type != UBIFS_DATA_KEY) {
2036                ubifs_err(c, "unexpected node type %d at LEB %d:%d",
2037                          type, zbr->lnum, zbr->offs);
2038                err = -EINVAL;
2039                goto out_free;
2040        }
2041
2042        ch = node;
2043        if (le64_to_cpu(ch->sqnum) > c->max_sqnum) {
2044                ubifs_err(c, "too high sequence number, max. is %llu",
2045                          c->max_sqnum);
2046                err = -EINVAL;
2047                goto out_dump;
2048        }
2049
2050        if (type == UBIFS_DATA_KEY) {
2051                long long blk_offs;
2052                struct ubifs_data_node *dn = node;
2053
2054                ubifs_assert(c, zbr->len >= UBIFS_DATA_NODE_SZ);
2055
2056                /*
2057                 * Search the inode node this data node belongs to and insert
2058                 * it to the RB-tree of inodes.
2059                 */
2060                inum = key_inum_flash(c, &dn->key);
2061                fscki = read_add_inode(c, priv, inum);
2062                if (IS_ERR(fscki)) {
2063                        err = PTR_ERR(fscki);
2064                        ubifs_err(c, "error %d while processing data node and trying to find inode node %lu",
2065                                  err, (unsigned long)inum);
2066                        goto out_dump;
2067                }
2068
2069                /* Make sure the data node is within inode size */
2070                blk_offs = key_block_flash(c, &dn->key);
2071                blk_offs <<= UBIFS_BLOCK_SHIFT;
2072                blk_offs += le32_to_cpu(dn->size);
2073                if (blk_offs > fscki->size) {
2074                        ubifs_err(c, "data node at LEB %d:%d is not within inode size %lld",
2075                                  zbr->lnum, zbr->offs, fscki->size);
2076                        err = -EINVAL;
2077                        goto out_dump;
2078                }
2079        } else {
2080                int nlen;
2081                struct ubifs_dent_node *dent = node;
2082                struct fsck_inode *fscki1;
2083
2084                ubifs_assert(c, zbr->len >= UBIFS_DENT_NODE_SZ);
2085
2086                err = ubifs_validate_entry(c, dent);
2087                if (err)
2088                        goto out_dump;
2089
2090                /*
2091                 * Search the inode node this entry refers to and the parent
2092                 * inode node and insert them to the RB-tree of inodes.
2093                 */
2094                inum = le64_to_cpu(dent->inum);
2095                fscki = read_add_inode(c, priv, inum);
2096                if (IS_ERR(fscki)) {
2097                        err = PTR_ERR(fscki);
2098                        ubifs_err(c, "error %d while processing entry node and trying to find inode node %lu",
2099                                  err, (unsigned long)inum);
2100                        goto out_dump;
2101                }
2102
2103                /* Count how many direntries or xentries refers this inode */
2104                fscki->references += 1;
2105
2106                inum = key_inum_flash(c, &dent->key);
2107                fscki1 = read_add_inode(c, priv, inum);
2108                if (IS_ERR(fscki1)) {
2109                        err = PTR_ERR(fscki1);
2110                        ubifs_err(c, "error %d while processing entry node and trying to find parent inode node %lu",
2111                                  err, (unsigned long)inum);
2112                        goto out_dump;
2113                }
2114
2115                nlen = le16_to_cpu(dent->nlen);
2116                if (type == UBIFS_XENT_KEY) {
2117                        fscki1->calc_xcnt += 1;
2118                        fscki1->calc_xsz += CALC_DENT_SIZE(nlen);
2119                        fscki1->calc_xsz += CALC_XATTR_BYTES(fscki->size);
2120                        fscki1->calc_xnms += nlen;
2121                } else {
2122                        fscki1->calc_sz += CALC_DENT_SIZE(nlen);
2123                        if (dent->type == UBIFS_ITYPE_DIR)
2124                                fscki1->calc_cnt += 1;
2125                }
2126        }
2127
2128out:
2129        kfree(node);
2130        return 0;
2131
2132out_dump:
2133        ubifs_msg(c, "dump of node at LEB %d:%d", zbr->lnum, zbr->offs);
2134        ubifs_dump_node(c, node, zbr->len);
2135out_free:
2136        kfree(node);
2137        return err;
2138}
2139
2140/**
2141 * free_inodes - free RB-tree of inodes.
2142 * @fsckd: FS checking information
2143 */
2144static void free_inodes(struct fsck_data *fsckd)
2145{
2146        struct fsck_inode *fscki, *n;
2147
2148        rbtree_postorder_for_each_entry_safe(fscki, n, &fsckd->inodes, rb)
2149                kfree(fscki);
2150}
2151
2152/**
2153 * check_inodes - checks all inodes.
2154 * @c: UBIFS file-system description object
2155 * @fsckd: FS checking information
2156 *
2157 * This is a helper function for 'dbg_check_filesystem()' which walks the
2158 * RB-tree of inodes after the index scan has been finished, and checks that
2159 * inode nlink, size, etc are correct. Returns zero if inodes are fine,
2160 * %-EINVAL if not, and a negative error code in case of failure.
2161 */
2162static int check_inodes(struct ubifs_info *c, struct fsck_data *fsckd)
2163{
2164        int n, err;
2165        union ubifs_key key;
2166        struct ubifs_znode *znode;
2167        struct ubifs_zbranch *zbr;
2168        struct ubifs_ino_node *ino;
2169        struct fsck_inode *fscki;
2170        struct rb_node *this = rb_first(&fsckd->inodes);
2171
2172        while (this) {
2173                fscki = rb_entry(this, struct fsck_inode, rb);
2174                this = rb_next(this);
2175
2176                if (S_ISDIR(fscki->mode)) {
2177                        /*
2178                         * Directories have to have exactly one reference (they
2179                         * cannot have hardlinks), although root inode is an
2180                         * exception.
2181                         */
2182                        if (fscki->inum != UBIFS_ROOT_INO &&
2183                            fscki->references != 1) {
2184                                ubifs_err(c, "directory inode %lu has %d direntries which refer it, but should be 1",
2185                                          (unsigned long)fscki->inum,
2186                                          fscki->references);
2187                                goto out_dump;
2188                        }
2189                        if (fscki->inum == UBIFS_ROOT_INO &&
2190                            fscki->references != 0) {
2191                                ubifs_err(c, "root inode %lu has non-zero (%d) direntries which refer it",
2192                                          (unsigned long)fscki->inum,
2193                                          fscki->references);
2194                                goto out_dump;
2195                        }
2196                        if (fscki->calc_sz != fscki->size) {
2197                                ubifs_err(c, "directory inode %lu size is %lld, but calculated size is %lld",
2198                                          (unsigned long)fscki->inum,
2199                                          fscki->size, fscki->calc_sz);
2200                                goto out_dump;
2201                        }
2202                        if (fscki->calc_cnt != fscki->nlink) {
2203                                ubifs_err(c, "directory inode %lu nlink is %d, but calculated nlink is %d",
2204                                          (unsigned long)fscki->inum,
2205                                          fscki->nlink, fscki->calc_cnt);
2206                                goto out_dump;
2207                        }
2208                } else {
2209                        if (fscki->references != fscki->nlink) {
2210                                ubifs_err(c, "inode %lu nlink is %d, but calculated nlink is %d",
2211                                          (unsigned long)fscki->inum,
2212                                          fscki->nlink, fscki->references);
2213                                goto out_dump;
2214                        }
2215                }
2216                if (fscki->xattr_sz != fscki->calc_xsz) {
2217                        ubifs_err(c, "inode %lu has xattr size %u, but calculated size is %lld",
2218                                  (unsigned long)fscki->inum, fscki->xattr_sz,
2219                                  fscki->calc_xsz);
2220                        goto out_dump;
2221                }
2222                if (fscki->xattr_cnt != fscki->calc_xcnt) {
2223                        ubifs_err(c, "inode %lu has %u xattrs, but calculated count is %lld",
2224                                  (unsigned long)fscki->inum,
2225                                  fscki->xattr_cnt, fscki->calc_xcnt);
2226                        goto out_dump;
2227                }
2228                if (fscki->xattr_nms != fscki->calc_xnms) {
2229                        ubifs_err(c, "inode %lu has xattr names' size %u, but calculated names' size is %lld",
2230                                  (unsigned long)fscki->inum, fscki->xattr_nms,
2231                                  fscki->calc_xnms);
2232                        goto out_dump;
2233                }
2234        }
2235
2236        return 0;
2237
2238out_dump:
2239        /* Read the bad inode and dump it */
2240        ino_key_init(c, &key, fscki->inum);
2241        err = ubifs_lookup_level0(c, &key, &znode, &n);
2242        if (!err) {
2243                ubifs_err(c, "inode %lu not found in index",
2244                          (unsigned long)fscki->inum);
2245                return -ENOENT;
2246        } else if (err < 0) {
2247                ubifs_err(c, "error %d while looking up inode %lu",
2248                          err, (unsigned long)fscki->inum);
2249                return err;
2250        }
2251
2252        zbr = &znode->zbranch[n];
2253        ino = kmalloc(zbr->len, GFP_NOFS);
2254        if (!ino)
2255                return -ENOMEM;
2256
2257        err = ubifs_tnc_read_node(c, zbr, ino);
2258        if (err) {
2259                ubifs_err(c, "cannot read inode node at LEB %d:%d, error %d",
2260                          zbr->lnum, zbr->offs, err);
2261                kfree(ino);
2262                return err;
2263        }
2264
2265        ubifs_msg(c, "dump of the inode %lu sitting in LEB %d:%d",
2266                  (unsigned long)fscki->inum, zbr->lnum, zbr->offs);
2267        ubifs_dump_node(c, ino, zbr->len);
2268        kfree(ino);
2269        return -EINVAL;
2270}
2271
2272/**
2273 * dbg_check_filesystem - check the file-system.
2274 * @c: UBIFS file-system description object
2275 *
2276 * This function checks the file system, namely:
2277 * o makes sure that all leaf nodes exist and their CRCs are correct;
2278 * o makes sure inode nlink, size, xattr size/count are correct (for all
2279 *   inodes).
2280 *
2281 * The function reads whole indexing tree and all nodes, so it is pretty
2282 * heavy-weight. Returns zero if the file-system is consistent, %-EINVAL if
2283 * not, and a negative error code in case of failure.
2284 */
2285int dbg_check_filesystem(struct ubifs_info *c)
2286{
2287        int err;
2288        struct fsck_data fsckd;
2289
2290        if (!dbg_is_chk_fs(c))
2291                return 0;
2292
2293        fsckd.inodes = RB_ROOT;
2294        err = dbg_walk_index(c, check_leaf, NULL, &fsckd);
2295        if (err)
2296                goto out_free;
2297
2298        err = check_inodes(c, &fsckd);
2299        if (err)
2300                goto out_free;
2301
2302        free_inodes(&fsckd);
2303        return 0;
2304
2305out_free:
2306        ubifs_err(c, "file-system check failed with error %d", err);
2307        dump_stack();
2308        free_inodes(&fsckd);
2309        return err;
2310}
2311
2312/**
2313 * dbg_check_data_nodes_order - check that list of data nodes is sorted.
2314 * @c: UBIFS file-system description object
2315 * @head: the list of nodes ('struct ubifs_scan_node' objects)
2316 *
2317 * This function returns zero if the list of data nodes is sorted correctly,
2318 * and %-EINVAL if not.
2319 */
2320int dbg_check_data_nodes_order(struct ubifs_info *c, struct list_head *head)
2321{
2322        struct list_head *cur;
2323        struct ubifs_scan_node *sa, *sb;
2324
2325        if (!dbg_is_chk_gen(c))
2326                return 0;
2327
2328        for (cur = head->next; cur->next != head; cur = cur->next) {
2329                ino_t inuma, inumb;
2330                uint32_t blka, blkb;
2331
2332                cond_resched();
2333                sa = container_of(cur, struct ubifs_scan_node, list);
2334                sb = container_of(cur->next, struct ubifs_scan_node, list);
2335
2336                if (sa->type != UBIFS_DATA_NODE) {
2337                        ubifs_err(c, "bad node type %d", sa->type);
2338                        ubifs_dump_node(c, sa->node, c->leb_size - sa->offs);
2339                        return -EINVAL;
2340                }
2341                if (sb->type != UBIFS_DATA_NODE) {
2342                        ubifs_err(c, "bad node type %d", sb->type);
2343                        ubifs_dump_node(c, sb->node, c->leb_size - sb->offs);
2344                        return -EINVAL;
2345                }
2346
2347                inuma = key_inum(c, &sa->key);
2348                inumb = key_inum(c, &sb->key);
2349
2350                if (inuma < inumb)
2351                        continue;
2352                if (inuma > inumb) {
2353                        ubifs_err(c, "larger inum %lu goes before inum %lu",
2354                                  (unsigned long)inuma, (unsigned long)inumb);
2355                        goto error_dump;
2356                }
2357
2358                blka = key_block(c, &sa->key);
2359                blkb = key_block(c, &sb->key);
2360
2361                if (blka > blkb) {
2362                        ubifs_err(c, "larger block %u goes before %u", blka, blkb);
2363                        goto error_dump;
2364                }
2365                if (blka == blkb) {
2366                        ubifs_err(c, "two data nodes for the same block");
2367                        goto error_dump;
2368                }
2369        }
2370
2371        return 0;
2372
2373error_dump:
2374        ubifs_dump_node(c, sa->node, c->leb_size - sa->offs);
2375        ubifs_dump_node(c, sb->node, c->leb_size - sb->offs);
2376        return -EINVAL;
2377}
2378
2379/**
2380 * dbg_check_nondata_nodes_order - check that list of data nodes is sorted.
2381 * @c: UBIFS file-system description object
2382 * @head: the list of nodes ('struct ubifs_scan_node' objects)
2383 *
2384 * This function returns zero if the list of non-data nodes is sorted correctly,
2385 * and %-EINVAL if not.
2386 */
2387int dbg_check_nondata_nodes_order(struct ubifs_info *c, struct list_head *head)
2388{
2389        struct list_head *cur;
2390        struct ubifs_scan_node *sa, *sb;
2391
2392        if (!dbg_is_chk_gen(c))
2393                return 0;
2394
2395        for (cur = head->next; cur->next != head; cur = cur->next) {
2396                ino_t inuma, inumb;
2397                uint32_t hasha, hashb;
2398
2399                cond_resched();
2400                sa = container_of(cur, struct ubifs_scan_node, list);
2401                sb = container_of(cur->next, struct ubifs_scan_node, list);
2402
2403                if (sa->type != UBIFS_INO_NODE && sa->type != UBIFS_DENT_NODE &&
2404                    sa->type != UBIFS_XENT_NODE) {
2405                        ubifs_err(c, "bad node type %d", sa->type);
2406                        ubifs_dump_node(c, sa->node, c->leb_size - sa->offs);
2407                        return -EINVAL;
2408                }
2409                if (sb->type != UBIFS_INO_NODE && sb->type != UBIFS_DENT_NODE &&
2410                    sb->type != UBIFS_XENT_NODE) {
2411                        ubifs_err(c, "bad node type %d", sb->type);
2412                        ubifs_dump_node(c, sb->node, c->leb_size - sb->offs);
2413                        return -EINVAL;
2414                }
2415
2416                if (sa->type != UBIFS_INO_NODE && sb->type == UBIFS_INO_NODE) {
2417                        ubifs_err(c, "non-inode node goes before inode node");
2418                        goto error_dump;
2419                }
2420
2421                if (sa->type == UBIFS_INO_NODE && sb->type != UBIFS_INO_NODE)
2422                        continue;
2423
2424                if (sa->type == UBIFS_INO_NODE && sb->type == UBIFS_INO_NODE) {
2425                        /* Inode nodes are sorted in descending size order */
2426                        if (sa->len < sb->len) {
2427                                ubifs_err(c, "smaller inode node goes first");
2428                                goto error_dump;
2429                        }
2430                        continue;
2431                }
2432
2433                /*
2434                 * This is either a dentry or xentry, which should be sorted in
2435                 * ascending (parent ino, hash) order.
2436                 */
2437                inuma = key_inum(c, &sa->key);
2438                inumb = key_inum(c, &sb->key);
2439
2440                if (inuma < inumb)
2441                        continue;
2442                if (inuma > inumb) {
2443                        ubifs_err(c, "larger inum %lu goes before inum %lu",
2444                                  (unsigned long)inuma, (unsigned long)inumb);
2445                        goto error_dump;
2446                }
2447
2448                hasha = key_block(c, &sa->key);
2449                hashb = key_block(c, &sb->key);
2450
2451                if (hasha > hashb) {
2452                        ubifs_err(c, "larger hash %u goes before %u",
2453                                  hasha, hashb);
2454                        goto error_dump;
2455                }
2456        }
2457
2458        return 0;
2459
2460error_dump:
2461        ubifs_msg(c, "dumping first node");
2462        ubifs_dump_node(c, sa->node, c->leb_size - sa->offs);
2463        ubifs_msg(c, "dumping second node");
2464        ubifs_dump_node(c, sb->node, c->leb_size - sb->offs);
2465        return -EINVAL;
2466}
2467
2468static inline int chance(unsigned int n, unsigned int out_of)
2469{
2470        return !!((prandom_u32() % out_of) + 1 <= n);
2471
2472}
2473
2474static int power_cut_emulated(struct ubifs_info *c, int lnum, int write)
2475{
2476        struct ubifs_debug_info *d = c->dbg;
2477
2478        ubifs_assert(c, dbg_is_tst_rcvry(c));
2479
2480        if (!d->pc_cnt) {
2481                /* First call - decide delay to the power cut */
2482                if (chance(1, 2)) {
2483                        unsigned long delay;
2484
2485                        if (chance(1, 2)) {
2486                                d->pc_delay = 1;
2487                                /* Fail within 1 minute */
2488                                delay = prandom_u32() % 60000;
2489                                d->pc_timeout = jiffies;
2490                                d->pc_timeout += msecs_to_jiffies(delay);
2491                                ubifs_warn(c, "failing after %lums", delay);
2492                        } else {
2493                                d->pc_delay = 2;
2494                                delay = prandom_u32() % 10000;
2495                                /* Fail within 10000 operations */
2496                                d->pc_cnt_max = delay;
2497                                ubifs_warn(c, "failing after %lu calls", delay);
2498                        }
2499                }
2500
2501                d->pc_cnt += 1;
2502        }
2503
2504        /* Determine if failure delay has expired */
2505        if (d->pc_delay == 1 && time_before(jiffies, d->pc_timeout))
2506                        return 0;
2507        if (d->pc_delay == 2 && d->pc_cnt++ < d->pc_cnt_max)
2508                        return 0;
2509
2510        if (lnum == UBIFS_SB_LNUM) {
2511                if (write && chance(1, 2))
2512                        return 0;
2513                if (chance(19, 20))
2514                        return 0;
2515                ubifs_warn(c, "failing in super block LEB %d", lnum);
2516        } else if (lnum == UBIFS_MST_LNUM || lnum == UBIFS_MST_LNUM + 1) {
2517                if (chance(19, 20))
2518                        return 0;
2519                ubifs_warn(c, "failing in master LEB %d", lnum);
2520        } else if (lnum >= UBIFS_LOG_LNUM && lnum <= c->log_last) {
2521                if (write && chance(99, 100))
2522                        return 0;
2523                if (chance(399, 400))
2524                        return 0;
2525                ubifs_warn(c, "failing in log LEB %d", lnum);
2526        } else if (lnum >= c->lpt_first && lnum <= c->lpt_last) {
2527                if (write && chance(7, 8))
2528                        return 0;
2529                if (chance(19, 20))
2530                        return 0;
2531                ubifs_warn(c, "failing in LPT LEB %d", lnum);
2532        } else if (lnum >= c->orph_first && lnum <= c->orph_last) {
2533                if (write && chance(1, 2))
2534                        return 0;
2535                if (chance(9, 10))
2536                        return 0;
2537                ubifs_warn(c, "failing in orphan LEB %d", lnum);
2538        } else if (lnum == c->ihead_lnum) {
2539                if (chance(99, 100))
2540                        return 0;
2541                ubifs_warn(c, "failing in index head LEB %d", lnum);
2542        } else if (c->jheads && lnum == c->jheads[GCHD].wbuf.lnum) {
2543                if (chance(9, 10))
2544                        return 0;
2545                ubifs_warn(c, "failing in GC head LEB %d", lnum);
2546        } else if (write && !RB_EMPTY_ROOT(&c->buds) &&
2547                   !ubifs_search_bud(c, lnum)) {
2548                if (chance(19, 20))
2549                        return 0;
2550                ubifs_warn(c, "failing in non-bud LEB %d", lnum);
2551        } else if (c->cmt_state == COMMIT_RUNNING_BACKGROUND ||
2552                   c->cmt_state == COMMIT_RUNNING_REQUIRED) {
2553                if (chance(999, 1000))
2554                        return 0;
2555                ubifs_warn(c, "failing in bud LEB %d commit running", lnum);
2556        } else {
2557                if (chance(9999, 10000))
2558                        return 0;
2559                ubifs_warn(c, "failing in bud LEB %d commit not running", lnum);
2560        }
2561
2562        d->pc_happened = 1;
2563        ubifs_warn(c, "========== Power cut emulated ==========");
2564        dump_stack();
2565        return 1;
2566}
2567
2568static int corrupt_data(const struct ubifs_info *c, const void *buf,
2569                        unsigned int len)
2570{
2571        unsigned int from, to, ffs = chance(1, 2);
2572        unsigned char *p = (void *)buf;
2573
2574        from = prandom_u32() % len;
2575        /* Corruption span max to end of write unit */
2576        to = min(len, ALIGN(from + 1, c->max_write_size));
2577
2578        ubifs_warn(c, "filled bytes %u-%u with %s", from, to - 1,
2579                   ffs ? "0xFFs" : "random data");
2580
2581        if (ffs)
2582                memset(p + from, 0xFF, to - from);
2583        else
2584                prandom_bytes(p + from, to - from);
2585
2586        return to;
2587}
2588
2589int dbg_leb_write(struct ubifs_info *c, int lnum, const void *buf,
2590                  int offs, int len)
2591{
2592        int err, failing;
2593
2594        if (dbg_is_power_cut(c))
2595                return -EROFS;
2596
2597        failing = power_cut_emulated(c, lnum, 1);
2598        if (failing) {
2599                len = corrupt_data(c, buf, len);
2600                ubifs_warn(c, "actually write %d bytes to LEB %d:%d (the buffer was corrupted)",
2601                           len, lnum, offs);
2602        }
2603        err = ubi_leb_write(c->ubi, lnum, buf, offs, len);
2604        if (err)
2605                return err;
2606        if (failing)
2607                return -EROFS;
2608        return 0;
2609}
2610
2611int dbg_leb_change(struct ubifs_info *c, int lnum, const void *buf,
2612                   int len)
2613{
2614        int err;
2615
2616        if (dbg_is_power_cut(c))
2617                return -EROFS;
2618        if (power_cut_emulated(c, lnum, 1))
2619                return -EROFS;
2620        err = ubi_leb_change(c->ubi, lnum, buf, len);
2621        if (err)
2622                return err;
2623        if (power_cut_emulated(c, lnum, 1))
2624                return -EROFS;
2625        return 0;
2626}
2627
2628int dbg_leb_unmap(struct ubifs_info *c, int lnum)
2629{
2630        int err;
2631
2632        if (dbg_is_power_cut(c))
2633                return -EROFS;
2634        if (power_cut_emulated(c, lnum, 0))
2635                return -EROFS;
2636        err = ubi_leb_unmap(c->ubi, lnum);
2637        if (err)
2638                return err;
2639        if (power_cut_emulated(c, lnum, 0))
2640                return -EROFS;
2641        return 0;
2642}
2643
2644int dbg_leb_map(struct ubifs_info *c, int lnum)
2645{
2646        int err;
2647
2648        if (dbg_is_power_cut(c))
2649                return -EROFS;
2650        if (power_cut_emulated(c, lnum, 0))
2651                return -EROFS;
2652        err = ubi_leb_map(c->ubi, lnum);
2653        if (err)
2654                return err;
2655        if (power_cut_emulated(c, lnum, 0))
2656                return -EROFS;
2657        return 0;
2658}
2659
2660/*
2661 * Root directory for UBIFS stuff in debugfs. Contains sub-directories which
2662 * contain the stuff specific to particular file-system mounts.
2663 */
2664static struct dentry *dfs_rootdir;
2665
2666static int dfs_file_open(struct inode *inode, struct file *file)
2667{
2668        file->private_data = inode->i_private;
2669        return nonseekable_open(inode, file);
2670}
2671
2672/**
2673 * provide_user_output - provide output to the user reading a debugfs file.
2674 * @val: boolean value for the answer
2675 * @u: the buffer to store the answer at
2676 * @count: size of the buffer
2677 * @ppos: position in the @u output buffer
2678 *
2679 * This is a simple helper function which stores @val boolean value in the user
2680 * buffer when the user reads one of UBIFS debugfs files. Returns amount of
2681 * bytes written to @u in case of success and a negative error code in case of
2682 * failure.
2683 */
2684static int provide_user_output(int val, char __user *u, size_t count,
2685                               loff_t *ppos)
2686{
2687        char buf[3];
2688
2689        if (val)
2690                buf[0] = '1';
2691        else
2692                buf[0] = '0';
2693        buf[1] = '\n';
2694        buf[2] = 0x00;
2695
2696        return simple_read_from_buffer(u, count, ppos, buf, 2);
2697}
2698
2699static ssize_t dfs_file_read(struct file *file, char __user *u, size_t count,
2700                             loff_t *ppos)
2701{
2702        struct dentry *dent = file->f_path.dentry;
2703        struct ubifs_info *c = file->private_data;
2704        struct ubifs_debug_info *d = c->dbg;
2705        int val;
2706
2707        if (dent == d->dfs_chk_gen)
2708                val = d->chk_gen;
2709        else if (dent == d->dfs_chk_index)
2710                val = d->chk_index;
2711        else if (dent == d->dfs_chk_orph)
2712                val = d->chk_orph;
2713        else if (dent == d->dfs_chk_lprops)
2714                val = d->chk_lprops;
2715        else if (dent == d->dfs_chk_fs)
2716                val = d->chk_fs;
2717        else if (dent == d->dfs_tst_rcvry)
2718                val = d->tst_rcvry;
2719        else if (dent == d->dfs_ro_error)
2720                val = c->ro_error;
2721        else
2722                return -EINVAL;
2723
2724        return provide_user_output(val, u, count, ppos);
2725}
2726
2727/**
2728 * interpret_user_input - interpret user debugfs file input.
2729 * @u: user-provided buffer with the input
2730 * @count: buffer size
2731 *
2732 * This is a helper function which interpret user input to a boolean UBIFS
2733 * debugfs file. Returns %0 or %1 in case of success and a negative error code
2734 * in case of failure.
2735 */
2736static int interpret_user_input(const char __user *u, size_t count)
2737{
2738        size_t buf_size;
2739        char buf[8];
2740
2741        buf_size = min_t(size_t, count, (sizeof(buf) - 1));
2742        if (copy_from_user(buf, u, buf_size))
2743                return -EFAULT;
2744
2745        if (buf[0] == '1')
2746                return 1;
2747        else if (buf[0] == '0')
2748                return 0;
2749
2750        return -EINVAL;
2751}
2752
2753static ssize_t dfs_file_write(struct file *file, const char __user *u,
2754                              size_t count, loff_t *ppos)
2755{
2756        struct ubifs_info *c = file->private_data;
2757        struct ubifs_debug_info *d = c->dbg;
2758        struct dentry *dent = file->f_path.dentry;
2759        int val;
2760
2761        if (file->f_path.dentry == d->dfs_dump_lprops) {
2762                ubifs_dump_lprops(c);
2763                return count;
2764        }
2765        if (file->f_path.dentry == d->dfs_dump_budg) {
2766                ubifs_dump_budg(c, &c->bi);
2767                return count;
2768        }
2769        if (file->f_path.dentry == d->dfs_dump_tnc) {
2770                mutex_lock(&c->tnc_mutex);
2771                ubifs_dump_tnc(c);
2772                mutex_unlock(&c->tnc_mutex);
2773                return count;
2774        }
2775
2776        val = interpret_user_input(u, count);
2777        if (val < 0)
2778                return val;
2779
2780        if (dent == d->dfs_chk_gen)
2781                d->chk_gen = val;
2782        else if (dent == d->dfs_chk_index)
2783                d->chk_index = val;
2784        else if (dent == d->dfs_chk_orph)
2785                d->chk_orph = val;
2786        else if (dent == d->dfs_chk_lprops)
2787                d->chk_lprops = val;
2788        else if (dent == d->dfs_chk_fs)
2789                d->chk_fs = val;
2790        else if (dent == d->dfs_tst_rcvry)
2791                d->tst_rcvry = val;
2792        else if (dent == d->dfs_ro_error)
2793                c->ro_error = !!val;
2794        else
2795                return -EINVAL;
2796
2797        return count;
2798}
2799
2800static const struct file_operations dfs_fops = {
2801        .open = dfs_file_open,
2802        .read = dfs_file_read,
2803        .write = dfs_file_write,
2804        .owner = THIS_MODULE,
2805        .llseek = no_llseek,
2806};
2807
2808/**
2809 * dbg_debugfs_init_fs - initialize debugfs for UBIFS instance.
2810 * @c: UBIFS file-system description object
2811 *
2812 * This function creates all debugfs files for this instance of UBIFS.
2813 *
2814 * Note, the only reason we have not merged this function with the
2815 * 'ubifs_debugging_init()' function is because it is better to initialize
2816 * debugfs interfaces at the very end of the mount process, and remove them at
2817 * the very beginning of the mount process.
2818 */
2819void dbg_debugfs_init_fs(struct ubifs_info *c)
2820{
2821        int n;
2822        const char *fname;
2823        struct ubifs_debug_info *d = c->dbg;
2824
2825        n = snprintf(d->dfs_dir_name, UBIFS_DFS_DIR_LEN + 1, UBIFS_DFS_DIR_NAME,
2826                     c->vi.ubi_num, c->vi.vol_id);
2827        if (n == UBIFS_DFS_DIR_LEN) {
2828                /* The array size is too small */
2829                return;
2830        }
2831
2832        fname = d->dfs_dir_name;
2833        d->dfs_dir = debugfs_create_dir(fname, dfs_rootdir);
2834
2835        fname = "dump_lprops";
2836        d->dfs_dump_lprops = debugfs_create_file(fname, S_IWUSR, d->dfs_dir, c,
2837                                                 &dfs_fops);
2838
2839        fname = "dump_budg";
2840        d->dfs_dump_budg = debugfs_create_file(fname, S_IWUSR, d->dfs_dir, c,
2841                                               &dfs_fops);
2842
2843        fname = "dump_tnc";
2844        d->dfs_dump_tnc = debugfs_create_file(fname, S_IWUSR, d->dfs_dir, c,
2845                                              &dfs_fops);
2846
2847        fname = "chk_general";
2848        d->dfs_chk_gen = debugfs_create_file(fname, S_IRUSR | S_IWUSR,
2849                                             d->dfs_dir, c, &dfs_fops);
2850
2851        fname = "chk_index";
2852        d->dfs_chk_index = debugfs_create_file(fname, S_IRUSR | S_IWUSR,
2853                                               d->dfs_dir, c, &dfs_fops);
2854
2855        fname = "chk_orphans";
2856        d->dfs_chk_orph = debugfs_create_file(fname, S_IRUSR | S_IWUSR,
2857                                              d->dfs_dir, c, &dfs_fops);
2858
2859        fname = "chk_lprops";
2860        d->dfs_chk_lprops = debugfs_create_file(fname, S_IRUSR | S_IWUSR,
2861                                                d->dfs_dir, c, &dfs_fops);
2862
2863        fname = "chk_fs";
2864        d->dfs_chk_fs = debugfs_create_file(fname, S_IRUSR | S_IWUSR,
2865                                            d->dfs_dir, c, &dfs_fops);
2866
2867        fname = "tst_recovery";
2868        d->dfs_tst_rcvry = debugfs_create_file(fname, S_IRUSR | S_IWUSR,
2869                                               d->dfs_dir, c, &dfs_fops);
2870
2871        fname = "ro_error";
2872        d->dfs_ro_error = debugfs_create_file(fname, S_IRUSR | S_IWUSR,
2873                                              d->dfs_dir, c, &dfs_fops);
2874}
2875
2876/**
2877 * dbg_debugfs_exit_fs - remove all debugfs files.
2878 * @c: UBIFS file-system description object
2879 */
2880void dbg_debugfs_exit_fs(struct ubifs_info *c)
2881{
2882        debugfs_remove_recursive(c->dbg->dfs_dir);
2883}
2884
2885struct ubifs_global_debug_info ubifs_dbg;
2886
2887static struct dentry *dfs_chk_gen;
2888static struct dentry *dfs_chk_index;
2889static struct dentry *dfs_chk_orph;
2890static struct dentry *dfs_chk_lprops;
2891static struct dentry *dfs_chk_fs;
2892static struct dentry *dfs_tst_rcvry;
2893
2894static ssize_t dfs_global_file_read(struct file *file, char __user *u,
2895                                    size_t count, loff_t *ppos)
2896{
2897        struct dentry *dent = file->f_path.dentry;
2898        int val;
2899
2900        if (dent == dfs_chk_gen)
2901                val = ubifs_dbg.chk_gen;
2902        else if (dent == dfs_chk_index)
2903                val = ubifs_dbg.chk_index;
2904        else if (dent == dfs_chk_orph)
2905                val = ubifs_dbg.chk_orph;
2906        else if (dent == dfs_chk_lprops)
2907                val = ubifs_dbg.chk_lprops;
2908        else if (dent == dfs_chk_fs)
2909                val = ubifs_dbg.chk_fs;
2910        else if (dent == dfs_tst_rcvry)
2911                val = ubifs_dbg.tst_rcvry;
2912        else
2913                return -EINVAL;
2914
2915        return provide_user_output(val, u, count, ppos);
2916}
2917
2918static ssize_t dfs_global_file_write(struct file *file, const char __user *u,
2919                                     size_t count, loff_t *ppos)
2920{
2921        struct dentry *dent = file->f_path.dentry;
2922        int val;
2923
2924        val = interpret_user_input(u, count);
2925        if (val < 0)
2926                return val;
2927
2928        if (dent == dfs_chk_gen)
2929                ubifs_dbg.chk_gen = val;
2930        else if (dent == dfs_chk_index)
2931                ubifs_dbg.chk_index = val;
2932        else if (dent == dfs_chk_orph)
2933                ubifs_dbg.chk_orph = val;
2934        else if (dent == dfs_chk_lprops)
2935                ubifs_dbg.chk_lprops = val;
2936        else if (dent == dfs_chk_fs)
2937                ubifs_dbg.chk_fs = val;
2938        else if (dent == dfs_tst_rcvry)
2939                ubifs_dbg.tst_rcvry = val;
2940        else
2941                return -EINVAL;
2942
2943        return count;
2944}
2945
2946static const struct file_operations dfs_global_fops = {
2947        .read = dfs_global_file_read,
2948        .write = dfs_global_file_write,
2949        .owner = THIS_MODULE,
2950        .llseek = no_llseek,
2951};
2952
2953/**
2954 * dbg_debugfs_init - initialize debugfs file-system.
2955 *
2956 * UBIFS uses debugfs file-system to expose various debugging knobs to
2957 * user-space. This function creates "ubifs" directory in the debugfs
2958 * file-system.
2959 */
2960void dbg_debugfs_init(void)
2961{
2962        const char *fname;
2963
2964        fname = "ubifs";
2965        dfs_rootdir = debugfs_create_dir(fname, NULL);
2966
2967        fname = "chk_general";
2968        dfs_chk_gen = debugfs_create_file(fname, S_IRUSR | S_IWUSR, dfs_rootdir,
2969                                          NULL, &dfs_global_fops);
2970
2971        fname = "chk_index";
2972        dfs_chk_index = debugfs_create_file(fname, S_IRUSR | S_IWUSR,
2973                                            dfs_rootdir, NULL, &dfs_global_fops);
2974
2975        fname = "chk_orphans";
2976        dfs_chk_orph = debugfs_create_file(fname, S_IRUSR | S_IWUSR,
2977                                           dfs_rootdir, NULL, &dfs_global_fops);
2978
2979        fname = "chk_lprops";
2980        dfs_chk_lprops = debugfs_create_file(fname, S_IRUSR | S_IWUSR,
2981                                             dfs_rootdir, NULL, &dfs_global_fops);
2982
2983        fname = "chk_fs";
2984        dfs_chk_fs = debugfs_create_file(fname, S_IRUSR | S_IWUSR, dfs_rootdir,
2985                                         NULL, &dfs_global_fops);
2986
2987        fname = "tst_recovery";
2988        dfs_tst_rcvry = debugfs_create_file(fname, S_IRUSR | S_IWUSR,
2989                                            dfs_rootdir, NULL, &dfs_global_fops);
2990}
2991
2992/**
2993 * dbg_debugfs_exit - remove the "ubifs" directory from debugfs file-system.
2994 */
2995void dbg_debugfs_exit(void)
2996{
2997        debugfs_remove_recursive(dfs_rootdir);
2998}
2999
3000void ubifs_assert_failed(struct ubifs_info *c, const char *expr,
3001                         const char *file, int line)
3002{
3003        ubifs_err(c, "UBIFS assert failed: %s, in %s:%u", expr, file, line);
3004
3005        switch (c->assert_action) {
3006                case ASSACT_PANIC:
3007                BUG();
3008                break;
3009
3010                case ASSACT_RO:
3011                ubifs_ro_mode(c, -EINVAL);
3012                break;
3013
3014                case ASSACT_REPORT:
3015                default:
3016                dump_stack();
3017                break;
3018
3019        }
3020}
3021
3022/**
3023 * ubifs_debugging_init - initialize UBIFS debugging.
3024 * @c: UBIFS file-system description object
3025 *
3026 * This function initializes debugging-related data for the file system.
3027 * Returns zero in case of success and a negative error code in case of
3028 * failure.
3029 */
3030int ubifs_debugging_init(struct ubifs_info *c)
3031{
3032        c->dbg = kzalloc(sizeof(struct ubifs_debug_info), GFP_KERNEL);
3033        if (!c->dbg)
3034                return -ENOMEM;
3035
3036        return 0;
3037}
3038
3039/**
3040 * ubifs_debugging_exit - free debugging data.
3041 * @c: UBIFS file-system description object
3042 */
3043void ubifs_debugging_exit(struct ubifs_info *c)
3044{
3045        kfree(c->dbg);
3046}
3047