fs/ubifs/debug.c

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