15c784fba879dc4afda4227bc9576c152c8a3c01
[muen/linux.git] / drivers / staging / erofs / super.c
1 // SPDX-License-Identifier: GPL-2.0
2 /*
3  * linux/drivers/staging/erofs/super.c
4  *
5  * Copyright (C) 2017-2018 HUAWEI, Inc.
6  *             http://www.huawei.com/
7  * Created by Gao Xiang <gaoxiang25@huawei.com>
8  *
9  * This file is subject to the terms and conditions of the GNU General Public
10  * License.  See the file COPYING in the main directory of the Linux
11  * distribution for more details.
12  */
13 #include <linux/module.h>
14 #include <linux/buffer_head.h>
15 #include <linux/statfs.h>
16 #include <linux/parser.h>
17 #include <linux/seq_file.h>
18 #include "internal.h"
19 #include "xattr.h"
20
21 #define CREATE_TRACE_POINTS
22 #include <trace/events/erofs.h>
23
24 static struct kmem_cache *erofs_inode_cachep __read_mostly;
25
26 static void init_once(void *ptr)
27 {
28         struct erofs_vnode *vi = ptr;
29
30         inode_init_once(&vi->vfs_inode);
31 }
32
33 static int __init erofs_init_inode_cache(void)
34 {
35         erofs_inode_cachep = kmem_cache_create("erofs_inode",
36                 sizeof(struct erofs_vnode), 0,
37                 SLAB_RECLAIM_ACCOUNT, init_once);
38
39         return erofs_inode_cachep != NULL ? 0 : -ENOMEM;
40 }
41
42 static void erofs_exit_inode_cache(void)
43 {
44         kmem_cache_destroy(erofs_inode_cachep);
45 }
46
47 static struct inode *alloc_inode(struct super_block *sb)
48 {
49         struct erofs_vnode *vi =
50                 kmem_cache_alloc(erofs_inode_cachep, GFP_KERNEL);
51
52         if (vi == NULL)
53                 return NULL;
54
55         /* zero out everything except vfs_inode */
56         memset(vi, 0, offsetof(struct erofs_vnode, vfs_inode));
57         return &vi->vfs_inode;
58 }
59
60 static void i_callback(struct rcu_head *head)
61 {
62         struct inode *inode = container_of(head, struct inode, i_rcu);
63         struct erofs_vnode *vi = EROFS_V(inode);
64
65         /* be careful RCU symlink path (see ext4_inode_info->i_data)! */
66         if (is_inode_fast_symlink(inode))
67                 kfree(inode->i_link);
68
69         kfree(vi->xattr_shared_xattrs);
70
71         kmem_cache_free(erofs_inode_cachep, vi);
72 }
73
74 static void destroy_inode(struct inode *inode)
75 {
76         call_rcu(&inode->i_rcu, i_callback);
77 }
78
79 static int superblock_read(struct super_block *sb)
80 {
81         struct erofs_sb_info *sbi;
82         struct buffer_head *bh;
83         struct erofs_super_block *layout;
84         unsigned int blkszbits;
85         int ret;
86
87         bh = sb_bread(sb, 0);
88
89         if (bh == NULL) {
90                 errln("cannot read erofs superblock");
91                 return -EIO;
92         }
93
94         sbi = EROFS_SB(sb);
95         layout = (struct erofs_super_block *)((u8 *)bh->b_data
96                  + EROFS_SUPER_OFFSET);
97
98         ret = -EINVAL;
99         if (le32_to_cpu(layout->magic) != EROFS_SUPER_MAGIC_V1) {
100                 errln("cannot find valid erofs superblock");
101                 goto out;
102         }
103
104         blkszbits = layout->blkszbits;
105         /* 9(512 bytes) + LOG_SECTORS_PER_BLOCK == LOG_BLOCK_SIZE */
106         if (unlikely(blkszbits != LOG_BLOCK_SIZE)) {
107                 errln("blksize %u isn't supported on this platform",
108                         1 << blkszbits);
109                 goto out;
110         }
111
112         sbi->blocks = le32_to_cpu(layout->blocks);
113         sbi->meta_blkaddr = le32_to_cpu(layout->meta_blkaddr);
114 #ifdef CONFIG_EROFS_FS_XATTR
115         sbi->xattr_blkaddr = le32_to_cpu(layout->xattr_blkaddr);
116 #endif
117         sbi->islotbits = ffs(sizeof(struct erofs_inode_v1)) - 1;
118 #ifdef CONFIG_EROFS_FS_ZIP
119         /* TODO: clusterbits should be related to inode */
120         sbi->clusterbits = blkszbits;
121
122         if (1 << (sbi->clusterbits - PAGE_SHIFT) > Z_EROFS_CLUSTER_MAX_PAGES)
123                 errln("clusterbits %u is not supported on this kernel",
124                         sbi->clusterbits);
125 #endif
126
127         sbi->root_nid = le16_to_cpu(layout->root_nid);
128         sbi->inos = le64_to_cpu(layout->inos);
129
130         sbi->build_time = le64_to_cpu(layout->build_time);
131         sbi->build_time_nsec = le32_to_cpu(layout->build_time_nsec);
132
133         memcpy(&sb->s_uuid, layout->uuid, sizeof(layout->uuid));
134         memcpy(sbi->volume_name, layout->volume_name,
135                 sizeof(layout->volume_name));
136
137         ret = 0;
138 out:
139         brelse(bh);
140         return ret;
141 }
142
143 #ifdef CONFIG_EROFS_FAULT_INJECTION
144 char *erofs_fault_name[FAULT_MAX] = {
145         [FAULT_KMALLOC]         = "kmalloc",
146 };
147
148 static void __erofs_build_fault_attr(struct erofs_sb_info *sbi,
149                                      unsigned int rate)
150 {
151         struct erofs_fault_info *ffi = &sbi->fault_info;
152
153         if (rate) {
154                 atomic_set(&ffi->inject_ops, 0);
155                 ffi->inject_rate = rate;
156                 ffi->inject_type = (1 << FAULT_MAX) - 1;
157         } else {
158                 memset(ffi, 0, sizeof(struct erofs_fault_info));
159         }
160
161         set_opt(sbi, FAULT_INJECTION);
162 }
163
164 static int erofs_build_fault_attr(struct erofs_sb_info *sbi,
165                                   substring_t *args)
166 {
167         int rate = 0;
168
169         if (args->from && match_int(args, &rate))
170                 return -EINVAL;
171
172         __erofs_build_fault_attr(sbi, rate);
173         return 0;
174 }
175
176 static unsigned int erofs_get_fault_rate(struct erofs_sb_info *sbi)
177 {
178         return sbi->fault_info.inject_rate;
179 }
180 #else
181 static void __erofs_build_fault_attr(struct erofs_sb_info *sbi,
182                                      unsigned int rate)
183 {
184 }
185
186 static int erofs_build_fault_attr(struct erofs_sb_info *sbi,
187                                   substring_t *args)
188 {
189         infoln("fault_injection options not supported");
190         return 0;
191 }
192
193 static unsigned int erofs_get_fault_rate(struct erofs_sb_info *sbi)
194 {
195         return 0;
196 }
197 #endif
198
199 static void default_options(struct erofs_sb_info *sbi)
200 {
201         /* set up some FS parameters */
202 #ifdef CONFIG_EROFS_FS_ZIP
203         sbi->max_sync_decompress_pages = DEFAULT_MAX_SYNC_DECOMPRESS_PAGES;
204 #endif
205
206 #ifdef CONFIG_EROFS_FS_XATTR
207         set_opt(sbi, XATTR_USER);
208 #endif
209
210 #ifdef CONFIG_EROFS_FS_POSIX_ACL
211         set_opt(sbi, POSIX_ACL);
212 #endif
213 }
214
215 enum {
216         Opt_user_xattr,
217         Opt_nouser_xattr,
218         Opt_acl,
219         Opt_noacl,
220         Opt_fault_injection,
221         Opt_err
222 };
223
224 static match_table_t erofs_tokens = {
225         {Opt_user_xattr, "user_xattr"},
226         {Opt_nouser_xattr, "nouser_xattr"},
227         {Opt_acl, "acl"},
228         {Opt_noacl, "noacl"},
229         {Opt_fault_injection, "fault_injection=%u"},
230         {Opt_err, NULL}
231 };
232
233 static int parse_options(struct super_block *sb, char *options)
234 {
235         substring_t args[MAX_OPT_ARGS];
236         char *p;
237         int err;
238
239         if (!options)
240                 return 0;
241
242         while ((p = strsep(&options, ",")) != NULL) {
243                 int token;
244
245                 if (!*p)
246                         continue;
247
248                 args[0].to = args[0].from = NULL;
249                 token = match_token(p, erofs_tokens, args);
250
251                 switch (token) {
252 #ifdef CONFIG_EROFS_FS_XATTR
253                 case Opt_user_xattr:
254                         set_opt(EROFS_SB(sb), XATTR_USER);
255                         break;
256                 case Opt_nouser_xattr:
257                         clear_opt(EROFS_SB(sb), XATTR_USER);
258                         break;
259 #else
260                 case Opt_user_xattr:
261                         infoln("user_xattr options not supported");
262                         break;
263                 case Opt_nouser_xattr:
264                         infoln("nouser_xattr options not supported");
265                         break;
266 #endif
267 #ifdef CONFIG_EROFS_FS_POSIX_ACL
268                 case Opt_acl:
269                         set_opt(EROFS_SB(sb), POSIX_ACL);
270                         break;
271                 case Opt_noacl:
272                         clear_opt(EROFS_SB(sb), POSIX_ACL);
273                         break;
274 #else
275                 case Opt_acl:
276                         infoln("acl options not supported");
277                         break;
278                 case Opt_noacl:
279                         infoln("noacl options not supported");
280                         break;
281 #endif
282                 case Opt_fault_injection:
283                         err = erofs_build_fault_attr(EROFS_SB(sb), args);
284                         if (err)
285                                 return err;
286                         break;
287
288                 default:
289                         errln("Unrecognized mount option \"%s\" "
290                                         "or missing value", p);
291                         return -EINVAL;
292                 }
293         }
294         return 0;
295 }
296
297 #ifdef EROFS_FS_HAS_MANAGED_CACHE
298
299 static const struct address_space_operations managed_cache_aops;
300
301 static int managed_cache_releasepage(struct page *page, gfp_t gfp_mask)
302 {
303         int ret = 1;    /* 0 - busy */
304         struct address_space *const mapping = page->mapping;
305
306         DBG_BUGON(!PageLocked(page));
307         DBG_BUGON(mapping->a_ops != &managed_cache_aops);
308
309         if (PagePrivate(page))
310                 ret = erofs_try_to_free_cached_page(mapping, page);
311
312         return ret;
313 }
314
315 static void managed_cache_invalidatepage(struct page *page,
316         unsigned int offset, unsigned int length)
317 {
318         const unsigned int stop = length + offset;
319
320         DBG_BUGON(!PageLocked(page));
321
322         /* Check for potential overflow in debug mode */
323         DBG_BUGON(stop > PAGE_SIZE || stop < length);
324
325         if (offset == 0 && stop == PAGE_SIZE)
326                 while (!managed_cache_releasepage(page, GFP_NOFS))
327                         cond_resched();
328 }
329
330 static const struct address_space_operations managed_cache_aops = {
331         .releasepage = managed_cache_releasepage,
332         .invalidatepage = managed_cache_invalidatepage,
333 };
334
335 static struct inode *erofs_init_managed_cache(struct super_block *sb)
336 {
337         struct inode *inode = new_inode(sb);
338
339         if (unlikely(inode == NULL))
340                 return ERR_PTR(-ENOMEM);
341
342         set_nlink(inode, 1);
343         inode->i_size = OFFSET_MAX;
344
345         inode->i_mapping->a_ops = &managed_cache_aops;
346         mapping_set_gfp_mask(inode->i_mapping,
347                              GFP_NOFS | __GFP_HIGHMEM |
348                              __GFP_MOVABLE |  __GFP_NOFAIL);
349         return inode;
350 }
351
352 #endif
353
354 static int erofs_read_super(struct super_block *sb,
355         const char *dev_name, void *data, int silent)
356 {
357         struct inode *inode;
358         struct erofs_sb_info *sbi;
359         int err = -EINVAL;
360
361         infoln("read_super, device -> %s", dev_name);
362         infoln("options -> %s", (char *)data);
363
364         if (unlikely(!sb_set_blocksize(sb, EROFS_BLKSIZ))) {
365                 errln("failed to set erofs blksize");
366                 goto err;
367         }
368
369         sbi = kzalloc(sizeof(struct erofs_sb_info), GFP_KERNEL);
370         if (unlikely(sbi == NULL)) {
371                 err = -ENOMEM;
372                 goto err;
373         }
374         sb->s_fs_info = sbi;
375
376         err = superblock_read(sb);
377         if (err)
378                 goto err_sbread;
379
380         sb->s_magic = EROFS_SUPER_MAGIC;
381         sb->s_flags |= SB_RDONLY | SB_NOATIME;
382         sb->s_maxbytes = MAX_LFS_FILESIZE;
383         sb->s_time_gran = 1;
384
385         sb->s_op = &erofs_sops;
386
387 #ifdef CONFIG_EROFS_FS_XATTR
388         sb->s_xattr = erofs_xattr_handlers;
389 #endif
390
391         /* set erofs default mount options */
392         default_options(sbi);
393
394         err = parse_options(sb, data);
395         if (err)
396                 goto err_parseopt;
397
398         if (!silent)
399                 infoln("root inode @ nid %llu", ROOT_NID(sbi));
400
401         if (test_opt(sbi, POSIX_ACL))
402                 sb->s_flags |= SB_POSIXACL;
403         else
404                 sb->s_flags &= ~SB_POSIXACL;
405
406 #ifdef CONFIG_EROFS_FS_ZIP
407         INIT_RADIX_TREE(&sbi->workstn_tree, GFP_ATOMIC);
408 #endif
409
410 #ifdef EROFS_FS_HAS_MANAGED_CACHE
411         sbi->managed_cache = erofs_init_managed_cache(sb);
412         if (IS_ERR(sbi->managed_cache)) {
413                 err = PTR_ERR(sbi->managed_cache);
414                 goto err_init_managed_cache;
415         }
416 #endif
417
418         /* get the root inode */
419         inode = erofs_iget(sb, ROOT_NID(sbi), true);
420         if (IS_ERR(inode)) {
421                 err = PTR_ERR(inode);
422                 goto err_iget;
423         }
424
425         if (!S_ISDIR(inode->i_mode)) {
426                 errln("rootino(nid %llu) is not a directory(i_mode %o)",
427                         ROOT_NID(sbi), inode->i_mode);
428                 err = -EINVAL;
429                 iput(inode);
430                 goto err_iget;
431         }
432
433         sb->s_root = d_make_root(inode);
434         if (sb->s_root == NULL) {
435                 err = -ENOMEM;
436                 goto err_iget;
437         }
438
439         /* save the device name to sbi */
440         sbi->dev_name = __getname();
441         if (sbi->dev_name == NULL) {
442                 err = -ENOMEM;
443                 goto err_devname;
444         }
445
446         snprintf(sbi->dev_name, PATH_MAX, "%s", dev_name);
447         sbi->dev_name[PATH_MAX - 1] = '\0';
448
449         erofs_register_super(sb);
450
451         if (!silent)
452                 infoln("mounted on %s with opts: %s.", dev_name,
453                         (char *)data);
454         return 0;
455         /*
456          * please add a label for each exit point and use
457          * the following name convention, thus new features
458          * can be integrated easily without renaming labels.
459          */
460 err_devname:
461         dput(sb->s_root);
462 err_iget:
463 #ifdef EROFS_FS_HAS_MANAGED_CACHE
464         iput(sbi->managed_cache);
465 err_init_managed_cache:
466 #endif
467 err_parseopt:
468 err_sbread:
469         sb->s_fs_info = NULL;
470         kfree(sbi);
471 err:
472         return err;
473 }
474
475 /*
476  * could be triggered after deactivate_locked_super()
477  * is called, thus including umount and failed to initialize.
478  */
479 static void erofs_put_super(struct super_block *sb)
480 {
481         struct erofs_sb_info *sbi = EROFS_SB(sb);
482
483         /* for cases which are failed in "read_super" */
484         if (sbi == NULL)
485                 return;
486
487         WARN_ON(sb->s_magic != EROFS_SUPER_MAGIC);
488
489         infoln("unmounted for %s", sbi->dev_name);
490         __putname(sbi->dev_name);
491
492 #ifdef EROFS_FS_HAS_MANAGED_CACHE
493         iput(sbi->managed_cache);
494 #endif
495
496         mutex_lock(&sbi->umount_mutex);
497
498 #ifdef CONFIG_EROFS_FS_ZIP
499         /* clean up the compression space of this sb */
500         erofs_shrink_workstation(EROFS_SB(sb), ~0UL, true);
501 #endif
502
503         erofs_unregister_super(sb);
504         mutex_unlock(&sbi->umount_mutex);
505
506         kfree(sbi);
507         sb->s_fs_info = NULL;
508 }
509
510
511 struct erofs_mount_private {
512         const char *dev_name;
513         char *options;
514 };
515
516 /* support mount_bdev() with options */
517 static int erofs_fill_super(struct super_block *sb,
518         void *_priv, int silent)
519 {
520         struct erofs_mount_private *priv = _priv;
521
522         return erofs_read_super(sb, priv->dev_name,
523                 priv->options, silent);
524 }
525
526 static struct dentry *erofs_mount(
527         struct file_system_type *fs_type, int flags,
528         const char *dev_name, void *data)
529 {
530         struct erofs_mount_private priv = {
531                 .dev_name = dev_name,
532                 .options = data
533         };
534
535         return mount_bdev(fs_type, flags, dev_name,
536                 &priv, erofs_fill_super);
537 }
538
539 static void erofs_kill_sb(struct super_block *sb)
540 {
541         kill_block_super(sb);
542 }
543
544 static struct file_system_type erofs_fs_type = {
545         .owner          = THIS_MODULE,
546         .name           = "erofs",
547         .mount          = erofs_mount,
548         .kill_sb        = erofs_kill_sb,
549         .fs_flags       = FS_REQUIRES_DEV,
550 };
551 MODULE_ALIAS_FS("erofs");
552
553 static int __init erofs_module_init(void)
554 {
555         int err;
556
557         erofs_check_ondisk_layout_definitions();
558         infoln("initializing erofs " EROFS_VERSION);
559
560         err = erofs_init_inode_cache();
561         if (err)
562                 goto icache_err;
563
564         err = register_shrinker(&erofs_shrinker_info);
565         if (err)
566                 goto shrinker_err;
567
568         err = z_erofs_init_zip_subsystem();
569         if (err)
570                 goto zip_err;
571
572         err = register_filesystem(&erofs_fs_type);
573         if (err)
574                 goto fs_err;
575
576         infoln("successfully to initialize erofs");
577         return 0;
578
579 fs_err:
580         z_erofs_exit_zip_subsystem();
581 zip_err:
582         unregister_shrinker(&erofs_shrinker_info);
583 shrinker_err:
584         erofs_exit_inode_cache();
585 icache_err:
586         return err;
587 }
588
589 static void __exit erofs_module_exit(void)
590 {
591         unregister_filesystem(&erofs_fs_type);
592         z_erofs_exit_zip_subsystem();
593         unregister_shrinker(&erofs_shrinker_info);
594         erofs_exit_inode_cache();
595         infoln("successfully finalize erofs");
596 }
597
598 /* get filesystem statistics */
599 static int erofs_statfs(struct dentry *dentry, struct kstatfs *buf)
600 {
601         struct super_block *sb = dentry->d_sb;
602         struct erofs_sb_info *sbi = EROFS_SB(sb);
603         u64 id = huge_encode_dev(sb->s_bdev->bd_dev);
604
605         buf->f_type = sb->s_magic;
606         buf->f_bsize = EROFS_BLKSIZ;
607         buf->f_blocks = sbi->blocks;
608         buf->f_bfree = buf->f_bavail = 0;
609
610         buf->f_files = ULLONG_MAX;
611         buf->f_ffree = ULLONG_MAX - sbi->inos;
612
613         buf->f_namelen = EROFS_NAME_LEN;
614
615         buf->f_fsid.val[0] = (u32)id;
616         buf->f_fsid.val[1] = (u32)(id >> 32);
617         return 0;
618 }
619
620 static int erofs_show_options(struct seq_file *seq, struct dentry *root)
621 {
622         struct erofs_sb_info *sbi __maybe_unused = EROFS_SB(root->d_sb);
623
624 #ifdef CONFIG_EROFS_FS_XATTR
625         if (test_opt(sbi, XATTR_USER))
626                 seq_puts(seq, ",user_xattr");
627         else
628                 seq_puts(seq, ",nouser_xattr");
629 #endif
630 #ifdef CONFIG_EROFS_FS_POSIX_ACL
631         if (test_opt(sbi, POSIX_ACL))
632                 seq_puts(seq, ",acl");
633         else
634                 seq_puts(seq, ",noacl");
635 #endif
636         if (test_opt(sbi, FAULT_INJECTION))
637                 seq_printf(seq, ",fault_injection=%u",
638                         erofs_get_fault_rate(sbi));
639         return 0;
640 }
641
642 static int erofs_remount(struct super_block *sb, int *flags, char *data)
643 {
644         struct erofs_sb_info *sbi = EROFS_SB(sb);
645         unsigned int org_mnt_opt = sbi->mount_opt;
646         unsigned int org_inject_rate = erofs_get_fault_rate(sbi);
647         int err;
648
649         DBG_BUGON(!sb_rdonly(sb));
650         err = parse_options(sb, data);
651         if (err)
652                 goto out;
653
654         if (test_opt(sbi, POSIX_ACL))
655                 sb->s_flags |= SB_POSIXACL;
656         else
657                 sb->s_flags &= ~SB_POSIXACL;
658
659         *flags |= SB_RDONLY;
660         return 0;
661 out:
662         __erofs_build_fault_attr(sbi, org_inject_rate);
663         sbi->mount_opt = org_mnt_opt;
664
665         return err;
666 }
667
668 const struct super_operations erofs_sops = {
669         .put_super = erofs_put_super,
670         .alloc_inode = alloc_inode,
671         .destroy_inode = destroy_inode,
672         .statfs = erofs_statfs,
673         .show_options = erofs_show_options,
674         .remount_fs = erofs_remount,
675 };
676
677 module_init(erofs_module_init);
678 module_exit(erofs_module_exit);
679
680 MODULE_DESCRIPTION("Enhanced ROM File System");
681 MODULE_AUTHOR("Gao Xiang, Yu Chao, Miao Xie, CONSUMER BG, HUAWEI Inc.");
682 MODULE_LICENSE("GPL");
683