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 (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 | |