1 // SPDX-License-Identifier: GPL-2.0-or-later
2 /* CacheFiles path walking and related routines
4 * Copyright (C) 2007 Red Hat, Inc. All Rights Reserved.
5 * Written by David Howells (dhowells@redhat.com)
8 #include <linux/module.h>
9 #include <linux/sched.h>
10 #include <linux/file.h>
12 #include <linux/fsnotify.h>
13 #include <linux/quotaops.h>
14 #include <linux/xattr.h>
15 #include <linux/mount.h>
16 #include <linux/namei.h>
17 #include <linux/security.h>
18 #include <linux/slab.h>
21 #define CACHEFILES_KEYBUF_SIZE 512
24 * dump debugging info about an object
27 void __cachefiles_printk_object(struct cachefiles_object *object,
30 struct fscache_cookie *cookie;
34 pr_err("%sobject: OBJ%x\n", prefix, object->fscache.debug_id);
35 pr_err("%sobjstate=%s fl=%lx wbusy=%x ev=%lx[%lx]\n",
36 prefix, object->fscache.state->name,
37 object->fscache.flags, work_busy(&object->fscache.work),
38 object->fscache.events, object->fscache.event_mask);
39 pr_err("%sops=%u inp=%u exc=%u\n",
40 prefix, object->fscache.n_ops, object->fscache.n_in_progress,
41 object->fscache.n_exclusive);
42 pr_err("%sparent=%p\n",
43 prefix, object->fscache.parent);
45 spin_lock(&object->fscache.lock);
46 cookie = object->fscache.cookie;
48 pr_err("%scookie=%p [pr=%p nd=%p fl=%lx]\n",
50 object->fscache.cookie,
51 object->fscache.cookie->parent,
52 object->fscache.cookie->netfs_data,
53 object->fscache.cookie->flags);
54 pr_err("%skey=[%u] '", prefix, cookie->key_len);
55 k = (cookie->key_len <= sizeof(cookie->inline_key)) ?
56 cookie->inline_key : cookie->key;
57 for (loop = 0; loop < cookie->key_len; loop++)
58 pr_cont("%02x", k[loop]);
61 pr_err("%scookie=NULL\n", prefix);
63 spin_unlock(&object->fscache.lock);
67 * dump debugging info about a pair of objects
69 static noinline void cachefiles_printk_object(struct cachefiles_object *object,
70 struct cachefiles_object *xobject)
73 __cachefiles_printk_object(object, "");
75 __cachefiles_printk_object(xobject, "x");
79 * mark the owner of a dentry, if there is one, to indicate that that dentry
80 * has been preemptively deleted
81 * - the caller must hold the i_mutex on the dentry's parent as required to
82 * call vfs_unlink(), vfs_rmdir() or vfs_rename()
84 static void cachefiles_mark_object_buried(struct cachefiles_cache *cache,
85 struct dentry *dentry,
86 enum fscache_why_object_killed why)
88 struct cachefiles_object *object;
91 _enter(",'%pd'", dentry);
93 write_lock(&cache->active_lock);
95 p = cache->active_nodes.rb_node;
97 object = rb_entry(p, struct cachefiles_object, active_node);
98 if (object->dentry > dentry)
100 else if (object->dentry < dentry)
106 write_unlock(&cache->active_lock);
107 trace_cachefiles_mark_buried(NULL, dentry, why);
108 _leave(" [no owner]");
111 /* found the dentry for */
113 kdebug("preemptive burial: OBJ%x [%s] %p",
114 object->fscache.debug_id,
115 object->fscache.state->name,
118 trace_cachefiles_mark_buried(object, dentry, why);
120 if (fscache_object_is_live(&object->fscache)) {
122 pr_err("Error: Can't preemptively bury live object\n");
123 cachefiles_printk_object(object, NULL);
125 if (why != FSCACHE_OBJECT_IS_STALE)
126 fscache_object_mark_killed(&object->fscache, why);
129 write_unlock(&cache->active_lock);
130 _leave(" [owner marked]");
134 * record the fact that an object is now active
136 static int cachefiles_mark_object_active(struct cachefiles_cache *cache,
137 struct cachefiles_object *object)
139 struct cachefiles_object *xobject;
140 struct rb_node **_p, *_parent = NULL;
141 struct dentry *dentry;
143 _enter(",%p", object);
146 write_lock(&cache->active_lock);
148 dentry = object->dentry;
149 trace_cachefiles_mark_active(object, dentry);
151 if (test_and_set_bit(CACHEFILES_OBJECT_ACTIVE, &object->flags)) {
152 pr_err("Error: Object already active\n");
153 cachefiles_printk_object(object, NULL);
157 _p = &cache->active_nodes.rb_node;
160 xobject = rb_entry(_parent,
161 struct cachefiles_object, active_node);
163 ASSERT(xobject != object);
165 if (xobject->dentry > dentry)
166 _p = &(*_p)->rb_left;
167 else if (xobject->dentry < dentry)
168 _p = &(*_p)->rb_right;
170 goto wait_for_old_object;
173 rb_link_node(&object->active_node, _parent, _p);
174 rb_insert_color(&object->active_node, &cache->active_nodes);
176 write_unlock(&cache->active_lock);
180 /* an old object from a previous incarnation is hogging the slot - we
181 * need to wait for it to be destroyed */
183 trace_cachefiles_wait_active(object, dentry, xobject);
184 clear_bit(CACHEFILES_OBJECT_ACTIVE, &object->flags);
186 if (fscache_object_is_live(&xobject->fscache)) {
188 pr_err("Error: Unexpected object collision\n");
189 cachefiles_printk_object(object, xobject);
191 atomic_inc(&xobject->usage);
192 write_unlock(&cache->active_lock);
194 if (test_bit(CACHEFILES_OBJECT_ACTIVE, &xobject->flags)) {
195 wait_queue_head_t *wq;
197 signed long timeout = 60 * HZ;
198 wait_queue_entry_t wait;
201 /* if the object we're waiting for is queued for processing,
202 * then just put ourselves on the queue behind it */
203 if (work_pending(&xobject->fscache.work)) {
204 _debug("queue OBJ%x behind OBJ%x immediately",
205 object->fscache.debug_id,
206 xobject->fscache.debug_id);
210 /* otherwise we sleep until either the object we're waiting for
211 * is done, or the fscache_object is congested */
212 wq = bit_waitqueue(&xobject->flags, CACHEFILES_OBJECT_ACTIVE);
216 prepare_to_wait(wq, &wait, TASK_UNINTERRUPTIBLE);
217 if (!test_bit(CACHEFILES_OBJECT_ACTIVE, &xobject->flags))
220 requeue = fscache_object_sleep_till_congested(&timeout);
221 } while (timeout > 0 && !requeue);
222 finish_wait(wq, &wait);
225 test_bit(CACHEFILES_OBJECT_ACTIVE, &xobject->flags)) {
226 _debug("queue OBJ%x behind OBJ%x after wait",
227 object->fscache.debug_id,
228 xobject->fscache.debug_id);
234 pr_err("Error: Overlong wait for old active object to go away\n");
235 cachefiles_printk_object(object, xobject);
240 ASSERT(!test_bit(CACHEFILES_OBJECT_ACTIVE, &xobject->flags));
242 cache->cache.ops->put_object(&xobject->fscache,
243 (enum fscache_obj_ref_trace)cachefiles_obj_put_wait_retry);
247 cache->cache.ops->put_object(&xobject->fscache,
248 (enum fscache_obj_ref_trace)cachefiles_obj_put_wait_timeo);
249 _leave(" = -ETIMEDOUT");
254 * Mark an object as being inactive.
256 void cachefiles_mark_object_inactive(struct cachefiles_cache *cache,
257 struct cachefiles_object *object,
260 struct dentry *dentry = object->dentry;
261 struct inode *inode = d_backing_inode(dentry);
263 trace_cachefiles_mark_inactive(object, dentry, inode);
265 write_lock(&cache->active_lock);
266 rb_erase(&object->active_node, &cache->active_nodes);
267 clear_bit(CACHEFILES_OBJECT_ACTIVE, &object->flags);
268 write_unlock(&cache->active_lock);
270 wake_up_bit(&object->flags, CACHEFILES_OBJECT_ACTIVE);
272 /* This object can now be culled, so we need to let the daemon know
273 * that there is something it can remove if it needs to.
275 atomic_long_add(i_blocks, &cache->b_released);
276 if (atomic_inc_return(&cache->f_released))
277 cachefiles_state_changed(cache);
281 * delete an object representation from the cache
282 * - file backed objects are unlinked
283 * - directory backed objects are stuffed into the graveyard for userspace to
285 * - unlocks the directory mutex
287 static int cachefiles_bury_object(struct cachefiles_cache *cache,
288 struct cachefiles_object *object,
292 enum fscache_why_object_killed why)
294 struct dentry *grave, *trap;
295 struct path path, path_to_graveyard;
296 char nbuffer[8 + 8 + 1];
299 _enter(",'%pd','%pd'", dir, rep);
301 _debug("remove %p from %p", rep, dir);
303 /* non-directories can just be unlinked */
304 if (!d_is_dir(rep)) {
305 _debug("unlink stale object");
307 path.mnt = cache->mnt;
309 ret = security_path_unlink(&path, rep);
311 cachefiles_io_error(cache, "Unlink security error");
313 trace_cachefiles_unlink(object, rep, why);
314 ret = vfs_unlink(&init_user_ns, d_inode(dir), rep,
318 cachefiles_mark_object_buried(cache, rep, why);
321 inode_unlock(d_inode(dir));
324 cachefiles_io_error(cache, "Unlink failed");
326 _leave(" = %d", ret);
330 /* directories have to be moved to the graveyard */
331 _debug("move stale object to graveyard");
332 inode_unlock(d_inode(dir));
335 /* first step is to make up a grave dentry in the graveyard */
336 sprintf(nbuffer, "%08x%08x",
337 (uint32_t) ktime_get_real_seconds(),
338 (uint32_t) atomic_inc_return(&cache->gravecounter));
340 /* do the multiway lock magic */
341 trap = lock_rename(cache->graveyard, dir);
343 /* do some checks before getting the grave dentry */
344 if (rep->d_parent != dir || IS_DEADDIR(d_inode(rep))) {
345 /* the entry was probably culled when we dropped the parent dir
347 unlock_rename(cache->graveyard, dir);
348 _leave(" = 0 [culled?]");
352 if (!d_can_lookup(cache->graveyard)) {
353 unlock_rename(cache->graveyard, dir);
354 cachefiles_io_error(cache, "Graveyard no longer a directory");
359 unlock_rename(cache->graveyard, dir);
360 cachefiles_io_error(cache, "May not make directory loop");
364 if (d_mountpoint(rep)) {
365 unlock_rename(cache->graveyard, dir);
366 cachefiles_io_error(cache, "Mountpoint in cache");
370 grave = lookup_one_len(nbuffer, cache->graveyard, strlen(nbuffer));
372 unlock_rename(cache->graveyard, dir);
374 if (PTR_ERR(grave) == -ENOMEM) {
375 _leave(" = -ENOMEM");
379 cachefiles_io_error(cache, "Lookup error %ld",
384 if (d_is_positive(grave)) {
385 unlock_rename(cache->graveyard, dir);
392 if (d_mountpoint(grave)) {
393 unlock_rename(cache->graveyard, dir);
395 cachefiles_io_error(cache, "Mountpoint in graveyard");
399 /* target should not be an ancestor of source */
401 unlock_rename(cache->graveyard, dir);
403 cachefiles_io_error(cache, "May not make directory loop");
407 /* attempt the rename */
408 path.mnt = cache->mnt;
410 path_to_graveyard.mnt = cache->mnt;
411 path_to_graveyard.dentry = cache->graveyard;
412 ret = security_path_rename(&path, rep, &path_to_graveyard, grave, 0);
414 cachefiles_io_error(cache, "Rename security error %d", ret);
416 struct renamedata rd = {
417 .old_mnt_userns = &init_user_ns,
418 .old_dir = d_inode(dir),
420 .new_mnt_userns = &init_user_ns,
421 .new_dir = d_inode(cache->graveyard),
424 trace_cachefiles_rename(object, rep, grave, why);
425 ret = vfs_rename(&rd);
426 if (ret != 0 && ret != -ENOMEM)
427 cachefiles_io_error(cache,
428 "Rename failed with error %d", ret);
431 cachefiles_mark_object_buried(cache, rep, why);
434 unlock_rename(cache->graveyard, dir);
441 * delete an object representation from the cache
443 int cachefiles_delete_object(struct cachefiles_cache *cache,
444 struct cachefiles_object *object)
449 _enter(",OBJ%x{%p}", object->fscache.debug_id, object->dentry);
451 ASSERT(object->dentry);
452 ASSERT(d_backing_inode(object->dentry));
453 ASSERT(object->dentry->d_parent);
455 dir = dget_parent(object->dentry);
457 inode_lock_nested(d_inode(dir), I_MUTEX_PARENT);
459 if (test_bit(FSCACHE_OBJECT_KILLED_BY_CACHE, &object->fscache.flags)) {
460 /* object allocation for the same key preemptively deleted this
461 * object's file so that it could create its own file */
462 _debug("object preemptively buried");
463 inode_unlock(d_inode(dir));
466 /* we need to check that our parent is _still_ our parent - it
467 * may have been renamed */
468 if (dir == object->dentry->d_parent) {
469 ret = cachefiles_bury_object(cache, object, dir,
470 object->dentry, false,
471 FSCACHE_OBJECT_WAS_RETIRED);
473 /* it got moved, presumably by cachefilesd culling it,
474 * so it's no longer in the key path and we can ignore
476 inode_unlock(d_inode(dir));
482 _leave(" = %d", ret);
487 * walk from the parent object to the child object through the backing
488 * filesystem, creating directories as we go
490 int cachefiles_walk_to_object(struct cachefiles_object *parent,
491 struct cachefiles_object *object,
493 struct cachefiles_xattr *auxdata)
495 struct cachefiles_cache *cache;
496 struct dentry *dir, *next = NULL;
503 _enter("OBJ%x{%p},OBJ%x,%s,",
504 parent->fscache.debug_id, parent->dentry,
505 object->fscache.debug_id, key);
507 cache = container_of(parent->fscache.cache,
508 struct cachefiles_cache, cache);
509 path.mnt = cache->mnt;
511 ASSERT(parent->dentry);
512 ASSERT(d_backing_inode(parent->dentry));
514 if (!(d_is_dir(parent->dentry))) {
515 // TODO: convert file to dir
516 _leave("looking up in none directory");
520 dir = dget(parent->dentry);
523 /* attempt to transit the first directory component */
527 /* key ends in a double NUL */
528 key = key + nlen + 1;
533 /* search the current directory for the element name */
534 _debug("lookup '%s'", name);
536 inode_lock_nested(d_inode(dir), I_MUTEX_PARENT);
539 next = lookup_one_len(name, dir, nlen);
540 cachefiles_hist(cachefiles_lookup_histogram, start);
542 trace_cachefiles_lookup(object, next, NULL);
546 inode = d_backing_inode(next);
547 trace_cachefiles_lookup(object, next, inode);
548 _debug("next -> %p %s", next, inode ? "positive" : "negative");
551 object->new = !inode;
553 /* if this element of the path doesn't exist, then the lookup phase
554 * failed, and we can release any readers in the certain knowledge that
555 * there's nothing for them to actually read */
556 if (d_is_negative(next))
557 fscache_object_lookup_negative(&object->fscache);
559 /* we need to create the object if it's negative */
560 if (key || object->type == FSCACHE_COOKIE_TYPE_INDEX) {
561 /* index objects and intervening tree levels must be subdirs */
562 if (d_is_negative(next)) {
563 ret = cachefiles_has_space(cache, 1, 0);
568 ret = security_path_mkdir(&path, next, 0);
572 ret = vfs_mkdir(&init_user_ns, d_inode(dir), next, 0);
573 cachefiles_hist(cachefiles_mkdir_histogram, start);
575 trace_cachefiles_mkdir(object, next, ret);
579 if (unlikely(d_unhashed(next))) {
581 inode_unlock(d_inode(dir));
584 ASSERT(d_backing_inode(next));
586 _debug("mkdir -> %p{%p{ino=%lu}}",
587 next, d_backing_inode(next), d_backing_inode(next)->i_ino);
589 } else if (!d_can_lookup(next)) {
590 pr_err("inode %lu is not a directory\n",
591 d_backing_inode(next)->i_ino);
597 /* non-index objects start out life as files */
598 if (d_is_negative(next)) {
599 ret = cachefiles_has_space(cache, 1, 0);
604 ret = security_path_mknod(&path, next, S_IFREG, 0);
608 ret = vfs_create(&init_user_ns, d_inode(dir), next,
610 cachefiles_hist(cachefiles_create_histogram, start);
611 trace_cachefiles_create(object, next, ret);
615 ASSERT(d_backing_inode(next));
617 _debug("create -> %p{%p{ino=%lu}}",
618 next, d_backing_inode(next), d_backing_inode(next)->i_ino);
620 } else if (!d_can_lookup(next) &&
623 pr_err("inode %lu is not a file or directory\n",
624 d_backing_inode(next)->i_ino);
630 /* process the next component */
633 inode_unlock(d_inode(dir));
640 /* we've found the object we were looking for */
641 object->dentry = next;
643 /* if we've found that the terminal object exists, then we need to
644 * check its attributes and delete it if it's out of date */
646 _debug("validate '%pd'", next);
648 ret = cachefiles_check_object_xattr(object, auxdata);
649 if (ret == -ESTALE) {
650 /* delete the object (the deleter drops the directory
652 object->dentry = NULL;
654 ret = cachefiles_bury_object(cache, object, dir, next,
656 FSCACHE_OBJECT_IS_STALE);
663 _debug("redo lookup");
664 fscache_object_retrying_stale(&object->fscache);
669 /* note that we're now using this object */
670 ret = cachefiles_mark_object_active(cache, object);
672 inode_unlock(d_inode(dir));
676 if (ret == -ETIMEDOUT)
677 goto mark_active_timed_out;
679 _debug("=== OBTAINED_OBJECT ===");
682 /* attach data to a newly constructed terminal object */
683 ret = cachefiles_set_object_xattr(object, auxdata);
687 /* always update the atime on an object we've just looked up
688 * (this is used to keep track of culling, and atimes are only
689 * updated by read, write and readdir but not lookup or
695 /* open a file interface onto a data file */
696 if (object->type != FSCACHE_COOKIE_TYPE_INDEX) {
697 if (d_is_reg(object->dentry)) {
698 const struct address_space_operations *aops;
701 aops = d_backing_inode(object->dentry)->i_mapping->a_ops;
704 if (object->dentry->d_sb->s_blocksize > PAGE_SIZE)
707 object->backer = object->dentry;
709 BUG(); // TODO: open file in data-class subdir
714 fscache_obtained_object(&object->fscache);
716 _leave(" = 0 [%lu]", d_backing_inode(object->dentry)->i_ino);
720 fscache_object_mark_killed(&object->fscache, FSCACHE_OBJECT_NO_SPACE);
722 _debug("create error %d", ret);
724 cachefiles_io_error(cache, "Create/mkdir failed");
727 mark_active_timed_out:
728 _debug("mark active timed out");
732 _debug("check error %d", ret);
733 cachefiles_mark_object_inactive(
734 cache, object, d_backing_inode(object->dentry)->i_blocks);
736 dput(object->dentry);
737 object->dentry = NULL;
741 _debug("delete error %d", ret);
745 _debug("lookup error %ld", PTR_ERR(next));
748 cachefiles_io_error(cache, "Lookup failed");
751 inode_unlock(d_inode(dir));
756 _leave(" = error %d", -ret);
763 struct dentry *cachefiles_get_directory(struct cachefiles_cache *cache,
767 struct dentry *subdir;
772 _enter(",,%s", dirname);
774 /* search the current directory for the element name */
775 inode_lock(d_inode(dir));
779 subdir = lookup_one_len(dirname, dir, strlen(dirname));
780 cachefiles_hist(cachefiles_lookup_histogram, start);
781 if (IS_ERR(subdir)) {
782 if (PTR_ERR(subdir) == -ENOMEM)
787 _debug("subdir -> %p %s",
788 subdir, d_backing_inode(subdir) ? "positive" : "negative");
790 /* we need to create the subdir if it doesn't exist yet */
791 if (d_is_negative(subdir)) {
792 ret = cachefiles_has_space(cache, 1, 0);
796 _debug("attempt mkdir");
798 path.mnt = cache->mnt;
800 ret = security_path_mkdir(&path, subdir, 0700);
803 ret = vfs_mkdir(&init_user_ns, d_inode(dir), subdir, 0700);
807 if (unlikely(d_unhashed(subdir))) {
811 ASSERT(d_backing_inode(subdir));
813 _debug("mkdir -> %p{%p{ino=%lu}}",
815 d_backing_inode(subdir),
816 d_backing_inode(subdir)->i_ino);
819 inode_unlock(d_inode(dir));
821 /* we need to make sure the subdir is a directory */
822 ASSERT(d_backing_inode(subdir));
824 if (!d_can_lookup(subdir)) {
825 pr_err("%s is not a directory\n", dirname);
831 if (!(d_backing_inode(subdir)->i_opflags & IOP_XATTR) ||
832 !d_backing_inode(subdir)->i_op->lookup ||
833 !d_backing_inode(subdir)->i_op->mkdir ||
834 !d_backing_inode(subdir)->i_op->create ||
835 !d_backing_inode(subdir)->i_op->rename ||
836 !d_backing_inode(subdir)->i_op->rmdir ||
837 !d_backing_inode(subdir)->i_op->unlink)
840 _leave(" = [%lu]", d_backing_inode(subdir)->i_ino);
845 _leave(" = %d [check]", ret);
849 inode_unlock(d_inode(dir));
851 pr_err("mkdir %s failed with error %d\n", dirname, ret);
855 inode_unlock(d_inode(dir));
856 ret = PTR_ERR(subdir);
857 pr_err("Lookup %s failed with error %d\n", dirname, ret);
861 inode_unlock(d_inode(dir));
862 _leave(" = -ENOMEM");
863 return ERR_PTR(-ENOMEM);
867 * find out if an object is in use or not
868 * - if finds object and it's not in use:
869 * - returns a pointer to the object and a reference on it
870 * - returns with the directory locked
872 static struct dentry *cachefiles_check_active(struct cachefiles_cache *cache,
876 struct cachefiles_object *object;
878 struct dentry *victim;
885 /* look up the victim */
886 inode_lock_nested(d_inode(dir), I_MUTEX_PARENT);
889 victim = lookup_one_len(filename, dir, strlen(filename));
890 cachefiles_hist(cachefiles_lookup_histogram, start);
894 //_debug("victim -> %p %s",
895 // victim, d_backing_inode(victim) ? "positive" : "negative");
897 /* if the object is no longer there then we probably retired the object
898 * at the netfs's request whilst the cull was in progress
900 if (d_is_negative(victim)) {
901 inode_unlock(d_inode(dir));
903 _leave(" = -ENOENT [absent]");
904 return ERR_PTR(-ENOENT);
907 /* check to see if we're using this object */
908 read_lock(&cache->active_lock);
910 _n = cache->active_nodes.rb_node;
913 object = rb_entry(_n, struct cachefiles_object, active_node);
915 if (object->dentry > victim)
917 else if (object->dentry < victim)
923 read_unlock(&cache->active_lock);
925 //_leave(" = %p", victim);
929 read_unlock(&cache->active_lock);
930 inode_unlock(d_inode(dir));
932 //_leave(" = -EBUSY [in use]");
933 return ERR_PTR(-EBUSY);
936 inode_unlock(d_inode(dir));
937 ret = PTR_ERR(victim);
938 if (ret == -ENOENT) {
939 /* file or dir now absent - probably retired by netfs */
940 _leave(" = -ESTALE [absent]");
941 return ERR_PTR(-ESTALE);
945 cachefiles_io_error(cache, "Lookup failed");
946 } else if (ret != -ENOMEM) {
947 pr_err("Internal error: %d\n", ret);
951 _leave(" = %d", ret);
956 * cull an object if it's not in use
957 * - called only by cache manager daemon
959 int cachefiles_cull(struct cachefiles_cache *cache, struct dentry *dir,
962 struct dentry *victim;
965 _enter(",%pd/,%s", dir, filename);
967 victim = cachefiles_check_active(cache, dir, filename);
969 return PTR_ERR(victim);
971 _debug("victim -> %p %s",
972 victim, d_backing_inode(victim) ? "positive" : "negative");
974 /* okay... the victim is not being used so we can cull it
975 * - start by marking it as stale
977 _debug("victim is cullable");
979 ret = cachefiles_remove_object_xattr(cache, victim);
983 /* actually remove the victim (drops the dir mutex) */
986 ret = cachefiles_bury_object(cache, NULL, dir, victim, false,
987 FSCACHE_OBJECT_WAS_CULLED);
996 inode_unlock(d_inode(dir));
999 if (ret == -ENOENT) {
1000 /* file or dir now absent - probably retired by netfs */
1001 _leave(" = -ESTALE [absent]");
1005 if (ret != -ENOMEM) {
1006 pr_err("Internal error: %d\n", ret);
1010 _leave(" = %d", ret);
1015 * find out if an object is in use or not
1016 * - called only by cache manager daemon
1017 * - returns -EBUSY or 0 to indicate whether an object is in use or not
1019 int cachefiles_check_in_use(struct cachefiles_cache *cache, struct dentry *dir,
1022 struct dentry *victim;
1024 //_enter(",%pd/,%s",
1027 victim = cachefiles_check_active(cache, dir, filename);
1029 return PTR_ERR(victim);
1031 inode_unlock(d_inode(dir));