>
> +/**
> + * undo_compound_page() - Reverse the effect of prep_compound_page().
> + * @page: The head page of a compound page to demote.
> + *
> + * Returns the pages to non-compound state as if prep_compound_page()
> + * had never been called. split_page() must NOT have been called on
> + * the compound page; tail refcounts must be 0. The caller must ensure
> + * no other users hold references to the compound page.
> + */
> +void undo_compound_page(struct page *page)
> +{
> + unsigned int i, nr = 1U << compound_order(page);
> +
> + page[1].flags.f &= ~PAGE_FLAGS_SECOND;
> + for (i = 1; i < nr; i++) {
> + page[i].mapping = NULL;
> + clear_compound_head(&page[i]);
> + }
> + ClearPageHead(page);
> +}
> +
> static inline void set_buddy_order(struct page *page, unsigned int order)
> {
> set_page_private(page, order);
> diff --git a/mm/shmem.c b/mm/shmem.c
> index 3b5dc21b323c..45e80a74f77c 100644
> --- a/mm/shmem.c
> +++ b/mm/shmem.c
> @@ -937,6 +937,111 @@ int shmem_add_to_page_cache(struct folio *folio,
> return 0;
> }
>
> +/**
> + * shmem_insert_folio() - Insert an isolated folio into a shmem file.
> + * @file: The shmem file created with shmem_file_setup().
> + * @folio: The folio to insert. Must be isolated (not on LRU), unlocked,
> + * have exactly one reference (the caller's), have no page-table
> + * mappings, and have folio->mapping == NULL.
> + * @order: The allocation order of @folio. If @order > 0 and @folio is
> + * not already a large (compound) folio, it will be promoted to a
> + * compound folio of this order inside this function. This requires
> + * the standard post-alloc state: head refcount == 1, tail
> + * refcounts == 0 (i.e. split_page() must NOT have been called).
> + * On failure the promotion is reversed and the folio is returned
> + * to its original non-compound state.
> + * @index: Page-cache index at which to insert. Must be aligned to
> + * (1 << @order) and within the file's size.
> + * @writeback: If true, attempt immediate writeback to swap after insertion.
> + * Best-effort; failure is silently ignored.
> + * @folio_gfp: The GFP flags to use for memory-cgroup charging.
> + *
> + * The folio is inserted zero-copy into the shmem page cache and placed on
> + * the anon LRU, where it participates in normal kernel reclaim (written to
> + * swap under memory pressure). Any previous content at @index is discarded.
> + * On success the caller should release their reference with folio_put() and
> + * track the (@file, @index) pair for later recovery via shmem_read_folio()
> + * and release via shmem_truncate_range().
> + *
> + * Return: 0 on success. On failure the folio is returned to its original
> + * state and the caller retains ownership.
> + */
> +int shmem_insert_folio(struct file *file, struct folio *folio, unsigned int
> order,
> + pgoff_t index, bool writeback, gfp_t folio_gfp)
> +{
> + struct address_space *mapping = file->f_mapping;
> + struct inode *inode = mapping->host;
> + bool promoted;
> + long nr_pages;
> + int ret;
> +
> + promoted = order > 0 && !folio_test_large(folio);
> + if (promoted)
> + prep_compound_page(&folio->page, order);
> + nr_pages = folio_nr_pages(folio);
> +
> + VM_BUG_ON_FOLIO(folio_test_lru(folio), folio);
> + VM_BUG_ON_FOLIO(folio_mapped(folio), folio);
> + VM_BUG_ON_FOLIO(folio_test_swapcache(folio), folio);
> + VM_BUG_ON_FOLIO(folio->mapping, folio);
> + VM_BUG_ON(index != round_down(index, nr_pages));
No new VM_BUG_ON_FOLIO etc.
But in general, pushing in random allocated pages into shmem, converting them to
folios is not something I particularly enjoy seeing.
--
Cheers,
David
