1/*
2 *   fs/cifs/fscache.c - CIFS filesystem cache interface
3 *
4 *   Copyright (c) 2010 Novell, Inc.
5 *   Author(s): Suresh Jayaraman (sjayaraman@suse.de>
6 *
7 *   This library is free software; you can redistribute it and/or modify
8 *   it under the terms of the GNU Lesser General Public License as published
9 *   by the Free Software Foundation; either version 2.1 of the License, or
10 *   (at your option) any later version.
11 *
12 *   This library is distributed in the hope that it will be useful,
13 *   but WITHOUT ANY WARRANTY; without even the implied warranty of
14 *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See
15 *   the GNU Lesser General Public License for more details.
16 *
17 *   You should have received a copy of the GNU Lesser General Public License
18 *   along with this library; if not, write to the Free Software
19 *   Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
20 */
21#include "fscache.h"
22#include "cifsglob.h"
23#include "cifs_debug.h"
24#include "cifs_fs_sb.h"
25
26void cifs_fscache_get_client_cookie(struct TCP_Server_Info *server)
27{
28	server->fscache =
29		fscache_acquire_cookie(cifs_fscache_netfs.primary_index,
30				&cifs_fscache_server_index_def, server);
31	cFYI(1, "CIFS: get client cookie (0x%p/0x%p)", server,
32				server->fscache);
33}
34
35void cifs_fscache_release_client_cookie(struct TCP_Server_Info *server)
36{
37	cFYI(1, "CIFS: release client cookie (0x%p/0x%p)", server,
38				server->fscache);
39	fscache_relinquish_cookie(server->fscache, 0);
40	server->fscache = NULL;
41}
42
43void cifs_fscache_get_super_cookie(struct cifsTconInfo *tcon)
44{
45	struct TCP_Server_Info *server = tcon->ses->server;
46
47	tcon->fscache =
48		fscache_acquire_cookie(server->fscache,
49				&cifs_fscache_super_index_def, tcon);
50	cFYI(1, "CIFS: get superblock cookie (0x%p/0x%p)",
51				server->fscache, tcon->fscache);
52}
53
54void cifs_fscache_release_super_cookie(struct cifsTconInfo *tcon)
55{
56	cFYI(1, "CIFS: releasing superblock cookie (0x%p)", tcon->fscache);
57	fscache_relinquish_cookie(tcon->fscache, 0);
58	tcon->fscache = NULL;
59}
60
61static void cifs_fscache_enable_inode_cookie(struct inode *inode)
62{
63	struct cifsInodeInfo *cifsi = CIFS_I(inode);
64	struct cifs_sb_info *cifs_sb = CIFS_SB(inode->i_sb);
65
66	if (cifsi->fscache)
67		return;
68
69	cifsi->fscache = fscache_acquire_cookie(cifs_sb->tcon->fscache,
70				&cifs_fscache_inode_object_def,
71				cifsi);
72	cFYI(1, "CIFS: got FH cookie (0x%p/0x%p)",
73			cifs_sb->tcon->fscache, cifsi->fscache);
74}
75
76void cifs_fscache_release_inode_cookie(struct inode *inode)
77{
78	struct cifsInodeInfo *cifsi = CIFS_I(inode);
79
80	if (cifsi->fscache) {
81		cFYI(1, "CIFS releasing inode cookie (0x%p)",
82				cifsi->fscache);
83		fscache_relinquish_cookie(cifsi->fscache, 0);
84		cifsi->fscache = NULL;
85	}
86}
87
88static void cifs_fscache_disable_inode_cookie(struct inode *inode)
89{
90	struct cifsInodeInfo *cifsi = CIFS_I(inode);
91
92	if (cifsi->fscache) {
93		cFYI(1, "CIFS disabling inode cookie (0x%p)",
94				cifsi->fscache);
95		fscache_relinquish_cookie(cifsi->fscache, 1);
96		cifsi->fscache = NULL;
97	}
98}
99
100void cifs_fscache_set_inode_cookie(struct inode *inode, struct file *filp)
101{
102	if ((filp->f_flags & O_ACCMODE) != O_RDONLY)
103		cifs_fscache_disable_inode_cookie(inode);
104	else {
105		cifs_fscache_enable_inode_cookie(inode);
106		cFYI(1, "CIFS: fscache inode cookie set");
107	}
108}
109
110void cifs_fscache_reset_inode_cookie(struct inode *inode)
111{
112	struct cifsInodeInfo *cifsi = CIFS_I(inode);
113	struct cifs_sb_info *cifs_sb = CIFS_SB(inode->i_sb);
114	struct fscache_cookie *old = cifsi->fscache;
115
116	if (cifsi->fscache) {
117		/* retire the current fscache cache and get a new one */
118		fscache_relinquish_cookie(cifsi->fscache, 1);
119
120		cifsi->fscache = fscache_acquire_cookie(cifs_sb->tcon->fscache,
121					&cifs_fscache_inode_object_def,
122					cifsi);
123		cFYI(1, "CIFS: new cookie 0x%p oldcookie 0x%p",
124				cifsi->fscache, old);
125	}
126}
127
128int cifs_fscache_release_page(struct page *page, gfp_t gfp)
129{
130	if (PageFsCache(page)) {
131		struct inode *inode = page->mapping->host;
132		struct cifsInodeInfo *cifsi = CIFS_I(inode);
133
134		cFYI(1, "CIFS: fscache release page (0x%p/0x%p)",
135				page, cifsi->fscache);
136		if (!fscache_maybe_release_page(cifsi->fscache, page, gfp))
137			return 0;
138	}
139
140	return 1;
141}
142
143static void cifs_readpage_from_fscache_complete(struct page *page, void *ctx,
144						int error)
145{
146	cFYI(1, "CFS: readpage_from_fscache_complete (0x%p/%d)",
147			page, error);
148	if (!error)
149		SetPageUptodate(page);
150	unlock_page(page);
151}
152
153/*
154 * Retrieve a page from FS-Cache
155 */
156int __cifs_readpage_from_fscache(struct inode *inode, struct page *page)
157{
158	int ret;
159
160	cFYI(1, "CIFS: readpage_from_fscache(fsc:%p, p:%p, i:0x%p",
161			CIFS_I(inode)->fscache, page, inode);
162	ret = fscache_read_or_alloc_page(CIFS_I(inode)->fscache, page,
163					 cifs_readpage_from_fscache_complete,
164					 NULL,
165					 GFP_KERNEL);
166	switch (ret) {
167
168	case 0: /* page found in fscache, read submitted */
169		cFYI(1, "CIFS: readpage_from_fscache: submitted");
170		return ret;
171	case -ENOBUFS:	/* page won't be cached */
172	case -ENODATA:	/* page not in cache */
173		cFYI(1, "CIFS: readpage_from_fscache %d", ret);
174		return 1;
175
176	default:
177		cERROR(1, "unknown error ret = %d", ret);
178	}
179	return ret;
180}
181
182/*
183 * Retrieve a set of pages from FS-Cache
184 */
185int __cifs_readpages_from_fscache(struct inode *inode,
186				struct address_space *mapping,
187				struct list_head *pages,
188				unsigned *nr_pages)
189{
190	int ret;
191
192	cFYI(1, "CIFS: __cifs_readpages_from_fscache (0x%p/%u/0x%p)",
193			CIFS_I(inode)->fscache, *nr_pages, inode);
194	ret = fscache_read_or_alloc_pages(CIFS_I(inode)->fscache, mapping,
195					  pages, nr_pages,
196					  cifs_readpage_from_fscache_complete,
197					  NULL,
198					  mapping_gfp_mask(mapping));
199	switch (ret) {
200	case 0:	/* read submitted to the cache for all pages */
201		cFYI(1, "CIFS: readpages_from_fscache: submitted");
202		return ret;
203
204	case -ENOBUFS:	/* some pages are not cached and can't be */
205	case -ENODATA:	/* some pages are not cached */
206		cFYI(1, "CIFS: readpages_from_fscache: no page");
207		return 1;
208
209	default:
210		cFYI(1, "unknown error ret = %d", ret);
211	}
212
213	return ret;
214}
215
216void __cifs_readpage_to_fscache(struct inode *inode, struct page *page)
217{
218	int ret;
219
220	cFYI(1, "CIFS: readpage_to_fscache(fsc: %p, p: %p, i: %p",
221			CIFS_I(inode)->fscache, page, inode);
222	ret = fscache_write_page(CIFS_I(inode)->fscache, page, GFP_KERNEL);
223	if (ret != 0)
224		fscache_uncache_page(CIFS_I(inode)->fscache, page);
225}
226
227void __cifs_fscache_invalidate_page(struct page *page, struct inode *inode)
228{
229	struct cifsInodeInfo *cifsi = CIFS_I(inode);
230	struct fscache_cookie *cookie = cifsi->fscache;
231
232	cFYI(1, "CIFS: fscache invalidatepage (0x%p/0x%p)", page, cookie);
233	fscache_wait_on_page_write(cookie, page);
234	fscache_uncache_page(cookie, page);
235}
236