projects/linux·blob master · refs

818 lines · 20.4 KiB

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