a69787e7dd964b2c57c016b6d6aa87b987285ace
[linux-2.6.git] / fs / cachefiles / rdwr.c
1 /* Storage object read/write
2  *
3  * Copyright (C) 2007 Red Hat, Inc. All Rights Reserved.
4  * Written by David Howells (dhowells@redhat.com)
5  *
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.
10  */
11
12 #include <linux/mount.h>
13 #include <linux/file.h>
14 #include "internal.h"
15
16 /*
17  * detect wake up events generated by the unlocking of pages in which we're
18  * interested
19  * - we use this to detect read completion of backing pages
20  * - the caller holds the waitqueue lock
21  */
22 static int cachefiles_read_waiter(wait_queue_t *wait, unsigned mode,
23                                   int sync, void *_key)
24 {
25         struct cachefiles_one_read *monitor =
26                 container_of(wait, struct cachefiles_one_read, monitor);
27         struct cachefiles_object *object;
28         struct wait_bit_key *key = _key;
29         struct page *page = wait->private;
30
31         ASSERT(key);
32
33         _enter("{%lu},%u,%d,{%p,%u}",
34                monitor->netfs_page->index, mode, sync,
35                key->flags, key->bit_nr);
36
37         if (key->flags != &page->flags ||
38             key->bit_nr != PG_locked)
39                 return 0;
40
41         _debug("--- monitor %p %lx ---", page, page->flags);
42
43         if (!PageUptodate(page) && !PageError(page))
44                 dump_stack();
45
46         /* remove from the waitqueue */
47         list_del(&wait->task_list);
48
49         /* move onto the action list and queue for FS-Cache thread pool */
50         ASSERT(monitor->op);
51
52         object = container_of(monitor->op->op.object,
53                               struct cachefiles_object, fscache);
54
55         spin_lock(&object->work_lock);
56         list_add_tail(&monitor->op_link, &monitor->op->to_do);
57         spin_unlock(&object->work_lock);
58
59         fscache_enqueue_retrieval(monitor->op);
60         return 0;
61 }
62
63 /*
64  * copy data from backing pages to netfs pages to complete a read operation
65  * - driven by FS-Cache's thread pool
66  */
67 static void cachefiles_read_copier(struct fscache_operation *_op)
68 {
69         struct cachefiles_one_read *monitor;
70         struct cachefiles_object *object;
71         struct fscache_retrieval *op;
72         struct pagevec pagevec;
73         int error, max;
74
75         op = container_of(_op, struct fscache_retrieval, op);
76         object = container_of(op->op.object,
77                               struct cachefiles_object, fscache);
78
79         _enter("{ino=%lu}", object->backer->d_inode->i_ino);
80
81         pagevec_init(&pagevec, 0);
82
83         max = 8;
84         spin_lock_irq(&object->work_lock);
85
86         while (!list_empty(&op->to_do)) {
87                 monitor = list_entry(op->to_do.next,
88                                      struct cachefiles_one_read, op_link);
89                 list_del(&monitor->op_link);
90
91                 spin_unlock_irq(&object->work_lock);
92
93                 _debug("- copy {%lu}", monitor->back_page->index);
94
95                 error = -EIO;
96                 if (PageUptodate(monitor->back_page)) {
97                         copy_highpage(monitor->netfs_page, monitor->back_page);
98
99                         pagevec_add(&pagevec, monitor->netfs_page);
100                         fscache_mark_pages_cached(monitor->op, &pagevec);
101                         error = 0;
102                 }
103
104                 if (error)
105                         cachefiles_io_error_obj(
106                                 object,
107                                 "Readpage failed on backing file %lx",
108                                 (unsigned long) monitor->back_page->flags);
109
110                 page_cache_release(monitor->back_page);
111
112                 fscache_end_io(op, monitor->netfs_page, error);
113                 page_cache_release(monitor->netfs_page);
114                 fscache_put_retrieval(op);
115                 kfree(monitor);
116
117                 /* let the thread pool have some air occasionally */
118                 max--;
119                 if (max < 0 || need_resched()) {
120                         if (!list_empty(&op->to_do))
121                                 fscache_enqueue_retrieval(op);
122                         _leave(" [maxed out]");
123                         return;
124                 }
125
126                 spin_lock_irq(&object->work_lock);
127         }
128
129         spin_unlock_irq(&object->work_lock);
130         _leave("");
131 }
132
133 /*
134  * read the corresponding page to the given set from the backing file
135  * - an uncertain page is simply discarded, to be tried again another time
136  */
137 static int cachefiles_read_backing_file_one(struct cachefiles_object *object,
138                                             struct fscache_retrieval *op,
139                                             struct page *netpage,
140                                             struct pagevec *pagevec)
141 {
142         struct cachefiles_one_read *monitor;
143         struct address_space *bmapping;
144         struct page *newpage, *backpage;
145         int ret;
146
147         _enter("");
148
149         pagevec_reinit(pagevec);
150
151         _debug("read back %p{%lu,%d}",
152                netpage, netpage->index, page_count(netpage));
153
154         monitor = kzalloc(sizeof(*monitor), GFP_KERNEL);
155         if (!monitor)
156                 goto nomem;
157
158         monitor->netfs_page = netpage;
159         monitor->op = fscache_get_retrieval(op);
160
161         init_waitqueue_func_entry(&monitor->monitor, cachefiles_read_waiter);
162
163         /* attempt to get hold of the backing page */
164         bmapping = object->backer->d_inode->i_mapping;
165         newpage = NULL;
166
167         for (;;) {
168                 backpage = find_get_page(bmapping, netpage->index);
169                 if (backpage)
170                         goto backing_page_already_present;
171
172                 if (!newpage) {
173                         newpage = page_cache_alloc_cold(bmapping);
174                         if (!newpage)
175                                 goto nomem_monitor;
176                 }
177
178                 ret = add_to_page_cache(newpage, bmapping,
179                                         netpage->index, GFP_KERNEL);
180                 if (ret == 0)
181                         goto installed_new_backing_page;
182                 if (ret != -EEXIST)
183                         goto nomem_page;
184         }
185
186         /* we've installed a new backing page, so now we need to add it
187          * to the LRU list and start it reading */
188 installed_new_backing_page:
189         _debug("- new %p", newpage);
190
191         backpage = newpage;
192         newpage = NULL;
193
194         page_cache_get(backpage);
195         pagevec_add(pagevec, backpage);
196         __pagevec_lru_add_file(pagevec);
197
198 read_backing_page:
199         ret = bmapping->a_ops->readpage(NULL, backpage);
200         if (ret < 0)
201                 goto read_error;
202
203         /* set the monitor to transfer the data across */
204 monitor_backing_page:
205         _debug("- monitor add");
206
207         /* install the monitor */
208         page_cache_get(monitor->netfs_page);
209         page_cache_get(backpage);
210         monitor->back_page = backpage;
211         monitor->monitor.private = backpage;
212         add_page_wait_queue(backpage, &monitor->monitor);
213         monitor = NULL;
214
215         /* but the page may have been read before the monitor was installed, so
216          * the monitor may miss the event - so we have to ensure that we do get
217          * one in such a case */
218         if (trylock_page(backpage)) {
219                 _debug("jumpstart %p {%lx}", backpage, backpage->flags);
220                 unlock_page(backpage);
221         }
222         goto success;
223
224         /* if the backing page is already present, it can be in one of
225          * three states: read in progress, read failed or read okay */
226 backing_page_already_present:
227         _debug("- present");
228
229         if (newpage) {
230                 page_cache_release(newpage);
231                 newpage = NULL;
232         }
233
234         if (PageError(backpage))
235                 goto io_error;
236
237         if (PageUptodate(backpage))
238                 goto backing_page_already_uptodate;
239
240         if (!trylock_page(backpage))
241                 goto monitor_backing_page;
242         _debug("read %p {%lx}", backpage, backpage->flags);
243         goto read_backing_page;
244
245         /* the backing page is already up to date, attach the netfs
246          * page to the pagecache and LRU and copy the data across */
247 backing_page_already_uptodate:
248         _debug("- uptodate");
249
250         pagevec_add(pagevec, netpage);
251         fscache_mark_pages_cached(op, pagevec);
252
253         copy_highpage(netpage, backpage);
254         fscache_end_io(op, netpage, 0);
255
256 success:
257         _debug("success");
258         ret = 0;
259
260 out:
261         if (backpage)
262                 page_cache_release(backpage);
263         if (monitor) {
264                 fscache_put_retrieval(monitor->op);
265                 kfree(monitor);
266         }
267         _leave(" = %d", ret);
268         return ret;
269
270 read_error:
271         _debug("read error %d", ret);
272         if (ret == -ENOMEM)
273                 goto out;
274 io_error:
275         cachefiles_io_error_obj(object, "Page read error on backing file");
276         ret = -ENOBUFS;
277         goto out;
278
279 nomem_page:
280         page_cache_release(newpage);
281 nomem_monitor:
282         fscache_put_retrieval(monitor->op);
283         kfree(monitor);
284 nomem:
285         _leave(" = -ENOMEM");
286         return -ENOMEM;
287 }
288
289 /*
290  * read a page from the cache or allocate a block in which to store it
291  * - cache withdrawal is prevented by the caller
292  * - returns -EINTR if interrupted
293  * - returns -ENOMEM if ran out of memory
294  * - returns -ENOBUFS if no buffers can be made available
295  * - returns -ENOBUFS if page is beyond EOF
296  * - if the page is backed by a block in the cache:
297  *   - a read will be started which will call the callback on completion
298  *   - 0 will be returned
299  * - else if the page is unbacked:
300  *   - the metadata will be retained
301  *   - -ENODATA will be returned
302  */
303 int cachefiles_read_or_alloc_page(struct fscache_retrieval *op,
304                                   struct page *page,
305                                   gfp_t gfp)
306 {
307         struct cachefiles_object *object;
308         struct cachefiles_cache *cache;
309         struct pagevec pagevec;
310         struct inode *inode;
311         sector_t block0, block;
312         unsigned shift;
313         int ret;
314
315         object = container_of(op->op.object,
316                               struct cachefiles_object, fscache);
317         cache = container_of(object->fscache.cache,
318                              struct cachefiles_cache, cache);
319
320         _enter("{%p},{%lx},,,", object, page->index);
321
322         if (!object->backer)
323                 return -ENOBUFS;
324
325         inode = object->backer->d_inode;
326         ASSERT(S_ISREG(inode->i_mode));
327         ASSERT(inode->i_mapping->a_ops->bmap);
328         ASSERT(inode->i_mapping->a_ops->readpages);
329
330         /* calculate the shift required to use bmap */
331         if (inode->i_sb->s_blocksize > PAGE_SIZE)
332                 return -ENOBUFS;
333
334         shift = PAGE_SHIFT - inode->i_sb->s_blocksize_bits;
335
336         op->op.flags = FSCACHE_OP_FAST;
337         op->op.processor = cachefiles_read_copier;
338
339         pagevec_init(&pagevec, 0);
340
341         /* we assume the absence or presence of the first block is a good
342          * enough indication for the page as a whole
343          * - TODO: don't use bmap() for this as it is _not_ actually good
344          *   enough for this as it doesn't indicate errors, but it's all we've
345          *   got for the moment
346          */
347         block0 = page->index;
348         block0 <<= shift;
349
350         block = inode->i_mapping->a_ops->bmap(inode->i_mapping, block0);
351         _debug("%llx -> %llx",
352                (unsigned long long) block0,
353                (unsigned long long) block);
354
355         if (block) {
356                 /* submit the apparently valid page to the backing fs to be
357                  * read from disk */
358                 ret = cachefiles_read_backing_file_one(object, op, page,
359                                                        &pagevec);
360         } else if (cachefiles_has_space(cache, 0, 1) == 0) {
361                 /* there's space in the cache we can use */
362                 pagevec_add(&pagevec, page);
363                 fscache_mark_pages_cached(op, &pagevec);
364                 ret = -ENODATA;
365         } else {
366                 ret = -ENOBUFS;
367         }
368
369         _leave(" = %d", ret);
370         return ret;
371 }
372
373 /*
374  * read the corresponding pages to the given set from the backing file
375  * - any uncertain pages are simply discarded, to be tried again another time
376  */
377 static int cachefiles_read_backing_file(struct cachefiles_object *object,
378                                         struct fscache_retrieval *op,
379                                         struct list_head *list,
380                                         struct pagevec *mark_pvec)
381 {
382         struct cachefiles_one_read *monitor = NULL;
383         struct address_space *bmapping = object->backer->d_inode->i_mapping;
384         struct pagevec lru_pvec;
385         struct page *newpage = NULL, *netpage, *_n, *backpage = NULL;
386         int ret = 0;
387
388         _enter("");
389
390         pagevec_init(&lru_pvec, 0);
391
392         list_for_each_entry_safe(netpage, _n, list, lru) {
393                 list_del(&netpage->lru);
394
395                 _debug("read back %p{%lu,%d}",
396                        netpage, netpage->index, page_count(netpage));
397
398                 if (!monitor) {
399                         monitor = kzalloc(sizeof(*monitor), GFP_KERNEL);
400                         if (!monitor)
401                                 goto nomem;
402
403                         monitor->op = fscache_get_retrieval(op);
404                         init_waitqueue_func_entry(&monitor->monitor,
405                                                   cachefiles_read_waiter);
406                 }
407
408                 for (;;) {
409                         backpage = find_get_page(bmapping, netpage->index);
410                         if (backpage)
411                                 goto backing_page_already_present;
412
413                         if (!newpage) {
414                                 newpage = page_cache_alloc_cold(bmapping);
415                                 if (!newpage)
416                                         goto nomem;
417                         }
418
419                         ret = add_to_page_cache(newpage, bmapping,
420                                                 netpage->index, GFP_KERNEL);
421                         if (ret == 0)
422                                 goto installed_new_backing_page;
423                         if (ret != -EEXIST)
424                                 goto nomem;
425                 }
426
427                 /* we've installed a new backing page, so now we need to add it
428                  * to the LRU list and start it reading */
429         installed_new_backing_page:
430                 _debug("- new %p", newpage);
431
432                 backpage = newpage;
433                 newpage = NULL;
434
435                 page_cache_get(backpage);
436                 if (!pagevec_add(&lru_pvec, backpage))
437                         __pagevec_lru_add_file(&lru_pvec);
438
439         reread_backing_page:
440                 ret = bmapping->a_ops->readpage(NULL, backpage);
441                 if (ret < 0)
442                         goto read_error;
443
444                 /* add the netfs page to the pagecache and LRU, and set the
445                  * monitor to transfer the data across */
446         monitor_backing_page:
447                 _debug("- monitor add");
448
449                 ret = add_to_page_cache(netpage, op->mapping, netpage->index,
450                                         GFP_KERNEL);
451                 if (ret < 0) {
452                         if (ret == -EEXIST) {
453                                 page_cache_release(netpage);
454                                 continue;
455                         }
456                         goto nomem;
457                 }
458
459                 page_cache_get(netpage);
460                 if (!pagevec_add(&lru_pvec, netpage))
461                         __pagevec_lru_add_file(&lru_pvec);
462
463                 /* install a monitor */
464                 page_cache_get(netpage);
465                 monitor->netfs_page = netpage;
466
467                 page_cache_get(backpage);
468                 monitor->back_page = backpage;
469                 monitor->monitor.private = backpage;
470                 add_page_wait_queue(backpage, &monitor->monitor);
471                 monitor = NULL;
472
473                 /* but the page may have been read before the monitor was
474                  * installed, so the monitor may miss the event - so we have to
475                  * ensure that we do get one in such a case */
476                 if (trylock_page(backpage)) {
477                         _debug("2unlock %p {%lx}", backpage, backpage->flags);
478                         unlock_page(backpage);
479                 }
480
481                 page_cache_release(backpage);
482                 backpage = NULL;
483
484                 page_cache_release(netpage);
485                 netpage = NULL;
486                 continue;
487
488                 /* if the backing page is already present, it can be in one of
489                  * three states: read in progress, read failed or read okay */
490         backing_page_already_present:
491                 _debug("- present %p", backpage);
492
493                 if (PageError(backpage))
494                         goto io_error;
495
496                 if (PageUptodate(backpage))
497                         goto backing_page_already_uptodate;
498
499                 _debug("- not ready %p{%lx}", backpage, backpage->flags);
500
501                 if (!trylock_page(backpage))
502                         goto monitor_backing_page;
503
504                 if (PageError(backpage)) {
505                         _debug("error %lx", backpage->flags);
506                         unlock_page(backpage);
507                         goto io_error;
508                 }
509
510                 if (PageUptodate(backpage))
511                         goto backing_page_already_uptodate_unlock;
512
513                 /* we've locked a page that's neither up to date nor erroneous,
514                  * so we need to attempt to read it again */
515                 goto reread_backing_page;
516
517                 /* the backing page is already up to date, attach the netfs
518                  * page to the pagecache and LRU and copy the data across */
519         backing_page_already_uptodate_unlock:
520                 _debug("uptodate %lx", backpage->flags);
521                 unlock_page(backpage);
522         backing_page_already_uptodate:
523                 _debug("- uptodate");
524
525                 ret = add_to_page_cache(netpage, op->mapping, netpage->index,
526                                         GFP_KERNEL);
527                 if (ret < 0) {
528                         if (ret == -EEXIST) {
529                                 page_cache_release(netpage);
530                                 continue;
531                         }
532                         goto nomem;
533                 }
534
535                 copy_highpage(netpage, backpage);
536
537                 page_cache_release(backpage);
538                 backpage = NULL;
539
540                 if (!pagevec_add(mark_pvec, netpage))
541                         fscache_mark_pages_cached(op, mark_pvec);
542
543                 page_cache_get(netpage);
544                 if (!pagevec_add(&lru_pvec, netpage))
545                         __pagevec_lru_add_file(&lru_pvec);
546
547                 fscache_end_io(op, netpage, 0);
548                 page_cache_release(netpage);
549                 netpage = NULL;
550                 continue;
551         }
552
553         netpage = NULL;
554
555         _debug("out");
556
557 out:
558         /* tidy up */
559         pagevec_lru_add_file(&lru_pvec);
560
561         if (newpage)
562                 page_cache_release(newpage);
563         if (netpage)
564                 page_cache_release(netpage);
565         if (backpage)
566                 page_cache_release(backpage);
567         if (monitor) {
568                 fscache_put_retrieval(op);
569                 kfree(monitor);
570         }
571
572         list_for_each_entry_safe(netpage, _n, list, lru) {
573                 list_del(&netpage->lru);
574                 page_cache_release(netpage);
575         }
576
577         _leave(" = %d", ret);
578         return ret;
579
580 nomem:
581         _debug("nomem");
582         ret = -ENOMEM;
583         goto out;
584
585 read_error:
586         _debug("read error %d", ret);
587         if (ret == -ENOMEM)
588                 goto out;
589 io_error:
590         cachefiles_io_error_obj(object, "Page read error on backing file");
591         ret = -ENOBUFS;
592         goto out;
593 }
594
595 /*
596  * read a list of pages from the cache or allocate blocks in which to store
597  * them
598  */
599 int cachefiles_read_or_alloc_pages(struct fscache_retrieval *op,
600                                    struct list_head *pages,
601                                    unsigned *nr_pages,
602                                    gfp_t gfp)
603 {
604         struct cachefiles_object *object;
605         struct cachefiles_cache *cache;
606         struct list_head backpages;
607         struct pagevec pagevec;
608         struct inode *inode;
609         struct page *page, *_n;
610         unsigned shift, nrbackpages;
611         int ret, ret2, space;
612
613         object = container_of(op->op.object,
614                               struct cachefiles_object, fscache);
615         cache = container_of(object->fscache.cache,
616                              struct cachefiles_cache, cache);
617
618         _enter("{OBJ%x,%d},,%d,,",
619                object->fscache.debug_id, atomic_read(&op->op.usage),
620                *nr_pages);
621
622         if (!object->backer)
623                 return -ENOBUFS;
624
625         space = 1;
626         if (cachefiles_has_space(cache, 0, *nr_pages) < 0)
627                 space = 0;
628
629         inode = object->backer->d_inode;
630         ASSERT(S_ISREG(inode->i_mode));
631         ASSERT(inode->i_mapping->a_ops->bmap);
632         ASSERT(inode->i_mapping->a_ops->readpages);
633
634         /* calculate the shift required to use bmap */
635         if (inode->i_sb->s_blocksize > PAGE_SIZE)
636                 return -ENOBUFS;
637
638         shift = PAGE_SHIFT - inode->i_sb->s_blocksize_bits;
639
640         pagevec_init(&pagevec, 0);
641
642         op->op.flags = FSCACHE_OP_FAST;
643         op->op.processor = cachefiles_read_copier;
644
645         INIT_LIST_HEAD(&backpages);
646         nrbackpages = 0;
647
648         ret = space ? -ENODATA : -ENOBUFS;
649         list_for_each_entry_safe(page, _n, pages, lru) {
650                 sector_t block0, block;
651
652                 /* we assume the absence or presence of the first block is a
653                  * good enough indication for the page as a whole
654                  * - TODO: don't use bmap() for this as it is _not_ actually
655                  *   good enough for this as it doesn't indicate errors, but
656                  *   it's all we've got for the moment
657                  */
658                 block0 = page->index;
659                 block0 <<= shift;
660
661                 block = inode->i_mapping->a_ops->bmap(inode->i_mapping,
662                                                       block0);
663                 _debug("%llx -> %llx",
664                        (unsigned long long) block0,
665                        (unsigned long long) block);
666
667                 if (block) {
668                         /* we have data - add it to the list to give to the
669                          * backing fs */
670                         list_move(&page->lru, &backpages);
671                         (*nr_pages)--;
672                         nrbackpages++;
673                 } else if (space && pagevec_add(&pagevec, page) == 0) {
674                         fscache_mark_pages_cached(op, &pagevec);
675                         ret = -ENODATA;
676                 }
677         }
678
679         if (pagevec_count(&pagevec) > 0)
680                 fscache_mark_pages_cached(op, &pagevec);
681
682         if (list_empty(pages))
683                 ret = 0;
684
685         /* submit the apparently valid pages to the backing fs to be read from
686          * disk */
687         if (nrbackpages > 0) {
688                 ret2 = cachefiles_read_backing_file(object, op, &backpages,
689                                                     &pagevec);
690                 if (ret2 == -ENOMEM || ret2 == -EINTR)
691                         ret = ret2;
692         }
693
694         if (pagevec_count(&pagevec) > 0)
695                 fscache_mark_pages_cached(op, &pagevec);
696
697         _leave(" = %d [nr=%u%s]",
698                ret, *nr_pages, list_empty(pages) ? " empty" : "");
699         return ret;
700 }
701
702 /*
703  * allocate a block in the cache in which to store a page
704  * - cache withdrawal is prevented by the caller
705  * - returns -EINTR if interrupted
706  * - returns -ENOMEM if ran out of memory
707  * - returns -ENOBUFS if no buffers can be made available
708  * - returns -ENOBUFS if page is beyond EOF
709  * - otherwise:
710  *   - the metadata will be retained
711  *   - 0 will be returned
712  */
713 int cachefiles_allocate_page(struct fscache_retrieval *op,
714                              struct page *page,
715                              gfp_t gfp)
716 {
717         struct cachefiles_object *object;
718         struct cachefiles_cache *cache;
719         struct pagevec pagevec;
720         int ret;
721
722         object = container_of(op->op.object,
723                               struct cachefiles_object, fscache);
724         cache = container_of(object->fscache.cache,
725                              struct cachefiles_cache, cache);
726
727         _enter("%p,{%lx},", object, page->index);
728
729         ret = cachefiles_has_space(cache, 0, 1);
730         if (ret == 0) {
731                 pagevec_init(&pagevec, 0);
732                 pagevec_add(&pagevec, page);
733                 fscache_mark_pages_cached(op, &pagevec);
734         } else {
735                 ret = -ENOBUFS;
736         }
737
738         _leave(" = %d", ret);
739         return ret;
740 }
741
742 /*
743  * allocate blocks in the cache in which to store a set of pages
744  * - cache withdrawal is prevented by the caller
745  * - returns -EINTR if interrupted
746  * - returns -ENOMEM if ran out of memory
747  * - returns -ENOBUFS if some buffers couldn't be made available
748  * - returns -ENOBUFS if some pages are beyond EOF
749  * - otherwise:
750  *   - -ENODATA will be returned
751  * - metadata will be retained for any page marked
752  */
753 int cachefiles_allocate_pages(struct fscache_retrieval *op,
754                               struct list_head *pages,
755                               unsigned *nr_pages,
756                               gfp_t gfp)
757 {
758         struct cachefiles_object *object;
759         struct cachefiles_cache *cache;
760         struct pagevec pagevec;
761         struct page *page;
762         int ret;
763
764         object = container_of(op->op.object,
765                               struct cachefiles_object, fscache);
766         cache = container_of(object->fscache.cache,
767                              struct cachefiles_cache, cache);
768
769         _enter("%p,,,%d,", object, *nr_pages);
770
771         ret = cachefiles_has_space(cache, 0, *nr_pages);
772         if (ret == 0) {
773                 pagevec_init(&pagevec, 0);
774
775                 list_for_each_entry(page, pages, lru) {
776                         if (pagevec_add(&pagevec, page) == 0)
777                                 fscache_mark_pages_cached(op, &pagevec);
778                 }
779
780                 if (pagevec_count(&pagevec) > 0)
781                         fscache_mark_pages_cached(op, &pagevec);
782                 ret = -ENODATA;
783         } else {
784                 ret = -ENOBUFS;
785         }
786
787         _leave(" = %d", ret);
788         return ret;
789 }
790
791 /*
792  * request a page be stored in the cache
793  * - cache withdrawal is prevented by the caller
794  * - this request may be ignored if there's no cache block available, in which
795  *   case -ENOBUFS will be returned
796  * - if the op is in progress, 0 will be returned
797  */
798 int cachefiles_write_page(struct fscache_storage *op, struct page *page)
799 {
800         struct cachefiles_object *object;
801         struct cachefiles_cache *cache;
802         mm_segment_t old_fs;
803         struct file *file;
804         loff_t pos;
805         void *data;
806         int ret;
807
808         ASSERT(op != NULL);
809         ASSERT(page != NULL);
810
811         object = container_of(op->op.object,
812                               struct cachefiles_object, fscache);
813
814         _enter("%p,%p{%lx},,,", object, page, page->index);
815
816         if (!object->backer) {
817                 _leave(" = -ENOBUFS");
818                 return -ENOBUFS;
819         }
820
821         ASSERT(S_ISREG(object->backer->d_inode->i_mode));
822
823         cache = container_of(object->fscache.cache,
824                              struct cachefiles_cache, cache);
825
826         /* write the page to the backing filesystem and let it store it in its
827          * own time */
828         dget(object->backer);
829         mntget(cache->mnt);
830         file = dentry_open(object->backer, cache->mnt, O_RDWR,
831                            cache->cache_cred);
832         if (IS_ERR(file)) {
833                 ret = PTR_ERR(file);
834         } else {
835                 ret = -EIO;
836                 if (file->f_op->write) {
837                         pos = (loff_t) page->index << PAGE_SHIFT;
838                         data = kmap(page);
839                         old_fs = get_fs();
840                         set_fs(KERNEL_DS);
841                         ret = file->f_op->write(
842                                 file, (const void __user *) data, PAGE_SIZE,
843                                 &pos);
844                         set_fs(old_fs);
845                         kunmap(page);
846                         if (ret != PAGE_SIZE)
847                                 ret = -EIO;
848                 }
849                 fput(file);
850         }
851
852         if (ret < 0) {
853                 if (ret == -EIO)
854                         cachefiles_io_error_obj(
855                                 object, "Write page to backing file failed");
856                 ret = -ENOBUFS;
857         }
858
859         _leave(" = %d", ret);
860         return ret;
861 }
862
863 /*
864  * detach a backing block from a page
865  * - cache withdrawal is prevented by the caller
866  */
867 void cachefiles_uncache_page(struct fscache_object *_object, struct page *page)
868 {
869         struct cachefiles_object *object;
870         struct cachefiles_cache *cache;
871
872         object = container_of(_object, struct cachefiles_object, fscache);
873         cache = container_of(object->fscache.cache,
874                              struct cachefiles_cache, cache);
875
876         _enter("%p,{%lu}", object, page->index);
877
878         spin_unlock(&object->fscache.cookie->lock);
879 }