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_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 */
  16struct cleancache_filekey {
  17        union {
  18                ino_t ino;
  19                __u32 fh[CLEANCACHE_KEY_MAX];
  20                u32 key[CLEANCACHE_KEY_MAX];
  21        } u;
  22};
  23
  24struct 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
  36extern struct cleancache_ops *
  37        cleancache_register_ops(struct cleancache_ops *ops);
  38extern void __cleancache_init_fs(struct super_block *);
  39extern void __cleancache_init_shared_fs(char *, struct super_block *);
  40extern int  __cleancache_get_page(struct page *);
  41extern void __cleancache_put_page(struct page *);
  42extern void __cleancache_invalidate_page(struct address_space *, struct page *);
  43extern void __cleancache_invalidate_inode(struct address_space *);
  44extern void __cleancache_invalidate_fs(struct super_block *);
  45
  46#ifdef CONFIG_CLEANCACHE
  47#define cleancache_enabled (1)
  48static inline bool cleancache_fs_enabled(struct page *page)
  49{
  50        return page->mapping->host->i_sb->cleancache_poolid >= 0;
  51}
  52static 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
  75static inline void cleancache_init_fs(struct super_block *sb)
  76{
  77        if (cleancache_enabled)
  78                __cleancache_init_fs(sb);
  79}
  80
  81static 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
  87static inline int cleancache_get_page(struct page *page)
  88{
  89        int ret = -1;
  90
  91        if (cleancache_enabled && cleancache_fs_enabled(page))
  92                ret = __cleancache_get_page(page);
  93        return ret;
  94}
  95
  96static inline void cleancache_put_page(struct page *page)
  97{
  98        if (cleancache_enabled && cleancache_fs_enabled(page))
  99                __cleancache_put_page(page);
 100}
 101
 102static 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
 110static 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
 116static 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 */
 123