// SPDX-License-Identifier: GPL-2.0-or-later/* * Squashfs - a compressed read only filesystem for Linux * * Copyright (c) 2016-present, Facebook, Inc. * All rights reserved. * * zstd_wrapper.c */ #include <linux/mutex.h>#include <linux/bio.h>#include <linux/slab.h>#include <linux/zstd.h>#include <linux/vmalloc.h> #include "squashfs_fs.h"#include "squashfs_fs_sb.h"#include "squashfs.h"#include "decompressor.h"#include "page_actor.h" struct workspace {	void *mem;	size_t mem_size;	size_t window_size;}; static void *zstd_init(struct squashfs_sb_info *msblk, void *buff){	struct workspace *wksp = kmalloc_obj(*wksp); 	if (wksp == NULL)		goto failed;	wksp->window_size = max_t(size_t,			msblk->block_size, SQUASHFS_METADATA_SIZE);	wksp->mem_size = zstd_dstream_workspace_bound(wksp->window_size);	wksp->mem = vmalloc(wksp->mem_size);	if (wksp->mem == NULL)		goto failed; 	return wksp; failed:	ERROR("Failed to allocate zstd workspace\n");	kfree(wksp);	return ERR_PTR(-ENOMEM);}  static void zstd_free(void *strm){	struct workspace *wksp = strm; 	if (wksp)		vfree(wksp->mem);	kfree(wksp);}  static int zstd_uncompress(struct squashfs_sb_info *msblk, void *strm,	struct bio *bio, int offset, int length,	struct squashfs_page_actor *output){	struct workspace *wksp = strm;	zstd_dstream *stream;	size_t total_out = 0;	int error = 0;	zstd_in_buffer in_buf = { NULL, 0, 0 };	zstd_out_buffer out_buf = { NULL, 0, 0 };	struct bvec_iter_all iter_all = {};	struct bio_vec *bvec = bvec_init_iter_all(&iter_all); 	stream = zstd_init_dstream(wksp->window_size, wksp->mem, wksp->mem_size); 	if (!stream) {		ERROR("Failed to initialize zstd decompressor\n");		return -EIO;	} 	out_buf.size = PAGE_SIZE;	out_buf.dst = squashfs_first_page(output);	if (IS_ERR(out_buf.dst)) {		error = PTR_ERR(out_buf.dst);		goto finish;	} 	for (;;) {		size_t zstd_err; 		if (in_buf.pos == in_buf.size) {			const void *data;			int avail; 			if (!bio_next_segment(bio, &iter_all)) {				error = -EIO;				break;			} 			avail = min(length, ((int)bvec->bv_len) - offset);			data = bvec_virt(bvec);			length -= avail;			in_buf.src = data + offset;			in_buf.size = avail;			in_buf.pos = 0;			offset = 0;		} 		if (out_buf.pos == out_buf.size) {			out_buf.dst = squashfs_next_page(output);			if (IS_ERR(out_buf.dst)) {				error = PTR_ERR(out_buf.dst);				break;			} else if (out_buf.dst == NULL) {				/* Shouldn't run out of pages				 * before stream is done.				 */				error = -EIO;				break;			}			out_buf.pos = 0;			out_buf.size = PAGE_SIZE;		} 		total_out -= out_buf.pos;		zstd_err = zstd_decompress_stream(stream, &out_buf, &in_buf);		total_out += out_buf.pos; /* add the additional data produced */		if (zstd_err == 0)			break; 		if (zstd_is_error(zstd_err)) {			ERROR("zstd decompression error: %d\n",					(int)zstd_get_error_code(zstd_err));			error = -EIO;			break;		}	} finish: 	squashfs_finish_page(output); 	return error ? error : total_out;} const struct squashfs_decompressor squashfs_zstd_comp_ops = {	.init = zstd_init,	.free = zstd_free,	.decompress = zstd_uncompress,	.id = ZSTD_COMPRESSION,	.name = "zstd",	.alloc_buffer = 1,	.supported = 1};