Line data Source code
1 : #ifndef _LINUX_CLEANCACHE_H
2 : #define _LINUX_CLEANCACHE_H
3 :
4 : #include <linux/fs.h>
5 : #include <linux/exportfs.h>
6 : #include <linux/mm.h>
7 :
8 : #define CLEANCACHE_KEY_MAX 6
9 :
10 : /*
11 : * cleancache requires every file with a page in cleancache to have a
12 : * unique key unless/until the file is removed/truncated. For some
13 : * filesystems, the inode number is unique, but for "modern" filesystems
14 : * an exportable filehandle is required (see exportfs.h)
15 : */
16 : struct cleancache_filekey {
17 : union {
18 : ino_t ino;
19 : __u32 fh[CLEANCACHE_KEY_MAX];
20 : u32 key[CLEANCACHE_KEY_MAX];
21 : } u;
22 : };
23 :
24 : struct cleancache_ops {
25 : int (*init_fs)(size_t);
26 : int (*init_shared_fs)(char *uuid, size_t);
27 : int (*get_page)(int, struct cleancache_filekey,
28 : pgoff_t, struct page *);
29 : void (*put_page)(int, struct cleancache_filekey,
30 : pgoff_t, struct page *);
31 : void (*invalidate_page)(int, struct cleancache_filekey, pgoff_t);
32 : void (*invalidate_inode)(int, struct cleancache_filekey);
33 : void (*invalidate_fs)(int);
34 : };
35 :
36 : extern struct cleancache_ops *
37 : cleancache_register_ops(struct cleancache_ops *ops);
38 : extern void __cleancache_init_fs(struct super_block *);
39 : extern void __cleancache_init_shared_fs(char *, struct super_block *);
40 : extern int __cleancache_get_page(struct page *);
41 : extern void __cleancache_put_page(struct page *);
42 : extern void __cleancache_invalidate_page(struct address_space *, struct page *);
43 : extern void __cleancache_invalidate_inode(struct address_space *);
44 : extern void __cleancache_invalidate_fs(struct super_block *);
45 :
46 : #ifdef CONFIG_CLEANCACHE
47 : #define cleancache_enabled (1)
48 : static inline bool cleancache_fs_enabled(struct page *page)
49 : {
50 486456 : return page->mapping->host->i_sb->cleancache_poolid >= 0;
51 : }
52 : static inline bool cleancache_fs_enabled_mapping(struct address_space *mapping)
53 : {
54 : return mapping->host->i_sb->cleancache_poolid >= 0;
55 : }
56 : #else
57 : #define cleancache_enabled (0)
58 : #define cleancache_fs_enabled(_page) (0)
59 : #define cleancache_fs_enabled_mapping(_page) (0)
60 : #endif
61 :
62 : /*
63 : * The shim layer provided by these inline functions allows the compiler
64 : * to reduce all cleancache hooks to nothingness if CONFIG_CLEANCACHE
65 : * is disabled, to a single global variable check if CONFIG_CLEANCACHE
66 : * is enabled but no cleancache "backend" has dynamically enabled it,
67 : * and, for the most frequent cleancache ops, to a single global variable
68 : * check plus a superblock element comparison if CONFIG_CLEANCACHE is enabled
69 : * and a cleancache backend has dynamically enabled cleancache, but the
70 : * filesystem referenced by that cleancache op has not enabled cleancache.
71 : * As a result, CONFIG_CLEANCACHE can be enabled by default with essentially
72 : * no measurable performance impact.
73 : */
74 :
75 : static inline void cleancache_init_fs(struct super_block *sb)
76 : {
77 : if (cleancache_enabled)
78 : __cleancache_init_fs(sb);
79 : }
80 :
81 : static inline void cleancache_init_shared_fs(char *uuid, struct super_block *sb)
82 : {
83 : if (cleancache_enabled)
84 : __cleancache_init_shared_fs(uuid, sb);
85 : }
86 :
87 486456 : static inline int cleancache_get_page(struct page *page)
88 : {
89 : int ret = -1;
90 :
91 486456 : if (cleancache_enabled && cleancache_fs_enabled(page))
92 472988 : ret = __cleancache_get_page(page);
93 486456 : return ret;
94 : }
95 :
96 : static inline void cleancache_put_page(struct page *page)
97 : {
98 : if (cleancache_enabled && cleancache_fs_enabled(page))
99 : __cleancache_put_page(page);
100 : }
101 :
102 : static inline void cleancache_invalidate_page(struct address_space *mapping,
103 : struct page *page)
104 : {
105 : /* careful... page->mapping is NULL sometimes when this is called */
106 : if (cleancache_enabled && cleancache_fs_enabled_mapping(mapping))
107 : __cleancache_invalidate_page(mapping, page);
108 : }
109 :
110 : static inline void cleancache_invalidate_inode(struct address_space *mapping)
111 : {
112 : if (cleancache_enabled && cleancache_fs_enabled_mapping(mapping))
113 : __cleancache_invalidate_inode(mapping);
114 : }
115 :
116 : static inline void cleancache_invalidate_fs(struct super_block *sb)
117 : {
118 : if (cleancache_enabled)
119 : __cleancache_invalidate_fs(sb);
120 : }
121 :
122 : #endif /* _LINUX_CLEANCACHE_H */
|