Linux kernel mirror (for testing)
git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git
tjh.dev
kernel
os
linux
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#ifndef __EROFS_INTERNAL_H
8#define __EROFS_INTERNAL_H
9
10#include <linux/fs.h>
11#include <linux/dcache.h>
12#include <linux/mm.h>
13#include <linux/pagemap.h>
14#include <linux/bio.h>
15#include <linux/magic.h>
16#include <linux/slab.h>
17#include <linux/vmalloc.h>
18#include <linux/iomap.h>
19#include "erofs_fs.h"
20
21/* redefine pr_fmt "erofs: " */
22#undef pr_fmt
23#define pr_fmt(fmt) "erofs: " fmt
24
25__printf(3, 4) void _erofs_err(struct super_block *sb,
26 const char *function, const char *fmt, ...);
27#define erofs_err(sb, fmt, ...) \
28 _erofs_err(sb, __func__, fmt "\n", ##__VA_ARGS__)
29__printf(3, 4) void _erofs_info(struct super_block *sb,
30 const char *function, const char *fmt, ...);
31#define erofs_info(sb, fmt, ...) \
32 _erofs_info(sb, __func__, fmt "\n", ##__VA_ARGS__)
33#ifdef CONFIG_EROFS_FS_DEBUG
34#define DBG_BUGON BUG_ON
35#else
36#define DBG_BUGON(x) ((void)(x))
37#endif /* !CONFIG_EROFS_FS_DEBUG */
38
39/* EROFS_SUPER_MAGIC_V1 to represent the whole file system */
40#define EROFS_SUPER_MAGIC EROFS_SUPER_MAGIC_V1
41
42typedef u64 erofs_nid_t;
43typedef u64 erofs_off_t;
44/* data type for filesystem-wide blocks number */
45typedef u32 erofs_blk_t;
46
47struct erofs_device_info {
48 char *path;
49 struct erofs_fscache *fscache;
50 struct block_device *bdev;
51 struct dax_device *dax_dev;
52 u64 dax_part_off;
53
54 u32 blocks;
55 u32 mapped_blkaddr;
56};
57
58enum {
59 EROFS_SYNC_DECOMPRESS_AUTO,
60 EROFS_SYNC_DECOMPRESS_FORCE_ON,
61 EROFS_SYNC_DECOMPRESS_FORCE_OFF
62};
63
64struct erofs_mount_opts {
65#ifdef CONFIG_EROFS_FS_ZIP
66 /* current strategy of how to use managed cache */
67 unsigned char cache_strategy;
68 /* strategy of sync decompression (0 - auto, 1 - force on, 2 - force off) */
69 unsigned int sync_decompress;
70
71 /* threshold for decompression synchronously */
72 unsigned int max_sync_decompress_pages;
73#endif
74 unsigned int mount_opt;
75};
76
77struct erofs_dev_context {
78 struct idr tree;
79 struct rw_semaphore rwsem;
80
81 unsigned int extra_devices;
82 bool flatdev;
83};
84
85struct erofs_fs_context {
86 struct erofs_mount_opts opt;
87 struct erofs_dev_context *devs;
88 char *fsid;
89 char *domain_id;
90};
91
92/* all filesystem-wide lz4 configurations */
93struct erofs_sb_lz4_info {
94 /* # of pages needed for EROFS lz4 rolling decompression */
95 u16 max_distance_pages;
96 /* maximum possible blocks for pclusters in the filesystem */
97 u16 max_pclusterblks;
98};
99
100struct erofs_domain {
101 refcount_t ref;
102 struct list_head list;
103 struct fscache_volume *volume;
104 char *domain_id;
105};
106
107struct erofs_fscache {
108 struct fscache_cookie *cookie;
109 struct inode *inode; /* anonymous inode for the blob */
110
111 /* used for share domain mode */
112 struct erofs_domain *domain;
113 struct list_head node;
114 refcount_t ref;
115 char *name;
116};
117
118struct erofs_xattr_prefix_item {
119 struct erofs_xattr_long_prefix *prefix;
120 u8 infix_len;
121};
122
123struct erofs_sb_info {
124 struct erofs_mount_opts opt; /* options */
125#ifdef CONFIG_EROFS_FS_ZIP
126 /* list for all registered superblocks, mainly for shrinker */
127 struct list_head list;
128 struct mutex umount_mutex;
129
130 /* managed XArray arranged in physical block number */
131 struct xarray managed_pslots;
132
133 unsigned int shrinker_run_no;
134 u16 available_compr_algs;
135
136 /* pseudo inode to manage cached pages */
137 struct inode *managed_cache;
138
139 struct erofs_sb_lz4_info lz4;
140#endif /* CONFIG_EROFS_FS_ZIP */
141 struct inode *packed_inode;
142 struct erofs_dev_context *devs;
143 struct dax_device *dax_dev;
144 u64 dax_part_off;
145 u64 total_blocks;
146 u32 primarydevice_blocks;
147
148 u32 meta_blkaddr;
149#ifdef CONFIG_EROFS_FS_XATTR
150 u32 xattr_blkaddr;
151 u32 xattr_prefix_start;
152 u8 xattr_prefix_count;
153 struct erofs_xattr_prefix_item *xattr_prefixes;
154#endif
155 u16 device_id_mask; /* valid bits of device id to be used */
156
157 unsigned char islotbits; /* inode slot unit size in bit shift */
158 unsigned char blkszbits; /* filesystem block size in bit shift */
159
160 u32 sb_size; /* total superblock size */
161 u32 build_time_nsec;
162 u64 build_time;
163
164 /* what we really care is nid, rather than ino.. */
165 erofs_nid_t root_nid;
166 erofs_nid_t packed_nid;
167 /* used for statfs, f_files - f_favail */
168 u64 inos;
169
170 u8 uuid[16]; /* 128-bit uuid for volume */
171 u8 volume_name[16]; /* volume name */
172 u32 feature_compat;
173 u32 feature_incompat;
174
175 /* sysfs support */
176 struct kobject s_kobj; /* /sys/fs/erofs/<devname> */
177 struct completion s_kobj_unregister;
178
179 /* fscache support */
180 struct fscache_volume *volume;
181 struct erofs_fscache *s_fscache;
182 struct erofs_domain *domain;
183 char *fsid;
184 char *domain_id;
185};
186
187#define EROFS_SB(sb) ((struct erofs_sb_info *)(sb)->s_fs_info)
188#define EROFS_I_SB(inode) ((struct erofs_sb_info *)(inode)->i_sb->s_fs_info)
189
190/* Mount flags set via mount options or defaults */
191#define EROFS_MOUNT_XATTR_USER 0x00000010
192#define EROFS_MOUNT_POSIX_ACL 0x00000020
193#define EROFS_MOUNT_DAX_ALWAYS 0x00000040
194#define EROFS_MOUNT_DAX_NEVER 0x00000080
195
196#define clear_opt(opt, option) ((opt)->mount_opt &= ~EROFS_MOUNT_##option)
197#define set_opt(opt, option) ((opt)->mount_opt |= EROFS_MOUNT_##option)
198#define test_opt(opt, option) ((opt)->mount_opt & EROFS_MOUNT_##option)
199
200static inline bool erofs_is_fscache_mode(struct super_block *sb)
201{
202 return IS_ENABLED(CONFIG_EROFS_FS_ONDEMAND) && !sb->s_bdev;
203}
204
205enum {
206 EROFS_ZIP_CACHE_DISABLED,
207 EROFS_ZIP_CACHE_READAHEAD,
208 EROFS_ZIP_CACHE_READAROUND
209};
210
211#define EROFS_LOCKED_MAGIC (INT_MIN | 0xE0F510CCL)
212
213/* basic unit of the workstation of a super_block */
214struct erofs_workgroup {
215 /* the workgroup index in the workstation */
216 pgoff_t index;
217
218 /* overall workgroup reference count */
219 atomic_t refcount;
220};
221
222static inline bool erofs_workgroup_try_to_freeze(struct erofs_workgroup *grp,
223 int val)
224{
225 preempt_disable();
226 if (val != atomic_cmpxchg(&grp->refcount, val, EROFS_LOCKED_MAGIC)) {
227 preempt_enable();
228 return false;
229 }
230 return true;
231}
232
233static inline void erofs_workgroup_unfreeze(struct erofs_workgroup *grp,
234 int orig_val)
235{
236 /*
237 * other observers should notice all modifications
238 * in the freezing period.
239 */
240 smp_mb();
241 atomic_set(&grp->refcount, orig_val);
242 preempt_enable();
243}
244
245static inline int erofs_wait_on_workgroup_freezed(struct erofs_workgroup *grp)
246{
247 return atomic_cond_read_relaxed(&grp->refcount,
248 VAL != EROFS_LOCKED_MAGIC);
249}
250
251enum erofs_kmap_type {
252 EROFS_NO_KMAP, /* don't map the buffer */
253 EROFS_KMAP, /* use kmap_local_page() to map the buffer */
254};
255
256struct erofs_buf {
257 struct inode *inode;
258 struct page *page;
259 void *base;
260 enum erofs_kmap_type kmap_type;
261};
262#define __EROFS_BUF_INITIALIZER ((struct erofs_buf){ .page = NULL })
263
264#define ROOT_NID(sb) ((sb)->root_nid)
265
266#define erofs_blknr(sb, addr) ((addr) >> (sb)->s_blocksize_bits)
267#define erofs_blkoff(sb, addr) ((addr) & ((sb)->s_blocksize - 1))
268#define erofs_pos(sb, blk) ((erofs_off_t)(blk) << (sb)->s_blocksize_bits)
269#define erofs_iblks(i) (round_up((i)->i_size, i_blocksize(i)) >> (i)->i_blkbits)
270
271#define EROFS_FEATURE_FUNCS(name, compat, feature) \
272static inline bool erofs_sb_has_##name(struct erofs_sb_info *sbi) \
273{ \
274 return sbi->feature_##compat & EROFS_FEATURE_##feature; \
275}
276
277EROFS_FEATURE_FUNCS(zero_padding, incompat, INCOMPAT_ZERO_PADDING)
278EROFS_FEATURE_FUNCS(compr_cfgs, incompat, INCOMPAT_COMPR_CFGS)
279EROFS_FEATURE_FUNCS(big_pcluster, incompat, INCOMPAT_BIG_PCLUSTER)
280EROFS_FEATURE_FUNCS(chunked_file, incompat, INCOMPAT_CHUNKED_FILE)
281EROFS_FEATURE_FUNCS(device_table, incompat, INCOMPAT_DEVICE_TABLE)
282EROFS_FEATURE_FUNCS(compr_head2, incompat, INCOMPAT_COMPR_HEAD2)
283EROFS_FEATURE_FUNCS(ztailpacking, incompat, INCOMPAT_ZTAILPACKING)
284EROFS_FEATURE_FUNCS(fragments, incompat, INCOMPAT_FRAGMENTS)
285EROFS_FEATURE_FUNCS(dedupe, incompat, INCOMPAT_DEDUPE)
286EROFS_FEATURE_FUNCS(xattr_prefixes, incompat, INCOMPAT_XATTR_PREFIXES)
287EROFS_FEATURE_FUNCS(sb_chksum, compat, COMPAT_SB_CHKSUM)
288
289/* atomic flag definitions */
290#define EROFS_I_EA_INITED_BIT 0
291#define EROFS_I_Z_INITED_BIT 1
292
293/* bitlock definitions (arranged in reverse order) */
294#define EROFS_I_BL_XATTR_BIT (BITS_PER_LONG - 1)
295#define EROFS_I_BL_Z_BIT (BITS_PER_LONG - 2)
296
297struct erofs_inode {
298 erofs_nid_t nid;
299
300 /* atomic flags (including bitlocks) */
301 unsigned long flags;
302
303 unsigned char datalayout;
304 unsigned char inode_isize;
305 unsigned int xattr_isize;
306
307 unsigned int xattr_shared_count;
308 unsigned int *xattr_shared_xattrs;
309
310 union {
311 erofs_blk_t raw_blkaddr;
312 struct {
313 unsigned short chunkformat;
314 unsigned char chunkbits;
315 };
316#ifdef CONFIG_EROFS_FS_ZIP
317 struct {
318 unsigned short z_advise;
319 unsigned char z_algorithmtype[2];
320 unsigned char z_logical_clusterbits;
321 unsigned long z_tailextent_headlcn;
322 union {
323 struct {
324 erofs_off_t z_idataoff;
325 unsigned short z_idata_size;
326 };
327 erofs_off_t z_fragmentoff;
328 };
329 };
330#endif /* CONFIG_EROFS_FS_ZIP */
331 };
332 /* the corresponding vfs inode */
333 struct inode vfs_inode;
334};
335
336#define EROFS_I(ptr) container_of(ptr, struct erofs_inode, vfs_inode)
337
338static inline erofs_off_t erofs_iloc(struct inode *inode)
339{
340 struct erofs_sb_info *sbi = EROFS_I_SB(inode);
341
342 return erofs_pos(inode->i_sb, sbi->meta_blkaddr) +
343 (EROFS_I(inode)->nid << sbi->islotbits);
344}
345
346static inline unsigned int erofs_inode_version(unsigned int ifmt)
347{
348 return (ifmt >> EROFS_I_VERSION_BIT) & EROFS_I_VERSION_MASK;
349}
350
351static inline unsigned int erofs_inode_datalayout(unsigned int ifmt)
352{
353 return (ifmt >> EROFS_I_DATALAYOUT_BIT) & EROFS_I_DATALAYOUT_MASK;
354}
355
356/*
357 * Different from grab_cache_page_nowait(), reclaiming is never triggered
358 * when allocating new pages.
359 */
360static inline
361struct page *erofs_grab_cache_page_nowait(struct address_space *mapping,
362 pgoff_t index)
363{
364 return pagecache_get_page(mapping, index,
365 FGP_LOCK|FGP_CREAT|FGP_NOFS|FGP_NOWAIT,
366 readahead_gfp_mask(mapping) & ~__GFP_RECLAIM);
367}
368
369/* Has a disk mapping */
370#define EROFS_MAP_MAPPED 0x0001
371/* Located in metadata (could be copied from bd_inode) */
372#define EROFS_MAP_META 0x0002
373/* The extent is encoded */
374#define EROFS_MAP_ENCODED 0x0004
375/* The length of extent is full */
376#define EROFS_MAP_FULL_MAPPED 0x0008
377/* Located in the special packed inode */
378#define EROFS_MAP_FRAGMENT 0x0010
379/* The extent refers to partial decompressed data */
380#define EROFS_MAP_PARTIAL_REF 0x0020
381
382struct erofs_map_blocks {
383 struct erofs_buf buf;
384
385 erofs_off_t m_pa, m_la;
386 u64 m_plen, m_llen;
387
388 unsigned short m_deviceid;
389 char m_algorithmformat;
390 unsigned int m_flags;
391};
392
393/*
394 * Used to get the exact decompressed length, e.g. fiemap (consider lookback
395 * approach instead if possible since it's more metadata lightweight.)
396 */
397#define EROFS_GET_BLOCKS_FIEMAP 0x0001
398/* Used to map the whole extent if non-negligible data is requested for LZMA */
399#define EROFS_GET_BLOCKS_READMORE 0x0002
400/* Used to map tail extent for tailpacking inline or fragment pcluster */
401#define EROFS_GET_BLOCKS_FINDTAIL 0x0004
402
403enum {
404 Z_EROFS_COMPRESSION_SHIFTED = Z_EROFS_COMPRESSION_MAX,
405 Z_EROFS_COMPRESSION_INTERLACED,
406 Z_EROFS_COMPRESSION_RUNTIME_MAX
407};
408
409struct erofs_map_dev {
410 struct erofs_fscache *m_fscache;
411 struct block_device *m_bdev;
412 struct dax_device *m_daxdev;
413 u64 m_dax_part_off;
414
415 erofs_off_t m_pa;
416 unsigned int m_deviceid;
417};
418
419extern struct file_system_type erofs_fs_type;
420extern const struct super_operations erofs_sops;
421
422extern const struct address_space_operations erofs_raw_access_aops;
423extern const struct address_space_operations z_erofs_aops;
424extern const struct address_space_operations erofs_fscache_access_aops;
425
426extern const struct inode_operations erofs_generic_iops;
427extern const struct inode_operations erofs_symlink_iops;
428extern const struct inode_operations erofs_fast_symlink_iops;
429extern const struct inode_operations erofs_dir_iops;
430
431extern const struct file_operations erofs_file_fops;
432extern const struct file_operations erofs_dir_fops;
433
434extern const struct iomap_ops z_erofs_iomap_report_ops;
435
436/* flags for erofs_fscache_register_cookie() */
437#define EROFS_REG_COOKIE_SHARE 0x0001
438#define EROFS_REG_COOKIE_NEED_NOEXIST 0x0002
439
440void *erofs_read_metadata(struct super_block *sb, struct erofs_buf *buf,
441 erofs_off_t *offset, int *lengthp);
442void erofs_unmap_metabuf(struct erofs_buf *buf);
443void erofs_put_metabuf(struct erofs_buf *buf);
444void *erofs_bread(struct erofs_buf *buf, erofs_blk_t blkaddr,
445 enum erofs_kmap_type type);
446void erofs_init_metabuf(struct erofs_buf *buf, struct super_block *sb);
447void *erofs_read_metabuf(struct erofs_buf *buf, struct super_block *sb,
448 erofs_blk_t blkaddr, enum erofs_kmap_type type);
449int erofs_map_dev(struct super_block *sb, struct erofs_map_dev *dev);
450int erofs_fiemap(struct inode *inode, struct fiemap_extent_info *fieinfo,
451 u64 start, u64 len);
452int erofs_map_blocks(struct inode *inode, struct erofs_map_blocks *map);
453struct inode *erofs_iget(struct super_block *sb, erofs_nid_t nid);
454int erofs_getattr(struct mnt_idmap *idmap, const struct path *path,
455 struct kstat *stat, u32 request_mask,
456 unsigned int query_flags);
457int erofs_namei(struct inode *dir, const struct qstr *name,
458 erofs_nid_t *nid, unsigned int *d_type);
459
460static inline void *erofs_vm_map_ram(struct page **pages, unsigned int count)
461{
462 int retried = 0;
463
464 while (1) {
465 void *p = vm_map_ram(pages, count, -1);
466
467 /* retry two more times (totally 3 times) */
468 if (p || ++retried >= 3)
469 return p;
470 vm_unmap_aliases();
471 }
472 return NULL;
473}
474
475int erofs_register_sysfs(struct super_block *sb);
476void erofs_unregister_sysfs(struct super_block *sb);
477int __init erofs_init_sysfs(void);
478void erofs_exit_sysfs(void);
479
480struct page *erofs_allocpage(struct page **pagepool, gfp_t gfp);
481static inline void erofs_pagepool_add(struct page **pagepool, struct page *page)
482{
483 set_page_private(page, (unsigned long)*pagepool);
484 *pagepool = page;
485}
486void erofs_release_pages(struct page **pagepool);
487
488#ifdef CONFIG_EROFS_FS_ZIP
489int erofs_workgroup_put(struct erofs_workgroup *grp);
490struct erofs_workgroup *erofs_find_workgroup(struct super_block *sb,
491 pgoff_t index);
492struct erofs_workgroup *erofs_insert_workgroup(struct super_block *sb,
493 struct erofs_workgroup *grp);
494void erofs_workgroup_free_rcu(struct erofs_workgroup *grp);
495void erofs_shrinker_register(struct super_block *sb);
496void erofs_shrinker_unregister(struct super_block *sb);
497int __init erofs_init_shrinker(void);
498void erofs_exit_shrinker(void);
499int __init z_erofs_init_zip_subsystem(void);
500void z_erofs_exit_zip_subsystem(void);
501int erofs_try_to_free_all_cached_pages(struct erofs_sb_info *sbi,
502 struct erofs_workgroup *egrp);
503int erofs_try_to_free_cached_page(struct page *page);
504int z_erofs_load_lz4_config(struct super_block *sb,
505 struct erofs_super_block *dsb,
506 struct z_erofs_lz4_cfgs *lz4, int len);
507int z_erofs_map_blocks_iter(struct inode *inode, struct erofs_map_blocks *map,
508 int flags);
509void *erofs_get_pcpubuf(unsigned int requiredpages);
510void erofs_put_pcpubuf(void *ptr);
511int erofs_pcpubuf_growsize(unsigned int nrpages);
512void __init erofs_pcpubuf_init(void);
513void erofs_pcpubuf_exit(void);
514#else
515static inline void erofs_shrinker_register(struct super_block *sb) {}
516static inline void erofs_shrinker_unregister(struct super_block *sb) {}
517static inline int erofs_init_shrinker(void) { return 0; }
518static inline void erofs_exit_shrinker(void) {}
519static inline int z_erofs_init_zip_subsystem(void) { return 0; }
520static inline void z_erofs_exit_zip_subsystem(void) {}
521static inline int z_erofs_load_lz4_config(struct super_block *sb,
522 struct erofs_super_block *dsb,
523 struct z_erofs_lz4_cfgs *lz4, int len)
524{
525 if (lz4 || dsb->u1.lz4_max_distance) {
526 erofs_err(sb, "lz4 algorithm isn't enabled");
527 return -EINVAL;
528 }
529 return 0;
530}
531static inline void erofs_pcpubuf_init(void) {}
532static inline void erofs_pcpubuf_exit(void) {}
533#endif /* !CONFIG_EROFS_FS_ZIP */
534
535#ifdef CONFIG_EROFS_FS_ZIP_LZMA
536int __init z_erofs_lzma_init(void);
537void z_erofs_lzma_exit(void);
538int z_erofs_load_lzma_config(struct super_block *sb,
539 struct erofs_super_block *dsb,
540 struct z_erofs_lzma_cfgs *lzma, int size);
541#else
542static inline int z_erofs_lzma_init(void) { return 0; }
543static inline int z_erofs_lzma_exit(void) { return 0; }
544static inline int z_erofs_load_lzma_config(struct super_block *sb,
545 struct erofs_super_block *dsb,
546 struct z_erofs_lzma_cfgs *lzma, int size) {
547 if (lzma) {
548 erofs_err(sb, "lzma algorithm isn't enabled");
549 return -EINVAL;
550 }
551 return 0;
552}
553#endif /* !CONFIG_EROFS_FS_ZIP_LZMA */
554
555#ifdef CONFIG_EROFS_FS_ONDEMAND
556int erofs_fscache_register_fs(struct super_block *sb);
557void erofs_fscache_unregister_fs(struct super_block *sb);
558
559struct erofs_fscache *erofs_fscache_register_cookie(struct super_block *sb,
560 char *name, unsigned int flags);
561void erofs_fscache_unregister_cookie(struct erofs_fscache *fscache);
562#else
563static inline int erofs_fscache_register_fs(struct super_block *sb)
564{
565 return -EOPNOTSUPP;
566}
567static inline void erofs_fscache_unregister_fs(struct super_block *sb) {}
568
569static inline
570struct erofs_fscache *erofs_fscache_register_cookie(struct super_block *sb,
571 char *name, unsigned int flags)
572{
573 return ERR_PTR(-EOPNOTSUPP);
574}
575
576static inline void erofs_fscache_unregister_cookie(struct erofs_fscache *fscache)
577{
578}
579#endif
580
581#define EFSCORRUPTED EUCLEAN /* Filesystem is corrupted */
582
583#endif /* __EROFS_INTERNAL_H */