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 } 347