1 /* NFS FS-Cache index structure definition
3 * Copyright (C) 2008 Red Hat, Inc. All Rights Reserved.
4 * Written by David Howells (dhowells@redhat.com)
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.
12 #include <linux/init.h>
13 #include <linux/kernel.h>
14 #include <linux/sched.h>
16 #include <linux/nfs_fs.h>
17 #include <linux/nfs_fs_sb.h>
18 #include <linux/in6.h>
23 #define NFSDBG_FACILITY NFSDBG_FSCACHE
26 * Define the NFS filesystem for FS-Cache. Upon registration FS-Cache sticks
27 * the cookie for the top-level index object for NFS into here. The top-level
28 * index can than have other cache objects inserted into it.
30 struct fscache_netfs nfs_fscache_netfs
= {
36 * Register NFS for caching
38 int nfs_fscache_register(void)
40 return fscache_register_netfs(&nfs_fscache_netfs
);
44 * Unregister NFS for caching
46 void nfs_fscache_unregister(void)
48 fscache_unregister_netfs(&nfs_fscache_netfs
);
52 * Layout of the key for an NFS server cache object.
54 struct nfs_server_key
{
55 uint16_t nfsversion
; /* NFS protocol version */
56 uint16_t family
; /* address family */
57 uint16_t port
; /* IP port */
59 struct in_addr ipv4_addr
; /* IPv4 address */
60 struct in6_addr ipv6_addr
; /* IPv6 address */
65 * Generate a key to describe a server in the main NFS index
66 * - We return the length of the key, or 0 if we can't generate one
68 static uint16_t nfs_server_get_key(const void *cookie_netfs_data
,
69 void *buffer
, uint16_t bufmax
)
71 const struct nfs_client
*clp
= cookie_netfs_data
;
72 const struct sockaddr_in6
*sin6
= (struct sockaddr_in6
*) &clp
->cl_addr
;
73 const struct sockaddr_in
*sin
= (struct sockaddr_in
*) &clp
->cl_addr
;
74 struct nfs_server_key
*key
= buffer
;
75 uint16_t len
= sizeof(struct nfs_server_key
);
77 key
->nfsversion
= clp
->rpc_ops
->version
;
78 key
->family
= clp
->cl_addr
.ss_family
;
82 switch (clp
->cl_addr
.ss_family
) {
84 key
->port
= sin
->sin_port
;
85 key
->addr
[0].ipv4_addr
= sin
->sin_addr
;
86 len
+= sizeof(key
->addr
[0].ipv4_addr
);
90 key
->port
= sin6
->sin6_port
;
91 key
->addr
[0].ipv6_addr
= sin6
->sin6_addr
;
92 len
+= sizeof(key
->addr
[0].ipv6_addr
);
96 printk(KERN_WARNING
"NFS: Unknown network family '%d'\n",
97 clp
->cl_addr
.ss_family
);
106 * Define the server object for FS-Cache. This is used to describe a server
107 * object to fscache_acquire_cookie(). It is keyed by the NFS protocol and
108 * server address parameters.
110 const struct fscache_cookie_def nfs_fscache_server_index_def
= {
111 .name
= "NFS.server",
112 .type
= FSCACHE_COOKIE_TYPE_INDEX
,
113 .get_key
= nfs_server_get_key
,
117 * Generate a key to describe a superblock key in the main NFS index
119 static uint16_t nfs_super_get_key(const void *cookie_netfs_data
,
120 void *buffer
, uint16_t bufmax
)
122 const struct nfs_fscache_key
*key
;
123 const struct nfs_server
*nfss
= cookie_netfs_data
;
126 key
= nfss
->fscache_key
;
127 len
= sizeof(key
->key
) + key
->key
.uniq_len
;
131 memcpy(buffer
, &key
->key
, sizeof(key
->key
));
132 memcpy(buffer
+ sizeof(key
->key
),
133 key
->key
.uniquifier
, key
->key
.uniq_len
);
140 * Define the superblock object for FS-Cache. This is used to describe a
141 * superblock object to fscache_acquire_cookie(). It is keyed by all the NFS
142 * parameters that might cause a separate superblock.
144 const struct fscache_cookie_def nfs_fscache_super_index_def
= {
146 .type
= FSCACHE_COOKIE_TYPE_INDEX
,
147 .get_key
= nfs_super_get_key
,
151 * Definition of the auxiliary data attached to NFS inode storage objects
154 * The contents of this struct are recorded in the on-disk local cache in the
155 * auxiliary data attached to the data storage object backing an inode. This
156 * permits coherency to be managed when a new inode binds to an already extant
159 struct nfs_fscache_inode_auxdata
{
160 struct timespec mtime
;
161 struct timespec ctime
;
167 * Generate a key to describe an NFS inode in an NFS server's index
169 static uint16_t nfs_fscache_inode_get_key(const void *cookie_netfs_data
,
170 void *buffer
, uint16_t bufmax
)
172 const struct nfs_inode
*nfsi
= cookie_netfs_data
;
175 /* use the inode's NFS filehandle as the key */
176 nsize
= nfsi
->fh
.size
;
177 memcpy(buffer
, nfsi
->fh
.data
, nsize
);
182 * Get certain file attributes from the netfs data
183 * - This function can be absent for an index
184 * - Not permitted to return an error
185 * - The netfs data from the cookie being used as the source is presented
187 static void nfs_fscache_inode_get_attr(const void *cookie_netfs_data
,
190 const struct nfs_inode
*nfsi
= cookie_netfs_data
;
192 *size
= nfsi
->vfs_inode
.i_size
;
196 * Get the auxiliary data from netfs data
197 * - This function can be absent if the index carries no state data
198 * - Should store the auxiliary data in the buffer
199 * - Should return the amount of amount stored
200 * - Not permitted to return an error
201 * - The netfs data from the cookie being used as the source is presented
203 static uint16_t nfs_fscache_inode_get_aux(const void *cookie_netfs_data
,
204 void *buffer
, uint16_t bufmax
)
206 struct nfs_fscache_inode_auxdata auxdata
;
207 const struct nfs_inode
*nfsi
= cookie_netfs_data
;
209 memset(&auxdata
, 0, sizeof(auxdata
));
210 auxdata
.size
= nfsi
->vfs_inode
.i_size
;
211 auxdata
.mtime
= nfsi
->vfs_inode
.i_mtime
;
212 auxdata
.ctime
= nfsi
->vfs_inode
.i_ctime
;
214 if (NFS_SERVER(&nfsi
->vfs_inode
)->nfs_client
->rpc_ops
->version
== 4)
215 auxdata
.change_attr
= nfsi
->change_attr
;
217 if (bufmax
> sizeof(auxdata
))
218 bufmax
= sizeof(auxdata
);
220 memcpy(buffer
, &auxdata
, bufmax
);
225 * Consult the netfs about the state of an object
226 * - This function can be absent if the index carries no state data
227 * - The netfs data from the cookie being used as the target is
228 * presented, as is the auxiliary data
231 enum fscache_checkaux
nfs_fscache_inode_check_aux(void *cookie_netfs_data
,
235 struct nfs_fscache_inode_auxdata auxdata
;
236 struct nfs_inode
*nfsi
= cookie_netfs_data
;
238 if (datalen
!= sizeof(auxdata
))
239 return FSCACHE_CHECKAUX_OBSOLETE
;
241 memset(&auxdata
, 0, sizeof(auxdata
));
242 auxdata
.size
= nfsi
->vfs_inode
.i_size
;
243 auxdata
.mtime
= nfsi
->vfs_inode
.i_mtime
;
244 auxdata
.ctime
= nfsi
->vfs_inode
.i_ctime
;
246 if (NFS_SERVER(&nfsi
->vfs_inode
)->nfs_client
->rpc_ops
->version
== 4)
247 auxdata
.change_attr
= nfsi
->change_attr
;
249 if (memcmp(data
, &auxdata
, datalen
) != 0)
250 return FSCACHE_CHECKAUX_OBSOLETE
;
252 return FSCACHE_CHECKAUX_OKAY
;
256 * Indication from FS-Cache that the cookie is no longer cached
257 * - This function is called when the backing store currently caching a cookie
259 * - The netfs should use this to clean up any markers indicating cached pages
260 * - This is mandatory for any object that may have data
262 static void nfs_fscache_inode_now_uncached(void *cookie_netfs_data
)
264 struct nfs_inode
*nfsi
= cookie_netfs_data
;
269 pagevec_init(&pvec
, 0);
272 dprintk("NFS: nfs_inode_now_uncached: nfs_inode 0x%p\n", nfsi
);
275 /* grab a bunch of pages to unmark */
276 nr_pages
= pagevec_lookup(&pvec
,
277 nfsi
->vfs_inode
.i_mapping
,
279 PAGEVEC_SIZE
- pagevec_count(&pvec
));
283 for (loop
= 0; loop
< nr_pages
; loop
++)
284 ClearPageFsCache(pvec
.pages
[loop
]);
286 first
= pvec
.pages
[nr_pages
- 1]->index
+ 1;
289 pagevec_release(&pvec
);
295 * Get an extra reference on a read context.
296 * - This function can be absent if the completion function doesn't require a
298 * - The read context is passed back to NFS in the event that a data read on the
299 * cache fails with EIO - in which case the server must be contacted to
300 * retrieve the data, which requires the read context for security.
302 static void nfs_fh_get_context(void *cookie_netfs_data
, void *context
)
304 get_nfs_open_context(context
);
308 * Release an extra reference on a read context.
309 * - This function can be absent if the completion function doesn't require a
312 static void nfs_fh_put_context(void *cookie_netfs_data
, void *context
)
315 put_nfs_open_context(context
);
319 * Define the inode object for FS-Cache. This is used to describe an inode
320 * object to fscache_acquire_cookie(). It is keyed by the NFS file handle for
323 * Coherency is managed by comparing the copies of i_size, i_mtime and i_ctime
324 * held in the cache auxiliary data for the data storage object with those in
325 * the inode struct in memory.
327 const struct fscache_cookie_def nfs_fscache_inode_object_def
= {
329 .type
= FSCACHE_COOKIE_TYPE_DATAFILE
,
330 .get_key
= nfs_fscache_inode_get_key
,
331 .get_attr
= nfs_fscache_inode_get_attr
,
332 .get_aux
= nfs_fscache_inode_get_aux
,
333 .check_aux
= nfs_fscache_inode_check_aux
,
334 .now_uncached
= nfs_fscache_inode_now_uncached
,
335 .get_context
= nfs_fh_get_context
,
336 .put_context
= nfs_fh_put_context
,