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 */ 21 struct 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 */ 64 struct nfs_fscache_inode_auxdata { 65 struct timespec mtime; 66 struct timespec ctime; 67 u64 change_attr; 68 }; 69 70 /* 71 * fscache-index.c 72 */ 73 extern struct fscache_netfs nfs_fscache_netfs; 74 extern const struct fscache_cookie_def nfs_fscache_server_index_def; 75 extern const struct fscache_cookie_def nfs_fscache_super_index_def; 76 extern const struct fscache_cookie_def nfs_fscache_inode_object_def; 77 78 extern int nfs_fscache_register(void); 79 extern void nfs_fscache_unregister(void); 80 81 /* 82 * fscache.c 83 */ 84 extern void nfs_fscache_get_client_cookie(struct nfs_client *); 85 extern void nfs_fscache_release_client_cookie(struct nfs_client *); 86 87 extern void nfs_fscache_get_super_cookie(struct super_block *, const char *, int); 88 extern void nfs_fscache_release_super_cookie(struct super_block *); 89 90 extern void nfs_fscache_init_inode(struct inode *); 91 extern void nfs_fscache_clear_inode(struct inode *); 92 extern void nfs_fscache_open_file(struct inode *, struct file *); 93 94 extern void __nfs_fscache_invalidate_page(struct page *, struct inode *); 95 extern int nfs_fscache_release_page(struct page *, gfp_t); 96 97 extern int __nfs_readpage_from_fscache(struct nfs_open_context *, 98 struct inode *, struct page *); 99 extern int __nfs_readpages_from_fscache(struct nfs_open_context *, 100 struct inode *, struct address_space *, 101 struct list_head *, unsigned *); 102 extern void __nfs_readpage_to_fscache(struct inode *, struct page *, int); 103 104 /* 105 * wait for a page to complete writing to the cache 106 */ 107 static inline void nfs_fscache_wait_on_page_write(struct nfs_inode *nfsi, 108 struct page *page) 109 { 110 if (PageFsCache(page)) 111 fscache_wait_on_page_write(nfsi->fscache, page); 112 } 113 114 /* 115 * release the caching state associated with a page if undergoing complete page 116 * invalidation 117 */ 118 static inline void nfs_fscache_invalidate_page(struct page *page, 119 struct inode *inode) 120 { 121 if (PageFsCache(page)) 122 __nfs_fscache_invalidate_page(page, inode); 123 } 124 125 /* 126 * Retrieve a page from an inode data storage object. 127 */ 128 static inline int nfs_readpage_from_fscache(struct nfs_open_context *ctx, 129 struct inode *inode, 130 struct page *page) 131 { 132 if (NFS_I(inode)->fscache) 133 return __nfs_readpage_from_fscache(ctx, inode, page); 134 return -ENOBUFS; 135 } 136 137 /* 138 * Retrieve a set of pages from an inode data storage object. 139 */ 140 static inline int nfs_readpages_from_fscache(struct nfs_open_context *ctx, 141 struct inode *inode, 142 struct address_space *mapping, 143 struct list_head *pages, 144 unsigned *nr_pages) 145 { 146 if (NFS_I(inode)->fscache) 147 return __nfs_readpages_from_fscache(ctx, inode, mapping, pages, 148 nr_pages); 149 return -ENOBUFS; 150 } 151 152 /* 153 * Store a page newly fetched from the server in an inode data storage object 154 * in the cache. 155 */ 156 static inline void nfs_readpage_to_fscache(struct inode *inode, 157 struct page *page, 158 int sync) 159 { 160 if (PageFsCache(page)) 161 __nfs_readpage_to_fscache(inode, page, sync); 162 } 163 164 /* 165 * Invalidate the contents of fscache for this inode. This will not sleep. 166 */ 167 static inline void nfs_fscache_invalidate(struct inode *inode) 168 { 169 fscache_invalidate(NFS_I(inode)->fscache); 170 } 171 172 /* 173 * Wait for an object to finish being invalidated. 174 */ 175 static inline void nfs_fscache_wait_on_invalidate(struct inode *inode) 176 { 177 fscache_wait_on_invalidate(NFS_I(inode)->fscache); 178 } 179 180 /* 181 * indicate the client caching state as readable text 182 */ 183 static inline const char *nfs_server_fscache_state(struct nfs_server *server) 184 { 185 if (server->fscache) 186 return "yes"; 187 return "no "; 188 } 189 190 #else /* CONFIG_NFS_FSCACHE */ 191 static inline int nfs_fscache_register(void) { return 0; } 192 static inline void nfs_fscache_unregister(void) {} 193 194 static inline void nfs_fscache_get_client_cookie(struct nfs_client *clp) {} 195 static inline void nfs_fscache_release_client_cookie(struct nfs_client *clp) {} 196 197 static inline void nfs_fscache_release_super_cookie(struct super_block *sb) {} 198 199 static inline void nfs_fscache_init_inode(struct inode *inode) {} 200 static inline void nfs_fscache_clear_inode(struct inode *inode) {} 201 static inline void nfs_fscache_open_file(struct inode *inode, 202 struct file *filp) {} 203 204 static inline int nfs_fscache_release_page(struct page *page, gfp_t gfp) 205 { 206 return 1; /* True: may release page */ 207 } 208 static inline void nfs_fscache_invalidate_page(struct page *page, 209 struct inode *inode) {} 210 static inline void nfs_fscache_wait_on_page_write(struct nfs_inode *nfsi, 211 struct page *page) {} 212 213 static inline int nfs_readpage_from_fscache(struct nfs_open_context *ctx, 214 struct inode *inode, 215 struct page *page) 216 { 217 return -ENOBUFS; 218 } 219 static inline int nfs_readpages_from_fscache(struct nfs_open_context *ctx, 220 struct inode *inode, 221 struct address_space *mapping, 222 struct list_head *pages, 223 unsigned *nr_pages) 224 { 225 return -ENOBUFS; 226 } 227 static inline void nfs_readpage_to_fscache(struct inode *inode, 228 struct page *page, int sync) {} 229 230 231 static inline void nfs_fscache_invalidate(struct inode *inode) {} 232 static inline void nfs_fscache_wait_on_invalidate(struct inode *inode) {} 233 234 static inline const char *nfs_server_fscache_state(struct nfs_server *server) 235 { 236 return "no "; 237 } 238 239 #endif /* CONFIG_NFS_FSCACHE */ 240 #endif /* _NFS_FSCACHE_H */ 241