xref: /openbmc/linux/fs/nfs/fscache.c (revision 8bdc2a19)
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  #include "nfstrace.h"
23  
24  #define NFS_MAX_KEY_LEN 1000
25  
26  static bool nfs_append_int(char *key, int *_len, unsigned long long x)
27  {
28  	if (*_len > NFS_MAX_KEY_LEN)
29  		return false;
30  	if (x == 0)
31  		key[(*_len)++] = ',';
32  	else
33  		*_len += sprintf(key + *_len, ",%llx", x);
34  	return true;
35  }
36  
37  /*
38   * Get the per-client index cookie for an NFS client if the appropriate mount
39   * flag was set
40   * - We always try and get an index cookie for the client, but get filehandle
41   *   cookies on a per-superblock basis, depending on the mount flags
42   */
43  static bool nfs_fscache_get_client_key(struct nfs_client *clp,
44  				       char *key, int *_len)
45  {
46  	const struct sockaddr_in6 *sin6 = (struct sockaddr_in6 *) &clp->cl_addr;
47  	const struct sockaddr_in *sin = (struct sockaddr_in *) &clp->cl_addr;
48  
49  	*_len += snprintf(key + *_len, NFS_MAX_KEY_LEN - *_len,
50  			  ",%u.%u,%x",
51  			  clp->rpc_ops->version,
52  			  clp->cl_minorversion,
53  			  clp->cl_addr.ss_family);
54  
55  	switch (clp->cl_addr.ss_family) {
56  	case AF_INET:
57  		if (!nfs_append_int(key, _len, sin->sin_port) ||
58  		    !nfs_append_int(key, _len, sin->sin_addr.s_addr))
59  			return false;
60  		return true;
61  
62  	case AF_INET6:
63  		if (!nfs_append_int(key, _len, sin6->sin6_port) ||
64  		    !nfs_append_int(key, _len, sin6->sin6_addr.s6_addr32[0]) ||
65  		    !nfs_append_int(key, _len, sin6->sin6_addr.s6_addr32[1]) ||
66  		    !nfs_append_int(key, _len, sin6->sin6_addr.s6_addr32[2]) ||
67  		    !nfs_append_int(key, _len, sin6->sin6_addr.s6_addr32[3]))
68  			return false;
69  		return true;
70  
71  	default:
72  		printk(KERN_WARNING "NFS: Unknown network family '%d'\n",
73  		       clp->cl_addr.ss_family);
74  		return false;
75  	}
76  }
77  
78  /*
79   * Get the cache cookie for an NFS superblock.
80   *
81   * The default uniquifier is just an empty string, but it may be overridden
82   * either by the 'fsc=xxx' option to mount, or by inheriting it from the parent
83   * superblock across an automount point of some nature.
84   */
85  int nfs_fscache_get_super_cookie(struct super_block *sb, const char *uniq, int ulen)
86  {
87  	struct fscache_volume *vcookie;
88  	struct nfs_server *nfss = NFS_SB(sb);
89  	unsigned int len = 3;
90  	char *key;
91  
92  	if (uniq) {
93  		nfss->fscache_uniq = kmemdup_nul(uniq, ulen, GFP_KERNEL);
94  		if (!nfss->fscache_uniq)
95  			return -ENOMEM;
96  	}
97  
98  	key = kmalloc(NFS_MAX_KEY_LEN + 24, GFP_KERNEL);
99  	if (!key)
100  		return -ENOMEM;
101  
102  	memcpy(key, "nfs", 3);
103  	if (!nfs_fscache_get_client_key(nfss->nfs_client, key, &len) ||
104  	    !nfs_append_int(key, &len, nfss->fsid.major) ||
105  	    !nfs_append_int(key, &len, nfss->fsid.minor) ||
106  	    !nfs_append_int(key, &len, sb->s_flags & NFS_SB_MASK) ||
107  	    !nfs_append_int(key, &len, nfss->flags) ||
108  	    !nfs_append_int(key, &len, nfss->rsize) ||
109  	    !nfs_append_int(key, &len, nfss->wsize) ||
110  	    !nfs_append_int(key, &len, nfss->acregmin) ||
111  	    !nfs_append_int(key, &len, nfss->acregmax) ||
112  	    !nfs_append_int(key, &len, nfss->acdirmin) ||
113  	    !nfs_append_int(key, &len, nfss->acdirmax) ||
114  	    !nfs_append_int(key, &len, nfss->client->cl_auth->au_flavor))
115  		goto out;
116  
117  	if (ulen > 0) {
118  		if (ulen > NFS_MAX_KEY_LEN - len)
119  			goto out;
120  		key[len++] = ',';
121  		memcpy(key + len, uniq, ulen);
122  		len += ulen;
123  	}
124  	key[len] = 0;
125  
126  	/* create a cache index for looking up filehandles */
127  	vcookie = fscache_acquire_volume(key,
128  					 NULL, /* preferred_cache */
129  					 NULL, 0 /* coherency_data */);
130  	if (IS_ERR(vcookie)) {
131  		if (vcookie != ERR_PTR(-EBUSY)) {
132  			kfree(key);
133  			return PTR_ERR(vcookie);
134  		}
135  		pr_err("NFS: Cache volume key already in use (%s)\n", key);
136  		vcookie = NULL;
137  	}
138  	nfss->fscache = vcookie;
139  
140  out:
141  	kfree(key);
142  	return 0;
143  }
144  
145  /*
146   * release a per-superblock cookie
147   */
148  void nfs_fscache_release_super_cookie(struct super_block *sb)
149  {
150  	struct nfs_server *nfss = NFS_SB(sb);
151  
152  	fscache_relinquish_volume(nfss->fscache, NULL, false);
153  	nfss->fscache = NULL;
154  	kfree(nfss->fscache_uniq);
155  }
156  
157  /*
158   * Initialise the per-inode cache cookie pointer for an NFS inode.
159   */
160  void nfs_fscache_init_inode(struct inode *inode)
161  {
162  	struct nfs_fscache_inode_auxdata auxdata;
163  	struct nfs_server *nfss = NFS_SERVER(inode);
164  	struct nfs_inode *nfsi = NFS_I(inode);
165  
166  	nfsi->fscache = NULL;
167  	if (!(nfss->fscache && S_ISREG(inode->i_mode)))
168  		return;
169  
170  	nfs_fscache_update_auxdata(&auxdata, inode);
171  
172  	nfsi->fscache = fscache_acquire_cookie(NFS_SB(inode->i_sb)->fscache,
173  					       0,
174  					       nfsi->fh.data, /* index_key */
175  					       nfsi->fh.size,
176  					       &auxdata,      /* aux_data */
177  					       sizeof(auxdata),
178  					       i_size_read(inode));
179  }
180  
181  /*
182   * Release a per-inode cookie.
183   */
184  void nfs_fscache_clear_inode(struct inode *inode)
185  {
186  	struct nfs_inode *nfsi = NFS_I(inode);
187  	struct fscache_cookie *cookie = nfs_i_fscache(inode);
188  
189  	fscache_relinquish_cookie(cookie, false);
190  	nfsi->fscache = NULL;
191  }
192  
193  /*
194   * Enable or disable caching for a file that is being opened as appropriate.
195   * The cookie is allocated when the inode is initialised, but is not enabled at
196   * that time.  Enablement is deferred to file-open time to avoid stat() and
197   * access() thrashing the cache.
198   *
199   * For now, with NFS, only regular files that are open read-only will be able
200   * to use the cache.
201   *
202   * We enable the cache for an inode if we open it read-only and it isn't
203   * currently open for writing.  We disable the cache if the inode is open
204   * write-only.
205   *
206   * The caller uses the file struct to pin i_writecount on the inode before
207   * calling us when a file is opened for writing, so we can make use of that.
208   *
209   * Note that this may be invoked multiple times in parallel by parallel
210   * nfs_open() functions.
211   */
212  void nfs_fscache_open_file(struct inode *inode, struct file *filp)
213  {
214  	struct nfs_fscache_inode_auxdata auxdata;
215  	struct fscache_cookie *cookie = nfs_i_fscache(inode);
216  	bool open_for_write = inode_is_open_for_write(inode);
217  
218  	if (!fscache_cookie_valid(cookie))
219  		return;
220  
221  	fscache_use_cookie(cookie, open_for_write);
222  	if (open_for_write) {
223  		nfs_fscache_update_auxdata(&auxdata, inode);
224  		fscache_invalidate(cookie, &auxdata, i_size_read(inode),
225  				   FSCACHE_INVAL_DIO_WRITE);
226  	}
227  }
228  EXPORT_SYMBOL_GPL(nfs_fscache_open_file);
229  
230  void nfs_fscache_release_file(struct inode *inode, struct file *filp)
231  {
232  	struct nfs_fscache_inode_auxdata auxdata;
233  	struct fscache_cookie *cookie = nfs_i_fscache(inode);
234  
235  	if (fscache_cookie_valid(cookie)) {
236  		nfs_fscache_update_auxdata(&auxdata, inode);
237  		fscache_unuse_cookie(cookie, &auxdata, NULL);
238  	}
239  }
240  
241  /*
242   * Fallback page reading interface.
243   */
244  static int fscache_fallback_read_page(struct inode *inode, struct page *page)
245  {
246  	struct netfs_cache_resources cres;
247  	struct fscache_cookie *cookie = nfs_i_fscache(inode);
248  	struct iov_iter iter;
249  	struct bio_vec bvec[1];
250  	int ret;
251  
252  	memset(&cres, 0, sizeof(cres));
253  	bvec[0].bv_page		= page;
254  	bvec[0].bv_offset	= 0;
255  	bvec[0].bv_len		= PAGE_SIZE;
256  	iov_iter_bvec(&iter, READ, bvec, ARRAY_SIZE(bvec), PAGE_SIZE);
257  
258  	ret = fscache_begin_read_operation(&cres, cookie);
259  	if (ret < 0)
260  		return ret;
261  
262  	ret = fscache_read(&cres, page_offset(page), &iter, NETFS_READ_HOLE_FAIL,
263  			   NULL, NULL);
264  	fscache_end_operation(&cres);
265  	return ret;
266  }
267  
268  /*
269   * Fallback page writing interface.
270   */
271  static int fscache_fallback_write_page(struct inode *inode, struct page *page,
272  				       bool no_space_allocated_yet)
273  {
274  	struct netfs_cache_resources cres;
275  	struct fscache_cookie *cookie = nfs_i_fscache(inode);
276  	struct iov_iter iter;
277  	struct bio_vec bvec[1];
278  	loff_t start = page_offset(page);
279  	size_t len = PAGE_SIZE;
280  	int ret;
281  
282  	memset(&cres, 0, sizeof(cres));
283  	bvec[0].bv_page		= page;
284  	bvec[0].bv_offset	= 0;
285  	bvec[0].bv_len		= PAGE_SIZE;
286  	iov_iter_bvec(&iter, WRITE, bvec, ARRAY_SIZE(bvec), PAGE_SIZE);
287  
288  	ret = fscache_begin_write_operation(&cres, cookie);
289  	if (ret < 0)
290  		return ret;
291  
292  	ret = cres.ops->prepare_write(&cres, &start, &len, i_size_read(inode),
293  				      no_space_allocated_yet);
294  	if (ret == 0)
295  		ret = fscache_write(&cres, page_offset(page), &iter, NULL, NULL);
296  	fscache_end_operation(&cres);
297  	return ret;
298  }
299  
300  /*
301   * Retrieve a page from fscache
302   */
303  int __nfs_fscache_read_page(struct inode *inode, struct page *page)
304  {
305  	int ret;
306  
307  	trace_nfs_fscache_read_page(inode, page);
308  	if (PageChecked(page)) {
309  		ClearPageChecked(page);
310  		ret = 1;
311  		goto out;
312  	}
313  
314  	ret = fscache_fallback_read_page(inode, page);
315  	if (ret < 0) {
316  		nfs_inc_fscache_stats(inode, NFSIOS_FSCACHE_PAGES_READ_FAIL);
317  		SetPageChecked(page);
318  		goto out;
319  	}
320  
321  	/* Read completed synchronously */
322  	nfs_inc_fscache_stats(inode, NFSIOS_FSCACHE_PAGES_READ_OK);
323  	SetPageUptodate(page);
324  	ret = 0;
325  out:
326  	trace_nfs_fscache_read_page_exit(inode, page, ret);
327  	return ret;
328  }
329  
330  /*
331   * Store a newly fetched page in fscache.  We can be certain there's no page
332   * stored in the cache as yet otherwise we would've read it from there.
333   */
334  void __nfs_fscache_write_page(struct inode *inode, struct page *page)
335  {
336  	int ret;
337  
338  	trace_nfs_fscache_write_page(inode, page);
339  
340  	ret = fscache_fallback_write_page(inode, page, true);
341  
342  	if (ret != 0) {
343  		nfs_inc_fscache_stats(inode, NFSIOS_FSCACHE_PAGES_WRITTEN_FAIL);
344  		nfs_inc_fscache_stats(inode, NFSIOS_FSCACHE_PAGES_UNCACHED);
345  	} else {
346  		nfs_inc_fscache_stats(inode, NFSIOS_FSCACHE_PAGES_WRITTEN_OK);
347  	}
348  	trace_nfs_fscache_write_page_exit(inode, page, ret);
349  }
350