SAFE public projects git trees. - safe/jmp/linux-2.6/blob - fs/ubifs/recovery.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 implements functions needed to recover from unclean un-mounts.
  25  * When UBIFS is mounted, it checks a flag on the master node to determine if
  26  * an un-mount was completed successfully. If not, the process of mounting
  27  * incorparates additional checking and fixing of on-flash data structures.
  28  * UBIFS always cleans away all remnants of an unclean un-mount, so that
  29  * errors do not accumulate. However UBIFS defers recovery if it is mounted
  30  * read-only, and the flash is not modified in that case.
  31  */
  32
  33 #include <linux/crc32.h>
  34 #include "ubifs.h"
  35
  36 /**
  37  * is_empty - determine whether a buffer is empty (contains all 0xff).
  38  * @buf: buffer to clean
  39  * @len: length of buffer
  40  *
  41  * This function returns %1 if the buffer is empty (contains all 0xff) otherwise
  42  * %0 is returned.
  43  */
  44 static int is_empty(void *buf, int len)
  45 {
  46         uint8_t *p = buf;
  47         int i;
  48
  49         for (i = 0; i < len; i++)
  50                 if (*p++ != 0xff)
  51                         return 0;
  52         return 1;
  53 }
  54
  55 /**
  56  * first_non_ff - find offset of the first non-0xff byte.
  57  * @buf: buffer to search in
  58  * @len: length of buffer
  59  *
  60  * This function returns offset of the first non-0xff byte in @buf or %-1 if
  61  * the buffer contains only 0xff bytes.
  62  */
  63 static int first_non_ff(void *buf, int len)
  64 {
  65         uint8_t *p = buf;
  66         int i;
  67
  68         for (i = 0; i < len; i++)
  69                 if (*p++ != 0xff)
  70                         return i;
  71         return -1;
  72 }
  73
  74 /**
  75  * get_master_node - get the last valid master node allowing for corruption.
  76  * @c: UBIFS file-system description object
  77  * @lnum: LEB number
  78  * @pbuf: buffer containing the LEB read, is returned here
  79  * @mst: master node, if found, is returned here
  80  * @cor: corruption, if found, is returned here
  81  *
  82  * This function allocates a buffer, reads the LEB into it, and finds and
  83  * returns the last valid master node allowing for one area of corruption.
  84  * The corrupt area, if there is one, must be consistent with the assumption
  85  * that it is the result of an unclean unmount while the master node was being
  86  * written. Under those circumstances, it is valid to use the previously written
  87  * master node.
  88  *
  89  * This function returns %0 on success and a negative error code on failure.
  90  */
  91 static int get_master_node(const struct ubifs_info *c, int lnum, void **pbuf,
  92                            struct ubifs_mst_node **mst, void **cor)
  93 {
  94         const int sz = c->mst_node_alsz;
  95         int err, offs, len;
  96         void *sbuf, *buf;
  97
  98         sbuf = vmalloc(c->leb_size);
  99         if (!sbuf)
 100                 return -ENOMEM;
 101
 102         err = ubi_read(c->ubi, lnum, sbuf, 0, c->leb_size);
 103         if (err && err != -EBADMSG)
 104                 goto out_free;
 105
 106         /* Find the first position that is definitely not a node */
 107         offs = 0;
 108         buf = sbuf;
 109         len = c->leb_size;
 110         while (offs + UBIFS_MST_NODE_SZ <= c->leb_size) {
 111                 struct ubifs_ch *ch = buf;
 112
 113                 if (le32_to_cpu(ch->magic) != UBIFS_NODE_MAGIC)
 114                         break;
 115                 offs += sz;
 116                 buf  += sz;
 117                 len  -= sz;
 118         }
 119         /* See if there was a valid master node before that */
 120         if (offs) {
 121                 int ret;
 122
 123                 offs -= sz;
 124                 buf  -= sz;
 125                 len  += sz;
 126                 ret = ubifs_scan_a_node(c, buf, len, lnum, offs, 1);
 127                 if (ret != SCANNED_A_NODE && offs) {
 128                         /* Could have been corruption so check one place back */
 129                         offs -= sz;
 130                         buf  -= sz;
 131                         len  += sz;
 132                         ret = ubifs_scan_a_node(c, buf, len, lnum, offs, 1);
 133                         if (ret != SCANNED_A_NODE)
 134                                 /*
 135                                  * We accept only one area of corruption because
 136                                  * we are assuming that it was caused while
 137                                  * trying to write a master node.
 138                                  */
 139                                 goto out_err;
 140                 }
 141                 if (ret == SCANNED_A_NODE) {
 142                         struct ubifs_ch *ch = buf;
 143
 144                         if (ch->node_type != UBIFS_MST_NODE)
 145                                 goto out_err;
 146                         dbg_rcvry("found a master node at %d:%d", lnum, offs);
 147                         *mst = buf;
 148                         offs += sz;
 149                         buf  += sz;
 150                         len  -= sz;
 151                 }
 152         }
 153         /* Check for corruption */
 154         if (offs < c->leb_size) {
 155                 if (!is_empty(buf, min_t(int, len, sz))) {
 156                         *cor = buf;
 157                         dbg_rcvry("found corruption at %d:%d", lnum, offs);
 158                 }
 159                 offs += sz;
 160                 buf  += sz;
 161                 len  -= sz;
 162         }
 163         /* Check remaining empty space */
 164         if (offs < c->leb_size)
 165                 if (!is_empty(buf, len))
 166                         goto out_err;
 167         *pbuf = sbuf;
 168         return 0;
 169
 170 out_err:
 171         err = -EINVAL;
 172 out_free:
 173         vfree(sbuf);
 174         *mst = NULL;
 175         *cor = NULL;
 176         return err;
 177 }
 178
 179 /**
 180  * write_rcvrd_mst_node - write recovered master node.
 181  * @c: UBIFS file-system description object
 182  * @mst: master node
 183  *
 184  * This function returns %0 on success and a negative error code on failure.
 185  */
 186 static int write_rcvrd_mst_node(struct ubifs_info *c,
 187                                 struct ubifs_mst_node *mst)
 188 {
 189         int err = 0, lnum = UBIFS_MST_LNUM, sz = c->mst_node_alsz;
 190         __le32 save_flags;
 191
 192         dbg_rcvry("recovery");
 193
 194         save_flags = mst->flags;
 195         mst->flags |= cpu_to_le32(UBIFS_MST_RCVRY);
 196
 197         ubifs_prepare_node(c, mst, UBIFS_MST_NODE_SZ, 1);
 198         err = ubi_leb_change(c->ubi, lnum, mst, sz, UBI_SHORTTERM);
 199         if (err)
 200                 goto out;
 201         err = ubi_leb_change(c->ubi, lnum + 1, mst, sz, UBI_SHORTTERM);
 202         if (err)
 203                 goto out;
 204 out:
 205         mst->flags = save_flags;
 206         return err;
 207 }
 208
 209 /**
 210  * ubifs_recover_master_node - recover the master node.
 211  * @c: UBIFS file-system description object
 212  *
 213  * This function recovers the master node from corruption that may occur due to
 214  * an unclean unmount.
 215  *
 216  * This function returns %0 on success and a negative error code on failure.
 217  */
 218 int ubifs_recover_master_node(struct ubifs_info *c)
 219 {
 220         void *buf1 = NULL, *buf2 = NULL, *cor1 = NULL, *cor2 = NULL;
 221         struct ubifs_mst_node *mst1 = NULL, *mst2 = NULL, *mst;
 222         const int sz = c->mst_node_alsz;
 223         int err, offs1, offs2;
 224
 225         dbg_rcvry("recovery");
 226
 227         err = get_master_node(c, UBIFS_MST_LNUM, &buf1, &mst1, &cor1);
 228         if (err)
 229                 goto out_free;
 230
 231         err = get_master_node(c, UBIFS_MST_LNUM + 1, &buf2, &mst2, &cor2);
 232         if (err)
 233                 goto out_free;
 234
 235         if (mst1) {
 236                 offs1 = (void *)mst1 - buf1;
 237                 if ((le32_to_cpu(mst1->flags) & UBIFS_MST_RCVRY) &&
 238                     (offs1 == 0 && !cor1)) {
 239                         /*
 240                          * mst1 was written by recovery at offset 0 with no
 241                          * corruption.
 242                          */
 243                         dbg_rcvry("recovery recovery");
 244                         mst = mst1;
 245                 } else if (mst2) {
 246                         offs2 = (void *)mst2 - buf2;
 247                         if (offs1 == offs2) {
 248                                 /* Same offset, so must be the same */
 249                                 if (memcmp((void *)mst1 + UBIFS_CH_SZ,
 250                                            (void *)mst2 + UBIFS_CH_SZ,
 251                                            UBIFS_MST_NODE_SZ - UBIFS_CH_SZ))
 252                                         goto out_err;
 253                                 mst = mst1;
 254                         } else if (offs2 + sz == offs1) {
 255                                 /* 1st LEB was written, 2nd was not */
 256                                 if (cor1)
 257                                         goto out_err;
 258                                 mst = mst1;
 259                         } else if (offs1 == 0 && offs2 + sz >= c->leb_size) {
 260                                 /* 1st LEB was unmapped and written, 2nd not */
 261                                 if (cor1)
 262                                         goto out_err;
 263                                 mst = mst1;
 264                         } else
 265                                 goto out_err;
 266                 } else {
 267                         /*
 268                          * 2nd LEB was unmapped and about to be written, so
 269                          * there must be only one master node in the first LEB
 270                          * and no corruption.
 271                          */
 272                         if (offs1 != 0 || cor1)
 273                                 goto out_err;
 274                         mst = mst1;
 275                 }
 276         } else {
 277                 if (!mst2)
 278                         goto out_err;
 279                 /*
 280                  * 1st LEB was unmapped and about to be written, so there must
 281                  * be no room left in 2nd LEB.
 282                  */
 283                 offs2 = (void *)mst2 - buf2;
 284                 if (offs2 + sz + sz <= c->leb_size)
 285                         goto out_err;
 286                 mst = mst2;
 287         }
 288
 289         ubifs_msg("recovered master node from LEB %d",
 290                   (mst == mst1 ? UBIFS_MST_LNUM : UBIFS_MST_LNUM + 1));
 291
 292         memcpy(c->mst_node, mst, UBIFS_MST_NODE_SZ);
 293
 294         if ((c->vfs_sb->s_flags & MS_RDONLY)) {
 295                 /* Read-only mode. Keep a copy for switching to rw mode */
 296                 c->rcvrd_mst_node = kmalloc(sz, GFP_KERNEL);
 297                 if (!c->rcvrd_mst_node) {
 298                         err = -ENOMEM;
 299                         goto out_free;
 300                 }
 301                 memcpy(c->rcvrd_mst_node, c->mst_node, UBIFS_MST_NODE_SZ);
 302         } else {
 303                 /* Write the recovered master node */
 304                 c->max_sqnum = le64_to_cpu(mst->ch.sqnum) - 1;
 305                 err = write_rcvrd_mst_node(c, c->mst_node);
 306                 if (err)
 307                         goto out_free;
 308         }
 309
 310         vfree(buf2);
 311         vfree(buf1);
 312
 313         return 0;
 314
 315 out_err:
 316         err = -EINVAL;
 317 out_free:
 318         ubifs_err("failed to recover master node");
 319         if (mst1) {
 320                 dbg_err("dumping first master node");
 321                 dbg_dump_node(c, mst1);
 322         }
 323         if (mst2) {
 324                 dbg_err("dumping second master node");
 325                 dbg_dump_node(c, mst2);
 326         }
 327         vfree(buf2);
 328         vfree(buf1);
 329         return err;
 330 }
 331
 332 /**
 333  * ubifs_write_rcvrd_mst_node - write the recovered master node.
 334  * @c: UBIFS file-system description object
 335  *
 336  * This function writes the master node that was recovered during mounting in
 337  * read-only mode and must now be written because we are remounting rw.
 338  *
 339  * This function returns %0 on success and a negative error code on failure.
 340  */
 341 int ubifs_write_rcvrd_mst_node(struct ubifs_info *c)
 342 {
 343         int err;
 344
 345         if (!c->rcvrd_mst_node)
 346                 return 0;
 347         c->rcvrd_mst_node->flags |= cpu_to_le32(UBIFS_MST_DIRTY);
 348         c->mst_node->flags |= cpu_to_le32(UBIFS_MST_DIRTY);
 349         err = write_rcvrd_mst_node(c, c->rcvrd_mst_node);
 350         if (err)
 351                 return err;
 352         kfree(c->rcvrd_mst_node);
 353         c->rcvrd_mst_node = NULL;
 354         return 0;
 355 }
 356
 357 /**
 358  * is_last_write - determine if an offset was in the last write to a LEB.
 359  * @c: UBIFS file-system description object
 360  * @buf: buffer to check
 361  * @offs: offset to check
 362  *
 363  * This function returns %1 if @offs was in the last write to the LEB whose data
 364  * is in @buf, otherwise %0 is returned.  The determination is made by checking
 365  * for subsequent empty space starting from the next @c->min_io_size boundary.
 366  */
 367 static int is_last_write(const struct ubifs_info *c, void *buf, int offs)
 368 {
 369         int empty_offs, check_len;
 370         uint8_t *p;
 371
 372         /*
 373          * Round up to the next @c->min_io_size boundary i.e. @offs is in the
 374          * last wbuf written. After that should be empty space.
 375          */
 376         empty_offs = ALIGN(offs + 1, c->min_io_size);
 377         check_len = c->leb_size - empty_offs;
 378         p = buf + empty_offs - offs;
 379         return is_empty(p, check_len);
 380 }
 381
 382 /**
 383  * clean_buf - clean the data from an LEB sitting in a buffer.
 384  * @c: UBIFS file-system description object
 385  * @buf: buffer to clean
 386  * @lnum: LEB number to clean
 387  * @offs: offset from which to clean
 388  * @len: length of buffer
 389  *
 390  * This function pads up to the next min_io_size boundary (if there is one) and
 391  * sets empty space to all 0xff. @buf, @offs and @len are updated to the next
 392  * @c->min_io_size boundary.
 393  */
 394 static void clean_buf(const struct ubifs_info *c, void **buf, int lnum,
 395                       int *offs, int *len)
 396 {
 397         int empty_offs, pad_len;
 398
 399         lnum = lnum;
 400         dbg_rcvry("cleaning corruption at %d:%d", lnum, *offs);
 401
 402         ubifs_assert(!(*offs & 7));
 403         empty_offs = ALIGN(*offs, c->min_io_size);
 404         pad_len = empty_offs - *offs;
 405         ubifs_pad(c, *buf, pad_len);
 406         *offs += pad_len;
 407         *buf += pad_len;
 408         *len -= pad_len;
 409         memset(*buf, 0xff, c->leb_size - empty_offs);
 410 }
 411
 412 /**
 413  * no_more_nodes - determine if there are no more nodes in a buffer.
 414  * @c: UBIFS file-system description object
 415  * @buf: buffer to check
 416  * @len: length of buffer
 417  * @lnum: LEB number of the LEB from which @buf was read
 418  * @offs: offset from which @buf was read
 419  *
 420  * This function ensures that the corrupted node at @offs is the last thing
 421  * written to a LEB. This function returns %1 if more data is not found and
 422  * %0 if more data is found.
 423  */
 424 static int no_more_nodes(const struct ubifs_info *c, void *buf, int len,
 425                         int lnum, int offs)
 426 {
 427         struct ubifs_ch *ch = buf;
 428         int skip, dlen = le32_to_cpu(ch->len);
 429
 430         /* Check for empty space after the corrupt node's common header */
 431         skip = ALIGN(offs + UBIFS_CH_SZ, c->min_io_size) - offs;
 432         if (is_empty(buf + skip, len - skip))
 433                 return 1;
 434         /*
 435          * The area after the common header size is not empty, so the common
 436          * header must be intact. Check it.
 437          */
 438         if (ubifs_check_node(c, buf, lnum, offs, 1, 0) != -EUCLEAN) {
 439                 dbg_rcvry("unexpected bad common header at %d:%d", lnum, offs);
 440                 return 0;
 441         }
 442         /* Now we know the corrupt node's length we can skip over it */
 443         skip = ALIGN(offs + dlen, c->min_io_size) - offs;
 444         /* After which there should be empty space */
 445         if (is_empty(buf + skip, len - skip))
 446                 return 1;
 447         dbg_rcvry("unexpected data at %d:%d", lnum, offs + skip);
 448         return 0;
 449 }
 450
 451 /**
 452  * fix_unclean_leb - fix an unclean LEB.
 453  * @c: UBIFS file-system description object
 454  * @sleb: scanned LEB information
 455  * @start: offset where scan started
 456  */
 457 static int fix_unclean_leb(struct ubifs_info *c, struct ubifs_scan_leb *sleb,
 458                            int start)
 459 {
 460         int lnum = sleb->lnum, endpt = start;
 461
 462         /* Get the end offset of the last node we are keeping */
 463         if (!list_empty(&sleb->nodes)) {
 464                 struct ubifs_scan_node *snod;
 465
 466                 snod = list_entry(sleb->nodes.prev,
 467                                   struct ubifs_scan_node, list);
 468                 endpt = snod->offs + snod->len;
 469         }
 470
 471         if ((c->vfs_sb->s_flags & MS_RDONLY) && !c->remounting_rw) {
 472                 /* Add to recovery list */
 473                 struct ubifs_unclean_leb *ucleb;
 474
 475                 dbg_rcvry("need to fix LEB %d start %d endpt %d",
 476                           lnum, start, sleb->endpt);
 477                 ucleb = kzalloc(sizeof(struct ubifs_unclean_leb), GFP_NOFS);
 478                 if (!ucleb)
 479                         return -ENOMEM;
 480                 ucleb->lnum = lnum;
 481                 ucleb->endpt = endpt;
 482                 list_add_tail(&ucleb->list, &c->unclean_leb_list);
 483         } else {
 484                 /* Write the fixed LEB back to flash */
 485                 int err;
 486
 487                 dbg_rcvry("fixing LEB %d start %d endpt %d",
 488                           lnum, start, sleb->endpt);
 489                 if (endpt == 0) {
 490                         err = ubifs_leb_unmap(c, lnum);
 491                         if (err)
 492                                 return err;
 493                 } else {
 494                         int len = ALIGN(endpt, c->min_io_size);
 495
 496                         if (start) {
 497                                 err = ubi_read(c->ubi, lnum, sleb->buf, 0,
 498                                                start);
 499                                 if (err)
 500                                         return err;
 501                         }
 502                         /* Pad to min_io_size */
 503                         if (len > endpt) {
 504                                 int pad_len = len - ALIGN(endpt, 8);
 505
 506                                 if (pad_len > 0) {
 507                                         void *buf = sleb->buf + len - pad_len;
 508
 509                                         ubifs_pad(c, buf, pad_len);
 510                                 }
 511                         }
 512                         err = ubi_leb_change(c->ubi, lnum, sleb->buf, len,
 513                                              UBI_UNKNOWN);
 514                         if (err)
 515                                 return err;
 516                 }
 517         }
 518         return 0;
 519 }
 520
 521 /**
 522  * drop_incomplete_group - drop nodes from an incomplete group.
 523  * @sleb: scanned LEB information
 524  * @offs: offset of dropped nodes is returned here
 525  *
 526  * This function returns %1 if nodes are dropped and %0 otherwise.
 527  */
 528 static int drop_incomplete_group(struct ubifs_scan_leb *sleb, int *offs)
 529 {
 530         int dropped = 0;
 531
 532         while (!list_empty(&sleb->nodes)) {
 533                 struct ubifs_scan_node *snod;
 534                 struct ubifs_ch *ch;
 535
 536                 snod = list_entry(sleb->nodes.prev, struct ubifs_scan_node,
 537                                   list);
 538                 ch = snod->node;
 539                 if (ch->group_type != UBIFS_IN_NODE_GROUP)
 540                         return dropped;
 541                 dbg_rcvry("dropping node at %d:%d", sleb->lnum, snod->offs);
 542                 *offs = snod->offs;
 543                 list_del(&snod->list);
 544                 kfree(snod);
 545                 sleb->nodes_cnt -= 1;
 546                 dropped = 1;
 547         }
 548         return dropped;
 549 }
 550
 551 /**
 552  * ubifs_recover_leb - scan and recover a LEB.
 553  * @c: UBIFS file-system description object
 554  * @lnum: LEB number
 555  * @offs: offset
 556  * @sbuf: LEB-sized buffer to use
 557  * @grouped: nodes may be grouped for recovery
 558  *
 559  * This function does a scan of a LEB, but caters for errors that might have
 560  * been caused by the unclean unmount from which we are attempting to recover.
 561  * Returns %0 in case of success, %-EUCLEAN if an unrecoverable corruption is
 562  * found, and a negative error code in case of failure.
 563  */
 564 struct ubifs_scan_leb *ubifs_recover_leb(struct ubifs_info *c, int lnum,
 565                                          int offs, void *sbuf, int grouped)
 566 {
 567         int err, len = c->leb_size - offs, need_clean = 0, quiet = 1;
 568         int empty_chkd = 0, start = offs;
 569         struct ubifs_scan_leb *sleb;
 570         void *buf = sbuf + offs;
 571
 572         dbg_rcvry("%d:%d", lnum, offs);
 573
 574         sleb = ubifs_start_scan(c, lnum, offs, sbuf);
 575         if (IS_ERR(sleb))
 576                 return sleb;
 577
 578         if (sleb->ecc)
 579                 need_clean = 1;
 580
 581         while (len >= 8) {
 582                 int ret;
 583
 584                 dbg_scan("look at LEB %d:%d (%d bytes left)",
 585                          lnum, offs, len);
 586
 587                 cond_resched();
 588
 589                 /*
 590                  * Scan quietly until there is an error from which we cannot
 591                  * recover
 592                  */
 593                 ret = ubifs_scan_a_node(c, buf, len, lnum, offs, quiet);
 594
 595                 if (ret == SCANNED_A_NODE) {
 596                         /* A valid node, and not a padding node */
 597                         struct ubifs_ch *ch = buf;
 598                         int node_len;
 599
 600                         err = ubifs_add_snod(c, sleb, buf, offs);
 601                         if (err)
 602                                 goto error;
 603                         node_len = ALIGN(le32_to_cpu(ch->len), 8);
 604                         offs += node_len;
 605                         buf += node_len;
 606                         len -= node_len;
 607                         continue;
 608                 }
 609
 610                 if (ret > 0) {
 611                         /* Padding bytes or a valid padding node */
 612                         offs += ret;
 613                         buf += ret;
 614                         len -= ret;
 615                         continue;
 616                 }
 617
 618                 if (ret == SCANNED_EMPTY_SPACE) {
 619                         if (!is_empty(buf, len)) {
 620                                 if (!is_last_write(c, buf, offs))
 621                                         break;
 622                                 clean_buf(c, &buf, lnum, &offs, &len);
 623                                 need_clean = 1;
 624                         }
 625                         empty_chkd = 1;
 626                         break;
 627                 }
 628
 629                 if (ret == SCANNED_GARBAGE || ret == SCANNED_A_BAD_PAD_NODE)
 630                         if (is_last_write(c, buf, offs)) {
 631                                 clean_buf(c, &buf, lnum, &offs, &len);
 632                                 need_clean = 1;
 633                                 empty_chkd = 1;
 634                                 break;
 635                         }
 636
 637                 if (ret == SCANNED_A_CORRUPT_NODE)
 638                         if (no_more_nodes(c, buf, len, lnum, offs)) {
 639                                 clean_buf(c, &buf, lnum, &offs, &len);
 640                                 need_clean = 1;
 641                                 empty_chkd = 1;
 642                                 break;
 643                         }
 644
 645                 if (quiet) {
 646                         /* Redo the last scan but noisily */
 647                         quiet = 0;
 648                         continue;
 649                 }
 650
 651                 switch (ret) {
 652                 case SCANNED_GARBAGE:
 653                         dbg_err("garbage");
 654                         goto corrupted;
 655                 case SCANNED_A_CORRUPT_NODE:
 656                 case SCANNED_A_BAD_PAD_NODE:
 657                         dbg_err("bad node");
 658                         goto corrupted;
 659                 default:
 660                         dbg_err("unknown");
 661                         err = -EINVAL;
 662                         goto error;
 663                 }
 664         }
 665
 666         if (!empty_chkd && !is_empty(buf, len)) {
 667                 if (is_last_write(c, buf, offs)) {
 668                         clean_buf(c, &buf, lnum, &offs, &len);
 669                         need_clean = 1;
 670                 } else {
 671                         int corruption = first_non_ff(buf, len);
 672
 673                         ubifs_err("corrupt empty space LEB %d:%d, corruption "
 674                                   "starts at %d", lnum, offs, corruption);
 675                         /* Make sure we dump interesting non-0xFF data */
 676                         offs = corruption;
 677                         buf += corruption;
 678                         goto corrupted;
 679                 }
 680         }
 681
 682         /* Drop nodes from incomplete group */
 683         if (grouped && drop_incomplete_group(sleb, &offs)) {
 684                 buf = sbuf + offs;
 685                 len = c->leb_size - offs;
 686                 clean_buf(c, &buf, lnum, &offs, &len);
 687                 need_clean = 1;
 688         }
 689
 690         if (offs % c->min_io_size) {
 691                 clean_buf(c, &buf, lnum, &offs, &len);
 692                 need_clean = 1;
 693         }
 694
 695         ubifs_end_scan(c, sleb, lnum, offs);
 696
 697         if (need_clean) {
 698                 err = fix_unclean_leb(c, sleb, start);
 699                 if (err)
 700                         goto error;
 701         }
 702
 703         return sleb;
 704
 705 corrupted:
 706         ubifs_scanned_corruption(c, lnum, offs, buf);
 707         err = -EUCLEAN;
 708 error:
 709         ubifs_err("LEB %d scanning failed", lnum);
 710         ubifs_scan_destroy(sleb);
 711         return ERR_PTR(err);
 712 }
 713
 714 /**
 715  * get_cs_sqnum - get commit start sequence number.
 716  * @c: UBIFS file-system description object
 717  * @lnum: LEB number of commit start node
 718  * @offs: offset of commit start node
 719  * @cs_sqnum: commit start sequence number is returned here
 720  *
 721  * This function returns %0 on success and a negative error code on failure.
 722  */
 723 static int get_cs_sqnum(struct ubifs_info *c, int lnum, int offs,
 724                         unsigned long long *cs_sqnum)
 725 {
 726         struct ubifs_cs_node *cs_node = NULL;
 727         int err, ret;
 728
 729         dbg_rcvry("at %d:%d", lnum, offs);
 730         cs_node = kmalloc(UBIFS_CS_NODE_SZ, GFP_KERNEL);
 731         if (!cs_node)
 732                 return -ENOMEM;
 733         if (c->leb_size - offs < UBIFS_CS_NODE_SZ)
 734                 goto out_err;
 735         err = ubi_read(c->ubi, lnum, (void *)cs_node, offs, UBIFS_CS_NODE_SZ);
 736         if (err && err != -EBADMSG)
 737                 goto out_free;
 738         ret = ubifs_scan_a_node(c, cs_node, UBIFS_CS_NODE_SZ, lnum, offs, 0);
 739         if (ret != SCANNED_A_NODE) {
 740                 dbg_err("Not a valid node");
 741                 goto out_err;
 742         }
 743         if (cs_node->ch.node_type != UBIFS_CS_NODE) {
 744                 dbg_err("Node a CS node, type is %d", cs_node->ch.node_type);
 745                 goto out_err;
 746         }
 747         if (le64_to_cpu(cs_node->cmt_no) != c->cmt_no) {
 748                 dbg_err("CS node cmt_no %llu != current cmt_no %llu",
 749                         (unsigned long long)le64_to_cpu(cs_node->cmt_no),
 750                         c->cmt_no);
 751                 goto out_err;
 752         }
 753         *cs_sqnum = le64_to_cpu(cs_node->ch.sqnum);
 754         dbg_rcvry("commit start sqnum %llu", *cs_sqnum);
 755         kfree(cs_node);
 756         return 0;
 757
 758 out_err:
 759         err = -EINVAL;
 760 out_free:
 761         ubifs_err("failed to get CS sqnum");
 762         kfree(cs_node);
 763         return err;
 764 }
 765
 766 /**
 767  * ubifs_recover_log_leb - scan and recover a log LEB.
 768  * @c: UBIFS file-system description object
 769  * @lnum: LEB number
 770  * @offs: offset
 771  * @sbuf: LEB-sized buffer to use
 772  *
 773  * This function does a scan of a LEB, but caters for errors that might have
 774  * been caused by the unclean unmount from which we are attempting to recover.
 775  *
 776  * This function returns %0 on success and a negative error code on failure.
 777  */
 778 struct ubifs_scan_leb *ubifs_recover_log_leb(struct ubifs_info *c, int lnum,
 779                                              int offs, void *sbuf)
 780 {
 781         struct ubifs_scan_leb *sleb;
 782         int next_lnum;
 783
 784         dbg_rcvry("LEB %d", lnum);
 785         next_lnum = lnum + 1;
 786         if (next_lnum >= UBIFS_LOG_LNUM + c->log_lebs)
 787                 next_lnum = UBIFS_LOG_LNUM;
 788         if (next_lnum != c->ltail_lnum) {
 789                 /*
 790                  * We can only recover at the end of the log, so check that the
 791                  * next log LEB is empty or out of date.
 792                  */
 793                 sleb = ubifs_scan(c, next_lnum, 0, sbuf, 0);
 794                 if (IS_ERR(sleb))
 795                         return sleb;
 796                 if (sleb->nodes_cnt) {
 797                         struct ubifs_scan_node *snod;
 798                         unsigned long long cs_sqnum = c->cs_sqnum;
 799
 800                         snod = list_entry(sleb->nodes.next,
 801                                           struct ubifs_scan_node, list);
 802                         if (cs_sqnum == 0) {
 803                                 int err;
 804
 805                                 err = get_cs_sqnum(c, lnum, offs, &cs_sqnum);
 806                                 if (err) {
 807                                         ubifs_scan_destroy(sleb);
 808                                         return ERR_PTR(err);
 809                                 }
 810                         }
 811                         if (snod->sqnum > cs_sqnum) {
 812                                 ubifs_err("unrecoverable log corruption "
 813                                           "in LEB %d", lnum);
 814                                 ubifs_scan_destroy(sleb);
 815                                 return ERR_PTR(-EUCLEAN);
 816                         }
 817                 }
 818                 ubifs_scan_destroy(sleb);
 819         }
 820         return ubifs_recover_leb(c, lnum, offs, sbuf, 0);
 821 }
 822
 823 /**
 824  * recover_head - recover a head.
 825  * @c: UBIFS file-system description object
 826  * @lnum: LEB number of head to recover
 827  * @offs: offset of head to recover
 828  * @sbuf: LEB-sized buffer to use
 829  *
 830  * This function ensures that there is no data on the flash at a head location.
 831  *
 832  * This function returns %0 on success and a negative error code on failure.
 833  */
 834 static int recover_head(const struct ubifs_info *c, int lnum, int offs,
 835                         void *sbuf)
 836 {
 837         int len, err;
 838
 839         if (c->min_io_size > 1)
 840                 len = c->min_io_size;
 841         else
 842                 len = 512;
 843         if (offs + len > c->leb_size)
 844                 len = c->leb_size - offs;
 845
 846         if (!len)
 847                 return 0;
 848
 849         /* Read at the head location and check it is empty flash */
 850         err = ubi_read(c->ubi, lnum, sbuf, offs, len);
 851         if (err || !is_empty(sbuf, len)) {
 852                 dbg_rcvry("cleaning head at %d:%d", lnum, offs);
 853                 if (offs == 0)
 854                         return ubifs_leb_unmap(c, lnum);
 855                 err = ubi_read(c->ubi, lnum, sbuf, 0, offs);
 856                 if (err)
 857                         return err;
 858                 return ubi_leb_change(c->ubi, lnum, sbuf, offs, UBI_UNKNOWN);
 859         }
 860
 861         return 0;
 862 }
 863
 864 /**
 865  * ubifs_recover_inl_heads - recover index and LPT heads.
 866  * @c: UBIFS file-system description object
 867  * @sbuf: LEB-sized buffer to use
 868  *
 869  * This function ensures that there is no data on the flash at the index and
 870  * LPT head locations.
 871  *
 872  * This deals with the recovery of a half-completed journal commit. UBIFS is
 873  * careful never to overwrite the last version of the index or the LPT. Because
 874  * the index and LPT are wandering trees, data from a half-completed commit will
 875  * not be referenced anywhere in UBIFS. The data will be either in LEBs that are
 876  * assumed to be empty and will be unmapped anyway before use, or in the index
 877  * and LPT heads.
 878  *
 879  * This function returns %0 on success and a negative error code on failure.
 880  */
 881 int ubifs_recover_inl_heads(const struct ubifs_info *c, void *sbuf)
 882 {
 883         int err;
 884
 885         ubifs_assert(!(c->vfs_sb->s_flags & MS_RDONLY) || c->remounting_rw);
 886
 887         dbg_rcvry("checking index head at %d:%d", c->ihead_lnum, c->ihead_offs);
 888         err = recover_head(c, c->ihead_lnum, c->ihead_offs, sbuf);
 889         if (err)
 890                 return err;
 891
 892         dbg_rcvry("checking LPT head at %d:%d", c->nhead_lnum, c->nhead_offs);
 893         err = recover_head(c, c->nhead_lnum, c->nhead_offs, sbuf);
 894         if (err)
 895                 return err;
 896
 897         return 0;
 898 }
 899
 900 /**
 901  *  clean_an_unclean_leb - read and write a LEB to remove corruption.
 902  * @c: UBIFS file-system description object
 903  * @ucleb: unclean LEB information
 904  * @sbuf: LEB-sized buffer to use
 905  *
 906  * This function reads a LEB up to a point pre-determined by the mount recovery,
 907  * checks the nodes, and writes the result back to the flash, thereby cleaning
 908  * off any following corruption, or non-fatal ECC errors.
 909  *
 910  * This function returns %0 on success and a negative error code on failure.
 911  */
 912 static int clean_an_unclean_leb(const struct ubifs_info *c,
 913                                 struct ubifs_unclean_leb *ucleb, void *sbuf)
 914 {
 915         int err, lnum = ucleb->lnum, offs = 0, len = ucleb->endpt, quiet = 1;
 916         void *buf = sbuf;
 917
 918         dbg_rcvry("LEB %d len %d", lnum, len);
 919
 920         if (len == 0) {
 921                 /* Nothing to read, just unmap it */
 922                 err = ubifs_leb_unmap(c, lnum);
 923                 if (err)
 924                         return err;
 925                 return 0;
 926         }
 927
 928         err = ubi_read(c->ubi, lnum, buf, offs, len);
 929         if (err && err != -EBADMSG)
 930                 return err;
 931
 932         while (len >= 8) {
 933                 int ret;
 934
 935                 cond_resched();
 936
 937                 /* Scan quietly until there is an error */
 938                 ret = ubifs_scan_a_node(c, buf, len, lnum, offs, quiet);
 939
 940                 if (ret == SCANNED_A_NODE) {
 941                         /* A valid node, and not a padding node */
 942                         struct ubifs_ch *ch = buf;
 943                         int node_len;
 944
 945                         node_len = ALIGN(le32_to_cpu(ch->len), 8);
 946                         offs += node_len;
 947                         buf += node_len;
 948                         len -= node_len;
 949                         continue;
 950                 }
 951
 952                 if (ret > 0) {
 953                         /* Padding bytes or a valid padding node */
 954                         offs += ret;
 955                         buf += ret;
 956                         len -= ret;
 957                         continue;
 958                 }
 959
 960                 if (ret == SCANNED_EMPTY_SPACE) {
 961                         ubifs_err("unexpected empty space at %d:%d",
 962                                   lnum, offs);
 963                         return -EUCLEAN;
 964                 }
 965
 966                 if (quiet) {
 967                         /* Redo the last scan but noisily */
 968                         quiet = 0;
 969                         continue;
 970                 }
 971
 972                 ubifs_scanned_corruption(c, lnum, offs, buf);
 973                 return -EUCLEAN;
 974         }
 975
 976         /* Pad to min_io_size */
 977         len = ALIGN(ucleb->endpt, c->min_io_size);
 978         if (len > ucleb->endpt) {
 979                 int pad_len = len - ALIGN(ucleb->endpt, 8);
 980
 981                 if (pad_len > 0) {
 982                         buf = c->sbuf + len - pad_len;
 983                         ubifs_pad(c, buf, pad_len);
 984                 }
 985         }
 986
 987         /* Write back the LEB atomically */
 988         err = ubi_leb_change(c->ubi, lnum, sbuf, len, UBI_UNKNOWN);
 989         if (err)
 990                 return err;
 991
 992         dbg_rcvry("cleaned LEB %d", lnum);
 993
 994         return 0;
 995 }
 996
 997 /**
 998  * ubifs_clean_lebs - clean LEBs recovered during read-only mount.
 999  * @c: UBIFS file-system description object
1000  * @sbuf: LEB-sized buffer to use
1001  *
1002  * This function cleans a LEB identified during recovery that needs to be
1003  * written but was not because UBIFS was mounted read-only. This happens when
1004  * remounting to read-write mode.
1005  *
1006  * This function returns %0 on success and a negative error code on failure.
1007  */
1008 int ubifs_clean_lebs(const struct ubifs_info *c, void *sbuf)
1009 {
1010         dbg_rcvry("recovery");
1011         while (!list_empty(&c->unclean_leb_list)) {
1012                 struct ubifs_unclean_leb *ucleb;
1013                 int err;
1014
1015                 ucleb = list_entry(c->unclean_leb_list.next,
1016                                    struct ubifs_unclean_leb, list);
1017                 err = clean_an_unclean_leb(c, ucleb, sbuf);
1018                 if (err)
1019                         return err;
1020                 list_del(&ucleb->list);
1021                 kfree(ucleb);
1022         }
1023         return 0;
1024 }
1025
1026 /**
1027  * ubifs_rcvry_gc_commit - recover the GC LEB number and run the commit.
1028  * @c: UBIFS file-system description object
1029  *
1030  * Out-of-place garbage collection requires always one empty LEB with which to
1031  * start garbage collection. The LEB number is recorded in c->gc_lnum and is
1032  * written to the master node on unmounting. In the case of an unclean unmount
1033  * the value of gc_lnum recorded in the master node is out of date and cannot
1034  * be used. Instead, recovery must allocate an empty LEB for this purpose.
1035  * However, there may not be enough empty space, in which case it must be
1036  * possible to GC the dirtiest LEB into the GC head LEB.
1037  *
1038  * This function also runs the commit which causes the TNC updates from
1039  * size-recovery and orphans to be written to the flash. That is important to
1040  * ensure correct replay order for subsequent mounts.
1041  *
1042  * This function returns %0 on success and a negative error code on failure.
1043  */
1044 int ubifs_rcvry_gc_commit(struct ubifs_info *c)
1045 {
1046         struct ubifs_wbuf *wbuf = &c->jheads[GCHD].wbuf;
1047         struct ubifs_lprops lp;
1048         int lnum, err;
1049
1050         c->gc_lnum = -1;
1051         if (wbuf->lnum == -1) {
1052                 dbg_rcvry("no GC head LEB");
1053                 goto find_free;
1054         }
1055         /*
1056          * See whether the used space in the dirtiest LEB fits in the GC head
1057          * LEB.
1058          */
1059         if (wbuf->offs == c->leb_size) {
1060                 dbg_rcvry("no room in GC head LEB");
1061                 goto find_free;
1062         }
1063         err = ubifs_find_dirty_leb(c, &lp, wbuf->offs, 2);
1064         if (err) {
1065                 if (err == -ENOSPC)
1066                         dbg_err("could not find a dirty LEB");
1067                 return err;
1068         }
1069         ubifs_assert(!(lp.flags & LPROPS_INDEX));
1070         lnum = lp.lnum;
1071         if (lp.free + lp.dirty == c->leb_size) {
1072                 /* An empty LEB was returned */
1073                 if (lp.free != c->leb_size) {
1074                         err = ubifs_change_one_lp(c, lnum, c->leb_size,
1075                                                   0, 0, 0, 0);
1076                         if (err)
1077                                 return err;
1078                 }
1079                 err = ubifs_leb_unmap(c, lnum);
1080                 if (err)
1081                         return err;
1082                 c->gc_lnum = lnum;
1083                 dbg_rcvry("allocated LEB %d for GC", lnum);
1084                 /* Run the commit */
1085                 dbg_rcvry("committing");
1086                 return ubifs_run_commit(c);
1087         }
1088         /*
1089          * There was no empty LEB so the used space in the dirtiest LEB must fit
1090          * in the GC head LEB.
1091          */
1092         if (lp.free + lp.dirty < wbuf->offs) {
1093                 dbg_rcvry("LEB %d doesn't fit in GC head LEB %d:%d",
1094                           lnum, wbuf->lnum, wbuf->offs);
1095                 err = ubifs_return_leb(c, lnum);
1096                 if (err)
1097                         return err;
1098                 goto find_free;
1099         }
1100         /*
1101          * We run the commit before garbage collection otherwise subsequent
1102          * mounts will see the GC and orphan deletion in a different order.
1103          */
1104         dbg_rcvry("committing");
1105         err = ubifs_run_commit(c);
1106         if (err)
1107                 return err;
1108         /*
1109          * The data in the dirtiest LEB fits in the GC head LEB, so do the GC
1110          * - use locking to keep 'ubifs_assert()' happy.
1111          */
1112         dbg_rcvry("GC'ing LEB %d", lnum);
1113         mutex_lock_nested(&wbuf->io_mutex, wbuf->jhead);
1114         err = ubifs_garbage_collect_leb(c, &lp);
1115         if (err >= 0) {
1116                 int err2 = ubifs_wbuf_sync_nolock(wbuf);
1117
1118                 if (err2)
1119                         err = err2;
1120         }
1121         mutex_unlock(&wbuf->io_mutex);
1122         if (err < 0) {
1123                 dbg_err("GC failed, error %d", err);
1124                 if (err == -EAGAIN)
1125                         err = -EINVAL;
1126                 return err;
1127         }
1128         if (err != LEB_RETAINED) {
1129                 dbg_err("GC returned %d", err);
1130                 return -EINVAL;
1131         }
1132         err = ubifs_leb_unmap(c, c->gc_lnum);
1133         if (err)
1134                 return err;
1135         dbg_rcvry("allocated LEB %d for GC", lnum);
1136         return 0;
1137
1138 find_free:
1139         /*
1140          * There is no GC head LEB or the free space in the GC head LEB is too
1141          * small. Allocate gc_lnum by calling 'ubifs_find_free_leb_for_idx()' so
1142          * GC is not run.
1143          */
1144         lnum = ubifs_find_free_leb_for_idx(c);
1145         if (lnum < 0) {
1146                 dbg_err("could not find an empty LEB");
1147                 return lnum;
1148         }
1149         /* And reset the index flag */
1150         err = ubifs_change_one_lp(c, lnum, LPROPS_NC, LPROPS_NC, 0,
1151                                   LPROPS_INDEX, 0);
1152         if (err)
1153                 return err;
1154         c->gc_lnum = lnum;
1155         dbg_rcvry("allocated LEB %d for GC", lnum);
1156         /* Run the commit */
1157         dbg_rcvry("committing");
1158         return ubifs_run_commit(c);
1159 }
1160
1161 /**
1162  * struct size_entry - inode size information for recovery.
1163  * @rb: link in the RB-tree of sizes
1164  * @inum: inode number
1165  * @i_size: size on inode
1166  * @d_size: maximum size based on data nodes
1167  * @exists: indicates whether the inode exists
1168  * @inode: inode if pinned in memory awaiting rw mode to fix it
1169  */
1170 struct size_entry {
1171         struct rb_node rb;
1172         ino_t inum;
1173         loff_t i_size;
1174         loff_t d_size;
1175         int exists;
1176         struct inode *inode;
1177 };
1178
1179 /**
1180  * add_ino - add an entry to the size tree.
1181  * @c: UBIFS file-system description object
1182  * @inum: inode number
1183  * @i_size: size on inode
1184  * @d_size: maximum size based on data nodes
1185  * @exists: indicates whether the inode exists
1186  */
1187 static int add_ino(struct ubifs_info *c, ino_t inum, loff_t i_size,
1188                    loff_t d_size, int exists)
1189 {
1190         struct rb_node **p = &c->size_tree.rb_node, *parent = NULL;
1191         struct size_entry *e;
1192
1193         while (*p) {
1194                 parent = *p;
1195                 e = rb_entry(parent, struct size_entry, rb);
1196                 if (inum < e->inum)
1197                         p = &(*p)->rb_left;
1198                 else
1199                         p = &(*p)->rb_right;
1200         }
1201
1202         e = kzalloc(sizeof(struct size_entry), GFP_KERNEL);
1203         if (!e)
1204                 return -ENOMEM;
1205
1206         e->inum = inum;
1207         e->i_size = i_size;
1208         e->d_size = d_size;
1209         e->exists = exists;
1210
1211         rb_link_node(&e->rb, parent, p);
1212         rb_insert_color(&e->rb, &c->size_tree);
1213
1214         return 0;
1215 }
1216
1217 /**
1218  * find_ino - find an entry on the size tree.
1219  * @c: UBIFS file-system description object
1220  * @inum: inode number
1221  */
1222 static struct size_entry *find_ino(struct ubifs_info *c, ino_t inum)
1223 {
1224         struct rb_node *p = c->size_tree.rb_node;
1225         struct size_entry *e;
1226
1227         while (p) {
1228                 e = rb_entry(p, struct size_entry, rb);
1229                 if (inum < e->inum)
1230                         p = p->rb_left;
1231                 else if (inum > e->inum)
1232                         p = p->rb_right;
1233                 else
1234                         return e;
1235         }
1236         return NULL;
1237 }
1238
1239 /**
1240  * remove_ino - remove an entry from the size tree.
1241  * @c: UBIFS file-system description object
1242  * @inum: inode number
1243  */
1244 static void remove_ino(struct ubifs_info *c, ino_t inum)
1245 {
1246         struct size_entry *e = find_ino(c, inum);
1247
1248         if (!e)
1249                 return;
1250         rb_erase(&e->rb, &c->size_tree);
1251         kfree(e);
1252 }
1253
1254 /**
1255  * ubifs_destroy_size_tree - free resources related to the size tree.
1256  * @c: UBIFS file-system description object
1257  */
1258 void ubifs_destroy_size_tree(struct ubifs_info *c)
1259 {
1260         struct rb_node *this = c->size_tree.rb_node;
1261         struct size_entry *e;
1262
1263         while (this) {
1264                 if (this->rb_left) {
1265                         this = this->rb_left;
1266                         continue;
1267                 } else if (this->rb_right) {
1268                         this = this->rb_right;
1269                         continue;
1270                 }
1271                 e = rb_entry(this, struct size_entry, rb);
1272                 if (e->inode)
1273                         iput(e->inode);
1274                 this = rb_parent(this);
1275                 if (this) {
1276                         if (this->rb_left == &e->rb)
1277                                 this->rb_left = NULL;
1278                         else
1279                                 this->rb_right = NULL;
1280                 }
1281                 kfree(e);
1282         }
1283         c->size_tree = RB_ROOT;
1284 }
1285
1286 /**
1287  * ubifs_recover_size_accum - accumulate inode sizes for recovery.
1288  * @c: UBIFS file-system description object
1289  * @key: node key
1290  * @deletion: node is for a deletion
1291  * @new_size: inode size
1292  *
1293  * This function has two purposes:
1294  *     1) to ensure there are no data nodes that fall outside the inode size
1295  *     2) to ensure there are no data nodes for inodes that do not exist
1296  * To accomplish those purposes, a rb-tree is constructed containing an entry
1297  * for each inode number in the journal that has not been deleted, and recording
1298  * the size from the inode node, the maximum size of any data node (also altered
1299  * by truncations) and a flag indicating a inode number for which no inode node
1300  * was present in the journal.
1301  *
1302  * Note that there is still the possibility that there are data nodes that have
1303  * been committed that are beyond the inode size, however the only way to find
1304  * them would be to scan the entire index. Alternatively, some provision could
1305  * be made to record the size of inodes at the start of commit, which would seem
1306  * very cumbersome for a scenario that is quite unlikely and the only negative
1307  * consequence of which is wasted space.
1308  *
1309  * This functions returns %0 on success and a negative error code on failure.
1310  */
1311 int ubifs_recover_size_accum(struct ubifs_info *c, union ubifs_key *key,
1312                              int deletion, loff_t new_size)
1313 {
1314         ino_t inum = key_inum(c, key);
1315         struct size_entry *e;
1316         int err;
1317
1318         switch (key_type(c, key)) {
1319         case UBIFS_INO_KEY:
1320                 if (deletion)
1321                         remove_ino(c, inum);
1322                 else {
1323                         e = find_ino(c, inum);
1324                         if (e) {
1325                                 e->i_size = new_size;
1326                                 e->exists = 1;
1327                         } else {
1328                                 err = add_ino(c, inum, new_size, 0, 1);
1329                                 if (err)
1330                                         return err;
1331                         }
1332                 }
1333                 break;
1334         case UBIFS_DATA_KEY:
1335                 e = find_ino(c, inum);
1336                 if (e) {
1337                         if (new_size > e->d_size)
1338                                 e->d_size = new_size;
1339                 } else {
1340                         err = add_ino(c, inum, 0, new_size, 0);
1341                         if (err)
1342                                 return err;
1343                 }
1344                 break;
1345         case UBIFS_TRUN_KEY:
1346                 e = find_ino(c, inum);
1347                 if (e)
1348                         e->d_size = new_size;
1349                 break;
1350         }
1351         return 0;
1352 }
1353
1354 /**
1355  * fix_size_in_place - fix inode size in place on flash.
1356  * @c: UBIFS file-system description object
1357  * @e: inode size information for recovery
1358  */
1359 static int fix_size_in_place(struct ubifs_info *c, struct size_entry *e)
1360 {
1361         struct ubifs_ino_node *ino = c->sbuf;
1362         unsigned char *p;
1363         union ubifs_key key;
1364         int err, lnum, offs, len;
1365         loff_t i_size;
1366         uint32_t crc;
1367
1368         /* Locate the inode node LEB number and offset */
1369         ino_key_init(c, &key, e->inum);
1370         err = ubifs_tnc_locate(c, &key, ino, &lnum, &offs);
1371         if (err)
1372                 goto out;
1373         /*
1374          * If the size recorded on the inode node is greater than the size that
1375          * was calculated from nodes in the journal then don't change the inode.
1376          */
1377         i_size = le64_to_cpu(ino->size);
1378         if (i_size >= e->d_size)
1379                 return 0;
1380         /* Read the LEB */
1381         err = ubi_read(c->ubi, lnum, c->sbuf, 0, c->leb_size);
1382         if (err)
1383                 goto out;
1384         /* Change the size field and recalculate the CRC */
1385         ino = c->sbuf + offs;
1386         ino->size = cpu_to_le64(e->d_size);
1387         len = le32_to_cpu(ino->ch.len);
1388         crc = crc32(UBIFS_CRC32_INIT, (void *)ino + 8, len - 8);
1389         ino->ch.crc = cpu_to_le32(crc);
1390         /* Work out where data in the LEB ends and free space begins */
1391         p = c->sbuf;
1392         len = c->leb_size - 1;
1393         while (p[len] == 0xff)
1394                 len -= 1;
1395         len = ALIGN(len + 1, c->min_io_size);
1396         /* Atomically write the fixed LEB back again */
1397         err = ubi_leb_change(c->ubi, lnum, c->sbuf, len, UBI_UNKNOWN);
1398         if (err)
1399                 goto out;
1400         dbg_rcvry("inode %lu at %d:%d size %lld -> %lld ",
1401                   (unsigned long)e->inum, lnum, offs, i_size, e->d_size);
1402         return 0;
1403
1404 out:
1405         ubifs_warn("inode %lu failed to fix size %lld -> %lld error %d",
1406                    (unsigned long)e->inum, e->i_size, e->d_size, err);
1407         return err;
1408 }
1409
1410 /**
1411  * ubifs_recover_size - recover inode size.
1412  * @c: UBIFS file-system description object
1413  *
1414  * This function attempts to fix inode size discrepancies identified by the
1415  * 'ubifs_recover_size_accum()' function.
1416  *
1417  * This functions returns %0 on success and a negative error code on failure.
1418  */
1419 int ubifs_recover_size(struct ubifs_info *c)
1420 {
1421         struct rb_node *this = rb_first(&c->size_tree);
1422
1423         while (this) {
1424                 struct size_entry *e;
1425                 int err;
1426
1427                 e = rb_entry(this, struct size_entry, rb);
1428                 if (!e->exists) {
1429                         union ubifs_key key;
1430
1431                         ino_key_init(c, &key, e->inum);
1432                         err = ubifs_tnc_lookup(c, &key, c->sbuf);
1433                         if (err && err != -ENOENT)
1434                                 return err;
1435                         if (err == -ENOENT) {
1436                                 /* Remove data nodes that have no inode */
1437                                 dbg_rcvry("removing ino %lu",
1438                                           (unsigned long)e->inum);
1439                                 err = ubifs_tnc_remove_ino(c, e->inum);
1440                                 if (err)
1441                                         return err;
1442                         } else {
1443                                 struct ubifs_ino_node *ino = c->sbuf;
1444
1445                                 e->exists = 1;
1446                                 e->i_size = le64_to_cpu(ino->size);
1447                         }
1448                 }
1449                 if (e->exists && e->i_size < e->d_size) {
1450                         if (!e->inode && (c->vfs_sb->s_flags & MS_RDONLY)) {
1451                                 /* Fix the inode size and pin it in memory */
1452                                 struct inode *inode;
1453
1454                                 inode = ubifs_iget(c->vfs_sb, e->inum);
1455                                 if (IS_ERR(inode))
1456                                         return PTR_ERR(inode);
1457                                 if (inode->i_size < e->d_size) {
1458                                         dbg_rcvry("ino %lu size %lld -> %lld",
1459                                                   (unsigned long)e->inum,
1460                                                   e->d_size, inode->i_size);
1461                                         inode->i_size = e->d_size;
1462                                         ubifs_inode(inode)->ui_size = e->d_size;
1463                                         e->inode = inode;
1464                                         this = rb_next(this);
1465                                         continue;
1466                                 }
1467                                 iput(inode);
1468                         } else {
1469                                 /* Fix the size in place */
1470                                 err = fix_size_in_place(c, e);
1471                                 if (err)
1472                                         return err;
1473                                 if (e->inode)
1474                                         iput(e->inode);
1475                         }
1476                 }
1477                 this = rb_next(this);
1478                 rb_erase(&e->rb, &c->size_tree);
1479                 kfree(e);
1480         }
1481         return 0;
1482 }