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(d_inode(dir), rep, NULL);
317 cachefiles_mark_object_buried(cache, rep, why);
320 inode_unlock(d_inode(dir));
323 cachefiles_io_error(cache, "Unlink failed");
325 _leave(" = %d", ret);
329 /* directories have to be moved to the graveyard */
330 _debug("move stale object to graveyard");
331 inode_unlock(d_inode(dir));
334 /* first step is to make up a grave dentry in the graveyard */
335 sprintf(nbuffer, "%08x%08x",
336 (uint32_t) ktime_get_real_seconds(),
337 (uint32_t) atomic_inc_return(&cache->gravecounter));
339 /* do the multiway lock magic */
340 trap = lock_rename(cache->graveyard, dir);
342 /* do some checks before getting the grave dentry */
343 if (rep->d_parent != dir || IS_DEADDIR(d_inode(rep))) {
344 /* the entry was probably culled when we dropped the parent dir
346 unlock_rename(cache->graveyard, dir);
347 _leave(" = 0 [culled?]");
351 if (!d_can_lookup(cache->graveyard)) {
352 unlock_rename(cache->graveyard, dir);
353 cachefiles_io_error(cache, "Graveyard no longer a directory");
358 unlock_rename(cache->graveyard, dir);
359 cachefiles_io_error(cache, "May not make directory loop");
363 if (d_mountpoint(rep)) {
364 unlock_rename(cache->graveyard, dir);
365 cachefiles_io_error(cache, "Mountpoint in cache");
369 grave = lookup_one_len(nbuffer, cache->graveyard, strlen(nbuffer));
371 unlock_rename(cache->graveyard, dir);
373 if (PTR_ERR(grave) == -ENOMEM) {
374 _leave(" = -ENOMEM");
378 cachefiles_io_error(cache, "Lookup error %ld",
383 if (d_is_positive(grave)) {
384 unlock_rename(cache->graveyard, dir);
391 if (d_mountpoint(grave)) {
392 unlock_rename(cache->graveyard, dir);
394 cachefiles_io_error(cache, "Mountpoint in graveyard");
398 /* target should not be an ancestor of source */
400 unlock_rename(cache->graveyard, dir);
402 cachefiles_io_error(cache, "May not make directory loop");
406 /* attempt the rename */
407 path.mnt = cache->mnt;
409 path_to_graveyard.mnt = cache->mnt;
410 path_to_graveyard.dentry = cache->graveyard;
411 ret = security_path_rename(&path, rep, &path_to_graveyard, grave, 0);
413 cachefiles_io_error(cache, "Rename security error %d", ret);
415 struct renamedata rd = {
416 .old_dir = d_inode(dir),
418 .new_dir = d_inode(cache->graveyard),
421 trace_cachefiles_rename(object, rep, grave, why);
422 ret = vfs_rename(&rd);
423 if (ret != 0 && ret != -ENOMEM)
424 cachefiles_io_error(cache,
425 "Rename failed with error %d", ret);
428 cachefiles_mark_object_buried(cache, rep, why);
431 unlock_rename(cache->graveyard, dir);
438 * delete an object representation from the cache
440 int cachefiles_delete_object(struct cachefiles_cache *cache,
441 struct cachefiles_object *object)
446 _enter(",OBJ%x{%p}", object->fscache.debug_id, object->dentry);
448 ASSERT(object->dentry);
449 ASSERT(d_backing_inode(object->dentry));
450 ASSERT(object->dentry->d_parent);
452 dir = dget_parent(object->dentry);
454 inode_lock_nested(d_inode(dir), I_MUTEX_PARENT);
456 if (test_bit(FSCACHE_OBJECT_KILLED_BY_CACHE, &object->fscache.flags)) {
457 /* object allocation for the same key preemptively deleted this
458 * object's file so that it could create its own file */
459 _debug("object preemptively buried");
460 inode_unlock(d_inode(dir));
463 /* we need to check that our parent is _still_ our parent - it
464 * may have been renamed */
465 if (dir == object->dentry->d_parent) {
466 ret = cachefiles_bury_object(cache, object, dir,
467 object->dentry, false,
468 FSCACHE_OBJECT_WAS_RETIRED);
470 /* it got moved, presumably by cachefilesd culling it,
471 * so it's no longer in the key path and we can ignore
473 inode_unlock(d_inode(dir));
479 _leave(" = %d", ret);
484 * walk from the parent object to the child object through the backing
485 * filesystem, creating directories as we go
487 int cachefiles_walk_to_object(struct cachefiles_object *parent,
488 struct cachefiles_object *object,
490 struct cachefiles_xattr *auxdata)
492 struct cachefiles_cache *cache;
493 struct dentry *dir, *next = NULL;
500 _enter("OBJ%x{%p},OBJ%x,%s,",
501 parent->fscache.debug_id, parent->dentry,
502 object->fscache.debug_id, key);
504 cache = container_of(parent->fscache.cache,
505 struct cachefiles_cache, cache);
506 path.mnt = cache->mnt;
508 ASSERT(parent->dentry);
509 ASSERT(d_backing_inode(parent->dentry));
511 if (!(d_is_dir(parent->dentry))) {
512 // TODO: convert file to dir
513 _leave("looking up in none directory");
517 dir = dget(parent->dentry);
520 /* attempt to transit the first directory component */
524 /* key ends in a double NUL */
525 key = key + nlen + 1;
530 /* search the current directory for the element name */
531 _debug("lookup '%s'", name);
533 inode_lock_nested(d_inode(dir), I_MUTEX_PARENT);
536 next = lookup_one_len(name, dir, nlen);
537 cachefiles_hist(cachefiles_lookup_histogram, start);
539 trace_cachefiles_lookup(object, next, NULL);
543 inode = d_backing_inode(next);
544 trace_cachefiles_lookup(object, next, inode);
545 _debug("next -> %p %s", next, inode ? "positive" : "negative");
548 object->new = !inode;
550 /* if this element of the path doesn't exist, then the lookup phase
551 * failed, and we can release any readers in the certain knowledge that
552 * there's nothing for them to actually read */
553 if (d_is_negative(next))
554 fscache_object_lookup_negative(&object->fscache);
556 /* we need to create the object if it's negative */
557 if (key || object->type == FSCACHE_COOKIE_TYPE_INDEX) {
558 /* index objects and intervening tree levels must be subdirs */
559 if (d_is_negative(next)) {
560 ret = cachefiles_has_space(cache, 1, 0);
565 ret = security_path_mkdir(&path, next, 0);
569 ret = vfs_mkdir(d_inode(dir), next, 0);
570 cachefiles_hist(cachefiles_mkdir_histogram, start);
572 trace_cachefiles_mkdir(object, next, ret);
576 if (unlikely(d_unhashed(next))) {
578 inode_unlock(d_inode(dir));
581 ASSERT(d_backing_inode(next));
583 _debug("mkdir -> %p{%p{ino=%lu}}",
584 next, d_backing_inode(next), d_backing_inode(next)->i_ino);
586 } else if (!d_can_lookup(next)) {
587 pr_err("inode %lu is not a directory\n",
588 d_backing_inode(next)->i_ino);
594 /* non-index objects start out life as files */
595 if (d_is_negative(next)) {
596 ret = cachefiles_has_space(cache, 1, 0);
601 ret = security_path_mknod(&path, next, S_IFREG, 0);
605 ret = vfs_create(d_inode(dir), next, S_IFREG, true);
606 cachefiles_hist(cachefiles_create_histogram, start);
607 trace_cachefiles_create(object, next, ret);
611 ASSERT(d_backing_inode(next));
613 _debug("create -> %p{%p{ino=%lu}}",
614 next, d_backing_inode(next), d_backing_inode(next)->i_ino);
616 } else if (!d_can_lookup(next) &&
619 pr_err("inode %lu is not a file or directory\n",
620 d_backing_inode(next)->i_ino);
626 /* process the next component */
629 inode_unlock(d_inode(dir));
636 /* we've found the object we were looking for */
637 object->dentry = next;
639 /* if we've found that the terminal object exists, then we need to
640 * check its attributes and delete it if it's out of date */
642 _debug("validate '%pd'", next);
644 ret = cachefiles_check_object_xattr(object, auxdata);
645 if (ret == -ESTALE) {
646 /* delete the object (the deleter drops the directory
648 object->dentry = NULL;
650 ret = cachefiles_bury_object(cache, object, dir, next,
652 FSCACHE_OBJECT_IS_STALE);
659 _debug("redo lookup");
660 fscache_object_retrying_stale(&object->fscache);
665 /* note that we're now using this object */
666 ret = cachefiles_mark_object_active(cache, object);
668 inode_unlock(d_inode(dir));
672 if (ret == -ETIMEDOUT)
673 goto mark_active_timed_out;
675 _debug("=== OBTAINED_OBJECT ===");
678 /* attach data to a newly constructed terminal object */
679 ret = cachefiles_set_object_xattr(object, auxdata);
683 /* always update the atime on an object we've just looked up
684 * (this is used to keep track of culling, and atimes are only
685 * updated by read, write and readdir but not lookup or
691 /* open a file interface onto a data file */
692 if (object->type != FSCACHE_COOKIE_TYPE_INDEX) {
693 if (d_is_reg(object->dentry)) {
694 const struct address_space_operations *aops;
697 aops = d_backing_inode(object->dentry)->i_mapping->a_ops;
700 if (object->dentry->d_sb->s_blocksize > PAGE_SIZE)
703 object->backer = object->dentry;
705 BUG(); // TODO: open file in data-class subdir
710 fscache_obtained_object(&object->fscache);
712 _leave(" = 0 [%lu]", d_backing_inode(object->dentry)->i_ino);
716 fscache_object_mark_killed(&object->fscache, FSCACHE_OBJECT_NO_SPACE);
718 _debug("create error %d", ret);
720 cachefiles_io_error(cache, "Create/mkdir failed");
723 mark_active_timed_out:
724 _debug("mark active timed out");
728 _debug("check error %d", ret);
729 cachefiles_mark_object_inactive(
730 cache, object, d_backing_inode(object->dentry)->i_blocks);
732 dput(object->dentry);
733 object->dentry = NULL;
737 _debug("delete error %d", ret);
741 _debug("lookup error %ld", PTR_ERR(next));
744 cachefiles_io_error(cache, "Lookup failed");
747 inode_unlock(d_inode(dir));
752 _leave(" = error %d", -ret);
759 struct dentry *cachefiles_get_directory(struct cachefiles_cache *cache,
763 struct dentry *subdir;
768 _enter(",,%s", dirname);
770 /* search the current directory for the element name */
771 inode_lock(d_inode(dir));
775 subdir = lookup_one_len(dirname, dir, strlen(dirname));
776 cachefiles_hist(cachefiles_lookup_histogram, start);
777 if (IS_ERR(subdir)) {
778 if (PTR_ERR(subdir) == -ENOMEM)
783 _debug("subdir -> %p %s",
784 subdir, d_backing_inode(subdir) ? "positive" : "negative");
786 /* we need to create the subdir if it doesn't exist yet */
787 if (d_is_negative(subdir)) {
788 ret = cachefiles_has_space(cache, 1, 0);
792 _debug("attempt mkdir");
794 path.mnt = cache->mnt;
796 ret = security_path_mkdir(&path, subdir, 0700);
799 ret = vfs_mkdir(d_inode(dir), subdir, 0700);
803 if (unlikely(d_unhashed(subdir))) {
807 ASSERT(d_backing_inode(subdir));
809 _debug("mkdir -> %p{%p{ino=%lu}}",
811 d_backing_inode(subdir),
812 d_backing_inode(subdir)->i_ino);
815 inode_unlock(d_inode(dir));
817 /* we need to make sure the subdir is a directory */
818 ASSERT(d_backing_inode(subdir));
820 if (!d_can_lookup(subdir)) {
821 pr_err("%s is not a directory\n", dirname);
827 if (!(d_backing_inode(subdir)->i_opflags & IOP_XATTR) ||
828 !d_backing_inode(subdir)->i_op->lookup ||
829 !d_backing_inode(subdir)->i_op->mkdir ||
830 !d_backing_inode(subdir)->i_op->create ||
831 !d_backing_inode(subdir)->i_op->rename ||
832 !d_backing_inode(subdir)->i_op->rmdir ||
833 !d_backing_inode(subdir)->i_op->unlink)
836 _leave(" = [%lu]", d_backing_inode(subdir)->i_ino);
841 _leave(" = %d [check]", ret);
845 inode_unlock(d_inode(dir));
847 pr_err("mkdir %s failed with error %d\n", dirname, ret);
851 inode_unlock(d_inode(dir));
852 ret = PTR_ERR(subdir);
853 pr_err("Lookup %s failed with error %d\n", dirname, ret);
857 inode_unlock(d_inode(dir));
858 _leave(" = -ENOMEM");
859 return ERR_PTR(-ENOMEM);
863 * find out if an object is in use or not
864 * - if finds object and it's not in use:
865 * - returns a pointer to the object and a reference on it
866 * - returns with the directory locked
868 static struct dentry *cachefiles_check_active(struct cachefiles_cache *cache,
872 struct cachefiles_object *object;
874 struct dentry *victim;
881 /* look up the victim */
882 inode_lock_nested(d_inode(dir), I_MUTEX_PARENT);
885 victim = lookup_one_len(filename, dir, strlen(filename));
886 cachefiles_hist(cachefiles_lookup_histogram, start);
890 //_debug("victim -> %p %s",
891 // victim, d_backing_inode(victim) ? "positive" : "negative");
893 /* if the object is no longer there then we probably retired the object
894 * at the netfs's request whilst the cull was in progress
896 if (d_is_negative(victim)) {
897 inode_unlock(d_inode(dir));
899 _leave(" = -ENOENT [absent]");
900 return ERR_PTR(-ENOENT);
903 /* check to see if we're using this object */
904 read_lock(&cache->active_lock);
906 _n = cache->active_nodes.rb_node;
909 object = rb_entry(_n, struct cachefiles_object, active_node);
911 if (object->dentry > victim)
913 else if (object->dentry < victim)
919 read_unlock(&cache->active_lock);
921 //_leave(" = %p", victim);
925 read_unlock(&cache->active_lock);
926 inode_unlock(d_inode(dir));
928 //_leave(" = -EBUSY [in use]");
929 return ERR_PTR(-EBUSY);
932 inode_unlock(d_inode(dir));
933 ret = PTR_ERR(victim);
934 if (ret == -ENOENT) {
935 /* file or dir now absent - probably retired by netfs */
936 _leave(" = -ESTALE [absent]");
937 return ERR_PTR(-ESTALE);
941 cachefiles_io_error(cache, "Lookup failed");
942 } else if (ret != -ENOMEM) {
943 pr_err("Internal error: %d\n", ret);
947 _leave(" = %d", ret);
952 * cull an object if it's not in use
953 * - called only by cache manager daemon
955 int cachefiles_cull(struct cachefiles_cache *cache, struct dentry *dir,
958 struct dentry *victim;
961 _enter(",%pd/,%s", dir, filename);
963 victim = cachefiles_check_active(cache, dir, filename);
965 return PTR_ERR(victim);
967 _debug("victim -> %p %s",
968 victim, d_backing_inode(victim) ? "positive" : "negative");
970 /* okay... the victim is not being used so we can cull it
971 * - start by marking it as stale
973 _debug("victim is cullable");
975 ret = cachefiles_remove_object_xattr(cache, victim);
979 /* actually remove the victim (drops the dir mutex) */
982 ret = cachefiles_bury_object(cache, NULL, dir, victim, false,
983 FSCACHE_OBJECT_WAS_CULLED);
992 inode_unlock(d_inode(dir));
995 if (ret == -ENOENT) {
996 /* file or dir now absent - probably retired by netfs */
997 _leave(" = -ESTALE [absent]");
1001 if (ret != -ENOMEM) {
1002 pr_err("Internal error: %d\n", ret);
1006 _leave(" = %d", ret);
1011 * find out if an object is in use or not
1012 * - called only by cache manager daemon
1013 * - returns -EBUSY or 0 to indicate whether an object is in use or not
1015 int cachefiles_check_in_use(struct cachefiles_cache *cache, struct dentry *dir,
1018 struct dentry *victim;
1020 //_enter(",%pd/,%s",
1023 victim = cachefiles_check_active(cache, dir, filename);
1025 return PTR_ERR(victim);
1027 inode_unlock(d_inode(dir));