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