1 // SPDX-License-Identifier: GPL-2.0-or-later
2 /* CacheFiles path walking and related routines
3 *
4 * Copyright (C) 2021 Red Hat, Inc. All Rights Reserved.
5 * Written by David Howells (dhowells@redhat.com)
6 */
7
8 #include <linux/fs.h>
9 #include <linux/namei.h>
10 #include "internal.h"
11
12 /*
13 * Mark the backing file as being a cache file if it's not already in use. The
14 * mark tells the culling request command that it's not allowed to cull the
15 * file or directory. The caller must hold the inode lock.
16 */
__cachefiles_mark_inode_in_use(struct cachefiles_object * object,struct inode * inode)17 static bool __cachefiles_mark_inode_in_use(struct cachefiles_object *object,
18 struct inode *inode)
19 {
20 bool can_use = false;
21
22 if (!(inode->i_flags & S_KERNEL_FILE)) {
23 inode->i_flags |= S_KERNEL_FILE;
24 trace_cachefiles_mark_active(object, inode);
25 can_use = true;
26 } else {
27 trace_cachefiles_mark_failed(object, inode);
28 }
29
30 return can_use;
31 }
32
cachefiles_mark_inode_in_use(struct cachefiles_object * object,struct inode * inode)33 static bool cachefiles_mark_inode_in_use(struct cachefiles_object *object,
34 struct inode *inode)
35 {
36 bool can_use;
37
38 inode_lock(inode);
39 can_use = __cachefiles_mark_inode_in_use(object, inode);
40 inode_unlock(inode);
41 return can_use;
42 }
43
44 /*
45 * Unmark a backing inode. The caller must hold the inode lock.
46 */
__cachefiles_unmark_inode_in_use(struct cachefiles_object * object,struct inode * inode)47 static void __cachefiles_unmark_inode_in_use(struct cachefiles_object *object,
48 struct inode *inode)
49 {
50 inode->i_flags &= ~S_KERNEL_FILE;
51 trace_cachefiles_mark_inactive(object, inode);
52 }
53
cachefiles_do_unmark_inode_in_use(struct cachefiles_object * object,struct inode * inode)54 static void cachefiles_do_unmark_inode_in_use(struct cachefiles_object *object,
55 struct inode *inode)
56 {
57 inode_lock(inode);
58 __cachefiles_unmark_inode_in_use(object, inode);
59 inode_unlock(inode);
60 }
61
62 /*
63 * Unmark a backing inode and tell cachefilesd that there's something that can
64 * be culled.
65 */
cachefiles_unmark_inode_in_use(struct cachefiles_object * object,struct file * file)66 void cachefiles_unmark_inode_in_use(struct cachefiles_object *object,
67 struct file *file)
68 {
69 struct cachefiles_cache *cache = object->volume->cache;
70 struct inode *inode = file_inode(file);
71
72 cachefiles_do_unmark_inode_in_use(object, inode);
73
74 if (!test_bit(CACHEFILES_OBJECT_USING_TMPFILE, &object->flags)) {
75 atomic_long_add(inode->i_blocks, &cache->b_released);
76 if (atomic_inc_return(&cache->f_released))
77 cachefiles_state_changed(cache);
78 }
79 }
80
81 /*
82 * get a subdirectory
83 */
cachefiles_get_directory(struct cachefiles_cache * cache,struct dentry * dir,const char * dirname,bool * _is_new)84 struct dentry *cachefiles_get_directory(struct cachefiles_cache *cache,
85 struct dentry *dir,
86 const char *dirname,
87 bool *_is_new)
88 {
89 struct dentry *subdir;
90 struct path path;
91 int ret;
92
93 _enter(",,%s", dirname);
94
95 /* search the current directory for the element name */
96 inode_lock_nested(d_inode(dir), I_MUTEX_PARENT);
97
98 retry:
99 ret = cachefiles_inject_read_error();
100 if (ret == 0)
101 subdir = lookup_one_len(dirname, dir, strlen(dirname));
102 else
103 subdir = ERR_PTR(ret);
104 trace_cachefiles_lookup(NULL, dir, subdir);
105 if (IS_ERR(subdir)) {
106 trace_cachefiles_vfs_error(NULL, d_backing_inode(dir),
107 PTR_ERR(subdir),
108 cachefiles_trace_lookup_error);
109 if (PTR_ERR(subdir) == -ENOMEM)
110 goto nomem_d_alloc;
111 goto lookup_error;
112 }
113
114 _debug("subdir -> %pd %s",
115 subdir, d_backing_inode(subdir) ? "positive" : "negative");
116
117 /* we need to create the subdir if it doesn't exist yet */
118 if (d_is_negative(subdir)) {
119 ret = cachefiles_has_space(cache, 1, 0,
120 cachefiles_has_space_for_create);
121 if (ret < 0)
122 goto mkdir_error;
123
124 _debug("attempt mkdir");
125
126 path.mnt = cache->mnt;
127 path.dentry = dir;
128 ret = security_path_mkdir(&path, subdir, 0700);
129 if (ret < 0)
130 goto mkdir_error;
131 ret = cachefiles_inject_write_error();
132 if (ret == 0)
133 subdir = vfs_mkdir(&nop_mnt_idmap, d_inode(dir), subdir, 0700);
134 else
135 subdir = ERR_PTR(ret);
136 if (IS_ERR(subdir)) {
137 trace_cachefiles_vfs_error(NULL, d_inode(dir), ret,
138 cachefiles_trace_mkdir_error);
139 goto mkdir_error;
140 }
141 trace_cachefiles_mkdir(dir, subdir);
142
143 if (unlikely(d_unhashed(subdir) || d_is_negative(subdir))) {
144 dput(subdir);
145 goto retry;
146 }
147 ASSERT(d_backing_inode(subdir));
148
149 _debug("mkdir -> %pd{ino=%lu}",
150 subdir, d_backing_inode(subdir)->i_ino);
151 if (_is_new)
152 *_is_new = true;
153 }
154
155 /* Tell rmdir() it's not allowed to delete the subdir */
156 inode_lock(d_inode(subdir));
157 inode_unlock(d_inode(dir));
158
159 if (!__cachefiles_mark_inode_in_use(NULL, d_inode(subdir))) {
160 pr_notice("cachefiles: Inode already in use: %pd (B=%lx)\n",
161 subdir, d_inode(subdir)->i_ino);
162 goto mark_error;
163 }
164
165 inode_unlock(d_inode(subdir));
166
167 /* we need to make sure the subdir is a directory */
168 ASSERT(d_backing_inode(subdir));
169
170 if (!d_can_lookup(subdir)) {
171 pr_err("%s is not a directory\n", dirname);
172 ret = -EIO;
173 goto check_error;
174 }
175
176 ret = -EPERM;
177 if (!(d_backing_inode(subdir)->i_opflags & IOP_XATTR) ||
178 !d_backing_inode(subdir)->i_op->lookup ||
179 !d_backing_inode(subdir)->i_op->mkdir ||
180 !d_backing_inode(subdir)->i_op->rename ||
181 !d_backing_inode(subdir)->i_op->rmdir ||
182 !d_backing_inode(subdir)->i_op->unlink)
183 goto check_error;
184
185 _leave(" = [%lu]", d_backing_inode(subdir)->i_ino);
186 return subdir;
187
188 check_error:
189 cachefiles_put_directory(subdir);
190 _leave(" = %d [check]", ret);
191 return ERR_PTR(ret);
192
193 mark_error:
194 inode_unlock(d_inode(subdir));
195 dput(subdir);
196 return ERR_PTR(-EBUSY);
197
198 mkdir_error:
199 inode_unlock(d_inode(dir));
200 if (!IS_ERR(subdir))
201 dput(subdir);
202 pr_err("mkdir %s failed with error %d\n", dirname, ret);
203 return ERR_PTR(ret);
204
205 lookup_error:
206 inode_unlock(d_inode(dir));
207 ret = PTR_ERR(subdir);
208 pr_err("Lookup %s failed with error %d\n", dirname, ret);
209 return ERR_PTR(ret);
210
211 nomem_d_alloc:
212 inode_unlock(d_inode(dir));
213 _leave(" = -ENOMEM");
214 return ERR_PTR(-ENOMEM);
215 }
216
217 /*
218 * Put a subdirectory.
219 */
cachefiles_put_directory(struct dentry * dir)220 void cachefiles_put_directory(struct dentry *dir)
221 {
222 if (dir) {
223 cachefiles_do_unmark_inode_in_use(NULL, d_inode(dir));
224 dput(dir);
225 }
226 }
227
228 /*
229 * Remove a regular file from the cache.
230 */
cachefiles_unlink(struct cachefiles_cache * cache,struct cachefiles_object * object,struct dentry * dir,struct dentry * dentry,enum fscache_why_object_killed why)231 static int cachefiles_unlink(struct cachefiles_cache *cache,
232 struct cachefiles_object *object,
233 struct dentry *dir, struct dentry *dentry,
234 enum fscache_why_object_killed why)
235 {
236 struct path path = {
237 .mnt = cache->mnt,
238 .dentry = dir,
239 };
240 int ret;
241
242 trace_cachefiles_unlink(object, d_inode(dentry)->i_ino, why);
243 ret = security_path_unlink(&path, dentry);
244 if (ret < 0) {
245 cachefiles_io_error(cache, "Unlink security error");
246 return ret;
247 }
248
249 ret = cachefiles_inject_remove_error();
250 if (ret == 0) {
251 ret = vfs_unlink(&nop_mnt_idmap, d_backing_inode(dir), dentry, NULL);
252 if (ret == -EIO)
253 cachefiles_io_error(cache, "Unlink failed");
254 }
255 if (ret != 0)
256 trace_cachefiles_vfs_error(object, d_backing_inode(dir), ret,
257 cachefiles_trace_unlink_error);
258 return ret;
259 }
260
261 /*
262 * Delete an object representation from the cache
263 * - File backed objects are unlinked
264 * - Directory backed objects are stuffed into the graveyard for userspace to
265 * delete
266 */
cachefiles_bury_object(struct cachefiles_cache * cache,struct cachefiles_object * object,struct dentry * dir,struct dentry * rep,enum fscache_why_object_killed why)267 int cachefiles_bury_object(struct cachefiles_cache *cache,
268 struct cachefiles_object *object,
269 struct dentry *dir,
270 struct dentry *rep,
271 enum fscache_why_object_killed why)
272 {
273 struct dentry *grave, *trap;
274 struct path path, path_to_graveyard;
275 char nbuffer[8 + 8 + 1];
276 int ret;
277
278 _enter(",'%pd','%pd'", dir, rep);
279
280 if (rep->d_parent != dir) {
281 inode_unlock(d_inode(dir));
282 _leave(" = -ESTALE");
283 return -ESTALE;
284 }
285
286 /* non-directories can just be unlinked */
287 if (!d_is_dir(rep)) {
288 dget(rep); /* Stop the dentry being negated if it's only pinned
289 * by a file struct.
290 */
291 ret = cachefiles_unlink(cache, object, dir, rep, why);
292 dput(rep);
293
294 inode_unlock(d_inode(dir));
295 _leave(" = %d", ret);
296 return ret;
297 }
298
299 /* directories have to be moved to the graveyard */
300 _debug("move stale object to graveyard");
301 inode_unlock(d_inode(dir));
302
303 try_again:
304 /* first step is to make up a grave dentry in the graveyard */
305 sprintf(nbuffer, "%08x%08x",
306 (uint32_t) ktime_get_real_seconds(),
307 (uint32_t) atomic_inc_return(&cache->gravecounter));
308
309 /* do the multiway lock magic */
310 trap = lock_rename(cache->graveyard, dir);
311 if (IS_ERR(trap))
312 return PTR_ERR(trap);
313
314 /* do some checks before getting the grave dentry */
315 if (rep->d_parent != dir || IS_DEADDIR(d_inode(rep))) {
316 /* the entry was probably culled when we dropped the parent dir
317 * lock */
318 unlock_rename(cache->graveyard, dir);
319 _leave(" = 0 [culled?]");
320 return 0;
321 }
322
323 if (!d_can_lookup(cache->graveyard)) {
324 unlock_rename(cache->graveyard, dir);
325 cachefiles_io_error(cache, "Graveyard no longer a directory");
326 return -EIO;
327 }
328
329 if (trap == rep) {
330 unlock_rename(cache->graveyard, dir);
331 cachefiles_io_error(cache, "May not make directory loop");
332 return -EIO;
333 }
334
335 if (d_mountpoint(rep)) {
336 unlock_rename(cache->graveyard, dir);
337 cachefiles_io_error(cache, "Mountpoint in cache");
338 return -EIO;
339 }
340
341 grave = lookup_one_len(nbuffer, cache->graveyard, strlen(nbuffer));
342 if (IS_ERR(grave)) {
343 unlock_rename(cache->graveyard, dir);
344 trace_cachefiles_vfs_error(object, d_inode(cache->graveyard),
345 PTR_ERR(grave),
346 cachefiles_trace_lookup_error);
347
348 if (PTR_ERR(grave) == -ENOMEM) {
349 _leave(" = -ENOMEM");
350 return -ENOMEM;
351 }
352
353 cachefiles_io_error(cache, "Lookup error %ld", PTR_ERR(grave));
354 return -EIO;
355 }
356
357 if (d_is_positive(grave)) {
358 unlock_rename(cache->graveyard, dir);
359 dput(grave);
360 grave = NULL;
361 cond_resched();
362 goto try_again;
363 }
364
365 if (d_mountpoint(grave)) {
366 unlock_rename(cache->graveyard, dir);
367 dput(grave);
368 cachefiles_io_error(cache, "Mountpoint in graveyard");
369 return -EIO;
370 }
371
372 /* target should not be an ancestor of source */
373 if (trap == grave) {
374 unlock_rename(cache->graveyard, dir);
375 dput(grave);
376 cachefiles_io_error(cache, "May not make directory loop");
377 return -EIO;
378 }
379
380 /* attempt the rename */
381 path.mnt = cache->mnt;
382 path.dentry = dir;
383 path_to_graveyard.mnt = cache->mnt;
384 path_to_graveyard.dentry = cache->graveyard;
385 ret = security_path_rename(&path, rep, &path_to_graveyard, grave, 0);
386 if (ret < 0) {
387 cachefiles_io_error(cache, "Rename security error %d", ret);
388 } else {
389 struct renamedata rd = {
390 .old_mnt_idmap = &nop_mnt_idmap,
391 .old_dir = d_inode(dir),
392 .old_dentry = rep,
393 .new_mnt_idmap = &nop_mnt_idmap,
394 .new_dir = d_inode(cache->graveyard),
395 .new_dentry = grave,
396 };
397 trace_cachefiles_rename(object, d_inode(rep)->i_ino, why);
398 ret = cachefiles_inject_read_error();
399 if (ret == 0)
400 ret = vfs_rename(&rd);
401 if (ret != 0)
402 trace_cachefiles_vfs_error(object, d_inode(dir), ret,
403 cachefiles_trace_rename_error);
404 if (ret != 0 && ret != -ENOMEM)
405 cachefiles_io_error(cache,
406 "Rename failed with error %d", ret);
407 }
408
409 __cachefiles_unmark_inode_in_use(object, d_inode(rep));
410 unlock_rename(cache->graveyard, dir);
411 dput(grave);
412 _leave(" = 0");
413 return 0;
414 }
415
416 /*
417 * Delete a cache file.
418 */
cachefiles_delete_object(struct cachefiles_object * object,enum fscache_why_object_killed why)419 int cachefiles_delete_object(struct cachefiles_object *object,
420 enum fscache_why_object_killed why)
421 {
422 struct cachefiles_volume *volume = object->volume;
423 struct dentry *dentry = object->file->f_path.dentry;
424 struct dentry *fan = volume->fanout[(u8)object->cookie->key_hash];
425 int ret;
426
427 _enter(",OBJ%x{%pD}", object->debug_id, object->file);
428
429 /* Stop the dentry being negated if it's only pinned by a file struct. */
430 dget(dentry);
431
432 inode_lock_nested(d_backing_inode(fan), I_MUTEX_PARENT);
433 ret = cachefiles_unlink(volume->cache, object, fan, dentry, why);
434 inode_unlock(d_backing_inode(fan));
435 dput(dentry);
436 return ret;
437 }
438
439 /*
440 * Create a temporary file and leave it unattached and un-xattr'd until the
441 * time comes to discard the object from memory.
442 */
cachefiles_create_tmpfile(struct cachefiles_object * object)443 struct file *cachefiles_create_tmpfile(struct cachefiles_object *object)
444 {
445 struct cachefiles_volume *volume = object->volume;
446 struct cachefiles_cache *cache = volume->cache;
447 const struct cred *saved_cred;
448 struct dentry *fan = volume->fanout[(u8)object->cookie->key_hash];
449 struct file *file;
450 const struct path parentpath = { .mnt = cache->mnt, .dentry = fan };
451 uint64_t ni_size;
452 long ret;
453
454
455 cachefiles_begin_secure(cache, &saved_cred);
456
457 ret = cachefiles_inject_write_error();
458 if (ret == 0) {
459 file = kernel_tmpfile_open(&nop_mnt_idmap, &parentpath,
460 S_IFREG | 0600,
461 O_RDWR | O_LARGEFILE | O_DIRECT,
462 cache->cache_cred);
463 ret = PTR_ERR_OR_ZERO(file);
464 }
465 if (ret) {
466 trace_cachefiles_vfs_error(object, d_inode(fan), ret,
467 cachefiles_trace_tmpfile_error);
468 if (ret == -EIO)
469 cachefiles_io_error_obj(object, "Failed to create tmpfile");
470 goto err;
471 }
472
473 trace_cachefiles_tmpfile(object, file_inode(file));
474
475 /* This is a newly created file with no other possible user */
476 if (!cachefiles_mark_inode_in_use(object, file_inode(file)))
477 WARN_ON(1);
478
479 ret = cachefiles_ondemand_init_object(object);
480 if (ret < 0)
481 goto err_unuse;
482
483 ni_size = object->cookie->object_size;
484 ni_size = round_up(ni_size, CACHEFILES_DIO_BLOCK_SIZE);
485
486 if (ni_size > 0) {
487 trace_cachefiles_trunc(object, file_inode(file), 0, ni_size,
488 cachefiles_trunc_expand_tmpfile);
489 ret = cachefiles_inject_write_error();
490 if (ret == 0)
491 ret = vfs_truncate(&file->f_path, ni_size);
492 if (ret < 0) {
493 trace_cachefiles_vfs_error(
494 object, file_inode(file), ret,
495 cachefiles_trace_trunc_error);
496 goto err_unuse;
497 }
498 }
499
500 ret = -EINVAL;
501 if (unlikely(!file->f_op->read_iter) ||
502 unlikely(!file->f_op->write_iter)) {
503 fput(file);
504 pr_notice("Cache does not support read_iter and write_iter\n");
505 goto err_unuse;
506 }
507 out:
508 cachefiles_end_secure(cache, saved_cred);
509 return file;
510
511 err_unuse:
512 cachefiles_do_unmark_inode_in_use(object, file_inode(file));
513 fput(file);
514 err:
515 file = ERR_PTR(ret);
516 goto out;
517 }
518
519 /*
520 * Create a new file.
521 */
cachefiles_create_file(struct cachefiles_object * object)522 static bool cachefiles_create_file(struct cachefiles_object *object)
523 {
524 struct file *file;
525 int ret;
526
527 ret = cachefiles_has_space(object->volume->cache, 1, 0,
528 cachefiles_has_space_for_create);
529 if (ret < 0)
530 return false;
531
532 file = cachefiles_create_tmpfile(object);
533 if (IS_ERR(file))
534 return false;
535
536 set_bit(FSCACHE_COOKIE_NEEDS_UPDATE, &object->cookie->flags);
537 set_bit(CACHEFILES_OBJECT_USING_TMPFILE, &object->flags);
538 _debug("create -> %pD{ino=%lu}", file, file_inode(file)->i_ino);
539 object->file = file;
540 return true;
541 }
542
543 /*
544 * Open an existing file, checking its attributes and replacing it if it is
545 * stale.
546 */
cachefiles_open_file(struct cachefiles_object * object,struct dentry * dentry)547 static bool cachefiles_open_file(struct cachefiles_object *object,
548 struct dentry *dentry)
549 {
550 struct cachefiles_cache *cache = object->volume->cache;
551 struct file *file;
552 struct path path;
553 int ret;
554
555 _enter("%pd", dentry);
556
557 if (!cachefiles_mark_inode_in_use(object, d_inode(dentry))) {
558 pr_notice("cachefiles: Inode already in use: %pd (B=%lx)\n",
559 dentry, d_inode(dentry)->i_ino);
560 return false;
561 }
562
563 /* We need to open a file interface onto a data file now as we can't do
564 * it on demand because writeback called from do_exit() sees
565 * current->fs == NULL - which breaks d_path() called from ext4 open.
566 */
567 path.mnt = cache->mnt;
568 path.dentry = dentry;
569 file = kernel_file_open(&path, O_RDWR | O_LARGEFILE | O_DIRECT, cache->cache_cred);
570 if (IS_ERR(file)) {
571 trace_cachefiles_vfs_error(object, d_backing_inode(dentry),
572 PTR_ERR(file),
573 cachefiles_trace_open_error);
574 goto error;
575 }
576
577 if (unlikely(!file->f_op->read_iter) ||
578 unlikely(!file->f_op->write_iter)) {
579 pr_notice("Cache does not support read_iter and write_iter\n");
580 goto error_fput;
581 }
582 _debug("file -> %pd positive", dentry);
583
584 ret = cachefiles_ondemand_init_object(object);
585 if (ret < 0)
586 goto error_fput;
587
588 ret = cachefiles_check_auxdata(object, file);
589 if (ret < 0)
590 goto check_failed;
591
592 clear_bit(FSCACHE_COOKIE_NO_DATA_TO_READ, &object->cookie->flags);
593
594 object->file = file;
595
596 /* Always update the atime on an object we've just looked up (this is
597 * used to keep track of culling, and atimes are only updated by read,
598 * write and readdir but not lookup or open).
599 */
600 touch_atime(&file->f_path);
601 return true;
602
603 check_failed:
604 fscache_cookie_lookup_negative(object->cookie);
605 cachefiles_unmark_inode_in_use(object, file);
606 fput(file);
607 if (ret == -ESTALE)
608 return cachefiles_create_file(object);
609 return false;
610
611 error_fput:
612 fput(file);
613 error:
614 cachefiles_do_unmark_inode_in_use(object, d_inode(dentry));
615 return false;
616 }
617
618 /*
619 * walk from the parent object to the child object through the backing
620 * filesystem, creating directories as we go
621 */
cachefiles_look_up_object(struct cachefiles_object * object)622 bool cachefiles_look_up_object(struct cachefiles_object *object)
623 {
624 struct cachefiles_volume *volume = object->volume;
625 struct dentry *dentry, *fan = volume->fanout[(u8)object->cookie->key_hash];
626 int ret;
627
628 _enter("OBJ%x,%s,", object->debug_id, object->d_name);
629
630 /* Look up path "cache/vol/fanout/file". */
631 ret = cachefiles_inject_read_error();
632 if (ret == 0)
633 dentry = lookup_positive_unlocked(object->d_name, fan,
634 object->d_name_len);
635 else
636 dentry = ERR_PTR(ret);
637 trace_cachefiles_lookup(object, fan, dentry);
638 if (IS_ERR(dentry)) {
639 if (dentry == ERR_PTR(-ENOENT))
640 goto new_file;
641 if (dentry == ERR_PTR(-EIO))
642 cachefiles_io_error_obj(object, "Lookup failed");
643 return false;
644 }
645
646 if (!d_is_reg(dentry)) {
647 pr_err("%pd is not a file\n", dentry);
648 inode_lock_nested(d_inode(fan), I_MUTEX_PARENT);
649 ret = cachefiles_bury_object(volume->cache, object, fan, dentry,
650 FSCACHE_OBJECT_IS_WEIRD);
651 dput(dentry);
652 if (ret < 0)
653 return false;
654 goto new_file;
655 }
656
657 ret = cachefiles_open_file(object, dentry);
658 dput(dentry);
659 if (!ret)
660 return false;
661
662 _leave(" = t [%lu]", file_inode(object->file)->i_ino);
663 return true;
664
665 new_file:
666 fscache_cookie_lookup_negative(object->cookie);
667 return cachefiles_create_file(object);
668 }
669
670 /*
671 * Attempt to link a temporary file into its rightful place in the cache.
672 */
cachefiles_commit_tmpfile(struct cachefiles_cache * cache,struct cachefiles_object * object)673 bool cachefiles_commit_tmpfile(struct cachefiles_cache *cache,
674 struct cachefiles_object *object)
675 {
676 struct cachefiles_volume *volume = object->volume;
677 struct dentry *dentry, *fan = volume->fanout[(u8)object->cookie->key_hash];
678 bool success = false;
679 int ret;
680
681 _enter(",%pD", object->file);
682
683 inode_lock_nested(d_inode(fan), I_MUTEX_PARENT);
684 ret = cachefiles_inject_read_error();
685 if (ret == 0)
686 dentry = lookup_one_len(object->d_name, fan, object->d_name_len);
687 else
688 dentry = ERR_PTR(ret);
689 if (IS_ERR(dentry)) {
690 trace_cachefiles_vfs_error(object, d_inode(fan), PTR_ERR(dentry),
691 cachefiles_trace_lookup_error);
692 _debug("lookup fail %ld", PTR_ERR(dentry));
693 goto out_unlock;
694 }
695
696 if (!d_is_negative(dentry)) {
697 ret = cachefiles_unlink(volume->cache, object, fan, dentry,
698 FSCACHE_OBJECT_IS_STALE);
699 if (ret < 0)
700 goto out_dput;
701
702 dput(dentry);
703 ret = cachefiles_inject_read_error();
704 if (ret == 0)
705 dentry = lookup_one_len(object->d_name, fan, object->d_name_len);
706 else
707 dentry = ERR_PTR(ret);
708 if (IS_ERR(dentry)) {
709 trace_cachefiles_vfs_error(object, d_inode(fan), PTR_ERR(dentry),
710 cachefiles_trace_lookup_error);
711 _debug("lookup fail %ld", PTR_ERR(dentry));
712 goto out_unlock;
713 }
714 }
715
716 ret = cachefiles_inject_read_error();
717 if (ret == 0)
718 ret = vfs_link(object->file->f_path.dentry, &nop_mnt_idmap,
719 d_inode(fan), dentry, NULL);
720 if (ret < 0) {
721 trace_cachefiles_vfs_error(object, d_inode(fan), ret,
722 cachefiles_trace_link_error);
723 _debug("link fail %d", ret);
724 } else {
725 trace_cachefiles_link(object, file_inode(object->file));
726 spin_lock(&object->lock);
727 /* TODO: Do we want to switch the file pointer to the new dentry? */
728 clear_bit(CACHEFILES_OBJECT_USING_TMPFILE, &object->flags);
729 spin_unlock(&object->lock);
730 success = true;
731 }
732
733 out_dput:
734 dput(dentry);
735 out_unlock:
736 inode_unlock(d_inode(fan));
737 _leave(" = %u", success);
738 return success;
739 }
740
741 /*
742 * Look up an inode to be checked or culled. Return -EBUSY if the inode is
743 * marked in use.
744 */
cachefiles_lookup_for_cull(struct cachefiles_cache * cache,struct dentry * dir,char * filename)745 static struct dentry *cachefiles_lookup_for_cull(struct cachefiles_cache *cache,
746 struct dentry *dir,
747 char *filename)
748 {
749 struct dentry *victim;
750 int ret = -ENOENT;
751
752 inode_lock_nested(d_inode(dir), I_MUTEX_PARENT);
753
754 victim = lookup_one_len(filename, dir, strlen(filename));
755 if (IS_ERR(victim))
756 goto lookup_error;
757 if (d_is_negative(victim))
758 goto lookup_put;
759 if (d_inode(victim)->i_flags & S_KERNEL_FILE)
760 goto lookup_busy;
761 return victim;
762
763 lookup_busy:
764 ret = -EBUSY;
765 lookup_put:
766 inode_unlock(d_inode(dir));
767 dput(victim);
768 return ERR_PTR(ret);
769
770 lookup_error:
771 inode_unlock(d_inode(dir));
772 ret = PTR_ERR(victim);
773 if (ret == -ENOENT)
774 return ERR_PTR(-ESTALE); /* Probably got retired by the netfs */
775
776 if (ret == -EIO) {
777 cachefiles_io_error(cache, "Lookup failed");
778 } else if (ret != -ENOMEM) {
779 pr_err("Internal error: %d\n", ret);
780 ret = -EIO;
781 }
782
783 return ERR_PTR(ret);
784 }
785
786 /*
787 * Cull an object if it's not in use
788 * - called only by cache manager daemon
789 */
cachefiles_cull(struct cachefiles_cache * cache,struct dentry * dir,char * filename)790 int cachefiles_cull(struct cachefiles_cache *cache, struct dentry *dir,
791 char *filename)
792 {
793 struct dentry *victim;
794 struct inode *inode;
795 int ret;
796
797 _enter(",%pd/,%s", dir, filename);
798
799 victim = cachefiles_lookup_for_cull(cache, dir, filename);
800 if (IS_ERR(victim))
801 return PTR_ERR(victim);
802
803 /* check to see if someone is using this object */
804 inode = d_inode(victim);
805 inode_lock(inode);
806 if (inode->i_flags & S_KERNEL_FILE) {
807 ret = -EBUSY;
808 } else {
809 /* Stop the cache from picking it back up */
810 inode->i_flags |= S_KERNEL_FILE;
811 ret = 0;
812 }
813 inode_unlock(inode);
814 if (ret < 0)
815 goto error_unlock;
816
817 ret = cachefiles_bury_object(cache, NULL, dir, victim,
818 FSCACHE_OBJECT_WAS_CULLED);
819 if (ret < 0)
820 goto error;
821
822 fscache_count_culled();
823 dput(victim);
824 _leave(" = 0");
825 return 0;
826
827 error_unlock:
828 inode_unlock(d_inode(dir));
829 error:
830 dput(victim);
831 if (ret == -ENOENT)
832 return -ESTALE; /* Probably got retired by the netfs */
833
834 if (ret != -ENOMEM) {
835 pr_err("Internal error: %d\n", ret);
836 ret = -EIO;
837 }
838
839 _leave(" = %d", ret);
840 return ret;
841 }
842
843 /*
844 * Find out if an object is in use or not
845 * - called only by cache manager daemon
846 * - returns -EBUSY or 0 to indicate whether an object is in use or not
847 */
cachefiles_check_in_use(struct cachefiles_cache * cache,struct dentry * dir,char * filename)848 int cachefiles_check_in_use(struct cachefiles_cache *cache, struct dentry *dir,
849 char *filename)
850 {
851 struct dentry *victim;
852 int ret = 0;
853
854 victim = cachefiles_lookup_for_cull(cache, dir, filename);
855 if (IS_ERR(victim))
856 return PTR_ERR(victim);
857
858 inode_unlock(d_inode(dir));
859 dput(victim);
860 return ret;
861 }
862