[linux-block.git] / fs / squashfs / page_actor.c

// SPDX-License-Identifier: GPL-2.0-only
/*
 * Copyright (c) 2013
 * Phillip Lougher <phillip@squashfs.org.uk>
 */

#include <linux/kernel.h>
#include <linux/slab.h>
#include <linux/pagemap.h>
#include "squashfs_fs_sb.h"
#include "decompressor.h"
#include "page_actor.h"

/*
 * This file contains implementations of page_actor for decompressing into
 * an intermediate buffer, and for decompressing directly into the
 * page cache.
 *
 * Calling code should avoid sleeping between calls to squashfs_first_page()
 * and squashfs_finish_page().
 */

/* Implementation of page_actor for decompressing into intermediate buffer */
static void *cache_first_page(struct squashfs_page_actor *actor)
{
	actor->next_page = 1;
	return actor->buffer[0];
}

static void *cache_next_page(struct squashfs_page_actor *actor)
{
	if (actor->next_page == actor->pages)
		return NULL;

	return actor->buffer[actor->next_page++];
}

static void cache_finish_page(struct squashfs_page_actor *actor)
{
	/* empty */
}

struct squashfs_page_actor *squashfs_page_actor_init(void **buffer,
	int pages, int length)
{
	struct squashfs_page_actor *actor = kmalloc(sizeof(*actor), GFP_KERNEL);

	if (actor == NULL)
		return NULL;

	actor->length = length ? : pages * PAGE_SIZE;
	actor->buffer = buffer;
	actor->pages = pages;
	actor->next_page = 0;
	actor->tmp_buffer = NULL;
	actor->squashfs_first_page = cache_first_page;
	actor->squashfs_next_page = cache_next_page;
	actor->squashfs_finish_page = cache_finish_page;
	return actor;
}

/* Implementation of page_actor for decompressing directly into page cache. */
static loff_t page_next_index(struct squashfs_page_actor *actor)
{
	return page_folio(actor->page[actor->next_page])->index;
}

static void *handle_next_page(struct squashfs_page_actor *actor)
{
	int max_pages = (actor->length + PAGE_SIZE - 1) >> PAGE_SHIFT;

	if (actor->returned_pages == max_pages)
		return NULL;

	if ((actor->next_page == actor->pages) ||
			(actor->next_index != page_next_index(actor))) {
		actor->next_index++;
		actor->returned_pages++;
		actor->last_page = NULL;
		return actor->alloc_buffer ? actor->tmp_buffer : ERR_PTR(-ENOMEM);
	}

	actor->next_index++;
	actor->returned_pages++;
	actor->last_page = actor->page[actor->next_page];
	return actor->pageaddr = kmap_local_page(actor->page[actor->next_page++]);
}

static void *direct_first_page(struct squashfs_page_actor *actor)
{
	return handle_next_page(actor);
}

static void *direct_next_page(struct squashfs_page_actor *actor)
{
	if (actor->pageaddr) {
		kunmap_local(actor->pageaddr);
		actor->pageaddr = NULL;
	}

	return handle_next_page(actor);
}

static void direct_finish_page(struct squashfs_page_actor *actor)
{
	if (actor->pageaddr)
		kunmap_local(actor->pageaddr);
}

struct squashfs_page_actor *squashfs_page_actor_init_special(struct squashfs_sb_info *msblk,
	struct page **page, int pages, int length, loff_t start_index)
{
	struct squashfs_page_actor *actor = kmalloc(sizeof(*actor), GFP_KERNEL);

	if (actor == NULL)
		return NULL;

	if (msblk->decompressor->alloc_buffer) {
		actor->tmp_buffer = kmalloc(PAGE_SIZE, GFP_KERNEL);

		if (actor->tmp_buffer == NULL) {
			kfree(actor);
			return NULL;
		}
	} else
		actor->tmp_buffer = NULL;

	actor->length = length ? : pages * PAGE_SIZE;
	actor->page = page;
	actor->pages = pages;
	actor->next_page = 0;
	actor->returned_pages = 0;
	actor->next_index = start_index >> PAGE_SHIFT;
	actor->pageaddr = NULL;
	actor->last_page = NULL;
	actor->alloc_buffer = msblk->decompressor->alloc_buffer;
	actor->squashfs_first_page = direct_first_page;
	actor->squashfs_next_page = direct_next_page;
	actor->squashfs_finish_page = direct_finish_page;
	return actor;
}
Commit	Line	Data
20c8ccb1	1	// SPDX-License-Identifier: GPL-2.0-only
0d455c12 PL	2	/*
	3	* Copyright (c) 2013
	4	* Phillip Lougher <phillip@squashfs.org.uk>
0d455c12 PL	5	*/
	6
	7	#include <linux/kernel.h>
	8	#include <linux/slab.h>
	9	#include <linux/pagemap.h>
