1 // SPDX-License-Identifier: GPL-2.0
2
3 #include <string.h>
4
5 #include "util/compress.h"
6 #include "util/debug.h"
7
8 int 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
16 int 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
31 ssize_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
81 size_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
Linux® is a registered trademark of Linus Torvalds in the United States and other countries.
TOMOYO® is a registered trademark of NTT DATA CORPORATION.