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 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 */ 75 extern struct fscache_netfs nfs_fscache_netfs; 76 extern const struct fscache_cookie_def nfs_fscache_server_index_def; 77 extern const struct fscache_cookie_def nfs_fscache_super_index_def; 78 extern const struct fscache_cookie_def nfs_fscache_inode_object_def; 79 80 extern int nfs_fscache_register(void); 81 extern void nfs_fscache_unregister(void); 82 83 /* 84 * fscache.c 85 */ 86 extern void nfs_fscache_get_client_cookie(struct nfs_client *); 87 extern void nfs_fscache_release_client_cookie(struct nfs_client *); 88 89 extern void nfs_fscache_get_super_cookie(struct super_block *, const char *, int); 90 extern void nfs_fscache_release_super_cookie(struct super_block *); 91 92 extern void nfs_fscache_init_inode(struct inode *); 93 extern void nfs_fscache_clear_inode(struct inode *); 94 extern void nfs_fscache_open_file(struct inode *, struct file *); 95 96 extern void __nfs_fscache_invalidate_page(struct page *, struct inode *); 97 extern int nfs_fscache_release_page(struct page *, gfp_t); 98 99 extern int __nfs_readpage_from_fscache(struct nfs_open_context *, 100 struct inode *, struct page *); 101 extern int __nfs_readpages_from_fscache(struct nfs_open_context *, 102 struct inode *, struct address_space *, 103 struct list_head *, unsigned *); 104 extern void __nfs_readpage_to_fscache(struct inode *, struct page *, int); 105 106 /* 107 * wait for a page to complete writing to the cache 108 */ 109 static 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 */ 120 static 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 */ 130 static 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 */ 142 static 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 */ 158 static 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 */ 169 static 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 */ 177 static 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 */ 185 static 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 */ 193 static inline int nfs_fscache_register(void) { return 0; } 194 static inline void nfs_fscache_unregister(void) {} 195 196 static inline void nfs_fscache_get_client_cookie(struct nfs_client *clp) {} 197 static inline void nfs_fscache_release_client_cookie(struct nfs_client *clp) {} 198 199 static inline void nfs_fscache_release_super_cookie(struct super_block *sb) {} 200 201 static inline void nfs_fscache_init_inode(struct inode *inode) {} 202 static inline void nfs_fscache_clear_inode(struct inode *inode) {} 203 static inline void nfs_fscache_open_file(struct inode *inode, 204 struct file *filp) {} 205 206 static inline int nfs_fscache_release_page(struct page *page, gfp_t gfp) 207 { 208 return 1; /* True: may release page */ 209 } 210 static inline void nfs_fscache_invalidate_page(struct page *page, 211 struct inode *inode) {} 212 static inline void nfs_fscache_wait_on_page_write(struct nfs_inode *nfsi, 213 struct page *page) {} 214 215 static inline int nfs_readpage_from_fscache(struct nfs_open_context *ctx, 216 struct inode *inode, 217 struct page *page) 218 { 219 return -ENOBUFS; 220 } 221 static 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 } 229 static inline void nfs_readpage_to_fscache(struct inode *inode, 230 struct page *page, int sync) {} 231 232 233 static inline void nfs_fscache_invalidate(struct inode *inode) {} 234 static inline void nfs_fscache_wait_on_invalidate(struct inode *inode) {} 235 236 static 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