[GitHub/mt8127/android_kernel_alcatel_ttab.git] / include / linux / cleancache.h

#ifndef _LINUX_CLEANCACHE_H
#define _LINUX_CLEANCACHE_H

#include <linux/fs.h>
#include <linux/exportfs.h>
#include <linux/mm.h>

#define CLEANCACHE_KEY_MAX 6

/*
 * cleancache requires every file with a page in cleancache to have a
 * unique key unless/until the file is removed/truncated.  For some
 * filesystems, the inode number is unique, but for "modern" filesystems
 * an exportable filehandle is required (see exportfs.h)
 */
struct cleancache_filekey {
	union {
		ino_t ino;
		__u32 fh[CLEANCACHE_KEY_MAX];
		u32 key[CLEANCACHE_KEY_MAX];
	} u;
};

struct cleancache_ops {
	int (*init_fs)(size_t);
	int (*init_shared_fs)(char *uuid, size_t);
	int (*get_page)(int, struct cleancache_filekey,
			pgoff_t, struct page *);
	void (*put_page)(int, struct cleancache_filekey,
			pgoff_t, struct page *);
	void (*invalidate_page)(int, struct cleancache_filekey, pgoff_t);
	void (*invalidate_inode)(int, struct cleancache_filekey);
	void (*invalidate_fs)(int);
};

extern struct cleancache_ops *
	cleancache_register_ops(struct cleancache_ops *ops);
extern void __cleancache_init_fs(struct super_block *);
extern void __cleancache_init_shared_fs(char *, struct super_block *);
extern int  __cleancache_get_page(struct page *);
extern void __cleancache_put_page(struct page *);
extern void __cleancache_invalidate_page(struct address_space *, struct page *);
extern void __cleancache_invalidate_inode(struct address_space *);
extern void __cleancache_invalidate_fs(struct super_block *);

#ifdef CONFIG_CLEANCACHE
#define cleancache_enabled (1)
static inline bool cleancache_fs_enabled(struct page *page)
{
	return page->mapping->host->i_sb->cleancache_poolid >= 0;
}
static inline bool cleancache_fs_enabled_mapping(struct address_space *mapping)
{
	return mapping->host->i_sb->cleancache_poolid >= 0;
}
#else
#define cleancache_enabled (0)
#define cleancache_fs_enabled(_page) (0)
#define cleancache_fs_enabled_mapping(_page) (0)
#endif

/*
 * The shim layer provided by these inline functions allows the compiler
 * to reduce all cleancache hooks to nothingness if CONFIG_CLEANCACHE
 * is disabled, to a single global variable check if CONFIG_CLEANCACHE
 * is enabled but no cleancache "backend" has dynamically enabled it,
 * and, for the most frequent cleancache ops, to a single global variable
 * check plus a superblock element comparison if CONFIG_CLEANCACHE is enabled
 * and a cleancache backend has dynamically enabled cleancache, but the
 * filesystem referenced by that cleancache op has not enabled cleancache.
 * As a result, CONFIG_CLEANCACHE can be enabled by default with essentially
 * no measurable performance impact.
 */

static inline void cleancache_init_fs(struct super_block *sb)
{
	if (cleancache_enabled)
		__cleancache_init_fs(sb);
}

static inline void cleancache_init_shared_fs(char *uuid, struct super_block *sb)
{
	if (cleancache_enabled)
		__cleancache_init_shared_fs(uuid, sb);
}

static inline int cleancache_get_page(struct page *page)
{
	int ret = -1;

	if (cleancache_enabled && cleancache_fs_enabled(page))
		ret = __cleancache_get_page(page);
	return ret;
}

static inline void cleancache_put_page(struct page *page)
{
	if (cleancache_enabled && cleancache_fs_enabled(page))
		__cleancache_put_page(page);
}

static inline void cleancache_invalidate_page(struct address_space *mapping,
					struct page *page)
{
	/* careful... page->mapping is NULL sometimes when this is called */
	if (cleancache_enabled && cleancache_fs_enabled_mapping(mapping))
		__cleancache_invalidate_page(mapping, page);
}

static inline void cleancache_invalidate_inode(struct address_space *mapping)
{
	if (cleancache_enabled && cleancache_fs_enabled_mapping(mapping))
		__cleancache_invalidate_inode(mapping);
}

static inline void cleancache_invalidate_fs(struct super_block *sb)
{
	if (cleancache_enabled)
		__cleancache_invalidate_fs(sb);
}

#endif /* _LINUX_CLEANCACHE_H */
Commit	Line	Data
077b1f83 DM	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 *);
91c6cc9b DM	31	void (*invalidate_page)(int, struct cleancache_filekey, pgoff_t);
	32	void (*invalidate_inode)(int, struct cleancache_filekey);
	33	void (*invalidate_fs)(int);
077b1f83 DM	34	};
077b1f83 DM	35
833f8662	36	extern struct cleancache_ops *
077b1f83 DM	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 *);
3167760f DM	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 *);
077b1f83 DM	45
077b1f83 DM	46	#ifdef CONFIG_CLEANCACHE
ff610a1d	47	#define cleancache_enabled (1)
077b1f83 DM	48	static inline bool cleancache_fs_enabled(struct page *page)
	49	{
	50	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	static 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
	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
3167760f	102	static inline void cleancache_invalidate_page(struct address_space *mapping,
077b1f83 DM	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))
3167760f	107	__cleancache_invalidate_page(mapping, page);
077b1f83 DM	108	}
077b1f83 DM	109
3167760f	110	static inline void cleancache_invalidate_inode(struct address_space *mapping)
077b1f83 DM	111	{
077b1f83 DM	112	if (cleancache_enabled && cleancache_fs_enabled_mapping(mapping))
3167760f	113	__cleancache_invalidate_inode(mapping);
077b1f83 DM	114	}
077b1f83 DM	115
3167760f	116	static inline void cleancache_invalidate_fs(struct super_block *sb)
077b1f83 DM	117	{
077b1f83 DM	118	if (cleancache_enabled)
3167760f	119	__cleancache_invalidate_fs(sb);
077b1f83 DM	120	}
	121
	122	#endif /* _LINUX_CLEANCACHE_H */