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