gzip.c/gzip.h		gzip decompression support

/*

 * CDDL HEADER START

 *

 * The contents of this file are subject to the terms of the

 * Common Development and Distribution License (the "License").

 * You may not use this file except in compliance with the License.

 *

 * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE

 * or http://www.opensolaris.org/os/licensing.

 * See the License for the specific language governing permissions

 * and limitations under the License.

 *

 * When distributing Covered Code, include this CDDL HEADER in each

 * file and include the License file at usr/src/OPENSOLARIS.LICENSE.

 * If applicable, add the following below this CDDL HEADER, with the

 * fields enclosed by brackets "[]" replaced with your own identifying

 * information: Portions Copyright [yyyy] [name of copyright owner]

 *

 * CDDL HEADER END

 */

/*

 * Copyright 2007 Sun Microsystems, Inc.  All rights reserved.

 * Use is subject to license terms.

 */

/*

 * Mikhail Zakharov <zmey20000@yahoo.com> 2022.01.21

 */

#include <sys/qat.h>

#include <contrib/zlib/zlib.h>

#include <contrib/zlib/zutil.h>

#include "gzip.h"

/*ARGSUSED*/

static void *

zfs_zcalloc(void *opaque, uint_t items, uint_t size)

{

        void *ptr;

        ptr = malloc((size_t)items * size);

        return ptr;

}

/*ARGSUSED*/

static void

zfs_zcfree(void *opaque, void *ptr)

{

        free(ptr);

}

/*

 * Uncompress the buffer 'src' into the buffer 'dst'.  The caller must store

 * the expected decompressed data size externally so it can be passed in.

 * The resulting decompressed size is then returned through dstlen.  This

 * function return Z_OK on success, or another error code on failure.

 */

int

z_uncompress(void *dst, size_t *dstlen, const void *src, size_t srclen)

{

        z_stream zs;

        int err;

        bzero(&zs, sizeof (zs));

        zs.next_in = (unsigned char *)src;

        zs.avail_in = srclen;

        zs.next_out = dst;

        zs.avail_out = *dstlen;

        zs.zalloc = zfs_zcalloc;

        zs.zfree = zfs_zcfree;

        /*

         * Call inflateInit2() specifying a window size of DEF_WBITS

         * with the 6th bit set to indicate that the compression format

         * type (zlib or gzip) should be automatically detected.

         */

        if ((err = inflateInit2(&zs, DEF_WBITS | 0x20)) != Z_OK)

                return (err);

        if ((err = inflate(&zs, Z_FINISH)) != Z_STREAM_END) {

                (void) inflateEnd(&zs);

                return (err == Z_OK ? Z_BUF_ERROR : err);

        }

        *dstlen = zs.total_out;

        return (inflateEnd(&zs));

}

/*ARGSUSED*/

int

gzip_decompress(void *s_start, void *d_start, size_t s_len, size_t d_len, int n)

{

	size_t dstlen = d_len;

	ASSERT(d_len >= s_len);

	/* check if hardware accelerator can be used */

	if (qat_dc_use_accel(d_len)) {

		if (qat_compress(QAT_DECOMPRESS, s_start, s_len,

		    d_start, d_len, &dstlen) == CPA_STATUS_SUCCESS)

			return (0);

		/* if hardware de-compress fail, do it again with software */

	}

	if (z_uncompress(d_start, &dstlen, s_start, s_len) != Z_OK)

		return (-1);

	return (0);

}

/*

 * gzip decompression functions, as well as this header file, are based 

 * on the code from sys/cddl/contrib/opensolaris/uts/common/zmod and 

 * sys/contrib/openzfs/module/zfs/gzip.c

 */

#define Z_OK            0

#define Z_STREAM_END    1

#define Z_NEED_DICT     2

#define Z_ERRNO         (-1)

#define Z_STREAM_ERROR  (-2)

#define Z_DATA_ERROR    (-3)

#define Z_MEM_ERROR     (-4)

#define Z_BUF_ERROR     (-5)

#define Z_VERSION_ERROR (-6)

#define Z_NO_COMPRESSION        0

#define Z_BEST_SPEED            1

#define Z_BEST_COMPRESSION      9

#define Z_DEFAULT_COMPRESSION   (-1)

extern int z_uncompress(void *, size_t *, const void *, size_t);

extern int gzip_decompress(void *src, void *dst, size_t s_len, size_t d_len,

    int level);

#include "gzip.c"