Merge branch 'linux-next' of git://git.infradead.org/~dedekind/ubifs-2.6

	int subtract_lebs;

	long long available;

	/*

	 * Force the amount available to the total size reported if the used

	 * space is zero.

	 */

	if (c->lst.total_used <= UBIFS_INO_NODE_SZ &&

	    c->budg_data_growth + c->budg_dd_growth == 0) {

		/* Do the same calculation as for c->block_cnt */

		available = c->main_lebs - 2;

		available *= c->leb_size - c->dark_wm;

		return available;

	}

	available = c->main_bytes - c->lst.total_used;

	/*

}

/**

 * ubifs_budg_get_free_space - return amount of free space.

 * @c: UBIFS file-system description object

 * ubifs_reported_space - calculate reported free space.

 * @c: the UBIFS file-system description object

 * @free: amount of free space

 *

 * This function calculates amount of free space which will be reported to

 * user-space. User-space application tend to expect that if the file-system

 * (e.g., via the 'statfs()' call) reports that it has N bytes available, they

 * are able to write a file of size N. UBIFS attaches node headers to each data

 * node and it has to write indexind nodes as well. This introduces additional

 * overhead, and UBIFS it has to report sligtly less free space to meet the

 * above expectetion.

 *

 * This function assumes free space is made up of uncompressed data nodes and

 * full index nodes (one per data node, tripled because we always allow enough

 * space to write the index thrice).

 *

 * This function returns amount of free space on the file-system.

 * Note, the calculation is pessimistic, which means that most of the time

 * UBIFS reports less space than it actually has.

 */

long long ubifs_budg_get_free_space(struct ubifs_info *c)

long long ubifs_reported_space(const struct ubifs_info *c, uint64_t free)

{

	int divisor, factor, f;

	/*

	 * Reported space size is @free * X, where X is UBIFS block size

	 * divided by UBIFS block size + all overhead one data block

	 * introduces. The overhead is the node header + indexing overhead.

	 *

	 * Indexing overhead calculations are based on the following formula:

	 * I = N/(f - 1) + 1, where I - number of indexing nodes, N - number

	 * of data nodes, f - fanout. Because effective UBIFS fanout is twice

	 * as less than maximum fanout, we assume that each data node

	 * introduces 3 * @c->max_idx_node_sz / (@c->fanout/2 - 1) bytes.

	 * Note, the multiplier 3 is because UBIFS reseves thrice as more space

	 * for the index.

	 */

	f = c->fanout > 3 ? c->fanout >> 1 : 2;

	factor = UBIFS_BLOCK_SIZE;

	divisor = UBIFS_MAX_DATA_NODE_SZ;

	divisor += (c->max_idx_node_sz * 3) / (f - 1);

	free *= factor;

	do_div(free, divisor);

	return free;

}

/**

 * ubifs_get_free_space - return amount of free space.

 * @c: UBIFS file-system description object

 *

 * This function calculates amount of free space to report to user-space.

 *

 * Because UBIFS may introduce substantial overhead (the index, node headers,

 * alighment, wastage at the end of eraseblocks, etc), it cannot report real

 * amount of free flash space it has (well, because not all dirty space is

 * reclamable, UBIFS does not actually know the real amount). If UBIFS did so,

 * it would bread user expectetion about what free space is. Users seem to

 * accustomed to assume that if the file-system reports N bytes of free space,

 * they would be able to fit a file of N bytes to the FS. This almost works for

 * traditional file-systems, because they have way less overhead than UBIFS.

 * So, to keep users happy, UBIFS tries to take the overhead into account.

 */

long long ubifs_get_free_space(struct ubifs_info *c)

