]>
git.ipfire.org Git - people/ms/u-boot.git/blob - fs/ubifs/master.c
2 * This file is part of UBIFS.
4 * Copyright (C) 2006-2008 Nokia Corporation.
6 * SPDX-License-Identifier: GPL-2.0+
8 * Authors: Artem Bityutskiy (Битюцкий Артём)
12 /* This file implements reading and writing the master node */
17 #include <linux/compat.h>
18 #include <linux/err.h>
19 #include <ubi_uboot.h>
23 * scan_for_master - search the valid master node.
24 * @c: UBIFS file-system description object
26 * This function scans the master node LEBs and search for the latest master
27 * node. Returns zero in case of success, %-EUCLEAN if there master area is
28 * corrupted and requires recovery, and a negative error code in case of
31 static int scan_for_master(struct ubifs_info
*c
)
33 struct ubifs_scan_leb
*sleb
;
34 struct ubifs_scan_node
*snod
;
35 int lnum
, offs
= 0, nodes_cnt
;
37 lnum
= UBIFS_MST_LNUM
;
39 sleb
= ubifs_scan(c
, lnum
, 0, c
->sbuf
, 1);
42 nodes_cnt
= sleb
->nodes_cnt
;
44 snod
= list_entry(sleb
->nodes
.prev
, struct ubifs_scan_node
,
46 if (snod
->type
!= UBIFS_MST_NODE
)
48 memcpy(c
->mst_node
, snod
->node
, snod
->len
);
51 ubifs_scan_destroy(sleb
);
55 sleb
= ubifs_scan(c
, lnum
, 0, c
->sbuf
, 1);
58 if (sleb
->nodes_cnt
!= nodes_cnt
)
62 snod
= list_entry(sleb
->nodes
.prev
, struct ubifs_scan_node
, list
);
63 if (snod
->type
!= UBIFS_MST_NODE
)
65 if (snod
->offs
!= offs
)
67 if (memcmp((void *)c
->mst_node
+ UBIFS_CH_SZ
,
68 (void *)snod
->node
+ UBIFS_CH_SZ
,
69 UBIFS_MST_NODE_SZ
- UBIFS_CH_SZ
))
72 ubifs_scan_destroy(sleb
);
76 ubifs_scan_destroy(sleb
);
80 ubifs_err("unexpected node type %d master LEB %d:%d",
81 snod
->type
, lnum
, snod
->offs
);
82 ubifs_scan_destroy(sleb
);
87 * validate_master - validate master node.
88 * @c: UBIFS file-system description object
90 * This function validates data which was read from master node. Returns zero
91 * if the data is all right and %-EINVAL if not.
93 static int validate_master(const struct ubifs_info
*c
)
98 if (c
->max_sqnum
>= SQNUM_WATERMARK
) {
103 if (c
->cmt_no
>= c
->max_sqnum
) {
108 if (c
->highest_inum
>= INUM_WATERMARK
) {
113 if (c
->lhead_lnum
< UBIFS_LOG_LNUM
||
114 c
->lhead_lnum
>= UBIFS_LOG_LNUM
+ c
->log_lebs
||
115 c
->lhead_offs
< 0 || c
->lhead_offs
>= c
->leb_size
||
116 c
->lhead_offs
& (c
->min_io_size
- 1)) {
121 if (c
->zroot
.lnum
>= c
->leb_cnt
|| c
->zroot
.lnum
< c
->main_first
||
122 c
->zroot
.offs
>= c
->leb_size
|| c
->zroot
.offs
& 7) {
127 if (c
->zroot
.len
< c
->ranges
[UBIFS_IDX_NODE
].min_len
||
128 c
->zroot
.len
> c
->ranges
[UBIFS_IDX_NODE
].max_len
) {
133 if (c
->gc_lnum
>= c
->leb_cnt
|| c
->gc_lnum
< c
->main_first
) {
138 if (c
->ihead_lnum
>= c
->leb_cnt
|| c
->ihead_lnum
< c
->main_first
||
139 c
->ihead_offs
% c
->min_io_size
|| c
->ihead_offs
< 0 ||
140 c
->ihead_offs
> c
->leb_size
|| c
->ihead_offs
& 7) {
145 main_sz
= (long long)c
->main_lebs
* c
->leb_size
;
146 if (c
->bi
.old_idx_sz
& 7 || c
->bi
.old_idx_sz
>= main_sz
) {
151 if (c
->lpt_lnum
< c
->lpt_first
|| c
->lpt_lnum
> c
->lpt_last
||
152 c
->lpt_offs
< 0 || c
->lpt_offs
+ c
->nnode_sz
> c
->leb_size
) {
157 if (c
->nhead_lnum
< c
->lpt_first
|| c
->nhead_lnum
> c
->lpt_last
||
158 c
->nhead_offs
< 0 || c
->nhead_offs
% c
->min_io_size
||
159 c
->nhead_offs
> c
->leb_size
) {
164 if (c
->ltab_lnum
< c
->lpt_first
|| c
->ltab_lnum
> c
->lpt_last
||
166 c
->ltab_offs
+ c
->ltab_sz
> c
->leb_size
) {
171 if (c
->big_lpt
&& (c
->lsave_lnum
< c
->lpt_first
||
172 c
->lsave_lnum
> c
->lpt_last
|| c
->lsave_offs
< 0 ||
173 c
->lsave_offs
+ c
->lsave_sz
> c
->leb_size
)) {
178 if (c
->lscan_lnum
< c
->main_first
|| c
->lscan_lnum
>= c
->leb_cnt
) {
183 if (c
->lst
.empty_lebs
< 0 || c
->lst
.empty_lebs
> c
->main_lebs
- 2) {
188 if (c
->lst
.idx_lebs
< 0 || c
->lst
.idx_lebs
> c
->main_lebs
- 1) {
193 if (c
->lst
.total_free
< 0 || c
->lst
.total_free
> main_sz
||
194 c
->lst
.total_free
& 7) {
199 if (c
->lst
.total_dirty
< 0 || (c
->lst
.total_dirty
& 7)) {
204 if (c
->lst
.total_used
< 0 || (c
->lst
.total_used
& 7)) {
209 if (c
->lst
.total_free
+ c
->lst
.total_dirty
+
210 c
->lst
.total_used
> main_sz
) {
215 if (c
->lst
.total_dead
+ c
->lst
.total_dark
+
216 c
->lst
.total_used
+ c
->bi
.old_idx_sz
> main_sz
) {
221 if (c
->lst
.total_dead
< 0 ||
222 c
->lst
.total_dead
> c
->lst
.total_free
+ c
->lst
.total_dirty
||
223 c
->lst
.total_dead
& 7) {
228 if (c
->lst
.total_dark
< 0 ||
229 c
->lst
.total_dark
> c
->lst
.total_free
+ c
->lst
.total_dirty
||
230 c
->lst
.total_dark
& 7) {
238 ubifs_err("bad master node at offset %d error %d", c
->mst_offs
, err
);
239 ubifs_dump_node(c
, c
->mst_node
);
244 * ubifs_read_master - read master node.
245 * @c: UBIFS file-system description object
247 * This function finds and reads the master node during file-system mount. If
248 * the flash is empty, it creates default master node as well. Returns zero in
249 * case of success and a negative error code in case of failure.
251 int ubifs_read_master(struct ubifs_info
*c
)
253 int err
, old_leb_cnt
;
255 c
->mst_node
= kzalloc(c
->mst_node_alsz
, GFP_KERNEL
);
259 err
= scan_for_master(c
);
262 err
= ubifs_recover_master_node(c
);
265 * Note, we do not free 'c->mst_node' here because the
266 * unmount routine will take care of this.
271 /* Make sure that the recovery flag is clear */
272 c
->mst_node
->flags
&= cpu_to_le32(~UBIFS_MST_RCVRY
);
274 c
->max_sqnum
= le64_to_cpu(c
->mst_node
->ch
.sqnum
);
275 c
->highest_inum
= le64_to_cpu(c
->mst_node
->highest_inum
);
276 c
->cmt_no
= le64_to_cpu(c
->mst_node
->cmt_no
);
277 c
->zroot
.lnum
= le32_to_cpu(c
->mst_node
->root_lnum
);
278 c
->zroot
.offs
= le32_to_cpu(c
->mst_node
->root_offs
);
279 c
->zroot
.len
= le32_to_cpu(c
->mst_node
->root_len
);
280 c
->lhead_lnum
= le32_to_cpu(c
->mst_node
->log_lnum
);
281 c
->gc_lnum
= le32_to_cpu(c
->mst_node
->gc_lnum
);
282 c
->ihead_lnum
= le32_to_cpu(c
->mst_node
->ihead_lnum
);
283 c
->ihead_offs
= le32_to_cpu(c
->mst_node
->ihead_offs
);
284 c
->bi
.old_idx_sz
= le64_to_cpu(c
->mst_node
->index_size
);
285 c
->lpt_lnum
= le32_to_cpu(c
->mst_node
->lpt_lnum
);
286 c
->lpt_offs
= le32_to_cpu(c
->mst_node
->lpt_offs
);
287 c
->nhead_lnum
= le32_to_cpu(c
->mst_node
->nhead_lnum
);
288 c
->nhead_offs
= le32_to_cpu(c
->mst_node
->nhead_offs
);
289 c
->ltab_lnum
= le32_to_cpu(c
->mst_node
->ltab_lnum
);
290 c
->ltab_offs
= le32_to_cpu(c
->mst_node
->ltab_offs
);
291 c
->lsave_lnum
= le32_to_cpu(c
->mst_node
->lsave_lnum
);
292 c
->lsave_offs
= le32_to_cpu(c
->mst_node
->lsave_offs
);
293 c
->lscan_lnum
= le32_to_cpu(c
->mst_node
->lscan_lnum
);
294 c
->lst
.empty_lebs
= le32_to_cpu(c
->mst_node
->empty_lebs
);
295 c
->lst
.idx_lebs
= le32_to_cpu(c
->mst_node
->idx_lebs
);
296 old_leb_cnt
= le32_to_cpu(c
->mst_node
->leb_cnt
);
297 c
->lst
.total_free
= le64_to_cpu(c
->mst_node
->total_free
);
298 c
->lst
.total_dirty
= le64_to_cpu(c
->mst_node
->total_dirty
);
299 c
->lst
.total_used
= le64_to_cpu(c
->mst_node
->total_used
);
300 c
->lst
.total_dead
= le64_to_cpu(c
->mst_node
->total_dead
);
301 c
->lst
.total_dark
= le64_to_cpu(c
->mst_node
->total_dark
);
303 c
->calc_idx_sz
= c
->bi
.old_idx_sz
;
305 if (c
->mst_node
->flags
& cpu_to_le32(UBIFS_MST_NO_ORPHS
))
308 if (old_leb_cnt
!= c
->leb_cnt
) {
309 /* The file system has been resized */
310 int growth
= c
->leb_cnt
- old_leb_cnt
;
312 if (c
->leb_cnt
< old_leb_cnt
||
313 c
->leb_cnt
< UBIFS_MIN_LEB_CNT
) {
314 ubifs_err("bad leb_cnt on master node");
315 ubifs_dump_node(c
, c
->mst_node
);
319 dbg_mnt("Auto resizing (master) from %d LEBs to %d LEBs",
320 old_leb_cnt
, c
->leb_cnt
);
321 c
->lst
.empty_lebs
+= growth
;
322 c
->lst
.total_free
+= growth
* (long long)c
->leb_size
;
323 c
->lst
.total_dark
+= growth
* (long long)c
->dark_wm
;
326 * Reflect changes back onto the master node. N.B. the master
327 * node gets written immediately whenever mounting (or
328 * remounting) in read-write mode, so we do not need to write it
331 c
->mst_node
->leb_cnt
= cpu_to_le32(c
->leb_cnt
);
332 c
->mst_node
->empty_lebs
= cpu_to_le32(c
->lst
.empty_lebs
);
333 c
->mst_node
->total_free
= cpu_to_le64(c
->lst
.total_free
);
334 c
->mst_node
->total_dark
= cpu_to_le64(c
->lst
.total_dark
);
337 err
= validate_master(c
);
342 err
= dbg_old_index_check_init(c
, &c
->zroot
);
350 * ubifs_write_master - write master node.
351 * @c: UBIFS file-system description object
353 * This function writes the master node. The caller has to take the
354 * @c->mst_mutex lock before calling this function. Returns zero in case of
355 * success and a negative error code in case of failure. The master node is
356 * written twice to enable recovery.
358 int ubifs_write_master(struct ubifs_info
*c
)
360 int err
, lnum
, offs
, len
;
362 ubifs_assert(!c
->ro_media
&& !c
->ro_mount
);
366 lnum
= UBIFS_MST_LNUM
;
367 offs
= c
->mst_offs
+ c
->mst_node_alsz
;
368 len
= UBIFS_MST_NODE_SZ
;
370 if (offs
+ UBIFS_MST_NODE_SZ
> c
->leb_size
) {
371 err
= ubifs_leb_unmap(c
, lnum
);
378 c
->mst_node
->highest_inum
= cpu_to_le64(c
->highest_inum
);
380 err
= ubifs_write_node(c
, c
->mst_node
, len
, lnum
, offs
);
387 err
= ubifs_leb_unmap(c
, lnum
);
391 err
= ubifs_write_node(c
, c
->mst_node
, len
, lnum
, offs
);