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