]>
Commit | Line | Data |
---|---|---|
1 | /* AFS caching stuff | |
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 License | |
8 | * as published by the Free Software Foundation; either version | |
9 | * 2 of the License, or (at your option) any later version. | |
10 | */ | |
11 | ||
12 | #include <linux/sched.h> | |
13 | #include "internal.h" | |
14 | ||
15 | static uint16_t afs_cell_cache_get_key(const void *cookie_netfs_data, | |
16 | void *buffer, uint16_t buflen); | |
17 | static uint16_t afs_cell_cache_get_aux(const void *cookie_netfs_data, | |
18 | void *buffer, uint16_t buflen); | |
19 | static enum fscache_checkaux afs_cell_cache_check_aux(void *cookie_netfs_data, | |
20 | const void *buffer, | |
21 | uint16_t buflen); | |
22 | ||
23 | static uint16_t afs_vlocation_cache_get_key(const void *cookie_netfs_data, | |
24 | void *buffer, uint16_t buflen); | |
25 | static uint16_t afs_vlocation_cache_get_aux(const void *cookie_netfs_data, | |
26 | void *buffer, uint16_t buflen); | |
27 | static enum fscache_checkaux afs_vlocation_cache_check_aux( | |
28 | void *cookie_netfs_data, const void *buffer, uint16_t buflen); | |
29 | ||
30 | static uint16_t afs_volume_cache_get_key(const void *cookie_netfs_data, | |
31 | void *buffer, uint16_t buflen); | |
32 | ||
33 | static uint16_t afs_vnode_cache_get_key(const void *cookie_netfs_data, | |
34 | void *buffer, uint16_t buflen); | |
35 | static void afs_vnode_cache_get_attr(const void *cookie_netfs_data, | |
36 | uint64_t *size); | |
37 | static uint16_t afs_vnode_cache_get_aux(const void *cookie_netfs_data, | |
38 | void *buffer, uint16_t buflen); | |
39 | static enum fscache_checkaux afs_vnode_cache_check_aux(void *cookie_netfs_data, | |
40 | const void *buffer, | |
41 | uint16_t buflen); | |
42 | static void afs_vnode_cache_now_uncached(void *cookie_netfs_data); | |
43 | ||
44 | struct fscache_netfs afs_cache_netfs = { | |
45 | .name = "afs", | |
46 | .version = 0, | |
47 | }; | |
48 | ||
49 | struct fscache_cookie_def afs_cell_cache_index_def = { | |
50 | .name = "AFS.cell", | |
51 | .type = FSCACHE_COOKIE_TYPE_INDEX, | |
52 | .get_key = afs_cell_cache_get_key, | |
53 | .get_aux = afs_cell_cache_get_aux, | |
54 | .check_aux = afs_cell_cache_check_aux, | |
55 | }; | |
56 | ||
57 | struct fscache_cookie_def afs_vlocation_cache_index_def = { | |
58 | .name = "AFS.vldb", | |
59 | .type = FSCACHE_COOKIE_TYPE_INDEX, | |
60 | .get_key = afs_vlocation_cache_get_key, | |
61 | .get_aux = afs_vlocation_cache_get_aux, | |
62 | .check_aux = afs_vlocation_cache_check_aux, | |
63 | }; | |
64 | ||
65 | struct fscache_cookie_def afs_volume_cache_index_def = { | |
66 | .name = "AFS.volume", | |
67 | .type = FSCACHE_COOKIE_TYPE_INDEX, | |
68 | .get_key = afs_volume_cache_get_key, | |
69 | }; | |
70 | ||
71 | struct fscache_cookie_def afs_vnode_cache_index_def = { | |
72 | .name = "AFS.vnode", | |
73 | .type = FSCACHE_COOKIE_TYPE_DATAFILE, | |
74 | .get_key = afs_vnode_cache_get_key, | |
75 | .get_attr = afs_vnode_cache_get_attr, | |
76 | .get_aux = afs_vnode_cache_get_aux, | |
77 | .check_aux = afs_vnode_cache_check_aux, | |
78 | .now_uncached = afs_vnode_cache_now_uncached, | |
79 | }; | |
80 | ||
81 | /* | |
82 | * set the key for the index entry | |
83 | */ | |
84 | static uint16_t afs_cell_cache_get_key(const void *cookie_netfs_data, | |
85 | void *buffer, uint16_t bufmax) | |
86 | { | |
87 | const struct afs_cell *cell = cookie_netfs_data; | |
88 | uint16_t klen; | |
89 | ||
90 | _enter("%p,%p,%u", cell, buffer, bufmax); | |
91 | ||
92 | klen = strlen(cell->name); | |
93 | if (klen > bufmax) | |
94 | return 0; | |
95 | ||
96 | memcpy(buffer, cell->name, klen); | |
97 | return klen; | |
98 | } | |
99 | ||
100 | /* | |
101 | * provide new auxilliary cache data | |
102 | */ | |
103 | static uint16_t afs_cell_cache_get_aux(const void *cookie_netfs_data, | |
104 | void *buffer, uint16_t bufmax) | |
105 | { | |
106 | const struct afs_cell *cell = cookie_netfs_data; | |
107 | uint16_t dlen; | |
108 | ||
109 | _enter("%p,%p,%u", cell, buffer, bufmax); | |
110 | ||
111 | dlen = cell->vl_naddrs * sizeof(cell->vl_addrs[0]); | |
112 | dlen = min(dlen, bufmax); | |
113 | dlen &= ~(sizeof(cell->vl_addrs[0]) - 1); | |
114 | ||
115 | memcpy(buffer, cell->vl_addrs, dlen); | |
116 | return dlen; | |
117 | } | |
118 | ||
119 | /* | |
120 | * check that the auxilliary data indicates that the entry is still valid | |
121 | */ | |
122 | static enum fscache_checkaux afs_cell_cache_check_aux(void *cookie_netfs_data, | |
123 | const void *buffer, | |
124 | uint16_t buflen) | |
125 | { | |
126 | _leave(" = OKAY"); | |
127 | return FSCACHE_CHECKAUX_OKAY; | |
128 | } | |
129 | ||
130 | /*****************************************************************************/ | |
131 | /* | |
132 | * set the key for the index entry | |
133 | */ | |
134 | static uint16_t afs_vlocation_cache_get_key(const void *cookie_netfs_data, | |
135 | void *buffer, uint16_t bufmax) | |
136 | { | |
137 | const struct afs_vlocation *vlocation = cookie_netfs_data; | |
138 | uint16_t klen; | |
139 | ||
140 | _enter("{%s},%p,%u", vlocation->vldb.name, buffer, bufmax); | |
141 | ||
142 | klen = strnlen(vlocation->vldb.name, sizeof(vlocation->vldb.name)); | |
143 | if (klen > bufmax) | |
144 | return 0; | |
145 | ||
146 | memcpy(buffer, vlocation->vldb.name, klen); | |
147 | ||
148 | _leave(" = %u", klen); | |
149 | return klen; | |
150 | } | |
151 | ||
152 | /* | |
153 | * provide new auxilliary cache data | |
154 | */ | |
155 | static uint16_t afs_vlocation_cache_get_aux(const void *cookie_netfs_data, | |
156 | void *buffer, uint16_t bufmax) | |
157 | { | |
158 | const struct afs_vlocation *vlocation = cookie_netfs_data; | |
159 | uint16_t dlen; | |
160 | ||
161 | _enter("{%s},%p,%u", vlocation->vldb.name, buffer, bufmax); | |
162 | ||
163 | dlen = sizeof(struct afs_cache_vlocation); | |
164 | dlen -= offsetof(struct afs_cache_vlocation, nservers); | |
165 | if (dlen > bufmax) | |
166 | return 0; | |
167 | ||
168 | memcpy(buffer, (uint8_t *)&vlocation->vldb.nservers, dlen); | |
169 | ||
170 | _leave(" = %u", dlen); | |
171 | return dlen; | |
172 | } | |
173 | ||
174 | /* | |
175 | * check that the auxilliary data indicates that the entry is still valid | |
176 | */ | |
177 | static | |
178 | enum fscache_checkaux afs_vlocation_cache_check_aux(void *cookie_netfs_data, | |
179 | const void *buffer, | |
180 | uint16_t buflen) | |
181 | { | |
182 | const struct afs_cache_vlocation *cvldb; | |
183 | struct afs_vlocation *vlocation = cookie_netfs_data; | |
184 | uint16_t dlen; | |
185 | ||
186 | _enter("{%s},%p,%u", vlocation->vldb.name, buffer, buflen); | |
187 | ||
188 | /* check the size of the data is what we're expecting */ | |
189 | dlen = sizeof(struct afs_cache_vlocation); | |
190 | dlen -= offsetof(struct afs_cache_vlocation, nservers); | |
191 | if (dlen != buflen) | |
192 | return FSCACHE_CHECKAUX_OBSOLETE; | |
193 | ||
194 | cvldb = container_of(buffer, struct afs_cache_vlocation, nservers); | |
195 | ||
196 | /* if what's on disk is more valid than what's in memory, then use the | |
197 | * VL record from the cache */ | |
198 | if (!vlocation->valid || vlocation->vldb.rtime == cvldb->rtime) { | |
199 | memcpy((uint8_t *)&vlocation->vldb.nservers, buffer, dlen); | |
200 | vlocation->valid = 1; | |
201 | _leave(" = SUCCESS [c->m]"); | |
202 | return FSCACHE_CHECKAUX_OKAY; | |
203 | } | |
204 | ||
205 | /* need to update the cache if the cached info differs */ | |
206 | if (memcmp(&vlocation->vldb, buffer, dlen) != 0) { | |
207 | /* delete if the volume IDs for this name differ */ | |
208 | if (memcmp(&vlocation->vldb.vid, &cvldb->vid, | |
209 | sizeof(cvldb->vid)) != 0 | |
210 | ) { | |
211 | _leave(" = OBSOLETE"); | |
212 | return FSCACHE_CHECKAUX_OBSOLETE; | |
213 | } | |
214 | ||
215 | _leave(" = UPDATE"); | |
216 | return FSCACHE_CHECKAUX_NEEDS_UPDATE; | |
217 | } | |
218 | ||
219 | _leave(" = OKAY"); | |
220 | return FSCACHE_CHECKAUX_OKAY; | |
221 | } | |
222 | ||
223 | /*****************************************************************************/ | |
224 | /* | |
225 | * set the key for the volume index entry | |
226 | */ | |
227 | static uint16_t afs_volume_cache_get_key(const void *cookie_netfs_data, | |
228 | void *buffer, uint16_t bufmax) | |
229 | { | |
230 | const struct afs_volume *volume = cookie_netfs_data; | |
231 | uint16_t klen; | |
232 | ||
233 | _enter("{%u},%p,%u", volume->type, buffer, bufmax); | |
234 | ||
235 | klen = sizeof(volume->type); | |
236 | if (klen > bufmax) | |
237 | return 0; | |
238 | ||
239 | memcpy(buffer, &volume->type, sizeof(volume->type)); | |
240 | ||
241 | _leave(" = %u", klen); | |
242 | return klen; | |
243 | ||
244 | } | |
245 | ||
246 | /*****************************************************************************/ | |
247 | /* | |
248 | * set the key for the index entry | |
249 | */ | |
250 | static uint16_t afs_vnode_cache_get_key(const void *cookie_netfs_data, | |
251 | void *buffer, uint16_t bufmax) | |
252 | { | |
253 | const struct afs_vnode *vnode = cookie_netfs_data; | |
254 | uint16_t klen; | |
255 | ||
256 | _enter("{%x,%x,%llx},%p,%u", | |
257 | vnode->fid.vnode, vnode->fid.unique, vnode->status.data_version, | |
258 | buffer, bufmax); | |
259 | ||
260 | klen = sizeof(vnode->fid.vnode); | |
261 | if (klen > bufmax) | |
262 | return 0; | |
263 | ||
264 | memcpy(buffer, &vnode->fid.vnode, sizeof(vnode->fid.vnode)); | |
265 | ||
266 | _leave(" = %u", klen); | |
267 | return klen; | |
268 | } | |
269 | ||
270 | /* | |
271 | * provide updated file attributes | |
272 | */ | |
273 | static void afs_vnode_cache_get_attr(const void *cookie_netfs_data, | |
274 | uint64_t *size) | |
275 | { | |
276 | const struct afs_vnode *vnode = cookie_netfs_data; | |
277 | ||
278 | _enter("{%x,%x,%llx},", | |
279 | vnode->fid.vnode, vnode->fid.unique, | |
280 | vnode->status.data_version); | |
281 | ||
282 | *size = vnode->status.size; | |
283 | } | |
284 | ||
285 | /* | |
286 | * provide new auxilliary cache data | |
287 | */ | |
288 | static uint16_t afs_vnode_cache_get_aux(const void *cookie_netfs_data, | |
289 | void *buffer, uint16_t bufmax) | |
290 | { | |
291 | const struct afs_vnode *vnode = cookie_netfs_data; | |
292 | uint16_t dlen; | |
293 | ||
294 | _enter("{%x,%x,%Lx},%p,%u", | |
295 | vnode->fid.vnode, vnode->fid.unique, vnode->status.data_version, | |
296 | buffer, bufmax); | |
297 | ||
298 | dlen = sizeof(vnode->fid.unique) + sizeof(vnode->status.data_version); | |
299 | if (dlen > bufmax) | |
300 | return 0; | |
301 | ||
302 | memcpy(buffer, &vnode->fid.unique, sizeof(vnode->fid.unique)); | |
303 | buffer += sizeof(vnode->fid.unique); | |
304 | memcpy(buffer, &vnode->status.data_version, | |
305 | sizeof(vnode->status.data_version)); | |
306 | ||
307 | _leave(" = %u", dlen); | |
308 | return dlen; | |
309 | } | |
310 | ||
311 | /* | |
312 | * check that the auxilliary data indicates that the entry is still valid | |
313 | */ | |
314 | static enum fscache_checkaux afs_vnode_cache_check_aux(void *cookie_netfs_data, | |
315 | const void *buffer, | |
316 | uint16_t buflen) | |
317 | { | |
318 | struct afs_vnode *vnode = cookie_netfs_data; | |
319 | uint16_t dlen; | |
320 | ||
321 | _enter("{%x,%x,%llx},%p,%u", | |
322 | vnode->fid.vnode, vnode->fid.unique, vnode->status.data_version, | |
323 | buffer, buflen); | |
324 | ||
325 | /* check the size of the data is what we're expecting */ | |
326 | dlen = sizeof(vnode->fid.unique) + sizeof(vnode->status.data_version); | |
327 | if (dlen != buflen) { | |
328 | _leave(" = OBSOLETE [len %hx != %hx]", dlen, buflen); | |
329 | return FSCACHE_CHECKAUX_OBSOLETE; | |
330 | } | |
331 | ||
332 | if (memcmp(buffer, | |
333 | &vnode->fid.unique, | |
334 | sizeof(vnode->fid.unique) | |
335 | ) != 0) { | |
336 | unsigned unique; | |
337 | ||
338 | memcpy(&unique, buffer, sizeof(unique)); | |
339 | ||
340 | _leave(" = OBSOLETE [uniq %x != %x]", | |
341 | unique, vnode->fid.unique); | |
342 | return FSCACHE_CHECKAUX_OBSOLETE; | |
343 | } | |
344 | ||
345 | if (memcmp(buffer + sizeof(vnode->fid.unique), | |
346 | &vnode->status.data_version, | |
347 | sizeof(vnode->status.data_version) | |
348 | ) != 0) { | |
349 | afs_dataversion_t version; | |
350 | ||
351 | memcpy(&version, buffer + sizeof(vnode->fid.unique), | |
352 | sizeof(version)); | |
353 | ||
354 | _leave(" = OBSOLETE [vers %llx != %llx]", | |
355 | version, vnode->status.data_version); | |
356 | return FSCACHE_CHECKAUX_OBSOLETE; | |
357 | } | |
358 | ||
359 | _leave(" = SUCCESS"); | |
360 | return FSCACHE_CHECKAUX_OKAY; | |
361 | } | |
362 | ||
363 | /* | |
364 | * indication the cookie is no longer uncached | |
365 | * - this function is called when the backing store currently caching a cookie | |
366 | * is removed | |
367 | * - the netfs should use this to clean up any markers indicating cached pages | |
368 | * - this is mandatory for any object that may have data | |
369 | */ | |
370 | static void afs_vnode_cache_now_uncached(void *cookie_netfs_data) | |
371 | { | |
372 | struct afs_vnode *vnode = cookie_netfs_data; | |
373 | struct pagevec pvec; | |
374 | pgoff_t first; | |
375 | int loop, nr_pages; | |
376 | ||
377 | _enter("{%x,%x,%Lx}", | |
378 | vnode->fid.vnode, vnode->fid.unique, vnode->status.data_version); | |
379 | ||
380 | pagevec_init(&pvec, 0); | |
381 | first = 0; | |
382 | ||
383 | for (;;) { | |
384 | /* grab a bunch of pages to clean */ | |
385 | nr_pages = pagevec_lookup(&pvec, vnode->vfs_inode.i_mapping, | |
386 | first, | |
387 | PAGEVEC_SIZE - pagevec_count(&pvec)); | |
388 | if (!nr_pages) | |
389 | break; | |
390 | ||
391 | for (loop = 0; loop < nr_pages; loop++) | |
392 | ClearPageFsCache(pvec.pages[loop]); | |
393 | ||
394 | first = pvec.pages[nr_pages - 1]->index + 1; | |
395 | ||
396 | pvec.nr = nr_pages; | |
397 | pagevec_release(&pvec); | |
398 | cond_resched(); | |
399 | } | |
400 | ||
401 | _leave(""); | |
402 | } |