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/dax.h>
12 #include <linux/dcache.h>
13 #include <linux/mm.h>
14 #include <linux/module.h>
15 #include <linux/pagemap.h>
16 #include <linux/bio.h>
17 #include <linux/magic.h>
18 #include <linux/slab.h>
19 #include <linux/vmalloc.h>
20 #include <linux/iomap.h>
21 #include "erofs_fs.h"
22
23 __printf(2, 3) void _erofs_printk(struct super_block *sb, const char *fmt, ...);
24 #define erofs_err(sb, fmt, ...) \
25 _erofs_printk(sb, KERN_ERR fmt "\n", ##__VA_ARGS__)
26 #define erofs_warn(sb, fmt, ...) \
27 _erofs_printk(sb, KERN_WARNING fmt "\n", ##__VA_ARGS__)
28 #define erofs_info(sb, fmt, ...) \
29 _erofs_printk(sb, KERN_INFO fmt "\n", ##__VA_ARGS__)
30
31 #ifdef CONFIG_EROFS_FS_DEBUG
32 #define DBG_BUGON BUG_ON
33 #else
34 #define DBG_BUGON(x) ((void)(x))
35 #endif /* !CONFIG_EROFS_FS_DEBUG */
36
37 /* EROFS_SUPER_MAGIC_V1 to represent the whole file system */
38 #define EROFS_SUPER_MAGIC EROFS_SUPER_MAGIC_V1
39
40 typedef u64 erofs_nid_t;
41 typedef u64 erofs_off_t;
42 typedef u64 erofs_blk_t;
43
44 struct erofs_device_info {
45 char *path;
46 struct file *file;
47 struct dax_device *dax_dev;
48 u64 fsoff, dax_part_off;
49
50 erofs_blk_t blocks;
51 erofs_blk_t uniaddr;
52 };
53
54 enum {
55 EROFS_SYNC_DECOMPRESS_AUTO,
56 EROFS_SYNC_DECOMPRESS_FORCE_ON,
57 EROFS_SYNC_DECOMPRESS_FORCE_OFF
58 };
59
60 struct erofs_mount_opts {
61 /* current strategy of how to use managed cache */
62 unsigned char cache_strategy;
63 unsigned int mount_opt;
64 };
65
66 struct erofs_dev_context {
67 struct idr tree;
68 struct rw_semaphore rwsem;
69
70 unsigned int extra_devices;
71 bool flatdev;
72 };
73
74 struct erofs_sb_lz4_info {
75 u16 max_pclusterblks; /* maximum physical blocks for LZ4 pclusters */
76 };
77
78 struct erofs_xattr_prefix_item {
79 struct erofs_xattr_long_prefix *prefix;
80 u8 infix_len;
81 };
82
83 struct erofs_sb_info {
84 struct erofs_device_info dif0;
85 struct erofs_mount_opts opt; /* options */
86 #ifdef CONFIG_EROFS_FS_ZIP
87 /* list for all registered superblocks, mainly for shrinker */
88 struct list_head list;
89 struct mutex umount_mutex;
90
91 /* managed XArray arranged in physical block number */
92 struct xarray managed_pslots;
93
94 unsigned int sync_decompress; /* strategy for sync decompression */
95 unsigned int shrinker_run_no;
96
97 struct erofs_sb_lz4_info lz4;
98 #endif /* CONFIG_EROFS_FS_ZIP */
99 struct inode *managed_cache; /* pseudo inode to cache physical data */
100 struct inode *packed_inode;
101 struct inode *metabox_inode;
102 struct erofs_dev_context *devs;
103 u64 total_blocks;
104
105 u32 meta_blkaddr;
106 #ifdef CONFIG_EROFS_FS_XATTR
107 u32 xattr_blkaddr;
108 u32 xattr_prefix_start;
109 u8 xattr_prefix_count;
110 u8 ishare_xattr_prefix_id;
111 struct erofs_xattr_prefix_item *xattr_prefixes;
112 unsigned int xattr_filter_reserved;
113 #endif
114 u16 device_id_mask; /* valid bits of device id to be used */
115
116 unsigned char islotbits; /* inode slot unit size in bit shift */
117 unsigned char blkszbits; /* filesystem block size in bit shift */
118
119 u32 sb_size; /* total superblock size */
120 u32 fixed_nsec;
121 s64 epoch;
122
123 /* what we really care is nid, rather than ino.. */
124 erofs_nid_t root_nid;
125 erofs_nid_t packed_nid;
126 erofs_nid_t metabox_nid;
127 /* used for statfs, f_files - f_favail */
128 u64 inos;
129
130 char *volume_name;
131 u32 feature_compat;
132 u32 feature_incompat;
133 u16 available_compr_algs;
134
135 /* sysfs support */
136 struct kobject s_kobj; /* /sys/fs/erofs/<devname> */
137 struct completion s_kobj_unregister;
138 erofs_off_t dir_ra_bytes;
139
140 char *domain_id;
141 };
142
143 #define EROFS_SB(sb) ((struct erofs_sb_info *)(sb)->s_fs_info)
144 #define EROFS_I_SB(inode) ((struct erofs_sb_info *)(inode)->i_sb->s_fs_info)
145
146 /* Mount flags set via mount options or defaults */
147 #define EROFS_MOUNT_XATTR_USER 0x00000010
148 #define EROFS_MOUNT_POSIX_ACL 0x00000020
149 #define EROFS_MOUNT_DAX_ALWAYS 0x00000040
150 #define EROFS_MOUNT_DAX_NEVER 0x00000080
151 #define EROFS_MOUNT_DIRECT_IO 0x00000100
152 #define EROFS_MOUNT_INODE_SHARE 0x00000200
153
154 #define clear_opt(opt, option) ((opt)->mount_opt &= ~EROFS_MOUNT_##option)
155 #define set_opt(opt, option) ((opt)->mount_opt |= EROFS_MOUNT_##option)
156 #define test_opt(opt, option) ((opt)->mount_opt & EROFS_MOUNT_##option)
157
erofs_is_fileio_mode(struct erofs_sb_info * sbi)158 static inline bool erofs_is_fileio_mode(struct erofs_sb_info *sbi)
159 {
160 return IS_ENABLED(CONFIG_EROFS_FS_BACKED_BY_FILE) && sbi->dif0.file;
161 }
162
163 extern struct file_system_type erofs_anon_fs_type;
164
165 enum {
166 EROFS_ZIP_CACHE_DISABLED,
167 EROFS_ZIP_CACHE_READAHEAD,
168 EROFS_ZIP_CACHE_READAROUND
169 };
170
171 struct erofs_buf {
172 struct address_space *mapping;
173 u64 off;
174 struct page *page;
175 void *base;
176 bool mc;
177 };
178 #define __EROFS_BUF_INITIALIZER ((struct erofs_buf){ .page = NULL })
179
180 #define erofs_blknr(sb, pos) ((erofs_blk_t)((pos) >> (sb)->s_blocksize_bits))
181 #define erofs_blkoff(sb, pos) ((pos) & ((sb)->s_blocksize - 1))
182 #define erofs_pos(sb, blk) ((erofs_off_t)(blk) << (sb)->s_blocksize_bits)
183 #define erofs_iblks(i) (round_up((i)->i_size, i_blocksize(i)) >> (i)->i_blkbits)
184
185 #define EROFS_FEATURE_FUNCS(name, compat, feature) \
186 static inline bool erofs_sb_has_##name(struct erofs_sb_info *sbi) \
187 { \
188 return sbi->feature_##compat & EROFS_FEATURE_##feature; \
189 }
190
EROFS_FEATURE_FUNCS(lz4_0padding,incompat,INCOMPAT_LZ4_0PADDING)191 EROFS_FEATURE_FUNCS(lz4_0padding, incompat, INCOMPAT_LZ4_0PADDING)
192 EROFS_FEATURE_FUNCS(compr_cfgs, incompat, INCOMPAT_COMPR_CFGS)
193 EROFS_FEATURE_FUNCS(big_pcluster, incompat, INCOMPAT_BIG_PCLUSTER)
194 EROFS_FEATURE_FUNCS(chunked_file, incompat, INCOMPAT_CHUNKED_FILE)
195 EROFS_FEATURE_FUNCS(device_table, incompat, INCOMPAT_DEVICE_TABLE)
196 EROFS_FEATURE_FUNCS(compr_head2, incompat, INCOMPAT_COMPR_HEAD2)
197 EROFS_FEATURE_FUNCS(ztailpacking, incompat, INCOMPAT_ZTAILPACKING)
198 EROFS_FEATURE_FUNCS(fragments, incompat, INCOMPAT_FRAGMENTS)
199 EROFS_FEATURE_FUNCS(dedupe, incompat, INCOMPAT_DEDUPE)
200 EROFS_FEATURE_FUNCS(xattr_prefixes, incompat, INCOMPAT_XATTR_PREFIXES)
201 EROFS_FEATURE_FUNCS(48bit, incompat, INCOMPAT_48BIT)
202 EROFS_FEATURE_FUNCS(metabox, incompat, INCOMPAT_METABOX)
203 EROFS_FEATURE_FUNCS(sb_chksum, compat, COMPAT_SB_CHKSUM)
204 EROFS_FEATURE_FUNCS(xattr_filter, compat, COMPAT_XATTR_FILTER)
205 EROFS_FEATURE_FUNCS(shared_ea_in_metabox, compat, COMPAT_SHARED_EA_IN_METABOX)
206 EROFS_FEATURE_FUNCS(plain_xattr_pfx, compat, COMPAT_PLAIN_XATTR_PFX)
207 EROFS_FEATURE_FUNCS(ishare_xattrs, compat, COMPAT_ISHARE_XATTRS)
208
209 static inline u64 erofs_nid_to_ino64(struct erofs_sb_info *sbi, erofs_nid_t nid)
210 {
211 if (!erofs_sb_has_metabox(sbi))
212 return nid;
213
214 /*
215 * When metadata compression is enabled, avoid generating excessively
216 * large inode numbers for metadata-compressed inodes. Shift NIDs in
217 * the 31-62 bit range left by one and move the metabox flag to bit 31.
218 *
219 * Note: on-disk NIDs remain unchanged as they are primarily used for
220 * compatibility with non-LFS 32-bit applications.
221 */
222 return ((nid << 1) & GENMASK_ULL(63, 32)) | (nid & GENMASK(30, 0)) |
223 ((nid >> EROFS_DIRENT_NID_METABOX_BIT) << 31);
224 }
225
226 /* atomic flag definitions */
227 #define EROFS_I_EA_INITED_BIT 0
228 #define EROFS_I_Z_INITED_BIT 1
229
230 /* bitlock definitions (arranged in reverse order) */
231 #define EROFS_I_BL_XATTR_BIT (BITS_PER_LONG - 1)
232 #define EROFS_I_BL_Z_BIT (BITS_PER_LONG - 2)
233
234 /* default readahead size of directories */
235 #define EROFS_DIR_RA_BYTES 16384
236
237 struct erofs_inode_fingerprint {
238 u8 *opaque;
239 int size;
240 };
241
242 struct erofs_inode {
243 erofs_nid_t nid;
244
245 /* atomic flags (including bitlocks) */
246 unsigned long flags;
247
248 unsigned char datalayout;
249 unsigned char inode_isize;
250 bool dot_omitted;
251 unsigned int xattr_isize;
252
253 unsigned int xattr_name_filter;
254 unsigned int xattr_shared_count;
255 unsigned int *xattr_shared_xattrs;
256
257 union {
258 erofs_blk_t startblk;
259 struct {
260 unsigned short chunkformat;
261 unsigned char chunkbits;
262 };
263 #ifdef CONFIG_EROFS_FS_ZIP
264 struct {
265 unsigned short z_advise;
266 unsigned char z_algofmt[2];
267 unsigned char z_lclusterbits;
268 union {
269 u64 z_tailextent_headlcn;
270 u64 z_extents;
271 };
272 erofs_off_t z_fragmentoff;
273 unsigned short z_idata_size;
274 };
275 #endif /* CONFIG_EROFS_FS_ZIP */
276 };
277 #ifdef CONFIG_EROFS_FS_PAGE_CACHE_SHARE
278 struct list_head ishare_list;
279 union {
280 /* for each anon shared inode */
281 struct {
282 struct erofs_inode_fingerprint fingerprint;
283 spinlock_t ishare_lock;
284 };
285 /* for each real filesystem inode */
286 struct dentry *sharedentry;
287 };
288 #endif
289 /* the corresponding vfs inode */
290 struct inode vfs_inode;
291 };
292
293 #define EROFS_I(ptr) container_of(ptr, struct erofs_inode, vfs_inode)
294
erofs_inode_in_metabox(struct inode * inode)295 static inline bool erofs_inode_in_metabox(struct inode *inode)
296 {
297 return EROFS_I(inode)->nid & BIT_ULL(EROFS_DIRENT_NID_METABOX_BIT);
298 }
299
erofs_iloc(struct inode * inode)300 static inline erofs_off_t erofs_iloc(struct inode *inode)
301 {
302 struct erofs_sb_info *sbi = EROFS_I_SB(inode);
303 erofs_nid_t nid_lo = EROFS_I(inode)->nid & EROFS_DIRENT_NID_MASK;
304
305 if (erofs_inode_in_metabox(inode))
306 return nid_lo << sbi->islotbits;
307 return erofs_pos(inode->i_sb, sbi->meta_blkaddr) +
308 (nid_lo << sbi->islotbits);
309 }
310
erofs_inode_version(unsigned int ifmt)311 static inline unsigned int erofs_inode_version(unsigned int ifmt)
312 {
313 return (ifmt >> EROFS_I_VERSION_BIT) & EROFS_I_VERSION_MASK;
314 }
315
erofs_inode_datalayout(unsigned int ifmt)316 static inline unsigned int erofs_inode_datalayout(unsigned int ifmt)
317 {
318 return (ifmt >> EROFS_I_DATALAYOUT_BIT) & EROFS_I_DATALAYOUT_MASK;
319 }
320
321 /* reclaiming is never triggered when allocating new folios. */
erofs_grab_folio_nowait(struct address_space * as,pgoff_t index)322 static inline struct folio *erofs_grab_folio_nowait(struct address_space *as,
323 pgoff_t index)
324 {
325 return __filemap_get_folio(as, index,
326 FGP_LOCK|FGP_CREAT|FGP_NOFS|FGP_NOWAIT,
327 readahead_gfp_mask(as) & ~__GFP_RECLAIM);
328 }
329
330 /* Allocated on disk at @m_pa (e.g. NOT a fragment extent) */
331 #define EROFS_MAP_MAPPED 0x0001
332 /* Located in metadata (could be copied from bd_inode) */
333 #define EROFS_MAP_META 0x0002
334 /* @m_llen may be truncated by the runtime compared to the on-disk record */
335 #define EROFS_MAP_PARTIAL_MAPPED 0x0004
336 /* The on-disk @m_llen may cover only part of the encoded data */
337 #define EROFS_MAP_PARTIAL_REF 0x0008
338 /* Located in the special packed inode */
339 #define EROFS_MAP_FRAGMENT 0x0010
340 /* The encoded on-disk data will be fully handled (decompressed) */
341 #define EROFS_MAP_FULL(f) (!((f) & (EROFS_MAP_PARTIAL_MAPPED | \
342 EROFS_MAP_PARTIAL_REF)))
343
344 struct erofs_map_blocks {
345 struct erofs_buf buf;
346
347 erofs_off_t m_pa, m_la;
348 u64 m_plen, m_llen;
349
350 unsigned short m_deviceid;
351 char m_algorithmformat;
352 unsigned int m_flags;
353 };
354
355 /*
356 * Used to get the exact decompressed length, e.g. fiemap (consider lookback
357 * approach instead if possible since it's more metadata lightweight.)
358 */
359 #define EROFS_GET_BLOCKS_FIEMAP 0x0001
360 /* Used to map the whole extent if non-negligible data is requested for LZMA */
361 #define EROFS_GET_BLOCKS_READMORE 0x0002
362 /* Used to map tail extent for tailpacking inline or fragment pcluster */
363 #define EROFS_GET_BLOCKS_FINDTAIL 0x0004
364
365 enum {
366 Z_EROFS_COMPRESSION_SHIFTED = Z_EROFS_COMPRESSION_MAX,
367 Z_EROFS_COMPRESSION_INTERLACED,
368 Z_EROFS_COMPRESSION_RUNTIME_MAX
369 };
370
371 struct erofs_map_dev {
372 struct super_block *m_sb;
373 struct erofs_device_info *m_dif;
374 struct block_device *m_bdev;
375
376 erofs_off_t m_pa;
377 unsigned int m_deviceid;
378 };
379
380 extern const struct super_operations erofs_sops;
381 extern const struct address_space_operations erofs_aops;
382 extern const struct address_space_operations erofs_fileio_aops;
383 extern const struct address_space_operations z_erofs_aops;
384
385 extern const struct inode_operations erofs_generic_iops;
386 extern const struct inode_operations erofs_symlink_iops;
387 extern const struct inode_operations erofs_fast_symlink_iops;
388 extern const struct inode_operations erofs_dir_iops;
389
390 extern const struct file_operations erofs_file_fops;
391 extern const struct file_operations erofs_dir_fops;
392 extern const struct file_operations erofs_ishare_fops;
393
394 extern const struct iomap_ops z_erofs_iomap_report_ops;
395
396 int erofs_setup_managed_cache(struct super_block *sb);
397 #ifdef CONFIG_EROFS_FS_BACKED_BY_FILE
398 int erofs_read_meta_folio(struct file *file, struct folio *folio);
399 #else
400 #define erofs_read_meta_folio NULL
401 #endif
402 void *erofs_read_metadata(struct super_block *sb, struct erofs_buf *buf,
403 erofs_off_t *offset, int *lengthp);
404 void erofs_unmap_metabuf(struct erofs_buf *buf);
405 void erofs_put_metabuf(struct erofs_buf *buf);
406 void *erofs_bread(struct erofs_buf *buf, erofs_off_t offset, bool need_kmap);
407 int erofs_init_metabuf(struct erofs_buf *buf, struct super_block *sb,
408 bool in_metabox);
409 void *erofs_read_metabuf(struct erofs_buf *buf, struct super_block *sb,
410 erofs_off_t offset, bool in_metabox);
411 int erofs_map_dev(struct super_block *sb, struct erofs_map_dev *dev);
412 int erofs_fiemap(struct inode *inode, struct fiemap_extent_info *fieinfo,
413 u64 start, u64 len);
414 loff_t erofs_file_llseek(struct file *file, loff_t offset, int whence);
415 int erofs_map_blocks(struct inode *inode, struct erofs_map_blocks *map);
416 void erofs_onlinefolio_init(struct folio *folio);
417 void erofs_onlinefolio_split(struct folio *folio);
418 void erofs_onlinefolio_end(struct folio *folio, int err, bool dirty);
419 struct inode *erofs_iget(struct super_block *sb, erofs_nid_t nid);
420 int erofs_getattr(struct mnt_idmap *idmap, const struct path *path,
421 struct kstat *stat, u32 request_mask,
422 unsigned int query_flags);
423 int erofs_namei(struct inode *dir, const struct qstr *name,
424 erofs_nid_t *nid, unsigned int *d_type);
425
erofs_vm_map_ram(struct page ** pages,unsigned int count)426 static inline void *erofs_vm_map_ram(struct page **pages, unsigned int count)
427 {
428 int retried = 0;
429
430 while (1) {
431 void *p = vm_map_ram(pages, count, -1);
432
433 /* retry two more times (totally 3 times) */
434 if (p || ++retried >= 3)
435 return p;
436 vm_unmap_aliases();
437 }
438 return NULL;
439 }
440
441 static inline const struct address_space_operations *
erofs_get_aops(struct inode * realinode)442 erofs_get_aops(struct inode *realinode)
443 {
444 if (erofs_inode_is_data_compressed(EROFS_I(realinode)->datalayout)) {
445 if (!IS_ENABLED(CONFIG_EROFS_FS_ZIP))
446 return ERR_PTR(-EOPNOTSUPP);
447 DO_ONCE_LITE_IF(realinode->i_blkbits != PAGE_SHIFT,
448 erofs_info, realinode->i_sb,
449 "EXPERIMENTAL EROFS subpage compressed block support in use. Use at your own risk!");
450 return &z_erofs_aops;
451 }
452 if (IS_ENABLED(CONFIG_EROFS_FS_BACKED_BY_FILE) &&
453 erofs_is_fileio_mode(EROFS_SB(realinode->i_sb)))
454 return &erofs_fileio_aops;
455 return &erofs_aops;
456 }
457
458 int erofs_register_sysfs(struct super_block *sb);
459 void erofs_unregister_sysfs(struct super_block *sb);
460 int __init erofs_init_sysfs(void);
461 void erofs_exit_sysfs(void);
462
463 struct page *__erofs_allocpage(struct page **pagepool, gfp_t gfp, bool tryrsv);
erofs_allocpage(struct page ** pagepool,gfp_t gfp)464 static inline struct page *erofs_allocpage(struct page **pagepool, gfp_t gfp)
465 {
466 return __erofs_allocpage(pagepool, gfp, false);
467 }
erofs_pagepool_add(struct page ** pagepool,struct page * page)468 static inline void erofs_pagepool_add(struct page **pagepool, struct page *page)
469 {
470 set_page_private(page, (unsigned long)*pagepool);
471 *pagepool = page;
472 }
473 void erofs_release_pages(struct page **pagepool);
474
475 #ifdef CONFIG_EROFS_FS_ZIP
476 #define MNGD_MAPPING(sbi) ((sbi)->managed_cache->i_mapping)
477
478 extern atomic_long_t erofs_global_shrink_cnt;
479 void erofs_shrinker_register(struct super_block *sb);
480 void erofs_shrinker_unregister(struct super_block *sb);
481 int __init erofs_init_shrinker(void);
482 void erofs_exit_shrinker(void);
483 int __init z_erofs_init_subsystem(void);
484 void z_erofs_exit_subsystem(void);
485 int z_erofs_init_super(struct super_block *sb);
486 unsigned long z_erofs_shrink_scan(struct erofs_sb_info *sbi,
487 unsigned long nr_shrink);
488 int z_erofs_map_blocks_iter(struct inode *inode, struct erofs_map_blocks *map,
489 int flags);
490 void *z_erofs_get_gbuf(unsigned int requiredpages);
491 void z_erofs_put_gbuf(void *ptr);
492 int z_erofs_gbuf_growsize(unsigned int nrpages);
493 int __init z_erofs_gbuf_init(void);
494 void z_erofs_gbuf_exit(void);
495 #else
erofs_shrinker_register(struct super_block * sb)496 static inline void erofs_shrinker_register(struct super_block *sb) {}
erofs_shrinker_unregister(struct super_block * sb)497 static inline void erofs_shrinker_unregister(struct super_block *sb) {}
erofs_init_shrinker(void)498 static inline int erofs_init_shrinker(void) { return 0; }
erofs_exit_shrinker(void)499 static inline void erofs_exit_shrinker(void) {}
z_erofs_init_subsystem(void)500 static inline int z_erofs_init_subsystem(void) { return 0; }
z_erofs_exit_subsystem(void)501 static inline void z_erofs_exit_subsystem(void) {}
z_erofs_init_super(struct super_block * sb)502 static inline int z_erofs_init_super(struct super_block *sb) { return 0; }
503 #endif /* !CONFIG_EROFS_FS_ZIP */
504 int z_erofs_parse_cfgs(struct super_block *sb, struct erofs_super_block *dsb);
505
506 #ifdef CONFIG_EROFS_FS_BACKED_BY_FILE
507 struct bio *erofs_fileio_bio_alloc(struct erofs_map_dev *mdev);
508 void erofs_fileio_submit_bio(struct bio *bio);
509 #else
erofs_fileio_bio_alloc(struct erofs_map_dev * mdev)510 static inline struct bio *erofs_fileio_bio_alloc(struct erofs_map_dev *mdev) { return NULL; }
erofs_fileio_submit_bio(struct bio * bio)511 static inline void erofs_fileio_submit_bio(struct bio *bio) {}
512 #endif
513
514 #ifdef CONFIG_EROFS_FS_PAGE_CACHE_SHARE
515 int __init erofs_init_ishare(void);
516 void erofs_exit_ishare(void);
517 bool erofs_ishare_fill_inode(struct inode *inode);
518 void erofs_ishare_free_inode(struct inode *inode);
519 struct inode *erofs_real_inode(struct inode *inode, bool *need_iput);
520 #else
erofs_init_ishare(void)521 static inline int erofs_init_ishare(void) { return 0; }
erofs_exit_ishare(void)522 static inline void erofs_exit_ishare(void) {}
erofs_ishare_fill_inode(struct inode * inode)523 static inline bool erofs_ishare_fill_inode(struct inode *inode) { return false; }
erofs_ishare_free_inode(struct inode * inode)524 static inline void erofs_ishare_free_inode(struct inode *inode) {}
erofs_real_inode(struct inode * inode,bool * need_iput)525 static inline struct inode *erofs_real_inode(struct inode *inode, bool *need_iput)
526 {
527 *need_iput = false;
528 return inode;
529 }
530 #endif
531
532 long erofs_ioctl(struct file *filp, unsigned int cmd, unsigned long arg);
533 long erofs_compat_ioctl(struct file *filp, unsigned int cmd,
534 unsigned long arg);
535
536 #endif /* __EROFS_INTERNAL_H */
537