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