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
);
78 key
->nfsversion
= clp
->rpc_ops
->version
;
79 key
->family
= clp
->cl_addr
.ss_family
;
81 switch (clp
->cl_addr
.ss_family
) {
83 key
->port
= sin
->sin_port
;
84 key
->addr
[0].ipv4_addr
= sin
->sin_addr
;
85 len
+= sizeof(key
->addr
[0].ipv4_addr
);
89 key
->port
= sin6
->sin6_port
;
90 key
->addr
[0].ipv6_addr
= sin6
->sin6_addr
;
91 len
+= sizeof(key
->addr
[0].ipv6_addr
);
95 printk(KERN_WARNING
"NFS: Unknown network family '%d'\n",
96 clp
->cl_addr
.ss_family
);
105 * Define the server object for FS-Cache. This is used to describe a server
106 * object to fscache_acquire_cookie(). It is keyed by the NFS protocol and
107 * server address parameters.
109 const struct fscache_cookie_def nfs_fscache_server_index_def
= {
110 .name
= "NFS.server",
111 .type
= FSCACHE_COOKIE_TYPE_INDEX
,
112 .get_key
= nfs_server_get_key
,
116 * Generate a key to describe a superblock key in the main NFS index
118 static uint16_t nfs_super_get_key(const void *cookie_netfs_data
,
119 void *buffer
, uint16_t bufmax
)
121 const struct nfs_fscache_key
*key
;
122 const struct nfs_server
*nfss
= cookie_netfs_data
;
125 key
= nfss
->fscache_key
;
126 len
= sizeof(key
->key
) + key
->key
.uniq_len
;
130 memcpy(buffer
, &key
->key
, sizeof(key
->key
));
131 memcpy(buffer
+ sizeof(key
->key
),
132 key
->key
.uniquifier
, key
->key
.uniq_len
);
139 * Define the superblock object for FS-Cache. This is used to describe a
140 * superblock object to fscache_acquire_cookie(). It is keyed by all the NFS
141 * parameters that might cause a separate superblock.
143 const struct fscache_cookie_def nfs_fscache_super_index_def
= {
145 .type
= FSCACHE_COOKIE_TYPE_INDEX
,
146 .get_key
= nfs_super_get_key
,
150 * Definition of the auxiliary data attached to NFS inode storage objects
153 * The contents of this struct are recorded in the on-disk local cache in the
154 * auxiliary data attached to the data storage object backing an inode. This
155 * permits coherency to be managed when a new inode binds to an already extant
158 struct nfs_fscache_inode_auxdata
{
159 struct timespec mtime
;
160 struct timespec ctime
;
166 * Generate a key to describe an NFS inode in an NFS server's index
168 static uint16_t nfs_fscache_inode_get_key(const void *cookie_netfs_data
,
169 void *buffer
, uint16_t bufmax
)
171 const struct nfs_inode
*nfsi
= cookie_netfs_data
;
174 /* use the inode's NFS filehandle as the key */
175 nsize
= nfsi
->fh
.size
;
176 memcpy(buffer
, nfsi
->fh
.data
, nsize
);
181 * Get certain file attributes from the netfs data
182 * - This function can be absent for an index
183 * - Not permitted to return an error
184 * - The netfs data from the cookie being used as the source is presented
186 static void nfs_fscache_inode_get_attr(const void *cookie_netfs_data
,
189 const struct nfs_inode
*nfsi
= cookie_netfs_data
;
191 *size
= nfsi
->vfs_inode
.i_size
;
195 * Get the auxiliary data from netfs data
196 * - This function can be absent if the index carries no state data
197 * - Should store the auxiliary data in the buffer
198 * - Should return the amount of amount stored
199 * - Not permitted to return an error
200 * - The netfs data from the cookie being used as the source is presented
202 static uint16_t nfs_fscache_inode_get_aux(const void *cookie_netfs_data
,
203 void *buffer
, uint16_t bufmax
)
205 struct nfs_fscache_inode_auxdata auxdata
;
206 const struct nfs_inode
*nfsi
= cookie_netfs_data
;
208 memset(&auxdata
, 0, sizeof(auxdata
));
209 auxdata
.size
= nfsi
->vfs_inode
.i_size
;
210 auxdata
.mtime
= nfsi
->vfs_inode
.i_mtime
;
211 auxdata
.ctime
= nfsi
->vfs_inode
.i_ctime
;
213 if (NFS_SERVER(&nfsi
->vfs_inode
)->nfs_client
->rpc_ops
->version
== 4)
214 auxdata
.change_attr
= nfsi
->vfs_inode
.i_version
;
216 if (bufmax
> sizeof(auxdata
))
217 bufmax
= sizeof(auxdata
);
219 memcpy(buffer
, &auxdata
, bufmax
);
224 * Consult the netfs about the state of an object
225 * - This function can be absent if the index carries no state data
226 * - The netfs data from the cookie being used as the target is
227 * presented, as is the auxiliary data
230 enum fscache_checkaux
nfs_fscache_inode_check_aux(void *cookie_netfs_data
,
234 struct nfs_fscache_inode_auxdata auxdata
;
235 struct nfs_inode
*nfsi
= cookie_netfs_data
;
237 if (datalen
!= sizeof(auxdata
))
238 return FSCACHE_CHECKAUX_OBSOLETE
;
240 memset(&auxdata
, 0, sizeof(auxdata
));
241 auxdata
.size
= nfsi
->vfs_inode
.i_size
;
242 auxdata
.mtime
= nfsi
->vfs_inode
.i_mtime
;
243 auxdata
.ctime
= nfsi
->vfs_inode
.i_ctime
;
245 if (NFS_SERVER(&nfsi
->vfs_inode
)->nfs_client
->rpc_ops
->version
== 4)
246 auxdata
.change_attr
= nfsi
->vfs_inode
.i_version
;
248 if (memcmp(data
, &auxdata
, datalen
) != 0)
249 return FSCACHE_CHECKAUX_OBSOLETE
;
251 return FSCACHE_CHECKAUX_OKAY
;
255 * Get an extra reference on a read context.
256 * - This function can be absent if the completion function doesn't require a
258 * - The read context is passed back to NFS in the event that a data read on the
259 * cache fails with EIO - in which case the server must be contacted to
260 * retrieve the data, which requires the read context for security.
262 static void nfs_fh_get_context(void *cookie_netfs_data
, void *context
)
264 get_nfs_open_context(context
);
268 * Release an extra reference on a read context.
269 * - This function can be absent if the completion function doesn't require a
272 static void nfs_fh_put_context(void *cookie_netfs_data
, void *context
)
275 put_nfs_open_context(context
);
279 * Define the inode object for FS-Cache. This is used to describe an inode
280 * object to fscache_acquire_cookie(). It is keyed by the NFS file handle for
283 * Coherency is managed by comparing the copies of i_size, i_mtime and i_ctime
284 * held in the cache auxiliary data for the data storage object with those in
285 * the inode struct in memory.
287 const struct fscache_cookie_def nfs_fscache_inode_object_def
= {
289 .type
= FSCACHE_COOKIE_TYPE_DATAFILE
,
290 .get_key
= nfs_fscache_inode_get_key
,
291 .get_attr
= nfs_fscache_inode_get_attr
,
292 .get_aux
= nfs_fscache_inode_get_aux
,
293 .check_aux
= nfs_fscache_inode_check_aux
,
294 .get_context
= nfs_fh_get_context
,
295 .put_context
= nfs_fh_put_context
,