Commit | Line | Data |
---|---|---|
99ccbd22 MT |
1 | /* |
2 | * Ceph cache definitions. | |
3 | * | |
4 | * Copyright (C) 2013 by Adfin Solutions, Inc. All Rights Reserved. | |
5 | * Written by Milosz Tanski (milosz@adfin.com) | |
6 | * | |
7 | * This program is free software; you can redistribute it and/or modify | |
8 | * it under the terms of the GNU General Public License version 2 | |
9 | * as published by the Free Software Foundation. | |
10 | * | |
11 | * This program is distributed in the hope that it will be useful, | |
12 | * but WITHOUT ANY WARRANTY; without even the implied warranty of | |
13 | * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the | |
14 | * GNU General Public License for more details. | |
15 | * | |
16 | * You should have received a copy of the GNU General Public License | |
17 | * along with this program; if not, write to: | |
18 | * Free Software Foundation | |
19 | * 51 Franklin Street, Fifth Floor | |
20 | * Boston, MA 02111-1301 USA | |
21 | * | |
22 | */ | |
23 | ||
99ccbd22 MT |
24 | #include "super.h" |
25 | #include "cache.h" | |
26 | ||
27 | struct ceph_aux_inode { | |
28 | struct timespec mtime; | |
29 | loff_t size; | |
30 | }; | |
31 | ||
32 | struct fscache_netfs ceph_cache_netfs = { | |
33 | .name = "ceph", | |
34 | .version = 0, | |
35 | }; | |
36 | ||
37 | static uint16_t ceph_fscache_session_get_key(const void *cookie_netfs_data, | |
38 | void *buffer, uint16_t maxbuf) | |
39 | { | |
40 | const struct ceph_fs_client* fsc = cookie_netfs_data; | |
41 | uint16_t klen; | |
42 | ||
43 | klen = sizeof(fsc->client->fsid); | |
44 | if (klen > maxbuf) | |
45 | return 0; | |
46 | ||
47 | memcpy(buffer, &fsc->client->fsid, klen); | |
48 | return klen; | |
49 | } | |
50 | ||
51 | static const struct fscache_cookie_def ceph_fscache_fsid_object_def = { | |
52 | .name = "CEPH.fsid", | |
53 | .type = FSCACHE_COOKIE_TYPE_INDEX, | |
54 | .get_key = ceph_fscache_session_get_key, | |
55 | }; | |
56 | ||
971f0bde | 57 | int ceph_fscache_register(void) |
99ccbd22 MT |
58 | { |
59 | return fscache_register_netfs(&ceph_cache_netfs); | |
60 | } | |
61 | ||
971f0bde | 62 | void ceph_fscache_unregister(void) |
99ccbd22 MT |
63 | { |
64 | fscache_unregister_netfs(&ceph_cache_netfs); | |
65 | } | |
66 | ||
67 | int ceph_fscache_register_fs(struct ceph_fs_client* fsc) | |
68 | { | |
69 | fsc->fscache = fscache_acquire_cookie(ceph_cache_netfs.primary_index, | |
70 | &ceph_fscache_fsid_object_def, | |
94d30ae9 | 71 | fsc, true); |
99ccbd22 MT |
72 | |
73 | if (fsc->fscache == NULL) { | |
74 | pr_err("Unable to resgister fsid: %p fscache cookie", fsc); | |
75 | return 0; | |
76 | } | |
77 | ||
78 | fsc->revalidate_wq = alloc_workqueue("ceph-revalidate", 0, 1); | |
79 | if (fsc->revalidate_wq == NULL) | |
80 | return -ENOMEM; | |
81 | ||
82 | return 0; | |
83 | } | |
84 | ||
85 | static uint16_t ceph_fscache_inode_get_key(const void *cookie_netfs_data, | |
86 | void *buffer, uint16_t maxbuf) | |
87 | { | |
88 | const struct ceph_inode_info* ci = cookie_netfs_data; | |
89 | uint16_t klen; | |
90 | ||
91 | /* use ceph virtual inode (id + snaphot) */ | |
92 | klen = sizeof(ci->i_vino); | |
93 | if (klen > maxbuf) | |
94 | return 0; | |
95 | ||
96 | memcpy(buffer, &ci->i_vino, klen); | |
97 | return klen; | |
98 | } | |
99 | ||
100 | static uint16_t ceph_fscache_inode_get_aux(const void *cookie_netfs_data, | |
101 | void *buffer, uint16_t bufmax) | |
102 | { | |
103 | struct ceph_aux_inode aux; | |
104 | const struct ceph_inode_info* ci = cookie_netfs_data; | |
105 | const struct inode* inode = &ci->vfs_inode; | |
106 | ||
107 | memset(&aux, 0, sizeof(aux)); | |
108 | aux.mtime = inode->i_mtime; | |
109 | aux.size = inode->i_size; | |
110 | ||
111 | memcpy(buffer, &aux, sizeof(aux)); | |
112 | ||
113 | return sizeof(aux); | |
114 | } | |
115 | ||
116 | static void ceph_fscache_inode_get_attr(const void *cookie_netfs_data, | |
117 | uint64_t *size) | |
118 | { | |
119 | const struct ceph_inode_info* ci = cookie_netfs_data; | |
120 | const struct inode* inode = &ci->vfs_inode; | |
121 | ||
122 | *size = inode->i_size; | |
123 | } | |
124 | ||
125 | static enum fscache_checkaux ceph_fscache_inode_check_aux( | |
126 | void *cookie_netfs_data, const void *data, uint16_t dlen) | |
127 | { | |
128 | struct ceph_aux_inode aux; | |
129 | struct ceph_inode_info* ci = cookie_netfs_data; | |
130 | struct inode* inode = &ci->vfs_inode; | |
131 | ||
132 | if (dlen != sizeof(aux)) | |
133 | return FSCACHE_CHECKAUX_OBSOLETE; | |
134 | ||
135 | memset(&aux, 0, sizeof(aux)); | |
136 | aux.mtime = inode->i_mtime; | |
137 | aux.size = inode->i_size; | |
138 | ||
139 | if (memcmp(data, &aux, sizeof(aux)) != 0) | |
140 | return FSCACHE_CHECKAUX_OBSOLETE; | |
141 | ||
142 | dout("ceph inode 0x%p cached okay", ci); | |
143 | return FSCACHE_CHECKAUX_OKAY; | |
144 | } | |
145 | ||
146 | static void ceph_fscache_inode_now_uncached(void* cookie_netfs_data) | |
147 | { | |
148 | struct ceph_inode_info* ci = cookie_netfs_data; | |
149 | struct pagevec pvec; | |
150 | pgoff_t first; | |
151 | int loop, nr_pages; | |
152 | ||
153 | pagevec_init(&pvec, 0); | |
154 | first = 0; | |
155 | ||
156 | dout("ceph inode 0x%p now uncached", ci); | |
157 | ||
158 | while (1) { | |
159 | nr_pages = pagevec_lookup(&pvec, ci->vfs_inode.i_mapping, first, | |
160 | PAGEVEC_SIZE - pagevec_count(&pvec)); | |
161 | ||
162 | if (!nr_pages) | |
163 | break; | |
164 | ||
165 | for (loop = 0; loop < nr_pages; loop++) | |
166 | ClearPageFsCache(pvec.pages[loop]); | |
167 | ||
168 | first = pvec.pages[nr_pages - 1]->index + 1; | |
169 | ||
170 | pvec.nr = nr_pages; | |
171 | pagevec_release(&pvec); | |
172 | cond_resched(); | |
173 | } | |
174 | } | |
175 | ||
176 | static const struct fscache_cookie_def ceph_fscache_inode_object_def = { | |
177 | .name = "CEPH.inode", | |
178 | .type = FSCACHE_COOKIE_TYPE_DATAFILE, | |
179 | .get_key = ceph_fscache_inode_get_key, | |
180 | .get_attr = ceph_fscache_inode_get_attr, | |
181 | .get_aux = ceph_fscache_inode_get_aux, | |
182 | .check_aux = ceph_fscache_inode_check_aux, | |
183 | .now_uncached = ceph_fscache_inode_now_uncached, | |
184 | }; | |
185 | ||
186 | void ceph_fscache_register_inode_cookie(struct ceph_fs_client* fsc, | |
187 | struct ceph_inode_info* ci) | |
188 | { | |
189 | struct inode* inode = &ci->vfs_inode; | |
190 | ||
191 | /* No caching for filesystem */ | |
192 | if (fsc->fscache == NULL) | |
193 | return; | |
194 | ||
195 | /* Only cache for regular files that are read only */ | |
196 | if ((ci->vfs_inode.i_mode & S_IFREG) == 0) | |
197 | return; | |
198 | ||
199 | /* Avoid multiple racing open requests */ | |
200 | mutex_lock(&inode->i_mutex); | |
201 | ||
202 | if (ci->fscache) | |
203 | goto done; | |
204 | ||
205 | ci->fscache = fscache_acquire_cookie(fsc->fscache, | |
206 | &ceph_fscache_inode_object_def, | |
94d30ae9 | 207 | ci, true); |
99ccbd22 MT |
208 | done: |
209 | mutex_unlock(&inode->i_mutex); | |
210 | ||
211 | } | |
212 | ||
213 | void ceph_fscache_unregister_inode_cookie(struct ceph_inode_info* ci) | |
214 | { | |
215 | struct fscache_cookie* cookie; | |
216 | ||
217 | if ((cookie = ci->fscache) == NULL) | |
218 | return; | |
219 | ||
220 | ci->fscache = NULL; | |
221 | ||
222 | fscache_uncache_all_inode_pages(cookie, &ci->vfs_inode); | |
223 | fscache_relinquish_cookie(cookie, 0); | |
224 | } | |
225 | ||
226 | static void ceph_vfs_readpage_complete(struct page *page, void *data, int error) | |
227 | { | |
228 | if (!error) | |
229 | SetPageUptodate(page); | |
230 | } | |
231 | ||
232 | static void ceph_vfs_readpage_complete_unlock(struct page *page, void *data, int error) | |
233 | { | |
234 | if (!error) | |
235 | SetPageUptodate(page); | |
236 | ||
237 | unlock_page(page); | |
238 | } | |
239 | ||
240 | static inline int cache_valid(struct ceph_inode_info *ci) | |
241 | { | |
242 | return ((ceph_caps_issued(ci) & CEPH_CAP_FILE_CACHE) && | |
243 | (ci->i_fscache_gen == ci->i_rdcache_gen)); | |
244 | } | |
245 | ||
246 | ||
247 | /* Atempt to read from the fscache, | |
248 | * | |
249 | * This function is called from the readpage_nounlock context. DO NOT attempt to | |
250 | * unlock the page here (or in the callback). | |
251 | */ | |
252 | int ceph_readpage_from_fscache(struct inode *inode, struct page *page) | |
253 | { | |
254 | struct ceph_inode_info *ci = ceph_inode(inode); | |
255 | int ret; | |
256 | ||
257 | if (!cache_valid(ci)) | |
258 | return -ENOBUFS; | |
259 | ||
260 | ret = fscache_read_or_alloc_page(ci->fscache, page, | |
261 | ceph_vfs_readpage_complete, NULL, | |
262 | GFP_KERNEL); | |
263 | ||
264 | switch (ret) { | |
265 | case 0: /* Page found */ | |
266 | dout("page read submitted\n"); | |
267 | return 0; | |
268 | case -ENOBUFS: /* Pages were not found, and can't be */ | |
269 | case -ENODATA: /* Pages were not found */ | |
270 | dout("page/inode not in cache\n"); | |
271 | return ret; | |
272 | default: | |
273 | dout("%s: unknown error ret = %i\n", __func__, ret); | |
274 | return ret; | |
275 | } | |
276 | } | |
277 | ||
278 | int ceph_readpages_from_fscache(struct inode *inode, | |
279 | struct address_space *mapping, | |
280 | struct list_head *pages, | |
281 | unsigned *nr_pages) | |
282 | { | |
283 | struct ceph_inode_info *ci = ceph_inode(inode); | |
284 | int ret; | |
285 | ||
286 | if (!cache_valid(ci)) | |
287 | return -ENOBUFS; | |
288 | ||
289 | ret = fscache_read_or_alloc_pages(ci->fscache, mapping, pages, nr_pages, | |
290 | ceph_vfs_readpage_complete_unlock, | |
291 | NULL, mapping_gfp_mask(mapping)); | |
292 | ||
293 | switch (ret) { | |
294 | case 0: /* All pages found */ | |
295 | dout("all-page read submitted\n"); | |
296 | return 0; | |
297 | case -ENOBUFS: /* Some pages were not found, and can't be */ | |
298 | case -ENODATA: /* some pages were not found */ | |
299 | dout("page/inode not in cache\n"); | |
300 | return ret; | |
301 | default: | |
302 | dout("%s: unknown error ret = %i\n", __func__, ret); | |
303 | return ret; | |
304 | } | |
305 | } | |
306 | ||
307 | void ceph_readpage_to_fscache(struct inode *inode, struct page *page) | |
308 | { | |
309 | struct ceph_inode_info *ci = ceph_inode(inode); | |
310 | int ret; | |
311 | ||
9b8dd1e8 MT |
312 | if (!PageFsCache(page)) |
313 | return; | |
314 | ||
99ccbd22 MT |
315 | if (!cache_valid(ci)) |
316 | return; | |
317 | ||
318 | ret = fscache_write_page(ci->fscache, page, GFP_KERNEL); | |
319 | if (ret) | |
320 | fscache_uncache_page(ci->fscache, page); | |
321 | } | |
322 | ||
323 | void ceph_invalidate_fscache_page(struct inode* inode, struct page *page) | |
324 | { | |
325 | struct ceph_inode_info *ci = ceph_inode(inode); | |
326 | ||
327 | fscache_wait_on_page_write(ci->fscache, page); | |
328 | fscache_uncache_page(ci->fscache, page); | |
329 | } | |
330 | ||
331 | void ceph_fscache_unregister_fs(struct ceph_fs_client* fsc) | |
332 | { | |
333 | if (fsc->revalidate_wq) | |
334 | destroy_workqueue(fsc->revalidate_wq); | |
335 | ||
336 | fscache_relinquish_cookie(fsc->fscache, 0); | |
337 | fsc->fscache = NULL; | |
338 | } | |
339 | ||
340 | static void ceph_revalidate_work(struct work_struct *work) | |
341 | { | |
342 | int issued; | |
343 | u32 orig_gen; | |
344 | struct ceph_inode_info *ci = container_of(work, struct ceph_inode_info, | |
345 | i_revalidate_work); | |
346 | struct inode *inode = &ci->vfs_inode; | |
347 | ||
348 | spin_lock(&ci->i_ceph_lock); | |
349 | issued = __ceph_caps_issued(ci, NULL); | |
350 | orig_gen = ci->i_rdcache_gen; | |
351 | spin_unlock(&ci->i_ceph_lock); | |
352 | ||
353 | if (!(issued & CEPH_CAP_FILE_CACHE)) { | |
354 | dout("revalidate_work lost cache before validation %p\n", | |
355 | inode); | |
356 | goto out; | |
357 | } | |
358 | ||
359 | if (!fscache_check_consistency(ci->fscache)) | |
360 | fscache_invalidate(ci->fscache); | |
361 | ||
362 | spin_lock(&ci->i_ceph_lock); | |
363 | /* Update the new valid generation (backwards sanity check too) */ | |
364 | if (orig_gen > ci->i_fscache_gen) { | |
365 | ci->i_fscache_gen = orig_gen; | |
366 | } | |
367 | spin_unlock(&ci->i_ceph_lock); | |
368 | ||
369 | out: | |
370 | iput(&ci->vfs_inode); | |
371 | } | |
372 | ||
373 | void ceph_queue_revalidate(struct inode *inode) | |
374 | { | |
e81568eb | 375 | struct ceph_fs_client *fsc = ceph_sb_to_client(inode->i_sb); |
99ccbd22 MT |
376 | struct ceph_inode_info *ci = ceph_inode(inode); |
377 | ||
e81568eb MT |
378 | if (fsc->revalidate_wq == NULL || ci->fscache == NULL) |
379 | return; | |
380 | ||
99ccbd22 MT |
381 | ihold(inode); |
382 | ||
383 | if (queue_work(ceph_sb_to_client(inode->i_sb)->revalidate_wq, | |
384 | &ci->i_revalidate_work)) { | |
385 | dout("ceph_queue_revalidate %p\n", inode); | |
386 | } else { | |
387 | dout("ceph_queue_revalidate %p failed\n)", inode); | |
388 | iput(inode); | |
389 | } | |
390 | } | |
391 | ||
392 | void ceph_fscache_inode_init(struct ceph_inode_info *ci) | |
393 | { | |
394 | ci->fscache = NULL; | |
395 | /* The first load is verifed cookie open time */ | |
396 | ci->i_fscache_gen = 1; | |
397 | INIT_WORK(&ci->i_revalidate_work, ceph_revalidate_work); | |
398 | } |