LXR linux/include/linux/cleancache.h

   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 */
  20struct cleancache_filekey {
  21        union {
  22                ino_t ino;
  23                __u32 fh[CLEANCACHE_KEY_MAX];
  24                u32 key[CLEANCACHE_KEY_MAX];
  25        } u;
  26};
  27
  28struct 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
  40extern int cleancache_register_ops(struct cleancache_ops *ops);
  41extern void __cleancache_init_fs(struct super_block *);
  42extern void __cleancache_init_shared_fs(struct super_block *);
  43extern int  __cleancache_get_page(struct page *);
  44extern void __cleancache_put_page(struct page *);
  45extern void __cleancache_invalidate_page(struct address_space *, struct page *);
  46extern void __cleancache_invalidate_inode(struct address_space *);
  47extern void __cleancache_invalidate_fs(struct super_block *);
  48
  49#ifdef CONFIG_CLEANCACHE
  50#define cleancache_enabled (1)
  51static inline bool cleancache_fs_enabled(struct page *page)
  52{
  53        return page->mapping->host->i_sb->cleancache_poolid >= 0;
  54}
  55static 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
  78static inline void cleancache_init_fs(struct super_block *sb)
  79{
  80        if (cleancache_enabled)
  81                __cleancache_init_fs(sb);
  82}
  83
  84static inline void cleancache_init_shared_fs(struct super_block *sb)
  85{
  86        if (cleancache_enabled)
  87                __cleancache_init_shared_fs(sb);
  88}
  89
  90static 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
  99static inline void cleancache_put_page(struct page *page)
 100{
 101        if (cleancache_enabled && cleancache_fs_enabled(page))
 102                __cleancache_put_page(page);
 103}
 104
 105static 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
 113static 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
 119static 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