[J-u-boot.git] / fs / ubifs / sb.c

/*
 * This file is part of UBIFS.
 *
 * Copyright (C) 2006-2008 Nokia Corporation.
 *
 * This program is free software; you can redistribute it and/or modify it
 * under the terms of the GNU General Public License version 2 as published by
 * the Free Software Foundation.
 *
 * This program is distributed in the hope that it will be useful, but WITHOUT
 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
 * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License for
 * more details.
 *
 * You should have received a copy of the GNU General Public License along with
 * this program; if not, write to the Free Software Foundation, Inc., 51
 * Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
 *
 * Authors: Artem Bityutskiy (Битюцкий Артём)
 *          Adrian Hunter
 */

/*
 * This file implements UBIFS superblock. The superblock is stored at the first
 * LEB of the volume and is never changed by UBIFS. Only user-space tools may
 * change it. The superblock node mostly contains geometry information.
 */

#include "ubifs.h"

/*
 * Default journal size in logical eraseblocks as a percent of total
 * flash size.
 */
#define DEFAULT_JNL_PERCENT 5

/* Default maximum journal size in bytes */
#define DEFAULT_MAX_JNL (32*1024*1024)

/* Default indexing tree fanout */
#define DEFAULT_FANOUT 8

/* Default number of data journal heads */
#define DEFAULT_JHEADS_CNT 1

/* Default positions of different LEBs in the main area */
#define DEFAULT_IDX_LEB  0
#define DEFAULT_DATA_LEB 1
#define DEFAULT_GC_LEB   2

/* Default number of LEB numbers in LPT's save table */
#define DEFAULT_LSAVE_CNT 256

/* Default reserved pool size as a percent of maximum free space */
#define DEFAULT_RP_PERCENT 5

/* The default maximum size of reserved pool in bytes */
#define DEFAULT_MAX_RP_SIZE (5*1024*1024)

/* Default time granularity in nanoseconds */
#define DEFAULT_TIME_GRAN 1000000000

/**
 * validate_sb - validate superblock node.
 * @c: UBIFS file-system description object
 * @sup: superblock node
 *
 * This function validates superblock node @sup. Since most of data was read
 * from the superblock and stored in @c, the function validates fields in @c
 * instead. Returns zero in case of success and %-EINVAL in case of validation
 * failure.
 */
static int validate_sb(struct ubifs_info *c, struct ubifs_sb_node *sup)
{
	long long max_bytes;
	int err = 1, min_leb_cnt;

	if (!c->key_hash) {
		err = 2;
		goto failed;
	}

	if (sup->key_fmt != UBIFS_SIMPLE_KEY_FMT) {
		err = 3;
		goto failed;
	}

	if (le32_to_cpu(sup->min_io_size) != c->min_io_size) {
		ubifs_err("min. I/O unit mismatch: %d in superblock, %d real",
			  le32_to_cpu(sup->min_io_size), c->min_io_size);
		goto failed;
	}

	if (le32_to_cpu(sup->leb_size) != c->leb_size) {
		ubifs_err("LEB size mismatch: %d in superblock, %d real",
			  le32_to_cpu(sup->leb_size), c->leb_size);
		goto failed;
	}

	if (c->log_lebs < UBIFS_MIN_LOG_LEBS ||
	    c->lpt_lebs < UBIFS_MIN_LPT_LEBS ||
	    c->orph_lebs < UBIFS_MIN_ORPH_LEBS ||
	    c->main_lebs < UBIFS_MIN_MAIN_LEBS) {
		err = 4;
		goto failed;
	}

	/*
	 * Calculate minimum allowed amount of main area LEBs. This is very
	 * similar to %UBIFS_MIN_LEB_CNT, but we take into account real what we
	 * have just read from the superblock.
	 */
	min_leb_cnt = UBIFS_SB_LEBS + UBIFS_MST_LEBS + c->log_lebs;
	min_leb_cnt += c->lpt_lebs + c->orph_lebs + c->jhead_cnt + 6;

	if (c->leb_cnt < min_leb_cnt || c->leb_cnt > c->vi.size) {
		ubifs_err("bad LEB count: %d in superblock, %d on UBI volume, "
			  "%d minimum required", c->leb_cnt, c->vi.size,
			  min_leb_cnt);
		goto failed;
	}

	if (c->max_leb_cnt < c->leb_cnt) {
		ubifs_err("max. LEB count %d less than LEB count %d",
			  c->max_leb_cnt, c->leb_cnt);
		goto failed;
	}

	if (c->main_lebs < UBIFS_MIN_MAIN_LEBS) {
		err = 7;
		goto failed;
	}

	if (c->max_bud_bytes < (long long)c->leb_size * UBIFS_MIN_BUD_LEBS ||
	    c->max_bud_bytes > (long long)c->leb_size * c->main_lebs) {
		err = 8;
		goto failed;
	}

	if (c->jhead_cnt < NONDATA_JHEADS_CNT + 1 ||
	    c->jhead_cnt > NONDATA_JHEADS_CNT + UBIFS_MAX_JHEADS) {
		err = 9;
		goto failed;
	}

	if (c->fanout < UBIFS_MIN_FANOUT ||
	    ubifs_idx_node_sz(c, c->fanout) > c->leb_size) {
		err = 10;
		goto failed;
	}

	if (c->lsave_cnt < 0 || (c->lsave_cnt > DEFAULT_LSAVE_CNT &&
	    c->lsave_cnt > c->max_leb_cnt - UBIFS_SB_LEBS - UBIFS_MST_LEBS -
	    c->log_lebs - c->lpt_lebs - c->orph_lebs)) {
		err = 11;
		goto failed;
	}

	if (UBIFS_SB_LEBS + UBIFS_MST_LEBS + c->log_lebs + c->lpt_lebs +
	    c->orph_lebs + c->main_lebs != c->leb_cnt) {
		err = 12;
		goto failed;
	}

	if (c->default_compr < 0 || c->default_compr >= UBIFS_COMPR_TYPES_CNT) {
		err = 13;
		goto failed;
	}

	max_bytes = c->main_lebs * (long long)c->leb_size;
	if (c->rp_size < 0 || max_bytes < c->rp_size) {
		err = 14;
		goto failed;
	}

	if (le32_to_cpu(sup->time_gran) > 1000000000 ||
	    le32_to_cpu(sup->time_gran) < 1) {
		err = 15;
		goto failed;
	}

	return 0;

failed:
	ubifs_err("bad superblock, error %d", err);
	dbg_dump_node(c, sup);
	return -EINVAL;
}

