314 lines
10 KiB
C
314 lines
10 KiB
C
// SPDX-License-Identifier: Zlib
|
|
|
|
#include "../zlib_deflate/defutil.h"
|
|
#include "dfltcc_util.h"
|
|
#include "dfltcc_deflate.h"
|
|
#include <asm/setup.h>
|
|
#include <linux/export.h>
|
|
#include <linux/zutil.h>
|
|
|
|
#define GET_DFLTCC_DEFLATE_STATE(state) ((struct dfltcc_deflate_state *)GET_DFLTCC_STATE(state))
|
|
|
|
/*
|
|
* Compress.
|
|
*/
|
|
int dfltcc_can_deflate(
|
|
z_streamp strm
|
|
)
|
|
{
|
|
deflate_state *state = (deflate_state *)strm->state;
|
|
struct dfltcc_deflate_state *dfltcc_state = GET_DFLTCC_DEFLATE_STATE(state);
|
|
|
|
/* Check for kernel dfltcc command line parameter */
|
|
if (zlib_dfltcc_support == ZLIB_DFLTCC_DISABLED ||
|
|
zlib_dfltcc_support == ZLIB_DFLTCC_INFLATE_ONLY)
|
|
return 0;
|
|
|
|
/* Unsupported compression settings */
|
|
if (!dfltcc_are_params_ok(state->level, state->w_bits, state->strategy,
|
|
dfltcc_state->level_mask))
|
|
return 0;
|
|
|
|
/* Unsupported hardware */
|
|
if (!is_bit_set(dfltcc_state->common.af.fns, DFLTCC_GDHT) ||
|
|
!is_bit_set(dfltcc_state->common.af.fns, DFLTCC_CMPR) ||
|
|
!is_bit_set(dfltcc_state->common.af.fmts, DFLTCC_FMT0))
|
|
return 0;
|
|
|
|
return 1;
|
|
}
|
|
EXPORT_SYMBOL(dfltcc_can_deflate);
|
|
|
|
void dfltcc_reset_deflate_state(z_streamp strm) {
|
|
deflate_state *state = (deflate_state *)strm->state;
|
|
struct dfltcc_deflate_state *dfltcc_state = GET_DFLTCC_DEFLATE_STATE(state);
|
|
|
|
dfltcc_reset_state(&dfltcc_state->common);
|
|
|
|
/* Initialize tuning parameters */
|
|
if (zlib_dfltcc_support == ZLIB_DFLTCC_FULL_DEBUG)
|
|
dfltcc_state->level_mask = DFLTCC_LEVEL_MASK_DEBUG;
|
|
else
|
|
dfltcc_state->level_mask = DFLTCC_LEVEL_MASK;
|
|
dfltcc_state->block_size = DFLTCC_BLOCK_SIZE;
|
|
dfltcc_state->block_threshold = DFLTCC_FIRST_FHT_BLOCK_SIZE;
|
|
dfltcc_state->dht_threshold = DFLTCC_DHT_MIN_SAMPLE_SIZE;
|
|
}
|
|
EXPORT_SYMBOL(dfltcc_reset_deflate_state);
|
|
|
|
static void dfltcc_gdht(
|
|
z_streamp strm
|
|
)
|
|
{
|
|
deflate_state *state = (deflate_state *)strm->state;
|
|
struct dfltcc_param_v0 *param = &GET_DFLTCC_STATE(state)->param;
|
|
size_t avail_in = strm->avail_in;
|
|
|
|
dfltcc(DFLTCC_GDHT,
|
|
param, NULL, NULL,
|
|
&strm->next_in, &avail_in, NULL);
|
|
}
|
|
|
|
static dfltcc_cc dfltcc_cmpr(
|
|
z_streamp strm
|
|
)
|
|
{
|
|
deflate_state *state = (deflate_state *)strm->state;
|
|
struct dfltcc_param_v0 *param = &GET_DFLTCC_STATE(state)->param;
|
|
size_t avail_in = strm->avail_in;
|
|
size_t avail_out = strm->avail_out;
|
|
dfltcc_cc cc;
|
|
|
|
cc = dfltcc(DFLTCC_CMPR | HBT_CIRCULAR,
|
|
param, &strm->next_out, &avail_out,
|
|
&strm->next_in, &avail_in, state->window);
|
|
strm->total_in += (strm->avail_in - avail_in);
|
|
strm->total_out += (strm->avail_out - avail_out);
|
|
strm->avail_in = avail_in;
|
|
strm->avail_out = avail_out;
|
|
return cc;
|
|
}
|
|
|
|
static void send_eobs(
|
|
z_streamp strm,
|
|
const struct dfltcc_param_v0 *param
|
|
)
|
|
{
|
|
deflate_state *state = (deflate_state *)strm->state;
|
|
|
|
zlib_tr_send_bits(
|
|
state,
|
|
bi_reverse(param->eobs >> (15 - param->eobl), param->eobl),
|
|
param->eobl);
|
|
flush_pending(strm);
|
|
if (state->pending != 0) {
|
|
/* The remaining data is located in pending_out[0:pending]. If someone
|
|
* calls put_byte() - this might happen in deflate() - the byte will be
|
|
* placed into pending_buf[pending], which is incorrect. Move the
|
|
* remaining data to the beginning of pending_buf so that put_byte() is
|
|
* usable again.
|
|
*/
|
|
memmove(state->pending_buf, state->pending_out, state->pending);
|
|
state->pending_out = state->pending_buf;
|
|
}
|
|
#ifdef ZLIB_DEBUG
|
|
state->compressed_len += param->eobl;
|
|
#endif
|
|
}
|
|
|
|
int dfltcc_deflate(
|
|
z_streamp strm,
|
|
int flush,
|
|
block_state *result
|
|
)
|
|
{
|
|
deflate_state *state = (deflate_state *)strm->state;
|
|
struct dfltcc_deflate_state *dfltcc_state = GET_DFLTCC_DEFLATE_STATE(state);
|
|
struct dfltcc_param_v0 *param = &dfltcc_state->common.param;
|
|
uInt masked_avail_in;
|
|
dfltcc_cc cc;
|
|
int need_empty_block;
|
|
int soft_bcc;
|
|
int no_flush;
|
|
|
|
if (!dfltcc_can_deflate(strm)) {
|
|
/* Clear history. */
|
|
if (flush == Z_FULL_FLUSH)
|
|
param->hl = 0;
|
|
return 0;
|
|
}
|
|
|
|
again:
|
|
masked_avail_in = 0;
|
|
soft_bcc = 0;
|
|
no_flush = flush == Z_NO_FLUSH;
|
|
|
|
/* No input data. Return, except when Continuation Flag is set, which means
|
|
* that DFLTCC has buffered some output in the parameter block and needs to
|
|
* be called again in order to flush it.
|
|
*/
|
|
if (strm->avail_in == 0 && !param->cf) {
|
|
/* A block is still open, and the hardware does not support closing
|
|
* blocks without adding data. Thus, close it manually.
|
|
*/
|
|
if (!no_flush && param->bcf) {
|
|
send_eobs(strm, param);
|
|
param->bcf = 0;
|
|
}
|
|
/* Let one of deflate_* functions write a trailing empty block. */
|
|
if (flush == Z_FINISH)
|
|
return 0;
|
|
/* Clear history. */
|
|
if (flush == Z_FULL_FLUSH)
|
|
param->hl = 0;
|
|
/* Trigger block post-processing if necessary. */
|
|
*result = no_flush ? need_more : block_done;
|
|
return 1;
|
|
}
|
|
|
|
/* There is an open non-BFINAL block, we are not going to close it just
|
|
* yet, we have compressed more than DFLTCC_BLOCK_SIZE bytes and we see
|
|
* more than DFLTCC_DHT_MIN_SAMPLE_SIZE bytes. Open a new block with a new
|
|
* DHT in order to adapt to a possibly changed input data distribution.
|
|
*/
|
|
if (param->bcf && no_flush &&
|
|
strm->total_in > dfltcc_state->block_threshold &&
|
|
strm->avail_in >= dfltcc_state->dht_threshold) {
|
|
if (param->cf) {
|
|
/* We need to flush the DFLTCC buffer before writing the
|
|
* End-of-block Symbol. Mask the input data and proceed as usual.
|
|
*/
|
|
masked_avail_in += strm->avail_in;
|
|
strm->avail_in = 0;
|
|
no_flush = 0;
|
|
} else {
|
|
/* DFLTCC buffer is empty, so we can manually write the
|
|
* End-of-block Symbol right away.
|
|
*/
|
|
send_eobs(strm, param);
|
|
param->bcf = 0;
|
|
dfltcc_state->block_threshold =
|
|
strm->total_in + dfltcc_state->block_size;
|
|
}
|
|
}
|
|
|
|
/* No space for compressed data. If we proceed, dfltcc_cmpr() will return
|
|
* DFLTCC_CC_OP1_TOO_SHORT without buffering header bits, but we will still
|
|
* set BCF=1, which is wrong. Avoid complications and return early.
|
|
*/
|
|
if (strm->avail_out == 0) {
|
|
*result = need_more;
|
|
return 1;
|
|
}
|
|
|
|
/* The caller gave us too much data. Pass only one block worth of
|
|
* uncompressed data to DFLTCC and mask the rest, so that on the next
|
|
* iteration we start a new block.
|
|
*/
|
|
if (no_flush && strm->avail_in > dfltcc_state->block_size) {
|
|
masked_avail_in += (strm->avail_in - dfltcc_state->block_size);
|
|
strm->avail_in = dfltcc_state->block_size;
|
|
}
|
|
|
|
/* When we have an open non-BFINAL deflate block and caller indicates that
|
|
* the stream is ending, we need to close an open deflate block and open a
|
|
* BFINAL one.
|
|
*/
|
|
need_empty_block = flush == Z_FINISH && param->bcf && !param->bhf;
|
|
|
|
/* Translate stream to parameter block */
|
|
param->cvt = CVT_ADLER32;
|
|
if (!no_flush)
|
|
/* We need to close a block. Always do this in software - when there is
|
|
* no input data, the hardware will not hohor BCC. */
|
|
soft_bcc = 1;
|
|
if (flush == Z_FINISH && !param->bcf)
|
|
/* We are about to open a BFINAL block, set Block Header Final bit
|
|
* until the stream ends.
|
|
*/
|
|
param->bhf = 1;
|
|
/* DFLTCC-CMPR will write to next_out, so make sure that buffers with
|
|
* higher precedence are empty.
|
|
*/
|
|
Assert(state->pending == 0, "There must be no pending bytes");
|
|
Assert(state->bi_valid < 8, "There must be less than 8 pending bits");
|
|
param->sbb = (unsigned int)state->bi_valid;
|
|
if (param->sbb > 0)
|
|
*strm->next_out = (Byte)state->bi_buf;
|
|
/* Honor history and check value */
|
|
param->nt = 0;
|
|
param->cv = strm->adler;
|
|
|
|
/* When opening a block, choose a Huffman-Table Type */
|
|
if (!param->bcf) {
|
|
if (strm->total_in == 0 && dfltcc_state->block_threshold > 0) {
|
|
param->htt = HTT_FIXED;
|
|
}
|
|
else {
|
|
param->htt = HTT_DYNAMIC;
|
|
dfltcc_gdht(strm);
|
|
}
|
|
}
|
|
|
|
/* Deflate */
|
|
do {
|
|
cc = dfltcc_cmpr(strm);
|
|
if (strm->avail_in < 4096 && masked_avail_in > 0)
|
|
/* We are about to call DFLTCC with a small input buffer, which is
|
|
* inefficient. Since there is masked data, there will be at least
|
|
* one more DFLTCC call, so skip the current one and make the next
|
|
* one handle more data.
|
|
*/
|
|
break;
|
|
} while (cc == DFLTCC_CC_AGAIN);
|
|
|
|
/* Translate parameter block to stream */
|
|
strm->msg = oesc_msg(dfltcc_state->common.msg, param->oesc);
|
|
state->bi_valid = param->sbb;
|
|
if (state->bi_valid == 0)
|
|
state->bi_buf = 0; /* Avoid accessing next_out */
|
|
else
|
|
state->bi_buf = *strm->next_out & ((1 << state->bi_valid) - 1);
|
|
strm->adler = param->cv;
|
|
|
|
/* Unmask the input data */
|
|
strm->avail_in += masked_avail_in;
|
|
masked_avail_in = 0;
|
|
|
|
/* If we encounter an error, it means there is a bug in DFLTCC call */
|
|
Assert(cc != DFLTCC_CC_OP2_CORRUPT || param->oesc == 0, "BUG");
|
|
|
|
/* Update Block-Continuation Flag. It will be used to check whether to call
|
|
* GDHT the next time.
|
|
*/
|
|
if (cc == DFLTCC_CC_OK) {
|
|
if (soft_bcc) {
|
|
send_eobs(strm, param);
|
|
param->bcf = 0;
|
|
dfltcc_state->block_threshold =
|
|
strm->total_in + dfltcc_state->block_size;
|
|
} else
|
|
param->bcf = 1;
|
|
if (flush == Z_FINISH) {
|
|
if (need_empty_block)
|
|
/* Make the current deflate() call also close the stream */
|
|
return 0;
|
|
else {
|
|
bi_windup(state);
|
|
*result = finish_done;
|
|
}
|
|
} else {
|
|
if (flush == Z_FULL_FLUSH)
|
|
param->hl = 0; /* Clear history */
|
|
*result = flush == Z_NO_FLUSH ? need_more : block_done;
|
|
}
|
|
} else {
|
|
param->bcf = 1;
|
|
*result = need_more;
|
|
}
|
|
if (strm->avail_in != 0 && strm->avail_out != 0)
|
|
goto again; /* deflate() must use all input or all output */
|
|
return 1;
|
|
}
|
|
EXPORT_SYMBOL(dfltcc_deflate);
|