Branch data Line data Source code
1 : : // SPDX-License-Identifier: GPL-2.0-or-later
2 : : /* NFS filesystem cache interface
3 : : *
4 : : * Copyright (C) 2008 Red Hat, Inc. All Rights Reserved.
5 : : * Written by David Howells (dhowells@redhat.com)
6 : : */
7 : :
8 : : #include <linux/init.h>
9 : : #include <linux/kernel.h>
10 : : #include <linux/sched.h>
11 : : #include <linux/mm.h>
12 : : #include <linux/nfs_fs.h>
13 : : #include <linux/nfs_fs_sb.h>
14 : : #include <linux/in6.h>
15 : : #include <linux/seq_file.h>
16 : : #include <linux/slab.h>
17 : : #include <linux/iversion.h>
18 : :
19 : : #include "internal.h"
20 : : #include "iostat.h"
21 : : #include "fscache.h"
22 : :
23 : : #define NFSDBG_FACILITY NFSDBG_FSCACHE
24 : :
25 : : static struct rb_root nfs_fscache_keys = RB_ROOT;
26 : : static DEFINE_SPINLOCK(nfs_fscache_keys_lock);
27 : :
28 : : /*
29 : : * Layout of the key for an NFS server cache object.
30 : : */
31 : : struct nfs_server_key {
32 : : struct {
33 : : uint16_t nfsversion; /* NFS protocol version */
34 : : uint32_t minorversion; /* NFSv4 minor version */
35 : : uint16_t family; /* address family */
36 : : __be16 port; /* IP port */
37 : : } hdr;
38 : : union {
39 : : struct in_addr ipv4_addr; /* IPv4 address */
40 : : struct in6_addr ipv6_addr; /* IPv6 address */
41 : : };
42 : : } __packed;
43 : :
44 : : /*
45 : : * Get the per-client index cookie for an NFS client if the appropriate mount
46 : : * flag was set
47 : : * - We always try and get an index cookie for the client, but get filehandle
48 : : * cookies on a per-superblock basis, depending on the mount flags
49 : : */
50 : 0 : void nfs_fscache_get_client_cookie(struct nfs_client *clp)
51 : : {
52 : : const struct sockaddr_in6 *sin6 = (struct sockaddr_in6 *) &clp->cl_addr;
53 : : const struct sockaddr_in *sin = (struct sockaddr_in *) &clp->cl_addr;
54 : : struct nfs_server_key key;
55 : : uint16_t len = sizeof(key.hdr);
56 : :
57 : 0 : memset(&key, 0, sizeof(key));
58 : 0 : key.hdr.nfsversion = clp->rpc_ops->version;
59 : 0 : key.hdr.minorversion = clp->cl_minorversion;
60 : 0 : key.hdr.family = clp->cl_addr.ss_family;
61 : :
62 : 0 : switch (clp->cl_addr.ss_family) {
63 : : case AF_INET:
64 : 0 : key.hdr.port = sin->sin_port;
65 : 0 : key.ipv4_addr = sin->sin_addr;
66 : : len += sizeof(key.ipv4_addr);
67 : 0 : break;
68 : :
69 : : case AF_INET6:
70 : 0 : key.hdr.port = sin6->sin6_port;
71 : 0 : key.ipv6_addr = sin6->sin6_addr;
72 : : len += sizeof(key.ipv6_addr);
73 : 0 : break;
74 : :
75 : : default:
76 : 0 : printk(KERN_WARNING "NFS: Unknown network family '%d'\n",
77 : : clp->cl_addr.ss_family);
78 : 0 : clp->fscache = NULL;
79 : 0 : return;
80 : : }
81 : :
82 : : /* create a cache index for looking up filehandles */
83 : 0 : clp->fscache = fscache_acquire_cookie(nfs_fscache_netfs.primary_index,
84 : : &nfs_fscache_server_index_def,
85 : : &key, len,
86 : : NULL, 0,
87 : : clp, 0, true);
88 : : dfprintk(FSCACHE, "NFS: get client cookie (0x%p/0x%p)\n",
89 : : clp, clp->fscache);
90 : : }
91 : :
92 : : /*
93 : : * Dispose of a per-client cookie
94 : : */
95 : 0 : void nfs_fscache_release_client_cookie(struct nfs_client *clp)
96 : : {
97 : : dfprintk(FSCACHE, "NFS: releasing client cookie (0x%p/0x%p)\n",
98 : : clp, clp->fscache);
99 : :
100 : 0 : fscache_relinquish_cookie(clp->fscache, NULL, false);
101 : 0 : clp->fscache = NULL;
102 : 0 : }
103 : :
104 : : /*
105 : : * Get the cache cookie for an NFS superblock. We have to handle
106 : : * uniquification here because the cache doesn't do it for us.
107 : : *
108 : : * The default uniquifier is just an empty string, but it may be overridden
109 : : * either by the 'fsc=xxx' option to mount, or by inheriting it from the parent
110 : : * superblock across an automount point of some nature.
111 : : */
112 : 0 : void nfs_fscache_get_super_cookie(struct super_block *sb, const char *uniq, int ulen)
113 : : {
114 : : struct nfs_fscache_key *key, *xkey;
115 : : struct nfs_server *nfss = NFS_SB(sb);
116 : : struct rb_node **p, *parent;
117 : : int diff;
118 : :
119 : 0 : nfss->fscache_key = NULL;
120 : 0 : nfss->fscache = NULL;
121 : 0 : if (!(nfss->options & NFS_OPTION_FSCACHE))
122 : : return;
123 : 0 : if (!uniq) {
124 : : uniq = "";
125 : : ulen = 1;
126 : : }
127 : :
128 : 0 : key = kzalloc(sizeof(*key) + ulen, GFP_KERNEL);
129 : 0 : if (!key)
130 : : return;
131 : :
132 : 0 : key->nfs_client = nfss->nfs_client;
133 : 0 : key->key.super.s_flags = sb->s_flags & NFS_MS_MASK;
134 : 0 : key->key.nfs_server.flags = nfss->flags;
135 : 0 : key->key.nfs_server.rsize = nfss->rsize;
136 : 0 : key->key.nfs_server.wsize = nfss->wsize;
137 : 0 : key->key.nfs_server.acregmin = nfss->acregmin;
138 : 0 : key->key.nfs_server.acregmax = nfss->acregmax;
139 : 0 : key->key.nfs_server.acdirmin = nfss->acdirmin;
140 : 0 : key->key.nfs_server.acdirmax = nfss->acdirmax;
141 : 0 : key->key.nfs_server.fsid = nfss->fsid;
142 : 0 : key->key.rpc_auth.au_flavor = nfss->client->cl_auth->au_flavor;
143 : :
144 : 0 : key->key.uniq_len = ulen;
145 : 0 : memcpy(key->key.uniquifier, uniq, ulen);
146 : :
147 : : spin_lock(&nfs_fscache_keys_lock);
148 : : p = &nfs_fscache_keys.rb_node;
149 : : parent = NULL;
150 : 0 : while (*p) {
151 : : parent = *p;
152 : : xkey = rb_entry(parent, struct nfs_fscache_key, node);
153 : :
154 : 0 : if (key->nfs_client < xkey->nfs_client)
155 : : goto go_left;
156 : 0 : if (key->nfs_client > xkey->nfs_client)
157 : : goto go_right;
158 : :
159 : 0 : diff = memcmp(&key->key, &xkey->key, sizeof(key->key));
160 : 0 : if (diff < 0)
161 : : goto go_left;
162 : 0 : if (diff > 0)
163 : : goto go_right;
164 : :
165 : 0 : if (key->key.uniq_len == 0)
166 : : goto non_unique;
167 : 0 : diff = memcmp(key->key.uniquifier,
168 : 0 : xkey->key.uniquifier,
169 : : key->key.uniq_len);
170 : 0 : if (diff < 0)
171 : : goto go_left;
172 : 0 : if (diff > 0)
173 : : goto go_right;
174 : : goto non_unique;
175 : :
176 : : go_left:
177 : 0 : p = &(*p)->rb_left;
178 : 0 : continue;
179 : : go_right:
180 : 0 : p = &(*p)->rb_right;
181 : : }
182 : :
183 : 0 : rb_link_node(&key->node, parent, p);
184 : 0 : rb_insert_color(&key->node, &nfs_fscache_keys);
185 : : spin_unlock(&nfs_fscache_keys_lock);
186 : 0 : nfss->fscache_key = key;
187 : :
188 : : /* create a cache index for looking up filehandles */
189 : 0 : nfss->fscache = fscache_acquire_cookie(nfss->nfs_client->fscache,
190 : : &nfs_fscache_super_index_def,
191 : 0 : &key->key,
192 : : sizeof(key->key) + ulen,
193 : : NULL, 0,
194 : : nfss, 0, true);
195 : : dfprintk(FSCACHE, "NFS: get superblock cookie (0x%p/0x%p)\n",
196 : : nfss, nfss->fscache);
197 : 0 : return;
198 : :
199 : : non_unique:
200 : : spin_unlock(&nfs_fscache_keys_lock);
201 : 0 : kfree(key);
202 : 0 : nfss->fscache_key = NULL;
203 : 0 : nfss->fscache = NULL;
204 : 0 : printk(KERN_WARNING "NFS:"
205 : : " Cache request denied due to non-unique superblock keys\n");
206 : : }
207 : :
208 : : /*
209 : : * release a per-superblock cookie
210 : : */
211 : 0 : void nfs_fscache_release_super_cookie(struct super_block *sb)
212 : : {
213 : : struct nfs_server *nfss = NFS_SB(sb);
214 : :
215 : : dfprintk(FSCACHE, "NFS: releasing superblock cookie (0x%p/0x%p)\n",
216 : : nfss, nfss->fscache);
217 : :
218 : 0 : fscache_relinquish_cookie(nfss->fscache, NULL, false);
219 : 0 : nfss->fscache = NULL;
220 : :
221 : 0 : if (nfss->fscache_key) {
222 : : spin_lock(&nfs_fscache_keys_lock);
223 : 0 : rb_erase(&nfss->fscache_key->node, &nfs_fscache_keys);
224 : : spin_unlock(&nfs_fscache_keys_lock);
225 : 0 : kfree(nfss->fscache_key);
226 : 0 : nfss->fscache_key = NULL;
227 : : }
228 : 0 : }
229 : :
230 : 0 : static void nfs_fscache_update_auxdata(struct nfs_fscache_inode_auxdata *auxdata,
231 : : struct nfs_inode *nfsi)
232 : : {
233 : 0 : memset(auxdata, 0, sizeof(*auxdata));
234 : 0 : auxdata->mtime_sec = nfsi->vfs_inode.i_mtime.tv_sec;
235 : 0 : auxdata->mtime_nsec = nfsi->vfs_inode.i_mtime.tv_nsec;
236 : 0 : auxdata->ctime_sec = nfsi->vfs_inode.i_ctime.tv_sec;
237 : 0 : auxdata->ctime_nsec = nfsi->vfs_inode.i_ctime.tv_nsec;
238 : :
239 : 0 : if (NFS_SERVER(&nfsi->vfs_inode)->nfs_client->rpc_ops->version == 4)
240 : 0 : auxdata->change_attr = inode_peek_iversion_raw(&nfsi->vfs_inode);
241 : 0 : }
242 : :
243 : : /*
244 : : * Initialise the per-inode cache cookie pointer for an NFS inode.
245 : : */
246 : 0 : void nfs_fscache_init_inode(struct inode *inode)
247 : : {
248 : : struct nfs_fscache_inode_auxdata auxdata;
249 : : struct nfs_server *nfss = NFS_SERVER(inode);
250 : : struct nfs_inode *nfsi = NFS_I(inode);
251 : :
252 : : nfsi->fscache = NULL;
253 : 0 : if (!(nfss->fscache && S_ISREG(inode->i_mode)))
254 : 0 : return;
255 : :
256 : 0 : nfs_fscache_update_auxdata(&auxdata, nfsi);
257 : :
258 : 0 : nfsi->fscache = fscache_acquire_cookie(NFS_SB(inode->i_sb)->fscache,
259 : : &nfs_fscache_inode_object_def,
260 : 0 : nfsi->fh.data, nfsi->fh.size,
261 : : &auxdata, sizeof(auxdata),
262 : : nfsi, nfsi->vfs_inode.i_size, false);
263 : : }
264 : :
265 : : /*
266 : : * Release a per-inode cookie.
267 : : */
268 : 0 : void nfs_fscache_clear_inode(struct inode *inode)
269 : : {
270 : : struct nfs_fscache_inode_auxdata auxdata;
271 : : struct nfs_inode *nfsi = NFS_I(inode);
272 : : struct fscache_cookie *cookie = nfs_i_fscache(inode);
273 : :
274 : : dfprintk(FSCACHE, "NFS: clear cookie (0x%p/0x%p)\n", nfsi, cookie);
275 : :
276 : 0 : nfs_fscache_update_auxdata(&auxdata, nfsi);
277 : : fscache_relinquish_cookie(cookie, &auxdata, false);
278 : 0 : nfsi->fscache = NULL;
279 : 0 : }
280 : :
281 : 0 : static bool nfs_fscache_can_enable(void *data)
282 : : {
283 : : struct inode *inode = data;
284 : :
285 : 0 : return !inode_is_open_for_write(inode);
286 : : }
287 : :
288 : : /*
289 : : * Enable or disable caching for a file that is being opened as appropriate.
290 : : * The cookie is allocated when the inode is initialised, but is not enabled at
291 : : * that time. Enablement is deferred to file-open time to avoid stat() and
292 : : * access() thrashing the cache.
293 : : *
294 : : * For now, with NFS, only regular files that are open read-only will be able
295 : : * to use the cache.
296 : : *
297 : : * We enable the cache for an inode if we open it read-only and it isn't
298 : : * currently open for writing. We disable the cache if the inode is open
299 : : * write-only.
300 : : *
301 : : * The caller uses the file struct to pin i_writecount on the inode before
302 : : * calling us when a file is opened for writing, so we can make use of that.
303 : : *
304 : : * Note that this may be invoked multiple times in parallel by parallel
305 : : * nfs_open() functions.
306 : : */
307 : 0 : void nfs_fscache_open_file(struct inode *inode, struct file *filp)
308 : : {
309 : : struct nfs_fscache_inode_auxdata auxdata;
310 : : struct nfs_inode *nfsi = NFS_I(inode);
311 : : struct fscache_cookie *cookie = nfs_i_fscache(inode);
312 : :
313 : 0 : if (!fscache_cookie_valid(cookie))
314 : 0 : return;
315 : :
316 : 0 : nfs_fscache_update_auxdata(&auxdata, nfsi);
317 : :
318 : 0 : if (inode_is_open_for_write(inode)) {
319 : : dfprintk(FSCACHE, "NFS: nfsi 0x%p disabling cache\n", nfsi);
320 : 0 : clear_bit(NFS_INO_FSCACHE, &nfsi->flags);
321 : 0 : fscache_disable_cookie(cookie, &auxdata, true);
322 : : fscache_uncache_all_inode_pages(cookie, inode);
323 : : } else {
324 : : dfprintk(FSCACHE, "NFS: nfsi 0x%p enabling cache\n", nfsi);
325 : 0 : fscache_enable_cookie(cookie, &auxdata, nfsi->vfs_inode.i_size,
326 : : nfs_fscache_can_enable, inode);
327 : 0 : if (fscache_cookie_enabled(cookie))
328 : 0 : set_bit(NFS_INO_FSCACHE, &NFS_I(inode)->flags);
329 : : }
330 : : }
331 : : EXPORT_SYMBOL_GPL(nfs_fscache_open_file);
332 : :
333 : : /*
334 : : * Release the caching state associated with a page, if the page isn't busy
335 : : * interacting with the cache.
336 : : * - Returns true (can release page) or false (page busy).
337 : : */
338 : 0 : int nfs_fscache_release_page(struct page *page, gfp_t gfp)
339 : : {
340 : 0 : if (PageFsCache(page)) {
341 : 0 : struct fscache_cookie *cookie = nfs_i_fscache(page->mapping->host);
342 : :
343 : 0 : BUG_ON(!cookie);
344 : : dfprintk(FSCACHE, "NFS: fscache releasepage (0x%p/0x%p/0x%p)\n",
345 : : cookie, page, NFS_I(page->mapping->host));
346 : :
347 : 0 : if (!fscache_maybe_release_page(cookie, page, gfp))
348 : : return 0;
349 : :
350 : 0 : nfs_inc_fscache_stats(page->mapping->host,
351 : : NFSIOS_FSCACHE_PAGES_UNCACHED);
352 : : }
353 : :
354 : : return 1;
355 : : }
356 : :
357 : : /*
358 : : * Release the caching state associated with a page if undergoing complete page
359 : : * invalidation.
360 : : */
361 : 0 : void __nfs_fscache_invalidate_page(struct page *page, struct inode *inode)
362 : : {
363 : : struct fscache_cookie *cookie = nfs_i_fscache(inode);
364 : :
365 : 0 : BUG_ON(!cookie);
366 : :
367 : : dfprintk(FSCACHE, "NFS: fscache invalidatepage (0x%p/0x%p/0x%p)\n",
368 : : cookie, page, NFS_I(inode));
369 : :
370 : : fscache_wait_on_page_write(cookie, page);
371 : :
372 : 0 : BUG_ON(!PageLocked(page));
373 : : fscache_uncache_page(cookie, page);
374 : 0 : nfs_inc_fscache_stats(page->mapping->host,
375 : : NFSIOS_FSCACHE_PAGES_UNCACHED);
376 : 0 : }
377 : :
378 : : /*
379 : : * Handle completion of a page being read from the cache.
380 : : * - Called in process (keventd) context.
381 : : */
382 : 0 : static void nfs_readpage_from_fscache_complete(struct page *page,
383 : : void *context,
384 : : int error)
385 : : {
386 : : dfprintk(FSCACHE,
387 : : "NFS: readpage_from_fscache_complete (0x%p/0x%p/%d)\n",
388 : : page, context, error);
389 : :
390 : : /* if the read completes with an error, we just unlock the page and let
391 : : * the VM reissue the readpage */
392 : 0 : if (!error) {
393 : : SetPageUptodate(page);
394 : 0 : unlock_page(page);
395 : : } else {
396 : 0 : error = nfs_readpage_async(context, page->mapping->host, page);
397 : 0 : if (error)
398 : 0 : unlock_page(page);
399 : : }
400 : 0 : }
401 : :
402 : : /*
403 : : * Retrieve a page from fscache
404 : : */
405 : 0 : int __nfs_readpage_from_fscache(struct nfs_open_context *ctx,
406 : : struct inode *inode, struct page *page)
407 : : {
408 : : int ret;
409 : :
410 : : dfprintk(FSCACHE,
411 : : "NFS: readpage_from_fscache(fsc:%p/p:%p(i:%lx f:%lx)/0x%p)\n",
412 : : nfs_i_fscache(inode), page, page->index, page->flags, inode);
413 : :
414 : 0 : ret = fscache_read_or_alloc_page(nfs_i_fscache(inode),
415 : : page,
416 : : nfs_readpage_from_fscache_complete,
417 : : ctx,
418 : : GFP_KERNEL);
419 : :
420 : 0 : switch (ret) {
421 : : case 0: /* read BIO submitted (page in fscache) */
422 : : dfprintk(FSCACHE,
423 : : "NFS: readpage_from_fscache: BIO submitted\n");
424 : 0 : nfs_inc_fscache_stats(inode, NFSIOS_FSCACHE_PAGES_READ_OK);
425 : 0 : return ret;
426 : :
427 : : case -ENOBUFS: /* inode not in cache */
428 : : case -ENODATA: /* page not in cache */
429 : 0 : nfs_inc_fscache_stats(inode, NFSIOS_FSCACHE_PAGES_READ_FAIL);
430 : : dfprintk(FSCACHE,
431 : : "NFS: readpage_from_fscache %d\n", ret);
432 : 0 : return 1;
433 : :
434 : : default:
435 : : dfprintk(FSCACHE, "NFS: readpage_from_fscache %d\n", ret);
436 : 0 : nfs_inc_fscache_stats(inode, NFSIOS_FSCACHE_PAGES_READ_FAIL);
437 : : }
438 : 0 : return ret;
439 : : }
440 : :
441 : : /*
442 : : * Retrieve a set of pages from fscache
443 : : */
444 : 0 : int __nfs_readpages_from_fscache(struct nfs_open_context *ctx,
445 : : struct inode *inode,
446 : : struct address_space *mapping,
447 : : struct list_head *pages,
448 : : unsigned *nr_pages)
449 : : {
450 : 0 : unsigned npages = *nr_pages;
451 : : int ret;
452 : :
453 : : dfprintk(FSCACHE, "NFS: nfs_getpages_from_fscache (0x%p/%u/0x%p)\n",
454 : : nfs_i_fscache(inode), npages, inode);
455 : :
456 : 0 : ret = fscache_read_or_alloc_pages(nfs_i_fscache(inode),
457 : : mapping, pages, nr_pages,
458 : : nfs_readpage_from_fscache_complete,
459 : : ctx,
460 : : mapping_gfp_mask(mapping));
461 : 0 : if (*nr_pages < npages)
462 : 0 : nfs_add_fscache_stats(inode, NFSIOS_FSCACHE_PAGES_READ_OK,
463 : : npages);
464 : 0 : if (*nr_pages > 0)
465 : 0 : nfs_add_fscache_stats(inode, NFSIOS_FSCACHE_PAGES_READ_FAIL,
466 : : *nr_pages);
467 : :
468 : 0 : switch (ret) {
469 : : case 0: /* read submitted to the cache for all pages */
470 : 0 : BUG_ON(!list_empty(pages));
471 : 0 : BUG_ON(*nr_pages != 0);
472 : : dfprintk(FSCACHE,
473 : : "NFS: nfs_getpages_from_fscache: submitted\n");
474 : :
475 : : return ret;
476 : :
477 : : case -ENOBUFS: /* some pages aren't cached and can't be */
478 : : case -ENODATA: /* some pages aren't cached */
479 : : dfprintk(FSCACHE,
480 : : "NFS: nfs_getpages_from_fscache: no page: %d\n", ret);
481 : : return 1;
482 : :
483 : : default:
484 : : dfprintk(FSCACHE,
485 : : "NFS: nfs_getpages_from_fscache: ret %d\n", ret);
486 : : }
487 : :
488 : 0 : return ret;
489 : : }
490 : :
491 : : /*
492 : : * Store a newly fetched page in fscache
493 : : * - PG_fscache must be set on the page
494 : : */
495 : 0 : void __nfs_readpage_to_fscache(struct inode *inode, struct page *page, int sync)
496 : : {
497 : : int ret;
498 : :
499 : : dfprintk(FSCACHE,
500 : : "NFS: readpage_to_fscache(fsc:%p/p:%p(i:%lx f:%lx)/%d)\n",
501 : : nfs_i_fscache(inode), page, page->index, page->flags, sync);
502 : :
503 : 0 : ret = fscache_write_page(nfs_i_fscache(inode), page,
504 : : inode->i_size, GFP_KERNEL);
505 : : dfprintk(FSCACHE,
506 : : "NFS: readpage_to_fscache: p:%p(i:%lu f:%lx) ret %d\n",
507 : : page, page->index, page->flags, ret);
508 : :
509 : 0 : if (ret != 0) {
510 : : fscache_uncache_page(nfs_i_fscache(inode), page);
511 : 0 : nfs_inc_fscache_stats(inode,
512 : : NFSIOS_FSCACHE_PAGES_WRITTEN_FAIL);
513 : 0 : nfs_inc_fscache_stats(inode, NFSIOS_FSCACHE_PAGES_UNCACHED);
514 : : } else {
515 : 0 : nfs_inc_fscache_stats(inode,
516 : : NFSIOS_FSCACHE_PAGES_WRITTEN_OK);
517 : : }
518 : 0 : }
|
