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