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