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