1 // SPDX-License-Identifier: GPL-2.0-only 2 /* 3 * Copyright (C) 2017-2018 HUAWEI, Inc. 4 * https://www.huawei.com/ 5 * Copyright (C) 2021, Alibaba Cloud 6 */ 7 #include <linux/statfs.h> 8 #include <linux/seq_file.h> 9 #include <linux/crc32c.h> 10 #include <linux/fs_context.h> 11 #include <linux/fs_parser.h> 12 #include <linux/exportfs.h> 13 #include <linux/backing-dev.h> 14 #include "xattr.h" 15 16 #define CREATE_TRACE_POINTS 17 #include <trace/events/erofs.h> 18 19 static struct kmem_cache *erofs_inode_cachep __read_mostly; 20 21 void _erofs_printk(struct super_block *sb, const char *fmt, ...) 22 { 23 struct va_format vaf; 24 va_list args; 25 int level; 26 27 va_start(args, fmt); 28 29 level = printk_get_level(fmt); 30 vaf.fmt = printk_skip_level(fmt); 31 vaf.va = &args; 32 if (sb) 33 printk("%c%cerofs (device %s): %pV", 34 KERN_SOH_ASCII, level, sb->s_id, &vaf); 35 else 36 printk("%c%cerofs: %pV", KERN_SOH_ASCII, level, &vaf); 37 va_end(args); 38 } 39 40 static int erofs_superblock_csum_verify(struct super_block *sb, void *sbdata) 41 { 42 size_t len = 1 << EROFS_SB(sb)->blkszbits; 43 struct erofs_super_block *dsb; 44 u32 expected_crc, crc; 45 46 if (len > EROFS_SUPER_OFFSET) 47 len -= EROFS_SUPER_OFFSET; 48 49 dsb = kmemdup(sbdata + EROFS_SUPER_OFFSET, len, GFP_KERNEL); 50 if (!dsb) 51 return -ENOMEM; 52 53 expected_crc = le32_to_cpu(dsb->checksum); 54 dsb->checksum = 0; 55 /* to allow for x86 boot sectors and other oddities. */ 56 crc = crc32c(~0, dsb, len); 57 kfree(dsb); 58 59 if (crc != expected_crc) { 60 erofs_err(sb, "invalid checksum 0x%08x, 0x%08x expected", 61 crc, expected_crc); 62 return -EBADMSG; 63 } 64 return 0; 65 } 66 67 static void erofs_inode_init_once(void *ptr) 68 { 69 struct erofs_inode *vi = ptr; 70 71 inode_init_once(&vi->vfs_inode); 72 } 73 74 static struct inode *erofs_alloc_inode(struct super_block *sb) 75 { 76 struct erofs_inode *vi = 77 alloc_inode_sb(sb, erofs_inode_cachep, GFP_KERNEL); 78 79 if (!vi) 80 return NULL; 81 82 /* zero out everything except vfs_inode */ 83 memset(vi, 0, offsetof(struct erofs_inode, vfs_inode)); 84 return &vi->vfs_inode; 85 } 86 87 static void erofs_free_inode(struct inode *inode) 88 { 89 struct erofs_inode *vi = EROFS_I(inode); 90 91 if (inode->i_op == &erofs_fast_symlink_iops) 92 kfree(inode->i_link); 93 kfree(vi->xattr_shared_xattrs); 94 kmem_cache_free(erofs_inode_cachep, vi); 95 } 96 97 /* read variable-sized metadata, offset will be aligned by 4-byte */ 98 void *erofs_read_metadata(struct super_block *sb, struct erofs_buf *buf, 99 erofs_off_t *offset, int *lengthp) 100 { 101 u8 *buffer, *ptr; 102 int len, i, cnt; 103 104 *offset = round_up(*offset, 4); 105 ptr = erofs_bread(buf, *offset, EROFS_KMAP); 106 if (IS_ERR(ptr)) 107 return ptr; 108 109 len = le16_to_cpu(*(__le16 *)ptr); 110 if (!len) 111 len = U16_MAX + 1; 112 buffer = kmalloc(len, GFP_KERNEL); 113 if (!buffer) 114 return ERR_PTR(-ENOMEM); 115 *offset += sizeof(__le16); 116 *lengthp = len; 117 118 for (i = 0; i < len; i += cnt) { 119 cnt = min_t(int, sb->s_blocksize - erofs_blkoff(sb, *offset), 120 len - i); 121 ptr = erofs_bread(buf, *offset, EROFS_KMAP); 122 if (IS_ERR(ptr)) { 123 kfree(buffer); 124 return ptr; 125 } 126 memcpy(buffer + i, ptr, cnt); 127 *offset += cnt; 128 } 129 return buffer; 130 } 131 132 #ifndef CONFIG_EROFS_FS_ZIP 133 static int z_erofs_parse_cfgs(struct super_block *sb, 134 struct erofs_super_block *dsb) 135 { 136 if (!dsb->u1.available_compr_algs) 137 return 0; 138 139 erofs_err(sb, "compression disabled, unable to mount compressed EROFS"); 140 return -EOPNOTSUPP; 141 } 142 #endif 143 144 static int erofs_init_device(struct erofs_buf *buf, struct super_block *sb, 145 struct erofs_device_info *dif, erofs_off_t *pos) 146 { 147 struct erofs_sb_info *sbi = EROFS_SB(sb); 148 struct erofs_fscache *fscache; 149 struct erofs_deviceslot *dis; 150 struct file *file; 151 152 dis = erofs_read_metabuf(buf, sb, *pos, EROFS_KMAP); 153 if (IS_ERR(dis)) 154 return PTR_ERR(dis); 155 156 if (!sbi->devs->flatdev && !dif->path) { 157 if (!dis->tag[0]) { 158 erofs_err(sb, "empty device tag @ pos %llu", *pos); 159 return -EINVAL; 160 } 161 dif->path = kmemdup_nul(dis->tag, sizeof(dis->tag), GFP_KERNEL); 162 if (!dif->path) 163 return -ENOMEM; 164 } 165 166 if (erofs_is_fscache_mode(sb)) { 167 fscache = erofs_fscache_register_cookie(sb, dif->path, 0); 168 if (IS_ERR(fscache)) 169 return PTR_ERR(fscache); 170 dif->fscache = fscache; 171 } else if (!sbi->devs->flatdev) { 172 file = erofs_is_fileio_mode(sbi) ? 173 filp_open(dif->path, O_RDONLY | O_LARGEFILE, 0) : 174 bdev_file_open_by_path(dif->path, 175 BLK_OPEN_READ, sb->s_type, NULL); 176 if (IS_ERR(file)) 177 return PTR_ERR(file); 178 179 if (!erofs_is_fileio_mode(sbi)) { 180 dif->dax_dev = fs_dax_get_by_bdev(file_bdev(file), 181 &dif->dax_part_off, NULL, NULL); 182 } else if (!S_ISREG(file_inode(file)->i_mode)) { 183 fput(file); 184 return -EINVAL; 185 } 186 dif->file = file; 187 } 188 189 dif->blocks = le32_to_cpu(dis->blocks); 190 dif->mapped_blkaddr = le32_to_cpu(dis->mapped_blkaddr); 191 sbi->total_blocks += dif->blocks; 192 *pos += EROFS_DEVT_SLOT_SIZE; 193 return 0; 194 } 195 196 static int erofs_scan_devices(struct super_block *sb, 197 struct erofs_super_block *dsb) 198 { 199 struct erofs_sb_info *sbi = EROFS_SB(sb); 200 unsigned int ondisk_extradevs; 201 erofs_off_t pos; 202 struct erofs_buf buf = __EROFS_BUF_INITIALIZER; 203 struct erofs_device_info *dif; 204 int id, err = 0; 205 206 sbi->total_blocks = sbi->dif0.blocks; 207 if (!erofs_sb_has_device_table(sbi)) 208 ondisk_extradevs = 0; 209 else 210 ondisk_extradevs = le16_to_cpu(dsb->extra_devices); 211 212 if (sbi->devs->extra_devices && 213 ondisk_extradevs != sbi->devs->extra_devices) { 214 erofs_err(sb, "extra devices don't match (ondisk %u, given %u)", 215 ondisk_extradevs, sbi->devs->extra_devices); 216 return -EINVAL; 217 } 218 if (!ondisk_extradevs) 219 return 0; 220 221 if (!sbi->devs->extra_devices && !erofs_is_fscache_mode(sb)) 222 sbi->devs->flatdev = true; 223 224 sbi->device_id_mask = roundup_pow_of_two(ondisk_extradevs + 1) - 1; 225 pos = le16_to_cpu(dsb->devt_slotoff) * EROFS_DEVT_SLOT_SIZE; 226 down_read(&sbi->devs->rwsem); 227 if (sbi->devs->extra_devices) { 228 idr_for_each_entry(&sbi->devs->tree, dif, id) { 229 err = erofs_init_device(&buf, sb, dif, &pos); 230 if (err) 231 break; 232 } 233 } else { 234 for (id = 0; id < ondisk_extradevs; id++) { 235 dif = kzalloc(sizeof(*dif), GFP_KERNEL); 236 if (!dif) { 237 err = -ENOMEM; 238 break; 239 } 240 241 err = idr_alloc(&sbi->devs->tree, dif, 0, 0, GFP_KERNEL); 242 if (err < 0) { 243 kfree(dif); 244 break; 245 } 246 ++sbi->devs->extra_devices; 247 248 err = erofs_init_device(&buf, sb, dif, &pos); 249 if (err) 250 break; 251 } 252 } 253 up_read(&sbi->devs->rwsem); 254 erofs_put_metabuf(&buf); 255 return err; 256 } 257 258 static int erofs_read_superblock(struct super_block *sb) 259 { 260 struct erofs_sb_info *sbi = EROFS_SB(sb); 261 struct erofs_buf buf = __EROFS_BUF_INITIALIZER; 262 struct erofs_super_block *dsb; 263 void *data; 264 int ret; 265 266 data = erofs_read_metabuf(&buf, sb, 0, EROFS_KMAP); 267 if (IS_ERR(data)) { 268 erofs_err(sb, "cannot read erofs superblock"); 269 return PTR_ERR(data); 270 } 271 272 dsb = (struct erofs_super_block *)(data + EROFS_SUPER_OFFSET); 273 ret = -EINVAL; 274 if (le32_to_cpu(dsb->magic) != EROFS_SUPER_MAGIC_V1) { 275 erofs_err(sb, "cannot find valid erofs superblock"); 276 goto out; 277 } 278 279 sbi->blkszbits = dsb->blkszbits; 280 if (sbi->blkszbits < 9 || sbi->blkszbits > PAGE_SHIFT) { 281 erofs_err(sb, "blkszbits %u isn't supported", sbi->blkszbits); 282 goto out; 283 } 284 if (dsb->dirblkbits) { 285 erofs_err(sb, "dirblkbits %u isn't supported", dsb->dirblkbits); 286 goto out; 287 } 288 289 sbi->feature_compat = le32_to_cpu(dsb->feature_compat); 290 if (erofs_sb_has_sb_chksum(sbi)) { 291 ret = erofs_superblock_csum_verify(sb, data); 292 if (ret) 293 goto out; 294 } 295 296 ret = -EINVAL; 297 sbi->feature_incompat = le32_to_cpu(dsb->feature_incompat); 298 if (sbi->feature_incompat & ~EROFS_ALL_FEATURE_INCOMPAT) { 299 erofs_err(sb, "unidentified incompatible feature %x, please upgrade kernel", 300 sbi->feature_incompat & ~EROFS_ALL_FEATURE_INCOMPAT); 301 goto out; 302 } 303 304 sbi->sb_size = 128 + dsb->sb_extslots * EROFS_SB_EXTSLOT_SIZE; 305 if (sbi->sb_size > PAGE_SIZE - EROFS_SUPER_OFFSET) { 306 erofs_err(sb, "invalid sb_extslots %u (more than a fs block)", 307 sbi->sb_size); 308 goto out; 309 } 310 sbi->dif0.blocks = le32_to_cpu(dsb->blocks); 311 sbi->meta_blkaddr = le32_to_cpu(dsb->meta_blkaddr); 312 #ifdef CONFIG_EROFS_FS_XATTR 313 sbi->xattr_blkaddr = le32_to_cpu(dsb->xattr_blkaddr); 314 sbi->xattr_prefix_start = le32_to_cpu(dsb->xattr_prefix_start); 315 sbi->xattr_prefix_count = dsb->xattr_prefix_count; 316 sbi->xattr_filter_reserved = dsb->xattr_filter_reserved; 317 #endif 318 sbi->islotbits = ilog2(sizeof(struct erofs_inode_compact)); 319 sbi->root_nid = le16_to_cpu(dsb->root_nid); 320 sbi->packed_nid = le64_to_cpu(dsb->packed_nid); 321 sbi->inos = le64_to_cpu(dsb->inos); 322 323 sbi->build_time = le64_to_cpu(dsb->build_time); 324 sbi->build_time_nsec = le32_to_cpu(dsb->build_time_nsec); 325 326 super_set_uuid(sb, (void *)dsb->uuid, sizeof(dsb->uuid)); 327 328 ret = strscpy(sbi->volume_name, dsb->volume_name, 329 sizeof(dsb->volume_name)); 330 if (ret < 0) { /* -E2BIG */ 331 erofs_err(sb, "bad volume name without NIL terminator"); 332 ret = -EFSCORRUPTED; 333 goto out; 334 } 335 336 /* parse on-disk compression configurations */ 337 ret = z_erofs_parse_cfgs(sb, dsb); 338 if (ret < 0) 339 goto out; 340 341 /* handle multiple devices */ 342 ret = erofs_scan_devices(sb, dsb); 343 344 if (erofs_is_fscache_mode(sb)) 345 erofs_info(sb, "[deprecated] fscache-based on-demand read feature in use. Use at your own risk!"); 346 out: 347 erofs_put_metabuf(&buf); 348 return ret; 349 } 350 351 static void erofs_default_options(struct erofs_sb_info *sbi) 352 { 353 #ifdef CONFIG_EROFS_FS_ZIP 354 sbi->opt.cache_strategy = EROFS_ZIP_CACHE_READAROUND; 355 sbi->opt.max_sync_decompress_pages = 3; 356 sbi->opt.sync_decompress = EROFS_SYNC_DECOMPRESS_AUTO; 357 #endif 358 #ifdef CONFIG_EROFS_FS_XATTR 359 set_opt(&sbi->opt, XATTR_USER); 360 #endif 361 #ifdef CONFIG_EROFS_FS_POSIX_ACL 362 set_opt(&sbi->opt, POSIX_ACL); 363 #endif 364 } 365 366 enum { 367 Opt_user_xattr, Opt_acl, Opt_cache_strategy, Opt_dax, Opt_dax_enum, 368 Opt_device, Opt_fsid, Opt_domain_id, Opt_directio, 369 Opt_err 370 }; 371 372 static const struct constant_table erofs_param_cache_strategy[] = { 373 {"disabled", EROFS_ZIP_CACHE_DISABLED}, 374 {"readahead", EROFS_ZIP_CACHE_READAHEAD}, 375 {"readaround", EROFS_ZIP_CACHE_READAROUND}, 376 {} 377 }; 378 379 static const struct constant_table erofs_dax_param_enums[] = { 380 {"always", EROFS_MOUNT_DAX_ALWAYS}, 381 {"never", EROFS_MOUNT_DAX_NEVER}, 382 {} 383 }; 384 385 static const struct fs_parameter_spec erofs_fs_parameters[] = { 386 fsparam_flag_no("user_xattr", Opt_user_xattr), 387 fsparam_flag_no("acl", Opt_acl), 388 fsparam_enum("cache_strategy", Opt_cache_strategy, 389 erofs_param_cache_strategy), 390 fsparam_flag("dax", Opt_dax), 391 fsparam_enum("dax", Opt_dax_enum, erofs_dax_param_enums), 392 fsparam_string("device", Opt_device), 393 fsparam_string("fsid", Opt_fsid), 394 fsparam_string("domain_id", Opt_domain_id), 395 fsparam_flag_no("directio", Opt_directio), 396 {} 397 }; 398 399 static bool erofs_fc_set_dax_mode(struct fs_context *fc, unsigned int mode) 400 { 401 #ifdef CONFIG_FS_DAX 402 struct erofs_sb_info *sbi = fc->s_fs_info; 403 404 switch (mode) { 405 case EROFS_MOUNT_DAX_ALWAYS: 406 set_opt(&sbi->opt, DAX_ALWAYS); 407 clear_opt(&sbi->opt, DAX_NEVER); 408 return true; 409 case EROFS_MOUNT_DAX_NEVER: 410 set_opt(&sbi->opt, DAX_NEVER); 411 clear_opt(&sbi->opt, DAX_ALWAYS); 412 return true; 413 default: 414 DBG_BUGON(1); 415 return false; 416 } 417 #else 418 errorfc(fc, "dax options not supported"); 419 return false; 420 #endif 421 } 422 423 static int erofs_fc_parse_param(struct fs_context *fc, 424 struct fs_parameter *param) 425 { 426 struct erofs_sb_info *sbi = fc->s_fs_info; 427 struct fs_parse_result result; 428 struct erofs_device_info *dif; 429 int opt, ret; 430 431 opt = fs_parse(fc, erofs_fs_parameters, param, &result); 432 if (opt < 0) 433 return opt; 434 435 switch (opt) { 436 case Opt_user_xattr: 437 #ifdef CONFIG_EROFS_FS_XATTR 438 if (result.boolean) 439 set_opt(&sbi->opt, XATTR_USER); 440 else 441 clear_opt(&sbi->opt, XATTR_USER); 442 #else 443 errorfc(fc, "{,no}user_xattr options not supported"); 444 #endif 445 break; 446 case Opt_acl: 447 #ifdef CONFIG_EROFS_FS_POSIX_ACL 448 if (result.boolean) 449 set_opt(&sbi->opt, POSIX_ACL); 450 else 451 clear_opt(&sbi->opt, POSIX_ACL); 452 #else 453 errorfc(fc, "{,no}acl options not supported"); 454 #endif 455 break; 456 case Opt_cache_strategy: 457 #ifdef CONFIG_EROFS_FS_ZIP 458 sbi->opt.cache_strategy = result.uint_32; 459 #else 460 errorfc(fc, "compression not supported, cache_strategy ignored"); 461 #endif 462 break; 463 case Opt_dax: 464 if (!erofs_fc_set_dax_mode(fc, EROFS_MOUNT_DAX_ALWAYS)) 465 return -EINVAL; 466 break; 467 case Opt_dax_enum: 468 if (!erofs_fc_set_dax_mode(fc, result.uint_32)) 469 return -EINVAL; 470 break; 471 case Opt_device: 472 dif = kzalloc(sizeof(*dif), GFP_KERNEL); 473 if (!dif) 474 return -ENOMEM; 475 dif->path = kstrdup(param->string, GFP_KERNEL); 476 if (!dif->path) { 477 kfree(dif); 478 return -ENOMEM; 479 } 480 down_write(&sbi->devs->rwsem); 481 ret = idr_alloc(&sbi->devs->tree, dif, 0, 0, GFP_KERNEL); 482 up_write(&sbi->devs->rwsem); 483 if (ret < 0) { 484 kfree(dif->path); 485 kfree(dif); 486 return ret; 487 } 488 ++sbi->devs->extra_devices; 489 break; 490 #ifdef CONFIG_EROFS_FS_ONDEMAND 491 case Opt_fsid: 492 kfree(sbi->fsid); 493 sbi->fsid = kstrdup(param->string, GFP_KERNEL); 494 if (!sbi->fsid) 495 return -ENOMEM; 496 break; 497 case Opt_domain_id: 498 kfree(sbi->domain_id); 499 sbi->domain_id = kstrdup(param->string, GFP_KERNEL); 500 if (!sbi->domain_id) 501 return -ENOMEM; 502 break; 503 #else 504 case Opt_fsid: 505 case Opt_domain_id: 506 errorfc(fc, "%s option not supported", erofs_fs_parameters[opt].name); 507 break; 508 #endif 509 case Opt_directio: 510 #ifdef CONFIG_EROFS_FS_BACKED_BY_FILE 511 if (result.boolean) 512 set_opt(&sbi->opt, DIRECT_IO); 513 else 514 clear_opt(&sbi->opt, DIRECT_IO); 515 #else 516 errorfc(fc, "%s option not supported", erofs_fs_parameters[opt].name); 517 #endif 518 break; 519 default: 520 return -ENOPARAM; 521 } 522 return 0; 523 } 524 525 static struct inode *erofs_nfs_get_inode(struct super_block *sb, 526 u64 ino, u32 generation) 527 { 528 return erofs_iget(sb, ino); 529 } 530 531 static struct dentry *erofs_fh_to_dentry(struct super_block *sb, 532 struct fid *fid, int fh_len, int fh_type) 533 { 534 return generic_fh_to_dentry(sb, fid, fh_len, fh_type, 535 erofs_nfs_get_inode); 536 } 537 538 static struct dentry *erofs_fh_to_parent(struct super_block *sb, 539 struct fid *fid, int fh_len, int fh_type) 540 { 541 return generic_fh_to_parent(sb, fid, fh_len, fh_type, 542 erofs_nfs_get_inode); 543 } 544 545 static struct dentry *erofs_get_parent(struct dentry *child) 546 { 547 erofs_nid_t nid; 548 unsigned int d_type; 549 int err; 550 551 err = erofs_namei(d_inode(child), &dotdot_name, &nid, &d_type); 552 if (err) 553 return ERR_PTR(err); 554 return d_obtain_alias(erofs_iget(child->d_sb, nid)); 555 } 556 557 static const struct export_operations erofs_export_ops = { 558 .encode_fh = generic_encode_ino32_fh, 559 .fh_to_dentry = erofs_fh_to_dentry, 560 .fh_to_parent = erofs_fh_to_parent, 561 .get_parent = erofs_get_parent, 562 }; 563 564 static void erofs_set_sysfs_name(struct super_block *sb) 565 { 566 struct erofs_sb_info *sbi = EROFS_SB(sb); 567 568 if (sbi->domain_id) 569 super_set_sysfs_name_generic(sb, "%s,%s", sbi->domain_id, 570 sbi->fsid); 571 else if (sbi->fsid) 572 super_set_sysfs_name_generic(sb, "%s", sbi->fsid); 573 else if (erofs_is_fileio_mode(sbi)) 574 super_set_sysfs_name_generic(sb, "%s", 575 bdi_dev_name(sb->s_bdi)); 576 else 577 super_set_sysfs_name_id(sb); 578 } 579 580 static int erofs_fc_fill_super(struct super_block *sb, struct fs_context *fc) 581 { 582 struct inode *inode; 583 struct erofs_sb_info *sbi = EROFS_SB(sb); 584 int err; 585 586 sb->s_magic = EROFS_SUPER_MAGIC; 587 sb->s_flags |= SB_RDONLY | SB_NOATIME; 588 sb->s_maxbytes = MAX_LFS_FILESIZE; 589 sb->s_op = &erofs_sops; 590 591 sbi->blkszbits = PAGE_SHIFT; 592 if (!sb->s_bdev) { 593 sb->s_blocksize = PAGE_SIZE; 594 sb->s_blocksize_bits = PAGE_SHIFT; 595 596 if (erofs_is_fscache_mode(sb)) { 597 err = erofs_fscache_register_fs(sb); 598 if (err) 599 return err; 600 } 601 err = super_setup_bdi(sb); 602 if (err) 603 return err; 604 } else { 605 if (!sb_set_blocksize(sb, PAGE_SIZE)) { 606 errorfc(fc, "failed to set initial blksize"); 607 return -EINVAL; 608 } 609 610 sbi->dif0.dax_dev = fs_dax_get_by_bdev(sb->s_bdev, 611 &sbi->dif0.dax_part_off, NULL, NULL); 612 } 613 614 err = erofs_read_superblock(sb); 615 if (err) 616 return err; 617 618 if (sb->s_blocksize_bits != sbi->blkszbits) { 619 if (erofs_is_fscache_mode(sb)) { 620 errorfc(fc, "unsupported blksize for fscache mode"); 621 return -EINVAL; 622 } 623 624 if (erofs_is_fileio_mode(sbi)) { 625 sb->s_blocksize = 1 << sbi->blkszbits; 626 sb->s_blocksize_bits = sbi->blkszbits; 627 } else if (!sb_set_blocksize(sb, 1 << sbi->blkszbits)) { 628 errorfc(fc, "failed to set erofs blksize"); 629 return -EINVAL; 630 } 631 } 632 633 if (test_opt(&sbi->opt, DAX_ALWAYS)) { 634 if (!sbi->dif0.dax_dev) { 635 errorfc(fc, "DAX unsupported by block device. Turning off DAX."); 636 clear_opt(&sbi->opt, DAX_ALWAYS); 637 } else if (sbi->blkszbits != PAGE_SHIFT) { 638 errorfc(fc, "unsupported blocksize for DAX"); 639 clear_opt(&sbi->opt, DAX_ALWAYS); 640 } 641 } 642 643 sb->s_time_gran = 1; 644 sb->s_xattr = erofs_xattr_handlers; 645 sb->s_export_op = &erofs_export_ops; 646 647 if (test_opt(&sbi->opt, POSIX_ACL)) 648 sb->s_flags |= SB_POSIXACL; 649 else 650 sb->s_flags &= ~SB_POSIXACL; 651 652 #ifdef CONFIG_EROFS_FS_ZIP 653 xa_init(&sbi->managed_pslots); 654 #endif 655 656 inode = erofs_iget(sb, sbi->root_nid); 657 if (IS_ERR(inode)) 658 return PTR_ERR(inode); 659 660 if (!S_ISDIR(inode->i_mode)) { 661 erofs_err(sb, "rootino(nid %llu) is not a directory(i_mode %o)", 662 sbi->root_nid, inode->i_mode); 663 iput(inode); 664 return -EINVAL; 665 } 666 667 sb->s_root = d_make_root(inode); 668 if (!sb->s_root) 669 return -ENOMEM; 670 671 erofs_shrinker_register(sb); 672 if (erofs_sb_has_fragments(sbi) && sbi->packed_nid) { 673 sbi->packed_inode = erofs_iget(sb, sbi->packed_nid); 674 if (IS_ERR(sbi->packed_inode)) { 675 err = PTR_ERR(sbi->packed_inode); 676 sbi->packed_inode = NULL; 677 return err; 678 } 679 } 680 err = erofs_init_managed_cache(sb); 681 if (err) 682 return err; 683 684 err = erofs_xattr_prefixes_init(sb); 685 if (err) 686 return err; 687 688 erofs_set_sysfs_name(sb); 689 err = erofs_register_sysfs(sb); 690 if (err) 691 return err; 692 693 erofs_info(sb, "mounted with root inode @ nid %llu.", sbi->root_nid); 694 return 0; 695 } 696 697 static int erofs_fc_get_tree(struct fs_context *fc) 698 { 699 struct erofs_sb_info *sbi = fc->s_fs_info; 700 int ret; 701 702 if (IS_ENABLED(CONFIG_EROFS_FS_ONDEMAND) && sbi->fsid) 703 return get_tree_nodev(fc, erofs_fc_fill_super); 704 705 ret = get_tree_bdev_flags(fc, erofs_fc_fill_super, 706 IS_ENABLED(CONFIG_EROFS_FS_BACKED_BY_FILE) ? 707 GET_TREE_BDEV_QUIET_LOOKUP : 0); 708 #ifdef CONFIG_EROFS_FS_BACKED_BY_FILE 709 if (ret == -ENOTBLK) { 710 struct file *file; 711 712 if (!fc->source) 713 return invalf(fc, "No source specified"); 714 file = filp_open(fc->source, O_RDONLY | O_LARGEFILE, 0); 715 if (IS_ERR(file)) 716 return PTR_ERR(file); 717 sbi->dif0.file = file; 718 719 if (S_ISREG(file_inode(sbi->dif0.file)->i_mode) && 720 sbi->dif0.file->f_mapping->a_ops->read_folio) 721 return get_tree_nodev(fc, erofs_fc_fill_super); 722 } 723 #endif 724 return ret; 725 } 726 727 static int erofs_fc_reconfigure(struct fs_context *fc) 728 { 729 struct super_block *sb = fc->root->d_sb; 730 struct erofs_sb_info *sbi = EROFS_SB(sb); 731 struct erofs_sb_info *new_sbi = fc->s_fs_info; 732 733 DBG_BUGON(!sb_rdonly(sb)); 734 735 if (new_sbi->fsid || new_sbi->domain_id) 736 erofs_info(sb, "ignoring reconfiguration for fsid|domain_id."); 737 738 if (test_opt(&new_sbi->opt, POSIX_ACL)) 739 fc->sb_flags |= SB_POSIXACL; 740 else 741 fc->sb_flags &= ~SB_POSIXACL; 742 743 sbi->opt = new_sbi->opt; 744 745 fc->sb_flags |= SB_RDONLY; 746 return 0; 747 } 748 749 static int erofs_release_device_info(int id, void *ptr, void *data) 750 { 751 struct erofs_device_info *dif = ptr; 752 753 fs_put_dax(dif->dax_dev, NULL); 754 if (dif->file) 755 fput(dif->file); 756 erofs_fscache_unregister_cookie(dif->fscache); 757 dif->fscache = NULL; 758 kfree(dif->path); 759 kfree(dif); 760 return 0; 761 } 762 763 static void erofs_free_dev_context(struct erofs_dev_context *devs) 764 { 765 if (!devs) 766 return; 767 idr_for_each(&devs->tree, &erofs_release_device_info, NULL); 768 idr_destroy(&devs->tree); 769 kfree(devs); 770 } 771 772 static void erofs_sb_free(struct erofs_sb_info *sbi) 773 { 774 erofs_free_dev_context(sbi->devs); 775 kfree(sbi->fsid); 776 kfree(sbi->domain_id); 777 if (sbi->dif0.file) 778 fput(sbi->dif0.file); 779 kfree(sbi); 780 } 781 782 static void erofs_fc_free(struct fs_context *fc) 783 { 784 struct erofs_sb_info *sbi = fc->s_fs_info; 785 786 if (sbi) /* free here if an error occurs before transferring to sb */ 787 erofs_sb_free(sbi); 788 } 789 790 static const struct fs_context_operations erofs_context_ops = { 791 .parse_param = erofs_fc_parse_param, 792 .get_tree = erofs_fc_get_tree, 793 .reconfigure = erofs_fc_reconfigure, 794 .free = erofs_fc_free, 795 }; 796 797 static int erofs_init_fs_context(struct fs_context *fc) 798 { 799 struct erofs_sb_info *sbi; 800 801 sbi = kzalloc(sizeof(*sbi), GFP_KERNEL); 802 if (!sbi) 803 return -ENOMEM; 804 805 sbi->devs = kzalloc(sizeof(struct erofs_dev_context), GFP_KERNEL); 806 if (!sbi->devs) { 807 kfree(sbi); 808 return -ENOMEM; 809 } 810 fc->s_fs_info = sbi; 811 812 idr_init(&sbi->devs->tree); 813 init_rwsem(&sbi->devs->rwsem); 814 erofs_default_options(sbi); 815 fc->ops = &erofs_context_ops; 816 return 0; 817 } 818 819 static void erofs_kill_sb(struct super_block *sb) 820 { 821 struct erofs_sb_info *sbi = EROFS_SB(sb); 822 823 if ((IS_ENABLED(CONFIG_EROFS_FS_ONDEMAND) && sbi->fsid) || 824 sbi->dif0.file) 825 kill_anon_super(sb); 826 else 827 kill_block_super(sb); 828 fs_put_dax(sbi->dif0.dax_dev, NULL); 829 erofs_fscache_unregister_fs(sb); 830 erofs_sb_free(sbi); 831 sb->s_fs_info = NULL; 832 } 833 834 static void erofs_put_super(struct super_block *sb) 835 { 836 struct erofs_sb_info *const sbi = EROFS_SB(sb); 837 838 DBG_BUGON(!sbi); 839 840 erofs_unregister_sysfs(sb); 841 erofs_shrinker_unregister(sb); 842 erofs_xattr_prefixes_cleanup(sb); 843 #ifdef CONFIG_EROFS_FS_ZIP 844 iput(sbi->managed_cache); 845 sbi->managed_cache = NULL; 846 #endif 847 iput(sbi->packed_inode); 848 sbi->packed_inode = NULL; 849 erofs_free_dev_context(sbi->devs); 850 sbi->devs = NULL; 851 erofs_fscache_unregister_fs(sb); 852 } 853 854 static struct file_system_type erofs_fs_type = { 855 .owner = THIS_MODULE, 856 .name = "erofs", 857 .init_fs_context = erofs_init_fs_context, 858 .kill_sb = erofs_kill_sb, 859 .fs_flags = FS_REQUIRES_DEV | FS_ALLOW_IDMAP, 860 }; 861 MODULE_ALIAS_FS("erofs"); 862 863 static int __init erofs_module_init(void) 864 { 865 int err; 866 867 erofs_check_ondisk_layout_definitions(); 868 869 erofs_inode_cachep = kmem_cache_create("erofs_inode", 870 sizeof(struct erofs_inode), 0, 871 SLAB_RECLAIM_ACCOUNT | SLAB_ACCOUNT, 872 erofs_inode_init_once); 873 if (!erofs_inode_cachep) 874 return -ENOMEM; 875 876 err = erofs_init_shrinker(); 877 if (err) 878 goto shrinker_err; 879 880 err = z_erofs_init_subsystem(); 881 if (err) 882 goto zip_err; 883 884 err = erofs_init_sysfs(); 885 if (err) 886 goto sysfs_err; 887 888 err = register_filesystem(&erofs_fs_type); 889 if (err) 890 goto fs_err; 891 892 return 0; 893 894 fs_err: 895 erofs_exit_sysfs(); 896 sysfs_err: 897 z_erofs_exit_subsystem(); 898 zip_err: 899 erofs_exit_shrinker(); 900 shrinker_err: 901 kmem_cache_destroy(erofs_inode_cachep); 902 return err; 903 } 904 905 static void __exit erofs_module_exit(void) 906 { 907 unregister_filesystem(&erofs_fs_type); 908 909 /* Ensure all RCU free inodes / pclusters are safe to be destroyed. */ 910 rcu_barrier(); 911 912 erofs_exit_sysfs(); 913 z_erofs_exit_subsystem(); 914 erofs_exit_shrinker(); 915 kmem_cache_destroy(erofs_inode_cachep); 916 } 917 918 static int erofs_statfs(struct dentry *dentry, struct kstatfs *buf) 919 { 920 struct super_block *sb = dentry->d_sb; 921 struct erofs_sb_info *sbi = EROFS_SB(sb); 922 923 buf->f_type = sb->s_magic; 924 buf->f_bsize = sb->s_blocksize; 925 buf->f_blocks = sbi->total_blocks; 926 buf->f_bfree = buf->f_bavail = 0; 927 buf->f_files = ULLONG_MAX; 928 buf->f_ffree = ULLONG_MAX - sbi->inos; 929 buf->f_namelen = EROFS_NAME_LEN; 930 931 if (uuid_is_null(&sb->s_uuid)) 932 buf->f_fsid = u64_to_fsid(!sb->s_bdev ? 0 : 933 huge_encode_dev(sb->s_bdev->bd_dev)); 934 else 935 buf->f_fsid = uuid_to_fsid(sb->s_uuid.b); 936 return 0; 937 } 938 939 static int erofs_show_options(struct seq_file *seq, struct dentry *root) 940 { 941 struct erofs_sb_info *sbi = EROFS_SB(root->d_sb); 942 struct erofs_mount_opts *opt = &sbi->opt; 943 944 if (IS_ENABLED(CONFIG_EROFS_FS_XATTR)) 945 seq_puts(seq, test_opt(opt, XATTR_USER) ? 946 ",user_xattr" : ",nouser_xattr"); 947 if (IS_ENABLED(CONFIG_EROFS_FS_POSIX_ACL)) 948 seq_puts(seq, test_opt(opt, POSIX_ACL) ? ",acl" : ",noacl"); 949 if (IS_ENABLED(CONFIG_EROFS_FS_ZIP)) 950 seq_printf(seq, ",cache_strategy=%s", 951 erofs_param_cache_strategy[opt->cache_strategy].name); 952 if (test_opt(opt, DAX_ALWAYS)) 953 seq_puts(seq, ",dax=always"); 954 if (test_opt(opt, DAX_NEVER)) 955 seq_puts(seq, ",dax=never"); 956 if (erofs_is_fileio_mode(sbi) && test_opt(opt, DIRECT_IO)) 957 seq_puts(seq, ",directio"); 958 #ifdef CONFIG_EROFS_FS_ONDEMAND 959 if (sbi->fsid) 960 seq_printf(seq, ",fsid=%s", sbi->fsid); 961 if (sbi->domain_id) 962 seq_printf(seq, ",domain_id=%s", sbi->domain_id); 963 #endif 964 return 0; 965 } 966 967 const struct super_operations erofs_sops = { 968 .put_super = erofs_put_super, 969 .alloc_inode = erofs_alloc_inode, 970 .free_inode = erofs_free_inode, 971 .statfs = erofs_statfs, 972 .show_options = erofs_show_options, 973 }; 974 975 module_init(erofs_module_init); 976 module_exit(erofs_module_exit); 977 978 MODULE_DESCRIPTION("Enhanced ROM File System"); 979 MODULE_AUTHOR("Gao Xiang, Chao Yu, Miao Xie, CONSUMER BG, HUAWEI Inc."); 980 MODULE_LICENSE("GPL"); 981