[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
#define _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 void v9fs_cache_inode_get_cookie(struct inode *inode)
{
}

static inline void v9fs_cache_inode_put_cookie(struct inode *inode)
{
}

static inline void v9fs_cache_inode_set_cookie(struct inode *inode, struct file *file)
{
}

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
7c7afc44	24	#define _9P_CACHE_H
60e78d2c AK	25	#ifdef CONFIG_9P_FSCACHE
	26	#include <linux/fscache.h>
	27	#include <linux/spinlock.h>
	28
60e78d2c AK	29	extern struct fscache_netfs v9fs_cache_netfs;
	30	extern const struct fscache_cookie_def v9fs_cache_session_index_def;
	31	extern const struct fscache_cookie_def v9fs_cache_inode_index_def;
	32
	33	extern void v9fs_cache_session_get_cookie(struct v9fs_session_info *v9ses);
	34	extern void v9fs_cache_session_put_cookie(struct v9fs_session_info *v9ses);
	35
	36	extern void v9fs_cache_inode_get_cookie(struct inode *inode);
	37	extern void v9fs_cache_inode_put_cookie(struct inode *inode);
	38	extern void v9fs_cache_inode_flush_cookie(struct inode *inode);
	39	extern void v9fs_cache_inode_set_cookie(struct inode inode, struct file filp);
	40	extern void v9fs_cache_inode_reset_cookie(struct inode *inode);
	41
	42	extern int __v9fs_cache_register(void);
	43	extern void __v9fs_cache_unregister(void);
	44
	45	extern int __v9fs_fscache_release_page(struct page *page, gfp_t gfp);
	46	extern void __v9fs_fscache_invalidate_page(struct page *page);
	47	extern int __v9fs_readpage_from_fscache(struct inode *inode,
	48	struct page *page);
	49	extern int __v9fs_readpages_from_fscache(struct inode *inode,
	50	struct address_space *mapping,
	51	struct list_head *pages,
	52	unsigned *nr_pages);
	53	extern void __v9fs_readpage_to_fscache(struct inode inode, struct page page);
2efda799 AK	54	extern void __v9fs_fscache_wait_on_page_write(struct inode *inode,
2efda799 AK	55	struct page *page);
60e78d2c AK	56
	57	static inline int v9fs_fscache_release_page(struct page *page,
	58	gfp_t gfp)
	59	{
	60	return __v9fs_fscache_release_page(page, gfp);
	61	}
	62
	63	static inline void v9fs_fscache_invalidate_page(struct page *page)
	64	{
	65	__v9fs_fscache_invalidate_page(page);
	66	}
	67
	68	static inline int v9fs_readpage_from_fscache(struct inode *inode,
	69	struct page *page)
	70	{
	71	return __v9fs_readpage_from_fscache(inode, page);
	72	}
	73
	74	static inline int v9fs_readpages_from_fscache(struct inode *inode,
	75	struct address_space *mapping,
	76	struct list_head *pages,
	77	unsigned *nr_pages)
	78	{
	79	return __v9fs_readpages_from_fscache(inode, mapping, pages,
	80	nr_pages);
	81	}
	82
	83	static inline void v9fs_readpage_to_fscache(struct inode *inode,
	84	struct page *page)
	85	{
	86	if (PageFsCache(page))
	87	__v9fs_readpage_to_fscache(inode, page);
	88	}
	89
	90	static inline void v9fs_uncache_page(struct inode inode, struct page page)
	91	{
a78ce05d AK	92	struct v9fs_inode *v9inode = V9FS_I(inode);
a78ce05d AK	93	fscache_uncache_page(v9inode->fscache, page);
60e78d2c AK	94	BUG_ON(PageFsCache(page));
	95	}
	96
2efda799 AK	97	static inline void v9fs_fscache_wait_on_page_write(struct inode *inode,
	98	struct page *page)
	99	{
	100	return __v9fs_fscache_wait_on_page_write(inode, page);
	101	}
	102
60e78d2c AK	103	#else /* CONFIG_9P_FSCACHE */
60e78d2c AK	104
ceaec15d AV	105	static inline void v9fs_cache_inode_get_cookie(struct inode *inode)
	106	{
	107	}
	108
	109	static inline void v9fs_cache_inode_put_cookie(struct inode *inode)
	110	{
	111	}
	112
	113	static inline void v9fs_cache_inode_set_cookie(struct inode inode, struct file file)
	114	{
	115	}
	116
60e78d2c AK	117	static inline int v9fs_fscache_release_page(struct page *page,
	118	gfp_t gfp) {
	119	return 1;
	120	}
	121
	122	static inline void v9fs_fscache_invalidate_page(struct page *page) {}
	123
	124	static inline int v9fs_readpage_from_fscache(struct inode *inode,
	125	struct page *page)
	126	{
	127	return -ENOBUFS;
	128	}
	129
	130	static inline int v9fs_readpages_from_fscache(struct inode *inode,
	131	struct address_space *mapping,
	132	struct list_head *pages,
	133	unsigned *nr_pages)
	134	{
	135	return -ENOBUFS;
	136	}
	137
	138	static inline void v9fs_readpage_to_fscache(struct inode *inode,
	139	struct page *page)
	140	{}
	141
	142	static inline void v9fs_uncache_page(struct inode inode, struct page page)
	143	{}
	144
2efda799 AK	145	static inline void v9fs_fscache_wait_on_page_write(struct inode *inode,
	146	struct page *page)
	147	{
	148	return;
	149	}
	150
60e78d2c AK	151	#endif /* CONFIG_9P_FSCACHE */
60e78d2c AK	152	#endif /* _9P_CACHE_H */