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