]>
git.ipfire.org Git - thirdparty/u-boot.git/blob - fs/ubifs/master.c
1 // SPDX-License-Identifier: GPL-2.0+
3 * This file is part of UBIFS.
5 * Copyright (C) 2006-2008 Nokia Corporation.
7 * Authors: Artem Bityutskiy (Битюцкий Артём)
11 /* This file implements reading and writing the master node */
15 #include <linux/compat.h>
16 #include <linux/err.h>
17 #include <ubi_uboot.h>
21 * scan_for_master - search the valid master node.
22 * @c: UBIFS file-system description object
24 * This function scans the master node LEBs and search for the latest master
25 * node. Returns zero in case of success, %-EUCLEAN if there master area is
26 * corrupted and requires recovery, and a negative error code in case of
29 static int scan_for_master(struct ubifs_info
*c
)
31 struct ubifs_scan_leb
*sleb
;
32 struct ubifs_scan_node
*snod
;
33 int lnum
, offs
= 0, nodes_cnt
;
35 lnum
= UBIFS_MST_LNUM
;
37 sleb
= ubifs_scan(c
, lnum
, 0, c
->sbuf
, 1);
40 nodes_cnt
= sleb
->nodes_cnt
;
42 snod
= list_entry(sleb
->nodes
.prev
, struct ubifs_scan_node
,
44 if (snod
->type
!= UBIFS_MST_NODE
)
46 memcpy(c
->mst_node
, snod
->node
, snod
->len
);
49 ubifs_scan_destroy(sleb
);
53 sleb
= ubifs_scan(c
, lnum
, 0, c
->sbuf
, 1);
56 if (sleb
->nodes_cnt
!= nodes_cnt
)
60 snod
= list_entry(sleb
->nodes
.prev
, struct ubifs_scan_node
, list
);
61 if (snod
->type
!= UBIFS_MST_NODE
)
63 if (snod
->offs
!= offs
)
65 if (memcmp((void *)c
->mst_node
+ UBIFS_CH_SZ
,
66 (void *)snod
->node
+ UBIFS_CH_SZ
,
67 UBIFS_MST_NODE_SZ
- UBIFS_CH_SZ
))
70 ubifs_scan_destroy(sleb
);
74 ubifs_scan_destroy(sleb
);
78 ubifs_err(c
, "unexpected node type %d master LEB %d:%d",
79 snod
->type
, lnum
, snod
->offs
);
80 ubifs_scan_destroy(sleb
);
85 * validate_master - validate master node.
86 * @c: UBIFS file-system description object
88 * This function validates data which was read from master node. Returns zero
89 * if the data is all right and %-EINVAL if not.
91 static int validate_master(const struct ubifs_info
*c
)
96 if (c
->max_sqnum
>= SQNUM_WATERMARK
) {
101 if (c
->cmt_no
>= c
->max_sqnum
) {
106 if (c
->highest_inum
>= INUM_WATERMARK
) {
111 if (c
->lhead_lnum
< UBIFS_LOG_LNUM
||
112 c
->lhead_lnum
>= UBIFS_LOG_LNUM
+ c
->log_lebs
||
113 c
->lhead_offs
< 0 || c
->lhead_offs
>= c
->leb_size
||
114 c
->lhead_offs
& (c
->min_io_size
- 1)) {
119 if (c
->zroot
.lnum
>= c
->leb_cnt
|| c
->zroot
.lnum
< c
->main_first
||
120 c
->zroot
.offs
>= c
->leb_size
|| c
->zroot
.offs
& 7) {
125 if (c
->zroot
.len
< c
->ranges
[UBIFS_IDX_NODE
].min_len
||
126 c
->zroot
.len
> c
->ranges
[UBIFS_IDX_NODE
].max_len
) {
131 if (c
->gc_lnum
>= c
->leb_cnt
|| c
->gc_lnum
< c
->main_first
) {
136 if (c
->ihead_lnum
>= c
->leb_cnt
|| c
->ihead_lnum
< c
->main_first
||
137 c
->ihead_offs
% c
->min_io_size
|| c
->ihead_offs
< 0 ||
138 c
->ihead_offs
> c
->leb_size
|| c
->ihead_offs
& 7) {
143 main_sz
= (long long)c
->main_lebs
* c
->leb_size
;
144 if (c
->bi
.old_idx_sz
& 7 || c
->bi
.old_idx_sz
>= main_sz
) {
149 if (c
->lpt_lnum
< c
->lpt_first
|| c
->lpt_lnum
> c
->lpt_last
||
150 c
->lpt_offs
< 0 || c
->lpt_offs
+ c
->nnode_sz
> c
->leb_size
) {
155 if (c
->nhead_lnum
< c
->lpt_first
|| c
->nhead_lnum
> c
->lpt_last
||
156 c
->nhead_offs
< 0 || c
->nhead_offs
% c
->min_io_size
||
157 c
->nhead_offs
> c
->leb_size
) {
162 if (c
->ltab_lnum
< c
->lpt_first
|| c
->ltab_lnum
> c
->lpt_last
||
164 c
->ltab_offs
+ c
->ltab_sz
> c
->leb_size
) {
169 if (c
->big_lpt
&& (c
->lsave_lnum
< c
->lpt_first
||
170 c
->lsave_lnum
> c
->lpt_last
|| c
->lsave_offs
< 0 ||
171 c
->lsave_offs
+ c
->lsave_sz
> c
->leb_size
)) {
176 if (c
->lscan_lnum
< c
->main_first
|| c
->lscan_lnum
>= c
->leb_cnt
) {
181 if (c
->lst
.empty_lebs
< 0 || c
->lst
.empty_lebs
> c
->main_lebs
- 2) {
186 if (c
->lst
.idx_lebs
< 0 || c
->lst
.idx_lebs
> c
->main_lebs
- 1) {
191 if (c
->lst
.total_free
< 0 || c
->lst
.total_free
> main_sz
||
192 c
->lst
.total_free
& 7) {
197 if (c
->lst
.total_dirty
< 0 || (c
->lst
.total_dirty
& 7)) {
202 if (c
->lst
.total_used
< 0 || (c
->lst
.total_used
& 7)) {
207 if (c
->lst
.total_free
+ c
->lst
.total_dirty
+
208 c
->lst
.total_used
> main_sz
) {
213 if (c
->lst
.total_dead
+ c
->lst
.total_dark
+
214 c
->lst
.total_used
+ c
->bi
.old_idx_sz
> main_sz
) {
219 if (c
->lst
.total_dead
< 0 ||
220 c
->lst
.total_dead
> c
->lst
.total_free
+ c
->lst
.total_dirty
||
221 c
->lst
.total_dead
& 7) {
226 if (c
->lst
.total_dark
< 0 ||
227 c
->lst
.total_dark
> c
->lst
.total_free
+ c
->lst
.total_dirty
||
228 c
->lst
.total_dark
& 7) {
236 ubifs_err(c
, "bad master node at offset %d error %d", c
->mst_offs
, err
);
237 ubifs_dump_node(c
, c
->mst_node
);
242 * ubifs_read_master - read master node.
243 * @c: UBIFS file-system description object
245 * This function finds and reads the master node during file-system mount. If
246 * the flash is empty, it creates default master node as well. Returns zero in
247 * case of success and a negative error code in case of failure.
249 int ubifs_read_master(struct ubifs_info
*c
)
251 int err
, old_leb_cnt
;
253 c
->mst_node
= kzalloc(c
->mst_node_alsz
, GFP_KERNEL
);
257 err
= scan_for_master(c
);
260 err
= ubifs_recover_master_node(c
);
263 * Note, we do not free 'c->mst_node' here because the
264 * unmount routine will take care of this.
269 /* Make sure that the recovery flag is clear */
270 c
->mst_node
->flags
&= cpu_to_le32(~UBIFS_MST_RCVRY
);
272 c
->max_sqnum
= le64_to_cpu(c
->mst_node
->ch
.sqnum
);
273 c
->highest_inum
= le64_to_cpu(c
->mst_node
->highest_inum
);
274 c
->cmt_no
= le64_to_cpu(c
->mst_node
->cmt_no
);
275 c
->zroot
.lnum
= le32_to_cpu(c
->mst_node
->root_lnum
);
276 c
->zroot
.offs
= le32_to_cpu(c
->mst_node
->root_offs
);
277 c
->zroot
.len
= le32_to_cpu(c
->mst_node
->root_len
);
278 c
->lhead_lnum
= le32_to_cpu(c
->mst_node
->log_lnum
);
279 c
->gc_lnum
= le32_to_cpu(c
->mst_node
->gc_lnum
);
280 c
->ihead_lnum
= le32_to_cpu(c
->mst_node
->ihead_lnum
);
281 c
->ihead_offs
= le32_to_cpu(c
->mst_node
->ihead_offs
);
282 c
->bi
.old_idx_sz
= le64_to_cpu(c
->mst_node
->index_size
);
283 c
->lpt_lnum
= le32_to_cpu(c
->mst_node
->lpt_lnum
);
284 c
->lpt_offs
= le32_to_cpu(c
->mst_node
->lpt_offs
);
285 c
->nhead_lnum
= le32_to_cpu(c
->mst_node
->nhead_lnum
);
286 c
->nhead_offs
= le32_to_cpu(c
->mst_node
->nhead_offs
);
287 c
->ltab_lnum
= le32_to_cpu(c
->mst_node
->ltab_lnum
);
288 c
->ltab_offs
= le32_to_cpu(c
->mst_node
->ltab_offs
);
289 c
->lsave_lnum
= le32_to_cpu(c
->mst_node
->lsave_lnum
);
290 c
->lsave_offs
= le32_to_cpu(c
->mst_node
->lsave_offs
);
291 c
->lscan_lnum
= le32_to_cpu(c
->mst_node
->lscan_lnum
);
292 c
->lst
.empty_lebs
= le32_to_cpu(c
->mst_node
->empty_lebs
);
293 c
->lst
.idx_lebs
= le32_to_cpu(c
->mst_node
->idx_lebs
);
294 old_leb_cnt
= le32_to_cpu(c
->mst_node
->leb_cnt
);
295 c
->lst
.total_free
= le64_to_cpu(c
->mst_node
->total_free
);
296 c
->lst
.total_dirty
= le64_to_cpu(c
->mst_node
->total_dirty
);
297 c
->lst
.total_used
= le64_to_cpu(c
->mst_node
->total_used
);
298 c
->lst
.total_dead
= le64_to_cpu(c
->mst_node
->total_dead
);
299 c
->lst
.total_dark
= le64_to_cpu(c
->mst_node
->total_dark
);
301 c
->calc_idx_sz
= c
->bi
.old_idx_sz
;
303 if (c
->mst_node
->flags
& cpu_to_le32(UBIFS_MST_NO_ORPHS
))
306 if (old_leb_cnt
!= c
->leb_cnt
) {
307 /* The file system has been resized */
308 int growth
= c
->leb_cnt
- old_leb_cnt
;
310 if (c
->leb_cnt
< old_leb_cnt
||
311 c
->leb_cnt
< UBIFS_MIN_LEB_CNT
) {
312 ubifs_err(c
, "bad leb_cnt on master node");
313 ubifs_dump_node(c
, c
->mst_node
);
317 dbg_mnt("Auto resizing (master) from %d LEBs to %d LEBs",
318 old_leb_cnt
, c
->leb_cnt
);
319 c
->lst
.empty_lebs
+= growth
;
320 c
->lst
.total_free
+= growth
* (long long)c
->leb_size
;
321 c
->lst
.total_dark
+= growth
* (long long)c
->dark_wm
;
324 * Reflect changes back onto the master node. N.B. the master
325 * node gets written immediately whenever mounting (or
326 * remounting) in read-write mode, so we do not need to write it
329 c
->mst_node
->leb_cnt
= cpu_to_le32(c
->leb_cnt
);
330 c
->mst_node
->empty_lebs
= cpu_to_le32(c
->lst
.empty_lebs
);
331 c
->mst_node
->total_free
= cpu_to_le64(c
->lst
.total_free
);
332 c
->mst_node
->total_dark
= cpu_to_le64(c
->lst
.total_dark
);
335 err
= validate_master(c
);
340 err
= dbg_old_index_check_init(c
, &c
->zroot
);
348 * ubifs_write_master - write master node.
349 * @c: UBIFS file-system description object
351 * This function writes the master node. Returns zero in case of success and a
352 * negative error code in case of failure. The master node is written twice to
355 int ubifs_write_master(struct ubifs_info
*c
)
357 int err
, lnum
, offs
, len
;
359 ubifs_assert(!c
->ro_media
&& !c
->ro_mount
);
363 lnum
= UBIFS_MST_LNUM
;
364 offs
= c
->mst_offs
+ c
->mst_node_alsz
;
365 len
= UBIFS_MST_NODE_SZ
;
367 if (offs
+ UBIFS_MST_NODE_SZ
> c
->leb_size
) {
368 err
= ubifs_leb_unmap(c
, lnum
);
375 c
->mst_node
->highest_inum
= cpu_to_le64(c
->highest_inum
);
377 err
= ubifs_write_node(c
, c
->mst_node
, len
, lnum
, offs
);
384 err
= ubifs_leb_unmap(c
, lnum
);
388 err
= ubifs_write_node(c
, c
->mst_node
, len
, lnum
, offs
);