cachepc-linux

Fork of AMDESE/linux with modifications for CachePC side-channel attack
git clone https://git.sinitax.com/sinitax/cachepc-linux
Log | Files | Refs | README | LICENSE | sfeed.txt

zstd_wrapper.c (3071B)

      1// SPDX-License-Identifier: GPL-2.0-or-later
      2/*
      3 * Squashfs - a compressed read only filesystem for Linux
      4 *
      5 * Copyright (c) 2016-present, Facebook, Inc.
      6 * All rights reserved.
      7 *
      8 * zstd_wrapper.c
      9 */
     10
     11#include <linux/mutex.h>
     12#include <linux/bio.h>
     13#include <linux/slab.h>
     14#include <linux/zstd.h>
     15#include <linux/vmalloc.h>
     16
     17#include "squashfs_fs.h"
     18#include "squashfs_fs_sb.h"
     19#include "squashfs.h"
     20#include "decompressor.h"
     21#include "page_actor.h"
     22
     23struct workspace {
     24	void *mem;
     25	size_t mem_size;
     26	size_t window_size;
     27};
     28
     29static void *zstd_init(struct squashfs_sb_info *msblk, void *buff)
     30{
     31	struct workspace *wksp = kmalloc(sizeof(*wksp), GFP_KERNEL);
     32
     33	if (wksp == NULL)
     34		goto failed;
     35	wksp->window_size = max_t(size_t,
     36			msblk->block_size, SQUASHFS_METADATA_SIZE);
     37	wksp->mem_size = zstd_dstream_workspace_bound(wksp->window_size);
     38	wksp->mem = vmalloc(wksp->mem_size);
     39	if (wksp->mem == NULL)
     40		goto failed;
     41
     42	return wksp;
     43
     44failed:
     45	ERROR("Failed to allocate zstd workspace\n");
     46	kfree(wksp);
     47	return ERR_PTR(-ENOMEM);
     48}
     49
     50
     51static void zstd_free(void *strm)
     52{
     53	struct workspace *wksp = strm;
     54
     55	if (wksp)
     56		vfree(wksp->mem);
     57	kfree(wksp);
     58}
     59
     60
     61static int zstd_uncompress(struct squashfs_sb_info *msblk, void *strm,
     62	struct bio *bio, int offset, int length,
     63	struct squashfs_page_actor *output)
     64{
     65	struct workspace *wksp = strm;
     66	zstd_dstream *stream;
     67	size_t total_out = 0;
     68	int error = 0;
     69	zstd_in_buffer in_buf = { NULL, 0, 0 };
     70	zstd_out_buffer out_buf = { NULL, 0, 0 };
     71	struct bvec_iter_all iter_all = {};
     72	struct bio_vec *bvec = bvec_init_iter_all(&iter_all);
     73
     74	stream = zstd_init_dstream(wksp->window_size, wksp->mem, wksp->mem_size);
     75
     76	if (!stream) {
     77		ERROR("Failed to initialize zstd decompressor\n");
     78		return -EIO;
     79	}
     80
     81	out_buf.size = PAGE_SIZE;
     82	out_buf.dst = squashfs_first_page(output);
     83
     84	for (;;) {
     85		size_t zstd_err;
     86
     87		if (in_buf.pos == in_buf.size) {
     88			const void *data;
     89			int avail;
     90
     91			if (!bio_next_segment(bio, &iter_all)) {
     92				error = -EIO;
     93				break;
     94			}
     95
     96			avail = min(length, ((int)bvec->bv_len) - offset);
     97			data = bvec_virt(bvec);
     98			length -= avail;
     99			in_buf.src = data + offset;
    100			in_buf.size = avail;
    101			in_buf.pos = 0;
    102			offset = 0;
    103		}
    104
    105		if (out_buf.pos == out_buf.size) {
    106			out_buf.dst = squashfs_next_page(output);
    107			if (out_buf.dst == NULL) {
    108				/* Shouldn't run out of pages
    109				 * before stream is done.
    110				 */
    111				error = -EIO;
    112				break;
    113			}
    114			out_buf.pos = 0;
    115			out_buf.size = PAGE_SIZE;
    116		}
    117
    118		total_out -= out_buf.pos;
    119		zstd_err = zstd_decompress_stream(stream, &out_buf, &in_buf);
    120		total_out += out_buf.pos; /* add the additional data produced */
    121		if (zstd_err == 0)
    122			break;
    123
    124		if (zstd_is_error(zstd_err)) {
    125			ERROR("zstd decompression error: %d\n",
    126					(int)zstd_get_error_code(zstd_err));
    127			error = -EIO;
    128			break;
    129		}
    130	}
    131
    132	squashfs_finish_page(output);
    133
    134	return error ? error : total_out;
    135}
    136
    137const struct squashfs_decompressor squashfs_zstd_comp_ops = {
    138	.init = zstd_init,
    139	.free = zstd_free,
    140	.decompress = zstd_uncompress,
    141	.id = ZSTD_COMPRESSION,
    142	.name = "zstd",
    143	.supported = 1
    144};