subr_compressor.c

Version: - FREEBSD - FREEBSD-13-STABLE - FREEBSD-13-0 - FREEBSD-12-STABLE - FREEBSD-12-0 - FREEBSD-11-STABLE - FREEBSD-11-0 - FREEBSD-10-STABLE - FREEBSD-10-0 - FREEBSD-9-STABLE - FREEBSD-9-0 - FREEBSD-8-STABLE - FREEBSD-8-0 - FREEBSD-7-STABLE - FREEBSD-7-0 - FREEBSD-6-STABLE - FREEBSD-6-0 - FREEBSD-5-STABLE - FREEBSD-5-0 - FREEBSD-4-STABLE - FREEBSD-3-STABLE - FREEBSD22 - l41 - OPENBSD - linux-2.6 - MK84 - PLAN9 - xnu-8792
SearchContext: - none - 3 - 10
    1 /*-
    2  * SPDX-License-Identifier: BSD-2-Clause-FreeBSD
    3  *
    4  * Copyright (c) 2014, 2017 Mark Johnston <markj@FreeBSD.org>
    5  * Copyright (c) 2017 Conrad Meyer <cem@FreeBSD.org>
    6  *
    7  * Redistribution and use in source and binary forms, with or without
    8  * modification, are permitted provided that the following conditions are
    9  * met:
   10  * 1. Redistributions of source code must retain the above copyright
   11  *    notice, this list of conditions and the following disclaimer.
   12  * 2. Redistributions in binary form must reproduce the above copyright
   13  *    notice, this list of conditions and the following disclaimer in
   14  *    the documentation and/or other materials provided with the
   15  *    distribution.
   16  *
   17  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
   18  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
   19  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
   20  * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
   21  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
   22  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
   23  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
   24  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
   25  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
   26  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
   27  * SUCH DAMAGE.
   28  */
   29 
   30 /*
   31  * Subroutines used for writing compressed user process and kernel core dumps.
   32  */
   33 
   34 #include <sys/cdefs.h>
   35 __FBSDID("$FreeBSD$");
   36 
   37 #include "opt_gzio.h"
   38 #include "opt_zstdio.h"
   39 
   40 #include <sys/param.h>
   41 #include <sys/systm.h>
   42 
   43 #include <sys/compressor.h>
   44 #include <sys/endian.h>
   45 #include <sys/kernel.h>
   46 #include <sys/linker_set.h>
   47 #include <sys/malloc.h>
   48 
   49 MALLOC_DEFINE(M_COMPRESS, "compressor", "kernel compression subroutines");
   50 
   51 struct compressor_methods {
   52         int format;
   53         void *(* const init)(size_t, int);
   54         void (* const reset)(void *);
   55         int (* const write)(void *, void *, size_t, compressor_cb_t, void *);
   56         void (* const fini)(void *);
   57 };
   58 
   59 struct compressor {
   60         const struct compressor_methods *methods;
   61         compressor_cb_t cb;
   62         void *priv;
   63         void *arg;
   64 };
   65 
   66 SET_DECLARE(compressors, struct compressor_methods);
   67 
   68 #ifdef GZIO
   69 
   70 #include <contrib/zlib/zutil.h>
   71 
   72 struct gz_stream {
   73         uint8_t         *gz_buffer;     /* output buffer */
   74         size_t          gz_bufsz;       /* output buffer size */
   75         off_t           gz_off;         /* offset into the output stream */
   76         uint32_t        gz_crc;         /* stream CRC32 */
   77         z_stream        gz_stream;      /* zlib state */
   78 };
   79 
   80 static void     *gz_init(size_t maxiosize, int level);
   81 static void     gz_reset(void *stream);
   82 static int      gz_write(void *stream, void *data, size_t len, compressor_cb_t,
   83                     void *);
   84 static void     gz_fini(void *stream);
   85 
   86 static void *
   87 gz_alloc(void *arg __unused, u_int n, u_int sz)
   88 {
   89 
   90         /*
   91          * Memory for zlib state is allocated using M_NODUMP since it may be
   92          * used to compress a kernel dump, and we don't want zlib to attempt to
   93          * compress its own state.
   94          */
   95         return (malloc(n * sz, M_COMPRESS, M_WAITOK | M_ZERO | M_NODUMP));
   96 }
   97 
   98 static void
   99 gz_free(void *arg __unused, void *ptr)
  100 {
  101 
  102         free(ptr, M_COMPRESS);
  103 }
  104 
  105 static void *
  106 gz_init(size_t maxiosize, int level)
  107 {
  108         struct gz_stream *s;
  109         int error;
  110 
  111         s = gz_alloc(NULL, 1, roundup2(sizeof(*s), PAGE_SIZE));
  112         s->gz_buffer = gz_alloc(NULL, 1, maxiosize);
  113         s->gz_bufsz = maxiosize;
  114 
  115         s->gz_stream.zalloc = gz_alloc;
  116         s->gz_stream.zfree = gz_free;
  117         s->gz_stream.opaque = NULL;
  118         s->gz_stream.next_in = Z_NULL;
  119         s->gz_stream.avail_in = 0;
  120 
  121         if (level != Z_DEFAULT_COMPRESSION) {
  122                 if (level < Z_BEST_SPEED)
  123                         level = Z_BEST_SPEED;
  124                 else if (level > Z_BEST_COMPRESSION)
  125                         level = Z_BEST_COMPRESSION;
  126         }
  127 
  128         error = deflateInit2(&s->gz_stream, level, Z_DEFLATED, -MAX_WBITS,
  129             DEF_MEM_LEVEL, Z_DEFAULT_STRATEGY);
  130         if (error != 0)
  131                 goto fail;
  132 
  133         gz_reset(s);
  134 
  135         return (s);
  136 
  137 fail:
  138         gz_free(NULL, s);
  139         return (NULL);
  140 }
  141 
  142 static void
  143 gz_reset(void *stream)
  144 {
  145         struct gz_stream *s;
  146         uint8_t *hdr;
  147         const size_t hdrlen = 10;
  148 
  149         s = stream;
  150         s->gz_off = 0;
  151         s->gz_crc = crc32(0L, Z_NULL, 0);
  152 
  153         (void)deflateReset(&s->gz_stream);
  154         s->gz_stream.avail_out = s->gz_bufsz;
  155         s->gz_stream.next_out = s->gz_buffer;
  156 
  157         /* Write the gzip header to the output buffer. */
  158         hdr = s->gz_buffer;
  159         memset(hdr, 0, hdrlen);
  160         hdr[0] = 0x1f;
  161         hdr[1] = 0x8b;
  162         hdr[2] = Z_DEFLATED;
  163         hdr[9] = OS_CODE;
  164         s->gz_stream.next_out += hdrlen;
  165         s->gz_stream.avail_out -= hdrlen;
  166 }
  167 
  168 static int
  169 gz_write(void *stream, void *data, size_t len, compressor_cb_t cb,
  170     void *arg)
  171 {
  172         struct gz_stream *s;
  173         uint8_t trailer[8];
  174         size_t room;
  175         int error, zerror, zflag;
  176 
  177         s = stream;
  178         zflag = data == NULL ? Z_FINISH : Z_NO_FLUSH;
  179 
  180         if (len > 0) {
  181                 s->gz_stream.avail_in = len;
  182                 s->gz_stream.next_in = data;
  183                 s->gz_crc = crc32(s->gz_crc, data, len);
  184         }
  185 
  186         error = 0;
  187         do {
  188                 zerror = deflate(&s->gz_stream, zflag);
  189                 if (zerror != Z_OK && zerror != Z_STREAM_END) {
  190                         error = EIO;
  191                         break;
  192                 }
  193 
  194                 if (s->gz_stream.avail_out == 0 || zerror == Z_STREAM_END) {
  195                         /*
  196                          * Our output buffer is full or there's nothing left
  197                          * to produce, so we're flushing the buffer.
  198                          */
  199                         len = s->gz_bufsz - s->gz_stream.avail_out;
  200                         if (zerror == Z_STREAM_END) {
  201                                 /*
  202                                  * Try to pack as much of the trailer into the
  203                                  * output buffer as we can.
  204                                  */
  205                                 ((uint32_t *)trailer)[0] = htole32(s->gz_crc);
  206                                 ((uint32_t *)trailer)[1] =
  207                                     htole32(s->gz_stream.total_in);
  208                                 room = MIN(sizeof(trailer),
  209                                     s->gz_bufsz - len);
  210                                 memcpy(s->gz_buffer + len, trailer, room);
  211                                 len += room;
  212                         }
  213 
  214                         error = cb(s->gz_buffer, len, s->gz_off, arg);
  215                         if (error != 0)
  216                                 break;
  217 
  218                         s->gz_off += len;
  219                         s->gz_stream.next_out = s->gz_buffer;
  220                         s->gz_stream.avail_out = s->gz_bufsz;
  221 
  222                         /*
  223                          * If we couldn't pack the trailer into the output
  224                          * buffer, write it out now.
  225                          */
  226                         if (zerror == Z_STREAM_END && room < sizeof(trailer))
  227                                 error = cb(trailer + room,
  228                                     sizeof(trailer) - room, s->gz_off, arg);
  229                 }
  230         } while (zerror != Z_STREAM_END &&
  231             (zflag == Z_FINISH || s->gz_stream.avail_in > 0));
  232 
  233         return (error);
  234 }
  235 
  236 static void
  237 gz_fini(void *stream)
  238 {
  239         struct gz_stream *s;
  240 
  241         s = stream;
  242         (void)deflateEnd(&s->gz_stream);
  243         gz_free(NULL, s->gz_buffer);
  244         gz_free(NULL, s);
  245 }
  246 
  247 struct compressor_methods gzip_methods = {
  248         .format = COMPRESS_GZIP,
  249         .init = gz_init,
  250         .reset = gz_reset,
  251         .write = gz_write,
  252         .fini = gz_fini,
  253 };
  254 DATA_SET(compressors, gzip_methods);
  255 
  256 #endif /* GZIO */
  257 
  258 #ifdef ZSTDIO
  259 
  260 #define ZSTD_STATIC_LINKING_ONLY
  261 #include <contrib/zstd/lib/zstd.h>
  262 
  263 struct zstdio_stream {
  264         ZSTD_CCtx       *zst_stream;
  265         ZSTD_inBuffer   zst_inbuffer;
  266         ZSTD_outBuffer  zst_outbuffer;
  267         uint8_t *       zst_buffer;     /* output buffer */
  268         size_t          zst_maxiosz;    /* Max output IO size */
  269         off_t           zst_off;        /* offset into the output stream */
  270         void *          zst_static_wkspc;
  271 };
  272 
  273 static void     *zstdio_init(size_t maxiosize, int level);
  274 static void     zstdio_reset(void *stream);
  275 static int      zstdio_write(void *stream, void *data, size_t len,
  276                     compressor_cb_t, void *);
  277 static void     zstdio_fini(void *stream);
  278 
  279 static void *
  280 zstdio_init(size_t maxiosize, int level)
  281 {
  282         ZSTD_CCtx *dump_compressor;
  283         struct zstdio_stream *s;
  284         void *wkspc, *owkspc, *buffer;
  285         size_t wkspc_size, buf_size, rc;
  286 
  287         s = NULL;
  288         wkspc_size = ZSTD_estimateCStreamSize(level);
  289         owkspc = wkspc = malloc(wkspc_size + 8, M_COMPRESS,
  290             M_WAITOK | M_NODUMP);
  291         /* Zstd API requires 8-byte alignment. */
  292         if ((uintptr_t)wkspc % 8 != 0)
  293                 wkspc = (void *)roundup2((uintptr_t)wkspc, 8);
  294 
  295         dump_compressor = ZSTD_initStaticCCtx(wkspc, wkspc_size);
  296         if (dump_compressor == NULL) {
  297                 printf("%s: workspace too small.\n", __func__);
  298                 goto out;
  299         }
  300 
  301         rc = ZSTD_CCtx_setParameter(dump_compressor, ZSTD_c_checksumFlag, 1);
  302         if (ZSTD_isError(rc)) {
  303                 printf("%s: error setting checksumFlag: %s\n", __func__,
  304                     ZSTD_getErrorName(rc));
  305                 goto out;
  306         }
  307         rc = ZSTD_CCtx_setParameter(dump_compressor, ZSTD_c_compressionLevel,
  308             level);
  309         if (ZSTD_isError(rc)) {
  310                 printf("%s: error setting compressLevel: %s\n", __func__,
  311                     ZSTD_getErrorName(rc));
  312                 goto out;
  313         }
  314 
  315         buf_size = ZSTD_CStreamOutSize() * 2;
  316         buffer = malloc(buf_size, M_COMPRESS, M_WAITOK | M_NODUMP);
  317 
  318         s = malloc(sizeof(*s), M_COMPRESS, M_NODUMP | M_WAITOK);
  319         s->zst_buffer = buffer;
  320         s->zst_outbuffer.dst = buffer;
  321         s->zst_outbuffer.size = buf_size;
  322         s->zst_maxiosz = maxiosize;
  323         s->zst_stream = dump_compressor;
  324         s->zst_static_wkspc = owkspc;
  325 
  326         zstdio_reset(s);
  327 
  328 out:
  329         if (s == NULL)
  330                 free(owkspc, M_COMPRESS);
  331         return (s);
  332 }
  333 
  334 static void
  335 zstdio_reset(void *stream)
  336 {
  337         struct zstdio_stream *s;
  338         size_t res;
  339 
  340         s = stream;
  341         res = ZSTD_CCtx_reset(s->zst_stream, ZSTD_reset_session_only);
  342         if (ZSTD_isError(res))
  343                 panic("%s: could not reset stream %p: %s\n", __func__, s,
  344                     ZSTD_getErrorName(res));
  345         res = ZSTD_CCtx_setPledgedSrcSize(s->zst_stream,
  346             ZSTD_CONTENTSIZE_UNKNOWN);
  347         if (ZSTD_isError(res))
  348                 panic("%s: could not set src size on %p: %s\n", __func__, s,
  349                     ZSTD_getErrorName(res));
  350 
  351         s->zst_off = 0;
  352         s->zst_inbuffer.src = NULL;
  353         s->zst_inbuffer.size = 0;
  354         s->zst_inbuffer.pos = 0;
  355         s->zst_outbuffer.pos = 0;
  356 }
  357 
  358 static int
  359 zst_flush_intermediate(struct zstdio_stream *s, compressor_cb_t cb, void *arg)
  360 {
  361         size_t bytes_to_dump;
  362         int error;
  363 
  364         /* Flush as many full output blocks as possible. */
  365         /* XXX: 4096 is arbitrary safe HDD block size for kernel dumps */
  366         while (s->zst_outbuffer.pos >= 4096) {
  367                 bytes_to_dump = rounddown(s->zst_outbuffer.pos, 4096);
  368 
  369                 if (bytes_to_dump > s->zst_maxiosz)
  370                         bytes_to_dump = s->zst_maxiosz;
  371 
  372                 error = cb(s->zst_buffer, bytes_to_dump, s->zst_off, arg);
  373                 if (error != 0)
  374                         return (error);
  375 
  376                 /*
  377                  * Shift any non-full blocks up to the front of the output
  378                  * buffer.
  379                  */
  380                 s->zst_outbuffer.pos -= bytes_to_dump;
  381                 memmove(s->zst_outbuffer.dst,
  382                     (char *)s->zst_outbuffer.dst + bytes_to_dump,
  383                     s->zst_outbuffer.pos);
  384                 s->zst_off += bytes_to_dump;
  385         }
  386         return (0);
  387 }
  388 
  389 static int
  390 zstdio_flush(struct zstdio_stream *s, compressor_cb_t cb, void *arg)
  391 {
  392         size_t rc, lastpos;
  393         int error;
  394 
  395         /*
  396          * Positive return indicates unflushed data remaining; need to call
  397          * endStream again after clearing out room in output buffer.
  398          */
  399         rc = 1;
  400         lastpos = s->zst_outbuffer.pos;
  401         while (rc > 0) {
  402                 rc = ZSTD_endStream(s->zst_stream, &s->zst_outbuffer);
  403                 if (ZSTD_isError(rc)) {
  404                         printf("%s: ZSTD_endStream failed (%s)\n", __func__,
  405                             ZSTD_getErrorName(rc));
  406                         return (EIO);
  407                 }
  408                 if (lastpos == s->zst_outbuffer.pos) {
  409                         printf("%s: did not make forward progress endStream %zu\n",
  410                             __func__, lastpos);
  411                         return (EIO);
  412                 }
  413 
  414                 error = zst_flush_intermediate(s, cb, arg);
  415                 if (error != 0)
  416                         return (error);
  417 
  418                 lastpos = s->zst_outbuffer.pos;
  419         }
  420 
  421         /*
  422          * We've already done an intermediate flush, so all full blocks have
  423          * been written.  Only a partial block remains.  Padding happens in a
  424          * higher layer.
  425          */
  426         if (s->zst_outbuffer.pos != 0) {
  427                 error = cb(s->zst_buffer, s->zst_outbuffer.pos, s->zst_off,
  428                     arg);
  429                 if (error != 0)
  430                         return (error);
  431         }
  432 
  433         return (0);
  434 }
  435 
  436 static int
  437 zstdio_write(void *stream, void *data, size_t len, compressor_cb_t cb,
  438     void *arg)
  439 {
  440         struct zstdio_stream *s;
  441         size_t lastpos, rc;
  442         int error;
  443 
  444         s = stream;
  445         if (data == NULL)
  446                 return (zstdio_flush(s, cb, arg));
  447 
  448         s->zst_inbuffer.src = data;
  449         s->zst_inbuffer.size = len;
  450         s->zst_inbuffer.pos = 0;
  451         lastpos = 0;
  452 
  453         while (s->zst_inbuffer.pos < s->zst_inbuffer.size) {
  454                 rc = ZSTD_compressStream(s->zst_stream, &s->zst_outbuffer,
  455                     &s->zst_inbuffer);
  456                 if (ZSTD_isError(rc)) {
  457                         printf("%s: Compress failed on %p! (%s)\n",
  458                             __func__, data, ZSTD_getErrorName(rc));
  459                         return (EIO);
  460                 }
  461 
  462                 if (lastpos == s->zst_inbuffer.pos) {
  463                         /*
  464                          * XXX: May need flushStream to make forward progress
  465                          */
  466                         printf("ZSTD: did not make forward progress @pos %zu\n",
  467                             lastpos);
  468                         return (EIO);
  469                 }
  470                 lastpos = s->zst_inbuffer.pos;
  471 
  472                 error = zst_flush_intermediate(s, cb, arg);
  473                 if (error != 0)
  474                         return (error);
  475         }
  476         return (0);
  477 }
  478 
  479 static void
  480 zstdio_fini(void *stream)
  481 {
  482         struct zstdio_stream *s;
  483 
  484         s = stream;
  485         if (s->zst_static_wkspc != NULL)
  486                 free(s->zst_static_wkspc, M_COMPRESS);
  487         else
  488                 ZSTD_freeCCtx(s->zst_stream);
  489         free(s->zst_buffer, M_COMPRESS);
  490         free(s, M_COMPRESS);
  491 }
  492 
  493 static struct compressor_methods zstd_methods = {
  494         .format = COMPRESS_ZSTD,
  495         .init = zstdio_init,
  496         .reset = zstdio_reset,
  497         .write = zstdio_write,
  498         .fini = zstdio_fini,
  499 };
  500 DATA_SET(compressors, zstd_methods);
  501 
  502 #endif /* ZSTDIO */
  503 
  504 bool
  505 compressor_avail(int format)
  506 {
  507         struct compressor_methods **iter;
  508 
  509         SET_FOREACH(iter, compressors) {
  510                 if ((*iter)->format == format)
  511                         return (true);
  512         }
  513         return (false);
  514 }
  515 
  516 struct compressor *
  517 compressor_init(compressor_cb_t cb, int format, size_t maxiosize, int level,
  518     void *arg)
  519 {
  520         struct compressor_methods **iter;
  521         struct compressor *s;
  522         void *priv;
  523 
  524         SET_FOREACH(iter, compressors) {
  525                 if ((*iter)->format == format)
  526                         break;
  527         }
  528         if (iter == SET_LIMIT(compressors))
  529                 return (NULL);
  530 
  531         priv = (*iter)->init(maxiosize, level);
  532         if (priv == NULL)
  533                 return (NULL);
  534 
  535         s = malloc(sizeof(*s), M_COMPRESS, M_WAITOK | M_ZERO);
  536         s->methods = (*iter);
  537         s->priv = priv;
  538         s->cb = cb;
  539         s->arg = arg;
  540         return (s);
  541 }
  542 
  543 void
  544 compressor_reset(struct compressor *stream)
  545 {
  546 
  547         stream->methods->reset(stream->priv);
  548 }
  549 
  550 int
  551 compressor_write(struct compressor *stream, void *data, size_t len)
  552 {
  553 
  554         return (stream->methods->write(stream->priv, data, len, stream->cb,
  555             stream->arg));
  556 }
  557 
  558 int
  559 compressor_flush(struct compressor *stream)
  560 {
  561 
  562         return (stream->methods->write(stream->priv, NULL, 0, stream->cb,
  563             stream->arg));
  564 }
  565 
  566 void
  567 compressor_fini(struct compressor *stream)
  568 {
  569 
  570         stream->methods->fini(stream->priv);
  571 }
Cache object: 80160ed648ba3bf0055bdfd309091676
[ source navigation ] [ diff markup ] [ identifier search ] [ freetext search ] [ file search ] [ list types ] [ track identifier ]
This page is part of the FreeBSD/Linux Linux Kernel Cross-Reference, and was automatically generated using a modified version of the LXR engine.
FreeBSD/Linux Kernel Cross Reference sys/kern/subr_compressor.c

FreeBSD/Linux Kernel Cross Reference
sys/kern/subr_compressor.c
