← Back to branch summary

~pmdj/ubuntu/trusty/qemu/2.9+applesmc+fadtv3

« back to all changes in this revision

Viewing changes to roms/u-boot/fs/ubifs/sb.c

  • Committer: Phil Dennis-Jordan
  • Date: 2017-07-21 08:03:43 UTC
  • mfrom: (1.1.1)
  • Revision ID: phil@philjordan.eu-20170721080343-2yr2vdj7713czahv
New upstream release 2.9.0.

Show diffs side-by-side

added added

removed removed

Lines of Context:
roms/u-boot/fs/ubifs/sb.c
 
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 (32*1024*1024)
 
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 (5*1024*1024)
 
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
 
 
238
        c->fmt_version = le32_to_cpu(sup->fmt_version);
 
239
        c->ro_compat_version = le32_to_cpu(sup->ro_compat_version);
 
240
 
 
241
        /*
 
242
         * The software supports all previous versions but not future versions,
 
243
         * due to the unavailability of time-travelling equipment.
 
244
         */
 
245
        if (c->fmt_version > UBIFS_FORMAT_VERSION) {
 
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;
 
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
}