1 /* CacheFiles path walking and related routines
3 * Copyright (C) 2007 Red Hat, Inc. All Rights Reserved.
4 * Written by David Howells (dhowells@redhat.com)
6 * This program is free software; you can redistribute it and/or
7 * modify it under the terms of the GNU General Public Licence
8 * as published by the Free Software Foundation; either version
9 * 2 of the Licence, or (at your option) any later version.
12 #include <linux/module.h>
13 #include <linux/sched.h>
14 #include <linux/file.h>
16 #include <linux/fsnotify.h>
17 #include <linux/quotaops.h>
18 #include <linux/xattr.h>
19 #include <linux/mount.h>
20 #include <linux/namei.h>
21 #include <linux/security.h>
22 #include <linux/slab.h>
23 #include <linux/xattr.h>
26 #define CACHEFILES_KEYBUF_SIZE 512
29 * dump debugging info about an object
32 void __cachefiles_printk_object(struct cachefiles_object *object,
35 struct fscache_cookie *cookie;
39 pr_err("%sobject: OBJ%x\n", prefix, object->fscache.debug_id);
40 pr_err("%sobjstate=%s fl=%lx wbusy=%x ev=%lx[%lx]\n",
41 prefix, object->fscache.state->name,
42 object->fscache.flags, work_busy(&object->fscache.work),
43 object->fscache.events, object->fscache.event_mask);
44 pr_err("%sops=%u inp=%u exc=%u\n",
45 prefix, object->fscache.n_ops, object->fscache.n_in_progress,
46 object->fscache.n_exclusive);
47 pr_err("%sparent=%p\n",
48 prefix, object->fscache.parent);
50 spin_lock(&object->fscache.lock);
51 cookie = object->fscache.cookie;
53 pr_err("%scookie=%p [pr=%p nd=%p fl=%lx]\n",
55 object->fscache.cookie,
56 object->fscache.cookie->parent,
57 object->fscache.cookie->netfs_data,
58 object->fscache.cookie->flags);
59 pr_err("%skey=[%u] '", prefix, cookie->key_len);
60 k = (cookie->key_len <= sizeof(cookie->inline_key)) ?
61 cookie->inline_key : cookie->key;
62 for (loop = 0; loop < cookie->key_len; loop++)
63 pr_cont("%02x", k[loop]);
66 pr_err("%scookie=NULL\n", prefix);
68 spin_unlock(&object->fscache.lock);
72 * dump debugging info about a pair of objects
74 static noinline void cachefiles_printk_object(struct cachefiles_object *object,
75 struct cachefiles_object *xobject)
78 __cachefiles_printk_object(object, "");
80 __cachefiles_printk_object(xobject, "x");
84 * mark the owner of a dentry, if there is one, to indicate that that dentry
85 * has been preemptively deleted
86 * - the caller must hold the i_mutex on the dentry's parent as required to
87 * call vfs_unlink(), vfs_rmdir() or vfs_rename()
89 static void cachefiles_mark_object_buried(struct cachefiles_cache *cache,
90 struct dentry *dentry,
91 enum fscache_why_object_killed why)
93 struct cachefiles_object *object;
96 _enter(",'%pd'", dentry);
98 write_lock(&cache->active_lock);
100 p = cache->active_nodes.rb_node;
102 object = rb_entry(p, struct cachefiles_object, active_node);
103 if (object->dentry > dentry)
105 else if (object->dentry < dentry)
111 write_unlock(&cache->active_lock);
112 trace_cachefiles_mark_buried(NULL, dentry, why);
113 _leave(" [no owner]");
116 /* found the dentry for */
118 kdebug("preemptive burial: OBJ%x [%s] %p",
119 object->fscache.debug_id,
120 object->fscache.state->name,
123 trace_cachefiles_mark_buried(object, dentry, why);
125 if (fscache_object_is_live(&object->fscache)) {
127 pr_err("Error: Can't preemptively bury live object\n");
128 cachefiles_printk_object(object, NULL);
130 if (why != FSCACHE_OBJECT_IS_STALE)
131 fscache_object_mark_killed(&object->fscache, why);
134 write_unlock(&cache->active_lock);
135 _leave(" [owner marked]");
139 * record the fact that an object is now active
141 static int cachefiles_mark_object_active(struct cachefiles_cache *cache,
142 struct cachefiles_object *object)
144 struct cachefiles_object *xobject;
145 struct rb_node **_p, *_parent = NULL;
146 struct dentry *dentry;
148 _enter(",%p", object);
151 write_lock(&cache->active_lock);
153 dentry = object->dentry;
154 trace_cachefiles_mark_active(object, dentry);
156 if (test_and_set_bit(CACHEFILES_OBJECT_ACTIVE, &object->flags)) {
157 pr_err("Error: Object already active\n");
158 cachefiles_printk_object(object, NULL);
162 _p = &cache->active_nodes.rb_node;
165 xobject = rb_entry(_parent,
166 struct cachefiles_object, active_node);
168 ASSERT(xobject != object);
170 if (xobject->dentry > dentry)
171 _p = &(*_p)->rb_left;
172 else if (xobject->dentry < dentry)
173 _p = &(*_p)->rb_right;
175 goto wait_for_old_object;
178 rb_link_node(&object->active_node, _parent, _p);
179 rb_insert_color(&object->active_node, &cache->active_nodes);
181 write_unlock(&cache->active_lock);
185 /* an old object from a previous incarnation is hogging the slot - we
186 * need to wait for it to be destroyed */
188 trace_cachefiles_wait_active(object, dentry, xobject);
189 clear_bit(CACHEFILES_OBJECT_ACTIVE, &object->flags);
191 if (fscache_object_is_live(&xobject->fscache)) {
193 pr_err("Error: Unexpected object collision\n");
194 cachefiles_printk_object(object, xobject);
196 atomic_inc(&xobject->usage);
197 write_unlock(&cache->active_lock);
199 if (test_bit(CACHEFILES_OBJECT_ACTIVE, &xobject->flags)) {
200 wait_queue_head_t *wq;
202 signed long timeout = 60 * HZ;
203 wait_queue_entry_t wait;
206 /* if the object we're waiting for is queued for processing,
207 * then just put ourselves on the queue behind it */
208 if (work_pending(&xobject->fscache.work)) {
209 _debug("queue OBJ%x behind OBJ%x immediately",
210 object->fscache.debug_id,
211 xobject->fscache.debug_id);
215 /* otherwise we sleep until either the object we're waiting for
216 * is done, or the fscache_object is congested */
217 wq = bit_waitqueue(&xobject->flags, CACHEFILES_OBJECT_ACTIVE);
221 prepare_to_wait(wq, &wait, TASK_UNINTERRUPTIBLE);
222 if (!test_bit(CACHEFILES_OBJECT_ACTIVE, &xobject->flags))
225 requeue = fscache_object_sleep_till_congested(&timeout);
226 } while (timeout > 0 && !requeue);
227 finish_wait(wq, &wait);
230 test_bit(CACHEFILES_OBJECT_ACTIVE, &xobject->flags)) {
231 _debug("queue OBJ%x behind OBJ%x after wait",
232 object->fscache.debug_id,
233 xobject->fscache.debug_id);
239 pr_err("Error: Overlong wait for old active object to go away\n");
240 cachefiles_printk_object(object, xobject);
245 ASSERT(!test_bit(CACHEFILES_OBJECT_ACTIVE, &xobject->flags));
247 cache->cache.ops->put_object(&xobject->fscache,
248 (enum fscache_obj_ref_trace)cachefiles_obj_put_wait_retry);
252 cache->cache.ops->put_object(&xobject->fscache,
253 (enum fscache_obj_ref_trace)cachefiles_obj_put_wait_timeo);
254 _leave(" = -ETIMEDOUT");
259 * Mark an object as being inactive.
261 void cachefiles_mark_object_inactive(struct cachefiles_cache *cache,
262 struct cachefiles_object *object,
265 struct dentry *dentry = object->dentry;
266 struct inode *inode = d_backing_inode(dentry);
268 trace_cachefiles_mark_inactive(object, dentry, inode);
270 write_lock(&cache->active_lock);
271 rb_erase(&object->active_node, &cache->active_nodes);
272 clear_bit(CACHEFILES_OBJECT_ACTIVE, &object->flags);
273 write_unlock(&cache->active_lock);
275 wake_up_bit(&object->flags, CACHEFILES_OBJECT_ACTIVE);
277 /* This object can now be culled, so we need to let the daemon know
278 * that there is something it can remove if it needs to.
280 atomic_long_add(i_blocks, &cache->b_released);
281 if (atomic_inc_return(&cache->f_released))
282 cachefiles_state_changed(cache);
286 * delete an object representation from the cache
287 * - file backed objects are unlinked
288 * - directory backed objects are stuffed into the graveyard for userspace to
290 * - unlocks the directory mutex
292 static int cachefiles_bury_object(struct cachefiles_cache *cache,
293 struct cachefiles_object *object,
297 enum fscache_why_object_killed why)
299 struct dentry *grave, *trap;
300 struct path path, path_to_graveyard;
301 char nbuffer[8 + 8 + 1];
304 _enter(",'%pd','%pd'", dir, rep);
306 _debug("remove %p from %p", rep, dir);
308 /* non-directories can just be unlinked */
309 if (!d_is_dir(rep)) {
310 _debug("unlink stale object");
312 path.mnt = cache->mnt;
314 ret = security_path_unlink(&path, rep);
316 cachefiles_io_error(cache, "Unlink security error");
318 trace_cachefiles_unlink(object, rep, why);
319 ret = vfs_unlink(d_inode(dir), rep, NULL);
322 cachefiles_mark_object_buried(cache, rep, why);
325 inode_unlock(d_inode(dir));
328 cachefiles_io_error(cache, "Unlink failed");
330 _leave(" = %d", ret);
334 /* directories have to be moved to the graveyard */
335 _debug("move stale object to graveyard");
336 inode_unlock(d_inode(dir));
339 /* first step is to make up a grave dentry in the graveyard */
340 sprintf(nbuffer, "%08x%08x",
341 (uint32_t) get_seconds(),
342 (uint32_t) atomic_inc_return(&cache->gravecounter));
344 /* do the multiway lock magic */
345 trap = lock_rename(cache->graveyard, dir);
347 /* do some checks before getting the grave dentry */
348 if (rep->d_parent != dir || IS_DEADDIR(d_inode(rep))) {
349 /* the entry was probably culled when we dropped the parent dir
351 unlock_rename(cache->graveyard, dir);
352 _leave(" = 0 [culled?]");
356 if (!d_can_lookup(cache->graveyard)) {
357 unlock_rename(cache->graveyard, dir);
358 cachefiles_io_error(cache, "Graveyard no longer a directory");
363 unlock_rename(cache->graveyard, dir);
364 cachefiles_io_error(cache, "May not make directory loop");
368 if (d_mountpoint(rep)) {
369 unlock_rename(cache->graveyard, dir);
370 cachefiles_io_error(cache, "Mountpoint in cache");
374 grave = lookup_one_len(nbuffer, cache->graveyard, strlen(nbuffer));
376 unlock_rename(cache->graveyard, dir);
378 if (PTR_ERR(grave) == -ENOMEM) {
379 _leave(" = -ENOMEM");
383 cachefiles_io_error(cache, "Lookup error %ld",
388 if (d_is_positive(grave)) {
389 unlock_rename(cache->graveyard, dir);
396 if (d_mountpoint(grave)) {
397 unlock_rename(cache->graveyard, dir);
399 cachefiles_io_error(cache, "Mountpoint in graveyard");
403 /* target should not be an ancestor of source */
405 unlock_rename(cache->graveyard, dir);
407 cachefiles_io_error(cache, "May not make directory loop");
411 /* attempt the rename */
412 path.mnt = cache->mnt;
414 path_to_graveyard.mnt = cache->mnt;
415 path_to_graveyard.dentry = cache->graveyard;
416 ret = security_path_rename(&path, rep, &path_to_graveyard, grave, 0);
418 cachefiles_io_error(cache, "Rename security error %d", ret);
420 trace_cachefiles_rename(object, rep, grave, why);
421 ret = vfs_rename(d_inode(dir), rep,
422 d_inode(cache->graveyard), grave, NULL, 0);
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));