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
97 retry:
98 ret = cachefiles_inject_read_error();
99 if (ret == 0)
100 subdir = start_creating(&nop_mnt_idmap, dir, &QSTR(dirname));
101 else
102 subdir = ERR_PTR(ret);
103 trace_cachefiles_lookup(NULL, dir, subdir);
104 if (IS_ERR(subdir)) {
105 trace_cachefiles_vfs_error(NULL, d_backing_inode(dir),
106 PTR_ERR(subdir),
107 cachefiles_trace_lookup_error);
108 if (PTR_ERR(subdir) == -ENOMEM)
109 goto nomem_d_alloc;
110 goto lookup_error;
111 }
112
113 _debug("subdir -> %pd %s",
114 subdir, d_backing_inode(subdir) ? "positive" : "negative");
115
116 /* we need to create the subdir if it doesn't exist yet */
117 if (d_is_negative(subdir)) {
118 ret = cachefiles_has_space(cache, 1, 0,
119 cachefiles_has_space_for_create);
120 if (ret < 0)
121 goto mkdir_error;
122
123 _debug("attempt mkdir");
124
125 path.mnt = cache->mnt;
126 path.dentry = dir;
127 ret = security_path_mkdir(&path, subdir, 0700);
128 if (ret < 0)
129 goto mkdir_error;
130 ret = cachefiles_inject_write_error();
131 if (ret == 0) {
132 subdir = vfs_mkdir(&nop_mnt_idmap, d_inode(dir), subdir, 0700, NULL);
133 if (IS_ERR(subdir))
134 ret = PTR_ERR(subdir);
135 } else {
136 end_creating(subdir);
137 subdir = ERR_PTR(ret);
138 }
139 if (IS_ERR(subdir)) {
140 trace_cachefiles_vfs_error(NULL, d_inode(dir), ret,
141 cachefiles_trace_mkdir_error);
142 goto mkdir_error;
143 }
144 trace_cachefiles_mkdir(dir, subdir);
145
146 if (unlikely(d_unhashed(subdir) || d_is_negative(subdir))) {
147 end_creating(subdir);
148 goto retry;
149 }
150 ASSERT(d_backing_inode(subdir));
151
152 _debug("mkdir -> %pd{ino=%llu}",
153 subdir, d_backing_inode(subdir)->i_ino);
154 if (_is_new)
155 *_is_new = true;
156 }
157
158 /* Tell rmdir() it's not allowed to delete the subdir */
159 inode_lock(d_inode(subdir));
160 end_creating_keep(subdir);
161
162 if (!__cachefiles_mark_inode_in_use(NULL, d_inode(subdir))) {
163 pr_notice("cachefiles: Inode already in use: %pd (B=%llx)\n",
164 subdir, d_inode(subdir)->i_ino);
165 goto mark_error;
166 }
167
168 inode_unlock(d_inode(subdir));
169
170 /* we need to make sure the subdir is a directory */
171 ASSERT(d_backing_inode(subdir));
172
173 if (!d_can_lookup(subdir)) {
174 pr_err("%s is not a directory\n", dirname);
175 ret = -EIO;
176 goto check_error;
177 }
178
179 ret = -EPERM;
180 if (!(d_backing_inode(subdir)->i_opflags & IOP_XATTR) ||
181 !d_backing_inode(subdir)->i_op->lookup ||
182 !d_backing_inode(subdir)->i_op->mkdir ||
183 !d_backing_inode(subdir)->i_op->rename ||
184 !d_backing_inode(subdir)->i_op->rmdir ||
185 !d_backing_inode(subdir)->i_op->unlink)
186 goto check_error;
187
188 _leave(" = [%llu]", d_backing_inode(subdir)->i_ino);
189 return subdir;
190
191 check_error:
192 cachefiles_put_directory(subdir);
193 _leave(" = %d [check]", ret);
194 return ERR_PTR(ret);
195
196 mark_error:
197 inode_unlock(d_inode(subdir));
198 dput(subdir);
199 return ERR_PTR(-EBUSY);
200
201 mkdir_error:
202 end_creating(subdir);
203 pr_err("mkdir %s failed with error %d\n", dirname, ret);
204 return ERR_PTR(ret);
205
206 lookup_error:
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 * On entry dir must be locked. It will be unlocked on exit.
267 * On entry there must be at least 2 refs on rep, one will be dropped on exit.
268 */
cachefiles_bury_object(struct cachefiles_cache * cache,struct cachefiles_object * object,struct dentry * dir,struct dentry * rep,enum fscache_why_object_killed why)269 int cachefiles_bury_object(struct cachefiles_cache *cache,
270 struct cachefiles_object *object,
271 struct dentry *dir,
272 struct dentry *rep,
273 enum fscache_why_object_killed why)
274 {
275 struct dentry *grave;
276 struct renamedata rd = {};
277 struct path path, path_to_graveyard;
278 char nbuffer[8 + 8 + 1];
279 int ret;
280
281 _enter(",'%pd','%pd'", dir, rep);
282
283 if (rep->d_parent != dir) {
284 end_removing(rep);
285 _leave(" = -ESTALE");
286 return -ESTALE;
287 }
288
289 /* non-directories can just be unlinked */
290 if (!d_is_dir(rep)) {
291 ret = cachefiles_unlink(cache, object, dir, rep, why);
292 end_removing(rep);
293
294 _leave(" = %d", ret);
295 return ret;
296 }
297
298 /* directories have to be moved to the graveyard */
299 _debug("move stale object to graveyard");
300 end_removing(rep);
301
302 try_again:
303 /* first step is to make up a grave dentry in the graveyard */
304 sprintf(nbuffer, "%08x%08x",
305 (uint32_t) ktime_get_real_seconds(),
306 (uint32_t) atomic_inc_return(&cache->gravecounter));
307
308 rd.mnt_idmap = &nop_mnt_idmap;
309 rd.old_parent = dir;
310 rd.new_parent = cache->graveyard;
311 rd.flags = 0;
312 ret = start_renaming_dentry(&rd, 0, rep, &QSTR(nbuffer));
313 if (ret) {
314 /* Some errors aren't fatal */
315 if (ret == -EXDEV)
316 /* double-lock failed */
317 return ret;
318 if (d_unhashed(rep) || rep->d_parent != dir || IS_DEADDIR(d_inode(rep))) {
319 /* the entry was probably culled when we dropped the parent dir
320 * lock */
321 _leave(" = 0 [culled?]");
322 return 0;
323 }
324 if (ret == -EINVAL || ret == -ENOTEMPTY) {
325 cachefiles_io_error(cache, "May not make directory loop");
326 return -EIO;
327 }
328 if (ret == -ENOMEM) {
329 _leave(" = -ENOMEM");
330 return -ENOMEM;
331 }
332
333 cachefiles_io_error(cache, "Lookup error %d", ret);
334 return -EIO;
335 }
336
337 if (d_mountpoint(rep)) {
338 end_renaming(&rd);
339 cachefiles_io_error(cache, "Mountpoint in cache");
340 return -EIO;
341 }
342
343 grave = rd.new_dentry;
344 if (d_is_positive(grave)) {
345 end_renaming(&rd);
346 grave = NULL;
347 cond_resched();
348 goto try_again;
349 }
350
351 if (d_mountpoint(grave)) {
352 end_renaming(&rd);
353 cachefiles_io_error(cache, "Mountpoint in graveyard");
354 return -EIO;
355 }
356
357 /* attempt the rename */
358 path.mnt = cache->mnt;
359 path.dentry = dir;
360 path_to_graveyard.mnt = cache->mnt;
361 path_to_graveyard.dentry = cache->graveyard;
362 ret = security_path_rename(&path, rep, &path_to_graveyard, grave, 0);
363 if (ret < 0) {
364 cachefiles_io_error(cache, "Rename security error %d", ret);
365 } else {
366 trace_cachefiles_rename(object, d_inode(rep)->i_ino, why);
367 ret = cachefiles_inject_read_error();
368 if (ret == 0)
369 ret = vfs_rename(&rd);
370 if (ret != 0)
371 trace_cachefiles_vfs_error(object, d_inode(dir), ret,
372 cachefiles_trace_rename_error);
373 if (ret != 0 && ret != -ENOMEM)
374 cachefiles_io_error(cache,
375 "Rename failed with error %d", ret);
376 }
377
378 __cachefiles_unmark_inode_in_use(object, d_inode(rep));
379 end_renaming(&rd);
380 _leave(" = 0");
381 return 0;
382 }
383
384 /*
385 * Delete a cache file.
386 */
cachefiles_delete_object(struct cachefiles_object * object,enum fscache_why_object_killed why)387 int cachefiles_delete_object(struct cachefiles_object *object,
388 enum fscache_why_object_killed why)
389 {
390 struct cachefiles_volume *volume = object->volume;
391 struct dentry *dentry = object->file->f_path.dentry;
392 struct dentry *fan = volume->fanout[(u8)object->cookie->key_hash];
393 int ret;
394
395 _enter(",OBJ%x{%pD}", object->debug_id, object->file);
396
397 dentry = start_removing_dentry(fan, dentry);
398 if (IS_ERR(dentry))
399 ret = PTR_ERR(dentry);
400 else
401 ret = cachefiles_unlink(volume->cache, object, fan, dentry, why);
402 end_removing(dentry);
403 return ret;
404 }
405
406 /*
407 * Create a temporary file and leave it unattached and un-xattr'd until the
408 * time comes to discard the object from memory.
409 */
cachefiles_create_tmpfile(struct cachefiles_object * object)410 struct file *cachefiles_create_tmpfile(struct cachefiles_object *object)
411 {
412 struct cachefiles_volume *volume = object->volume;
413 struct cachefiles_cache *cache = volume->cache;
414 const struct cred *saved_cred;
415 struct dentry *fan = volume->fanout[(u8)object->cookie->key_hash];
416 struct file *file;
417 const struct path parentpath = { .mnt = cache->mnt, .dentry = fan };
418 uint64_t ni_size;
419 long ret;
420
421
422 cachefiles_begin_secure(cache, &saved_cred);
423
424 ret = cachefiles_inject_write_error();
425 if (ret == 0) {
426 file = kernel_tmpfile_open(&nop_mnt_idmap, &parentpath,
427 S_IFREG | 0600,
428 O_RDWR | O_LARGEFILE | O_DIRECT,
429 cache->cache_cred);
430 ret = PTR_ERR_OR_ZERO(file);
431 }
432 if (ret) {
433 trace_cachefiles_vfs_error(object, d_inode(fan), ret,
434 cachefiles_trace_tmpfile_error);
435 if (ret == -EIO)
436 cachefiles_io_error_obj(object, "Failed to create tmpfile");
437 goto err;
438 }
439
440 trace_cachefiles_tmpfile(object, file_inode(file));
441
442 /* This is a newly created file with no other possible user */
443 if (!cachefiles_mark_inode_in_use(object, file_inode(file)))
444 WARN_ON(1);
445
446 ret = cachefiles_ondemand_init_object(object);
447 if (ret < 0)
448 goto err_unuse;
449
450 ni_size = object->cookie->object_size;
451 ni_size = round_up(ni_size, CACHEFILES_DIO_BLOCK_SIZE);
452
453 if (ni_size > 0) {
454 trace_cachefiles_trunc(object, file_inode(file), 0, ni_size,
455 cachefiles_trunc_expand_tmpfile);
456 ret = cachefiles_inject_write_error();
457 if (ret == 0)
458 ret = vfs_truncate(&file->f_path, ni_size);
459 if (ret < 0) {
460 trace_cachefiles_vfs_error(
461 object, file_inode(file), ret,
462 cachefiles_trace_trunc_error);
463 goto err_unuse;
464 }
465 }
466
467 ret = -EINVAL;
468 if (unlikely(!file->f_op->read_iter) ||
469 unlikely(!file->f_op->write_iter)) {
470 fput(file);
471 pr_notice("Cache does not support read_iter and write_iter\n");
472 goto err_unuse;
473 }
474 out:
475 cachefiles_end_secure(cache, saved_cred);
476 return file;
477
478 err_unuse:
479 cachefiles_do_unmark_inode_in_use(object, file_inode(file));
480 fput(file);
481 err:
482 file = ERR_PTR(ret);
483 goto out;
484 }
485
486 /*
487 * Create a new file.
488 */
cachefiles_create_file(struct cachefiles_object * object)489 static bool cachefiles_create_file(struct cachefiles_object *object)
490 {
491 struct file *file;
492 int ret;
493
494 ret = cachefiles_has_space(object->volume->cache, 1, 0,
495 cachefiles_has_space_for_create);
496 if (ret < 0)
497 return false;
498
499 file = cachefiles_create_tmpfile(object);
500 if (IS_ERR(file))
501 return false;
502
503 set_bit(FSCACHE_COOKIE_NEEDS_UPDATE, &object->cookie->flags);
504 set_bit(CACHEFILES_OBJECT_USING_TMPFILE, &object->flags);
505 _debug("create -> %pD{ino=%llu}", file, file_inode(file)->i_ino);
506 object->file = file;
507 return true;
508 }
509
510 /*
511 * Open an existing file, checking its attributes and replacing it if it is
512 * stale.
513 */
cachefiles_open_file(struct cachefiles_object * object,struct dentry * dentry)514 static bool cachefiles_open_file(struct cachefiles_object *object,
515 struct dentry *dentry)
516 {
517 struct cachefiles_cache *cache = object->volume->cache;
518 struct file *file;
519 struct path path;
520 int ret;
521
522 _enter("%pd", dentry);
523
524 if (!cachefiles_mark_inode_in_use(object, d_inode(dentry))) {
525 pr_notice("cachefiles: Inode already in use: %pd (B=%llx)\n",
526 dentry, d_inode(dentry)->i_ino);
527 return false;
528 }
529
530 /* We need to open a file interface onto a data file now as we can't do
531 * it on demand because writeback called from do_exit() sees
532 * current->fs == NULL - which breaks d_path() called from ext4 open.
533 */
534 path.mnt = cache->mnt;
535 path.dentry = dentry;
536 file = kernel_file_open(&path, O_RDWR | O_LARGEFILE | O_DIRECT, cache->cache_cred);
537 if (IS_ERR(file)) {
538 trace_cachefiles_vfs_error(object, d_backing_inode(dentry),
539 PTR_ERR(file),
540 cachefiles_trace_open_error);
541 goto error;
542 }
543
544 if (unlikely(!file->f_op->read_iter) ||
545 unlikely(!file->f_op->write_iter)) {
546 pr_notice("Cache does not support read_iter and write_iter\n");
547 goto error_fput;
548 }
549 _debug("file -> %pd positive", dentry);
550
551 ret = cachefiles_ondemand_init_object(object);
552 if (ret < 0)
553 goto error_fput;
554
555 ret = cachefiles_check_auxdata(object, file);
556 if (ret < 0)
557 goto check_failed;
558
559 clear_bit(FSCACHE_COOKIE_NO_DATA_TO_READ, &object->cookie->flags);
560
561 object->file = file;
562
563 /* Always update the atime on an object we've just looked up (this is
564 * used to keep track of culling, and atimes are only updated by read,
565 * write and readdir but not lookup or open).
566 */
567 touch_atime(&file->f_path);
568 return true;
569
570 check_failed:
571 fscache_cookie_lookup_negative(object->cookie);
572 cachefiles_unmark_inode_in_use(object, file);
573 fput(file);
574 if (ret == -ESTALE)
575 return cachefiles_create_file(object);
576 return false;
577
578 error_fput:
579 fput(file);
580 error:
581 cachefiles_do_unmark_inode_in_use(object, d_inode(dentry));
582 return false;
583 }
584
585 /*
586 * walk from the parent object to the child object through the backing
587 * filesystem, creating directories as we go
588 */
cachefiles_look_up_object(struct cachefiles_object * object)589 bool cachefiles_look_up_object(struct cachefiles_object *object)
590 {
591 struct cachefiles_volume *volume = object->volume;
592 struct dentry *dentry, *fan = volume->fanout[(u8)object->cookie->key_hash];
593 int ret;
594
595 _enter("OBJ%x,%s,", object->debug_id, object->d_name);
596
597 /* Look up path "cache/vol/fanout/file". */
598 ret = cachefiles_inject_read_error();
599 if (ret == 0)
600 dentry = lookup_one_positive_unlocked(&nop_mnt_idmap,
601 &QSTR(object->d_name), fan);
602 else
603 dentry = ERR_PTR(ret);
604 trace_cachefiles_lookup(object, fan, dentry);
605 if (IS_ERR(dentry)) {
606 if (dentry == ERR_PTR(-ENOENT))
607 goto new_file;
608 if (dentry == ERR_PTR(-EIO))
609 cachefiles_io_error_obj(object, "Lookup failed");
610 return false;
611 }
612
613 if (!d_is_reg(dentry)) {
614 pr_err("%pd is not a file\n", dentry);
615 struct dentry *de = start_removing_dentry(fan, dentry);
616 if (IS_ERR(de))
617 ret = PTR_ERR(de);
618 else
619 ret = cachefiles_bury_object(volume->cache, object,
620 fan, de,
621 FSCACHE_OBJECT_IS_WEIRD);
622 dput(dentry);
623 if (ret < 0)
624 return false;
625 goto new_file;
626 }
627
628 ret = cachefiles_open_file(object, dentry);
629 dput(dentry);
630 if (!ret)
631 return false;
632
633 _leave(" = t [%llu]", file_inode(object->file)->i_ino);
634 return true;
635
636 new_file:
637 fscache_cookie_lookup_negative(object->cookie);
638 return cachefiles_create_file(object);
639 }
640
641 /*
642 * Attempt to link a temporary file into its rightful place in the cache.
643 */
cachefiles_commit_tmpfile(struct cachefiles_cache * cache,struct cachefiles_object * object)644 bool cachefiles_commit_tmpfile(struct cachefiles_cache *cache,
645 struct cachefiles_object *object)
646 {
647 struct cachefiles_volume *volume = object->volume;
648 struct dentry *dentry, *fan = volume->fanout[(u8)object->cookie->key_hash];
649 bool success = false;
650 int ret;
651
652 _enter(",%pD", object->file);
653
654 ret = cachefiles_inject_read_error();
655 if (ret == 0)
656 dentry = start_creating(&nop_mnt_idmap, fan, &QSTR(object->d_name));
657 else
658 dentry = ERR_PTR(ret);
659 if (IS_ERR(dentry)) {
660 trace_cachefiles_vfs_error(object, d_inode(fan), PTR_ERR(dentry),
661 cachefiles_trace_lookup_error);
662 _debug("lookup fail %ld", PTR_ERR(dentry));
663 goto out;
664 }
665
666 /*
667 * This loop will only execute more than once if some other thread
668 * races to create the object we are trying to create.
669 */
670 while (!d_is_negative(dentry)) {
671 ret = cachefiles_unlink(volume->cache, object, fan, dentry,
672 FSCACHE_OBJECT_IS_STALE);
673 if (ret < 0)
674 goto out_end;
675
676 end_creating(dentry);
677
678 ret = cachefiles_inject_read_error();
679 if (ret == 0)
680 dentry = start_creating(&nop_mnt_idmap, fan,
681 &QSTR(object->d_name));
682 else
683 dentry = ERR_PTR(ret);
684 if (IS_ERR(dentry)) {
685 trace_cachefiles_vfs_error(object, d_inode(fan), PTR_ERR(dentry),
686 cachefiles_trace_lookup_error);
687 _debug("lookup fail %ld", PTR_ERR(dentry));
688 goto out;
689 }
690 }
691
692 ret = cachefiles_inject_read_error();
693 if (ret == 0)
694 ret = vfs_link(object->file->f_path.dentry, &nop_mnt_idmap,
695 d_inode(fan), dentry, NULL);
696 if (ret < 0) {
697 trace_cachefiles_vfs_error(object, d_inode(fan), ret,
698 cachefiles_trace_link_error);
699 _debug("link fail %d", ret);
700 } else {
701 trace_cachefiles_link(object, file_inode(object->file));
702 spin_lock(&object->lock);
703 /* TODO: Do we want to switch the file pointer to the new dentry? */
704 clear_bit(CACHEFILES_OBJECT_USING_TMPFILE, &object->flags);
705 spin_unlock(&object->lock);
706 success = true;
707 }
708
709 out_end:
710 end_creating(dentry);
711 out:
712 _leave(" = %u", success);
713 return success;
714 }
715
716 /*
717 * Look up an inode to be checked or culled. Return -EBUSY if the inode is
718 * marked in use.
719 */
cachefiles_lookup_for_cull(struct cachefiles_cache * cache,struct dentry * dir,char * filename)720 static struct dentry *cachefiles_lookup_for_cull(struct cachefiles_cache *cache,
721 struct dentry *dir,
722 char *filename)
723 {
724 struct dentry *victim;
725 int ret = -ENOENT;
726
727 victim = start_removing(&nop_mnt_idmap, dir, &QSTR(filename));
728
729 if (IS_ERR(victim))
730 goto lookup_error;
731 if (d_inode(victim)->i_flags & S_KERNEL_FILE)
732 goto lookup_busy;
733 return victim;
734
735 lookup_busy:
736 ret = -EBUSY;
737 end_removing(victim);
738 return ERR_PTR(ret);
739
740 lookup_error:
741 ret = PTR_ERR(victim);
742 if (ret == -ENOENT)
743 return ERR_PTR(-ESTALE); /* Probably got retired by the netfs */
744
745 if (ret == -EIO) {
746 cachefiles_io_error(cache, "Lookup failed");
747 } else if (ret != -ENOMEM) {
748 pr_err("Internal error: %d\n", ret);
749 ret = -EIO;
750 }
751
752 return ERR_PTR(ret);
753 }
754
755 /*
756 * Cull an object if it's not in use
757 * - called only by cache manager daemon
758 */
cachefiles_cull(struct cachefiles_cache * cache,struct dentry * dir,char * filename)759 int cachefiles_cull(struct cachefiles_cache *cache, struct dentry *dir,
760 char *filename)
761 {
762 struct dentry *victim;
763 struct inode *inode;
764 int ret;
765
766 _enter(",%pd/,%s", dir, filename);
767
768 victim = cachefiles_lookup_for_cull(cache, dir, filename);
769 if (IS_ERR(victim))
770 return PTR_ERR(victim);
771
772 /* check to see if someone is using this object */
773 inode = d_inode(victim);
774 inode_lock(inode);
775 if (inode->i_flags & S_KERNEL_FILE) {
776 ret = -EBUSY;
777 } else {
778 /* Stop the cache from picking it back up */
779 inode->i_flags |= S_KERNEL_FILE;
780 ret = 0;
781 }
782 inode_unlock(inode);
783 if (ret < 0)
784 goto error_unlock;
785
786 /*
787 * cachefiles_bury_object() expects 2 references to 'victim',
788 * and drops one.
789 */
790 dget(victim);
791 ret = cachefiles_bury_object(cache, NULL, dir, victim,
792 FSCACHE_OBJECT_WAS_CULLED);
793 dput(victim);
794 if (ret < 0)
795 goto error;
796
797 fscache_count_culled();
798 _leave(" = 0");
799 return 0;
800
801 error_unlock:
802 end_removing(victim);
803 error:
804 if (ret == -ENOENT)
805 return -ESTALE; /* Probably got retired by the netfs */
806
807 if (ret != -ENOMEM) {
808 pr_err("Internal error: %d\n", ret);
809 ret = -EIO;
810 }
811
812 _leave(" = %d", ret);
813 return ret;
814 }
815
816 /*
817 * Find out if an object is in use or not
818 * - called only by cache manager daemon
819 * - returns -EBUSY or 0 to indicate whether an object is in use or not
820 */
cachefiles_check_in_use(struct cachefiles_cache * cache,struct dentry * dir,char * filename)821 int cachefiles_check_in_use(struct cachefiles_cache *cache, struct dentry *dir,
822 char *filename)
823 {
824 struct dentry *victim;
825 int ret = 0;
826
827 victim = cachefiles_lookup_for_cull(cache, dir, filename);
828 if (IS_ERR(victim))
829 return PTR_ERR(victim);
830
831 inode_unlock(d_inode(dir));
832 dput(victim);
833 return ret;
834 }
835