[linux.git] / fs / 9p / cache.h

/*
 * V9FS cache definitions.
 *
 *  Copyright (C) 2009 by Abhishek Kulkarni <[email protected]>
 *
 *  This program is free software; you can redistribute it and/or modify
 *  it under the terms of the GNU General Public License version 2
 *  as published by the Free Software Foundation.
 *
 *  This program is distributed in the hope that it will be useful,
 *  but WITHOUT ANY WARRANTY; without even the implied warranty of
 *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 *  GNU General Public License for more details.
 *
 *  You should have received a copy of the GNU General Public License
 *  along with this program; if not, write to:
 *  Free Software Foundation
 *  51 Franklin Street, Fifth Floor
 *  Boston, MA  02111-1301  USA
 *
 */

#ifndef _9P_CACHE_H
#ifdef CONFIG_9P_FSCACHE
#include <linux/fscache.h>
#include <linux/spinlock.h>

extern struct fscache_netfs v9fs_cache_netfs;
extern const struct fscache_cookie_def v9fs_cache_session_index_def;
extern const struct fscache_cookie_def v9fs_cache_inode_index_def;

extern void v9fs_cache_session_get_cookie(struct v9fs_session_info *v9ses);
extern void v9fs_cache_session_put_cookie(struct v9fs_session_info *v9ses);

extern void v9fs_cache_inode_get_cookie(struct inode *inode);
extern void v9fs_cache_inode_put_cookie(struct inode *inode);
extern void v9fs_cache_inode_flush_cookie(struct inode *inode);
extern void v9fs_cache_inode_set_cookie(struct inode *inode, struct file *filp);
extern void v9fs_cache_inode_reset_cookie(struct inode *inode);

extern int __v9fs_cache_register(void);
extern void __v9fs_cache_unregister(void);

extern int __v9fs_fscache_release_page(struct page *page, gfp_t gfp);
extern void __v9fs_fscache_invalidate_page(struct page *page);
extern int __v9fs_readpage_from_fscache(struct inode *inode,
					struct page *page);
extern int __v9fs_readpages_from_fscache(struct inode *inode,
					 struct address_space *mapping,
					 struct list_head *pages,
					 unsigned *nr_pages);
extern void __v9fs_readpage_to_fscache(struct inode *inode, struct page *page);
extern void __v9fs_fscache_wait_on_page_write(struct inode *inode,
					      struct page *page);

static inline int v9fs_fscache_release_page(struct page *page,
					    gfp_t gfp)
{
	return __v9fs_fscache_release_page(page, gfp);
}

static inline void v9fs_fscache_invalidate_page(struct page *page)
{
	__v9fs_fscache_invalidate_page(page);
}

static inline int v9fs_readpage_from_fscache(struct inode *inode,
					     struct page *page)
{
	return __v9fs_readpage_from_fscache(inode, page);
}

static inline int v9fs_readpages_from_fscache(struct inode *inode,
					      struct address_space *mapping,
					      struct list_head *pages,
					      unsigned *nr_pages)
{
	return __v9fs_readpages_from_fscache(inode, mapping, pages,
					     nr_pages);
}

static inline void v9fs_readpage_to_fscache(struct inode *inode,
					    struct page *page)
{
	if (PageFsCache(page))
		__v9fs_readpage_to_fscache(inode, page);
}

static inline void v9fs_uncache_page(struct inode *inode, struct page *page)
{
	struct v9fs_inode *v9inode = V9FS_I(inode);
	fscache_uncache_page(v9inode->fscache, page);
	BUG_ON(PageFsCache(page));
}

static inline void v9fs_fscache_wait_on_page_write(struct inode *inode,
						   struct page *page)
{
	return __v9fs_fscache_wait_on_page_write(inode, page);
}

#else /* CONFIG_9P_FSCACHE */

static inline int v9fs_fscache_release_page(struct page *page,
					    gfp_t gfp) {
	return 1;
}

static inline void v9fs_fscache_invalidate_page(struct page *page) {}

static inline int v9fs_readpage_from_fscache(struct inode *inode,
					     struct page *page)
{
	return -ENOBUFS;
}

static inline int v9fs_readpages_from_fscache(struct inode *inode,
					      struct address_space *mapping,
					      struct list_head *pages,
					      unsigned *nr_pages)
{
	return -ENOBUFS;
}

static inline void v9fs_readpage_to_fscache(struct inode *inode,
					    struct page *page)
{}

static inline void v9fs_uncache_page(struct inode *inode, struct page *page)
{}

static inline void v9fs_fscache_wait_on_page_write(struct inode *inode,
						   struct page *page)
{
	return;
}

#endif /* CONFIG_9P_FSCACHE */
#endif /* _9P_CACHE_H */
Commit	Line	Data
60e78d2c AK	1	/*
	2	* V9FS cache definitions.
	3	*
	4	* Copyright (C) 2009 by Abhishek Kulkarni <[email protected]>
	5	*
	6	* This program is free software; you can redistribute it and/or modify
	7	* it under the terms of the GNU General Public License version 2
	8	* as published by the Free Software Foundation.
	9	*
	10	* This program is distributed in the hope that it will be useful,
	11	* but WITHOUT ANY WARRANTY; without even the implied warranty of
	12	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
	13	* GNU General Public License for more details.
	14	*
	15	* You should have received a copy of the GNU General Public License
	16	* along with this program; if not, write to:
	17	* Free Software Foundation
	18	* 51 Franklin Street, Fifth Floor
	19	* Boston, MA 02111-1301 USA
	20	*
	21	*/
	22
	23	#ifndef _9P_CACHE_H
	24	#ifdef CONFIG_9P_FSCACHE
	25	#include <linux/fscache.h>
	26	#include <linux/spinlock.h>
	27
