fs/ubifs/replay.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: Adrian Hunter
  20  *          Artem Bityutskiy (Битюцкий Артём)
  21  */
  22
  23 /*
  24  * This file contains journal replay code. It runs when the file-system is being
  25  * mounted and requires no locking.
  26  *
  27  * The larger is the journal, the longer it takes to scan it, so the longer it
  28  * takes to mount UBIFS. This is why the journal has limited size which may be
  29  * changed depending on the system requirements. But a larger journal gives
  30  * faster I/O speed because it writes the index less frequently. So this is a
  31  * trade-off. Also, the journal is indexed by the in-memory index (TNC), so the
  32  * larger is the journal, the more memory its index may consume.
  33  */
  34
  35 #include "ubifs.h"
  36
  37 /*
  38  * Replay flags.
  39  *
  40  * REPLAY_DELETION: node was deleted
  41  * REPLAY_REF: node is a reference node
  42  */
  43 enum {
  44         REPLAY_DELETION = 1,
  45         REPLAY_REF = 2,
  46 };
  47
  48 /**
  49  * struct replay_entry - replay tree entry.
  50  * @lnum: logical eraseblock number of the node
  51  * @offs: node offset
  52  * @len: node length
  53  * @sqnum: node sequence number
  54  * @flags: replay flags
  55  * @rb: links the replay tree
  56  * @key: node key
  57  * @nm: directory entry name
  58  * @old_size: truncation old size
  59  * @new_size: truncation new size
  60  * @free: amount of free space in a bud
  61  * @dirty: amount of dirty space in a bud from padding and deletion nodes
  62  *
  63  * UBIFS journal replay must compare node sequence numbers, which means it must
  64  * build a tree of node information to insert into the TNC.
  65  */
  66 struct replay_entry {
  67         int lnum;
  68         int offs;
  69         int len;
  70         unsigned long long sqnum;
  71         int flags;
  72         struct rb_node rb;
  73         union ubifs_key key;
  74         union {
  75                 struct qstr nm;
  76                 struct {
  77                         loff_t old_size;
  78                         loff_t new_size;
  79                 };
  80                 struct {
  81                         int free;
  82                         int dirty;
  83                 };
  84         };
  85 };
  86
  87 /**
  88  * struct bud_entry - entry in the list of buds to replay.
  89  * @list: next bud in the list
  90  * @bud: bud description object
  91  * @free: free bytes in the bud
  92  * @sqnum: reference node sequence number
  93  */
  94 struct bud_entry {
  95         struct list_head list;
  96         struct ubifs_bud *bud;
  97         int free;
  98         unsigned long long sqnum;
  99 };
 100
 101 /**
 102  * set_bud_lprops - set free and dirty space used by a bud.
 103  * @c: UBIFS file-system description object
 104  * @r: replay entry of bud
 105  */
 106 static int set_bud_lprops(struct ubifs_info *c, struct replay_entry *r)
 107 {
 108         const struct ubifs_lprops *lp;
 109         int err = 0, dirty;
 110
 111         ubifs_get_lprops(c);
 112
 113         lp = ubifs_lpt_lookup_dirty(c, r->lnum);
 114         if (IS_ERR(lp)) {
 115                 err = PTR_ERR(lp);
 116                 goto out;
 117         }
 118
 119         dirty = lp->dirty;
 120         if (r->offs == 0 && (lp->free != c->leb_size || lp->dirty != 0)) {
 121                 /*
 122                  * The LEB was added to the journal with a starting offset of
 123                  * zero which means the LEB must have been empty. The LEB
 124                  * property values should be lp->free == c->leb_size and
 125                  * lp->dirty == 0, but that is not the case. The reason is that
 126                  * the LEB was garbage collected. The garbage collector resets
 127                  * the free and dirty space without recording it anywhere except
 128                  * lprops, so if there is not a commit then lprops does not have
 129                  * that information next time the file system is mounted.
 130                  *
 131                  * We do not need to adjust free space because the scan has told
 132                  * us the exact value which is recorded in the replay entry as
 133                  * r->free.
 134                  *
 135                  * However we do need to subtract from the dirty space the
 136                  * amount of space that the garbage collector reclaimed, which
 137                  * is the whole LEB minus the amount of space that was free.
 138                  */
 139                 dbg_mnt("bud LEB %d was GC'd (%d free, %d dirty)", r->lnum,
 140                         lp->free, lp->dirty);
 141                 dbg_gc("bud LEB %d was GC'd (%d free, %d dirty)", r->lnum,
 142                         lp->free, lp->dirty);
 143                 dirty -= c->leb_size - lp->free;
 144                 /*
 145                  * If the replay order was perfect the dirty space would now be
 146                  * zero. The order is not perfect because the journal heads
 147                  * race with each other. This is not a problem but is does mean
 148                  * that the dirty space may temporarily exceed c->leb_size
 149                  * during the replay.
 150                  */
 151                 if (dirty != 0)
 152                         dbg_msg("LEB %d lp: %d free %d dirty "
 153                                 "replay: %d free %d dirty", r->lnum, lp->free,
 154                                 lp->dirty, r->free, r->dirty);
 155         }
 156         lp = ubifs_change_lp(c, lp, r->free, dirty + r->dirty,
 157                              lp->flags | LPROPS_TAKEN, 0);
 158         if (IS_ERR(lp)) {
 159                 err = PTR_ERR(lp);
 160                 goto out;
 161         }
 162 out:
 163         ubifs_release_lprops(c);
 164         return err;
 165 }
 166
 167 /**
 168  * trun_remove_range - apply a replay entry for a truncation to the TNC.
 169  * @c: UBIFS file-system description object
 170  * @r: replay entry of truncation
 171  */
 172 static int trun_remove_range(struct ubifs_info *c, struct replay_entry *r)
 173 {
 174         unsigned min_blk, max_blk;
 175         union ubifs_key min_key, max_key;
 176         ino_t ino;
 177
 178         min_blk = r->new_size / UBIFS_BLOCK_SIZE;
 179         if (r->new_size & (UBIFS_BLOCK_SIZE - 1))
 180                 min_blk += 1;
 181
 182         max_blk = r->old_size / UBIFS_BLOCK_SIZE;
 183         if ((r->old_size & (UBIFS_BLOCK_SIZE - 1)) == 0)
 184                 max_blk -= 1;
 185
 186         ino = key_inum(c, &r->key);
 187
 188         data_key_init(c, &min_key, ino, min_blk);
 189         data_key_init(c, &max_key, ino, max_blk);
 190
 191         return ubifs_tnc_remove_range(c, &min_key, &max_key);
 192 }
 193
 194 /**
 195  * apply_replay_entry - apply a replay entry to the TNC.
 196  * @c: UBIFS file-system description object
 197  * @r: replay entry to apply
 198  *
 199  * Apply a replay entry to the TNC.
 200  */
 201 static int apply_replay_entry(struct ubifs_info *c, struct replay_entry *r)
 202 {
 203         int err, deletion = ((r->flags & REPLAY_DELETION) != 0);
 204
 205         dbg_mnt("LEB %d:%d len %d flgs %d sqnum %llu %s", r->lnum,
 206                 r->offs, r->len, r->flags, r->sqnum, DBGKEY(&r->key));
 207
 208         /* Set c->replay_sqnum to help deal with dangling branches. */
 209         c->replay_sqnum = r->sqnum;
 210
 211         if (r->flags & REPLAY_REF)
 212                 err = set_bud_lprops(c, r);
 213         else if (is_hash_key(c, &r->key)) {
 214                 if (deletion)
 215                         err = ubifs_tnc_remove_nm(c, &r->key, &r->nm);
 216                 else
 217                         err = ubifs_tnc_add_nm(c, &r->key, r->lnum, r->offs,
 218                                                r->len, &r->nm);
 219         } else {
 220                 if (deletion)
 221                         switch (key_type(c, &r->key)) {
 222                         case UBIFS_INO_KEY:
 223                         {
 224                                 ino_t inum = key_inum(c, &r->key);
 225
 226                                 err = ubifs_tnc_remove_ino(c, inum);
 227                                 break;
 228                         }
 229                         case UBIFS_TRUN_KEY:
 230                                 err = trun_remove_range(c, r);
 231                                 break;
 232                         default:
 233                                 err = ubifs_tnc_remove(c, &r->key);
 234                                 break;
 235                         }
 236                 else
 237                         err = ubifs_tnc_add(c, &r->key, r->lnum, r->offs,
 238                                             r->len);
 239                 if (err)
 240                         return err;
 241
 242                 if (c->need_recovery)
 243                         err = ubifs_recover_size_accum(c, &r->key, deletion,
 244                                                        r->new_size);
 245         }
 246
 247         return err;
 248 }
 249
 250 /**
 251  * destroy_replay_tree - destroy the replay.
 252  * @c: UBIFS file-system description object
 253  *
 254  * Destroy the replay tree.
 255  */
 256 static void destroy_replay_tree(struct ubifs_info *c)
 257 {
 258         struct rb_node *this = c->replay_tree.rb_node;
 259         struct replay_entry *r;
 260
 261         while (this) {
 262                 if (this->rb_left) {
 263                         this = this->rb_left;
 264                         continue;
 265                 } else if (this->rb_right) {
 266                         this = this->rb_right;
 267                         continue;
 268                 }
 269                 r = rb_entry(this, struct replay_entry, rb);
 270                 this = rb_parent(this);
 271                 if (this) {
 272                         if (this->rb_left == &r->rb)
 273                                 this->rb_left = NULL;
 274                         else
 275                                 this->rb_right = NULL;
 276                 }
 277                 if (is_hash_key(c, &r->key))
 278                         kfree(r->nm.name);
 279                 kfree(r);
 280         }
 281         c->replay_tree = RB_ROOT;
 282 }
 283
 284 /**
 285  * apply_replay_tree - apply the replay tree to the TNC.
 286  * @c: UBIFS file-system description object
 287  *
 288  * Apply the replay tree.
 289  * Returns zero in case of success and a negative error code in case of
 290  * failure.
 291  */
 292 static int apply_replay_tree(struct ubifs_info *c)
 293 {
 294         struct rb_node *this = rb_first(&c->replay_tree);
 295
 296         while (this) {
 297                 struct replay_entry *r;
 298                 int err;
 299
 300                 cond_resched();
 301
 302                 r = rb_entry(this, struct replay_entry, rb);
 303                 err = apply_replay_entry(c, r);
 304                 if (err)
 305                         return err;
 306                 this = rb_next(this);
 307         }
 308         return 0;
 309 }
 310
 311 /**
 312  * insert_node - insert a node to the replay tree.
 313  * @c: UBIFS file-system description object
 314  * @lnum: node logical eraseblock number
 315  * @offs: node offset
 316  * @len: node length
 317  * @key: node key
 318  * @sqnum: sequence number
 319  * @deletion: non-zero if this is a deletion
 320  * @used: number of bytes in use in a LEB
 321  * @old_size: truncation old size
 322  * @new_size: truncation new size
 323  *
 324  * This function inserts a scanned non-direntry node to the replay tree. The
 325  * replay tree is an RB-tree containing @struct replay_entry elements which are
 326  * indexed by the sequence number. The replay tree is applied at the very end
 327  * of the replay process. Since the tree is sorted in sequence number order,
 328  * the older modifications are applied first. This function returns zero in
 329  * case of success and a negative error code in case of failure.
 330  */
 331 static int insert_node(struct ubifs_info *c, int lnum, int offs, int len,
 332                        union ubifs_key *key, unsigned long long sqnum,
 333                        int deletion, int *used, loff_t old_size,
 334                        loff_t new_size)
 335 {
 336         struct rb_node **p = &c->replay_tree.rb_node, *parent = NULL;
 337         struct replay_entry *r;
 338
 339         if (key_inum(c, key) >= c->highest_inum)
 340                 c->highest_inum = key_inum(c, key);
 341
 342         dbg_mnt("add LEB %d:%d, key %s", lnum, offs, DBGKEY(key));
 343         while (*p) {
 344                 parent = *p;
 345                 r = rb_entry(parent, struct replay_entry, rb);
 346                 if (sqnum < r->sqnum) {
 347                         p = &(*p)->rb_left;
 348                         continue;
 349                 } else if (sqnum > r->sqnum) {
 350                         p = &(*p)->rb_right;
 351                         continue;
 352                 }
 353                 ubifs_err("duplicate sqnum in replay");
 354                 return -EINVAL;
 355         }
 356
 357         r = kzalloc(sizeof(struct replay_entry), GFP_KERNEL);
 358         if (!r)
 359                 return -ENOMEM;
 360
 361         if (!deletion)
 362                 *used += ALIGN(len, 8);
 363         r->lnum = lnum;
 364         r->offs = offs;
 365         r->len = len;
 366         r->sqnum = sqnum;
 367         r->flags = (deletion ? REPLAY_DELETION : 0);
 368         r->old_size = old_size;
 369         r->new_size = new_size;
 370         key_copy(c, key, &r->key);
 371
 372         rb_link_node(&r->rb, parent, p);
 373         rb_insert_color(&r->rb, &c->replay_tree);
 374         return 0;
 375 }
 376
 377 /**
 378  * insert_dent - insert a directory entry node into the replay tree.
 379  * @c: UBIFS file-system description object
 380  * @lnum: node logical eraseblock number
 381  * @offs: node offset
 382  * @len: node length
 383  * @key: node key
 384  * @name: directory entry name
 385  * @nlen: directory entry name length
 386  * @sqnum: sequence number
 387  * @deletion: non-zero if this is a deletion
 388  * @used: number of bytes in use in a LEB
 389  *
 390  * This function inserts a scanned directory entry node to the replay tree.
 391  * Returns zero in case of success and a negative error code in case of
 392  * failure.
 393  *
 394  * This function is also used for extended attribute entries because they are
 395  * implemented as directory entry nodes.
 396  */
 397 static int insert_dent(struct ubifs_info *c, int lnum, int offs, int len,
 398                        union ubifs_key *key, const char *name, int nlen,
 399                        unsigned long long sqnum, int deletion, int *used)
 400 {
 401         struct rb_node **p = &c->replay_tree.rb_node, *parent = NULL;
 402         struct replay_entry *r;
 403         char *nbuf;
 404
 405         if (key_inum(c, key) >= c->highest_inum)
 406                 c->highest_inum = key_inum(c, key);
 407
 408         dbg_mnt("add LEB %d:%d, key %s", lnum, offs, DBGKEY(key));
 409         while (*p) {
 410                 parent = *p;
 411                 r = rb_entry(parent, struct replay_entry, rb);
 412                 if (sqnum < r->sqnum) {
 413                         p = &(*p)->rb_left;
 414                         continue;
 415                 }
 416                 if (sqnum > r->sqnum) {
 417                         p = &(*p)->rb_right;
 418                         continue;
 419                 }
 420                 ubifs_err("duplicate sqnum in replay");
 421                 return -EINVAL;
 422         }
 423
 424         r = kzalloc(sizeof(struct replay_entry), GFP_KERNEL);
 425         if (!r)
 426                 return -ENOMEM;
 427         nbuf = kmalloc(nlen + 1, GFP_KERNEL);
 428         if (!nbuf) {
 429                 kfree(r);
 430                 return -ENOMEM;
 431         }
 432
 433         if (!deletion)
 434                 *used += ALIGN(len, 8);
 435         r->lnum = lnum;
 436         r->offs = offs;
 437         r->len = len;
 438         r->sqnum = sqnum;
 439         r->nm.len = nlen;
 440         memcpy(nbuf, name, nlen);
 441         nbuf[nlen] = '\0';
 442         r->nm.name = nbuf;
 443         r->flags = (deletion ? REPLAY_DELETION : 0);
 444         key_copy(c, key, &r->key);
 445
 446         ubifs_assert(!*p);
 447         rb_link_node(&r->rb, parent, p);
 448         rb_insert_color(&r->rb, &c->replay_tree);
 449         return 0;
 450 }
 451
 452 /**
 453  * ubifs_validate_entry - validate directory or extended attribute entry node.
 454  * @c: UBIFS file-system description object
 455  * @dent: the node to validate
 456  *
 457  * This function validates directory or extended attribute entry node @dent.
 458  * Returns zero if the node is all right and a %-EINVAL if not.
 459  */
 460 int ubifs_validate_entry(struct ubifs_info *c,
 461                          const struct ubifs_dent_node *dent)
 462 {
 463         int key_type = key_type_flash(c, dent->key);
 464         int nlen = le16_to_cpu(dent->nlen);
 465
 466         if (le32_to_cpu(dent->ch.len) != nlen + UBIFS_DENT_NODE_SZ + 1 ||
 467             dent->type >= UBIFS_ITYPES_CNT ||
 468             nlen > UBIFS_MAX_NLEN || dent->name[nlen] != 0 ||
 469             strnlen(dent->name, nlen) != nlen ||
 470             le64_to_cpu(dent->inum) > MAX_INUM) {
 471                 ubifs_err("bad %s node", key_type == UBIFS_DENT_KEY ?
 472                           "directory entry" : "extended attribute entry");
 473                 return -EINVAL;
 474         }
 475
 476         if (key_type != UBIFS_DENT_KEY && key_type != UBIFS_XENT_KEY) {
 477                 ubifs_err("bad key type %d", key_type);
 478                 return -EINVAL;
 479         }
 480
 481         return 0;
 482 }
 483
 484 /**
 485  * replay_bud - replay a bud logical eraseblock.
 486  * @c: UBIFS file-system description object
 487  * @lnum: bud logical eraseblock number to replay
 488  * @offs: bud start offset
 489  * @jhead: journal head to which this bud belongs
 490  * @free: amount of free space in the bud is returned here
 491  * @dirty: amount of dirty space from padding and deletion nodes is returned
 492  * here
 493  *
 494  * This function returns zero in case of success and a negative error code in
 495  * case of failure.
 496  */
 497 static int replay_bud(struct ubifs_info *c, int lnum, int offs, int jhead,
 498                       int *free, int *dirty)
 499 {
 500         int err = 0, used = 0;
 501         struct ubifs_scan_leb *sleb;
 502         struct ubifs_scan_node *snod;
 503         struct ubifs_bud *bud;
 504
 505         dbg_mnt("replay bud LEB %d, head %d", lnum, jhead);
 506         if (c->need_recovery)
 507                 sleb = ubifs_recover_leb(c, lnum, offs, c->sbuf, jhead != GCHD);
 508         else
 509                 sleb = ubifs_scan(c, lnum, offs, c->sbuf, 0);
 510         if (IS_ERR(sleb))
 511                 return PTR_ERR(sleb);
 512
 513         /*
 514          * The bud does not have to start from offset zero - the beginning of
 515          * the 'lnum' LEB may contain previously committed data. One of the
 516          * things we have to do in replay is to correctly update lprops with
 517          * newer information about this LEB.
 518          *
 519          * At this point lprops thinks that this LEB has 'c->leb_size - offs'
 520          * bytes of free space because it only contain information about
 521          * committed data.
 522          *
 523          * But we know that real amount of free space is 'c->leb_size -
 524          * sleb->endpt', and the space in the 'lnum' LEB between 'offs' and
 525          * 'sleb->endpt' is used by bud data. We have to correctly calculate
 526          * how much of these data are dirty and update lprops with this
 527          * information.
 528          *
 529          * The dirt in that LEB region is comprised of padding nodes, deletion
 530          * nodes, truncation nodes and nodes which are obsoleted by subsequent
 531          * nodes in this LEB. So instead of calculating clean space, we
 532          * calculate used space ('used' variable).
 533          */
 534
 535         list_for_each_entry(snod, &sleb->nodes, list) {
 536                 int deletion = 0;
 537
 538                 cond_resched();
 539
 540                 if (snod->sqnum >= SQNUM_WATERMARK) {
 541                         ubifs_err("file system's life ended");
 542                         goto out_dump;
 543                 }
 544
 545                 if (snod->sqnum > c->max_sqnum)
 546                         c->max_sqnum = snod->sqnum;
 547
 548                 switch (snod->type) {
 549                 case UBIFS_INO_NODE:
 550                 {
 551                         struct ubifs_ino_node *ino = snod->node;
 552                         loff_t new_size = le64_to_cpu(ino->size);
 553
 554                         if (le32_to_cpu(ino->nlink) == 0)
 555                                 deletion = 1;
 556                         err = insert_node(c, lnum, snod->offs, snod->len,
 557                                           &snod->key, snod->sqnum, deletion,
 558                                           &used, 0, new_size);
 559                         break;
 560                 }
 561                 case UBIFS_DATA_NODE:
 562                 {
 563                         struct ubifs_data_node *dn = snod->node;
 564                         loff_t new_size = le32_to_cpu(dn->size) +
 565                                           key_block(c, &snod->key) *
 566                                           UBIFS_BLOCK_SIZE;
 567
 568                         err = insert_node(c, lnum, snod->offs, snod->len,
 569                                           &snod->key, snod->sqnum, deletion,
 570                                           &used, 0, new_size);
 571                         break;
 572                 }
 573                 case UBIFS_DENT_NODE:
 574                 case UBIFS_XENT_NODE:
 575                 {
 576                         struct ubifs_dent_node *dent = snod->node;
 577
 578                         err = ubifs_validate_entry(c, dent);
 579                         if (err)
 580                                 goto out_dump;
 581
 582                         err = insert_dent(c, lnum, snod->offs, snod->len,
 583                                           &snod->key, dent->name,
 584                                           le16_to_cpu(dent->nlen), snod->sqnum,
 585                                           !le64_to_cpu(dent->inum), &used);
 586                         break;
 587                 }
 588                 case UBIFS_TRUN_NODE:
 589                 {
 590                         struct ubifs_trun_node *trun = snod->node;
 591                         loff_t old_size = le64_to_cpu(trun->old_size);
 592                         loff_t new_size = le64_to_cpu(trun->new_size);
 593                         union ubifs_key key;
 594
 595                         /* Validate truncation node */
 596                         if (old_size < 0 || old_size > c->max_inode_sz ||
 597                             new_size < 0 || new_size > c->max_inode_sz ||
 598                             old_size <= new_size) {
 599                                 ubifs_err("bad truncation node");
 600                                 goto out_dump;
 601                         }
 602
 603                         /*
 604                          * Create a fake truncation key just to use the same
 605                          * functions which expect nodes to have keys.
 606                          */
 607                         trun_key_init(c, &key, le32_to_cpu(trun->inum));
 608                         err = insert_node(c, lnum, snod->offs, snod->len,
 609                                           &key, snod->sqnum, 1, &used,
 610                                           old_size, new_size);
 611                         break;
 612                 }
 613                 default:
 614                         ubifs_err("unexpected node type %d in bud LEB %d:%d",
 615                                   snod->type, lnum, snod->offs);
 616                         err = -EINVAL;
 617                         goto out_dump;
 618                 }
 619                 if (err)
 620                         goto out;
 621         }
 622
 623         bud = ubifs_search_bud(c, lnum);
 624         if (!bud)
 625                 BUG();
 626
 627         ubifs_assert(sleb->endpt - offs >= used);
 628         ubifs_assert(sleb->endpt % c->min_io_size == 0);
 629
 630         if (sleb->endpt + c->min_io_size <= c->leb_size && !c->ro_mount)
 631                 err = ubifs_wbuf_seek_nolock(&c->jheads[jhead].wbuf, lnum,
 632                                              sleb->endpt, UBI_SHORTTERM);
 633
 634         *dirty = sleb->endpt - offs - used;
 635         *free = c->leb_size - sleb->endpt;
 636
 637 out:
 638         ubifs_scan_destroy(sleb);
 639         return err;
 640
 641 out_dump:
 642         ubifs_err("bad node is at LEB %d:%d", lnum, snod->offs);
 643         dbg_dump_node(c, snod->node);
 644         ubifs_scan_destroy(sleb);
 645         return -EINVAL;
 646 }
 647
 648 /**
 649  * insert_ref_node - insert a reference node to the replay tree.
 650  * @c: UBIFS file-system description object
 651  * @lnum: node logical eraseblock number
 652  * @offs: node offset
 653  * @sqnum: sequence number
 654  * @free: amount of free space in bud
 655  * @dirty: amount of dirty space from padding and deletion nodes
 656  *
 657  * This function inserts a reference node to the replay tree and returns zero
 658  * in case of success or a negative error code in case of failure.
 659  */
 660 static int insert_ref_node(struct ubifs_info *c, int lnum, int offs,
 661                            unsigned long long sqnum, int free, int dirty)
 662 {
 663         struct rb_node **p = &c->replay_tree.rb_node, *parent = NULL;
 664         struct replay_entry *r;
 665
 666         dbg_mnt("add ref LEB %d:%d", lnum, offs);
 667         while (*p) {
 668                 parent = *p;
 669                 r = rb_entry(parent, struct replay_entry, rb);
 670                 if (sqnum < r->sqnum) {
 671                         p = &(*p)->rb_left;
 672                         continue;
 673                 } else if (sqnum > r->sqnum) {
 674                         p = &(*p)->rb_right;
 675                         continue;
 676                 }
 677                 ubifs_err("duplicate sqnum in replay tree");
 678                 return -EINVAL;
 679         }
 680
 681         r = kzalloc(sizeof(struct replay_entry), GFP_KERNEL);
 682         if (!r)
 683                 return -ENOMEM;
 684
 685         r->lnum = lnum;
 686         r->offs = offs;
 687         r->sqnum = sqnum;
 688         r->flags = REPLAY_REF;
 689         r->free = free;
 690         r->dirty = dirty;
 691
 692         rb_link_node(&r->rb, parent, p);
 693         rb_insert_color(&r->rb, &c->replay_tree);
 694         return 0;
 695 }
 696
 697 /**
 698  * replay_buds - replay all buds.
 699  * @c: UBIFS file-system description object
 700  *
 701  * This function returns zero in case of success and a negative error code in
 702  * case of failure.
 703  */
 704 static int replay_buds(struct ubifs_info *c)
 705 {
 706         struct bud_entry *b;
 707         int err, uninitialized_var(free), uninitialized_var(dirty);
 708
 709         list_for_each_entry(b, &c->replay_buds, list) {
 710                 err = replay_bud(c, b->bud->lnum, b->bud->start, b->bud->jhead,
 711                                  &free, &dirty);
 712                 if (err)
 713                         return err;
 714                 err = insert_ref_node(c, b->bud->lnum, b->bud->start, b->sqnum,
 715                                       free, dirty);
 716                 if (err)
 717                         return err;
 718         }
 719
 720         return 0;
 721 }
 722
 723 /**
 724  * destroy_bud_list - destroy the list of buds to replay.
 725  * @c: UBIFS file-system description object
 726  */
 727 static void destroy_bud_list(struct ubifs_info *c)
 728 {
 729         struct bud_entry *b;
 730
 731         while (!list_empty(&c->replay_buds)) {
 732                 b = list_entry(c->replay_buds.next, struct bud_entry, list);
 733                 list_del(&b->list);
 734                 kfree(b);
 735         }
 736 }
 737
 738 /**
 739  * add_replay_bud - add a bud to the list of buds to replay.
 740  * @c: UBIFS file-system description object
 741  * @lnum: bud logical eraseblock number to replay
 742  * @offs: bud start offset
 743  * @jhead: journal head to which this bud belongs
 744  * @sqnum: reference node sequence number
 745  *
 746  * This function returns zero in case of success and a negative error code in
 747  * case of failure.
 748  */
 749 static int add_replay_bud(struct ubifs_info *c, int lnum, int offs, int jhead,
 750                           unsigned long long sqnum)
 751 {
 752         struct ubifs_bud *bud;
 753         struct bud_entry *b;
 754
 755         dbg_mnt("add replay bud LEB %d:%d, head %d", lnum, offs, jhead);
 756
 757         bud = kmalloc(sizeof(struct ubifs_bud), GFP_KERNEL);
 758         if (!bud)
 759                 return -ENOMEM;
 760
 761         b = kmalloc(sizeof(struct bud_entry), GFP_KERNEL);
 762         if (!b) {
 763                 kfree(bud);
 764                 return -ENOMEM;
 765         }
 766
 767         bud->lnum = lnum;
 768         bud->start = offs;
 769         bud->jhead = jhead;
 770         ubifs_add_bud(c, bud);
 771
 772         b->bud = bud;
 773         b->sqnum = sqnum;
 774         list_add_tail(&b->list, &c->replay_buds);
 775
 776         return 0;
 777 }
 778
 779 /**
 780  * validate_ref - validate a reference node.
 781  * @c: UBIFS file-system description object
 782  * @ref: the reference node to validate
 783  * @ref_lnum: LEB number of the reference node
 784  * @ref_offs: reference node offset
 785  *
 786  * This function returns %1 if a bud reference already exists for the LEB. %0 is
 787  * returned if the reference node is new, otherwise %-EINVAL is returned if
 788  * validation failed.
 789  */
 790 static int validate_ref(struct ubifs_info *c, const struct ubifs_ref_node *ref)
 791 {
 792         struct ubifs_bud *bud;
 793         int lnum = le32_to_cpu(ref->lnum);
 794         unsigned int offs = le32_to_cpu(ref->offs);
 795         unsigned int jhead = le32_to_cpu(ref->jhead);
 796
 797         /*
 798          * ref->offs may point to the end of LEB when the journal head points
 799          * to the end of LEB and we write reference node for it during commit.
 800          * So this is why we require 'offs > c->leb_size'.
 801          */
 802         if (jhead >= c->jhead_cnt || lnum >= c->leb_cnt ||
 803             lnum < c->main_first || offs > c->leb_size ||
 804             offs & (c->min_io_size - 1))
 805                 return -EINVAL;
 806
 807         /* Make sure we have not already looked at this bud */
 808         bud = ubifs_search_bud(c, lnum);
 809         if (bud) {
 810                 if (bud->jhead == jhead && bud->start <= offs)
 811                         return 1;
 812                 ubifs_err("bud at LEB %d:%d was already referred", lnum, offs);
 813                 return -EINVAL;
 814         }
 815
 816         return 0;
 817 }
 818
 819 /**
 820  * replay_log_leb - replay a log logical eraseblock.
 821  * @c: UBIFS file-system description object
 822  * @lnum: log logical eraseblock to replay
 823  * @offs: offset to start replaying from
 824  * @sbuf: scan buffer
 825  *
 826  * This function replays a log LEB and returns zero in case of success, %1 if
 827  * this is the last LEB in the log, and a negative error code in case of
 828  * failure.
 829  */
 830 static int replay_log_leb(struct ubifs_info *c, int lnum, int offs, void *sbuf)
 831 {
 832         int err;
 833         struct ubifs_scan_leb *sleb;
 834         struct ubifs_scan_node *snod;
 835         const struct ubifs_cs_node *node;
 836
 837         dbg_mnt("replay log LEB %d:%d", lnum, offs);
 838         sleb = ubifs_scan(c, lnum, offs, sbuf, c->need_recovery);
 839         if (IS_ERR(sleb)) {
 840                 if (PTR_ERR(sleb) != -EUCLEAN || !c->need_recovery)
 841                         return PTR_ERR(sleb);
 842                 /*
 843                  * Note, the below function will recover this log LEB only if
 844                  * it is the last, because unclean reboots can possibly corrupt
 845                  * only the tail of the log.
 846                  */
 847                 sleb = ubifs_recover_log_leb(c, lnum, offs, sbuf);
 848                 if (IS_ERR(sleb))
 849                         return PTR_ERR(sleb);
 850         }
 851
 852         if (sleb->nodes_cnt == 0) {
 853                 err = 1;
 854                 goto out;
 855         }
 856
 857         node = sleb->buf;
 858         snod = list_entry(sleb->nodes.next, struct ubifs_scan_node, list);
 859         if (c->cs_sqnum == 0) {
 860                 /*
 861                  * This is the first log LEB we are looking at, make sure that
 862                  * the first node is a commit start node. Also record its
 863                  * sequence number so that UBIFS can determine where the log
 864                  * ends, because all nodes which were have higher sequence
 865                  * numbers.
 866                  */
 867                 if (snod->type != UBIFS_CS_NODE) {
 868                         dbg_err("first log node at LEB %d:%d is not CS node",
 869                                 lnum, offs);
 870                         goto out_dump;
 871                 }
 872                 if (le64_to_cpu(node->cmt_no) != c->cmt_no) {
 873                         dbg_err("first CS node at LEB %d:%d has wrong "
 874                                 "commit number %llu expected %llu",
 875                                 lnum, offs,
 876                                 (unsigned long long)le64_to_cpu(node->cmt_no),
 877                                 c->cmt_no);
 878                         goto out_dump;
 879                 }
 880
 881                 c->cs_sqnum = le64_to_cpu(node->ch.sqnum);
 882                 dbg_mnt("commit start sqnum %llu", c->cs_sqnum);
 883         }
 884
 885         if (snod->sqnum < c->cs_sqnum) {
 886                 /*
 887                  * This means that we reached end of log and now
 888                  * look to the older log data, which was already
 889                  * committed but the eraseblock was not erased (UBIFS
 890                  * only un-maps it). So this basically means we have to
 891                  * exit with "end of log" code.
 892                  */
 893                 err = 1;
 894                 goto out;
 895         }
 896
 897         /* Make sure the first node sits at offset zero of the LEB */
 898         if (snod->offs != 0) {
 899                 dbg_err("first node is not at zero offset");
 900                 goto out_dump;
 901         }
 902
 903         list_for_each_entry(snod, &sleb->nodes, list) {
 904                 cond_resched();
 905
 906                 if (snod->sqnum >= SQNUM_WATERMARK) {
 907                         ubifs_err("file system's life ended");
 908                         goto out_dump;
 909                 }
 910
 911                 if (snod->sqnum < c->cs_sqnum) {
 912                         dbg_err("bad sqnum %llu, commit sqnum %llu",
 913                                 snod->sqnum, c->cs_sqnum);
 914                         goto out_dump;
 915                 }
 916
 917                 if (snod->sqnum > c->max_sqnum)
 918                         c->max_sqnum = snod->sqnum;
 919
 920                 switch (snod->type) {
 921                 case UBIFS_REF_NODE: {
 922                         const struct ubifs_ref_node *ref = snod->node;
 923
 924                         err = validate_ref(c, ref);
 925                         if (err == 1)
 926                                 break; /* Already have this bud */
 927                         if (err)
 928                                 goto out_dump;
 929
 930                         err = add_replay_bud(c, le32_to_cpu(ref->lnum),
 931                                              le32_to_cpu(ref->offs),
 932                                              le32_to_cpu(ref->jhead),
 933                                              snod->sqnum);
 934                         if (err)
 935                                 goto out;
 936
 937                         break;
 938                 }
 939                 case UBIFS_CS_NODE:
 940                         /* Make sure it sits at the beginning of LEB */
 941                         if (snod->offs != 0) {
 942                                 ubifs_err("unexpected node in log");
 943                                 goto out_dump;
 944                         }
 945                         break;
 946                 default:
 947                         ubifs_err("unexpected node in log");
 948                         goto out_dump;
 949                 }
 950         }
 951
 952         if (sleb->endpt || c->lhead_offs >= c->leb_size) {
 953                 c->lhead_lnum = lnum;
 954                 c->lhead_offs = sleb->endpt;
 955         }
 956
 957         err = !sleb->endpt;
 958 out:
 959         ubifs_scan_destroy(sleb);
 960         return err;
 961
 962 out_dump:
 963         ubifs_err("log error detected while replaying the log at LEB %d:%d",
 964                   lnum, offs + snod->offs);
 965         dbg_dump_node(c, snod->node);
 966         ubifs_scan_destroy(sleb);
 967         return -EINVAL;
 968 }
 969
 970 /**
 971  * take_ihead - update the status of the index head in lprops to 'taken'.
 972  * @c: UBIFS file-system description object
 973  *
 974  * This function returns the amount of free space in the index head LEB or a
 975  * negative error code.
 976  */
 977 static int take_ihead(struct ubifs_info *c)
 978 {
 979         const struct ubifs_lprops *lp;
 980         int err, free;
 981
 982         ubifs_get_lprops(c);
 983
 984         lp = ubifs_lpt_lookup_dirty(c, c->ihead_lnum);
 985         if (IS_ERR(lp)) {
 986                 err = PTR_ERR(lp);
 987                 goto out;
 988         }
 989
 990         free = lp->free;
 991
 992         lp = ubifs_change_lp(c, lp, LPROPS_NC, LPROPS_NC,
 993                              lp->flags | LPROPS_TAKEN, 0);
 994         if (IS_ERR(lp)) {
 995                 err = PTR_ERR(lp);
 996                 goto out;
 997         }
 998
 999         err = free;
1000 out:
1001         ubifs_release_lprops(c);
1002         return err;
1003 }
1004
1005 /**
1006  * ubifs_replay_journal - replay journal.
1007  * @c: UBIFS file-system description object
1008  *
1009  * This function scans the journal, replays and cleans it up. It makes sure all
1010  * memory data structures related to uncommitted journal are built (dirty TNC
1011  * tree, tree of buds, modified lprops, etc).
1012  */
1013 int ubifs_replay_journal(struct ubifs_info *c)
1014 {
1015         int err, i, lnum, offs, free;
1016
1017         BUILD_BUG_ON(UBIFS_TRUN_KEY > 5);
1018
1019         /* Update the status of the index head in lprops to 'taken' */
1020         free = take_ihead(c);
1021         if (free < 0)
1022                 return free; /* Error code */
1023
1024         if (c->ihead_offs != c->leb_size - free) {
1025                 ubifs_err("bad index head LEB %d:%d", c->ihead_lnum,
1026                           c->ihead_offs);
1027                 return -EINVAL;
1028         }
1029
1030         dbg_mnt("start replaying the journal");
1031         c->replaying = 1;
1032         lnum = c->ltail_lnum = c->lhead_lnum;
1033         offs = c->lhead_offs;
1034
1035         for (i = 0; i < c->log_lebs; i++, lnum++) {
1036                 if (lnum >= UBIFS_LOG_LNUM + c->log_lebs) {
1037                         /*
1038                          * The log is logically circular, we reached the last
1039                          * LEB, switch to the first one.
1040                          */
1041                         lnum = UBIFS_LOG_LNUM;
1042                         offs = 0;
1043                 }
1044                 err = replay_log_leb(c, lnum, offs, c->sbuf);
1045                 if (err == 1)
1046                         /* We hit the end of the log */
1047                         break;
1048                 if (err)
1049                         goto out;
1050                 offs = 0;
1051         }
1052
1053         err = replay_buds(c);
1054         if (err)
1055                 goto out;
1056
1057         err = apply_replay_tree(c);
1058         if (err)
1059                 goto out;
1060
1061         /*
1062          * UBIFS budgeting calculations use @c->budg_uncommitted_idx variable
1063          * to roughly estimate index growth. Things like @c->min_idx_lebs
1064          * depend on it. This means we have to initialize it to make sure
1065          * budgeting works properly.
1066          */
1067         c->budg_uncommitted_idx = atomic_long_read(&c->dirty_zn_cnt);
1068         c->budg_uncommitted_idx *= c->max_idx_node_sz;
1069
1070         ubifs_assert(c->bud_bytes <= c->max_bud_bytes || c->need_recovery);
1071         dbg_mnt("finished, log head LEB %d:%d, max_sqnum %llu, "
1072                 "highest_inum %lu", c->lhead_lnum, c->lhead_offs, c->max_sqnum,
1073                 (unsigned long)c->highest_inum);
1074 out:
1075         destroy_replay_tree(c);
1076         destroy_bud_list(c);
1077         c->replaying = 0;
1078         return err;
1079 }