diff --git a/SOURCES/zlib-1.2.11-IBM-Z-hw-accelrated-deflate-fix.patch b/SOURCES/zlib-1.2.11-IBM-Z-hw-accelrated-deflate-fix.patch new file mode 100644 index 0000000..92fa27c --- /dev/null +++ b/SOURCES/zlib-1.2.11-IBM-Z-hw-accelrated-deflate-fix.patch @@ -0,0 +1,286 @@ +From 772ddd6500a74220e641782cc2ee892433197192 Mon Sep 17 00:00:00 2001 +From: IBM developers +Date: Mon, 25 May 2020 14:09:48 +0200 +Subject: [PATCH] Fix for Z hardware-accelerated deflate for s390x + architectures + +--- + configure | 7 +++ + contrib/s390/dfltcc.c | 94 ++++++++++++++++++++--------------- + contrib/s390/dfltcc_deflate.h | 10 ++-- + deflate.c | 12 +++-- + 4 files changed, 76 insertions(+), 47 deletions(-) + +diff --git a/configure b/configure +index 66caece..bfe4386 100755 +--- a/configure ++++ b/configure +@@ -114,6 +114,7 @@ case "$1" in + echo ' configure [--const] [--zprefix] [--prefix=PREFIX] [--eprefix=EXPREFIX]' | tee -a configure.log + echo ' [--static] [--64] [--libdir=LIBDIR] [--sharedlibdir=LIBDIR]' | tee -a configure.log + echo ' [--includedir=INCLUDEDIR] [--archs="-arch i386 -arch x86_64"]' | tee -a configure.log ++ echo ' [--dfltcc]' | tee -a configure.log + exit 0 ;; + -p*=* | --prefix=*) prefix=`echo $1 | sed 's/.*=//'`; shift ;; + -e*=* | --eprefix=*) exec_prefix=`echo $1 | sed 's/.*=//'`; shift ;; +@@ -137,6 +138,12 @@ case "$1" in + -c* | --const) zconst=1; shift ;; + -w* | --warn) warn=1; shift ;; + -d* | --debug) debug=1; shift ;; ++ --dfltcc) ++ CFLAGS="$CFLAGS -DDFLTCC" ++ OBJC="$OBJC dfltcc.o" ++ PIC_OBJC="$PIC_OBJC dfltcc.lo" ++ shift ++ ;; + *) + echo "unknown option: $1" | tee -a configure.log + echo "$0 --help for help" | tee -a configure.log +diff --git a/contrib/s390/dfltcc.c b/contrib/s390/dfltcc.c +index d187796..face8f1 100644 +--- a/contrib/s390/dfltcc.c ++++ b/contrib/s390/dfltcc.c +@@ -2,8 +2,8 @@ + + /* + Use the following commands to build zlib with DFLTCC support: +- $ CFLAGS=-DDFLTCC ./configure +- $ make OBJA=dfltcc.o PIC_OBJA=dfltcc.lo ++ $ ./configure --dfltcc ++ $ make + */ + + #define _GNU_SOURCE +@@ -230,31 +230,28 @@ struct dfltcc_state { + /* + Compress. + */ +-local inline int dfltcc_are_params_ok(int level, +- uInt window_bits, +- int strategy, +- uLong level_mask); +-local inline int dfltcc_are_params_ok(level, window_bits, strategy, level_mask) ++local inline int dfltcc_can_deflate_with_params(z_streamp strm, ++ int level, ++ uInt window_bits, ++ int strategy); ++local inline int dfltcc_can_deflate_with_params(strm, ++ level, ++ window_bits, ++ strategy) ++ z_streamp strm; + int level; + uInt window_bits; + int strategy; +- uLong level_mask; +-{ +- return (level_mask & (1 << level)) != 0 && +- (window_bits == HB_BITS) && +- (strategy == Z_FIXED || strategy == Z_DEFAULT_STRATEGY); +-} +- +- +-int ZLIB_INTERNAL dfltcc_can_deflate(strm) +- z_streamp strm; + { + deflate_state FAR *state = (deflate_state FAR *)strm->state; + struct dfltcc_state FAR *dfltcc_state = GET_DFLTCC_STATE(state); + + /* Unsupported compression settings */ +- if (!dfltcc_are_params_ok(state->level, state->w_bits, state->strategy, +- dfltcc_state->level_mask)) ++ if ((dfltcc_state->level_mask & (1 << level)) == 0) ++ return 0; ++ if (window_bits != HB_BITS) ++ return 0; ++ if (strategy != Z_FIXED && strategy != Z_DEFAULT_STRATEGY) + return 0; + + /* Unsupported hardware */ +@@ -266,6 +263,17 @@ int ZLIB_INTERNAL dfltcc_can_deflate(strm) + return 1; + } + ++int ZLIB_INTERNAL dfltcc_can_deflate(strm) ++ z_streamp strm; ++{ ++ deflate_state FAR *state = (deflate_state FAR *)strm->state; ++ ++ return dfltcc_can_deflate_with_params(strm, ++ state->level, ++ state->w_bits, ++ state->strategy); ++} ++ + local void dfltcc_gdht OF((z_streamp strm)); + local void dfltcc_gdht(strm) + z_streamp strm; +@@ -349,22 +357,24 @@ again: + soft_bcc = 0; + no_flush = flush == Z_NO_FLUSH; + +- /* Trailing empty block. Switch to software, 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. ++ /* 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 (flush == Z_FINISH && strm->avail_in == 0 && !param->cf) { +- if (param->bcf) { +- /* A block is still open, and the hardware does not support closing +- * blocks without adding data. Thus, close it manually. +- */ ++ 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; + } +- return 0; +- } +- +- if (strm->avail_in == 0 && !param->cf) { ++ /* 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; + *result = need_more; + return 1; + } +@@ -418,7 +428,7 @@ again: + param->cvt = state->wrap == 2 ? CVT_CRC32 : 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 nohor BCC. */ ++ * no input data, the hardware will not honor BCC. */ + soft_bcc = 1; + if (flush == Z_FINISH && !param->bcf) + /* We are about to open a BFINAL block, set Block Header Final bit +@@ -433,8 +443,8 @@ again: + param->sbb = (unsigned int)state->bi_valid; + if (param->sbb > 0) + *strm->next_out = (Bytef)state->bi_buf; +- if (param->hl) +- param->nt = 0; /* Honor history */ ++ /* Honor history and check value */ ++ param->nt = 0; + param->cv = state->wrap == 2 ? ZSWAP32(strm->adler) : strm->adler; + + /* When opening a block, choose a Huffman-Table Type */ +@@ -792,17 +802,20 @@ void ZLIB_INTERNAL dfltcc_free_window(strm, w) + fly with deflateParams, we need to convert between hardware and software + window formats. + */ +-int ZLIB_INTERNAL dfltcc_deflate_params(strm, level, strategy) ++int ZLIB_INTERNAL dfltcc_deflate_params(strm, level, strategy, flush) + z_streamp strm; + int level; + int strategy; ++ int *flush; + { + deflate_state FAR *state = (deflate_state FAR *)strm->state; + struct dfltcc_state FAR *dfltcc_state = GET_DFLTCC_STATE(state); + struct dfltcc_param_v0 FAR *param = &dfltcc_state->param; + int could_deflate = dfltcc_can_deflate(strm); +- int can_deflate = dfltcc_are_params_ok(level, state->w_bits, strategy, +- dfltcc_state->level_mask); ++ int can_deflate = dfltcc_can_deflate_with_params(strm, ++ level, ++ state->w_bits, ++ strategy); + + if (can_deflate == could_deflate) + /* We continue to work in the same mode - no changes needed */ +@@ -812,8 +825,11 @@ int ZLIB_INTERNAL dfltcc_deflate_params(strm, level, strategy) + /* DFLTCC was not used yet - no changes needed */ + return Z_OK; + +- /* Switching between hardware and software is not implemented */ +- return Z_STREAM_ERROR; ++ /* For now, do not convert between window formats - simply get rid of the ++ * old data instead. ++ */ ++ *flush = Z_FULL_FLUSH; ++ return Z_OK; + } + + /* +diff --git a/contrib/s390/dfltcc_deflate.h b/contrib/s390/dfltcc_deflate.h +index a129a91..947b1e4 100644 +--- a/contrib/s390/dfltcc_deflate.h ++++ b/contrib/s390/dfltcc_deflate.h +@@ -9,7 +9,8 @@ int ZLIB_INTERNAL dfltcc_deflate OF((z_streamp strm, + block_state *result)); + int ZLIB_INTERNAL dfltcc_deflate_params OF((z_streamp strm, + int level, +- int strategy)); ++ int strategy, ++ int *flush)); + int ZLIB_INTERNAL dfltcc_deflate_set_dictionary OF((z_streamp strm, + const Bytef *dictionary, + uInt dict_length)); +@@ -29,11 +30,14 @@ int ZLIB_INTERNAL dfltcc_deflate_get_dictionary OF((z_streamp strm, + } while (0) + #define DEFLATE_RESET_KEEP_HOOK(strm) \ + dfltcc_reset((strm), sizeof(deflate_state)) +-#define DEFLATE_PARAMS_HOOK(strm, level, strategy) \ ++#define DEFLATE_PARAMS_HOOK(strm, level, strategy, hook_flush) \ + do { \ + int err; \ + \ +- err = dfltcc_deflate_params((strm), (level), (strategy)); \ ++ err = dfltcc_deflate_params((strm), \ ++ (level), \ ++ (strategy), \ ++ (hook_flush)); \ + if (err == Z_STREAM_ERROR) \ + return err; \ + } while (0) +diff --git a/deflate.c b/deflate.c +index 9b09718..9284483 100644 +--- a/deflate.c ++++ b/deflate.c +@@ -74,7 +74,7 @@ const char deflate_copyright[] = + #define DEFLATE_SET_DICTIONARY_HOOK(strm, dict, dict_len) do {} while (0) + #define DEFLATE_GET_DICTIONARY_HOOK(strm, dict, dict_len) do {} while (0) + #define DEFLATE_RESET_KEEP_HOOK(strm) do {} while (0) +-#define DEFLATE_PARAMS_HOOK(strm, level, strategy) do {} while (0) ++#define DEFLATE_PARAMS_HOOK(strm, level, strategy, hook_flush) do {} while (0) + #define DEFLATE_BOUND_ADJUST_COMPLEN(strm, complen, sourceLen) do {} while (0) + #define DEFLATE_NEED_CONSERVATIVE_BOUND(strm) 0 + #define DEFLATE_HOOK(strm, flush, bstate) 0 +@@ -589,6 +589,7 @@ int ZEXPORT deflateParams(strm, level, strategy) + { + deflate_state *s; + compress_func func; ++ int hook_flush = Z_NO_FLUSH; + + if (deflateStateCheck(strm)) return Z_STREAM_ERROR; + s = strm->state; +@@ -601,13 +602,14 @@ int ZEXPORT deflateParams(strm, level, strategy) + if (level < 0 || level > 9 || strategy < 0 || strategy > Z_FIXED) { + return Z_STREAM_ERROR; + } +- DEFLATE_PARAMS_HOOK(strm, level, strategy); ++ DEFLATE_PARAMS_HOOK(strm, level, strategy, &hook_flush); + func = configuration_table[s->level].func; + +- if ((strategy != s->strategy || func != configuration_table[level].func) && +- s->high_water) { ++ if ((strategy != s->strategy || func != configuration_table[level].func || ++ hook_flush != Z_NO_FLUSH) && s->high_water) { + /* Flush the last buffer: */ +- int err = deflate(strm, Z_BLOCK); ++ int err = deflate(strm, RANK(hook_flush) > RANK(Z_BLOCK) ? ++ hook_flush : Z_BLOCK); + if (err == Z_STREAM_ERROR) + return err; + if (strm->avail_out == 0) +-- +2.24.1 + diff --git a/SPECS/zlib.spec b/SPECS/zlib.spec index 4884bd9..d85c90a 100644 --- a/SPECS/zlib.spec +++ b/SPECS/zlib.spec @@ -3,7 +3,7 @@ Name: zlib Version: 1.2.11 -Release: 13%{?dist} +Release: 15%{?dist} Summary: The compression and decompression library # /contrib/dotzlib/ have Boost license License: zlib and Boost @@ -22,6 +22,8 @@ Patch3: zlib-1.2.11-optimized-CRC32-framework.patch Patch4: zlib-1.2.11-firefox-crash-fix.patch # fixed covscan issues Patch5: zlib-1.2.11-covscan-issues.patch +# fix for IBM Z optimalizations +Patch6: zlib-1.2.11-IBM-Z-hw-accelrated-deflate-fix.patch BuildRequires: automake, autoconf, libtool @@ -80,6 +82,7 @@ developing applications which use minizip. %patch3 -p1 %patch4 -p1 %patch5 -p1 +%patch6 -p1 iconv -f iso-8859-2 -t utf-8 < ChangeLog > ChangeLog.tmp mv ChangeLog.tmp ChangeLog @@ -90,19 +93,15 @@ export CFLAGS="$RPM_OPT_FLAGS" %ifarch ppc64 CFLAGS+=" -O3" %endif -%ifarch s390 s390x -CFLAGS+=" -DDFLTCC" -%endif - -export MKFLAGS="" -%ifarch s390 s390x -MKFLAGS+="OBJA=dfltcc.o PIC_OBJA=dfltcc.lo" -%endif export LDFLAGS="$LDFLAGS -Wl,-z,relro -Wl,-z,now" # no-autotools, %%configure is not compatible +%ifarch s390 s390x +./configure --libdir=%{_libdir} --includedir=%{_includedir} --prefix=%{_prefix} --dfltcc +%else ./configure --libdir=%{_libdir} --includedir=%{_includedir} --prefix=%{_prefix} -%make_build $MKFLAGS +%endif +%make_build %if %{with minizip} cd contrib/minizip @@ -163,9 +162,15 @@ find $RPM_BUILD_ROOT -name '*.la' -delete %changelog +* Mon Jun 15 2020 Ondrej Dubaj - 1.2.11-15 +- Another fix for Z hardware-accelerated deflate for s390x architectures + +* Mon May 25 2020 Ondrej Dubaj - 1.2.11-14 +- Fix for Z hardware-accelerated deflate for s390x architectures + * Tue Oct 29 2019 Ondrej Dubaj - 1.2.11-13 - Added -DDFLTCC parameter to configure to enable -- Z hardware-accelerated deflate for s390x architectures +- Z hardware-accelerated deflate for s390x architectures (#1659433) * Tue Oct 15 2019 Ondrej Dubaj - 1.2.11-12 - fixed covscan issues