Raphael M Zinsly <rzinsly@xxxxxxxxxxxxx> writes: > Thanks for the reviews Daniel, I'll use your testcases and address the > issues you found, I still have some questions bellow: > > On 18/03/2020 03:18, Daniel Axtens wrote: >> Raphael Moreira Zinsly <rzinsly@xxxxxxxxxxxxx> writes: >> >>> Include a decompression testcase for the powerpc NX-GZIP >>> engine. >> >> I compiled gzip with the AFL++ fuzzer and generated a corpus of tests to >> run against this decompressor. I also fuzzed the decompressor >> directly. I found a few issues. I _think_ they're just in the userspace >> but I'm a bit too early in the process to know. >> >> I realise this is self-test code but: >> a) it stops me testing more deeply, and > I don't understand what do you mean by that, what did you couldn't test? I'm trying to stress-test the accellerator by fuzzing it. If it hangs with an infinite loop rather than cleanly exiting, that inhibits my ability to stress-test it. >> b) it looks like some of this code is shared with https://github.com/libnxz/power-gzip/ > Is that an issue? > This selftest were develop by the same team that develop the userspace > library, the first version of this tests were pushed there in order for > the team to review. It uses some of the headers of the library to access > the accelerator and part of the code in the samples. What I mean is that if there's a bug in code we copied, we should also report it to the developers of the library so that it gets fixed in both places. Regards, Daniel > Regards, > Raphael > >> >> The issues I've found are: >> >> 1) In the ERR_NX_DATA_LENGTH case, the decompressor doesn't check that >> you're making forward progress, so you can provoke it into an >> infinite loop. >> >> Here's an _extremely_ ugly fix: >> >> diff --git a/tools/testing/selftests/powerpc/nx-gzip/gunz_test.c b/tools/testing/selftests/powerpc/nx-gzip/gunz_test.c >> index 653de92698cc..236a1f567656 100644 >> --- a/tools/testing/selftests/powerpc/nx-gzip/gunz_test.c >> +++ b/tools/testing/selftests/powerpc/nx-gzip/gunz_test.c >> @@ -343,6 +343,8 @@ int decompress_file(int argc, char **argv, void *devhandle) >> nx_dde_t dde_out[6] __attribute__((aligned (128))); >> int pgfault_retries; >> >> + int last_first_used = 0; >> + >> /* when using mmap'ed files */ >> off_t input_file_offset; >> >> @@ -642,6 +644,11 @@ int decompress_file(int argc, char **argv, void *devhandle) >> first_used = fifo_used_first_bytes(cur_in, used_in, fifo_in_len); >> last_used = fifo_used_last_bytes(cur_in, used_in, fifo_in_len); >> >> + if (first_used > 0 && last_first_used > 0) { >> + assert(first_used != last_first_used); >> + } >> + last_first_used = first_used; >> + >> if (first_used > 0) >> nx_append_dde(ddl_in, fifo_in + cur_in, first_used); >> >> >> 2) It looks like you can provoke an out-of-bounds write. I've seen both >> infinte loops printing something that seems to come from the file >> content like: >> >> 57201: Got signal 11 si_code 3, si_addr 0xcacacacacacacac8 >> >> or a less bizzare address like >> >> 19285: Got signal 11 si_code 1, si_addr 0x7fffcf1b0000 >> >> Depending on the build I've also seen the stack smasher protection fire. >> >> I don't understand the code well enough to figure out how this comes to >> be just yet. >> >> I've included a few test cases as attachments. I've preconverted them >> with xxd to avoid anything that might flag suspicious gzip files! >> Decompress them then use `xxd -r attachment testcase.gz` to convert them >> back. >> >> Regards, >> Daniel >> >> >> >> >>> >>> Signed-off-by: Bulent Abali <abali@xxxxxxxxxx> >>> Signed-off-by: Raphael Moreira Zinsly <rzinsly@xxxxxxxxxxxxx> >>> --- >>> .../selftests/powerpc/nx-gzip/Makefile | 7 +- >>> .../selftests/powerpc/nx-gzip/gunz_test.c | 1058 +++++++++++++++++ >>> 2 files changed, 1062 insertions(+), 3 deletions(-) >>> create mode 100644 tools/testing/selftests/powerpc/nx-gzip/gunz_test.c >>> >>> diff --git a/tools/testing/selftests/powerpc/nx-gzip/Makefile b/tools/testing/selftests/powerpc/nx-gzip/Makefile >>> index ab903f63bbbd..82abc19a49a0 100644 >>> --- a/tools/testing/selftests/powerpc/nx-gzip/Makefile >>> +++ b/tools/testing/selftests/powerpc/nx-gzip/Makefile >>> @@ -1,9 +1,9 @@ >>> CC = gcc >>> CFLAGS = -O3 >>> INC = ./inc >>> -SRC = gzfht_test.c >>> +SRC = gzfht_test.c gunz_test.c >>> OBJ = $(SRC:.c=.o) >>> -TESTS = gzfht_test >>> +TESTS = gzfht_test gunz_test >>> EXTRA_SOURCES = gzip_vas.c >>> >>> all: $(TESTS) >>> @@ -16,6 +16,7 @@ $(TESTS): $(OBJ) >>> >>> run_tests: $(TESTS) >>> ./gzfht_test gzip_vas.c >>> + ./gunz_test gzip_vas.c.nx.gz >>> >>> clean: >>> - rm -f $(TESTS) *.o *~ *.gz >>> + rm -f $(TESTS) *.o *~ *.gz *.gunzip >>> diff --git a/tools/testing/selftests/powerpc/nx-gzip/gunz_test.c b/tools/testing/selftests/powerpc/nx-gzip/gunz_test.c >>> new file mode 100644 >>> index 000000000000..653de92698cc >>> --- /dev/null >>> +++ b/tools/testing/selftests/powerpc/nx-gzip/gunz_test.c >>> @@ -0,0 +1,1058 @@ >>> +/* SPDX-License-Identifier: GPL-2.0-or-later >>> + * >>> + * P9 gunzip sample code for demonstrating the P9 NX hardware >>> + * interface. Not intended for productive uses or for performance or >>> + * compression ratio measurements. Note also that /dev/crypto/gzip, >>> + * VAS and skiboot support are required >>> + * >>> + * Copyright 2020 IBM Corp. >>> + * >>> + * Author: Bulent Abali <abali@xxxxxxxxxx> >>> + * >>> + * https://github.com/libnxz/power-gzip for zlib api and other utils >>> + * Definitions of acronyms used here. See >>> + * P9 NX Gzip Accelerator User's Manual for details >>> + * >>> + * adler/crc: 32 bit checksums appended to stream tail >>> + * ce: completion extension >>> + * cpb: coprocessor parameter block (metadata) >>> + * crb: coprocessor request block (command) >>> + * csb: coprocessor status block (status) >>> + * dht: dynamic huffman table >>> + * dde: data descriptor element (address, length) >>> + * ddl: list of ddes >>> + * dh/fh: dynamic and fixed huffman types >>> + * fc: coprocessor function code >>> + * histlen: history/dictionary length >>> + * history: sliding window of up to 32KB of data >>> + * lzcount: Deflate LZ symbol counts >>> + * rembytecnt: remaining byte count >>> + * sfbt: source final block type; last block's type during decomp >>> + * spbc: source processed byte count >>> + * subc: source unprocessed bit count >>> + * tebc: target ending bit count; valid bits in the last byte >>> + * tpbc: target processed byte count >>> + * vas: virtual accelerator switch; the user mode interface >>> + */ >>> + >>> +#include <stdio.h> >>> +#include <stdlib.h> >>> +#include <string.h> >>> +#include <unistd.h> >>> +#include <stdint.h> >>> +#include <sys/types.h> >>> +#include <sys/stat.h> >>> +#include <sys/time.h> >>> +#include <sys/fcntl.h> >>> +#include <sys/mman.h> >>> +#include <endian.h> >>> +#include <bits/endian.h> >>> +#include <sys/ioctl.h> >>> +#include <assert.h> >>> +#include <errno.h> >>> +#include <signal.h> >>> +#include "nxu.h" >>> +#include "nx.h" >>> + >>> +int nx_dbg = 0; >>> +FILE *nx_gzip_log = NULL; >>> + >>> +#define NX_MIN(X, Y) (((X) < (Y))?(X):(Y)) >>> +#define NX_MAX(X, Y) (((X) > (Y))?(X):(Y)) >>> + >>> +#define mb() asm volatile("sync" ::: "memory") >>> +#define rmb() asm volatile("lwsync" ::: "memory") >>> +#define wmb() rmb() >>> + >>> +const int fifo_in_len = 1<<24; >>> +const int fifo_out_len = 1<<24; >>> +const int page_sz = 1<<16; >>> +const int line_sz = 1<<7; >>> +const int window_max = 1<<15; >>> +const int retry_max = 50; >>> + >>> +extern void *nx_fault_storage_address; >>> +extern void *nx_function_begin(int function, int pri); >>> +extern int nx_function_end(void *handle); >>> + >>> +/* >>> + * Fault in pages prior to NX job submission. wr=1 may be required to >>> + * touch writeable pages. System zero pages do not fault-in the page as >>> + * intended. Typically set wr=1 for NX target pages and set wr=0 for >>> + * NX source pages. >>> + */ >>> +static int nx_touch_pages(void *buf, long buf_len, long page_len, int wr) >>> +{ >>> + char *begin = buf; >>> + char *end = (char *) buf + buf_len - 1; >>> + volatile char t; >>> + >>> + assert(buf_len >= 0 && !!buf); >>> + >>> + NXPRT(fprintf(stderr, "touch %p %p len 0x%lx wr=%d\n", buf, >>> + buf + buf_len, buf_len, wr)); >>> + >>> + if (buf_len <= 0 || buf == NULL) >>> + return -1; >>> + >>> + do { >>> + t = *begin; >>> + if (wr) >>> + *begin = t; >>> + begin = begin + page_len; >>> + } while (begin < end); >>> + >>> + /* When buf_sz is small or buf tail is in another page. */ >>> + t = *end; >>> + if (wr) >>> + *end = t; >>> + >>> + return 0; >>> +} >>> + >>> +void sigsegv_handler(int sig, siginfo_t *info, void *ctx) >>> +{ >>> + fprintf(stderr, "%d: Got signal %d si_code %d, si_addr %p\n", getpid(), >>> + sig, info->si_code, info->si_addr); >>> + >>> + nx_fault_storage_address = info->si_addr; >>> +} >>> + >>> +/* >>> + * Adds an (address, len) pair to the list of ddes (ddl) and updates >>> + * the base dde. ddl[0] is the only dde in a direct dde which >>> + * contains a single (addr,len) pair. For more pairs, ddl[0] becomes >>> + * the indirect (base) dde that points to a list of direct ddes. >>> + * See Section 6.4 of the NX-gzip user manual for DDE description. >>> + * Addr=NULL, len=0 clears the ddl[0]. Returns the total number of >>> + * bytes in ddl. Caller is responsible for allocting the array of >>> + * nx_dde_t *ddl. If N addresses are required in the scatter-gather >>> + * list, the ddl array must have N+1 entries minimum. >>> + */ >>> +static inline uint32_t nx_append_dde(nx_dde_t *ddl, void *addr, uint32_t len) >>> +{ >>> + uint32_t ddecnt; >>> + uint32_t bytes; >>> + >>> + if (addr == NULL && len == 0) { >>> + clearp_dde(ddl); >>> + return 0; >>> + } >>> + >>> + NXPRT(fprintf(stderr, "%d: nx_append_dde addr %p len %x\n", __LINE__, >>> + addr, len)); >>> + >>> + /* Number of ddes in the dde list ; == 0 when it is a direct dde */ >>> + ddecnt = getpnn(ddl, dde_count); >>> + bytes = getp32(ddl, ddebc); >>> + >>> + if (ddecnt == 0 && bytes == 0) { >>> + /* First dde is unused; make it a direct dde */ >>> + bytes = len; >>> + putp32(ddl, ddebc, bytes); >>> + putp64(ddl, ddead, (uint64_t) addr); >>> + } else if (ddecnt == 0) { >>> + /* Converting direct to indirect dde >>> + * ddl[0] becomes head dde of ddl >>> + * copy direct to indirect first. >>> + */ >>> + ddl[1] = ddl[0]; >>> + >>> + /* Add the new dde next */ >>> + clear_dde(ddl[2]); >>> + put32(ddl[2], ddebc, len); >>> + put64(ddl[2], ddead, (uint64_t) addr); >>> + >>> + /* Ddl head points to 2 direct ddes */ >>> + ddecnt = 2; >>> + putpnn(ddl, dde_count, ddecnt); >>> + bytes = bytes + len; >>> + putp32(ddl, ddebc, bytes); >>> + /* Pointer to the first direct dde */ >>> + putp64(ddl, ddead, (uint64_t) &ddl[1]); >>> + } else { >>> + /* Append a dde to an existing indirect ddl */ >>> + ++ddecnt; >>> + clear_dde(ddl[ddecnt]); >>> + put64(ddl[ddecnt], ddead, (uint64_t) addr); >>> + put32(ddl[ddecnt], ddebc, len); >>> + >>> + putpnn(ddl, dde_count, ddecnt); >>> + bytes = bytes + len; >>> + putp32(ddl, ddebc, bytes); /* byte sum of all dde */ >>> + } >>> + return bytes; >>> +} >>> + >>> +/* >>> + * Touch specified number of pages represented in number bytes >>> + * beginning from the first buffer in a dde list. >>> + * Do not touch the pages past buf_sz-th byte's page. >>> + * >>> + * Set buf_sz = 0 to touch all pages described by the ddep. >>> + */ >>> +static int nx_touch_pages_dde(nx_dde_t *ddep, long buf_sz, long page_sz, >>> + int wr) >>> +{ >>> + uint32_t indirect_count; >>> + uint32_t buf_len; >>> + long total; >>> + uint64_t buf_addr; >>> + nx_dde_t *dde_list; >>> + int i; >>> + >>> + assert(!!ddep); >>> + >>> + indirect_count = getpnn(ddep, dde_count); >>> + >>> + NXPRT(fprintf(stderr, "nx_touch_pages_dde dde_count %d request len \ >>> + 0x%lx\n", indirect_count, buf_sz)); >>> + >>> + if (indirect_count == 0) { >>> + /* Direct dde */ >>> + buf_len = getp32(ddep, ddebc); >>> + buf_addr = getp64(ddep, ddead); >>> + >>> + NXPRT(fprintf(stderr, "touch direct ddebc 0x%x ddead %p\n", >>> + buf_len, (void *)buf_addr)); >>> + >>> + if (buf_sz == 0) >>> + nx_touch_pages((void *)buf_addr, buf_len, page_sz, wr); >>> + else >>> + nx_touch_pages((void *)buf_addr, NX_MIN(buf_len, >>> + buf_sz), page_sz, wr); >>> + >>> + return ERR_NX_OK; >>> + } >>> + >>> + /* Indirect dde */ >>> + if (indirect_count > MAX_DDE_COUNT) >>> + return ERR_NX_EXCESSIVE_DDE; >>> + >>> + /* First address of the list */ >>> + dde_list = (nx_dde_t *) getp64(ddep, ddead); >>> + >>> + if (buf_sz == 0) >>> + buf_sz = getp32(ddep, ddebc); >>> + >>> + total = 0; >>> + for (i = 0; i < indirect_count; i++) { >>> + buf_len = get32(dde_list[i], ddebc); >>> + buf_addr = get64(dde_list[i], ddead); >>> + total += buf_len; >>> + >>> + NXPRT(fprintf(stderr, "touch loop len 0x%x ddead %p total \ >>> + 0x%lx\n", buf_len, (void *)buf_addr, total)); >>> + >>> + /* Touching fewer pages than encoded in the ddebc */ >>> + if (total > buf_sz) { >>> + buf_len = NX_MIN(buf_len, total - buf_sz); >>> + nx_touch_pages((void *)buf_addr, buf_len, page_sz, wr); >>> + NXPRT(fprintf(stderr, "touch loop break len 0x%x \ >>> + ddead %p\n", buf_len, (void *)buf_addr)); >>> + break; >>> + } >>> + nx_touch_pages((void *)buf_addr, buf_len, page_sz, wr); >>> + } >>> + return ERR_NX_OK; >>> +} >>> + >>> +/* >>> + * Src and dst buffers are supplied in scatter gather lists. >>> + * NX function code and other parameters supplied in cmdp. >>> + */ >>> +static int nx_submit_job(nx_dde_t *src, nx_dde_t *dst, nx_gzip_crb_cpb_t *cmdp, >>> + void *handle) >>> +{ >>> + int cc; >>> + uint64_t csbaddr; >>> + >>> + memset((void *)&cmdp->crb.csb, 0, sizeof(cmdp->crb.csb)); >>> + >>> + cmdp->crb.source_dde = *src; >>> + cmdp->crb.target_dde = *dst; >>> + >>> + /* Status, output byte count in tpbc */ >>> + csbaddr = ((uint64_t) &cmdp->crb.csb) & csb_address_mask; >>> + put64(cmdp->crb, csb_address, csbaddr); >>> + >>> + /* NX reports input bytes in spbc; cleared */ >>> + cmdp->cpb.out_spbc_comp_wrap = 0; >>> + cmdp->cpb.out_spbc_comp_with_count = 0; >>> + cmdp->cpb.out_spbc_decomp = 0; >>> + >>> + /* Clear output */ >>> + put32(cmdp->cpb, out_crc, INIT_CRC); >>> + put32(cmdp->cpb, out_adler, INIT_ADLER); >>> + >>> + cc = nxu_run_job(cmdp, handle); >>> + >>> + if (!cc) >>> + cc = getnn(cmdp->crb.csb, csb_cc); /* CC Table 6-8 */ >>> + >>> + return cc; >>> +} >>> + >>> +/* fifo queue management */ >>> +#define fifo_used_bytes(used) (used) >>> +#define fifo_free_bytes(used, len) ((len)-(used)) >>> +/* amount of free bytes in the first and last parts */ >>> +#define fifo_free_first_bytes(cur, used, len) ((((cur)+(used)) <= (len)) \ >>> + ? (len)-((cur)+(used)) : 0) >>> +#define fifo_free_last_bytes(cur, used, len) ((((cur)+(used)) <= (len)) \ >>> + ? (cur) : (len)-(used)) >>> +/* amount of used bytes in the first and last parts */ >>> +#define fifo_used_first_bytes(cur, used, len) ((((cur)+(used)) <= (len)) \ >>> + ? (used) : (len)-(cur)) >>> +#define fifo_used_last_bytes(cur, used, len) ((((cur)+(used)) <= (len)) \ >>> + ? 0 : ((used)+(cur))-(len)) >>> +/* first and last free parts start here */ >>> +#define fifo_free_first_offset(cur, used) ((cur)+(used)) >>> +#define fifo_free_last_offset(cur, used, len) \ >>> + fifo_used_last_bytes(cur, used, len) >>> +/* first and last used parts start here */ >>> +#define fifo_used_first_offset(cur) (cur) >>> +#define fifo_used_last_offset(cur) (0) >>> + >>> +int decompress_file(int argc, char **argv, void *devhandle) >>> +{ >>> + FILE *inpf; >>> + FILE *outf; >>> + >>> + int c, expect, i, cc, rc = 0; >>> + char gzfname[1024]; >>> + >>> + /* Queuing, file ops, byte counting */ >>> + char *fifo_in, *fifo_out; >>> + int used_in, cur_in, used_out, cur_out, read_sz, n; >>> + int first_free, last_free, first_used, last_used; >>> + int first_offset, last_offset; >>> + int write_sz, free_space, source_sz; >>> + int source_sz_estimate, target_sz_estimate; >>> + uint64_t last_comp_ratio; /* 1000 max */ >>> + uint64_t total_out; >>> + int is_final, is_eof; >>> + >>> + /* nx hardware */ >>> + int sfbt, subc, spbc, tpbc, nx_ce, fc, resuming = 0; >>> + int history_len = 0; >>> + nx_gzip_crb_cpb_t cmd, *cmdp; >>> + nx_dde_t *ddl_in; >>> + nx_dde_t dde_in[6] __attribute__((aligned (128))); >>> + nx_dde_t *ddl_out; >>> + nx_dde_t dde_out[6] __attribute__((aligned (128))); >>> + int pgfault_retries; >>> + >>> + /* when using mmap'ed files */ >>> + off_t input_file_offset; >>> + >>> + if (argc > 2) { >>> + fprintf(stderr, "usage: %s <fname> or stdin\n", argv[0]); >>> + fprintf(stderr, " writes to stdout or <fname>.nx.gunzip\n"); >>> + return -1; >>> + } >>> + >>> + if (argc == 1) { >>> + inpf = stdin; >>> + outf = stdout; >>> + } else if (argc == 2) { >>> + char w[1024]; >>> + char *wp; >>> + inpf = fopen(argv[1], "r"); >>> + if (inpf == NULL) { >>> + perror(argv[1]); >>> + return -1; >>> + } >>> + >>> + /* Make a new file name to write to. Ignoring '.gz' */ >>> + wp = (NULL != (wp = strrchr(argv[1], '/'))) ? ++wp : argv[1]; >>> + strcpy(w, wp); >>> + strcat(w, ".nx.gunzip"); >>> + >>> + outf = fopen(w, "w"); >>> + if (outf == NULL) { >>> + perror(w); >>> + return -1; >>> + } >>> + } >>> + >>> +#define GETINPC(X) fgetc(X) >>> + >>> + /* Decode the gzip header */ >>> + c = GETINPC(inpf); expect = 0x1f; /* ID1 */ >>> + if (c != expect) >>> + goto err1; >>> + >>> + c = GETINPC(inpf); expect = 0x8b; /* ID2 */ >>> + if (c != expect) >>> + goto err1; >>> + >>> + c = GETINPC(inpf); expect = 0x08; /* CM */ >>> + if (c != expect) >>> + goto err1; >>> + >>> + int flg = GETINPC(inpf); /* FLG */ >>> + if (flg & 0b11100000 || flg & 0b100) >>> + goto err2; >>> + >>> + fprintf(stderr, "gzHeader FLG %x\n", flg); >>> + >>> + /* Read 6 bytes; ignoring the MTIME, XFL, OS fields in this >>> + * sample code. >>> + */ >>> + for (i = 0; i < 6; i++) { >>> + char tmp[10]; >>> + if (EOF == (tmp[i] = GETINPC(inpf))) >>> + goto err3; >>> + fprintf(stderr, "%02x ", tmp[i]); >>> + if (i == 5) >>> + fprintf(stderr, "\n"); >>> + } >>> + fprintf(stderr, "gzHeader MTIME, XFL, OS ignored\n"); >>> + >>> + /* FNAME */ >>> + if (flg & 0b1000) { >>> + int k = 0; >>> + do { >>> + if (EOF == (c = GETINPC(inpf))) >>> + goto err3; >>> + gzfname[k++] = c; >>> + } while (c); >>> + fprintf(stderr, "gzHeader FNAME: %s\n", gzfname); >>> + } >>> + >>> + /* FHCRC */ >>> + if (flg & 0b10) { >>> + c = GETINPC(inpf); c = GETINPC(inpf); >>> + fprintf(stderr, "gzHeader FHCRC: ignored\n"); >>> + } >>> + >>> + used_in = cur_in = used_out = cur_out = 0; >>> + is_final = is_eof = 0; >>> + >>> + /* Allocate one page larger to prevent page faults due to NX >>> + * overfetching. >>> + * Either do this (char*)(uintptr_t)aligned_alloc or use >>> + * -std=c11 flag to make the int-to-pointer warning go away. >>> + */ >>> + assert((fifo_in = (char *)(uintptr_t)aligned_alloc(line_sz, >>> + fifo_in_len + page_sz)) != NULL); >>> + assert((fifo_out = (char *)(uintptr_t)aligned_alloc(line_sz, >>> + fifo_out_len + page_sz + line_sz)) != NULL); >>> + /* Leave unused space due to history rounding rules */ >>> + fifo_out = fifo_out + line_sz; >>> + nx_touch_pages(fifo_out, fifo_out_len, page_sz, 1); >>> + >>> + ddl_in = &dde_in[0]; >>> + ddl_out = &dde_out[0]; >>> + cmdp = &cmd; >>> + memset(&cmdp->crb, 0, sizeof(cmdp->crb)); >>> + >>> +read_state: >>> + >>> + /* Read from .gz file */ >>> + >>> + NXPRT(fprintf(stderr, "read_state:\n")); >>> + >>> + if (is_eof != 0) >>> + goto write_state; >>> + >>> + /* We read in to fifo_in in two steps: first: read in to from >>> + * cur_in to the end of the buffer. last: if free space wrapped >>> + * around, read from fifo_in offset 0 to offset cur_in. >>> + */ >>> + >>> + /* Reset fifo head to reduce unnecessary wrap arounds */ >>> + cur_in = (used_in == 0) ? 0 : cur_in; >>> + >>> + /* Free space total is reduced by a gap */ >>> + free_space = NX_MAX(0, fifo_free_bytes(used_in, fifo_in_len) >>> + - line_sz); >>> + >>> + /* Free space may wrap around as first and last */ >>> + first_free = fifo_free_first_bytes(cur_in, used_in, fifo_in_len); >>> + last_free = fifo_free_last_bytes(cur_in, used_in, fifo_in_len); >>> + >>> + /* Start offsets of the free memory */ >>> + first_offset = fifo_free_first_offset(cur_in, used_in); >>> + last_offset = fifo_free_last_offset(cur_in, used_in, fifo_in_len); >>> + >>> + /* Reduce read_sz because of the line_sz gap */ >>> + read_sz = NX_MIN(free_space, first_free); >>> + n = 0; >>> + if (read_sz > 0) { >>> + /* Read in to offset cur_in + used_in */ >>> + n = fread(fifo_in + first_offset, 1, read_sz, inpf); >>> + used_in = used_in + n; >>> + free_space = free_space - n; >>> + assert(n <= read_sz); >>> + if (n != read_sz) { >>> + /* Either EOF or error; exit the read loop */ >>> + is_eof = 1; >>> + goto write_state; >>> + } >>> + } >>> + >>> + /* If free space wrapped around */ >>> + if (last_free > 0) { >>> + /* Reduce read_sz because of the line_sz gap */ >>> + read_sz = NX_MIN(free_space, last_free); >>> + n = 0; >>> + if (read_sz > 0) { >>> + n = fread(fifo_in + last_offset, 1, read_sz, inpf); >>> + used_in = used_in + n; /* Increase used space */ >>> + free_space = free_space - n; /* Decrease free space */ >>> + assert(n <= read_sz); >>> + if (n != read_sz) { >>> + /* Either EOF or error; exit the read loop */ >>> + is_eof = 1; >>> + goto write_state; >>> + } >>> + } >>> + } >>> + >>> + /* At this point we have used_in bytes in fifo_in with the >>> + * data head starting at cur_in and possibly wrapping around. >>> + */ >>> + >>> +write_state: >>> + >>> + /* Write decompressed data to output file */ >>> + >>> + NXPRT(fprintf(stderr, "write_state:\n")); >>> + >>> + if (used_out == 0) >>> + goto decomp_state; >>> + >>> + /* If fifo_out has data waiting, write it out to the file to >>> + * make free target space for the accelerator used bytes in >>> + * the first and last parts of fifo_out. >>> + */ >>> + >>> + first_used = fifo_used_first_bytes(cur_out, used_out, fifo_out_len); >>> + last_used = fifo_used_last_bytes(cur_out, used_out, fifo_out_len); >>> + >>> + write_sz = first_used; >>> + >>> + n = 0; >>> + if (write_sz > 0) { >>> + n = fwrite(fifo_out + cur_out, 1, write_sz, outf); >>> + used_out = used_out - n; >>> + /* Move head of the fifo */ >>> + cur_out = (cur_out + n) % fifo_out_len; >>> + assert(n <= write_sz); >>> + if (n != write_sz) { >>> + fprintf(stderr, "error: write\n"); >>> + rc = -1; >>> + goto err5; >>> + } >>> + } >>> + >>> + if (last_used > 0) { /* If more data available in the last part */ >>> + write_sz = last_used; /* Keep it here for later */ >>> + n = 0; >>> + if (write_sz > 0) { >>> + n = fwrite(fifo_out, 1, write_sz, outf); >>> + used_out = used_out - n; >>> + cur_out = (cur_out + n) % fifo_out_len; >>> + assert(n <= write_sz); >>> + if (n != write_sz) { >>> + fprintf(stderr, "error: write\n"); >>> + rc = -1; >>> + goto err5; >>> + } >>> + } >>> + } >>> + >>> +decomp_state: >>> + >>> + /* NX decompresses input data */ >>> + >>> + NXPRT(fprintf(stderr, "decomp_state:\n")); >>> + >>> + if (is_final) >>> + goto finish_state; >>> + >>> + /* Address/len lists */ >>> + clearp_dde(ddl_in); >>> + clearp_dde(ddl_out); >>> + >>> + /* FC, CRC, HistLen, Table 6-6 */ >>> + if (resuming) { >>> + /* Resuming a partially decompressed input. >>> + * The key to resume is supplying the 32KB >>> + * dictionary (history) to NX, which is basically >>> + * the last 32KB of output produced. >>> + */ >>> + fc = GZIP_FC_DECOMPRESS_RESUME; >>> + >>> + cmdp->cpb.in_crc = cmdp->cpb.out_crc; >>> + cmdp->cpb.in_adler = cmdp->cpb.out_adler; >>> + >>> + /* Round up the history size to quadword. Section 2.10 */ >>> + history_len = (history_len + 15) / 16; >>> + putnn(cmdp->cpb, in_histlen, history_len); >>> + history_len = history_len * 16; /* bytes */ >>> + >>> + if (history_len > 0) { >>> + /* Chain in the history buffer to the DDE list */ >>> + if (cur_out >= history_len) { >>> + nx_append_dde(ddl_in, fifo_out >>> + + (cur_out - history_len), >>> + history_len); >>> + } else { >>> + nx_append_dde(ddl_in, fifo_out >>> + + ((fifo_out_len + cur_out) >>> + - history_len), >>> + history_len - cur_out); >>> + /* Up to 32KB history wraps around fifo_out */ >>> + nx_append_dde(ddl_in, fifo_out, cur_out); >>> + } >>> + >>> + } >>> + } else { >>> + /* First decompress job */ >>> + fc = GZIP_FC_DECOMPRESS; >>> + >>> + history_len = 0; >>> + /* Writing 0 clears out subc as well */ >>> + cmdp->cpb.in_histlen = 0; >>> + total_out = 0; >>> + >>> + put32(cmdp->cpb, in_crc, INIT_CRC); >>> + put32(cmdp->cpb, in_adler, INIT_ADLER); >>> + put32(cmdp->cpb, out_crc, INIT_CRC); >>> + put32(cmdp->cpb, out_adler, INIT_ADLER); >>> + >>> + /* Assuming 10% compression ratio initially; use the >>> + * most recently measured compression ratio as a >>> + * heuristic to estimate the input and output >>> + * sizes. If we give too much input, the target buffer >>> + * overflows and NX cycles are wasted, and then we >>> + * must retry with smaller input size. 1000 is 100%. >>> + */ >>> + last_comp_ratio = 100UL; >>> + } >>> + cmdp->crb.gzip_fc = 0; >>> + putnn(cmdp->crb, gzip_fc, fc); >>> + >>> + /* >>> + * NX source buffers >>> + */ >>> + first_used = fifo_used_first_bytes(cur_in, used_in, fifo_in_len); >>> + last_used = fifo_used_last_bytes(cur_in, used_in, fifo_in_len); >>> + >>> + if (first_used > 0) >>> + nx_append_dde(ddl_in, fifo_in + cur_in, first_used); >>> + >>> + if (last_used > 0) >>> + nx_append_dde(ddl_in, fifo_in, last_used); >>> + >>> + /* >>> + * NX target buffers >>> + */ >>> + first_free = fifo_free_first_bytes(cur_out, used_out, fifo_out_len); >>> + last_free = fifo_free_last_bytes(cur_out, used_out, fifo_out_len); >>> + >>> + /* Reduce output free space amount not to overwrite the history */ >>> + int target_max = NX_MAX(0, fifo_free_bytes(used_out, fifo_out_len) >>> + - (1<<16)); >>> + >>> + NXPRT(fprintf(stderr, "target_max %d (0x%x)\n", target_max, >>> + target_max)); >>> + >>> + first_free = NX_MIN(target_max, first_free); >>> + if (first_free > 0) { >>> + first_offset = fifo_free_first_offset(cur_out, used_out); >>> + nx_append_dde(ddl_out, fifo_out + first_offset, first_free); >>> + } >>> + >>> + if (last_free > 0) { >>> + last_free = NX_MIN(target_max - first_free, last_free); >>> + if (last_free > 0) { >>> + last_offset = fifo_free_last_offset(cur_out, used_out, >>> + fifo_out_len); >>> + nx_append_dde(ddl_out, fifo_out + last_offset, >>> + last_free); >>> + } >>> + } >>> + >>> + /* Target buffer size is used to limit the source data size >>> + * based on previous measurements of compression ratio. >>> + */ >>> + >>> + /* source_sz includes history */ >>> + source_sz = getp32(ddl_in, ddebc); >>> + assert(source_sz > history_len); >>> + source_sz = source_sz - history_len; >>> + >>> + /* Estimating how much source is needed to 3/4 fill a >>> + * target_max size target buffer. If we overshoot, then NX >>> + * must repeat the job with smaller input and we waste >>> + * bandwidth. If we undershoot then we use more NX calls than >>> + * necessary. >>> + */ >>> + >>> + source_sz_estimate = ((uint64_t)target_max * last_comp_ratio * 3UL) >>> + / 4000; >>> + >>> + if (source_sz_estimate < source_sz) { >>> + /* Target might be small, therefore limiting the >>> + * source data. >>> + */ >>> + source_sz = source_sz_estimate; >>> + target_sz_estimate = target_max; >>> + } else { >>> + /* Source file might be small, therefore limiting target >>> + * touch pages to a smaller value to save processor cycles. >>> + */ >>> + target_sz_estimate = ((uint64_t)source_sz * 1000UL) >>> + / (last_comp_ratio + 1); >>> + target_sz_estimate = NX_MIN(2 * target_sz_estimate, >>> + target_max); >>> + } >>> + >>> + source_sz = source_sz + history_len; >>> + >>> + /* Some NX condition codes require submitting the NX job again. >>> + * Kernel doesn't handle NX page faults. Expects user code to >>> + * touch pages. >>> + */ >>> + pgfault_retries = retry_max; >>> + >>> +restart_nx: >>> + >>> + putp32(ddl_in, ddebc, source_sz); >>> + >>> + /* Fault in pages */ >>> + nx_touch_pages_dde(ddl_in, 0, page_sz, 0); >>> + nx_touch_pages_dde(ddl_out, target_sz_estimate, page_sz, 1); >>> + >>> + /* Send job to NX */ >>> + cc = nx_submit_job(ddl_in, ddl_out, cmdp, devhandle); >>> + >>> + switch (cc) { >>> + >>> + case ERR_NX_TRANSLATION: >>> + >>> + /* We touched the pages ahead of time. In the most common case >>> + * we shouldn't be here. But may be some pages were paged out. >>> + * Kernel should have placed the faulting address to fsaddr. >>> + */ >>> + NXPRT(fprintf(stderr, "ERR_NX_TRANSLATION %p\n", >>> + (void *)cmdp->crb.csb.fsaddr)); >>> + >>> + /* Touch 1 byte, read-only */ >>> + nx_touch_pages((void *)cmdp->crb.csb.fsaddr, 1, page_sz, 0); >>> + >>> + if (pgfault_retries == retry_max) { >>> + /* Try once with exact number of pages */ >>> + --pgfault_retries; >>> + goto restart_nx; >>> + } else if (pgfault_retries > 0) { >>> + /* If still faulting try fewer input pages >>> + * assuming memory outage >>> + */ >>> + if (source_sz > page_sz) >>> + source_sz = NX_MAX(source_sz / 2, page_sz); >>> + --pgfault_retries; >>> + goto restart_nx; >>> + } else { >>> + fprintf(stderr, "cannot make progress; too many page \ >>> + fault retries cc= %d\n", cc); >>> + rc = -1; >>> + goto err5; >>> + } >>> + >>> + case ERR_NX_DATA_LENGTH: >>> + >>> + NXPRT(fprintf(stderr, "ERR_NX_DATA_LENGTH; not an error \ >>> + usually; stream may have trailing data\n")); >>> + >>> + /* Not an error in the most common case; it just says >>> + * there is trailing data that we must examine. >>> + * >>> + * CC=3 CE(1)=0 CE(0)=1 indicates partial completion >>> + * Fig.6-7 and Table 6-8. >>> + */ >>> + nx_ce = get_csb_ce_ms3b(cmdp->crb.csb); >>> + >>> + if (!csb_ce_termination(nx_ce) && >>> + csb_ce_partial_completion(nx_ce)) { >>> + /* Check CPB for more information >>> + * spbc and tpbc are valid >>> + */ >>> + sfbt = getnn(cmdp->cpb, out_sfbt); /* Table 6-4 */ >>> + subc = getnn(cmdp->cpb, out_subc); /* Table 6-4 */ >>> + spbc = get32(cmdp->cpb, out_spbc_decomp); >>> + tpbc = get32(cmdp->crb.csb, tpbc); >>> + assert(target_max >= tpbc); >>> + >>> + goto ok_cc3; /* not an error */ >>> + } else { >>> + /* History length error when CE(1)=1 CE(0)=0. */ >>> + rc = -1; >>> + fprintf(stderr, "history length error cc= %d\n", cc); >>> + goto err5; >>> + } >>> + >>> + case ERR_NX_TARGET_SPACE: >>> + >>> + /* Target buffer not large enough; retry smaller input >>> + * data; give at least 1 byte. SPBC/TPBC are not valid. >>> + */ >>> + assert(source_sz > history_len); >>> + source_sz = ((source_sz - history_len + 2) / 2) + history_len; >>> + NXPRT(fprintf(stderr, "ERR_NX_TARGET_SPACE; retry with \ >>> + smaller input data src %d hist %d\n", source_sz, >>> + history_len)); >>> + goto restart_nx; >>> + >>> + case ERR_NX_OK: >>> + >>> + /* This should not happen for gzip formatted data; >>> + * we need trailing crc and isize >>> + */ >>> + fprintf(stderr, "ERR_NX_OK\n"); >>> + spbc = get32(cmdp->cpb, out_spbc_decomp); >>> + tpbc = get32(cmdp->crb.csb, tpbc); >>> + assert(target_max >= tpbc); >>> + assert(spbc >= history_len); >>> + source_sz = spbc - history_len; >>> + goto offsets_state; >>> + >>> + default: >>> + fprintf(stderr, "error: cc= %d\n", cc); >>> + rc = -1; >>> + goto err5; >>> + } >>> + >>> +ok_cc3: >>> + >>> + NXPRT(fprintf(stderr, "cc3: sfbt: %x\n", sfbt)); >>> + >>> + assert(spbc > history_len); >>> + source_sz = spbc - history_len; >>> + >>> + /* Table 6-4: Source Final Block Type (SFBT) describes the >>> + * last processed deflate block and clues the software how to >>> + * resume the next job. SUBC indicates how many input bits NX >>> + * consumed but did not process. SPBC indicates how many >>> + * bytes of source were given to the accelerator including >>> + * history bytes. >>> + */ >>> + >>> + switch (sfbt) { >>> + int dhtlen; >>> + >>> + case 0b0000: /* Deflate final EOB received */ >>> + >>> + /* Calculating the checksum start position. */ >>> + >>> + source_sz = source_sz - subc / 8; >>> + is_final = 1; >>> + break; >>> + >>> + /* Resume decompression cases are below. Basically >>> + * indicates where NX has suspended and how to resume >>> + * the input stream. >>> + */ >>> + >>> + case 0b1000: /* Within a literal block; use rembytecount */ >>> + case 0b1001: /* Within a literal block; use rembytecount; bfinal=1 */ >>> + >>> + /* Supply the partially processed source byte again */ >>> + source_sz = source_sz - ((subc + 7) / 8); >>> + >>> + /* SUBC LS 3bits: number of bits in the first source byte need >>> + * to be processed. >>> + * 000 means all 8 bits; Table 6-3 >>> + * Clear subc, histlen, sfbt, rembytecnt, dhtlen >>> + */ >>> + cmdp->cpb.in_subc = 0; >>> + cmdp->cpb.in_sfbt = 0; >>> + putnn(cmdp->cpb, in_subc, subc % 8); >>> + putnn(cmdp->cpb, in_sfbt, sfbt); >>> + putnn(cmdp->cpb, in_rembytecnt, getnn(cmdp->cpb, >>> + out_rembytecnt)); >>> + break; >>> + >>> + case 0b1010: /* Within a FH block; */ >>> + case 0b1011: /* Within a FH block; bfinal=1 */ >>> + >>> + source_sz = source_sz - ((subc + 7) / 8); >>> + >>> + /* Clear subc, histlen, sfbt, rembytecnt, dhtlen */ >>> + cmdp->cpb.in_subc = 0; >>> + cmdp->cpb.in_sfbt = 0; >>> + putnn(cmdp->cpb, in_subc, subc % 8); >>> + putnn(cmdp->cpb, in_sfbt, sfbt); >>> + break; >>> + >>> + case 0b1100: /* Within a DH block; */ >>> + case 0b1101: /* Within a DH block; bfinal=1 */ >>> + >>> + source_sz = source_sz - ((subc + 7) / 8); >>> + >>> + /* Clear subc, histlen, sfbt, rembytecnt, dhtlen */ >>> + cmdp->cpb.in_subc = 0; >>> + cmdp->cpb.in_sfbt = 0; >>> + putnn(cmdp->cpb, in_subc, subc % 8); >>> + putnn(cmdp->cpb, in_sfbt, sfbt); >>> + >>> + dhtlen = getnn(cmdp->cpb, out_dhtlen); >>> + putnn(cmdp->cpb, in_dhtlen, dhtlen); >>> + assert(dhtlen >= 42); >>> + >>> + /* Round up to a qword */ >>> + dhtlen = (dhtlen + 127) / 128; >>> + >>> + while (dhtlen > 0) { /* Copy dht from cpb.out to cpb.in */ >>> + --dhtlen; >>> + cmdp->cpb.in_dht[dhtlen] = cmdp->cpb.out_dht[dhtlen]; >>> + } >>> + break; >>> + >>> + case 0b1110: /* Within a block header; bfinal=0; */ >>> + /* Also given if source data exactly ends (SUBC=0) with >>> + * EOB code with BFINAL=0. Means the next byte will >>> + * contain a block header. >>> + */ >>> + case 0b1111: /* within a block header with BFINAL=1. */ >>> + >>> + source_sz = source_sz - ((subc + 7) / 8); >>> + >>> + /* Clear subc, histlen, sfbt, rembytecnt, dhtlen */ >>> + cmdp->cpb.in_subc = 0; >>> + cmdp->cpb.in_sfbt = 0; >>> + putnn(cmdp->cpb, in_subc, subc % 8); >>> + putnn(cmdp->cpb, in_sfbt, sfbt); >>> + } >>> + >>> +offsets_state: >>> + >>> + /* Adjust the source and target buffer offsets and lengths */ >>> + >>> + NXPRT(fprintf(stderr, "offsets_state:\n")); >>> + >>> + /* Delete input data from fifo_in */ >>> + used_in = used_in - source_sz; >>> + cur_in = (cur_in + source_sz) % fifo_in_len; >>> + input_file_offset = input_file_offset + source_sz; >>> + >>> + /* Add output data to fifo_out */ >>> + used_out = used_out + tpbc; >>> + >>> + assert(used_out <= fifo_out_len); >>> + >>> + total_out = total_out + tpbc; >>> + >>> + /* Deflate history is 32KB max. No need to supply more >>> + * than 32KB on a resume. >>> + */ >>> + history_len = (total_out > window_max) ? window_max : total_out; >>> + >>> + /* To estimate expected expansion in the next NX job; 500 means 50%. >>> + * Deflate best case is around 1 to 1000. >>> + */ >>> + last_comp_ratio = (1000UL * ((uint64_t)source_sz + 1)) >>> + / ((uint64_t)tpbc + 1); >>> + last_comp_ratio = NX_MAX(NX_MIN(1000UL, last_comp_ratio), 1); >>> + NXPRT(fprintf(stderr, "comp_ratio %ld source_sz %d spbc %d tpbc %d\n", >>> + last_comp_ratio, source_sz, spbc, tpbc)); >>> + >>> + resuming = 1; >>> + >>> +finish_state: >>> + >>> + NXPRT(fprintf(stderr, "finish_state:\n")); >>> + >>> + if (is_final) { >>> + if (used_out) >>> + goto write_state; /* More data to write out */ >>> + else if (used_in < 8) { >>> + /* Need at least 8 more bytes containing gzip crc >>> + * and isize. >>> + */ >>> + rc = -1; >>> + goto err4; >>> + } else { >>> + /* Compare checksums and exit */ >>> + int i; >>> + char tail[8]; >>> + uint32_t cksum, isize; >>> + for (i = 0; i < 8; i++) >>> + tail[i] = fifo_in[(cur_in + i) % fifo_in_len]; >>> + fprintf(stderr, "computed checksum %08x isize %08x\n", >>> + cmdp->cpb.out_crc, (uint32_t) (total_out >>> + % (1ULL<<32))); >>> + cksum = (tail[0] | tail[1]<<8 | tail[2]<<16 >>> + | tail[3]<<24); >>> + isize = (tail[4] | tail[5]<<8 | tail[6]<<16 >>> + | tail[7]<<24); >>> + fprintf(stderr, "stored checksum %08x isize %08x\n", >>> + cksum, isize); >>> + >>> + if (cksum == cmdp->cpb.out_crc && isize == (uint32_t) >>> + (total_out % (1ULL<<32))) { >>> + rc = 0; goto ok1; >>> + } else { >>> + rc = -1; goto err4; >>> + } >>> + } >>> + } else >>> + goto read_state; >>> + >>> + return -1; >>> + >>> +err1: >>> + fprintf(stderr, "error: not a gzip file, expect %x, read %x\n", >>> + expect, c); >>> + return -1; >>> + >>> +err2: >>> + fprintf(stderr, "error: the FLG byte is wrong or not handled by this \ >>> + code sample\n"); >>> + return -1; >>> + >>> +err3: >>> + fprintf(stderr, "error: gzip header\n"); >>> + return -1; >>> + >>> +err4: >>> + fprintf(stderr, "error: checksum\n"); >>> + >>> +err5: >>> +ok1: >>> + fprintf(stderr, "decomp is complete: fclose\n"); >>> + fclose(outf); >>> + >>> + return rc; >>> +} >>> + >>> + >>> +int main(int argc, char **argv) >>> +{ >>> + int rc; >>> + struct sigaction act; >>> + void *handle; >>> + >>> + act.sa_handler = 0; >>> + act.sa_sigaction = sigsegv_handler; >>> + act.sa_flags = SA_SIGINFO; >>> + act.sa_restorer = 0; >>> + sigemptyset(&act.sa_mask); >>> + sigaction(SIGSEGV, &act, NULL); >>> + >>> + handle = nx_function_begin(NX_FUNC_COMP_GZIP, 0); >>> + if (!handle) { >>> + fprintf(stderr, "Unable to init NX, errno %d\n", errno); >>> + exit(-1); >>> + } >>> + >>> + rc = decompress_file(argc, argv, handle); >>> + >>> + nx_function_end(handle); >>> + >>> + return rc; >>> +} >>> -- >>> 2.21.0 > > -- > Raphael Moreira Zinsly > IBM > Linux on Power Toolchain
