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