import zlib-1.2.11-16.el8_2

SOURCES/zlib-1.2.11-IBM-Z-hw-accelrated-deflate-fix.patch

@@ -0,0 +1,516 @@
+From 608b71008c16ce6fbf2305145c5ffb69cd88ef59 Mon Sep 17 00:00:00 2001
+From: Ondrej Dubaj <odubaj@redhat.com>
+Date: Fri, 7 Aug 2020 07:12:50 +0200
+Subject: [PATCH] Fix for Z hardware-accelerated deflate for s390x
+
+---
+ configure                     |   7 +
+ contrib/s390/dfltcc.c         | 244 +++++++++++++++++++++-------------
+ contrib/s390/dfltcc_deflate.h |  10 +-
+ deflate.c                     |  21 +--
+ 4 files changed, 177 insertions(+), 105 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..d88a0d6 100644
+--- a/contrib/s390/dfltcc.c
++++ b/contrib/s390/dfltcc.c
+@@ -2,12 +2,13 @@
+ 
+ /*
+    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
+ #include <ctype.h>
++#include <errno.h>
+ #include <inttypes.h>
+ #include <stddef.h>
+ #include <stdio.h>
+@@ -230,31 +231,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 +264,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 +358,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 +429,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 +444,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 */
+@@ -642,27 +653,86 @@ int ZLIB_INTERNAL dfltcc_inflate_disable(strm)
+     return 0;
+ }
+ 
+-/*
+-   Memory management.
+-   DFLTCC requires parameter blocks and window to be aligned. zlib allows
+-   users to specify their own allocation functions, so using e.g.
+-   `posix_memalign' is not an option. Thus, we overallocate and take the
+-   aligned portion of the buffer.
+-*/
++local int env_dfltcc_disabled;
++local int env_source_date_epoch;
++local unsigned long env_level_mask;
++local unsigned long env_block_size;
++local unsigned long env_block_threshold;
++local unsigned long env_dht_threshold;
++local unsigned long env_ribm;
++local uint64_t cpu_facilities[(DFLTCC_FACILITY / 64) + 1];
++local struct dfltcc_qaf_param cpu_af __attribute__((aligned(8))); 
++
+ local inline int is_dfltcc_enabled OF((void));
+ local inline int is_dfltcc_enabled(void)
++{
++    if (env_dfltcc_disabled)
++      /* User has explicitly disabled DFLTCC. */
++      return 0;
++
++    return is_bit_set((const char *)cpu_facilities, DFLTCC_FACILITY);
++}
++
++local unsigned long xstrtoul OF((const char *s, unsigned long _default));
++local unsigned long xstrtoul(s, _default)
++    const char *s;
++    unsigned long _default;
++{
++    char *endptr;
++    unsigned long result;
++
++    if (!(s && *s))
++        return _default;
++    errno = 0;
++    result = strtoul(s, &endptr, 0);
++    return (errno || *endptr) ? _default : result;
++}
++
++__attribute__((constructor)) local void init_globals OF((void));
++__attribute__((constructor)) local void init_globals(void)
+ {
+     const char *env;
+-    uint64_t facilities[(DFLTCC_FACILITY / 64) + 1];
+     register char r0 __asm__("r0");
+ 
+     env = secure_getenv("DFLTCC");
+-    if (env && !strcmp(env, "0"))
+-      /* User has explicitly disabled DFLTCC. */
+-      return 0;
++    
++
++    env_dfltcc_disabled = env && !strcmp(env, "0");
++
++    env = secure_getenv("SOURCE_DATE_EPOCH");
++    env_source_date_epoch = !!env;
++
++#ifndef DFLTCC_LEVEL_MASK
++#define DFLTCC_LEVEL_MASK 0x2
++#endif
++    env_level_mask = xstrtoul(secure_getenv("DFLTCC_LEVEL_MASK"),
++                              DFLTCC_LEVEL_MASK);
++
++#ifndef DFLTCC_BLOCK_SIZE
++#define DFLTCC_BLOCK_SIZE 1048576
++#endif
++    env_block_size = xstrtoul(secure_getenv("DFLTCC_BLOCK_SIZE"),
++                              DFLTCC_BLOCK_SIZE);
+ 
+-    memset(facilities, 0, sizeof(facilities));
+-    r0 = sizeof(facilities) / sizeof(facilities[0]) - 1;
++#ifndef DFLTCC_FIRST_FHT_BLOCK_SIZE
++#define DFLTCC_FIRST_FHT_BLOCK_SIZE 4096
++#endif
++    env_block_threshold = xstrtoul(secure_getenv("DFLTCC_FIRST_FHT_BLOCK_SIZE"),
++                                   DFLTCC_FIRST_FHT_BLOCK_SIZE);
++
++#ifndef DFLTCC_DHT_MIN_SAMPLE_SIZE
++#define DFLTCC_DHT_MIN_SAMPLE_SIZE 4096
++#endif
++    env_dht_threshold = xstrtoul(secure_getenv("DFLTCC_DHT_MIN_SAMPLE_SIZE"),
++                                  DFLTCC_DHT_MIN_SAMPLE_SIZE);
++
++#ifndef DFLTCC_RIBM
++#define DFLTCC_RIBM 0
++#endif
++    env_ribm = xstrtoul(secure_getenv("DFLTCC_RIBM"), DFLTCC_RIBM);
++
++    memset(cpu_facilities, 0, sizeof(cpu_facilities));
++    r0 = sizeof(cpu_facilities) / sizeof(cpu_facilities[0]) - 1;
+     /* STFLE is supported since z9-109 and only in z/Architecture mode. When
+      * compiling with -m31, gcc defaults to ESA mode, however, since the kernel
+      * is 64-bit, it's always z/Architecture mode at runtime.
+@@ -671,31 +741,35 @@ local inline int is_dfltcc_enabled(void)
+                      ".machinemode zarch\n"
+                      "stfle %[facilities]\n"
+                      ".machinemode pop\n"
+-                     : [facilities] "=Q" (facilities)
++                     : [facilities] "=Q" (cpu_facilities)
+                      , [r0] "+r" (r0)
+                      :
+                      : "cc");
+-    return is_bit_set((const char *)facilities, DFLTCC_FACILITY);
++    /* Initialize available functions */
++    if (is_dfltcc_enabled())
++        dfltcc(DFLTCC_QAF, &cpu_af, NULL, NULL, NULL, NULL, NULL);
++    else
++        memset(&cpu_af, 0, sizeof(cpu_af)); 
+ }
+ 
++/*
++   Memory management.
++
++   DFLTCC requires parameter blocks and window to be aligned. zlib allows
++   users to specify their own allocation functions, so using e.g.
++   `posix_memalign' is not an option. Thus, we overallocate and take the
++   aligned portion of the buffer.
++*/ 
+ void ZLIB_INTERNAL dfltcc_reset(strm, size)
+     z_streamp strm;
+     uInt size;
+ {
+     struct dfltcc_state *dfltcc_state =
+         (struct dfltcc_state *)((char FAR *)strm->state + ALIGN_UP(size, 8));
+-    struct dfltcc_qaf_param *param =
+-        (struct dfltcc_qaf_param *)&dfltcc_state->param;
+-    const char *s;
+ 
+-    /* Initialize available functions */
+-    if (is_dfltcc_enabled()) {
+-        dfltcc(DFLTCC_QAF, param, NULL, NULL, NULL, NULL, NULL);
+-        memmove(&dfltcc_state->af, param, sizeof(dfltcc_state->af));
+-    } else
+-        memset(&dfltcc_state->af, 0, sizeof(dfltcc_state->af));
++    memcpy(&dfltcc_state->af, &cpu_af, sizeof(dfltcc_state->af));
+ 
+-    if (secure_getenv("SOURCE_DATE_EPOCH"))
++    if (env_source_date_epoch)
+         /* User needs reproducible results, but the output of DFLTCC_CMPR
+          * depends on buffers' page offsets.
+          */
+@@ -706,36 +780,11 @@ void ZLIB_INTERNAL dfltcc_reset(strm, size)
+     dfltcc_state->param.nt = 1;
+ 
+     /* Initialize tuning parameters */
+-#ifndef DFLTCC_LEVEL_MASK
+-#define DFLTCC_LEVEL_MASK 0x2
+-#endif
+-    s = secure_getenv("DFLTCC_LEVEL_MASK");
+-    dfltcc_state->level_mask = (s && *s) ? strtoul(s, NULL, 0) :
+-                                           DFLTCC_LEVEL_MASK;
+-#ifndef DFLTCC_BLOCK_SIZE
+-#define DFLTCC_BLOCK_SIZE 1048576
+-#endif
+-    s = secure_getenv("DFLTCC_BLOCK_SIZE");
+-    dfltcc_state->block_size = (s && *s) ? strtoul(s, NULL, 0) :
+-                                           DFLTCC_BLOCK_SIZE;
+-#ifndef DFLTCC_FIRST_FHT_BLOCK_SIZE
+-#define DFLTCC_FIRST_FHT_BLOCK_SIZE 4096
+-#endif
+-    s = secure_getenv("DFLTCC_FIRST_FHT_BLOCK_SIZE");
+-    dfltcc_state->block_threshold = (s && *s) ? strtoul(s, NULL, 0) :
+-                                                DFLTCC_FIRST_FHT_BLOCK_SIZE;
+-#ifndef DFLTCC_DHT_MIN_SAMPLE_SIZE
+-#define DFLTCC_DHT_MIN_SAMPLE_SIZE 4096
+-#endif
+-    s = secure_getenv("DFLTCC_DHT_MIN_SAMPLE_SIZE");
+-    dfltcc_state->dht_threshold = (s && *s) ? strtoul(s, NULL, 0) :
+-                                              DFLTCC_DHT_MIN_SAMPLE_SIZE;
+-#ifndef DFLTCC_RIBM
+-#define DFLTCC_RIBM 0
+-#endif
+-    s = secure_getenv("DFLTCC_RIBM");
+-    dfltcc_state->param.ribm = (s && *s) ? strtoul(s, NULL, 0) :
+-                                           DFLTCC_RIBM;
++    dfltcc_state->level_mask = env_level_mask;
++    dfltcc_state->block_size = env_block_size;
++    dfltcc_state->block_threshold = env_block_threshold;
++    dfltcc_state->dht_threshold = env_dht_threshold;
++    dfltcc_state->param.ribm = env_ribm;
+ }
+ 
+ voidpf ZLIB_INTERNAL dfltcc_alloc_state(strm, items, size)
+@@ -787,22 +836,26 @@ void ZLIB_INTERNAL dfltcc_free_window(strm, w)
+ 
+ /*
+    Switching between hardware and software compression.
++
+    DFLTCC does not support all zlib settings, e.g. generation of non-compressed
+    blocks or alternative window sizes. When such settings are applied on the
+    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 +865,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..de36784 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 b17a7dd..a80bd3e 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)
+@@ -1065,7 +1067,6 @@ int ZEXPORT deflate (strm, flush)
+     }
+ 
+     if (flush != Z_FINISH) return Z_OK;
+-    if (s->wrap <= 0) return Z_STREAM_END;
+ 
+     /* Write the trailer */
+ #ifdef GZIP
+@@ -1081,7 +1082,7 @@ int ZEXPORT deflate (strm, flush)
+     }
+     else
+ #endif
+-    {
++    if (s->wrap == 1) {
+         putShortMSB(s, (uInt)(strm->adler >> 16));
+         putShortMSB(s, (uInt)(strm->adler & 0xffff));
+     }
+@@ -1090,7 +1091,11 @@ int ZEXPORT deflate (strm, flush)
+      * to flush the rest.
+      */
+     if (s->wrap > 0) s->wrap = -s->wrap; /* write the trailer only once! */
+-    return s->pending != 0 ? Z_OK : Z_STREAM_END;
++    if (s->pending == 0) {
++        Assert(s->bi_valid == 0, "bi_buf not flushed");
++        return Z_STREAM_END;
++    }
++    return Z_OK; 
+ }
+ 
+ /* ========================================================================= */
+-- 
+2.26.0
+

