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) ktime_get_real_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
));