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