SOURCES/zlib-1.2.11-permit-deflateParams-change.patch

@@ -0,0 +1,70 @@
+From d09bb1ab8ef9bb91457c0ead09589e8807489260 Mon Sep 17 00:00:00 2001
+From: Ondrej Dubaj <odubaj@redhat.com>
+Date: Thu, 6 Aug 2020 08:09:53 +0200
+Subject: [PATCH] Permit a deflateParams() parameter change.
+
+This change allows a parameter change even if the input data has
+not all been compressed and copied to the application output
+buffer, so long as all of the input data has been compressed to
+the internal pending output buffer. This also allows an immediate
+deflateParams change so long as there have been no deflate calls
+since initialization or reset.
+---
+ deflate.c |  6 +++---
+ zlib.h    | 11 ++++++-----
+ 2 files changed, 9 insertions(+), 8 deletions(-)
+
+diff --git a/deflate.c b/deflate.c
+index 9705c1c..f3c9924 100644
+--- a/deflate.c
++++ b/deflate.c
+@@ -509,7 +509,7 @@ int ZEXPORT deflateResetKeep (strm)
+         s->wrap == 2 ? crc32(0L, Z_NULL, 0) :
+ #endif
+         adler32(0L, Z_NULL, 0);
+-    s->last_flush = Z_NO_FLUSH;
++    s->last_flush = -2;
+ 
+     _tr_init(s);
+ 
+@@ -606,13 +606,13 @@ int ZEXPORT deflateParams(strm, level, strategy)
+     func = configuration_table[s->level].func;
+ 
+     if ((strategy != s->strategy || func != configuration_table[level].func ||
+-        hook_flush != Z_NO_FLUSH) && s->high_water) {
++        hook_flush != Z_NO_FLUSH) && s->last_flush != -2) {
+         /* Flush the last buffer: */
+         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)
++        if (strm->avail_in || (s->strstart - s->block_start) + s->lookahead)
+             return Z_BUF_ERROR;
+     }
+     if (s->level != level) {
+diff --git a/zlib.h b/zlib.h
+index f09cdaf..001624e 100644
+--- a/zlib.h
++++ b/zlib.h
+@@ -712,11 +712,12 @@ ZEXTERN int ZEXPORT deflateParams OF((z_streamp strm,
+    used to switch between compression and straight copy of the input data, or
+    to switch to a different kind of input data requiring a different strategy.
+    If the compression approach (which is a function of the level) or the
+-   strategy is changed, and if any input has been consumed in a previous
+-   deflate() call, then the input available so far is compressed with the old
+-   level and strategy using deflate(strm, Z_BLOCK).  There are three approaches
+-   for the compression levels 0, 1..3, and 4..9 respectively.  The new level
+-   and strategy will take effect at the next call of deflate().
++   strategy is changed, and if there have been any deflate() calls since the
++   state was initialized or reset, then the input available so far is
++   compressed with the old level and strategy using deflate(strm, Z_BLOCK).
++   There are three approaches for the compression levels 0, 1..3, and 4..9
++   respectively.  The new level and strategy will take effect at the next call
++   of deflate().
+ 
+      If a deflate(strm, Z_BLOCK) is performed by deflateParams(), and it does
+    not have enough output space to complete, then the parameter change will not
+-- 
+2.26.0
+

SPECS/zlib.spec

@@ -3,7 +3,7 @@
 
 Name:    zlib
 Version: 1.2.11
-Release: 13%{?dist}
+Release: 16%{?dist}
 Summary: The compression and decompression library
 # /contrib/dotzlib/ have Boost license
 License: zlib and Boost
@@ -22,6 +22,10 @@ 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
+# permit a deflateParams() parameter change
+Patch7: zlib-1.2.11-permit-deflateParams-change.patch
 
 BuildRequires: automake, autoconf, libtool
 
@@ -80,6 +84,8 @@ developing applications which use minizip.
 %patch3 -p1
 %patch4 -p1
 %patch5 -p1
+%patch6 -p1
+%patch7 -p1
 
 iconv -f iso-8859-2 -t utf-8 < ChangeLog > ChangeLog.tmp
 mv ChangeLog.tmp ChangeLog
@@ -90,19 +96,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 +165,20 @@ find $RPM_BUILD_ROOT -name '*.la' -delete
 
 
 %changelog
+* Mon Jun 15 2020 Ondrej Dubaj <odubaj@redhat.com> - 1.2.11-16
+- Permit a deflateParams() parameter change
+- Another fix for Z hardware-accelerated deflate for s390x architectures
+- according to previous change by upstream
+
+* Mon Jun 15 2020 Ondrej Dubaj <odubaj@redhat.com> - 1.2.11-15
+- Another fix for Z hardware-accelerated deflate for s390x architectures
+
+* Mon May 25 2020 Ondrej Dubaj <odubaj@redhat.com> - 1.2.11-14
+- Fix for Z hardware-accelerated deflate for s390x architectures
+
 * Tue Oct 29 2019 Ondrej Dubaj <odubaj@redhat.com> - 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 <odubaj@redhat.com> - 1.2.11-12
 - fixed covscan issues