1 From 5fb9fdfb8757fc9afb6318a3dcf9dce0a97de352 Mon Sep 17 00:00:00 2001
2 From: Phillip Lougher <phillip@squashfs.org.uk>
3 Date: Wed, 19 Apr 2023 18:35:53 +0100
4 Subject: [PATCH] xz_wrapper: make new OpenWrt extended options non-default
6 The reason why these options are being made non-default are
9 https://github.com/plougher/squashfs-tools/pull/218#issuecomment-1515197256
11 The new options can be enabled by editing the Makefile or by defining
12 XZ_EXTENDED_OPTIONS on the Make command line, e.g.
14 % CONFIG=1 XZ_SUPPORT=1 XZ_EXTENDED_OPTIONS=1 make
16 Signed-off-by: Phillip Lougher <phillip@squashfs.org.uk>
18 squashfs-tools/Makefile | 12 +
19 squashfs-tools/xz_wrapper.c | 117 +----
20 squashfs-tools/xz_wrapper_extended.c | 664 +++++++++++++++++++++++++++
21 3 files changed, 679 insertions(+), 114 deletions(-)
22 create mode 100644 squashfs-tools/xz_wrapper_extended.c
24 --- a/squashfs-tools/Makefile
25 +++ b/squashfs-tools/Makefile
26 @@ -39,6 +39,10 @@ GZIP_SUPPORT = 1
30 +# Enable support for OpenWrt extended compression options by uncommenting
31 +# next line. Do not do this unless you understand the implications.
32 +#XZ_EXTENDED_OPTIONS = 1
35 ############ Building LZO support ##############
37 @@ -197,6 +201,7 @@ INSTALL_MANPAGES_DIR ?= $(INSTALL_PREFIX
40 LZMA_DIR ?= ../../../../LZMA/lzma465
41 +XZ_EXTENDED_OPTIONS ?= 0
45 @@ -248,8 +253,13 @@ endif
47 ifeq ($(XZ_SUPPORT),1)
48 CFLAGS += -DXZ_SUPPORT
49 +ifeq ($(XZ_EXTENDED_OPTIONS),1)
50 +MKSQUASHFS_OBJS += xz_wrapper_extended.o
51 +UNSQUASHFS_OBJS += xz_wrapper_extended.o
53 MKSQUASHFS_OBJS += xz_wrapper.o
54 UNSQUASHFS_OBJS += xz_wrapper.o
59 @@ -428,6 +438,8 @@ lz4_wrapper.o: lz4_wrapper.c squashfs_fs
61 xz_wrapper.o: xz_wrapper.c squashfs_fs.h xz_wrapper.h compressor.h
63 +xz_wrapper_extended.o: xz_wrapper_extended.c squashfs_fs.h xz_wrapper.h compressor.h
65 unsquashfs: $(UNSQUASHFS_OBJS)
66 $(CC) $(LDFLAGS) $(EXTRA_LDFLAGS) $(UNSQUASHFS_OBJS) $(LIBS) -o $@
67 ln -sf unsquashfs sqfscat
68 --- a/squashfs-tools/xz_wrapper.c
69 +++ b/squashfs-tools/xz_wrapper.c
70 @@ -44,10 +44,7 @@ static struct bcj bcj[] = {
71 static int filter_count = 1;
72 static int dictionary_size = 0;
73 static float dictionary_percent = 0;
74 -static int preset = LZMA_PRESET_DEFAULT;
81 * This function is called by the options parsing code in mksquashfs.c
82 @@ -56,11 +53,6 @@ static int pb = -1;
83 * Two specific options are supported:
92 * This function returns:
93 * >=0 (number of additional args parsed) on success
94 @@ -149,85 +141,6 @@ static int xz_options(char *argv[], int
98 - } else if(strcmp(argv[0], "-Xpreset") == 0) {
103 - fprintf(stderr, "xz: -Xpreset missing preset-level "
104 - "(valid value 0-9)\n");
108 - val = strtol(argv[1], &b, 10);
109 - if (*b != '\0' || (int) val < 0 || (int) val & ~LZMA_PRESET_LEVEL_MASK) {
110 - fprintf(stderr, "xz: -Xpreset can't be "
111 - "negative or more than the max preset\n");
115 - preset &= ~LZMA_PRESET_LEVEL_MASK;
116 - preset |= (int) val;
119 - } else if(strcmp(argv[0], "-Xe") == 0) {
120 - preset |= LZMA_PRESET_EXTREME;
123 - } else if(strcmp(argv[0], "-Xlc") == 0) {
128 - fprintf(stderr, "xz: -Xlc missing value\n");
132 - val = strtol(argv[1], &b, 10);
133 - if (*b != '\0' || (int) val < LZMA_LCLP_MIN || (int) val > LZMA_LCLP_MAX) {
134 - fprintf(stderr, "xz: -Xlc invalid value\n");
141 - } else if(strcmp(argv[0], "-Xlp") == 0) {
146 - fprintf(stderr, "xz: -Xlp missing value\n");
150 - val = strtol(argv[1], &b, 10);
151 - if (*b != '\0' || (int) val < LZMA_LCLP_MIN || (int) val > LZMA_LCLP_MAX) {
152 - fprintf(stderr, "xz: -Xlp invalid value\n");
159 - } else if(strcmp(argv[0], "-Xpb") == 0) {
164 - fprintf(stderr, "xz: -Xpb missing value\n");
168 - val = strtol(argv[1], &b, 10);
169 - if (*b != '\0' || (int) val < LZMA_PB_MIN || (int) val > LZMA_PB_MAX) {
170 - fprintf(stderr, "xz: -Xpb invalid value\n");
180 @@ -533,20 +446,11 @@ static int xz_compress(void *strm, void
181 for(i = 0; i < stream->filters; i++) {
182 struct filter *filter = &stream->filter[i];
184 - if(lzma_lzma_preset(&stream->opt, preset))
185 + if(lzma_lzma_preset(&stream->opt, LZMA_PRESET_DEFAULT))
188 stream->opt.dict_size = stream->dictionary_size;
191 - stream->opt.lc = lc;
194 - stream->opt.lp = lp;
197 - stream->opt.pb = pb;
200 res = lzma_stream_buffer_encode(filter->filter,
201 LZMA_CHECK_CRC32, NULL, src, size, filter->buffer,
202 @@ -617,28 +521,13 @@ static void xz_usage(FILE *stream)
203 fprintf(stream, " header as either 2^n or as 2^n+2^(n+1).\n\t\t");
204 fprintf(stream, "Example dict-sizes are 75%%, 50%%, 37.5%%, 25%%, or");
205 fprintf(stream, " 32K, 16K, 8K\n\t\tetc.\n");
206 - fprintf(stream, "\t -Xpreset <preset-level>\n");
207 - fprintf(stream, "\t\tUse <preset-value> as the custom preset to use");
208 - fprintf(stream, " on compress.\n\t\t<preset-level> should be 0 .. 9");
209 - fprintf(stream, " (default 6)\n");
210 - fprintf(stream, "\t -Xe\n");
211 - fprintf(stream, "\t\tEnable additional compression settings by passing");
212 - fprintf(stream, " the EXTREME\n\t\tflag to the compression flags.\n");
213 - fprintf(stream, "\t -Xlc <value>\n");
214 - fprintf(stream, "\t -Xlp <value>\n");
215 - fprintf(stream, "\t -Xpb <value>\n");
219 static int option_args(char *option)
221 if(strcmp(option, "-Xbcj") == 0 ||
222 - strcmp(option, "-Xdict-size") == 0 ||
223 - strcmp(option, "-Xpreset") == 0 ||
224 - strcmp(option, "-Xe") == 0 ||
225 - strcmp(option, "-Xlc") == 0 ||
226 - strcmp(option, "-Xlp") == 0 ||
227 - strcmp(option, "-Xpb") == 0)
228 + strcmp(option, "-Xdict-size") == 0)
233 +++ b/squashfs-tools/xz_wrapper_extended.c
236 + * Copyright (c) 2010, 2011, 2012, 2013, 2021, 2022
237 + * Phillip Lougher <phillip@squashfs.org.uk>
239 + * This program is free software; you can redistribute it and/or
240 + * modify it under the terms of the GNU General Public License
241 + * as published by the Free Software Foundation; either version 2,
242 + * or (at your option) any later version.
244 + * This program is distributed in the hope that it will be useful,
245 + * but WITHOUT ANY WARRANTY; without even the implied warranty of
246 + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
247 + * GNU General Public License for more details.
249 + * You should have received a copy of the GNU General Public License
250 + * along with this program; if not, write to the Free Software
251 + * Foundation, 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
253 + * xz_wrapper_extended.c
255 + * Support for XZ (LZMA2) compression using XZ Utils liblzma
256 + * http://tukaani.org/xz/
258 + * This file supports OpenWrt extended XZ compression options.
266 +#include "squashfs_fs.h"
267 +#include "xz_wrapper.h"
268 +#include "compressor.h"
270 +static struct bcj bcj[] = {
271 + { "x86", LZMA_FILTER_X86, 0 },
272 + { "powerpc", LZMA_FILTER_POWERPC, 0 },
273 + { "ia64", LZMA_FILTER_IA64, 0 },
274 + { "arm", LZMA_FILTER_ARM, 0 },
275 + { "armthumb", LZMA_FILTER_ARMTHUMB, 0 },
276 + { "sparc", LZMA_FILTER_SPARC, 0 },
277 + { NULL, LZMA_VLI_UNKNOWN, 0 }
280 +static int filter_count = 1;
281 +static int dictionary_size = 0;
282 +static float dictionary_percent = 0;
283 +static int preset = LZMA_PRESET_DEFAULT;
289 + * This function is called by the options parsing code in mksquashfs.c
290 + * to parse any -X compressor option.
292 + * Two specific options are supported:
301 + * This function returns:
302 + * >=0 (number of additional args parsed) on success
303 + * -1 if the option was unrecognised, or
304 + * -2 if the option was recognised, but otherwise bad in
305 + * some way (e.g. invalid parameter)
307 + * Note: this function sets internal compressor state, but does not
308 + * pass back the results of the parsing other than success/failure.
309 + * The xz_dump_options() function is called later to get the options in
310 + * a format suitable for writing to the filesystem.
312 +static int xz_options(char *argv[], int argc)
317 + if(strcmp(argv[0], "-Xbcj") == 0) {
319 + fprintf(stderr, "xz: -Xbcj missing filter\n");
324 + while(name[0] != '\0') {
325 + for(i = 0; bcj[i].name; i++) {
326 + int n = strlen(bcj[i].name);
327 + if((strncmp(name, bcj[i].name, n) == 0) &&
328 + (name[n] == '\0' ||
330 + if(bcj[i].selected == 0) {
331 + bcj[i].selected = 1;
334 + name += name[n] == ',' ? n + 1 : n;
338 + if(bcj[i].name == NULL) {
339 + fprintf(stderr, "xz: -Xbcj unrecognised "
346 + } else if(strcmp(argv[0], "-Xdict-size") == 0) {
351 + fprintf(stderr, "xz: -Xdict-size missing dict-size\n");
355 + size = strtof(argv[1], &b);
357 + if(size <= 0 || size > 100) {
358 + fprintf(stderr, "xz: -Xdict-size percentage "
359 + "should be 0 < dict-size <= 100\n");
363 + dictionary_percent = size;
364 + dictionary_size = 0;
366 + if((float) ((int) size) != size) {
367 + fprintf(stderr, "xz: -Xdict-size can't be "
368 + "fractional unless a percentage of the"
373 + dictionary_percent = 0;
374 + dictionary_size = (int) size;
376 + if(*b == 'k' || *b == 'K')
377 + dictionary_size *= 1024;
378 + else if(*b == 'm' || *b == 'M')
379 + dictionary_size *= 1024 * 1024;
380 + else if(*b != '\0') {
381 + fprintf(stderr, "xz: -Xdict-size invalid "
388 + } else if(strcmp(argv[0], "-Xpreset") == 0) {
393 + fprintf(stderr, "xz: -Xpreset missing preset-level "
394 + "(valid value 0-9)\n");
398 + val = strtol(argv[1], &b, 10);
399 + if (*b != '\0' || (int) val < 0 || (int) val & ~LZMA_PRESET_LEVEL_MASK) {
400 + fprintf(stderr, "xz: -Xpreset can't be "
401 + "negative or more than the max preset\n");
405 + preset &= ~LZMA_PRESET_LEVEL_MASK;
406 + preset |= (int) val;
409 + } else if(strcmp(argv[0], "-Xe") == 0) {
410 + preset |= LZMA_PRESET_EXTREME;
413 + } else if(strcmp(argv[0], "-Xlc") == 0) {
418 + fprintf(stderr, "xz: -Xlc missing value\n");
422 + val = strtol(argv[1], &b, 10);
423 + if (*b != '\0' || (int) val < LZMA_LCLP_MIN || (int) val > LZMA_LCLP_MAX) {
424 + fprintf(stderr, "xz: -Xlc invalid value\n");
431 + } else if(strcmp(argv[0], "-Xlp") == 0) {
436 + fprintf(stderr, "xz: -Xlp missing value\n");
440 + val = strtol(argv[1], &b, 10);
441 + if (*b != '\0' || (int) val < LZMA_LCLP_MIN || (int) val > LZMA_LCLP_MAX) {
442 + fprintf(stderr, "xz: -Xlp invalid value\n");
449 + } else if(strcmp(argv[0], "-Xpb") == 0) {
454 + fprintf(stderr, "xz: -Xpb missing value\n");
458 + val = strtol(argv[1], &b, 10);
459 + if (*b != '\0' || (int) val < LZMA_PB_MIN || (int) val > LZMA_PB_MAX) {
460 + fprintf(stderr, "xz: -Xpb invalid value\n");
477 + * This function is called after all options have been parsed.
478 + * It is used to do post-processing on the compressor options using
479 + * values that were not expected to be known at option parse time.
481 + * In this case block_size may not be known until after -Xdict-size has
482 + * been processed (in the case where -b is specified after -Xdict-size)
484 + * This function returns 0 on successful post processing, or
487 +static int xz_options_post(int block_size)
490 + * if -Xdict-size has been specified use this to compute the datablock
493 + if(dictionary_size || dictionary_percent) {
496 + if(dictionary_size) {
497 + if(dictionary_size > block_size) {
498 + fprintf(stderr, "xz: -Xdict-size is larger than"
503 + dictionary_size = block_size * dictionary_percent / 100;
505 + if(dictionary_size < 8192) {
506 + fprintf(stderr, "xz: -Xdict-size should be 8192 bytes "
512 + * dictionary_size must be storable in xz header as either
513 + * 2^n or as 2^n+2^(n+1)
515 + n = ffs(dictionary_size) - 1;
516 + if(dictionary_size != (1 << n) &&
517 + dictionary_size != ((1 << n) + (1 << (n + 1)))) {
518 + fprintf(stderr, "xz: -Xdict-size is an unsupported "
519 + "value, dict-size must be storable in xz "
521 + fprintf(stderr, "as either 2^n or as 2^n+2^(n+1). "
522 + "Example dict-sizes are 75%%, 50%%, 37.5%%, "
524 + fprintf(stderr, "or 32K, 16K, 8K etc.\n");
529 + /* No -Xdict-size specified, use defaults */
530 + dictionary_size = block_size;
540 + * This function is called by mksquashfs to dump the parsed
541 + * compressor options in a format suitable for writing to the
542 + * compressor options field in the filesystem (stored immediately
543 + * after the superblock).
545 + * This function returns a pointer to the compression options structure
546 + * to be stored (and the size), or NULL if there are no compression
549 +static void *xz_dump_options(int block_size, int *size)
551 + static struct comp_opts comp_opts;
555 + * don't store compressor specific options in file system if the
556 + * default options are being used - no compressor options in the
557 + * file system means the default options are always assumed
560 + * metadata dictionary size: SQUASHFS_METADATA_SIZE
561 + * datablock dictionary size: block_size
564 + if(dictionary_size == block_size && filter_count == 1)
567 + for(i = 0; bcj[i].name; i++)
568 + flags |= bcj[i].selected << i;
570 + comp_opts.dictionary_size = dictionary_size;
571 + comp_opts.flags = flags;
573 + SQUASHFS_INSWAP_COMP_OPTS(&comp_opts);
575 + *size = sizeof(comp_opts);
581 + * This function is a helper specifically for the append mode of
582 + * mksquashfs. Its purpose is to set the internal compressor state
583 + * to the stored compressor options in the passed compressor options
586 + * In effect this function sets up the compressor options
587 + * to the same state they were when the filesystem was originally
588 + * generated, this is to ensure on appending, the compressor uses
589 + * the same compression options that were used to generate the
590 + * original filesystem.
592 + * Note, even if there are no compressor options, this function is still
593 + * called with an empty compressor structure (size == 0), to explicitly
594 + * set the default options, this is to ensure any user supplied
595 + * -X options on the appending mksquashfs command line are over-ridden
597 + * This function returns 0 on sucessful extraction of options, and
600 +static int xz_extract_options(int block_size, void *buffer, int size)
602 + struct comp_opts *comp_opts = buffer;
607 + dictionary_size = block_size;
610 + /* check passed comp opts struct is of the correct length */
611 + if(size != sizeof(struct comp_opts))
614 + SQUASHFS_INSWAP_COMP_OPTS(comp_opts);
616 + dictionary_size = comp_opts->dictionary_size;
617 + flags = comp_opts->flags;
620 + * check that the dictionary size seems correct - the dictionary
621 + * size should 2^n or 2^n+2^(n+1)
623 + n = ffs(dictionary_size) - 1;
624 + if(dictionary_size != (1 << n) &&
625 + dictionary_size != ((1 << n) + (1 << (n + 1))))
630 + for(i = 0; bcj[i].name; i++) {
631 + if((flags >> i) & 1) {
632 + bcj[i].selected = 1;
635 + bcj[i].selected = 0;
641 + fprintf(stderr, "xz: error reading stored compressor options from "
648 +static void xz_display_options(void *buffer, int size)
650 + struct comp_opts *comp_opts = buffer;
651 + int dictionary_size, flags, printed;
654 + /* check passed comp opts struct is of the correct length */
655 + if(size != sizeof(struct comp_opts))
658 + SQUASHFS_INSWAP_COMP_OPTS(comp_opts);
660 + dictionary_size = comp_opts->dictionary_size;
661 + flags = comp_opts->flags;
664 + * check that the dictionary size seems correct - the dictionary
665 + * size should 2^n or 2^n+2^(n+1)
667 + n = ffs(dictionary_size) - 1;
668 + if(dictionary_size != (1 << n) &&
669 + dictionary_size != ((1 << n) + (1 << (n + 1))))
672 + printf("\tDictionary size %d\n", dictionary_size);
675 + for(i = 0; bcj[i].name; i++) {
676 + if((flags >> i) & 1) {
680 + printf("\tFilters selected: ");
681 + printf("%s", bcj[i].name);
687 + printf("\tNo filters specified\n");
694 + fprintf(stderr, "xz: error reading stored compressor options from "
700 + * This function is called by mksquashfs to initialise the
701 + * compressor, before compress() is called.
703 + * This function returns 0 on success, and
706 +static int xz_init(void **strm, int block_size, int datablock)
708 + int i, j, filters = datablock ? filter_count : 1;
709 + struct filter *filter = malloc(filters * sizeof(struct filter));
710 + struct xz_stream *stream;
715 + stream = *strm = malloc(sizeof(struct xz_stream));
719 + stream->filter = filter;
720 + stream->filters = filters;
722 + memset(filter, 0, filters * sizeof(struct filter));
724 + stream->dictionary_size = datablock ? dictionary_size :
725 + SQUASHFS_METADATA_SIZE;
727 + filter[0].filter[0].id = LZMA_FILTER_LZMA2;
728 + filter[0].filter[0].options = &stream->opt;
729 + filter[0].filter[1].id = LZMA_VLI_UNKNOWN;
731 + for(i = 0, j = 1; datablock && bcj[i].name; i++) {
732 + if(bcj[i].selected) {
733 + filter[j].buffer = malloc(block_size);
734 + if(filter[j].buffer == NULL)
736 + filter[j].filter[0].id = bcj[i].id;
737 + filter[j].filter[1].id = LZMA_FILTER_LZMA2;
738 + filter[j].filter[1].options = &stream->opt;
739 + filter[j].filter[2].id = LZMA_VLI_UNKNOWN;
747 + for(i = 1; i < filters; i++)
748 + free(filter[i].buffer);
759 +static int xz_compress(void *strm, void *dest, void *src, int size,
760 + int block_size, int *error)
764 + struct xz_stream *stream = strm;
765 + struct filter *selected = NULL;
767 + stream->filter[0].buffer = dest;
769 + for(i = 0; i < stream->filters; i++) {
770 + struct filter *filter = &stream->filter[i];
772 + if(lzma_lzma_preset(&stream->opt, preset))
775 + stream->opt.dict_size = stream->dictionary_size;
778 + stream->opt.lc = lc;
781 + stream->opt.lp = lp;
784 + stream->opt.pb = pb;
786 + filter->length = 0;
787 + res = lzma_stream_buffer_encode(filter->filter,
788 + LZMA_CHECK_CRC32, NULL, src, size, filter->buffer,
789 + &filter->length, block_size);
791 + if(res == LZMA_OK) {
792 + if(!selected || selected->length > filter->length)
794 + } else if(res != LZMA_BUF_ERROR)
800 + * Output buffer overflow. Return out of buffer space
804 + if(selected->buffer != dest)
805 + memcpy(dest, selected->buffer, selected->length);
807 + return (int) selected->length;
811 + * All other errors return failure, with the compressor
812 + * specific error code in *error
819 +static int xz_uncompress(void *dest, void *src, int size, int outsize,
822 + size_t src_pos = 0;
823 + size_t dest_pos = 0;
824 + uint64_t memlimit = MEMLIMIT;
826 + lzma_ret res = lzma_stream_buffer_decode(&memlimit, 0, NULL,
827 + src, &src_pos, size, dest, &dest_pos, outsize);
829 + if(res == LZMA_OK && size == (int) src_pos)
830 + return (int) dest_pos;
838 +static void xz_usage(FILE *stream)
840 + fprintf(stream, "\t -Xbcj filter1,filter2,...,filterN\n");
841 + fprintf(stream, "\t\tCompress using filter1,filter2,...,filterN in");
842 + fprintf(stream, " turn\n\t\t(in addition to no filter), and choose");
843 + fprintf(stream, " the best compression.\n");
844 + fprintf(stream, "\t\tAvailable filters: x86, arm, armthumb,");
845 + fprintf(stream, " powerpc, sparc, ia64\n");
846 + fprintf(stream, "\t -Xdict-size <dict-size>\n");
847 + fprintf(stream, "\t\tUse <dict-size> as the XZ dictionary size. The");
848 + fprintf(stream, " dictionary size\n\t\tcan be specified as a");
849 + fprintf(stream, " percentage of the block size, or as an\n\t\t");
850 + fprintf(stream, "absolute value. The dictionary size must be less");
851 + fprintf(stream, " than or equal\n\t\tto the block size and 8192 bytes");
852 + fprintf(stream, " or larger. It must also be\n\t\tstorable in the xz");
853 + fprintf(stream, " header as either 2^n or as 2^n+2^(n+1).\n\t\t");
854 + fprintf(stream, "Example dict-sizes are 75%%, 50%%, 37.5%%, 25%%, or");
855 + fprintf(stream, " 32K, 16K, 8K\n\t\tetc.\n");
856 + fprintf(stream, "\t -Xpreset <preset-level>\n");
857 + fprintf(stream, "\t\tUse <preset-value> as the custom preset to use");
858 + fprintf(stream, " on compress.\n\t\t<preset-level> should be 0 .. 9");
859 + fprintf(stream, " (default 6)\n");
860 + fprintf(stream, "\t -Xe\n");
861 + fprintf(stream, "\t\tEnable additional compression settings by passing");
862 + fprintf(stream, " the EXTREME\n\t\tflag to the compression flags.\n");
863 + fprintf(stream, "\t -Xlc <value>\n");
864 + fprintf(stream, "\t -Xlp <value>\n");
865 + fprintf(stream, "\t -Xpb <value>\n");
869 +static int option_args(char *option)
871 + if(strcmp(option, "-Xbcj") == 0 ||
872 + strcmp(option, "-Xdict-size") == 0 ||
873 + strcmp(option, "-Xpreset") == 0 ||
874 + strcmp(option, "-Xe") == 0 ||
875 + strcmp(option, "-Xlc") == 0 ||
876 + strcmp(option, "-Xlp") == 0 ||
877 + strcmp(option, "-Xpb") == 0)
884 +struct compressor xz_comp_ops = {
886 + .compress = xz_compress,
887 + .uncompress = xz_uncompress,
888 + .options = xz_options,
889 + .options_post = xz_options_post,
890 + .dump_options = xz_dump_options,
891 + .extract_options = xz_extract_options,
892 + .display_options = xz_display_options,
894 + .option_args = option_args,
895 + .id = XZ_COMPRESSION,