f268eedd PL	10	#include "squashfs_fs_sb.h"
f268eedd PL	11	#include "decompressor.h"
0d455c12 PL	12	#include "page_actor.h"
	13
	14	/*
	15	* This file contains implementations of page_actor for decompressing into
	16	* an intermediate buffer, and for decompressing directly into the
	17	* page cache.
	18	*
	19	* Calling code should avoid sleeping between calls to squashfs_first_page()
	20	* and squashfs_finish_page().
	21	*/
	22
	23	/* Implementation of page_actor for decompressing into intermediate buffer */
	24	static void cache_first_page(struct squashfs_page_actor actor)
	25	{
	26	actor->next_page = 1;
	27	return actor->buffer[0];
	28	}
	29
	30	static void cache_next_page(struct squashfs_page_actor actor)
	31	{
	32	if (actor->next_page == actor->pages)
	33	return NULL;
	34
	35	return actor->buffer[actor->next_page++];
	36	}
	37
	38	static void cache_finish_page(struct squashfs_page_actor *actor)
	39	{
	40	/* empty */
	41	}
	42
	43	struct squashfs_page_actor squashfs_page_actor_init(void *buffer,
	44	int pages, int length)
	45	{
	46	struct squashfs_page_actor actor = kmalloc(sizeof(actor), GFP_KERNEL);
	47
	48	if (actor == NULL)
	49	return NULL;
	50
09cbfeaf	51	actor->length = length ? : pages * PAGE_SIZE;
0d455c12 PL	52	actor->buffer = buffer;
	53	actor->pages = pages;
	54	actor->next_page = 0;
1f13dff0	55	actor->tmp_buffer = NULL;
0d455c12 PL	56	actor->squashfs_first_page = cache_first_page;
	57	actor->squashfs_next_page = cache_next_page;
	58	actor->squashfs_finish_page = cache_finish_page;
	59	return actor;
	60	}
	61
	62	/* Implementation of page_actor for decompressing directly into page cache. */
2258e22f PL	63	static loff_t page_next_index(struct squashfs_page_actor *actor)
	64	{
	65	return page_folio(actor->page[actor->next_page])->index;
	66	}
	67
f268eedd PL	68	static void handle_next_page(struct squashfs_page_actor actor)
	69	{
	70	int max_pages = (actor->length + PAGE_SIZE - 1) >> PAGE_SHIFT;
	71
	72	if (actor->returned_pages == max_pages)
	73	return NULL;
	74
	75	if ((actor->next_page == actor->pages) \|\|
2258e22f	76	(actor->next_index != page_next_index(actor))) {
f268eedd PL	77	actor->next_index++;
f268eedd PL	78	actor->returned_pages++;
9ef8eb61	79	actor->last_page = NULL;
1f13dff0	80	return actor->alloc_buffer ? actor->tmp_buffer : ERR_PTR(-ENOMEM);
f268eedd PL	81	}
	82
	83	actor->next_index++;
	84	actor->returned_pages++;
9ef8eb61	85	actor->last_page = actor->page[actor->next_page];
f268eedd PL	86	return actor->pageaddr = kmap_local_page(actor->page[actor->next_page++]);
	87	}
	88
0d455c12 PL	89	static void direct_first_page(struct squashfs_page_actor actor)
0d455c12 PL	90	{
f268eedd	91	return handle_next_page(actor);
0d455c12 PL	92	}
	93
	94	static void direct_next_page(struct squashfs_page_actor actor)
	95	{
1f13dff0	96	if (actor->pageaddr) {
f268eedd	97	kunmap_local(actor->pageaddr);
1f13dff0 PL	98	actor->pageaddr = NULL;
1f13dff0 PL	99	}
0d455c12	100
f268eedd	101	return handle_next_page(actor);
0d455c12 PL	102	}
	103
	104	static void direct_finish_page(struct squashfs_page_actor *actor)
	105	{
	106	if (actor->pageaddr)
f268eedd	107	kunmap_local(actor->pageaddr);
0d455c12 PL	108	}
0d455c12 PL	109
f268eedd	110	struct squashfs_page_actor squashfs_page_actor_init_special(struct squashfs_sb_info msblk,
2258e22f	111	struct page **page, int pages, int length, loff_t start_index)
0d455c12 PL	112	{
	113	struct squashfs_page_actor actor = kmalloc(sizeof(actor), GFP_KERNEL);
	114
	115	if (actor == NULL)
	116	return NULL;
	117
1f13dff0 PL	118	if (msblk->decompressor->alloc_buffer) {
	119	actor->tmp_buffer = kmalloc(PAGE_SIZE, GFP_KERNEL);
	120
	121	if (actor->tmp_buffer == NULL) {
	122	kfree(actor);
	123	return NULL;
	124	}
	125	} else
	126	actor->tmp_buffer = NULL;
	127
09cbfeaf	128	actor->length = length ? : pages * PAGE_SIZE;
0d455c12 PL	129	actor->page = page;
	130	actor->pages = pages;
	131	actor->next_page = 0;
f268eedd	132	actor->returned_pages = 0;
2258e22f	133	actor->next_index = start_index >> PAGE_SHIFT;
0d455c12	134	actor->pageaddr = NULL;
9ef8eb61	135	actor->last_page = NULL;
f268eedd	136	actor->alloc_buffer = msblk->decompressor->alloc_buffer;
0d455c12 PL	137	actor->squashfs_first_page = direct_first_page;
	138	actor->squashfs_next_page = direct_next_page;
	139	actor->squashfs_finish_page = direct_finish_page;
	140	return actor;
	141	}