/**
 * ubifs_read_sb_node - read superblock node.
 * @c: UBIFS file-system description object
 *
 * This function returns a pointer to the superblock node or a negative error
 * code.
 */
struct ubifs_sb_node *ubifs_read_sb_node(struct ubifs_info *c)
{
	struct ubifs_sb_node *sup;
	int err;

	sup = kmalloc(ALIGN(UBIFS_SB_NODE_SZ, c->min_io_size), GFP_NOFS);
	if (!sup)
		return ERR_PTR(-ENOMEM);

	err = ubifs_read_node(c, sup, UBIFS_SB_NODE, UBIFS_SB_NODE_SZ,
			      UBIFS_SB_LNUM, 0);
	if (err) {
		kfree(sup);
		return ERR_PTR(err);
	}

	return sup;
}

/**
 * ubifs_read_superblock - read superblock.
 * @c: UBIFS file-system description object
 *
 * This function finds, reads and checks the superblock. If an empty UBI volume
 * is being mounted, this function creates default superblock. Returns zero in
 * case of success, and a negative error code in case of failure.
 */
int ubifs_read_superblock(struct ubifs_info *c)
{
	int err, sup_flags;
	struct ubifs_sb_node *sup;

	if (c->empty) {
		printf("No UBIFS filesystem found!\n");
		return -1;
	}

	sup = ubifs_read_sb_node(c);
	if (IS_ERR(sup))
		return PTR_ERR(sup);

	c->fmt_version = le32_to_cpu(sup->fmt_version);
	c->ro_compat_version = le32_to_cpu(sup->ro_compat_version);

	/*
	 * The software supports all previous versions but not future versions,
	 * due to the unavailability of time-travelling equipment.
	 */
	if (c->fmt_version > UBIFS_FORMAT_VERSION) {
		struct super_block *sb = c->vfs_sb;
		int mounting_ro = sb->s_flags & MS_RDONLY;

		ubifs_assert(!c->ro_media || mounting_ro);
		if (!mounting_ro ||
		    c->ro_compat_version > UBIFS_RO_COMPAT_VERSION) {
			ubifs_err("on-flash format version is w%d/r%d, but "
				  "software only supports up to version "
				  "w%d/r%d", c->fmt_version,
				  c->ro_compat_version, UBIFS_FORMAT_VERSION,
				  UBIFS_RO_COMPAT_VERSION);
			if (c->ro_compat_version <= UBIFS_RO_COMPAT_VERSION) {
				ubifs_msg("only R/O mounting is possible");
				err = -EROFS;
			} else
				err = -EINVAL;
			goto out;
		}

		/*
		 * The FS is mounted R/O, and the media format is
		 * R/O-compatible with the UBIFS implementation, so we can
		 * mount.
		 */
		c->rw_incompat = 1;
	}

	if (c->fmt_version < 3) {
		ubifs_err("on-flash format version %d is not supported",
			  c->fmt_version);
		err = -EINVAL;
		goto out;
	}

	switch (sup->key_hash) {
	case UBIFS_KEY_HASH_R5:
		c->key_hash = key_r5_hash;
		c->key_hash_type = UBIFS_KEY_HASH_R5;
		break;

	case UBIFS_KEY_HASH_TEST:
		c->key_hash = key_test_hash;
		c->key_hash_type = UBIFS_KEY_HASH_TEST;
		break;
	};

	c->key_fmt = sup->key_fmt;

	switch (c->key_fmt) {
	case UBIFS_SIMPLE_KEY_FMT:
		c->key_len = UBIFS_SK_LEN;
		break;
	default:
		ubifs_err("unsupported key format");
		err = -EINVAL;
		goto out;
	}

	c->leb_cnt       = le32_to_cpu(sup->leb_cnt);
	c->max_leb_cnt   = le32_to_cpu(sup->max_leb_cnt);
	c->max_bud_bytes = le64_to_cpu(sup->max_bud_bytes);
	c->log_lebs      = le32_to_cpu(sup->log_lebs);
	c->lpt_lebs      = le32_to_cpu(sup->lpt_lebs);
	c->orph_lebs     = le32_to_cpu(sup->orph_lebs);
	c->jhead_cnt     = le32_to_cpu(sup->jhead_cnt) + NONDATA_JHEADS_CNT;
	c->fanout        = le32_to_cpu(sup->fanout);
	c->lsave_cnt     = le32_to_cpu(sup->lsave_cnt);
	c->default_compr = le16_to_cpu(sup->default_compr);
	c->rp_size       = le64_to_cpu(sup->rp_size);
	c->rp_uid        = le32_to_cpu(sup->rp_uid);
	c->rp_gid        = le32_to_cpu(sup->rp_gid);
	sup_flags        = le32_to_cpu(sup->flags);

	c->vfs_sb->s_time_gran = le32_to_cpu(sup->time_gran);
	memcpy(&c->uuid, &sup->uuid, 16);
	c->big_lpt = !!(sup_flags & UBIFS_FLG_BIGLPT);

	/* Automatically increase file system size to the maximum size */
	c->old_leb_cnt = c->leb_cnt;
	if (c->leb_cnt < c->vi.size && c->leb_cnt < c->max_leb_cnt) {
		c->leb_cnt = min_t(int, c->max_leb_cnt, c->vi.size);
		dbg_mnt("Auto resizing (ro) from %d LEBs to %d LEBs",
			c->old_leb_cnt,	c->leb_cnt);
	}

	c->log_bytes = (long long)c->log_lebs * c->leb_size;
	c->log_last = UBIFS_LOG_LNUM + c->log_lebs - 1;
	c->lpt_first = UBIFS_LOG_LNUM + c->log_lebs;
	c->lpt_last = c->lpt_first + c->lpt_lebs - 1;
	c->orph_first = c->lpt_last + 1;
	c->orph_last = c->orph_first + c->orph_lebs - 1;
	c->main_lebs = c->leb_cnt - UBIFS_SB_LEBS - UBIFS_MST_LEBS;
	c->main_lebs -= c->log_lebs + c->lpt_lebs + c->orph_lebs;
	c->main_first = c->leb_cnt - c->main_lebs;
	c->report_rp_size = ubifs_reported_space(c, c->rp_size);

	err = validate_sb(c, sup);
out:
	kfree(sup);
	return err;
}
Commit	Line	Data
9eefe2a2 SR	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: Artem Bityutskiy (Битюцкий Артём)
	20	* Adrian Hunter
	21	*/
	22
	23	/*
	24	* This file implements UBIFS superblock. The superblock is stored at the first
	25	* LEB of the volume and is never changed by UBIFS. Only user-space tools may
	26	* change it. The superblock node mostly contains geometry information.
	27	*/
	28
	29	#include "ubifs.h"
	30
	31	/*
	32	* Default journal size in logical eraseblocks as a percent of total
	33	* flash size.
	34	*/
	35	#define DEFAULT_JNL_PERCENT 5
	36
	37	/* Default maximum journal size in bytes */
	38	#define DEFAULT_MAX_JNL (3210241024)
	39
	40	/* Default indexing tree fanout */
	41	#define DEFAULT_FANOUT 8
	42
	43	/* Default number of data journal heads */
	44	#define DEFAULT_JHEADS_CNT 1
	45
	46	/* Default positions of different LEBs in the main area */
	47	#define DEFAULT_IDX_LEB 0
	48	#define DEFAULT_DATA_LEB 1
	49	#define DEFAULT_GC_LEB 2
	50
	51	/* Default number of LEB numbers in LPT's save table */
	52	#define DEFAULT_LSAVE_CNT 256
	53
	54	/* Default reserved pool size as a percent of maximum free space */
	55	#define DEFAULT_RP_PERCENT 5
	56
	57	/* The default maximum size of reserved pool in bytes */
	58	#define DEFAULT_MAX_RP_SIZE (510241024)
	59
	60	/* Default time granularity in nanoseconds */
	61	#define DEFAULT_TIME_GRAN 1000000000
	62
	63	/**
	64	* validate_sb - validate superblock node.
65	* @c: UBIFS file-system description object
66	* @sup: superblock node
67	*
68	* This function validates superblock node @sup. Since most of data was read
69	* from the superblock and stored in @c, the function validates fields in @c
70	* instead. Returns zero in case of success and %-EINVAL in case of validation
71	* failure.
72	*/
73	static int validate_sb(struct ubifs_info c, struct ubifs_sb_node sup)
74	{
75	long long max_bytes;
76	int err = 1, min_leb_cnt;
77
78	if (!c->key_hash) {
79	err = 2;
80	goto failed;
81	}
82
83	if (sup->key_fmt != UBIFS_SIMPLE_KEY_FMT) {
84	err = 3;
85	goto failed;
86	}
87
88	if (le32_to_cpu(sup->min_io_size) != c->min_io_size) {
89	ubifs_err("min. I/O unit mismatch: %d in superblock, %d real",
90	le32_to_cpu(sup->min_io_size), c->min_io_size);
91	goto failed;
92	}
93
94	if (le32_to_cpu(sup->leb_size) != c->leb_size) {
95	ubifs_err("LEB size mismatch: %d in superblock, %d real",
96	le32_to_cpu(sup->leb_size), c->leb_size);
97	goto failed;
98	}
99
100	if (c->log_lebs < UBIFS_MIN_LOG_LEBS \|\|
101	c->lpt_lebs < UBIFS_MIN_LPT_LEBS \|\|
102	c->orph_lebs < UBIFS_MIN_ORPH_LEBS \|\|
103	c->main_lebs < UBIFS_MIN_MAIN_LEBS) {
104	err = 4;
105	goto failed;
106	}
107
108	/*
109	* Calculate minimum allowed amount of main area LEBs. This is very
110	* similar to %UBIFS_MIN_LEB_CNT, but we take into account real what we
111	* have just read from the superblock.
112	*/
113	min_leb_cnt = UBIFS_SB_LEBS + UBIFS_MST_LEBS + c->log_lebs;
114	min_leb_cnt += c->lpt_lebs + c->orph_lebs + c->jhead_cnt + 6;
115
116	if (c->leb_cnt < min_leb_cnt \|\| c->leb_cnt > c->vi.size) {
117	ubifs_err("bad LEB count: %d in superblock, %d on UBI volume, "
118	"%d minimum required", c->leb_cnt, c->vi.size,
119	min_leb_cnt);
120	goto failed;
121	}
122
123	if (c->max_leb_cnt < c->leb_cnt) {
124	ubifs_err("max. LEB count %d less than LEB count %d",
125	c->max_leb_cnt, c->leb_cnt);
126	goto failed;
127	}
128
129	if (c->main_lebs < UBIFS_MIN_MAIN_LEBS) {
130	err = 7;
131	goto failed;
132	}
133
134	if (c->max_bud_bytes < (long long)c->leb_size * UBIFS_MIN_BUD_LEBS \|\|
135	c->max_bud_bytes > (long long)c->leb_size * c->main_lebs) {
136	err = 8;
137	goto failed;
138	}
139
140	if (c->jhead_cnt < NONDATA_JHEADS_CNT + 1 \|\|
141	c->jhead_cnt > NONDATA_JHEADS_CNT + UBIFS_MAX_JHEADS) {
142	err = 9;
143	goto failed;
144	}
145
146	if (c->fanout < UBIFS_MIN_FANOUT \|\|
147	ubifs_idx_node_sz(c, c->fanout) > c->leb_size) {
148	err = 10;
149	goto failed;
150	}
151
152	if (c->lsave_cnt < 0 \|\| (c->lsave_cnt > DEFAULT_LSAVE_CNT &&
153	c->lsave_cnt > c->max_leb_cnt - UBIFS_SB_LEBS - UBIFS_MST_LEBS -
154	c->log_lebs - c->lpt_lebs - c->orph_lebs)) {
155	err = 11;
156	goto failed;
157	}
158
159	if (UBIFS_SB_LEBS + UBIFS_MST_LEBS + c->log_lebs + c->lpt_lebs +
160	c->orph_lebs + c->main_lebs != c->leb_cnt) {
161	err = 12;
162	goto failed;
163	}
164
165	if (c->default_compr < 0 \|\| c->default_compr >= UBIFS_COMPR_TYPES_CNT) {
166	err = 13;
167	goto failed;
168	}
169
170	max_bytes = c->main_lebs * (long long)c->leb_size;
171	if (c->rp_size < 0 \|\| max_bytes < c->rp_size) {
172	err = 14;
173	goto failed;
174	}
175
176	if (le32_to_cpu(sup->time_gran) > 1000000000 \|\|
177	le32_to_cpu(sup->time_gran) < 1) {
178	err = 15;
179	goto failed;
180	}
181
182	return 0;
183
184	failed:
185	ubifs_err("bad superblock, error %d", err);
186	dbg_dump_node(c, sup);
187	return -EINVAL;
188	}
189
190	/**
191	* ubifs_read_sb_node - read superblock node.
192	* @c: UBIFS file-system description object
193	*
194	* This function returns a pointer to the superblock node or a negative error
195	* code.
196	*/
197	struct ubifs_sb_node ubifs_read_sb_node(struct ubifs_info c)
198	{
199	struct ubifs_sb_node *sup;
200	int err;
201
202	sup = kmalloc(ALIGN(UBIFS_SB_NODE_SZ, c->min_io_size), GFP_NOFS);
203	if (!sup)
204	return ERR_PTR(-ENOMEM);
205
206	err = ubifs_read_node(c, sup, UBIFS_SB_NODE, UBIFS_SB_NODE_SZ,
207	UBIFS_SB_LNUM, 0);
208	if (err) {
209	kfree(sup);
210	return ERR_PTR(err);
211	}
212
213	return sup;
214	}
215
216	/**
217	* ubifs_read_superblock - read superblock.
218	* @c: UBIFS file-system description object
219	*
220	* This function finds, reads and checks the superblock. If an empty UBI volume
221	* is being mounted, this function creates default superblock. Returns zero in
222	* case of success, and a negative error code in case of failure.
223	*/
224	int ubifs_read_superblock(struct ubifs_info *c)
225	{
226	int err, sup_flags;
227	struct ubifs_sb_node *sup;
228
229	if (c->empty) {
230	printf("No UBIFS filesystem found!\n");
231	return -1;
232	}
233
234	sup = ubifs_read_sb_node(c);
235	if (IS_ERR(sup))
236	return PTR_ERR(sup);
237
febd7e41 AB	238	c->fmt_version = le32_to_cpu(sup->fmt_version);
	239	c->ro_compat_version = le32_to_cpu(sup->ro_compat_version);
	240
9eefe2a2 SR	241	/*
	242	* The software supports all previous versions but not future versions,
	243	* due to the unavailability of time-travelling equipment.
	244	*/
9eefe2a2	245	if (c->fmt_version > UBIFS_FORMAT_VERSION) {
febd7e41 AB	246	struct super_block *sb = c->vfs_sb;
	247	int mounting_ro = sb->s_flags & MS_RDONLY;
	248
	249	ubifs_assert(!c->ro_media \|\| mounting_ro);
	250	if (!mounting_ro \|\|
	251	c->ro_compat_version > UBIFS_RO_COMPAT_VERSION) {
	252	ubifs_err("on-flash format version is w%d/r%d, but "
	253	"software only supports up to version "
	254	"w%d/r%d", c->fmt_version,
	255	c->ro_compat_version, UBIFS_FORMAT_VERSION,
	256	UBIFS_RO_COMPAT_VERSION);
	257	if (c->ro_compat_version <= UBIFS_RO_COMPAT_VERSION) {
	258	ubifs_msg("only R/O mounting is possible");
	259	err = -EROFS;
	260	} else
	261	err = -EINVAL;
	262	goto out;
	263	}
	264
	265	/*
	266	* The FS is mounted R/O, and the media format is
	267	* R/O-compatible with the UBIFS implementation, so we can
	268	* mount.
	269	*/
	270	c->rw_incompat = 1;
9eefe2a2 SR	271	}
	272
	273	if (c->fmt_version < 3) {
	274	ubifs_err("on-flash format version %d is not supported",
	275	c->fmt_version);
	276	err = -EINVAL;
	277	goto out;
	278	}
	279
	280	switch (sup->key_hash) {
	281	case UBIFS_KEY_HASH_R5:
	282	c->key_hash = key_r5_hash;
	283	c->key_hash_type = UBIFS_KEY_HASH_R5;
	284	break;
	285
	286	case UBIFS_KEY_HASH_TEST:
	287	c->key_hash = key_test_hash;
	288	c->key_hash_type = UBIFS_KEY_HASH_TEST;
	289	break;
	290	};
	291
	292	c->key_fmt = sup->key_fmt;
	293
	294	switch (c->key_fmt) {
	295	case UBIFS_SIMPLE_KEY_FMT:
	296	c->key_len = UBIFS_SK_LEN;
	297	break;
	298	default:
	299	ubifs_err("unsupported key format");
	300	err = -EINVAL;
	301	goto out;
	302	}
	303
	304	c->leb_cnt = le32_to_cpu(sup->leb_cnt);
	305	c->max_leb_cnt = le32_to_cpu(sup->max_leb_cnt);
	306	c->max_bud_bytes = le64_to_cpu(sup->max_bud_bytes);
	307	c->log_lebs = le32_to_cpu(sup->log_lebs);
	308	c->lpt_lebs = le32_to_cpu(sup->lpt_lebs);
	309	c->orph_lebs = le32_to_cpu(sup->orph_lebs);
	310	c->jhead_cnt = le32_to_cpu(sup->jhead_cnt) + NONDATA_JHEADS_CNT;
	311	c->fanout = le32_to_cpu(sup->fanout);
	312	c->lsave_cnt = le32_to_cpu(sup->lsave_cnt);
	313	c->default_compr = le16_to_cpu(sup->default_compr);
	314	c->rp_size = le64_to_cpu(sup->rp_size);
	315	c->rp_uid = le32_to_cpu(sup->rp_uid);
	316	c->rp_gid = le32_to_cpu(sup->rp_gid);
	317	sup_flags = le32_to_cpu(sup->flags);
	318
	319	c->vfs_sb->s_time_gran = le32_to_cpu(sup->time_gran);
	320	memcpy(&c->uuid, &sup->uuid, 16);
	321	c->big_lpt = !!(sup_flags & UBIFS_FLG_BIGLPT);
	322
	323	/* Automatically increase file system size to the maximum size */
	324	c->old_leb_cnt = c->leb_cnt;
	325	if (c->leb_cnt < c->vi.size && c->leb_cnt < c->max_leb_cnt) {
	326	c->leb_cnt = min_t(int, c->max_leb_cnt, c->vi.size);
	327	dbg_mnt("Auto resizing (ro) from %d LEBs to %d LEBs",
	328	c->old_leb_cnt, c->leb_cnt);
	329	}
	330
	331	c->log_bytes = (long long)c->log_lebs * c->leb_size;
	332	c->log_last = UBIFS_LOG_LNUM + c->log_lebs - 1;
	333	c->lpt_first = UBIFS_LOG_LNUM + c->log_lebs;
	334	c->lpt_last = c->lpt_first + c->lpt_lebs - 1;
335	c->orph_first = c->lpt_last + 1;
336	c->orph_last = c->orph_first + c->orph_lebs - 1;
337	c->main_lebs = c->leb_cnt - UBIFS_SB_LEBS - UBIFS_MST_LEBS;
338	c->main_lebs -= c->log_lebs + c->lpt_lebs + c->orph_lebs;
339	c->main_first = c->leb_cnt - c->main_lebs;
340	c->report_rp_size = ubifs_reported_space(c, c->rp_size);
341
342	err = validate_sb(c, sup);
343	out:
344	kfree(sup);
345	return err;
346	}