60e78d2c AK	28	extern struct fscache_netfs v9fs_cache_netfs;
	29	extern const struct fscache_cookie_def v9fs_cache_session_index_def;
	30	extern const struct fscache_cookie_def v9fs_cache_inode_index_def;
	31
	32	extern void v9fs_cache_session_get_cookie(struct v9fs_session_info *v9ses);
	33	extern void v9fs_cache_session_put_cookie(struct v9fs_session_info *v9ses);
	34
	35	extern void v9fs_cache_inode_get_cookie(struct inode *inode);
	36	extern void v9fs_cache_inode_put_cookie(struct inode *inode);
	37	extern void v9fs_cache_inode_flush_cookie(struct inode *inode);
	38	extern void v9fs_cache_inode_set_cookie(struct inode inode, struct file filp);
	39	extern void v9fs_cache_inode_reset_cookie(struct inode *inode);
	40
	41	extern int __v9fs_cache_register(void);
	42	extern void __v9fs_cache_unregister(void);
	43
	44	extern int __v9fs_fscache_release_page(struct page *page, gfp_t gfp);
	45	extern void __v9fs_fscache_invalidate_page(struct page *page);
	46	extern int __v9fs_readpage_from_fscache(struct inode *inode,
	47	struct page *page);
	48	extern int __v9fs_readpages_from_fscache(struct inode *inode,
	49	struct address_space *mapping,
	50	struct list_head *pages,
	51	unsigned *nr_pages);
	52	extern void __v9fs_readpage_to_fscache(struct inode inode, struct page page);
2efda799 AK	53	extern void __v9fs_fscache_wait_on_page_write(struct inode *inode,
2efda799 AK	54	struct page *page);
60e78d2c AK	55
	56	static inline int v9fs_fscache_release_page(struct page *page,
	57	gfp_t gfp)
	58	{
	59	return __v9fs_fscache_release_page(page, gfp);
	60	}
	61
	62	static inline void v9fs_fscache_invalidate_page(struct page *page)
	63	{
	64	__v9fs_fscache_invalidate_page(page);
	65	}
	66
	67	static inline int v9fs_readpage_from_fscache(struct inode *inode,
	68	struct page *page)
	69	{
	70	return __v9fs_readpage_from_fscache(inode, page);
	71	}
	72
	73	static inline int v9fs_readpages_from_fscache(struct inode *inode,
	74	struct address_space *mapping,
	75	struct list_head *pages,
	76	unsigned *nr_pages)
	77	{
	78	return __v9fs_readpages_from_fscache(inode, mapping, pages,
	79	nr_pages);
	80	}
	81
	82	static inline void v9fs_readpage_to_fscache(struct inode *inode,
	83	struct page *page)
	84	{
	85	if (PageFsCache(page))
	86	__v9fs_readpage_to_fscache(inode, page);
	87	}
	88
	89	static inline void v9fs_uncache_page(struct inode inode, struct page page)
	90	{
a78ce05d AK	91	struct v9fs_inode *v9inode = V9FS_I(inode);
a78ce05d AK	92	fscache_uncache_page(v9inode->fscache, page);
60e78d2c AK	93	BUG_ON(PageFsCache(page));
	94	}
	95
2efda799 AK	96	static inline void v9fs_fscache_wait_on_page_write(struct inode *inode,
	97	struct page *page)
	98	{
	99	return __v9fs_fscache_wait_on_page_write(inode, page);
	100	}
	101
60e78d2c AK	102	#else /* CONFIG_9P_FSCACHE */
60e78d2c AK	103
60e78d2c AK	104	static inline int v9fs_fscache_release_page(struct page *page,
	105	gfp_t gfp) {
	106	return 1;
	107	}
	108
	109	static inline void v9fs_fscache_invalidate_page(struct page *page) {}
	110
	111	static inline int v9fs_readpage_from_fscache(struct inode *inode,
	112	struct page *page)
	113	{
	114	return -ENOBUFS;
	115	}
	116
	117	static inline int v9fs_readpages_from_fscache(struct inode *inode,
	118	struct address_space *mapping,
	119	struct list_head *pages,
	120	unsigned *nr_pages)
	121	{
	122	return -ENOBUFS;
	123	}
	124
	125	static inline void v9fs_readpage_to_fscache(struct inode *inode,
	126	struct page *page)
	127	{}
	128
	129	static inline void v9fs_uncache_page(struct inode inode, struct page page)
	130	{}
	131
2efda799 AK	132	static inline void v9fs_fscache_wait_on_page_write(struct inode *inode,
	133	struct page *page)
	134	{
	135	return;
	136	}
	137
60e78d2c AK	138	#endif /* CONFIG_9P_FSCACHE */
60e78d2c AK	139	#endif /* _9P_CACHE_H */