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