1/* SPDX-License-Identifier: GPL-2.0-or-later */ 2/* NFS filesystem cache interface definitions 3 * 4 * Copyright (C) 2008 Red Hat, Inc. All Rights Reserved. 5 * Written by David Howells (dhowells@redhat.com) 6 */ 7 8#ifndef _NFS_FSCACHE_H 9#define _NFS_FSCACHE_H 10 11#include <linux/nfs_fs.h> 12#include <linux/nfs_mount.h> 13#include <linux/nfs4_mount.h> 14#include <linux/fscache.h> 15 16#ifdef CONFIG_NFS_FSCACHE 17 18/* 19 * set of NFS FS-Cache objects that form a superblock key 20 */ 21struct nfs_fscache_key { 22 struct rb_node node; 23 struct nfs_client *nfs_client; /* the server */ 24 25 /* the elements of the unique key - as used by nfs_compare_super() and 26 * nfs_compare_mount_options() to distinguish superblocks */ 27 struct { 28 struct { 29 unsigned long s_flags; /* various flags 30 * (& NFS_MS_MASK) */ 31 } super; 32 33 struct { 34 struct nfs_fsid fsid; 35 int flags; 36 unsigned int rsize; /* read size */ 37 unsigned int wsize; /* write size */ 38 unsigned int acregmin; /* attr cache timeouts */ 39 unsigned int acregmax; 40 unsigned int acdirmin; 41 unsigned int acdirmax; 42 } nfs_server; 43 44 struct { 45 rpc_authflavor_t au_flavor; 46 } rpc_auth; 47 48 /* uniquifier - can be used if nfs_server.flags includes 49 * NFS_MOUNT_UNSHARED */ 50 u8 uniq_len; 51 char uniquifier[0]; 52 } key; 53}; 54 55/* 56 * Definition of the auxiliary data attached to NFS inode storage objects 57 * within the cache. 58 * 59 * The contents of this struct are recorded in the on-disk local cache in the 60 * auxiliary data attached to the data storage object backing an inode. This 61 * permits coherency to be managed when a new inode binds to an already extant 62 * cache object. 63 */ 64struct nfs_fscache_inode_auxdata { 65 s64 mtime_sec; 66 s64 mtime_nsec; 67 s64 ctime_sec; 68 s64 ctime_nsec; 69 u64 change_attr; 70}; 71 72/* 73 * fscache-index.c 74 */ 75extern struct fscache_netfs nfs_fscache_netfs; 76extern const struct fscache_cookie_def nfs_fscache_server_index_def; 77extern const struct fscache_cookie_def nfs_fscache_super_index_def; 78extern const struct fscache_cookie_def nfs_fscache_inode_object_def; 79 80extern int nfs_fscache_register(void); 81extern void nfs_fscache_unregister(void); 82 83/* 84 * fscache.c 85 */ 86extern void nfs_fscache_get_client_cookie(struct nfs_client *); 87extern void nfs_fscache_release_client_cookie(struct nfs_client *); 88 89extern void nfs_fscache_get_super_cookie(struct super_block *, const char *, int); 90extern void nfs_fscache_release_super_cookie(struct super_block *); 91 92extern void nfs_fscache_init_inode(struct inode *); 93extern void nfs_fscache_clear_inode(struct inode *); 94extern void nfs_fscache_open_file(struct inode *, struct file *); 95 96extern void __nfs_fscache_invalidate_page(struct page *, struct inode *); 97extern int nfs_fscache_release_page(struct page *, gfp_t); 98 99extern int __nfs_readpage_from_fscache(struct nfs_open_context *, 100 struct inode *, struct page *); 101extern int __nfs_readpages_from_fscache(struct nfs_open_context *, 102 struct inode *, struct address_space *, 103 struct list_head *, unsigned *); 104extern void __nfs_readpage_to_fscache(struct inode *, struct page *, int); 105 106/* 107 * wait for a page to complete writing to the cache 108 */ 109static inline void nfs_fscache_wait_on_page_write(struct nfs_inode *nfsi, 110 struct page *page) 111{ 112 if (PageFsCache(page)) 113 fscache_wait_on_page_write(nfsi->fscache, page); 114} 115 116/* 117 * release the caching state associated with a page if undergoing complete page 118 * invalidation 119 */ 120static inline void nfs_fscache_invalidate_page(struct page *page, 121 struct inode *inode) 122{ 123 if (PageFsCache(page)) 124 __nfs_fscache_invalidate_page(page, inode); 125} 126 127/* 128 * Retrieve a page from an inode data storage object. 129 */ 130static inline int nfs_readpage_from_fscache(struct nfs_open_context *ctx, 131 struct inode *inode, 132 struct page *page) 133{ 134 if (NFS_I(inode)->fscache) 135 return __nfs_readpage_from_fscache(ctx, inode, page); 136 return -ENOBUFS; 137} 138 139/* 140 * Retrieve a set of pages from an inode data storage object. 141 */ 142static inline int nfs_readpages_from_fscache(struct nfs_open_context *ctx, 143 struct inode *inode, 144 struct address_space *mapping, 145 struct list_head *pages, 146 unsigned *nr_pages) 147{ 148 if (NFS_I(inode)->fscache) 149 return __nfs_readpages_from_fscache(ctx, inode, mapping, pages, 150 nr_pages); 151 return -ENOBUFS; 152} 153 154/* 155 * Store a page newly fetched from the server in an inode data storage object 156 * in the cache. 157 */ 158static inline void nfs_readpage_to_fscache(struct inode *inode, 159 struct page *page, 160 int sync) 161{ 162 if (PageFsCache(page)) 163 __nfs_readpage_to_fscache(inode, page, sync); 164} 165 166/* 167 * Invalidate the contents of fscache for this inode. This will not sleep. 168 */ 169static inline void nfs_fscache_invalidate(struct inode *inode) 170{ 171 fscache_invalidate(NFS_I(inode)->fscache); 172} 173 174/* 175 * Wait for an object to finish being invalidated. 176 */ 177static inline void nfs_fscache_wait_on_invalidate(struct inode *inode) 178{ 179 fscache_wait_on_invalidate(NFS_I(inode)->fscache); 180} 181 182/* 183 * indicate the client caching state as readable text 184 */ 185static inline const char *nfs_server_fscache_state(struct nfs_server *server) 186{ 187 if (server->fscache) 188 return "yes"; 189 return "no "; 190} 191 192#else /* CONFIG_NFS_FSCACHE */ 193static inline int nfs_fscache_register(void) { return 0; } 194static inline void nfs_fscache_unregister(void) {} 195 196static inline void nfs_fscache_get_client_cookie(struct nfs_client *clp) {} 197static inline void nfs_fscache_release_client_cookie(struct nfs_client *clp) {} 198 199static inline void nfs_fscache_release_super_cookie(struct super_block *sb) {} 200 201static inline void nfs_fscache_init_inode(struct inode *inode) {} 202static inline void nfs_fscache_clear_inode(struct inode *inode) {} 203static inline void nfs_fscache_open_file(struct inode *inode, 204 struct file *filp) {} 205 206static inline int nfs_fscache_release_page(struct page *page, gfp_t gfp) 207{ 208 return 1; /* True: may release page */ 209} 210static inline void nfs_fscache_invalidate_page(struct page *page, 211 struct inode *inode) {} 212static inline void nfs_fscache_wait_on_page_write(struct nfs_inode *nfsi, 213 struct page *page) {} 214 215static inline int nfs_readpage_from_fscache(struct nfs_open_context *ctx, 216 struct inode *inode, 217 struct page *page) 218{ 219 return -ENOBUFS; 220} 221static inline int nfs_readpages_from_fscache(struct nfs_open_context *ctx, 222 struct inode *inode, 223 struct address_space *mapping, 224 struct list_head *pages, 225 unsigned *nr_pages) 226{ 227 return -ENOBUFS; 228} 229static inline void nfs_readpage_to_fscache(struct inode *inode, 230 struct page *page, int sync) {} 231 232 233static inline void nfs_fscache_invalidate(struct inode *inode) {} 234static inline void nfs_fscache_wait_on_invalidate(struct inode *inode) {} 235 236static inline const char *nfs_server_fscache_state(struct nfs_server *server) 237{ 238 return "no "; 239} 240 241#endif /* CONFIG_NFS_FSCACHE */ 242#endif /* _NFS_FSCACHE_H */ 243