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