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