diff --git a/zipl/boot/zlib/deflate.c b/zipl/boot/zlib/deflate.c index 40fc4ae2..1b8b74b3 100644 --- a/zipl/boot/zlib/deflate.c +++ b/zipl/boot/zlib/deflate.c @@ -1136,8 +1136,8 @@ int zlib_deflate_workspacesize(int windowBits, int memLevel) windowBits = -windowBits; /* Since the return value is typically passed to vmalloc() unchecked... */ - BUG_ON(memLevel < 1 || memLevel > MAX_MEM_LEVEL || windowBits < 9 || - windowBits > 15); + if (memLevel < 1 || memLevel > MAX_MEM_LEVEL || windowBits < 9 || windowBits > 15) + return 0; return sizeof(deflate_workspace) + zlib_deflate_window_memsize(windowBits) diff --git a/zipl/boot/zlib/deftree.c b/zipl/boot/zlib/deftree.c index 47dd1b81..f4720232 100644 --- a/zipl/boot/zlib/deftree.c +++ b/zipl/boot/zlib/deftree.c @@ -229,7 +229,7 @@ static void tr_static_init(void) /* The static distance tree is trivial: */ for (n = 0; n < D_CODES; n++) { static_dtree[n].Len = 5; - static_dtree[n].Code = bitrev32((u32)n) >> (32 - 5); + static_dtree[n].Code = bi_reverse((unsigned)n, 5); } static_init_done = 1; } @@ -465,7 +465,7 @@ static void gen_codes( int len = tree[n].Len; if (len == 0) continue; /* Now reverse the bits */ - tree[n].Code = bitrev32((u32)(next_code[len]++)) >> (32 - len); + tree[n].Code = (ush)bi_reverse(next_code[len]++, len); Tracecv(tree != static_ltree, (stderr,"\nn %3d %c l %2d c %4x (%x) ", n, (isgraph(n) ? n : ' '), len, tree[n].Code, next_code[len]-1)); diff --git a/zipl/boot/zlib/defutil.h b/zipl/boot/zlib/defutil.h index 40915f0c..c211cba4 100644 --- a/zipl/boot/zlib/defutil.h +++ b/zipl/boot/zlib/defutil.h @@ -2,6 +2,7 @@ #define DEFUTIL_H #include "zlib/zutil.h" +#include "../libc.h" #define Assert(err, str) #define Trace(dummy) @@ -9,7 +10,9 @@ #define Tracecv(err, dummy) #define Tracevv(dummy) - +#define PAGE_SIZE 4096 +#define PTR_ALIGN(p, a) ((typeof(p))ALIGN((unsigned long)(p), (a))) +#define max(a, b) MAX(a, b) #define LENGTH_CODES 29 /* number of length codes, not counting the special END_BLOCK code */ diff --git a/zipl/boot/zlib/dfltcc.c b/zipl/boot/zlib/dfltcc.c index 34ea49de..84c5c58e 100644 --- a/zipl/boot/zlib/dfltcc.c +++ b/zipl/boot/zlib/dfltcc.c @@ -15,7 +15,7 @@ char *oesc_msg( #ifdef STATIC return NULL; /* Ignore for pre-boot decompressor */ #else - sprintf(buf, "Operation-Ending-Supplemental Code is 0x%.2X", oesc); + snprintf(buf, 64, "Operation-Ending-Supplemental Code is 0x%.2X", oesc); return buf; #endif } diff --git a/zipl/boot/zlib/dfltcc.h b/zipl/boot/zlib/dfltcc.h index be9e1d75..4256dfb3 100644 --- a/zipl/boot/zlib/dfltcc.h +++ b/zipl/boot/zlib/dfltcc.h @@ -4,6 +4,7 @@ #include "defutil.h" #include +#include /* * Tuning parameters. @@ -114,8 +115,7 @@ void dfltcc_reset_state(struct dfltcc_state *dfltcc_state); static inline int is_dfltcc_enabled(void) { -return (zlib_dfltcc_support != ZLIB_DFLTCC_DISABLED && - test_facility(DFLTCC_FACILITY)); + return 1; /* Consider DFLTCC facility always enabled */ } #define DEFLATE_DFLTCC_ENABLED() is_dfltcc_enabled() diff --git a/zipl/boot/zlib/dfltcc_deflate.c b/zipl/boot/zlib/dfltcc_deflate.c index 1c76d3a8..9f7b06aa 100644 --- a/zipl/boot/zlib/dfltcc_deflate.c +++ b/zipl/boot/zlib/dfltcc_deflate.c @@ -17,11 +17,6 @@ int dfltcc_can_deflate( 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)) @@ -35,7 +30,6 @@ int dfltcc_can_deflate( return 1; } -EXPORT_SYMBOL(dfltcc_can_deflate); void dfltcc_reset_deflate_state(z_streamp strm) { deflate_state *state = (deflate_state *)strm->state; @@ -44,15 +38,11 @@ void dfltcc_reset_deflate_state(z_streamp strm) { 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->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 @@ -308,4 +298,3 @@ again: goto again; /* deflate() must use all input or all output */ return 1; } -EXPORT_SYMBOL(dfltcc_deflate); diff --git a/zipl/include/zlib/zlib.h b/zipl/include/zlib/zlib.h index 4e510718..a99963fc 100644 --- a/zipl/include/zlib/zlib.h +++ b/zipl/include/zlib/zlib.h @@ -32,21 +32,16 @@ #include "zconf.h" +/* Always build with DFLTCC support */ +#define CONFIG_ZLIB_DFLTCC + /* zlib deflate based on ZLIB_VERSION "1.1.3" */ -/* zlib inflate based on ZLIB_VERSION "1.2.3" */ /* - This is a modified version of zlib for use inside the Linux kernel. - The main changes are to perform all memory allocation in advance. - - Inflation Changes: - * Z_PACKET_FLUSH is added and used by ppp_deflate. Before returning - this checks there is no more input data available and the next data - is a STORED block. It also resets the mode to be read for the next - data, all as per PPP requirements. - * Addition of zlib_inflateIncomp which copies incompressible data into - the history window and adjusts the accoutning without calling - zlib_inflate itself to inflate the data. + This is a modified version of zlib for use inside s390-tools for dump + compression. It contains deflate parts only. Inflate code and function + prototypes are removed. + All memory allocations are to be performed in advance. */ /* @@ -311,145 +306,6 @@ extern int zlib_deflateEnd (z_streamp strm); deallocated). */ - -extern int zlib_inflate_workspacesize (void); -/* - Returns the number of bytes that needs to be allocated for a per- - stream workspace. A pointer to this number of bytes should be - returned in stream->workspace before calling zlib_inflateInit(). -*/ - -/* -extern int zlib_inflateInit (z_streamp strm); - - Initializes the internal stream state for decompression. The fields - next_in, avail_in, and workspace must be initialized before by - the caller. If next_in is not NULL and avail_in is large enough (the exact - value depends on the compression method), inflateInit determines the - compression method from the zlib header and allocates all data structures - accordingly; otherwise the allocation will be deferred to the first call of - inflate. If zalloc and zfree are set to NULL, inflateInit updates them to - use default allocation functions. - - inflateInit returns Z_OK if success, Z_MEM_ERROR if there was not enough - memory, Z_VERSION_ERROR if the zlib library version is incompatible with the - version assumed by the caller. msg is set to null if there is no error - message. inflateInit does not perform any decompression apart from reading - the zlib header if present: this will be done by inflate(). (So next_in and - avail_in may be modified, but next_out and avail_out are unchanged.) -*/ - - -extern int zlib_inflate (z_streamp strm, int flush); -/* - inflate decompresses as much data as possible, and stops when the input - buffer becomes empty or the output buffer becomes full. It may introduce - some output latency (reading input without producing any output) except when - forced to flush. - - The detailed semantics are as follows. inflate performs one or both of the - following actions: - - - Decompress more input starting at next_in and update next_in and avail_in - accordingly. If not all input can be processed (because there is not - enough room in the output buffer), next_in is updated and processing - will resume at this point for the next call of inflate(). - - - Provide more output starting at next_out and update next_out and avail_out - accordingly. inflate() provides as much output as possible, until there - is no more input data or no more space in the output buffer (see below - about the flush parameter). - - Before the call of inflate(), the application should ensure that at least - one of the actions is possible, by providing more input and/or consuming - more output, and updating the next_* and avail_* values accordingly. - The application can consume the uncompressed output when it wants, for - example when the output buffer is full (avail_out == 0), or after each - call of inflate(). If inflate returns Z_OK and with zero avail_out, it - must be called again after making room in the output buffer because there - might be more output pending. - - The flush parameter of inflate() can be Z_NO_FLUSH, Z_SYNC_FLUSH, - Z_FINISH, or Z_BLOCK. Z_SYNC_FLUSH requests that inflate() flush as much - output as possible to the output buffer. Z_BLOCK requests that inflate() stop - if and when it gets to the next deflate block boundary. When decoding the - zlib or gzip format, this will cause inflate() to return immediately after - the header and before the first block. When doing a raw inflate, inflate() - will go ahead and process the first block, and will return when it gets to - the end of that block, or when it runs out of data. - - The Z_BLOCK option assists in appending to or combining deflate streams. - Also to assist in this, on return inflate() will set strm->data_type to the - number of unused bits in the last byte taken from strm->next_in, plus 64 - if inflate() is currently decoding the last block in the deflate stream, - plus 128 if inflate() returned immediately after decoding an end-of-block - code or decoding the complete header up to just before the first byte of the - deflate stream. The end-of-block will not be indicated until all of the - uncompressed data from that block has been written to strm->next_out. The - number of unused bits may in general be greater than seven, except when - bit 7 of data_type is set, in which case the number of unused bits will be - less than eight. - - inflate() should normally be called until it returns Z_STREAM_END or an - error. However if all decompression is to be performed in a single step - (a single call of inflate), the parameter flush should be set to - Z_FINISH. In this case all pending input is processed and all pending - output is flushed; avail_out must be large enough to hold all the - uncompressed data. (The size of the uncompressed data may have been saved - by the compressor for this purpose.) The next operation on this stream must - be inflateEnd to deallocate the decompression state. The use of Z_FINISH - is never required, but can be used to inform inflate that a faster approach - may be used for the single inflate() call. - - In this implementation, inflate() always flushes as much output as - possible to the output buffer, and always uses the faster approach on the - first call. So the only effect of the flush parameter in this implementation - is on the return value of inflate(), as noted below, or when it returns early - because Z_BLOCK is used. - - If a preset dictionary is needed after this call (see inflateSetDictionary - below), inflate sets strm->adler to the adler32 checksum of the dictionary - chosen by the compressor and returns Z_NEED_DICT; otherwise it sets - strm->adler to the adler32 checksum of all output produced so far (that is, - total_out bytes) and returns Z_OK, Z_STREAM_END or an error code as described - below. At the end of the stream, inflate() checks that its computed adler32 - checksum is equal to that saved by the compressor and returns Z_STREAM_END - only if the checksum is correct. - - inflate() will decompress and check either zlib-wrapped or gzip-wrapped - deflate data. The header type is detected automatically. Any information - contained in the gzip header is not retained, so applications that need that - information should instead use raw inflate, see inflateInit2() below, or - inflateBack() and perform their own processing of the gzip header and - trailer. - - inflate() returns Z_OK if some progress has been made (more input processed - or more output produced), Z_STREAM_END if the end of the compressed data has - been reached and all uncompressed output has been produced, Z_NEED_DICT if a - preset dictionary is needed at this point, Z_DATA_ERROR if the input data was - corrupted (input stream not conforming to the zlib format or incorrect check - value), Z_STREAM_ERROR if the stream structure was inconsistent (for example - if next_in or next_out was NULL), Z_MEM_ERROR if there was not enough memory, - Z_BUF_ERROR if no progress is possible or if there was not enough room in the - output buffer when Z_FINISH is used. Note that Z_BUF_ERROR is not fatal, and - inflate() can be called again with more input and more output space to - continue decompressing. If Z_DATA_ERROR is returned, the application may then - call inflateSync() to look for a good compression block if a partial recovery - of the data is desired. -*/ - - -extern int zlib_inflateEnd (z_streamp strm); -/* - All dynamically allocated data structures for this stream are freed. - This function discards any unprocessed input and does not flush any - pending output. - - inflateEnd returns Z_OK if success, Z_STREAM_ERROR if the stream state - was inconsistent. In the error case, msg may be set but then points to a - static string (which must not be deallocated). -*/ - /* Advanced functions */ /* @@ -516,84 +372,14 @@ static inline unsigned long deflateBound(unsigned long s) return s + ((s + 7) >> 3) + ((s + 63) >> 6) + 11; } -/* -extern int inflateInit2 (z_streamp strm, int windowBits); - - This is another version of inflateInit with an extra parameter. The - fields next_in, avail_in, zalloc, zfree and opaque must be initialized - before by the caller. - - The windowBits parameter is the base two logarithm of the maximum window - size (the size of the history buffer). It should be in the range 8..15 for - this version of the library. The default value is 15 if inflateInit is used - instead. windowBits must be greater than or equal to the windowBits value - provided to deflateInit2() while compressing, or it must be equal to 15 if - deflateInit2() was not used. If a compressed stream with a larger window - size is given as input, inflate() will return with the error code - Z_DATA_ERROR instead of trying to allocate a larger window. - - windowBits can also be -8..-15 for raw inflate. In this case, -windowBits - determines the window size. inflate() will then process raw deflate data, - not looking for a zlib or gzip header, not generating a check value, and not - looking for any check values for comparison at the end of the stream. This - is for use with other formats that use the deflate compressed data format - such as zip. Those formats provide their own check values. If a custom - format is developed using the raw deflate format for compressed data, it is - recommended that a check value such as an adler32 or a crc32 be applied to - the uncompressed data as is done in the zlib, gzip, and zip formats. For - most applications, the zlib format should be used as is. Note that comments - above on the use in deflateInit2() applies to the magnitude of windowBits. - - windowBits can also be greater than 15 for optional gzip decoding. Add - 32 to windowBits to enable zlib and gzip decoding with automatic header - detection, or add 16 to decode only the gzip format (the zlib format will - return a Z_DATA_ERROR). If a gzip stream is being decoded, strm->adler is - a crc32 instead of an adler32. - - inflateInit2 returns Z_OK if success, Z_MEM_ERROR if there was not enough - memory, Z_STREAM_ERROR if a parameter is invalid (such as a null strm). msg - is set to null if there is no error message. inflateInit2 does not perform - any decompression apart from reading the zlib header if present: this will - be done by inflate(). (So next_in and avail_in may be modified, but next_out - and avail_out are unchanged.) -*/ - -extern int zlib_inflateReset (z_streamp strm); -/* - This function is equivalent to inflateEnd followed by inflateInit, - but does not free and reallocate all the internal decompression state. - The stream will keep attributes that may have been set by inflateInit2. - - inflateReset returns Z_OK if success, or Z_STREAM_ERROR if the source - stream state was inconsistent (such as zalloc or state being NULL). -*/ - -extern int zlib_inflateIncomp (z_stream *strm); -/* - This function adds the data at next_in (avail_in bytes) to the output - history without performing any output. There must be no pending output, - and the decompressor must be expecting to see the start of a block. - Calling this function is equivalent to decompressing a stored block - containing the data at next_in (except that the data is not output). -*/ - #define zlib_deflateInit(strm, level) \ zlib_deflateInit2((strm), (level), Z_DEFLATED, MAX_WBITS, \ DEF_MEM_LEVEL, Z_DEFAULT_STRATEGY) -#define zlib_inflateInit(strm) \ - zlib_inflateInit2((strm), DEF_WBITS) - extern int zlib_deflateInit2(z_streamp strm, int level, int method, int windowBits, int memLevel, int strategy); -extern int zlib_inflateInit2(z_streamp strm, int windowBits); - #if !defined(_Z_UTIL_H) && !defined(NO_DUMMY_DECL) struct internal_state {int dummy;}; /* hack for buggy compilers */ #endif -/* Utility function: initialize zlib, unpack binary blob, clean up zlib, - * return len or negative error code. */ -extern int zlib_inflate_blob(void *dst, unsigned dst_sz, const void *src, unsigned src_sz); - #endif /* _ZLIB_H */