]> git.proxmox.com Git - mirror_ubuntu-eoan-kernel.git/blame - fs/ceph/cache.c
Merge tag 'for-linus-20180922' of git://git.kernel.dk/linux-block
[mirror_ubuntu-eoan-kernel.git] / fs / ceph / cache.c
CommitLineData
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
27struct ceph_aux_inode {
9bbeab41
AB
28 u64 version;
29 u64 mtime_sec;
30 u64 mtime_nsec;
99ccbd22
MT
31};
32
33struct fscache_netfs ceph_cache_netfs = {
34 .name = "ceph",
35 .version = 0,
36};
37
1d8f8360
YZ
38static DEFINE_MUTEX(ceph_fscache_lock);
39static LIST_HEAD(ceph_fscache_list);
40
41struct ceph_fscache_entry {
42 struct list_head list;
43 struct fscache_cookie *fscache;
1d8f8360 44 size_t uniq_len;
402cb8dd
DH
45 /* The following members must be last */
46 struct ceph_fsid fsid;
1d8f8360
YZ
47 char uniquifier[0];
48};
49
99ccbd22
MT
50static const struct fscache_cookie_def ceph_fscache_fsid_object_def = {
51 .name = "CEPH.fsid",
52 .type = FSCACHE_COOKIE_TYPE_INDEX,
99ccbd22
MT
53};
54
57a35dfb 55int __init ceph_fscache_register(void)
99ccbd22
MT
56{
57 return fscache_register_netfs(&ceph_cache_netfs);
58}
59
971f0bde 60void ceph_fscache_unregister(void)
99ccbd22
MT
61{
62 fscache_unregister_netfs(&ceph_cache_netfs);
63}
64
65int ceph_fscache_register_fs(struct ceph_fs_client* fsc)
66{
1d8f8360
YZ
67 const struct ceph_fsid *fsid = &fsc->client->fsid;
68 const char *fscache_uniq = fsc->mount_options->fscache_uniq;
69 size_t uniq_len = fscache_uniq ? strlen(fscache_uniq) : 0;
70 struct ceph_fscache_entry *ent;
71 int err = 0;
72
73 mutex_lock(&ceph_fscache_lock);
74 list_for_each_entry(ent, &ceph_fscache_list, list) {
75 if (memcmp(&ent->fsid, fsid, sizeof(*fsid)))
76 continue;
77 if (ent->uniq_len != uniq_len)
78 continue;
79 if (uniq_len && memcmp(ent->uniquifier, fscache_uniq, uniq_len))
80 continue;
81
82 pr_err("fscache cookie already registered for fsid %pU\n", fsid);
83 pr_err(" use fsc=%%s mount option to specify a uniquifier\n");
84 err = -EBUSY;
85 goto out_unlock;
86 }
87
88 ent = kzalloc(sizeof(*ent) + uniq_len, GFP_KERNEL);
89 if (!ent) {
90 err = -ENOMEM;
91 goto out_unlock;
92 }
93
402cb8dd
DH
94 memcpy(&ent->fsid, fsid, sizeof(*fsid));
95 if (uniq_len > 0) {
96 memcpy(&ent->uniquifier, fscache_uniq, uniq_len);
97 ent->uniq_len = uniq_len;
98 }
99
99ccbd22
MT
100 fsc->fscache = fscache_acquire_cookie(ceph_cache_netfs.primary_index,
101 &ceph_fscache_fsid_object_def,
402cb8dd
DH
102 &ent->fsid, sizeof(ent->fsid) + uniq_len,
103 NULL, 0,
ee1235a9 104 fsc, 0, true);
99ccbd22 105
1d8f8360 106 if (fsc->fscache) {
1d8f8360
YZ
107 ent->fscache = fsc->fscache;
108 list_add_tail(&ent->list, &ceph_fscache_list);
109 } else {
110 kfree(ent);
111 pr_err("unable to register fscache cookie for fsid %pU\n",
112 fsid);
113 /* all other fs ignore this error */
114 }
115out_unlock:
116 mutex_unlock(&ceph_fscache_lock);
117 return err;
99ccbd22
MT
118}
119
99ccbd22 120static enum fscache_checkaux ceph_fscache_inode_check_aux(
ee1235a9
DH
121 void *cookie_netfs_data, const void *data, uint16_t dlen,
122 loff_t object_size)
99ccbd22
MT
123{
124 struct ceph_aux_inode aux;
125 struct ceph_inode_info* ci = cookie_netfs_data;
126 struct inode* inode = &ci->vfs_inode;
127
ee1235a9
DH
128 if (dlen != sizeof(aux) ||
129 i_size_read(inode) != object_size)
99ccbd22
MT
130 return FSCACHE_CHECKAUX_OBSOLETE;
131
132 memset(&aux, 0, sizeof(aux));
f6973c09 133 aux.version = ci->i_version;
9bbeab41
AB
134 aux.mtime_sec = inode->i_mtime.tv_sec;
135 aux.mtime_nsec = inode->i_mtime.tv_nsec;
99ccbd22
MT
136
137 if (memcmp(data, &aux, sizeof(aux)) != 0)
138 return FSCACHE_CHECKAUX_OBSOLETE;
139
4c069a58 140 dout("ceph inode 0x%p cached okay\n", ci);
99ccbd22
MT
141 return FSCACHE_CHECKAUX_OKAY;
142}
143
99ccbd22
MT
144static const struct fscache_cookie_def ceph_fscache_inode_object_def = {
145 .name = "CEPH.inode",
146 .type = FSCACHE_COOKIE_TYPE_DATAFILE,
99ccbd22 147 .check_aux = ceph_fscache_inode_check_aux,
99ccbd22
MT
148};
149
46b59b2b 150void ceph_fscache_register_inode_cookie(struct inode *inode)
99ccbd22 151{
46b59b2b
YZ
152 struct ceph_inode_info *ci = ceph_inode(inode);
153 struct ceph_fs_client *fsc = ceph_inode_to_client(inode);
402cb8dd 154 struct ceph_aux_inode aux;
99ccbd22
MT
155
156 /* No caching for filesystem */
d37b1d99 157 if (!fsc->fscache)
99ccbd22
MT
158 return;
159
160 /* Only cache for regular files that are read only */
46b59b2b 161 if (!S_ISREG(inode->i_mode))
99ccbd22
MT
162 return;
163
46b59b2b
YZ
164 inode_lock_nested(inode, I_MUTEX_CHILD);
165 if (!ci->fscache) {
402cb8dd
DH
166 memset(&aux, 0, sizeof(aux));
167 aux.version = ci->i_version;
9bbeab41
AB
168 aux.mtime_sec = inode->i_mtime.tv_sec;
169 aux.mtime_nsec = inode->i_mtime.tv_nsec;
46b59b2b 170 ci->fscache = fscache_acquire_cookie(fsc->fscache,
402cb8dd
DH
171 &ceph_fscache_inode_object_def,
172 &ci->i_vino, sizeof(ci->i_vino),
173 &aux, sizeof(aux),
ee1235a9 174 ci, i_size_read(inode), false);
46b59b2b 175 }
5955102c 176 inode_unlock(inode);
99ccbd22
MT
177}
178
179void ceph_fscache_unregister_inode_cookie(struct ceph_inode_info* ci)
180{
181 struct fscache_cookie* cookie;
182
183 if ((cookie = ci->fscache) == NULL)
184 return;
185
186 ci->fscache = NULL;
187
188 fscache_uncache_all_inode_pages(cookie, &ci->vfs_inode);
402cb8dd 189 fscache_relinquish_cookie(cookie, &ci->i_vino, false);
99ccbd22
MT
190}
191
46b59b2b
YZ
192static bool ceph_fscache_can_enable(void *data)
193{
194 struct inode *inode = data;
195 return !inode_is_open_for_write(inode);
196}
197
198void ceph_fscache_file_set_cookie(struct inode *inode, struct file *filp)
199{
200 struct ceph_inode_info *ci = ceph_inode(inode);
201
202 if (!fscache_cookie_valid(ci->fscache))
203 return;
204
205 if (inode_is_open_for_write(inode)) {
206 dout("fscache_file_set_cookie %p %p disabling cache\n",
207 inode, filp);
402cb8dd 208 fscache_disable_cookie(ci->fscache, &ci->i_vino, false);
46b59b2b
YZ
209 fscache_uncache_all_inode_pages(ci->fscache, inode);
210 } else {
ee1235a9 211 fscache_enable_cookie(ci->fscache, &ci->i_vino, i_size_read(inode),
402cb8dd 212 ceph_fscache_can_enable, inode);
46b59b2b 213 if (fscache_cookie_enabled(ci->fscache)) {
0fbc5360 214 dout("fscache_file_set_cookie %p %p enabling cache\n",
46b59b2b
YZ
215 inode, filp);
216 }
217 }
218}
219
dd2bc473 220static void ceph_readpage_from_fscache_complete(struct page *page, void *data, int error)
99ccbd22
MT
221{
222 if (!error)
223 SetPageUptodate(page);
224
225 unlock_page(page);
226}
227
3b33f692 228static inline bool cache_valid(struct ceph_inode_info *ci)
99ccbd22 229{
f7f7e7a0 230 return ci->i_fscache_gen == ci->i_rdcache_gen;
99ccbd22
MT
231}
232
233
234/* Atempt to read from the fscache,
235 *
236 * This function is called from the readpage_nounlock context. DO NOT attempt to
237 * unlock the page here (or in the callback).
238 */
239int ceph_readpage_from_fscache(struct inode *inode, struct page *page)
240{
241 struct ceph_inode_info *ci = ceph_inode(inode);
242 int ret;
243
244 if (!cache_valid(ci))
245 return -ENOBUFS;
246
247 ret = fscache_read_or_alloc_page(ci->fscache, page,
dd2bc473 248 ceph_readpage_from_fscache_complete, NULL,
99ccbd22
MT
249 GFP_KERNEL);
250
251 switch (ret) {
252 case 0: /* Page found */
253 dout("page read submitted\n");
254 return 0;
255 case -ENOBUFS: /* Pages were not found, and can't be */
256 case -ENODATA: /* Pages were not found */
257 dout("page/inode not in cache\n");
258 return ret;
259 default:
260 dout("%s: unknown error ret = %i\n", __func__, ret);
261 return ret;
262 }
263}
264
265int ceph_readpages_from_fscache(struct inode *inode,
266 struct address_space *mapping,
267 struct list_head *pages,
268 unsigned *nr_pages)
269{
270 struct ceph_inode_info *ci = ceph_inode(inode);
271 int ret;
272
273 if (!cache_valid(ci))
274 return -ENOBUFS;
275
276 ret = fscache_read_or_alloc_pages(ci->fscache, mapping, pages, nr_pages,
dd2bc473 277 ceph_readpage_from_fscache_complete,
99ccbd22
MT
278 NULL, mapping_gfp_mask(mapping));
279
280 switch (ret) {
281 case 0: /* All pages found */
282 dout("all-page read submitted\n");
283 return 0;
284 case -ENOBUFS: /* Some pages were not found, and can't be */
285 case -ENODATA: /* some pages were not found */
286 dout("page/inode not in cache\n");
287 return ret;
288 default:
289 dout("%s: unknown error ret = %i\n", __func__, ret);
290 return ret;
291 }
292}
293
294void ceph_readpage_to_fscache(struct inode *inode, struct page *page)
295{
296 struct ceph_inode_info *ci = ceph_inode(inode);
297 int ret;
298
9b8dd1e8
MT
299 if (!PageFsCache(page))
300 return;
301
99ccbd22
MT
302 if (!cache_valid(ci))
303 return;
304
ee1235a9
DH
305 ret = fscache_write_page(ci->fscache, page, i_size_read(inode),
306 GFP_KERNEL);
99ccbd22
MT
307 if (ret)
308 fscache_uncache_page(ci->fscache, page);
309}
310
311void ceph_invalidate_fscache_page(struct inode* inode, struct page *page)
312{
313 struct ceph_inode_info *ci = ceph_inode(inode);
314
ffc79664
MT
315 if (!PageFsCache(page))
316 return;
317
99ccbd22
MT
318 fscache_wait_on_page_write(ci->fscache, page);
319 fscache_uncache_page(ci->fscache, page);
320}
321
322void ceph_fscache_unregister_fs(struct ceph_fs_client* fsc)
323{
1d8f8360
YZ
324 if (fscache_cookie_valid(fsc->fscache)) {
325 struct ceph_fscache_entry *ent;
326 bool found = false;
327
328 mutex_lock(&ceph_fscache_lock);
329 list_for_each_entry(ent, &ceph_fscache_list, list) {
330 if (ent->fscache == fsc->fscache) {
331 list_del(&ent->list);
332 kfree(ent);
333 found = true;
334 break;
335 }
336 }
337 WARN_ON_ONCE(!found);
338 mutex_unlock(&ceph_fscache_lock);
339
402cb8dd 340 __fscache_relinquish_cookie(fsc->fscache, NULL, false);
1d8f8360 341 }
99ccbd22
MT
342 fsc->fscache = NULL;
343}
344
f7f7e7a0
YZ
345/*
346 * caller should hold CEPH_CAP_FILE_{RD,CACHE}
347 */
348void ceph_fscache_revalidate_cookie(struct ceph_inode_info *ci)
99ccbd22 349{
f7f7e7a0 350 if (cache_valid(ci))
e81568eb
MT
351 return;
352
f7f7e7a0
YZ
353 /* resue i_truncate_mutex. There should be no pending
354 * truncate while the caller holds CEPH_CAP_FILE_RD */
355 mutex_lock(&ci->i_truncate_mutex);
356 if (!cache_valid(ci)) {
402cb8dd 357 if (fscache_check_consistency(ci->fscache, &ci->i_vino))
f7f7e7a0
YZ
358 fscache_invalidate(ci->fscache);
359 spin_lock(&ci->i_ceph_lock);
360 ci->i_fscache_gen = ci->i_rdcache_gen;
361 spin_unlock(&ci->i_ceph_lock);
99ccbd22 362 }
f7f7e7a0 363 mutex_unlock(&ci->i_truncate_mutex);
99ccbd22 364}