1*83d290c5STom Rini // SPDX-License-Identifier: GPL-2.0+
29eefe2a2SStefan Roese /*
39eefe2a2SStefan Roese * This file is part of UBIFS.
49eefe2a2SStefan Roese *
59eefe2a2SStefan Roese * Copyright (C) 2006-2008 Nokia Corporation.
69eefe2a2SStefan Roese *
79eefe2a2SStefan Roese * Authors: Artem Bityutskiy (Битюцкий Артём)
89eefe2a2SStefan Roese * Adrian Hunter
99eefe2a2SStefan Roese */
109eefe2a2SStefan Roese
119eefe2a2SStefan Roese /*
129eefe2a2SStefan Roese * This file implements UBIFS superblock. The superblock is stored at the first
139eefe2a2SStefan Roese * LEB of the volume and is never changed by UBIFS. Only user-space tools may
149eefe2a2SStefan Roese * change it. The superblock node mostly contains geometry information.
159eefe2a2SStefan Roese */
169eefe2a2SStefan Roese
179eefe2a2SStefan Roese #include "ubifs.h"
18ff94bc40SHeiko Schocher #ifndef __UBOOT__
19ff94bc40SHeiko Schocher #include <linux/slab.h>
20ff94bc40SHeiko Schocher #include <linux/random.h>
21ff94bc40SHeiko Schocher #include <linux/math64.h>
22ff94bc40SHeiko Schocher #else
23ff94bc40SHeiko Schocher
24ff94bc40SHeiko Schocher #include <linux/compat.h>
25ff94bc40SHeiko Schocher #include <linux/err.h>
26ff94bc40SHeiko Schocher #include <ubi_uboot.h>
27ff94bc40SHeiko Schocher #include <linux/stat.h>
28ff94bc40SHeiko Schocher #endif
299eefe2a2SStefan Roese
309eefe2a2SStefan Roese /*
319eefe2a2SStefan Roese * Default journal size in logical eraseblocks as a percent of total
329eefe2a2SStefan Roese * flash size.
339eefe2a2SStefan Roese */
349eefe2a2SStefan Roese #define DEFAULT_JNL_PERCENT 5
359eefe2a2SStefan Roese
369eefe2a2SStefan Roese /* Default maximum journal size in bytes */
379eefe2a2SStefan Roese #define DEFAULT_MAX_JNL (32*1024*1024)
389eefe2a2SStefan Roese
399eefe2a2SStefan Roese /* Default indexing tree fanout */
409eefe2a2SStefan Roese #define DEFAULT_FANOUT 8
419eefe2a2SStefan Roese
429eefe2a2SStefan Roese /* Default number of data journal heads */
439eefe2a2SStefan Roese #define DEFAULT_JHEADS_CNT 1
449eefe2a2SStefan Roese
459eefe2a2SStefan Roese /* Default positions of different LEBs in the main area */
469eefe2a2SStefan Roese #define DEFAULT_IDX_LEB 0
479eefe2a2SStefan Roese #define DEFAULT_DATA_LEB 1
489eefe2a2SStefan Roese #define DEFAULT_GC_LEB 2
499eefe2a2SStefan Roese
509eefe2a2SStefan Roese /* Default number of LEB numbers in LPT's save table */
519eefe2a2SStefan Roese #define DEFAULT_LSAVE_CNT 256
529eefe2a2SStefan Roese
539eefe2a2SStefan Roese /* Default reserved pool size as a percent of maximum free space */
549eefe2a2SStefan Roese #define DEFAULT_RP_PERCENT 5
559eefe2a2SStefan Roese
569eefe2a2SStefan Roese /* The default maximum size of reserved pool in bytes */
579eefe2a2SStefan Roese #define DEFAULT_MAX_RP_SIZE (5*1024*1024)
589eefe2a2SStefan Roese
599eefe2a2SStefan Roese /* Default time granularity in nanoseconds */
609eefe2a2SStefan Roese #define DEFAULT_TIME_GRAN 1000000000
619eefe2a2SStefan Roese
62ff94bc40SHeiko Schocher #ifndef __UBOOT__
63ff94bc40SHeiko Schocher /**
64ff94bc40SHeiko Schocher * create_default_filesystem - format empty UBI volume.
65ff94bc40SHeiko Schocher * @c: UBIFS file-system description object
66ff94bc40SHeiko Schocher *
67ff94bc40SHeiko Schocher * This function creates default empty file-system. Returns zero in case of
68ff94bc40SHeiko Schocher * success and a negative error code in case of failure.
69ff94bc40SHeiko Schocher */
create_default_filesystem(struct ubifs_info * c)70ff94bc40SHeiko Schocher static int create_default_filesystem(struct ubifs_info *c)
71ff94bc40SHeiko Schocher {
72ff94bc40SHeiko Schocher struct ubifs_sb_node *sup;
73ff94bc40SHeiko Schocher struct ubifs_mst_node *mst;
74ff94bc40SHeiko Schocher struct ubifs_idx_node *idx;
75ff94bc40SHeiko Schocher struct ubifs_branch *br;
76ff94bc40SHeiko Schocher struct ubifs_ino_node *ino;
77ff94bc40SHeiko Schocher struct ubifs_cs_node *cs;
78ff94bc40SHeiko Schocher union ubifs_key key;
79ff94bc40SHeiko Schocher int err, tmp, jnl_lebs, log_lebs, max_buds, main_lebs, main_first;
80ff94bc40SHeiko Schocher int lpt_lebs, lpt_first, orph_lebs, big_lpt, ino_waste, sup_flags = 0;
81ff94bc40SHeiko Schocher int min_leb_cnt = UBIFS_MIN_LEB_CNT;
82ff94bc40SHeiko Schocher long long tmp64, main_bytes;
83ff94bc40SHeiko Schocher __le64 tmp_le64;
84ff94bc40SHeiko Schocher
85ff94bc40SHeiko Schocher /* Some functions called from here depend on the @c->key_len filed */
86ff94bc40SHeiko Schocher c->key_len = UBIFS_SK_LEN;
87ff94bc40SHeiko Schocher
88ff94bc40SHeiko Schocher /*
89ff94bc40SHeiko Schocher * First of all, we have to calculate default file-system geometry -
90ff94bc40SHeiko Schocher * log size, journal size, etc.
91ff94bc40SHeiko Schocher */
92ff94bc40SHeiko Schocher if (c->leb_cnt < 0x7FFFFFFF / DEFAULT_JNL_PERCENT)
93ff94bc40SHeiko Schocher /* We can first multiply then divide and have no overflow */
94ff94bc40SHeiko Schocher jnl_lebs = c->leb_cnt * DEFAULT_JNL_PERCENT / 100;
95ff94bc40SHeiko Schocher else
96ff94bc40SHeiko Schocher jnl_lebs = (c->leb_cnt / 100) * DEFAULT_JNL_PERCENT;
97ff94bc40SHeiko Schocher
98ff94bc40SHeiko Schocher if (jnl_lebs < UBIFS_MIN_JNL_LEBS)
99ff94bc40SHeiko Schocher jnl_lebs = UBIFS_MIN_JNL_LEBS;
100ff94bc40SHeiko Schocher if (jnl_lebs * c->leb_size > DEFAULT_MAX_JNL)
101ff94bc40SHeiko Schocher jnl_lebs = DEFAULT_MAX_JNL / c->leb_size;
102ff94bc40SHeiko Schocher
103ff94bc40SHeiko Schocher /*
104ff94bc40SHeiko Schocher * The log should be large enough to fit reference nodes for all bud
105ff94bc40SHeiko Schocher * LEBs. Because buds do not have to start from the beginning of LEBs
106ff94bc40SHeiko Schocher * (half of the LEB may contain committed data), the log should
107ff94bc40SHeiko Schocher * generally be larger, make it twice as large.
108ff94bc40SHeiko Schocher */
109ff94bc40SHeiko Schocher tmp = 2 * (c->ref_node_alsz * jnl_lebs) + c->leb_size - 1;
110ff94bc40SHeiko Schocher log_lebs = tmp / c->leb_size;
111ff94bc40SHeiko Schocher /* Plus one LEB reserved for commit */
112ff94bc40SHeiko Schocher log_lebs += 1;
113ff94bc40SHeiko Schocher if (c->leb_cnt - min_leb_cnt > 8) {
114ff94bc40SHeiko Schocher /* And some extra space to allow writes while committing */
115ff94bc40SHeiko Schocher log_lebs += 1;
116ff94bc40SHeiko Schocher min_leb_cnt += 1;
117ff94bc40SHeiko Schocher }
118ff94bc40SHeiko Schocher
119ff94bc40SHeiko Schocher max_buds = jnl_lebs - log_lebs;
120ff94bc40SHeiko Schocher if (max_buds < UBIFS_MIN_BUD_LEBS)
121ff94bc40SHeiko Schocher max_buds = UBIFS_MIN_BUD_LEBS;
122ff94bc40SHeiko Schocher
123ff94bc40SHeiko Schocher /*
124ff94bc40SHeiko Schocher * Orphan nodes are stored in a separate area. One node can store a lot
125ff94bc40SHeiko Schocher * of orphan inode numbers, but when new orphan comes we just add a new
126ff94bc40SHeiko Schocher * orphan node. At some point the nodes are consolidated into one
127ff94bc40SHeiko Schocher * orphan node.
128ff94bc40SHeiko Schocher */
129ff94bc40SHeiko Schocher orph_lebs = UBIFS_MIN_ORPH_LEBS;
130ff94bc40SHeiko Schocher if (c->leb_cnt - min_leb_cnt > 1)
131ff94bc40SHeiko Schocher /*
132ff94bc40SHeiko Schocher * For debugging purposes it is better to have at least 2
133ff94bc40SHeiko Schocher * orphan LEBs, because the orphan subsystem would need to do
134ff94bc40SHeiko Schocher * consolidations and would be stressed more.
135ff94bc40SHeiko Schocher */
136ff94bc40SHeiko Schocher orph_lebs += 1;
137ff94bc40SHeiko Schocher
138ff94bc40SHeiko Schocher main_lebs = c->leb_cnt - UBIFS_SB_LEBS - UBIFS_MST_LEBS - log_lebs;
139ff94bc40SHeiko Schocher main_lebs -= orph_lebs;
140ff94bc40SHeiko Schocher
141ff94bc40SHeiko Schocher lpt_first = UBIFS_LOG_LNUM + log_lebs;
142ff94bc40SHeiko Schocher c->lsave_cnt = DEFAULT_LSAVE_CNT;
143ff94bc40SHeiko Schocher c->max_leb_cnt = c->leb_cnt;
144ff94bc40SHeiko Schocher err = ubifs_create_dflt_lpt(c, &main_lebs, lpt_first, &lpt_lebs,
145ff94bc40SHeiko Schocher &big_lpt);
146ff94bc40SHeiko Schocher if (err)
147ff94bc40SHeiko Schocher return err;
148ff94bc40SHeiko Schocher
149ff94bc40SHeiko Schocher dbg_gen("LEB Properties Tree created (LEBs %d-%d)", lpt_first,
150ff94bc40SHeiko Schocher lpt_first + lpt_lebs - 1);
151ff94bc40SHeiko Schocher
152ff94bc40SHeiko Schocher main_first = c->leb_cnt - main_lebs;
153ff94bc40SHeiko Schocher
154ff94bc40SHeiko Schocher /* Create default superblock */
155ff94bc40SHeiko Schocher tmp = ALIGN(UBIFS_SB_NODE_SZ, c->min_io_size);
156ff94bc40SHeiko Schocher sup = kzalloc(tmp, GFP_KERNEL);
157ff94bc40SHeiko Schocher if (!sup)
158ff94bc40SHeiko Schocher return -ENOMEM;
159ff94bc40SHeiko Schocher
160ff94bc40SHeiko Schocher tmp64 = (long long)max_buds * c->leb_size;
161ff94bc40SHeiko Schocher if (big_lpt)
162ff94bc40SHeiko Schocher sup_flags |= UBIFS_FLG_BIGLPT;
163ff94bc40SHeiko Schocher
164ff94bc40SHeiko Schocher sup->ch.node_type = UBIFS_SB_NODE;
165ff94bc40SHeiko Schocher sup->key_hash = UBIFS_KEY_HASH_R5;
166ff94bc40SHeiko Schocher sup->flags = cpu_to_le32(sup_flags);
167ff94bc40SHeiko Schocher sup->min_io_size = cpu_to_le32(c->min_io_size);
168ff94bc40SHeiko Schocher sup->leb_size = cpu_to_le32(c->leb_size);
169ff94bc40SHeiko Schocher sup->leb_cnt = cpu_to_le32(c->leb_cnt);
170ff94bc40SHeiko Schocher sup->max_leb_cnt = cpu_to_le32(c->max_leb_cnt);
171ff94bc40SHeiko Schocher sup->max_bud_bytes = cpu_to_le64(tmp64);
172ff94bc40SHeiko Schocher sup->log_lebs = cpu_to_le32(log_lebs);
173ff94bc40SHeiko Schocher sup->lpt_lebs = cpu_to_le32(lpt_lebs);
174ff94bc40SHeiko Schocher sup->orph_lebs = cpu_to_le32(orph_lebs);
175ff94bc40SHeiko Schocher sup->jhead_cnt = cpu_to_le32(DEFAULT_JHEADS_CNT);
176ff94bc40SHeiko Schocher sup->fanout = cpu_to_le32(DEFAULT_FANOUT);
177ff94bc40SHeiko Schocher sup->lsave_cnt = cpu_to_le32(c->lsave_cnt);
178ff94bc40SHeiko Schocher sup->fmt_version = cpu_to_le32(UBIFS_FORMAT_VERSION);
179ff94bc40SHeiko Schocher sup->time_gran = cpu_to_le32(DEFAULT_TIME_GRAN);
180ff94bc40SHeiko Schocher if (c->mount_opts.override_compr)
181ff94bc40SHeiko Schocher sup->default_compr = cpu_to_le16(c->mount_opts.compr_type);
182ff94bc40SHeiko Schocher else
183ff94bc40SHeiko Schocher sup->default_compr = cpu_to_le16(UBIFS_COMPR_LZO);
184ff94bc40SHeiko Schocher
185ff94bc40SHeiko Schocher generate_random_uuid(sup->uuid);
186ff94bc40SHeiko Schocher
187ff94bc40SHeiko Schocher main_bytes = (long long)main_lebs * c->leb_size;
188ff94bc40SHeiko Schocher tmp64 = div_u64(main_bytes * DEFAULT_RP_PERCENT, 100);
189ff94bc40SHeiko Schocher if (tmp64 > DEFAULT_MAX_RP_SIZE)
190ff94bc40SHeiko Schocher tmp64 = DEFAULT_MAX_RP_SIZE;
191ff94bc40SHeiko Schocher sup->rp_size = cpu_to_le64(tmp64);
192ff94bc40SHeiko Schocher sup->ro_compat_version = cpu_to_le32(UBIFS_RO_COMPAT_VERSION);
193ff94bc40SHeiko Schocher
194ff94bc40SHeiko Schocher err = ubifs_write_node(c, sup, UBIFS_SB_NODE_SZ, 0, 0);
195ff94bc40SHeiko Schocher kfree(sup);
196ff94bc40SHeiko Schocher if (err)
197ff94bc40SHeiko Schocher return err;
198ff94bc40SHeiko Schocher
199ff94bc40SHeiko Schocher dbg_gen("default superblock created at LEB 0:0");
200ff94bc40SHeiko Schocher
201ff94bc40SHeiko Schocher /* Create default master node */
202ff94bc40SHeiko Schocher mst = kzalloc(c->mst_node_alsz, GFP_KERNEL);
203ff94bc40SHeiko Schocher if (!mst)
204ff94bc40SHeiko Schocher return -ENOMEM;
205ff94bc40SHeiko Schocher
206ff94bc40SHeiko Schocher mst->ch.node_type = UBIFS_MST_NODE;
207ff94bc40SHeiko Schocher mst->log_lnum = cpu_to_le32(UBIFS_LOG_LNUM);
208ff94bc40SHeiko Schocher mst->highest_inum = cpu_to_le64(UBIFS_FIRST_INO);
209ff94bc40SHeiko Schocher mst->cmt_no = 0;
210ff94bc40SHeiko Schocher mst->root_lnum = cpu_to_le32(main_first + DEFAULT_IDX_LEB);
211ff94bc40SHeiko Schocher mst->root_offs = 0;
212ff94bc40SHeiko Schocher tmp = ubifs_idx_node_sz(c, 1);
213ff94bc40SHeiko Schocher mst->root_len = cpu_to_le32(tmp);
214ff94bc40SHeiko Schocher mst->gc_lnum = cpu_to_le32(main_first + DEFAULT_GC_LEB);
215ff94bc40SHeiko Schocher mst->ihead_lnum = cpu_to_le32(main_first + DEFAULT_IDX_LEB);
216ff94bc40SHeiko Schocher mst->ihead_offs = cpu_to_le32(ALIGN(tmp, c->min_io_size));
217ff94bc40SHeiko Schocher mst->index_size = cpu_to_le64(ALIGN(tmp, 8));
218ff94bc40SHeiko Schocher mst->lpt_lnum = cpu_to_le32(c->lpt_lnum);
219ff94bc40SHeiko Schocher mst->lpt_offs = cpu_to_le32(c->lpt_offs);
220ff94bc40SHeiko Schocher mst->nhead_lnum = cpu_to_le32(c->nhead_lnum);
221ff94bc40SHeiko Schocher mst->nhead_offs = cpu_to_le32(c->nhead_offs);
222ff94bc40SHeiko Schocher mst->ltab_lnum = cpu_to_le32(c->ltab_lnum);
223ff94bc40SHeiko Schocher mst->ltab_offs = cpu_to_le32(c->ltab_offs);
224ff94bc40SHeiko Schocher mst->lsave_lnum = cpu_to_le32(c->lsave_lnum);
225ff94bc40SHeiko Schocher mst->lsave_offs = cpu_to_le32(c->lsave_offs);
226ff94bc40SHeiko Schocher mst->lscan_lnum = cpu_to_le32(main_first);
227ff94bc40SHeiko Schocher mst->empty_lebs = cpu_to_le32(main_lebs - 2);
228ff94bc40SHeiko Schocher mst->idx_lebs = cpu_to_le32(1);
229ff94bc40SHeiko Schocher mst->leb_cnt = cpu_to_le32(c->leb_cnt);
230ff94bc40SHeiko Schocher
231ff94bc40SHeiko Schocher /* Calculate lprops statistics */
232ff94bc40SHeiko Schocher tmp64 = main_bytes;
233ff94bc40SHeiko Schocher tmp64 -= ALIGN(ubifs_idx_node_sz(c, 1), c->min_io_size);
234ff94bc40SHeiko Schocher tmp64 -= ALIGN(UBIFS_INO_NODE_SZ, c->min_io_size);
235ff94bc40SHeiko Schocher mst->total_free = cpu_to_le64(tmp64);
236ff94bc40SHeiko Schocher
237ff94bc40SHeiko Schocher tmp64 = ALIGN(ubifs_idx_node_sz(c, 1), c->min_io_size);
238ff94bc40SHeiko Schocher ino_waste = ALIGN(UBIFS_INO_NODE_SZ, c->min_io_size) -
239ff94bc40SHeiko Schocher UBIFS_INO_NODE_SZ;
240ff94bc40SHeiko Schocher tmp64 += ino_waste;
241ff94bc40SHeiko Schocher tmp64 -= ALIGN(ubifs_idx_node_sz(c, 1), 8);
242ff94bc40SHeiko Schocher mst->total_dirty = cpu_to_le64(tmp64);
243ff94bc40SHeiko Schocher
244ff94bc40SHeiko Schocher /* The indexing LEB does not contribute to dark space */
245ff94bc40SHeiko Schocher tmp64 = ((long long)(c->main_lebs - 1) * c->dark_wm);
246ff94bc40SHeiko Schocher mst->total_dark = cpu_to_le64(tmp64);
247ff94bc40SHeiko Schocher
248ff94bc40SHeiko Schocher mst->total_used = cpu_to_le64(UBIFS_INO_NODE_SZ);
249ff94bc40SHeiko Schocher
250ff94bc40SHeiko Schocher err = ubifs_write_node(c, mst, UBIFS_MST_NODE_SZ, UBIFS_MST_LNUM, 0);
251ff94bc40SHeiko Schocher if (err) {
252ff94bc40SHeiko Schocher kfree(mst);
253ff94bc40SHeiko Schocher return err;
254ff94bc40SHeiko Schocher }
255ff94bc40SHeiko Schocher err = ubifs_write_node(c, mst, UBIFS_MST_NODE_SZ, UBIFS_MST_LNUM + 1,
256ff94bc40SHeiko Schocher 0);
257ff94bc40SHeiko Schocher kfree(mst);
258ff94bc40SHeiko Schocher if (err)
259ff94bc40SHeiko Schocher return err;
260ff94bc40SHeiko Schocher
261ff94bc40SHeiko Schocher dbg_gen("default master node created at LEB %d:0", UBIFS_MST_LNUM);
262ff94bc40SHeiko Schocher
263ff94bc40SHeiko Schocher /* Create the root indexing node */
264ff94bc40SHeiko Schocher tmp = ubifs_idx_node_sz(c, 1);
265ff94bc40SHeiko Schocher idx = kzalloc(ALIGN(tmp, c->min_io_size), GFP_KERNEL);
266ff94bc40SHeiko Schocher if (!idx)
267ff94bc40SHeiko Schocher return -ENOMEM;
268ff94bc40SHeiko Schocher
269ff94bc40SHeiko Schocher c->key_fmt = UBIFS_SIMPLE_KEY_FMT;
270ff94bc40SHeiko Schocher c->key_hash = key_r5_hash;
271ff94bc40SHeiko Schocher
272ff94bc40SHeiko Schocher idx->ch.node_type = UBIFS_IDX_NODE;
273ff94bc40SHeiko Schocher idx->child_cnt = cpu_to_le16(1);
274ff94bc40SHeiko Schocher ino_key_init(c, &key, UBIFS_ROOT_INO);
275ff94bc40SHeiko Schocher br = ubifs_idx_branch(c, idx, 0);
276ff94bc40SHeiko Schocher key_write_idx(c, &key, &br->key);
277ff94bc40SHeiko Schocher br->lnum = cpu_to_le32(main_first + DEFAULT_DATA_LEB);
278ff94bc40SHeiko Schocher br->len = cpu_to_le32(UBIFS_INO_NODE_SZ);
279ff94bc40SHeiko Schocher err = ubifs_write_node(c, idx, tmp, main_first + DEFAULT_IDX_LEB, 0);
280ff94bc40SHeiko Schocher kfree(idx);
281ff94bc40SHeiko Schocher if (err)
282ff94bc40SHeiko Schocher return err;
283ff94bc40SHeiko Schocher
284ff94bc40SHeiko Schocher dbg_gen("default root indexing node created LEB %d:0",
285ff94bc40SHeiko Schocher main_first + DEFAULT_IDX_LEB);
286ff94bc40SHeiko Schocher
287ff94bc40SHeiko Schocher /* Create default root inode */
288ff94bc40SHeiko Schocher tmp = ALIGN(UBIFS_INO_NODE_SZ, c->min_io_size);
289ff94bc40SHeiko Schocher ino = kzalloc(tmp, GFP_KERNEL);
290ff94bc40SHeiko Schocher if (!ino)
291ff94bc40SHeiko Schocher return -ENOMEM;
292ff94bc40SHeiko Schocher
293ff94bc40SHeiko Schocher ino_key_init_flash(c, &ino->key, UBIFS_ROOT_INO);
294ff94bc40SHeiko Schocher ino->ch.node_type = UBIFS_INO_NODE;
295ff94bc40SHeiko Schocher ino->creat_sqnum = cpu_to_le64(++c->max_sqnum);
296ff94bc40SHeiko Schocher ino->nlink = cpu_to_le32(2);
297ff94bc40SHeiko Schocher tmp_le64 = cpu_to_le64(CURRENT_TIME_SEC.tv_sec);
298ff94bc40SHeiko Schocher ino->atime_sec = tmp_le64;
299ff94bc40SHeiko Schocher ino->ctime_sec = tmp_le64;
300ff94bc40SHeiko Schocher ino->mtime_sec = tmp_le64;
301ff94bc40SHeiko Schocher ino->atime_nsec = 0;
302ff94bc40SHeiko Schocher ino->ctime_nsec = 0;
303ff94bc40SHeiko Schocher ino->mtime_nsec = 0;
304ff94bc40SHeiko Schocher ino->mode = cpu_to_le32(S_IFDIR | S_IRUGO | S_IWUSR | S_IXUGO);
305ff94bc40SHeiko Schocher ino->size = cpu_to_le64(UBIFS_INO_NODE_SZ);
306ff94bc40SHeiko Schocher
307ff94bc40SHeiko Schocher /* Set compression enabled by default */
308ff94bc40SHeiko Schocher ino->flags = cpu_to_le32(UBIFS_COMPR_FL);
309ff94bc40SHeiko Schocher
310ff94bc40SHeiko Schocher err = ubifs_write_node(c, ino, UBIFS_INO_NODE_SZ,
311ff94bc40SHeiko Schocher main_first + DEFAULT_DATA_LEB, 0);
312ff94bc40SHeiko Schocher kfree(ino);
313ff94bc40SHeiko Schocher if (err)
314ff94bc40SHeiko Schocher return err;
315ff94bc40SHeiko Schocher
316ff94bc40SHeiko Schocher dbg_gen("root inode created at LEB %d:0",
317ff94bc40SHeiko Schocher main_first + DEFAULT_DATA_LEB);
318ff94bc40SHeiko Schocher
319ff94bc40SHeiko Schocher /*
320ff94bc40SHeiko Schocher * The first node in the log has to be the commit start node. This is
321ff94bc40SHeiko Schocher * always the case during normal file-system operation. Write a fake
322ff94bc40SHeiko Schocher * commit start node to the log.
323ff94bc40SHeiko Schocher */
324ff94bc40SHeiko Schocher tmp = ALIGN(UBIFS_CS_NODE_SZ, c->min_io_size);
325ff94bc40SHeiko Schocher cs = kzalloc(tmp, GFP_KERNEL);
326ff94bc40SHeiko Schocher if (!cs)
327ff94bc40SHeiko Schocher return -ENOMEM;
328ff94bc40SHeiko Schocher
329ff94bc40SHeiko Schocher cs->ch.node_type = UBIFS_CS_NODE;
330ff94bc40SHeiko Schocher err = ubifs_write_node(c, cs, UBIFS_CS_NODE_SZ, UBIFS_LOG_LNUM, 0);
331ff94bc40SHeiko Schocher kfree(cs);
3320195a7bbSHeiko Schocher if (err)
3330195a7bbSHeiko Schocher return err;
334ff94bc40SHeiko Schocher
3350195a7bbSHeiko Schocher ubifs_msg(c, "default file-system created");
336ff94bc40SHeiko Schocher return 0;
337ff94bc40SHeiko Schocher }
338ff94bc40SHeiko Schocher #endif
339ff94bc40SHeiko Schocher
3409eefe2a2SStefan Roese /**
3419eefe2a2SStefan Roese * validate_sb - validate superblock node.
3429eefe2a2SStefan Roese * @c: UBIFS file-system description object
3439eefe2a2SStefan Roese * @sup: superblock node
3449eefe2a2SStefan Roese *
3459eefe2a2SStefan Roese * This function validates superblock node @sup. Since most of data was read
3469eefe2a2SStefan Roese * from the superblock and stored in @c, the function validates fields in @c
3479eefe2a2SStefan Roese * instead. Returns zero in case of success and %-EINVAL in case of validation
3489eefe2a2SStefan Roese * failure.
3499eefe2a2SStefan Roese */
validate_sb(struct ubifs_info * c,struct ubifs_sb_node * sup)3509eefe2a2SStefan Roese static int validate_sb(struct ubifs_info *c, struct ubifs_sb_node *sup)
3519eefe2a2SStefan Roese {
3529eefe2a2SStefan Roese long long max_bytes;
3539eefe2a2SStefan Roese int err = 1, min_leb_cnt;
3549eefe2a2SStefan Roese
3559eefe2a2SStefan Roese if (!c->key_hash) {
3569eefe2a2SStefan Roese err = 2;
3579eefe2a2SStefan Roese goto failed;
3589eefe2a2SStefan Roese }
3599eefe2a2SStefan Roese
3609eefe2a2SStefan Roese if (sup->key_fmt != UBIFS_SIMPLE_KEY_FMT) {
3619eefe2a2SStefan Roese err = 3;
3629eefe2a2SStefan Roese goto failed;
3639eefe2a2SStefan Roese }
3649eefe2a2SStefan Roese
3659eefe2a2SStefan Roese if (le32_to_cpu(sup->min_io_size) != c->min_io_size) {
3660195a7bbSHeiko Schocher ubifs_err(c, "min. I/O unit mismatch: %d in superblock, %d real",
3679eefe2a2SStefan Roese le32_to_cpu(sup->min_io_size), c->min_io_size);
3689eefe2a2SStefan Roese goto failed;
3699eefe2a2SStefan Roese }
3709eefe2a2SStefan Roese
3719eefe2a2SStefan Roese if (le32_to_cpu(sup->leb_size) != c->leb_size) {
3720195a7bbSHeiko Schocher ubifs_err(c, "LEB size mismatch: %d in superblock, %d real",
3739eefe2a2SStefan Roese le32_to_cpu(sup->leb_size), c->leb_size);
3749eefe2a2SStefan Roese goto failed;
3759eefe2a2SStefan Roese }
3769eefe2a2SStefan Roese
3779eefe2a2SStefan Roese if (c->log_lebs < UBIFS_MIN_LOG_LEBS ||
3789eefe2a2SStefan Roese c->lpt_lebs < UBIFS_MIN_LPT_LEBS ||
3799eefe2a2SStefan Roese c->orph_lebs < UBIFS_MIN_ORPH_LEBS ||
3809eefe2a2SStefan Roese c->main_lebs < UBIFS_MIN_MAIN_LEBS) {
3819eefe2a2SStefan Roese err = 4;
3829eefe2a2SStefan Roese goto failed;
3839eefe2a2SStefan Roese }
3849eefe2a2SStefan Roese
3859eefe2a2SStefan Roese /*
3869eefe2a2SStefan Roese * Calculate minimum allowed amount of main area LEBs. This is very
3879eefe2a2SStefan Roese * similar to %UBIFS_MIN_LEB_CNT, but we take into account real what we
3889eefe2a2SStefan Roese * have just read from the superblock.
3899eefe2a2SStefan Roese */
3909eefe2a2SStefan Roese min_leb_cnt = UBIFS_SB_LEBS + UBIFS_MST_LEBS + c->log_lebs;
3919eefe2a2SStefan Roese min_leb_cnt += c->lpt_lebs + c->orph_lebs + c->jhead_cnt + 6;
3929eefe2a2SStefan Roese
3939eefe2a2SStefan Roese if (c->leb_cnt < min_leb_cnt || c->leb_cnt > c->vi.size) {
3940195a7bbSHeiko Schocher ubifs_err(c, "bad LEB count: %d in superblock, %d on UBI volume, %d minimum required",
395ff94bc40SHeiko Schocher c->leb_cnt, c->vi.size, min_leb_cnt);
3969eefe2a2SStefan Roese goto failed;
3979eefe2a2SStefan Roese }
3989eefe2a2SStefan Roese
3999eefe2a2SStefan Roese if (c->max_leb_cnt < c->leb_cnt) {
4000195a7bbSHeiko Schocher ubifs_err(c, "max. LEB count %d less than LEB count %d",
4019eefe2a2SStefan Roese c->max_leb_cnt, c->leb_cnt);
4029eefe2a2SStefan Roese goto failed;
4039eefe2a2SStefan Roese }
4049eefe2a2SStefan Roese
4059eefe2a2SStefan Roese if (c->main_lebs < UBIFS_MIN_MAIN_LEBS) {
4060195a7bbSHeiko Schocher ubifs_err(c, "too few main LEBs count %d, must be at least %d",
407ff94bc40SHeiko Schocher c->main_lebs, UBIFS_MIN_MAIN_LEBS);
4089eefe2a2SStefan Roese goto failed;
4099eefe2a2SStefan Roese }
4109eefe2a2SStefan Roese
411ff94bc40SHeiko Schocher max_bytes = (long long)c->leb_size * UBIFS_MIN_BUD_LEBS;
412ff94bc40SHeiko Schocher if (c->max_bud_bytes < max_bytes) {
4130195a7bbSHeiko Schocher ubifs_err(c, "too small journal (%lld bytes), must be at least %lld bytes",
414ff94bc40SHeiko Schocher c->max_bud_bytes, max_bytes);
415ff94bc40SHeiko Schocher goto failed;
416ff94bc40SHeiko Schocher }
417ff94bc40SHeiko Schocher
418ff94bc40SHeiko Schocher max_bytes = (long long)c->leb_size * c->main_lebs;
419ff94bc40SHeiko Schocher if (c->max_bud_bytes > max_bytes) {
4200195a7bbSHeiko Schocher ubifs_err(c, "too large journal size (%lld bytes), only %lld bytes available in the main area",
421ff94bc40SHeiko Schocher c->max_bud_bytes, max_bytes);
4229eefe2a2SStefan Roese goto failed;
4239eefe2a2SStefan Roese }
4249eefe2a2SStefan Roese
4259eefe2a2SStefan Roese if (c->jhead_cnt < NONDATA_JHEADS_CNT + 1 ||
4269eefe2a2SStefan Roese c->jhead_cnt > NONDATA_JHEADS_CNT + UBIFS_MAX_JHEADS) {
4279eefe2a2SStefan Roese err = 9;
4289eefe2a2SStefan Roese goto failed;
4299eefe2a2SStefan Roese }
4309eefe2a2SStefan Roese
4319eefe2a2SStefan Roese if (c->fanout < UBIFS_MIN_FANOUT ||
4329eefe2a2SStefan Roese ubifs_idx_node_sz(c, c->fanout) > c->leb_size) {
4339eefe2a2SStefan Roese err = 10;
4349eefe2a2SStefan Roese goto failed;
4359eefe2a2SStefan Roese }
4369eefe2a2SStefan Roese
4379eefe2a2SStefan Roese if (c->lsave_cnt < 0 || (c->lsave_cnt > DEFAULT_LSAVE_CNT &&
4389eefe2a2SStefan Roese c->lsave_cnt > c->max_leb_cnt - UBIFS_SB_LEBS - UBIFS_MST_LEBS -
4399eefe2a2SStefan Roese c->log_lebs - c->lpt_lebs - c->orph_lebs)) {
4409eefe2a2SStefan Roese err = 11;
4419eefe2a2SStefan Roese goto failed;
4429eefe2a2SStefan Roese }
4439eefe2a2SStefan Roese
4449eefe2a2SStefan Roese if (UBIFS_SB_LEBS + UBIFS_MST_LEBS + c->log_lebs + c->lpt_lebs +
4459eefe2a2SStefan Roese c->orph_lebs + c->main_lebs != c->leb_cnt) {
4469eefe2a2SStefan Roese err = 12;
4479eefe2a2SStefan Roese goto failed;
4489eefe2a2SStefan Roese }
4499eefe2a2SStefan Roese
4500195a7bbSHeiko Schocher if (c->default_compr >= UBIFS_COMPR_TYPES_CNT) {
4519eefe2a2SStefan Roese err = 13;
4529eefe2a2SStefan Roese goto failed;
4539eefe2a2SStefan Roese }
4549eefe2a2SStefan Roese
4559eefe2a2SStefan Roese if (c->rp_size < 0 || max_bytes < c->rp_size) {
4569eefe2a2SStefan Roese err = 14;
4579eefe2a2SStefan Roese goto failed;
4589eefe2a2SStefan Roese }
4599eefe2a2SStefan Roese
4609eefe2a2SStefan Roese if (le32_to_cpu(sup->time_gran) > 1000000000 ||
4619eefe2a2SStefan Roese le32_to_cpu(sup->time_gran) < 1) {
4629eefe2a2SStefan Roese err = 15;
4639eefe2a2SStefan Roese goto failed;
4649eefe2a2SStefan Roese }
4659eefe2a2SStefan Roese
4669eefe2a2SStefan Roese return 0;
4679eefe2a2SStefan Roese
4689eefe2a2SStefan Roese failed:
4690195a7bbSHeiko Schocher ubifs_err(c, "bad superblock, error %d", err);
470ff94bc40SHeiko Schocher ubifs_dump_node(c, sup);
4719eefe2a2SStefan Roese return -EINVAL;
4729eefe2a2SStefan Roese }
4739eefe2a2SStefan Roese
4749eefe2a2SStefan Roese /**
4759eefe2a2SStefan Roese * ubifs_read_sb_node - read superblock node.
4769eefe2a2SStefan Roese * @c: UBIFS file-system description object
4779eefe2a2SStefan Roese *
4789eefe2a2SStefan Roese * This function returns a pointer to the superblock node or a negative error
479ff94bc40SHeiko Schocher * code. Note, the user of this function is responsible of kfree()'ing the
480ff94bc40SHeiko Schocher * returned superblock buffer.
4819eefe2a2SStefan Roese */
ubifs_read_sb_node(struct ubifs_info * c)4829eefe2a2SStefan Roese struct ubifs_sb_node *ubifs_read_sb_node(struct ubifs_info *c)
4839eefe2a2SStefan Roese {
4849eefe2a2SStefan Roese struct ubifs_sb_node *sup;
4859eefe2a2SStefan Roese int err;
4869eefe2a2SStefan Roese
4879eefe2a2SStefan Roese sup = kmalloc(ALIGN(UBIFS_SB_NODE_SZ, c->min_io_size), GFP_NOFS);
4889eefe2a2SStefan Roese if (!sup)
4899eefe2a2SStefan Roese return ERR_PTR(-ENOMEM);
4909eefe2a2SStefan Roese
4919eefe2a2SStefan Roese err = ubifs_read_node(c, sup, UBIFS_SB_NODE, UBIFS_SB_NODE_SZ,
4929eefe2a2SStefan Roese UBIFS_SB_LNUM, 0);
4939eefe2a2SStefan Roese if (err) {
4949eefe2a2SStefan Roese kfree(sup);
4959eefe2a2SStefan Roese return ERR_PTR(err);
4969eefe2a2SStefan Roese }
4979eefe2a2SStefan Roese
4989eefe2a2SStefan Roese return sup;
4999eefe2a2SStefan Roese }
5009eefe2a2SStefan Roese
5019eefe2a2SStefan Roese /**
502ff94bc40SHeiko Schocher * ubifs_write_sb_node - write superblock node.
503ff94bc40SHeiko Schocher * @c: UBIFS file-system description object
504ff94bc40SHeiko Schocher * @sup: superblock node read with 'ubifs_read_sb_node()'
505ff94bc40SHeiko Schocher *
506ff94bc40SHeiko Schocher * This function returns %0 on success and a negative error code on failure.
507ff94bc40SHeiko Schocher */
ubifs_write_sb_node(struct ubifs_info * c,struct ubifs_sb_node * sup)508ff94bc40SHeiko Schocher int ubifs_write_sb_node(struct ubifs_info *c, struct ubifs_sb_node *sup)
509ff94bc40SHeiko Schocher {
510ff94bc40SHeiko Schocher int len = ALIGN(UBIFS_SB_NODE_SZ, c->min_io_size);
511ff94bc40SHeiko Schocher
512ff94bc40SHeiko Schocher ubifs_prepare_node(c, sup, UBIFS_SB_NODE_SZ, 1);
513ff94bc40SHeiko Schocher return ubifs_leb_change(c, UBIFS_SB_LNUM, sup, len);
514ff94bc40SHeiko Schocher }
515ff94bc40SHeiko Schocher
516ff94bc40SHeiko Schocher /**
5179eefe2a2SStefan Roese * ubifs_read_superblock - read superblock.
5189eefe2a2SStefan Roese * @c: UBIFS file-system description object
5199eefe2a2SStefan Roese *
5209eefe2a2SStefan Roese * This function finds, reads and checks the superblock. If an empty UBI volume
5219eefe2a2SStefan Roese * is being mounted, this function creates default superblock. Returns zero in
5229eefe2a2SStefan Roese * case of success, and a negative error code in case of failure.
5239eefe2a2SStefan Roese */
ubifs_read_superblock(struct ubifs_info * c)5249eefe2a2SStefan Roese int ubifs_read_superblock(struct ubifs_info *c)
5259eefe2a2SStefan Roese {
5269eefe2a2SStefan Roese int err, sup_flags;
5279eefe2a2SStefan Roese struct ubifs_sb_node *sup;
5289eefe2a2SStefan Roese
5299eefe2a2SStefan Roese if (c->empty) {
530ff94bc40SHeiko Schocher #ifndef __UBOOT__
531ff94bc40SHeiko Schocher err = create_default_filesystem(c);
532ff94bc40SHeiko Schocher if (err)
533ff94bc40SHeiko Schocher return err;
534ff94bc40SHeiko Schocher #else
5359eefe2a2SStefan Roese printf("No UBIFS filesystem found!\n");
5369eefe2a2SStefan Roese return -1;
537ff94bc40SHeiko Schocher #endif
5389eefe2a2SStefan Roese }
5399eefe2a2SStefan Roese
5409eefe2a2SStefan Roese sup = ubifs_read_sb_node(c);
5419eefe2a2SStefan Roese if (IS_ERR(sup))
5429eefe2a2SStefan Roese return PTR_ERR(sup);
5439eefe2a2SStefan Roese
544febd7e41SArtem Bityutskiy c->fmt_version = le32_to_cpu(sup->fmt_version);
545febd7e41SArtem Bityutskiy c->ro_compat_version = le32_to_cpu(sup->ro_compat_version);
546febd7e41SArtem Bityutskiy
5479eefe2a2SStefan Roese /*
5489eefe2a2SStefan Roese * The software supports all previous versions but not future versions,
5499eefe2a2SStefan Roese * due to the unavailability of time-travelling equipment.
5509eefe2a2SStefan Roese */
5519eefe2a2SStefan Roese if (c->fmt_version > UBIFS_FORMAT_VERSION) {
552ff94bc40SHeiko Schocher ubifs_assert(!c->ro_media || c->ro_mount);
553ff94bc40SHeiko Schocher if (!c->ro_mount ||
554febd7e41SArtem Bityutskiy c->ro_compat_version > UBIFS_RO_COMPAT_VERSION) {
5550195a7bbSHeiko Schocher ubifs_err(c, "on-flash format version is w%d/r%d, but software only supports up to version w%d/r%d",
556ff94bc40SHeiko Schocher c->fmt_version, c->ro_compat_version,
557ff94bc40SHeiko Schocher UBIFS_FORMAT_VERSION,
558febd7e41SArtem Bityutskiy UBIFS_RO_COMPAT_VERSION);
559febd7e41SArtem Bityutskiy if (c->ro_compat_version <= UBIFS_RO_COMPAT_VERSION) {
5600195a7bbSHeiko Schocher ubifs_msg(c, "only R/O mounting is possible");
561febd7e41SArtem Bityutskiy err = -EROFS;
562febd7e41SArtem Bityutskiy } else
5639eefe2a2SStefan Roese err = -EINVAL;
5649eefe2a2SStefan Roese goto out;
5659eefe2a2SStefan Roese }
5669eefe2a2SStefan Roese
567febd7e41SArtem Bityutskiy /*
568febd7e41SArtem Bityutskiy * The FS is mounted R/O, and the media format is
569febd7e41SArtem Bityutskiy * R/O-compatible with the UBIFS implementation, so we can
570febd7e41SArtem Bityutskiy * mount.
571febd7e41SArtem Bityutskiy */
572febd7e41SArtem Bityutskiy c->rw_incompat = 1;
573febd7e41SArtem Bityutskiy }
574febd7e41SArtem Bityutskiy
5759eefe2a2SStefan Roese if (c->fmt_version < 3) {
5760195a7bbSHeiko Schocher ubifs_err(c, "on-flash format version %d is not supported",
5779eefe2a2SStefan Roese c->fmt_version);
5789eefe2a2SStefan Roese err = -EINVAL;
5799eefe2a2SStefan Roese goto out;
5809eefe2a2SStefan Roese }
5819eefe2a2SStefan Roese
5829eefe2a2SStefan Roese switch (sup->key_hash) {
5839eefe2a2SStefan Roese case UBIFS_KEY_HASH_R5:
5849eefe2a2SStefan Roese c->key_hash = key_r5_hash;
5859eefe2a2SStefan Roese c->key_hash_type = UBIFS_KEY_HASH_R5;
5869eefe2a2SStefan Roese break;
5879eefe2a2SStefan Roese
5889eefe2a2SStefan Roese case UBIFS_KEY_HASH_TEST:
5899eefe2a2SStefan Roese c->key_hash = key_test_hash;
5909eefe2a2SStefan Roese c->key_hash_type = UBIFS_KEY_HASH_TEST;
5919eefe2a2SStefan Roese break;
5929eefe2a2SStefan Roese };
5939eefe2a2SStefan Roese
5949eefe2a2SStefan Roese c->key_fmt = sup->key_fmt;
5959eefe2a2SStefan Roese
5969eefe2a2SStefan Roese switch (c->key_fmt) {
5979eefe2a2SStefan Roese case UBIFS_SIMPLE_KEY_FMT:
5989eefe2a2SStefan Roese c->key_len = UBIFS_SK_LEN;
5999eefe2a2SStefan Roese break;
6009eefe2a2SStefan Roese default:
6010195a7bbSHeiko Schocher ubifs_err(c, "unsupported key format");
6029eefe2a2SStefan Roese err = -EINVAL;
6039eefe2a2SStefan Roese goto out;
6049eefe2a2SStefan Roese }
6059eefe2a2SStefan Roese
6069eefe2a2SStefan Roese c->leb_cnt = le32_to_cpu(sup->leb_cnt);
6079eefe2a2SStefan Roese c->max_leb_cnt = le32_to_cpu(sup->max_leb_cnt);
6089eefe2a2SStefan Roese c->max_bud_bytes = le64_to_cpu(sup->max_bud_bytes);
6099eefe2a2SStefan Roese c->log_lebs = le32_to_cpu(sup->log_lebs);
6109eefe2a2SStefan Roese c->lpt_lebs = le32_to_cpu(sup->lpt_lebs);
6119eefe2a2SStefan Roese c->orph_lebs = le32_to_cpu(sup->orph_lebs);
6129eefe2a2SStefan Roese c->jhead_cnt = le32_to_cpu(sup->jhead_cnt) + NONDATA_JHEADS_CNT;
6139eefe2a2SStefan Roese c->fanout = le32_to_cpu(sup->fanout);
6149eefe2a2SStefan Roese c->lsave_cnt = le32_to_cpu(sup->lsave_cnt);
6159eefe2a2SStefan Roese c->rp_size = le64_to_cpu(sup->rp_size);
616ff94bc40SHeiko Schocher #ifndef __UBOOT__
617ff94bc40SHeiko Schocher c->rp_uid = make_kuid(&init_user_ns, le32_to_cpu(sup->rp_uid));
618ff94bc40SHeiko Schocher c->rp_gid = make_kgid(&init_user_ns, le32_to_cpu(sup->rp_gid));
619ff94bc40SHeiko Schocher #else
620ff94bc40SHeiko Schocher c->rp_uid.val = le32_to_cpu(sup->rp_uid);
621ff94bc40SHeiko Schocher c->rp_gid.val = le32_to_cpu(sup->rp_gid);
622ff94bc40SHeiko Schocher #endif
6239eefe2a2SStefan Roese sup_flags = le32_to_cpu(sup->flags);
624ff94bc40SHeiko Schocher if (!c->mount_opts.override_compr)
625ff94bc40SHeiko Schocher c->default_compr = le16_to_cpu(sup->default_compr);
6269eefe2a2SStefan Roese
6279eefe2a2SStefan Roese c->vfs_sb->s_time_gran = le32_to_cpu(sup->time_gran);
6289eefe2a2SStefan Roese memcpy(&c->uuid, &sup->uuid, 16);
6299eefe2a2SStefan Roese c->big_lpt = !!(sup_flags & UBIFS_FLG_BIGLPT);
630ff94bc40SHeiko Schocher c->space_fixup = !!(sup_flags & UBIFS_FLG_SPACE_FIXUP);
6319eefe2a2SStefan Roese
6329eefe2a2SStefan Roese /* Automatically increase file system size to the maximum size */
6339eefe2a2SStefan Roese c->old_leb_cnt = c->leb_cnt;
6349eefe2a2SStefan Roese if (c->leb_cnt < c->vi.size && c->leb_cnt < c->max_leb_cnt) {
6359eefe2a2SStefan Roese c->leb_cnt = min_t(int, c->max_leb_cnt, c->vi.size);
636ff94bc40SHeiko Schocher if (c->ro_mount)
6379eefe2a2SStefan Roese dbg_mnt("Auto resizing (ro) from %d LEBs to %d LEBs",
6389eefe2a2SStefan Roese c->old_leb_cnt, c->leb_cnt);
639ff94bc40SHeiko Schocher #ifndef __UBOOT__
640ff94bc40SHeiko Schocher else {
641ff94bc40SHeiko Schocher dbg_mnt("Auto resizing (sb) from %d LEBs to %d LEBs",
642ff94bc40SHeiko Schocher c->old_leb_cnt, c->leb_cnt);
643ff94bc40SHeiko Schocher sup->leb_cnt = cpu_to_le32(c->leb_cnt);
644ff94bc40SHeiko Schocher err = ubifs_write_sb_node(c, sup);
645ff94bc40SHeiko Schocher if (err)
646ff94bc40SHeiko Schocher goto out;
647ff94bc40SHeiko Schocher c->old_leb_cnt = c->leb_cnt;
648ff94bc40SHeiko Schocher }
649ff94bc40SHeiko Schocher #endif
6509eefe2a2SStefan Roese }
6519eefe2a2SStefan Roese
6529eefe2a2SStefan Roese c->log_bytes = (long long)c->log_lebs * c->leb_size;
6539eefe2a2SStefan Roese c->log_last = UBIFS_LOG_LNUM + c->log_lebs - 1;
6549eefe2a2SStefan Roese c->lpt_first = UBIFS_LOG_LNUM + c->log_lebs;
6559eefe2a2SStefan Roese c->lpt_last = c->lpt_first + c->lpt_lebs - 1;
6569eefe2a2SStefan Roese c->orph_first = c->lpt_last + 1;
6579eefe2a2SStefan Roese c->orph_last = c->orph_first + c->orph_lebs - 1;
6589eefe2a2SStefan Roese c->main_lebs = c->leb_cnt - UBIFS_SB_LEBS - UBIFS_MST_LEBS;
6599eefe2a2SStefan Roese c->main_lebs -= c->log_lebs + c->lpt_lebs + c->orph_lebs;
6609eefe2a2SStefan Roese c->main_first = c->leb_cnt - c->main_lebs;
6619eefe2a2SStefan Roese
6629eefe2a2SStefan Roese err = validate_sb(c, sup);
6639eefe2a2SStefan Roese out:
6649eefe2a2SStefan Roese kfree(sup);
6659eefe2a2SStefan Roese return err;
6669eefe2a2SStefan Roese }
667ff94bc40SHeiko Schocher
668ff94bc40SHeiko Schocher /**
669ff94bc40SHeiko Schocher * fixup_leb - fixup/unmap an LEB containing free space.
670ff94bc40SHeiko Schocher * @c: UBIFS file-system description object
671ff94bc40SHeiko Schocher * @lnum: the LEB number to fix up
672ff94bc40SHeiko Schocher * @len: number of used bytes in LEB (starting at offset 0)
673ff94bc40SHeiko Schocher *
674ff94bc40SHeiko Schocher * This function reads the contents of the given LEB number @lnum, then fixes
675ff94bc40SHeiko Schocher * it up, so that empty min. I/O units in the end of LEB are actually erased on
676ff94bc40SHeiko Schocher * flash (rather than being just all-0xff real data). If the LEB is completely
677ff94bc40SHeiko Schocher * empty, it is simply unmapped.
678ff94bc40SHeiko Schocher */
fixup_leb(struct ubifs_info * c,int lnum,int len)679ff94bc40SHeiko Schocher static int fixup_leb(struct ubifs_info *c, int lnum, int len)
680ff94bc40SHeiko Schocher {
681ff94bc40SHeiko Schocher int err;
682ff94bc40SHeiko Schocher
683ff94bc40SHeiko Schocher ubifs_assert(len >= 0);
684ff94bc40SHeiko Schocher ubifs_assert(len % c->min_io_size == 0);
685ff94bc40SHeiko Schocher ubifs_assert(len < c->leb_size);
686ff94bc40SHeiko Schocher
687ff94bc40SHeiko Schocher if (len == 0) {
688ff94bc40SHeiko Schocher dbg_mnt("unmap empty LEB %d", lnum);
689ff94bc40SHeiko Schocher return ubifs_leb_unmap(c, lnum);
690ff94bc40SHeiko Schocher }
691ff94bc40SHeiko Schocher
692ff94bc40SHeiko Schocher dbg_mnt("fixup LEB %d, data len %d", lnum, len);
693ff94bc40SHeiko Schocher err = ubifs_leb_read(c, lnum, c->sbuf, 0, len, 1);
694ff94bc40SHeiko Schocher if (err)
695ff94bc40SHeiko Schocher return err;
696ff94bc40SHeiko Schocher
697ff94bc40SHeiko Schocher return ubifs_leb_change(c, lnum, c->sbuf, len);
698ff94bc40SHeiko Schocher }
699ff94bc40SHeiko Schocher
700ff94bc40SHeiko Schocher /**
701ff94bc40SHeiko Schocher * fixup_free_space - find & remap all LEBs containing free space.
702ff94bc40SHeiko Schocher * @c: UBIFS file-system description object
703ff94bc40SHeiko Schocher *
704ff94bc40SHeiko Schocher * This function walks through all LEBs in the filesystem and fiexes up those
705ff94bc40SHeiko Schocher * containing free/empty space.
706ff94bc40SHeiko Schocher */
fixup_free_space(struct ubifs_info * c)707ff94bc40SHeiko Schocher static int fixup_free_space(struct ubifs_info *c)
708ff94bc40SHeiko Schocher {
709ff94bc40SHeiko Schocher int lnum, err = 0;
710ff94bc40SHeiko Schocher struct ubifs_lprops *lprops;
711ff94bc40SHeiko Schocher
712ff94bc40SHeiko Schocher ubifs_get_lprops(c);
713ff94bc40SHeiko Schocher
714ff94bc40SHeiko Schocher /* Fixup LEBs in the master area */
715ff94bc40SHeiko Schocher for (lnum = UBIFS_MST_LNUM; lnum < UBIFS_LOG_LNUM; lnum++) {
716ff94bc40SHeiko Schocher err = fixup_leb(c, lnum, c->mst_offs + c->mst_node_alsz);
717ff94bc40SHeiko Schocher if (err)
718ff94bc40SHeiko Schocher goto out;
719ff94bc40SHeiko Schocher }
720ff94bc40SHeiko Schocher
721ff94bc40SHeiko Schocher /* Unmap unused log LEBs */
722ff94bc40SHeiko Schocher lnum = ubifs_next_log_lnum(c, c->lhead_lnum);
723ff94bc40SHeiko Schocher while (lnum != c->ltail_lnum) {
724ff94bc40SHeiko Schocher err = fixup_leb(c, lnum, 0);
725ff94bc40SHeiko Schocher if (err)
726ff94bc40SHeiko Schocher goto out;
727ff94bc40SHeiko Schocher lnum = ubifs_next_log_lnum(c, lnum);
728ff94bc40SHeiko Schocher }
729ff94bc40SHeiko Schocher
730ff94bc40SHeiko Schocher /*
731ff94bc40SHeiko Schocher * Fixup the log head which contains the only a CS node at the
732ff94bc40SHeiko Schocher * beginning.
733ff94bc40SHeiko Schocher */
734ff94bc40SHeiko Schocher err = fixup_leb(c, c->lhead_lnum,
735ff94bc40SHeiko Schocher ALIGN(UBIFS_CS_NODE_SZ, c->min_io_size));
736ff94bc40SHeiko Schocher if (err)
737ff94bc40SHeiko Schocher goto out;
738ff94bc40SHeiko Schocher
739ff94bc40SHeiko Schocher /* Fixup LEBs in the LPT area */
740ff94bc40SHeiko Schocher for (lnum = c->lpt_first; lnum <= c->lpt_last; lnum++) {
741ff94bc40SHeiko Schocher int free = c->ltab[lnum - c->lpt_first].free;
742ff94bc40SHeiko Schocher
743ff94bc40SHeiko Schocher if (free > 0) {
744ff94bc40SHeiko Schocher err = fixup_leb(c, lnum, c->leb_size - free);
745ff94bc40SHeiko Schocher if (err)
746ff94bc40SHeiko Schocher goto out;
747ff94bc40SHeiko Schocher }
748ff94bc40SHeiko Schocher }
749ff94bc40SHeiko Schocher
750ff94bc40SHeiko Schocher /* Unmap LEBs in the orphans area */
751ff94bc40SHeiko Schocher for (lnum = c->orph_first; lnum <= c->orph_last; lnum++) {
752ff94bc40SHeiko Schocher err = fixup_leb(c, lnum, 0);
753ff94bc40SHeiko Schocher if (err)
754ff94bc40SHeiko Schocher goto out;
755ff94bc40SHeiko Schocher }
756ff94bc40SHeiko Schocher
757ff94bc40SHeiko Schocher /* Fixup LEBs in the main area */
758ff94bc40SHeiko Schocher for (lnum = c->main_first; lnum < c->leb_cnt; lnum++) {
759ff94bc40SHeiko Schocher lprops = ubifs_lpt_lookup(c, lnum);
760ff94bc40SHeiko Schocher if (IS_ERR(lprops)) {
761ff94bc40SHeiko Schocher err = PTR_ERR(lprops);
762ff94bc40SHeiko Schocher goto out;
763ff94bc40SHeiko Schocher }
764ff94bc40SHeiko Schocher
765ff94bc40SHeiko Schocher if (lprops->free > 0) {
766ff94bc40SHeiko Schocher err = fixup_leb(c, lnum, c->leb_size - lprops->free);
767ff94bc40SHeiko Schocher if (err)
768ff94bc40SHeiko Schocher goto out;
769ff94bc40SHeiko Schocher }
770ff94bc40SHeiko Schocher }
771ff94bc40SHeiko Schocher
772ff94bc40SHeiko Schocher out:
773ff94bc40SHeiko Schocher ubifs_release_lprops(c);
774ff94bc40SHeiko Schocher return err;
775ff94bc40SHeiko Schocher }
776ff94bc40SHeiko Schocher
777ff94bc40SHeiko Schocher /**
778ff94bc40SHeiko Schocher * ubifs_fixup_free_space - find & fix all LEBs with free space.
779ff94bc40SHeiko Schocher * @c: UBIFS file-system description object
780ff94bc40SHeiko Schocher *
781ff94bc40SHeiko Schocher * This function fixes up LEBs containing free space on first mount, if the
782ff94bc40SHeiko Schocher * appropriate flag was set when the FS was created. Each LEB with one or more
783ff94bc40SHeiko Schocher * empty min. I/O unit (i.e. free-space-count > 0) is re-written, to make sure
784ff94bc40SHeiko Schocher * the free space is actually erased. E.g., this is necessary for some NAND
785ff94bc40SHeiko Schocher * chips, since the free space may have been programmed like real "0xff" data
786ff94bc40SHeiko Schocher * (generating a non-0xff ECC), causing future writes to the not-really-erased
787ff94bc40SHeiko Schocher * NAND pages to behave badly. After the space is fixed up, the superblock flag
788ff94bc40SHeiko Schocher * is cleared, so that this is skipped for all future mounts.
789ff94bc40SHeiko Schocher */
ubifs_fixup_free_space(struct ubifs_info * c)790ff94bc40SHeiko Schocher int ubifs_fixup_free_space(struct ubifs_info *c)
791ff94bc40SHeiko Schocher {
792ff94bc40SHeiko Schocher int err;
793ff94bc40SHeiko Schocher struct ubifs_sb_node *sup;
794ff94bc40SHeiko Schocher
795ff94bc40SHeiko Schocher ubifs_assert(c->space_fixup);
796ff94bc40SHeiko Schocher ubifs_assert(!c->ro_mount);
797ff94bc40SHeiko Schocher
7980195a7bbSHeiko Schocher ubifs_msg(c, "start fixing up free space");
799ff94bc40SHeiko Schocher
800ff94bc40SHeiko Schocher err = fixup_free_space(c);
801ff94bc40SHeiko Schocher if (err)
802ff94bc40SHeiko Schocher return err;
803ff94bc40SHeiko Schocher
804ff94bc40SHeiko Schocher sup = ubifs_read_sb_node(c);
805ff94bc40SHeiko Schocher if (IS_ERR(sup))
806ff94bc40SHeiko Schocher return PTR_ERR(sup);
807ff94bc40SHeiko Schocher
808ff94bc40SHeiko Schocher /* Free-space fixup is no longer required */
809ff94bc40SHeiko Schocher c->space_fixup = 0;
810ff94bc40SHeiko Schocher sup->flags &= cpu_to_le32(~UBIFS_FLG_SPACE_FIXUP);
811ff94bc40SHeiko Schocher
812ff94bc40SHeiko Schocher err = ubifs_write_sb_node(c, sup);
813ff94bc40SHeiko Schocher kfree(sup);
814ff94bc40SHeiko Schocher if (err)
815ff94bc40SHeiko Schocher return err;
816ff94bc40SHeiko Schocher
8170195a7bbSHeiko Schocher ubifs_msg(c, "free space fixup complete");
818ff94bc40SHeiko Schocher return err;
819ff94bc40SHeiko Schocher }
820