OSCL-LXR linux-6.0.1/​tools/​testing/​selftests/​powerpc/​nx-gzip/​gunz_test.c	Source navigation Diff markup Identifier search General search
	Version: linux-6.0.1 spark-3.0.0 hadoop-3.2.0-src hadoop-3.3.0-src spark-2.4.7 linux-4.15.13 hadoop-2.7.4-src Revert   Change

 // 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@us.ibm.com>
  *
  * 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:
  * https://github.com/libnxz/power-gzip/blob/develop/doc/power_nx_gzip_um.pdf
  *
  * 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
  */
 
 #define _ISOC11_SOURCE  // For aligned_alloc()
 #define _DEFAULT_SOURCE // For endian.h
 
 #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"
 #include "crb.h"
 
 int nx_dbg;
 FILE *nx_gzip_log;
 
 #define NX_MIN(X, Y) (((X) < (Y))?(X):(Y))
 #define NX_MAX(X, Y) (((X) > (Y))?(X):(Y))
 
 #define GETINPC(X) fgetc(X)
 #define FNAME_MAX 1024
 
 /* 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)
 
 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;
 
 /*
  * 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(struct 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: %s addr %p len %x\n", __LINE__, addr,
             __func__, 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(struct 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;
     struct nx_dde_t *dde_list;
     int i;
 
     assert(!!ddep);
 
     indirect_count = getpnn(ddep, dde_count);
 
     NXPRT(fprintf(stderr, "%s dde_count %d request len ", __func__,
             indirect_count));
     NXPRT(fprintf(stderr, "0x%lx\n", 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)
             nxu_touch_pages((void *)buf_addr, buf_len, page_sz, wr);
         else
             nxu_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 = (struct 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 ",
                 buf_len, (void *)buf_addr));
         NXPRT(fprintf(stderr, "0x%lx\n", total));
 
         /* Touching fewer pages than encoded in the ddebc */
         if (total > buf_sz) {
             buf_len = NX_MIN(buf_len, total - buf_sz);
             nxu_touch_pages((void *)buf_addr, buf_len, page_sz, wr);
             NXPRT(fprintf(stderr, "touch loop break len 0x%x ",
                       buf_len));
             NXPRT(fprintf(stderr, "ddead %p\n", (void *)buf_addr));
             break;
         }
         nxu_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(struct nx_dde_t *src, struct nx_dde_t *dst,
              struct nx_gzip_crb_cpb_t *cmdp, void *handle)
 {
     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);
 
     /* Submit the crb, the job descriptor, to the accelerator. */
     return nxu_submit_job(cmdp, handle);
 }
 
 int decompress_file(int argc, char **argv, void *devhandle)
 {
     FILE *inpf = NULL;
     FILE *outf = NULL;
 
     int c, expect, i, cc, rc = 0;
     char gzfname[FNAME_MAX];
 
     /* 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 = 0; /* 1000 max */
     uint64_t total_out = 0;
     int is_final, is_eof;
 
     /* nx hardware */
     int sfbt, subc, spbc, tpbc, nx_ce, fc, resuming = 0;
     int history_len = 0;
     struct nx_gzip_crb_cpb_t cmd, *cmdp;
     struct nx_dde_t *ddl_in;
     struct nx_dde_t dde_in[6] __aligned(128);
     struct nx_dde_t *ddl_out;
     struct nx_dde_t dde_out[6] __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+1) : argv[1];
         strcpy(w, wp);
         strcat(w, ".nx.gunzip");
 
         outf = fopen(w, "w");
         if (outf == NULL) {
             perror(w);
             return -1;
         }
     }
 
     /* 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 & 0xE0 || flg & 0x4 || flg == EOF)
         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];
 
         tmp[i] = GETINPC(inpf);
         if (tmp[i] == EOF)
             goto err3;
         fprintf(stderr, "%02x ", tmp[i]);
         if (i == 5)
             fprintf(stderr, "\n");
     }
     fprintf(stderr, "gzHeader MTIME, XFL, OS ignored\n");
 
     /* FNAME */
     if (flg & 0x8) {
         int k = 0;
 
         do {
             c = GETINPC(inpf);
             if (c == EOF || k >= FNAME_MAX)
                 goto err3;
             gzfname[k++] = c;
         } while (c);
         fprintf(stderr, "gzHeader FNAME: %s\n", gzfname);
     }
 
     /* FHCRC */
     if (flg & 0x2) {
         c = GETINPC(inpf);
         if (c == EOF)
             goto err3;
         c = GETINPC(inpf);
         if (c == EOF)
             goto err3;
         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;
     nxu_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 = NX_MAX_FAULTS;
 
 restart_nx:
 
     putp32(ddl_in, ddebc, source_sz);
 
     /* Fault in pages */
     nxu_touch_pages(cmdp, sizeof(struct nx_gzip_crb_cpb_t), page_sz, 1);
     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_AT_FAULT:
 
         /* 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_AT_FAULT %p\n",
                   (void *)cmdp->crb.csb.fsaddr));
 
         if (pgfault_retries == NX_MAX_FAULTS) {
             /* 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 ");
             fprintf(stderr, "page fault retries cc= %d\n", cc);
             rc = -1;
             goto err5;
         }
 
     case ERR_NX_DATA_LENGTH:
 
         NXPRT(fprintf(stderr, "ERR_NX_DATA_LENGTH; "));
         NXPRT(fprintf(stderr, "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 "));
         NXPRT(fprintf(stderr, "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 0x0: /* 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 0x8: /* Within a literal block; use rembytecount */
     case 0x9: /* 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 0xA: /* Within a FH block; */
     case 0xB: /* 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 0xC: /* Within a DH block; */
     case 0xD: /* 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 0xE: /* 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 0xF: /* 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);
 
         /* Engine did not process any data */
         if (is_eof && (source_sz == 0))
             is_final = 1;
     }
 
 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;
             unsigned 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 = ((uint32_t) tail[0] | (uint32_t) tail[1]<<8
                  | (uint32_t) tail[2]<<16
                  | (uint32_t) tail[3]<<24);
             isize = ((uint32_t) tail[4] | (uint32_t) tail[5]<<8
                  | (uint32_t) tail[6]<<16
                  | (uint32_t) 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 being handled\n");
     return -1;
 
 err3:
     fprintf(stderr, "error: gzip header\n");
     return -1;
 
 err4:
     fprintf(stderr, "error: checksum missing or mismatch\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;
 
     nx_dbg = 0;
     nx_gzip_log = NULL;
     act.sa_handler = 0;
     act.sa_sigaction = nxu_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;
 }

This page was automatically generated by the 2.1.0 LXR engine. The LXR team