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.c (2672B)

      1// SPDX-License-Identifier: GPL-2.0
      2
      3#include <string.h>
      4
      5#include "util/compress.h"
      6#include "util/debug.h"
      7
      8int zstd_init(struct zstd_data *data, int level)
      9{
     10	size_t ret;
     11
     12	data->dstream = ZSTD_createDStream();
     13	if (data->dstream == NULL) {
     14		pr_err("Couldn't create decompression stream.\n");
     15		return -1;
     16	}
     17
     18	ret = ZSTD_initDStream(data->dstream);
     19	if (ZSTD_isError(ret)) {
     20		pr_err("Failed to initialize decompression stream: %s\n", ZSTD_getErrorName(ret));
     21		return -1;
     22	}
     23
     24	if (!level)
     25		return 0;
     26
     27	data->cstream = ZSTD_createCStream();
     28	if (data->cstream == NULL) {
     29		pr_err("Couldn't create compression stream.\n");
     30		return -1;
     31	}
     32
     33	ret = ZSTD_initCStream(data->cstream, level);
     34	if (ZSTD_isError(ret)) {
     35		pr_err("Failed to initialize compression stream: %s\n", ZSTD_getErrorName(ret));
     36		return -1;
     37	}
     38
     39	return 0;
     40}
     41
     42int zstd_fini(struct zstd_data *data)
     43{
     44	if (data->dstream) {
     45		ZSTD_freeDStream(data->dstream);
     46		data->dstream = NULL;
     47	}
     48
     49	if (data->cstream) {
     50		ZSTD_freeCStream(data->cstream);
     51		data->cstream = NULL;
     52	}
     53
     54	return 0;
     55}
     56
     57size_t zstd_compress_stream_to_records(struct zstd_data *data, void *dst, size_t dst_size,
     58				       void *src, size_t src_size, size_t max_record_size,
     59				       size_t process_header(void *record, size_t increment))
     60{
     61	size_t ret, size, compressed = 0;
     62	ZSTD_inBuffer input = { src, src_size, 0 };
     63	ZSTD_outBuffer output;
     64	void *record;
     65
     66	while (input.pos < input.size) {
     67		record = dst;
     68		size = process_header(record, 0);
     69		compressed += size;
     70		dst += size;
     71		dst_size -= size;
     72		output = (ZSTD_outBuffer){ dst, (dst_size > max_record_size) ?
     73						max_record_size : dst_size, 0 };
     74		ret = ZSTD_compressStream(data->cstream, &output, &input);
     75		ZSTD_flushStream(data->cstream, &output);
     76		if (ZSTD_isError(ret)) {
     77			pr_err("failed to compress %ld bytes: %s\n",
     78				(long)src_size, ZSTD_getErrorName(ret));
     79			memcpy(dst, src, src_size);
     80			return src_size;
     81		}
     82		size = output.pos;
     83		size = process_header(record, size);
     84		compressed += size;
     85		dst += size;
     86		dst_size -= size;
     87	}
     88
     89	return compressed;
     90}
     91
     92size_t zstd_decompress_stream(struct zstd_data *data, void *src, size_t src_size,
     93			      void *dst, size_t dst_size)
     94{
     95	size_t ret;
     96	ZSTD_inBuffer input = { src, src_size, 0 };
     97	ZSTD_outBuffer output = { dst, dst_size, 0 };
     98
     99	while (input.pos < input.size) {
    100		ret = ZSTD_decompressStream(data->dstream, &output, &input);
    101		if (ZSTD_isError(ret)) {
    102			pr_err("failed to decompress (B): %zd -> %zd, dst_size %zd : %s\n",
    103			       src_size, output.size, dst_size, ZSTD_getErrorName(ret));
    104			break;
    105		}
    106		output.dst  = dst + output.pos;
    107		output.size = dst_size - output.pos;
    108	}
    109
    110	return output.pos;
    111}