fs/ubifs/lpt_commit.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 commit-related functionality of the LEB properties
  25  * subsystem.
  26  */
  27
  28 #include <linux/crc16.h>
  29 #include "ubifs.h"
  30
  31 /**
  32  * first_dirty_cnode - find first dirty cnode.
  33  * @c: UBIFS file-system description object
  34  * @nnode: nnode at which to start
  35  *
  36  * This function returns the first dirty cnode or %NULL if there is not one.
  37  */
  38 static struct ubifs_cnode *first_dirty_cnode(struct ubifs_nnode *nnode)
  39 {
  40         ubifs_assert(nnode);
  41         while (1) {
  42                 int i, cont = 0;
  43
  44                 for (i = 0; i < UBIFS_LPT_FANOUT; i++) {
  45                         struct ubifs_cnode *cnode;
  46
  47                         cnode = nnode->nbranch[i].cnode;
  48                         if (cnode &&
  49                             test_bit(DIRTY_CNODE, &cnode->flags)) {
  50                                 if (cnode->level == 0)
  51                                         return cnode;
  52                                 nnode = (struct ubifs_nnode *)cnode;
  53                                 cont = 1;
  54                                 break;
  55                         }
  56                 }
  57                 if (!cont)
  58                         return (struct ubifs_cnode *)nnode;
  59         }
  60 }
  61
  62 /**
  63  * next_dirty_cnode - find next dirty cnode.
  64  * @cnode: cnode from which to begin searching
  65  *
  66  * This function returns the next dirty cnode or %NULL if there is not one.
  67  */
  68 static struct ubifs_cnode *next_dirty_cnode(struct ubifs_cnode *cnode)
  69 {
  70         struct ubifs_nnode *nnode;
  71         int i;
  72
  73         ubifs_assert(cnode);
  74         nnode = cnode->parent;
  75         if (!nnode)
  76                 return NULL;
  77         for (i = cnode->iip + 1; i < UBIFS_LPT_FANOUT; i++) {
  78                 cnode = nnode->nbranch[i].cnode;
  79                 if (cnode && test_bit(DIRTY_CNODE, &cnode->flags)) {
  80                         if (cnode->level == 0)
  81                                 return cnode; /* cnode is a pnode */
  82                         /* cnode is a nnode */
  83                         return first_dirty_cnode((struct ubifs_nnode *)cnode);
  84                 }
  85         }
  86         return (struct ubifs_cnode *)nnode;
  87 }
  88
  89 /**
  90  * get_cnodes_to_commit - create list of dirty cnodes to commit.
  91  * @c: UBIFS file-system description object
  92  *
  93  * This function returns the number of cnodes to commit.
  94  */
  95 static int get_cnodes_to_commit(struct ubifs_info *c)
  96 {
  97         struct ubifs_cnode *cnode, *cnext;
  98         int cnt = 0;
  99
 100         if (!c->nroot)
 101                 return 0;
 102
 103         if (!test_bit(DIRTY_CNODE, &c->nroot->flags))
 104                 return 0;
 105
 106         c->lpt_cnext = first_dirty_cnode(c->nroot);
 107         cnode = c->lpt_cnext;
 108         if (!cnode)
 109                 return 0;
 110         cnt += 1;
 111         while (1) {
 112                 ubifs_assert(!test_bit(COW_ZNODE, &cnode->flags));
 113                 __set_bit(COW_ZNODE, &cnode->flags);
 114                 cnext = next_dirty_cnode(cnode);
 115                 if (!cnext) {
 116                         cnode->cnext = c->lpt_cnext;
 117                         break;
 118                 }
 119                 cnode->cnext = cnext;
 120                 cnode = cnext;
 121                 cnt += 1;
 122         }
 123         dbg_cmt("committing %d cnodes", cnt);
 124         dbg_lp("committing %d cnodes", cnt);
 125         ubifs_assert(cnt == c->dirty_nn_cnt + c->dirty_pn_cnt);
 126         return cnt;
 127 }
 128
 129 /**
 130  * upd_ltab - update LPT LEB properties.
 131  * @c: UBIFS file-system description object
 132  * @lnum: LEB number
 133  * @free: amount of free space
 134  * @dirty: amount of dirty space to add
 135  */
 136 static void upd_ltab(struct ubifs_info *c, int lnum, int free, int dirty)
 137 {
 138         dbg_lp("LEB %d free %d dirty %d to %d +%d",
 139                lnum, c->ltab[lnum - c->lpt_first].free,
 140                c->ltab[lnum - c->lpt_first].dirty, free, dirty);
 141         ubifs_assert(lnum >= c->lpt_first && lnum <= c->lpt_last);
 142         c->ltab[lnum - c->lpt_first].free = free;
 143         c->ltab[lnum - c->lpt_first].dirty += dirty;
 144 }
 145
 146 /**
 147  * alloc_lpt_leb - allocate an LPT LEB that is empty.
 148  * @c: UBIFS file-system description object
 149  * @lnum: LEB number is passed and returned here
 150  *
 151  * This function finds the next empty LEB in the ltab starting from @lnum. If a
 152  * an empty LEB is found it is returned in @lnum and the function returns %0.
 153  * Otherwise the function returns -ENOSPC.  Note however, that LPT is designed
 154  * never to run out of space.
 155  */
 156 static int alloc_lpt_leb(struct ubifs_info *c, int *lnum)
 157 {
 158         int i, n;
 159
 160         n = *lnum - c->lpt_first + 1;
 161         for (i = n; i < c->lpt_lebs; i++) {
 162                 if (c->ltab[i].tgc || c->ltab[i].cmt)
 163                         continue;
 164                 if (c->ltab[i].free == c->leb_size) {
 165                         c->ltab[i].cmt = 1;
 166                         *lnum = i + c->lpt_first;
 167                         return 0;
 168                 }
 169         }
 170
 171         for (i = 0; i < n; i++) {
 172                 if (c->ltab[i].tgc || c->ltab[i].cmt)
 173                         continue;
 174                 if (c->ltab[i].free == c->leb_size) {
 175                         c->ltab[i].cmt = 1;
 176                         *lnum = i + c->lpt_first;
 177                         return 0;
 178                 }
 179         }
 180         return -ENOSPC;
 181 }
 182
 183 /**
 184  * layout_cnodes - layout cnodes for commit.
 185  * @c: UBIFS file-system description object
 186  *
 187  * This function returns %0 on success and a negative error code on failure.
 188  */
 189 static int layout_cnodes(struct ubifs_info *c)
 190 {
 191         int lnum, offs, len, alen, done_lsave, done_ltab, err;
 192         struct ubifs_cnode *cnode;
 193
 194         err = dbg_chk_lpt_sz(c, 0, 0);
 195         if (err)
 196                 return err;
 197         cnode = c->lpt_cnext;
 198         if (!cnode)
 199                 return 0;
 200         lnum = c->nhead_lnum;
 201         offs = c->nhead_offs;
 202         /* Try to place lsave and ltab nicely */
 203         done_lsave = !c->big_lpt;
 204         done_ltab = 0;
 205         if (!done_lsave && offs + c->lsave_sz <= c->leb_size) {
 206                 done_lsave = 1;
 207                 c->lsave_lnum = lnum;
 208                 c->lsave_offs = offs;
 209                 offs += c->lsave_sz;
 210                 dbg_chk_lpt_sz(c, 1, c->lsave_sz);
 211         }
 212
 213         if (offs + c->ltab_sz <= c->leb_size) {
 214                 done_ltab = 1;
 215                 c->ltab_lnum = lnum;
 216                 c->ltab_offs = offs;
 217                 offs += c->ltab_sz;
 218                 dbg_chk_lpt_sz(c, 1, c->ltab_sz);
 219         }
 220
 221         do {
 222                 if (cnode->level) {
 223                         len = c->nnode_sz;
 224                         c->dirty_nn_cnt -= 1;
 225                 } else {
 226                         len = c->pnode_sz;
 227                         c->dirty_pn_cnt -= 1;
 228                 }
 229                 while (offs + len > c->leb_size) {
 230                         alen = ALIGN(offs, c->min_io_size);
 231                         upd_ltab(c, lnum, c->leb_size - alen, alen - offs);
 232                         dbg_chk_lpt_sz(c, 2, alen - offs);
 233                         err = alloc_lpt_leb(c, &lnum);
 234                         if (err)
 235                                 goto no_space;
 236                         offs = 0;
 237                         ubifs_assert(lnum >= c->lpt_first &&
 238                                      lnum <= c->lpt_last);
 239                         /* Try to place lsave and ltab nicely */
 240                         if (!done_lsave) {
 241                                 done_lsave = 1;
 242                                 c->lsave_lnum = lnum;
 243                                 c->lsave_offs = offs;
 244                                 offs += c->lsave_sz;
 245                                 dbg_chk_lpt_sz(c, 1, c->lsave_sz);
 246                                 continue;
 247                         }
 248                         if (!done_ltab) {
 249                                 done_ltab = 1;
 250                                 c->ltab_lnum = lnum;
 251                                 c->ltab_offs = offs;
 252                                 offs += c->ltab_sz;
 253                                 dbg_chk_lpt_sz(c, 1, c->ltab_sz);
 254                                 continue;
 255                         }
 256                         break;
 257                 }
 258                 if (cnode->parent) {
 259                         cnode->parent->nbranch[cnode->iip].lnum = lnum;
 260                         cnode->parent->nbranch[cnode->iip].offs = offs;
 261                 } else {
 262                         c->lpt_lnum = lnum;
 263                         c->lpt_offs = offs;
 264                 }
 265                 offs += len;
 266                 dbg_chk_lpt_sz(c, 1, len);
 267                 cnode = cnode->cnext;
 268         } while (cnode && cnode != c->lpt_cnext);
 269
 270         /* Make sure to place LPT's save table */
 271         if (!done_lsave) {
 272                 if (offs + c->lsave_sz > c->leb_size) {
 273                         alen = ALIGN(offs, c->min_io_size);
 274                         upd_ltab(c, lnum, c->leb_size - alen, alen - offs);
 275                         dbg_chk_lpt_sz(c, 2, alen - offs);
 276                         err = alloc_lpt_leb(c, &lnum);
 277                         if (err)
 278                                 goto no_space;
 279                         offs = 0;
 280                         ubifs_assert(lnum >= c->lpt_first &&
 281                                      lnum <= c->lpt_last);
 282                 }
 283                 done_lsave = 1;
 284                 c->lsave_lnum = lnum;
 285                 c->lsave_offs = offs;
 286                 offs += c->lsave_sz;
 287                 dbg_chk_lpt_sz(c, 1, c->lsave_sz);
 288         }
 289
 290         /* Make sure to place LPT's own lprops table */
 291         if (!done_ltab) {
 292                 if (offs + c->ltab_sz > c->leb_size) {
 293                         alen = ALIGN(offs, c->min_io_size);
 294                         upd_ltab(c, lnum, c->leb_size - alen, alen - offs);
 295                         dbg_chk_lpt_sz(c, 2, alen - offs);
 296                         err = alloc_lpt_leb(c, &lnum);
 297                         if (err)
 298                                 goto no_space;
 299                         offs = 0;
 300                         ubifs_assert(lnum >= c->lpt_first &&
 301                                      lnum <= c->lpt_last);
 302                 }
 303                 done_ltab = 1;
 304                 c->ltab_lnum = lnum;
 305                 c->ltab_offs = offs;
 306                 offs += c->ltab_sz;
 307                 dbg_chk_lpt_sz(c, 1, c->ltab_sz);
 308         }
 309
 310         alen = ALIGN(offs, c->min_io_size);
 311         upd_ltab(c, lnum, c->leb_size - alen, alen - offs);
 312         dbg_chk_lpt_sz(c, 4, alen - offs);
 313         err = dbg_chk_lpt_sz(c, 3, alen);
 314         if (err)
 315                 return err;
 316         return 0;
 317
 318 no_space:
 319         ubifs_err("LPT out of space");
 320         dbg_err("LPT out of space at LEB %d:%d needing %d, done_ltab %d, "
 321                 "done_lsave %d", lnum, offs, len, done_ltab, done_lsave);
 322         dbg_dump_lpt_info(c);
 323         dbg_dump_lpt_lebs(c);
 324         dump_stack();
 325         return err;
 326 }
 327
 328 /**
 329  * realloc_lpt_leb - allocate an LPT LEB that is empty.
 330  * @c: UBIFS file-system description object
 331  * @lnum: LEB number is passed and returned here
 332  *
 333  * This function duplicates exactly the results of the function alloc_lpt_leb.
 334  * It is used during end commit to reallocate the same LEB numbers that were
 335  * allocated by alloc_lpt_leb during start commit.
 336  *
 337  * This function finds the next LEB that was allocated by the alloc_lpt_leb
 338  * function starting from @lnum. If a LEB is found it is returned in @lnum and
 339  * the function returns %0. Otherwise the function returns -ENOSPC.
 340  * Note however, that LPT is designed never to run out of space.
 341  */
 342 static int realloc_lpt_leb(struct ubifs_info *c, int *lnum)
 343 {
 344         int i, n;
 345
 346         n = *lnum - c->lpt_first + 1;
 347         for (i = n; i < c->lpt_lebs; i++)
 348                 if (c->ltab[i].cmt) {
 349                         c->ltab[i].cmt = 0;
 350                         *lnum = i + c->lpt_first;
 351                         return 0;
 352                 }
 353
 354         for (i = 0; i < n; i++)
 355                 if (c->ltab[i].cmt) {
 356                         c->ltab[i].cmt = 0;
 357                         *lnum = i + c->lpt_first;
 358                         return 0;
 359                 }
 360         return -ENOSPC;
 361 }
 362
 363 /**
 364  * write_cnodes - write cnodes for commit.
 365  * @c: UBIFS file-system description object
 366  *
 367  * This function returns %0 on success and a negative error code on failure.
 368  */
 369 static int write_cnodes(struct ubifs_info *c)
 370 {
 371         int lnum, offs, len, from, err, wlen, alen, done_ltab, done_lsave;
 372         struct ubifs_cnode *cnode;
 373         void *buf = c->lpt_buf;
 374
 375         cnode = c->lpt_cnext;
 376         if (!cnode)
 377                 return 0;
 378         lnum = c->nhead_lnum;
 379         offs = c->nhead_offs;
 380         from = offs;
 381         /* Ensure empty LEB is unmapped */
 382         if (offs == 0) {
 383                 err = ubifs_leb_unmap(c, lnum);
 384                 if (err)
 385                         return err;
 386         }
 387         /* Try to place lsave and ltab nicely */
 388         done_lsave = !c->big_lpt;
 389         done_ltab = 0;
 390         if (!done_lsave && offs + c->lsave_sz <= c->leb_size) {
 391                 done_lsave = 1;
 392                 ubifs_pack_lsave(c, buf + offs, c->lsave);
 393                 offs += c->lsave_sz;
 394                 dbg_chk_lpt_sz(c, 1, c->lsave_sz);
 395         }
 396
 397         if (offs + c->ltab_sz <= c->leb_size) {
 398                 done_ltab = 1;
 399                 ubifs_pack_ltab(c, buf + offs, c->ltab_cmt);
 400                 offs += c->ltab_sz;
 401                 dbg_chk_lpt_sz(c, 1, c->ltab_sz);
 402         }
 403
 404         /* Loop for each cnode */
 405         do {
 406                 if (cnode->level)
 407                         len = c->nnode_sz;
 408                 else
 409                         len = c->pnode_sz;
 410                 while (offs + len > c->leb_size) {
 411                         wlen = offs - from;
 412                         if (wlen) {
 413                                 alen = ALIGN(wlen, c->min_io_size);
 414                                 memset(buf + offs, 0xff, alen - wlen);
 415                                 err = ubifs_leb_write(c, lnum, buf + from, from,
 416                                                        alen, UBI_SHORTTERM);
 417                                 if (err)
 418                                         return err;
 419                                 dbg_chk_lpt_sz(c, 4, alen - wlen);
 420                         }
 421                         dbg_chk_lpt_sz(c, 2, 0);
 422                         err = realloc_lpt_leb(c, &lnum);
 423                         if (err)
 424                                 goto no_space;
 425                         offs = 0;
 426                         from = 0;
 427                         ubifs_assert(lnum >= c->lpt_first &&
 428                                      lnum <= c->lpt_last);
 429                         err = ubifs_leb_unmap(c, lnum);
 430                         if (err)
 431                                 return err;
 432                         /* Try to place lsave and ltab nicely */
 433                         if (!done_lsave) {
 434                                 done_lsave = 1;
 435                                 ubifs_pack_lsave(c, buf + offs, c->lsave);
 436                                 offs += c->lsave_sz;
 437                                 dbg_chk_lpt_sz(c, 1, c->lsave_sz);
 438                                 continue;
 439                         }
 440                         if (!done_ltab) {
 441                                 done_ltab = 1;
 442                                 ubifs_pack_ltab(c, buf + offs, c->ltab_cmt);
 443                                 offs += c->ltab_sz;
 444                                 dbg_chk_lpt_sz(c, 1, c->ltab_sz);
 445                                 continue;
 446                         }
 447                         break;
 448                 }
 449                 if (cnode->level)
 450                         ubifs_pack_nnode(c, buf + offs,
 451                                          (struct ubifs_nnode *)cnode);
 452                 else
 453                         ubifs_pack_pnode(c, buf + offs,
 454                                          (struct ubifs_pnode *)cnode);
 455                 /*
 456                  * The reason for the barriers is the same as in case of TNC.
 457                  * See comment in 'write_index()'. 'dirty_cow_nnode()' and
 458                  * 'dirty_cow_pnode()' are the functions for which this is
 459                  * important.
 460                  */
 461                 clear_bit(DIRTY_CNODE, &cnode->flags);
 462                 smp_mb__before_clear_bit();
 463                 clear_bit(COW_ZNODE, &cnode->flags);
 464                 smp_mb__after_clear_bit();
 465                 offs += len;
 466                 dbg_chk_lpt_sz(c, 1, len);
 467                 cnode = cnode->cnext;
 468         } while (cnode && cnode != c->lpt_cnext);
 469
 470         /* Make sure to place LPT's save table */
 471         if (!done_lsave) {
 472                 if (offs + c->lsave_sz > c->leb_size) {
 473                         wlen = offs - from;
 474                         alen = ALIGN(wlen, c->min_io_size);
 475                         memset(buf + offs, 0xff, alen - wlen);
 476                         err = ubifs_leb_write(c, lnum, buf + from, from, alen,
 477                                               UBI_SHORTTERM);
 478                         if (err)
 479                                 return err;
 480                         dbg_chk_lpt_sz(c, 2, alen - wlen);
 481                         err = realloc_lpt_leb(c, &lnum);
 482                         if (err)
 483                                 goto no_space;
 484                         offs = 0;
 485                         ubifs_assert(lnum >= c->lpt_first &&
 486                                      lnum <= c->lpt_last);
 487                         err = ubifs_leb_unmap(c, lnum);
 488                         if (err)
 489                                 return err;
 490                 }
 491                 done_lsave = 1;
 492                 ubifs_pack_lsave(c, buf + offs, c->lsave);
 493                 offs += c->lsave_sz;
 494                 dbg_chk_lpt_sz(c, 1, c->lsave_sz);
 495         }
 496
 497         /* Make sure to place LPT's own lprops table */
 498         if (!done_ltab) {
 499                 if (offs + c->ltab_sz > c->leb_size) {
 500                         wlen = offs - from;
 501                         alen = ALIGN(wlen, c->min_io_size);
 502                         memset(buf + offs, 0xff, alen - wlen);
 503                         err = ubifs_leb_write(c, lnum, buf + from, from, alen,
 504                                               UBI_SHORTTERM);
 505                         if (err)
 506                                 return err;
 507                         dbg_chk_lpt_sz(c, 2, alen - wlen);
 508                         err = realloc_lpt_leb(c, &lnum);
 509                         if (err)
 510                                 goto no_space;
 511                         offs = 0;
 512                         ubifs_assert(lnum >= c->lpt_first &&
 513                                      lnum <= c->lpt_last);
 514                         err = ubifs_leb_unmap(c, lnum);
 515                         if (err)
 516                                 return err;
 517                 }
 518                 done_ltab = 1;
 519                 ubifs_pack_ltab(c, buf + offs, c->ltab_cmt);
 520                 offs += c->ltab_sz;
 521                 dbg_chk_lpt_sz(c, 1, c->ltab_sz);
 522         }
 523
 524         /* Write remaining data in buffer */
 525         wlen = offs - from;
 526         alen = ALIGN(wlen, c->min_io_size);
 527         memset(buf + offs, 0xff, alen - wlen);
 528         err = ubifs_leb_write(c, lnum, buf + from, from, alen, UBI_SHORTTERM);
 529         if (err)
 530                 return err;
 531
 532         dbg_chk_lpt_sz(c, 4, alen - wlen);
 533         err = dbg_chk_lpt_sz(c, 3, ALIGN(offs, c->min_io_size));
 534         if (err)
 535                 return err;
 536
 537         c->nhead_lnum = lnum;
 538         c->nhead_offs = ALIGN(offs, c->min_io_size);
 539
 540         dbg_lp("LPT root is at %d:%d", c->lpt_lnum, c->lpt_offs);
 541         dbg_lp("LPT head is at %d:%d", c->nhead_lnum, c->nhead_offs);
 542         dbg_lp("LPT ltab is at %d:%d", c->ltab_lnum, c->ltab_offs);
 543         if (c->big_lpt)
 544                 dbg_lp("LPT lsave is at %d:%d", c->lsave_lnum, c->lsave_offs);
 545
 546         return 0;
 547
 548 no_space:
 549         ubifs_err("LPT out of space mismatch");
 550         dbg_err("LPT out of space mismatch at LEB %d:%d needing %d, done_ltab "
 551                 "%d, done_lsave %d", lnum, offs, len, done_ltab, done_lsave);
 552         dbg_dump_lpt_info(c);
 553         dbg_dump_lpt_lebs(c);
 554         dump_stack();
 555         return err;
 556 }
 557
 558 /**
 559  * next_pnode - find next pnode.
 560  * @c: UBIFS file-system description object
 561  * @pnode: pnode
 562  *
 563  * This function returns the next pnode or %NULL if there are no more pnodes.
 564  */
 565 static struct ubifs_pnode *next_pnode(struct ubifs_info *c,
 566                                       struct ubifs_pnode *pnode)
 567 {
 568         struct ubifs_nnode *nnode;
 569         int iip;
 570
 571         /* Try to go right */
 572         nnode = pnode->parent;
 573         iip = pnode->iip + 1;
 574         if (iip < UBIFS_LPT_FANOUT) {
 575                 /* We assume here that LEB zero is never an LPT LEB */
 576                 if (nnode->nbranch[iip].lnum)
 577                         return ubifs_get_pnode(c, nnode, iip);
 578         }
 579
 580         /* Go up while can't go right */
 581         do {
 582                 iip = nnode->iip + 1;
 583                 nnode = nnode->parent;
 584                 if (!nnode)
 585                         return NULL;
 586                 /* We assume here that LEB zero is never an LPT LEB */
 587         } while (iip >= UBIFS_LPT_FANOUT || !nnode->nbranch[iip].lnum);
 588
 589         /* Go right */
 590         nnode = ubifs_get_nnode(c, nnode, iip);
 591         if (IS_ERR(nnode))
 592                 return (void *)nnode;
 593
 594         /* Go down to level 1 */
 595         while (nnode->level > 1) {
 596                 nnode = ubifs_get_nnode(c, nnode, 0);
 597                 if (IS_ERR(nnode))
 598                         return (void *)nnode;
 599         }
 600
 601         return ubifs_get_pnode(c, nnode, 0);
 602 }
 603
 604 /**
 605  * pnode_lookup - lookup a pnode in the LPT.
 606  * @c: UBIFS file-system description object
 607  * @i: pnode number (0 to main_lebs - 1)
 608  *
 609  * This function returns a pointer to the pnode on success or a negative
 610  * error code on failure.
 611  */
 612 static struct ubifs_pnode *pnode_lookup(struct ubifs_info *c, int i)
 613 {
 614         int err, h, iip, shft;
 615         struct ubifs_nnode *nnode;
 616
 617         if (!c->nroot) {
 618                 err = ubifs_read_nnode(c, NULL, 0);
 619                 if (err)
 620                         return ERR_PTR(err);
 621         }
 622         i <<= UBIFS_LPT_FANOUT_SHIFT;
 623         nnode = c->nroot;
 624         shft = c->lpt_hght * UBIFS_LPT_FANOUT_SHIFT;
 625         for (h = 1; h < c->lpt_hght; h++) {
 626                 iip = ((i >> shft) & (UBIFS_LPT_FANOUT - 1));
 627                 shft -= UBIFS_LPT_FANOUT_SHIFT;
 628                 nnode = ubifs_get_nnode(c, nnode, iip);
 629                 if (IS_ERR(nnode))
 630                         return ERR_PTR(PTR_ERR(nnode));
 631         }
 632         iip = ((i >> shft) & (UBIFS_LPT_FANOUT - 1));
 633         return ubifs_get_pnode(c, nnode, iip);
 634 }
 635
 636 /**
 637  * add_pnode_dirt - add dirty space to LPT LEB properties.
 638  * @c: UBIFS file-system description object
 639  * @pnode: pnode for which to add dirt
 640  */
 641 static void add_pnode_dirt(struct ubifs_info *c, struct ubifs_pnode *pnode)
 642 {
 643         ubifs_add_lpt_dirt(c, pnode->parent->nbranch[pnode->iip].lnum,
 644                            c->pnode_sz);
 645 }
 646
 647 /**
 648  * do_make_pnode_dirty - mark a pnode dirty.
 649  * @c: UBIFS file-system description object
 650  * @pnode: pnode to mark dirty
 651  */
 652 static void do_make_pnode_dirty(struct ubifs_info *c, struct ubifs_pnode *pnode)
 653 {
 654         /* Assumes cnext list is empty i.e. not called during commit */
 655         if (!test_and_set_bit(DIRTY_CNODE, &pnode->flags)) {
 656                 struct ubifs_nnode *nnode;
 657
 658                 c->dirty_pn_cnt += 1;
 659                 add_pnode_dirt(c, pnode);
 660                 /* Mark parent and ancestors dirty too */
 661                 nnode = pnode->parent;
 662                 while (nnode) {
 663                         if (!test_and_set_bit(DIRTY_CNODE, &nnode->flags)) {
 664                                 c->dirty_nn_cnt += 1;
 665                                 ubifs_add_nnode_dirt(c, nnode);
 666                                 nnode = nnode->parent;
 667                         } else
 668                                 break;
 669                 }
 670         }
 671 }
 672
 673 /**
 674  * make_tree_dirty - mark the entire LEB properties tree dirty.
 675  * @c: UBIFS file-system description object
 676  *
 677  * This function is used by the "small" LPT model to cause the entire LEB
 678  * properties tree to be written.  The "small" LPT model does not use LPT
 679  * garbage collection because it is more efficient to write the entire tree
 680  * (because it is small).
 681  *
 682  * This function returns %0 on success and a negative error code on failure.
 683  */
 684 static int make_tree_dirty(struct ubifs_info *c)
 685 {
 686         struct ubifs_pnode *pnode;
 687
 688         pnode = pnode_lookup(c, 0);
 689         while (pnode) {
 690                 do_make_pnode_dirty(c, pnode);
 691                 pnode = next_pnode(c, pnode);
 692                 if (IS_ERR(pnode))
 693                         return PTR_ERR(pnode);
 694         }
 695         return 0;
 696 }
 697
 698 /**
 699  * need_write_all - determine if the LPT area is running out of free space.
 700  * @c: UBIFS file-system description object
 701  *
 702  * This function returns %1 if the LPT area is running out of free space and %0
 703  * if it is not.
 704  */
 705 static int need_write_all(struct ubifs_info *c)
 706 {
 707         long long free = 0;
 708         int i;
 709
 710         for (i = 0; i < c->lpt_lebs; i++) {
 711                 if (i + c->lpt_first == c->nhead_lnum)
 712                         free += c->leb_size - c->nhead_offs;
 713                 else if (c->ltab[i].free == c->leb_size)
 714                         free += c->leb_size;
 715                 else if (c->ltab[i].free + c->ltab[i].dirty == c->leb_size)
 716                         free += c->leb_size;
 717         }
 718         /* Less than twice the size left */
 719         if (free <= c->lpt_sz * 2)
 720                 return 1;
 721         return 0;
 722 }
 723
 724 /**
 725  * lpt_tgc_start - start trivial garbage collection of LPT LEBs.
 726  * @c: UBIFS file-system description object
 727  *
 728  * LPT trivial garbage collection is where a LPT LEB contains only dirty and
 729  * free space and so may be reused as soon as the next commit is completed.
 730  * This function is called during start commit to mark LPT LEBs for trivial GC.
 731  */
 732 static void lpt_tgc_start(struct ubifs_info *c)
 733 {
 734         int i;
 735
 736         for (i = 0; i < c->lpt_lebs; i++) {
 737                 if (i + c->lpt_first == c->nhead_lnum)
 738                         continue;
 739                 if (c->ltab[i].dirty > 0 &&
 740                     c->ltab[i].free + c->ltab[i].dirty == c->leb_size) {
 741                         c->ltab[i].tgc = 1;
 742                         c->ltab[i].free = c->leb_size;
 743                         c->ltab[i].dirty = 0;
 744                         dbg_lp("LEB %d", i + c->lpt_first);
 745                 }
 746         }
 747 }
 748
 749 /**
 750  * lpt_tgc_end - end trivial garbage collection of LPT LEBs.
 751  * @c: UBIFS file-system description object
 752  *
 753  * LPT trivial garbage collection is where a LPT LEB contains only dirty and
 754  * free space and so may be reused as soon as the next commit is completed.
 755  * This function is called after the commit is completed (master node has been
 756  * written) and un-maps LPT LEBs that were marked for trivial GC.
 757  */
 758 static int lpt_tgc_end(struct ubifs_info *c)
 759 {
 760         int i, err;
 761
 762         for (i = 0; i < c->lpt_lebs; i++)
 763                 if (c->ltab[i].tgc) {
 764                         err = ubifs_leb_unmap(c, i + c->lpt_first);
 765                         if (err)
 766                                 return err;
 767                         c->ltab[i].tgc = 0;
 768                         dbg_lp("LEB %d", i + c->lpt_first);
 769                 }
 770         return 0;
 771 }
 772
 773 /**
 774  * populate_lsave - fill the lsave array with important LEB numbers.
 775  * @c: the UBIFS file-system description object
 776  *
 777  * This function is only called for the "big" model. It records a small number
 778  * of LEB numbers of important LEBs.  Important LEBs are ones that are (from
 779  * most important to least important): empty, freeable, freeable index, dirty
 780  * index, dirty or free. Upon mount, we read this list of LEB numbers and bring
 781  * their pnodes into memory.  That will stop us from having to scan the LPT
 782  * straight away. For the "small" model we assume that scanning the LPT is no
 783  * big deal.
 784  */
 785 static void populate_lsave(struct ubifs_info *c)
 786 {
 787         struct ubifs_lprops *lprops;
 788         struct ubifs_lpt_heap *heap;
 789         int i, cnt = 0;
 790
 791         ubifs_assert(c->big_lpt);
 792         if (!(c->lpt_drty_flgs & LSAVE_DIRTY)) {
 793                 c->lpt_drty_flgs |= LSAVE_DIRTY;
 794                 ubifs_add_lpt_dirt(c, c->lsave_lnum, c->lsave_sz);
 795         }
 796         list_for_each_entry(lprops, &c->empty_list, list) {
 797                 c->lsave[cnt++] = lprops->lnum;
 798                 if (cnt >= c->lsave_cnt)
 799                         return;
 800         }
 801         list_for_each_entry(lprops, &c->freeable_list, list) {
 802                 c->lsave[cnt++] = lprops->lnum;
 803                 if (cnt >= c->lsave_cnt)
 804                         return;
 805         }
 806         list_for_each_entry(lprops, &c->frdi_idx_list, list) {
 807                 c->lsave[cnt++] = lprops->lnum;
 808                 if (cnt >= c->lsave_cnt)
 809                         return;
 810         }
 811         heap = &c->lpt_heap[LPROPS_DIRTY_IDX - 1];
 812         for (i = 0; i < heap->cnt; i++) {
 813                 c->lsave[cnt++] = heap->arr[i]->lnum;
 814                 if (cnt >= c->lsave_cnt)
 815                         return;
 816         }
 817         heap = &c->lpt_heap[LPROPS_DIRTY - 1];
 818         for (i = 0; i < heap->cnt; i++) {
 819                 c->lsave[cnt++] = heap->arr[i]->lnum;
 820                 if (cnt >= c->lsave_cnt)
 821                         return;
 822         }
 823         heap = &c->lpt_heap[LPROPS_FREE - 1];
 824         for (i = 0; i < heap->cnt; i++) {
 825                 c->lsave[cnt++] = heap->arr[i]->lnum;
 826                 if (cnt >= c->lsave_cnt)
 827                         return;
 828         }
 829         /* Fill it up completely */
 830         while (cnt < c->lsave_cnt)
 831                 c->lsave[cnt++] = c->main_first;
 832 }
 833
 834 /**
 835  * nnode_lookup - lookup a nnode in the LPT.
 836  * @c: UBIFS file-system description object
 837  * @i: nnode number
 838  *
 839  * This function returns a pointer to the nnode on success or a negative
 840  * error code on failure.
 841  */
 842 static struct ubifs_nnode *nnode_lookup(struct ubifs_info *c, int i)
 843 {
 844         int err, iip;
 845         struct ubifs_nnode *nnode;
 846
 847         if (!c->nroot) {
 848                 err = ubifs_read_nnode(c, NULL, 0);
 849                 if (err)
 850                         return ERR_PTR(err);
 851         }
 852         nnode = c->nroot;
 853         while (1) {
 854                 iip = i & (UBIFS_LPT_FANOUT - 1);
 855                 i >>= UBIFS_LPT_FANOUT_SHIFT;
 856                 if (!i)
 857                         break;
 858                 nnode = ubifs_get_nnode(c, nnode, iip);
 859                 if (IS_ERR(nnode))
 860                         return nnode;
 861         }
 862         return nnode;
 863 }
 864
 865 /**
 866  * make_nnode_dirty - find a nnode and, if found, make it dirty.
 867  * @c: UBIFS file-system description object
 868  * @node_num: nnode number of nnode to make dirty
 869  * @lnum: LEB number where nnode was written
 870  * @offs: offset where nnode was written
 871  *
 872  * This function is used by LPT garbage collection.  LPT garbage collection is
 873  * used only for the "big" LPT model (c->big_lpt == 1).  Garbage collection
 874  * simply involves marking all the nodes in the LEB being garbage-collected as
 875  * dirty.  The dirty nodes are written next commit, after which the LEB is free
 876  * to be reused.
 877  *
 878  * This function returns %0 on success and a negative error code on failure.
 879  */
 880 static int make_nnode_dirty(struct ubifs_info *c, int node_num, int lnum,
 881                             int offs)
 882 {
 883         struct ubifs_nnode *nnode;
 884
 885         nnode = nnode_lookup(c, node_num);
 886         if (IS_ERR(nnode))
 887                 return PTR_ERR(nnode);
 888         if (nnode->parent) {
 889                 struct ubifs_nbranch *branch;
 890
 891                 branch = &nnode->parent->nbranch[nnode->iip];
 892                 if (branch->lnum != lnum || branch->offs != offs)
 893                         return 0; /* nnode is obsolete */
 894         } else if (c->lpt_lnum != lnum || c->lpt_offs != offs)
 895                         return 0; /* nnode is obsolete */
 896         /* Assumes cnext list is empty i.e. not called during commit */
 897         if (!test_and_set_bit(DIRTY_CNODE, &nnode->flags)) {
 898                 c->dirty_nn_cnt += 1;
 899                 ubifs_add_nnode_dirt(c, nnode);
 900                 /* Mark parent and ancestors dirty too */
 901                 nnode = nnode->parent;
 902                 while (nnode) {
 903                         if (!test_and_set_bit(DIRTY_CNODE, &nnode->flags)) {
 904                                 c->dirty_nn_cnt += 1;
 905                                 ubifs_add_nnode_dirt(c, nnode);
 906                                 nnode = nnode->parent;
 907                         } else
 908                                 break;
 909                 }
 910         }
 911         return 0;
 912 }
 913
 914 /**
 915  * make_pnode_dirty - find a pnode and, if found, make it dirty.
 916  * @c: UBIFS file-system description object
 917  * @node_num: pnode number of pnode to make dirty
 918  * @lnum: LEB number where pnode was written
 919  * @offs: offset where pnode was written
 920  *
 921  * This function is used by LPT garbage collection.  LPT garbage collection is
 922  * used only for the "big" LPT model (c->big_lpt == 1).  Garbage collection
 923  * simply involves marking all the nodes in the LEB being garbage-collected as
 924  * dirty.  The dirty nodes are written next commit, after which the LEB is free
 925  * to be reused.
 926  *
 927  * This function returns %0 on success and a negative error code on failure.
 928  */
 929 static int make_pnode_dirty(struct ubifs_info *c, int node_num, int lnum,
 930                             int offs)
 931 {
 932         struct ubifs_pnode *pnode;
 933         struct ubifs_nbranch *branch;
 934
 935         pnode = pnode_lookup(c, node_num);
 936         if (IS_ERR(pnode))
 937                 return PTR_ERR(pnode);
 938         branch = &pnode->parent->nbranch[pnode->iip];
 939         if (branch->lnum != lnum || branch->offs != offs)
 940                 return 0;
 941         do_make_pnode_dirty(c, pnode);
 942         return 0;
 943 }
 944
 945 /**
 946  * make_ltab_dirty - make ltab node dirty.
 947  * @c: UBIFS file-system description object
 948  * @lnum: LEB number where ltab was written
 949  * @offs: offset where ltab was written
 950  *
 951  * This function is used by LPT garbage collection.  LPT garbage collection is
 952  * used only for the "big" LPT model (c->big_lpt == 1).  Garbage collection
 953  * simply involves marking all the nodes in the LEB being garbage-collected as
 954  * dirty.  The dirty nodes are written next commit, after which the LEB is free
 955  * to be reused.
 956  *
 957  * This function returns %0 on success and a negative error code on failure.
 958  */
 959 static int make_ltab_dirty(struct ubifs_info *c, int lnum, int offs)
 960 {
 961         if (lnum != c->ltab_lnum || offs != c->ltab_offs)
 962                 return 0; /* This ltab node is obsolete */
 963         if (!(c->lpt_drty_flgs & LTAB_DIRTY)) {
 964                 c->lpt_drty_flgs |= LTAB_DIRTY;
 965                 ubifs_add_lpt_dirt(c, c->ltab_lnum, c->ltab_sz);
 966         }
 967         return 0;
 968 }
 969
 970 /**
 971  * make_lsave_dirty - make lsave node dirty.
 972  * @c: UBIFS file-system description object
 973  * @lnum: LEB number where lsave was written
 974  * @offs: offset where lsave was written
 975  *
 976  * This function is used by LPT garbage collection.  LPT garbage collection is
 977  * used only for the "big" LPT model (c->big_lpt == 1).  Garbage collection
 978  * simply involves marking all the nodes in the LEB being garbage-collected as
 979  * dirty.  The dirty nodes are written next commit, after which the LEB is free
 980  * to be reused.
 981  *
 982  * This function returns %0 on success and a negative error code on failure.
 983  */
 984 static int make_lsave_dirty(struct ubifs_info *c, int lnum, int offs)
 985 {
 986         if (lnum != c->lsave_lnum || offs != c->lsave_offs)
 987                 return 0; /* This lsave node is obsolete */
 988         if (!(c->lpt_drty_flgs & LSAVE_DIRTY)) {
 989                 c->lpt_drty_flgs |= LSAVE_DIRTY;
 990                 ubifs_add_lpt_dirt(c, c->lsave_lnum, c->lsave_sz);
 991         }
 992         return 0;
 993 }
 994
 995 /**
 996  * make_node_dirty - make node dirty.
 997  * @c: UBIFS file-system description object
 998  * @node_type: LPT node type
 999  * @node_num: node number
1000  * @lnum: LEB number where node was written
1001  * @offs: offset where node was written
1002  *
1003  * This function is used by LPT garbage collection.  LPT garbage collection is
1004  * used only for the "big" LPT model (c->big_lpt == 1).  Garbage collection
1005  * simply involves marking all the nodes in the LEB being garbage-collected as
1006  * dirty.  The dirty nodes are written next commit, after which the LEB is free
1007  * to be reused.
1008  *
1009  * This function returns %0 on success and a negative error code on failure.
1010  */
1011 static int make_node_dirty(struct ubifs_info *c, int node_type, int node_num,
1012                            int lnum, int offs)
1013 {
1014         switch (node_type) {
1015         case UBIFS_LPT_NNODE:
1016                 return make_nnode_dirty(c, node_num, lnum, offs);
1017         case UBIFS_LPT_PNODE:
1018                 return make_pnode_dirty(c, node_num, lnum, offs);
1019         case UBIFS_LPT_LTAB:
1020                 return make_ltab_dirty(c, lnum, offs);
1021         case UBIFS_LPT_LSAVE:
1022                 return make_lsave_dirty(c, lnum, offs);
1023         }
1024         return -EINVAL;
1025 }
1026
1027 /**
1028  * get_lpt_node_len - return the length of a node based on its type.
1029  * @c: UBIFS file-system description object
1030  * @node_type: LPT node type
1031  */
1032 static int get_lpt_node_len(const struct ubifs_info *c, int node_type)
1033 {
1034         switch (node_type) {
1035         case UBIFS_LPT_NNODE:
1036                 return c->nnode_sz;
1037         case UBIFS_LPT_PNODE:
1038                 return c->pnode_sz;
1039         case UBIFS_LPT_LTAB:
1040                 return c->ltab_sz;
1041         case UBIFS_LPT_LSAVE:
1042                 return c->lsave_sz;
1043         }
1044         return 0;
1045 }
1046
1047 /**
1048  * get_pad_len - return the length of padding in a buffer.
1049  * @c: UBIFS file-system description object
1050  * @buf: buffer
1051  * @len: length of buffer
1052  */
1053 static int get_pad_len(const struct ubifs_info *c, uint8_t *buf, int len)
1054 {
1055         int offs, pad_len;
1056
1057         if (c->min_io_size == 1)
1058                 return 0;
1059         offs = c->leb_size - len;
1060         pad_len = ALIGN(offs, c->min_io_size) - offs;
1061         return pad_len;
1062 }
1063
1064 /**
1065  * get_lpt_node_type - return type (and node number) of a node in a buffer.
1066  * @c: UBIFS file-system description object
1067  * @buf: buffer
1068  * @node_num: node number is returned here
1069  */
1070 static int get_lpt_node_type(const struct ubifs_info *c, uint8_t *buf,
1071                              int *node_num)
1072 {
1073         uint8_t *addr = buf + UBIFS_LPT_CRC_BYTES;
1074         int pos = 0, node_type;
1075
1076         node_type = ubifs_unpack_bits(&addr, &pos, UBIFS_LPT_TYPE_BITS);
1077         *node_num = ubifs_unpack_bits(&addr, &pos, c->pcnt_bits);
1078         return node_type;
1079 }
1080
1081 /**
1082  * is_a_node - determine if a buffer contains a node.
1083  * @c: UBIFS file-system description object
1084  * @buf: buffer
1085  * @len: length of buffer
1086  *
1087  * This function returns %1 if the buffer contains a node or %0 if it does not.
1088  */
1089 static int is_a_node(const struct ubifs_info *c, uint8_t *buf, int len)
1090 {
1091         uint8_t *addr = buf + UBIFS_LPT_CRC_BYTES;
1092         int pos = 0, node_type, node_len;
1093         uint16_t crc, calc_crc;
1094
1095         if (len < UBIFS_LPT_CRC_BYTES + (UBIFS_LPT_TYPE_BITS + 7) / 8)
1096                 return 0;
1097         node_type = ubifs_unpack_bits(&addr, &pos, UBIFS_LPT_TYPE_BITS);
1098         if (node_type == UBIFS_LPT_NOT_A_NODE)
1099                 return 0;
1100         node_len = get_lpt_node_len(c, node_type);
1101         if (!node_len || node_len > len)
1102                 return 0;
1103         pos = 0;
1104         addr = buf;
1105         crc = ubifs_unpack_bits(&addr, &pos, UBIFS_LPT_CRC_BITS);
1106         calc_crc = crc16(-1, buf + UBIFS_LPT_CRC_BYTES,
1107                          node_len - UBIFS_LPT_CRC_BYTES);
1108         if (crc != calc_crc)
1109                 return 0;
1110         return 1;
1111 }
1112
1113 /**
1114  * lpt_gc_lnum - garbage collect a LPT LEB.
1115  * @c: UBIFS file-system description object
1116  * @lnum: LEB number to garbage collect
1117  *
1118  * LPT garbage collection is used only for the "big" LPT model
1119  * (c->big_lpt == 1).  Garbage collection simply involves marking all the nodes
1120  * in the LEB being garbage-collected as dirty.  The dirty nodes are written
1121  * next commit, after which the LEB is free to be reused.
1122  *
1123  * This function returns %0 on success and a negative error code on failure.
1124  */
1125 static int lpt_gc_lnum(struct ubifs_info *c, int lnum)
1126 {
1127         int err, len = c->leb_size, node_type, node_num, node_len, offs;
1128         void *buf = c->lpt_buf;
1129
1130         dbg_lp("LEB %d", lnum);
1131         err = ubi_read(c->ubi, lnum, buf, 0, c->leb_size);
1132         if (err) {
1133                 ubifs_err("cannot read LEB %d, error %d", lnum, err);
1134                 return err;
1135         }
1136         while (1) {
1137                 if (!is_a_node(c, buf, len)) {
1138                         int pad_len;
1139
1140                         pad_len = get_pad_len(c, buf, len);
1141                         if (pad_len) {
1142                                 buf += pad_len;
1143                                 len -= pad_len;
1144                                 continue;
1145                         }
1146                         return 0;
1147                 }
1148                 node_type = get_lpt_node_type(c, buf, &node_num);
1149                 node_len = get_lpt_node_len(c, node_type);
1150                 offs = c->leb_size - len;
1151                 ubifs_assert(node_len != 0);
1152                 mutex_lock(&c->lp_mutex);
1153                 err = make_node_dirty(c, node_type, node_num, lnum, offs);
1154                 mutex_unlock(&c->lp_mutex);
1155                 if (err)
1156                         return err;
1157                 buf += node_len;
1158                 len -= node_len;
1159         }
1160         return 0;
1161 }
1162
1163 /**
1164  * lpt_gc - LPT garbage collection.
1165  * @c: UBIFS file-system description object
1166  *
1167  * Select a LPT LEB for LPT garbage collection and call 'lpt_gc_lnum()'.
1168  * Returns %0 on success and a negative error code on failure.
1169  */
1170 static int lpt_gc(struct ubifs_info *c)
1171 {
1172         int i, lnum = -1, dirty = 0;
1173
1174         mutex_lock(&c->lp_mutex);
1175         for (i = 0; i < c->lpt_lebs; i++) {
1176                 ubifs_assert(!c->ltab[i].tgc);
1177                 if (i + c->lpt_first == c->nhead_lnum ||
1178                     c->ltab[i].free + c->ltab[i].dirty == c->leb_size)
1179                         continue;
1180                 if (c->ltab[i].dirty > dirty) {
1181                         dirty = c->ltab[i].dirty;
1182                         lnum = i + c->lpt_first;
1183                 }
1184         }
1185         mutex_unlock(&c->lp_mutex);
1186         if (lnum == -1)
1187                 return -ENOSPC;
1188         return lpt_gc_lnum(c, lnum);
1189 }
1190
1191 /**
1192  * ubifs_lpt_start_commit - UBIFS commit starts.
1193  * @c: the UBIFS file-system description object
1194  *
1195  * This function has to be called when UBIFS starts the commit operation.
1196  * This function "freezes" all currently dirty LEB properties and does not
1197  * change them anymore. Further changes are saved and tracked separately
1198  * because they are not part of this commit. This function returns zero in case
1199  * of success and a negative error code in case of failure.
1200  */
1201 int ubifs_lpt_start_commit(struct ubifs_info *c)
1202 {
1203         int err, cnt;
1204
1205         dbg_lp("");
1206
1207         mutex_lock(&c->lp_mutex);
1208         err = dbg_chk_lpt_free_spc(c);
1209         if (err)
1210                 goto out;
1211         err = dbg_check_ltab(c);
1212         if (err)
1213                 goto out;
1214
1215         if (c->check_lpt_free) {
1216                 /*
1217                  * We ensure there is enough free space in
1218                  * ubifs_lpt_post_commit() by marking nodes dirty. That
1219                  * information is lost when we unmount, so we also need
1220                  * to check free space once after mounting also.
1221                  */
1222                 c->check_lpt_free = 0;
1223                 while (need_write_all(c)) {
1224                         mutex_unlock(&c->lp_mutex);
1225                         err = lpt_gc(c);
1226                         if (err)
1227                                 return err;
1228                         mutex_lock(&c->lp_mutex);
1229                 }
1230         }
1231
1232         lpt_tgc_start(c);
1233
1234         if (!c->dirty_pn_cnt) {
1235                 dbg_cmt("no cnodes to commit");
1236                 err = 0;
1237                 goto out;
1238         }
1239
1240         if (!c->big_lpt && need_write_all(c)) {
1241                 /* If needed, write everything */
1242                 err = make_tree_dirty(c);
1243                 if (err)
1244                         goto out;
1245                 lpt_tgc_start(c);
1246         }
1247
1248         if (c->big_lpt)
1249                 populate_lsave(c);
1250
1251         cnt = get_cnodes_to_commit(c);
1252         ubifs_assert(cnt != 0);
1253
1254         err = layout_cnodes(c);
1255         if (err)
1256                 goto out;
1257
1258         /* Copy the LPT's own lprops for end commit to write */
1259         memcpy(c->ltab_cmt, c->ltab,
1260                sizeof(struct ubifs_lpt_lprops) * c->lpt_lebs);
1261         c->lpt_drty_flgs &= ~(LTAB_DIRTY | LSAVE_DIRTY);
1262
1263 out:
1264         mutex_unlock(&c->lp_mutex);
1265         return err;
1266 }
1267
1268 /**
1269  * free_obsolete_cnodes - free obsolete cnodes for commit end.
1270  * @c: UBIFS file-system description object
1271  */
1272 static void free_obsolete_cnodes(struct ubifs_info *c)
1273 {
1274         struct ubifs_cnode *cnode, *cnext;
1275
1276         cnext = c->lpt_cnext;
1277         if (!cnext)
1278                 return;
1279         do {
1280                 cnode = cnext;
1281                 cnext = cnode->cnext;
1282                 if (test_bit(OBSOLETE_CNODE, &cnode->flags))
1283                         kfree(cnode);
1284                 else
1285                         cnode->cnext = NULL;
1286         } while (cnext != c->lpt_cnext);
1287         c->lpt_cnext = NULL;
1288 }
1289
1290 /**
1291  * ubifs_lpt_end_commit - finish the commit operation.
1292  * @c: the UBIFS file-system description object
1293  *
1294  * This function has to be called when the commit operation finishes. It
1295  * flushes the changes which were "frozen" by 'ubifs_lprops_start_commit()' to
1296  * the media. Returns zero in case of success and a negative error code in case
1297  * of failure.
1298  */
1299 int ubifs_lpt_end_commit(struct ubifs_info *c)
1300 {
1301         int err;
1302
1303         dbg_lp("");
1304
1305         if (!c->lpt_cnext)
1306                 return 0;
1307
1308         err = write_cnodes(c);
1309         if (err)
1310                 return err;
1311
1312         mutex_lock(&c->lp_mutex);
1313         free_obsolete_cnodes(c);
1314         mutex_unlock(&c->lp_mutex);
1315
1316         return 0;
1317 }
1318
1319 /**
1320  * ubifs_lpt_post_commit - post commit LPT trivial GC and LPT GC.
1321  * @c: UBIFS file-system description object
1322  *
1323  * LPT trivial GC is completed after a commit. Also LPT GC is done after a
1324  * commit for the "big" LPT model.
1325  */
1326 int ubifs_lpt_post_commit(struct ubifs_info *c)
1327 {
1328         int err;
1329
1330         mutex_lock(&c->lp_mutex);
1331         err = lpt_tgc_end(c);
1332         if (err)
1333                 goto out;
1334         if (c->big_lpt)
1335                 while (need_write_all(c)) {
1336                         mutex_unlock(&c->lp_mutex);
1337                         err = lpt_gc(c);
1338                         if (err)
1339                                 return err;
1340                         mutex_lock(&c->lp_mutex);
1341                 }
1342 out:
1343         mutex_unlock(&c->lp_mutex);
1344         return err;
1345 }
1346
1347 /**
1348  * first_nnode - find the first nnode in memory.
1349  * @c: UBIFS file-system description object
1350  * @hght: height of tree where nnode found is returned here
1351  *
1352  * This function returns a pointer to the nnode found or %NULL if no nnode is
1353  * found. This function is a helper to 'ubifs_lpt_free()'.
1354  */
1355 static struct ubifs_nnode *first_nnode(struct ubifs_info *c, int *hght)
1356 {
1357         struct ubifs_nnode *nnode;
1358         int h, i, found;
1359
1360         nnode = c->nroot;
1361         *hght = 0;
1362         if (!nnode)
1363                 return NULL;
1364         for (h = 1; h < c->lpt_hght; h++) {
1365                 found = 0;
1366                 for (i = 0; i < UBIFS_LPT_FANOUT; i++) {
1367                         if (nnode->nbranch[i].nnode) {
1368                                 found = 1;
1369                                 nnode = nnode->nbranch[i].nnode;
1370                                 *hght = h;
1371                                 break;
1372                         }
1373                 }
1374                 if (!found)
1375                         break;
1376         }
1377         return nnode;
1378 }
1379
1380 /**
1381  * next_nnode - find the next nnode in memory.
1382  * @c: UBIFS file-system description object
1383  * @nnode: nnode from which to start.
1384  * @hght: height of tree where nnode is, is passed and returned here
1385  *
1386  * This function returns a pointer to the nnode found or %NULL if no nnode is
1387  * found. This function is a helper to 'ubifs_lpt_free()'.
1388  */
1389 static struct ubifs_nnode *next_nnode(struct ubifs_info *c,
1390                                       struct ubifs_nnode *nnode, int *hght)
1391 {
1392         struct ubifs_nnode *parent;
1393         int iip, h, i, found;
1394
1395         parent = nnode->parent;
1396         if (!parent)
1397                 return NULL;
1398         if (nnode->iip == UBIFS_LPT_FANOUT - 1) {
1399                 *hght -= 1;
1400                 return parent;
1401         }
1402         for (iip = nnode->iip + 1; iip < UBIFS_LPT_FANOUT; iip++) {
1403                 nnode = parent->nbranch[iip].nnode;
1404                 if (nnode)
1405                         break;
1406         }
1407         if (!nnode) {
1408                 *hght -= 1;
1409                 return parent;
1410         }
1411         for (h = *hght + 1; h < c->lpt_hght; h++) {
1412                 found = 0;
1413                 for (i = 0; i < UBIFS_LPT_FANOUT; i++) {
1414                         if (nnode->nbranch[i].nnode) {
1415                                 found = 1;
1416                                 nnode = nnode->nbranch[i].nnode;
1417                                 *hght = h;
1418                                 break;
1419                         }
1420                 }
1421                 if (!found)
1422                         break;
1423         }
1424         return nnode;
1425 }
1426
1427 /**
1428  * ubifs_lpt_free - free resources owned by the LPT.
1429  * @c: UBIFS file-system description object
1430  * @wr_only: free only resources used for writing
1431  */
1432 void ubifs_lpt_free(struct ubifs_info *c, int wr_only)
1433 {
1434         struct ubifs_nnode *nnode;
1435         int i, hght;
1436
1437         /* Free write-only things first */
1438
1439         free_obsolete_cnodes(c); /* Leftover from a failed commit */
1440
1441         vfree(c->ltab_cmt);
1442         c->ltab_cmt = NULL;
1443         vfree(c->lpt_buf);
1444         c->lpt_buf = NULL;
1445         kfree(c->lsave);
1446         c->lsave = NULL;
1447
1448         if (wr_only)
1449                 return;
1450
1451         /* Now free the rest */
1452
1453         nnode = first_nnode(c, &hght);
1454         while (nnode) {
1455                 for (i = 0; i < UBIFS_LPT_FANOUT; i++)
1456                         kfree(nnode->nbranch[i].nnode);
1457                 nnode = next_nnode(c, nnode, &hght);
1458         }
1459         for (i = 0; i < LPROPS_HEAP_CNT; i++)
1460                 kfree(c->lpt_heap[i].arr);
1461         kfree(c->dirty_idx.arr);
1462         kfree(c->nroot);
1463         vfree(c->ltab);
1464         kfree(c->lpt_nod_buf);
1465 }
1466
1467 #ifdef CONFIG_UBIFS_FS_DEBUG
1468
1469 /**
1470  * dbg_is_all_ff - determine if a buffer contains only 0xFF bytes.
1471  * @buf: buffer
1472  * @len: buffer length
1473  */
1474 static int dbg_is_all_ff(uint8_t *buf, int len)
1475 {
1476         int i;
1477
1478         for (i = 0; i < len; i++)
1479                 if (buf[i] != 0xff)
1480                         return 0;
1481         return 1;
1482 }
1483
1484 /**
1485  * dbg_is_nnode_dirty - determine if a nnode is dirty.
1486  * @c: the UBIFS file-system description object
1487  * @lnum: LEB number where nnode was written
1488  * @offs: offset where nnode was written
1489  */
1490 static int dbg_is_nnode_dirty(struct ubifs_info *c, int lnum, int offs)
1491 {
1492         struct ubifs_nnode *nnode;
1493         int hght;
1494
1495         /* Entire tree is in memory so first_nnode / next_nnode are OK */
1496         nnode = first_nnode(c, &hght);
1497         for (; nnode; nnode = next_nnode(c, nnode, &hght)) {
1498                 struct ubifs_nbranch *branch;
1499
1500                 cond_resched();
1501                 if (nnode->parent) {
1502                         branch = &nnode->parent->nbranch[nnode->iip];
1503                         if (branch->lnum != lnum || branch->offs != offs)
1504                                 continue;
1505                         if (test_bit(DIRTY_CNODE, &nnode->flags))
1506                                 return 1;
1507                         return 0;
1508                 } else {
1509                         if (c->lpt_lnum != lnum || c->lpt_offs != offs)
1510                                 continue;
1511                         if (test_bit(DIRTY_CNODE, &nnode->flags))
1512                                 return 1;
1513                         return 0;
1514                 }
1515         }
1516         return 1;
1517 }
1518
1519 /**
1520  * dbg_is_pnode_dirty - determine if a pnode is dirty.
1521  * @c: the UBIFS file-system description object
1522  * @lnum: LEB number where pnode was written
1523  * @offs: offset where pnode was written
1524  */
1525 static int dbg_is_pnode_dirty(struct ubifs_info *c, int lnum, int offs)
1526 {
1527         int i, cnt;
1528
1529         cnt = DIV_ROUND_UP(c->main_lebs, UBIFS_LPT_FANOUT);
1530         for (i = 0; i < cnt; i++) {
1531                 struct ubifs_pnode *pnode;
1532                 struct ubifs_nbranch *branch;
1533
1534                 cond_resched();
1535                 pnode = pnode_lookup(c, i);
1536                 if (IS_ERR(pnode))
1537                         return PTR_ERR(pnode);
1538                 branch = &pnode->parent->nbranch[pnode->iip];
1539                 if (branch->lnum != lnum || branch->offs != offs)
1540                         continue;
1541                 if (test_bit(DIRTY_CNODE, &pnode->flags))
1542                         return 1;
1543                 return 0;
1544         }
1545         return 1;
1546 }
1547
1548 /**
1549  * dbg_is_ltab_dirty - determine if a ltab node is dirty.
1550  * @c: the UBIFS file-system description object
1551  * @lnum: LEB number where ltab node was written
1552  * @offs: offset where ltab node was written
1553  */
1554 static int dbg_is_ltab_dirty(struct ubifs_info *c, int lnum, int offs)
1555 {
1556         if (lnum != c->ltab_lnum || offs != c->ltab_offs)
1557                 return 1;
1558         return (c->lpt_drty_flgs & LTAB_DIRTY) != 0;
1559 }
1560
1561 /**
1562  * dbg_is_lsave_dirty - determine if a lsave node is dirty.
1563  * @c: the UBIFS file-system description object
1564  * @lnum: LEB number where lsave node was written
1565  * @offs: offset where lsave node was written
1566  */
1567 static int dbg_is_lsave_dirty(struct ubifs_info *c, int lnum, int offs)
1568 {
1569         if (lnum != c->lsave_lnum || offs != c->lsave_offs)
1570                 return 1;
1571         return (c->lpt_drty_flgs & LSAVE_DIRTY) != 0;
1572 }
1573
1574 /**
1575  * dbg_is_node_dirty - determine if a node is dirty.
1576  * @c: the UBIFS file-system description object
1577  * @node_type: node type
1578  * @lnum: LEB number where node was written
1579  * @offs: offset where node was written
1580  */
1581 static int dbg_is_node_dirty(struct ubifs_info *c, int node_type, int lnum,
1582                              int offs)
1583 {
1584         switch (node_type) {
1585         case UBIFS_LPT_NNODE:
1586                 return dbg_is_nnode_dirty(c, lnum, offs);
1587         case UBIFS_LPT_PNODE:
1588                 return dbg_is_pnode_dirty(c, lnum, offs);
1589         case UBIFS_LPT_LTAB:
1590                 return dbg_is_ltab_dirty(c, lnum, offs);
1591         case UBIFS_LPT_LSAVE:
1592                 return dbg_is_lsave_dirty(c, lnum, offs);
1593         }
1594         return 1;
1595 }
1596
1597 /**
1598  * dbg_check_ltab_lnum - check the ltab for a LPT LEB number.
1599  * @c: the UBIFS file-system description object
1600  * @lnum: LEB number where node was written
1601  * @offs: offset where node was written
1602  *
1603  * This function returns %0 on success and a negative error code on failure.
1604  */
1605 static int dbg_check_ltab_lnum(struct ubifs_info *c, int lnum)
1606 {
1607         int err, len = c->leb_size, dirty = 0, node_type, node_num, node_len;
1608         int ret;
1609         void *buf = c->dbg->buf;
1610
1611         if (!(ubifs_chk_flags & UBIFS_CHK_LPROPS))
1612                 return 0;
1613
1614         dbg_lp("LEB %d", lnum);
1615         err = ubi_read(c->ubi, lnum, buf, 0, c->leb_size);
1616         if (err) {
1617                 dbg_msg("ubi_read failed, LEB %d, error %d", lnum, err);
1618                 return err;
1619         }
1620         while (1) {
1621                 if (!is_a_node(c, buf, len)) {
1622                         int i, pad_len;
1623
1624                         pad_len = get_pad_len(c, buf, len);
1625                         if (pad_len) {
1626                                 buf += pad_len;
1627                                 len -= pad_len;
1628                                 dirty += pad_len;
1629                                 continue;
1630                         }
1631                         if (!dbg_is_all_ff(buf, len)) {
1632                                 dbg_msg("invalid empty space in LEB %d at %d",
1633                                         lnum, c->leb_size - len);
1634                                 err = -EINVAL;
1635                         }
1636                         i = lnum - c->lpt_first;
1637                         if (len != c->ltab[i].free) {
1638                                 dbg_msg("invalid free space in LEB %d "
1639                                         "(free %d, expected %d)",
1640                                         lnum, len, c->ltab[i].free);
1641                                 err = -EINVAL;
1642                         }
1643                         if (dirty != c->ltab[i].dirty) {
1644                                 dbg_msg("invalid dirty space in LEB %d "
1645                                         "(dirty %d, expected %d)",
1646                                         lnum, dirty, c->ltab[i].dirty);
1647                                 err = -EINVAL;
1648                         }
1649                         return err;
1650                 }
1651                 node_type = get_lpt_node_type(c, buf, &node_num);
1652                 node_len = get_lpt_node_len(c, node_type);
1653                 ret = dbg_is_node_dirty(c, node_type, lnum, c->leb_size - len);
1654                 if (ret == 1)
1655                         dirty += node_len;
1656                 buf += node_len;
1657                 len -= node_len;
1658         }
1659 }
1660
1661 /**
1662  * dbg_check_ltab - check the free and dirty space in the ltab.
1663  * @c: the UBIFS file-system description object
1664  *
1665  * This function returns %0 on success and a negative error code on failure.
1666  */
1667 int dbg_check_ltab(struct ubifs_info *c)
1668 {
1669         int lnum, err, i, cnt;
1670
1671         if (!(ubifs_chk_flags & UBIFS_CHK_LPROPS))
1672                 return 0;
1673
1674         /* Bring the entire tree into memory */
1675         cnt = DIV_ROUND_UP(c->main_lebs, UBIFS_LPT_FANOUT);
1676         for (i = 0; i < cnt; i++) {
1677                 struct ubifs_pnode *pnode;
1678
1679                 pnode = pnode_lookup(c, i);
1680                 if (IS_ERR(pnode))
1681                         return PTR_ERR(pnode);
1682                 cond_resched();
1683         }
1684
1685         /* Check nodes */
1686         err = dbg_check_lpt_nodes(c, (struct ubifs_cnode *)c->nroot, 0, 0);
1687         if (err)
1688                 return err;
1689
1690         /* Check each LEB */
1691         for (lnum = c->lpt_first; lnum <= c->lpt_last; lnum++) {
1692                 err = dbg_check_ltab_lnum(c, lnum);
1693                 if (err) {
1694                         dbg_err("failed at LEB %d", lnum);
1695                         return err;
1696                 }
1697         }
1698
1699         dbg_lp("succeeded");
1700         return 0;
1701 }
1702
1703 /**
1704  * dbg_chk_lpt_free_spc - check LPT free space is enough to write entire LPT.
1705  * @c: the UBIFS file-system description object
1706  *
1707  * This function returns %0 on success and a negative error code on failure.
1708  */
1709 int dbg_chk_lpt_free_spc(struct ubifs_info *c)
1710 {
1711         long long free = 0;
1712         int i;
1713
1714         if (!(ubifs_chk_flags & UBIFS_CHK_LPROPS))
1715                 return 0;
1716
1717         for (i = 0; i < c->lpt_lebs; i++) {
1718                 if (c->ltab[i].tgc || c->ltab[i].cmt)
1719                         continue;
1720                 if (i + c->lpt_first == c->nhead_lnum)
1721                         free += c->leb_size - c->nhead_offs;
1722                 else if (c->ltab[i].free == c->leb_size)
1723                         free += c->leb_size;
1724         }
1725         if (free < c->lpt_sz) {
1726                 dbg_err("LPT space error: free %lld lpt_sz %lld",
1727                         free, c->lpt_sz);
1728                 dbg_dump_lpt_info(c);
1729                 dbg_dump_lpt_lebs(c);
1730                 dump_stack();
1731                 return -EINVAL;
1732         }
1733         return 0;
1734 }
1735
1736 /**
1737  * dbg_chk_lpt_sz - check LPT does not write more than LPT size.
1738  * @c: the UBIFS file-system description object
1739  * @action: action
1740  * @len: length written
1741  *
1742  * This function returns %0 on success and a negative error code on failure.
1743  */
1744 int dbg_chk_lpt_sz(struct ubifs_info *c, int action, int len)
1745 {
1746         struct ubifs_debug_info *d = c->dbg;
1747         long long chk_lpt_sz, lpt_sz;
1748         int err = 0;
1749
1750         if (!(ubifs_chk_flags & UBIFS_CHK_LPROPS))
1751                 return 0;
1752
1753         switch (action) {
1754         case 0:
1755                 d->chk_lpt_sz = 0;
1756                 d->chk_lpt_sz2 = 0;
1757                 d->chk_lpt_lebs = 0;
1758                 d->chk_lpt_wastage = 0;
1759                 if (c->dirty_pn_cnt > c->pnode_cnt) {
1760                         dbg_err("dirty pnodes %d exceed max %d",
1761                                 c->dirty_pn_cnt, c->pnode_cnt);
1762                         err = -EINVAL;
1763                 }
1764                 if (c->dirty_nn_cnt > c->nnode_cnt) {
1765                         dbg_err("dirty nnodes %d exceed max %d",
1766                                 c->dirty_nn_cnt, c->nnode_cnt);
1767                         err = -EINVAL;
1768                 }
1769                 return err;
1770         case 1:
1771                 d->chk_lpt_sz += len;
1772                 return 0;
1773         case 2:
1774                 d->chk_lpt_sz += len;
1775                 d->chk_lpt_wastage += len;
1776                 d->chk_lpt_lebs += 1;
1777                 return 0;
1778         case 3:
1779                 chk_lpt_sz = c->leb_size;
1780                 chk_lpt_sz *= d->chk_lpt_lebs;
1781                 chk_lpt_sz += len - c->nhead_offs;
1782                 if (d->chk_lpt_sz != chk_lpt_sz) {
1783                         dbg_err("LPT wrote %lld but space used was %lld",
1784                                 d->chk_lpt_sz, chk_lpt_sz);
1785                         err = -EINVAL;
1786                 }
1787                 if (d->chk_lpt_sz > c->lpt_sz) {
1788                         dbg_err("LPT wrote %lld but lpt_sz is %lld",
1789                                 d->chk_lpt_sz, c->lpt_sz);
1790                         err = -EINVAL;
1791                 }
1792                 if (d->chk_lpt_sz2 && d->chk_lpt_sz != d->chk_lpt_sz2) {
1793                         dbg_err("LPT layout size %lld but wrote %lld",
1794                                 d->chk_lpt_sz, d->chk_lpt_sz2);
1795                         err = -EINVAL;
1796                 }
1797                 if (d->chk_lpt_sz2 && d->new_nhead_offs != len) {
1798                         dbg_err("LPT new nhead offs: expected %d was %d",
1799                                 d->new_nhead_offs, len);
1800                         err = -EINVAL;
1801                 }
1802                 lpt_sz = (long long)c->pnode_cnt * c->pnode_sz;
1803                 lpt_sz += (long long)c->nnode_cnt * c->nnode_sz;
1804                 lpt_sz += c->ltab_sz;
1805                 if (c->big_lpt)
1806                         lpt_sz += c->lsave_sz;
1807                 if (d->chk_lpt_sz - d->chk_lpt_wastage > lpt_sz) {
1808                         dbg_err("LPT chk_lpt_sz %lld + waste %lld exceeds %lld",
1809                                 d->chk_lpt_sz, d->chk_lpt_wastage, lpt_sz);
1810                         err = -EINVAL;
1811                 }
1812                 if (err) {
1813                         dbg_dump_lpt_info(c);
1814                         dbg_dump_lpt_lebs(c);
1815                         dump_stack();
1816                 }
1817                 d->chk_lpt_sz2 = d->chk_lpt_sz;
1818                 d->chk_lpt_sz = 0;
1819                 d->chk_lpt_wastage = 0;
1820                 d->chk_lpt_lebs = 0;
1821                 d->new_nhead_offs = len;
1822                 return err;
1823         case 4:
1824                 d->chk_lpt_sz += len;
1825                 d->chk_lpt_wastage += len;
1826                 return 0;
1827         default:
1828                 return -EINVAL;
1829         }
1830 }
1831
1832 /**
1833  * dbg_dump_lpt_leb - dump an LPT LEB.
1834  * @c: UBIFS file-system description object
1835  * @lnum: LEB number to dump
1836  *
1837  * This function dumps an LEB from LPT area. Nodes in this area are very
1838  * different to nodes in the main area (e.g., they do not have common headers,
1839  * they do not have 8-byte alignments, etc), so we have a separate function to
1840  * dump LPT area LEBs. Note, LPT has to be locked by the caller.
1841  */
1842 static void dump_lpt_leb(const struct ubifs_info *c, int lnum)
1843 {
1844         int err, len = c->leb_size, node_type, node_num, node_len, offs;
1845         void *buf = c->dbg->buf;
1846
1847         printk(KERN_DEBUG "(pid %d) start dumping LEB %d\n",
1848                current->pid, lnum);
1849         err = ubi_read(c->ubi, lnum, buf, 0, c->leb_size);
1850         if (err) {
1851                 ubifs_err("cannot read LEB %d, error %d", lnum, err);
1852                 return;
1853         }
1854         while (1) {
1855                 offs = c->leb_size - len;
1856                 if (!is_a_node(c, buf, len)) {
1857                         int pad_len;
1858
1859                         pad_len = get_pad_len(c, buf, len);
1860                         if (pad_len) {
1861                                 printk(KERN_DEBUG "LEB %d:%d, pad %d bytes\n",
1862                                        lnum, offs, pad_len);
1863                                 buf += pad_len;
1864                                 len -= pad_len;
1865                                 continue;
1866                         }
1867                         if (len)
1868                                 printk(KERN_DEBUG "LEB %d:%d, free %d bytes\n",
1869                                        lnum, offs, len);
1870                         break;
1871                 }
1872
1873                 node_type = get_lpt_node_type(c, buf, &node_num);
1874                 switch (node_type) {
1875                 case UBIFS_LPT_PNODE:
1876                 {
1877                         node_len = c->pnode_sz;
1878                         if (c->big_lpt)
1879                                 printk(KERN_DEBUG "LEB %d:%d, pnode num %d\n",
1880                                        lnum, offs, node_num);
1881                         else
1882                                 printk(KERN_DEBUG "LEB %d:%d, pnode\n",
1883                                        lnum, offs);
1884                         break;
1885                 }
1886                 case UBIFS_LPT_NNODE:
1887                 {
1888                         int i;
1889                         struct ubifs_nnode nnode;
1890
1891                         node_len = c->nnode_sz;
1892                         if (c->big_lpt)
1893                                 printk(KERN_DEBUG "LEB %d:%d, nnode num %d, ",
1894                                        lnum, offs, node_num);
1895                         else
1896                                 printk(KERN_DEBUG "LEB %d:%d, nnode, ",
1897                                        lnum, offs);
1898                         err = ubifs_unpack_nnode(c, buf, &nnode);
1899                         for (i = 0; i < UBIFS_LPT_FANOUT; i++) {
1900                                 printk("%d:%d", nnode.nbranch[i].lnum,
1901                                        nnode.nbranch[i].offs);
1902                                 if (i != UBIFS_LPT_FANOUT - 1)
1903                                         printk(", ");
1904                         }
1905                         printk("\n");
1906                         break;
1907                 }
1908                 case UBIFS_LPT_LTAB:
1909                         node_len = c->ltab_sz;
1910                         printk(KERN_DEBUG "LEB %d:%d, ltab\n",
1911                                lnum, offs);
1912                         break;
1913                 case UBIFS_LPT_LSAVE:
1914                         node_len = c->lsave_sz;
1915                         printk(KERN_DEBUG "LEB %d:%d, lsave len\n", lnum, offs);
1916                         break;
1917                 default:
1918                         ubifs_err("LPT node type %d not recognized", node_type);
1919                         return;
1920                 }
1921
1922                 buf += node_len;
1923                 len -= node_len;
1924         }
1925
1926         printk(KERN_DEBUG "(pid %d) finish dumping LEB %d\n",
1927                current->pid, lnum);
1928 }
1929
1930 /**
1931  * dbg_dump_lpt_lebs - dump LPT lebs.
1932  * @c: UBIFS file-system description object
1933  *
1934  * This function dumps all LPT LEBs. The caller has to make sure the LPT is
1935  * locked.
1936  */
1937 void dbg_dump_lpt_lebs(const struct ubifs_info *c)
1938 {
1939         int i;
1940
1941         printk(KERN_DEBUG "(pid %d) start dumping all LPT LEBs\n",
1942                current->pid);
1943         for (i = 0; i < c->lpt_lebs; i++)
1944                 dump_lpt_leb(c, i + c->lpt_first);
1945         printk(KERN_DEBUG "(pid %d) finish dumping all LPT LEBs\n",
1946                current->pid);
1947 }
1948
1949 #endif /* CONFIG_UBIFS_FS_DEBUG */