1
2
3
4
5
6
7#include <linux/module.h>
8#include <linux/buffer_head.h>
9#include <linux/statfs.h>
10#include <linux/parser.h>
11#include <linux/seq_file.h>
12#include <linux/crc32c.h>
13#include "xattr.h"
14
15#define CREATE_TRACE_POINTS
16#include <trace/events/erofs.h>
17
18static struct kmem_cache *erofs_inode_cachep __read_mostly;
19
20void _erofs_err(struct super_block *sb, const char *function,
21 const char *fmt, ...)
22{
23 struct va_format vaf;
24 va_list args;
25
26 va_start(args, fmt);
27
28 vaf.fmt = fmt;
29 vaf.va = &args;
30
31 pr_err("(device %s): %s: %pV", sb->s_id, function, &vaf);
32 va_end(args);
33}
34
35void _erofs_info(struct super_block *sb, const char *function,
36 const char *fmt, ...)
37{
38 struct va_format vaf;
39 va_list args;
40
41 va_start(args, fmt);
42
43 vaf.fmt = fmt;
44 vaf.va = &args;
45
46 pr_info("(device %s): %pV", sb->s_id, &vaf);
47 va_end(args);
48}
49
50static int erofs_superblock_csum_verify(struct super_block *sb, void *sbdata)
51{
52 struct erofs_super_block *dsb;
53 u32 expected_crc, crc;
54
55 dsb = kmemdup(sbdata + EROFS_SUPER_OFFSET,
56 EROFS_BLKSIZ - EROFS_SUPER_OFFSET, GFP_KERNEL);
57 if (!dsb)
58 return -ENOMEM;
59
60 expected_crc = le32_to_cpu(dsb->checksum);
61 dsb->checksum = 0;
62
63 crc = crc32c(~0, dsb, EROFS_BLKSIZ - EROFS_SUPER_OFFSET);
64 kfree(dsb);
65
66 if (crc != expected_crc) {
67 erofs_err(sb, "invalid checksum 0x%08x, 0x%08x expected",
68 crc, expected_crc);
69 return -EBADMSG;
70 }
71 return 0;
72}
73
74static void erofs_inode_init_once(void *ptr)
75{
76 struct erofs_inode *vi = ptr;
77
78 inode_init_once(&vi->vfs_inode);
79}
80
81static struct inode *erofs_alloc_inode(struct super_block *sb)
82{
83 struct erofs_inode *vi =
84 kmem_cache_alloc(erofs_inode_cachep, GFP_KERNEL);
85
86 if (!vi)
87 return NULL;
88
89
90 memset(vi, 0, offsetof(struct erofs_inode, vfs_inode));
91 return &vi->vfs_inode;
92}
93
94static void erofs_free_inode(struct inode *inode)
95{
96 struct erofs_inode *vi = EROFS_I(inode);
97
98
99 if (inode->i_op == &erofs_fast_symlink_iops)
100 kfree(inode->i_link);
101 kfree(vi->xattr_shared_xattrs);
102
103 kmem_cache_free(erofs_inode_cachep, vi);
104}
105
106static bool check_layout_compatibility(struct super_block *sb,
107 struct erofs_super_block *dsb)
108{
109 const unsigned int feature = le32_to_cpu(dsb->feature_incompat);
110
111 EROFS_SB(sb)->feature_incompat = feature;
112
113
114 if (feature & (~EROFS_ALL_FEATURE_INCOMPAT)) {
115 erofs_err(sb,
116 "unidentified incompatible feature %x, please upgrade kernel version",
117 feature & ~EROFS_ALL_FEATURE_INCOMPAT);
118 return false;
119 }
120 return true;
121}
122
123static int erofs_read_superblock(struct super_block *sb)
124{
125 struct erofs_sb_info *sbi;
126 struct page *page;
127 struct erofs_super_block *dsb;
128 unsigned int blkszbits;
129 void *data;
130 int ret;
131
132 page = read_mapping_page(sb->s_bdev->bd_inode->i_mapping, 0, NULL);
133 if (IS_ERR(page)) {
134 erofs_err(sb, "cannot read erofs superblock");
135 return PTR_ERR(page);
136 }
137
138 sbi = EROFS_SB(sb);
139
140 data = kmap(page);
141 dsb = (struct erofs_super_block *)(data + EROFS_SUPER_OFFSET);
142
143 ret = -EINVAL;
144 if (le32_to_cpu(dsb->magic) != EROFS_SUPER_MAGIC_V1) {
145 erofs_err(sb, "cannot find valid erofs superblock");
146 goto out;
147 }
148
149 sbi->feature_compat = le32_to_cpu(dsb->feature_compat);
150 if (sbi->feature_compat & EROFS_FEATURE_COMPAT_SB_CHKSUM) {
151 ret = erofs_superblock_csum_verify(sb, data);
152 if (ret)
153 goto out;
154 }
155
156 blkszbits = dsb->blkszbits;
157
158 if (blkszbits != LOG_BLOCK_SIZE) {
159 erofs_err(sb, "blksize %u isn't supported on this platform",
160 1 << blkszbits);
161 goto out;
162 }
163
164 if (!check_layout_compatibility(sb, dsb))
165 goto out;
166
167 sbi->blocks = le32_to_cpu(dsb->blocks);
168 sbi->meta_blkaddr = le32_to_cpu(dsb->meta_blkaddr);
169#ifdef CONFIG_EROFS_FS_XATTR
170 sbi->xattr_blkaddr = le32_to_cpu(dsb->xattr_blkaddr);
171#endif
172 sbi->islotbits = ilog2(sizeof(struct erofs_inode_compact));
173 sbi->root_nid = le16_to_cpu(dsb->root_nid);
174 sbi->inos = le64_to_cpu(dsb->inos);
175
176 sbi->build_time = le64_to_cpu(dsb->build_time);
177 sbi->build_time_nsec = le32_to_cpu(dsb->build_time_nsec);
178
179 memcpy(&sb->s_uuid, dsb->uuid, sizeof(dsb->uuid));
180
181 ret = strscpy(sbi->volume_name, dsb->volume_name,
182 sizeof(dsb->volume_name));
183 if (ret < 0) {
184 erofs_err(sb, "bad volume name without NIL terminator");
185 ret = -EFSCORRUPTED;
186 goto out;
187 }
188 ret = 0;
189out:
190 kunmap(page);
191 put_page(page);
192 return ret;
193}
194
195#ifdef CONFIG_EROFS_FS_ZIP
196static int erofs_build_cache_strategy(struct super_block *sb,
197 substring_t *args)
198{
199 struct erofs_sb_info *sbi = EROFS_SB(sb);
200 const char *cs = match_strdup(args);
201 int err = 0;
202
203 if (!cs) {
204 erofs_err(sb, "Not enough memory to store cache strategy");
205 return -ENOMEM;
206 }
207
208 if (!strcmp(cs, "disabled")) {
209 sbi->cache_strategy = EROFS_ZIP_CACHE_DISABLED;
210 } else if (!strcmp(cs, "readahead")) {
211 sbi->cache_strategy = EROFS_ZIP_CACHE_READAHEAD;
212 } else if (!strcmp(cs, "readaround")) {
213 sbi->cache_strategy = EROFS_ZIP_CACHE_READAROUND;
214 } else {
215 erofs_err(sb, "Unrecognized cache strategy \"%s\"", cs);
216 err = -EINVAL;
217 }
218 kfree(cs);
219 return err;
220}
221#else
222static int erofs_build_cache_strategy(struct super_block *sb,
223 substring_t *args)
224{
225 erofs_info(sb, "EROFS compression is disabled, so cache strategy is ignored");
226 return 0;
227}
228#endif
229
230
231static void erofs_default_options(struct erofs_sb_info *sbi)
232{
233#ifdef CONFIG_EROFS_FS_ZIP
234 sbi->cache_strategy = EROFS_ZIP_CACHE_READAROUND;
235 sbi->max_sync_decompress_pages = 3;
236#endif
237#ifdef CONFIG_EROFS_FS_XATTR
238 set_opt(sbi, XATTR_USER);
239#endif
240#ifdef CONFIG_EROFS_FS_POSIX_ACL
241 set_opt(sbi, POSIX_ACL);
242#endif
243}
244
245enum {
246 Opt_user_xattr,
247 Opt_nouser_xattr,
248 Opt_acl,
249 Opt_noacl,
250 Opt_cache_strategy,
251 Opt_err
252};
253
254static match_table_t erofs_tokens = {
255 {Opt_user_xattr, "user_xattr"},
256 {Opt_nouser_xattr, "nouser_xattr"},
257 {Opt_acl, "acl"},
258 {Opt_noacl, "noacl"},
259 {Opt_cache_strategy, "cache_strategy=%s"},
260 {Opt_err, NULL}
261};
262
263static int erofs_parse_options(struct super_block *sb, char *options)
264{
265 substring_t args[MAX_OPT_ARGS];
266 char *p;
267 int err;
268
269 if (!options)
270 return 0;
271
272 while ((p = strsep(&options, ","))) {
273 int token;
274
275 if (!*p)
276 continue;
277
278 args[0].to = args[0].from = NULL;
279 token = match_token(p, erofs_tokens, args);
280
281 switch (token) {
282#ifdef CONFIG_EROFS_FS_XATTR
283 case Opt_user_xattr:
284 set_opt(EROFS_SB(sb), XATTR_USER);
285 break;
286 case Opt_nouser_xattr:
287 clear_opt(EROFS_SB(sb), XATTR_USER);
288 break;
289#else
290 case Opt_user_xattr:
291 erofs_info(sb, "user_xattr options not supported");
292 break;
293 case Opt_nouser_xattr:
294 erofs_info(sb, "nouser_xattr options not supported");
295 break;
296#endif
297#ifdef CONFIG_EROFS_FS_POSIX_ACL
298 case Opt_acl:
299 set_opt(EROFS_SB(sb), POSIX_ACL);
300 break;
301 case Opt_noacl:
302 clear_opt(EROFS_SB(sb), POSIX_ACL);
303 break;
304#else
305 case Opt_acl:
306 erofs_info(sb, "acl options not supported");
307 break;
308 case Opt_noacl:
309 erofs_info(sb, "noacl options not supported");
310 break;
311#endif
312 case Opt_cache_strategy:
313 err = erofs_build_cache_strategy(sb, args);
314 if (err)
315 return err;
316 break;
317 default:
318 erofs_err(sb, "Unrecognized mount option \"%s\" or missing value", p);
319 return -EINVAL;
320 }
321 }
322 return 0;
323}
324
325#ifdef CONFIG_EROFS_FS_ZIP
326static const struct address_space_operations managed_cache_aops;
327
328static int erofs_managed_cache_releasepage(struct page *page, gfp_t gfp_mask)
329{
330 int ret = 1;
331 struct address_space *const mapping = page->mapping;
332
333 DBG_BUGON(!PageLocked(page));
334 DBG_BUGON(mapping->a_ops != &managed_cache_aops);
335
336 if (PagePrivate(page))
337 ret = erofs_try_to_free_cached_page(mapping, page);
338
339 return ret;
340}
341
342static void erofs_managed_cache_invalidatepage(struct page *page,
343 unsigned int offset,
344 unsigned int length)
345{
346 const unsigned int stop = length + offset;
347
348 DBG_BUGON(!PageLocked(page));
349
350
351 DBG_BUGON(stop > PAGE_SIZE || stop < length);
352
353 if (offset == 0 && stop == PAGE_SIZE)
354 while (!erofs_managed_cache_releasepage(page, GFP_NOFS))
355 cond_resched();
356}
357
358static const struct address_space_operations managed_cache_aops = {
359 .releasepage = erofs_managed_cache_releasepage,
360 .invalidatepage = erofs_managed_cache_invalidatepage,
361};
362
363static int erofs_init_managed_cache(struct super_block *sb)
364{
365 struct erofs_sb_info *const sbi = EROFS_SB(sb);
366 struct inode *const inode = new_inode(sb);
367
368 if (!inode)
369 return -ENOMEM;
370
371 set_nlink(inode, 1);
372 inode->i_size = OFFSET_MAX;
373
374 inode->i_mapping->a_ops = &managed_cache_aops;
375 mapping_set_gfp_mask(inode->i_mapping,
376 GFP_NOFS | __GFP_HIGHMEM | __GFP_MOVABLE);
377 sbi->managed_cache = inode;
378 return 0;
379}
380#else
381static int erofs_init_managed_cache(struct super_block *sb) { return 0; }
382#endif
383
384static int erofs_fill_super(struct super_block *sb, void *data, int silent)
385{
386 struct inode *inode;
387 struct erofs_sb_info *sbi;
388 int err;
389
390 sb->s_magic = EROFS_SUPER_MAGIC;
391
392 if (!sb_set_blocksize(sb, EROFS_BLKSIZ)) {
393 erofs_err(sb, "failed to set erofs blksize");
394 return -EINVAL;
395 }
396
397 sbi = kzalloc(sizeof(*sbi), GFP_KERNEL);
398 if (!sbi)
399 return -ENOMEM;
400
401 sb->s_fs_info = sbi;
402 err = erofs_read_superblock(sb);
403 if (err)
404 return err;
405
406 sb->s_flags |= SB_RDONLY | SB_NOATIME;
407 sb->s_maxbytes = MAX_LFS_FILESIZE;
408 sb->s_time_gran = 1;
409
410 sb->s_op = &erofs_sops;
411
412#ifdef CONFIG_EROFS_FS_XATTR
413 sb->s_xattr = erofs_xattr_handlers;
414#endif
415
416 erofs_default_options(sbi);
417
418 err = erofs_parse_options(sb, data);
419 if (err)
420 return err;
421
422 if (test_opt(sbi, POSIX_ACL))
423 sb->s_flags |= SB_POSIXACL;
424 else
425 sb->s_flags &= ~SB_POSIXACL;
426
427#ifdef CONFIG_EROFS_FS_ZIP
428 INIT_RADIX_TREE(&sbi->workstn_tree, GFP_ATOMIC);
429#endif
430
431
432 inode = erofs_iget(sb, ROOT_NID(sbi), true);
433 if (IS_ERR(inode))
434 return PTR_ERR(inode);
435
436 if (!S_ISDIR(inode->i_mode)) {
437 erofs_err(sb, "rootino(nid %llu) is not a directory(i_mode %o)",
438 ROOT_NID(sbi), inode->i_mode);
439 iput(inode);
440 return -EINVAL;
441 }
442
443 sb->s_root = d_make_root(inode);
444 if (!sb->s_root)
445 return -ENOMEM;
446
447 erofs_shrinker_register(sb);
448
449 err = erofs_init_managed_cache(sb);
450 if (err)
451 return err;
452
453 erofs_info(sb, "mounted with opts: %s, root inode @ nid %llu.",
454 (char *)data, ROOT_NID(sbi));
455 return 0;
456}
457
458static struct dentry *erofs_mount(struct file_system_type *fs_type, int flags,
459 const char *dev_name, void *data)
460{
461 return mount_bdev(fs_type, flags, dev_name, data, erofs_fill_super);
462}
463
464
465
466
467
468static void erofs_kill_sb(struct super_block *sb)
469{
470 struct erofs_sb_info *sbi;
471
472 WARN_ON(sb->s_magic != EROFS_SUPER_MAGIC);
473
474 kill_block_super(sb);
475
476 sbi = EROFS_SB(sb);
477 if (!sbi)
478 return;
479 kfree(sbi);
480 sb->s_fs_info = NULL;
481}
482
483
484static void erofs_put_super(struct super_block *sb)
485{
486 struct erofs_sb_info *const sbi = EROFS_SB(sb);
487
488 DBG_BUGON(!sbi);
489
490 erofs_shrinker_unregister(sb);
491#ifdef CONFIG_EROFS_FS_ZIP
492 iput(sbi->managed_cache);
493 sbi->managed_cache = NULL;
494#endif
495}
496
497static struct file_system_type erofs_fs_type = {
498 .owner = THIS_MODULE,
499 .name = "erofs",
500 .mount = erofs_mount,
501 .kill_sb = erofs_kill_sb,
502 .fs_flags = FS_REQUIRES_DEV,
503};
504MODULE_ALIAS_FS("erofs");
505
506static int __init erofs_module_init(void)
507{
508 int err;
509
510 erofs_check_ondisk_layout_definitions();
511
512 erofs_inode_cachep = kmem_cache_create("erofs_inode",
513 sizeof(struct erofs_inode), 0,
514 SLAB_RECLAIM_ACCOUNT,
515 erofs_inode_init_once);
516 if (!erofs_inode_cachep) {
517 err = -ENOMEM;
518 goto icache_err;
519 }
520
521 err = erofs_init_shrinker();
522 if (err)
523 goto shrinker_err;
524
525 err = z_erofs_init_zip_subsystem();
526 if (err)
527 goto zip_err;
528
529 err = register_filesystem(&erofs_fs_type);
530 if (err)
531 goto fs_err;
532
533 return 0;
534
535fs_err:
536 z_erofs_exit_zip_subsystem();
537zip_err:
538 erofs_exit_shrinker();
539shrinker_err:
540 kmem_cache_destroy(erofs_inode_cachep);
541icache_err:
542 return err;
543}
544
545static void __exit erofs_module_exit(void)
546{
547 unregister_filesystem(&erofs_fs_type);
548 z_erofs_exit_zip_subsystem();
549 erofs_exit_shrinker();
550
551
552 rcu_barrier();
553 kmem_cache_destroy(erofs_inode_cachep);
554}
555
556
557static int erofs_statfs(struct dentry *dentry, struct kstatfs *buf)
558{
559 struct super_block *sb = dentry->d_sb;
560 struct erofs_sb_info *sbi = EROFS_SB(sb);
561 u64 id = huge_encode_dev(sb->s_bdev->bd_dev);
562
563 buf->f_type = sb->s_magic;
564 buf->f_bsize = EROFS_BLKSIZ;
565 buf->f_blocks = sbi->blocks;
566 buf->f_bfree = buf->f_bavail = 0;
567
568 buf->f_files = ULLONG_MAX;
569 buf->f_ffree = ULLONG_MAX - sbi->inos;
570
571 buf->f_namelen = EROFS_NAME_LEN;
572
573 buf->f_fsid.val[0] = (u32)id;
574 buf->f_fsid.val[1] = (u32)(id >> 32);
575 return 0;
576}
577
578static int erofs_show_options(struct seq_file *seq, struct dentry *root)
579{
580 struct erofs_sb_info *sbi __maybe_unused = EROFS_SB(root->d_sb);
581
582#ifdef CONFIG_EROFS_FS_XATTR
583 if (test_opt(sbi, XATTR_USER))
584 seq_puts(seq, ",user_xattr");
585 else
586 seq_puts(seq, ",nouser_xattr");
587#endif
588#ifdef CONFIG_EROFS_FS_POSIX_ACL
589 if (test_opt(sbi, POSIX_ACL))
590 seq_puts(seq, ",acl");
591 else
592 seq_puts(seq, ",noacl");
593#endif
594#ifdef CONFIG_EROFS_FS_ZIP
595 if (sbi->cache_strategy == EROFS_ZIP_CACHE_DISABLED) {
596 seq_puts(seq, ",cache_strategy=disabled");
597 } else if (sbi->cache_strategy == EROFS_ZIP_CACHE_READAHEAD) {
598 seq_puts(seq, ",cache_strategy=readahead");
599 } else if (sbi->cache_strategy == EROFS_ZIP_CACHE_READAROUND) {
600 seq_puts(seq, ",cache_strategy=readaround");
601 }
602#endif
603 return 0;
604}
605
606static int erofs_remount(struct super_block *sb, int *flags, char *data)
607{
608 struct erofs_sb_info *sbi = EROFS_SB(sb);
609 unsigned int org_mnt_opt = sbi->mount_opt;
610 int err;
611
612 DBG_BUGON(!sb_rdonly(sb));
613 err = erofs_parse_options(sb, data);
614 if (err)
615 goto out;
616
617 if (test_opt(sbi, POSIX_ACL))
618 sb->s_flags |= SB_POSIXACL;
619 else
620 sb->s_flags &= ~SB_POSIXACL;
621
622 *flags |= SB_RDONLY;
623 return 0;
624out:
625 sbi->mount_opt = org_mnt_opt;
626 return err;
627}
628
629const struct super_operations erofs_sops = {
630 .put_super = erofs_put_super,
631 .alloc_inode = erofs_alloc_inode,
632 .free_inode = erofs_free_inode,
633 .statfs = erofs_statfs,
634 .show_options = erofs_show_options,
635 .remount_fs = erofs_remount,
636};
637
638module_init(erofs_module_init);
639module_exit(erofs_module_exit);
640
641MODULE_DESCRIPTION("Enhanced ROM File System");
642MODULE_AUTHOR("Gao Xiang, Chao Yu, Miao Xie, CONSUMER BG, HUAWEI Inc.");
643MODULE_LICENSE("GPL");
644
645
