1// SPDX-License-Identifier: GPL-2.0-or-later
2/* FS-Cache interface to CacheFiles
3 *
4 * Copyright (C) 2021 Red Hat, Inc. All Rights Reserved.
5 * Written by David Howells (dhowells@redhat.com)
6 */
7
8#include <linux/slab.h>
9#include <linux/mount.h>
10#include <linux/xattr.h>
11#include <linux/file.h>
12#include <linux/namei.h>
13#include <linux/falloc.h>
14#include <trace/events/fscache.h>
15#include "internal.h"
16
17static atomic_t cachefiles_object_debug_id;
18
19/*
20 * Allocate a cache object record.
21 */
22static
23struct cachefiles_object *cachefiles_alloc_object(struct fscache_cookie *cookie)
24{
25 struct fscache_volume *vcookie = cookie->volume;
26 struct cachefiles_volume *volume = vcookie->cache_priv;
27 struct cachefiles_object *object;
28
29 _enter("{%s},%x,", vcookie->key, cookie->debug_id);
30
31 object = kmem_cache_zalloc(cachefiles_object_jar, GFP_KERNEL);
32 if (!object)
33 return NULL;
34
35 if (cachefiles_ondemand_init_obj_info(obj: object, volume)) {
36 kmem_cache_free(s: cachefiles_object_jar, objp: object);
37 return NULL;
38 }
39
40 refcount_set(r: &object->ref, n: 1);
41
42 spin_lock_init(&object->lock);
43 INIT_LIST_HEAD(list: &object->cache_link);
44 object->volume = volume;
45 object->debug_id = atomic_inc_return(v: &cachefiles_object_debug_id);
46 object->cookie = fscache_get_cookie(cookie, where: fscache_cookie_get_attach_object);
47
48 fscache_count_object(cache: vcookie->cache);
49 trace_cachefiles_ref(object_debug_id: object->debug_id, cookie_debug_id: cookie->debug_id, usage: 1,
50 why: cachefiles_obj_new);
51 return object;
52}
53
54/*
55 * Note that an object has been seen.
56 */
57void cachefiles_see_object(struct cachefiles_object *object,
58 enum cachefiles_obj_ref_trace why)
59{
60 trace_cachefiles_ref(object_debug_id: object->debug_id, cookie_debug_id: object->cookie->debug_id,
61 usage: refcount_read(r: &object->ref), why);
62}
63
64/*
65 * Increment the usage count on an object;
66 */
67struct cachefiles_object *cachefiles_grab_object(struct cachefiles_object *object,
68 enum cachefiles_obj_ref_trace why)
69{
70 int r;
71
72 __refcount_inc(r: &object->ref, oldp: &r);
73 trace_cachefiles_ref(object_debug_id: object->debug_id, cookie_debug_id: object->cookie->debug_id, usage: r, why);
74 return object;
75}
76
77/*
78 * dispose of a reference to an object
79 */
80void cachefiles_put_object(struct cachefiles_object *object,
81 enum cachefiles_obj_ref_trace why)
82{
83 unsigned int object_debug_id = object->debug_id;
84 unsigned int cookie_debug_id = object->cookie->debug_id;
85 struct fscache_cache *cache;
86 bool done;
87 int r;
88
89 done = __refcount_dec_and_test(r: &object->ref, oldp: &r);
90 trace_cachefiles_ref(object_debug_id, cookie_debug_id, usage: r, why);
91 if (done) {
92 _debug("- kill object OBJ%x", object_debug_id);
93
94 ASSERTCMP(object->file, ==, NULL);
95
96 kfree(objp: object->d_name);
97 cachefiles_ondemand_deinit_obj_info(obj: object);
98 cache = object->volume->cache->cache;
99 fscache_put_cookie(cookie: object->cookie, where: fscache_cookie_put_object);
100 object->cookie = NULL;
101 kmem_cache_free(s: cachefiles_object_jar, objp: object);
102 fscache_uncount_object(cache);
103 }
104
105 _leave("");
106}
107
108/*
109 * Adjust the size of a cache file if necessary to match the DIO size. We keep
110 * the EOF marker a multiple of DIO blocks so that we don't fall back to doing
111 * non-DIO for a partial block straddling the EOF, but we also have to be
112 * careful of someone expanding the file and accidentally accreting the
113 * padding.
114 */
115static int cachefiles_adjust_size(struct cachefiles_object *object)
116{
117 struct iattr newattrs;
118 struct file *file = object->file;
119 uint64_t ni_size;
120 loff_t oi_size;
121 int ret;
122
123 ni_size = object->cookie->object_size;
124 ni_size = round_up(ni_size, CACHEFILES_DIO_BLOCK_SIZE);
125
126 _enter("{OBJ%x},[%llu]",
127 object->debug_id, (unsigned long long) ni_size);
128
129 if (!file)
130 return -ENOBUFS;
131
132 oi_size = i_size_read(inode: file_inode(f: file));
133 if (oi_size == ni_size)
134 return 0;
135
136 inode_lock(inode: file_inode(f: file));
137
138 /* if there's an extension to a partial page at the end of the backing
139 * file, we need to discard the partial page so that we pick up new
140 * data after it */
141 if (oi_size & ~PAGE_MASK && ni_size > oi_size) {
142 _debug("discard tail %llx", oi_size);
143 newattrs.ia_valid = ATTR_SIZE;
144 newattrs.ia_size = oi_size & PAGE_MASK;
145 ret = cachefiles_inject_remove_error();
146 if (ret == 0)
147 ret = notify_change(&nop_mnt_idmap, file->f_path.dentry,
148 &newattrs, NULL);
149 if (ret < 0)
150 goto truncate_failed;
151 }
152
153 newattrs.ia_valid = ATTR_SIZE;
154 newattrs.ia_size = ni_size;
155 ret = cachefiles_inject_write_error();
156 if (ret == 0)
157 ret = notify_change(&nop_mnt_idmap, file->f_path.dentry,
158 &newattrs, NULL);
159
160truncate_failed:
161 inode_unlock(inode: file_inode(f: file));
162
163 if (ret < 0)
164 trace_cachefiles_io_error(NULL, backer: file_inode(f: file), error: ret,
165 where: cachefiles_trace_notify_change_error);
166 if (ret == -EIO) {
167 cachefiles_io_error_obj(object, "Size set failed");
168 ret = -ENOBUFS;
169 }
170
171 _leave(" = %d", ret);
172 return ret;
173}
174
175/*
176 * Attempt to look up the nominated node in this cache
177 */
178static bool cachefiles_lookup_cookie(struct fscache_cookie *cookie)
179{
180 struct cachefiles_object *object;
181 struct cachefiles_cache *cache = cookie->volume->cache->cache_priv;
182 const struct cred *saved_cred;
183 bool success;
184
185 object = cachefiles_alloc_object(cookie);
186 if (!object)
187 goto fail;
188
189 _enter("{OBJ%x}", object->debug_id);
190
191 if (!cachefiles_cook_key(object))
192 goto fail_put;
193
194 cookie->cache_priv = object;
195
196 cachefiles_begin_secure(cache, saved_cred: &saved_cred);
197
198 success = cachefiles_look_up_object(object);
199 if (!success)
200 goto fail_withdraw;
201
202 cachefiles_see_object(object, why: cachefiles_obj_see_lookup_cookie);
203
204 spin_lock(lock: &cache->object_list_lock);
205 list_add(new: &object->cache_link, head: &cache->object_list);
206 spin_unlock(lock: &cache->object_list_lock);
207 cachefiles_adjust_size(object);
208
209 cachefiles_end_secure(cache, saved_cred);
210 _leave(" = t");
211 return true;
212
213fail_withdraw:
214 cachefiles_end_secure(cache, saved_cred);
215 cachefiles_see_object(object, why: cachefiles_obj_see_lookup_failed);
216 fscache_caching_failed(cookie);
217 _debug("failed c=%08x o=%08x", cookie->debug_id, object->debug_id);
218 /* The caller holds an access count on the cookie, so we need them to
219 * drop it before we can withdraw the object.
220 */
221 return false;
222
223fail_put:
224 cachefiles_put_object(object, why: cachefiles_obj_put_alloc_fail);
225fail:
226 return false;
227}
228
229/*
230 * Shorten the backing object to discard any dirty data and free up
231 * any unused granules.
232 */
233static bool cachefiles_shorten_object(struct cachefiles_object *object,
234 struct file *file, loff_t new_size)
235{
236 struct cachefiles_cache *cache = object->volume->cache;
237 struct inode *inode = file_inode(f: file);
238 loff_t i_size, dio_size;
239 int ret;
240
241 dio_size = round_up(new_size, CACHEFILES_DIO_BLOCK_SIZE);
242 i_size = i_size_read(inode);
243
244 trace_cachefiles_trunc(obj: object, backer: inode, from: i_size, to: dio_size,
245 why: cachefiles_trunc_shrink);
246 ret = cachefiles_inject_remove_error();
247 if (ret == 0)
248 ret = vfs_truncate(&file->f_path, dio_size);
249 if (ret < 0) {
250 trace_cachefiles_io_error(obj: object, backer: file_inode(f: file), error: ret,
251 where: cachefiles_trace_trunc_error);
252 cachefiles_io_error_obj(object, "Trunc-to-size failed %d", ret);
253 cachefiles_remove_object_xattr(cache, object, dentry: file->f_path.dentry);
254 return false;
255 }
256
257 if (new_size < dio_size) {
258 trace_cachefiles_trunc(obj: object, backer: inode, from: dio_size, to: new_size,
259 why: cachefiles_trunc_dio_adjust);
260 ret = cachefiles_inject_write_error();
261 if (ret == 0)
262 ret = vfs_fallocate(file, FALLOC_FL_ZERO_RANGE,
263 offset: new_size, len: dio_size - new_size);
264 if (ret < 0) {
265 trace_cachefiles_io_error(obj: object, backer: file_inode(f: file), error: ret,
266 where: cachefiles_trace_fallocate_error);
267 cachefiles_io_error_obj(object, "Trunc-to-dio-size failed %d", ret);
268 cachefiles_remove_object_xattr(cache, object, dentry: file->f_path.dentry);
269 return false;
270 }
271 }
272
273 return true;
274}
275
276/*
277 * Resize the backing object.
278 */
279static void cachefiles_resize_cookie(struct netfs_cache_resources *cres,
280 loff_t new_size)
281{
282 struct cachefiles_object *object = cachefiles_cres_object(cres);
283 struct cachefiles_cache *cache = object->volume->cache;
284 struct fscache_cookie *cookie = object->cookie;
285 const struct cred *saved_cred;
286 struct file *file = cachefiles_cres_file(cres);
287 loff_t old_size = cookie->object_size;
288
289 _enter("%llu->%llu", old_size, new_size);
290
291 if (new_size < old_size) {
292 cachefiles_begin_secure(cache, saved_cred: &saved_cred);
293 cachefiles_shorten_object(object, file, new_size);
294 cachefiles_end_secure(cache, saved_cred);
295 object->cookie->object_size = new_size;
296 return;
297 }
298
299 /* The file is being expanded. We don't need to do anything
300 * particularly. cookie->initial_size doesn't change and so the point
301 * at which we have to download before doesn't change.
302 */
303 cookie->object_size = new_size;
304}
305
306/*
307 * Commit changes to the object as we drop it.
308 */
309static void cachefiles_commit_object(struct cachefiles_object *object,
310 struct cachefiles_cache *cache)
311{
312 bool update = false;
313
314 if (test_and_clear_bit(FSCACHE_COOKIE_LOCAL_WRITE, addr: &object->cookie->flags))
315 update = true;
316 if (test_and_clear_bit(FSCACHE_COOKIE_NEEDS_UPDATE, addr: &object->cookie->flags))
317 update = true;
318 if (update)
319 cachefiles_set_object_xattr(object);
320
321 if (test_bit(CACHEFILES_OBJECT_USING_TMPFILE, &object->flags))
322 cachefiles_commit_tmpfile(cache, object);
323}
324
325/*
326 * Finalise and object and close the VFS structs that we have.
327 */
328static void cachefiles_clean_up_object(struct cachefiles_object *object,
329 struct cachefiles_cache *cache)
330{
331 struct file *file;
332
333 if (test_bit(FSCACHE_COOKIE_RETIRED, &object->cookie->flags)) {
334 if (!test_bit(CACHEFILES_OBJECT_USING_TMPFILE, &object->flags)) {
335 cachefiles_see_object(object, why: cachefiles_obj_see_clean_delete);
336 _debug("- inval object OBJ%x", object->debug_id);
337 cachefiles_delete_object(object, why: FSCACHE_OBJECT_WAS_RETIRED);
338 } else {
339 cachefiles_see_object(object, why: cachefiles_obj_see_clean_drop_tmp);
340 _debug("- inval object OBJ%x tmpfile", object->debug_id);
341 }
342 } else {
343 cachefiles_see_object(object, why: cachefiles_obj_see_clean_commit);
344 cachefiles_commit_object(object, cache);
345 }
346
347 cachefiles_unmark_inode_in_use(object, file: object->file);
348
349 spin_lock(lock: &object->lock);
350 file = object->file;
351 object->file = NULL;
352 spin_unlock(lock: &object->lock);
353
354 if (file)
355 fput(file);
356}
357
358/*
359 * Withdraw caching for a cookie.
360 */
361static void cachefiles_withdraw_cookie(struct fscache_cookie *cookie)
362{
363 struct cachefiles_object *object = cookie->cache_priv;
364 struct cachefiles_cache *cache = object->volume->cache;
365 const struct cred *saved_cred;
366
367 _enter("o=%x", object->debug_id);
368 cachefiles_see_object(object, why: cachefiles_obj_see_withdraw_cookie);
369
370 if (!list_empty(head: &object->cache_link)) {
371 spin_lock(lock: &cache->object_list_lock);
372 cachefiles_see_object(object, why: cachefiles_obj_see_withdrawal);
373 list_del_init(entry: &object->cache_link);
374 spin_unlock(lock: &cache->object_list_lock);
375 }
376
377 cachefiles_ondemand_clean_object(object);
378
379 if (object->file) {
380 cachefiles_begin_secure(cache, saved_cred: &saved_cred);
381 cachefiles_clean_up_object(object, cache);
382 cachefiles_end_secure(cache, saved_cred);
383 }
384
385 cookie->cache_priv = NULL;
386 cachefiles_put_object(object, why: cachefiles_obj_put_detach);
387}
388
389/*
390 * Invalidate the storage associated with a cookie.
391 */
392static bool cachefiles_invalidate_cookie(struct fscache_cookie *cookie)
393{
394 struct cachefiles_object *object = cookie->cache_priv;
395 struct file *new_file, *old_file;
396 bool old_tmpfile;
397
398 _enter("o=%x,[%llu]", object->debug_id, object->cookie->object_size);
399
400 old_tmpfile = test_bit(CACHEFILES_OBJECT_USING_TMPFILE, &object->flags);
401
402 if (!object->file) {
403 fscache_resume_after_invalidation(cookie);
404 _leave(" = t [light]");
405 return true;
406 }
407
408 new_file = cachefiles_create_tmpfile(object);
409 if (IS_ERR(ptr: new_file))
410 goto failed;
411
412 /* Substitute the VFS target */
413 _debug("sub");
414 spin_lock(lock: &object->lock);
415
416 old_file = object->file;
417 object->file = new_file;
418 object->content_info = CACHEFILES_CONTENT_NO_DATA;
419 set_bit(CACHEFILES_OBJECT_USING_TMPFILE, addr: &object->flags);
420 set_bit(FSCACHE_COOKIE_NEEDS_UPDATE, addr: &object->cookie->flags);
421
422 spin_unlock(lock: &object->lock);
423 _debug("subbed");
424
425 /* Allow I/O to take place again */
426 fscache_resume_after_invalidation(cookie);
427
428 if (old_file) {
429 if (!old_tmpfile) {
430 struct cachefiles_volume *volume = object->volume;
431 struct dentry *fan = volume->fanout[(u8)cookie->key_hash];
432 struct dentry *obj;
433
434 obj = start_removing_dentry(parent: fan, child: old_file->f_path.dentry);
435 if (!IS_ERR(ptr: obj))
436 cachefiles_bury_object(cache: volume->cache, object,
437 dir: fan, rep: obj,
438 why: FSCACHE_OBJECT_INVALIDATED);
439 }
440 fput(old_file);
441 }
442
443 _leave(" = t");
444 return true;
445
446failed:
447 _leave(" = f");
448 return false;
449}
450
451const struct fscache_cache_ops cachefiles_cache_ops = {
452 .name = "cachefiles",
453 .acquire_volume = cachefiles_acquire_volume,
454 .free_volume = cachefiles_free_volume,
455 .lookup_cookie = cachefiles_lookup_cookie,
456 .withdraw_cookie = cachefiles_withdraw_cookie,
457 .invalidate_cookie = cachefiles_invalidate_cookie,
458 .begin_operation = cachefiles_begin_operation,
459 .resize_cookie = cachefiles_resize_cookie,
460 .prepare_to_write = cachefiles_prepare_to_write,
461};
462

source code of linux/fs/cachefiles/interface.c