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