Lines Matching full:page
30 * Regular page slots are stabilized by the page lock even without the tree
83 struct page *page = pvec->pages[i]; in truncate_exceptional_pvec_entries() local
86 if (!xa_is_value(page)) { in truncate_exceptional_pvec_entries()
87 pvec->pages[j++] = page; in truncate_exceptional_pvec_entries()
99 __clear_shadow_entry(mapping, index, page); in truncate_exceptional_pvec_entries()
138 * do_invalidatepage - invalidate part or all of a page
139 * @page: the page which is affected
143 * do_invalidatepage() is called when all or part of the page has become
152 void do_invalidatepage(struct page *page, unsigned int offset, in do_invalidatepage() argument
155 void (*invalidatepage)(struct page *, unsigned int, unsigned int); in do_invalidatepage()
157 invalidatepage = page->mapping->a_ops->invalidatepage; in do_invalidatepage()
163 (*invalidatepage)(page, offset, length); in do_invalidatepage()
167 * If truncate cannot remove the fs-private metadata from the page, the page
171 * We need to bail out if page->mapping is no longer equal to the original
172 * mapping. This happens a) when the VM reclaimed the page while we waited on
174 * c) when tmpfs swizzles a page between a tmpfs inode and swapper_space.
176 static void truncate_cleanup_page(struct page *page) in truncate_cleanup_page() argument
178 if (page_mapped(page)) in truncate_cleanup_page()
179 unmap_mapping_page(page); in truncate_cleanup_page()
181 if (page_has_private(page)) in truncate_cleanup_page()
182 do_invalidatepage(page, 0, thp_size(page)); in truncate_cleanup_page()
185 * Some filesystems seem to re-dirty the page even after in truncate_cleanup_page()
189 cancel_dirty_page(page); in truncate_cleanup_page()
190 ClearPageMappedToDisk(page); in truncate_cleanup_page()
199 * Returns non-zero if the page was successfully invalidated.
202 invalidate_complete_page(struct address_space *mapping, struct page *page) in invalidate_complete_page() argument
206 if (page->mapping != mapping) in invalidate_complete_page()
209 if (page_has_private(page) && !try_to_release_page(page, 0)) in invalidate_complete_page()
212 ret = remove_mapping(mapping, page); in invalidate_complete_page()
217 int truncate_inode_page(struct address_space *mapping, struct page *page) in truncate_inode_page() argument
219 VM_BUG_ON_PAGE(PageTail(page), page); in truncate_inode_page()
221 if (page->mapping != mapping) in truncate_inode_page()
224 truncate_cleanup_page(page); in truncate_inode_page()
225 delete_from_page_cache(page); in truncate_inode_page()
232 int generic_error_remove_page(struct address_space *mapping, struct page *page) in generic_error_remove_page() argument
242 return truncate_inode_page(mapping, page); in generic_error_remove_page()
247 * Safely invalidate one page from its pagecache mapping.
248 * It only drops clean, unused pages. The page must be locked.
250 * Returns 1 if the page is successfully invalidated, otherwise 0.
252 int invalidate_inode_page(struct page *page) in invalidate_inode_page() argument
254 struct address_space *mapping = page_mapping(page); in invalidate_inode_page()
257 if (PageDirty(page) || PageWriteback(page)) in invalidate_inode_page()
259 if (page_mapped(page)) in invalidate_inode_page()
261 return invalidate_complete_page(mapping, page); in invalidate_inode_page()
270 * Truncate the page cache, removing the pages that are between
272 * if lstart or lend + 1 is not page aligned).
275 * block on page locks and it will not block on writeback. The second pass
280 * We pass down the cache-hot hint to the page freeing code. Even if the
286 * page aligned properly.
338 struct page *page = pvec.pages[i]; in truncate_inode_pages_range() local
340 /* We rely upon deletion not changing page->index */ in truncate_inode_pages_range()
345 if (xa_is_value(page)) in truncate_inode_pages_range()
348 if (!trylock_page(page)) in truncate_inode_pages_range()
350 WARN_ON(page_to_index(page) != index); in truncate_inode_pages_range()
351 if (PageWriteback(page)) { in truncate_inode_pages_range()
352 unlock_page(page); in truncate_inode_pages_range()
355 if (page->mapping != mapping) { in truncate_inode_pages_range()
356 unlock_page(page); in truncate_inode_pages_range()
359 pagevec_add(&locked_pvec, page); in truncate_inode_pages_range()
372 struct page *page = find_lock_page(mapping, start - 1); in truncate_inode_pages_range() local
373 if (page) { in truncate_inode_pages_range()
376 /* Truncation within a single page */ in truncate_inode_pages_range()
380 wait_on_page_writeback(page); in truncate_inode_pages_range()
381 zero_user_segment(page, partial_start, top); in truncate_inode_pages_range()
382 cleancache_invalidate_page(mapping, page); in truncate_inode_pages_range()
383 if (page_has_private(page)) in truncate_inode_pages_range()
384 do_invalidatepage(page, partial_start, in truncate_inode_pages_range()
386 unlock_page(page); in truncate_inode_pages_range()
387 put_page(page); in truncate_inode_pages_range()
391 struct page *page = find_lock_page(mapping, end); in truncate_inode_pages_range() local
392 if (page) { in truncate_inode_pages_range()
393 wait_on_page_writeback(page); in truncate_inode_pages_range()
394 zero_user_segment(page, 0, partial_end); in truncate_inode_pages_range()
395 cleancache_invalidate_page(mapping, page); in truncate_inode_pages_range()
396 if (page_has_private(page)) in truncate_inode_pages_range()
397 do_invalidatepage(page, 0, in truncate_inode_pages_range()
399 unlock_page(page); in truncate_inode_pages_range()
400 put_page(page); in truncate_inode_pages_range()
404 * If the truncation happened within a single page no pages in truncate_inode_pages_range()
430 struct page *page = pvec.pages[i]; in truncate_inode_pages_range() local
432 /* We rely upon deletion not changing page->index */ in truncate_inode_pages_range()
440 if (xa_is_value(page)) in truncate_inode_pages_range()
443 lock_page(page); in truncate_inode_pages_range()
444 WARN_ON(page_to_index(page) != index); in truncate_inode_pages_range()
445 wait_on_page_writeback(page); in truncate_inode_pages_range()
446 truncate_inode_page(mapping, page); in truncate_inode_pages_range()
447 unlock_page(page); in truncate_inode_pages_range()
466 * Note: When this function returns, there can be a page in the process of
492 * Page reclaim can not participate in regular inode lifetime in truncate_inode_pages_final()
543 struct page *page = pvec.pages[i]; in __invalidate_mapping_pages() local
545 /* We rely upon deletion not changing page->index */ in __invalidate_mapping_pages()
550 if (xa_is_value(page)) { in __invalidate_mapping_pages()
552 page); in __invalidate_mapping_pages()
556 if (!trylock_page(page)) in __invalidate_mapping_pages()
559 WARN_ON(page_to_index(page) != index); in __invalidate_mapping_pages()
562 if (PageTransTail(page)) { in __invalidate_mapping_pages()
563 unlock_page(page); in __invalidate_mapping_pages()
565 } else if (PageTransHuge(page)) { in __invalidate_mapping_pages()
570 * invalidate the page as the part outside of in __invalidate_mapping_pages()
574 unlock_page(page); in __invalidate_mapping_pages()
579 get_page(page); in __invalidate_mapping_pages()
583 * the huge page. in __invalidate_mapping_pages()
589 ret = invalidate_inode_page(page); in __invalidate_mapping_pages()
590 unlock_page(page); in __invalidate_mapping_pages()
592 * Invalidation is a hint that the page is no longer in __invalidate_mapping_pages()
596 deactivate_file_page(page); in __invalidate_mapping_pages()
602 if (PageTransHuge(page)) in __invalidate_mapping_pages()
603 put_page(page); in __invalidate_mapping_pages()
648 * This is like invalidate_complete_page(), except it ignores the page's
655 invalidate_complete_page2(struct address_space *mapping, struct page *page) in invalidate_complete_page2() argument
659 if (page->mapping != mapping) in invalidate_complete_page2()
662 if (page_has_private(page) && !try_to_release_page(page, GFP_KERNEL)) in invalidate_complete_page2()
666 if (PageDirty(page)) in invalidate_complete_page2()
669 BUG_ON(page_has_private(page)); in invalidate_complete_page2()
670 __delete_from_page_cache(page, NULL); in invalidate_complete_page2()
674 mapping->a_ops->freepage(page); in invalidate_complete_page2()
676 put_page(page); /* pagecache ref */ in invalidate_complete_page2()
683 static int do_launder_page(struct address_space *mapping, struct page *page) in do_launder_page() argument
685 if (!PageDirty(page)) in do_launder_page()
687 if (page->mapping != mapping || mapping->a_ops->launder_page == NULL) in do_launder_page()
689 return mapping->a_ops->launder_page(page); in do_launder_page()
695 * @start: the page offset 'from' which to invalidate
696 * @end: the page offset 'to' which to invalidate (inclusive)
723 struct page *page = pvec.pages[i]; in invalidate_inode_pages2_range() local
725 /* We rely upon deletion not changing page->index */ in invalidate_inode_pages2_range()
730 if (xa_is_value(page)) { in invalidate_inode_pages2_range()
732 index, page)) in invalidate_inode_pages2_range()
737 if (!did_range_unmap && page_mapped(page)) { in invalidate_inode_pages2_range()
739 * If page is mapped, before taking its lock, in invalidate_inode_pages2_range()
747 lock_page(page); in invalidate_inode_pages2_range()
748 WARN_ON(page_to_index(page) != index); in invalidate_inode_pages2_range()
749 if (page->mapping != mapping) { in invalidate_inode_pages2_range()
750 unlock_page(page); in invalidate_inode_pages2_range()
753 wait_on_page_writeback(page); in invalidate_inode_pages2_range()
755 if (page_mapped(page)) in invalidate_inode_pages2_range()
756 unmap_mapping_page(page); in invalidate_inode_pages2_range()
757 BUG_ON(page_mapped(page)); in invalidate_inode_pages2_range()
759 ret2 = do_launder_page(mapping, page); in invalidate_inode_pages2_range()
761 if (!invalidate_complete_page2(mapping, page)) in invalidate_inode_pages2_range()
766 unlock_page(page); in invalidate_inode_pages2_range()
774 * For DAX we invalidate page tables after invalidating page cache. We in invalidate_inode_pages2_range()
775 * could invalidate page tables while invalidating each entry however in invalidate_inode_pages2_range()
777 * work as we have no cheap way to find whether page cache entry didn't in invalidate_inode_pages2_range()
816 * situations such as writepage being called for a page that has already
827 * single-page unmaps. However after this first call, and in truncate_pagecache()
870 * write starting after current i_size. We mark the page straddling current
872 * the page. This way filesystem can be sure that page_mkwrite() is called on
873 * the page before user writes to the page via mmap after the i_size has been
876 * The function must be called after i_size is updated so that page fault
877 * coming after we unlock the page will already see the new i_size.
886 struct page *page; in pagecache_isize_extended() local
893 /* Page straddling @from will not have any hole block created? */ in pagecache_isize_extended()
899 page = find_lock_page(inode->i_mapping, index); in pagecache_isize_extended()
900 /* Page not cached? Nothing to do */ in pagecache_isize_extended()
901 if (!page) in pagecache_isize_extended()
907 if (page_mkclean(page)) in pagecache_isize_extended()
908 set_page_dirty(page); in pagecache_isize_extended()
909 unlock_page(page); in pagecache_isize_extended()
910 put_page(page); in pagecache_isize_extended()
924 * situations such as writepage being called for a page that has already
936 * doing their own page rounding first. Note that unmap_mapping_range in truncate_pagecache_range()