1
2
3
4
5
6
7
8#include <linux/mount.h>
9#include <linux/slab.h>
10#include <linux/file.h>
11#include <linux/swap.h>
12#include "internal.h"
13
14
15
16
17
18
19
20static int cachefiles_read_waiter(wait_queue_entry_t *wait, unsigned mode,
21 int sync, void *_key)
22{
23 struct cachefiles_one_read *monitor =
24 container_of(wait, struct cachefiles_one_read, monitor);
25 struct cachefiles_object *object;
26 struct fscache_retrieval *op = monitor->op;
27 struct wait_bit_key *key = _key;
28 struct page *page = wait->private;
29
30 ASSERT(key);
31
32 _enter("{%lu},%u,%d,{%p,%u}",
33 monitor->netfs_page->index, mode, sync,
34 key->flags, key->bit_nr);
35
36 if (key->flags != &page->flags ||
37 key->bit_nr != PG_locked)
38 return 0;
39
40 _debug("--- monitor %p %lx ---", page, page->flags);
41
42 if (!PageUptodate(page) && !PageError(page)) {
43
44 _debug("page probably truncated");
45 }
46
47
48 list_del(&wait->entry);
49
50
51 ASSERT(op);
52
53
54
55
56
57
58 fscache_get_retrieval(op);
59
60 object = container_of(op->op.object, struct cachefiles_object, fscache);
61 spin_lock(&object->work_lock);
62 list_add_tail(&monitor->op_link, &op->to_do);
63 fscache_enqueue_retrieval(op);
64 spin_unlock(&object->work_lock);
65
66 fscache_put_retrieval(op);
67 return 0;
68}
69
70
71
72
73
74
75
76
77static int cachefiles_read_reissue(struct cachefiles_object *object,
78 struct cachefiles_one_read *monitor)
79{
80 struct address_space *bmapping = d_backing_inode(object->backer)->i_mapping;
81 struct page *backpage = monitor->back_page, *backpage2;
82 int ret;
83
84 _enter("{ino=%lx},{%lx,%lx}",
85 d_backing_inode(object->backer)->i_ino,
86 backpage->index, backpage->flags);
87
88
89 if (backpage->mapping != bmapping) {
90 _leave(" = -ENODATA [mapping]");
91 return -ENODATA;
92 }
93
94 backpage2 = find_get_page(bmapping, backpage->index);
95 if (!backpage2) {
96 _leave(" = -ENODATA [gone]");
97 return -ENODATA;
98 }
99
100 if (backpage != backpage2) {
101 put_page(backpage2);
102 _leave(" = -ENODATA [different]");
103 return -ENODATA;
104 }
105
106
107
108 put_page(backpage2);
109
110 INIT_LIST_HEAD(&monitor->op_link);
111 add_page_wait_queue(backpage, &monitor->monitor);
112
113 if (trylock_page(backpage)) {
114 ret = -EIO;
115 if (PageError(backpage))
116 goto unlock_discard;
117 ret = 0;
118 if (PageUptodate(backpage))
119 goto unlock_discard;
120
121 _debug("reissue read");
122 ret = bmapping->a_ops->readpage(NULL, backpage);
123 if (ret < 0)
124 goto discard;
125 }
126
127
128
129
130 if (trylock_page(backpage)) {
131 _debug("jumpstart %p {%lx}", backpage, backpage->flags);
132 unlock_page(backpage);
133 }
134
135
136 _leave(" = -EINPROGRESS");
137 return -EINPROGRESS;
138
139unlock_discard:
140 unlock_page(backpage);
141discard:
142 spin_lock_irq(&object->work_lock);
143 list_del(&monitor->op_link);
144 spin_unlock_irq(&object->work_lock);
145 _leave(" = %d", ret);
146 return ret;
147}
148
149
150
151
152
153static void cachefiles_read_copier(struct fscache_operation *_op)
154{
155 struct cachefiles_one_read *monitor;
156 struct cachefiles_object *object;
157 struct fscache_retrieval *op;
158 int error, max;
159
160 op = container_of(_op, struct fscache_retrieval, op);
161 object = container_of(op->op.object,
162 struct cachefiles_object, fscache);
163
164 _enter("{ino=%lu}", d_backing_inode(object->backer)->i_ino);
165
166 max = 8;
167 spin_lock_irq(&object->work_lock);
168
169 while (!list_empty(&op->to_do)) {
170 monitor = list_entry(op->to_do.next,
171 struct cachefiles_one_read, op_link);
172 list_del(&monitor->op_link);
173
174 spin_unlock_irq(&object->work_lock);
175
176 _debug("- copy {%lu}", monitor->back_page->index);
177
178 recheck:
179 if (test_bit(FSCACHE_COOKIE_INVALIDATING,
180 &object->fscache.cookie->flags)) {
181 error = -ESTALE;
182 } else if (PageUptodate(monitor->back_page)) {
183 copy_highpage(monitor->netfs_page, monitor->back_page);
184 fscache_mark_page_cached(monitor->op,
185 monitor->netfs_page);
186 error = 0;
187 } else if (!PageError(monitor->back_page)) {
188
189 error = cachefiles_read_reissue(object, monitor);
190 if (error == -EINPROGRESS)
191 goto next;
192 goto recheck;
193 } else {
194 cachefiles_io_error_obj(
195 object,
196 "Readpage failed on backing file %lx",
197 (unsigned long) monitor->back_page->flags);
198 error = -EIO;
199 }
200
201 put_page(monitor->back_page);
202
203 fscache_end_io(op, monitor->netfs_page, error);
204 put_page(monitor->netfs_page);
205 fscache_retrieval_complete(op, 1);
206 fscache_put_retrieval(op);
207 kfree(monitor);
208
209 next:
210
211 max--;
212 if (max < 0 || need_resched()) {
213 if (!list_empty(&op->to_do))
214 fscache_enqueue_retrieval(op);
215 _leave(" [maxed out]");
216 return;
217 }
218
219 spin_lock_irq(&object->work_lock);
220 }
221
222 spin_unlock_irq(&object->work_lock);
223 _leave("");
224}
225
226
227
228
229
230static int cachefiles_read_backing_file_one(struct cachefiles_object *object,
231 struct fscache_retrieval *op,
232 struct page *netpage)
233{
234 struct cachefiles_one_read *monitor;
235 struct address_space *bmapping;
236 struct page *newpage, *backpage;
237 int ret;
238
239 _enter("");
240
241 _debug("read back %p{%lu,%d}",
242 netpage, netpage->index, page_count(netpage));
243
244 monitor = kzalloc(sizeof(*monitor), cachefiles_gfp);
245 if (!monitor)
246 goto nomem;
247
248 monitor->netfs_page = netpage;
249 monitor->op = fscache_get_retrieval(op);
250
251 init_waitqueue_func_entry(&monitor->monitor, cachefiles_read_waiter);
252
253
254 bmapping = d_backing_inode(object->backer)->i_mapping;
255 newpage = NULL;
256
257 for (;;) {
258 backpage = find_get_page(bmapping, netpage->index);
259 if (backpage)
260 goto backing_page_already_present;
261
262 if (!newpage) {
263 newpage = __page_cache_alloc(cachefiles_gfp);
264 if (!newpage)
265 goto nomem_monitor;
266 }
267
268 ret = add_to_page_cache_lru(newpage, bmapping,
269 netpage->index, cachefiles_gfp);
270 if (ret == 0)
271 goto installed_new_backing_page;
272 if (ret != -EEXIST)
273 goto nomem_page;
274 }
275
276
277
278installed_new_backing_page:
279 _debug("- new %p", newpage);
280
281 backpage = newpage;
282 newpage = NULL;
283
284read_backing_page:
285 ret = bmapping->a_ops->readpage(NULL, backpage);
286 if (ret < 0)
287 goto read_error;
288
289
290monitor_backing_page:
291 _debug("- monitor add");
292
293
294 get_page(monitor->netfs_page);
295 get_page(backpage);
296 monitor->back_page = backpage;
297 monitor->monitor.private = backpage;
298 add_page_wait_queue(backpage, &monitor->monitor);
299 monitor = NULL;
300
301
302
303
304 if (trylock_page(backpage)) {
305 _debug("jumpstart %p {%lx}", backpage, backpage->flags);
306 unlock_page(backpage);
307 }
308 goto success;
309
310
311
312backing_page_already_present:
313 _debug("- present");
314
315 if (newpage) {
316 put_page(newpage);
317 newpage = NULL;
318 }
319
320 if (PageError(backpage))
321 goto io_error;
322
323 if (PageUptodate(backpage))
324 goto backing_page_already_uptodate;
325
326 if (!trylock_page(backpage))
327 goto monitor_backing_page;
328 _debug("read %p {%lx}", backpage, backpage->flags);
329 goto read_backing_page;
330
331
332
333backing_page_already_uptodate:
334 _debug("- uptodate");
335
336 fscache_mark_page_cached(op, netpage);
337
338 copy_highpage(netpage, backpage);
339 fscache_end_io(op, netpage, 0);
340 fscache_retrieval_complete(op, 1);
341
342success:
343 _debug("success");
344 ret = 0;
345
346out:
347 if (backpage)
348 put_page(backpage);
349 if (monitor) {
350 fscache_put_retrieval(monitor->op);
351 kfree(monitor);
352 }
353 _leave(" = %d", ret);
354 return ret;
355
356read_error:
357 _debug("read error %d", ret);
358 if (ret == -ENOMEM) {
359 fscache_retrieval_complete(op, 1);
360 goto out;
361 }
362io_error:
363 cachefiles_io_error_obj(object, "Page read error on backing file");
364 fscache_retrieval_complete(op, 1);
365 ret = -ENOBUFS;
366 goto out;
367
368nomem_page:
369 put_page(newpage);
370nomem_monitor:
371 fscache_put_retrieval(monitor->op);
372 kfree(monitor);
373nomem:
374 fscache_retrieval_complete(op, 1);
375 _leave(" = -ENOMEM");
376 return -ENOMEM;
377}
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393int cachefiles_read_or_alloc_page(struct fscache_retrieval *op,
394 struct page *page,
395 gfp_t gfp)
396{
397 struct cachefiles_object *object;
398 struct cachefiles_cache *cache;
399 struct inode *inode;
400 sector_t block;
401 unsigned shift;
402 int ret, ret2;
403
404 object = container_of(op->op.object,
405 struct cachefiles_object, fscache);
406 cache = container_of(object->fscache.cache,
407 struct cachefiles_cache, cache);
408
409 _enter("{%p},{%lx},,,", object, page->index);
410
411 if (!object->backer)
412 goto enobufs;
413
414 inode = d_backing_inode(object->backer);
415 ASSERT(S_ISREG(inode->i_mode));
416 ASSERT(inode->i_mapping->a_ops->readpages);
417
418
419 shift = PAGE_SHIFT - inode->i_sb->s_blocksize_bits;
420
421 op->op.flags &= FSCACHE_OP_KEEP_FLAGS;
422 op->op.flags |= FSCACHE_OP_ASYNC;
423 op->op.processor = cachefiles_read_copier;
424
425
426
427
428
429
430
431 block = page->index;
432 block <<= shift;
433
434 ret2 = bmap(inode, &block);
435 ASSERT(ret2 == 0);
436
437 _debug("%llx -> %llx",
438 (unsigned long long) (page->index << shift),
439 (unsigned long long) block);
440
441 if (block) {
442
443
444 ret = cachefiles_read_backing_file_one(object, op, page);
445 } else if (cachefiles_has_space(cache, 0, 1) == 0) {
446
447 fscache_mark_page_cached(op, page);
448 fscache_retrieval_complete(op, 1);
449 ret = -ENODATA;
450 } else {
451 goto enobufs;
452 }
453
454 _leave(" = %d", ret);
455 return ret;
456
457enobufs:
458 fscache_retrieval_complete(op, 1);
459 _leave(" = -ENOBUFS");
460 return -ENOBUFS;
461}
462
463
464
465
466
467static int cachefiles_read_backing_file(struct cachefiles_object *object,
468 struct fscache_retrieval *op,
469 struct list_head *list)
470{
471 struct cachefiles_one_read *monitor = NULL;
472 struct address_space *bmapping = d_backing_inode(object->backer)->i_mapping;
473 struct page *newpage = NULL, *netpage, *_n, *backpage = NULL;
474 int ret = 0;
475
476 _enter("");
477
478 list_for_each_entry_safe(netpage, _n, list, lru) {
479 list_del(&netpage->lru);
480
481 _debug("read back %p{%lu,%d}",
482 netpage, netpage->index, page_count(netpage));
483
484 if (!monitor) {
485 monitor = kzalloc(sizeof(*monitor), cachefiles_gfp);
486 if (!monitor)
487 goto nomem;
488
489 monitor->op = fscache_get_retrieval(op);
490 init_waitqueue_func_entry(&monitor->monitor,
491 cachefiles_read_waiter);
492 }
493
494 for (;;) {
495 backpage = find_get_page(bmapping, netpage->index);
496 if (backpage)
497 goto backing_page_already_present;
498
499 if (!newpage) {
500 newpage = __page_cache_alloc(cachefiles_gfp);
501 if (!newpage)
502 goto nomem;
503 }
504
505 ret = add_to_page_cache_lru(newpage, bmapping,
506 netpage->index,
507 cachefiles_gfp);
508 if (ret == 0)
509 goto installed_new_backing_page;
510 if (ret != -EEXIST)
511 goto nomem;
512 }
513
514
515
516 installed_new_backing_page:
517 _debug("- new %p", newpage);
518
519 backpage = newpage;
520 newpage = NULL;
521
522 reread_backing_page:
523 ret = bmapping->a_ops->readpage(NULL, backpage);
524 if (ret < 0)
525 goto read_error;
526
527
528
529 monitor_backing_page:
530 _debug("- monitor add");
531
532 ret = add_to_page_cache_lru(netpage, op->mapping,
533 netpage->index, cachefiles_gfp);
534 if (ret < 0) {
535 if (ret == -EEXIST) {
536 put_page(backpage);
537 backpage = NULL;
538 put_page(netpage);
539 netpage = NULL;
540 fscache_retrieval_complete(op, 1);
541 continue;
542 }
543 goto nomem;
544 }
545
546
547 get_page(netpage);
548 monitor->netfs_page = netpage;
549
550 get_page(backpage);
551 monitor->back_page = backpage;
552 monitor->monitor.private = backpage;
553 add_page_wait_queue(backpage, &monitor->monitor);
554 monitor = NULL;
555
556
557
558
559 if (trylock_page(backpage)) {
560 _debug("2unlock %p {%lx}", backpage, backpage->flags);
561 unlock_page(backpage);
562 }
563
564 put_page(backpage);
565 backpage = NULL;
566
567 put_page(netpage);
568 netpage = NULL;
569 continue;
570
571
572
573 backing_page_already_present:
574 _debug("- present %p", backpage);
575
576 if (PageError(backpage))
577 goto io_error;
578
579 if (PageUptodate(backpage))
580 goto backing_page_already_uptodate;
581
582 _debug("- not ready %p{%lx}", backpage, backpage->flags);
583
584 if (!trylock_page(backpage))
585 goto monitor_backing_page;
586
587 if (PageError(backpage)) {
588 _debug("error %lx", backpage->flags);
589 unlock_page(backpage);
590 goto io_error;
591 }
592
593 if (PageUptodate(backpage))
594 goto backing_page_already_uptodate_unlock;
595
596
597
598 goto reread_backing_page;
599
600
601
602 backing_page_already_uptodate_unlock:
603 _debug("uptodate %lx", backpage->flags);
604 unlock_page(backpage);
605 backing_page_already_uptodate:
606 _debug("- uptodate");
607
608 ret = add_to_page_cache_lru(netpage, op->mapping,
609 netpage->index, cachefiles_gfp);
610 if (ret < 0) {
611 if (ret == -EEXIST) {
612 put_page(backpage);
613 backpage = NULL;
614 put_page(netpage);
615 netpage = NULL;
616 fscache_retrieval_complete(op, 1);
617 continue;
618 }
619 goto nomem;
620 }
621
622 copy_highpage(netpage, backpage);
623
624 put_page(backpage);
625 backpage = NULL;
626
627 fscache_mark_page_cached(op, netpage);
628
629
630 fscache_end_io(op, netpage, 0);
631 put_page(netpage);
632 netpage = NULL;
633 fscache_retrieval_complete(op, 1);
634 continue;
635 }
636
637 netpage = NULL;
638
639 _debug("out");
640
641out:
642
643 if (newpage)
644 put_page(newpage);
645 if (netpage)
646 put_page(netpage);
647 if (backpage)
648 put_page(backpage);
649 if (monitor) {
650 fscache_put_retrieval(op);
651 kfree(monitor);
652 }
653
654 list_for_each_entry_safe(netpage, _n, list, lru) {
655 list_del(&netpage->lru);
656 put_page(netpage);
657 fscache_retrieval_complete(op, 1);
658 }
659
660 _leave(" = %d", ret);
661 return ret;
662
663nomem:
664 _debug("nomem");
665 ret = -ENOMEM;
666 goto record_page_complete;
667
668read_error:
669 _debug("read error %d", ret);
670 if (ret == -ENOMEM)
671 goto record_page_complete;
672io_error:
673 cachefiles_io_error_obj(object, "Page read error on backing file");
674 ret = -ENOBUFS;
675record_page_complete:
676 fscache_retrieval_complete(op, 1);
677 goto out;
678}
679
680
681
682
683
684int cachefiles_read_or_alloc_pages(struct fscache_retrieval *op,
685 struct list_head *pages,
686 unsigned *nr_pages,
687 gfp_t gfp)
688{
689 struct cachefiles_object *object;
690 struct cachefiles_cache *cache;
691 struct list_head backpages;
692 struct pagevec pagevec;
693 struct inode *inode;
694 struct page *page, *_n;
695 unsigned shift, nrbackpages;
696 int ret, ret2, space;
697
698 object = container_of(op->op.object,
699 struct cachefiles_object, fscache);
700 cache = container_of(object->fscache.cache,
701 struct cachefiles_cache, cache);
702
703 _enter("{OBJ%x,%d},,%d,,",
704 object->fscache.debug_id, atomic_read(&op->op.usage),
705 *nr_pages);
706
707 if (!object->backer)
708 goto all_enobufs;
709
710 space = 1;
711 if (cachefiles_has_space(cache, 0, *nr_pages) < 0)
712 space = 0;
713
714 inode = d_backing_inode(object->backer);
715 ASSERT(S_ISREG(inode->i_mode));
716 ASSERT(inode->i_mapping->a_ops->readpages);
717
718
719 shift = PAGE_SHIFT - inode->i_sb->s_blocksize_bits;
720
721 pagevec_init(&pagevec);
722
723 op->op.flags &= FSCACHE_OP_KEEP_FLAGS;
724 op->op.flags |= FSCACHE_OP_ASYNC;
725 op->op.processor = cachefiles_read_copier;
726
727 INIT_LIST_HEAD(&backpages);
728 nrbackpages = 0;
729
730 ret = space ? -ENODATA : -ENOBUFS;
731 list_for_each_entry_safe(page, _n, pages, lru) {
732 sector_t block;
733
734
735
736
737
738
739
740 block = page->index;
741 block <<= shift;
742
743 ret2 = bmap(inode, &block);
744 ASSERT(ret2 == 0);
745
746 _debug("%llx -> %llx",
747 (unsigned long long) (page->index << shift),
748 (unsigned long long) block);
749
750 if (block) {
751
752
753 list_move(&page->lru, &backpages);
754 (*nr_pages)--;
755 nrbackpages++;
756 } else if (space && pagevec_add(&pagevec, page) == 0) {
757 fscache_mark_pages_cached(op, &pagevec);
758 fscache_retrieval_complete(op, 1);
759 ret = -ENODATA;
760 } else {
761 fscache_retrieval_complete(op, 1);
762 }
763 }
764
765 if (pagevec_count(&pagevec) > 0)
766 fscache_mark_pages_cached(op, &pagevec);
767
768 if (list_empty(pages))
769 ret = 0;
770
771
772
773 if (nrbackpages > 0) {
774 ret2 = cachefiles_read_backing_file(object, op, &backpages);
775 if (ret2 == -ENOMEM || ret2 == -EINTR)
776 ret = ret2;
777 }
778
779 _leave(" = %d [nr=%u%s]",
780 ret, *nr_pages, list_empty(pages) ? " empty" : "");
781 return ret;
782
783all_enobufs:
784 fscache_retrieval_complete(op, *nr_pages);
785 return -ENOBUFS;
786}
787
788
789
790
791
792
793
794
795
796
797
798
799int cachefiles_allocate_page(struct fscache_retrieval *op,
800 struct page *page,
801 gfp_t gfp)
802{
803 struct cachefiles_object *object;
804 struct cachefiles_cache *cache;
805 int ret;
806
807 object = container_of(op->op.object,
808 struct cachefiles_object, fscache);
809 cache = container_of(object->fscache.cache,
810 struct cachefiles_cache, cache);
811
812 _enter("%p,{%lx},", object, page->index);
813
814 ret = cachefiles_has_space(cache, 0, 1);
815 if (ret == 0)
816 fscache_mark_page_cached(op, page);
817 else
818 ret = -ENOBUFS;
819
820 fscache_retrieval_complete(op, 1);
821 _leave(" = %d", ret);
822 return ret;
823}
824
825
826
827
828
829
830
831
832
833
834
835
836int cachefiles_allocate_pages(struct fscache_retrieval *op,
837 struct list_head *pages,
838 unsigned *nr_pages,
839 gfp_t gfp)
840{
841 struct cachefiles_object *object;
842 struct cachefiles_cache *cache;
843 struct pagevec pagevec;
844 struct page *page;
845 int ret;
846
847 object = container_of(op->op.object,
848 struct cachefiles_object, fscache);
849 cache = container_of(object->fscache.cache,
850 struct cachefiles_cache, cache);
851
852 _enter("%p,,,%d,", object, *nr_pages);
853
854 ret = cachefiles_has_space(cache, 0, *nr_pages);
855 if (ret == 0) {
856 pagevec_init(&pagevec);
857
858 list_for_each_entry(page, pages, lru) {
859 if (pagevec_add(&pagevec, page) == 0)
860 fscache_mark_pages_cached(op, &pagevec);
861 }
862
863 if (pagevec_count(&pagevec) > 0)
864 fscache_mark_pages_cached(op, &pagevec);
865 ret = -ENODATA;
866 } else {
867 ret = -ENOBUFS;
868 }
869
870 fscache_retrieval_complete(op, *nr_pages);
871 _leave(" = %d", ret);
872 return ret;
873}
874
875
876
877
878
879
880
881
882int cachefiles_write_page(struct fscache_storage *op, struct page *page)
883{
884 struct cachefiles_object *object;
885 struct cachefiles_cache *cache;
886 struct file *file;
887 struct path path;
888 loff_t pos, eof;
889 size_t len;
890 void *data;
891 int ret = -ENOBUFS;
892
893 ASSERT(op != NULL);
894 ASSERT(page != NULL);
895
896 object = container_of(op->op.object,
897 struct cachefiles_object, fscache);
898
899 _enter("%p,%p{%lx},,,", object, page, page->index);
900
901 if (!object->backer) {
902 _leave(" = -ENOBUFS");
903 return -ENOBUFS;
904 }
905
906 ASSERT(d_is_reg(object->backer));
907
908 cache = container_of(object->fscache.cache,
909 struct cachefiles_cache, cache);
910
911 pos = (loff_t)page->index << PAGE_SHIFT;
912
913
914
915
916 eof = object->fscache.store_limit_l;
917 if (pos >= eof)
918 goto error;
919
920
921
922 path.mnt = cache->mnt;
923 path.dentry = object->backer;
924 file = dentry_open(&path, O_RDWR | O_LARGEFILE, cache->cache_cred);
925 if (IS_ERR(file)) {
926 ret = PTR_ERR(file);
927 goto error_2;
928 }
929
930 len = PAGE_SIZE;
931 if (eof & ~PAGE_MASK) {
932 if (eof - pos < PAGE_SIZE) {
933 _debug("cut short %llx to %llx",
934 pos, eof);
935 len = eof - pos;
936 ASSERTCMP(pos + len, ==, eof);
937 }
938 }
939
940 data = kmap(page);
941 ret = kernel_write(file, data, len, &pos);
942 kunmap(page);
943 fput(file);
944 if (ret != len)
945 goto error_eio;
946
947 _leave(" = 0");
948 return 0;
949
950error_eio:
951 ret = -EIO;
952error_2:
953 if (ret == -EIO)
954 cachefiles_io_error_obj(object,
955 "Write page to backing file failed");
956error:
957 _leave(" = -ENOBUFS [%d]", ret);
958 return -ENOBUFS;
959}
960
961
962
963
964
965void cachefiles_uncache_page(struct fscache_object *_object, struct page *page)
966 __releases(&object->fscache.cookie->lock)
967{
968 struct cachefiles_object *object;
969
970 object = container_of(_object, struct cachefiles_object, fscache);
971
972 _enter("%p,{%lu}", object, page->index);
973
974 spin_unlock(&object->fscache.cookie->lock);
975}
976