1
2
3
4
5
6
7
8#include <linux/module.h>
9#include <linux/sched.h>
10#include <linux/file.h>
11#include <linux/fs.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>
19#include "internal.h"
20
21#define CACHEFILES_KEYBUF_SIZE 512
22
23
24
25
26static noinline
27void __cachefiles_printk_object(struct cachefiles_object *object,
28 const char *prefix)
29{
30 struct fscache_cookie *cookie;
31 const u8 *k;
32 unsigned loop;
33
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);
44
45 spin_lock(&object->fscache.lock);
46 cookie = object->fscache.cookie;
47 if (cookie) {
48 pr_err("%scookie=%p [pr=%p nd=%p fl=%lx]\n",
49 prefix,
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]);
59 pr_cont("'\n");
60 } else {
61 pr_err("%scookie=NULL\n", prefix);
62 }
63 spin_unlock(&object->fscache.lock);
64}
65
66
67
68
69static noinline void cachefiles_printk_object(struct cachefiles_object *object,
70 struct cachefiles_object *xobject)
71{
72 if (object)
73 __cachefiles_printk_object(object, "");
74 if (xobject)
75 __cachefiles_printk_object(xobject, "x");
76}
77
78
79
80
81
82
83
84static void cachefiles_mark_object_buried(struct cachefiles_cache *cache,
85 struct dentry *dentry,
86 enum fscache_why_object_killed why)
87{
88 struct cachefiles_object *object;
89 struct rb_node *p;
90
91 _enter(",'%pd'", dentry);
92
93 write_lock(&cache->active_lock);
94
95 p = cache->active_nodes.rb_node;
96 while (p) {
97 object = rb_entry(p, struct cachefiles_object, active_node);
98 if (object->dentry > dentry)
99 p = p->rb_left;
100 else if (object->dentry < dentry)
101 p = p->rb_right;
102 else
103 goto found_dentry;
104 }
105
106 write_unlock(&cache->active_lock);
107 trace_cachefiles_mark_buried(NULL, dentry, why);
108 _leave(" [no owner]");
109 return;
110
111
112found_dentry:
113 kdebug("preemptive burial: OBJ%x [%s] %p",
114 object->fscache.debug_id,
115 object->fscache.state->name,
116 dentry);
117
118 trace_cachefiles_mark_buried(object, dentry, why);
119
120 if (fscache_object_is_live(&object->fscache)) {
121 pr_err("\n");
122 pr_err("Error: Can't preemptively bury live object\n");
123 cachefiles_printk_object(object, NULL);
124 } else {
125 if (why != FSCACHE_OBJECT_IS_STALE)
126 fscache_object_mark_killed(&object->fscache, why);
127 }
128
129 write_unlock(&cache->active_lock);
130 _leave(" [owner marked]");
131}
132
133
134
135
136static int cachefiles_mark_object_active(struct cachefiles_cache *cache,
137 struct cachefiles_object *object)
138{
139 struct cachefiles_object *xobject;
140 struct rb_node **_p, *_parent = NULL;
141 struct dentry *dentry;
142
143 _enter(",%p", object);
144
145try_again:
146 write_lock(&cache->active_lock);
147
148 dentry = object->dentry;
149 trace_cachefiles_mark_active(object, dentry);
150
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);
154 BUG();
155 }
156
157 _p = &cache->active_nodes.rb_node;
158 while (*_p) {
159 _parent = *_p;
160 xobject = rb_entry(_parent,
161 struct cachefiles_object, active_node);
162
163 ASSERT(xobject != object);
164
165 if (xobject->dentry > dentry)
166 _p = &(*_p)->rb_left;
167 else if (xobject->dentry < dentry)
168 _p = &(*_p)->rb_right;
169 else
170 goto wait_for_old_object;
171 }
172
173 rb_link_node(&object->active_node, _parent, _p);
174 rb_insert_color(&object->active_node, &cache->active_nodes);
175
176 write_unlock(&cache->active_lock);
177 _leave(" = 0");
178 return 0;
179
180
181
182wait_for_old_object:
183 trace_cachefiles_wait_active(object, dentry, xobject);
184 clear_bit(CACHEFILES_OBJECT_ACTIVE, &object->flags);
185
186 if (fscache_object_is_live(&xobject->fscache)) {
187 pr_err("\n");
188 pr_err("Error: Unexpected object collision\n");
189 cachefiles_printk_object(object, xobject);
190 }
191 atomic_inc(&xobject->usage);
192 write_unlock(&cache->active_lock);
193
194 if (test_bit(CACHEFILES_OBJECT_ACTIVE, &xobject->flags)) {
195 wait_queue_head_t *wq;
196
197 signed long timeout = 60 * HZ;
198 wait_queue_entry_t wait;
199 bool requeue;
200
201
202
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);
207 goto requeue;
208 }
209
210
211
212 wq = bit_waitqueue(&xobject->flags, CACHEFILES_OBJECT_ACTIVE);
213 init_wait(&wait);
214 requeue = false;
215 do {
216 prepare_to_wait(wq, &wait, TASK_UNINTERRUPTIBLE);
217 if (!test_bit(CACHEFILES_OBJECT_ACTIVE, &xobject->flags))
218 break;
219
220 requeue = fscache_object_sleep_till_congested(&timeout);
221 } while (timeout > 0 && !requeue);
222 finish_wait(wq, &wait);
223
224 if (requeue &&
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);
229 goto requeue;
230 }
231
232 if (timeout <= 0) {
233 pr_err("\n");
234 pr_err("Error: Overlong wait for old active object to go away\n");
235 cachefiles_printk_object(object, xobject);
236 goto requeue;
237 }
238 }
239
240 ASSERT(!test_bit(CACHEFILES_OBJECT_ACTIVE, &xobject->flags));
241
242 cache->cache.ops->put_object(&xobject->fscache,
243 (enum fscache_obj_ref_trace)cachefiles_obj_put_wait_retry);
244 goto try_again;
245
246requeue:
247 cache->cache.ops->put_object(&xobject->fscache,
248 (enum fscache_obj_ref_trace)cachefiles_obj_put_wait_timeo);
249 _leave(" = -ETIMEDOUT");
250 return -ETIMEDOUT;
251}
252
253
254
255
256void cachefiles_mark_object_inactive(struct cachefiles_cache *cache,
257 struct cachefiles_object *object,
258 blkcnt_t i_blocks)
259{
260 struct dentry *dentry = object->dentry;
261 struct inode *inode = d_backing_inode(dentry);
262
263 trace_cachefiles_mark_inactive(object, dentry, inode);
264
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);
269
270 wake_up_bit(&object->flags, CACHEFILES_OBJECT_ACTIVE);
271
272
273
274
275 atomic_long_add(i_blocks, &cache->b_released);
276 if (atomic_inc_return(&cache->f_released))
277 cachefiles_state_changed(cache);
278}
279
280
281
282
283
284
285
286
287static int cachefiles_bury_object(struct cachefiles_cache *cache,
288 struct cachefiles_object *object,
289 struct dentry *dir,
290 struct dentry *rep,
291 bool preemptive,
292 enum fscache_why_object_killed why)
293{
294 struct dentry *grave, *trap;
295 struct path path, path_to_graveyard;
296 char nbuffer[8 + 8 + 1];
297 int ret;
298
299 _enter(",'%pd','%pd'", dir, rep);
300
301 _debug("remove %p from %p", rep, dir);
302
303
304 if (!d_is_dir(rep)) {
305 _debug("unlink stale object");
306
307 path.mnt = cache->mnt;
308 path.dentry = dir;
309 ret = security_path_unlink(&path, rep);
310 if (ret < 0) {
311 cachefiles_io_error(cache, "Unlink security error");
312 } else {
313 trace_cachefiles_unlink(object, rep, why);
314 ret = vfs_unlink(&init_user_ns, d_inode(dir), rep,
315 NULL);
316
317 if (preemptive)
318 cachefiles_mark_object_buried(cache, rep, why);
319 }
320
321 inode_unlock(d_inode(dir));
322
323 if (ret == -EIO)
324 cachefiles_io_error(cache, "Unlink failed");
325
326 _leave(" = %d", ret);
327 return ret;
328 }
329
330
331 _debug("move stale object to graveyard");
332 inode_unlock(d_inode(dir));
333
334try_again:
335
336 sprintf(nbuffer, "%08x%08x",
337 (uint32_t) ktime_get_real_seconds(),
338 (uint32_t) atomic_inc_return(&cache->gravecounter));
339
340
341 trap = lock_rename(cache->graveyard, dir);
342
343
344 if (rep->d_parent != dir || IS_DEADDIR(d_inode(rep))) {
345
346
347 unlock_rename(cache->graveyard, dir);
348 _leave(" = 0 [culled?]");
349 return 0;
350 }
351
352 if (!d_can_lookup(cache->graveyard)) {
353 unlock_rename(cache->graveyard, dir);
354 cachefiles_io_error(cache, "Graveyard no longer a directory");
355 return -EIO;
356 }
357
358 if (trap == rep) {
359 unlock_rename(cache->graveyard, dir);
360 cachefiles_io_error(cache, "May not make directory loop");
361 return -EIO;
362 }
363
364 if (d_mountpoint(rep)) {
365 unlock_rename(cache->graveyard, dir);
366 cachefiles_io_error(cache, "Mountpoint in cache");
367 return -EIO;
368 }
369
370 grave = lookup_one_len(nbuffer, cache->graveyard, strlen(nbuffer));
371 if (IS_ERR(grave)) {
372 unlock_rename(cache->graveyard, dir);
373
374 if (PTR_ERR(grave) == -ENOMEM) {
375 _leave(" = -ENOMEM");
376 return -ENOMEM;
377 }
378
379 cachefiles_io_error(cache, "Lookup error %ld",
380 PTR_ERR(grave));
381 return -EIO;
382 }
383
384 if (d_is_positive(grave)) {
385 unlock_rename(cache->graveyard, dir);
386 dput(grave);
387 grave = NULL;
388 cond_resched();
389 goto try_again;
390 }
391
392 if (d_mountpoint(grave)) {
393 unlock_rename(cache->graveyard, dir);
394 dput(grave);
395 cachefiles_io_error(cache, "Mountpoint in graveyard");
396 return -EIO;
397 }
398
399
400 if (trap == grave) {
401 unlock_rename(cache->graveyard, dir);
402 dput(grave);
403 cachefiles_io_error(cache, "May not make directory loop");
404 return -EIO;
405 }
406
407
408 path.mnt = cache->mnt;
409 path.dentry = dir;
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);
413 if (ret < 0) {
414 cachefiles_io_error(cache, "Rename security error %d", ret);
415 } else {
416 struct renamedata rd = {
417 .old_mnt_userns = &init_user_ns,
418 .old_dir = d_inode(dir),
419 .old_dentry = rep,
420 .new_mnt_userns = &init_user_ns,
421 .new_dir = d_inode(cache->graveyard),
422 .new_dentry = grave,
423 };
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);
429
430 if (preemptive)
431 cachefiles_mark_object_buried(cache, rep, why);
432 }
433
434 unlock_rename(cache->graveyard, dir);
435 dput(grave);
436 _leave(" = 0");
437 return 0;
438}
439
440
441
442
443int cachefiles_delete_object(struct cachefiles_cache *cache,
444 struct cachefiles_object *object)
445{
446 struct dentry *dir;
447 int ret;
448
449 _enter(",OBJ%x{%p}", object->fscache.debug_id, object->dentry);
450
451 ASSERT(object->dentry);
452 ASSERT(d_backing_inode(object->dentry));
453 ASSERT(object->dentry->d_parent);
454
455 dir = dget_parent(object->dentry);
456
457 inode_lock_nested(d_inode(dir), I_MUTEX_PARENT);
458
459 if (test_bit(FSCACHE_OBJECT_KILLED_BY_CACHE, &object->fscache.flags)) {
460
461
462 _debug("object preemptively buried");
463 inode_unlock(d_inode(dir));
464 ret = 0;
465 } else {
466
467
468 if (dir == object->dentry->d_parent) {
469 ret = cachefiles_bury_object(cache, object, dir,
470 object->dentry, false,
471 FSCACHE_OBJECT_WAS_RETIRED);
472 } else {
473
474
475
476 inode_unlock(d_inode(dir));
477 ret = 0;
478 }
479 }
480
481 dput(dir);
482 _leave(" = %d", ret);
483 return ret;
484}
485
486
487
488
489
490int cachefiles_walk_to_object(struct cachefiles_object *parent,
491 struct cachefiles_object *object,
492 const char *key,
493 struct cachefiles_xattr *auxdata)
494{
495 struct cachefiles_cache *cache;
496 struct dentry *dir, *next = NULL;
497 struct inode *inode;
498 struct path path;
499 unsigned long start;
500 const char *name;
501 int ret, nlen;
502
503 _enter("OBJ%x{%p},OBJ%x,%s,",
504 parent->fscache.debug_id, parent->dentry,
505 object->fscache.debug_id, key);
506
507 cache = container_of(parent->fscache.cache,
508 struct cachefiles_cache, cache);
509 path.mnt = cache->mnt;
510
511 ASSERT(parent->dentry);
512 ASSERT(d_backing_inode(parent->dentry));
513
514 if (!(d_is_dir(parent->dentry))) {
515
516 _leave("looking up in none directory");
517 return -ENOBUFS;
518 }
519
520 dir = dget(parent->dentry);
521
522advance:
523
524 name = key;
525 nlen = strlen(key);
526
527
528 key = key + nlen + 1;
529 if (!*key)
530 key = NULL;
531
532lookup_again:
533
534 _debug("lookup '%s'", name);
535
536 inode_lock_nested(d_inode(dir), I_MUTEX_PARENT);
537
538 start = jiffies;
539 next = lookup_one_len(name, dir, nlen);
540 cachefiles_hist(cachefiles_lookup_histogram, start);
541 if (IS_ERR(next)) {
542 trace_cachefiles_lookup(object, next, NULL);
543 goto lookup_error;
544 }
545
546 inode = d_backing_inode(next);
547 trace_cachefiles_lookup(object, next, inode);
548 _debug("next -> %p %s", next, inode ? "positive" : "negative");
549
550 if (!key)
551 object->new = !inode;
552
553
554
555
556 if (d_is_negative(next))
557 fscache_object_lookup_negative(&object->fscache);
558
559
560 if (key || object->type == FSCACHE_COOKIE_TYPE_INDEX) {
561
562 if (d_is_negative(next)) {
563 ret = cachefiles_has_space(cache, 1, 0);
564 if (ret < 0)
565 goto no_space_error;
566
567 path.dentry = dir;
568 ret = security_path_mkdir(&path, next, 0);
569 if (ret < 0)
570 goto create_error;
571 start = jiffies;
572 ret = vfs_mkdir(&init_user_ns, d_inode(dir), next, 0);
573 cachefiles_hist(cachefiles_mkdir_histogram, start);
574 if (!key)
575 trace_cachefiles_mkdir(object, next, ret);
576 if (ret < 0)
577 goto create_error;
578
579 if (unlikely(d_unhashed(next))) {
580 dput(next);
581 inode_unlock(d_inode(dir));
582 goto lookup_again;
583 }
584 ASSERT(d_backing_inode(next));
585
586 _debug("mkdir -> %p{%p{ino=%lu}}",
587 next, d_backing_inode(next), d_backing_inode(next)->i_ino);
588
589 } else if (!d_can_lookup(next)) {
590 pr_err("inode %lu is not a directory\n",
591 d_backing_inode(next)->i_ino);
592 ret = -ENOBUFS;
593 goto error;
594 }
595
596 } else {
597
598 if (d_is_negative(next)) {
599 ret = cachefiles_has_space(cache, 1, 0);
600 if (ret < 0)
601 goto no_space_error;
602
603 path.dentry = dir;
604 ret = security_path_mknod(&path, next, S_IFREG, 0);
605 if (ret < 0)
606 goto create_error;
607 start = jiffies;
608 ret = vfs_create(&init_user_ns, d_inode(dir), next,
609 S_IFREG, true);
610 cachefiles_hist(cachefiles_create_histogram, start);
611 trace_cachefiles_create(object, next, ret);
612 if (ret < 0)
613 goto create_error;
614
615 ASSERT(d_backing_inode(next));
616
617 _debug("create -> %p{%p{ino=%lu}}",
618 next, d_backing_inode(next), d_backing_inode(next)->i_ino);
619
620 } else if (!d_can_lookup(next) &&
621 !d_is_reg(next)
622 ) {
623 pr_err("inode %lu is not a file or directory\n",
624 d_backing_inode(next)->i_ino);
625 ret = -ENOBUFS;
626 goto error;
627 }
628 }
629
630
631 if (key) {
632 _debug("advance");
633 inode_unlock(d_inode(dir));
634 dput(dir);
635 dir = next;
636 next = NULL;
637 goto advance;
638 }
639
640
641 object->dentry = next;
642
643
644
645 if (!object->new) {
646 _debug("validate '%pd'", next);
647
648 ret = cachefiles_check_object_xattr(object, auxdata);
649 if (ret == -ESTALE) {
650
651
652 object->dentry = NULL;
653
654 ret = cachefiles_bury_object(cache, object, dir, next,
655 true,
656 FSCACHE_OBJECT_IS_STALE);
657 dput(next);
658 next = NULL;
659
660 if (ret < 0)
661 goto delete_error;
662
663 _debug("redo lookup");
664 fscache_object_retrying_stale(&object->fscache);
665 goto lookup_again;
666 }
667 }
668
669
670 ret = cachefiles_mark_object_active(cache, object);
671
672 inode_unlock(d_inode(dir));
673 dput(dir);
674 dir = NULL;
675
676 if (ret == -ETIMEDOUT)
677 goto mark_active_timed_out;
678
679 _debug("=== OBTAINED_OBJECT ===");
680
681 if (object->new) {
682
683 ret = cachefiles_set_object_xattr(object, auxdata);
684 if (ret < 0)
685 goto check_error;
686 } else {
687
688
689
690
691 path.dentry = next;
692 touch_atime(&path);
693 }
694
695
696 if (object->type != FSCACHE_COOKIE_TYPE_INDEX) {
697 if (d_is_reg(object->dentry)) {
698 const struct address_space_operations *aops;
699
700 ret = -EPERM;
701 aops = d_backing_inode(object->dentry)->i_mapping->a_ops;
702 if (!aops->bmap)
703 goto check_error;
704 if (object->dentry->d_sb->s_blocksize > PAGE_SIZE)
705 goto check_error;
706
707 object->backer = object->dentry;
708 } else {
709 BUG();
710 }
711 }
712
713 object->new = 0;
714 fscache_obtained_object(&object->fscache);
715
716 _leave(" = 0 [%lu]", d_backing_inode(object->dentry)->i_ino);
717 return 0;
718
719no_space_error:
720 fscache_object_mark_killed(&object->fscache, FSCACHE_OBJECT_NO_SPACE);
721create_error:
722 _debug("create error %d", ret);
723 if (ret == -EIO)
724 cachefiles_io_error(cache, "Create/mkdir failed");
725 goto error;
726
727mark_active_timed_out:
728 _debug("mark active timed out");
729 goto release_dentry;
730
731check_error:
732 _debug("check error %d", ret);
733 cachefiles_mark_object_inactive(
734 cache, object, d_backing_inode(object->dentry)->i_blocks);
735release_dentry:
736 dput(object->dentry);
737 object->dentry = NULL;
738 goto error_out;
739
740delete_error:
741 _debug("delete error %d", ret);
742 goto error_out2;
743
744lookup_error:
745 _debug("lookup error %ld", PTR_ERR(next));
746 ret = PTR_ERR(next);
747 if (ret == -EIO)
748 cachefiles_io_error(cache, "Lookup failed");
749 next = NULL;
750error:
751 inode_unlock(d_inode(dir));
752 dput(next);
753error_out2:
754 dput(dir);
755error_out:
756 _leave(" = error %d", -ret);
757 return ret;
758}
759
760
761
762
763struct dentry *cachefiles_get_directory(struct cachefiles_cache *cache,
764 struct dentry *dir,
765 const char *dirname)
766{
767 struct dentry *subdir;
768 unsigned long start;
769 struct path path;
770 int ret;
771
772 _enter(",,%s", dirname);
773
774
775 inode_lock(d_inode(dir));
776
777retry:
778 start = jiffies;
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)
783 goto nomem_d_alloc;
784 goto lookup_error;
785 }
786
787 _debug("subdir -> %p %s",
788 subdir, d_backing_inode(subdir) ? "positive" : "negative");
789
790
791 if (d_is_negative(subdir)) {
792 ret = cachefiles_has_space(cache, 1, 0);
793 if (ret < 0)
794 goto mkdir_error;
795
796 _debug("attempt mkdir");
797
798 path.mnt = cache->mnt;
799 path.dentry = dir;
800 ret = security_path_mkdir(&path, subdir, 0700);
801 if (ret < 0)
802 goto mkdir_error;
803 ret = vfs_mkdir(&init_user_ns, d_inode(dir), subdir, 0700);
804 if (ret < 0)
805 goto mkdir_error;
806
807 if (unlikely(d_unhashed(subdir))) {
808 dput(subdir);
809 goto retry;
810 }
811 ASSERT(d_backing_inode(subdir));
812
813 _debug("mkdir -> %p{%p{ino=%lu}}",
814 subdir,
815 d_backing_inode(subdir),
816 d_backing_inode(subdir)->i_ino);
817 }
818
819 inode_unlock(d_inode(dir));
820
821
822 ASSERT(d_backing_inode(subdir));
823
824 if (!d_can_lookup(subdir)) {
825 pr_err("%s is not a directory\n", dirname);
826 ret = -EIO;
827 goto check_error;
828 }
829
830 ret = -EPERM;
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)
838 goto check_error;
839
840 _leave(" = [%lu]", d_backing_inode(subdir)->i_ino);
841 return subdir;
842
843check_error:
844 dput(subdir);
845 _leave(" = %d [check]", ret);
846 return ERR_PTR(ret);
847
848mkdir_error:
849 inode_unlock(d_inode(dir));
850 dput(subdir);
851 pr_err("mkdir %s failed with error %d\n", dirname, ret);
852 return ERR_PTR(ret);
853
854lookup_error:
855 inode_unlock(d_inode(dir));
856 ret = PTR_ERR(subdir);
857 pr_err("Lookup %s failed with error %d\n", dirname, ret);
858 return ERR_PTR(ret);
859
860nomem_d_alloc:
861 inode_unlock(d_inode(dir));
862 _leave(" = -ENOMEM");
863 return ERR_PTR(-ENOMEM);
864}
865
866
867
868
869
870
871
872static struct dentry *cachefiles_check_active(struct cachefiles_cache *cache,
873 struct dentry *dir,
874 char *filename)
875{
876 struct cachefiles_object *object;
877 struct rb_node *_n;
878 struct dentry *victim;
879 unsigned long start;
880 int ret;
881
882
883
884
885
886 inode_lock_nested(d_inode(dir), I_MUTEX_PARENT);
887
888 start = jiffies;
889 victim = lookup_one_len(filename, dir, strlen(filename));
890 cachefiles_hist(cachefiles_lookup_histogram, start);
891 if (IS_ERR(victim))
892 goto lookup_error;
893
894
895
896
897
898
899
900 if (d_is_negative(victim)) {
901 inode_unlock(d_inode(dir));
902 dput(victim);
903 _leave(" = -ENOENT [absent]");
904 return ERR_PTR(-ENOENT);
905 }
906
907
908 read_lock(&cache->active_lock);
909
910 _n = cache->active_nodes.rb_node;
911
912 while (_n) {
913 object = rb_entry(_n, struct cachefiles_object, active_node);
914
915 if (object->dentry > victim)
916 _n = _n->rb_left;
917 else if (object->dentry < victim)
918 _n = _n->rb_right;
919 else
920 goto object_in_use;
921 }
922
923 read_unlock(&cache->active_lock);
924
925
926 return victim;
927
928object_in_use:
929 read_unlock(&cache->active_lock);
930 inode_unlock(d_inode(dir));
931 dput(victim);
932
933 return ERR_PTR(-EBUSY);
934
935lookup_error:
936 inode_unlock(d_inode(dir));
937 ret = PTR_ERR(victim);
938 if (ret == -ENOENT) {
939
940 _leave(" = -ESTALE [absent]");
941 return ERR_PTR(-ESTALE);
942 }
943
944 if (ret == -EIO) {
945 cachefiles_io_error(cache, "Lookup failed");
946 } else if (ret != -ENOMEM) {
947 pr_err("Internal error: %d\n", ret);
948 ret = -EIO;
949 }
950
951 _leave(" = %d", ret);
952 return ERR_PTR(ret);
953}
954
955
956
957
958
959int cachefiles_cull(struct cachefiles_cache *cache, struct dentry *dir,
960 char *filename)
961{
962 struct dentry *victim;
963 int ret;
964
965 _enter(",%pd/,%s", dir, filename);
966
967 victim = cachefiles_check_active(cache, dir, filename);
968 if (IS_ERR(victim))
969 return PTR_ERR(victim);
970
971 _debug("victim -> %p %s",
972 victim, d_backing_inode(victim) ? "positive" : "negative");
973
974
975
976
977 _debug("victim is cullable");
978
979 ret = cachefiles_remove_object_xattr(cache, victim);
980 if (ret < 0)
981 goto error_unlock;
982
983
984 _debug("bury");
985
986 ret = cachefiles_bury_object(cache, NULL, dir, victim, false,
987 FSCACHE_OBJECT_WAS_CULLED);
988 if (ret < 0)
989 goto error;
990
991 dput(victim);
992 _leave(" = 0");
993 return 0;
994
995error_unlock:
996 inode_unlock(d_inode(dir));
997error:
998 dput(victim);
999 if (ret == -ENOENT) {
1000
1001 _leave(" = -ESTALE [absent]");
1002 return -ESTALE;
1003 }
1004
1005 if (ret != -ENOMEM) {
1006 pr_err("Internal error: %d\n", ret);
1007 ret = -EIO;
1008 }
1009
1010 _leave(" = %d", ret);
1011 return ret;
1012}
1013
1014
1015
1016
1017
1018
1019int cachefiles_check_in_use(struct cachefiles_cache *cache, struct dentry *dir,
1020 char *filename)
1021{
1022 struct dentry *victim;
1023
1024
1025
1026
1027 victim = cachefiles_check_active(cache, dir, filename);
1028 if (IS_ERR(victim))
1029 return PTR_ERR(victim);
1030
1031 inode_unlock(d_inode(dir));
1032 dput(victim);
1033
1034 return 0;
1035}
1036