{

	int min_idx_lebs, rsvd_idx_lebs;

	int min_idx_lebs, rsvd_idx_lebs, lebs;

	long long available, outstanding, free;

	/* Do exactly the same calculations as in 'do_budget_space()' */

	spin_lock(&c->space_lock);

	min_idx_lebs = ubifs_calc_min_idx_lebs(c);

	outstanding = c->budg_data_growth + c->budg_dd_growth;

	if (min_idx_lebs > c->lst.idx_lebs)

		rsvd_idx_lebs = min_idx_lebs - c->lst.idx_lebs;

	else

		rsvd_idx_lebs = 0;

	if (rsvd_idx_lebs > c->lst.empty_lebs + c->freeable_cnt + c->idx_gc_cnt

				- c->lst.taken_empty_lebs) {

	/*

	 * Force the amount available to the total size reported if the used

	 * space is zero.

	 */

	if (c->lst.total_used <= UBIFS_INO_NODE_SZ && !outstanding) {

		spin_unlock(&c->space_lock);

		return 0;

		return (long long)c->block_cnt << UBIFS_BLOCK_SHIFT;

	}

	available = ubifs_calc_available(c, min_idx_lebs);

	outstanding = c->budg_data_growth + c->budg_dd_growth;

	c->min_idx_lebs = min_idx_lebs;

	/*

	 * When reporting free space to user-space, UBIFS guarantees that it is

	 * possible to write a file of free space size. This means that for

	 * empty LEBs we may use more precise calculations than

	 * 'ubifs_calc_available()' is using. Namely, we know that in empty

	 * LEBs we would waste only @c->leb_overhead bytes, not @c->dark_wm.

	 * Thus, amend the available space.

	 *

	 * Note, the calculations below are similar to what we have in

	 * 'do_budget_space()', so refer there for comments.

	 */

	if (min_idx_lebs > c->lst.idx_lebs)

		rsvd_idx_lebs = min_idx_lebs - c->lst.idx_lebs;

	else

		rsvd_idx_lebs = 0;

	lebs = c->lst.empty_lebs + c->freeable_cnt + c->idx_gc_cnt -

	       c->lst.taken_empty_lebs;

	lebs -= rsvd_idx_lebs;

	available += lebs * (c->dark_wm - c->leb_overhead);

	spin_unlock(&c->space_lock);

	if (available > outstanding)

	if (err) {

		if (err != -ENOSPC)

			return err;

		err = 0;

		budgeted = 0;

	}

	int err;

	struct ubifs_budget_req req;

	loff_t old_size = inode->i_size, new_size = attr->ia_size;

	int offset = new_size & (UBIFS_BLOCK_SIZE - 1);

	int offset = new_size & (UBIFS_BLOCK_SIZE - 1), budgeted = 1;

	struct ubifs_inode *ui = ubifs_inode(inode);

	dbg_gen("ino %lu, size %lld -> %lld", inode->i_ino, old_size, new_size);

	/* A funny way to budget for truncation node */

	req.dirtied_ino_d = UBIFS_TRUN_NODE_SZ;

	err = ubifs_budget_space(c, &req);

	if (err)

	if (err) {

		/*

		 * Treat truncations to zero as deletion and always allow them,

		 * just like we do for '->unlink()'.

		 */

		if (new_size || err != -ENOSPC)

			return err;

		budgeted = 0;

	}

	err = vmtruncate(inode, new_size);

	if (err)

	err = ubifs_jnl_truncate(c, inode, old_size, new_size);

	mutex_unlock(&ui->ui_mutex);

out_budg:

	if (budgeted)

		ubifs_release_budget(c, &req);

	else {

		c->nospace = c->nospace_rp = 0;

		smp_wmb();

	}

	return err;

}

 * dirty index heap, and it falls-back to LPT scanning if the heaps are empty

 * or do not have an LEB which satisfies the @min_space criteria.

 *

 * Note:

 *   o LEBs which have less than dead watermark of dirty space are never picked

 *   by this function;

 *

 * Returns zero and the LEB properties of

 * found dirty LEB in case of success, %-ENOSPC if no dirty LEB was found and a

 * negative error code in case of other failures. The returned LEB is marked as

 * "taken".

 * Note, LEBs which have less than dead watermark of free + dirty space are

 * never picked by this function.

 *

 * The additional @pick_free argument controls if this function has to return a

 * free or freeable LEB if one is present. For example, GC must to set it to %1,

 *

 * In addition @pick_free is set to %2 by the recovery process in order to

 * recover gc_lnum in which case an index LEB must not be returned.

 *

 * This function returns zero and the LEB properties of found dirty LEB in case

 * of success, %-ENOSPC if no dirty LEB was found and a negative error code in

 * case of other failures. The returned LEB is marked as "taken".

 */

int ubifs_find_dirty_leb(struct ubifs_info *c, struct ubifs_lprops *ret_lp,

			 int min_space, int pick_free)

		int lebs, rsvd_idx_lebs = 0;

		spin_lock(&c->space_lock);

		lebs = c->lst.empty_lebs;

		lebs = c->lst.empty_lebs + c->idx_gc_cnt;

		lebs += c->freeable_cnt - c->lst.taken_empty_lebs;

		/*

		lp = idx_lp;

	if (lp) {

		ubifs_assert(lp->dirty >= c->dead_wm);

		ubifs_assert(lp->free + lp->dirty >= c->dead_wm);

		goto found;

	}

		if (err)

			goto out;

		/* Allow for races with TNC */

		c->gced_lnum = lnum;

		smp_wmb();

		c->gc_seq += 1;

		smp_wmb();

		if (c->gc_lnum == -1) {

			c->gc_lnum = lnum;

			err = LEB_RETAINED;