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