Mikhail Zaslonko | aa5b395 | 2020-01-30 22:16:17 -0800 | [diff] [blame] | 1 | // SPDX-License-Identifier: Zlib |
| 2 | |
| 3 | #include "../zlib_deflate/defutil.h" |
| 4 | #include "dfltcc_util.h" |
| 5 | #include "dfltcc.h" |
Mikhail Zaslonko | c65e681 | 2020-01-30 22:16:27 -0800 | [diff] [blame] | 6 | #include <asm/setup.h> |
Randy Dunlap | 605cc30 | 2020-12-29 15:15:04 -0800 | [diff] [blame] | 7 | #include <linux/export.h> |
Mikhail Zaslonko | aa5b395 | 2020-01-30 22:16:17 -0800 | [diff] [blame] | 8 | #include <linux/zutil.h> |
| 9 | |
| 10 | /* |
| 11 | * Compress. |
| 12 | */ |
| 13 | int dfltcc_can_deflate( |
| 14 | z_streamp strm |
| 15 | ) |
| 16 | { |
| 17 | deflate_state *state = (deflate_state *)strm->state; |
| 18 | struct dfltcc_state *dfltcc_state = GET_DFLTCC_STATE(state); |
| 19 | |
Mikhail Zaslonko | c65e681 | 2020-01-30 22:16:27 -0800 | [diff] [blame] | 20 | /* Check for kernel dfltcc command line parameter */ |
| 21 | if (zlib_dfltcc_support == ZLIB_DFLTCC_DISABLED || |
| 22 | zlib_dfltcc_support == ZLIB_DFLTCC_INFLATE_ONLY) |
| 23 | return 0; |
| 24 | |
Mikhail Zaslonko | aa5b395 | 2020-01-30 22:16:17 -0800 | [diff] [blame] | 25 | /* Unsupported compression settings */ |
| 26 | if (!dfltcc_are_params_ok(state->level, state->w_bits, state->strategy, |
| 27 | dfltcc_state->level_mask)) |
| 28 | return 0; |
| 29 | |
| 30 | /* Unsupported hardware */ |
| 31 | if (!is_bit_set(dfltcc_state->af.fns, DFLTCC_GDHT) || |
| 32 | !is_bit_set(dfltcc_state->af.fns, DFLTCC_CMPR) || |
| 33 | !is_bit_set(dfltcc_state->af.fmts, DFLTCC_FMT0)) |
| 34 | return 0; |
| 35 | |
| 36 | return 1; |
| 37 | } |
Randy Dunlap | 605cc30 | 2020-12-29 15:15:04 -0800 | [diff] [blame] | 38 | EXPORT_SYMBOL(dfltcc_can_deflate); |
Mikhail Zaslonko | aa5b395 | 2020-01-30 22:16:17 -0800 | [diff] [blame] | 39 | |
| 40 | static void dfltcc_gdht( |
| 41 | z_streamp strm |
| 42 | ) |
| 43 | { |
| 44 | deflate_state *state = (deflate_state *)strm->state; |
| 45 | struct dfltcc_param_v0 *param = &GET_DFLTCC_STATE(state)->param; |
| 46 | size_t avail_in = avail_in = strm->avail_in; |
| 47 | |
| 48 | dfltcc(DFLTCC_GDHT, |
| 49 | param, NULL, NULL, |
| 50 | &strm->next_in, &avail_in, NULL); |
| 51 | } |
| 52 | |
| 53 | static dfltcc_cc dfltcc_cmpr( |
| 54 | z_streamp strm |
| 55 | ) |
| 56 | { |
| 57 | deflate_state *state = (deflate_state *)strm->state; |
| 58 | struct dfltcc_param_v0 *param = &GET_DFLTCC_STATE(state)->param; |
| 59 | size_t avail_in = strm->avail_in; |
| 60 | size_t avail_out = strm->avail_out; |
| 61 | dfltcc_cc cc; |
| 62 | |
| 63 | cc = dfltcc(DFLTCC_CMPR | HBT_CIRCULAR, |
| 64 | param, &strm->next_out, &avail_out, |
| 65 | &strm->next_in, &avail_in, state->window); |
| 66 | strm->total_in += (strm->avail_in - avail_in); |
| 67 | strm->total_out += (strm->avail_out - avail_out); |
| 68 | strm->avail_in = avail_in; |
| 69 | strm->avail_out = avail_out; |
| 70 | return cc; |
| 71 | } |
| 72 | |
| 73 | static void send_eobs( |
| 74 | z_streamp strm, |
| 75 | const struct dfltcc_param_v0 *param |
| 76 | ) |
| 77 | { |
| 78 | deflate_state *state = (deflate_state *)strm->state; |
| 79 | |
| 80 | zlib_tr_send_bits( |
| 81 | state, |
| 82 | bi_reverse(param->eobs >> (15 - param->eobl), param->eobl), |
| 83 | param->eobl); |
| 84 | flush_pending(strm); |
| 85 | if (state->pending != 0) { |
| 86 | /* The remaining data is located in pending_out[0:pending]. If someone |
| 87 | * calls put_byte() - this might happen in deflate() - the byte will be |
| 88 | * placed into pending_buf[pending], which is incorrect. Move the |
| 89 | * remaining data to the beginning of pending_buf so that put_byte() is |
| 90 | * usable again. |
| 91 | */ |
| 92 | memmove(state->pending_buf, state->pending_out, state->pending); |
| 93 | state->pending_out = state->pending_buf; |
| 94 | } |
| 95 | #ifdef ZLIB_DEBUG |
| 96 | state->compressed_len += param->eobl; |
| 97 | #endif |
| 98 | } |
| 99 | |
| 100 | int dfltcc_deflate( |
| 101 | z_streamp strm, |
| 102 | int flush, |
| 103 | block_state *result |
| 104 | ) |
| 105 | { |
| 106 | deflate_state *state = (deflate_state *)strm->state; |
| 107 | struct dfltcc_state *dfltcc_state = GET_DFLTCC_STATE(state); |
| 108 | struct dfltcc_param_v0 *param = &dfltcc_state->param; |
| 109 | uInt masked_avail_in; |
| 110 | dfltcc_cc cc; |
| 111 | int need_empty_block; |
| 112 | int soft_bcc; |
| 113 | int no_flush; |
| 114 | |
| 115 | if (!dfltcc_can_deflate(strm)) |
| 116 | return 0; |
| 117 | |
| 118 | again: |
| 119 | masked_avail_in = 0; |
| 120 | soft_bcc = 0; |
| 121 | no_flush = flush == Z_NO_FLUSH; |
| 122 | |
| 123 | /* Trailing empty block. Switch to software, except when Continuation Flag |
| 124 | * is set, which means that DFLTCC has buffered some output in the |
| 125 | * parameter block and needs to be called again in order to flush it. |
| 126 | */ |
| 127 | if (flush == Z_FINISH && strm->avail_in == 0 && !param->cf) { |
| 128 | if (param->bcf) { |
| 129 | /* A block is still open, and the hardware does not support closing |
| 130 | * blocks without adding data. Thus, close it manually. |
| 131 | */ |
| 132 | send_eobs(strm, param); |
| 133 | param->bcf = 0; |
| 134 | } |
| 135 | return 0; |
| 136 | } |
| 137 | |
| 138 | if (strm->avail_in == 0 && !param->cf) { |
| 139 | *result = need_more; |
| 140 | return 1; |
| 141 | } |
| 142 | |
| 143 | /* There is an open non-BFINAL block, we are not going to close it just |
| 144 | * yet, we have compressed more than DFLTCC_BLOCK_SIZE bytes and we see |
| 145 | * more than DFLTCC_DHT_MIN_SAMPLE_SIZE bytes. Open a new block with a new |
| 146 | * DHT in order to adapt to a possibly changed input data distribution. |
| 147 | */ |
| 148 | if (param->bcf && no_flush && |
| 149 | strm->total_in > dfltcc_state->block_threshold && |
| 150 | strm->avail_in >= dfltcc_state->dht_threshold) { |
| 151 | if (param->cf) { |
| 152 | /* We need to flush the DFLTCC buffer before writing the |
| 153 | * End-of-block Symbol. Mask the input data and proceed as usual. |
| 154 | */ |
| 155 | masked_avail_in += strm->avail_in; |
| 156 | strm->avail_in = 0; |
| 157 | no_flush = 0; |
| 158 | } else { |
| 159 | /* DFLTCC buffer is empty, so we can manually write the |
| 160 | * End-of-block Symbol right away. |
| 161 | */ |
| 162 | send_eobs(strm, param); |
| 163 | param->bcf = 0; |
| 164 | dfltcc_state->block_threshold = |
| 165 | strm->total_in + dfltcc_state->block_size; |
| 166 | if (strm->avail_out == 0) { |
| 167 | *result = need_more; |
| 168 | return 1; |
| 169 | } |
| 170 | } |
| 171 | } |
| 172 | |
| 173 | /* The caller gave us too much data. Pass only one block worth of |
| 174 | * uncompressed data to DFLTCC and mask the rest, so that on the next |
| 175 | * iteration we start a new block. |
| 176 | */ |
| 177 | if (no_flush && strm->avail_in > dfltcc_state->block_size) { |
| 178 | masked_avail_in += (strm->avail_in - dfltcc_state->block_size); |
| 179 | strm->avail_in = dfltcc_state->block_size; |
| 180 | } |
| 181 | |
| 182 | /* When we have an open non-BFINAL deflate block and caller indicates that |
| 183 | * the stream is ending, we need to close an open deflate block and open a |
| 184 | * BFINAL one. |
| 185 | */ |
| 186 | need_empty_block = flush == Z_FINISH && param->bcf && !param->bhf; |
| 187 | |
| 188 | /* Translate stream to parameter block */ |
| 189 | param->cvt = CVT_ADLER32; |
| 190 | if (!no_flush) |
| 191 | /* We need to close a block. Always do this in software - when there is |
| 192 | * no input data, the hardware will not nohor BCC. */ |
| 193 | soft_bcc = 1; |
| 194 | if (flush == Z_FINISH && !param->bcf) |
| 195 | /* We are about to open a BFINAL block, set Block Header Final bit |
| 196 | * until the stream ends. |
| 197 | */ |
| 198 | param->bhf = 1; |
| 199 | /* DFLTCC-CMPR will write to next_out, so make sure that buffers with |
| 200 | * higher precedence are empty. |
| 201 | */ |
| 202 | Assert(state->pending == 0, "There must be no pending bytes"); |
| 203 | Assert(state->bi_valid < 8, "There must be less than 8 pending bits"); |
| 204 | param->sbb = (unsigned int)state->bi_valid; |
| 205 | if (param->sbb > 0) |
| 206 | *strm->next_out = (Byte)state->bi_buf; |
| 207 | if (param->hl) |
| 208 | param->nt = 0; /* Honor history */ |
| 209 | param->cv = strm->adler; |
| 210 | |
| 211 | /* When opening a block, choose a Huffman-Table Type */ |
| 212 | if (!param->bcf) { |
| 213 | if (strm->total_in == 0 && dfltcc_state->block_threshold > 0) { |
| 214 | param->htt = HTT_FIXED; |
| 215 | } |
| 216 | else { |
| 217 | param->htt = HTT_DYNAMIC; |
| 218 | dfltcc_gdht(strm); |
| 219 | } |
| 220 | } |
| 221 | |
| 222 | /* Deflate */ |
| 223 | do { |
| 224 | cc = dfltcc_cmpr(strm); |
| 225 | if (strm->avail_in < 4096 && masked_avail_in > 0) |
| 226 | /* We are about to call DFLTCC with a small input buffer, which is |
| 227 | * inefficient. Since there is masked data, there will be at least |
| 228 | * one more DFLTCC call, so skip the current one and make the next |
| 229 | * one handle more data. |
| 230 | */ |
| 231 | break; |
| 232 | } while (cc == DFLTCC_CC_AGAIN); |
| 233 | |
| 234 | /* Translate parameter block to stream */ |
| 235 | strm->msg = oesc_msg(dfltcc_state->msg, param->oesc); |
| 236 | state->bi_valid = param->sbb; |
| 237 | if (state->bi_valid == 0) |
| 238 | state->bi_buf = 0; /* Avoid accessing next_out */ |
| 239 | else |
| 240 | state->bi_buf = *strm->next_out & ((1 << state->bi_valid) - 1); |
| 241 | strm->adler = param->cv; |
| 242 | |
| 243 | /* Unmask the input data */ |
| 244 | strm->avail_in += masked_avail_in; |
| 245 | masked_avail_in = 0; |
| 246 | |
| 247 | /* If we encounter an error, it means there is a bug in DFLTCC call */ |
| 248 | Assert(cc != DFLTCC_CC_OP2_CORRUPT || param->oesc == 0, "BUG"); |
| 249 | |
| 250 | /* Update Block-Continuation Flag. It will be used to check whether to call |
| 251 | * GDHT the next time. |
| 252 | */ |
| 253 | if (cc == DFLTCC_CC_OK) { |
| 254 | if (soft_bcc) { |
| 255 | send_eobs(strm, param); |
| 256 | param->bcf = 0; |
| 257 | dfltcc_state->block_threshold = |
| 258 | strm->total_in + dfltcc_state->block_size; |
| 259 | } else |
| 260 | param->bcf = 1; |
| 261 | if (flush == Z_FINISH) { |
| 262 | if (need_empty_block) |
| 263 | /* Make the current deflate() call also close the stream */ |
| 264 | return 0; |
| 265 | else { |
| 266 | bi_windup(state); |
| 267 | *result = finish_done; |
| 268 | } |
| 269 | } else { |
| 270 | if (flush == Z_FULL_FLUSH) |
| 271 | param->hl = 0; /* Clear history */ |
| 272 | *result = flush == Z_NO_FLUSH ? need_more : block_done; |
| 273 | } |
| 274 | } else { |
| 275 | param->bcf = 1; |
| 276 | *result = need_more; |
| 277 | } |
| 278 | if (strm->avail_in != 0 && strm->avail_out != 0) |
| 279 | goto again; /* deflate() must use all input or all output */ |
| 280 | return 1; |
| 281 | } |
Randy Dunlap | 605cc30 | 2020-12-29 15:15:04 -0800 | [diff] [blame] | 282 | EXPORT_SYMBOL(dfltcc_deflate); |