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 initialization and VFS superblock operations. Some 25 * initialization stuff which is rather large and complex is placed at 26 * corresponding subsystems, but most of it is here. 27 */ 28 29 #include <linux/init.h> 30 #include <linux/slab.h> 31 #include <linux/module.h> 32 #include <linux/ctype.h> 33 #include <linux/kthread.h> 34 #include <linux/parser.h> 35 #include <linux/seq_file.h> 36 #include <linux/mount.h> 37 #include <linux/math64.h> 38 #include <linux/writeback.h> 39 #include "ubifs.h" 40 41 /* 42 * Maximum amount of memory we may 'kmalloc()' without worrying that we are 43 * allocating too much. 44 */ 45 #define UBIFS_KMALLOC_OK (128*1024) 46 47 /* Slab cache for UBIFS inodes */ 48 struct kmem_cache *ubifs_inode_slab; 49 50 /* UBIFS TNC shrinker description */ 51 static struct shrinker ubifs_shrinker_info = { 52 .shrink = ubifs_shrinker, 53 .seeks = DEFAULT_SEEKS, 54 }; 55 56 /** 57 * validate_inode - validate inode. 58 * @c: UBIFS file-system description object 59 * @inode: the inode to validate 60 * 61 * This is a helper function for 'ubifs_iget()' which validates various fields 62 * of a newly built inode to make sure they contain sane values and prevent 63 * possible vulnerabilities. Returns zero if the inode is all right and 64 * a non-zero error code if not. 65 */ 66 static int validate_inode(struct ubifs_info *c, const struct inode *inode) 67 { 68 int err; 69 const struct ubifs_inode *ui = ubifs_inode(inode); 70 71 if (inode->i_size > c->max_inode_sz) { 72 ubifs_err("inode is too large (%lld)", 73 (long long)inode->i_size); 74 return 1; 75 } 76 77 if (ui->compr_type < 0 || ui->compr_type >= UBIFS_COMPR_TYPES_CNT) { 78 ubifs_err("unknown compression type %d", ui->compr_type); 79 return 2; 80 } 81 82 if (ui->xattr_names + ui->xattr_cnt > XATTR_LIST_MAX) 83 return 3; 84 85 if (ui->data_len < 0 || ui->data_len > UBIFS_MAX_INO_DATA) 86 return 4; 87 88 if (ui->xattr && (inode->i_mode & S_IFMT) != S_IFREG) 89 return 5; 90 91 if (!ubifs_compr_present(ui->compr_type)) { 92 ubifs_warn("inode %lu uses '%s' compression, but it was not " 93 "compiled in", inode->i_ino, 94 ubifs_compr_name(ui->compr_type)); 95 } 96 97 err = dbg_check_dir_size(c, inode); 98 return err; 99 } 100 101 struct inode *ubifs_iget(struct super_block *sb, unsigned long inum) 102 { 103 int err; 104 union ubifs_key key; 105 struct ubifs_ino_node *ino; 106 struct ubifs_info *c = sb->s_fs_info; 107 struct inode *inode; 108 struct ubifs_inode *ui; 109 110 dbg_gen("inode %lu", inum); 111 112 inode = iget_locked(sb, inum); 113 if (!inode) 114 return ERR_PTR(-ENOMEM); 115 if (!(inode->i_state & I_NEW)) 116 return inode; 117 ui = ubifs_inode(inode); 118 119 ino = kmalloc(UBIFS_MAX_INO_NODE_SZ, GFP_NOFS); 120 if (!ino) { 121 err = -ENOMEM; 122 goto out; 123 } 124 125 ino_key_init(c, &key, inode->i_ino); 126 127 err = ubifs_tnc_lookup(c, &key, ino); 128 if (err) 129 goto out_ino; 130 131 inode->i_flags |= (S_NOCMTIME | S_NOATIME); 132 inode->i_nlink = le32_to_cpu(ino->nlink); 133 inode->i_uid = le32_to_cpu(ino->uid); 134 inode->i_gid = le32_to_cpu(ino->gid); 135 inode->i_atime.tv_sec = (int64_t)le64_to_cpu(ino->atime_sec); 136 inode->i_atime.tv_nsec = le32_to_cpu(ino->atime_nsec); 137 inode->i_mtime.tv_sec = (int64_t)le64_to_cpu(ino->mtime_sec); 138 inode->i_mtime.tv_nsec = le32_to_cpu(ino->mtime_nsec); 139 inode->i_ctime.tv_sec = (int64_t)le64_to_cpu(ino->ctime_sec); 140 inode->i_ctime.tv_nsec = le32_to_cpu(ino->ctime_nsec); 141 inode->i_mode = le32_to_cpu(ino->mode); 142 inode->i_size = le64_to_cpu(ino->size); 143 144 ui->data_len = le32_to_cpu(ino->data_len); 145 ui->flags = le32_to_cpu(ino->flags); 146 ui->compr_type = le16_to_cpu(ino->compr_type); 147 ui->creat_sqnum = le64_to_cpu(ino->creat_sqnum); 148 ui->xattr_cnt = le32_to_cpu(ino->xattr_cnt); 149 ui->xattr_size = le32_to_cpu(ino->xattr_size); 150 ui->xattr_names = le32_to_cpu(ino->xattr_names); 151 ui->synced_i_size = ui->ui_size = inode->i_size; 152 153 ui->xattr = (ui->flags & UBIFS_XATTR_FL) ? 1 : 0; 154 155 err = validate_inode(c, inode); 156 if (err) 157 goto out_invalid; 158 159 /* Disable read-ahead */ 160 inode->i_mapping->backing_dev_info = &c->bdi; 161 162 switch (inode->i_mode & S_IFMT) { 163 case S_IFREG: 164 inode->i_mapping->a_ops = &ubifs_file_address_operations; 165 inode->i_op = &ubifs_file_inode_operations; 166 inode->i_fop = &ubifs_file_operations; 167 if (ui->xattr) { 168 ui->data = kmalloc(ui->data_len + 1, GFP_NOFS); 169 if (!ui->data) { 170 err = -ENOMEM; 171 goto out_ino; 172 } 173 memcpy(ui->data, ino->data, ui->data_len); 174 ((char *)ui->data)[ui->data_len] = '\0'; 175 } else if (ui->data_len != 0) { 176 err = 10; 177 goto out_invalid; 178 } 179 break; 180 case S_IFDIR: 181 inode->i_op = &ubifs_dir_inode_operations; 182 inode->i_fop = &ubifs_dir_operations; 183 if (ui->data_len != 0) { 184 err = 11; 185 goto out_invalid; 186 } 187 break; 188 case S_IFLNK: 189 inode->i_op = &ubifs_symlink_inode_operations; 190 if (ui->data_len <= 0 || ui->data_len > UBIFS_MAX_INO_DATA) { 191 err = 12; 192 goto out_invalid; 193 } 194 ui->data = kmalloc(ui->data_len + 1, GFP_NOFS); 195 if (!ui->data) { 196 err = -ENOMEM; 197 goto out_ino; 198 } 199 memcpy(ui->data, ino->data, ui->data_len); 200 ((char *)ui->data)[ui->data_len] = '\0'; 201 break; 202 case S_IFBLK: 203 case S_IFCHR: 204 { 205 dev_t rdev; 206 union ubifs_dev_desc *dev; 207 208 ui->data = kmalloc(sizeof(union ubifs_dev_desc), GFP_NOFS); 209 if (!ui->data) { 210 err = -ENOMEM; 211 goto out_ino; 212 } 213 214 dev = (union ubifs_dev_desc *)ino->data; 215 if (ui->data_len == sizeof(dev->new)) 216 rdev = new_decode_dev(le32_to_cpu(dev->new)); 217 else if (ui->data_len == sizeof(dev->huge)) 218 rdev = huge_decode_dev(le64_to_cpu(dev->huge)); 219 else { 220 err = 13; 221 goto out_invalid; 222 } 223 memcpy(ui->data, ino->data, ui->data_len); 224 inode->i_op = &ubifs_file_inode_operations; 225 init_special_inode(inode, inode->i_mode, rdev); 226 break; 227 } 228 case S_IFSOCK: 229 case S_IFIFO: 230 inode->i_op = &ubifs_file_inode_operations; 231 init_special_inode(inode, inode->i_mode, 0); 232 if (ui->data_len != 0) { 233 err = 14; 234 goto out_invalid; 235 } 236 break; 237 default: 238 err = 15; 239 goto out_invalid; 240 } 241 242 kfree(ino); 243 ubifs_set_inode_flags(inode); 244 unlock_new_inode(inode); 245 return inode; 246 247 out_invalid: 248 ubifs_err("inode %lu validation failed, error %d", inode->i_ino, err); 249 dbg_dump_node(c, ino); 250 dbg_dump_inode(c, inode); 251 err = -EINVAL; 252 out_ino: 253 kfree(ino); 254 out: 255 ubifs_err("failed to read inode %lu, error %d", inode->i_ino, err); 256 iget_failed(inode); 257 return ERR_PTR(err); 258 } 259 260 static struct inode *ubifs_alloc_inode(struct super_block *sb) 261 { 262 struct ubifs_inode *ui; 263 264 ui = kmem_cache_alloc(ubifs_inode_slab, GFP_NOFS); 265 if (!ui) 266 return NULL; 267 268 memset((void *)ui + sizeof(struct inode), 0, 269 sizeof(struct ubifs_inode) - sizeof(struct inode)); 270 mutex_init(&ui->ui_mutex); 271 spin_lock_init(&ui->ui_lock); 272 return &ui->vfs_inode; 273 }; 274 275 static void ubifs_destroy_inode(struct inode *inode) 276 { 277 struct ubifs_inode *ui = ubifs_inode(inode); 278 279 kfree(ui->data); 280 kmem_cache_free(ubifs_inode_slab, inode); 281 } 282 283 /* 284 * Note, Linux write-back code calls this without 'i_mutex'. 285 */ 286 static int ubifs_write_inode(struct inode *inode, int wait) 287 { 288 int err = 0; 289 struct ubifs_info *c = inode->i_sb->s_fs_info; 290 struct ubifs_inode *ui = ubifs_inode(inode); 291 292 ubifs_assert(!ui->xattr); 293 if (is_bad_inode(inode)) 294 return 0; 295 296 mutex_lock(&ui->ui_mutex); 297 /* 298 * Due to races between write-back forced by budgeting 299 * (see 'sync_some_inodes()') and pdflush write-back, the inode may 300 * have already been synchronized, do not do this again. This might 301 * also happen if it was synchronized in an VFS operation, e.g. 302 * 'ubifs_link()'. 303 */ 304 if (!ui->dirty) { 305 mutex_unlock(&ui->ui_mutex); 306 return 0; 307 } 308 309 /* 310 * As an optimization, do not write orphan inodes to the media just 311 * because this is not needed. 312 */ 313 dbg_gen("inode %lu, mode %#x, nlink %u", 314 inode->i_ino, (int)inode->i_mode, inode->i_nlink); 315 if (inode->i_nlink) { 316 err = ubifs_jnl_write_inode(c, inode); 317 if (err) 318 ubifs_err("can't write inode %lu, error %d", 319 inode->i_ino, err); 320 else 321 err = dbg_check_inode_size(c, inode, ui->ui_size); 322 } 323 324 ui->dirty = 0; 325 mutex_unlock(&ui->ui_mutex); 326 ubifs_release_dirty_inode_budget(c, ui); 327 return err; 328 } 329 330 static void ubifs_delete_inode(struct inode *inode) 331 { 332 int err; 333 struct ubifs_info *c = inode->i_sb->s_fs_info; 334 struct ubifs_inode *ui = ubifs_inode(inode); 335 336 if (ui->xattr) 337 /* 338 * Extended attribute inode deletions are fully handled in 339 * 'ubifs_removexattr()'. These inodes are special and have 340 * limited usage, so there is nothing to do here. 341 */ 342 goto out; 343 344 dbg_gen("inode %lu, mode %#x", inode->i_ino, (int)inode->i_mode); 345 ubifs_assert(!atomic_read(&inode->i_count)); 346 ubifs_assert(inode->i_nlink == 0); 347 348 truncate_inode_pages(&inode->i_data, 0); 349 if (is_bad_inode(inode)) 350 goto out; 351 352 ui->ui_size = inode->i_size = 0; 353 err = ubifs_jnl_delete_inode(c, inode); 354 if (err) 355 /* 356 * Worst case we have a lost orphan inode wasting space, so a 357 * simple error message is OK here. 358 */ 359 ubifs_err("can't delete inode %lu, error %d", 360 inode->i_ino, err); 361 362 out: 363 if (ui->dirty) 364 ubifs_release_dirty_inode_budget(c, ui); 365 else { 366 /* We've deleted something - clean the "no space" flags */ 367 c->nospace = c->nospace_rp = 0; 368 smp_wmb(); 369 } 370 clear_inode(inode); 371 } 372 373 static void ubifs_dirty_inode(struct inode *inode) 374 { 375 struct ubifs_inode *ui = ubifs_inode(inode); 376 377 ubifs_assert(mutex_is_locked(&ui->ui_mutex)); 378 if (!ui->dirty) { 379 ui->dirty = 1; 380 dbg_gen("inode %lu", inode->i_ino); 381 } 382 } 383 384 static int ubifs_statfs(struct dentry *dentry, struct kstatfs *buf) 385 { 386 struct ubifs_info *c = dentry->d_sb->s_fs_info; 387 unsigned long long free; 388 __le32 *uuid = (__le32 *)c->uuid; 389 390 free = ubifs_get_free_space(c); 391 dbg_gen("free space %lld bytes (%lld blocks)", 392 free, free >> UBIFS_BLOCK_SHIFT); 393 394 buf->f_type = UBIFS_SUPER_MAGIC; 395 buf->f_bsize = UBIFS_BLOCK_SIZE; 396 buf->f_blocks = c->block_cnt; 397 buf->f_bfree = free >> UBIFS_BLOCK_SHIFT; 398 if (free > c->report_rp_size) 399 buf->f_bavail = (free - c->report_rp_size) >> UBIFS_BLOCK_SHIFT; 400 else 401 buf->f_bavail = 0; 402 buf->f_files = 0; 403 buf->f_ffree = 0; 404 buf->f_namelen = UBIFS_MAX_NLEN; 405 buf->f_fsid.val[0] = le32_to_cpu(uuid[0]) ^ le32_to_cpu(uuid[2]); 406 buf->f_fsid.val[1] = le32_to_cpu(uuid[1]) ^ le32_to_cpu(uuid[3]); 407 ubifs_assert(buf->f_bfree <= c->block_cnt); 408 return 0; 409 } 410 411 static int ubifs_show_options(struct seq_file *s, struct vfsmount *mnt) 412 { 413 struct ubifs_info *c = mnt->mnt_sb->s_fs_info; 414 415 if (c->mount_opts.unmount_mode == 2) 416 seq_printf(s, ",fast_unmount"); 417 else if (c->mount_opts.unmount_mode == 1) 418 seq_printf(s, ",norm_unmount"); 419 420 if (c->mount_opts.bulk_read == 2) 421 seq_printf(s, ",bulk_read"); 422 else if (c->mount_opts.bulk_read == 1) 423 seq_printf(s, ",no_bulk_read"); 424 425 if (c->mount_opts.chk_data_crc == 2) 426 seq_printf(s, ",chk_data_crc"); 427 else if (c->mount_opts.chk_data_crc == 1) 428 seq_printf(s, ",no_chk_data_crc"); 429 430 if (c->mount_opts.override_compr) { 431 seq_printf(s, ",compr=%s", 432 ubifs_compr_name(c->mount_opts.compr_type)); 433 } 434 435 return 0; 436 } 437 438 static int ubifs_sync_fs(struct super_block *sb, int wait) 439 { 440 int i, err; 441 struct ubifs_info *c = sb->s_fs_info; 442 443 /* 444 * Zero @wait is just an advisory thing to help the file system shove 445 * lots of data into the queues, and there will be the second 446 * '->sync_fs()' call, with non-zero @wait. 447 */ 448 if (!wait) 449 return 0; 450 451 /* 452 * Synchronize write buffers, because 'ubifs_run_commit()' does not 453 * do this if it waits for an already running commit. 454 */ 455 for (i = 0; i < c->jhead_cnt; i++) { 456 err = ubifs_wbuf_sync(&c->jheads[i].wbuf); 457 if (err) 458 return err; 459 } 460 461 /* 462 * Strictly speaking, it is not necessary to commit the journal here, 463 * synchronizing write-buffers would be enough. But committing makes 464 * UBIFS free space predictions much more accurate, so we want to let 465 * the user be able to get more accurate results of 'statfs()' after 466 * they synchronize the file system. 467 */ 468 err = ubifs_run_commit(c); 469 if (err) 470 return err; 471 472 return ubi_sync(c->vi.ubi_num); 473 } 474 475 /** 476 * init_constants_early - initialize UBIFS constants. 477 * @c: UBIFS file-system description object 478 * 479 * This function initialize UBIFS constants which do not need the superblock to 480 * be read. It also checks that the UBI volume satisfies basic UBIFS 481 * requirements. Returns zero in case of success and a negative error code in 482 * case of failure. 483 */ 484 static int init_constants_early(struct ubifs_info *c) 485 { 486 if (c->vi.corrupted) { 487 ubifs_warn("UBI volume is corrupted - read-only mode"); 488 c->ro_media = 1; 489 } 490 491 if (c->di.ro_mode) { 492 ubifs_msg("read-only UBI device"); 493 c->ro_media = 1; 494 } 495 496 if (c->vi.vol_type == UBI_STATIC_VOLUME) { 497 ubifs_msg("static UBI volume - read-only mode"); 498 c->ro_media = 1; 499 } 500 501 c->leb_cnt = c->vi.size; 502 c->leb_size = c->vi.usable_leb_size; 503 c->half_leb_size = c->leb_size / 2; 504 c->min_io_size = c->di.min_io_size; 505 c->min_io_shift = fls(c->min_io_size) - 1; 506 507 if (c->leb_size < UBIFS_MIN_LEB_SZ) { 508 ubifs_err("too small LEBs (%d bytes), min. is %d bytes", 509 c->leb_size, UBIFS_MIN_LEB_SZ); 510 return -EINVAL; 511 } 512 513 if (c->leb_cnt < UBIFS_MIN_LEB_CNT) { 514 ubifs_err("too few LEBs (%d), min. is %d", 515 c->leb_cnt, UBIFS_MIN_LEB_CNT); 516 return -EINVAL; 517 } 518 519 if (!is_power_of_2(c->min_io_size)) { 520 ubifs_err("bad min. I/O size %d", c->min_io_size); 521 return -EINVAL; 522 } 523 524 /* 525 * UBIFS aligns all node to 8-byte boundary, so to make function in 526 * io.c simpler, assume minimum I/O unit size to be 8 bytes if it is 527 * less than 8. 528 */ 529 if (c->min_io_size < 8) { 530 c->min_io_size = 8; 531 c->min_io_shift = 3; 532 } 533 534 c->ref_node_alsz = ALIGN(UBIFS_REF_NODE_SZ, c->min_io_size); 535 c->mst_node_alsz = ALIGN(UBIFS_MST_NODE_SZ, c->min_io_size); 536 537 /* 538 * Initialize node length ranges which are mostly needed for node 539 * length validation. 540 */ 541 c->ranges[UBIFS_PAD_NODE].len = UBIFS_PAD_NODE_SZ; 542 c->ranges[UBIFS_SB_NODE].len = UBIFS_SB_NODE_SZ; 543 c->ranges[UBIFS_MST_NODE].len = UBIFS_MST_NODE_SZ; 544 c->ranges[UBIFS_REF_NODE].len = UBIFS_REF_NODE_SZ; 545 c->ranges[UBIFS_TRUN_NODE].len = UBIFS_TRUN_NODE_SZ; 546 c->ranges[UBIFS_CS_NODE].len = UBIFS_CS_NODE_SZ; 547 548 c->ranges[UBIFS_INO_NODE].min_len = UBIFS_INO_NODE_SZ; 549 c->ranges[UBIFS_INO_NODE].max_len = UBIFS_MAX_INO_NODE_SZ; 550 c->ranges[UBIFS_ORPH_NODE].min_len = 551 UBIFS_ORPH_NODE_SZ + sizeof(__le64); 552 c->ranges[UBIFS_ORPH_NODE].max_len = c->leb_size; 553 c->ranges[UBIFS_DENT_NODE].min_len = UBIFS_DENT_NODE_SZ; 554 c->ranges[UBIFS_DENT_NODE].max_len = UBIFS_MAX_DENT_NODE_SZ; 555 c->ranges[UBIFS_XENT_NODE].min_len = UBIFS_XENT_NODE_SZ; 556 c->ranges[UBIFS_XENT_NODE].max_len = UBIFS_MAX_XENT_NODE_SZ; 557 c->ranges[UBIFS_DATA_NODE].min_len = UBIFS_DATA_NODE_SZ; 558 c->ranges[UBIFS_DATA_NODE].max_len = UBIFS_MAX_DATA_NODE_SZ; 559 /* 560 * Minimum indexing node size is amended later when superblock is 561 * read and the key length is known. 562 */ 563 c->ranges[UBIFS_IDX_NODE].min_len = UBIFS_IDX_NODE_SZ + UBIFS_BRANCH_SZ; 564 /* 565 * Maximum indexing node size is amended later when superblock is 566 * read and the fanout is known. 567 */ 568 c->ranges[UBIFS_IDX_NODE].max_len = INT_MAX; 569 570 /* 571 * Initialize dead and dark LEB space watermarks. See gc.c for comments 572 * about these values. 573 */ 574 c->dead_wm = ALIGN(MIN_WRITE_SZ, c->min_io_size); 575 c->dark_wm = ALIGN(UBIFS_MAX_NODE_SZ, c->min_io_size); 576 577 /* 578 * Calculate how many bytes would be wasted at the end of LEB if it was 579 * fully filled with data nodes of maximum size. This is used in 580 * calculations when reporting free space. 581 */ 582 c->leb_overhead = c->leb_size % UBIFS_MAX_DATA_NODE_SZ; 583 584 /* Buffer size for bulk-reads */ 585 c->max_bu_buf_len = UBIFS_MAX_BULK_READ * UBIFS_MAX_DATA_NODE_SZ; 586 if (c->max_bu_buf_len > c->leb_size) 587 c->max_bu_buf_len = c->leb_size; 588 return 0; 589 } 590 591 /** 592 * bud_wbuf_callback - bud LEB write-buffer synchronization call-back. 593 * @c: UBIFS file-system description object 594 * @lnum: LEB the write-buffer was synchronized to 595 * @free: how many free bytes left in this LEB 596 * @pad: how many bytes were padded 597 * 598 * This is a callback function which is called by the I/O unit when the 599 * write-buffer is synchronized. We need this to correctly maintain space 600 * accounting in bud logical eraseblocks. This function returns zero in case of 601 * success and a negative error code in case of failure. 602 * 603 * This function actually belongs to the journal, but we keep it here because 604 * we want to keep it static. 605 */ 606 static int bud_wbuf_callback(struct ubifs_info *c, int lnum, int free, int pad) 607 { 608 return ubifs_update_one_lp(c, lnum, free, pad, 0, 0); 609 } 610 611 /* 612 * init_constants_sb - initialize UBIFS constants. 613 * @c: UBIFS file-system description object 614 * 615 * This is a helper function which initializes various UBIFS constants after 616 * the superblock has been read. It also checks various UBIFS parameters and 617 * makes sure they are all right. Returns zero in case of success and a 618 * negative error code in case of failure. 619 */ 620 static int init_constants_sb(struct ubifs_info *c) 621 { 622 int tmp, err; 623 long long tmp64; 624 625 c->main_bytes = (long long)c->main_lebs * c->leb_size; 626 c->max_znode_sz = sizeof(struct ubifs_znode) + 627 c->fanout * sizeof(struct ubifs_zbranch); 628 629 tmp = ubifs_idx_node_sz(c, 1); 630 c->ranges[UBIFS_IDX_NODE].min_len = tmp; 631 c->min_idx_node_sz = ALIGN(tmp, 8); 632 633 tmp = ubifs_idx_node_sz(c, c->fanout); 634 c->ranges[UBIFS_IDX_NODE].max_len = tmp; 635 c->max_idx_node_sz = ALIGN(tmp, 8); 636 637 /* Make sure LEB size is large enough to fit full commit */ 638 tmp = UBIFS_CS_NODE_SZ + UBIFS_REF_NODE_SZ * c->jhead_cnt; 639 tmp = ALIGN(tmp, c->min_io_size); 640 if (tmp > c->leb_size) { 641 dbg_err("too small LEB size %d, at least %d needed", 642 c->leb_size, tmp); 643 return -EINVAL; 644 } 645 646 /* 647 * Make sure that the log is large enough to fit reference nodes for 648 * all buds plus one reserved LEB. 649 */ 650 tmp64 = c->max_bud_bytes + c->leb_size - 1; 651 c->max_bud_cnt = div_u64(tmp64, c->leb_size); 652 tmp = (c->ref_node_alsz * c->max_bud_cnt + c->leb_size - 1); 653 tmp /= c->leb_size; 654 tmp += 1; 655 if (c->log_lebs < tmp) { 656 dbg_err("too small log %d LEBs, required min. %d LEBs", 657 c->log_lebs, tmp); 658 return -EINVAL; 659 } 660 661 /* 662 * When budgeting we assume worst-case scenarios when the pages are not 663 * be compressed and direntries are of the maximum size. 664 * 665 * Note, data, which may be stored in inodes is budgeted separately, so 666 * it is not included into 'c->inode_budget'. 667 */ 668 c->page_budget = UBIFS_MAX_DATA_NODE_SZ * UBIFS_BLOCKS_PER_PAGE; 669 c->inode_budget = UBIFS_INO_NODE_SZ; 670 c->dent_budget = UBIFS_MAX_DENT_NODE_SZ; 671 672 /* 673 * When the amount of flash space used by buds becomes 674 * 'c->max_bud_bytes', UBIFS just blocks all writers and starts commit. 675 * The writers are unblocked when the commit is finished. To avoid 676 * writers to be blocked UBIFS initiates background commit in advance, 677 * when number of bud bytes becomes above the limit defined below. 678 */ 679 c->bg_bud_bytes = (c->max_bud_bytes * 13) >> 4; 680 681 /* 682 * Ensure minimum journal size. All the bytes in the journal heads are 683 * considered to be used, when calculating the current journal usage. 684 * Consequently, if the journal is too small, UBIFS will treat it as 685 * always full. 686 */ 687 tmp64 = (long long)(c->jhead_cnt + 1) * c->leb_size + 1; 688 if (c->bg_bud_bytes < tmp64) 689 c->bg_bud_bytes = tmp64; 690 if (c->max_bud_bytes < tmp64 + c->leb_size) 691 c->max_bud_bytes = tmp64 + c->leb_size; 692 693 err = ubifs_calc_lpt_geom(c); 694 if (err) 695 return err; 696 697 /* Initialize effective LEB size used in budgeting calculations */ 698 c->idx_leb_size = c->leb_size - c->max_idx_node_sz; 699 return 0; 700 } 701 702 /* 703 * init_constants_master - initialize UBIFS constants. 704 * @c: UBIFS file-system description object 705 * 706 * This is a helper function which initializes various UBIFS constants after 707 * the master node has been read. It also checks various UBIFS parameters and 708 * makes sure they are all right. 709 */ 710 static void init_constants_master(struct ubifs_info *c) 711 { 712 long long tmp64; 713 714 c->min_idx_lebs = ubifs_calc_min_idx_lebs(c); 715 c->report_rp_size = ubifs_reported_space(c, c->rp_size); 716 717 /* 718 * Calculate total amount of FS blocks. This number is not used 719 * internally because it does not make much sense for UBIFS, but it is 720 * necessary to report something for the 'statfs()' call. 721 * 722 * Subtract the LEB reserved for GC, the LEB which is reserved for 723 * deletions, minimum LEBs for the index, and assume only one journal 724 * head is available. 725 */ 726 tmp64 = c->main_lebs - 1 - 1 - MIN_INDEX_LEBS - c->jhead_cnt + 1; 727 tmp64 *= (long long)c->leb_size - c->leb_overhead; 728 tmp64 = ubifs_reported_space(c, tmp64); 729 c->block_cnt = tmp64 >> UBIFS_BLOCK_SHIFT; 730 } 731 732 /** 733 * take_gc_lnum - reserve GC LEB. 734 * @c: UBIFS file-system description object 735 * 736 * This function ensures that the LEB reserved for garbage collection is marked 737 * as "taken" in lprops. We also have to set free space to LEB size and dirty 738 * space to zero, because lprops may contain out-of-date information if the 739 * file-system was un-mounted before it has been committed. This function 740 * returns zero in case of success and a negative error code in case of 741 * failure. 742 */ 743 static int take_gc_lnum(struct ubifs_info *c) 744 { 745 int err; 746 747 if (c->gc_lnum == -1) { 748 ubifs_err("no LEB for GC"); 749 return -EINVAL; 750 } 751 752 /* And we have to tell lprops that this LEB is taken */ 753 err = ubifs_change_one_lp(c, c->gc_lnum, c->leb_size, 0, 754 LPROPS_TAKEN, 0, 0); 755 return err; 756 } 757 758 /** 759 * alloc_wbufs - allocate write-buffers. 760 * @c: UBIFS file-system description object 761 * 762 * This helper function allocates and initializes UBIFS write-buffers. Returns 763 * zero in case of success and %-ENOMEM in case of failure. 764 */ 765 static int alloc_wbufs(struct ubifs_info *c) 766 { 767 int i, err; 768 769 c->jheads = kzalloc(c->jhead_cnt * sizeof(struct ubifs_jhead), 770 GFP_KERNEL); 771 if (!c->jheads) 772 return -ENOMEM; 773 774 /* Initialize journal heads */ 775 for (i = 0; i < c->jhead_cnt; i++) { 776 INIT_LIST_HEAD(&c->jheads[i].buds_list); 777 err = ubifs_wbuf_init(c, &c->jheads[i].wbuf); 778 if (err) 779 return err; 780 781 c->jheads[i].wbuf.sync_callback = &bud_wbuf_callback; 782 c->jheads[i].wbuf.jhead = i; 783 } 784 785 c->jheads[BASEHD].wbuf.dtype = UBI_SHORTTERM; 786 /* 787 * Garbage Collector head likely contains long-term data and 788 * does not need to be synchronized by timer. 789 */ 790 c->jheads[GCHD].wbuf.dtype = UBI_LONGTERM; 791 c->jheads[GCHD].wbuf.no_timer = 1; 792 793 return 0; 794 } 795 796 /** 797 * free_wbufs - free write-buffers. 798 * @c: UBIFS file-system description object 799 */ 800 static void free_wbufs(struct ubifs_info *c) 801 { 802 int i; 803 804 if (c->jheads) { 805 for (i = 0; i < c->jhead_cnt; i++) { 806 kfree(c->jheads[i].wbuf.buf); 807 kfree(c->jheads[i].wbuf.inodes); 808 } 809 kfree(c->jheads); 810 c->jheads = NULL; 811 } 812 } 813 814 /** 815 * free_orphans - free orphans. 816 * @c: UBIFS file-system description object 817 */ 818 static void free_orphans(struct ubifs_info *c) 819 { 820 struct ubifs_orphan *orph; 821 822 while (c->orph_dnext) { 823 orph = c->orph_dnext; 824 c->orph_dnext = orph->dnext; 825 list_del(&orph->list); 826 kfree(orph); 827 } 828 829 while (!list_empty(&c->orph_list)) { 830 orph = list_entry(c->orph_list.next, struct ubifs_orphan, list); 831 list_del(&orph->list); 832 kfree(orph); 833 dbg_err("orphan list not empty at unmount"); 834 } 835 836 vfree(c->orph_buf); 837 c->orph_buf = NULL; 838 } 839 840 /** 841 * free_buds - free per-bud objects. 842 * @c: UBIFS file-system description object 843 */ 844 static void free_buds(struct ubifs_info *c) 845 { 846 struct rb_node *this = c->buds.rb_node; 847 struct ubifs_bud *bud; 848 849 while (this) { 850 if (this->rb_left) 851 this = this->rb_left; 852 else if (this->rb_right) 853 this = this->rb_right; 854 else { 855 bud = rb_entry(this, struct ubifs_bud, rb); 856 this = rb_parent(this); 857 if (this) { 858 if (this->rb_left == &bud->rb) 859 this->rb_left = NULL; 860 else 861 this->rb_right = NULL; 862 } 863 kfree(bud); 864 } 865 } 866 } 867 868 /** 869 * check_volume_empty - check if the UBI volume is empty. 870 * @c: UBIFS file-system description object 871 * 872 * This function checks if the UBIFS volume is empty by looking if its LEBs are 873 * mapped or not. The result of checking is stored in the @c->empty variable. 874 * Returns zero in case of success and a negative error code in case of 875 * failure. 876 */ 877 static int check_volume_empty(struct ubifs_info *c) 878 { 879 int lnum, err; 880 881 c->empty = 1; 882 for (lnum = 0; lnum < c->leb_cnt; lnum++) { 883 err = ubi_is_mapped(c->ubi, lnum); 884 if (unlikely(err < 0)) 885 return err; 886 if (err == 1) { 887 c->empty = 0; 888 break; 889 } 890 891 cond_resched(); 892 } 893 894 return 0; 895 } 896 897 /* 898 * UBIFS mount options. 899 * 900 * Opt_fast_unmount: do not run a journal commit before un-mounting 901 * Opt_norm_unmount: run a journal commit before un-mounting 902 * Opt_bulk_read: enable bulk-reads 903 * Opt_no_bulk_read: disable bulk-reads 904 * Opt_chk_data_crc: check CRCs when reading data nodes 905 * Opt_no_chk_data_crc: do not check CRCs when reading data nodes 906 * Opt_override_compr: override default compressor 907 * Opt_err: just end of array marker 908 */ 909 enum { 910 Opt_fast_unmount, 911 Opt_norm_unmount, 912 Opt_bulk_read, 913 Opt_no_bulk_read, 914 Opt_chk_data_crc, 915 Opt_no_chk_data_crc, 916 Opt_override_compr, 917 Opt_err, 918 }; 919 920 static const match_table_t tokens = { 921 {Opt_fast_unmount, "fast_unmount"}, 922 {Opt_norm_unmount, "norm_unmount"}, 923 {Opt_bulk_read, "bulk_read"}, 924 {Opt_no_bulk_read, "no_bulk_read"}, 925 {Opt_chk_data_crc, "chk_data_crc"}, 926 {Opt_no_chk_data_crc, "no_chk_data_crc"}, 927 {Opt_override_compr, "compr=%s"}, 928 {Opt_err, NULL}, 929 }; 930 931 /** 932 * parse_standard_option - parse a standard mount option. 933 * @option: the option to parse 934 * 935 * Normally, standard mount options like "sync" are passed to file-systems as 936 * flags. However, when a "rootflags=" kernel boot parameter is used, they may 937 * be present in the options string. This function tries to deal with this 938 * situation and parse standard options. Returns 0 if the option was not 939 * recognized, and the corresponding integer flag if it was. 940 * 941 * UBIFS is only interested in the "sync" option, so do not check for anything 942 * else. 943 */ 944 static int parse_standard_option(const char *option) 945 { 946 ubifs_msg("parse %s", option); 947 if (!strcmp(option, "sync")) 948 return MS_SYNCHRONOUS; 949 return 0; 950 } 951 952 /** 953 * ubifs_parse_options - parse mount parameters. 954 * @c: UBIFS file-system description object 955 * @options: parameters to parse 956 * @is_remount: non-zero if this is FS re-mount 957 * 958 * This function parses UBIFS mount options and returns zero in case success 959 * and a negative error code in case of failure. 960 */ 961 static int ubifs_parse_options(struct ubifs_info *c, char *options, 962 int is_remount) 963 { 964 char *p; 965 substring_t args[MAX_OPT_ARGS]; 966 967 if (!options) 968 return 0; 969 970 while ((p = strsep(&options, ","))) { 971 int token; 972 973 if (!*p) 974 continue; 975 976 token = match_token(p, tokens, args); 977 switch (token) { 978 /* 979 * %Opt_fast_unmount and %Opt_norm_unmount options are ignored. 980 * We accept them in order to be backward-compatible. But this 981 * should be removed at some point. 982 */ 983 case Opt_fast_unmount: 984 c->mount_opts.unmount_mode = 2; 985 break; 986 case Opt_norm_unmount: 987 c->mount_opts.unmount_mode = 1; 988 break; 989 case Opt_bulk_read: 990 c->mount_opts.bulk_read = 2; 991 c->bulk_read = 1; 992 break; 993 case Opt_no_bulk_read: 994 c->mount_opts.bulk_read = 1; 995 c->bulk_read = 0; 996 break; 997 case Opt_chk_data_crc: 998 c->mount_opts.chk_data_crc = 2; 999 c->no_chk_data_crc = 0; 1000 break; 1001 case Opt_no_chk_data_crc: 1002 c->mount_opts.chk_data_crc = 1; 1003 c->no_chk_data_crc = 1; 1004 break; 1005 case Opt_override_compr: 1006 { 1007 char *name = match_strdup(&args[0]); 1008 1009 if (!name) 1010 return -ENOMEM; 1011 if (!strcmp(name, "none")) 1012 c->mount_opts.compr_type = UBIFS_COMPR_NONE; 1013 else if (!strcmp(name, "lzo")) 1014 c->mount_opts.compr_type = UBIFS_COMPR_LZO; 1015 else if (!strcmp(name, "zlib")) 1016 c->mount_opts.compr_type = UBIFS_COMPR_ZLIB; 1017 else { 1018 ubifs_err("unknown compressor \"%s\"", name); 1019 kfree(name); 1020 return -EINVAL; 1021 } 1022 kfree(name); 1023 c->mount_opts.override_compr = 1; 1024 c->default_compr = c->mount_opts.compr_type; 1025 break; 1026 } 1027 default: 1028 { 1029 unsigned long flag; 1030 struct super_block *sb = c->vfs_sb; 1031 1032 flag = parse_standard_option(p); 1033 if (!flag) { 1034 ubifs_err("unrecognized mount option \"%s\" " 1035 "or missing value", p); 1036 return -EINVAL; 1037 } 1038 sb->s_flags |= flag; 1039 break; 1040 } 1041 } 1042 } 1043 1044 return 0; 1045 } 1046 1047 /** 1048 * destroy_journal - destroy journal data structures. 1049 * @c: UBIFS file-system description object 1050 * 1051 * This function destroys journal data structures including those that may have 1052 * been created by recovery functions. 1053 */ 1054 static void destroy_journal(struct ubifs_info *c) 1055 { 1056 while (!list_empty(&c->unclean_leb_list)) { 1057 struct ubifs_unclean_leb *ucleb; 1058 1059 ucleb = list_entry(c->unclean_leb_list.next, 1060 struct ubifs_unclean_leb, list); 1061 list_del(&ucleb->list); 1062 kfree(ucleb); 1063 } 1064 while (!list_empty(&c->old_buds)) { 1065 struct ubifs_bud *bud; 1066 1067 bud = list_entry(c->old_buds.next, struct ubifs_bud, list); 1068 list_del(&bud->list); 1069 kfree(bud); 1070 } 1071 ubifs_destroy_idx_gc(c); 1072 ubifs_destroy_size_tree(c); 1073 ubifs_tnc_close(c); 1074 free_buds(c); 1075 } 1076 1077 /** 1078 * bu_init - initialize bulk-read information. 1079 * @c: UBIFS file-system description object 1080 */ 1081 static void bu_init(struct ubifs_info *c) 1082 { 1083 ubifs_assert(c->bulk_read == 1); 1084 1085 if (c->bu.buf) 1086 return; /* Already initialized */ 1087 1088 again: 1089 c->bu.buf = kmalloc(c->max_bu_buf_len, GFP_KERNEL | __GFP_NOWARN); 1090 if (!c->bu.buf) { 1091 if (c->max_bu_buf_len > UBIFS_KMALLOC_OK) { 1092 c->max_bu_buf_len = UBIFS_KMALLOC_OK; 1093 goto again; 1094 } 1095 1096 /* Just disable bulk-read */ 1097 ubifs_warn("Cannot allocate %d bytes of memory for bulk-read, " 1098 "disabling it", c->max_bu_buf_len); 1099 c->mount_opts.bulk_read = 1; 1100 c->bulk_read = 0; 1101 return; 1102 } 1103 } 1104 1105 /** 1106 * check_free_space - check if there is enough free space to mount. 1107 * @c: UBIFS file-system description object 1108 * 1109 * This function makes sure UBIFS has enough free space to be mounted in 1110 * read/write mode. UBIFS must always have some free space to allow deletions. 1111 */ 1112 static int check_free_space(struct ubifs_info *c) 1113 { 1114 ubifs_assert(c->dark_wm > 0); 1115 if (c->lst.total_free + c->lst.total_dirty < c->dark_wm) { 1116 ubifs_err("insufficient free space to mount in read/write mode"); 1117 dbg_dump_budg(c); 1118 dbg_dump_lprops(c); 1119 return -ENOSPC; 1120 } 1121 return 0; 1122 } 1123 1124 /** 1125 * mount_ubifs - mount UBIFS file-system. 1126 * @c: UBIFS file-system description object 1127 * 1128 * This function mounts UBIFS file system. Returns zero in case of success and 1129 * a negative error code in case of failure. 1130 * 1131 * Note, the function does not de-allocate resources it it fails half way 1132 * through, and the caller has to do this instead. 1133 */ 1134 static int mount_ubifs(struct ubifs_info *c) 1135 { 1136 struct super_block *sb = c->vfs_sb; 1137 int err, mounted_read_only = (sb->s_flags & MS_RDONLY); 1138 long long x; 1139 size_t sz; 1140 1141 err = init_constants_early(c); 1142 if (err) 1143 return err; 1144 1145 err = ubifs_debugging_init(c); 1146 if (err) 1147 return err; 1148 1149 err = check_volume_empty(c); 1150 if (err) 1151 goto out_free; 1152 1153 if (c->empty && (mounted_read_only || c->ro_media)) { 1154 /* 1155 * This UBI volume is empty, and read-only, or the file system 1156 * is mounted read-only - we cannot format it. 1157 */ 1158 ubifs_err("can't format empty UBI volume: read-only %s", 1159 c->ro_media ? "UBI volume" : "mount"); 1160 err = -EROFS; 1161 goto out_free; 1162 } 1163 1164 if (c->ro_media && !mounted_read_only) { 1165 ubifs_err("cannot mount read-write - read-only media"); 1166 err = -EROFS; 1167 goto out_free; 1168 } 1169 1170 /* 1171 * The requirement for the buffer is that it should fit indexing B-tree 1172 * height amount of integers. We assume the height if the TNC tree will 1173 * never exceed 64. 1174 */ 1175 err = -ENOMEM; 1176 c->bottom_up_buf = kmalloc(BOTTOM_UP_HEIGHT * sizeof(int), GFP_KERNEL); 1177 if (!c->bottom_up_buf) 1178 goto out_free; 1179 1180 c->sbuf = vmalloc(c->leb_size); 1181 if (!c->sbuf) 1182 goto out_free; 1183 1184 if (!mounted_read_only) { 1185 c->ileb_buf = vmalloc(c->leb_size); 1186 if (!c->ileb_buf) 1187 goto out_free; 1188 } 1189 1190 if (c->bulk_read == 1) 1191 bu_init(c); 1192 1193 /* 1194 * We have to check all CRCs, even for data nodes, when we mount the FS 1195 * (specifically, when we are replaying). 1196 */ 1197 c->always_chk_crc = 1; 1198 1199 err = ubifs_read_superblock(c); 1200 if (err) 1201 goto out_free; 1202 1203 /* 1204 * Make sure the compressor which is set as default in the superblock 1205 * or overridden by mount options is actually compiled in. 1206 */ 1207 if (!ubifs_compr_present(c->default_compr)) { 1208 ubifs_err("'compressor \"%s\" is not compiled in", 1209 ubifs_compr_name(c->default_compr)); 1210 err = -ENOTSUPP; 1211 goto out_free; 1212 } 1213 1214 err = init_constants_sb(c); 1215 if (err) 1216 goto out_free; 1217 1218 sz = ALIGN(c->max_idx_node_sz, c->min_io_size); 1219 sz = ALIGN(sz + c->max_idx_node_sz, c->min_io_size); 1220 c->cbuf = kmalloc(sz, GFP_NOFS); 1221 if (!c->cbuf) { 1222 err = -ENOMEM; 1223 goto out_free; 1224 } 1225 1226 sprintf(c->bgt_name, BGT_NAME_PATTERN, c->vi.ubi_num, c->vi.vol_id); 1227 if (!mounted_read_only) { 1228 err = alloc_wbufs(c); 1229 if (err) 1230 goto out_cbuf; 1231 1232 /* Create background thread */ 1233 c->bgt = kthread_create(ubifs_bg_thread, c, "%s", c->bgt_name); 1234 if (IS_ERR(c->bgt)) { 1235 err = PTR_ERR(c->bgt); 1236 c->bgt = NULL; 1237 ubifs_err("cannot spawn \"%s\", error %d", 1238 c->bgt_name, err); 1239 goto out_wbufs; 1240 } 1241 wake_up_process(c->bgt); 1242 } 1243 1244 err = ubifs_read_master(c); 1245 if (err) 1246 goto out_master; 1247 1248 init_constants_master(c); 1249 1250 if ((c->mst_node->flags & cpu_to_le32(UBIFS_MST_DIRTY)) != 0) { 1251 ubifs_msg("recovery needed"); 1252 c->need_recovery = 1; 1253 if (!mounted_read_only) { 1254 err = ubifs_recover_inl_heads(c, c->sbuf); 1255 if (err) 1256 goto out_master; 1257 } 1258 } else if (!mounted_read_only) { 1259 /* 1260 * Set the "dirty" flag so that if we reboot uncleanly we 1261 * will notice this immediately on the next mount. 1262 */ 1263 c->mst_node->flags |= cpu_to_le32(UBIFS_MST_DIRTY); 1264 err = ubifs_write_master(c); 1265 if (err) 1266 goto out_master; 1267 } 1268 1269 err = ubifs_lpt_init(c, 1, !mounted_read_only); 1270 if (err) 1271 goto out_lpt; 1272 1273 err = dbg_check_idx_size(c, c->old_idx_sz); 1274 if (err) 1275 goto out_lpt; 1276 1277 err = ubifs_replay_journal(c); 1278 if (err) 1279 goto out_journal; 1280 1281 /* Calculate 'min_idx_lebs' after journal replay */ 1282 c->min_idx_lebs = ubifs_calc_min_idx_lebs(c); 1283 1284 err = ubifs_mount_orphans(c, c->need_recovery, mounted_read_only); 1285 if (err) 1286 goto out_orphans; 1287 1288 if (!mounted_read_only) { 1289 int lnum; 1290 1291 err = check_free_space(c); 1292 if (err) 1293 goto out_orphans; 1294 1295 /* Check for enough log space */ 1296 lnum = c->lhead_lnum + 1; 1297 if (lnum >= UBIFS_LOG_LNUM + c->log_lebs) 1298 lnum = UBIFS_LOG_LNUM; 1299 if (lnum == c->ltail_lnum) { 1300 err = ubifs_consolidate_log(c); 1301 if (err) 1302 goto out_orphans; 1303 } 1304 1305 if (c->need_recovery) { 1306 err = ubifs_recover_size(c); 1307 if (err) 1308 goto out_orphans; 1309 err = ubifs_rcvry_gc_commit(c); 1310 } else { 1311 err = take_gc_lnum(c); 1312 if (err) 1313 goto out_orphans; 1314 1315 /* 1316 * GC LEB may contain garbage if there was an unclean 1317 * reboot, and it should be un-mapped. 1318 */ 1319 err = ubifs_leb_unmap(c, c->gc_lnum); 1320 if (err) 1321 return err; 1322 } 1323 1324 err = dbg_check_lprops(c); 1325 if (err) 1326 goto out_orphans; 1327 } else if (c->need_recovery) { 1328 err = ubifs_recover_size(c); 1329 if (err) 1330 goto out_orphans; 1331 } else { 1332 /* 1333 * Even if we mount read-only, we have to set space in GC LEB 1334 * to proper value because this affects UBIFS free space 1335 * reporting. We do not want to have a situation when 1336 * re-mounting from R/O to R/W changes amount of free space. 1337 */ 1338 err = take_gc_lnum(c); 1339 if (err) 1340 goto out_orphans; 1341 } 1342 1343 spin_lock(&ubifs_infos_lock); 1344 list_add_tail(&c->infos_list, &ubifs_infos); 1345 spin_unlock(&ubifs_infos_lock); 1346 1347 if (c->need_recovery) { 1348 if (mounted_read_only) 1349 ubifs_msg("recovery deferred"); 1350 else { 1351 c->need_recovery = 0; 1352 ubifs_msg("recovery completed"); 1353 /* 1354 * GC LEB has to be empty and taken at this point. But 1355 * the journal head LEBs may also be accounted as 1356 * "empty taken" if they are empty. 1357 */ 1358 ubifs_assert(c->lst.taken_empty_lebs > 0); 1359 } 1360 } else 1361 ubifs_assert(c->lst.taken_empty_lebs > 0); 1362 1363 err = dbg_check_filesystem(c); 1364 if (err) 1365 goto out_infos; 1366 1367 err = dbg_debugfs_init_fs(c); 1368 if (err) 1369 goto out_infos; 1370 1371 c->always_chk_crc = 0; 1372 1373 ubifs_msg("mounted UBI device %d, volume %d, name \"%s\"", 1374 c->vi.ubi_num, c->vi.vol_id, c->vi.name); 1375 if (mounted_read_only) 1376 ubifs_msg("mounted read-only"); 1377 x = (long long)c->main_lebs * c->leb_size; 1378 ubifs_msg("file system size: %lld bytes (%lld KiB, %lld MiB, %d " 1379 "LEBs)", x, x >> 10, x >> 20, c->main_lebs); 1380 x = (long long)c->log_lebs * c->leb_size + c->max_bud_bytes; 1381 ubifs_msg("journal size: %lld bytes (%lld KiB, %lld MiB, %d " 1382 "LEBs)", x, x >> 10, x >> 20, c->log_lebs + c->max_bud_cnt); 1383 ubifs_msg("media format: w%d/r%d (latest is w%d/r%d)", 1384 c->fmt_version, c->ro_compat_version, 1385 UBIFS_FORMAT_VERSION, UBIFS_RO_COMPAT_VERSION); 1386 ubifs_msg("default compressor: %s", ubifs_compr_name(c->default_compr)); 1387 ubifs_msg("reserved for root: %llu bytes (%llu KiB)", 1388 c->report_rp_size, c->report_rp_size >> 10); 1389 1390 dbg_msg("compiled on: " __DATE__ " at " __TIME__); 1391 dbg_msg("min. I/O unit size: %d bytes", c->min_io_size); 1392 dbg_msg("LEB size: %d bytes (%d KiB)", 1393 c->leb_size, c->leb_size >> 10); 1394 dbg_msg("data journal heads: %d", 1395 c->jhead_cnt - NONDATA_JHEADS_CNT); 1396 dbg_msg("UUID: %pUB", c->uuid); 1397 dbg_msg("big_lpt %d", c->big_lpt); 1398 dbg_msg("log LEBs: %d (%d - %d)", 1399 c->log_lebs, UBIFS_LOG_LNUM, c->log_last); 1400 dbg_msg("LPT area LEBs: %d (%d - %d)", 1401 c->lpt_lebs, c->lpt_first, c->lpt_last); 1402 dbg_msg("orphan area LEBs: %d (%d - %d)", 1403 c->orph_lebs, c->orph_first, c->orph_last); 1404 dbg_msg("main area LEBs: %d (%d - %d)", 1405 c->main_lebs, c->main_first, c->leb_cnt - 1); 1406 dbg_msg("index LEBs: %d", c->lst.idx_lebs); 1407 dbg_msg("total index bytes: %lld (%lld KiB, %lld MiB)", 1408 c->old_idx_sz, c->old_idx_sz >> 10, c->old_idx_sz >> 20); 1409 dbg_msg("key hash type: %d", c->key_hash_type); 1410 dbg_msg("tree fanout: %d", c->fanout); 1411 dbg_msg("reserved GC LEB: %d", c->gc_lnum); 1412 dbg_msg("first main LEB: %d", c->main_first); 1413 dbg_msg("max. znode size %d", c->max_znode_sz); 1414 dbg_msg("max. index node size %d", c->max_idx_node_sz); 1415 dbg_msg("node sizes: data %zu, inode %zu, dentry %zu", 1416 UBIFS_DATA_NODE_SZ, UBIFS_INO_NODE_SZ, UBIFS_DENT_NODE_SZ); 1417 dbg_msg("node sizes: trun %zu, sb %zu, master %zu", 1418 UBIFS_TRUN_NODE_SZ, UBIFS_SB_NODE_SZ, UBIFS_MST_NODE_SZ); 1419 dbg_msg("node sizes: ref %zu, cmt. start %zu, orph %zu", 1420 UBIFS_REF_NODE_SZ, UBIFS_CS_NODE_SZ, UBIFS_ORPH_NODE_SZ); 1421 dbg_msg("max. node sizes: data %zu, inode %zu dentry %zu", 1422 UBIFS_MAX_DATA_NODE_SZ, UBIFS_MAX_INO_NODE_SZ, 1423 UBIFS_MAX_DENT_NODE_SZ); 1424 dbg_msg("dead watermark: %d", c->dead_wm); 1425 dbg_msg("dark watermark: %d", c->dark_wm); 1426 dbg_msg("LEB overhead: %d", c->leb_overhead); 1427 x = (long long)c->main_lebs * c->dark_wm; 1428 dbg_msg("max. dark space: %lld (%lld KiB, %lld MiB)", 1429 x, x >> 10, x >> 20); 1430 dbg_msg("maximum bud bytes: %lld (%lld KiB, %lld MiB)", 1431 c->max_bud_bytes, c->max_bud_bytes >> 10, 1432 c->max_bud_bytes >> 20); 1433 dbg_msg("BG commit bud bytes: %lld (%lld KiB, %lld MiB)", 1434 c->bg_bud_bytes, c->bg_bud_bytes >> 10, 1435 c->bg_bud_bytes >> 20); 1436 dbg_msg("current bud bytes %lld (%lld KiB, %lld MiB)", 1437 c->bud_bytes, c->bud_bytes >> 10, c->bud_bytes >> 20); 1438 dbg_msg("max. seq. number: %llu", c->max_sqnum); 1439 dbg_msg("commit number: %llu", c->cmt_no); 1440 1441 return 0; 1442 1443 out_infos: 1444 spin_lock(&ubifs_infos_lock); 1445 list_del(&c->infos_list); 1446 spin_unlock(&ubifs_infos_lock); 1447 out_orphans: 1448 free_orphans(c); 1449 out_journal: 1450 destroy_journal(c); 1451 out_lpt: 1452 ubifs_lpt_free(c, 0); 1453 out_master: 1454 kfree(c->mst_node); 1455 kfree(c->rcvrd_mst_node); 1456 if (c->bgt) 1457 kthread_stop(c->bgt); 1458 out_wbufs: 1459 free_wbufs(c); 1460 out_cbuf: 1461 kfree(c->cbuf); 1462 out_free: 1463 kfree(c->bu.buf); 1464 vfree(c->ileb_buf); 1465 vfree(c->sbuf); 1466 kfree(c->bottom_up_buf); 1467 ubifs_debugging_exit(c); 1468 return err; 1469 } 1470 1471 /** 1472 * ubifs_umount - un-mount UBIFS file-system. 1473 * @c: UBIFS file-system description object 1474 * 1475 * Note, this function is called to free allocated resourced when un-mounting, 1476 * as well as free resources when an error occurred while we were half way 1477 * through mounting (error path cleanup function). So it has to make sure the 1478 * resource was actually allocated before freeing it. 1479 */ 1480 static void ubifs_umount(struct ubifs_info *c) 1481 { 1482 dbg_gen("un-mounting UBI device %d, volume %d", c->vi.ubi_num, 1483 c->vi.vol_id); 1484 1485 dbg_debugfs_exit_fs(c); 1486 spin_lock(&ubifs_infos_lock); 1487 list_del(&c->infos_list); 1488 spin_unlock(&ubifs_infos_lock); 1489 1490 if (c->bgt) 1491 kthread_stop(c->bgt); 1492 1493 destroy_journal(c); 1494 free_wbufs(c); 1495 free_orphans(c); 1496 ubifs_lpt_free(c, 0); 1497 1498 kfree(c->cbuf); 1499 kfree(c->rcvrd_mst_node); 1500 kfree(c->mst_node); 1501 kfree(c->bu.buf); 1502 vfree(c->ileb_buf); 1503 vfree(c->sbuf); 1504 kfree(c->bottom_up_buf); 1505 ubifs_debugging_exit(c); 1506 } 1507 1508 /** 1509 * ubifs_remount_rw - re-mount in read-write mode. 1510 * @c: UBIFS file-system description object 1511 * 1512 * UBIFS avoids allocating many unnecessary resources when mounted in read-only 1513 * mode. This function allocates the needed resources and re-mounts UBIFS in 1514 * read-write mode. 1515 */ 1516 static int ubifs_remount_rw(struct ubifs_info *c) 1517 { 1518 int err, lnum; 1519 1520 if (c->rw_incompat) { 1521 ubifs_err("the file-system is not R/W-compatible"); 1522 ubifs_msg("on-flash format version is w%d/r%d, but software " 1523 "only supports up to version w%d/r%d", c->fmt_version, 1524 c->ro_compat_version, UBIFS_FORMAT_VERSION, 1525 UBIFS_RO_COMPAT_VERSION); 1526 return -EROFS; 1527 } 1528 1529 mutex_lock(&c->umount_mutex); 1530 dbg_save_space_info(c); 1531 c->remounting_rw = 1; 1532 c->always_chk_crc = 1; 1533 1534 err = check_free_space(c); 1535 if (err) 1536 goto out; 1537 1538 if (c->old_leb_cnt != c->leb_cnt) { 1539 struct ubifs_sb_node *sup; 1540 1541 sup = ubifs_read_sb_node(c); 1542 if (IS_ERR(sup)) { 1543 err = PTR_ERR(sup); 1544 goto out; 1545 } 1546 sup->leb_cnt = cpu_to_le32(c->leb_cnt); 1547 err = ubifs_write_sb_node(c, sup); 1548 if (err) 1549 goto out; 1550 } 1551 1552 if (c->need_recovery) { 1553 ubifs_msg("completing deferred recovery"); 1554 err = ubifs_write_rcvrd_mst_node(c); 1555 if (err) 1556 goto out; 1557 err = ubifs_recover_size(c); 1558 if (err) 1559 goto out; 1560 err = ubifs_clean_lebs(c, c->sbuf); 1561 if (err) 1562 goto out; 1563 err = ubifs_recover_inl_heads(c, c->sbuf); 1564 if (err) 1565 goto out; 1566 } else { 1567 /* A readonly mount is not allowed to have orphans */ 1568 ubifs_assert(c->tot_orphans == 0); 1569 err = ubifs_clear_orphans(c); 1570 if (err) 1571 goto out; 1572 } 1573 1574 if (!(c->mst_node->flags & cpu_to_le32(UBIFS_MST_DIRTY))) { 1575 c->mst_node->flags |= cpu_to_le32(UBIFS_MST_DIRTY); 1576 err = ubifs_write_master(c); 1577 if (err) 1578 goto out; 1579 } 1580 1581 c->ileb_buf = vmalloc(c->leb_size); 1582 if (!c->ileb_buf) { 1583 err = -ENOMEM; 1584 goto out; 1585 } 1586 1587 err = ubifs_lpt_init(c, 0, 1); 1588 if (err) 1589 goto out; 1590 1591 err = alloc_wbufs(c); 1592 if (err) 1593 goto out; 1594 1595 ubifs_create_buds_lists(c); 1596 1597 /* Create background thread */ 1598 c->bgt = kthread_create(ubifs_bg_thread, c, "%s", c->bgt_name); 1599 if (IS_ERR(c->bgt)) { 1600 err = PTR_ERR(c->bgt); 1601 c->bgt = NULL; 1602 ubifs_err("cannot spawn \"%s\", error %d", 1603 c->bgt_name, err); 1604 goto out; 1605 } 1606 wake_up_process(c->bgt); 1607 1608 c->orph_buf = vmalloc(c->leb_size); 1609 if (!c->orph_buf) { 1610 err = -ENOMEM; 1611 goto out; 1612 } 1613 1614 /* Check for enough log space */ 1615 lnum = c->lhead_lnum + 1; 1616 if (lnum >= UBIFS_LOG_LNUM + c->log_lebs) 1617 lnum = UBIFS_LOG_LNUM; 1618 if (lnum == c->ltail_lnum) { 1619 err = ubifs_consolidate_log(c); 1620 if (err) 1621 goto out; 1622 } 1623 1624 if (c->need_recovery) 1625 err = ubifs_rcvry_gc_commit(c); 1626 else 1627 err = ubifs_leb_unmap(c, c->gc_lnum); 1628 if (err) 1629 goto out; 1630 1631 if (c->need_recovery) { 1632 c->need_recovery = 0; 1633 ubifs_msg("deferred recovery completed"); 1634 } 1635 1636 dbg_gen("re-mounted read-write"); 1637 c->vfs_sb->s_flags &= ~MS_RDONLY; 1638 c->remounting_rw = 0; 1639 c->always_chk_crc = 0; 1640 err = dbg_check_space_info(c); 1641 mutex_unlock(&c->umount_mutex); 1642 return err; 1643 1644 out: 1645 vfree(c->orph_buf); 1646 c->orph_buf = NULL; 1647 if (c->bgt) { 1648 kthread_stop(c->bgt); 1649 c->bgt = NULL; 1650 } 1651 free_wbufs(c); 1652 vfree(c->ileb_buf); 1653 c->ileb_buf = NULL; 1654 ubifs_lpt_free(c, 1); 1655 c->remounting_rw = 0; 1656 c->always_chk_crc = 0; 1657 mutex_unlock(&c->umount_mutex); 1658 return err; 1659 } 1660 1661 /** 1662 * ubifs_remount_ro - re-mount in read-only mode. 1663 * @c: UBIFS file-system description object 1664 * 1665 * We assume VFS has stopped writing. Possibly the background thread could be 1666 * running a commit, however kthread_stop will wait in that case. 1667 */ 1668 static void ubifs_remount_ro(struct ubifs_info *c) 1669 { 1670 int i, err; 1671 1672 ubifs_assert(!c->need_recovery); 1673 ubifs_assert(!(c->vfs_sb->s_flags & MS_RDONLY)); 1674 1675 mutex_lock(&c->umount_mutex); 1676 if (c->bgt) { 1677 kthread_stop(c->bgt); 1678 c->bgt = NULL; 1679 } 1680 1681 dbg_save_space_info(c); 1682 1683 for (i = 0; i < c->jhead_cnt; i++) { 1684 ubifs_wbuf_sync(&c->jheads[i].wbuf); 1685 hrtimer_cancel(&c->jheads[i].wbuf.timer); 1686 } 1687 1688 c->mst_node->flags &= ~cpu_to_le32(UBIFS_MST_DIRTY); 1689 c->mst_node->flags |= cpu_to_le32(UBIFS_MST_NO_ORPHS); 1690 c->mst_node->gc_lnum = cpu_to_le32(c->gc_lnum); 1691 err = ubifs_write_master(c); 1692 if (err) 1693 ubifs_ro_mode(c, err); 1694 1695 free_wbufs(c); 1696 vfree(c->orph_buf); 1697 c->orph_buf = NULL; 1698 vfree(c->ileb_buf); 1699 c->ileb_buf = NULL; 1700 ubifs_lpt_free(c, 1); 1701 err = dbg_check_space_info(c); 1702 if (err) 1703 ubifs_ro_mode(c, err); 1704 mutex_unlock(&c->umount_mutex); 1705 } 1706 1707 static void ubifs_put_super(struct super_block *sb) 1708 { 1709 int i; 1710 struct ubifs_info *c = sb->s_fs_info; 1711 1712 ubifs_msg("un-mount UBI device %d, volume %d", c->vi.ubi_num, 1713 c->vi.vol_id); 1714 1715 /* 1716 * The following asserts are only valid if there has not been a failure 1717 * of the media. For example, there will be dirty inodes if we failed 1718 * to write them back because of I/O errors. 1719 */ 1720 ubifs_assert(atomic_long_read(&c->dirty_pg_cnt) == 0); 1721 ubifs_assert(c->budg_idx_growth == 0); 1722 ubifs_assert(c->budg_dd_growth == 0); 1723 ubifs_assert(c->budg_data_growth == 0); 1724 1725 /* 1726 * The 'c->umount_lock' prevents races between UBIFS memory shrinker 1727 * and file system un-mount. Namely, it prevents the shrinker from 1728 * picking this superblock for shrinking - it will be just skipped if 1729 * the mutex is locked. 1730 */ 1731 mutex_lock(&c->umount_mutex); 1732 if (!(c->vfs_sb->s_flags & MS_RDONLY)) { 1733 /* 1734 * First of all kill the background thread to make sure it does 1735 * not interfere with un-mounting and freeing resources. 1736 */ 1737 if (c->bgt) { 1738 kthread_stop(c->bgt); 1739 c->bgt = NULL; 1740 } 1741 1742 /* Synchronize write-buffers */ 1743 if (c->jheads) 1744 for (i = 0; i < c->jhead_cnt; i++) 1745 ubifs_wbuf_sync(&c->jheads[i].wbuf); 1746 1747 /* 1748 * On fatal errors c->ro_media is set to 1, in which case we do 1749 * not write the master node. 1750 */ 1751 if (!c->ro_media) { 1752 /* 1753 * We are being cleanly unmounted which means the 1754 * orphans were killed - indicate this in the master 1755 * node. Also save the reserved GC LEB number. 1756 */ 1757 int err; 1758 1759 c->mst_node->flags &= ~cpu_to_le32(UBIFS_MST_DIRTY); 1760 c->mst_node->flags |= cpu_to_le32(UBIFS_MST_NO_ORPHS); 1761 c->mst_node->gc_lnum = cpu_to_le32(c->gc_lnum); 1762 err = ubifs_write_master(c); 1763 if (err) 1764 /* 1765 * Recovery will attempt to fix the master area 1766 * next mount, so we just print a message and 1767 * continue to unmount normally. 1768 */ 1769 ubifs_err("failed to write master node, " 1770 "error %d", err); 1771 } 1772 } 1773 1774 ubifs_umount(c); 1775 bdi_destroy(&c->bdi); 1776 ubi_close_volume(c->ubi); 1777 mutex_unlock(&c->umount_mutex); 1778 kfree(c); 1779 } 1780 1781 static int ubifs_remount_fs(struct super_block *sb, int *flags, char *data) 1782 { 1783 int err; 1784 struct ubifs_info *c = sb->s_fs_info; 1785 1786 dbg_gen("old flags %#lx, new flags %#x", sb->s_flags, *flags); 1787 1788 err = ubifs_parse_options(c, data, 1); 1789 if (err) { 1790 ubifs_err("invalid or unknown remount parameter"); 1791 return err; 1792 } 1793 1794 if ((sb->s_flags & MS_RDONLY) && !(*flags & MS_RDONLY)) { 1795 if (c->ro_media) { 1796 ubifs_msg("cannot re-mount due to prior errors"); 1797 return -EROFS; 1798 } 1799 err = ubifs_remount_rw(c); 1800 if (err) 1801 return err; 1802 } else if (!(sb->s_flags & MS_RDONLY) && (*flags & MS_RDONLY)) { 1803 if (c->ro_media) { 1804 ubifs_msg("cannot re-mount due to prior errors"); 1805 return -EROFS; 1806 } 1807 ubifs_remount_ro(c); 1808 } 1809 1810 if (c->bulk_read == 1) 1811 bu_init(c); 1812 else { 1813 dbg_gen("disable bulk-read"); 1814 kfree(c->bu.buf); 1815 c->bu.buf = NULL; 1816 } 1817 1818 ubifs_assert(c->lst.taken_empty_lebs > 0); 1819 return 0; 1820 } 1821 1822 const struct super_operations ubifs_super_operations = { 1823 .alloc_inode = ubifs_alloc_inode, 1824 .destroy_inode = ubifs_destroy_inode, 1825 .put_super = ubifs_put_super, 1826 .write_inode = ubifs_write_inode, 1827 .delete_inode = ubifs_delete_inode, 1828 .statfs = ubifs_statfs, 1829 .dirty_inode = ubifs_dirty_inode, 1830 .remount_fs = ubifs_remount_fs, 1831 .show_options = ubifs_show_options, 1832 .sync_fs = ubifs_sync_fs, 1833 }; 1834 1835 /** 1836 * open_ubi - parse UBI device name string and open the UBI device. 1837 * @name: UBI volume name 1838 * @mode: UBI volume open mode 1839 * 1840 * The primary method of mounting UBIFS is by specifying the UBI volume 1841 * character device node path. However, UBIFS may also be mounted withoug any 1842 * character device node using one of the following methods: 1843 * 1844 * o ubiX_Y - mount UBI device number X, volume Y; 1845 * o ubiY - mount UBI device number 0, volume Y; 1846 * o ubiX:NAME - mount UBI device X, volume with name NAME; 1847 * o ubi:NAME - mount UBI device 0, volume with name NAME. 1848 * 1849 * Alternative '!' separator may be used instead of ':' (because some shells 1850 * like busybox may interpret ':' as an NFS host name separator). This function 1851 * returns UBI volume description object in case of success and a negative 1852 * error code in case of failure. 1853 */ 1854 static struct ubi_volume_desc *open_ubi(const char *name, int mode) 1855 { 1856 struct ubi_volume_desc *ubi; 1857 int dev, vol; 1858 char *endptr; 1859 1860 /* First, try to open using the device node path method */ 1861 ubi = ubi_open_volume_path(name, mode); 1862 if (!IS_ERR(ubi)) 1863 return ubi; 1864 1865 /* Try the "nodev" method */ 1866 if (name[0] != 'u' || name[1] != 'b' || name[2] != 'i') 1867 return ERR_PTR(-EINVAL); 1868 1869 /* ubi:NAME method */ 1870 if ((name[3] == ':' || name[3] == '!') && name[4] != '\0') 1871 return ubi_open_volume_nm(0, name + 4, mode); 1872 1873 if (!isdigit(name[3])) 1874 return ERR_PTR(-EINVAL); 1875 1876 dev = simple_strtoul(name + 3, &endptr, 0); 1877 1878 /* ubiY method */ 1879 if (*endptr == '\0') 1880 return ubi_open_volume(0, dev, mode); 1881 1882 /* ubiX_Y method */ 1883 if (*endptr == '_' && isdigit(endptr[1])) { 1884 vol = simple_strtoul(endptr + 1, &endptr, 0); 1885 if (*endptr != '\0') 1886 return ERR_PTR(-EINVAL); 1887 return ubi_open_volume(dev, vol, mode); 1888 } 1889 1890 /* ubiX:NAME method */ 1891 if ((*endptr == ':' || *endptr == '!') && endptr[1] != '\0') 1892 return ubi_open_volume_nm(dev, ++endptr, mode); 1893 1894 return ERR_PTR(-EINVAL); 1895 } 1896 1897 static int ubifs_fill_super(struct super_block *sb, void *data, int silent) 1898 { 1899 struct ubi_volume_desc *ubi = sb->s_fs_info; 1900 struct ubifs_info *c; 1901 struct inode *root; 1902 int err; 1903 1904 c = kzalloc(sizeof(struct ubifs_info), GFP_KERNEL); 1905 if (!c) 1906 return -ENOMEM; 1907 1908 spin_lock_init(&c->cnt_lock); 1909 spin_lock_init(&c->cs_lock); 1910 spin_lock_init(&c->buds_lock); 1911 spin_lock_init(&c->space_lock); 1912 spin_lock_init(&c->orphan_lock); 1913 init_rwsem(&c->commit_sem); 1914 mutex_init(&c->lp_mutex); 1915 mutex_init(&c->tnc_mutex); 1916 mutex_init(&c->log_mutex); 1917 mutex_init(&c->mst_mutex); 1918 mutex_init(&c->umount_mutex); 1919 mutex_init(&c->bu_mutex); 1920 init_waitqueue_head(&c->cmt_wq); 1921 c->buds = RB_ROOT; 1922 c->old_idx = RB_ROOT; 1923 c->size_tree = RB_ROOT; 1924 c->orph_tree = RB_ROOT; 1925 INIT_LIST_HEAD(&c->infos_list); 1926 INIT_LIST_HEAD(&c->idx_gc); 1927 INIT_LIST_HEAD(&c->replay_list); 1928 INIT_LIST_HEAD(&c->replay_buds); 1929 INIT_LIST_HEAD(&c->uncat_list); 1930 INIT_LIST_HEAD(&c->empty_list); 1931 INIT_LIST_HEAD(&c->freeable_list); 1932 INIT_LIST_HEAD(&c->frdi_idx_list); 1933 INIT_LIST_HEAD(&c->unclean_leb_list); 1934 INIT_LIST_HEAD(&c->old_buds); 1935 INIT_LIST_HEAD(&c->orph_list); 1936 INIT_LIST_HEAD(&c->orph_new); 1937 1938 c->vfs_sb = sb; 1939 c->highest_inum = UBIFS_FIRST_INO; 1940 c->lhead_lnum = c->ltail_lnum = UBIFS_LOG_LNUM; 1941 1942 ubi_get_volume_info(ubi, &c->vi); 1943 ubi_get_device_info(c->vi.ubi_num, &c->di); 1944 1945 /* Re-open the UBI device in read-write mode */ 1946 c->ubi = ubi_open_volume(c->vi.ubi_num, c->vi.vol_id, UBI_READWRITE); 1947 if (IS_ERR(c->ubi)) { 1948 err = PTR_ERR(c->ubi); 1949 goto out_free; 1950 } 1951 1952 /* 1953 * UBIFS provides 'backing_dev_info' in order to disable read-ahead. For 1954 * UBIFS, I/O is not deferred, it is done immediately in readpage, 1955 * which means the user would have to wait not just for their own I/O 1956 * but the read-ahead I/O as well i.e. completely pointless. 1957 * 1958 * Read-ahead will be disabled because @c->bdi.ra_pages is 0. 1959 */ 1960 c->bdi.name = "ubifs", 1961 c->bdi.capabilities = BDI_CAP_MAP_COPY; 1962 c->bdi.unplug_io_fn = default_unplug_io_fn; 1963 err = bdi_init(&c->bdi); 1964 if (err) 1965 goto out_close; 1966 err = bdi_register(&c->bdi, NULL, "ubifs_%d_%d", 1967 c->vi.ubi_num, c->vi.vol_id); 1968 if (err) 1969 goto out_bdi; 1970 1971 err = ubifs_parse_options(c, data, 0); 1972 if (err) 1973 goto out_bdi; 1974 1975 sb->s_bdi = &c->bdi; 1976 sb->s_fs_info = c; 1977 sb->s_magic = UBIFS_SUPER_MAGIC; 1978 sb->s_blocksize = UBIFS_BLOCK_SIZE; 1979 sb->s_blocksize_bits = UBIFS_BLOCK_SHIFT; 1980 sb->s_maxbytes = c->max_inode_sz = key_max_inode_size(c); 1981 if (c->max_inode_sz > MAX_LFS_FILESIZE) 1982 sb->s_maxbytes = c->max_inode_sz = MAX_LFS_FILESIZE; 1983 sb->s_op = &ubifs_super_operations; 1984 1985 mutex_lock(&c->umount_mutex); 1986 err = mount_ubifs(c); 1987 if (err) { 1988 ubifs_assert(err < 0); 1989 goto out_unlock; 1990 } 1991 1992 /* Read the root inode */ 1993 root = ubifs_iget(sb, UBIFS_ROOT_INO); 1994 if (IS_ERR(root)) { 1995 err = PTR_ERR(root); 1996 goto out_umount; 1997 } 1998 1999 sb->s_root = d_alloc_root(root); 2000 if (!sb->s_root) 2001 goto out_iput; 2002 2003 mutex_unlock(&c->umount_mutex); 2004 return 0; 2005 2006 out_iput: 2007 iput(root); 2008 out_umount: 2009 ubifs_umount(c); 2010 out_unlock: 2011 mutex_unlock(&c->umount_mutex); 2012 out_bdi: 2013 bdi_destroy(&c->bdi); 2014 out_close: 2015 ubi_close_volume(c->ubi); 2016 out_free: 2017 kfree(c); 2018 return err; 2019 } 2020 2021 static int sb_test(struct super_block *sb, void *data) 2022 { 2023 dev_t *dev = data; 2024 struct ubifs_info *c = sb->s_fs_info; 2025 2026 return c->vi.cdev == *dev; 2027 } 2028 2029 static int ubifs_get_sb(struct file_system_type *fs_type, int flags, 2030 const char *name, void *data, struct vfsmount *mnt) 2031 { 2032 struct ubi_volume_desc *ubi; 2033 struct ubi_volume_info vi; 2034 struct super_block *sb; 2035 int err; 2036 2037 dbg_gen("name %s, flags %#x", name, flags); 2038 2039 /* 2040 * Get UBI device number and volume ID. Mount it read-only so far 2041 * because this might be a new mount point, and UBI allows only one 2042 * read-write user at a time. 2043 */ 2044 ubi = open_ubi(name, UBI_READONLY); 2045 if (IS_ERR(ubi)) { 2046 ubifs_err("cannot open \"%s\", error %d", 2047 name, (int)PTR_ERR(ubi)); 2048 return PTR_ERR(ubi); 2049 } 2050 ubi_get_volume_info(ubi, &vi); 2051 2052 dbg_gen("opened ubi%d_%d", vi.ubi_num, vi.vol_id); 2053 2054 sb = sget(fs_type, &sb_test, &set_anon_super, &vi.cdev); 2055 if (IS_ERR(sb)) { 2056 err = PTR_ERR(sb); 2057 goto out_close; 2058 } 2059 2060 if (sb->s_root) { 2061 /* A new mount point for already mounted UBIFS */ 2062 dbg_gen("this ubi volume is already mounted"); 2063 if ((flags ^ sb->s_flags) & MS_RDONLY) { 2064 err = -EBUSY; 2065 goto out_deact; 2066 } 2067 } else { 2068 sb->s_flags = flags; 2069 /* 2070 * Pass 'ubi' to 'fill_super()' in sb->s_fs_info where it is 2071 * replaced by 'c'. 2072 */ 2073 sb->s_fs_info = ubi; 2074 err = ubifs_fill_super(sb, data, flags & MS_SILENT ? 1 : 0); 2075 if (err) 2076 goto out_deact; 2077 /* We do not support atime */ 2078 sb->s_flags |= MS_ACTIVE | MS_NOATIME; 2079 } 2080 2081 /* 'fill_super()' opens ubi again so we must close it here */ 2082 ubi_close_volume(ubi); 2083 2084 simple_set_mnt(mnt, sb); 2085 return 0; 2086 2087 out_deact: 2088 deactivate_locked_super(sb); 2089 out_close: 2090 ubi_close_volume(ubi); 2091 return err; 2092 } 2093 2094 static struct file_system_type ubifs_fs_type = { 2095 .name = "ubifs", 2096 .owner = THIS_MODULE, 2097 .get_sb = ubifs_get_sb, 2098 .kill_sb = kill_anon_super, 2099 }; 2100 2101 /* 2102 * Inode slab cache constructor. 2103 */ 2104 static void inode_slab_ctor(void *obj) 2105 { 2106 struct ubifs_inode *ui = obj; 2107 inode_init_once(&ui->vfs_inode); 2108 } 2109 2110 static int __init ubifs_init(void) 2111 { 2112 int err; 2113 2114 BUILD_BUG_ON(sizeof(struct ubifs_ch) != 24); 2115 2116 /* Make sure node sizes are 8-byte aligned */ 2117 BUILD_BUG_ON(UBIFS_CH_SZ & 7); 2118 BUILD_BUG_ON(UBIFS_INO_NODE_SZ & 7); 2119 BUILD_BUG_ON(UBIFS_DENT_NODE_SZ & 7); 2120 BUILD_BUG_ON(UBIFS_XENT_NODE_SZ & 7); 2121 BUILD_BUG_ON(UBIFS_DATA_NODE_SZ & 7); 2122 BUILD_BUG_ON(UBIFS_TRUN_NODE_SZ & 7); 2123 BUILD_BUG_ON(UBIFS_SB_NODE_SZ & 7); 2124 BUILD_BUG_ON(UBIFS_MST_NODE_SZ & 7); 2125 BUILD_BUG_ON(UBIFS_REF_NODE_SZ & 7); 2126 BUILD_BUG_ON(UBIFS_CS_NODE_SZ & 7); 2127 BUILD_BUG_ON(UBIFS_ORPH_NODE_SZ & 7); 2128 2129 BUILD_BUG_ON(UBIFS_MAX_DENT_NODE_SZ & 7); 2130 BUILD_BUG_ON(UBIFS_MAX_XENT_NODE_SZ & 7); 2131 BUILD_BUG_ON(UBIFS_MAX_DATA_NODE_SZ & 7); 2132 BUILD_BUG_ON(UBIFS_MAX_INO_NODE_SZ & 7); 2133 BUILD_BUG_ON(UBIFS_MAX_NODE_SZ & 7); 2134 BUILD_BUG_ON(MIN_WRITE_SZ & 7); 2135 2136 /* Check min. node size */ 2137 BUILD_BUG_ON(UBIFS_INO_NODE_SZ < MIN_WRITE_SZ); 2138 BUILD_BUG_ON(UBIFS_DENT_NODE_SZ < MIN_WRITE_SZ); 2139 BUILD_BUG_ON(UBIFS_XENT_NODE_SZ < MIN_WRITE_SZ); 2140 BUILD_BUG_ON(UBIFS_TRUN_NODE_SZ < MIN_WRITE_SZ); 2141 2142 BUILD_BUG_ON(UBIFS_MAX_DENT_NODE_SZ > UBIFS_MAX_NODE_SZ); 2143 BUILD_BUG_ON(UBIFS_MAX_XENT_NODE_SZ > UBIFS_MAX_NODE_SZ); 2144 BUILD_BUG_ON(UBIFS_MAX_DATA_NODE_SZ > UBIFS_MAX_NODE_SZ); 2145 BUILD_BUG_ON(UBIFS_MAX_INO_NODE_SZ > UBIFS_MAX_NODE_SZ); 2146 2147 /* Defined node sizes */ 2148 BUILD_BUG_ON(UBIFS_SB_NODE_SZ != 4096); 2149 BUILD_BUG_ON(UBIFS_MST_NODE_SZ != 512); 2150 BUILD_BUG_ON(UBIFS_INO_NODE_SZ != 160); 2151 BUILD_BUG_ON(UBIFS_REF_NODE_SZ != 64); 2152 2153 /* 2154 * We use 2 bit wide bit-fields to store compression type, which should 2155 * be amended if more compressors are added. The bit-fields are: 2156 * @compr_type in 'struct ubifs_inode', @default_compr in 2157 * 'struct ubifs_info' and @compr_type in 'struct ubifs_mount_opts'. 2158 */ 2159 BUILD_BUG_ON(UBIFS_COMPR_TYPES_CNT > 4); 2160 2161 /* 2162 * We require that PAGE_CACHE_SIZE is greater-than-or-equal-to 2163 * UBIFS_BLOCK_SIZE. It is assumed that both are powers of 2. 2164 */ 2165 if (PAGE_CACHE_SIZE < UBIFS_BLOCK_SIZE) { 2166 ubifs_err("VFS page cache size is %u bytes, but UBIFS requires" 2167 " at least 4096 bytes", 2168 (unsigned int)PAGE_CACHE_SIZE); 2169 return -EINVAL; 2170 } 2171 2172 err = register_filesystem(&ubifs_fs_type); 2173 if (err) { 2174 ubifs_err("cannot register file system, error %d", err); 2175 return err; 2176 } 2177 2178 err = -ENOMEM; 2179 ubifs_inode_slab = kmem_cache_create("ubifs_inode_slab", 2180 sizeof(struct ubifs_inode), 0, 2181 SLAB_MEM_SPREAD | SLAB_RECLAIM_ACCOUNT, 2182 &inode_slab_ctor); 2183 if (!ubifs_inode_slab) 2184 goto out_reg; 2185 2186 register_shrinker(&ubifs_shrinker_info); 2187 2188 err = ubifs_compressors_init(); 2189 if (err) 2190 goto out_shrinker; 2191 2192 err = dbg_debugfs_init(); 2193 if (err) 2194 goto out_compr; 2195 2196 return 0; 2197 2198 out_compr: 2199 ubifs_compressors_exit(); 2200 out_shrinker: 2201 unregister_shrinker(&ubifs_shrinker_info); 2202 kmem_cache_destroy(ubifs_inode_slab); 2203 out_reg: 2204 unregister_filesystem(&ubifs_fs_type); 2205 return err; 2206 } 2207 /* late_initcall to let compressors initialize first */ 2208 late_initcall(ubifs_init); 2209 2210 static void __exit ubifs_exit(void) 2211 { 2212 ubifs_assert(list_empty(&ubifs_infos)); 2213 ubifs_assert(atomic_long_read(&ubifs_clean_zn_cnt) == 0); 2214 2215 dbg_debugfs_exit(); 2216 ubifs_compressors_exit(); 2217 unregister_shrinker(&ubifs_shrinker_info); 2218 kmem_cache_destroy(ubifs_inode_slab); 2219 unregister_filesystem(&ubifs_fs_type); 2220 } 2221 module_exit(ubifs_exit); 2222 2223 MODULE_LICENSE("GPL"); 2224 MODULE_VERSION(__stringify(UBIFS_VERSION)); 2225 MODULE_AUTHOR("Artem Bityutskiy, Adrian Hunter"); 2226 MODULE_DESCRIPTION("UBIFS - UBI File System"); 2227