ALSA: virtio: use module_virtio_driver() to simplify the code
[linux-2.6-microblaze.git] / mm / filemap.c
1 // SPDX-License-Identifier: GPL-2.0-only
2 /*
3  *      linux/mm/filemap.c
4  *
5  * Copyright (C) 1994-1999  Linus Torvalds
6  */
7
8 /*
9  * This file handles the generic file mmap semantics used by
10  * most "normal" filesystems (but you don't /have/ to use this:
11  * the NFS filesystem used to do this differently, for example)
12  */
13 #include <linux/export.h>
14 #include <linux/compiler.h>
15 #include <linux/dax.h>
16 #include <linux/fs.h>
17 #include <linux/sched/signal.h>
18 #include <linux/uaccess.h>
19 #include <linux/capability.h>
20 #include <linux/kernel_stat.h>
21 #include <linux/gfp.h>
22 #include <linux/mm.h>
23 #include <linux/swap.h>
24 #include <linux/mman.h>
25 #include <linux/pagemap.h>
26 #include <linux/file.h>
27 #include <linux/uio.h>
28 #include <linux/error-injection.h>
29 #include <linux/hash.h>
30 #include <linux/writeback.h>
31 #include <linux/backing-dev.h>
32 #include <linux/pagevec.h>
33 #include <linux/blkdev.h>
34 #include <linux/security.h>
35 #include <linux/cpuset.h>
36 #include <linux/hugetlb.h>
37 #include <linux/memcontrol.h>
38 #include <linux/cleancache.h>
39 #include <linux/shmem_fs.h>
40 #include <linux/rmap.h>
41 #include <linux/delayacct.h>
42 #include <linux/psi.h>
43 #include <linux/ramfs.h>
44 #include <linux/page_idle.h>
45 #include <asm/pgalloc.h>
46 #include <asm/tlbflush.h>
47 #include "internal.h"
48
49 #define CREATE_TRACE_POINTS
50 #include <trace/events/filemap.h>
51
52 /*
53  * FIXME: remove all knowledge of the buffer layer from the core VM
54  */
55 #include <linux/buffer_head.h> /* for try_to_free_buffers */
56
57 #include <asm/mman.h>
58
59 /*
60  * Shared mappings implemented 30.11.1994. It's not fully working yet,
61  * though.
62  *
63  * Shared mappings now work. 15.8.1995  Bruno.
64  *
65  * finished 'unifying' the page and buffer cache and SMP-threaded the
66  * page-cache, 21.05.1999, Ingo Molnar <mingo@redhat.com>
67  *
68  * SMP-threaded pagemap-LRU 1999, Andrea Arcangeli <andrea@suse.de>
69  */
70
71 /*
72  * Lock ordering:
73  *
74  *  ->i_mmap_rwsem              (truncate_pagecache)
75  *    ->private_lock            (__free_pte->__set_page_dirty_buffers)
76  *      ->swap_lock             (exclusive_swap_page, others)
77  *        ->i_pages lock
78  *
79  *  ->i_mutex
80  *    ->i_mmap_rwsem            (truncate->unmap_mapping_range)
81  *
82  *  ->mmap_lock
83  *    ->i_mmap_rwsem
84  *      ->page_table_lock or pte_lock   (various, mainly in memory.c)
85  *        ->i_pages lock        (arch-dependent flush_dcache_mmap_lock)
86  *
87  *  ->mmap_lock
88  *    ->lock_page               (access_process_vm)
89  *
90  *  ->i_mutex                   (generic_perform_write)
91  *    ->mmap_lock               (fault_in_pages_readable->do_page_fault)
92  *
93  *  bdi->wb.list_lock
94  *    sb_lock                   (fs/fs-writeback.c)
95  *    ->i_pages lock            (__sync_single_inode)
96  *
97  *  ->i_mmap_rwsem
98  *    ->anon_vma.lock           (vma_adjust)
99  *
100  *  ->anon_vma.lock
101  *    ->page_table_lock or pte_lock     (anon_vma_prepare and various)
102  *
103  *  ->page_table_lock or pte_lock
104  *    ->swap_lock               (try_to_unmap_one)
105  *    ->private_lock            (try_to_unmap_one)
106  *    ->i_pages lock            (try_to_unmap_one)
107  *    ->lruvec->lru_lock        (follow_page->mark_page_accessed)
108  *    ->lruvec->lru_lock        (check_pte_range->isolate_lru_page)
109  *    ->private_lock            (page_remove_rmap->set_page_dirty)
110  *    ->i_pages lock            (page_remove_rmap->set_page_dirty)
111  *    bdi.wb->list_lock         (page_remove_rmap->set_page_dirty)
112  *    ->inode->i_lock           (page_remove_rmap->set_page_dirty)
113  *    ->memcg->move_lock        (page_remove_rmap->lock_page_memcg)
114  *    bdi.wb->list_lock         (zap_pte_range->set_page_dirty)
115  *    ->inode->i_lock           (zap_pte_range->set_page_dirty)
116  *    ->private_lock            (zap_pte_range->__set_page_dirty_buffers)
117  *
118  * ->i_mmap_rwsem
119  *   ->tasklist_lock            (memory_failure, collect_procs_ao)
120  */
121
122 static void page_cache_delete(struct address_space *mapping,
123                                    struct page *page, void *shadow)
124 {
125         XA_STATE(xas, &mapping->i_pages, page->index);
126         unsigned int nr = 1;
127
128         mapping_set_update(&xas, mapping);
129
130         /* hugetlb pages are represented by a single entry in the xarray */
131         if (!PageHuge(page)) {
132                 xas_set_order(&xas, page->index, compound_order(page));
133                 nr = compound_nr(page);
134         }
135
136         VM_BUG_ON_PAGE(!PageLocked(page), page);
137         VM_BUG_ON_PAGE(PageTail(page), page);
138         VM_BUG_ON_PAGE(nr != 1 && shadow, page);
139
140         xas_store(&xas, shadow);
141         xas_init_marks(&xas);
142
143         page->mapping = NULL;
144         /* Leave page->index set: truncation lookup relies upon it */
145
146         if (shadow) {
147                 mapping->nrexceptional += nr;
148                 /*
149                  * Make sure the nrexceptional update is committed before
150                  * the nrpages update so that final truncate racing
151                  * with reclaim does not see both counters 0 at the
152                  * same time and miss a shadow entry.
153                  */
154                 smp_wmb();
155         }
156         mapping->nrpages -= nr;
157 }
158
159 static void unaccount_page_cache_page(struct address_space *mapping,
160                                       struct page *page)
161 {
162         int nr;
163
164         /*
165          * if we're uptodate, flush out into the cleancache, otherwise
166          * invalidate any existing cleancache entries.  We can't leave
167          * stale data around in the cleancache once our page is gone
168          */
169         if (PageUptodate(page) && PageMappedToDisk(page))
170                 cleancache_put_page(page);
171         else
172                 cleancache_invalidate_page(mapping, page);
173
174         VM_BUG_ON_PAGE(PageTail(page), page);
175         VM_BUG_ON_PAGE(page_mapped(page), page);
176         if (!IS_ENABLED(CONFIG_DEBUG_VM) && unlikely(page_mapped(page))) {
177                 int mapcount;
178
179                 pr_alert("BUG: Bad page cache in process %s  pfn:%05lx\n",
180                          current->comm, page_to_pfn(page));
181                 dump_page(page, "still mapped when deleted");
182                 dump_stack();
183                 add_taint(TAINT_BAD_PAGE, LOCKDEP_NOW_UNRELIABLE);
184
185                 mapcount = page_mapcount(page);
186                 if (mapping_exiting(mapping) &&
187                     page_count(page) >= mapcount + 2) {
188                         /*
189                          * All vmas have already been torn down, so it's
190                          * a good bet that actually the page is unmapped,
191                          * and we'd prefer not to leak it: if we're wrong,
192                          * some other bad page check should catch it later.
193                          */
194                         page_mapcount_reset(page);
195                         page_ref_sub(page, mapcount);
196                 }
197         }
198
199         /* hugetlb pages do not participate in page cache accounting. */
200         if (PageHuge(page))
201                 return;
202
203         nr = thp_nr_pages(page);
204
205         __mod_lruvec_page_state(page, NR_FILE_PAGES, -nr);
206         if (PageSwapBacked(page)) {
207                 __mod_lruvec_page_state(page, NR_SHMEM, -nr);
208                 if (PageTransHuge(page))
209                         __mod_lruvec_page_state(page, NR_SHMEM_THPS, -nr);
210         } else if (PageTransHuge(page)) {
211                 __mod_lruvec_page_state(page, NR_FILE_THPS, -nr);
212                 filemap_nr_thps_dec(mapping);
213         }
214
215         /*
216          * At this point page must be either written or cleaned by
217          * truncate.  Dirty page here signals a bug and loss of
218          * unwritten data.
219          *
220          * This fixes dirty accounting after removing the page entirely
221          * but leaves PageDirty set: it has no effect for truncated
222          * page and anyway will be cleared before returning page into
223          * buddy allocator.
224          */
225         if (WARN_ON_ONCE(PageDirty(page)))
226                 account_page_cleaned(page, mapping, inode_to_wb(mapping->host));
227 }
228
229 /*
230  * Delete a page from the page cache and free it. Caller has to make
231  * sure the page is locked and that nobody else uses it - or that usage
232  * is safe.  The caller must hold the i_pages lock.
233  */
234 void __delete_from_page_cache(struct page *page, void *shadow)
235 {
236         struct address_space *mapping = page->mapping;
237
238         trace_mm_filemap_delete_from_page_cache(page);
239
240         unaccount_page_cache_page(mapping, page);
241         page_cache_delete(mapping, page, shadow);
242 }
243
244 static void page_cache_free_page(struct address_space *mapping,
245                                 struct page *page)
246 {
247         void (*freepage)(struct page *);
248
249         freepage = mapping->a_ops->freepage;
250         if (freepage)
251                 freepage(page);
252
253         if (PageTransHuge(page) && !PageHuge(page)) {
254                 page_ref_sub(page, thp_nr_pages(page));
255                 VM_BUG_ON_PAGE(page_count(page) <= 0, page);
256         } else {
257                 put_page(page);
258         }
259 }
260
261 /**
262  * delete_from_page_cache - delete page from page cache
263  * @page: the page which the kernel is trying to remove from page cache
264  *
265  * This must be called only on pages that have been verified to be in the page
266  * cache and locked.  It will never put the page into the free list, the caller
267  * has a reference on the page.
268  */
269 void delete_from_page_cache(struct page *page)
270 {
271         struct address_space *mapping = page_mapping(page);
272         unsigned long flags;
273
274         BUG_ON(!PageLocked(page));
275         xa_lock_irqsave(&mapping->i_pages, flags);
276         __delete_from_page_cache(page, NULL);
277         xa_unlock_irqrestore(&mapping->i_pages, flags);
278
279         page_cache_free_page(mapping, page);
280 }
281 EXPORT_SYMBOL(delete_from_page_cache);
282
283 /*
284  * page_cache_delete_batch - delete several pages from page cache
285  * @mapping: the mapping to which pages belong
286  * @pvec: pagevec with pages to delete
287  *
288  * The function walks over mapping->i_pages and removes pages passed in @pvec
289  * from the mapping. The function expects @pvec to be sorted by page index
290  * and is optimised for it to be dense.
291  * It tolerates holes in @pvec (mapping entries at those indices are not
292  * modified). The function expects only THP head pages to be present in the
293  * @pvec.
294  *
295  * The function expects the i_pages lock to be held.
296  */
297 static void page_cache_delete_batch(struct address_space *mapping,
298                              struct pagevec *pvec)
299 {
300         XA_STATE(xas, &mapping->i_pages, pvec->pages[0]->index);
301         int total_pages = 0;
302         int i = 0;
303         struct page *page;
304
305         mapping_set_update(&xas, mapping);
306         xas_for_each(&xas, page, ULONG_MAX) {
307                 if (i >= pagevec_count(pvec))
308                         break;
309
310                 /* A swap/dax/shadow entry got inserted? Skip it. */
311                 if (xa_is_value(page))
312                         continue;
313                 /*
314                  * A page got inserted in our range? Skip it. We have our
315                  * pages locked so they are protected from being removed.
316                  * If we see a page whose index is higher than ours, it
317                  * means our page has been removed, which shouldn't be
318                  * possible because we're holding the PageLock.
319                  */
320                 if (page != pvec->pages[i]) {
321                         VM_BUG_ON_PAGE(page->index > pvec->pages[i]->index,
322                                         page);
323                         continue;
324                 }
325
326                 WARN_ON_ONCE(!PageLocked(page));
327
328                 if (page->index == xas.xa_index)
329                         page->mapping = NULL;
330                 /* Leave page->index set: truncation lookup relies on it */
331
332                 /*
333                  * Move to the next page in the vector if this is a regular
334                  * page or the index is of the last sub-page of this compound
335                  * page.
336                  */
337                 if (page->index + compound_nr(page) - 1 == xas.xa_index)
338                         i++;
339                 xas_store(&xas, NULL);
340                 total_pages++;
341         }
342         mapping->nrpages -= total_pages;
343 }
344
345 void delete_from_page_cache_batch(struct address_space *mapping,
346                                   struct pagevec *pvec)
347 {
348         int i;
349         unsigned long flags;
350
351         if (!pagevec_count(pvec))
352                 return;
353
354         xa_lock_irqsave(&mapping->i_pages, flags);
355         for (i = 0; i < pagevec_count(pvec); i++) {
356                 trace_mm_filemap_delete_from_page_cache(pvec->pages[i]);
357
358                 unaccount_page_cache_page(mapping, pvec->pages[i]);
359         }
360         page_cache_delete_batch(mapping, pvec);
361         xa_unlock_irqrestore(&mapping->i_pages, flags);
362
363         for (i = 0; i < pagevec_count(pvec); i++)
364                 page_cache_free_page(mapping, pvec->pages[i]);
365 }
366
367 int filemap_check_errors(struct address_space *mapping)
368 {
369         int ret = 0;
370         /* Check for outstanding write errors */
371         if (test_bit(AS_ENOSPC, &mapping->flags) &&
372             test_and_clear_bit(AS_ENOSPC, &mapping->flags))
373                 ret = -ENOSPC;
374         if (test_bit(AS_EIO, &mapping->flags) &&
375             test_and_clear_bit(AS_EIO, &mapping->flags))
376                 ret = -EIO;
377         return ret;
378 }
379 EXPORT_SYMBOL(filemap_check_errors);
380
381 static int filemap_check_and_keep_errors(struct address_space *mapping)
382 {
383         /* Check for outstanding write errors */
384         if (test_bit(AS_EIO, &mapping->flags))
385                 return -EIO;
386         if (test_bit(AS_ENOSPC, &mapping->flags))
387                 return -ENOSPC;
388         return 0;
389 }
390
391 /**
392  * __filemap_fdatawrite_range - start writeback on mapping dirty pages in range
393  * @mapping:    address space structure to write
394  * @start:      offset in bytes where the range starts
395  * @end:        offset in bytes where the range ends (inclusive)
396  * @sync_mode:  enable synchronous operation
397  *
398  * Start writeback against all of a mapping's dirty pages that lie
399  * within the byte offsets <start, end> inclusive.
400  *
401  * If sync_mode is WB_SYNC_ALL then this is a "data integrity" operation, as
402  * opposed to a regular memory cleansing writeback.  The difference between
403  * these two operations is that if a dirty page/buffer is encountered, it must
404  * be waited upon, and not just skipped over.
405  *
406  * Return: %0 on success, negative error code otherwise.
407  */
408 int __filemap_fdatawrite_range(struct address_space *mapping, loff_t start,
409                                 loff_t end, int sync_mode)
410 {
411         int ret;
412         struct writeback_control wbc = {
413                 .sync_mode = sync_mode,
414                 .nr_to_write = LONG_MAX,
415                 .range_start = start,
416                 .range_end = end,
417         };
418
419         if (!mapping_can_writeback(mapping) ||
420             !mapping_tagged(mapping, PAGECACHE_TAG_DIRTY))
421                 return 0;
422
423         wbc_attach_fdatawrite_inode(&wbc, mapping->host);
424         ret = do_writepages(mapping, &wbc);
425         wbc_detach_inode(&wbc);
426         return ret;
427 }
428
429 static inline int __filemap_fdatawrite(struct address_space *mapping,
430         int sync_mode)
431 {
432         return __filemap_fdatawrite_range(mapping, 0, LLONG_MAX, sync_mode);
433 }
434
435 int filemap_fdatawrite(struct address_space *mapping)
436 {
437         return __filemap_fdatawrite(mapping, WB_SYNC_ALL);
438 }
439 EXPORT_SYMBOL(filemap_fdatawrite);
440
441 int filemap_fdatawrite_range(struct address_space *mapping, loff_t start,
442                                 loff_t end)
443 {
444         return __filemap_fdatawrite_range(mapping, start, end, WB_SYNC_ALL);
445 }
446 EXPORT_SYMBOL(filemap_fdatawrite_range);
447
448 /**
449  * filemap_flush - mostly a non-blocking flush
450  * @mapping:    target address_space
451  *
452  * This is a mostly non-blocking flush.  Not suitable for data-integrity
453  * purposes - I/O may not be started against all dirty pages.
454  *
455  * Return: %0 on success, negative error code otherwise.
456  */
457 int filemap_flush(struct address_space *mapping)
458 {
459         return __filemap_fdatawrite(mapping, WB_SYNC_NONE);
460 }
461 EXPORT_SYMBOL(filemap_flush);
462
463 /**
464  * filemap_range_has_page - check if a page exists in range.
465  * @mapping:           address space within which to check
466  * @start_byte:        offset in bytes where the range starts
467  * @end_byte:          offset in bytes where the range ends (inclusive)
468  *
469  * Find at least one page in the range supplied, usually used to check if
470  * direct writing in this range will trigger a writeback.
471  *
472  * Return: %true if at least one page exists in the specified range,
473  * %false otherwise.
474  */
475 bool filemap_range_has_page(struct address_space *mapping,
476                            loff_t start_byte, loff_t end_byte)
477 {
478         struct page *page;
479         XA_STATE(xas, &mapping->i_pages, start_byte >> PAGE_SHIFT);
480         pgoff_t max = end_byte >> PAGE_SHIFT;
481
482         if (end_byte < start_byte)
483                 return false;
484
485         rcu_read_lock();
486         for (;;) {
487                 page = xas_find(&xas, max);
488                 if (xas_retry(&xas, page))
489                         continue;
490                 /* Shadow entries don't count */
491                 if (xa_is_value(page))
492                         continue;
493                 /*
494                  * We don't need to try to pin this page; we're about to
495                  * release the RCU lock anyway.  It is enough to know that
496                  * there was a page here recently.
497                  */
498                 break;
499         }
500         rcu_read_unlock();
501
502         return page != NULL;
503 }
504 EXPORT_SYMBOL(filemap_range_has_page);
505
506 static void __filemap_fdatawait_range(struct address_space *mapping,
507                                      loff_t start_byte, loff_t end_byte)
508 {
509         pgoff_t index = start_byte >> PAGE_SHIFT;
510         pgoff_t end = end_byte >> PAGE_SHIFT;
511         struct pagevec pvec;
512         int nr_pages;
513
514         if (end_byte < start_byte)
515                 return;
516
517         pagevec_init(&pvec);
518         while (index <= end) {
519                 unsigned i;
520
521                 nr_pages = pagevec_lookup_range_tag(&pvec, mapping, &index,
522                                 end, PAGECACHE_TAG_WRITEBACK);
523                 if (!nr_pages)
524                         break;
525
526                 for (i = 0; i < nr_pages; i++) {
527                         struct page *page = pvec.pages[i];
528
529                         wait_on_page_writeback(page);
530                         ClearPageError(page);
531                 }
532                 pagevec_release(&pvec);
533                 cond_resched();
534         }
535 }
536
537 /**
538  * filemap_fdatawait_range - wait for writeback to complete
539  * @mapping:            address space structure to wait for
540  * @start_byte:         offset in bytes where the range starts
541  * @end_byte:           offset in bytes where the range ends (inclusive)
542  *
543  * Walk the list of under-writeback pages of the given address space
544  * in the given range and wait for all of them.  Check error status of
545  * the address space and return it.
546  *
547  * Since the error status of the address space is cleared by this function,
548  * callers are responsible for checking the return value and handling and/or
549  * reporting the error.
550  *
551  * Return: error status of the address space.
552  */
553 int filemap_fdatawait_range(struct address_space *mapping, loff_t start_byte,
554                             loff_t end_byte)
555 {
556         __filemap_fdatawait_range(mapping, start_byte, end_byte);
557         return filemap_check_errors(mapping);
558 }
559 EXPORT_SYMBOL(filemap_fdatawait_range);
560
561 /**
562  * filemap_fdatawait_range_keep_errors - wait for writeback to complete
563  * @mapping:            address space structure to wait for
564  * @start_byte:         offset in bytes where the range starts
565  * @end_byte:           offset in bytes where the range ends (inclusive)
566  *
567  * Walk the list of under-writeback pages of the given address space in the
568  * given range and wait for all of them.  Unlike filemap_fdatawait_range(),
569  * this function does not clear error status of the address space.
570  *
571  * Use this function if callers don't handle errors themselves.  Expected
572  * call sites are system-wide / filesystem-wide data flushers: e.g. sync(2),
573  * fsfreeze(8)
574  */
575 int filemap_fdatawait_range_keep_errors(struct address_space *mapping,
576                 loff_t start_byte, loff_t end_byte)
577 {
578         __filemap_fdatawait_range(mapping, start_byte, end_byte);
579         return filemap_check_and_keep_errors(mapping);
580 }
581 EXPORT_SYMBOL(filemap_fdatawait_range_keep_errors);
582
583 /**
584  * file_fdatawait_range - wait for writeback to complete
585  * @file:               file pointing to address space structure to wait for
586  * @start_byte:         offset in bytes where the range starts
587  * @end_byte:           offset in bytes where the range ends (inclusive)
588  *
589  * Walk the list of under-writeback pages of the address space that file
590  * refers to, in the given range and wait for all of them.  Check error
591  * status of the address space vs. the file->f_wb_err cursor and return it.
592  *
593  * Since the error status of the file is advanced by this function,
594  * callers are responsible for checking the return value and handling and/or
595  * reporting the error.
596  *
597  * Return: error status of the address space vs. the file->f_wb_err cursor.
598  */
599 int file_fdatawait_range(struct file *file, loff_t start_byte, loff_t end_byte)
600 {
601         struct address_space *mapping = file->f_mapping;
602
603         __filemap_fdatawait_range(mapping, start_byte, end_byte);
604         return file_check_and_advance_wb_err(file);
605 }
606 EXPORT_SYMBOL(file_fdatawait_range);
607
608 /**
609  * filemap_fdatawait_keep_errors - wait for writeback without clearing errors
610  * @mapping: address space structure to wait for
611  *
612  * Walk the list of under-writeback pages of the given address space
613  * and wait for all of them.  Unlike filemap_fdatawait(), this function
614  * does not clear error status of the address space.
615  *
616  * Use this function if callers don't handle errors themselves.  Expected
617  * call sites are system-wide / filesystem-wide data flushers: e.g. sync(2),
618  * fsfreeze(8)
619  *
620  * Return: error status of the address space.
621  */
622 int filemap_fdatawait_keep_errors(struct address_space *mapping)
623 {
624         __filemap_fdatawait_range(mapping, 0, LLONG_MAX);
625         return filemap_check_and_keep_errors(mapping);
626 }
627 EXPORT_SYMBOL(filemap_fdatawait_keep_errors);
628
629 /* Returns true if writeback might be needed or already in progress. */
630 static bool mapping_needs_writeback(struct address_space *mapping)
631 {
632         if (dax_mapping(mapping))
633                 return mapping->nrexceptional;
634
635         return mapping->nrpages;
636 }
637
638 /**
639  * filemap_write_and_wait_range - write out & wait on a file range
640  * @mapping:    the address_space for the pages
641  * @lstart:     offset in bytes where the range starts
642  * @lend:       offset in bytes where the range ends (inclusive)
643  *
644  * Write out and wait upon file offsets lstart->lend, inclusive.
645  *
646  * Note that @lend is inclusive (describes the last byte to be written) so
647  * that this function can be used to write to the very end-of-file (end = -1).
648  *
649  * Return: error status of the address space.
650  */
651 int filemap_write_and_wait_range(struct address_space *mapping,
652                                  loff_t lstart, loff_t lend)
653 {
654         int err = 0;
655
656         if (mapping_needs_writeback(mapping)) {
657                 err = __filemap_fdatawrite_range(mapping, lstart, lend,
658                                                  WB_SYNC_ALL);
659                 /*
660                  * Even if the above returned error, the pages may be
661                  * written partially (e.g. -ENOSPC), so we wait for it.
662                  * But the -EIO is special case, it may indicate the worst
663                  * thing (e.g. bug) happened, so we avoid waiting for it.
664                  */
665                 if (err != -EIO) {
666                         int err2 = filemap_fdatawait_range(mapping,
667                                                 lstart, lend);
668                         if (!err)
669                                 err = err2;
670                 } else {
671                         /* Clear any previously stored errors */
672                         filemap_check_errors(mapping);
673                 }
674         } else {
675                 err = filemap_check_errors(mapping);
676         }
677         return err;
678 }
679 EXPORT_SYMBOL(filemap_write_and_wait_range);
680
681 void __filemap_set_wb_err(struct address_space *mapping, int err)
682 {
683         errseq_t eseq = errseq_set(&mapping->wb_err, err);
684
685         trace_filemap_set_wb_err(mapping, eseq);
686 }
687 EXPORT_SYMBOL(__filemap_set_wb_err);
688
689 /**
690  * file_check_and_advance_wb_err - report wb error (if any) that was previously
691  *                                 and advance wb_err to current one
692  * @file: struct file on which the error is being reported
693  *
694  * When userland calls fsync (or something like nfsd does the equivalent), we
695  * want to report any writeback errors that occurred since the last fsync (or
696  * since the file was opened if there haven't been any).
697  *
698  * Grab the wb_err from the mapping. If it matches what we have in the file,
699  * then just quickly return 0. The file is all caught up.
700  *
701  * If it doesn't match, then take the mapping value, set the "seen" flag in
702  * it and try to swap it into place. If it works, or another task beat us
703  * to it with the new value, then update the f_wb_err and return the error
704  * portion. The error at this point must be reported via proper channels
705  * (a'la fsync, or NFS COMMIT operation, etc.).
706  *
707  * While we handle mapping->wb_err with atomic operations, the f_wb_err
708  * value is protected by the f_lock since we must ensure that it reflects
709  * the latest value swapped in for this file descriptor.
710  *
711  * Return: %0 on success, negative error code otherwise.
712  */
713 int file_check_and_advance_wb_err(struct file *file)
714 {
715         int err = 0;
716         errseq_t old = READ_ONCE(file->f_wb_err);
717         struct address_space *mapping = file->f_mapping;
718
719         /* Locklessly handle the common case where nothing has changed */
720         if (errseq_check(&mapping->wb_err, old)) {
721                 /* Something changed, must use slow path */
722                 spin_lock(&file->f_lock);
723                 old = file->f_wb_err;
724                 err = errseq_check_and_advance(&mapping->wb_err,
725                                                 &file->f_wb_err);
726                 trace_file_check_and_advance_wb_err(file, old);
727                 spin_unlock(&file->f_lock);
728         }
729
730         /*
731          * We're mostly using this function as a drop in replacement for
732          * filemap_check_errors. Clear AS_EIO/AS_ENOSPC to emulate the effect
733          * that the legacy code would have had on these flags.
734          */
735         clear_bit(AS_EIO, &mapping->flags);
736         clear_bit(AS_ENOSPC, &mapping->flags);
737         return err;
738 }
739 EXPORT_SYMBOL(file_check_and_advance_wb_err);
740
741 /**
742  * file_write_and_wait_range - write out & wait on a file range
743  * @file:       file pointing to address_space with pages
744  * @lstart:     offset in bytes where the range starts
745  * @lend:       offset in bytes where the range ends (inclusive)
746  *
747  * Write out and wait upon file offsets lstart->lend, inclusive.
748  *
749  * Note that @lend is inclusive (describes the last byte to be written) so
750  * that this function can be used to write to the very end-of-file (end = -1).
751  *
752  * After writing out and waiting on the data, we check and advance the
753  * f_wb_err cursor to the latest value, and return any errors detected there.
754  *
755  * Return: %0 on success, negative error code otherwise.
756  */
757 int file_write_and_wait_range(struct file *file, loff_t lstart, loff_t lend)
758 {
759         int err = 0, err2;
760         struct address_space *mapping = file->f_mapping;
761
762         if (mapping_needs_writeback(mapping)) {
763                 err = __filemap_fdatawrite_range(mapping, lstart, lend,
764                                                  WB_SYNC_ALL);
765                 /* See comment of filemap_write_and_wait() */
766                 if (err != -EIO)
767                         __filemap_fdatawait_range(mapping, lstart, lend);
768         }
769         err2 = file_check_and_advance_wb_err(file);
770         if (!err)
771                 err = err2;
772         return err;
773 }
774 EXPORT_SYMBOL(file_write_and_wait_range);
775
776 /**
777  * replace_page_cache_page - replace a pagecache page with a new one
778  * @old:        page to be replaced
779  * @new:        page to replace with
780  *
781  * This function replaces a page in the pagecache with a new one.  On
782  * success it acquires the pagecache reference for the new page and
783  * drops it for the old page.  Both the old and new pages must be
784  * locked.  This function does not add the new page to the LRU, the
785  * caller must do that.
786  *
787  * The remove + add is atomic.  This function cannot fail.
788  */
789 void replace_page_cache_page(struct page *old, struct page *new)
790 {
791         struct address_space *mapping = old->mapping;
792         void (*freepage)(struct page *) = mapping->a_ops->freepage;
793         pgoff_t offset = old->index;
794         XA_STATE(xas, &mapping->i_pages, offset);
795         unsigned long flags;
796
797         VM_BUG_ON_PAGE(!PageLocked(old), old);
798         VM_BUG_ON_PAGE(!PageLocked(new), new);
799         VM_BUG_ON_PAGE(new->mapping, new);
800
801         get_page(new);
802         new->mapping = mapping;
803         new->index = offset;
804
805         mem_cgroup_migrate(old, new);
806
807         xas_lock_irqsave(&xas, flags);
808         xas_store(&xas, new);
809
810         old->mapping = NULL;
811         /* hugetlb pages do not participate in page cache accounting. */
812         if (!PageHuge(old))
813                 __dec_lruvec_page_state(old, NR_FILE_PAGES);
814         if (!PageHuge(new))
815                 __inc_lruvec_page_state(new, NR_FILE_PAGES);
816         if (PageSwapBacked(old))
817                 __dec_lruvec_page_state(old, NR_SHMEM);
818         if (PageSwapBacked(new))
819                 __inc_lruvec_page_state(new, NR_SHMEM);
820         xas_unlock_irqrestore(&xas, flags);
821         if (freepage)
822                 freepage(old);
823         put_page(old);
824 }
825 EXPORT_SYMBOL_GPL(replace_page_cache_page);
826
827 noinline int __add_to_page_cache_locked(struct page *page,
828                                         struct address_space *mapping,
829                                         pgoff_t offset, gfp_t gfp,
830                                         void **shadowp)
831 {
832         XA_STATE(xas, &mapping->i_pages, offset);
833         int huge = PageHuge(page);
834         int error;
835         bool charged = false;
836
837         VM_BUG_ON_PAGE(!PageLocked(page), page);
838         VM_BUG_ON_PAGE(PageSwapBacked(page), page);
839         mapping_set_update(&xas, mapping);
840
841         get_page(page);
842         page->mapping = mapping;
843         page->index = offset;
844
845         if (!huge) {
846                 error = mem_cgroup_charge(page, current->mm, gfp);
847                 if (error)
848                         goto error;
849                 charged = true;
850         }
851
852         gfp &= GFP_RECLAIM_MASK;
853
854         do {
855                 unsigned int order = xa_get_order(xas.xa, xas.xa_index);
856                 void *entry, *old = NULL;
857
858                 if (order > thp_order(page))
859                         xas_split_alloc(&xas, xa_load(xas.xa, xas.xa_index),
860                                         order, gfp);
861                 xas_lock_irq(&xas);
862                 xas_for_each_conflict(&xas, entry) {
863                         old = entry;
864                         if (!xa_is_value(entry)) {
865                                 xas_set_err(&xas, -EEXIST);
866                                 goto unlock;
867                         }
868                 }
869
870                 if (old) {
871                         if (shadowp)
872                                 *shadowp = old;
873                         /* entry may have been split before we acquired lock */
874                         order = xa_get_order(xas.xa, xas.xa_index);
875                         if (order > thp_order(page)) {
876                                 xas_split(&xas, old, order);
877                                 xas_reset(&xas);
878                         }
879                 }
880
881                 xas_store(&xas, page);
882                 if (xas_error(&xas))
883                         goto unlock;
884
885                 if (old)
886                         mapping->nrexceptional--;
887                 mapping->nrpages++;
888
889                 /* hugetlb pages do not participate in page cache accounting */
890                 if (!huge)
891                         __inc_lruvec_page_state(page, NR_FILE_PAGES);
892 unlock:
893                 xas_unlock_irq(&xas);
894         } while (xas_nomem(&xas, gfp));
895
896         if (xas_error(&xas)) {
897                 error = xas_error(&xas);
898                 if (charged)
899                         mem_cgroup_uncharge(page);
900                 goto error;
901         }
902
903         trace_mm_filemap_add_to_page_cache(page);
904         return 0;
905 error:
906         page->mapping = NULL;
907         /* Leave page->index set: truncation relies upon it */
908         put_page(page);
909         return error;
910 }
911 ALLOW_ERROR_INJECTION(__add_to_page_cache_locked, ERRNO);
912
913 /**
914  * add_to_page_cache_locked - add a locked page to the pagecache
915  * @page:       page to add
916  * @mapping:    the page's address_space
917  * @offset:     page index
918  * @gfp_mask:   page allocation mode
919  *
920  * This function is used to add a page to the pagecache. It must be locked.
921  * This function does not add the page to the LRU.  The caller must do that.
922  *
923  * Return: %0 on success, negative error code otherwise.
924  */
925 int add_to_page_cache_locked(struct page *page, struct address_space *mapping,
926                 pgoff_t offset, gfp_t gfp_mask)
927 {
928         return __add_to_page_cache_locked(page, mapping, offset,
929                                           gfp_mask, NULL);
930 }
931 EXPORT_SYMBOL(add_to_page_cache_locked);
932
933 int add_to_page_cache_lru(struct page *page, struct address_space *mapping,
934                                 pgoff_t offset, gfp_t gfp_mask)
935 {
936         void *shadow = NULL;
937         int ret;
938
939         __SetPageLocked(page);
940         ret = __add_to_page_cache_locked(page, mapping, offset,
941                                          gfp_mask, &shadow);
942         if (unlikely(ret))
943                 __ClearPageLocked(page);
944         else {
945                 /*
946                  * The page might have been evicted from cache only
947                  * recently, in which case it should be activated like
948                  * any other repeatedly accessed page.
949                  * The exception is pages getting rewritten; evicting other
950                  * data from the working set, only to cache data that will
951                  * get overwritten with something else, is a waste of memory.
952                  */
953                 WARN_ON_ONCE(PageActive(page));
954                 if (!(gfp_mask & __GFP_WRITE) && shadow)
955                         workingset_refault(page, shadow);
956                 lru_cache_add(page);
957         }
958         return ret;
959 }
960 EXPORT_SYMBOL_GPL(add_to_page_cache_lru);
961
962 #ifdef CONFIG_NUMA
963 struct page *__page_cache_alloc(gfp_t gfp)
964 {
965         int n;
966         struct page *page;
967
968         if (cpuset_do_page_mem_spread()) {
969                 unsigned int cpuset_mems_cookie;
970                 do {
971                         cpuset_mems_cookie = read_mems_allowed_begin();
972                         n = cpuset_mem_spread_node();
973                         page = __alloc_pages_node(n, gfp, 0);
974                 } while (!page && read_mems_allowed_retry(cpuset_mems_cookie));
975
976                 return page;
977         }
978         return alloc_pages(gfp, 0);
979 }
980 EXPORT_SYMBOL(__page_cache_alloc);
981 #endif
982
983 /*
984  * In order to wait for pages to become available there must be
985  * waitqueues associated with pages. By using a hash table of
986  * waitqueues where the bucket discipline is to maintain all
987  * waiters on the same queue and wake all when any of the pages
988  * become available, and for the woken contexts to check to be
989  * sure the appropriate page became available, this saves space
990  * at a cost of "thundering herd" phenomena during rare hash
991  * collisions.
992  */
993 #define PAGE_WAIT_TABLE_BITS 8
994 #define PAGE_WAIT_TABLE_SIZE (1 << PAGE_WAIT_TABLE_BITS)
995 static wait_queue_head_t page_wait_table[PAGE_WAIT_TABLE_SIZE] __cacheline_aligned;
996
997 static wait_queue_head_t *page_waitqueue(struct page *page)
998 {
999         return &page_wait_table[hash_ptr(page, PAGE_WAIT_TABLE_BITS)];
1000 }
1001
1002 void __init pagecache_init(void)
1003 {
1004         int i;
1005
1006         for (i = 0; i < PAGE_WAIT_TABLE_SIZE; i++)
1007                 init_waitqueue_head(&page_wait_table[i]);
1008
1009         page_writeback_init();
1010 }
1011
1012 /*
1013  * The page wait code treats the "wait->flags" somewhat unusually, because
1014  * we have multiple different kinds of waits, not just the usual "exclusive"
1015  * one.
1016  *
1017  * We have:
1018  *
1019  *  (a) no special bits set:
1020  *
1021  *      We're just waiting for the bit to be released, and when a waker
1022  *      calls the wakeup function, we set WQ_FLAG_WOKEN and wake it up,
1023  *      and remove it from the wait queue.
1024  *
1025  *      Simple and straightforward.
1026  *
1027  *  (b) WQ_FLAG_EXCLUSIVE:
1028  *
1029  *      The waiter is waiting to get the lock, and only one waiter should
1030  *      be woken up to avoid any thundering herd behavior. We'll set the
1031  *      WQ_FLAG_WOKEN bit, wake it up, and remove it from the wait queue.
1032  *
1033  *      This is the traditional exclusive wait.
1034  *
1035  *  (c) WQ_FLAG_EXCLUSIVE | WQ_FLAG_CUSTOM:
1036  *
1037  *      The waiter is waiting to get the bit, and additionally wants the
1038  *      lock to be transferred to it for fair lock behavior. If the lock
1039  *      cannot be taken, we stop walking the wait queue without waking
1040  *      the waiter.
1041  *
1042  *      This is the "fair lock handoff" case, and in addition to setting
1043  *      WQ_FLAG_WOKEN, we set WQ_FLAG_DONE to let the waiter easily see
1044  *      that it now has the lock.
1045  */
1046 static int wake_page_function(wait_queue_entry_t *wait, unsigned mode, int sync, void *arg)
1047 {
1048         unsigned int flags;
1049         struct wait_page_key *key = arg;
1050         struct wait_page_queue *wait_page
1051                 = container_of(wait, struct wait_page_queue, wait);
1052
1053         if (!wake_page_match(wait_page, key))
1054                 return 0;
1055
1056         /*
1057          * If it's a lock handoff wait, we get the bit for it, and
1058          * stop walking (and do not wake it up) if we can't.
1059          */
1060         flags = wait->flags;
1061         if (flags & WQ_FLAG_EXCLUSIVE) {
1062                 if (test_bit(key->bit_nr, &key->page->flags))
1063                         return -1;
1064                 if (flags & WQ_FLAG_CUSTOM) {
1065                         if (test_and_set_bit(key->bit_nr, &key->page->flags))
1066                                 return -1;
1067                         flags |= WQ_FLAG_DONE;
1068                 }
1069         }
1070
1071         /*
1072          * We are holding the wait-queue lock, but the waiter that
1073          * is waiting for this will be checking the flags without
1074          * any locking.
1075          *
1076          * So update the flags atomically, and wake up the waiter
1077          * afterwards to avoid any races. This store-release pairs
1078          * with the load-acquire in wait_on_page_bit_common().
1079          */
1080         smp_store_release(&wait->flags, flags | WQ_FLAG_WOKEN);
1081         wake_up_state(wait->private, mode);
1082
1083         /*
1084          * Ok, we have successfully done what we're waiting for,
1085          * and we can unconditionally remove the wait entry.
1086          *
1087          * Note that this pairs with the "finish_wait()" in the
1088          * waiter, and has to be the absolute last thing we do.
1089          * After this list_del_init(&wait->entry) the wait entry
1090          * might be de-allocated and the process might even have
1091          * exited.
1092          */
1093         list_del_init_careful(&wait->entry);
1094         return (flags & WQ_FLAG_EXCLUSIVE) != 0;
1095 }
1096
1097 static void wake_up_page_bit(struct page *page, int bit_nr)
1098 {
1099         wait_queue_head_t *q = page_waitqueue(page);
1100         struct wait_page_key key;
1101         unsigned long flags;
1102         wait_queue_entry_t bookmark;
1103
1104         key.page = page;
1105         key.bit_nr = bit_nr;
1106         key.page_match = 0;
1107
1108         bookmark.flags = 0;
1109         bookmark.private = NULL;
1110         bookmark.func = NULL;
1111         INIT_LIST_HEAD(&bookmark.entry);
1112
1113         spin_lock_irqsave(&q->lock, flags);
1114         __wake_up_locked_key_bookmark(q, TASK_NORMAL, &key, &bookmark);
1115
1116         while (bookmark.flags & WQ_FLAG_BOOKMARK) {
1117                 /*
1118                  * Take a breather from holding the lock,
1119                  * allow pages that finish wake up asynchronously
1120                  * to acquire the lock and remove themselves
1121                  * from wait queue
1122                  */
1123                 spin_unlock_irqrestore(&q->lock, flags);
1124                 cpu_relax();
1125                 spin_lock_irqsave(&q->lock, flags);
1126                 __wake_up_locked_key_bookmark(q, TASK_NORMAL, &key, &bookmark);
1127         }
1128
1129         /*
1130          * It is possible for other pages to have collided on the waitqueue
1131          * hash, so in that case check for a page match. That prevents a long-
1132          * term waiter
1133          *
1134          * It is still possible to miss a case here, when we woke page waiters
1135          * and removed them from the waitqueue, but there are still other
1136          * page waiters.
1137          */
1138         if (!waitqueue_active(q) || !key.page_match) {
1139                 ClearPageWaiters(page);
1140                 /*
1141                  * It's possible to miss clearing Waiters here, when we woke
1142                  * our page waiters, but the hashed waitqueue has waiters for
1143                  * other pages on it.
1144                  *
1145                  * That's okay, it's a rare case. The next waker will clear it.
1146                  */
1147         }
1148         spin_unlock_irqrestore(&q->lock, flags);
1149 }
1150
1151 static void wake_up_page(struct page *page, int bit)
1152 {
1153         if (!PageWaiters(page))
1154                 return;
1155         wake_up_page_bit(page, bit);
1156 }
1157
1158 /*
1159  * A choice of three behaviors for wait_on_page_bit_common():
1160  */
1161 enum behavior {
1162         EXCLUSIVE,      /* Hold ref to page and take the bit when woken, like
1163                          * __lock_page() waiting on then setting PG_locked.
1164                          */
1165         SHARED,         /* Hold ref to page and check the bit when woken, like
1166                          * wait_on_page_writeback() waiting on PG_writeback.
1167                          */
1168         DROP,           /* Drop ref to page before wait, no check when woken,
1169                          * like put_and_wait_on_page_locked() on PG_locked.
1170                          */
1171 };
1172
1173 /*
1174  * Attempt to check (or get) the page bit, and mark us done
1175  * if successful.
1176  */
1177 static inline bool trylock_page_bit_common(struct page *page, int bit_nr,
1178                                         struct wait_queue_entry *wait)
1179 {
1180         if (wait->flags & WQ_FLAG_EXCLUSIVE) {
1181                 if (test_and_set_bit(bit_nr, &page->flags))
1182                         return false;
1183         } else if (test_bit(bit_nr, &page->flags))
1184                 return false;
1185
1186         wait->flags |= WQ_FLAG_WOKEN | WQ_FLAG_DONE;
1187         return true;
1188 }
1189
1190 /* How many times do we accept lock stealing from under a waiter? */
1191 int sysctl_page_lock_unfairness = 5;
1192
1193 static inline int wait_on_page_bit_common(wait_queue_head_t *q,
1194         struct page *page, int bit_nr, int state, enum behavior behavior)
1195 {
1196         int unfairness = sysctl_page_lock_unfairness;
1197         struct wait_page_queue wait_page;
1198         wait_queue_entry_t *wait = &wait_page.wait;
1199         bool thrashing = false;
1200         bool delayacct = false;
1201         unsigned long pflags;
1202
1203         if (bit_nr == PG_locked &&
1204             !PageUptodate(page) && PageWorkingset(page)) {
1205                 if (!PageSwapBacked(page)) {
1206                         delayacct_thrashing_start();
1207                         delayacct = true;
1208                 }
1209                 psi_memstall_enter(&pflags);
1210                 thrashing = true;
1211         }
1212
1213         init_wait(wait);
1214         wait->func = wake_page_function;
1215         wait_page.page = page;
1216         wait_page.bit_nr = bit_nr;
1217
1218 repeat:
1219         wait->flags = 0;
1220         if (behavior == EXCLUSIVE) {
1221                 wait->flags = WQ_FLAG_EXCLUSIVE;
1222                 if (--unfairness < 0)
1223                         wait->flags |= WQ_FLAG_CUSTOM;
1224         }
1225
1226         /*
1227          * Do one last check whether we can get the
1228          * page bit synchronously.
1229          *
1230          * Do the SetPageWaiters() marking before that
1231          * to let any waker we _just_ missed know they
1232          * need to wake us up (otherwise they'll never
1233          * even go to the slow case that looks at the
1234          * page queue), and add ourselves to the wait
1235          * queue if we need to sleep.
1236          *
1237          * This part needs to be done under the queue
1238          * lock to avoid races.
1239          */
1240         spin_lock_irq(&q->lock);
1241         SetPageWaiters(page);
1242         if (!trylock_page_bit_common(page, bit_nr, wait))
1243                 __add_wait_queue_entry_tail(q, wait);
1244         spin_unlock_irq(&q->lock);
1245
1246         /*
1247          * From now on, all the logic will be based on
1248          * the WQ_FLAG_WOKEN and WQ_FLAG_DONE flag, to
1249          * see whether the page bit testing has already
1250          * been done by the wake function.
1251          *
1252          * We can drop our reference to the page.
1253          */
1254         if (behavior == DROP)
1255                 put_page(page);
1256
1257         /*
1258          * Note that until the "finish_wait()", or until
1259          * we see the WQ_FLAG_WOKEN flag, we need to
1260          * be very careful with the 'wait->flags', because
1261          * we may race with a waker that sets them.
1262          */
1263         for (;;) {
1264                 unsigned int flags;
1265
1266                 set_current_state(state);
1267
1268                 /* Loop until we've been woken or interrupted */
1269                 flags = smp_load_acquire(&wait->flags);
1270                 if (!(flags & WQ_FLAG_WOKEN)) {
1271                         if (signal_pending_state(state, current))
1272                                 break;
1273
1274                         io_schedule();
1275                         continue;
1276                 }
1277
1278                 /* If we were non-exclusive, we're done */
1279                 if (behavior != EXCLUSIVE)
1280                         break;
1281
1282                 /* If the waker got the lock for us, we're done */
1283                 if (flags & WQ_FLAG_DONE)
1284                         break;
1285
1286                 /*
1287                  * Otherwise, if we're getting the lock, we need to
1288                  * try to get it ourselves.
1289                  *
1290                  * And if that fails, we'll have to retry this all.
1291                  */
1292                 if (unlikely(test_and_set_bit(bit_nr, &page->flags)))
1293                         goto repeat;
1294
1295                 wait->flags |= WQ_FLAG_DONE;
1296                 break;
1297         }
1298
1299         /*
1300          * If a signal happened, this 'finish_wait()' may remove the last
1301          * waiter from the wait-queues, but the PageWaiters bit will remain
1302          * set. That's ok. The next wakeup will take care of it, and trying
1303          * to do it here would be difficult and prone to races.
1304          */
1305         finish_wait(q, wait);
1306
1307         if (thrashing) {
1308                 if (delayacct)
1309                         delayacct_thrashing_end();
1310                 psi_memstall_leave(&pflags);
1311         }
1312
1313         /*
1314          * NOTE! The wait->flags weren't stable until we've done the
1315          * 'finish_wait()', and we could have exited the loop above due
1316          * to a signal, and had a wakeup event happen after the signal
1317          * test but before the 'finish_wait()'.
1318          *
1319          * So only after the finish_wait() can we reliably determine
1320          * if we got woken up or not, so we can now figure out the final
1321          * return value based on that state without races.
1322          *
1323          * Also note that WQ_FLAG_WOKEN is sufficient for a non-exclusive
1324          * waiter, but an exclusive one requires WQ_FLAG_DONE.
1325          */
1326         if (behavior == EXCLUSIVE)
1327                 return wait->flags & WQ_FLAG_DONE ? 0 : -EINTR;
1328
1329         return wait->flags & WQ_FLAG_WOKEN ? 0 : -EINTR;
1330 }
1331
1332 void wait_on_page_bit(struct page *page, int bit_nr)
1333 {
1334         wait_queue_head_t *q = page_waitqueue(page);
1335         wait_on_page_bit_common(q, page, bit_nr, TASK_UNINTERRUPTIBLE, SHARED);
1336 }
1337 EXPORT_SYMBOL(wait_on_page_bit);
1338
1339 int wait_on_page_bit_killable(struct page *page, int bit_nr)
1340 {
1341         wait_queue_head_t *q = page_waitqueue(page);
1342         return wait_on_page_bit_common(q, page, bit_nr, TASK_KILLABLE, SHARED);
1343 }
1344 EXPORT_SYMBOL(wait_on_page_bit_killable);
1345
1346 /**
1347  * put_and_wait_on_page_locked - Drop a reference and wait for it to be unlocked
1348  * @page: The page to wait for.
1349  * @state: The sleep state (TASK_KILLABLE, TASK_UNINTERRUPTIBLE, etc).
1350  *
1351  * The caller should hold a reference on @page.  They expect the page to
1352  * become unlocked relatively soon, but do not wish to hold up migration
1353  * (for example) by holding the reference while waiting for the page to
1354  * come unlocked.  After this function returns, the caller should not
1355  * dereference @page.
1356  *
1357  * Return: 0 if the page was unlocked or -EINTR if interrupted by a signal.
1358  */
1359 int put_and_wait_on_page_locked(struct page *page, int state)
1360 {
1361         wait_queue_head_t *q;
1362
1363         page = compound_head(page);
1364         q = page_waitqueue(page);
1365         return wait_on_page_bit_common(q, page, PG_locked, state, DROP);
1366 }
1367
1368 /**
1369  * add_page_wait_queue - Add an arbitrary waiter to a page's wait queue
1370  * @page: Page defining the wait queue of interest
1371  * @waiter: Waiter to add to the queue
1372  *
1373  * Add an arbitrary @waiter to the wait queue for the nominated @page.
1374  */
1375 void add_page_wait_queue(struct page *page, wait_queue_entry_t *waiter)
1376 {
1377         wait_queue_head_t *q = page_waitqueue(page);
1378         unsigned long flags;
1379
1380         spin_lock_irqsave(&q->lock, flags);
1381         __add_wait_queue_entry_tail(q, waiter);
1382         SetPageWaiters(page);
1383         spin_unlock_irqrestore(&q->lock, flags);
1384 }
1385 EXPORT_SYMBOL_GPL(add_page_wait_queue);
1386
1387 #ifndef clear_bit_unlock_is_negative_byte
1388
1389 /*
1390  * PG_waiters is the high bit in the same byte as PG_lock.
1391  *
1392  * On x86 (and on many other architectures), we can clear PG_lock and
1393  * test the sign bit at the same time. But if the architecture does
1394  * not support that special operation, we just do this all by hand
1395  * instead.
1396  *
1397  * The read of PG_waiters has to be after (or concurrently with) PG_locked
1398  * being cleared, but a memory barrier should be unnecessary since it is
1399  * in the same byte as PG_locked.
1400  */
1401 static inline bool clear_bit_unlock_is_negative_byte(long nr, volatile void *mem)
1402 {
1403         clear_bit_unlock(nr, mem);
1404         /* smp_mb__after_atomic(); */
1405         return test_bit(PG_waiters, mem);
1406 }
1407
1408 #endif
1409
1410 /**
1411  * unlock_page - unlock a locked page
1412  * @page: the page
1413  *
1414  * Unlocks the page and wakes up sleepers in wait_on_page_locked().
1415  * Also wakes sleepers in wait_on_page_writeback() because the wakeup
1416  * mechanism between PageLocked pages and PageWriteback pages is shared.
1417  * But that's OK - sleepers in wait_on_page_writeback() just go back to sleep.
1418  *
1419  * Note that this depends on PG_waiters being the sign bit in the byte
1420  * that contains PG_locked - thus the BUILD_BUG_ON(). That allows us to
1421  * clear the PG_locked bit and test PG_waiters at the same time fairly
1422  * portably (architectures that do LL/SC can test any bit, while x86 can
1423  * test the sign bit).
1424  */
1425 void unlock_page(struct page *page)
1426 {
1427         BUILD_BUG_ON(PG_waiters != 7);
1428         page = compound_head(page);
1429         VM_BUG_ON_PAGE(!PageLocked(page), page);
1430         if (clear_bit_unlock_is_negative_byte(PG_locked, &page->flags))
1431                 wake_up_page_bit(page, PG_locked);
1432 }
1433 EXPORT_SYMBOL(unlock_page);
1434
1435 /**
1436  * end_page_writeback - end writeback against a page
1437  * @page: the page
1438  */
1439 void end_page_writeback(struct page *page)
1440 {
1441         /*
1442          * TestClearPageReclaim could be used here but it is an atomic
1443          * operation and overkill in this particular case. Failing to
1444          * shuffle a page marked for immediate reclaim is too mild to
1445          * justify taking an atomic operation penalty at the end of
1446          * ever page writeback.
1447          */
1448         if (PageReclaim(page)) {
1449                 ClearPageReclaim(page);
1450                 rotate_reclaimable_page(page);
1451         }
1452
1453         /*
1454          * Writeback does not hold a page reference of its own, relying
1455          * on truncation to wait for the clearing of PG_writeback.
1456          * But here we must make sure that the page is not freed and
1457          * reused before the wake_up_page().
1458          */
1459         get_page(page);
1460         if (!test_clear_page_writeback(page))
1461                 BUG();
1462
1463         smp_mb__after_atomic();
1464         wake_up_page(page, PG_writeback);
1465         put_page(page);
1466 }
1467 EXPORT_SYMBOL(end_page_writeback);
1468
1469 /*
1470  * After completing I/O on a page, call this routine to update the page
1471  * flags appropriately
1472  */
1473 void page_endio(struct page *page, bool is_write, int err)
1474 {
1475         if (!is_write) {
1476                 if (!err) {
1477                         SetPageUptodate(page);
1478                 } else {
1479                         ClearPageUptodate(page);
1480                         SetPageError(page);
1481                 }
1482                 unlock_page(page);
1483         } else {
1484                 if (err) {
1485                         struct address_space *mapping;
1486
1487                         SetPageError(page);
1488                         mapping = page_mapping(page);
1489                         if (mapping)
1490                                 mapping_set_error(mapping, err);
1491                 }
1492                 end_page_writeback(page);
1493         }
1494 }
1495 EXPORT_SYMBOL_GPL(page_endio);
1496
1497 /**
1498  * __lock_page - get a lock on the page, assuming we need to sleep to get it
1499  * @__page: the page to lock
1500  */
1501 void __lock_page(struct page *__page)
1502 {
1503         struct page *page = compound_head(__page);
1504         wait_queue_head_t *q = page_waitqueue(page);
1505         wait_on_page_bit_common(q, page, PG_locked, TASK_UNINTERRUPTIBLE,
1506                                 EXCLUSIVE);
1507 }
1508 EXPORT_SYMBOL(__lock_page);
1509
1510 int __lock_page_killable(struct page *__page)
1511 {
1512         struct page *page = compound_head(__page);
1513         wait_queue_head_t *q = page_waitqueue(page);
1514         return wait_on_page_bit_common(q, page, PG_locked, TASK_KILLABLE,
1515                                         EXCLUSIVE);
1516 }
1517 EXPORT_SYMBOL_GPL(__lock_page_killable);
1518
1519 int __lock_page_async(struct page *page, struct wait_page_queue *wait)
1520 {
1521         struct wait_queue_head *q = page_waitqueue(page);
1522         int ret = 0;
1523
1524         wait->page = page;
1525         wait->bit_nr = PG_locked;
1526
1527         spin_lock_irq(&q->lock);
1528         __add_wait_queue_entry_tail(q, &wait->wait);
1529         SetPageWaiters(page);
1530         ret = !trylock_page(page);
1531         /*
1532          * If we were successful now, we know we're still on the
1533          * waitqueue as we're still under the lock. This means it's
1534          * safe to remove and return success, we know the callback
1535          * isn't going to trigger.
1536          */
1537         if (!ret)
1538                 __remove_wait_queue(q, &wait->wait);
1539         else
1540                 ret = -EIOCBQUEUED;
1541         spin_unlock_irq(&q->lock);
1542         return ret;
1543 }
1544
1545 /*
1546  * Return values:
1547  * 1 - page is locked; mmap_lock is still held.
1548  * 0 - page is not locked.
1549  *     mmap_lock has been released (mmap_read_unlock(), unless flags had both
1550  *     FAULT_FLAG_ALLOW_RETRY and FAULT_FLAG_RETRY_NOWAIT set, in
1551  *     which case mmap_lock is still held.
1552  *
1553  * If neither ALLOW_RETRY nor KILLABLE are set, will always return 1
1554  * with the page locked and the mmap_lock unperturbed.
1555  */
1556 int __lock_page_or_retry(struct page *page, struct mm_struct *mm,
1557                          unsigned int flags)
1558 {
1559         if (fault_flag_allow_retry_first(flags)) {
1560                 /*
1561                  * CAUTION! In this case, mmap_lock is not released
1562                  * even though return 0.
1563                  */
1564                 if (flags & FAULT_FLAG_RETRY_NOWAIT)
1565                         return 0;
1566
1567                 mmap_read_unlock(mm);
1568                 if (flags & FAULT_FLAG_KILLABLE)
1569                         wait_on_page_locked_killable(page);
1570                 else
1571                         wait_on_page_locked(page);
1572                 return 0;
1573         }
1574         if (flags & FAULT_FLAG_KILLABLE) {
1575                 int ret;
1576
1577                 ret = __lock_page_killable(page);
1578                 if (ret) {
1579                         mmap_read_unlock(mm);
1580                         return 0;
1581                 }
1582         } else {
1583                 __lock_page(page);
1584         }
1585         return 1;
1586
1587 }
1588
1589 /**
1590  * page_cache_next_miss() - Find the next gap in the page cache.
1591  * @mapping: Mapping.
1592  * @index: Index.
1593  * @max_scan: Maximum range to search.
1594  *
1595  * Search the range [index, min(index + max_scan - 1, ULONG_MAX)] for the
1596  * gap with the lowest index.
1597  *
1598  * This function may be called under the rcu_read_lock.  However, this will
1599  * not atomically search a snapshot of the cache at a single point in time.
1600  * For example, if a gap is created at index 5, then subsequently a gap is
1601  * created at index 10, page_cache_next_miss covering both indices may
1602  * return 10 if called under the rcu_read_lock.
1603  *
1604  * Return: The index of the gap if found, otherwise an index outside the
1605  * range specified (in which case 'return - index >= max_scan' will be true).
1606  * In the rare case of index wrap-around, 0 will be returned.
1607  */
1608 pgoff_t page_cache_next_miss(struct address_space *mapping,
1609                              pgoff_t index, unsigned long max_scan)
1610 {
1611         XA_STATE(xas, &mapping->i_pages, index);
1612
1613         while (max_scan--) {
1614                 void *entry = xas_next(&xas);
1615                 if (!entry || xa_is_value(entry))
1616                         break;
1617                 if (xas.xa_index == 0)
1618                         break;
1619         }
1620
1621         return xas.xa_index;
1622 }
1623 EXPORT_SYMBOL(page_cache_next_miss);
1624
1625 /**
1626  * page_cache_prev_miss() - Find the previous gap in the page cache.
1627  * @mapping: Mapping.
1628  * @index: Index.
1629  * @max_scan: Maximum range to search.
1630  *
1631  * Search the range [max(index - max_scan + 1, 0), index] for the
1632  * gap with the highest index.
1633  *
1634  * This function may be called under the rcu_read_lock.  However, this will
1635  * not atomically search a snapshot of the cache at a single point in time.
1636  * For example, if a gap is created at index 10, then subsequently a gap is
1637  * created at index 5, page_cache_prev_miss() covering both indices may
1638  * return 5 if called under the rcu_read_lock.
1639  *
1640  * Return: The index of the gap if found, otherwise an index outside the
1641  * range specified (in which case 'index - return >= max_scan' will be true).
1642  * In the rare case of wrap-around, ULONG_MAX will be returned.
1643  */
1644 pgoff_t page_cache_prev_miss(struct address_space *mapping,
1645                              pgoff_t index, unsigned long max_scan)
1646 {
1647         XA_STATE(xas, &mapping->i_pages, index);
1648
1649         while (max_scan--) {
1650                 void *entry = xas_prev(&xas);
1651                 if (!entry || xa_is_value(entry))
1652                         break;
1653                 if (xas.xa_index == ULONG_MAX)
1654                         break;
1655         }
1656
1657         return xas.xa_index;
1658 }
1659 EXPORT_SYMBOL(page_cache_prev_miss);
1660
1661 /*
1662  * mapping_get_entry - Get a page cache entry.
1663  * @mapping: the address_space to search
1664  * @index: The page cache index.
1665  *
1666  * Looks up the page cache slot at @mapping & @offset.  If there is a
1667  * page cache page, the head page is returned with an increased refcount.
1668  *
1669  * If the slot holds a shadow entry of a previously evicted page, or a
1670  * swap entry from shmem/tmpfs, it is returned.
1671  *
1672  * Return: The head page or shadow entry, %NULL if nothing is found.
1673  */
1674 static struct page *mapping_get_entry(struct address_space *mapping,
1675                 pgoff_t index)
1676 {
1677         XA_STATE(xas, &mapping->i_pages, index);
1678         struct page *page;
1679
1680         rcu_read_lock();
1681 repeat:
1682         xas_reset(&xas);
1683         page = xas_load(&xas);
1684         if (xas_retry(&xas, page))
1685                 goto repeat;
1686         /*
1687          * A shadow entry of a recently evicted page, or a swap entry from
1688          * shmem/tmpfs.  Return it without attempting to raise page count.
1689          */
1690         if (!page || xa_is_value(page))
1691                 goto out;
1692
1693         if (!page_cache_get_speculative(page))
1694                 goto repeat;
1695
1696         /*
1697          * Has the page moved or been split?
1698          * This is part of the lockless pagecache protocol. See
1699          * include/linux/pagemap.h for details.
1700          */
1701         if (unlikely(page != xas_reload(&xas))) {
1702                 put_page(page);
1703                 goto repeat;
1704         }
1705 out:
1706         rcu_read_unlock();
1707
1708         return page;
1709 }
1710
1711 /**
1712  * pagecache_get_page - Find and get a reference to a page.
1713  * @mapping: The address_space to search.
1714  * @index: The page index.
1715  * @fgp_flags: %FGP flags modify how the page is returned.
1716  * @gfp_mask: Memory allocation flags to use if %FGP_CREAT is specified.
1717  *
1718  * Looks up the page cache entry at @mapping & @index.
1719  *
1720  * @fgp_flags can be zero or more of these flags:
1721  *
1722  * * %FGP_ACCESSED - The page will be marked accessed.
1723  * * %FGP_LOCK - The page is returned locked.
1724  * * %FGP_HEAD - If the page is present and a THP, return the head page
1725  *   rather than the exact page specified by the index.
1726  * * %FGP_ENTRY - If there is a shadow / swap / DAX entry, return it
1727  *   instead of allocating a new page to replace it.
1728  * * %FGP_CREAT - If no page is present then a new page is allocated using
1729  *   @gfp_mask and added to the page cache and the VM's LRU list.
1730  *   The page is returned locked and with an increased refcount.
1731  * * %FGP_FOR_MMAP - The caller wants to do its own locking dance if the
1732  *   page is already in cache.  If the page was allocated, unlock it before
1733  *   returning so the caller can do the same dance.
1734  * * %FGP_WRITE - The page will be written
1735  * * %FGP_NOFS - __GFP_FS will get cleared in gfp mask
1736  * * %FGP_NOWAIT - Don't get blocked by page lock
1737  *
1738  * If %FGP_LOCK or %FGP_CREAT are specified then the function may sleep even
1739  * if the %GFP flags specified for %FGP_CREAT are atomic.
1740  *
1741  * If there is a page cache page, it is returned with an increased refcount.
1742  *
1743  * Return: The found page or %NULL otherwise.
1744  */
1745 struct page *pagecache_get_page(struct address_space *mapping, pgoff_t index,
1746                 int fgp_flags, gfp_t gfp_mask)
1747 {
1748         struct page *page;
1749
1750 repeat:
1751         page = mapping_get_entry(mapping, index);
1752         if (xa_is_value(page)) {
1753                 if (fgp_flags & FGP_ENTRY)
1754                         return page;
1755                 page = NULL;
1756         }
1757         if (!page)
1758                 goto no_page;
1759
1760         if (fgp_flags & FGP_LOCK) {
1761                 if (fgp_flags & FGP_NOWAIT) {
1762                         if (!trylock_page(page)) {
1763                                 put_page(page);
1764                                 return NULL;
1765                         }
1766                 } else {
1767                         lock_page(page);
1768                 }
1769
1770                 /* Has the page been truncated? */
1771                 if (unlikely(page->mapping != mapping)) {
1772                         unlock_page(page);
1773                         put_page(page);
1774                         goto repeat;
1775                 }
1776                 VM_BUG_ON_PAGE(!thp_contains(page, index), page);
1777         }
1778
1779         if (fgp_flags & FGP_ACCESSED)
1780                 mark_page_accessed(page);
1781         else if (fgp_flags & FGP_WRITE) {
1782                 /* Clear idle flag for buffer write */
1783                 if (page_is_idle(page))
1784                         clear_page_idle(page);
1785         }
1786         if (!(fgp_flags & FGP_HEAD))
1787                 page = find_subpage(page, index);
1788
1789 no_page:
1790         if (!page && (fgp_flags & FGP_CREAT)) {
1791                 int err;
1792                 if ((fgp_flags & FGP_WRITE) && mapping_can_writeback(mapping))
1793                         gfp_mask |= __GFP_WRITE;
1794                 if (fgp_flags & FGP_NOFS)
1795                         gfp_mask &= ~__GFP_FS;
1796
1797                 page = __page_cache_alloc(gfp_mask);
1798                 if (!page)
1799                         return NULL;
1800
1801                 if (WARN_ON_ONCE(!(fgp_flags & (FGP_LOCK | FGP_FOR_MMAP))))
1802                         fgp_flags |= FGP_LOCK;
1803
1804                 /* Init accessed so avoid atomic mark_page_accessed later */
1805                 if (fgp_flags & FGP_ACCESSED)
1806                         __SetPageReferenced(page);
1807
1808                 err = add_to_page_cache_lru(page, mapping, index, gfp_mask);
1809                 if (unlikely(err)) {
1810                         put_page(page);
1811                         page = NULL;
1812                         if (err == -EEXIST)
1813                                 goto repeat;
1814                 }
1815
1816                 /*
1817                  * add_to_page_cache_lru locks the page, and for mmap we expect
1818                  * an unlocked page.
1819                  */
1820                 if (page && (fgp_flags & FGP_FOR_MMAP))
1821                         unlock_page(page);
1822         }
1823
1824         return page;
1825 }
1826 EXPORT_SYMBOL(pagecache_get_page);
1827
1828 static inline struct page *find_get_entry(struct xa_state *xas, pgoff_t max,
1829                 xa_mark_t mark)
1830 {
1831         struct page *page;
1832
1833 retry:
1834         if (mark == XA_PRESENT)
1835                 page = xas_find(xas, max);
1836         else
1837                 page = xas_find_marked(xas, max, mark);
1838
1839         if (xas_retry(xas, page))
1840                 goto retry;
1841         /*
1842          * A shadow entry of a recently evicted page, a swap
1843          * entry from shmem/tmpfs or a DAX entry.  Return it
1844          * without attempting to raise page count.
1845          */
1846         if (!page || xa_is_value(page))
1847                 return page;
1848
1849         if (!page_cache_get_speculative(page))
1850                 goto reset;
1851
1852         /* Has the page moved or been split? */
1853         if (unlikely(page != xas_reload(xas))) {
1854                 put_page(page);
1855                 goto reset;
1856         }
1857
1858         return page;
1859 reset:
1860         xas_reset(xas);
1861         goto retry;
1862 }
1863
1864 /**
1865  * find_get_entries - gang pagecache lookup
1866  * @mapping:    The address_space to search
1867  * @start:      The starting page cache index
1868  * @end:        The final page index (inclusive).
1869  * @pvec:       Where the resulting entries are placed.
1870  * @indices:    The cache indices corresponding to the entries in @entries
1871  *
1872  * find_get_entries() will search for and return a batch of entries in
1873  * the mapping.  The entries are placed in @pvec.  find_get_entries()
1874  * takes a reference on any actual pages it returns.
1875  *
1876  * The search returns a group of mapping-contiguous page cache entries
1877  * with ascending indexes.  There may be holes in the indices due to
1878  * not-present pages.
1879  *
1880  * Any shadow entries of evicted pages, or swap entries from
1881  * shmem/tmpfs, are included in the returned array.
1882  *
1883  * If it finds a Transparent Huge Page, head or tail, find_get_entries()
1884  * stops at that page: the caller is likely to have a better way to handle
1885  * the compound page as a whole, and then skip its extent, than repeatedly
1886  * calling find_get_entries() to return all its tails.
1887  *
1888  * Return: the number of pages and shadow entries which were found.
1889  */
1890 unsigned find_get_entries(struct address_space *mapping, pgoff_t start,
1891                 pgoff_t end, struct pagevec *pvec, pgoff_t *indices)
1892 {
1893         XA_STATE(xas, &mapping->i_pages, start);
1894         struct page *page;
1895         unsigned int ret = 0;
1896         unsigned nr_entries = PAGEVEC_SIZE;
1897
1898         rcu_read_lock();
1899         while ((page = find_get_entry(&xas, end, XA_PRESENT))) {
1900                 /*
1901                  * Terminate early on finding a THP, to allow the caller to
1902                  * handle it all at once; but continue if this is hugetlbfs.
1903                  */
1904                 if (!xa_is_value(page) && PageTransHuge(page) &&
1905                                 !PageHuge(page)) {
1906                         page = find_subpage(page, xas.xa_index);
1907                         nr_entries = ret + 1;
1908                 }
1909
1910                 indices[ret] = xas.xa_index;
1911                 pvec->pages[ret] = page;
1912                 if (++ret == nr_entries)
1913                         break;
1914         }
1915         rcu_read_unlock();
1916
1917         pvec->nr = ret;
1918         return ret;
1919 }
1920
1921 /**
1922  * find_lock_entries - Find a batch of pagecache entries.
1923  * @mapping:    The address_space to search.
1924  * @start:      The starting page cache index.
1925  * @end:        The final page index (inclusive).
1926  * @pvec:       Where the resulting entries are placed.
1927  * @indices:    The cache indices of the entries in @pvec.
1928  *
1929  * find_lock_entries() will return a batch of entries from @mapping.
1930  * Swap, shadow and DAX entries are included.  Pages are returned
1931  * locked and with an incremented refcount.  Pages which are locked by
1932  * somebody else or under writeback are skipped.  Only the head page of
1933  * a THP is returned.  Pages which are partially outside the range are
1934  * not returned.
1935  *
1936  * The entries have ascending indexes.  The indices may not be consecutive
1937  * due to not-present entries, THP pages, pages which could not be locked
1938  * or pages under writeback.
1939  *
1940  * Return: The number of entries which were found.
1941  */
1942 unsigned find_lock_entries(struct address_space *mapping, pgoff_t start,
1943                 pgoff_t end, struct pagevec *pvec, pgoff_t *indices)
1944 {
1945         XA_STATE(xas, &mapping->i_pages, start);
1946         struct page *page;
1947
1948         rcu_read_lock();
1949         while ((page = find_get_entry(&xas, end, XA_PRESENT))) {
1950                 if (!xa_is_value(page)) {
1951                         if (page->index < start)
1952                                 goto put;
1953                         VM_BUG_ON_PAGE(page->index != xas.xa_index, page);
1954                         if (page->index + thp_nr_pages(page) - 1 > end)
1955                                 goto put;
1956                         if (!trylock_page(page))
1957                                 goto put;
1958                         if (page->mapping != mapping || PageWriteback(page))
1959                                 goto unlock;
1960                         VM_BUG_ON_PAGE(!thp_contains(page, xas.xa_index),
1961                                         page);
1962                 }
1963                 indices[pvec->nr] = xas.xa_index;
1964                 if (!pagevec_add(pvec, page))
1965                         break;
1966                 goto next;
1967 unlock:
1968                 unlock_page(page);
1969 put:
1970                 put_page(page);
1971 next:
1972                 if (!xa_is_value(page) && PageTransHuge(page))
1973                         xas_set(&xas, page->index + thp_nr_pages(page));
1974         }
1975         rcu_read_unlock();
1976
1977         return pagevec_count(pvec);
1978 }
1979
1980 /**
1981  * find_get_pages_range - gang pagecache lookup
1982  * @mapping:    The address_space to search
1983  * @start:      The starting page index
1984  * @end:        The final page index (inclusive)
1985  * @nr_pages:   The maximum number of pages
1986  * @pages:      Where the resulting pages are placed
1987  *
1988  * find_get_pages_range() will search for and return a group of up to @nr_pages
1989  * pages in the mapping starting at index @start and up to index @end
1990  * (inclusive).  The pages are placed at @pages.  find_get_pages_range() takes
1991  * a reference against the returned pages.
1992  *
1993  * The search returns a group of mapping-contiguous pages with ascending
1994  * indexes.  There may be holes in the indices due to not-present pages.
1995  * We also update @start to index the next page for the traversal.
1996  *
1997  * Return: the number of pages which were found. If this number is
1998  * smaller than @nr_pages, the end of specified range has been
1999  * reached.
2000  */
2001 unsigned find_get_pages_range(struct address_space *mapping, pgoff_t *start,
2002                               pgoff_t end, unsigned int nr_pages,
2003                               struct page **pages)
2004 {
2005         XA_STATE(xas, &mapping->i_pages, *start);
2006         struct page *page;
2007         unsigned ret = 0;
2008
2009         if (unlikely(!nr_pages))
2010                 return 0;
2011
2012         rcu_read_lock();
2013         while ((page = find_get_entry(&xas, end, XA_PRESENT))) {
2014                 /* Skip over shadow, swap and DAX entries */
2015                 if (xa_is_value(page))
2016                         continue;
2017
2018                 pages[ret] = find_subpage(page, xas.xa_index);
2019                 if (++ret == nr_pages) {
2020                         *start = xas.xa_index + 1;
2021                         goto out;
2022                 }
2023         }
2024
2025         /*
2026          * We come here when there is no page beyond @end. We take care to not
2027          * overflow the index @start as it confuses some of the callers. This
2028          * breaks the iteration when there is a page at index -1 but that is
2029          * already broken anyway.
2030          */
2031         if (end == (pgoff_t)-1)
2032                 *start = (pgoff_t)-1;
2033         else
2034                 *start = end + 1;
2035 out:
2036         rcu_read_unlock();
2037
2038         return ret;
2039 }
2040
2041 /**
2042  * find_get_pages_contig - gang contiguous pagecache lookup
2043  * @mapping:    The address_space to search
2044  * @index:      The starting page index
2045  * @nr_pages:   The maximum number of pages
2046  * @pages:      Where the resulting pages are placed
2047  *
2048  * find_get_pages_contig() works exactly like find_get_pages(), except
2049  * that the returned number of pages are guaranteed to be contiguous.
2050  *
2051  * Return: the number of pages which were found.
2052  */
2053 unsigned find_get_pages_contig(struct address_space *mapping, pgoff_t index,
2054                                unsigned int nr_pages, struct page **pages)
2055 {
2056         XA_STATE(xas, &mapping->i_pages, index);
2057         struct page *page;
2058         unsigned int ret = 0;
2059
2060         if (unlikely(!nr_pages))
2061                 return 0;
2062
2063         rcu_read_lock();
2064         for (page = xas_load(&xas); page; page = xas_next(&xas)) {
2065                 if (xas_retry(&xas, page))
2066                         continue;
2067                 /*
2068                  * If the entry has been swapped out, we can stop looking.
2069                  * No current caller is looking for DAX entries.
2070                  */
2071                 if (xa_is_value(page))
2072                         break;
2073
2074                 if (!page_cache_get_speculative(page))
2075                         goto retry;
2076
2077                 /* Has the page moved or been split? */
2078                 if (unlikely(page != xas_reload(&xas)))
2079                         goto put_page;
2080
2081                 pages[ret] = find_subpage(page, xas.xa_index);
2082                 if (++ret == nr_pages)
2083                         break;
2084                 continue;
2085 put_page:
2086                 put_page(page);
2087 retry:
2088                 xas_reset(&xas);
2089         }
2090         rcu_read_unlock();
2091         return ret;
2092 }
2093 EXPORT_SYMBOL(find_get_pages_contig);
2094
2095 /**
2096  * find_get_pages_range_tag - Find and return head pages matching @tag.
2097  * @mapping:    the address_space to search
2098  * @index:      the starting page index
2099  * @end:        The final page index (inclusive)
2100  * @tag:        the tag index
2101  * @nr_pages:   the maximum number of pages
2102  * @pages:      where the resulting pages are placed
2103  *
2104  * Like find_get_pages(), except we only return head pages which are tagged
2105  * with @tag.  @index is updated to the index immediately after the last
2106  * page we return, ready for the next iteration.
2107  *
2108  * Return: the number of pages which were found.
2109  */
2110 unsigned find_get_pages_range_tag(struct address_space *mapping, pgoff_t *index,
2111                         pgoff_t end, xa_mark_t tag, unsigned int nr_pages,
2112                         struct page **pages)
2113 {
2114         XA_STATE(xas, &mapping->i_pages, *index);
2115         struct page *page;
2116         unsigned ret = 0;
2117
2118         if (unlikely(!nr_pages))
2119                 return 0;
2120
2121         rcu_read_lock();
2122         while ((page = find_get_entry(&xas, end, tag))) {
2123                 /*
2124                  * Shadow entries should never be tagged, but this iteration
2125                  * is lockless so there is a window for page reclaim to evict
2126                  * a page we saw tagged.  Skip over it.
2127                  */
2128                 if (xa_is_value(page))
2129                         continue;
2130
2131                 pages[ret] = page;
2132                 if (++ret == nr_pages) {
2133                         *index = page->index + thp_nr_pages(page);
2134                         goto out;
2135                 }
2136         }
2137
2138         /*
2139          * We come here when we got to @end. We take care to not overflow the
2140          * index @index as it confuses some of the callers. This breaks the
2141          * iteration when there is a page at index -1 but that is already
2142          * broken anyway.
2143          */
2144         if (end == (pgoff_t)-1)
2145                 *index = (pgoff_t)-1;
2146         else
2147                 *index = end + 1;
2148 out:
2149         rcu_read_unlock();
2150
2151         return ret;
2152 }
2153 EXPORT_SYMBOL(find_get_pages_range_tag);
2154
2155 /*
2156  * CD/DVDs are error prone. When a medium error occurs, the driver may fail
2157  * a _large_ part of the i/o request. Imagine the worst scenario:
2158  *
2159  *      ---R__________________________________________B__________
2160  *         ^ reading here                             ^ bad block(assume 4k)
2161  *
2162  * read(R) => miss => readahead(R...B) => media error => frustrating retries
2163  * => failing the whole request => read(R) => read(R+1) =>
2164  * readahead(R+1...B+1) => bang => read(R+2) => read(R+3) =>
2165  * readahead(R+3...B+2) => bang => read(R+3) => read(R+4) =>
2166  * readahead(R+4...B+3) => bang => read(R+4) => read(R+5) => ......
2167  *
2168  * It is going insane. Fix it by quickly scaling down the readahead size.
2169  */
2170 static void shrink_readahead_size_eio(struct file_ra_state *ra)
2171 {
2172         ra->ra_pages /= 4;
2173 }
2174
2175 /*
2176  * filemap_get_read_batch - Get a batch of pages for read
2177  *
2178  * Get a batch of pages which represent a contiguous range of bytes
2179  * in the file.  No tail pages will be returned.  If @index is in the
2180  * middle of a THP, the entire THP will be returned.  The last page in
2181  * the batch may have Readahead set or be not Uptodate so that the
2182  * caller can take the appropriate action.
2183  */
2184 static void filemap_get_read_batch(struct address_space *mapping,
2185                 pgoff_t index, pgoff_t max, struct pagevec *pvec)
2186 {
2187         XA_STATE(xas, &mapping->i_pages, index);
2188         struct page *head;
2189
2190         rcu_read_lock();
2191         for (head = xas_load(&xas); head; head = xas_next(&xas)) {
2192                 if (xas_retry(&xas, head))
2193                         continue;
2194                 if (xas.xa_index > max || xa_is_value(head))
2195                         break;
2196                 if (!page_cache_get_speculative(head))
2197                         goto retry;
2198
2199                 /* Has the page moved or been split? */
2200                 if (unlikely(head != xas_reload(&xas)))
2201                         goto put_page;
2202
2203                 if (!pagevec_add(pvec, head))
2204                         break;
2205                 if (!PageUptodate(head))
2206                         break;
2207                 if (PageReadahead(head))
2208                         break;
2209                 xas.xa_index = head->index + thp_nr_pages(head) - 1;
2210                 xas.xa_offset = (xas.xa_index >> xas.xa_shift) & XA_CHUNK_MASK;
2211                 continue;
2212 put_page:
2213                 put_page(head);
2214 retry:
2215                 xas_reset(&xas);
2216         }
2217         rcu_read_unlock();
2218 }
2219
2220 static int filemap_read_page(struct file *file, struct address_space *mapping,
2221                 struct page *page)
2222 {
2223         int error;
2224
2225         /*
2226          * A previous I/O error may have been due to temporary failures,
2227          * eg. multipath errors.  PG_error will be set again if readpage
2228          * fails.
2229          */
2230         ClearPageError(page);
2231         /* Start the actual read. The read will unlock the page. */
2232         error = mapping->a_ops->readpage(file, page);
2233         if (error)
2234                 return error;
2235
2236         error = wait_on_page_locked_killable(page);
2237         if (error)
2238                 return error;
2239         if (PageUptodate(page))
2240                 return 0;
2241         if (!page->mapping)     /* page truncated */
2242                 return AOP_TRUNCATED_PAGE;
2243         shrink_readahead_size_eio(&file->f_ra);
2244         return -EIO;
2245 }
2246
2247 static bool filemap_range_uptodate(struct address_space *mapping,
2248                 loff_t pos, struct iov_iter *iter, struct page *page)
2249 {
2250         int count;
2251
2252         if (PageUptodate(page))
2253                 return true;
2254         /* pipes can't handle partially uptodate pages */
2255         if (iov_iter_is_pipe(iter))
2256                 return false;
2257         if (!mapping->a_ops->is_partially_uptodate)
2258                 return false;
2259         if (mapping->host->i_blkbits >= (PAGE_SHIFT + thp_order(page)))
2260                 return false;
2261
2262         count = iter->count;
2263         if (page_offset(page) > pos) {
2264                 count -= page_offset(page) - pos;
2265                 pos = 0;
2266         } else {
2267                 pos -= page_offset(page);
2268         }
2269
2270         return mapping->a_ops->is_partially_uptodate(page, pos, count);
2271 }
2272
2273 static int filemap_update_page(struct kiocb *iocb,
2274                 struct address_space *mapping, struct iov_iter *iter,
2275                 struct page *page)
2276 {
2277         int error;
2278
2279         if (!trylock_page(page)) {
2280                 if (iocb->ki_flags & (IOCB_NOWAIT | IOCB_NOIO))
2281                         return -EAGAIN;
2282                 if (!(iocb->ki_flags & IOCB_WAITQ)) {
2283                         put_and_wait_on_page_locked(page, TASK_KILLABLE);
2284                         return AOP_TRUNCATED_PAGE;
2285                 }
2286                 error = __lock_page_async(page, iocb->ki_waitq);
2287                 if (error)
2288                         return error;
2289         }
2290
2291         if (!page->mapping)
2292                 goto truncated;
2293
2294         error = 0;
2295         if (filemap_range_uptodate(mapping, iocb->ki_pos, iter, page))
2296                 goto unlock;
2297
2298         error = -EAGAIN;
2299         if (iocb->ki_flags & (IOCB_NOIO | IOCB_NOWAIT | IOCB_WAITQ))
2300                 goto unlock;
2301
2302         error = filemap_read_page(iocb->ki_filp, mapping, page);
2303         if (error == AOP_TRUNCATED_PAGE)
2304                 put_page(page);
2305         return error;
2306 truncated:
2307         unlock_page(page);
2308         put_page(page);
2309         return AOP_TRUNCATED_PAGE;
2310 unlock:
2311         unlock_page(page);
2312         return error;
2313 }
2314
2315 static int filemap_create_page(struct file *file,
2316                 struct address_space *mapping, pgoff_t index,
2317                 struct pagevec *pvec)
2318 {
2319         struct page *page;
2320         int error;
2321
2322         page = page_cache_alloc(mapping);
2323         if (!page)
2324                 return -ENOMEM;
2325
2326         error = add_to_page_cache_lru(page, mapping, index,
2327                         mapping_gfp_constraint(mapping, GFP_KERNEL));
2328         if (error == -EEXIST)
2329                 error = AOP_TRUNCATED_PAGE;
2330         if (error)
2331                 goto error;
2332
2333         error = filemap_read_page(file, mapping, page);
2334         if (error)
2335                 goto error;
2336
2337         pagevec_add(pvec, page);
2338         return 0;
2339 error:
2340         put_page(page);
2341         return error;
2342 }
2343
2344 static int filemap_readahead(struct kiocb *iocb, struct file *file,
2345                 struct address_space *mapping, struct page *page,
2346                 pgoff_t last_index)
2347 {
2348         if (iocb->ki_flags & IOCB_NOIO)
2349                 return -EAGAIN;
2350         page_cache_async_readahead(mapping, &file->f_ra, file, page,
2351                         page->index, last_index - page->index);
2352         return 0;
2353 }
2354
2355 static int filemap_get_pages(struct kiocb *iocb, struct iov_iter *iter,
2356                 struct pagevec *pvec)
2357 {
2358         struct file *filp = iocb->ki_filp;
2359         struct address_space *mapping = filp->f_mapping;
2360         struct file_ra_state *ra = &filp->f_ra;
2361         pgoff_t index = iocb->ki_pos >> PAGE_SHIFT;
2362         pgoff_t last_index;
2363         struct page *page;
2364         int err = 0;
2365
2366         last_index = DIV_ROUND_UP(iocb->ki_pos + iter->count, PAGE_SIZE);
2367 retry:
2368         if (fatal_signal_pending(current))
2369                 return -EINTR;
2370
2371         filemap_get_read_batch(mapping, index, last_index, pvec);
2372         if (!pagevec_count(pvec)) {
2373                 if (iocb->ki_flags & IOCB_NOIO)
2374                         return -EAGAIN;
2375                 page_cache_sync_readahead(mapping, ra, filp, index,
2376                                 last_index - index);
2377                 filemap_get_read_batch(mapping, index, last_index, pvec);
2378         }
2379         if (!pagevec_count(pvec)) {
2380                 if (iocb->ki_flags & (IOCB_NOWAIT | IOCB_WAITQ))
2381                         return -EAGAIN;
2382                 err = filemap_create_page(filp, mapping,
2383                                 iocb->ki_pos >> PAGE_SHIFT, pvec);
2384                 if (err == AOP_TRUNCATED_PAGE)
2385                         goto retry;
2386                 return err;
2387         }
2388
2389         page = pvec->pages[pagevec_count(pvec) - 1];
2390         if (PageReadahead(page)) {
2391                 err = filemap_readahead(iocb, filp, mapping, page, last_index);
2392                 if (err)
2393                         goto err;
2394         }
2395         if (!PageUptodate(page)) {
2396                 if ((iocb->ki_flags & IOCB_WAITQ) && pagevec_count(pvec) > 1)
2397                         iocb->ki_flags |= IOCB_NOWAIT;
2398                 err = filemap_update_page(iocb, mapping, iter, page);
2399                 if (err)
2400                         goto err;
2401         }
2402
2403         return 0;
2404 err:
2405         if (err < 0)
2406                 put_page(page);
2407         if (likely(--pvec->nr))
2408                 return 0;
2409         if (err == AOP_TRUNCATED_PAGE)
2410                 goto retry;
2411         return err;
2412 }
2413
2414 /**
2415  * filemap_read - Read data from the page cache.
2416  * @iocb: The iocb to read.
2417  * @iter: Destination for the data.
2418  * @already_read: Number of bytes already read by the caller.
2419  *
2420  * Copies data from the page cache.  If the data is not currently present,
2421  * uses the readahead and readpage address_space operations to fetch it.
2422  *
2423  * Return: Total number of bytes copied, including those already read by
2424  * the caller.  If an error happens before any bytes are copied, returns
2425  * a negative error number.
2426  */
2427 ssize_t filemap_read(struct kiocb *iocb, struct iov_iter *iter,
2428                 ssize_t already_read)
2429 {
2430         struct file *filp = iocb->ki_filp;
2431         struct file_ra_state *ra = &filp->f_ra;
2432         struct address_space *mapping = filp->f_mapping;
2433         struct inode *inode = mapping->host;
2434         struct pagevec pvec;
2435         int i, error = 0;
2436         bool writably_mapped;
2437         loff_t isize, end_offset;
2438
2439         if (unlikely(iocb->ki_pos >= inode->i_sb->s_maxbytes))
2440                 return 0;
2441         if (unlikely(!iov_iter_count(iter)))
2442                 return 0;
2443
2444         iov_iter_truncate(iter, inode->i_sb->s_maxbytes);
2445         pagevec_init(&pvec);
2446
2447         do {
2448                 cond_resched();
2449
2450                 /*
2451                  * If we've already successfully copied some data, then we
2452                  * can no longer safely return -EIOCBQUEUED. Hence mark
2453                  * an async read NOWAIT at that point.
2454                  */
2455                 if ((iocb->ki_flags & IOCB_WAITQ) && already_read)
2456                         iocb->ki_flags |= IOCB_NOWAIT;
2457
2458                 error = filemap_get_pages(iocb, iter, &pvec);
2459                 if (error < 0)
2460                         break;
2461
2462                 /*
2463                  * i_size must be checked after we know the pages are Uptodate.
2464                  *
2465                  * Checking i_size after the check allows us to calculate
2466                  * the correct value for "nr", which means the zero-filled
2467                  * part of the page is not copied back to userspace (unless
2468                  * another truncate extends the file - this is desired though).
2469                  */
2470                 isize = i_size_read(inode);
2471                 if (unlikely(iocb->ki_pos >= isize))
2472                         goto put_pages;
2473                 end_offset = min_t(loff_t, isize, iocb->ki_pos + iter->count);
2474
2475                 /*
2476                  * Once we start copying data, we don't want to be touching any
2477                  * cachelines that might be contended:
2478                  */
2479                 writably_mapped = mapping_writably_mapped(mapping);
2480
2481                 /*
2482                  * When a sequential read accesses a page several times, only
2483                  * mark it as accessed the first time.
2484                  */
2485                 if (iocb->ki_pos >> PAGE_SHIFT !=
2486                     ra->prev_pos >> PAGE_SHIFT)
2487                         mark_page_accessed(pvec.pages[0]);
2488
2489                 for (i = 0; i < pagevec_count(&pvec); i++) {
2490                         struct page *page = pvec.pages[i];
2491                         size_t page_size = thp_size(page);
2492                         size_t offset = iocb->ki_pos & (page_size - 1);
2493                         size_t bytes = min_t(loff_t, end_offset - iocb->ki_pos,
2494                                              page_size - offset);
2495                         size_t copied;
2496
2497                         if (end_offset < page_offset(page))
2498                                 break;
2499                         if (i > 0)
2500                                 mark_page_accessed(page);
2501                         /*
2502                          * If users can be writing to this page using arbitrary
2503                          * virtual addresses, take care about potential aliasing
2504                          * before reading the page on the kernel side.
2505                          */
2506                         if (writably_mapped) {
2507                                 int j;
2508
2509                                 for (j = 0; j < thp_nr_pages(page); j++)
2510                                         flush_dcache_page(page + j);
2511                         }
2512
2513                         copied = copy_page_to_iter(page, offset, bytes, iter);
2514
2515                         already_read += copied;
2516                         iocb->ki_pos += copied;
2517                         ra->prev_pos = iocb->ki_pos;
2518
2519                         if (copied < bytes) {
2520                                 error = -EFAULT;
2521                                 break;
2522                         }
2523                 }
2524 put_pages:
2525                 for (i = 0; i < pagevec_count(&pvec); i++)
2526                         put_page(pvec.pages[i]);
2527                 pagevec_reinit(&pvec);
2528         } while (iov_iter_count(iter) && iocb->ki_pos < isize && !error);
2529
2530         file_accessed(filp);
2531
2532         return already_read ? already_read : error;
2533 }
2534 EXPORT_SYMBOL_GPL(filemap_read);
2535
2536 /**
2537  * generic_file_read_iter - generic filesystem read routine
2538  * @iocb:       kernel I/O control block
2539  * @iter:       destination for the data read
2540  *
2541  * This is the "read_iter()" routine for all filesystems
2542  * that can use the page cache directly.
2543  *
2544  * The IOCB_NOWAIT flag in iocb->ki_flags indicates that -EAGAIN shall
2545  * be returned when no data can be read without waiting for I/O requests
2546  * to complete; it doesn't prevent readahead.
2547  *
2548  * The IOCB_NOIO flag in iocb->ki_flags indicates that no new I/O
2549  * requests shall be made for the read or for readahead.  When no data
2550  * can be read, -EAGAIN shall be returned.  When readahead would be
2551  * triggered, a partial, possibly empty read shall be returned.
2552  *
2553  * Return:
2554  * * number of bytes copied, even for partial reads
2555  * * negative error code (or 0 if IOCB_NOIO) if nothing was read
2556  */
2557 ssize_t
2558 generic_file_read_iter(struct kiocb *iocb, struct iov_iter *iter)
2559 {
2560         size_t count = iov_iter_count(iter);
2561         ssize_t retval = 0;
2562
2563         if (!count)
2564                 return 0; /* skip atime */
2565
2566         if (iocb->ki_flags & IOCB_DIRECT) {
2567                 struct file *file = iocb->ki_filp;
2568                 struct address_space *mapping = file->f_mapping;
2569                 struct inode *inode = mapping->host;
2570                 loff_t size;
2571
2572                 size = i_size_read(inode);
2573                 if (iocb->ki_flags & IOCB_NOWAIT) {
2574                         if (filemap_range_has_page(mapping, iocb->ki_pos,
2575                                                    iocb->ki_pos + count - 1))
2576                                 return -EAGAIN;
2577                 } else {
2578                         retval = filemap_write_and_wait_range(mapping,
2579                                                 iocb->ki_pos,
2580                                                 iocb->ki_pos + count - 1);
2581                         if (retval < 0)
2582                                 return retval;
2583                 }
2584
2585                 file_accessed(file);
2586
2587                 retval = mapping->a_ops->direct_IO(iocb, iter);
2588                 if (retval >= 0) {
2589                         iocb->ki_pos += retval;
2590                         count -= retval;
2591                 }
2592                 if (retval != -EIOCBQUEUED)
2593                         iov_iter_revert(iter, count - iov_iter_count(iter));
2594
2595                 /*
2596                  * Btrfs can have a short DIO read if we encounter
2597                  * compressed extents, so if there was an error, or if
2598                  * we've already read everything we wanted to, or if
2599                  * there was a short read because we hit EOF, go ahead
2600                  * and return.  Otherwise fallthrough to buffered io for
2601                  * the rest of the read.  Buffered reads will not work for
2602                  * DAX files, so don't bother trying.
2603                  */
2604                 if (retval < 0 || !count || iocb->ki_pos >= size ||
2605                     IS_DAX(inode))
2606                         return retval;
2607         }
2608
2609         return filemap_read(iocb, iter, retval);
2610 }
2611 EXPORT_SYMBOL(generic_file_read_iter);
2612
2613 static inline loff_t page_seek_hole_data(struct xa_state *xas,
2614                 struct address_space *mapping, struct page *page,
2615                 loff_t start, loff_t end, bool seek_data)
2616 {
2617         const struct address_space_operations *ops = mapping->a_ops;
2618         size_t offset, bsz = i_blocksize(mapping->host);
2619
2620         if (xa_is_value(page) || PageUptodate(page))
2621                 return seek_data ? start : end;
2622         if (!ops->is_partially_uptodate)
2623                 return seek_data ? end : start;
2624
2625         xas_pause(xas);
2626         rcu_read_unlock();
2627         lock_page(page);
2628         if (unlikely(page->mapping != mapping))
2629                 goto unlock;
2630
2631         offset = offset_in_thp(page, start) & ~(bsz - 1);
2632
2633         do {
2634                 if (ops->is_partially_uptodate(page, offset, bsz) == seek_data)
2635                         break;
2636                 start = (start + bsz) & ~(bsz - 1);
2637                 offset += bsz;
2638         } while (offset < thp_size(page));
2639 unlock:
2640         unlock_page(page);
2641         rcu_read_lock();
2642         return start;
2643 }
2644
2645 static inline
2646 unsigned int seek_page_size(struct xa_state *xas, struct page *page)
2647 {
2648         if (xa_is_value(page))
2649                 return PAGE_SIZE << xa_get_order(xas->xa, xas->xa_index);
2650         return thp_size(page);
2651 }
2652
2653 /**
2654  * mapping_seek_hole_data - Seek for SEEK_DATA / SEEK_HOLE in the page cache.
2655  * @mapping: Address space to search.
2656  * @start: First byte to consider.
2657  * @end: Limit of search (exclusive).
2658  * @whence: Either SEEK_HOLE or SEEK_DATA.
2659  *
2660  * If the page cache knows which blocks contain holes and which blocks
2661  * contain data, your filesystem can use this function to implement
2662  * SEEK_HOLE and SEEK_DATA.  This is useful for filesystems which are
2663  * entirely memory-based such as tmpfs, and filesystems which support
2664  * unwritten extents.
2665  *
2666  * Return: The requested offset on successs, or -ENXIO if @whence specifies
2667  * SEEK_DATA and there is no data after @start.  There is an implicit hole
2668  * after @end - 1, so SEEK_HOLE returns @end if all the bytes between @start
2669  * and @end contain data.
2670  */
2671 loff_t mapping_seek_hole_data(struct address_space *mapping, loff_t start,
2672                 loff_t end, int whence)
2673 {
2674         XA_STATE(xas, &mapping->i_pages, start >> PAGE_SHIFT);
2675         pgoff_t max = (end - 1) / PAGE_SIZE;
2676         bool seek_data = (whence == SEEK_DATA);
2677         struct page *page;
2678
2679         if (end <= start)
2680                 return -ENXIO;
2681
2682         rcu_read_lock();
2683         while ((page = find_get_entry(&xas, max, XA_PRESENT))) {
2684                 loff_t pos = xas.xa_index * PAGE_SIZE;
2685
2686                 if (start < pos) {
2687                         if (!seek_data)
2688                                 goto unlock;
2689                         start = pos;
2690                 }
2691
2692                 pos += seek_page_size(&xas, page);
2693                 start = page_seek_hole_data(&xas, mapping, page, start, pos,
2694                                 seek_data);
2695                 if (start < pos)
2696                         goto unlock;
2697                 if (!xa_is_value(page))
2698                         put_page(page);
2699         }
2700         rcu_read_unlock();
2701
2702         if (seek_data)
2703                 return -ENXIO;
2704         goto out;
2705
2706 unlock:
2707         rcu_read_unlock();
2708         if (!xa_is_value(page))
2709                 put_page(page);
2710 out:
2711         if (start > end)
2712                 return end;
2713         return start;
2714 }
2715
2716 #ifdef CONFIG_MMU
2717 #define MMAP_LOTSAMISS  (100)
2718 /*
2719  * lock_page_maybe_drop_mmap - lock the page, possibly dropping the mmap_lock
2720  * @vmf - the vm_fault for this fault.
2721  * @page - the page to lock.
2722  * @fpin - the pointer to the file we may pin (or is already pinned).
2723  *
2724  * This works similar to lock_page_or_retry in that it can drop the mmap_lock.
2725  * It differs in that it actually returns the page locked if it returns 1 and 0
2726  * if it couldn't lock the page.  If we did have to drop the mmap_lock then fpin
2727  * will point to the pinned file and needs to be fput()'ed at a later point.
2728  */
2729 static int lock_page_maybe_drop_mmap(struct vm_fault *vmf, struct page *page,
2730                                      struct file **fpin)
2731 {
2732         if (trylock_page(page))
2733                 return 1;
2734
2735         /*
2736          * NOTE! This will make us return with VM_FAULT_RETRY, but with
2737          * the mmap_lock still held. That's how FAULT_FLAG_RETRY_NOWAIT
2738          * is supposed to work. We have way too many special cases..
2739          */
2740         if (vmf->flags & FAULT_FLAG_RETRY_NOWAIT)
2741                 return 0;
2742
2743         *fpin = maybe_unlock_mmap_for_io(vmf, *fpin);
2744         if (vmf->flags & FAULT_FLAG_KILLABLE) {
2745                 if (__lock_page_killable(page)) {
2746                         /*
2747                          * We didn't have the right flags to drop the mmap_lock,
2748                          * but all fault_handlers only check for fatal signals
2749                          * if we return VM_FAULT_RETRY, so we need to drop the
2750                          * mmap_lock here and return 0 if we don't have a fpin.
2751                          */
2752                         if (*fpin == NULL)
2753                                 mmap_read_unlock(vmf->vma->vm_mm);
2754                         return 0;
2755                 }
2756         } else
2757                 __lock_page(page);
2758         return 1;
2759 }
2760
2761
2762 /*
2763  * Synchronous readahead happens when we don't even find a page in the page
2764  * cache at all.  We don't want to perform IO under the mmap sem, so if we have
2765  * to drop the mmap sem we return the file that was pinned in order for us to do
2766  * that.  If we didn't pin a file then we return NULL.  The file that is
2767  * returned needs to be fput()'ed when we're done with it.
2768  */
2769 static struct file *do_sync_mmap_readahead(struct vm_fault *vmf)
2770 {
2771         struct file *file = vmf->vma->vm_file;
2772         struct file_ra_state *ra = &file->f_ra;
2773         struct address_space *mapping = file->f_mapping;
2774         DEFINE_READAHEAD(ractl, file, mapping, vmf->pgoff);
2775         struct file *fpin = NULL;
2776         unsigned int mmap_miss;
2777
2778         /* If we don't want any read-ahead, don't bother */
2779         if (vmf->vma->vm_flags & VM_RAND_READ)
2780                 return fpin;
2781         if (!ra->ra_pages)
2782                 return fpin;
2783
2784         if (vmf->vma->vm_flags & VM_SEQ_READ) {
2785                 fpin = maybe_unlock_mmap_for_io(vmf, fpin);
2786                 page_cache_sync_ra(&ractl, ra, ra->ra_pages);
2787                 return fpin;
2788         }
2789
2790         /* Avoid banging the cache line if not needed */
2791         mmap_miss = READ_ONCE(ra->mmap_miss);
2792         if (mmap_miss < MMAP_LOTSAMISS * 10)
2793                 WRITE_ONCE(ra->mmap_miss, ++mmap_miss);
2794
2795         /*
2796          * Do we miss much more than hit in this file? If so,
2797          * stop bothering with read-ahead. It will only hurt.
2798          */
2799         if (mmap_miss > MMAP_LOTSAMISS)
2800                 return fpin;
2801
2802         /*
2803          * mmap read-around
2804          */
2805         fpin = maybe_unlock_mmap_for_io(vmf, fpin);
2806         ra->start = max_t(long, 0, vmf->pgoff - ra->ra_pages / 2);
2807         ra->size = ra->ra_pages;
2808         ra->async_size = ra->ra_pages / 4;
2809         ractl._index = ra->start;
2810         do_page_cache_ra(&ractl, ra->size, ra->async_size);
2811         return fpin;
2812 }
2813
2814 /*
2815  * Asynchronous readahead happens when we find the page and PG_readahead,
2816  * so we want to possibly extend the readahead further.  We return the file that
2817  * was pinned if we have to drop the mmap_lock in order to do IO.
2818  */
2819 static struct file *do_async_mmap_readahead(struct vm_fault *vmf,
2820                                             struct page *page)
2821 {
2822         struct file *file = vmf->vma->vm_file;
2823         struct file_ra_state *ra = &file->f_ra;
2824         struct address_space *mapping = file->f_mapping;
2825         struct file *fpin = NULL;
2826         unsigned int mmap_miss;
2827         pgoff_t offset = vmf->pgoff;
2828
2829         /* If we don't want any read-ahead, don't bother */
2830         if (vmf->vma->vm_flags & VM_RAND_READ || !ra->ra_pages)
2831                 return fpin;
2832         mmap_miss = READ_ONCE(ra->mmap_miss);
2833         if (mmap_miss)
2834                 WRITE_ONCE(ra->mmap_miss, --mmap_miss);
2835         if (PageReadahead(page)) {
2836                 fpin = maybe_unlock_mmap_for_io(vmf, fpin);
2837                 page_cache_async_readahead(mapping, ra, file,
2838                                            page, offset, ra->ra_pages);
2839         }
2840         return fpin;
2841 }
2842
2843 /**
2844  * filemap_fault - read in file data for page fault handling
2845  * @vmf:        struct vm_fault containing details of the fault
2846  *
2847  * filemap_fault() is invoked via the vma operations vector for a
2848  * mapped memory region to read in file data during a page fault.
2849  *
2850  * The goto's are kind of ugly, but this streamlines the normal case of having
2851  * it in the page cache, and handles the special cases reasonably without
2852  * having a lot of duplicated code.
2853  *
2854  * vma->vm_mm->mmap_lock must be held on entry.
2855  *
2856  * If our return value has VM_FAULT_RETRY set, it's because the mmap_lock
2857  * may be dropped before doing I/O or by lock_page_maybe_drop_mmap().
2858  *
2859  * If our return value does not have VM_FAULT_RETRY set, the mmap_lock
2860  * has not been released.
2861  *
2862  * We never return with VM_FAULT_RETRY and a bit from VM_FAULT_ERROR set.
2863  *
2864  * Return: bitwise-OR of %VM_FAULT_ codes.
2865  */
2866 vm_fault_t filemap_fault(struct vm_fault *vmf)
2867 {
2868         int error;
2869         struct file *file = vmf->vma->vm_file;
2870         struct file *fpin = NULL;
2871         struct address_space *mapping = file->f_mapping;
2872         struct file_ra_state *ra = &file->f_ra;
2873         struct inode *inode = mapping->host;
2874         pgoff_t offset = vmf->pgoff;
2875         pgoff_t max_off;
2876         struct page *page;
2877         vm_fault_t ret = 0;
2878
2879         max_off = DIV_ROUND_UP(i_size_read(inode), PAGE_SIZE);
2880         if (unlikely(offset >= max_off))
2881                 return VM_FAULT_SIGBUS;
2882
2883         /*
2884          * Do we have something in the page cache already?
2885          */
2886         page = find_get_page(mapping, offset);
2887         if (likely(page) && !(vmf->flags & FAULT_FLAG_TRIED)) {
2888                 /*
2889                  * We found the page, so try async readahead before
2890                  * waiting for the lock.
2891                  */
2892                 fpin = do_async_mmap_readahead(vmf, page);
2893         } else if (!page) {
2894                 /* No page in the page cache at all */
2895                 count_vm_event(PGMAJFAULT);
2896                 count_memcg_event_mm(vmf->vma->vm_mm, PGMAJFAULT);
2897                 ret = VM_FAULT_MAJOR;
2898                 fpin = do_sync_mmap_readahead(vmf);
2899 retry_find:
2900                 page = pagecache_get_page(mapping, offset,
2901                                           FGP_CREAT|FGP_FOR_MMAP,
2902                                           vmf->gfp_mask);
2903                 if (!page) {
2904                         if (fpin)
2905                                 goto out_retry;
2906                         return VM_FAULT_OOM;
2907                 }
2908         }
2909
2910         if (!lock_page_maybe_drop_mmap(vmf, page, &fpin))
2911                 goto out_retry;
2912
2913         /* Did it get truncated? */
2914         if (unlikely(compound_head(page)->mapping != mapping)) {
2915                 unlock_page(page);
2916                 put_page(page);
2917                 goto retry_find;
2918         }
2919         VM_BUG_ON_PAGE(page_to_pgoff(page) != offset, page);
2920
2921         /*
2922          * We have a locked page in the page cache, now we need to check
2923          * that it's up-to-date. If not, it is going to be due to an error.
2924          */
2925         if (unlikely(!PageUptodate(page)))
2926                 goto page_not_uptodate;
2927
2928         /*
2929          * We've made it this far and we had to drop our mmap_lock, now is the
2930          * time to return to the upper layer and have it re-find the vma and
2931          * redo the fault.
2932          */
2933         if (fpin) {
2934                 unlock_page(page);
2935                 goto out_retry;
2936         }
2937
2938         /*
2939          * Found the page and have a reference on it.
2940          * We must recheck i_size under page lock.
2941          */
2942         max_off = DIV_ROUND_UP(i_size_read(inode), PAGE_SIZE);
2943         if (unlikely(offset >= max_off)) {
2944                 unlock_page(page);
2945                 put_page(page);
2946                 return VM_FAULT_SIGBUS;
2947         }
2948
2949         vmf->page = page;
2950         return ret | VM_FAULT_LOCKED;
2951
2952 page_not_uptodate:
2953         /*
2954          * Umm, take care of errors if the page isn't up-to-date.
2955          * Try to re-read it _once_. We do this synchronously,
2956          * because there really aren't any performance issues here
2957          * and we need to check for errors.
2958          */
2959         ClearPageError(page);
2960         fpin = maybe_unlock_mmap_for_io(vmf, fpin);
2961         error = mapping->a_ops->readpage(file, page);
2962         if (!error) {
2963                 wait_on_page_locked(page);
2964                 if (!PageUptodate(page))
2965                         error = -EIO;
2966         }
2967         if (fpin)
2968                 goto out_retry;
2969         put_page(page);
2970
2971         if (!error || error == AOP_TRUNCATED_PAGE)
2972                 goto retry_find;
2973
2974         shrink_readahead_size_eio(ra);
2975         return VM_FAULT_SIGBUS;
2976
2977 out_retry:
2978         /*
2979          * We dropped the mmap_lock, we need to return to the fault handler to
2980          * re-find the vma and come back and find our hopefully still populated
2981          * page.
2982          */
2983         if (page)
2984                 put_page(page);
2985         if (fpin)
2986                 fput(fpin);
2987         return ret | VM_FAULT_RETRY;
2988 }
2989 EXPORT_SYMBOL(filemap_fault);
2990
2991 static bool filemap_map_pmd(struct vm_fault *vmf, struct page *page)
2992 {
2993         struct mm_struct *mm = vmf->vma->vm_mm;
2994
2995         /* Huge page is mapped? No need to proceed. */
2996         if (pmd_trans_huge(*vmf->pmd)) {
2997                 unlock_page(page);
2998                 put_page(page);
2999                 return true;
3000         }
3001
3002         if (pmd_none(*vmf->pmd) && PageTransHuge(page)) {
3003             vm_fault_t ret = do_set_pmd(vmf, page);
3004             if (!ret) {
3005                     /* The page is mapped successfully, reference consumed. */
3006                     unlock_page(page);
3007                     return true;
3008             }
3009         }
3010
3011         if (pmd_none(*vmf->pmd)) {
3012                 vmf->ptl = pmd_lock(mm, vmf->pmd);
3013                 if (likely(pmd_none(*vmf->pmd))) {
3014                         mm_inc_nr_ptes(mm);
3015                         pmd_populate(mm, vmf->pmd, vmf->prealloc_pte);
3016                         vmf->prealloc_pte = NULL;
3017                 }
3018                 spin_unlock(vmf->ptl);
3019         }
3020
3021         /* See comment in handle_pte_fault() */
3022         if (pmd_devmap_trans_unstable(vmf->pmd)) {
3023                 unlock_page(page);
3024                 put_page(page);
3025                 return true;
3026         }
3027
3028         return false;
3029 }
3030
3031 static struct page *next_uptodate_page(struct page *page,
3032                                        struct address_space *mapping,
3033                                        struct xa_state *xas, pgoff_t end_pgoff)
3034 {
3035         unsigned long max_idx;
3036
3037         do {
3038                 if (!page)
3039                         return NULL;
3040                 if (xas_retry(xas, page))
3041                         continue;
3042                 if (xa_is_value(page))
3043                         continue;
3044                 if (PageLocked(page))
3045                         continue;
3046                 if (!page_cache_get_speculative(page))
3047                         continue;
3048                 /* Has the page moved or been split? */
3049                 if (unlikely(page != xas_reload(xas)))
3050                         goto skip;
3051                 if (!PageUptodate(page) || PageReadahead(page))
3052                         goto skip;
3053                 if (PageHWPoison(page))
3054                         goto skip;
3055                 if (!trylock_page(page))
3056                         goto skip;
3057                 if (page->mapping != mapping)
3058                         goto unlock;
3059                 if (!PageUptodate(page))
3060                         goto unlock;
3061                 max_idx = DIV_ROUND_UP(i_size_read(mapping->host), PAGE_SIZE);
3062                 if (xas->xa_index >= max_idx)
3063                         goto unlock;
3064                 return page;
3065 unlock:
3066                 unlock_page(page);
3067 skip:
3068                 put_page(page);
3069         } while ((page = xas_next_entry(xas, end_pgoff)) != NULL);
3070
3071         return NULL;
3072 }
3073
3074 static inline struct page *first_map_page(struct address_space *mapping,
3075                                           struct xa_state *xas,
3076                                           pgoff_t end_pgoff)
3077 {
3078         return next_uptodate_page(xas_find(xas, end_pgoff),
3079                                   mapping, xas, end_pgoff);
3080 }
3081
3082 static inline struct page *next_map_page(struct address_space *mapping,
3083                                          struct xa_state *xas,
3084                                          pgoff_t end_pgoff)
3085 {
3086         return next_uptodate_page(xas_next_entry(xas, end_pgoff),
3087                                   mapping, xas, end_pgoff);
3088 }
3089
3090 vm_fault_t filemap_map_pages(struct vm_fault *vmf,
3091                              pgoff_t start_pgoff, pgoff_t end_pgoff)
3092 {
3093         struct vm_area_struct *vma = vmf->vma;
3094         struct file *file = vma->vm_file;
3095         struct address_space *mapping = file->f_mapping;
3096         pgoff_t last_pgoff = start_pgoff;
3097         unsigned long addr;
3098         XA_STATE(xas, &mapping->i_pages, start_pgoff);
3099         struct page *head, *page;
3100         unsigned int mmap_miss = READ_ONCE(file->f_ra.mmap_miss);
3101         vm_fault_t ret = 0;
3102
3103         rcu_read_lock();
3104         head = first_map_page(mapping, &xas, end_pgoff);
3105         if (!head)
3106                 goto out;
3107
3108         if (filemap_map_pmd(vmf, head)) {
3109                 ret = VM_FAULT_NOPAGE;
3110                 goto out;
3111         }
3112
3113         addr = vma->vm_start + ((start_pgoff - vma->vm_pgoff) << PAGE_SHIFT);
3114         vmf->pte = pte_offset_map_lock(vma->vm_mm, vmf->pmd, addr, &vmf->ptl);
3115         do {
3116                 page = find_subpage(head, xas.xa_index);
3117                 if (PageHWPoison(page))
3118                         goto unlock;
3119
3120                 if (mmap_miss > 0)
3121                         mmap_miss--;
3122
3123                 addr += (xas.xa_index - last_pgoff) << PAGE_SHIFT;
3124                 vmf->pte += xas.xa_index - last_pgoff;
3125                 last_pgoff = xas.xa_index;
3126
3127                 if (!pte_none(*vmf->pte))
3128                         goto unlock;
3129
3130                 /* We're about to handle the fault */
3131                 if (vmf->address == addr)
3132                         ret = VM_FAULT_NOPAGE;
3133
3134                 do_set_pte(vmf, page, addr);
3135                 /* no need to invalidate: a not-present page won't be cached */
3136                 update_mmu_cache(vma, addr, vmf->pte);
3137                 unlock_page(head);
3138                 continue;
3139 unlock:
3140                 unlock_page(head);
3141                 put_page(head);
3142         } while ((head = next_map_page(mapping, &xas, end_pgoff)) != NULL);
3143         pte_unmap_unlock(vmf->pte, vmf->ptl);
3144 out:
3145         rcu_read_unlock();
3146         WRITE_ONCE(file->f_ra.mmap_miss, mmap_miss);
3147         return ret;
3148 }
3149 EXPORT_SYMBOL(filemap_map_pages);
3150
3151 vm_fault_t filemap_page_mkwrite(struct vm_fault *vmf)
3152 {
3153         struct address_space *mapping = vmf->vma->vm_file->f_mapping;
3154         struct page *page = vmf->page;
3155         vm_fault_t ret = VM_FAULT_LOCKED;
3156
3157         sb_start_pagefault(mapping->host->i_sb);
3158         file_update_time(vmf->vma->vm_file);
3159         lock_page(page);
3160         if (page->mapping != mapping) {
3161                 unlock_page(page);
3162                 ret = VM_FAULT_NOPAGE;
3163                 goto out;
3164         }
3165         /*
3166          * We mark the page dirty already here so that when freeze is in
3167          * progress, we are guaranteed that writeback during freezing will
3168          * see the dirty page and writeprotect it again.
3169          */
3170         set_page_dirty(page);
3171         wait_for_stable_page(page);
3172 out:
3173         sb_end_pagefault(mapping->host->i_sb);
3174         return ret;
3175 }
3176
3177 const struct vm_operations_struct generic_file_vm_ops = {
3178         .fault          = filemap_fault,
3179         .map_pages      = filemap_map_pages,
3180         .page_mkwrite   = filemap_page_mkwrite,
3181 };
3182
3183 /* This is used for a general mmap of a disk file */
3184
3185 int generic_file_mmap(struct file * file, struct vm_area_struct * vma)
3186 {
3187         struct address_space *mapping = file->f_mapping;
3188
3189         if (!mapping->a_ops->readpage)
3190                 return -ENOEXEC;
3191         file_accessed(file);
3192         vma->vm_ops = &generic_file_vm_ops;
3193         return 0;
3194 }
3195
3196 /*
3197  * This is for filesystems which do not implement ->writepage.
3198  */
3199 int generic_file_readonly_mmap(struct file *file, struct vm_area_struct *vma)
3200 {
3201         if ((vma->vm_flags & VM_SHARED) && (vma->vm_flags & VM_MAYWRITE))
3202                 return -EINVAL;
3203         return generic_file_mmap(file, vma);
3204 }
3205 #else
3206 vm_fault_t filemap_page_mkwrite(struct vm_fault *vmf)
3207 {
3208         return VM_FAULT_SIGBUS;
3209 }
3210 int generic_file_mmap(struct file * file, struct vm_area_struct * vma)
3211 {
3212         return -ENOSYS;
3213 }
3214 int generic_file_readonly_mmap(struct file * file, struct vm_area_struct * vma)
3215 {
3216         return -ENOSYS;
3217 }
3218 #endif /* CONFIG_MMU */
3219
3220 EXPORT_SYMBOL(filemap_page_mkwrite);
3221 EXPORT_SYMBOL(generic_file_mmap);
3222 EXPORT_SYMBOL(generic_file_readonly_mmap);
3223
3224 static struct page *wait_on_page_read(struct page *page)
3225 {
3226         if (!IS_ERR(page)) {
3227                 wait_on_page_locked(page);
3228                 if (!PageUptodate(page)) {
3229                         put_page(page);
3230                         page = ERR_PTR(-EIO);
3231                 }
3232         }
3233         return page;
3234 }
3235
3236 static struct page *do_read_cache_page(struct address_space *mapping,
3237                                 pgoff_t index,
3238                                 int (*filler)(void *, struct page *),
3239                                 void *data,
3240                                 gfp_t gfp)
3241 {
3242         struct page *page;
3243         int err;
3244 repeat:
3245         page = find_get_page(mapping, index);
3246         if (!page) {
3247                 page = __page_cache_alloc(gfp);
3248                 if (!page)
3249                         return ERR_PTR(-ENOMEM);
3250                 err = add_to_page_cache_lru(page, mapping, index, gfp);
3251                 if (unlikely(err)) {
3252                         put_page(page);
3253                         if (err == -EEXIST)
3254                                 goto repeat;
3255                         /* Presumably ENOMEM for xarray node */
3256                         return ERR_PTR(err);
3257                 }
3258
3259 filler:
3260                 if (filler)
3261                         err = filler(data, page);
3262                 else
3263                         err = mapping->a_ops->readpage(data, page);
3264
3265                 if (err < 0) {
3266                         put_page(page);
3267                         return ERR_PTR(err);
3268                 }
3269
3270                 page = wait_on_page_read(page);
3271                 if (IS_ERR(page))
3272                         return page;
3273                 goto out;
3274         }
3275         if (PageUptodate(page))
3276                 goto out;
3277
3278         /*
3279          * Page is not up to date and may be locked due to one of the following
3280          * case a: Page is being filled and the page lock is held
3281          * case b: Read/write error clearing the page uptodate status
3282          * case c: Truncation in progress (page locked)
3283          * case d: Reclaim in progress
3284          *
3285          * Case a, the page will be up to date when the page is unlocked.
3286          *    There is no need to serialise on the page lock here as the page
3287          *    is pinned so the lock gives no additional protection. Even if the
3288          *    page is truncated, the data is still valid if PageUptodate as
3289          *    it's a race vs truncate race.
3290          * Case b, the page will not be up to date
3291          * Case c, the page may be truncated but in itself, the data may still
3292          *    be valid after IO completes as it's a read vs truncate race. The
3293          *    operation must restart if the page is not uptodate on unlock but
3294          *    otherwise serialising on page lock to stabilise the mapping gives
3295          *    no additional guarantees to the caller as the page lock is
3296          *    released before return.
3297          * Case d, similar to truncation. If reclaim holds the page lock, it
3298          *    will be a race with remove_mapping that determines if the mapping
3299          *    is valid on unlock but otherwise the data is valid and there is
3300          *    no need to serialise with page lock.
3301          *
3302          * As the page lock gives no additional guarantee, we optimistically
3303          * wait on the page to be unlocked and check if it's up to date and
3304          * use the page if it is. Otherwise, the page lock is required to
3305          * distinguish between the different cases. The motivation is that we
3306          * avoid spurious serialisations and wakeups when multiple processes
3307          * wait on the same page for IO to complete.
3308          */
3309         wait_on_page_locked(page);
3310         if (PageUptodate(page))
3311                 goto out;
3312
3313         /* Distinguish between all the cases under the safety of the lock */
3314         lock_page(page);
3315
3316         /* Case c or d, restart the operation */
3317         if (!page->mapping) {
3318                 unlock_page(page);
3319                 put_page(page);
3320                 goto repeat;
3321         }
3322
3323         /* Someone else locked and filled the page in a very small window */
3324         if (PageUptodate(page)) {
3325                 unlock_page(page);
3326                 goto out;
3327         }
3328
3329         /*
3330          * A previous I/O error may have been due to temporary
3331          * failures.
3332          * Clear page error before actual read, PG_error will be
3333          * set again if read page fails.
3334          */
3335         ClearPageError(page);
3336         goto filler;
3337
3338 out:
3339         mark_page_accessed(page);
3340         return page;
3341 }
3342
3343 /**
3344  * read_cache_page - read into page cache, fill it if needed
3345  * @mapping:    the page's address_space
3346  * @index:      the page index
3347  * @filler:     function to perform the read
3348  * @data:       first arg to filler(data, page) function, often left as NULL
3349  *
3350  * Read into the page cache. If a page already exists, and PageUptodate() is
3351  * not set, try to fill the page and wait for it to become unlocked.
3352  *
3353  * If the page does not get brought uptodate, return -EIO.
3354  *
3355  * Return: up to date page on success, ERR_PTR() on failure.
3356  */
3357 struct page *read_cache_page(struct address_space *mapping,
3358                                 pgoff_t index,
3359                                 int (*filler)(void *, struct page *),
3360                                 void *data)
3361 {
3362         return do_read_cache_page(mapping, index, filler, data,
3363                         mapping_gfp_mask(mapping));
3364 }
3365 EXPORT_SYMBOL(read_cache_page);
3366
3367 /**
3368  * read_cache_page_gfp - read into page cache, using specified page allocation flags.
3369  * @mapping:    the page's address_space
3370  * @index:      the page index
3371  * @gfp:        the page allocator flags to use if allocating
3372  *
3373  * This is the same as "read_mapping_page(mapping, index, NULL)", but with
3374  * any new page allocations done using the specified allocation flags.
3375  *
3376  * If the page does not get brought uptodate, return -EIO.
3377  *
3378  * Return: up to date page on success, ERR_PTR() on failure.
3379  */
3380 struct page *read_cache_page_gfp(struct address_space *mapping,
3381                                 pgoff_t index,
3382                                 gfp_t gfp)
3383 {
3384         return do_read_cache_page(mapping, index, NULL, NULL, gfp);
3385 }
3386 EXPORT_SYMBOL(read_cache_page_gfp);
3387
3388 int pagecache_write_begin(struct file *file, struct address_space *mapping,
3389                                 loff_t pos, unsigned len, unsigned flags,
3390                                 struct page **pagep, void **fsdata)
3391 {
3392         const struct address_space_operations *aops = mapping->a_ops;
3393
3394         return aops->write_begin(file, mapping, pos, len, flags,
3395                                                         pagep, fsdata);
3396 }
3397 EXPORT_SYMBOL(pagecache_write_begin);
3398
3399 int pagecache_write_end(struct file *file, struct address_space *mapping,
3400                                 loff_t pos, unsigned len, unsigned copied,
3401                                 struct page *page, void *fsdata)
3402 {
3403         const struct address_space_operations *aops = mapping->a_ops;
3404
3405         return aops->write_end(file, mapping, pos, len, copied, page, fsdata);
3406 }
3407 EXPORT_SYMBOL(pagecache_write_end);
3408
3409 /*
3410  * Warn about a page cache invalidation failure during a direct I/O write.
3411  */
3412 void dio_warn_stale_pagecache(struct file *filp)
3413 {
3414         static DEFINE_RATELIMIT_STATE(_rs, 86400 * HZ, DEFAULT_RATELIMIT_BURST);
3415         char pathname[128];
3416         char *path;
3417
3418         errseq_set(&filp->f_mapping->wb_err, -EIO);
3419         if (__ratelimit(&_rs)) {
3420                 path = file_path(filp, pathname, sizeof(pathname));
3421                 if (IS_ERR(path))
3422                         path = "(unknown)";
3423                 pr_crit("Page cache invalidation failure on direct I/O.  Possible data corruption due to collision with buffered I/O!\n");
3424                 pr_crit("File: %s PID: %d Comm: %.20s\n", path, current->pid,
3425                         current->comm);
3426         }
3427 }
3428
3429 ssize_t
3430 generic_file_direct_write(struct kiocb *iocb, struct iov_iter *from)
3431 {
3432         struct file     *file = iocb->ki_filp;
3433         struct address_space *mapping = file->f_mapping;
3434         struct inode    *inode = mapping->host;
3435         loff_t          pos = iocb->ki_pos;
3436         ssize_t         written;
3437         size_t          write_len;
3438         pgoff_t         end;
3439
3440         write_len = iov_iter_count(from);
3441         end = (pos + write_len - 1) >> PAGE_SHIFT;
3442
3443         if (iocb->ki_flags & IOCB_NOWAIT) {
3444                 /* If there are pages to writeback, return */
3445                 if (filemap_range_has_page(file->f_mapping, pos,
3446                                            pos + write_len - 1))
3447                         return -EAGAIN;
3448         } else {
3449                 written = filemap_write_and_wait_range(mapping, pos,
3450                                                         pos + write_len - 1);
3451                 if (written)
3452                         goto out;
3453         }
3454
3455         /*
3456          * After a write we want buffered reads to be sure to go to disk to get
3457          * the new data.  We invalidate clean cached page from the region we're
3458          * about to write.  We do this *before* the write so that we can return
3459          * without clobbering -EIOCBQUEUED from ->direct_IO().
3460          */
3461         written = invalidate_inode_pages2_range(mapping,
3462                                         pos >> PAGE_SHIFT, end);
3463         /*
3464          * If a page can not be invalidated, return 0 to fall back
3465          * to buffered write.
3466          */
3467         if (written) {
3468                 if (written == -EBUSY)
3469                         return 0;
3470                 goto out;
3471         }
3472
3473         written = mapping->a_ops->direct_IO(iocb, from);
3474
3475         /*
3476          * Finally, try again to invalidate clean pages which might have been
3477          * cached by non-direct readahead, or faulted in by get_user_pages()
3478          * if the source of the write was an mmap'ed region of the file
3479          * we're writing.  Either one is a pretty crazy thing to do,
3480          * so we don't support it 100%.  If this invalidation
3481          * fails, tough, the write still worked...
3482          *
3483          * Most of the time we do not need this since dio_complete() will do
3484          * the invalidation for us. However there are some file systems that
3485          * do not end up with dio_complete() being called, so let's not break
3486          * them by removing it completely.
3487          *
3488          * Noticeable example is a blkdev_direct_IO().
3489          *
3490          * Skip invalidation for async writes or if mapping has no pages.
3491          */
3492         if (written > 0 && mapping->nrpages &&
3493             invalidate_inode_pages2_range(mapping, pos >> PAGE_SHIFT, end))
3494                 dio_warn_stale_pagecache(file);
3495
3496         if (written > 0) {
3497                 pos += written;
3498                 write_len -= written;
3499                 if (pos > i_size_read(inode) && !S_ISBLK(inode->i_mode)) {
3500                         i_size_write(inode, pos);
3501                         mark_inode_dirty(inode);
3502                 }
3503                 iocb->ki_pos = pos;
3504         }
3505         if (written != -EIOCBQUEUED)
3506                 iov_iter_revert(from, write_len - iov_iter_count(from));
3507 out:
3508         return written;
3509 }
3510 EXPORT_SYMBOL(generic_file_direct_write);
3511
3512 /*
3513  * Find or create a page at the given pagecache position. Return the locked
3514  * page. This function is specifically for buffered writes.
3515  */
3516 struct page *grab_cache_page_write_begin(struct address_space *mapping,
3517                                         pgoff_t index, unsigned flags)
3518 {
3519         struct page *page;
3520         int fgp_flags = FGP_LOCK|FGP_WRITE|FGP_CREAT;
3521
3522         if (flags & AOP_FLAG_NOFS)
3523                 fgp_flags |= FGP_NOFS;
3524
3525         page = pagecache_get_page(mapping, index, fgp_flags,
3526                         mapping_gfp_mask(mapping));
3527         if (page)
3528                 wait_for_stable_page(page);
3529
3530         return page;
3531 }
3532 EXPORT_SYMBOL(grab_cache_page_write_begin);
3533
3534 ssize_t generic_perform_write(struct file *file,
3535                                 struct iov_iter *i, loff_t pos)
3536 {
3537         struct address_space *mapping = file->f_mapping;
3538         const struct address_space_operations *a_ops = mapping->a_ops;
3539         long status = 0;
3540         ssize_t written = 0;
3541         unsigned int flags = 0;
3542
3543         do {
3544                 struct page *page;
3545                 unsigned long offset;   /* Offset into pagecache page */
3546                 unsigned long bytes;    /* Bytes to write to page */
3547                 size_t copied;          /* Bytes copied from user */
3548                 void *fsdata;
3549
3550                 offset = (pos & (PAGE_SIZE - 1));
3551                 bytes = min_t(unsigned long, PAGE_SIZE - offset,
3552                                                 iov_iter_count(i));
3553
3554 again:
3555                 /*
3556                  * Bring in the user page that we will copy from _first_.
3557                  * Otherwise there's a nasty deadlock on copying from the
3558                  * same page as we're writing to, without it being marked
3559                  * up-to-date.
3560                  *
3561                  * Not only is this an optimisation, but it is also required
3562                  * to check that the address is actually valid, when atomic
3563                  * usercopies are used, below.
3564                  */
3565                 if (unlikely(iov_iter_fault_in_readable(i, bytes))) {
3566                         status = -EFAULT;
3567                         break;
3568                 }
3569
3570                 if (fatal_signal_pending(current)) {
3571                         status = -EINTR;
3572                         break;
3573                 }
3574
3575                 status = a_ops->write_begin(file, mapping, pos, bytes, flags,
3576                                                 &page, &fsdata);
3577                 if (unlikely(status < 0))
3578                         break;
3579
3580                 if (mapping_writably_mapped(mapping))
3581                         flush_dcache_page(page);
3582
3583                 copied = iov_iter_copy_from_user_atomic(page, i, offset, bytes);
3584                 flush_dcache_page(page);
3585
3586                 status = a_ops->write_end(file, mapping, pos, bytes, copied,
3587                                                 page, fsdata);
3588                 if (unlikely(status < 0))
3589                         break;
3590                 copied = status;
3591
3592                 cond_resched();
3593
3594                 iov_iter_advance(i, copied);
3595                 if (unlikely(copied == 0)) {
3596                         /*
3597                          * If we were unable to copy any data at all, we must
3598                          * fall back to a single segment length write.
3599                          *
3600                          * If we didn't fallback here, we could livelock
3601                          * because not all segments in the iov can be copied at
3602                          * once without a pagefault.
3603                          */
3604                         bytes = min_t(unsigned long, PAGE_SIZE - offset,
3605                                                 iov_iter_single_seg_count(i));
3606                         goto again;
3607                 }
3608                 pos += copied;
3609                 written += copied;
3610
3611                 balance_dirty_pages_ratelimited(mapping);
3612         } while (iov_iter_count(i));
3613
3614         return written ? written : status;
3615 }
3616 EXPORT_SYMBOL(generic_perform_write);
3617
3618 /**
3619  * __generic_file_write_iter - write data to a file
3620  * @iocb:       IO state structure (file, offset, etc.)
3621  * @from:       iov_iter with data to write
3622  *
3623  * This function does all the work needed for actually writing data to a
3624  * file. It does all basic checks, removes SUID from the file, updates
3625  * modification times and calls proper subroutines depending on whether we
3626  * do direct IO or a standard buffered write.
3627  *
3628  * It expects i_mutex to be grabbed unless we work on a block device or similar
3629  * object which does not need locking at all.
3630  *
3631  * This function does *not* take care of syncing data in case of O_SYNC write.
3632  * A caller has to handle it. This is mainly due to the fact that we want to
3633  * avoid syncing under i_mutex.
3634  *
3635  * Return:
3636  * * number of bytes written, even for truncated writes
3637  * * negative error code if no data has been written at all
3638  */
3639 ssize_t __generic_file_write_iter(struct kiocb *iocb, struct iov_iter *from)
3640 {
3641         struct file *file = iocb->ki_filp;
3642         struct address_space * mapping = file->f_mapping;
3643         struct inode    *inode = mapping->host;
3644         ssize_t         written = 0;
3645         ssize_t         err;
3646         ssize_t         status;
3647
3648         /* We can write back this queue in page reclaim */
3649         current->backing_dev_info = inode_to_bdi(inode);
3650         err = file_remove_privs(file);
3651         if (err)
3652                 goto out;
3653
3654         err = file_update_time(file);
3655         if (err)
3656                 goto out;
3657
3658         if (iocb->ki_flags & IOCB_DIRECT) {
3659                 loff_t pos, endbyte;
3660
3661                 written = generic_file_direct_write(iocb, from);
3662                 /*
3663                  * If the write stopped short of completing, fall back to
3664                  * buffered writes.  Some filesystems do this for writes to
3665                  * holes, for example.  For DAX files, a buffered write will
3666                  * not succeed (even if it did, DAX does not handle dirty
3667                  * page-cache pages correctly).
3668                  */
3669                 if (written < 0 || !iov_iter_count(from) || IS_DAX(inode))
3670                         goto out;
3671
3672                 status = generic_perform_write(file, from, pos = iocb->ki_pos);
3673                 /*
3674                  * If generic_perform_write() returned a synchronous error
3675                  * then we want to return the number of bytes which were
3676                  * direct-written, or the error code if that was zero.  Note
3677                  * that this differs from normal direct-io semantics, which
3678                  * will return -EFOO even if some bytes were written.
3679                  */
3680                 if (unlikely(status < 0)) {
3681                         err = status;
3682                         goto out;
3683                 }
3684                 /*
3685                  * We need to ensure that the page cache pages are written to
3686                  * disk and invalidated to preserve the expected O_DIRECT
3687                  * semantics.
3688                  */
3689                 endbyte = pos + status - 1;
3690                 err = filemap_write_and_wait_range(mapping, pos, endbyte);
3691                 if (err == 0) {
3692                         iocb->ki_pos = endbyte + 1;
3693                         written += status;
3694                         invalidate_mapping_pages(mapping,
3695                                                  pos >> PAGE_SHIFT,
3696                                                  endbyte >> PAGE_SHIFT);
3697                 } else {
3698                         /*
3699                          * We don't know how much we wrote, so just return
3700                          * the number of bytes which were direct-written
3701                          */
3702                 }
3703         } else {
3704                 written = generic_perform_write(file, from, iocb->ki_pos);
3705                 if (likely(written > 0))
3706                         iocb->ki_pos += written;
3707         }
3708 out:
3709         current->backing_dev_info = NULL;
3710         return written ? written : err;
3711 }
3712 EXPORT_SYMBOL(__generic_file_write_iter);
3713
3714 /**
3715  * generic_file_write_iter - write data to a file
3716  * @iocb:       IO state structure
3717  * @from:       iov_iter with data to write
3718  *
3719  * This is a wrapper around __generic_file_write_iter() to be used by most
3720  * filesystems. It takes care of syncing the file in case of O_SYNC file
3721  * and acquires i_mutex as needed.
3722  * Return:
3723  * * negative error code if no data has been written at all of
3724  *   vfs_fsync_range() failed for a synchronous write
3725  * * number of bytes written, even for truncated writes
3726  */
3727 ssize_t generic_file_write_iter(struct kiocb *iocb, struct iov_iter *from)
3728 {
3729         struct file *file = iocb->ki_filp;
3730         struct inode *inode = file->f_mapping->host;
3731         ssize_t ret;
3732
3733         inode_lock(inode);
3734         ret = generic_write_checks(iocb, from);
3735         if (ret > 0)
3736                 ret = __generic_file_write_iter(iocb, from);
3737         inode_unlock(inode);
3738
3739         if (ret > 0)
3740                 ret = generic_write_sync(iocb, ret);
3741         return ret;
3742 }
3743 EXPORT_SYMBOL(generic_file_write_iter);
3744
3745 /**
3746  * try_to_release_page() - release old fs-specific metadata on a page
3747  *
3748  * @page: the page which the kernel is trying to free
3749  * @gfp_mask: memory allocation flags (and I/O mode)
3750  *
3751  * The address_space is to try to release any data against the page
3752  * (presumably at page->private).
3753  *
3754  * This may also be called if PG_fscache is set on a page, indicating that the
3755  * page is known to the local caching routines.
3756  *
3757  * The @gfp_mask argument specifies whether I/O may be performed to release
3758  * this page (__GFP_IO), and whether the call may block (__GFP_RECLAIM & __GFP_FS).
3759  *
3760  * Return: %1 if the release was successful, otherwise return zero.
3761  */
3762 int try_to_release_page(struct page *page, gfp_t gfp_mask)
3763 {
3764         struct address_space * const mapping = page->mapping;
3765
3766         BUG_ON(!PageLocked(page));
3767         if (PageWriteback(page))
3768                 return 0;
3769
3770         if (mapping && mapping->a_ops->releasepage)
3771                 return mapping->a_ops->releasepage(page, gfp_mask);
3772         return try_to_free_buffers(page);
3773 }
3774
3775 EXPORT_SYMBOL(try_to_release_page);