Merge tag 'pinctrl-v4.15-1' of git://git.kernel.org/pub/scm/linux/kernel/git/linusw...
[sfrench/cifs-2.6.git] / fs / afs / cache.c
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
43 struct fscache_netfs afs_cache_netfs = {
44         .name                   = "afs",
45         .version                = 0,
46 };
47
48 struct fscache_cookie_def afs_cell_cache_index_def = {
49         .name           = "AFS.cell",
50         .type           = FSCACHE_COOKIE_TYPE_INDEX,
51         .get_key        = afs_cell_cache_get_key,
52         .get_aux        = afs_cell_cache_get_aux,
53         .check_aux      = afs_cell_cache_check_aux,
54 };
55
56 struct fscache_cookie_def afs_vlocation_cache_index_def = {
57         .name                   = "AFS.vldb",
58         .type                   = FSCACHE_COOKIE_TYPE_INDEX,
59         .get_key                = afs_vlocation_cache_get_key,
60         .get_aux                = afs_vlocation_cache_get_aux,
61         .check_aux              = afs_vlocation_cache_check_aux,
62 };
63
64 struct fscache_cookie_def afs_volume_cache_index_def = {
65         .name           = "AFS.volume",
66         .type           = FSCACHE_COOKIE_TYPE_INDEX,
67         .get_key        = afs_volume_cache_get_key,
68 };
69
70 struct fscache_cookie_def afs_vnode_cache_index_def = {
71         .name                   = "AFS.vnode",
72         .type                   = FSCACHE_COOKIE_TYPE_DATAFILE,
73         .get_key                = afs_vnode_cache_get_key,
74         .get_attr               = afs_vnode_cache_get_attr,
75         .get_aux                = afs_vnode_cache_get_aux,
76         .check_aux              = afs_vnode_cache_check_aux,
77 };
78
79 /*
80  * set the key for the index entry
81  */
82 static uint16_t afs_cell_cache_get_key(const void *cookie_netfs_data,
83                                        void *buffer, uint16_t bufmax)
84 {
85         const struct afs_cell *cell = cookie_netfs_data;
86         uint16_t klen;
87
88         _enter("%p,%p,%u", cell, buffer, bufmax);
89
90         klen = strlen(cell->name);
91         if (klen > bufmax)
92                 return 0;
93
94         memcpy(buffer, cell->name, klen);
95         return klen;
96 }
97
98 /*
99  * provide new auxiliary cache data
100  */
101 static uint16_t afs_cell_cache_get_aux(const void *cookie_netfs_data,
102                                        void *buffer, uint16_t bufmax)
103 {
104         const struct afs_cell *cell = cookie_netfs_data;
105         uint16_t dlen;
106
107         _enter("%p,%p,%u", cell, buffer, bufmax);
108
109         dlen = cell->vl_naddrs * sizeof(cell->vl_addrs[0]);
110         dlen = min(dlen, bufmax);
111         dlen &= ~(sizeof(cell->vl_addrs[0]) - 1);
112
113         memcpy(buffer, cell->vl_addrs, dlen);
114         return dlen;
115 }
116
117 /*
118  * check that the auxiliary data indicates that the entry is still valid
119  */
120 static enum fscache_checkaux afs_cell_cache_check_aux(void *cookie_netfs_data,
121                                                       const void *buffer,
122                                                       uint16_t buflen)
123 {
124         _leave(" = OKAY");
125         return FSCACHE_CHECKAUX_OKAY;
126 }
127
128 /*****************************************************************************/
129 /*
130  * set the key for the index entry
131  */
132 static uint16_t afs_vlocation_cache_get_key(const void *cookie_netfs_data,
133                                             void *buffer, uint16_t bufmax)
134 {
135         const struct afs_vlocation *vlocation = cookie_netfs_data;
136         uint16_t klen;
137
138         _enter("{%s},%p,%u", vlocation->vldb.name, buffer, bufmax);
139
140         klen = strnlen(vlocation->vldb.name, sizeof(vlocation->vldb.name));
141         if (klen > bufmax)
142                 return 0;
143
144         memcpy(buffer, vlocation->vldb.name, klen);
145
146         _leave(" = %u", klen);
147         return klen;
148 }
149
150 /*
151  * provide new auxiliary cache data
152  */
153 static uint16_t afs_vlocation_cache_get_aux(const void *cookie_netfs_data,
154                                             void *buffer, uint16_t bufmax)
155 {
156         const struct afs_vlocation *vlocation = cookie_netfs_data;
157         uint16_t dlen;
158
159         _enter("{%s},%p,%u", vlocation->vldb.name, buffer, bufmax);
160
161         dlen = sizeof(struct afs_cache_vlocation);
162         dlen -= offsetof(struct afs_cache_vlocation, nservers);
163         if (dlen > bufmax)
164                 return 0;
165
166         memcpy(buffer, (uint8_t *)&vlocation->vldb.nservers, dlen);
167
168         _leave(" = %u", dlen);
169         return dlen;
170 }
171
172 /*
173  * check that the auxiliary data indicates that the entry is still valid
174  */
175 static
176 enum fscache_checkaux afs_vlocation_cache_check_aux(void *cookie_netfs_data,
177                                                     const void *buffer,
178                                                     uint16_t buflen)
179 {
180         const struct afs_cache_vlocation *cvldb;
181         struct afs_vlocation *vlocation = cookie_netfs_data;
182         uint16_t dlen;
183
184         _enter("{%s},%p,%u", vlocation->vldb.name, buffer, buflen);
185
186         /* check the size of the data is what we're expecting */
187         dlen = sizeof(struct afs_cache_vlocation);
188         dlen -= offsetof(struct afs_cache_vlocation, nservers);
189         if (dlen != buflen)
190                 return FSCACHE_CHECKAUX_OBSOLETE;
191
192         cvldb = container_of(buffer, struct afs_cache_vlocation, nservers);
193
194         /* if what's on disk is more valid than what's in memory, then use the
195          * VL record from the cache */
196         if (!vlocation->valid || vlocation->vldb.rtime == cvldb->rtime) {
197                 memcpy((uint8_t *)&vlocation->vldb.nservers, buffer, dlen);
198                 vlocation->valid = 1;
199                 _leave(" = SUCCESS [c->m]");
200                 return FSCACHE_CHECKAUX_OKAY;
201         }
202
203         /* need to update the cache if the cached info differs */
204         if (memcmp(&vlocation->vldb, buffer, dlen) != 0) {
205                 /* delete if the volume IDs for this name differ */
206                 if (memcmp(&vlocation->vldb.vid, &cvldb->vid,
207                            sizeof(cvldb->vid)) != 0
208                     ) {
209                         _leave(" = OBSOLETE");
210                         return FSCACHE_CHECKAUX_OBSOLETE;
211                 }
212
213                 _leave(" = UPDATE");
214                 return FSCACHE_CHECKAUX_NEEDS_UPDATE;
215         }
216
217         _leave(" = OKAY");
218         return FSCACHE_CHECKAUX_OKAY;
219 }
220
221 /*****************************************************************************/
222 /*
223  * set the key for the volume index entry
224  */
225 static uint16_t afs_volume_cache_get_key(const void *cookie_netfs_data,
226                                         void *buffer, uint16_t bufmax)
227 {
228         const struct afs_volume *volume = cookie_netfs_data;
229         uint16_t klen;
230
231         _enter("{%u},%p,%u", volume->type, buffer, bufmax);
232
233         klen = sizeof(volume->type);
234         if (klen > bufmax)
235                 return 0;
236
237         memcpy(buffer, &volume->type, sizeof(volume->type));
238
239         _leave(" = %u", klen);
240         return klen;
241
242 }
243
244 /*****************************************************************************/
245 /*
246  * set the key for the index entry
247  */
248 static uint16_t afs_vnode_cache_get_key(const void *cookie_netfs_data,
249                                         void *buffer, uint16_t bufmax)
250 {
251         const struct afs_vnode *vnode = cookie_netfs_data;
252         uint16_t klen;
253
254         _enter("{%x,%x,%llx},%p,%u",
255                vnode->fid.vnode, vnode->fid.unique, vnode->status.data_version,
256                buffer, bufmax);
257
258         klen = sizeof(vnode->fid.vnode);
259         if (klen > bufmax)
260                 return 0;
261
262         memcpy(buffer, &vnode->fid.vnode, sizeof(vnode->fid.vnode));
263
264         _leave(" = %u", klen);
265         return klen;
266 }
267
268 /*
269  * provide updated file attributes
270  */
271 static void afs_vnode_cache_get_attr(const void *cookie_netfs_data,
272                                      uint64_t *size)
273 {
274         const struct afs_vnode *vnode = cookie_netfs_data;
275
276         _enter("{%x,%x,%llx},",
277                vnode->fid.vnode, vnode->fid.unique,
278                vnode->status.data_version);
279
280         *size = vnode->status.size;
281 }
282
283 /*
284  * provide new auxiliary cache data
285  */
286 static uint16_t afs_vnode_cache_get_aux(const void *cookie_netfs_data,
287                                         void *buffer, uint16_t bufmax)
288 {
289         const struct afs_vnode *vnode = cookie_netfs_data;
290         uint16_t dlen;
291
292         _enter("{%x,%x,%Lx},%p,%u",
293                vnode->fid.vnode, vnode->fid.unique, vnode->status.data_version,
294                buffer, bufmax);
295
296         dlen = sizeof(vnode->fid.unique) + sizeof(vnode->status.data_version);
297         if (dlen > bufmax)
298                 return 0;
299
300         memcpy(buffer, &vnode->fid.unique, sizeof(vnode->fid.unique));
301         buffer += sizeof(vnode->fid.unique);
302         memcpy(buffer, &vnode->status.data_version,
303                sizeof(vnode->status.data_version));
304
305         _leave(" = %u", dlen);
306         return dlen;
307 }
308
309 /*
310  * check that the auxiliary data indicates that the entry is still valid
311  */
312 static enum fscache_checkaux afs_vnode_cache_check_aux(void *cookie_netfs_data,
313                                                        const void *buffer,
314                                                        uint16_t buflen)
315 {
316         struct afs_vnode *vnode = cookie_netfs_data;
317         uint16_t dlen;
318
319         _enter("{%x,%x,%llx},%p,%u",
320                vnode->fid.vnode, vnode->fid.unique, vnode->status.data_version,
321                buffer, buflen);
322
323         /* check the size of the data is what we're expecting */
324         dlen = sizeof(vnode->fid.unique) + sizeof(vnode->status.data_version);
325         if (dlen != buflen) {
326                 _leave(" = OBSOLETE [len %hx != %hx]", dlen, buflen);
327                 return FSCACHE_CHECKAUX_OBSOLETE;
328         }
329
330         if (memcmp(buffer,
331                    &vnode->fid.unique,
332                    sizeof(vnode->fid.unique)
333                    ) != 0) {
334                 unsigned unique;
335
336                 memcpy(&unique, buffer, sizeof(unique));
337
338                 _leave(" = OBSOLETE [uniq %x != %x]",
339                        unique, vnode->fid.unique);
340                 return FSCACHE_CHECKAUX_OBSOLETE;
341         }
342
343         if (memcmp(buffer + sizeof(vnode->fid.unique),
344                    &vnode->status.data_version,
345                    sizeof(vnode->status.data_version)
346                    ) != 0) {
347                 afs_dataversion_t version;
348
349                 memcpy(&version, buffer + sizeof(vnode->fid.unique),
350                        sizeof(version));
351
352                 _leave(" = OBSOLETE [vers %llx != %llx]",
353                        version, vnode->status.data_version);
354                 return FSCACHE_CHECKAUX_OBSOLETE;
355         }
356
357         _leave(" = SUCCESS");
358         return FSCACHE_CHECKAUX_OKAY;
359 }