Lines Matching refs:mapping
126 static void page_cache_delete(struct address_space *mapping,
129 XA_STATE(xas, &mapping->i_pages, folio->index);
132 mapping_set_update(&xas, mapping);
145 folio->mapping = NULL;
147 mapping->nrpages -= nr;
150 static void filemap_unaccount_folio(struct address_space *mapping,
163 if (mapping_exiting(mapping) && !folio_test_large(folio)) {
192 filemap_nr_thps_dec(mapping);
210 mapping_can_writeback(mapping)))
211 folio_account_cleaned(folio, inode_to_wb(mapping->host));
221 struct address_space *mapping = folio->mapping;
224 filemap_unaccount_folio(mapping, folio);
225 page_cache_delete(mapping, folio, shadow);
228 void filemap_free_folio(struct address_space *mapping, struct folio *folio)
233 free_folio = mapping->a_ops->free_folio;
252 struct address_space *mapping = folio->mapping;
255 spin_lock(&mapping->host->i_lock);
256 xa_lock_irq(&mapping->i_pages);
258 xa_unlock_irq(&mapping->i_pages);
259 if (mapping_shrinkable(mapping))
260 inode_add_lru(mapping->host);
261 spin_unlock(&mapping->host->i_lock);
263 filemap_free_folio(mapping, folio);
268 * @mapping: the mapping to which folios belong
271 * The function walks over mapping->i_pages and removes folios passed in
272 * @fbatch from the mapping. The function expects @fbatch to be sorted
274 * It tolerates holes in @fbatch (mapping entries at those indices are not
279 static void page_cache_delete_batch(struct address_space *mapping,
282 XA_STATE(xas, &mapping->i_pages, fbatch->folios[0]->index);
287 mapping_set_update(&xas, mapping);
310 folio->mapping = NULL;
317 mapping->nrpages -= total_pages;
320 void delete_from_page_cache_batch(struct address_space *mapping,
328 spin_lock(&mapping->host->i_lock);
329 xa_lock_irq(&mapping->i_pages);
334 filemap_unaccount_folio(mapping, folio);
336 page_cache_delete_batch(mapping, fbatch);
337 xa_unlock_irq(&mapping->i_pages);
338 if (mapping_shrinkable(mapping))
339 inode_add_lru(mapping->host);
340 spin_unlock(&mapping->host->i_lock);
343 filemap_free_folio(mapping, fbatch->folios[i]);
346 int filemap_check_errors(struct address_space *mapping)
350 if (test_bit(AS_ENOSPC, &mapping->flags) &&
351 test_and_clear_bit(AS_ENOSPC, &mapping->flags))
353 if (test_bit(AS_EIO, &mapping->flags) &&
354 test_and_clear_bit(AS_EIO, &mapping->flags))
360 static int filemap_check_and_keep_errors(struct address_space *mapping)
363 if (test_bit(AS_EIO, &mapping->flags))
365 if (test_bit(AS_ENOSPC, &mapping->flags))
371 * filemap_fdatawrite_wbc - start writeback on mapping dirty pages in range
372 * @mapping: address space structure to write
375 * Call writepages on the mapping using the provided wbc to control the
380 int filemap_fdatawrite_wbc(struct address_space *mapping,
385 if (!mapping_can_writeback(mapping) ||
386 !mapping_tagged(mapping, PAGECACHE_TAG_DIRTY))
389 wbc_attach_fdatawrite_inode(wbc, mapping->host);
390 ret = do_writepages(mapping, wbc);
397 * __filemap_fdatawrite_range - start writeback on mapping dirty pages in range
398 * @mapping: address space structure to write
403 * Start writeback against all of a mapping's dirty pages that lie
413 int __filemap_fdatawrite_range(struct address_space *mapping, loff_t start,
423 return filemap_fdatawrite_wbc(mapping, &wbc);
426 static inline int __filemap_fdatawrite(struct address_space *mapping,
429 return __filemap_fdatawrite_range(mapping, 0, LLONG_MAX, sync_mode);
432 int filemap_fdatawrite(struct address_space *mapping)
434 return __filemap_fdatawrite(mapping, WB_SYNC_ALL);
438 int filemap_fdatawrite_range(struct address_space *mapping, loff_t start,
441 return __filemap_fdatawrite_range(mapping, start, end, WB_SYNC_ALL);
447 * @mapping: target address_space
454 int filemap_flush(struct address_space *mapping)
456 return __filemap_fdatawrite(mapping, WB_SYNC_NONE);
462 * @mapping: address space within which to check
472 bool filemap_range_has_page(struct address_space *mapping,
476 XA_STATE(xas, &mapping->i_pages, start_byte >> PAGE_SHIFT);
503 static void __filemap_fdatawait_range(struct address_space *mapping,
516 nr_folios = filemap_get_folios_tag(mapping, &index, end,
535 * @mapping: address space structure to wait for
549 int filemap_fdatawait_range(struct address_space *mapping, loff_t start_byte,
552 __filemap_fdatawait_range(mapping, start_byte, end_byte);
553 return filemap_check_errors(mapping);
559 * @mapping: address space structure to wait for
571 int filemap_fdatawait_range_keep_errors(struct address_space *mapping,
574 __filemap_fdatawait_range(mapping, start_byte, end_byte);
575 return filemap_check_and_keep_errors(mapping);
597 struct address_space *mapping = file->f_mapping;
599 __filemap_fdatawait_range(mapping, start_byte, end_byte);
606 * @mapping: address space structure to wait for
618 int filemap_fdatawait_keep_errors(struct address_space *mapping)
620 __filemap_fdatawait_range(mapping, 0, LLONG_MAX);
621 return filemap_check_and_keep_errors(mapping);
626 static bool mapping_needs_writeback(struct address_space *mapping)
628 return mapping->nrpages;
631 bool filemap_range_has_writeback(struct address_space *mapping,
634 XA_STATE(xas, &mapping->i_pages, start_byte >> PAGE_SHIFT);
658 * @mapping: the address_space for the pages
669 int filemap_write_and_wait_range(struct address_space *mapping,
677 if (mapping_needs_writeback(mapping)) {
678 err = __filemap_fdatawrite_range(mapping, lstart, lend,
687 __filemap_fdatawait_range(mapping, lstart, lend);
689 err2 = filemap_check_errors(mapping);
696 void __filemap_set_wb_err(struct address_space *mapping, int err)
698 errseq_t eseq = errseq_set(&mapping->wb_err, err);
700 trace_filemap_set_wb_err(mapping, eseq);
713 * Grab the wb_err from the mapping. If it matches what we have in the file,
716 * If it doesn't match, then take the mapping value, set the "seen" flag in
722 * While we handle mapping->wb_err with atomic operations, the f_wb_err
732 struct address_space *mapping = file->f_mapping;
735 if (errseq_check(&mapping->wb_err, old)) {
739 err = errseq_check_and_advance(&mapping->wb_err,
750 clear_bit(AS_EIO, &mapping->flags);
751 clear_bit(AS_ENOSPC, &mapping->flags);
775 struct address_space *mapping = file->f_mapping;
780 if (mapping_needs_writeback(mapping)) {
781 err = __filemap_fdatawrite_range(mapping, lstart, lend,
785 __filemap_fdatawait_range(mapping, lstart, lend);
809 struct address_space *mapping = old->mapping;
810 void (*free_folio)(struct folio *) = mapping->a_ops->free_folio;
812 XA_STATE(xas, &mapping->i_pages, offset);
816 VM_BUG_ON_FOLIO(new->mapping, new);
819 new->mapping = mapping;
827 old->mapping = NULL;
844 noinline int __filemap_add_folio(struct address_space *mapping,
847 XA_STATE(xas, &mapping->i_pages, index);
854 mapping_set_update(&xas, mapping);
868 folio->mapping = mapping;
894 BUG_ON(shmem_mapping(mapping));
904 mapping->nrpages += nr;
925 folio->mapping = NULL;
932 int filemap_add_folio(struct address_space *mapping, struct folio *folio,
939 ret = __filemap_add_folio(mapping, folio, index, gfp, &shadow);
984 * Lock exclusively invalidate_lock of any passed mapping that is not NULL.
986 * @mapping1: the first mapping to lock
987 * @mapping2: the second mapping to lock
1004 * Unlock exclusive invalidate_lock of any passed mapping that is not NULL.
1006 * @mapping1: the first mapping to unlock
1007 * @mapping2: the second mapping to unlock
1714 * @mapping: Mapping.
1731 pgoff_t page_cache_next_miss(struct address_space *mapping,
1734 XA_STATE(xas, &mapping->i_pages, index);
1750 * @mapping: Mapping.
1767 pgoff_t page_cache_prev_miss(struct address_space *mapping,
1770 XA_STATE(xas, &mapping->i_pages, index);
1806 * @mapping: the address_space to search
1809 * Looks up the page cache entry at @mapping & @index. If it is a folio,
1816 void *filemap_get_entry(struct address_space *mapping, pgoff_t index)
1818 XA_STATE(xas, &mapping->i_pages, index);
1849 * @mapping: The address_space to search.
1854 * Looks up the page cache entry at @mapping & @index.
1863 struct folio *__filemap_get_folio(struct address_space *mapping, pgoff_t index,
1869 folio = filemap_get_entry(mapping, index);
1886 if (unlikely(folio->mapping != mapping)) {
1909 if ((fgp_flags & FGP_WRITE) && mapping_can_writeback(mapping))
1920 if (!mapping_large_folio_support(mapping))
1944 err = filemap_add_folio(mapping, folio, index, gfp);
2006 * @mapping: The address_space to search
2013 * the mapping. The entries are placed in @fbatch. find_get_entries()
2024 unsigned find_get_entries(struct address_space *mapping, pgoff_t *start,
2027 XA_STATE(xas, &mapping->i_pages, *start);
2052 * @mapping: The address_space to search.
2058 * find_lock_entries() will return a batch of entries from @mapping.
2070 unsigned find_lock_entries(struct address_space *mapping, pgoff_t *start,
2073 XA_STATE(xas, &mapping->i_pages, *start);
2085 if (folio->mapping != mapping ||
2116 * @mapping: The address_space to search
2121 * Search for and return a batch of folios in the mapping starting at
2135 unsigned filemap_get_folios(struct address_space *mapping, pgoff_t *start,
2138 XA_STATE(xas, &mapping->i_pages, *start);
2175 * @mapping: The address_space to search
2188 unsigned filemap_get_folios_contig(struct address_space *mapping,
2191 XA_STATE(xas, &mapping->i_pages, *start);
2248 * @mapping: The address_space to search
2259 unsigned filemap_get_folios_tag(struct address_space *mapping, pgoff_t *start,
2262 XA_STATE(xas, &mapping->i_pages, *start);
2329 static void filemap_get_read_batch(struct address_space *mapping,
2332 XA_STATE(xas, &mapping->i_pages, index);
2398 static bool filemap_range_uptodate(struct address_space *mapping,
2407 if (!mapping->a_ops->is_partially_uptodate)
2409 if (mapping->host->i_blkbits >= folio_shift(folio))
2419 return mapping->a_ops->is_partially_uptodate(folio, pos, count);
2423 struct address_space *mapping, size_t count,
2429 if (!filemap_invalidate_trylock_shared(mapping))
2432 filemap_invalidate_lock_shared(mapping);
2440 filemap_invalidate_unlock_shared(mapping);
2454 if (!folio->mapping)
2458 if (filemap_range_uptodate(mapping, iocb->ki_pos, count, folio,
2466 error = filemap_read_folio(iocb->ki_filp, mapping->a_ops->read_folio,
2472 filemap_invalidate_unlock_shared(mapping);
2479 struct address_space *mapping, pgoff_t index,
2485 folio = filemap_alloc_folio(mapping_gfp_mask(mapping), 0);
2499 * while mapping blocks for IO so let's hold the lock here as
2502 filemap_invalidate_lock_shared(mapping);
2503 error = filemap_add_folio(mapping, folio, index,
2504 mapping_gfp_constraint(mapping, GFP_KERNEL));
2510 error = filemap_read_folio(file, mapping->a_ops->read_folio, folio);
2514 filemap_invalidate_unlock_shared(mapping);
2518 filemap_invalidate_unlock_shared(mapping);
2524 struct address_space *mapping, struct folio *folio,
2527 DEFINE_READAHEAD(ractl, file, &file->f_ra, mapping, folio->index);
2539 struct address_space *mapping = filp->f_mapping;
2552 filemap_get_read_batch(mapping, index, last_index - 1, fbatch);
2556 page_cache_sync_readahead(mapping, ra, filp, index,
2558 filemap_get_read_batch(mapping, index, last_index - 1, fbatch);
2563 err = filemap_create_folio(filp, mapping,
2572 err = filemap_readahead(iocb, filp, mapping, folio, last_index);
2580 err = filemap_update_page(iocb, mapping, count, folio,
2622 struct address_space *mapping = filp->f_mapping;
2623 struct inode *inode = mapping->host;
2682 writably_mapped = mapping_writably_mapped(mapping);
2737 struct address_space *mapping = iocb->ki_filp->f_mapping;
2742 if (filemap_range_needs_writeback(mapping, pos, end))
2747 return filemap_write_and_wait_range(mapping, pos, end);
2752 struct address_space *mapping = iocb->ki_filp->f_mapping;
2759 if (filemap_range_has_page(mapping, pos, end))
2762 ret = filemap_write_and_wait_range(mapping, pos, end);
2773 return invalidate_inode_pages2_range(mapping, pos >> PAGE_SHIFT,
2809 struct address_space *mapping = file->f_mapping;
2810 struct inode *inode = mapping->host;
2817 retval = mapping->a_ops->direct_IO(iocb, iter);
2991 struct address_space *mapping, struct folio *folio,
2994 const struct address_space_operations *ops = mapping->a_ops;
2995 size_t offset, bsz = i_blocksize(mapping->host);
3005 if (unlikely(folio->mapping != mapping))
3032 * @mapping: Address space to search.
3048 loff_t mapping_seek_hole_data(struct address_space *mapping, loff_t start,
3051 XA_STATE(xas, &mapping->i_pages, start >> PAGE_SHIFT);
3072 start = folio_seek_hole_data(&xas, mapping, folio, start, pos,
3152 struct address_space *mapping = file->f_mapping;
3153 DEFINE_READAHEAD(ractl, file, ra, mapping, vmf->pgoff);
3269 struct address_space *mapping = file->f_mapping;
3270 struct inode *inode = mapping->host;
3283 folio = filemap_get_folio(mapping, index);
3292 filemap_invalidate_lock_shared(mapping);
3307 filemap_invalidate_lock_shared(mapping);
3310 folio = __filemap_get_folio(mapping, index,
3316 filemap_invalidate_unlock_shared(mapping);
3325 if (unlikely(folio->mapping != mapping)) {
3361 filemap_invalidate_unlock_shared(mapping);
3385 error = filemap_read_folio(file, mapping->a_ops->read_folio, folio);
3392 filemap_invalidate_unlock_shared(mapping);
3405 filemap_invalidate_unlock_shared(mapping);
3441 struct address_space *mapping, pgoff_t end_pgoff)
3464 if (folio->mapping != mapping)
3468 max_idx = DIV_ROUND_UP(i_size_read(mapping->host), PAGE_SIZE);
3572 struct address_space *mapping = file->f_mapping;
3575 XA_STATE(xas, &mapping->i_pages, start_pgoff);
3581 folio = next_uptodate_folio(&xas, mapping, end_pgoff);
3616 } while ((folio = next_uptodate_folio(&xas, mapping, end_pgoff)) != NULL);
3633 struct address_space *mapping = vmf->vma->vm_file->f_mapping;
3637 sb_start_pagefault(mapping->host->i_sb);
3640 if (folio->mapping != mapping) {
3653 sb_end_pagefault(mapping->host->i_sb);
3667 struct address_space *mapping = file->f_mapping;
3669 if (!mapping->a_ops->read_folio)
3704 static struct folio *do_read_cache_folio(struct address_space *mapping,
3711 filler = mapping->a_ops->read_folio;
3713 folio = filemap_get_folio(mapping, index);
3718 err = filemap_add_folio(mapping, folio, index, gfp);
3737 /* Folio was truncated from mapping */
3738 if (!folio->mapping) {
3766 * @mapping: The address_space to read from.
3777 * Context: May sleep. Expects mapping->invalidate_lock to be held.
3780 struct folio *read_cache_folio(struct address_space *mapping, pgoff_t index,
3783 return do_read_cache_folio(mapping, index, filler, file,
3784 mapping_gfp_mask(mapping));
3790 * @mapping: The address_space for the folio.
3794 * This is the same as "read_cache_folio(mapping, index, NULL, NULL)", but with
3801 * The function expects mapping->invalidate_lock to be already held.
3805 struct folio *mapping_read_folio_gfp(struct address_space *mapping,
3808 return do_read_cache_folio(mapping, index, NULL, NULL, gfp);
3812 static struct page *do_read_cache_page(struct address_space *mapping,
3817 folio = do_read_cache_folio(mapping, index, filler, file, gfp);
3823 struct page *read_cache_page(struct address_space *mapping,
3826 return do_read_cache_page(mapping, index, filler, file,
3827 mapping_gfp_mask(mapping));
3833 * @mapping: the page's address_space
3837 * This is the same as "read_mapping_page(mapping, index, NULL)", but with
3842 * The function expects mapping->invalidate_lock to be already held.
3846 struct page *read_cache_page_gfp(struct address_space *mapping,
3850 return do_read_cache_page(mapping, index, NULL, NULL, gfp);
3876 struct address_space *mapping = iocb->ki_filp->f_mapping;
3878 if (mapping->nrpages &&
3879 invalidate_inode_pages2_range(mapping,
3888 struct address_space *mapping = iocb->ki_filp->f_mapping;
3903 written = mapping->a_ops->direct_IO(iocb, from);
3920 * Skip invalidation for async writes or if mapping has no pages.
3923 struct inode *inode = mapping->host;
3945 struct address_space *mapping = file->f_mapping;
3946 const struct address_space_operations *a_ops = mapping->a_ops;
3978 status = a_ops->write_begin(file, mapping, pos, bytes,
3983 if (mapping_writably_mapped(mapping))
3989 status = a_ops->write_end(file, mapping, pos, bytes, copied,
4012 balance_dirty_pages_ratelimited(mapping);
4046 struct address_space *mapping = file->f_mapping;
4047 struct inode *inode = mapping->host;
4127 struct address_space * const mapping = folio->mapping;
4135 if (mapping && mapping->a_ops->release_folio)
4136 return mapping->a_ops->release_folio(folio, gfp);
4143 * filemap_cachestat() - compute the page cache statistics of a mapping
4144 * @mapping: The mapping to compute the statistics for.
4149 * This will query the page cache statistics of a mapping in the
4154 static void filemap_cachestat(struct address_space *mapping,
4157 XA_STATE(xas, &mapping->i_pages, first_index);
4200 if (shmem_mapping(mapping)) {
4270 struct address_space *mapping;
4299 mapping = f.file->f_mapping;
4300 filemap_cachestat(mapping, first_index, last_index, &cs);