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