UBIFS: use nicer 64-bit math (4d61db4f) · Commits · jan.koester / Linux

fs/ubifs/budget.c

+11 −14

Original line number	Diff line number	Diff line
		@@ -32,7 +32,7 @@

		#include "ubifs.h"
		#include <linux/writeback.h>
		#include <asm/div64.h>
		#include <linux/math64.h>

		/*
		* When pessimistic budget calculations say that there is no enough space,
		@@ -258,8 +258,8 @@ static int make_free_space(struct ubifs_info c, struct retries_info ri)
		*/
		int ubifs_calc_min_idx_lebs(struct ubifs_info *c)
		{
		int ret;
		uint64_t idx_size;
		int idx_lebs, eff_leb_size = c->leb_size - c->max_idx_node_sz;
		long long idx_size;

		idx_size = c->old_idx_sz + c->budg_idx_growth + c->budg_uncommitted_idx;

		@@ -271,18 +271,16 @@ int ubifs_calc_min_idx_lebs(struct ubifs_info *c)
		* pair, nor similarly the two variables for the new index size, so we
		* have to do this costly 64-bit division on fast-path.
		*/
		if (do_div(idx_size, c->leb_size - c->max_idx_node_sz))
		ret = idx_size + 1;
		else
		ret = idx_size;
		idx_size += eff_leb_size - 1;
		idx_lebs = div_u64(idx_size, eff_leb_size);
		/*
		* The index head is not available for the in-the-gaps method, so add an
		* extra LEB to compensate.
		*/
		ret += 1;
		if (ret < MIN_INDEX_LEBS)
		ret = MIN_INDEX_LEBS;
		return ret;
		idx_lebs += 1;
		if (idx_lebs < MIN_INDEX_LEBS)
		idx_lebs = MIN_INDEX_LEBS;
		return idx_lebs;
		}

		/**
		@@ -718,7 +716,7 @@ void ubifs_release_dirty_inode_budget(struct ubifs_info *c,
		* Note, the calculation is pessimistic, which means that most of the time
		* UBIFS reports less space than it actually has.
		*/
		long long ubifs_reported_space(const struct ubifs_info *c, uint64_t free)
		long long ubifs_reported_space(const struct ubifs_info *c, long long free)
		{
		int divisor, factor, f;

		@@ -740,8 +738,7 @@ long long ubifs_reported_space(const struct ubifs_info *c, uint64_t free)
		divisor = UBIFS_MAX_DATA_NODE_SZ;
		divisor += (c->max_idx_node_sz * 3) / (f - 1);
		free *= factor;
		do_div(free, divisor);
		return free;
		return div_u64(free, divisor);
		}

		/**

fs/ubifs/debug.c

+1 −0

Original line number	Diff line number	Diff line
		@@ -33,6 +33,7 @@
		#include <linux/module.h>
		#include <linux/moduleparam.h>
		#include <linux/debugfs.h>
		#include <linux/math64.h>

		#ifdef CONFIG_UBIFS_FS_DEBUG

fs/ubifs/lpt.c

+6 −9

Original line number	Diff line number	Diff line
		@@ -43,8 +43,9 @@
		* mounted.
		*/

		#include <linux/crc16.h>
		#include "ubifs.h"
		#include <linux/crc16.h>
		#include <linux/math64.h>

		/**
		* do_calc_lpt_geom - calculate sizes for the LPT area.
		@@ -135,15 +136,13 @@ static void do_calc_lpt_geom(struct ubifs_info *c)
		int ubifs_calc_lpt_geom(struct ubifs_info *c)
		{
		int lebs_needed;
		uint64_t sz;
		long long sz;

		do_calc_lpt_geom(c);

		/* Verify that lpt_lebs is big enough */
		sz = c->lpt_sz * 2; /* Must have at least 2 times the size */
		sz += c->leb_size - 1;
		do_div(sz, c->leb_size);
		lebs_needed = sz;
		lebs_needed = div_u64(sz + c->leb_size - 1, c->leb_size);
		if (lebs_needed > c->lpt_lebs) {
		ubifs_err("too few LPT LEBs");
		return -EINVAL;
		@@ -175,7 +174,7 @@ static int calc_dflt_lpt_geom(struct ubifs_info c, int main_lebs,
		int *big_lpt)
		{
		int i, lebs_needed;
		uint64_t sz;
		long long sz;

		/* Start by assuming the minimum number of LPT LEBs */
		c->lpt_lebs = UBIFS_MIN_LPT_LEBS;
		@@ -202,9 +201,7 @@ static int calc_dflt_lpt_geom(struct ubifs_info c, int main_lebs,
		/* Now check there are enough LPT LEBs */
		for (i = 0; i < 64 ; i++) {
		sz = c->lpt_sz * 4; /* Allow 4 times the size */
		sz += c->leb_size - 1;
		do_div(sz, c->leb_size);
		lebs_needed = sz;
		lebs_needed = div_u64(sz + c->leb_size - 1, c->leb_size);
		if (lebs_needed > c->lpt_lebs) {
		/* Not enough LPT LEBs so try again with more */
		c->lpt_lebs = lebs_needed;

fs/ubifs/sb.c

+5 −5

Original line number	Diff line number	Diff line
		@@ -28,6 +28,7 @@

		#include "ubifs.h"
		#include <linux/random.h>
		#include <linux/math64.h>

		/*
		* Default journal size in logical eraseblocks as a percent of total
		@@ -80,7 +81,7 @@ static int create_default_filesystem(struct ubifs_info *c)
		int err, tmp, jnl_lebs, log_lebs, max_buds, main_lebs, main_first;
		int lpt_lebs, lpt_first, orph_lebs, big_lpt, ino_waste, sup_flags = 0;
		int min_leb_cnt = UBIFS_MIN_LEB_CNT;
		uint64_t tmp64, main_bytes;
		long long tmp64, main_bytes;
		__le64 tmp_le64;

		/* Some functions called from here depend on the @c->key_len filed */
		@@ -160,7 +161,7 @@ static int create_default_filesystem(struct ubifs_info *c)
		if (!sup)
		return -ENOMEM;

		tmp64 = (uint64_t)max_buds * c->leb_size;
		tmp64 = (long long)max_buds * c->leb_size;
		if (big_lpt)
		sup_flags \|= UBIFS_FLG_BIGLPT;

		@@ -187,9 +188,8 @@ static int create_default_filesystem(struct ubifs_info *c)

		generate_random_uuid(sup->uuid);

		main_bytes = (uint64_t)main_lebs * c->leb_size;
		tmp64 = main_bytes * DEFAULT_RP_PERCENT;
		do_div(tmp64, 100);
		main_bytes = (long long)main_lebs * c->leb_size;
		tmp64 = div_u64(main_bytes * DEFAULT_RP_PERCENT, 100);
		if (tmp64 > DEFAULT_MAX_RP_SIZE)
		tmp64 = DEFAULT_MAX_RP_SIZE;
		sup->rp_size = cpu_to_le64(tmp64);

fs/ubifs/super.c

+6 −6

Original line number	Diff line number	Diff line
		@@ -34,6 +34,7 @@
		#include <linux/parser.h>
		#include <linux/seq_file.h>
		#include <linux/mount.h>
		#include <linux/math64.h>
		#include "ubifs.h"

		/*
		@@ -612,7 +613,7 @@ static int bud_wbuf_callback(struct ubifs_info *c, int lnum, int free, int pad)
		static int init_constants_late(struct ubifs_info *c)
		{
		int tmp, err;
		uint64_t tmp64;
		long long tmp64;

		c->main_bytes = (long long)c->main_lebs * c->leb_size;
		c->max_znode_sz = sizeof(struct ubifs_znode) +
		@@ -639,9 +640,8 @@ static int init_constants_late(struct ubifs_info *c)
		* Make sure that the log is large enough to fit reference nodes for
		* all buds plus one reserved LEB.
		*/
		tmp64 = c->max_bud_bytes;
		tmp = do_div(tmp64, c->leb_size);
		c->max_bud_cnt = tmp64 + !!tmp;
		tmp64 = c->max_bud_bytes + c->leb_size - 1;
		c->max_bud_cnt = div_u64(tmp64, c->leb_size);
		tmp = (c->ref_node_alsz * c->max_bud_cnt + c->leb_size - 1);
		tmp /= c->leb_size;
		tmp += 1;
		@@ -677,7 +677,7 @@ static int init_constants_late(struct ubifs_info *c)
		* Consequently, if the journal is too small, UBIFS will treat it as
		* always full.
		*/
		tmp64 = (uint64_t)(c->jhead_cnt + 1) * c->leb_size + 1;
		tmp64 = (long long)(c->jhead_cnt + 1) * c->leb_size + 1;
		if (c->bg_bud_bytes < tmp64)
		c->bg_bud_bytes = tmp64;
		if (c->max_bud_bytes < tmp64 + c->leb_size)
		@@ -699,7 +699,7 @@ static int init_constants_late(struct ubifs_info *c)
		* head is available.
		*/
		tmp64 = c->main_lebs - 1 - 1 - MIN_INDEX_LEBS - c->jhead_cnt + 1;
		tmp64 *= (uint64_t)c->leb_size - c->leb_overhead;
		tmp64 *= (long long)c->leb_size - c->leb_overhead;
		tmp64 = ubifs_reported_space(c, tmp64);
		c->block_cnt = tmp64 >> UBIFS_BLOCK_SHIFT;