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