Merge branch 'jn/5.1.1alpha+20120614'
Recent changes from upstream, including a documentation update and
small correctness fix for the "minimal version to decode" field.
Thanks to Lasse Collin for advice about which patches to apply.
After these changes, the xz and liblzma API and ABI match 5.1.2alpha,
except that no features that were not already present in Debian sid
have been added.
diff --git a/configure.ac b/configure.ac
index 25eb838..0c2f2fc 100644
--- a/configure.ac
+++ b/configure.ac
@@ -471,7 +471,40 @@
AC_CHECK_DECLS([CLOCK_MONOTONIC], [], [], [[#include <time.h>]])
CFLAGS=$OLD_CFLAGS
fi
-AM_CONDITIONAL([COND_THREADS], [test "x$ax_pthread_ok" = xyes])
+
+# As a Debian-specific hack, liblzma can use dlopen() to check if extra
+# paranoia is needed because unversioned symbols from liblzma.so.2 are
+# present in the same process. See src/liblzma/common/common.c.
+AC_MSG_CHECKING([if lzma_code checks should be relaxed for compatibility])
+AC_ARG_ENABLE([liblzma2-compat], [AC_HELP_STRING([--enable-liblzma2-compat],
+ [Relax run-time checks to accomodate old binaries built
+ with smaller sizeof(lzma_stream). The default is "dynamic",
+ which means to only use the relaxed checks when the dynamic
+ loader reports that liblzma.so.2 is loaded in the same process.])],
+ [], [enable_liblzma2_compat=dynamic])
+case $enable_liblzma2_compat in
+dynamic)
+ AC_SEARCH_LIBS([dlopen], [dl])
+ AC_DEFINE([LIBLZMA2_COMPAT_DYNAMIC], [1],
+ [Define to 1 to use dlopen() to check if lzma_code() checks
+ should be more tolerant because the process is also linked to
+ liblzma from Debian 6.0.])
+ AC_MSG_RESULT([auto])
+ ;;
+yes)
+ AC_DEFINE([LIBLZMA2_COMPAT], [1],
+ [Define to 1 to unconditionally make lzma_code() checks tolerant
+ to accomodate callers built against liblzma from Debian 6.0.])
+ AC_MSG_RESULT([yes])
+ ;;
+no)
+ AC_MSG_RESULT([no])
+ ;;
+*)
+ AC_MSG_RESULT([])
+ AC_MSG_ERROR([--enable-liblzma2: unrecognized value $enable_liblzma2_compat])
+ ;;
+esac
echo
echo "Initializing Libtool:"
diff --git a/debian/.gitignore b/debian/.gitignore
new file mode 100644
index 0000000..7936ab7
--- /dev/null
+++ b/debian/.gitignore
@@ -0,0 +1,23 @@
+/changelog.upstream
+/generated-m4.list
+/generated-po.list
+/generated-build-aux.list
+
+*.debhelper.log
+*.debhelper
+
+/*-stamp
+
+/normal-build/
+/static-build/
+/xzdec-build/
+/tmp/
+
+/liblzma5/
+/xz-utils/
+/xzdec/
+/liblzma-dev/
+/liblzma-doc/
+
+/files
+*.substvars
diff --git a/debian/README.source b/debian/README.source
new file mode 100644
index 0000000..f17a7de
--- /dev/null
+++ b/debian/README.source
@@ -0,0 +1,16 @@
+XZ Utils sources for Debian
+---------------------------
+
+This Debian package is developed in a public Git repository (see the Vcs-Git
+field of debian/control) based on XZ Utils’s repository on tukaani.org.
+To build from a git checkout:
+
+ debian/rules get-orig-source
+ mv xz-utils_*.tar.gz ..
+ debian/autogen.sh
+ debuild
+
+To build a released version, no special instructions apply.
+“dpkg-buildpackage” and “apt-get -b xz-utils” should work as usual.
+
+ -- Jonathan Nieder <jrnieder@gmail.com> Mon, 08 Feb 2010 17:30:00 -0600
diff --git a/debian/autogen.sh b/debian/autogen.sh
new file mode 100755
index 0000000..05a3a9f
--- /dev/null
+++ b/debian/autogen.sh
@@ -0,0 +1,32 @@
+#!/bin/sh
+# Generate debian/changelog.upstream, debian/generated-m4.list,
+# and debian/generated-po.list.
+#
+# Uses debian/changelog, the git revision log, and .gitignore
+# files from the current checkout.
+
+set -e
+
+changelog_needs_update() {
+ test -e debian/changelog.upstream &&
+ read line < debian/changelog.upstream ||
+ return 0
+
+ ver=${line#Version } &&
+ ver=${ver%;*} &&
+ test "$ver" != "" ||
+ return 0
+
+ read line < debian/changelog &&
+ rhs=${line#*(} &&
+ deb_ver=${rhs%)*} &&
+ new_ver=${deb_ver%-*} ||
+ return 0
+
+ test "$ver" != "$new_ver"
+}
+
+cp -f m4/.gitignore debian/generated-m4.list
+cp -f po/.gitignore debian/generated-po.list
+sed -n 's,^build-aux/,, p' .gitignore > debian/generated-build-aux.list
+! changelog_needs_update || exec sh debian/changelog.upstream.sh
diff --git a/debian/changelog b/debian/changelog
new file mode 100644
index 0000000..5f8a175
--- /dev/null
+++ b/debian/changelog
@@ -0,0 +1,626 @@
+xz-utils (5.1.1alpha+20120614-1.1) unstable; urgency=low
+
+ * liblzma: report a LZMA_DATA_ERROR when range encoded data starts
+ with a nonzero byte. This is a sanity check to catch malformed
+ files that no known encoders produce.
+ * xz -v -v --list: Support for decompressing blocks with zero-length
+ uncompressed data was added in xz 5.0.2, not 5.0.3.
+ * xz.1: "xz --robot -v -v --list" gained a "minimum xz version to
+ decompress" field.
+ * xz-utils/README.Debian: Document differences from upstream.
+ Closes: #685217.
+
+ -- Jonathan Nieder <jrnieder@gmail.com> Mon, 10 Sep 2012 14:00:55 -0700
+
+xz-utils (5.1.1alpha+20120614-1) unstable; urgency=low
+
+ * New snapshot, taken from upstream commit f1675f76.
+ - liblzma: BCJ filters would return a spurious LZMA_BUF_ERROR
+ result in certain circumstances. As a result, the xz tool
+ could produce inappropriate "Compressed data is corrupt" or
+ "Unexpected end of input" failures (reported in XZ Embedded as
+ Fedora bug 735408).
+ - "xz -v -v --list" prints the minimal XZ Utils version needed
+ to decompress a stream.
+ - "xz --robot -v --list" formats filenames more plainly.
+ - xzgrep does not fail unconditionally when the decompressor
+ dies with SIGPIPE due to unconsumed output any more. This
+ makes the exit status from commands such as "xzgrep -q" and
+ "xzgrep -l" more predictable and convenient for scripts.
+ - examples/xz_pipe_decomp.c did not check correctly for
+ truncated input.
+ - There is a new set of sample programs. The old ones have
+ been renamed to examples_old but are still maintained.
+ * liblzma:
+ - If dlopen() indicates that liblzma.so.2 is loaded, check fewer
+ reserved fields in the stream argument to the lzma_code()
+ function. This prevents out-of-bounds reads when liblzma5
+ functions are called by code built against liblzma2 (see
+ <http://sourceware.org/PR12977>).
+ - Remove the lzma_code@Base compatibility symbol.
+ Closes: #649522. Thanks to Eduard Bloch.
+ - Install run-time library to /lib so it can be used before /usr
+ is mounted. Closes: #672120.
+ - Configure with --disable-threads for now to avoid needlessly
+ linking to libpthread and librt.
+ * liblzma-dev:
+ - Install an appropriate library for static linking instead of
+ the decompression-only version used to build xzdec.
+ Closes: #673001. Thanks to Anton Tolchanov.
+ - Use the liblzma2-compatible version of lzma_code() in the
+ static library.
+ - Multi-Arch: same. Thanks to Riku Voipio.
+ - Install new examples and revised old examples to
+ /usr/share/doc/liblzma-dev.
+ * xz-utils:
+ - Use update-alternatives to provide lzma, unlzma, lzcat, and
+ the rest of the lz* scripts without conflicting with the lzma
+ package.
+ - Conflicts: lzma versions before before 9.22-1, when it started
+ providing lzma, unlzma, and lzcat through the alternatives
+ system.
+ - Conflicts: and Replaces: xz-lzma.
+ - README.Debian: Update instructions on configuring the package
+ to provide lzma compatibility commands.
+ * Remove xz-lzma package.
+ * Use dpkg-buildflags to retrieve compiler flags, including
+ hardening options. Build-Depends: dpkg-dev (>= 1.16.1).
+ Closes: #653739.
+ * debian/rules:
+ - build-arch: Simplify by using a double-colon rule instead of a
+ dependency on a dummy noop target.
+ - build-indep: Assume doxygen is available, instead of trying to
+ get by by assuming the caller meant to invoke build-arch when
+ it is missing. Build-Depends: dpkg-dev (>= 1.16.2).
+ - Rearrange for clarity.
+ * debian/symbols: Bump the minimal version for lzma_code(),
+ lzma_raw_buffer_decode(), and lzma_raw_buffer_encode().
+ * Use machine-readable copyright-format 1.0.
+ * Update copyright file.
+ * Standards-Version: 3.9.3 (checked).
+ * debian/changelog.upstream.sh: Use ‘git rev-list | git diff-tree’
+ instead of ‘git log’ to avoid depending on the build system’s
+ configuration.
+
+ -- Jonathan Nieder <jrnieder@gmail.com> Sat, 16 Jun 2012 15:03:17 -0500
+
+xz-utils (5.1.1alpha+20110809-3) unstable; urgency=low
+
+ * liblzma: Match upstream ABI.
+ - Remove the lzma_chunk_size() function.
+ - A few ABI tweaks to reserved space in structures.
+ - Enable ELF symbol versioning.
+ - Bump soname to 5.
+ - Continue to leave out threading support, since the relevant
+ interfaces in liblzma are not yet stable.
+ * xz-utils/README.Debian: Remove note on ABI differences.
+ * Remove liblzma/README.Debian.
+ * liblzma: Introduce a lzma_code@Base compatibility symbol to ensure
+ programs linked against unversioned symbols from liblzma2 can
+ share a process image with liblzma5 without breaking.
+ * debian/symbols: XZ_5.0 symbols come from liblzma5. Build-Depends:
+ dpkg-dev (>= 1.15.6); thanks to Jakub Wilk for a reminder.
+ * debian/symbols: The lzma_code@Base symbol is not guaranteed to
+ continue to exist in the future, so tell dpkg-shlibdeps to produce
+ an error if some package manages to use it.
+
+ -- Jonathan Nieder <jrnieder@gmail.com> Thu, 20 Oct 2011 21:31:31 -0500
+
+xz-utils (5.1.1alpha+20110809-2) unstable; urgency=low
+
+ * debian/rules build-arch: Do not trigger an infinite "make"
+ recursion loop when DEB_BUILD_OPTIONS=nocheck. Closes: #638071.
+ Thanks to Thorsten Glaser.
+
+ -- Jonathan Nieder <jrnieder@gmail.com> Tue, 16 Aug 2011 18:11:47 -0500
+
+xz-utils (5.1.1alpha+20110809-1) unstable; urgency=low
+
+ * New snapshot, taken from upstream commit 5c5b225.
+ - liblzma:
+ - lzma_stream_encoder() leaked memory.
+ - The LZMA2 decoder rejected streams that decompress to a
+ zero-length string.
+ - lzma_easy_buffer_encode() and lzma_stream_buffer_encode()
+ used to write such streams when asked to compress a 0-length
+ buffer.
+ - lzma_index_init() would segfault on allocation failure.
+ - liblzma: Various functions check their arguments (especially
+ choice of integrity check) better, making it harder to create
+ a corrupt .xz file instead of receiving an error.
+ - xz and scripts:
+ - "xz -v -v --list" would read and try to free() uninitialized
+ memory, continuing past the end of an on-stack array, when
+ asked to describe certain corrupted XZ files.
+ - xz -S.suf now refuses to compress a file whose name already
+ ends with the suffix “.suf”.
+ - xz --force can be used to compress setuid, setgid, sticky,
+ and multiply linked files.
+ - xz uses posix_fadvise() to speed up sequential input.
+ - xz --block-size forces a full flush periodically during
+ compression, for better random-access reading support and to
+ make simple parallelism possible in the future.
+ - unxz: The new --single-stream option discards trailing
+ garbage after the end of the first stream.
+ - xzdiff can read gzip- and bzip2-compressed files.
+ - xzdiff and xzgrep can read lzop-compressed files.
+ - xzegrep and xzfgrep perform extended regex and fixed-string
+ matches, respectively. (The previous behavior was to always
+ use basic regexes.)
+ - xzgrep -l (= --files-with-match) works.
+ - The Czech “xz --help” output uses a more correct term for
+ files with holes. Thanks to Petr Hubený. Closes: #605762.
+ - xz: New Polish and French translations.
+ - The Doxygen-generated documentation uses short, relative paths
+ to name source files. Closes: #572273.
+ * Update copyright file.
+ * Remove example programs from debian/examples. They are included
+ in the upstream source package now.
+ * Move liblzma to an architecture-specific directory, so the
+ native library and foreign-architecture versions can be installed
+ simultaneously.
+ - liblzma2: Pre-Depends: multiarch-support.
+ - Use debhelper compatibility level 9. This requires passing
+ the dh sequence name before other options when invoking dh in
+ debian/rules. Build-Depends: debhelper (>= 8.1.3).
+ - liblzma2, liblzma-dev: Install files under /usr/lib/<triplet>
+ instead of /usr/lib.
+ - Thanks to Steve Langasek for explaining the process on the
+ Debian wiki.
+ * Standards-Version: 3.9.2 (checked).
+ * debian/control: liblzma2 is Multi-Arch: same, while xz-utils
+ and xzdec are Multi-Arch: foreign. Closes: #637883. Thanks to
+ Riku Voipio.
+ * debian/symbols: Bump the minimal version for LZMA2 encoder
+ functions that reject more bad arguments and skip empty blocks.
+ * debian/rules: ./configure --disable-symbol-versions for now.
+ * debian/rules: Provide build-arch and build-indep targets that
+ only build the code and the API documentation, respectively.
+ Thanks to Roger Leigh for suggesting it through lintian.
+ Build-Depends: debhelper (>= 8.9.0).
+ * debian/rules: Treat DEB_BUILD_OPTIONS=nocheck as a request not to
+ run build-time tests. Thanks to Thorsten Glaser for a reminder.
+ Closes: #627209.
+
+ -- Jonathan Nieder <jrnieder@gmail.com> Tue, 16 Aug 2011 00:40:31 -0500
+
+xz-utils (5.0.0-2) unstable; urgency=low
+
+ * Upload to unstable.
+ * liblzma2, liblzma-dev, xz-lzma: Install release notes.
+ * debian/symbols: Bump the minimal versions for lzma_index_encoder,
+ lzma_index_decoder to the version in which they gained LZMA_FINISH
+ support.
+ * xz-utils/README.Debian: Document differences from upstream ABI.
+ * debian/changelog.upstream.sh: Avoid empty changelog entries when
+ multiple Debian revisions match an upstream tag.
+
+ -- Jonathan Nieder <jrnieder@gmail.com> Thu, 11 Nov 2010 13:45:20 -0600
+
+xz-utils (5.0.0-1) experimental; urgency=low
+
+ * Upload to experimental.
+ * New stable upstream release. Closes: #592298.
+ - xz avoids SA_RESTART. This should not have a visible effect
+ because xz already blocked signals during operations that
+ would be difficult to resume after interruption.
+ - liblzma: The coders returned by lzma_index_encoder() and
+ lzma_index_decoder() support an LZMA_FINISH action, with
+ identical semantics to LZMA_RUN.
+ - The printable (PDF and PS) versions of the manual are easier
+ to read.
+ - Many documentation and build system cleanups.
+ * liblzma: Back out upstream ABI tweaks.
+ * liblzma/README.Debian: Document ABI differences from upstream.
+ * Copy sample code not included in the release tarball from
+ the development upstream repository to debian/examples.
+ * debian/rules clean: Remove some files not included in the
+ release tarball.
+ * copyright: List new INSTALL.generic license.
+ * debian/rules clean: Take new build-aux scripts into account.
+ * debian/rules: Adapt for upstream build system changes.
+ Closes: #540443.
+ * xz-utils, xzdec: Install release notes.
+
+ -- Jonathan Nieder <jrnieder@gmail.com> Mon, 25 Oct 2010 05:45:18 -0500
+
+xz-utils (4.999.9beta+20100927-1) experimental; urgency=low
+
+ * New snapshot, taken from upstream commit cec0ddc.
+ - liblzma: The meaning of --extreme has been tweaked to address
+ cases in which it made the compression ratio worse. Some files
+ might benefit slightly less from --extreme.
+ - xz: Table columns are not misaligned any more in messages with
+ multi-byte characters (e.g., file sizes with LANG=fi_FI.UTF-8).
+ - xz: New German and Italian translations.
+ - Various documentation, message, and translation updates.
+ * Update copyright file.
+ * debian/rules get-orig-source: Update upstream Git URL.
+ * xz-utils/README.Debian: Advertise XZ_DEFAULTS.
+
+ -- Jonathan Nieder <jrnieder@gmail.com> Mon, 27 Sep 2010 16:22:22 -0500
+
+xz-utils (4.999.9beta+20100903-1) experimental; urgency=low
+
+ * New snapshot, taken from upstream commit 373ee26.
+ - liblzma: The settings for compression levels 0 through 5
+ (used by xz -0/.../-5) have been tweaked. This affects the
+ speed, compression ratio, and memory usage at compression and
+ decompression time.
+ - Does not search so hard for a match when a low "nice match
+ length" setting is specified without a depth.
+ - xz: The -1/.../-9 preset options override any previously
+ specified filters, rather than vice versa. To mix presets
+ with filter options, use the --lzma2=preset=n option.
+ - xz: Warns about --memlimit-compress settings that result in
+ compression settings changing even if no explicit -1/.../-9,
+ --lzma1, or --lzma2 option was used.
+ - "xz -v -v --compress" now prints an estimate of the memory
+ required to decompress a file.
+ * debian/copyright: Update upstream Git URL.
+ * debian/changelog.upstream.sh: Permit terser changelog lines.
+ * Standards-Version: 3.9.1 (checked).
+
+ -- Jonathan Nieder <jrnieder@gmail.com> Fri, 03 Sep 2010 17:05:20 -0500
+
+xz-utils (4.999.9beta+20100810-1) unstable; urgency=low
+
+ * New upstream snapshot, taken from upstream commit d5653ba8a.
+ - xz: The memory usage limiter is now disabled by default.
+ - xz: Support for an XZ_DEFAULTS environment variable was added.
+ It contains user-specific default settings, such as memory usage
+ limits, and can be overridden by the command line and XZ_OPT.
+ - xz: The new --memlimit-compress and --memlimit-decompress
+ options allow the memory usage limit to be set separately for
+ compression and decompression. A new --memlimit alias has been
+ added for the existing --memory option.
+ - xz: The --info-memory option (with or without --robot) now prints
+ how much RAM is installed in addition to the compression and
+ decompression memory limits.
+ * liblzma-doc: Simplify package description.
+ * debian/control: Build-Depends: autopoint | gettext (<< 0.18-1),
+ autopoint | cvs instead of autopoint, to help with backporting.
+ Thanks to Thorsten Glaser for a report.
+
+ -- Jonathan Nieder <jrnieder@gmail.com> Tue, 10 Aug 2010 20:27:14 -0500
+
+xz-utils (4.999.9beta+20100713-1) unstable; urgency=low
+
+ [ Thorsten Glaser ]
+ * Explicitly depend on autoconf (>= 2.64~) due to AC_PREREQ,
+ discovered during backporting.
+
+ [ Jonathan Nieder ]
+ * Upload to unstable.
+ * New upstream snapshot, taken from upstream commit a540198f.
+ - xz: The new --no-adjust option can be used to error out if there
+ is insufficient memory for the chosen compression level.
+ * liblzma-dev: Install examples to /usr/share/doc/liblzma-dev.
+ * Update copyright file.
+
+ * Drop unpack-time conflicts in favor of configuration-time
+ conflicts (Replaces + Breaks):
+ - xz-utils: against old xz-lzma (for lzmainfo).
+ - xzdec: against old xz-lzma (for lzmadec).
+ - xz-lzma: against lzip 1.7 (for lzdiff and lzgrep).
+ * Standards-Version: 3.9.0.
+
+ * debian/autogen.sh: Don’t regenerate upstream changelog when it is
+ not out of date.
+ * debian/rules get-orig-source: Use gzip --no-name --rsyncable.
+
+ -- Jonathan Nieder <jrnieder@gmail.com> Thu, 15 Jul 2010 01:53:37 -0500
+
+xz-utils (4.999.9beta+20100602-1) experimental; urgency=low
+
+ * New upstream snapshot, taken from upstream commit d8b41eed.
+ - The output from "xz -v --list" and "xz -v -v --list" has been
+ improved.
+ "xz -v -v --list" can be used to obtain an estimate for the memory
+ required to decompress a file.
+ - The xz manual page has some new material, including examples.
+ Closes: #578465.
+ - liblzma: The lzma_block_compressed_size() function no longer
+ returns LZMA_DATA_ERROR for valid Blocks.
+ * debian/symbols: Bump minimal version for lzma_block_compressed_size.
+ * Correct the 4.999.9beta+20100307-1 changelog entry to describe
+ which public functions were affected.
+
+ * Add new xz-lzma package to allow xz to provide lzma and related
+ commands. Conflicts: and Provides: lzma.
+ * xz-utils: Suggests: xz-lzma.
+ * xz-utils/README.Debian: Take xz-lzma into account.
+
+ -- Jonathan Nieder <jrnieder@gmail.com> Fri, 04 Jun 2010 15:53:58 -0500
+
+xz-utils (4.999.9beta+20100527-1) unstable; urgency=low
+
+ * New upstream snapshot, taken from upstream commit a334348dc.
+ - Show both elapsed time and estimated remaining time in xz -v.
+ Thanks to Trent W. Buck for the idea. Closes: #574583.
+ - liblzma: Remove the Subblock filter from the public API
+ (the ABI is unchanged).
+ * liblzma-dev.NEWS: Update.
+ * xz-utils: Update Czech translation.
+ * Change priority of xz-utils and liblzma2 to required and
+ xzdec to extra.
+
+ -- Jonathan Nieder <jrnieder@gmail.com> Thu, 27 May 2010 16:27:04 -0500
+
+xz-utils (4.999.9beta+20100307-1) unstable; urgency=low
+
+ * New upstream snapshot, taken from upstream commit f4b2b526.
+ - liblzma: The stream initialization functions were not correctly
+ initializing the internal allow_buffer_error flag. As a result,
+ ever since 4.999.9beta-1 in rare circumstances when decompressing
+ LZMA files, the xz tool would produce spurious "Unexpected end
+ of input" failures (Gentoo bug 305591).
+ - The default memory usage limit on low-memory systems has been
+ increased.
+ * debian/copyright: Clarify.
+
+ -- Jonathan Nieder <jrnieder@gmail.com> Tue, 09 Mar 2010 10:22:24 -0600
+
+xz-utils (4.999.9beta+20100212-4) unstable; urgency=low
+
+ * debian/control: Build-Depends: autopoint instead of cvs.
+ Closes: #572481.
+ * debian/copyright: Clean up and include more details.
+ * debian/rules get-orig-source: Unindent comment lines.
+ * xz-utils: include Czech translation.
+
+ -- Jonathan Nieder <jrnieder@gmail.com> Thu, 04 Mar 2010 10:17:15 -0600
+
+xz-utils (4.999.9beta+20100212-3) unstable; urgency=low
+
+ * liblzma-dev: Remove unneeded .la file.
+ * xz-utils: Dynamically link the xz binary.
+ * Do not waste time installing and running doxygen on buildds that
+ are not going to build arch-all packages.
+ Build-Depends-Indep: doxygen. Closes: #540444.
+
+ -- Jonathan Nieder <jrnieder@gmail.com> Tue, 23 Feb 2010 18:23:29 -0600
+
+xz-utils (4.999.9beta+20100212-2) unstable; urgency=low
+
+ * Split off xzdec and lzmadec commands into new xzdec package.
+ Thanks to Guillem Jover for the idea. Closes: #571060.
+ * xz-utils.NEWS: advertise this change.
+
+ -- Jonathan Nieder <jrnieder@gmail.com> Tue, 23 Feb 2010 08:09:39 -0600
+
+xz-utils (4.999.9beta+20100212-1) unstable; urgency=low
+
+ * New upstream snapshot, taken from upstream commit eb7d51a3f.
+ - xz --force compresses symlinks without complaint now.
+ - liblzma: the optimized CRC32 implementation for x86 no longer
+ misdetects the Hurd as Mac OS X.
+ * debian/rules: ./configure --enable-assembler on the Hurd.
+ * xz-utils: Simplify NEWS.Debian.gz.
+ * liblzma-dev: Add a NEWS file to keep track of future API changes.
+
+ * Drop unnecessary build-time conflict with autoconf2.13.
+ * Add a blank line to the end of all NEWS files.
+ (Works around: #247356)
+ * debian/README.source: Leave out “-I -i” options. Ignoring version
+ control cruft is the default behavior with dpkg source format 3.0.
+ * debian/changelog.upstream.sh: Pass ‘git log’ an explicit --format
+ option to avoid problems if format.pretty is set in gitconfig.
+
+ * Correct the 4.999.9beta+20100117-1 changelog entry. It said:
+ + The user-specified memory usage limit was not being honored in
+ some cases.
+ No such bug was observed, so describe the change instead.
+
+ -- Jonathan Nieder <jrnieder@gmail.com> Tue, 16 Feb 2010 00:30:24 -0600
+
+xz-utils (4.999.9beta+20100131-1) unstable; urgency=low
+
+ * New upstream snapshot, taken from upstream commit f9dd797a.
+ + xz: the --list option to display information about a compressed
+ file (e.g., its uncompressed size) is now functional. The output
+ of the xz --robot --list command still may change in future
+ versions.
+ * xz-utils: NEWS.Debian.gz: Clarify how interleaved output can
+ go wrong.
+ * debian/rules: Simplify:
+ - remove support for comma as a delimiter for $(DEB_BUILD_OPTIONS).
+ - rely on dh --parallel instead of tricky logic of our own to
+ handle parallel builds. Build-Depends: debhelper (>= 7.4.10).
+ * Correct some typos in the 4.999.9beta+20100117-1 changelog entry.
+ * Standards-Version: 3.8.4 (checked).
+ * Update copyright file.
+
+ -- Jonathan Nieder <jrnieder@gmail.com> Sun, 31 Jan 2010 17:32:02 -0600
+
+xz-utils (4.999.9beta+20100117-1) unstable; urgency=low
+
+ * New upstream snapshot, taken from upstream commit 07a11dad.
+ + Fix some logic errors in the internal memory usage configuration
+ API.
+ + xz will no longer compress or decompress special files in place,
+ even with --force.
+ --force still enables compression of the target of a symlink.
+ + xz will no longer read compressed data from a terminal or write
+ it to a terminal, even with --force.
+ + liblzma: many Index handling API improvements:
+ - An lzma_index includes more useful metadata that is not
+ actually from the Index. This is particularly helpful for
+ describing multiple-stream files.
+ * lzma_index_cat() does not take a stream padding argument
+ any more; use lzma_index_stream_padding() instead.
+ * lzma_index_memusage() takes two arguments now.
+ The new lzma_index_memused() convenience function
+ calculates the total memory usage of an lzma_index.
+ * lzma_index_count() has been replaced with
+ lzma_index_block_count() and lzma_index_stream_count().
+ * The new lzma_index_stream_flags() allows storing Stream
+ Flags (e.g., checksum types) with the Index information.
+ * The new lzma_index_checks() function indicates the list of
+ checksum types in use.
+ * lzma_index_equal() has been removed. Its semantics were
+ unclear, and something approximately equivalent can be
+ implemented by iterating over Blocks in application code.
+ - An lzma_index no longer represents a position within an Index.
+ The new lzma_index_iter type can be used for that purpose.
+ * Certain functions generate an iterator on demand now rather
+ than clobbering their lzma_index arguments. Using a single
+ lzma_index for multiple concurrent invocations is safe now:
+ lzma_index_buffer_encode(), lzma_index_encoder()
+ * Functions that used to specify a Record by modifying an
+ lzma_index argument have been renamed and taught to write
+ an lzma_index_iter instead:
+ lzma_index_locate() -> lzma_index_iter_locate()
+ lzma_index_rewind() -> lzma_index_iter_rewind()
+ lzma_index_read() -> lzma_index_iter_next()
+ * The lzma_index_record type used by lzma_index_read() for
+ complex seeks is no more. lzma_index_iter_next() instead
+ takes a parameter of the new lzma_index_iter_mode type.
+ * New function: lzma_index_iter_init()
+ * lzma_index_init() cannot reuse memory from an existing
+ lzma_index any more. The signature changed accordingly.
+ + xz: support for decompressing to a sparse file
+ - Try to write a sparse file if the decompressed stream contains
+ long runs of null bytes.
+ - The new --no-sparse option disables this behavior.
+ + xz: add Czech translation.
+ + liblzma-dev: lzma_filters_copy() and lzma_filters_update() are
+ declared not to throw exceptions.
+ * liblzma: bump soname.
+ * xz-utils: Add NEWS.Debian describing the sparse file support.
+ * debian/rules: Stop explicitly disabling assembler optimizations on
+ the Hurd. The configure script will check if a platform is
+ supported.
+
+ * debian/rules: Update clean target to handle comments and wildcards
+ in .gitignore.
+ * Build-Depends: perl.
+
+ * debian/rules: Speed up build by using autoreconf --symlink.
+ * Remove debian/dirs lists.
+ * Update copyright file and fix a small typo.
+
+ -- Jonathan Nieder <jrnieder@gmail.com> Mon, 18 Jan 2010 04:19:50 -0600
+
+xz-utils (4.999.9beta+20091116-1) unstable; urgency=low
+
+ * New upstream snapshot, taken from upstream commit d315ca4.
+ + liblzma: add some new functions:
+ - lzma_filters_copy() to copy a filter chain;
+ - lzma_filters_update() to change compression options mid-stream;
+ - lzma_physmem() to retrieve the total quantity of installed RAM.
+ + Fix a design error in liblzma API.
+ - Stop requiring caller to maintain filter chain during
+ compression. The library used to read it for new compression
+ options. Callers that need to change options mid-stream should
+ use lzma_filters_update() instead.
+ - Remove 'persistent' member from struct lzma_options_lzma.
+ + xz: add --robot --info-memory options, for front-ends to use to
+ read the memory usage limit.
+ * liblzma: bump soname; add README.Debian explaining why soname
+ differs from upstream.
+ * Use source format 3.0 (quilt).
+ * Update and clarify copyright file.
+
+ -- Jonathan Nieder <jrnieder@gmail.com> Mon, 16 Nov 2009 16:33:35 -0600
+
+xz-utils (4.999.9beta+20091016-1) unstable; urgency=low
+
+ * New upstream snapshot, taken from upstream commit 78e92c1.
+ * Drop xzmore.1 patch, applied upstream.
+ * debian/rules: Disable assembler optimizations on hurd. (Closes: #553331)
+ * debian/control: Clarify binary package descriptions. Thanks to
+ Justin B Rye and Ben Finney for the text.
+ * debian/rules get-orig-source: Use commit date (instead of last patch
+ date) to name snapshots.
+
+ -- Jonathan Nieder <jrnieder@gmail.com> Sun, 01 Nov 2009 00:22:04 -0500
+
+xz-utils (4.999.9beta+20091004-1) unstable; urgency=low
+
+ * Upload to unstable. (Closes: #543562)
+ * New upstream snapshot, taken from upstream commit ebfb2c5.
+ * Patch xzmore.1 to use dashes instead of minus signs.
+ * debian/control: Conflicts: xz-lzma. (Closes: #550249)
+ * liblzma-doc: Register Doxygen-generated docs with doc-base.
+ * debian/changelog.upstream.sh: Declare local variables.
+ * debian/changelog.upstream.sh: Cope with multiple Debian revisions per
+ upstream version.
+ * debian/rules: Use ":=" where appropriate.
+ * Add watch file.
+
+ -- Jonathan Nieder <jrnieder@gmail.com> Fri, 16 Oct 2009 13:58:54 -0500
+
+xz-utils (4.999.9beta+20091002-1) experimental; urgency=low
+
+ * New upstream snapshot, taken from upstream commit 29fd321.
+ * debian/control: Build-Depends: cvs (for autopoint).
+
+ -- Jonathan Nieder <jrnieder@gmail.com> Sun, 04 Oct 2009 00:21:08 -0500
+
+xz-utils (4.999.9beta-1) experimental; urgency=low
+
+ [ Jonathan Nieder ]
+ * New upstream release.
+ - Fix a data corruption in the compression code. (Closes: #544872)
+ - xzdiff: Fix comparing two compressed files. (Closes: #540543)
+ - Most of XZ Utils is now in the public domain. (Closes: #541391)
+ - Add doc/history.txt to the distributed tarball. (Closes: #541540)
+ * Update and clarify copyright file.
+ * Drop lzma compatibility commands for now. (Closes: #542060, #540232)
+ Add instructions to README.Debian for installing them locally.
+ * debian/control: Add information about the packaging Git repository.
+ * debian/control: Clarify package descriptions.
+ * debian/README.source: Clarify build instructions.
+ * Add debian/.gitignore listing build products.
+ * Build xz-utils with static liblzma.
+ - debian/rules: Use configure --enable-dynamic=mixed.
+ * Optimize xzdec for size, following suggestion in PACKAGERS.
+ - debian/rules: Build xzdec separately so it can be optimized for size.
+ - debian/control: Build-Depends: debhelper (>= 7.3.0).
+ * Generate upstream changelog instead of shipping placeholder.
+ - debian/README.source: Add instructions for regenerating upstream
+ changelog file.
+ - debian/changelog.upstream.sh: New script.
+ - debian/rules: Install generated changelog file.
+ * liblzma-doc: Drop documentation already shipped in
+ /usr/share/doc/xz-utils.
+ * liblzma-dev, liblzma-doc: Add short README.Debian with pointers to
+ development documentation.
+ * Drop debian/xzdec.1, since upstream ships a better man page.
+ * Run autotools at build time.
+ + debian/control:
+ - Build-Depends: autoconf, automake, libtool, gettext
+ - Build-Conflicts: autoconf2.13, automake1.4
+ + debian/rules:
+ - configure: autoreconf -fi
+ - clean: remove autotools-generated files to avoid .diff.gz
+ changes when built twice in a row.
+ * debian/rules: Add get-orig-source target.
+ * Prepare for upload to experimental.
+
+ [ Cristian Greco ]
+ * debian/copyright: refer to versioned GPL-3 file.
+ * debian/control: remove duplicate field ‘section’ in package xz-utils.
+
+ -- Jonathan Nieder <jrnieder@gmail.com> Wed, 30 Sep 2009 01:44:04 -0500
+
+xz-utils (4.999.8beta-1) experimental; urgency=low
+
+ [ Jonathan Nieder ]
+ * Initial package for Debian. (Closes: #518803)
+ + debian/rules:
+ - add minimal rules file (using Debhelper 7), a control file
+ describing the binary packages, and an appropriate compat file.
+ - use configure --enable-dynamic; use up-to-date config.guess and
+ config.sub files.
+ - do not run automake and so on on autobuilders. Instead, we can
+ run them ourselves when we build the source package.
+ + debian/README.source:
+ - add informations about the packaging GIT repository.
+ * Add liblzma-doc package with Doxygen-generated API docs.
+
+ [ Mohammed Adnène Trojette ]
+ * Prepare for upload to experimental.
+
+ -- Mohammed Adnène Trojette <adn+deb@diwi.org> Sat, 27 Jun 2009 17:26:56 +0200
diff --git a/debian/changelog.upstream.sh b/debian/changelog.upstream.sh
new file mode 100644
index 0000000..afaec0f
--- /dev/null
+++ b/debian/changelog.upstream.sh
@@ -0,0 +1,133 @@
+#!/bin/sh
+# Generate debian/changelog.upstream from debian/changelog and
+# the git revision log. Inspired by Gerrit Pape’s
+# debian/changelog.upstream.sh, from the git-core Debian package.
+
+set -e
+
+# If argument matches /^Version: /, output remaining text.
+# Result is true if and only if argument matches.
+version_line() {
+ local line result
+ line=$1
+ result=${line#Version: }
+
+ if test "$result" = "$line"
+ then
+ return 1
+ else
+ printf "%s\n" "$result"
+ return 0
+ fi
+}
+
+# If argument matches /^\* New.*snapshot.*commit /,
+# output remaining text.
+# Result is true if and only if argument matches.
+commit_id_line() {
+ local line result
+ line=$1
+ result=${line#\* New*snapshot*commit }
+
+ if test "$result" = "$line"
+ then
+ return 1
+ else
+ printf "%s\n" "$result"
+ return 0
+ fi
+}
+
+# Read standard input, scanning for a changelog entry of the
+# form “New snapshot, taken from upstream commit <blah>.”
+# Output is <blah>.
+# Fails and writes a message to standard error if no such entry is
+# found before the next Version: line with a different upstream
+# version (or EOF).
+# $1 is the upstream version sought.
+read_commit_id() {
+ local upstream_version line version cid
+ upstream_version=$1
+
+ while read line
+ do
+ if
+ version=$(version_line "$line") &&
+ test "${version%-*}" != "$upstream_version"
+ then
+ break
+ fi
+
+ if cid=$(commit_id_line "$line")
+ then
+ printf "%s\n" "${cid%.}"
+ return 0
+ fi
+ done
+
+ echo >&2 "No commit id for $upstream_version"
+ return 1
+}
+
+last=none
+last_cid=none
+# Add a list of all revisions up to $last to debian/changelog.upstream
+# and set last=$2.
+# $1 is a user-readable name for the commit $2
+add_version() {
+ local new new_cid limiter
+ new=$1
+ new_cid=$2
+
+ if test "$last" = none
+ then
+ : > debian/changelog.upstream
+ last=$new
+ last_cid=$new_cid
+ return 0
+ fi
+
+ exec >> debian/changelog.upstream
+ if test "$new" = none
+ then
+ echo "Version $last:"
+ echo "Version $last:" | tr "[:print:]" -
+ limiter=
+ elif test "$new" = "$last"
+ then
+ return 0
+ else
+ echo "Version $last; changes since $new:"
+ echo "Version $last; changes since $new:" | tr "[:print:]" -
+ limiter="$new_cid.."
+ fi
+ echo
+ git rev-list --no-merges "$limiter$last_cid" |
+ git diff-tree --date=iso --stat --format=medium --stdin
+ test "$new" = none || echo
+
+ last=$new
+ last_cid=$new_cid
+}
+
+dpkg-parsechangelog --format rfc822 --all | {
+while read line
+do
+ if version=$(version_line "$line")
+ then
+ # strip Debian revision
+ upstream_version=${version%-*}
+
+ if git rev-parse --verify -q "v$upstream_version" > /dev/null
+ then
+ # upstream release
+ add_version "$upstream_version" "v$upstream_version"
+ else
+ # snapshot
+ cid=$(read_commit_id "$upstream_version") || exit 1
+ add_version "$upstream_version" "$cid"
+ fi
+ fi
+done
+add_version none none
+}
diff --git a/debian/clean.sh b/debian/clean.sh
new file mode 100644
index 0000000..1a2f8b3
--- /dev/null
+++ b/debian/clean.sh
@@ -0,0 +1,46 @@
+#!/bin/sh
+# Remove files generated by autoreconf -fi.
+# For use by the clean target in debian/rules.
+
+set -e
+
+remove_files='#!/usr/bin/perl
+# Remove specified files from the current directory.
+# Each line must be a filename, a comment (starting with #),
+# a simple glob (of the form *.extension), or blank.
+# Filenames are restricted to a small character set.
+
+use strict;
+use warnings;
+
+my $fnchar = qr/[-_~.@[:alnum:]]/;
+
+my $empty = qr/^$/;
+my $comment = qr/^#/;
+my $simple = qr/^$fnchar+$/;
+my $glob = qr/^\*$fnchar+$/;
+while (my $line = <>) {
+ chomp $line;
+ next if $line =~ $empty;
+ next if $line =~ $comment;
+
+ if ($line =~ $simple) {
+ unlink $line;
+ next;
+ }
+ if ($line =~ $glob) {
+ unlink glob($line);
+ next;
+ }
+
+ die "cannot parse $line";
+}
+'
+
+dh_testdir
+rm -f debug/translation.bash tests/test_block.c ChangeLog
+rm -f ABOUT-NLS aclocal.m4 config.h.in configure
+(cd po && perl -e "$remove_files") < debian/generated-po.list
+(cd m4 && perl -e "$remove_files") < debian/generated-m4.list
+(cd build-aux && perl -e "$remove_files") < debian/generated-build-aux.list
+find . -name Makefile.in -delete
diff --git a/debian/compat b/debian/compat
new file mode 100644
index 0000000..ec63514
--- /dev/null
+++ b/debian/compat
@@ -0,0 +1 @@
+9
diff --git a/debian/control b/debian/control
new file mode 100644
index 0000000..986f0c1
--- /dev/null
+++ b/debian/control
@@ -0,0 +1,114 @@
+Source: xz-utils
+Section: utils
+Priority: required
+Maintainer: Jonathan Nieder <jrnieder@gmail.com>
+Uploaders: Mohammed Adnène Trojette <adn+deb@diwi.org>
+Build-Depends: debhelper (>= 8.9.0), perl, dpkg-dev (>= 1.16.2),
+ autoconf (>= 2.64~), automake, libtool (>= 2.2),
+ gettext, autopoint | gettext (<< 0.18-1), autopoint | cvs
+Build-Depends-Indep: doxygen
+Build-Conflicts: automake1.4
+Standards-Version: 3.9.3
+Vcs-Browser: http://git.debian.org/?p=collab-maint/xz.git
+Vcs-Git: git://git.debian.org/collab-maint/xz.git
+Homepage: http://tukaani.org/xz/
+
+Package: liblzma5
+Section: libs
+Architecture: any
+Depends: ${shlibs:Depends}, ${misc:Depends}
+Pre-Depends: ${misc:Pre-Depends}
+Multi-Arch: same
+Description: XZ-format compression library
+ XZ is the successor to the Lempel-Ziv/Markov-chain Algorithm
+ compression format, which provides memory-hungry but powerful
+ compression (often better than bzip2) and fast, easy decompression.
+ .
+ The native format of liblzma is XZ; it also supports raw (headerless)
+ streams and the older LZMA format used by lzma. (For 7-Zip's related
+ format, use the p7zip package instead.)
+
+Package: xz-utils
+Architecture: any
+Depends: ${shlibs:Depends}, ${misc:Depends}
+Multi-Arch: foreign
+Conflicts: lzma (<< 9.22-1), xz-lzma
+Breaks: lzip (<< 1.8~rc2)
+Replaces: lzip (<< 1.8~rc2), xz-lzma
+Provides: lzma
+Description: XZ-format compression utilities
+ XZ is the successor to the Lempel-Ziv/Markov-chain Algorithm
+ compression format, which provides memory-hungry but powerful
+ compression (often better than bzip2) and fast, easy decompression.
+ .
+ This package provides the command line tools for working with XZ
+ compression, including xz, unxz, xzcat, xzgrep, and so on. They can
+ also handle the older LZMA format, and if invoked via appropriate
+ symlinks will emulate the behavior of the commands in the lzma
+ package.
+ .
+ The XZ format is similar to the older LZMA format but includes some
+ improvements for general use:
+ .
+ * 'file' magic for detecting XZ files;
+ * crc64 data integrity check;
+ * limited random-access reading support;
+ * improved support for multithreading (not used in xz-utils);
+ * support for flushing the encoder.
+
+Package: xzdec
+Priority: extra
+Architecture: any
+Depends: ${shlibs:Depends}, ${misc:Depends}
+Multi-Arch: foreign
+Suggests: xz-utils
+Breaks: xz-lzma (<< 4.999.9beta+20091004-1)
+Replaces: xz-lzma (<< 4.999.9beta+20091004-1)
+Description: XZ-format compression utilities - tiny decompressors
+ XZ is the successor to the Lempel-Ziv/Markov-chain Algorithm
+ compression format, which provides memory-hungry but powerful
+ compression (often better than bzip2) and fast, easy decompression.
+ .
+ This package provides the xzdec and lzmadec utilities, which write
+ the decompressed version of a compressed file to standard output. The
+ binaries are very small, so they can be easily stored on small media
+ with some compressed files, and they are linked statically against
+ liblzma so they can be used on machines without a compatible version
+ of liblzma installed. However, they have:
+ .
+ * no compression support;
+ * no support for writing to a file other than standard output;
+ * no translated messages;
+ * been optimized for size rather than speed.
+ .
+ For a full-featured xzcat command without these limitations, use
+ the xz-utils package instead.
+
+Package: liblzma-dev
+Section: libdevel
+Priority: optional
+Multi-Arch: same
+Architecture: any
+Depends: liblzma5 (= ${binary:Version}), ${misc:Depends}
+Suggests: liblzma-doc
+Description: XZ-format compression library - development files
+ XZ is the successor to the Lempel-Ziv/Markov-chain Algorithm
+ compression format, which provides memory-hungry but powerful
+ compression (often better than bzip2) and fast, easy decompression.
+ .
+ The native format of liblzma is XZ; it also supports raw (headerless)
+ streams and the older LZMA format used by lzma. (For 7-Zip's related
+ format, use the p7zip package instead.) This package provides the
+ development library needed to build programs using liblzma.
+
+Package: liblzma-doc
+Section: doc
+Priority: optional
+Architecture: all
+Depends: ${misc:Depends}
+Suggests: liblzma-dev
+Description: XZ-format compression library - API documentation
+ This package contains a reference manual for the liblzma data
+ compression library, in Doxygen-generated HTML files. The purpose
+ of each struct, macro, and function in the public interface is
+ explained.
diff --git a/debian/copyright b/debian/copyright
new file mode 100644
index 0000000..3327901
--- /dev/null
+++ b/debian/copyright
@@ -0,0 +1,383 @@
+Format: http://www.debian.org/doc/packaging-manuals/copyright-format/1.0/
+Upstream-Name: XZ Utils
+Upstream-Contact:
+ Lasse Collin <lasse.collin@tukaani.org>
+ http://tukaani.org/xz/lists.html
+Source:
+ http://tukaani.org/xz
+ http://git.tukaani.org/xz.git
+Comment:
+ XZ Utils is developed and maintained upstream by Lasse Collin. Major
+ portions are based on code by other authors; see AUTHORS for details.
+ Most of the source has been put into the public domain, but some files
+ have not (details below).
+ .
+ This file describes the source package. The binary packages contain
+ some files derived from other works: for example, images in the API
+ documentation come from Doxygen.
+License:
+ Different licenses apply to different files in this package. Here
+ is a rough summary of which licenses apply to which parts of this
+ package (but check the individual files to be sure!):
+ .
+ - liblzma is in the public domain.
+ .
+ - xz, xzdec, and lzmadec command line tools are in the public
+ domain unless GNU getopt_long had to be compiled and linked
+ in from the lib directory. The getopt_long code is under
+ GNU LGPLv2.1+.
+ .
+ - The scripts to grep, diff, and view compressed files have been
+ adapted from gzip. These scripts and their documentation are
+ under GNU GPLv2+.
+ .
+ - All the documentation in the doc directory and most of the
+ XZ Utils specific documentation files in other directories
+ are in the public domain.
+ .
+ - Translated messages are in the public domain.
+ .
+ - The build system contains public domain files, and files that
+ are under GNU GPLv2+ or GNU GPLv3+. None of these files end up
+ in the binaries being built.
+ .
+ - Test files and test code in the tests directory, and debugging
+ utilities in the debug directory are in the public domain.
+ .
+ - The extra directory may contain public domain files, and files
+ that are under various free software licenses.
+ .
+ You can do whatever you want with the files that have been put into
+ the public domain. If you find public domain legally problematic,
+ take the previous sentence as a license grant. If you still find
+ the lack of copyright legally problematic, you have too many
+ lawyers.
+ .
+ As usual, this software is provided "as is", without any warranty.
+ .
+ If you copy significant amounts of public domain code from XZ Utils
+ into your project, acknowledging this somewhere in your software is
+ polite (especially if it is proprietary, non-free software), but
+ naturally it is not legally required. Here is an example of a good
+ notice to put into "about box" or into documentation:
+ .
+ This software includes code from XZ Utils <http://tukaani.org/xz/>.
+ .
+ The following license texts are included in the following files:
+ - COPYING.LGPLv2.1: GNU Lesser General Public License version 2.1
+ - COPYING.GPLv2: GNU General Public License version 2
+ - COPYING.GPLv3: GNU General Public License version 3
+ .
+ Note that the toolchain (compiler, linker etc.) may add some code
+ pieces that are copyrighted. Thus, it is possible that e.g. liblzma
+ binary wouldn't actually be in the public domain in its entirety
+ even though it contains no copyrighted code from the XZ Utils source
+ package.
+ .
+ If you have questions, don't hesitate to ask the author(s) for more
+ information.
+
+Files: *
+Copyright: 2006-2012, Lasse Collin
+ 1999-2008, Igor Pavlov
+ 2006, Ville Koskinen
+ 1998, Steve Reid
+ 2000, Wei Dai
+ 2003, Kevin Springle
+ 2009, Jonathan Nieder
+ 2010, Anders F Björklund
+License: PD
+ This file has been put in the public domain.
+ You can do whatever you want with this file.
+Comment:
+ From: Lasse Collin <lasse.collin@tukaani.org>
+ To: Jonathan Nieder <jrnieder@gmail.com>
+ Subject: Re: XZ utils for Debian
+ Date: Sun, 19 Jul 2009 13:28:23 +0300
+ Message-Id: <200907191328.23816.lasse.collin@tukaani.org>
+ .
+ [...]
+ .
+ > AUTHORS, ChangeLog, COPYING, README, THANKS, TODO,
+ > dos/README, windows/README
+ .
+ COPYING says that most docs are in the public domain. Maybe that's not
+ clear enough, but on the other hand it looks a bit stupid to put
+ copyright information in tiny and relatively small docs like README.
+ .
+ I don't dare to say that _all_ XZ Utils specific docs are in the public
+ domain unless otherwise mentioned in the file. I'm including PDF files
+ generated by groff + ps2pdf, and some day I might include Doxygen-
+ generated HTML docs too. Those don't include any copyright notices, but
+ it seems likely that groff + ps2pdf or at least Doxygen put some
+ copyrighted content into the generated files.
+
+Files: INSTALL NEWS PACKAGERS
+ windows/README-Windows.txt
+ windows/INSTALL-Windows.txt
+Copyright: 2009-2010, Lasse Collin
+License: probably-PD
+ See the note on AUTHORS, README, and so on above.
+
+Files: src/scripts/* lib/* extra/scanlzma/scanlzma.c
+Copyright: © 1993, Jean-loup Gailly
+ © 1989-1994, 1996-1999, 2001-2007, Free Software Foundation, Inc.
+ © 2006 Timo Lindfors
+ 2005, Charles Levert
+ 2005, 2009, Lasse Collin
+ 2009, Andrew Dudman
+Other-Authors: Paul Eggert, Ulrich Drepper
+License: GPL-2+
+
+Files: src/scripts/Makefile.am src/scripts/xzless.1
+Copyright: 2009, Andrew Dudman
+ 2009, Lasse Collin
+License: PD
+ This file has been put in the public domain.
+ You can do whatever you want with this file.
+
+Files: doc/examples/xz_pipe_comp.c doc/examples/xz_pipe_decomp.c
+Copyright: 2010, Daniel Mealha Cabrita
+License: PD
+ Not copyrighted -- provided to the public domain.
+
+Files: lib/getopt.c lib/getopt1.c lib/getopt.in.h
+Copyright: © 1987-2007 Free Software Foundation, Inc.
+Other-Authors: Ulrich Drepper
+License: LGPL-2.1+
+
+Files: m4/getopt.m4 m4/posix-shell.m4
+Copyright: © 2002-2006, 2008 Free Software Foundation, Inc.
+ © 2007-2008 Free Software Foundation, Inc.
+Other-Authors: Bruno Haible, Paul Eggert
+License: permissive-fsf
+
+Files: m4/acx_pthread.m4
+Copyright: © 2008, Steven G. Johnson <stevenj@alum.mit.edu>
+License: Autoconf
+
+Files: Doxyfile.in
+Copyright: © 1997-2007 by Dimitri van Heesch
+Origin: Doxygen 1.4.7
+License: GPL-2
+
+Files: src/liblzma/check/crc32_table_?e.h
+ src/liblzma/check/crc64_table_?e.h
+ src/liblzma/lzma/fastpos_table.c
+ src/liblzma/rangecoder/price_table.c
+Copyright: none, automatically generated data
+Generated-With:
+ src/liblzma/check/crc32_tablegen.c
+ src/liblzma/check/crc64_tablegen.c
+ src/liblzma/lzma/fastpos_tablegen.c
+ src/liblzma/rangecoder/price_tablegen.c
+License: none
+ No copyright to license.
+
+Files: .gitignore m4/.gitignore po/.gitignore po/LINGUAS po/POTFILES.in
+Copyright: none; these are just short lists.
+License: none
+ No copyright to license.
+
+Files: tests/compress_prepared_bcj_*
+Copyright: 2008-2009, Lasse Collin
+Source-Code: tests/bcj_test.c
+License: PD
+ This file has been put into the public domain.
+ You can do whatever you want with this file.
+Comment:
+ changelog.gz (commit 975d8fd) explains:
+ .
+ Recreated the BCJ test files for x86 and SPARC. The old files
+ were linked with crt*.o, which are copyrighted, and thus the
+ old test files were not in the public domain as a whole. They
+ are freely distributable though, but it is better to be careful
+ and avoid including any copyrighted pieces in the test files.
+ The new files are just compiled and assembled object files,
+ and thus don't contain any copyrighted code.
+
+Files: po/cs.po po/de.po po/fr.po
+Copyright: 2010, Marek Černocký
+ 2010, Andre Noll
+ 2011, Adrien Nader
+License: PD
+ This file is put in the public domain.
+
+Files: po/it.po po/pl.po
+Copyright: 2009, 2010, Gruppo traduzione italiano di Ubuntu-it
+ 2010, Lorenzo De Liso
+ 2009, 2010, 2011, Milo Casagrande
+ 2011, Jakub Bogusz
+License: PD
+ This file is in the public domain
+
+Files: INSTALL.generic
+Copyright: © 1994, 1995, 1996, 1999, 2000, 2001, 2002, 2004, 2005,
+ 2006, 2007, 2008, 2009, 2010 Free Software Foundation, Inc.
+License: permissive-nowarranty
+
+Files: dos/config.h
+Copyright: © 1992, 1993, 1994, 1999, 2000, 2001, 2002, 2005
+ Free Software Foundation, Inc.
+ 2007-2010, Lasse Collin
+Other-Authors: Roland McGrath, Akim Demaille, Paul Eggert,
+ David Mackenzie, Bruno Haible, and many others.
+Origin: configure.ac from XZ Utils,
+ visibility.m4 serial 1 (gettext-0.15),
+ Autoconf 2.52g
+License: config-h
+ configure.ac:
+ .
+ # Author: Lasse Collin
+ #
+ # This file has been put into the public domain.
+ # You can do whatever you want with this file.
+ .
+ visibility.m4:
+ .
+ dnl Copyright (C) 2005 Free Software Foundation, Inc.
+ dnl This file is free software; the Free Software Foundation
+ dnl gives unlimited permission to copy and/or distribute it,
+ dnl with or without modifications, as long as this notice is preserved.
+ .
+ dnl From Bruno Haible.
+ .
+ comments from Autoconf 2.52g:
+ .
+ # Copyright 1992, 1993, 1994, 1999, 2000, 2001, 2002
+ # Free Software Foundation, Inc.
+ .
+ [...]
+ .
+ # As a special exception, the Free Software Foundation gives unlimited
+ # permission to copy, distribute and modify the configure scripts that
+ # are the output of Autoconf. You need not follow the terms of the GNU
+ # General Public License when using or distributing such scripts, even
+ # though portions of the text of Autoconf appear in them. The GNU
+ # General Public License (GPL) does govern all other use of the material
+ # that constitutes the Autoconf program.
+ .
+ On Debian systems, the complete text of the GNU General Public
+ License version 2 can be found in ‘/usr/share/common-licenses/GPL-2’.
+ dos/config.h was generated with autoheader, which tells Autoconf to
+ output a script to generate a config.h file and then runs it.
+
+Files: po/Makevars
+Origin: gettext-runtime/po/Makevars (gettext-0.12)
+Copyright: © 2003 Free Software Foundation, Inc.
+Authors: Bruno Haible
+License: LGPL-2.1+
+ The gettext-runtime package is under the LGPL, see files intl/COPYING.LIB-2.0
+ and intl/COPYING.LIB-2.1.
+ .
+ On Debian systems, the complete text of intl/COPYING.LIB-2.0 from
+ gettext-runtime 0.12 can be found in ‘/usr/share/common-licenses/LGPL-2’
+ and the text of intl/COPYING.LIB-2.1 can be found in
+ ‘/usr/share/common-licenses/LGPL-2.1’.
+ .
+ po/Makevars consists mostly of helpful comments and does not contain a
+ copyright and license notice.
+
+Files: COPYING.GPLv2 COPYING.GPLv3 COPYING.LGPLv2.1
+Copyright: © 1989, 1991, 1999, 2007 Free Software Foundation, Inc.
+License: noderivs
+ Everyone is permitted to copy and distribute verbatim copies
+ of this license document, but changing it is not allowed.
+
+Files: debian/*
+Copyright: 2009-2012, Jonathan Nieder
+License: PD-debian
+ The Debian packaging files are in the public domain.
+ You may freely use, modify, distribute, and relicense them.
+
+License: LGPL-2.1+
+ This program is free software; you can redistribute it and/or modify
+ it under the terms of the GNU Lesser General Public License as published by
+ the Free Software Foundation; either version 2.1, or (at your option)
+ any later version.
+ .
+ This program is distributed in the hope that it will be useful,
+ but WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ GNU Lesser General Public License for more details.
+ .
+ You should have received a copy of the GNU Lesser General Public License along
+ with this program; if not, write to the Free Software Foundation,
+ Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
+ .
+ On Debian systems, the complete text of the GNU Lesser General Public
+ License version 2.1 can be found in ‘/usr/share/common-licenses/LGPL-2.1’.
+
+License: GPL-2
+ Permission to use, copy, modify, and distribute this software and its
+ documentation under the terms of the GNU General Public License is
+ hereby granted. No representations are made about the suitability of
+ this software for any purpose. It is provided "as is" without express
+ or implied warranty. See the GNU General Public License for more
+ details.
+ .
+ Documents produced by doxygen are derivative works derived from the
+ input used in their production; they are not affected by this license.
+ .
+ On Debian systems, the complete text of the version of the GNU General
+ Public License distributed with Doxygen can be found in
+ ‘/usr/share/common-licenses/GPL-2’.
+
+License: GPL-2+
+ This program is free software; you can redistribute it and/or modify
+ it under the terms of the GNU General Public License as published by
+ the Free Software Foundation; either version 2, or (at your option)
+ any later version.
+ .
+ This program is distributed in the hope that it will be useful,
+ but WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ GNU General Public License for more details.
+ .
+ You should have received a copy of the GNU General Public License along
+ with this program; if not, write to the Free Software Foundation,
+ Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
+ .
+ On Debian systems, the complete text of the GNU General Public License
+ version 2 can be found in ‘/usr/share/common-licenses/GPL-2’.
+
+License: Autoconf
+ This program is free software: you can redistribute it and/or modify it
+ under the terms of the GNU General Public License as published by the
+ Free Software Foundation, either version 3 of the License, or (at your
+ option) any later version.
+ .
+ This program is distributed in the hope that it will be useful, but
+ WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General
+ Public License for more details.
+ .
+ You should have received a copy of the GNU General Public License along
+ with this program. If not, see <http://www.gnu.org/licenses/>.
+ .
+ As a special exception, the respective Autoconf Macro's copyright owner
+ gives unlimited permission to copy, distribute and modify the configure
+ scripts that are the output of Autoconf when processing the Macro. You
+ need not follow the terms of the GNU General Public License when using
+ or distributing such scripts, even though portions of the text of the
+ Macro appear in them. The GNU General Public License (GPL) does govern
+ all other use of the material that constitutes the Autoconf Macro.
+ .
+ This special exception to the GPL applies to versions of the Autoconf
+ Macro released by the Autoconf Archive. When you make and distribute a
+ modified version of the Autoconf Macro, you may extend this special
+ exception to the GPL to apply to your modified version as well.
+ .
+ On Debian systems, the complete text of the GNU General Public
+ License version 3 can be found in ‘/usr/share/common-licenses/GPL-3’.
+
+License: permissive-fsf
+ This file is free software; the Free Software Foundation
+ gives unlimited permission to copy and/or distribute it,
+ with or without modifications, as long as this notice is preserved.
+
+License: permissive-nowarranty
+ Copying and distribution of this file, with or without modification,
+ are permitted in any medium without royalty provided the copyright
+ notice and this notice are preserved. This file is offered as-is,
+ without warranty of any kind.
diff --git a/debian/liblzma-dev.NEWS b/debian/liblzma-dev.NEWS
new file mode 100644
index 0000000..da790a0
--- /dev/null
+++ b/debian/liblzma-dev.NEWS
@@ -0,0 +1,24 @@
+xz-utils (4.999.9beta+20100527-1) unstable; urgency=low
+
+ Starting with this version, the declarations needed to use the Subblock
+ filter are not present in the liblzma headers. liblzma never supported
+ the Subblock filter, so compiled applications should not be affected by
+ this change.
+
+ The lzma_restrict macro has been removed from the liblzma headers. This
+ only affects the declarations contained there; the semantics are still the
+ same.
+
+ -- Jonathan Nieder <jrnieder@gmail.com> Thu, 27 May 2010 15:52:28 -0500
+
+xz-utils (4.999.9beta+20100212-1) unstable; urgency=low
+
+ Starting with this version, the lzma_block_header_decode() function
+ is advertised to require its block->version parameter to be initialized.
+ Future versions of liblzma may use an alternate version of the Block
+ options if the application declares it supports it. Existing applications
+ will continue to work for now because the only supported Block format
+ version is zero.
+
+ -- Jonathan Nieder <jrnieder@gmail.com> Mon, 15 Feb 2010 23:59:21 -0600
+
diff --git a/debian/liblzma-dev.README.Debian b/debian/liblzma-dev.README.Debian
new file mode 100644
index 0000000..81e397d
--- /dev/null
+++ b/debian/liblzma-dev.README.Debian
@@ -0,0 +1,19 @@
+From the XZ Utils README (included in the xz-utils package):
+
+1.3. Documentation for liblzma
+
+ The liblzma API headers include short docs about each function
+ and data type as Doxygen tags. These docs should be quite OK as
+ a quick reference.
+
+ I have planned to write a bunch of very well documented example
+ programs, which (due to comments) should work as a tutorial to
+ various features of liblzma. No such example programs have been
+ written yet.
+
+ For now, if you have never used liblzma, libbzip2, or zlib, I
+ recommend learning *basics* of zlib API. Once you know that, it
+ should be easier to learn liblzma.
+
+ http://zlib.net/manual.html
+ http://zlib.net/zlib_how.html
diff --git a/debian/liblzma-dev.docs b/debian/liblzma-dev.docs
new file mode 100644
index 0000000..9c1a7dc
--- /dev/null
+++ b/debian/liblzma-dev.docs
@@ -0,0 +1,5 @@
+doc/xz-file-format.txt
+doc/lzma-file-format.txt
+doc/examples
+doc/examples_old
+TODO
diff --git a/debian/liblzma-dev.install b/debian/liblzma-dev.install
new file mode 100644
index 0000000..97de04c
--- /dev/null
+++ b/debian/liblzma-dev.install
@@ -0,0 +1,5 @@
+usr/include/*
+usr/include/lzma/*
+usr/lib/*/lib*.a
+usr/lib/*/lib*.so
+usr/lib/*/pkgconfig/*
diff --git a/debian/liblzma-dev.links b/debian/liblzma-dev.links
new file mode 100644
index 0000000..06a0344
--- /dev/null
+++ b/debian/liblzma-dev.links
@@ -0,0 +1,3 @@
+usr/share/doc/liblzma5/AUTHORS usr/share/doc/liblzma-dev/AUTHORS
+usr/share/doc/liblzma5/THANKS usr/share/doc/liblzma-dev/THANKS
+usr/share/doc/liblzma5/NEWS.gz usr/share/doc/liblzma-dev/NEWS.gz
diff --git a/debian/liblzma-doc.README.Debian b/debian/liblzma-doc.README.Debian
new file mode 100644
index 0000000..81e397d
--- /dev/null
+++ b/debian/liblzma-doc.README.Debian
@@ -0,0 +1,19 @@
+From the XZ Utils README (included in the xz-utils package):
+
+1.3. Documentation for liblzma
+
+ The liblzma API headers include short docs about each function
+ and data type as Doxygen tags. These docs should be quite OK as
+ a quick reference.
+
+ I have planned to write a bunch of very well documented example
+ programs, which (due to comments) should work as a tutorial to
+ various features of liblzma. No such example programs have been
+ written yet.
+
+ For now, if you have never used liblzma, libbzip2, or zlib, I
+ recommend learning *basics* of zlib API. Once you know that, it
+ should be easier to learn liblzma.
+
+ http://zlib.net/manual.html
+ http://zlib.net/zlib_how.html
diff --git a/debian/liblzma-doc.doc-base b/debian/liblzma-doc.doc-base
new file mode 100644
index 0000000..f7cfdc2
--- /dev/null
+++ b/debian/liblzma-doc.doc-base
@@ -0,0 +1,12 @@
+Document: liblzma-doc
+Title: liblzma API Documentation
+Author: Lasse Collin
+Abstract: liblzma is a compression library supporting the .xz and .lzma
+ formats, among others. This Doxygen-generated reference manual
+ describes the data structures and functions making up its public
+ interface.
+Section: Programming/C
+
+Format: HTML
+Index: /usr/share/doc/liblzma-doc/html/index.html
+Files: /usr/share/doc/liblzma-doc/html/*
diff --git a/debian/liblzma-doc.docs b/debian/liblzma-doc.docs
new file mode 100644
index 0000000..f8172bb
--- /dev/null
+++ b/debian/liblzma-doc.docs
@@ -0,0 +1 @@
+debian/normal-build/doc/html/
diff --git a/debian/liblzma5.docs b/debian/liblzma5.docs
new file mode 100644
index 0000000..aa4127d
--- /dev/null
+++ b/debian/liblzma5.docs
@@ -0,0 +1,3 @@
+AUTHORS
+THANKS
+NEWS
diff --git a/debian/liblzma5.install b/debian/liblzma5.install
new file mode 100644
index 0000000..1b15eaa
--- /dev/null
+++ b/debian/liblzma5.install
@@ -0,0 +1 @@
+lib/*/liblzma.so.*
diff --git a/debian/patches/abi-liblzma2-compat b/debian/patches/abi-liblzma2-compat
new file mode 100644
index 0000000..051ab5c
--- /dev/null
+++ b/debian/patches/abi-liblzma2-compat
@@ -0,0 +1,208 @@
+From: Jonathan Nieder <jrnieder@gmail.com>
+Date: Thu, 17 May 2012 18:49:00 -0500
+Subject: liblzma: skip ABI-incompatible check when liblzma.so.2 is loaded
+
+When liblzma started using ELF symbol versioning at the same time
+as a soname bump (2 → 5) and a small increase in the reserved space at
+the end of the lzma_stream structure checked by lzma_code, introducing
+an unversioned compatibility symbol to ease the transition seemed like
+a great idea. After all:
+
+ - most applications only use one version of the library (liblzma.so.2
+ or liblzma.so.5) and would obviously work fine
+
+ - applications linking to the new version of the library
+ (liblzma.so.5) should use the default, versioned lzma_code symbol so
+ errors initializing the reserved space can be noticed
+
+ - symbol versioning should ensure application/library mixtures
+ independently making use of both versions of the library also
+ work. Calls using the unversioned symbol names would be resolved
+ using the old symbol from liblzma.so.2 or the compatibility symbol
+ from liblzma.so.5, avoiding segfaults and spurious
+ LZMA_OPTIONS_ERROR errors.
+
+ - application/library mixtures using both versions of the library and
+ passing lzma_stream objects between the two would break, but that
+ was never supposed to be supported, anyway.
+
+Three toolchain bugs dash that plan.
+
+Current (2.22) versions of the gold linker cannot be used to build
+libraries providing versioned and unversioned symbols with the same
+name. On the other hand, BFD ld doesn't mind. So GNU gold refuses to
+link versions of liblzma including the compatibility symbol (PR12261):
+
+ /usr/bin/ld: error: symbol lzma_code has undefined version
+
+Annoying, but livable. liblzma with the compatibility symbol just
+has to be built with BFD ld.
+
+More importantly, gold does not support linking to libraries providing
+versioned and unversioned symbols with the same name. If I link some
+code to a version of liblzma with the compatibility symbol:
+
+ ld -o demo demo.o -llzma
+
+then the documented behavior, implemented by BFD ld, is to interpret
+calls to lzma_code as referring to the default version
+(lzma_code@XZ_5.0). Current versions of GNU gold treat such calls as
+referring to whichever symbol comes first in liblzma.so.5's symbol
+table. If the unversioned symbol comes first (and in Debian liblzma5
+5.1.1alpha+20110809-3 it does), GNU gold will mislink new applications
+to use the unversioned compatibility symbol (PR13521):
+
+ $ ld.gold -o test.gold test.o -llzma
+ $ eu-readelf -s test.gold | grep lzma_code
+ 1: 0000000000000000 0 FUNC GLOBAL DEFAULT UNDEF lzma_code
+ 5: 0000000000000000 0 FUNC GLOBAL DEFAULT UNDEF lzma_code
+
+There is no warning.
+
+Worse, ld.so from glibc unpredictably will sometimes use the versioned
+symbol to resolve references to the unversioned base version when both
+are present (PR12977).
+
+Clearly no one has been testing mixtures of versioned and
+unversioned symbols at all, and we cannot trust the symbol resolution
+process to do anything in particular for them.
+
+This patch implements an alternative method to implement the same
+compatibility goals described above.
+
+ - No more compatibility symbol. liblzma.so.5 will define lzma_code
+ only once, with version XZ_5.0.
+
+ - When initializing an lzma_stream object, use dlopen("liblzma.so.2",
+ RTLD_NOLOAD) to detect whether the caller might have been expecting
+ the old ABI, and store that information in the private
+ stream->internal->liblzma2_compat field.
+
+ - In lzma_code, when checking reserved fields, skip fields past the
+ old end of the lzma_stream structure ifying reserved fields if and
+ only if this->internal->liblzma2_compat is false.
+
+That's it. Hopefully this time it will work reliably.
+
+Thanks to Eduard Bloch for noticing PR13521 and to Ian Lance Taylor
+for PR12977.
+
+Signed-off-by: Jonathan Nieder <jrnieder@gmail.com>
+---
+ configure.ac | 5 +++++
+ src/liblzma/common/common.c | 40 ++++++++++++++++++++++++++++++++++++++--
+ src/liblzma/common/common.h | 4 ++++
+ 3 files changed, 47 insertions(+), 2 deletions(-)
+
+diff --git a/configure.ac b/configure.ac
+index 25eb838f..88b81ba1 100644
+--- a/configure.ac
++++ b/configure.ac
+@@ -471,6 +471,11 @@ if test "x$enable_threads" = xyes; then
+ AC_CHECK_DECLS([CLOCK_MONOTONIC], [], [], [[#include <time.h>]])
+ CFLAGS=$OLD_CFLAGS
+ fi
++
++# As a Debian-specific hack, liblzma uses dlopen() to check if extra
++# paranoia is needed because unversioned symbols from liblzma.so.2 are
++# present in the same process. See src/liblzma/common/common.c.
++AC_SEARCH_LIBS([dlopen], [dl])
+
+ echo
+ echo "Initializing Libtool:"
+diff --git a/src/liblzma/common/common.c b/src/liblzma/common/common.c
+index 50c984c7..e61d940d 100644
+--- a/src/liblzma/common/common.c
++++ b/src/liblzma/common/common.c
+@@ -12,6 +12,8 @@
+
+ #include "common.h"
+
++#include <dlfcn.h>
++
+
+ /////////////
+ // Version //
+@@ -141,6 +143,17 @@ lzma_next_end(lzma_next_coder *next, lzma_allocator *allocator)
+ // External to internal API wrapper //
+ //////////////////////////////////////
+
++static bool
++liblzma2_loaded(void)
++{
++ void *handle = dlopen("liblzma.so.2", RTLD_LAZY | RTLD_NOLOAD);
++ if (handle) {
++ dlclose(handle);
++ return true;
++ }
++ return false;
++}
++
+ extern lzma_ret
+ lzma_strm_init(lzma_stream *strm)
+ {
+@@ -154,6 +167,7 @@ lzma_strm_init(lzma_stream *strm)
+ return LZMA_MEM_ERROR;
+
+ strm->internal->next = LZMA_NEXT_CODER_INIT;
++ strm->internal->liblzma2_compat = liblzma2_loaded();
+ }
+
+ memzero(strm->internal->supported_actions,
+@@ -168,6 +182,24 @@ lzma_strm_init(lzma_stream *strm)
+ }
+
+
++// Before v5.0.0~6 (liblzma: A few ABI tweaks to reserve space in
++// structures, 2010-10-23), the reserved fields in lzma_stream were:
++//
++// void *reserved_ptr1;
++// void *reserved_ptr2;
++// uint64_t reserved_int1;
++// uint64_t reserved_int2;
++// lzma_reserved_enum reserved_enum1;
++// lzma_reserved_enum reserved_enum2;
++//
++// Nowadays there are two more pointers between reserved_ptr2 and
++// reserved_int1 and two size_t fields between reserved_int2 and
++// reserved_enum1.
++//
++// When strm->internal->liblzma2_compat is set, limit the checks of
++// reserved fields to fields that were present in the old ABI to avoid
++// segfaults and spurious "Unsupported options" from callers sharing
++// the process image that expect the old ABI.
+ extern LZMA_API(lzma_ret)
+ lzma_code(lzma_stream *strm, lzma_action action)
+ {
+@@ -185,8 +217,12 @@ lzma_code(lzma_stream *strm, lzma_action action)
+ if (strm->reserved_ptr1 != NULL
+ || strm->reserved_ptr2 != NULL
+ || strm->reserved_ptr3 != NULL
+- || strm->reserved_ptr4 != NULL
+- || strm->reserved_int1 != 0
++ || strm->reserved_ptr4 != NULL)
++ return LZMA_OPTIONS_ERROR;
++
++ if (strm->internal->liblzma2_compat)
++ ; /* Enough checks. */
++ else if (strm->reserved_int1 != 0
+ || strm->reserved_int2 != 0
+ || strm->reserved_int3 != 0
+ || strm->reserved_int4 != 0
+diff --git a/src/liblzma/common/common.h b/src/liblzma/common/common.h
+index 45aba4f0..475661d8 100644
+--- a/src/liblzma/common/common.h
++++ b/src/liblzma/common/common.h
+@@ -200,6 +200,10 @@ struct lzma_internal_s {
+ /// If true, lzma_code will return LZMA_BUF_ERROR if no progress was
+ /// made (no input consumed and no output produced by next.code).
+ bool allow_buf_error;
++
++ /// Indicates whether we are sharing a process image with
++ /// liblzma.so.2 and need to tread carefully.
++ bool liblzma2_compat;
+ };
+
+
+--
+1.7.10.2
diff --git a/debian/patches/abi-threaded-encoder b/debian/patches/abi-threaded-encoder
new file mode 100644
index 0000000..04babbf
--- /dev/null
+++ b/debian/patches/abi-threaded-encoder
@@ -0,0 +1,2163 @@
+From: Jonathan Nieder <jrnieder@gmail.com>
+Date: Sat, 11 Jun 2011 21:41:15 -0500
+Subject: Remove threading functionality for now
+
+This reverts the following commits:
+
+ - 6ef4eabc0 (Bump the version number to 5.1.1alpha and liblzma soname
+ to 5.0.99)
+ - 70e750f59 (xz: Update the man page about threading)
+ - c29e6630c (xz: Print the maximum number of worker threads in xz -vv)
+ - 335fe260a (xz: Minor internal changes to handling of --threads)
+ - 24e0406c0 (xz: Add support for threaded compression)
+ - 9a4377be0 (Put the unstable APIs behind #ifdef LZMA_UNSTABLE)
+ - de678e0c9 (liblmza: Add lzma_stream_encoder_mt() for threaded
+ compression)
+
+The multithreaded compression functions, while useful, are not set in
+stone as part of the stable ABI. Changes will be easier to weather
+until the functions stabilize if they are left out from the
+non-experimental development branch of Debian for now.
+
+Signed-off-by: Jonathan Nieder <jrnieder@gmail.com>
+---
+ configure.ac | 1 -
+ src/liblzma/Makefile.am | 2 +-
+ src/liblzma/api/lzma/container.h | 167 ------
+ src/liblzma/api/lzma/version.h | 2 +-
+ src/liblzma/common/Makefile.inc | 7 -
+ src/liblzma/common/common.c | 9 +-
+ src/liblzma/common/common.h | 16 -
+ src/liblzma/common/outqueue.c | 184 ------
+ src/liblzma/common/outqueue.h | 155 -----
+ src/liblzma/common/stream_encoder_mt.c | 1013 --------------------------------
+ src/xz/args.c | 5 +-
+ src/xz/coder.c | 210 +++----
+ src/xz/hardware.c | 24 +-
+ src/xz/hardware.h | 9 +-
+ src/xz/private.h | 2 -
+ src/xz/xz.1 | 34 +-
+ 16 files changed, 117 insertions(+), 1723 deletions(-)
+ delete mode 100644 src/liblzma/common/outqueue.c
+ delete mode 100644 src/liblzma/common/outqueue.h
+ delete mode 100644 src/liblzma/common/stream_encoder_mt.c
+
+diff --git a/configure.ac b/configure.ac
+index 25eb838..c9585e5 100644
+--- a/configure.ac
++++ b/configure.ac
+@@ -471,7 +471,6 @@ if test "x$enable_threads" = xyes; then
+ AC_CHECK_DECLS([CLOCK_MONOTONIC], [], [], [[#include <time.h>]])
+ CFLAGS=$OLD_CFLAGS
+ fi
+-AM_CONDITIONAL([COND_THREADS], [test "x$ax_pthread_ok" = xyes])
+
+ echo
+ echo "Initializing Libtool:"
+diff --git a/src/liblzma/Makefile.am b/src/liblzma/Makefile.am
+index 5bd205d..ac2d1ed 100644
+--- a/src/liblzma/Makefile.am
++++ b/src/liblzma/Makefile.am
+@@ -24,7 +24,7 @@ liblzma_la_CPPFLAGS = \
+ -I$(top_srcdir)/src/liblzma/simple \
+ -I$(top_srcdir)/src/common \
+ -DTUKLIB_SYMBOL_PREFIX=lzma_
+-liblzma_la_LDFLAGS = -no-undefined -version-info 5:99:0
++liblzma_la_LDFLAGS = -no-undefined -version-info 5:0:0
+
+ if COND_SYMVERS
+ EXTRA_DIST += liblzma.map
+diff --git a/src/liblzma/api/lzma/container.h b/src/liblzma/api/lzma/container.h
+index 499d8b9..7a9ffc6 100644
+--- a/src/liblzma/api/lzma/container.h
++++ b/src/liblzma/api/lzma/container.h
+@@ -60,129 +60,6 @@
+ #define LZMA_PRESET_EXTREME (UINT32_C(1) << 31)
+
+
+-#ifdef LZMA_UNSTABLE /* Unstable API that may change. Use only for testing. */
+-/**
+- * \brief Multithreading options
+- */
+-typedef struct {
+- /**
+- * \brief Flags
+- *
+- * Set this to zero if no flags are wanted.
+- *
+- * No flags are currently supported.
+- */
+- uint32_t flags;
+-
+- /**
+- * \brief Number of worker threads to use
+- */
+- uint32_t threads;
+-
+- /**
+- * \brief Maximum uncompressed size of a Block
+- *
+- * The encoder will start a new .xz Block every block_size bytes.
+- * Using LZMA_FULL_FLUSH or LZMA_FULL_BARRIER with lzma_code()
+- * the caller may tell liblzma to start a new Block earlier.
+- *
+- * With LZMA2, a recommended block size is 2-4 times the LZMA2
+- * dictionary size. With very small dictionaries, it is recommended
+- * to use at least 1 MiB block size for good compression ratio, even
+- * if this is more than four times the dictionary size. Note that
+- * these are only recommendations for typical use cases; feel free
+- * to use other values. Just keep in mind that using a block size
+- * less than the LZMA2 dictionary size is waste of RAM.
+- *
+- * Set this to 0 to let liblzma choose the block size depending
+- * on the compression options. For LZMA2 it will be 3*dict_size
+- * or 1 MiB, whichever is more.
+- */
+- uint64_t block_size;
+-
+- /**
+- * \brief Timeout to allow lzma_code() to return early
+- *
+- * Multithreading can make liblzma to consume input and produce
+- * output in a very bursty way: it may first read a lot of input
+- * to fill internal buffers, then no input or output occurs for
+- * a while.
+- *
+- * In single-threaded mode, lzma_code() won't return until it has
+- * either consumed all the input or filled the output buffer. If
+- * this is done in multithreaded mode, it may cause a call
+- * lzma_code() to take even tens of seconds, which isn't acceptable
+- * in all applications.
+- *
+- * To avoid very long blocking times in lzma_code(), a timeout
+- * (in milliseconds) may be set here. If lzma_code() would block
+- * longer than this number of milliseconds, it will return with
+- * LZMA_OK. Reasonable values are 100 ms or more. The xz command
+- * line tool uses 300 ms.
+- *
+- * If long blocking times are fine for you, set timeout to a special
+- * value of 0, which will disable the timeout mechanism and will make
+- * lzma_code() block until all the input is consumed or the output
+- * buffer has been filled.
+- *
+- * \note Even with a timeout, lzma_code() might sometimes take
+- * somewhat long time to return. No timing guarantees
+- * are made.
+- */
+- uint32_t timeout;
+-
+- /**
+- * \brief Compression preset (level and possible flags)
+- *
+- * The preset is set just like with lzma_easy_encoder().
+- * The preset is ignored if filters below is non-NULL.
+- */
+- uint32_t preset;
+-
+- /**
+- * \brief Filter chain (alternative to a preset)
+- *
+- * If this is NULL, the preset above is used. Otherwise the preset
+- * is ignored and the filter chain specified here is used.
+- */
+- const lzma_filter *filters;
+-
+- /**
+- * \brief Integrity check type
+- *
+- * See check.h for available checks. The xz command line tool
+- * defaults to LZMA_CHECK_CRC64, which is a good choice if you
+- * are unsure.
+- */
+- lzma_check check;
+-
+- /*
+- * Reserved space to allow possible future extensions without
+- * breaking the ABI. You should not touch these, because the names
+- * of these variables may change. These are and will never be used
+- * with the currently supported options, so it is safe to leave these
+- * uninitialized.
+- */
+- lzma_reserved_enum reserved_enum1;
+- lzma_reserved_enum reserved_enum2;
+- lzma_reserved_enum reserved_enum3;
+- uint32_t reserved_int1;
+- uint32_t reserved_int2;
+- uint32_t reserved_int3;
+- uint32_t reserved_int4;
+- uint64_t reserved_int5;
+- uint64_t reserved_int6;
+- uint64_t reserved_int7;
+- uint64_t reserved_int8;
+- void *reserved_ptr1;
+- void *reserved_ptr2;
+- void *reserved_ptr3;
+- void *reserved_ptr4;
+-
+-} lzma_mt;
+-#endif
+-
+-
+ /**
+ * \brief Calculate approximate memory usage of easy encoder
+ *
+@@ -313,50 +190,6 @@ extern LZMA_API(lzma_ret) lzma_stream_encoder(lzma_stream *strm,
+ lzma_nothrow lzma_attr_warn_unused_result;
+
+
+-#ifdef LZMA_UNSTABLE /* Unstable API that may change. Use only for testing. */
+-/**
+- * \brief Calculate approximate memory usage of multithreaded .xz encoder
+- *
+- * Since doing the encoding in threaded mode doesn't affect the memory
+- * requirements of single-threaded decompressor, you can use
+- * lzma_easy_decoder_memusage(options->preset) or
+- * lzma_raw_decoder_memusage(options->filters) to calculate
+- * the decompressor memory requirements.
+- *
+- * \param options Compression options
+- *
+- * \return Number of bytes of memory required for encoding with the
+- * given options. If an error occurs, for example due to
+- * unsupported preset or filter chain, UINT64_MAX is returned.
+- */
+-extern LZMA_API(uint64_t) lzma_stream_encoder_mt_memusage(
+- const lzma_mt *options) lzma_nothrow lzma_attr_pure;
+-
+-
+-/**
+- * \brief Initialize multithreaded .xz Stream encoder
+- *
+- * This provides the functionality of lzma_easy_encoder() and
+- * lzma_stream_encoder() as a single function for multithreaded use.
+- *
+- * TODO: For lzma_code(), only LZMA_RUN and LZMA_FINISH are currently
+- * supported. Support for other actions has been planned.
+- *
+- * \param strm Pointer to properly prepared lzma_stream
+- * \param options Pointer to multithreaded compression options
+- *
+- * \return - LZMA_OK
+- * - LZMA_MEM_ERROR
+- * - LZMA_UNSUPPORTED_CHECK
+- * - LZMA_OPTIONS_ERROR
+- * - LZMA_PROG_ERROR
+- */
+-extern LZMA_API(lzma_ret) lzma_stream_encoder_mt(
+- lzma_stream *strm, const lzma_mt *options)
+- lzma_nothrow lzma_attr_warn_unused_result;
+-#endif
+-
+-
+ /**
+ * \brief Initialize .lzma encoder (legacy file format)
+ *
+diff --git a/src/liblzma/api/lzma/version.h b/src/liblzma/api/lzma/version.h
+index 4bf7e40..a908ea2 100644
+--- a/src/liblzma/api/lzma/version.h
++++ b/src/liblzma/api/lzma/version.h
+@@ -22,7 +22,7 @@
+ */
+ #define LZMA_VERSION_MAJOR 5
+ #define LZMA_VERSION_MINOR 1
+-#define LZMA_VERSION_PATCH 1
++#define LZMA_VERSION_PATCH 0
+ #define LZMA_VERSION_STABILITY LZMA_VERSION_STABILITY_ALPHA
+
+ #ifndef LZMA_VERSION_COMMIT
+diff --git a/src/liblzma/common/Makefile.inc b/src/liblzma/common/Makefile.inc
+index dd5a8c8..81d751e 100644
+--- a/src/liblzma/common/Makefile.inc
++++ b/src/liblzma/common/Makefile.inc
+@@ -40,13 +40,6 @@ liblzma_la_SOURCES += \
+ common/stream_encoder.c \
+ common/stream_flags_encoder.c \
+ common/vli_encoder.c
+-
+-if COND_THREADS
+-liblzma_la_SOURCES += \
+- common/outqueue.c \
+- common/outqueue.h \
+- common/stream_encoder_mt.c
+-endif
+ endif
+
+ if COND_MAIN_DECODER
+diff --git a/src/liblzma/common/common.c b/src/liblzma/common/common.c
+index 85ae96a..50c984c 100644
+--- a/src/liblzma/common/common.c
++++ b/src/liblzma/common/common.c
+@@ -263,9 +263,7 @@ lzma_code(lzma_stream *strm, lzma_action action)
+
+ strm->internal->avail_in = strm->avail_in;
+
+- // Cast is needed to silence a warning about LZMA_TIMED_OUT, which
+- // isn't part of lzma_ret enumeration.
+- switch ((unsigned int)(ret)) {
++ switch (ret) {
+ case LZMA_OK:
+ // Don't return LZMA_BUF_ERROR when it happens the first time.
+ // This is to avoid returning LZMA_BUF_ERROR when avail_out
+@@ -281,11 +279,6 @@ lzma_code(lzma_stream *strm, lzma_action action)
+ }
+ break;
+
+- case LZMA_TIMED_OUT:
+- strm->internal->allow_buf_error = false;
+- ret = LZMA_OK;
+- break;
+-
+ case LZMA_STREAM_END:
+ if (strm->internal->sequence == ISEQ_SYNC_FLUSH
+ || strm->internal->sequence == ISEQ_FULL_FLUSH)
+diff --git a/src/liblzma/common/common.h b/src/liblzma/common/common.h
+index 5c92af2..45aba4f 100644
+--- a/src/liblzma/common/common.h
++++ b/src/liblzma/common/common.h
+@@ -32,8 +32,6 @@
+
+ #define LZMA_API(type) LZMA_API_EXPORT type LZMA_API_CALL
+
+-#define LZMA_UNSTABLE
+-
+ #include "lzma.h"
+
+ // These allow helping the compiler in some often-executed branches, whose
+@@ -51,13 +49,6 @@
+ #define LZMA_BUFFER_SIZE 4096
+
+
+-/// Maximum number of worker threads within one multithreaded component.
+-/// The limit exists solely to make it simpler to prevent integer overflows
+-/// when allocating structures etc. This should be big enough for now...
+-/// the code won't scale anywhere close to this number anyway.
+-#define LZMA_THREADS_MAX 16384
+-
+-
+ /// Starting value for memory usage estimates. Instead of calculating size
+ /// of _every_ structure and taking into account malloc() overhead etc., we
+ /// add a base size to all memory usage estimates. It's not very accurate
+@@ -78,13 +69,6 @@
+ | LZMA_CONCATENATED )
+
+
+-/// Special return value (lzma_ret) to indicate that a timeout was reached
+-/// and lzma_code() must not return LZMA_BUF_ERROR. This is converted to
+-/// LZMA_OK in lzma_code(). This is not in the lzma_ret enumeration because
+-/// there's no need to have it in the public API.
+-#define LZMA_TIMED_OUT 32
+-
+-
+ /// Type of encoder/decoder specific data; the actual structure is defined
+ /// differently in different coders.
+ typedef struct lzma_coder_s lzma_coder;
+diff --git a/src/liblzma/common/outqueue.c b/src/liblzma/common/outqueue.c
+deleted file mode 100644
+index d7a87d9..0000000
+--- a/src/liblzma/common/outqueue.c
++++ /dev/null
+@@ -1,184 +0,0 @@
+-///////////////////////////////////////////////////////////////////////////////
+-//
+-/// \file outqueue.c
+-/// \brief Output queue handling in multithreaded coding
+-//
+-// Author: Lasse Collin
+-//
+-// This file has been put into the public domain.
+-// You can do whatever you want with this file.
+-//
+-///////////////////////////////////////////////////////////////////////////////
+-
+-#include "outqueue.h"
+-
+-
+-/// This is to ease integer overflow checking: We may allocate up to
+-/// 2 * LZMA_THREADS_MAX buffers and we need some extra memory for other
+-/// data structures (that's the second /2).
+-#define BUF_SIZE_MAX (UINT64_MAX / LZMA_THREADS_MAX / 2 / 2)
+-
+-
+-static lzma_ret
+-get_options(uint64_t *bufs_alloc_size, uint32_t *bufs_count,
+- uint64_t buf_size_max, uint32_t threads)
+-{
+- if (threads > LZMA_THREADS_MAX || buf_size_max > BUF_SIZE_MAX)
+- return LZMA_OPTIONS_ERROR;
+-
+- // The number of buffers is twice the number of threads.
+- // This wastes RAM but keeps the threads busy when buffers
+- // finish out of order.
+- //
+- // NOTE: If this is changed, update BUF_SIZE_MAX too.
+- *bufs_count = threads * 2;
+- *bufs_alloc_size = *bufs_count * buf_size_max;
+-
+- return LZMA_OK;
+-}
+-
+-
+-extern uint64_t
+-lzma_outq_memusage(uint64_t buf_size_max, uint32_t threads)
+-{
+- uint64_t bufs_alloc_size;
+- uint32_t bufs_count;
+-
+- if (get_options(&bufs_alloc_size, &bufs_count, buf_size_max, threads)
+- != LZMA_OK)
+- return UINT64_MAX;
+-
+- return sizeof(lzma_outq) + bufs_count * sizeof(lzma_outbuf)
+- + bufs_alloc_size;
+-}
+-
+-
+-extern lzma_ret
+-lzma_outq_init(lzma_outq *outq, lzma_allocator *allocator,
+- uint64_t buf_size_max, uint32_t threads)
+-{
+- uint64_t bufs_alloc_size;
+- uint32_t bufs_count;
+-
+- // Set bufs_count and bufs_alloc_size.
+- return_if_error(get_options(&bufs_alloc_size, &bufs_count,
+- buf_size_max, threads));
+-
+- // Allocate memory if needed.
+- if (outq->buf_size_max != buf_size_max
+- || outq->bufs_allocated != bufs_count) {
+- lzma_outq_end(outq, allocator);
+-
+-#if SIZE_MAX < UINT64_MAX
+- if (bufs_alloc_size > SIZE_MAX)
+- return LZMA_MEM_ERROR;
+-#endif
+-
+- outq->bufs = lzma_alloc(bufs_count * sizeof(lzma_outbuf),
+- allocator);
+- outq->bufs_mem = lzma_alloc((size_t)(bufs_alloc_size),
+- allocator);
+-
+- if (outq->bufs == NULL || outq->bufs_mem == NULL) {
+- lzma_outq_end(outq, allocator);
+- return LZMA_MEM_ERROR;
+- }
+- }
+-
+- // Initialize the rest of the main structure. Initialization of
+- // outq->bufs[] is done when they are actually needed.
+- outq->buf_size_max = (size_t)(buf_size_max);
+- outq->bufs_allocated = bufs_count;
+- outq->bufs_pos = 0;
+- outq->bufs_used = 0;
+- outq->read_pos = 0;
+-
+- return LZMA_OK;
+-}
+-
+-
+-extern void
+-lzma_outq_end(lzma_outq *outq, lzma_allocator *allocator)
+-{
+- lzma_free(outq->bufs, allocator);
+- outq->bufs = NULL;
+-
+- lzma_free(outq->bufs_mem, allocator);
+- outq->bufs_mem = NULL;
+-
+- return;
+-}
+-
+-
+-extern lzma_outbuf *
+-lzma_outq_get_buf(lzma_outq *outq)
+-{
+- // Caller must have checked it with lzma_outq_has_buf().
+- assert(outq->bufs_used < outq->bufs_allocated);
+-
+- // Initialize the new buffer.
+- lzma_outbuf *buf = &outq->bufs[outq->bufs_pos];
+- buf->buf = outq->bufs_mem + outq->bufs_pos * outq->buf_size_max;
+- buf->size = 0;
+- buf->finished = false;
+-
+- // Update the queue state.
+- if (++outq->bufs_pos == outq->bufs_allocated)
+- outq->bufs_pos = 0;
+-
+- ++outq->bufs_used;
+-
+- return buf;
+-}
+-
+-
+-extern bool
+-lzma_outq_is_readable(const lzma_outq *outq)
+-{
+- uint32_t i = outq->bufs_pos - outq->bufs_used;
+- if (outq->bufs_pos < outq->bufs_used)
+- i += outq->bufs_allocated;
+-
+- return outq->bufs[i].finished;
+-}
+-
+-
+-extern lzma_ret
+-lzma_outq_read(lzma_outq *restrict outq, uint8_t *restrict out,
+- size_t *restrict out_pos, size_t out_size,
+- lzma_vli *restrict unpadded_size,
+- lzma_vli *restrict uncompressed_size)
+-{
+- // There must be at least one buffer from which to read.
+- if (outq->bufs_used == 0)
+- return LZMA_OK;
+-
+- // Get the buffer.
+- uint32_t i = outq->bufs_pos - outq->bufs_used;
+- if (outq->bufs_pos < outq->bufs_used)
+- i += outq->bufs_allocated;
+-
+- lzma_outbuf *buf = &outq->bufs[i];
+-
+- // If it isn't finished yet, we cannot read from it.
+- if (!buf->finished)
+- return LZMA_OK;
+-
+- // Copy from the buffer to output.
+- lzma_bufcpy(buf->buf, &outq->read_pos, buf->size,
+- out, out_pos, out_size);
+-
+- // Return if we didn't get all the data from the buffer.
+- if (outq->read_pos < buf->size)
+- return LZMA_OK;
+-
+- // The buffer was finished. Tell the caller its size information.
+- *unpadded_size = buf->unpadded_size;
+- *uncompressed_size = buf->uncompressed_size;
+-
+- // Free this buffer for further use.
+- --outq->bufs_used;
+- outq->read_pos = 0;
+-
+- return LZMA_STREAM_END;
+-}
+diff --git a/src/liblzma/common/outqueue.h b/src/liblzma/common/outqueue.h
+deleted file mode 100644
+index 154f91b..0000000
+--- a/src/liblzma/common/outqueue.h
++++ /dev/null
+@@ -1,155 +0,0 @@
+-///////////////////////////////////////////////////////////////////////////////
+-//
+-/// \file outqueue.h
+-/// \brief Output queue handling in multithreaded coding
+-//
+-// Author: Lasse Collin
+-//
+-// This file has been put into the public domain.
+-// You can do whatever you want with this file.
+-//
+-///////////////////////////////////////////////////////////////////////////////
+-
+-#include "common.h"
+-
+-
+-/// Output buffer for a single thread
+-typedef struct {
+- /// Pointer to the output buffer of lzma_outq.buf_size_max bytes
+- uint8_t *buf;
+-
+- /// Amount of data written to buf
+- size_t size;
+-
+- /// Additional size information
+- lzma_vli unpadded_size;
+- lzma_vli uncompressed_size;
+-
+- /// True when no more data will be written into this buffer.
+- ///
+- /// \note This is read by another thread and thus access
+- /// to this variable needs a mutex.
+- bool finished;
+-
+-} lzma_outbuf;
+-
+-
+-typedef struct {
+- /// Array of buffers that are used cyclically.
+- lzma_outbuf *bufs;
+-
+- /// Memory allocated for all the buffers
+- uint8_t *bufs_mem;
+-
+- /// Amount of buffer space available in each buffer
+- size_t buf_size_max;
+-
+- /// Number of buffers allocated
+- uint32_t bufs_allocated;
+-
+- /// Position in the bufs array. The next buffer to be taken
+- /// into use is bufs[bufs_pos].
+- uint32_t bufs_pos;
+-
+- /// Number of buffers in use
+- uint32_t bufs_used;
+-
+- /// Position in the buffer in lzma_outq_read()
+- size_t read_pos;
+-
+-} lzma_outq;
+-
+-
+-/**
+- * \brief Calculate the memory usage of an output queue
+- *
+- * \return Approximate memory usage in bytes or UINT64_MAX on error.
+- */
+-extern uint64_t lzma_outq_memusage(uint64_t buf_size_max, uint32_t threads);
+-
+-
+-/// \brief Initialize an output queue
+-///
+-/// \param outq Pointer to an output queue. Before calling
+-/// this function the first time, *outq should
+-/// have been zeroed with memzero() so that this
+-/// function knows that there are no previous
+-/// allocations to free.
+-/// \param allocator Pointer to allocator or NULL
+-/// \param buf_size_max Maximum amount of data that a single buffer
+-/// in the queue may need to store.
+-/// \param threads Number of buffers that may be in use
+-/// concurrently. Note that more than this number
+-/// of buffers will actually get allocated to
+-/// improve performance when buffers finish
+-/// out of order.
+-///
+-/// \return - LZMA_OK
+-/// - LZMA_MEM_ERROR
+-///
+-extern lzma_ret lzma_outq_init(lzma_outq *outq, lzma_allocator *allocator,
+- uint64_t buf_size_max, uint32_t threads);
+-
+-
+-/// \brief Free the memory associated with the output queue
+-extern void lzma_outq_end(lzma_outq *outq, lzma_allocator *allocator);
+-
+-
+-/// \brief Get a new buffer
+-///
+-/// lzma_outq_has_buf() must be used to check that there is a buffer
+-/// available before calling lzma_outq_get_buf().
+-///
+-extern lzma_outbuf *lzma_outq_get_buf(lzma_outq *outq);
+-
+-
+-/// \brief Test if there is data ready to be read
+-///
+-/// Call to this function must be protected with the same mutex that
+-/// is used to protect lzma_outbuf.finished.
+-///
+-extern bool lzma_outq_is_readable(const lzma_outq *outq);
+-
+-
+-/// \brief Read finished data
+-///
+-/// \param outq Pointer to an output queue
+-/// \param out Beginning of the output buffer
+-/// \param out_pos The next byte will be written to
+-/// out[*out_pos].
+-/// \param out_size Size of the out buffer; the first byte into
+-/// which no data is written to is out[out_size].
+-/// \param unpadded_size Unpadded Size from the Block encoder
+-/// \param uncompressed_size Uncompressed Size from the Block encoder
+-///
+-/// \return - LZMA: All OK. Either no data was available or the buffer
+-/// being read didn't become empty yet.
+-/// - LZMA_STREAM_END: The buffer being read was finished.
+-/// *unpadded_size and *uncompressed_size were set.
+-///
+-/// \note This reads lzma_outbuf.finished variables and thus call
+-/// to this function needs to be protected with a mutex.
+-///
+-extern lzma_ret lzma_outq_read(lzma_outq *restrict outq,
+- uint8_t *restrict out, size_t *restrict out_pos,
+- size_t out_size, lzma_vli *restrict unpadded_size,
+- lzma_vli *restrict uncompressed_size);
+-
+-
+-/// \brief Test if there is at least one buffer free
+-///
+-/// This must be used before getting a new buffer with lzma_outq_get_buf().
+-///
+-static inline bool
+-lzma_outq_has_buf(const lzma_outq *outq)
+-{
+- return outq->bufs_used < outq->bufs_allocated;
+-}
+-
+-
+-/// \brief Test if the queue is completely empty
+-static inline bool
+-lzma_outq_is_empty(const lzma_outq *outq)
+-{
+- return outq->bufs_used == 0;
+-}
+diff --git a/src/liblzma/common/stream_encoder_mt.c b/src/liblzma/common/stream_encoder_mt.c
+deleted file mode 100644
+index a4b2800..0000000
+--- a/src/liblzma/common/stream_encoder_mt.c
++++ /dev/null
+@@ -1,1013 +0,0 @@
+-///////////////////////////////////////////////////////////////////////////////
+-//
+-/// \file stream_encoder_mt.c
+-/// \brief Multithreaded .xz Stream encoder
+-//
+-// Author: Lasse Collin
+-//
+-// This file has been put into the public domain.
+-// You can do whatever you want with this file.
+-//
+-///////////////////////////////////////////////////////////////////////////////
+-
+-#include "filter_encoder.h"
+-#include "easy_preset.h"
+-#include "block_encoder.h"
+-#include "index_encoder.h"
+-#include "outqueue.h"
+-
+-
+-/// Maximum supported block size. This makes it simpler to prevent integer
+-/// overflows if we are given unusually large block size.
+-#define BLOCK_SIZE_MAX (UINT64_MAX / LZMA_THREADS_MAX)
+-
+-
+-typedef enum {
+- /// Waiting for work.
+- THR_IDLE,
+-
+- /// Encoding is in progress.
+- THR_RUN,
+-
+- /// Encoding is in progress but no more input data will
+- /// be read.
+- THR_FINISH,
+-
+- /// The main thread wants the thread to stop whatever it was doing
+- /// but not exit.
+- THR_STOP,
+-
+- /// The main thread wants the thread to exit. We could use
+- /// cancellation but since there's stopped anyway, this is lazier.
+- THR_EXIT,
+-
+-} worker_state;
+-
+-
+-typedef struct worker_thread_s worker_thread;
+-struct worker_thread_s {
+- worker_state state;
+-
+- /// Input buffer of coder->block_size bytes. The main thread will
+- /// put new input into this and update in_size accordingly. Once
+- /// no more input is coming, state will be set to THR_FINISH.
+- uint8_t *in;
+-
+- /// Amount of data available in the input buffer. This is modified
+- /// only by the main thread.
+- size_t in_size;
+-
+- /// Output buffer for this thread. This is set by the main
+- /// thread every time a new Block is started with this thread
+- /// structure.
+- lzma_outbuf *outbuf;
+-
+- /// Pointer to the main structure is needed when putting this
+- /// thread back to the stack of free threads.
+- lzma_coder *coder;
+-
+- /// The allocator is set by the main thread. Since a copy of the
+- /// pointer is kept here, the application must not change the
+- /// allocator before calling lzma_end().
+- lzma_allocator *allocator;
+-
+- /// Block encoder
+- lzma_next_coder block_encoder;
+-
+- /// Compression options for this Block
+- lzma_block block_options;
+-
+- /// Next structure in the stack of free worker threads.
+- worker_thread *next;
+-
+- pthread_mutex_t mutex;
+- pthread_cond_t cond;
+-
+- /// The ID of this thread is used to join the thread
+- /// when it's not needed anymore.
+- pthread_t thread_id;
+-};
+-
+-
+-struct lzma_coder_s {
+- enum {
+- SEQ_STREAM_HEADER,
+- SEQ_BLOCK,
+- SEQ_INDEX,
+- SEQ_STREAM_FOOTER,
+- } sequence;
+-
+- /// Start a new Block every block_size bytes of input unless
+- /// LZMA_FULL_FLUSH or LZMA_FULL_BARRIER is used earlier.
+- size_t block_size;
+-
+- /// The filter chain currently in use
+- lzma_filter filters[LZMA_FILTERS_MAX + 1];
+-
+-
+- /// Index to hold sizes of the Blocks
+- lzma_index *index;
+-
+- /// Index encoder
+- lzma_next_coder index_encoder;
+-
+-
+- /// Stream Flags for encoding the Stream Header and Stream Footer.
+- lzma_stream_flags stream_flags;
+-
+- /// Buffer to hold Stream Header and Stream Footer.
+- uint8_t header[LZMA_STREAM_HEADER_SIZE];
+-
+- /// Read position in header[]
+- size_t header_pos;
+-
+-
+- /// Output buffer queue for compressed data
+- lzma_outq outq;
+-
+-
+- /// True if wait_max is used.
+- bool has_timeout;
+-
+- /// Maximum wait time if cannot use all the input and cannot
+- /// fill the output buffer.
+- struct timespec wait_max;
+-
+-
+- /// Error code from a worker thread
+- lzma_ret thread_error;
+-
+- /// Array of allocated thread-specific structures
+- worker_thread *threads;
+-
+- /// Number of structures in "threads" above. This is also the
+- /// number of threads that will be created at maximum.
+- uint32_t threads_max;
+-
+- /// Number of thread structures that have been initialized, and
+- /// thus the number of worker threads actually created so far.
+- uint32_t threads_initialized;
+-
+- /// Stack of free threads. When a thread finishes, it puts itself
+- /// back into this stack. This starts as empty because threads
+- /// are created only when actually needed.
+- worker_thread *threads_free;
+-
+- /// The most recent worker thread to which the main thread writes
+- /// the new input from the application.
+- worker_thread *thr;
+-
+- pthread_mutex_t mutex;
+- mythread_cond cond;
+-};
+-
+-
+-/// Tell the main thread that something has gone wrong.
+-static void
+-worker_error(worker_thread *thr, lzma_ret ret)
+-{
+- assert(ret != LZMA_OK);
+- assert(ret != LZMA_STREAM_END);
+-
+- mythread_sync(thr->coder->mutex) {
+- if (thr->coder->thread_error == LZMA_OK)
+- thr->coder->thread_error = ret;
+-
+- mythread_cond_signal(&thr->coder->cond);
+- }
+-
+- return;
+-}
+-
+-
+-static worker_state
+-worker_encode(worker_thread *thr, worker_state state)
+-{
+- // Set the Block options.
+- thr->block_options = (lzma_block){
+- .version = 0,
+- .check = thr->coder->stream_flags.check,
+- .compressed_size = thr->coder->outq.buf_size_max,
+- .uncompressed_size = thr->coder->block_size,
+-
+- // TODO: To allow changing the filter chain, the filters
+- // array must be copied to each worker_thread.
+- .filters = thr->coder->filters,
+- };
+-
+- // Calculate maximum size of the Block Header. This amount is
+- // reserved in the beginning of the buffer so that Block Header
+- // along with Compressed Size and Uncompressed Size can be
+- // written there.
+- lzma_ret ret = lzma_block_header_size(&thr->block_options);
+- if (ret != LZMA_OK) {
+- worker_error(thr, ret);
+- return THR_STOP;
+- }
+-
+- // Initialize the Block encoder.
+- ret = lzma_block_encoder_init(&thr->block_encoder,
+- thr->allocator, &thr->block_options);
+- if (ret != LZMA_OK) {
+- worker_error(thr, ret);
+- return THR_STOP;
+- }
+-
+- size_t in_pos = 0;
+- size_t in_size = 0;
+-
+- thr->outbuf->size = thr->block_options.header_size;
+- const size_t out_size = thr->coder->outq.buf_size_max;
+-
+- do {
+- mythread_sync(thr->mutex) {
+- while (in_size == thr->in_size
+- && thr->state == THR_RUN)
+- pthread_cond_wait(&thr->cond, &thr->mutex);
+-
+- state = thr->state;
+- in_size = thr->in_size;
+-
+- // TODO? Store in_pos and out_pos into *thr here
+- // so that the application may read them via
+- // some currently non-existing function to get
+- // progress information.
+- }
+-
+- // Return if we were asked to stop or exit.
+- if (state >= THR_STOP)
+- return state;
+-
+- lzma_action action = state == THR_FINISH
+- ? LZMA_FINISH : LZMA_RUN;
+-
+- // Limit the amount of input given to the Block encoder
+- // at once. This way this thread can react fairly quickly
+- // if the main thread wants us to stop or exit.
+- static const size_t in_chunk_max = 16384;
+- size_t in_limit = in_size;
+- if (in_size - in_pos > in_chunk_max) {
+- in_limit = in_pos + in_chunk_max;
+- action = LZMA_RUN;
+- }
+-
+- ret = thr->block_encoder.code(
+- thr->block_encoder.coder, thr->allocator,
+- thr->in, &in_pos, in_limit, thr->outbuf->buf,
+- &thr->outbuf->size, out_size, action);
+- } while (ret == LZMA_OK);
+-
+- if (ret != LZMA_STREAM_END) {
+- worker_error(thr, ret);
+- return THR_STOP;
+- }
+-
+- assert(state == THR_FINISH);
+-
+- // Encode the Block Header. By doing it after the compression,
+- // we can store the Compressed Size and Uncompressed Size fields.
+- ret = lzma_block_header_encode(&thr->block_options, thr->outbuf->buf);
+- if (ret != LZMA_OK) {
+- worker_error(thr, ret);
+- return THR_STOP;
+- }
+-
+- // Set the size information that will be read by the main thread
+- // to write the Index field.
+- thr->outbuf->unpadded_size
+- = lzma_block_unpadded_size(&thr->block_options);
+- assert(thr->outbuf->unpadded_size != 0);
+- thr->outbuf->uncompressed_size = thr->block_options.uncompressed_size;
+-
+- return THR_FINISH;
+-}
+-
+-
+-static void *
+-worker_start(void *thr_ptr)
+-{
+- worker_thread *thr = thr_ptr;
+- worker_state state = THR_IDLE; // Init to silence a warning
+-
+- while (true) {
+- // Wait for work.
+- mythread_sync(thr->mutex) {
+- while (true) {
+- // The thread is already idle so if we are
+- // requested to stop, just set the state.
+- if (thr->state == THR_STOP) {
+- thr->state = THR_IDLE;
+- pthread_cond_signal(&thr->cond);
+- }
+-
+- state = thr->state;
+- if (state != THR_IDLE)
+- break;
+-
+- pthread_cond_wait(&thr->cond, &thr->mutex);
+- }
+- }
+-
+- assert(state != THR_IDLE);
+- assert(state != THR_STOP);
+-
+- if (state <= THR_FINISH)
+- state = worker_encode(thr, state);
+-
+- if (state == THR_EXIT)
+- break;
+-
+- // Mark the thread as idle. Signal is needed for the case
+- // where the main thread is waiting for the threads to stop.
+- mythread_sync(thr->mutex) {
+- thr->state = THR_IDLE;
+- pthread_cond_signal(&thr->cond);
+- }
+-
+- mythread_sync(thr->coder->mutex) {
+- // Mark the output buffer as finished if
+- // no errors occurred.
+- thr->outbuf->finished = state == THR_FINISH;
+-
+- // Return this thread to the stack of free threads.
+- thr->next = thr->coder->threads_free;
+- thr->coder->threads_free = thr;
+-
+- mythread_cond_signal(&thr->coder->cond);
+- }
+- }
+-
+- // Exiting, free the resources.
+- pthread_mutex_destroy(&thr->mutex);
+- pthread_cond_destroy(&thr->cond);
+-
+- lzma_next_end(&thr->block_encoder, thr->allocator);
+- lzma_free(thr->in, thr->allocator);
+- return NULL;
+-}
+-
+-
+-/// Make the threads stop but not exit. Optionally wait for them to stop.
+-static void
+-threads_stop(lzma_coder *coder, bool wait)
+-{
+- // Tell the threads to stop.
+- for (uint32_t i = 0; i < coder->threads_initialized; ++i) {
+- mythread_sync(coder->threads[i].mutex) {
+- coder->threads[i].state = THR_STOP;
+- pthread_cond_signal(&coder->threads[i].cond);
+- }
+- }
+-
+- if (!wait)
+- return;
+-
+- // Wait for the threads to settle in the idle state.
+- for (uint32_t i = 0; i < coder->threads_initialized; ++i) {
+- mythread_sync(coder->threads[i].mutex) {
+- while (coder->threads[i].state != THR_IDLE)
+- pthread_cond_wait(&coder->threads[i].cond,
+- &coder->threads[i].mutex);
+- }
+- }
+-
+- return;
+-}
+-
+-
+-/// Stop the threads and free the resources associated with them.
+-/// Wait until the threads have exited.
+-static void
+-threads_end(lzma_coder *coder, lzma_allocator *allocator)
+-{
+- for (uint32_t i = 0; i < coder->threads_initialized; ++i) {
+- mythread_sync(coder->threads[i].mutex) {
+- coder->threads[i].state = THR_EXIT;
+- pthread_cond_signal(&coder->threads[i].cond);
+- }
+- }
+-
+- for (uint32_t i = 0; i < coder->threads_initialized; ++i) {
+- int ret = pthread_join(coder->threads[i].thread_id, NULL);
+- assert(ret == 0);
+- (void)ret;
+- }
+-
+- lzma_free(coder->threads, allocator);
+- return;
+-}
+-
+-
+-/// Initialize a new worker_thread structure and create a new thread.
+-static lzma_ret
+-initialize_new_thread(lzma_coder *coder, lzma_allocator *allocator)
+-{
+- worker_thread *thr = &coder->threads[coder->threads_initialized];
+-
+- thr->in = lzma_alloc(coder->block_size, allocator);
+- if (thr->in == NULL)
+- return LZMA_MEM_ERROR;
+-
+- if (pthread_mutex_init(&thr->mutex, NULL))
+- goto error_mutex;
+-
+- if (pthread_cond_init(&thr->cond, NULL))
+- goto error_cond;
+-
+- thr->state = THR_IDLE;
+- thr->allocator = allocator;
+- thr->coder = coder;
+- thr->block_encoder = LZMA_NEXT_CODER_INIT;
+-
+- if (mythread_create(&thr->thread_id, &worker_start, thr))
+- goto error_thread;
+-
+- ++coder->threads_initialized;
+- coder->thr = thr;
+-
+- return LZMA_OK;
+-
+-error_thread:
+- pthread_cond_destroy(&thr->cond);
+-
+-error_cond:
+- pthread_mutex_destroy(&thr->mutex);
+-
+-error_mutex:
+- lzma_free(thr->in, allocator);
+- return LZMA_MEM_ERROR;
+-}
+-
+-
+-static lzma_ret
+-get_thread(lzma_coder *coder, lzma_allocator *allocator)
+-{
+- // If there are no free output subqueues, there is no
+- // point to try getting a thread.
+- if (!lzma_outq_has_buf(&coder->outq))
+- return LZMA_OK;
+-
+- // If there is a free structure on the stack, use it.
+- mythread_sync(coder->mutex) {
+- if (coder->threads_free != NULL) {
+- coder->thr = coder->threads_free;
+- coder->threads_free = coder->threads_free->next;
+- }
+- }
+-
+- if (coder->thr == NULL) {
+- // If there are no uninitialized structures left, return.
+- if (coder->threads_initialized == coder->threads_max)
+- return LZMA_OK;
+-
+- // Initialize a new thread.
+- return_if_error(initialize_new_thread(coder, allocator));
+- }
+-
+- // Reset the parts of the thread state that have to be done
+- // in the main thread.
+- mythread_sync(coder->thr->mutex) {
+- coder->thr->state = THR_RUN;
+- coder->thr->in_size = 0;
+- coder->thr->outbuf = lzma_outq_get_buf(&coder->outq);
+- pthread_cond_signal(&coder->thr->cond);
+- }
+-
+- return LZMA_OK;
+-}
+-
+-
+-static lzma_ret
+-stream_encode_in(lzma_coder *coder, lzma_allocator *allocator,
+- const uint8_t *restrict in, size_t *restrict in_pos,
+- size_t in_size, lzma_action action)
+-{
+- while (*in_pos < in_size
+- || (coder->thr != NULL && action != LZMA_RUN)) {
+- if (coder->thr == NULL) {
+- // Get a new thread.
+- const lzma_ret ret = get_thread(coder, allocator);
+- if (coder->thr == NULL)
+- return ret;
+- }
+-
+- // Copy the input data to thread's buffer.
+- size_t thr_in_size = coder->thr->in_size;
+- lzma_bufcpy(in, in_pos, in_size, coder->thr->in,
+- &thr_in_size, coder->block_size);
+-
+- // Tell the Block encoder to finish if
+- // - it has got block_size bytes of input; or
+- // - all input was used and LZMA_FINISH, LZMA_FULL_FLUSH,
+- // or LZMA_FULL_BARRIER was used.
+- //
+- // TODO: LZMA_SYNC_FLUSH and LZMA_SYNC_BARRIER.
+- const bool finish = thr_in_size == coder->block_size
+- || (*in_pos == in_size && action != LZMA_RUN);
+-
+- bool block_error = false;
+-
+- mythread_sync(coder->thr->mutex) {
+- if (coder->thr->state == THR_IDLE) {
+- // Something has gone wrong with the Block
+- // encoder. It has set coder->thread_error
+- // which we will read a few lines later.
+- block_error = true;
+- } else {
+- // Tell the Block encoder its new amount
+- // of input and update the state if needed.
+- coder->thr->in_size = thr_in_size;
+-
+- if (finish)
+- coder->thr->state = THR_FINISH;
+-
+- pthread_cond_signal(&coder->thr->cond);
+- }
+- }
+-
+- if (block_error) {
+- lzma_ret ret;
+-
+- mythread_sync(coder->mutex) {
+- ret = coder->thread_error;
+- }
+-
+- return ret;
+- }
+-
+- if (finish)
+- coder->thr = NULL;
+- }
+-
+- return LZMA_OK;
+-}
+-
+-
+-/// Wait until more input can be consumed, more output can be read, or
+-/// an optional timeout is reached.
+-static bool
+-wait_for_work(lzma_coder *coder, struct timespec *wait_abs,
+- bool *has_blocked, bool has_input)
+-{
+- if (coder->has_timeout && !*has_blocked) {
+- // Every time when stream_encode_mt() is called via
+- // lzma_code(), *has_block starts as false. We set it
+- // to true here and calculate the absolute time when
+- // we must return if there's nothing to do.
+- //
+- // The idea of *has_blocked is to avoid unneeded calls
+- // to mythread_cond_abstime(), which may do a syscall
+- // depending on the operating system.
+- *has_blocked = true;
+- *wait_abs = coder->wait_max;
+- mythread_cond_abstime(&coder->cond, wait_abs);
+- }
+-
+- bool timed_out = false;
+-
+- mythread_sync(coder->mutex) {
+- // There are four things that we wait. If one of them
+- // becomes possible, we return.
+- // - If there is input left, we need to get a free
+- // worker thread and an output buffer for it.
+- // - Data ready to be read from the output queue.
+- // - A worker thread indicates an error.
+- // - Time out occurs.
+- while ((!has_input || coder->threads_free == NULL
+- || !lzma_outq_has_buf(&coder->outq))
+- && !lzma_outq_is_readable(&coder->outq)
+- && coder->thread_error == LZMA_OK
+- && !timed_out) {
+- if (coder->has_timeout)
+- timed_out = mythread_cond_timedwait(
+- &coder->cond, &coder->mutex,
+- wait_abs) != 0;
+- else
+- mythread_cond_wait(&coder->cond,
+- &coder->mutex);
+- }
+- }
+-
+- return timed_out;
+-}
+-
+-
+-static lzma_ret
+-stream_encode_mt(lzma_coder *coder, lzma_allocator *allocator,
+- const uint8_t *restrict in, size_t *restrict in_pos,
+- size_t in_size, uint8_t *restrict out,
+- size_t *restrict out_pos, size_t out_size, lzma_action action)
+-{
+- switch (coder->sequence) {
+- case SEQ_STREAM_HEADER:
+- lzma_bufcpy(coder->header, &coder->header_pos,
+- sizeof(coder->header),
+- out, out_pos, out_size);
+- if (coder->header_pos < sizeof(coder->header))
+- return LZMA_OK;
+-
+- coder->header_pos = 0;
+- coder->sequence = SEQ_BLOCK;
+-
+- // Fall through
+-
+- case SEQ_BLOCK: {
+- // Initialized to silence warnings.
+- lzma_vli unpadded_size = 0;
+- lzma_vli uncompressed_size = 0;
+- lzma_ret ret = LZMA_OK;
+-
+- // These are for wait_for_work().
+- bool has_blocked = false;
+- struct timespec wait_abs;
+-
+- while (true) {
+- mythread_sync(coder->mutex) {
+- // Check for Block encoder errors.
+- ret = coder->thread_error;
+- if (ret != LZMA_OK) {
+- assert(ret != LZMA_STREAM_END);
+- break;
+- }
+-
+- // Try to read compressed data to out[].
+- ret = lzma_outq_read(&coder->outq,
+- out, out_pos, out_size,
+- &unpadded_size,
+- &uncompressed_size);
+- }
+-
+- if (ret == LZMA_STREAM_END) {
+- // End of Block. Add it to the Index.
+- ret = lzma_index_append(coder->index,
+- allocator, unpadded_size,
+- uncompressed_size);
+-
+- // If we didn't fill the output buffer yet,
+- // try to read more data. Maybe the next
+- // outbuf has been finished already too.
+- if (*out_pos < out_size)
+- continue;
+- }
+-
+- if (ret != LZMA_OK) {
+- // coder->thread_error was set or
+- // lzma_index_append() failed.
+- threads_stop(coder, false);
+- return ret;
+- }
+-
+- // Check if the last Block was finished.
+- if (action == LZMA_FINISH
+- && *in_pos == in_size
+- && lzma_outq_is_empty(
+- &coder->outq))
+- break;
+-
+- // Try to give uncompressed data to a worker thread.
+- ret = stream_encode_in(coder, allocator,
+- in, in_pos, in_size, action);
+- if (ret != LZMA_OK) {
+- threads_stop(coder, false);
+- return ret;
+- }
+-
+- // Return if
+- // - we have used all the input and expect to
+- // get more input; or
+- // - the output buffer has been filled.
+- //
+- // TODO: Support flushing.
+- if ((*in_pos == in_size && action != LZMA_FINISH)
+- || *out_pos == out_size)
+- return LZMA_OK;
+-
+- // Neither in nor out has been used completely.
+- // Wait until there's something we can do.
+- if (wait_for_work(coder, &wait_abs, &has_blocked,
+- *in_pos < in_size))
+- return LZMA_TIMED_OUT;
+- }
+-
+- // All Blocks have been encoded and the threads have stopped.
+- // Prepare to encode the Index field.
+- return_if_error(lzma_index_encoder_init(
+- &coder->index_encoder, allocator,
+- coder->index));
+- coder->sequence = SEQ_INDEX;
+- }
+-
+- // Fall through
+-
+- case SEQ_INDEX: {
+- // Call the Index encoder. It doesn't take any input, so
+- // those pointers can be NULL.
+- const lzma_ret ret = coder->index_encoder.code(
+- coder->index_encoder.coder, allocator,
+- NULL, NULL, 0,
+- out, out_pos, out_size, LZMA_RUN);
+- if (ret != LZMA_STREAM_END)
+- return ret;
+-
+- // Encode the Stream Footer into coder->buffer.
+- coder->stream_flags.backward_size
+- = lzma_index_size(coder->index);
+- if (lzma_stream_footer_encode(&coder->stream_flags,
+- coder->header) != LZMA_OK)
+- return LZMA_PROG_ERROR;
+-
+- coder->sequence = SEQ_STREAM_FOOTER;
+- }
+-
+- // Fall through
+-
+- case SEQ_STREAM_FOOTER:
+- lzma_bufcpy(coder->header, &coder->header_pos,
+- sizeof(coder->header),
+- out, out_pos, out_size);
+- return coder->header_pos < sizeof(coder->header)
+- ? LZMA_OK : LZMA_STREAM_END;
+- }
+-
+- assert(0);
+- return LZMA_PROG_ERROR;
+-}
+-
+-
+-static void
+-stream_encoder_mt_end(lzma_coder *coder, lzma_allocator *allocator)
+-{
+- // Threads must be killed before the output queue can be freed.
+- threads_end(coder, allocator);
+- lzma_outq_end(&coder->outq, allocator);
+-
+- for (size_t i = 0; coder->filters[i].id != LZMA_VLI_UNKNOWN; ++i)
+- lzma_free(coder->filters[i].options, allocator);
+-
+- lzma_next_end(&coder->index_encoder, allocator);
+- lzma_index_end(coder->index, allocator);
+-
+- mythread_cond_destroy(&coder->cond);
+- pthread_mutex_destroy(&coder->mutex);
+-
+- lzma_free(coder, allocator);
+- return;
+-}
+-
+-
+-/// Options handling for lzma_stream_encoder_mt_init() and
+-/// lzma_stream_encoder_mt_memusage()
+-static lzma_ret
+-get_options(const lzma_mt *options, lzma_options_easy *opt_easy,
+- const lzma_filter **filters, uint64_t *block_size,
+- uint64_t *outbuf_size_max)
+-{
+- // Validate some of the options.
+- if (options == NULL)
+- return LZMA_PROG_ERROR;
+-
+- if (options->flags != 0 || options->threads == 0
+- || options->threads > LZMA_THREADS_MAX)
+- return LZMA_OPTIONS_ERROR;
+-
+- if (options->filters != NULL) {
+- // Filter chain was given, use it as is.
+- *filters = options->filters;
+- } else {
+- // Use a preset.
+- if (lzma_easy_preset(opt_easy, options->preset))
+- return LZMA_OPTIONS_ERROR;
+-
+- *filters = opt_easy->filters;
+- }
+-
+- // Block size
+- if (options->block_size > 0) {
+- if (options->block_size > BLOCK_SIZE_MAX)
+- return LZMA_OPTIONS_ERROR;
+-
+- *block_size = options->block_size;
+- } else {
+- // Determine the Block size from the filter chain.
+- *block_size = lzma_mt_block_size(*filters);
+- if (*block_size == 0)
+- return LZMA_OPTIONS_ERROR;
+-
+- assert(*block_size <= BLOCK_SIZE_MAX);
+- }
+-
+- // Calculate the maximum amount output that a single output buffer
+- // may need to hold. This is the same as the maximum total size of
+- // a Block.
+- //
+- // FIXME: As long as the encoder keeps the whole input buffer
+- // available and doesn't start writing output before finishing
+- // the Block, it could use lzma_stream_buffer_bound() and use
+- // uncompressed LZMA2 chunks if the data doesn't compress.
+- *outbuf_size_max = *block_size + *block_size / 16 + 16384;
+-
+- return LZMA_OK;
+-}
+-
+-
+-static lzma_ret
+-stream_encoder_mt_init(lzma_next_coder *next, lzma_allocator *allocator,
+- const lzma_mt *options)
+-{
+- lzma_next_coder_init(&stream_encoder_mt_init, next, allocator);
+-
+- // Get the filter chain.
+- lzma_options_easy easy;
+- const lzma_filter *filters;
+- uint64_t block_size;
+- uint64_t outbuf_size_max;
+- return_if_error(get_options(options, &easy, &filters,
+- &block_size, &outbuf_size_max));
+-
+-#if SIZE_MAX < UINT64_MAX
+- if (block_size > SIZE_MAX)
+- return LZMA_MEM_ERROR;
+-#endif
+-
+- // FIXME TODO: Validate the filter chain so that we can give
+- // an error in this function instead of delaying it to the first
+- // call to lzma_code().
+-
+- // Validate the Check ID.
+- if ((unsigned int)(options->check) > LZMA_CHECK_ID_MAX)
+- return LZMA_PROG_ERROR;
+-
+- if (!lzma_check_is_supported(options->check))
+- return LZMA_UNSUPPORTED_CHECK;
+-
+- // Allocate and initialize the base structure if needed.
+- if (next->coder == NULL) {
+- next->coder = lzma_alloc(sizeof(lzma_coder), allocator);
+- if (next->coder == NULL)
+- return LZMA_MEM_ERROR;
+-
+- // For the mutex and condition variable initializations
+- // the error handling has to be done here because
+- // stream_encoder_mt_end() doesn't know if they have
+- // already been initialized or not.
+- if (pthread_mutex_init(&next->coder->mutex, NULL)) {
+- lzma_free(next->coder, allocator);
+- next->coder = NULL;
+- return LZMA_MEM_ERROR;
+- }
+-
+- if (mythread_cond_init(&next->coder->cond)) {
+- pthread_mutex_destroy(&next->coder->mutex);
+- lzma_free(next->coder, allocator);
+- next->coder = NULL;
+- return LZMA_MEM_ERROR;
+- }
+-
+- next->code = &stream_encode_mt;
+- next->end = &stream_encoder_mt_end;
+-// next->update = &stream_encoder_mt_update;
+-
+- next->coder->filters[0].id = LZMA_VLI_UNKNOWN;
+- next->coder->index_encoder = LZMA_NEXT_CODER_INIT;
+- next->coder->index = NULL;
+- memzero(&next->coder->outq, sizeof(next->coder->outq));
+- next->coder->threads = NULL;
+- next->coder->threads_max = 0;
+- next->coder->threads_initialized = 0;
+- }
+-
+- // Basic initializations
+- next->coder->sequence = SEQ_STREAM_HEADER;
+- next->coder->block_size = (size_t)(block_size);
+- next->coder->thread_error = LZMA_OK;
+- next->coder->thr = NULL;
+-
+- // Allocate the thread-specific base structures.
+- assert(options->threads > 0);
+- if (next->coder->threads_max != options->threads) {
+- threads_end(next->coder, allocator);
+-
+- next->coder->threads = NULL;
+- next->coder->threads_max = 0;
+-
+- next->coder->threads_initialized = 0;
+- next->coder->threads_free = NULL;
+-
+- next->coder->threads = lzma_alloc(
+- options->threads * sizeof(worker_thread),
+- allocator);
+- if (next->coder->threads == NULL)
+- return LZMA_MEM_ERROR;
+-
+- next->coder->threads_max = options->threads;
+- } else {
+- // Reuse the old structures and threads. Tell the running
+- // threads to stop and wait until they have stopped.
+- threads_stop(next->coder, true);
+- }
+-
+- // Output queue
+- return_if_error(lzma_outq_init(&next->coder->outq, allocator,
+- outbuf_size_max, options->threads));
+-
+- // Timeout
+- if (options->timeout > 0) {
+- next->coder->wait_max.tv_sec = options->timeout / 1000;
+- next->coder->wait_max.tv_nsec
+- = (options->timeout % 1000) * 1000000L;
+- next->coder->has_timeout = true;
+- } else {
+- next->coder->has_timeout = false;
+- }
+-
+- // Free the old filter chain and copy the new one.
+- for (size_t i = 0; next->coder->filters[i].id != LZMA_VLI_UNKNOWN; ++i)
+- lzma_free(next->coder->filters[i].options, allocator);
+-
+- return_if_error(lzma_filters_copy(options->filters,
+- next->coder->filters, allocator));
+-
+- // Index
+- lzma_index_end(next->coder->index, allocator);
+- next->coder->index = lzma_index_init(allocator);
+- if (next->coder->index == NULL)
+- return LZMA_MEM_ERROR;
+-
+- // Stream Header
+- next->coder->stream_flags.version = 0;
+- next->coder->stream_flags.check = options->check;
+- return_if_error(lzma_stream_header_encode(
+- &next->coder->stream_flags, next->coder->header));
+-
+- next->coder->header_pos = 0;
+-
+- return LZMA_OK;
+-}
+-
+-
+-extern LZMA_API(lzma_ret)
+-lzma_stream_encoder_mt(lzma_stream *strm, const lzma_mt *options)
+-{
+- lzma_next_strm_init(stream_encoder_mt_init, strm, options);
+-
+- strm->internal->supported_actions[LZMA_RUN] = true;
+-// strm->internal->supported_actions[LZMA_SYNC_FLUSH] = true;
+-// strm->internal->supported_actions[LZMA_FULL_FLUSH] = true;
+-// strm->internal->supported_actions[LZMA_FULL_BARRIER] = true;
+- strm->internal->supported_actions[LZMA_FINISH] = true;
+-
+- return LZMA_OK;
+-}
+-
+-
+-// This function name is a monster but it's consistent with the older
+-// monster names. :-( 31 chars is the max that C99 requires so in that
+-// sense it's not too long. ;-)
+-extern LZMA_API(uint64_t)
+-lzma_stream_encoder_mt_memusage(const lzma_mt *options)
+-{
+- lzma_options_easy easy;
+- const lzma_filter *filters;
+- uint64_t block_size;
+- uint64_t outbuf_size_max;
+-
+- if (get_options(options, &easy, &filters, &block_size,
+- &outbuf_size_max) != LZMA_OK)
+- return UINT64_MAX;
+-
+- // Memory usage of the input buffers
+- const uint64_t inbuf_memusage = options->threads * block_size;
+-
+- // Memory usage of the filter encoders
+- uint64_t filters_memusage
+- = lzma_raw_encoder_memusage(options->filters);
+- if (filters_memusage == UINT64_MAX)
+- return UINT64_MAX;
+-
+- filters_memusage *= options->threads;
+-
+- // Memory usage of the output queue
+- const uint64_t outq_memusage = lzma_outq_memusage(
+- outbuf_size_max, options->threads);
+- if (outq_memusage == UINT64_MAX)
+- return UINT64_MAX;
+-
+- // Sum them with overflow checking.
+- uint64_t total_memusage = LZMA_MEMUSAGE_BASE + sizeof(lzma_coder)
+- + options->threads * sizeof(worker_thread);
+-
+- if (UINT64_MAX - total_memusage < inbuf_memusage)
+- return UINT64_MAX;
+-
+- total_memusage += inbuf_memusage;
+-
+- if (UINT64_MAX - total_memusage < filters_memusage)
+- return UINT64_MAX;
+-
+- total_memusage += filters_memusage;
+-
+- if (UINT64_MAX - total_memusage < outq_memusage)
+- return UINT64_MAX;
+-
+- return total_memusage + outq_memusage;
+-}
+diff --git a/src/xz/args.c b/src/xz/args.c
+index dea93c5..f207e7f 100644
+--- a/src/xz/args.c
++++ b/src/xz/args.c
+@@ -179,9 +179,8 @@ parse_real(args_info *args, int argc, char **argv)
+ break;
+
+ case 'T':
+- // The max is from src/liblzma/common/common.h.
+- hardware_threads_set(str_to_uint64("threads",
+- optarg, 0, 16384));
++ hardware_threadlimit_set(str_to_uint64(
++ "threads", optarg, 0, UINT32_MAX));
+ break;
+
+ // --version
+diff --git a/src/xz/coder.c b/src/xz/coder.c
+index 41193a7..4139da4 100644
+--- a/src/xz/coder.c
++++ b/src/xz/coder.c
+@@ -55,14 +55,6 @@ static lzma_check check;
+ /// This becomes false if the --check=CHECK option is used.
+ static bool check_default = true;
+
+-#ifdef HAVE_PTHREAD
+-static lzma_mt mt_options = {
+- .flags = 0,
+- .timeout = 300,
+- .filters = filters,
+-};
+-#endif
+-
+
+ extern void
+ coder_set_check(lzma_check new_check)
+@@ -125,15 +117,6 @@ memlimit_too_small(uint64_t memory_usage)
+ extern void
+ coder_set_compression_settings(void)
+ {
+- // The default check type is CRC64, but fallback to CRC32
+- // if CRC64 isn't supported by the copy of liblzma we are
+- // using. CRC32 is always supported.
+- if (check_default) {
+- check = LZMA_CHECK_CRC64;
+- if (!lzma_check_is_supported(check))
+- check = LZMA_CHECK_CRC32;
+- }
+-
+ // Options for LZMA1 or LZMA2 in case we are using a preset.
+ static lzma_options_lzma opt_lzma;
+
+@@ -187,30 +170,15 @@ coder_set_compression_settings(void)
+ // Print the selected filter chain.
+ message_filters_show(V_DEBUG, filters);
+
+- // Get the memory usage. Note that if --format=raw was used,
+- // we can be decompressing.
++ // If using --format=raw, we can be decoding. The memusage function
++ // also validates the filter chain and the options used for the
++ // filters.
+ const uint64_t memory_limit = hardware_memlimit_get(opt_mode);
+ uint64_t memory_usage;
+- if (opt_mode == MODE_COMPRESS) {
+-#ifdef HAVE_PTHREAD
+- if (opt_format == FORMAT_XZ && hardware_threads_get() > 1) {
+- mt_options.threads = hardware_threads_get();
+- mt_options.block_size = opt_block_size;
+- mt_options.check = check;
+- memory_usage = lzma_stream_encoder_mt_memusage(
+- &mt_options);
+- if (memory_usage != UINT64_MAX)
+- message(V_DEBUG, _("Using up to %" PRIu32
+- " threads."),
+- mt_options.threads);
+- } else
+-#endif
+- {
+- memory_usage = lzma_raw_encoder_memusage(filters);
+- }
+- } else {
++ if (opt_mode == MODE_COMPRESS)
++ memory_usage = lzma_raw_encoder_memusage(filters);
++ else
+ memory_usage = lzma_raw_decoder_memusage(filters);
+- }
+
+ if (memory_usage == UINT64_MAX)
+ message_fatal(_("Unsupported filter chain or filter options"));
+@@ -226,99 +194,90 @@ coder_set_compression_settings(void)
+ round_up_to_mib(decmem), 0));
+ }
+
+- if (memory_usage <= memory_limit)
+- return;
++ if (memory_usage > memory_limit) {
++ // If --no-auto-adjust was used or we didn't find LZMA1 or
++ // LZMA2 as the last filter, give an error immediately.
++ // --format=raw implies --no-auto-adjust.
++ if (!opt_auto_adjust || opt_format == FORMAT_RAW)
++ memlimit_too_small(memory_usage);
+
+- // If --no-auto-adjust was used or we didn't find LZMA1 or
+- // LZMA2 as the last filter, give an error immediately.
+- // --format=raw implies --no-auto-adjust.
+- if (!opt_auto_adjust || opt_format == FORMAT_RAW)
+- memlimit_too_small(memory_usage);
++ assert(opt_mode == MODE_COMPRESS);
+
+- assert(opt_mode == MODE_COMPRESS);
++ // Look for the last filter if it is LZMA2 or LZMA1, so
++ // we can make it use less RAM. With other filters we don't
++ // know what to do.
++ size_t i = 0;
++ while (filters[i].id != LZMA_FILTER_LZMA2
++ && filters[i].id != LZMA_FILTER_LZMA1) {
++ if (filters[i].id == LZMA_VLI_UNKNOWN)
++ memlimit_too_small(memory_usage);
++
++ ++i;
++ }
+
+-#ifdef HAVE_PTHREAD
+- if (opt_format == FORMAT_XZ && mt_options.threads > 1) {
+- // Try to reduce the number of threads before
+- // adjusting the compression settings down.
+- do {
+- // FIXME? The real single-threaded mode has
+- // lower memory usage, but it's not comparable
+- // because it doesn't write the size info
+- // into Block Headers.
+- if (--mt_options.threads == 0)
++ // Decrease the dictionary size until we meet the memory
++ // usage limit. First round down to full mebibytes.
++ lzma_options_lzma *opt = filters[i].options;
++ const uint32_t orig_dict_size = opt->dict_size;
++ opt->dict_size &= ~((UINT32_C(1) << 20) - 1);
++ while (true) {
++ // If it is below 1 MiB, auto-adjusting failed. We
++ // could be more sophisticated and scale it down even
++ // more, but let's see if many complain about this
++ // version.
++ //
++ // FIXME: Displays the scaled memory usage instead
++ // of the original.
++ if (opt->dict_size < (UINT32_C(1) << 20))
+ memlimit_too_small(memory_usage);
+
+- memory_usage = lzma_stream_encoder_mt_memusage(
+- &mt_options);
++ memory_usage = lzma_raw_encoder_memusage(filters);
+ if (memory_usage == UINT64_MAX)
+ message_bug();
+
+- } while (memory_usage > memory_limit);
+-
+- message(V_WARNING, _("Adjusted the number of threads "
+- "from %s to %s to not exceed "
+- "the memory usage limit of %s MiB"),
+- uint64_to_str(hardware_threads_get(), 0),
+- uint64_to_str(mt_options.threads, 1),
+- uint64_to_str(round_up_to_mib(
+- memory_limit), 2));
++ // Accept it if it is low enough.
++ if (memory_usage <= memory_limit)
++ break;
++
++ // Otherwise 1 MiB down and try again. I hope this
++ // isn't too slow method for cases where the original
++ // dict_size is very big.
++ opt->dict_size -= UINT32_C(1) << 20;
++ }
++
++ // Tell the user that we decreased the dictionary size.
++ message(V_WARNING, _("Adjusted LZMA%c dictionary size "
++ "from %s MiB to %s MiB to not exceed "
++ "the memory usage limit of %s MiB"),
++ filters[i].id == LZMA_FILTER_LZMA2
++ ? '2' : '1',
++ uint64_to_str(orig_dict_size >> 20, 0),
++ uint64_to_str(opt->dict_size >> 20, 1),
++ uint64_to_str(round_up_to_mib(
++ memory_limit), 2));
+ }
+-#endif
+-
+- if (memory_usage <= memory_limit)
+- return;
+-
+- // Look for the last filter if it is LZMA2 or LZMA1, so we can make
+- // it use less RAM. With other filters we don't know what to do.
+- size_t i = 0;
+- while (filters[i].id != LZMA_FILTER_LZMA2
+- && filters[i].id != LZMA_FILTER_LZMA1) {
+- if (filters[i].id == LZMA_VLI_UNKNOWN)
+- memlimit_too_small(memory_usage);
+
+- ++i;
++/*
++ // Limit the number of worker threads so that memory usage
++ // limit isn't exceeded.
++ assert(memory_usage > 0);
++ size_t thread_limit = memory_limit / memory_usage;
++ if (thread_limit == 0)
++ thread_limit = 1;
++
++ if (opt_threads > thread_limit)
++ opt_threads = thread_limit;
++*/
++
++ if (check_default) {
++ // The default check type is CRC64, but fallback to CRC32
++ // if CRC64 isn't supported by the copy of liblzma we are
++ // using. CRC32 is always supported.
++ check = LZMA_CHECK_CRC64;
++ if (!lzma_check_is_supported(check))
++ check = LZMA_CHECK_CRC32;
+ }
+
+- // Decrease the dictionary size until we meet the memory
+- // usage limit. First round down to full mebibytes.
+- lzma_options_lzma *opt = filters[i].options;
+- const uint32_t orig_dict_size = opt->dict_size;
+- opt->dict_size &= ~((UINT32_C(1) << 20) - 1);
+- while (true) {
+- // If it is below 1 MiB, auto-adjusting failed. We could be
+- // more sophisticated and scale it down even more, but let's
+- // see if many complain about this version.
+- //
+- // FIXME: Displays the scaled memory usage instead
+- // of the original.
+- if (opt->dict_size < (UINT32_C(1) << 20))
+- memlimit_too_small(memory_usage);
+-
+- memory_usage = lzma_raw_encoder_memusage(filters);
+- if (memory_usage == UINT64_MAX)
+- message_bug();
+-
+- // Accept it if it is low enough.
+- if (memory_usage <= memory_limit)
+- break;
+-
+- // Otherwise 1 MiB down and try again. I hope this
+- // isn't too slow method for cases where the original
+- // dict_size is very big.
+- opt->dict_size -= UINT32_C(1) << 20;
+- }
+-
+- // Tell the user that we decreased the dictionary size.
+- message(V_WARNING, _("Adjusted LZMA%c dictionary size "
+- "from %s MiB to %s MiB to not exceed "
+- "the memory usage limit of %s MiB"),
+- filters[i].id == LZMA_FILTER_LZMA2
+- ? '2' : '1',
+- uint64_to_str(orig_dict_size >> 20, 0),
+- uint64_to_str(opt->dict_size >> 20, 1),
+- uint64_to_str(round_up_to_mib(memory_limit), 2));
+-
+ return;
+ }
+
+@@ -400,14 +359,7 @@ coder_init(file_pair *pair)
+ break;
+
+ case FORMAT_XZ:
+-#ifdef HAVE_PTHREAD
+- if (hardware_threads_get() > 1)
+- ret = lzma_stream_encoder_mt(
+- &strm, &mt_options);
+- else
+-#endif
+- ret = lzma_stream_encoder(
+- &strm, filters, check);
++ ret = lzma_stream_encoder(&strm, filters, check);
+ break;
+
+ case FORMAT_LZMA:
+@@ -528,8 +480,8 @@ coder_normal(file_pair *pair)
+ // to the .xz format. If block_remaining == UINT64_MAX, only
+ // a single block is created.
+ uint64_t block_remaining = UINT64_MAX;
+- if (hardware_threads_get() == 1 && opt_mode == MODE_COMPRESS
+- && opt_format == FORMAT_XZ && opt_block_size > 0)
++ if (opt_mode == MODE_COMPRESS && opt_format == FORMAT_XZ
++ && opt_block_size > 0)
+ block_remaining = opt_block_size;
+
+ strm.next_out = out_buf.u8;
+diff --git a/src/xz/hardware.c b/src/xz/hardware.c
+index 925926c..a4733c2 100644
+--- a/src/xz/hardware.c
++++ b/src/xz/hardware.c
+@@ -14,9 +14,9 @@
+ #include "tuklib_cpucores.h"
+
+
+-/// Maximum number of worker threads. This can be set with
++/// Maximum number of free *coder* threads. This can be set with
+ /// the --threads=NUM command line option.
+-static uint32_t threads_max = 1;
++static uint32_t threadlimit;
+
+ /// Memory usage limit for compression
+ static uint64_t memlimit_compress;
+@@ -29,16 +29,15 @@ static uint64_t total_ram;
+
+
+ extern void
+-hardware_threads_set(uint32_t n)
++hardware_threadlimit_set(uint32_t new_threadlimit)
+ {
+- if (n == 0) {
+- // Automatic number of threads was requested.
+- // Use the number of available CPU cores.
+- threads_max = tuklib_cpucores();
+- if (threads_max == 0)
+- threads_max = 1;
++ if (new_threadlimit == 0) {
++ // The default is the number of available CPU cores.
++ threadlimit = tuklib_cpucores();
++ if (threadlimit == 0)
++ threadlimit = 1;
+ } else {
+- threads_max = n;
++ threadlimit = new_threadlimit;
+ }
+
+ return;
+@@ -46,9 +45,9 @@ hardware_threads_set(uint32_t n)
+
+
+ extern uint32_t
+-hardware_threads_get(void)
++hardware_threadlimit_get(void)
+ {
+- return threads_max;
++ return threadlimit;
+ }
+
+
+@@ -140,5 +139,6 @@ hardware_init(void)
+
+ // Set the defaults.
+ hardware_memlimit_set(0, true, true, false);
++ hardware_threadlimit_set(0);
+ return;
+ }
+diff --git a/src/xz/hardware.h b/src/xz/hardware.h
+index 4fae618..ad526f2 100644
+--- a/src/xz/hardware.h
++++ b/src/xz/hardware.h
+@@ -15,11 +15,12 @@
+ extern void hardware_init(void);
+
+
+-/// Set the maximum number of worker threads.
+-extern void hardware_threads_set(uint32_t threadlimit);
++/// Set custom value for maximum number of coder threads.
++extern void hardware_threadlimit_set(uint32_t threadlimit);
+
+-/// Get the maximum number of worker threads.
+-extern uint32_t hardware_threads_get(void);
++/// Get the maximum number of coder threads. Some additional helper threads
++/// are allowed on top of this).
++extern uint32_t hardware_threadlimit_get(void);
+
+
+ /// Set the memory usage limit. There are separate limits for compression
+diff --git a/src/xz/private.h b/src/xz/private.h
+index 978f81a..6b01e51 100644
+--- a/src/xz/private.h
++++ b/src/xz/private.h
+@@ -12,8 +12,6 @@
+
+ #include "sysdefs.h"
+ #include "mythread.h"
+-
+-#define LZMA_UNSTABLE
+ #include "lzma.h"
+
+ #include <sys/types.h>
+diff --git a/src/xz/xz.1 b/src/xz/xz.1
+index f4680f4..0329128 100644
+--- a/src/xz/xz.1
++++ b/src/xz/xz.1
+@@ -5,7 +5,7 @@
+ .\" This file has been put into the public domain.
+ .\" You can do whatever you want with this file.
+ .\"
+-.TH XZ 1 "2011-04-12" "Tukaani" "XZ Utils"
++.TH XZ 1 "2011-04-11" "Tukaani" "XZ Utils"
+ .
+ .SH NAME
+ xz, unxz, xzcat, lzma, unlzma, lzcat \- Compress or decompress .xz and .lzma files
+@@ -907,30 +907,24 @@ Automatic adjusting is always disabled when creating raw streams
+ .TP
+ \fB\-T\fR \fIthreads\fR, \fB\-\-threads=\fIthreads
+ Specify the number of worker threads to use.
+-Setting
+-.I threads
+-to a special value
+-.B 0
+-makes
+-.B xz
+-use as many threads as there are CPU cores on the system.
+ The actual number of threads can be less than
+ .I threads
+-if the input file is not big enough
+-for threading with the given settings or
+ if using more threads would exceed the memory usage limit.
+ .IP ""
+-Currently the only threading method is to split the input into
+-blocks and compress them independently from each other.
+-The default block size depends on the compression level and
+-can be overriden with the
+-.BI \-\-block\-size= size
+-option.
++.B "Multithreaded compression and decompression are not"
++.B "implemented yet, so this option has no effect for now."
+ .IP ""
+-.B "It is possible that the details of this option change before"
+-.B "the next stable XZ Utils release."
+-.B "This may include the meaning of the special value 0."
+-.\" FIXME
++.B "As of writing (2010-09-27), it hasn't been decided"
++.B "if threads will be used by default on multicore systems"
++.B "once support for threading has been implemented."
++.B "Comments are welcome."
++The complicating factor is that using many threads
++will increase the memory usage dramatically.
++Note that if multithreading will be the default,
++it will probably be done so that single-threaded and
++multithreaded modes produce the same output,
++so compression ratio won't be significantly affected
++if threading will be enabled by default.
+ .
+ .SS "Custom compressor filter chains"
+ A custom filter chain allows specifying
+--
+1.7.6
+
diff --git a/debian/patches/abi-version-script b/debian/patches/abi-version-script
new file mode 100644
index 0000000..2c5a2c4
--- /dev/null
+++ b/debian/patches/abi-version-script
@@ -0,0 +1,44 @@
+From: Jonathan Nieder <jrnieder@gmail.com>
+Date: Sat, 11 Jun 2011 23:33:43 -0500
+Subject: liblzma: Remove XZ_5.1.1alpha version symbol
+
+Now that the lzma_stream_encoder_mt{,_memusage} symbols are gone on
+this branch, liblzma should stop pretending to satisfy dependencies on
+XZ_5.1.1alpha.
+
+After this change, programs relying on those symbols will error out
+immediately at startup like they are supposed to:
+
+ app: liblzma.so.5: version `XZ_5.1.1alpha' not found (required by app)
+
+And your scripts that look for version definition entries with
+readelf -s (like RPM’s find-provides) can tell that this copy of
+liblzma lacks support for multithreaded encoding.
+
+Signed-off-by: Jonathan Nieder <jrnieder@gmail.com>
+---
+ src/liblzma/liblzma.map | 8 +-------
+ 1 files changed, 1 insertions(+), 7 deletions(-)
+
+diff --git a/src/liblzma/liblzma.map b/src/liblzma/liblzma.map
+index 835eb26..47a7c22 100644
+--- a/src/liblzma/liblzma.map
++++ b/src/liblzma/liblzma.map
+@@ -93,13 +93,7 @@ global:
+ lzma_vli_decode;
+ lzma_vli_encode;
+ lzma_vli_size;
+-};
+-
+-XZ_5.1.1alpha {
+-global:
+- lzma_stream_encoder_mt;
+- lzma_stream_encoder_mt_memusage;
+
+ local:
+ *;
+-} XZ_5.0;
++};
+--
+1.7.7
+
diff --git a/debian/patches/configure-liblzma2-compat b/debian/patches/configure-liblzma2-compat
new file mode 100644
index 0000000..46a9233
--- /dev/null
+++ b/debian/patches/configure-liblzma2-compat
@@ -0,0 +1,195 @@
+From: Jonathan Nieder <jrnieder@gmail.com>
+Date: Sat, 16 Jun 2012 05:57:42 -0500
+Subject: liblzma: make dlopen()-based liblzma2 compatibility optional
+
+Suppose I want to build a statically linked program:
+
+ gcc -static -o app app.c -lrpm -llzma
+
+Suppose further that librpm.a was built against a pre-5.0 version of
+liblzma so it does not allocate as much space for reserved fields at
+the end of lzma_stream as the current API requires.
+
+(This is a hypothetical scenario --- Debian librpm does not provide a
+static library.)
+
+If liblzma uses unpatched lzma_code() from XZ Utils >= 5.0, then
+during calls to librpm that try to compress or decompress an
+xz-compressed RPM, lzma_code’s reserved field checks will overflow the
+buffer and segfault.
+
+If liblzma uses the modified version of lzma_code() which asks libdl
+if liblzma.so.2 is resident and refrains from checking reserved fields
+past the end of the old lzma_stream struct when the answer is "yes",
+the behavior is no better. The dynamic library liblzma.so.2 is _not_
+resident, so lzma_code() dutifully reads reserved fields past the end
+of the buffer --- segfault.
+
+So the only safe behavior in the static library is to unconditionally
+disable checks that might break for callers we want to continue to
+support.
+
+The new "./configure --enable-liblzma2-compat" option implements all
+three sets of semantics:
+
+ - "./configure --disable-liblzma2-compat" means to check the full set
+ of reserved fields unconditionally. You can use this to check how
+ your application would behave with the unpatched library.
+
+ - "./configure --enable-liblzma2-compat=auto" means to skip checks of
+ reserved fields past the old end of struct lzma_stream when
+ liblzma.so.2 is resident. If a DSO built against liblzma2 shares
+ the process image, the ABI-incompatible checks are skipped for
+ safety, whereas in the usual case when no such DSO is resident, the
+ full set of checks is run to help application developers remember
+ to zero all reserved fields.
+
+ - "./configure --enable-liblzma2-compat" makes liblzma skip the
+ ABI-incompatible checks unconditionallty. You can use this if you
+ want your copy of liblzma to be usable by static libraries that
+ were built against the old library.
+
+Signed-off-by: Jonathan Nieder <jrnieder@gmail.com>
+---
+ configure.ac | 33 +++++++++++++++++++++++++++++++--
+ src/liblzma/common/common.c | 40 +++++++++++++++++++++++++++++++++++-----
+ src/liblzma/common/common.h | 2 ++
+ 3 files changed, 68 insertions(+), 7 deletions(-)
+
+diff --git a/configure.ac b/configure.ac
+index cbf92659..eb510fd9 100644
+--- a/configure.ac
++++ b/configure.ac
+@@ -468,10 +468,39 @@ if test "x$enable_threads" = xyes; then
+ CFLAGS=$OLD_CFLAGS
+ fi
+
+-# As a Debian-specific hack, liblzma uses dlopen() to check if extra
++# As a Debian-specific hack, liblzma can use dlopen() to check if extra
+ # paranoia is needed because unversioned symbols from liblzma.so.2 are
+ # present in the same process. See src/liblzma/common/common.c.
+-AC_SEARCH_LIBS([dlopen], [dl])
++AC_MSG_CHECKING([if lzma_code checks should be relaxed for compatibility])
++AC_ARG_ENABLE([liblzma2-compat], [AC_HELP_STRING([--enable-liblzma2-compat],
++ [Relax run-time checks to accomodate old binaries built
++ with smaller sizeof(lzma_stream). The default is "dynamic",
++ which means to only use the relaxed checks when the dynamic
++ loader reports that liblzma.so.2 is loaded in the same process.])],
++ [], [enable_liblzma2_compat=dynamic])
++case $enable_liblzma2_compat in
++dynamic)
++ AC_SEARCH_LIBS([dlopen], [dl])
++ AC_DEFINE([LIBLZMA2_COMPAT_DYNAMIC], [1],
++ [Define to 1 to use dlopen() to check if lzma_code() checks
++ should be more tolerant because the process is also linked to
++ liblzma from Debian 6.0.])
++ AC_MSG_RESULT([auto])
++ ;;
++yes)
++ AC_DEFINE([LIBLZMA2_COMPAT], [1],
++ [Define to 1 to unconditionally make lzma_code() checks tolerant
++ to accomodate callers built against liblzma from Debian 6.0.])
++ AC_MSG_RESULT([yes])
++ ;;
++no)
++ AC_MSG_RESULT([no])
++ ;;
++*)
++ AC_MSG_RESULT([])
++ AC_MSG_ERROR([--enable-liblzma2: unrecognized value $enable_liblzma2_compat])
++ ;;
++esac
+
+ echo
+ echo "Initializing Libtool:"
+diff --git a/src/liblzma/common/common.c b/src/liblzma/common/common.c
+index e61d940d..3bfdb755 100644
+--- a/src/liblzma/common/common.c
++++ b/src/liblzma/common/common.c
+@@ -143,16 +143,46 @@ lzma_next_end(lzma_next_coder *next, lzma_allocator *allocator)
+ // External to internal API wrapper //
+ //////////////////////////////////////
+
+-static bool
+-liblzma2_loaded(void)
++#ifdef LIBLZMA2_COMPAT_DYNAMIC
++
++static void
++init_liblzma2_compat(lzma_stream *strm)
+ {
+ void *handle = dlopen("liblzma.so.2", RTLD_LAZY | RTLD_NOLOAD);
+ if (handle) {
+ dlclose(handle);
+- return true;
++ strm->internal->liblzma2_compat = true;
++ return;
+ }
++ strm->internal->liblzma2_compat = false;
++}
++
++static bool
++liblzma2_loaded(lzma_stream *strm)
++{
++ return strm->internal->liblzma2_compat;
++}
++
++#else
++
++static void
++init_liblzma2_compat(lzma_stream *strm)
++{
++}
++
++#ifdef LIBLZMA2_COMPAT
++static bool liblzma2_loaded(lzma_stream *strm)
++{
++ return true;
++}
++#else
++static bool liblzma2_loaded(lzma_stream *strm)
++{
+ return false;
+ }
++#endif
++
++#endif
+
+ extern lzma_ret
+ lzma_strm_init(lzma_stream *strm)
+@@ -167,7 +197,7 @@ lzma_strm_init(lzma_stream *strm)
+ return LZMA_MEM_ERROR;
+
+ strm->internal->next = LZMA_NEXT_CODER_INIT;
+- strm->internal->liblzma2_compat = liblzma2_loaded();
++ init_liblzma2_compat(strm);
+ }
+
+ memzero(strm->internal->supported_actions,
+@@ -220,7 +250,7 @@ lzma_code(lzma_stream *strm, lzma_action action)
+ || strm->reserved_ptr4 != NULL)
+ return LZMA_OPTIONS_ERROR;
+
+- if (strm->internal->liblzma2_compat)
++ if (liblzma2_loaded(strm))
+ ; /* Enough checks. */
+ else if (strm->reserved_int1 != 0
+ || strm->reserved_int2 != 0
+diff --git a/src/liblzma/common/common.h b/src/liblzma/common/common.h
+index 475661d8..4081c2d3 100644
+--- a/src/liblzma/common/common.h
++++ b/src/liblzma/common/common.h
+@@ -201,9 +201,11 @@ struct lzma_internal_s {
+ /// made (no input consumed and no output produced by next.code).
+ bool allow_buf_error;
+
++#ifdef LIBLZMA2_COMPAT_DYNAMIC
+ /// Indicates whether we are sharing a process image with
+ /// liblzma.so.2 and need to tread carefully.
+ bool liblzma2_compat;
++#endif
+ };
+
+
+--
+1.7.10.4
+
diff --git a/debian/patches/decoder-check-first-0x00 b/debian/patches/decoder-check-first-0x00
new file mode 100644
index 0000000..442e318
--- /dev/null
+++ b/debian/patches/decoder-check-first-0x00
@@ -0,0 +1,69 @@
+From: Lasse Collin <lasse.collin@tukaani.org>
+Date: Thu, 28 Jun 2012 10:47:49 +0300
+Subject: liblzma: Check that the first byte of range encoded data is 0x00.
+
+It is just to be more pedantic and thus perhaps catch broken
+files slightly earlier.
+
+Signed-off-by: Jonathan Nieder <jrnieder@gmail.com>
+---
+ src/liblzma/lzma/lzma_decoder.c | 8 ++++++--
+ src/liblzma/rangecoder/range_decoder.h | 12 +++++++++---
+ 2 files changed, 15 insertions(+), 5 deletions(-)
+
+diff --git a/src/liblzma/lzma/lzma_decoder.c b/src/liblzma/lzma/lzma_decoder.c
+index 5abbc0d..b8f9317 100644
+--- a/src/liblzma/lzma/lzma_decoder.c
++++ b/src/liblzma/lzma/lzma_decoder.c
+@@ -289,8 +289,12 @@ lzma_decode(lzma_coder *restrict coder, lzma_dict *restrict dictptr,
+ // Initialization //
+ ////////////////////
+
+- if (!rc_read_init(&coder->rc, in, in_pos, in_size))
+- return LZMA_OK;
++ {
++ const lzma_ret ret = rc_read_init(
++ &coder->rc, in, in_pos, in_size);
++ if (ret != LZMA_STREAM_END)
++ return ret;
++ }
+
+ ///////////////
+ // Variables //
+diff --git a/src/liblzma/rangecoder/range_decoder.h b/src/liblzma/rangecoder/range_decoder.h
+index fb96180..e0b051f 100644
+--- a/src/liblzma/rangecoder/range_decoder.h
++++ b/src/liblzma/rangecoder/range_decoder.h
+@@ -25,20 +25,26 @@ typedef struct {
+
+
+ /// Reads the first five bytes to initialize the range decoder.
+-static inline bool
++static inline lzma_ret
+ rc_read_init(lzma_range_decoder *rc, const uint8_t *restrict in,
+ size_t *restrict in_pos, size_t in_size)
+ {
+ while (rc->init_bytes_left > 0) {
+ if (*in_pos == in_size)
+- return false;
++ return LZMA_OK;
++
++ // The first byte is always 0x00. It could have been omitted
++ // in LZMA2 but it wasn't, so one byte is wasted in every
++ // LZMA2 chunk.
++ if (rc->init_bytes_left == 5 && in[*in_pos] != 0x00)
++ return LZMA_DATA_ERROR;
+
+ rc->code = (rc->code << 8) | in[*in_pos];
+ ++*in_pos;
+ --rc->init_bytes_left;
+ }
+
+- return true;
++ return LZMA_STREAM_END;
+ }
+
+
+--
+1.7.9.6 (Apple Git-31.1)
+
diff --git a/debian/patches/man-date b/debian/patches/man-date
new file mode 100644
index 0000000..f43d3b7
--- /dev/null
+++ b/debian/patches/man-date
@@ -0,0 +1,25 @@
+From: Lasse Collin <lasse.collin@tukaani.org>
+Date: Fri, 22 Jun 2012 14:34:03 +0300
+Subject: xz: Update man page date to match the latest update.
+
+Signed-off-by: Jonathan Nieder <jrnieder@gmail.com>
+---
+ src/xz/xz.1 | 2 +-
+ 1 file changed, 1 insertion(+), 1 deletion(-)
+
+diff --git a/src/xz/xz.1 b/src/xz/xz.1
+index 3ff89f0..cb8cd1e 100644
+--- a/src/xz/xz.1
++++ b/src/xz/xz.1
+@@ -5,7 +5,7 @@
+ .\" This file has been put into the public domain.
+ .\" You can do whatever you want with this file.
+ .\"
+-.TH XZ 1 "2011-04-11" "Tukaani" "XZ Utils"
++.TH XZ 1 "2012-05-27" "Tukaani" "XZ Utils"
+ .
+ .SH NAME
+ xz, unxz, xzcat, lzma, unlzma, lzcat \- Compress or decompress .xz and .lzma files
+--
+1.7.9.6 (Apple Git-31.1)
+
diff --git a/debian/patches/man-xz-lvv-minver b/debian/patches/man-xz-lvv-minver
new file mode 100644
index 0000000..8b2f44d
--- /dev/null
+++ b/debian/patches/man-xz-lvv-minver
@@ -0,0 +1,55 @@
+From: Lasse Collin <lasse.collin@tukaani.org>
+Date: Sun, 1 Jul 2012 18:44:33 +0300
+Subject: xz: Update the man page about the new field in --robot -lvv.
+
+Signed-off-by: Jonathan Nieder <jrnieder@gmail.com>
+---
+ src/xz/xz.1 | 18 +++++++++++++++++-
+ 1 file changed, 17 insertions(+), 1 deletion(-)
+
+diff --git a/src/xz/xz.1 b/src/xz/xz.1
+index cb8cd1e..4da09ba 100644
+--- a/src/xz/xz.1
++++ b/src/xz/xz.1
+@@ -5,7 +5,7 @@
+ .\" This file has been put into the public domain.
+ .\" You can do whatever you want with this file.
+ .\"
+-.TH XZ 1 "2012-05-27" "Tukaani" "XZ Utils"
++.TH XZ 1 "2012-07-01" "Tukaani" "XZ Utils"
+ .
+ .SH NAME
+ xz, unxz, xzcat, lzma, unlzma, lzcat \- Compress or decompress .xz and .lzma files
+@@ -1889,6 +1889,14 @@ or
+ .B no
+ indicating if all block headers have both compressed size and
+ uncompressed size stored in them
++.PP
++.I Since
++.B xz
++.I 5.1.2alpha:
++.IP 4. 4
++Minimum
++.B xz
++version required to decompress the file
+ .RE
+ .PD
+ .PP
+@@ -1939,6 +1947,14 @@ or
+ .B no
+ indicating if all block headers have both compressed size and
+ uncompressed size stored in them
++.PP
++.I Since
++.B xz
++.I 5.1.2alpha:
++.IP 12. 4
++Minimum
++.B xz
++version required to decompress the file
+ .RE
+ .PD
+ .PP
+--
+1.7.9.6 (Apple Git-31.1)
+
diff --git a/debian/patches/series b/debian/patches/series
new file mode 100644
index 0000000..8020937
--- /dev/null
+++ b/debian/patches/series
@@ -0,0 +1,8 @@
+abi-threaded-encoder
+abi-version-script
+abi-liblzma2-compat
+configure-liblzma2-compat
+man-date
+man-xz-lvv-minver
+xz-lvv-empty-block-minver
+decoder-check-first-0x00
diff --git a/debian/patches/xz-lvv-empty-block-minver b/debian/patches/xz-lvv-empty-block-minver
new file mode 100644
index 0000000..2c658d9
--- /dev/null
+++ b/debian/patches/xz-lvv-empty-block-minver
@@ -0,0 +1,38 @@
+From: Lasse Collin <lasse.collin@tukaani.org>
+Date: Wed, 4 Jul 2012 19:58:23 +0300
+Subject: xz: Fix the version number printed by xz -lvv.
+
+The decoder bug was fixed in 5.0.2 instead of 5.0.3.
+
+Signed-off-by: Jonathan Nieder <jrnieder@gmail.com>
+---
+ src/xz/list.c | 6 +++---
+ 1 file changed, 3 insertions(+), 3 deletions(-)
+
+diff --git a/src/xz/list.c b/src/xz/list.c
+index e71fbe2..a9e0adb 100644
+--- a/src/xz/list.c
++++ b/src/xz/list.c
+@@ -482,7 +482,7 @@ parse_block_header(file_pair *pair, const lzma_index_iter *iter,
+ // Determine the minimum XZ Utils version that supports this Block.
+ //
+ // Currently the only thing that 5.0.0 doesn't support is empty
+- // LZMA2 Block. This bug was fixed in 5.0.3.
++ // LZMA2 Block. This decoder bug was fixed in 5.0.2.
+ {
+ size_t i = 0;
+ while (filters[i + 1].id != LZMA_VLI_UNKNOWN)
+@@ -490,8 +490,8 @@ parse_block_header(file_pair *pair, const lzma_index_iter *iter,
+
+ if (filters[i].id == LZMA_FILTER_LZMA2
+ && iter->block.uncompressed_size == 0
+- && xfi->min_version < 50000032U)
+- xfi->min_version = 50000032U;
++ && xfi->min_version < 50000022U)
++ xfi->min_version = 50000022U;
+ }
+
+ // Convert the filter chain to human readable form.
+--
+1.7.9.6 (Apple Git-31.1)
+
diff --git a/debian/rules b/debian/rules
new file mode 100755
index 0000000..fcbf5c2
--- /dev/null
+++ b/debian/rules
@@ -0,0 +1,164 @@
+#!/usr/bin/make -f
+
+build clean install binary-arch binary-indep binary:
+ +dh $@ --parallel $(opt_no_act)
+
+# Runs tests, too, if and only if nocheck is unset (see below).
+build-arch:: build-plain build-static build-small
+
+build-indep: debian/normal-build/Makefile
+ cd debian/normal-build && doxygen Doxyfile
+
+autoreconf_sources := $(wildcard Makefile.am */Makefile.am */*/Makefile.am)
+autoreconf_sources += configure.ac
+
+autoreconf_products := $(wildcard Makefile.in */Makefile.in */*/Makefile.in)
+autoreconf_products += configure # and more, but these will do
+
+configure_input := $(autoreconf_products)
+configure_input += Doxyfile.in
+configure_input += src/liblzma/liblzma.pc.in
+configure_input += $(wildcard src/scripts/*.in)
+
+override_dh_auto_clean:
+ rm -f debian/*-stamp
+ dh_auto_clean --builddirectory debian/xzdec-build
+ dh_auto_clean --builddirectory debian/normal-build
+ dh_auto_clean --builddirectory debian/static-build
+ sh debian/clean.sh
+
+override_dh_auto_install:
+ dh_auto_install --builddirectory debian/xzdec-build
+ dh_auto_install --builddirectory debian/normal-build
+ dh_auto_install --builddirectory debian/static-build
+ set -e; arch=$$(dpkg-architecture -qDEB_HOST_MULTIARCH); \
+ install -d debian/tmp/lib/$$arch; \
+ mv debian/tmp/usr/lib/$$arch/liblzma.so.* debian/tmp/lib/$$arch/; \
+ dso=$$(basename $$(readlink debian/tmp/usr/lib/$$arch/liblzma.so)); \
+ ln -s -f /lib/$$arch/$$dso debian/tmp/usr/lib/$$arch/liblzma.so
+
+override_dh_installchangelogs:
+ dh_installchangelogs debian/changelog.upstream
+
+build-plain: debian/normal-build/Makefile
+ dh_auto_build --builddirectory debian/normal-build
+
+build-static: debian/static-build/Makefile
+ dh_auto_build --builddirectory debian/static-build
+
+build-small: debian/xzdec-build/Makefile
+ dh_auto_build --builddirectory debian/xzdec-build
+
+debian/test-plain-stamp: | build-plain
+ dh_auto_test --builddirectory debian/normal-build
+ >$@
+
+debian/test-static-stamp: | build-static
+ dh_auto_test --builddirectory debian/static-build
+ >$@
+
+debian/test-xzdec-stamp: | build-small
+ $(MAKE) -C debian/xzdec-build/tests create_compress_files
+ $(MAKE) -C debian/xzdec-build/tests \
+ TESTS="test_check test_files.sh test_compress.sh" \
+ check-TESTS
+ >$@
+
+debian/normal-build/Makefile debian/normal-build/Doxyfile: $(configure_input)
+ dh_auto_configure --builddirectory debian/normal-build -- \
+ --disable-threads --disable-static \
+ $(opt_optimize) $(opt_quiet) \
+ --disable-xzdec --disable-lzmadec
+
+debian/static-build/Makefile: $(configure_input)
+ dh_auto_configure --builddirectory debian/static-build -- \
+ --disable-threads --disable-shared \
+ --enable-liblzma2-compat \
+ $(opt_optimize) $(opt_quiet) \
+ --disable-lzmainfo --disable-scripts \
+ --disable-xzdec --disable-lzmadec \
+ --disable-xz --disable-lzma-links
+
+debian/xzdec-build/Makefile: $(configure_input)
+ dh_auto_configure --builddirectory debian/xzdec-build -- \
+ --disable-shared --disable-nls --disable-encoders \
+ --enable-small --disable-threads \
+ --disable-liblzma2-compat \
+ $(opt_optimize_small) $(opt_quiet) \
+ --disable-lzmainfo --disable-scripts \
+ --disable-xz --disable-lzma-links
+
+$(autoreconf_products): $(autoreconf_sources)
+ autoreconf -is
+
+small_flags_env =
+small_flags_env += DEB_CFLAGS_MAINT_STRIP='-O2 -O3'
+small_flags_env += DEB_CFLAGS_MAINT_PREPEND=-Os
+flags_cmd = dpkg-buildflags --export=configure
+opt_optimize = $(shell $(flags_cmd))
+opt_optimize_small = $(shell $(small_flags_env) $(flags_cmd))
+
+opt_no_act =
+opt_quiet =
+
+# Unless noopt is set, use optimized CRC32 routine on the Hurd.
+ifeq (hurd,$(shell dpkg-architecture -qDEB_HOST_ARCH_OS))
+ cputype := $(shell dpkg-architecture -qDEB_HOST_ARCH_CPU)
+ ifeq (i386,$(cputype))
+ opt_optimize += --enable-assembler=x86
+ opt_optimize_small += --enable-assembler=x86
+ endif
+ ifeq (amd64,$(cputype))
+ opt_optimize += --enable-assembler=x86_64
+ opt_optimize_small += --enable-assembler=x86_64
+ endif
+endif
+
+ifneq (,$(filter noopt,$(DEB_BUILD_OPTIONS)))
+ opt_optimize += --disable-assembler
+ opt_optimize_small += --disable-assembler
+endif
+
+ifneq (,$(findstring n,$(MAKEFLAGS)))
+ opt_no_act = --no-act
+endif
+
+ifneq (,$(filter quiet,$(DEB_BUILD_OPTIONS)))
+ opt_quiet = --quiet
+ MAKEFLAGS += --quiet
+endif
+
+ifeq (,$(filter nocheck,$(DEB_BUILD_OPTIONS)))
+build-arch:: debian/test-plain-stamp
+build-arch:: debian/test-static-stamp
+build-arch:: debian/test-xzdec-stamp
+endif
+
+# Build a tarball with the latest upstream version.
+# This is made complicated by the need to choose a nice version number.
+REPO = http://git.tukaani.org/xz.git
+BRANCH = master
+get-orig-source:
+ mkdir debian-orig-source
+ -set -e; cd debian-orig-source; \
+ : Fetch latest upstream version.; \
+ git init -q; \
+ git fetch -q --tags $(REPO); \
+ git fetch -q $(REPO) $(BRANCH); \
+ : Determine version number.; \
+ commit_name=$$(git describe FETCH_HEAD); \
+ release=$${commit_name%%-*}; \
+ date=$$(date --utc --date="$$( \
+ git log -1 --pretty=format:%cD "$$commit_name" \
+ )" "+%Y%m%d"); \
+ if test "$$commit_name" = "$$release"; \
+ then upstream_version=$${commit_name#v}; \
+ else upstream_version="$${release#v}+$${date}"; \
+ fi; \
+ : Generate tarball.; \
+ echo "packaging $$commit_name"; \
+ git archive --format=tar "$$commit_name" \
+ --prefix="xz-utils-$$upstream_version/" | \
+ gzip -n --rsyncable -9 \
+ > "../xz-utils_$$upstream_version.orig.tar.gz"
+ rm -fr debian-orig-source
diff --git a/debian/source/format b/debian/source/format
new file mode 100644
index 0000000..163aaf8
--- /dev/null
+++ b/debian/source/format
@@ -0,0 +1 @@
+3.0 (quilt)
diff --git a/debian/symbols b/debian/symbols
new file mode 100644
index 0000000..ae398c9
--- /dev/null
+++ b/debian/symbols
@@ -0,0 +1,6 @@
+liblzma.so.5 liblzma5 #MINVER#
+* Build-Depends-Package: liblzma-dev
+ (symver)XZ_5.0 5.1.1alpha+20110809
+ lzma_code@XZ_5.0 5.1.1alpha+20120614
+ lzma_raw_buffer_decode@XZ_5.0 5.1.1alpha+20120614
+ lzma_raw_buffer_encode@XZ_5.0 5.1.1alpha+20120614
diff --git a/debian/watch b/debian/watch
new file mode 100644
index 0000000..6352a9c
--- /dev/null
+++ b/debian/watch
@@ -0,0 +1,3 @@
+version=3
+opts=dversionmangle=s/\+\d{8}$// \
+http://tukaani.org/xz/xz-([\d.]*(?:beta)?)\.tar\.gz
diff --git a/debian/xz-utils.NEWS b/debian/xz-utils.NEWS
new file mode 100644
index 0000000..6eac958
--- /dev/null
+++ b/debian/xz-utils.NEWS
@@ -0,0 +1,31 @@
+xz-utils (4.999.9beta+20100212-2) unstable; urgency=low
+
+ The tiny xzdec and lzmadec decompressors have been moved to the new
+ xzdec package. One can use xzcat (which is an abbreviation for
+ “xz --decompress --stdout”) to replace them where space is not a
+ premium.
+
+ -- Jonathan Nieder <jrnieder@gmail.com> Tue, 23 Feb 2010 08:24:10 -0600
+
+xz-utils (4.999.9beta+20100117-1) unstable; urgency=low
+
+ From this version on, xz produces sparse files by default when
+ decompressing. This saves disk space when reproducing files with long
+ runs of zero bytes, such as file system images. Implementing this
+ feature requires seeking forward beyond the end of a file so that the
+ operating system knows where to put in a hole.
+
+ If you use xz --decompress to write to end of a file that is appended
+ to at the same time by another process, this could cause concurrent
+ output from the other command to be overwritten. This is a rare and
+ quite weird thing to do. If you really want to do it, note that xz’s
+ buffering strategy is not part of its documented interface; to safely
+ interleave concurrent output from xz and another command, a
+ construction such as
+
+ xz --decompress input.xz | dd ibs=1k obs=1k >> log
+
+ would be needed to avoid unpredictable results.
+
+ -- Jonathan Nieder <jrnieder@gmail.com> Tue, 02 Feb 2010 15:51:37 -0600
+
diff --git a/debian/xz-utils.README.Debian b/debian/xz-utils.README.Debian
new file mode 100644
index 0000000..180be4c
--- /dev/null
+++ b/debian/xz-utils.README.Debian
@@ -0,0 +1,81 @@
+XZ Utils for Debian
+===================
+
+Contents:
+ 1. History
+ 2. Differences from standard XZ Utils
+ 3. LZMA Utils compatibility
+ 4. Configuration
+
+History
+-------
+
+XZ Utils should have been called LZMA Utils 4.42, but it came too late.
+The old .lzma file format has some problems, worst of which is the lack
+of magic number, but it gets enough use to still need to be supported.
+See /usr/share/doc/xz-utils/history.txt.gz for the full story.
+
+Differences from standard XZ Utils
+----------------------------------
+
+XZ Utils 5.1.y has some experimental features which are disabled in
+Debian to allow interfaces to evolve. Debian liblzma is also modified
+to avoid breakage when the same process loads liblzma2 from Debian 6.0
+(squeeze) and liblzma5.
+
+abi-threaded-encoder
+ Disable threaded compression in liblzma and xz.
+
+abi-version-script
+ liblzma: Do not pretend to satisfy dependencies on XZ_5.1.1alpha.
+
+abi-liblzma2-compat, configure-liblzma2-compat
+ Do not check reserved fields past the historical end of the
+ lzma_stream structure if liblzma.so.2 is loaded in the same
+ process image. Likewise when linked statically.
+ (See bug #649522.)
+
+man-date, man-xz-lvv-minver (from upstream)
+ Document the "Minimum version required to decompress" field of
+ "xz --robot -v -v --list" output.
+
+xz-lvv-empty-block-minver (from upstream)
+ Fix the version number printed by "xz -lvv" for files with Blocks
+ of zero uncompressed_size: the decoder bug preventing reading such
+ files was fixed in xz 5.0.2, not 5.0.3.
+
+decoder-check-first-0x00 (from upstream)
+ Check that the first byte of range encoded data is zero to catch
+ broken files sooner.
+
+LZMA Utils compatibility
+------------------------
+
+To support old scripts and muscle memory, XZ Utils can emulate the
+legacy LZMA Utils interface. To use this feature, you can install some
+subset of the following list of symbolic links to your $PATH.
+
+ lzma, unlzma, lzcat -> /usr/bin/xz
+ lzgrep, lzegrep, lzfgrep -> /usr/bin/xzgrep
+ lzless -> /usr/bin/xzless
+ lzmore -> /usr/bin/xzmore
+ lzdiff, lzcmp -> /usr/bin/xzdiff
+
+If you would like XZ Utils to provide these commands by default for
+all users, use "update-alternatives --config lzma".
+
+Configuration
+-------------
+
+The memory usage of xz can vary from a few hundred kilobytes to several
+gigabytes depending on the compression settings. If you would like xz
+to automatically scale down its settings while compressing to decrease
+memory usage, you can declare so by adding an option like the
+following to your environment (e.g., in ~/.profile):
+
+ XZ_DEFAULTS=--memlimit-compress=256MiB
+ export XZ_DEFAULTS
+
+See the "Memory usage" section of the xz(1) manual page for details.
+
+ -- Jonathan Nieder <jrnieder@gmail.com> Fri, 17 Aug 2012 23:37:47 -0700
diff --git a/debian/xz-utils.docs b/debian/xz-utils.docs
new file mode 100644
index 0000000..463b710
--- /dev/null
+++ b/debian/xz-utils.docs
@@ -0,0 +1,7 @@
+README
+NEWS
+AUTHORS
+THANKS
+doc/history.txt
+doc/faq.txt
+extra
diff --git a/debian/xz-utils.install b/debian/xz-utils.install
new file mode 100644
index 0000000..9acbd88
--- /dev/null
+++ b/debian/xz-utils.install
@@ -0,0 +1,19 @@
+usr/bin/xz
+usr/bin/unxz
+usr/bin/xzcat
+usr/bin/xzmore
+usr/bin/xzless
+usr/bin/xzdiff
+usr/bin/xzcmp
+usr/bin/xz*grep
+usr/share/man/man1/xz.1
+usr/share/man/man1/unxz.1
+usr/share/man/man1/xzcat.1
+usr/share/man/man1/xzmore.1
+usr/share/man/man1/xzless.1
+usr/share/man/man1/xzdiff.1
+usr/share/man/man1/xzcmp.1
+usr/share/man/man1/xz*grep.1
+usr/bin/lzmainfo
+usr/share/man/man1/lzmainfo.1
+usr/share/locale/*/LC_MESSAGES/xz.mo
diff --git a/debian/xz-utils.postinst b/debian/xz-utils.postinst
new file mode 100644
index 0000000..a2cf46f
--- /dev/null
+++ b/debian/xz-utils.postinst
@@ -0,0 +1,19 @@
+#!/bin/sh
+set -e
+
+slave () {
+ dir=$1 filename=$2 target=$3
+ echo "--slave $dir/$filename $filename $dir/$target"
+}
+
+update-alternatives --install /usr/bin/lzma lzma /usr/bin/xz 20 $(
+ slave /usr/share/man/man1 lzma.1.gz xz.1.gz
+ slave /usr/bin unlzma unxz
+ slave /usr/share/man/man1 unlzma.1.gz unxz.1.gz
+ for util in cat more less diff cmp grep egrep fgrep
+ do
+ slave /usr/bin lz$util xz$util
+ slave /usr/share/man/man1 lz$util.1.gz xz$util.1.gz
+ done
+)
+#DEBHELPER#
diff --git a/debian/xz-utils.prerm b/debian/xz-utils.prerm
new file mode 100644
index 0000000..8dd3d8f
--- /dev/null
+++ b/debian/xz-utils.prerm
@@ -0,0 +1,10 @@
+#!/bin/sh
+set -e
+if
+ test "$1" != upgrade ||
+ # downgrading to a pre-alternatives version
+ dpkg --compare-versions "$2" lt-nl 5.1.1alpha+20120614-1
+then
+ update-alternatives --remove lzma /usr/bin/xz
+fi
+#DEBHELPER#
diff --git a/debian/xzdec.docs b/debian/xzdec.docs
new file mode 100644
index 0000000..7b5ff1f
--- /dev/null
+++ b/debian/xzdec.docs
@@ -0,0 +1,6 @@
+README
+NEWS
+AUTHORS
+THANKS
+doc/history.txt
+doc/faq.txt
diff --git a/debian/xzdec.install b/debian/xzdec.install
new file mode 100644
index 0000000..7f67bd8
--- /dev/null
+++ b/debian/xzdec.install
@@ -0,0 +1,4 @@
+usr/bin/xzdec
+usr/bin/lzmadec
+usr/share/man/man1/xzdec.1
+usr/share/man/man1/lzmadec.1
diff --git a/src/liblzma/Makefile.am b/src/liblzma/Makefile.am
index 5bd205d..ac2d1ed 100644
--- a/src/liblzma/Makefile.am
+++ b/src/liblzma/Makefile.am
@@ -24,7 +24,7 @@
-I$(top_srcdir)/src/liblzma/simple \
-I$(top_srcdir)/src/common \
-DTUKLIB_SYMBOL_PREFIX=lzma_
-liblzma_la_LDFLAGS = -no-undefined -version-info 5:99:0
+liblzma_la_LDFLAGS = -no-undefined -version-info 5:0:0
if COND_SYMVERS
EXTRA_DIST += liblzma.map
diff --git a/src/liblzma/api/lzma/container.h b/src/liblzma/api/lzma/container.h
index 499d8b9..7a9ffc6 100644
--- a/src/liblzma/api/lzma/container.h
+++ b/src/liblzma/api/lzma/container.h
@@ -60,129 +60,6 @@
#define LZMA_PRESET_EXTREME (UINT32_C(1) << 31)
-#ifdef LZMA_UNSTABLE /* Unstable API that may change. Use only for testing. */
-/**
- * \brief Multithreading options
- */
-typedef struct {
- /**
- * \brief Flags
- *
- * Set this to zero if no flags are wanted.
- *
- * No flags are currently supported.
- */
- uint32_t flags;
-
- /**
- * \brief Number of worker threads to use
- */
- uint32_t threads;
-
- /**
- * \brief Maximum uncompressed size of a Block
- *
- * The encoder will start a new .xz Block every block_size bytes.
- * Using LZMA_FULL_FLUSH or LZMA_FULL_BARRIER with lzma_code()
- * the caller may tell liblzma to start a new Block earlier.
- *
- * With LZMA2, a recommended block size is 2-4 times the LZMA2
- * dictionary size. With very small dictionaries, it is recommended
- * to use at least 1 MiB block size for good compression ratio, even
- * if this is more than four times the dictionary size. Note that
- * these are only recommendations for typical use cases; feel free
- * to use other values. Just keep in mind that using a block size
- * less than the LZMA2 dictionary size is waste of RAM.
- *
- * Set this to 0 to let liblzma choose the block size depending
- * on the compression options. For LZMA2 it will be 3*dict_size
- * or 1 MiB, whichever is more.
- */
- uint64_t block_size;
-
- /**
- * \brief Timeout to allow lzma_code() to return early
- *
- * Multithreading can make liblzma to consume input and produce
- * output in a very bursty way: it may first read a lot of input
- * to fill internal buffers, then no input or output occurs for
- * a while.
- *
- * In single-threaded mode, lzma_code() won't return until it has
- * either consumed all the input or filled the output buffer. If
- * this is done in multithreaded mode, it may cause a call
- * lzma_code() to take even tens of seconds, which isn't acceptable
- * in all applications.
- *
- * To avoid very long blocking times in lzma_code(), a timeout
- * (in milliseconds) may be set here. If lzma_code() would block
- * longer than this number of milliseconds, it will return with
- * LZMA_OK. Reasonable values are 100 ms or more. The xz command
- * line tool uses 300 ms.
- *
- * If long blocking times are fine for you, set timeout to a special
- * value of 0, which will disable the timeout mechanism and will make
- * lzma_code() block until all the input is consumed or the output
- * buffer has been filled.
- *
- * \note Even with a timeout, lzma_code() might sometimes take
- * somewhat long time to return. No timing guarantees
- * are made.
- */
- uint32_t timeout;
-
- /**
- * \brief Compression preset (level and possible flags)
- *
- * The preset is set just like with lzma_easy_encoder().
- * The preset is ignored if filters below is non-NULL.
- */
- uint32_t preset;
-
- /**
- * \brief Filter chain (alternative to a preset)
- *
- * If this is NULL, the preset above is used. Otherwise the preset
- * is ignored and the filter chain specified here is used.
- */
- const lzma_filter *filters;
-
- /**
- * \brief Integrity check type
- *
- * See check.h for available checks. The xz command line tool
- * defaults to LZMA_CHECK_CRC64, which is a good choice if you
- * are unsure.
- */
- lzma_check check;
-
- /*
- * Reserved space to allow possible future extensions without
- * breaking the ABI. You should not touch these, because the names
- * of these variables may change. These are and will never be used
- * with the currently supported options, so it is safe to leave these
- * uninitialized.
- */
- lzma_reserved_enum reserved_enum1;
- lzma_reserved_enum reserved_enum2;
- lzma_reserved_enum reserved_enum3;
- uint32_t reserved_int1;
- uint32_t reserved_int2;
- uint32_t reserved_int3;
- uint32_t reserved_int4;
- uint64_t reserved_int5;
- uint64_t reserved_int6;
- uint64_t reserved_int7;
- uint64_t reserved_int8;
- void *reserved_ptr1;
- void *reserved_ptr2;
- void *reserved_ptr3;
- void *reserved_ptr4;
-
-} lzma_mt;
-#endif
-
-
/**
* \brief Calculate approximate memory usage of easy encoder
*
@@ -313,50 +190,6 @@
lzma_nothrow lzma_attr_warn_unused_result;
-#ifdef LZMA_UNSTABLE /* Unstable API that may change. Use only for testing. */
-/**
- * \brief Calculate approximate memory usage of multithreaded .xz encoder
- *
- * Since doing the encoding in threaded mode doesn't affect the memory
- * requirements of single-threaded decompressor, you can use
- * lzma_easy_decoder_memusage(options->preset) or
- * lzma_raw_decoder_memusage(options->filters) to calculate
- * the decompressor memory requirements.
- *
- * \param options Compression options
- *
- * \return Number of bytes of memory required for encoding with the
- * given options. If an error occurs, for example due to
- * unsupported preset or filter chain, UINT64_MAX is returned.
- */
-extern LZMA_API(uint64_t) lzma_stream_encoder_mt_memusage(
- const lzma_mt *options) lzma_nothrow lzma_attr_pure;
-
-
-/**
- * \brief Initialize multithreaded .xz Stream encoder
- *
- * This provides the functionality of lzma_easy_encoder() and
- * lzma_stream_encoder() as a single function for multithreaded use.
- *
- * TODO: For lzma_code(), only LZMA_RUN and LZMA_FINISH are currently
- * supported. Support for other actions has been planned.
- *
- * \param strm Pointer to properly prepared lzma_stream
- * \param options Pointer to multithreaded compression options
- *
- * \return - LZMA_OK
- * - LZMA_MEM_ERROR
- * - LZMA_UNSUPPORTED_CHECK
- * - LZMA_OPTIONS_ERROR
- * - LZMA_PROG_ERROR
- */
-extern LZMA_API(lzma_ret) lzma_stream_encoder_mt(
- lzma_stream *strm, const lzma_mt *options)
- lzma_nothrow lzma_attr_warn_unused_result;
-#endif
-
-
/**
* \brief Initialize .lzma encoder (legacy file format)
*
diff --git a/src/liblzma/api/lzma/version.h b/src/liblzma/api/lzma/version.h
index 4bf7e40..a908ea2 100644
--- a/src/liblzma/api/lzma/version.h
+++ b/src/liblzma/api/lzma/version.h
@@ -22,7 +22,7 @@
*/
#define LZMA_VERSION_MAJOR 5
#define LZMA_VERSION_MINOR 1
-#define LZMA_VERSION_PATCH 1
+#define LZMA_VERSION_PATCH 0
#define LZMA_VERSION_STABILITY LZMA_VERSION_STABILITY_ALPHA
#ifndef LZMA_VERSION_COMMIT
diff --git a/src/liblzma/common/Makefile.inc b/src/liblzma/common/Makefile.inc
index dd5a8c8..81d751e 100644
--- a/src/liblzma/common/Makefile.inc
+++ b/src/liblzma/common/Makefile.inc
@@ -40,13 +40,6 @@
common/stream_encoder.c \
common/stream_flags_encoder.c \
common/vli_encoder.c
-
-if COND_THREADS
-liblzma_la_SOURCES += \
- common/outqueue.c \
- common/outqueue.h \
- common/stream_encoder_mt.c
-endif
endif
if COND_MAIN_DECODER
diff --git a/src/liblzma/common/common.c b/src/liblzma/common/common.c
index 85ae96a..3bfdb75 100644
--- a/src/liblzma/common/common.c
+++ b/src/liblzma/common/common.c
@@ -12,6 +12,8 @@
#include "common.h"
+#include <dlfcn.h>
+
/////////////
// Version //
@@ -141,6 +143,47 @@
// External to internal API wrapper //
//////////////////////////////////////
+#ifdef LIBLZMA2_COMPAT_DYNAMIC
+
+static void
+init_liblzma2_compat(lzma_stream *strm)
+{
+ void *handle = dlopen("liblzma.so.2", RTLD_LAZY | RTLD_NOLOAD);
+ if (handle) {
+ dlclose(handle);
+ strm->internal->liblzma2_compat = true;
+ return;
+ }
+ strm->internal->liblzma2_compat = false;
+}
+
+static bool
+liblzma2_loaded(lzma_stream *strm)
+{
+ return strm->internal->liblzma2_compat;
+}
+
+#else
+
+static void
+init_liblzma2_compat(lzma_stream *strm)
+{
+}
+
+#ifdef LIBLZMA2_COMPAT
+static bool liblzma2_loaded(lzma_stream *strm)
+{
+ return true;
+}
+#else
+static bool liblzma2_loaded(lzma_stream *strm)
+{
+ return false;
+}
+#endif
+
+#endif
+
extern lzma_ret
lzma_strm_init(lzma_stream *strm)
{
@@ -154,6 +197,7 @@
return LZMA_MEM_ERROR;
strm->internal->next = LZMA_NEXT_CODER_INIT;
+ init_liblzma2_compat(strm);
}
memzero(strm->internal->supported_actions,
@@ -168,6 +212,24 @@
}
+// Before v5.0.0~6 (liblzma: A few ABI tweaks to reserve space in
+// structures, 2010-10-23), the reserved fields in lzma_stream were:
+//
+// void *reserved_ptr1;
+// void *reserved_ptr2;
+// uint64_t reserved_int1;
+// uint64_t reserved_int2;
+// lzma_reserved_enum reserved_enum1;
+// lzma_reserved_enum reserved_enum2;
+//
+// Nowadays there are two more pointers between reserved_ptr2 and
+// reserved_int1 and two size_t fields between reserved_int2 and
+// reserved_enum1.
+//
+// When strm->internal->liblzma2_compat is set, limit the checks of
+// reserved fields to fields that were present in the old ABI to avoid
+// segfaults and spurious "Unsupported options" from callers sharing
+// the process image that expect the old ABI.
extern LZMA_API(lzma_ret)
lzma_code(lzma_stream *strm, lzma_action action)
{
@@ -185,8 +247,12 @@
if (strm->reserved_ptr1 != NULL
|| strm->reserved_ptr2 != NULL
|| strm->reserved_ptr3 != NULL
- || strm->reserved_ptr4 != NULL
- || strm->reserved_int1 != 0
+ || strm->reserved_ptr4 != NULL)
+ return LZMA_OPTIONS_ERROR;
+
+ if (liblzma2_loaded(strm))
+ ; /* Enough checks. */
+ else if (strm->reserved_int1 != 0
|| strm->reserved_int2 != 0
|| strm->reserved_int3 != 0
|| strm->reserved_int4 != 0
@@ -263,9 +329,7 @@
strm->internal->avail_in = strm->avail_in;
- // Cast is needed to silence a warning about LZMA_TIMED_OUT, which
- // isn't part of lzma_ret enumeration.
- switch ((unsigned int)(ret)) {
+ switch (ret) {
case LZMA_OK:
// Don't return LZMA_BUF_ERROR when it happens the first time.
// This is to avoid returning LZMA_BUF_ERROR when avail_out
@@ -281,11 +345,6 @@
}
break;
- case LZMA_TIMED_OUT:
- strm->internal->allow_buf_error = false;
- ret = LZMA_OK;
- break;
-
case LZMA_STREAM_END:
if (strm->internal->sequence == ISEQ_SYNC_FLUSH
|| strm->internal->sequence == ISEQ_FULL_FLUSH)
diff --git a/src/liblzma/common/common.h b/src/liblzma/common/common.h
index 5c92af2..4081c2d 100644
--- a/src/liblzma/common/common.h
+++ b/src/liblzma/common/common.h
@@ -32,8 +32,6 @@
#define LZMA_API(type) LZMA_API_EXPORT type LZMA_API_CALL
-#define LZMA_UNSTABLE
-
#include "lzma.h"
// These allow helping the compiler in some often-executed branches, whose
@@ -51,13 +49,6 @@
#define LZMA_BUFFER_SIZE 4096
-/// Maximum number of worker threads within one multithreaded component.
-/// The limit exists solely to make it simpler to prevent integer overflows
-/// when allocating structures etc. This should be big enough for now...
-/// the code won't scale anywhere close to this number anyway.
-#define LZMA_THREADS_MAX 16384
-
-
/// Starting value for memory usage estimates. Instead of calculating size
/// of _every_ structure and taking into account malloc() overhead etc., we
/// add a base size to all memory usage estimates. It's not very accurate
@@ -78,13 +69,6 @@
| LZMA_CONCATENATED )
-/// Special return value (lzma_ret) to indicate that a timeout was reached
-/// and lzma_code() must not return LZMA_BUF_ERROR. This is converted to
-/// LZMA_OK in lzma_code(). This is not in the lzma_ret enumeration because
-/// there's no need to have it in the public API.
-#define LZMA_TIMED_OUT 32
-
-
/// Type of encoder/decoder specific data; the actual structure is defined
/// differently in different coders.
typedef struct lzma_coder_s lzma_coder;
@@ -216,6 +200,12 @@
/// If true, lzma_code will return LZMA_BUF_ERROR if no progress was
/// made (no input consumed and no output produced by next.code).
bool allow_buf_error;
+
+#ifdef LIBLZMA2_COMPAT_DYNAMIC
+ /// Indicates whether we are sharing a process image with
+ /// liblzma.so.2 and need to tread carefully.
+ bool liblzma2_compat;
+#endif
};
diff --git a/src/liblzma/common/outqueue.c b/src/liblzma/common/outqueue.c
deleted file mode 100644
index d7a87d9..0000000
--- a/src/liblzma/common/outqueue.c
+++ /dev/null
@@ -1,184 +0,0 @@
-///////////////////////////////////////////////////////////////////////////////
-//
-/// \file outqueue.c
-/// \brief Output queue handling in multithreaded coding
-//
-// Author: Lasse Collin
-//
-// This file has been put into the public domain.
-// You can do whatever you want with this file.
-//
-///////////////////////////////////////////////////////////////////////////////
-
-#include "outqueue.h"
-
-
-/// This is to ease integer overflow checking: We may allocate up to
-/// 2 * LZMA_THREADS_MAX buffers and we need some extra memory for other
-/// data structures (that's the second /2).
-#define BUF_SIZE_MAX (UINT64_MAX / LZMA_THREADS_MAX / 2 / 2)
-
-
-static lzma_ret
-get_options(uint64_t *bufs_alloc_size, uint32_t *bufs_count,
- uint64_t buf_size_max, uint32_t threads)
-{
- if (threads > LZMA_THREADS_MAX || buf_size_max > BUF_SIZE_MAX)
- return LZMA_OPTIONS_ERROR;
-
- // The number of buffers is twice the number of threads.
- // This wastes RAM but keeps the threads busy when buffers
- // finish out of order.
- //
- // NOTE: If this is changed, update BUF_SIZE_MAX too.
- *bufs_count = threads * 2;
- *bufs_alloc_size = *bufs_count * buf_size_max;
-
- return LZMA_OK;
-}
-
-
-extern uint64_t
-lzma_outq_memusage(uint64_t buf_size_max, uint32_t threads)
-{
- uint64_t bufs_alloc_size;
- uint32_t bufs_count;
-
- if (get_options(&bufs_alloc_size, &bufs_count, buf_size_max, threads)
- != LZMA_OK)
- return UINT64_MAX;
-
- return sizeof(lzma_outq) + bufs_count * sizeof(lzma_outbuf)
- + bufs_alloc_size;
-}
-
-
-extern lzma_ret
-lzma_outq_init(lzma_outq *outq, lzma_allocator *allocator,
- uint64_t buf_size_max, uint32_t threads)
-{
- uint64_t bufs_alloc_size;
- uint32_t bufs_count;
-
- // Set bufs_count and bufs_alloc_size.
- return_if_error(get_options(&bufs_alloc_size, &bufs_count,
- buf_size_max, threads));
-
- // Allocate memory if needed.
- if (outq->buf_size_max != buf_size_max
- || outq->bufs_allocated != bufs_count) {
- lzma_outq_end(outq, allocator);
-
-#if SIZE_MAX < UINT64_MAX
- if (bufs_alloc_size > SIZE_MAX)
- return LZMA_MEM_ERROR;
-#endif
-
- outq->bufs = lzma_alloc(bufs_count * sizeof(lzma_outbuf),
- allocator);
- outq->bufs_mem = lzma_alloc((size_t)(bufs_alloc_size),
- allocator);
-
- if (outq->bufs == NULL || outq->bufs_mem == NULL) {
- lzma_outq_end(outq, allocator);
- return LZMA_MEM_ERROR;
- }
- }
-
- // Initialize the rest of the main structure. Initialization of
- // outq->bufs[] is done when they are actually needed.
- outq->buf_size_max = (size_t)(buf_size_max);
- outq->bufs_allocated = bufs_count;
- outq->bufs_pos = 0;
- outq->bufs_used = 0;
- outq->read_pos = 0;
-
- return LZMA_OK;
-}
-
-
-extern void
-lzma_outq_end(lzma_outq *outq, lzma_allocator *allocator)
-{
- lzma_free(outq->bufs, allocator);
- outq->bufs = NULL;
-
- lzma_free(outq->bufs_mem, allocator);
- outq->bufs_mem = NULL;
-
- return;
-}
-
-
-extern lzma_outbuf *
-lzma_outq_get_buf(lzma_outq *outq)
-{
- // Caller must have checked it with lzma_outq_has_buf().
- assert(outq->bufs_used < outq->bufs_allocated);
-
- // Initialize the new buffer.
- lzma_outbuf *buf = &outq->bufs[outq->bufs_pos];
- buf->buf = outq->bufs_mem + outq->bufs_pos * outq->buf_size_max;
- buf->size = 0;
- buf->finished = false;
-
- // Update the queue state.
- if (++outq->bufs_pos == outq->bufs_allocated)
- outq->bufs_pos = 0;
-
- ++outq->bufs_used;
-
- return buf;
-}
-
-
-extern bool
-lzma_outq_is_readable(const lzma_outq *outq)
-{
- uint32_t i = outq->bufs_pos - outq->bufs_used;
- if (outq->bufs_pos < outq->bufs_used)
- i += outq->bufs_allocated;
-
- return outq->bufs[i].finished;
-}
-
-
-extern lzma_ret
-lzma_outq_read(lzma_outq *restrict outq, uint8_t *restrict out,
- size_t *restrict out_pos, size_t out_size,
- lzma_vli *restrict unpadded_size,
- lzma_vli *restrict uncompressed_size)
-{
- // There must be at least one buffer from which to read.
- if (outq->bufs_used == 0)
- return LZMA_OK;
-
- // Get the buffer.
- uint32_t i = outq->bufs_pos - outq->bufs_used;
- if (outq->bufs_pos < outq->bufs_used)
- i += outq->bufs_allocated;
-
- lzma_outbuf *buf = &outq->bufs[i];
-
- // If it isn't finished yet, we cannot read from it.
- if (!buf->finished)
- return LZMA_OK;
-
- // Copy from the buffer to output.
- lzma_bufcpy(buf->buf, &outq->read_pos, buf->size,
- out, out_pos, out_size);
-
- // Return if we didn't get all the data from the buffer.
- if (outq->read_pos < buf->size)
- return LZMA_OK;
-
- // The buffer was finished. Tell the caller its size information.
- *unpadded_size = buf->unpadded_size;
- *uncompressed_size = buf->uncompressed_size;
-
- // Free this buffer for further use.
- --outq->bufs_used;
- outq->read_pos = 0;
-
- return LZMA_STREAM_END;
-}
diff --git a/src/liblzma/common/outqueue.h b/src/liblzma/common/outqueue.h
deleted file mode 100644
index 154f91b..0000000
--- a/src/liblzma/common/outqueue.h
+++ /dev/null
@@ -1,155 +0,0 @@
-///////////////////////////////////////////////////////////////////////////////
-//
-/// \file outqueue.h
-/// \brief Output queue handling in multithreaded coding
-//
-// Author: Lasse Collin
-//
-// This file has been put into the public domain.
-// You can do whatever you want with this file.
-//
-///////////////////////////////////////////////////////////////////////////////
-
-#include "common.h"
-
-
-/// Output buffer for a single thread
-typedef struct {
- /// Pointer to the output buffer of lzma_outq.buf_size_max bytes
- uint8_t *buf;
-
- /// Amount of data written to buf
- size_t size;
-
- /// Additional size information
- lzma_vli unpadded_size;
- lzma_vli uncompressed_size;
-
- /// True when no more data will be written into this buffer.
- ///
- /// \note This is read by another thread and thus access
- /// to this variable needs a mutex.
- bool finished;
-
-} lzma_outbuf;
-
-
-typedef struct {
- /// Array of buffers that are used cyclically.
- lzma_outbuf *bufs;
-
- /// Memory allocated for all the buffers
- uint8_t *bufs_mem;
-
- /// Amount of buffer space available in each buffer
- size_t buf_size_max;
-
- /// Number of buffers allocated
- uint32_t bufs_allocated;
-
- /// Position in the bufs array. The next buffer to be taken
- /// into use is bufs[bufs_pos].
- uint32_t bufs_pos;
-
- /// Number of buffers in use
- uint32_t bufs_used;
-
- /// Position in the buffer in lzma_outq_read()
- size_t read_pos;
-
-} lzma_outq;
-
-
-/**
- * \brief Calculate the memory usage of an output queue
- *
- * \return Approximate memory usage in bytes or UINT64_MAX on error.
- */
-extern uint64_t lzma_outq_memusage(uint64_t buf_size_max, uint32_t threads);
-
-
-/// \brief Initialize an output queue
-///
-/// \param outq Pointer to an output queue. Before calling
-/// this function the first time, *outq should
-/// have been zeroed with memzero() so that this
-/// function knows that there are no previous
-/// allocations to free.
-/// \param allocator Pointer to allocator or NULL
-/// \param buf_size_max Maximum amount of data that a single buffer
-/// in the queue may need to store.
-/// \param threads Number of buffers that may be in use
-/// concurrently. Note that more than this number
-/// of buffers will actually get allocated to
-/// improve performance when buffers finish
-/// out of order.
-///
-/// \return - LZMA_OK
-/// - LZMA_MEM_ERROR
-///
-extern lzma_ret lzma_outq_init(lzma_outq *outq, lzma_allocator *allocator,
- uint64_t buf_size_max, uint32_t threads);
-
-
-/// \brief Free the memory associated with the output queue
-extern void lzma_outq_end(lzma_outq *outq, lzma_allocator *allocator);
-
-
-/// \brief Get a new buffer
-///
-/// lzma_outq_has_buf() must be used to check that there is a buffer
-/// available before calling lzma_outq_get_buf().
-///
-extern lzma_outbuf *lzma_outq_get_buf(lzma_outq *outq);
-
-
-/// \brief Test if there is data ready to be read
-///
-/// Call to this function must be protected with the same mutex that
-/// is used to protect lzma_outbuf.finished.
-///
-extern bool lzma_outq_is_readable(const lzma_outq *outq);
-
-
-/// \brief Read finished data
-///
-/// \param outq Pointer to an output queue
-/// \param out Beginning of the output buffer
-/// \param out_pos The next byte will be written to
-/// out[*out_pos].
-/// \param out_size Size of the out buffer; the first byte into
-/// which no data is written to is out[out_size].
-/// \param unpadded_size Unpadded Size from the Block encoder
-/// \param uncompressed_size Uncompressed Size from the Block encoder
-///
-/// \return - LZMA: All OK. Either no data was available or the buffer
-/// being read didn't become empty yet.
-/// - LZMA_STREAM_END: The buffer being read was finished.
-/// *unpadded_size and *uncompressed_size were set.
-///
-/// \note This reads lzma_outbuf.finished variables and thus call
-/// to this function needs to be protected with a mutex.
-///
-extern lzma_ret lzma_outq_read(lzma_outq *restrict outq,
- uint8_t *restrict out, size_t *restrict out_pos,
- size_t out_size, lzma_vli *restrict unpadded_size,
- lzma_vli *restrict uncompressed_size);
-
-
-/// \brief Test if there is at least one buffer free
-///
-/// This must be used before getting a new buffer with lzma_outq_get_buf().
-///
-static inline bool
-lzma_outq_has_buf(const lzma_outq *outq)
-{
- return outq->bufs_used < outq->bufs_allocated;
-}
-
-
-/// \brief Test if the queue is completely empty
-static inline bool
-lzma_outq_is_empty(const lzma_outq *outq)
-{
- return outq->bufs_used == 0;
-}
diff --git a/src/liblzma/common/stream_encoder_mt.c b/src/liblzma/common/stream_encoder_mt.c
deleted file mode 100644
index a4b2800..0000000
--- a/src/liblzma/common/stream_encoder_mt.c
+++ /dev/null
@@ -1,1013 +0,0 @@
-///////////////////////////////////////////////////////////////////////////////
-//
-/// \file stream_encoder_mt.c
-/// \brief Multithreaded .xz Stream encoder
-//
-// Author: Lasse Collin
-//
-// This file has been put into the public domain.
-// You can do whatever you want with this file.
-//
-///////////////////////////////////////////////////////////////////////////////
-
-#include "filter_encoder.h"
-#include "easy_preset.h"
-#include "block_encoder.h"
-#include "index_encoder.h"
-#include "outqueue.h"
-
-
-/// Maximum supported block size. This makes it simpler to prevent integer
-/// overflows if we are given unusually large block size.
-#define BLOCK_SIZE_MAX (UINT64_MAX / LZMA_THREADS_MAX)
-
-
-typedef enum {
- /// Waiting for work.
- THR_IDLE,
-
- /// Encoding is in progress.
- THR_RUN,
-
- /// Encoding is in progress but no more input data will
- /// be read.
- THR_FINISH,
-
- /// The main thread wants the thread to stop whatever it was doing
- /// but not exit.
- THR_STOP,
-
- /// The main thread wants the thread to exit. We could use
- /// cancellation but since there's stopped anyway, this is lazier.
- THR_EXIT,
-
-} worker_state;
-
-
-typedef struct worker_thread_s worker_thread;
-struct worker_thread_s {
- worker_state state;
-
- /// Input buffer of coder->block_size bytes. The main thread will
- /// put new input into this and update in_size accordingly. Once
- /// no more input is coming, state will be set to THR_FINISH.
- uint8_t *in;
-
- /// Amount of data available in the input buffer. This is modified
- /// only by the main thread.
- size_t in_size;
-
- /// Output buffer for this thread. This is set by the main
- /// thread every time a new Block is started with this thread
- /// structure.
- lzma_outbuf *outbuf;
-
- /// Pointer to the main structure is needed when putting this
- /// thread back to the stack of free threads.
- lzma_coder *coder;
-
- /// The allocator is set by the main thread. Since a copy of the
- /// pointer is kept here, the application must not change the
- /// allocator before calling lzma_end().
- lzma_allocator *allocator;
-
- /// Block encoder
- lzma_next_coder block_encoder;
-
- /// Compression options for this Block
- lzma_block block_options;
-
- /// Next structure in the stack of free worker threads.
- worker_thread *next;
-
- pthread_mutex_t mutex;
- pthread_cond_t cond;
-
- /// The ID of this thread is used to join the thread
- /// when it's not needed anymore.
- pthread_t thread_id;
-};
-
-
-struct lzma_coder_s {
- enum {
- SEQ_STREAM_HEADER,
- SEQ_BLOCK,
- SEQ_INDEX,
- SEQ_STREAM_FOOTER,
- } sequence;
-
- /// Start a new Block every block_size bytes of input unless
- /// LZMA_FULL_FLUSH or LZMA_FULL_BARRIER is used earlier.
- size_t block_size;
-
- /// The filter chain currently in use
- lzma_filter filters[LZMA_FILTERS_MAX + 1];
-
-
- /// Index to hold sizes of the Blocks
- lzma_index *index;
-
- /// Index encoder
- lzma_next_coder index_encoder;
-
-
- /// Stream Flags for encoding the Stream Header and Stream Footer.
- lzma_stream_flags stream_flags;
-
- /// Buffer to hold Stream Header and Stream Footer.
- uint8_t header[LZMA_STREAM_HEADER_SIZE];
-
- /// Read position in header[]
- size_t header_pos;
-
-
- /// Output buffer queue for compressed data
- lzma_outq outq;
-
-
- /// True if wait_max is used.
- bool has_timeout;
-
- /// Maximum wait time if cannot use all the input and cannot
- /// fill the output buffer.
- struct timespec wait_max;
-
-
- /// Error code from a worker thread
- lzma_ret thread_error;
-
- /// Array of allocated thread-specific structures
- worker_thread *threads;
-
- /// Number of structures in "threads" above. This is also the
- /// number of threads that will be created at maximum.
- uint32_t threads_max;
-
- /// Number of thread structures that have been initialized, and
- /// thus the number of worker threads actually created so far.
- uint32_t threads_initialized;
-
- /// Stack of free threads. When a thread finishes, it puts itself
- /// back into this stack. This starts as empty because threads
- /// are created only when actually needed.
- worker_thread *threads_free;
-
- /// The most recent worker thread to which the main thread writes
- /// the new input from the application.
- worker_thread *thr;
-
- pthread_mutex_t mutex;
- mythread_cond cond;
-};
-
-
-/// Tell the main thread that something has gone wrong.
-static void
-worker_error(worker_thread *thr, lzma_ret ret)
-{
- assert(ret != LZMA_OK);
- assert(ret != LZMA_STREAM_END);
-
- mythread_sync(thr->coder->mutex) {
- if (thr->coder->thread_error == LZMA_OK)
- thr->coder->thread_error = ret;
-
- mythread_cond_signal(&thr->coder->cond);
- }
-
- return;
-}
-
-
-static worker_state
-worker_encode(worker_thread *thr, worker_state state)
-{
- // Set the Block options.
- thr->block_options = (lzma_block){
- .version = 0,
- .check = thr->coder->stream_flags.check,
- .compressed_size = thr->coder->outq.buf_size_max,
- .uncompressed_size = thr->coder->block_size,
-
- // TODO: To allow changing the filter chain, the filters
- // array must be copied to each worker_thread.
- .filters = thr->coder->filters,
- };
-
- // Calculate maximum size of the Block Header. This amount is
- // reserved in the beginning of the buffer so that Block Header
- // along with Compressed Size and Uncompressed Size can be
- // written there.
- lzma_ret ret = lzma_block_header_size(&thr->block_options);
- if (ret != LZMA_OK) {
- worker_error(thr, ret);
- return THR_STOP;
- }
-
- // Initialize the Block encoder.
- ret = lzma_block_encoder_init(&thr->block_encoder,
- thr->allocator, &thr->block_options);
- if (ret != LZMA_OK) {
- worker_error(thr, ret);
- return THR_STOP;
- }
-
- size_t in_pos = 0;
- size_t in_size = 0;
-
- thr->outbuf->size = thr->block_options.header_size;
- const size_t out_size = thr->coder->outq.buf_size_max;
-
- do {
- mythread_sync(thr->mutex) {
- while (in_size == thr->in_size
- && thr->state == THR_RUN)
- pthread_cond_wait(&thr->cond, &thr->mutex);
-
- state = thr->state;
- in_size = thr->in_size;
-
- // TODO? Store in_pos and out_pos into *thr here
- // so that the application may read them via
- // some currently non-existing function to get
- // progress information.
- }
-
- // Return if we were asked to stop or exit.
- if (state >= THR_STOP)
- return state;
-
- lzma_action action = state == THR_FINISH
- ? LZMA_FINISH : LZMA_RUN;
-
- // Limit the amount of input given to the Block encoder
- // at once. This way this thread can react fairly quickly
- // if the main thread wants us to stop or exit.
- static const size_t in_chunk_max = 16384;
- size_t in_limit = in_size;
- if (in_size - in_pos > in_chunk_max) {
- in_limit = in_pos + in_chunk_max;
- action = LZMA_RUN;
- }
-
- ret = thr->block_encoder.code(
- thr->block_encoder.coder, thr->allocator,
- thr->in, &in_pos, in_limit, thr->outbuf->buf,
- &thr->outbuf->size, out_size, action);
- } while (ret == LZMA_OK);
-
- if (ret != LZMA_STREAM_END) {
- worker_error(thr, ret);
- return THR_STOP;
- }
-
- assert(state == THR_FINISH);
-
- // Encode the Block Header. By doing it after the compression,
- // we can store the Compressed Size and Uncompressed Size fields.
- ret = lzma_block_header_encode(&thr->block_options, thr->outbuf->buf);
- if (ret != LZMA_OK) {
- worker_error(thr, ret);
- return THR_STOP;
- }
-
- // Set the size information that will be read by the main thread
- // to write the Index field.
- thr->outbuf->unpadded_size
- = lzma_block_unpadded_size(&thr->block_options);
- assert(thr->outbuf->unpadded_size != 0);
- thr->outbuf->uncompressed_size = thr->block_options.uncompressed_size;
-
- return THR_FINISH;
-}
-
-
-static void *
-worker_start(void *thr_ptr)
-{
- worker_thread *thr = thr_ptr;
- worker_state state = THR_IDLE; // Init to silence a warning
-
- while (true) {
- // Wait for work.
- mythread_sync(thr->mutex) {
- while (true) {
- // The thread is already idle so if we are
- // requested to stop, just set the state.
- if (thr->state == THR_STOP) {
- thr->state = THR_IDLE;
- pthread_cond_signal(&thr->cond);
- }
-
- state = thr->state;
- if (state != THR_IDLE)
- break;
-
- pthread_cond_wait(&thr->cond, &thr->mutex);
- }
- }
-
- assert(state != THR_IDLE);
- assert(state != THR_STOP);
-
- if (state <= THR_FINISH)
- state = worker_encode(thr, state);
-
- if (state == THR_EXIT)
- break;
-
- // Mark the thread as idle. Signal is needed for the case
- // where the main thread is waiting for the threads to stop.
- mythread_sync(thr->mutex) {
- thr->state = THR_IDLE;
- pthread_cond_signal(&thr->cond);
- }
-
- mythread_sync(thr->coder->mutex) {
- // Mark the output buffer as finished if
- // no errors occurred.
- thr->outbuf->finished = state == THR_FINISH;
-
- // Return this thread to the stack of free threads.
- thr->next = thr->coder->threads_free;
- thr->coder->threads_free = thr;
-
- mythread_cond_signal(&thr->coder->cond);
- }
- }
-
- // Exiting, free the resources.
- pthread_mutex_destroy(&thr->mutex);
- pthread_cond_destroy(&thr->cond);
-
- lzma_next_end(&thr->block_encoder, thr->allocator);
- lzma_free(thr->in, thr->allocator);
- return NULL;
-}
-
-
-/// Make the threads stop but not exit. Optionally wait for them to stop.
-static void
-threads_stop(lzma_coder *coder, bool wait)
-{
- // Tell the threads to stop.
- for (uint32_t i = 0; i < coder->threads_initialized; ++i) {
- mythread_sync(coder->threads[i].mutex) {
- coder->threads[i].state = THR_STOP;
- pthread_cond_signal(&coder->threads[i].cond);
- }
- }
-
- if (!wait)
- return;
-
- // Wait for the threads to settle in the idle state.
- for (uint32_t i = 0; i < coder->threads_initialized; ++i) {
- mythread_sync(coder->threads[i].mutex) {
- while (coder->threads[i].state != THR_IDLE)
- pthread_cond_wait(&coder->threads[i].cond,
- &coder->threads[i].mutex);
- }
- }
-
- return;
-}
-
-
-/// Stop the threads and free the resources associated with them.
-/// Wait until the threads have exited.
-static void
-threads_end(lzma_coder *coder, lzma_allocator *allocator)
-{
- for (uint32_t i = 0; i < coder->threads_initialized; ++i) {
- mythread_sync(coder->threads[i].mutex) {
- coder->threads[i].state = THR_EXIT;
- pthread_cond_signal(&coder->threads[i].cond);
- }
- }
-
- for (uint32_t i = 0; i < coder->threads_initialized; ++i) {
- int ret = pthread_join(coder->threads[i].thread_id, NULL);
- assert(ret == 0);
- (void)ret;
- }
-
- lzma_free(coder->threads, allocator);
- return;
-}
-
-
-/// Initialize a new worker_thread structure and create a new thread.
-static lzma_ret
-initialize_new_thread(lzma_coder *coder, lzma_allocator *allocator)
-{
- worker_thread *thr = &coder->threads[coder->threads_initialized];
-
- thr->in = lzma_alloc(coder->block_size, allocator);
- if (thr->in == NULL)
- return LZMA_MEM_ERROR;
-
- if (pthread_mutex_init(&thr->mutex, NULL))
- goto error_mutex;
-
- if (pthread_cond_init(&thr->cond, NULL))
- goto error_cond;
-
- thr->state = THR_IDLE;
- thr->allocator = allocator;
- thr->coder = coder;
- thr->block_encoder = LZMA_NEXT_CODER_INIT;
-
- if (mythread_create(&thr->thread_id, &worker_start, thr))
- goto error_thread;
-
- ++coder->threads_initialized;
- coder->thr = thr;
-
- return LZMA_OK;
-
-error_thread:
- pthread_cond_destroy(&thr->cond);
-
-error_cond:
- pthread_mutex_destroy(&thr->mutex);
-
-error_mutex:
- lzma_free(thr->in, allocator);
- return LZMA_MEM_ERROR;
-}
-
-
-static lzma_ret
-get_thread(lzma_coder *coder, lzma_allocator *allocator)
-{
- // If there are no free output subqueues, there is no
- // point to try getting a thread.
- if (!lzma_outq_has_buf(&coder->outq))
- return LZMA_OK;
-
- // If there is a free structure on the stack, use it.
- mythread_sync(coder->mutex) {
- if (coder->threads_free != NULL) {
- coder->thr = coder->threads_free;
- coder->threads_free = coder->threads_free->next;
- }
- }
-
- if (coder->thr == NULL) {
- // If there are no uninitialized structures left, return.
- if (coder->threads_initialized == coder->threads_max)
- return LZMA_OK;
-
- // Initialize a new thread.
- return_if_error(initialize_new_thread(coder, allocator));
- }
-
- // Reset the parts of the thread state that have to be done
- // in the main thread.
- mythread_sync(coder->thr->mutex) {
- coder->thr->state = THR_RUN;
- coder->thr->in_size = 0;
- coder->thr->outbuf = lzma_outq_get_buf(&coder->outq);
- pthread_cond_signal(&coder->thr->cond);
- }
-
- return LZMA_OK;
-}
-
-
-static lzma_ret
-stream_encode_in(lzma_coder *coder, lzma_allocator *allocator,
- const uint8_t *restrict in, size_t *restrict in_pos,
- size_t in_size, lzma_action action)
-{
- while (*in_pos < in_size
- || (coder->thr != NULL && action != LZMA_RUN)) {
- if (coder->thr == NULL) {
- // Get a new thread.
- const lzma_ret ret = get_thread(coder, allocator);
- if (coder->thr == NULL)
- return ret;
- }
-
- // Copy the input data to thread's buffer.
- size_t thr_in_size = coder->thr->in_size;
- lzma_bufcpy(in, in_pos, in_size, coder->thr->in,
- &thr_in_size, coder->block_size);
-
- // Tell the Block encoder to finish if
- // - it has got block_size bytes of input; or
- // - all input was used and LZMA_FINISH, LZMA_FULL_FLUSH,
- // or LZMA_FULL_BARRIER was used.
- //
- // TODO: LZMA_SYNC_FLUSH and LZMA_SYNC_BARRIER.
- const bool finish = thr_in_size == coder->block_size
- || (*in_pos == in_size && action != LZMA_RUN);
-
- bool block_error = false;
-
- mythread_sync(coder->thr->mutex) {
- if (coder->thr->state == THR_IDLE) {
- // Something has gone wrong with the Block
- // encoder. It has set coder->thread_error
- // which we will read a few lines later.
- block_error = true;
- } else {
- // Tell the Block encoder its new amount
- // of input and update the state if needed.
- coder->thr->in_size = thr_in_size;
-
- if (finish)
- coder->thr->state = THR_FINISH;
-
- pthread_cond_signal(&coder->thr->cond);
- }
- }
-
- if (block_error) {
- lzma_ret ret;
-
- mythread_sync(coder->mutex) {
- ret = coder->thread_error;
- }
-
- return ret;
- }
-
- if (finish)
- coder->thr = NULL;
- }
-
- return LZMA_OK;
-}
-
-
-/// Wait until more input can be consumed, more output can be read, or
-/// an optional timeout is reached.
-static bool
-wait_for_work(lzma_coder *coder, struct timespec *wait_abs,
- bool *has_blocked, bool has_input)
-{
- if (coder->has_timeout && !*has_blocked) {
- // Every time when stream_encode_mt() is called via
- // lzma_code(), *has_block starts as false. We set it
- // to true here and calculate the absolute time when
- // we must return if there's nothing to do.
- //
- // The idea of *has_blocked is to avoid unneeded calls
- // to mythread_cond_abstime(), which may do a syscall
- // depending on the operating system.
- *has_blocked = true;
- *wait_abs = coder->wait_max;
- mythread_cond_abstime(&coder->cond, wait_abs);
- }
-
- bool timed_out = false;
-
- mythread_sync(coder->mutex) {
- // There are four things that we wait. If one of them
- // becomes possible, we return.
- // - If there is input left, we need to get a free
- // worker thread and an output buffer for it.
- // - Data ready to be read from the output queue.
- // - A worker thread indicates an error.
- // - Time out occurs.
- while ((!has_input || coder->threads_free == NULL
- || !lzma_outq_has_buf(&coder->outq))
- && !lzma_outq_is_readable(&coder->outq)
- && coder->thread_error == LZMA_OK
- && !timed_out) {
- if (coder->has_timeout)
- timed_out = mythread_cond_timedwait(
- &coder->cond, &coder->mutex,
- wait_abs) != 0;
- else
- mythread_cond_wait(&coder->cond,
- &coder->mutex);
- }
- }
-
- return timed_out;
-}
-
-
-static lzma_ret
-stream_encode_mt(lzma_coder *coder, lzma_allocator *allocator,
- const uint8_t *restrict in, size_t *restrict in_pos,
- size_t in_size, uint8_t *restrict out,
- size_t *restrict out_pos, size_t out_size, lzma_action action)
-{
- switch (coder->sequence) {
- case SEQ_STREAM_HEADER:
- lzma_bufcpy(coder->header, &coder->header_pos,
- sizeof(coder->header),
- out, out_pos, out_size);
- if (coder->header_pos < sizeof(coder->header))
- return LZMA_OK;
-
- coder->header_pos = 0;
- coder->sequence = SEQ_BLOCK;
-
- // Fall through
-
- case SEQ_BLOCK: {
- // Initialized to silence warnings.
- lzma_vli unpadded_size = 0;
- lzma_vli uncompressed_size = 0;
- lzma_ret ret = LZMA_OK;
-
- // These are for wait_for_work().
- bool has_blocked = false;
- struct timespec wait_abs;
-
- while (true) {
- mythread_sync(coder->mutex) {
- // Check for Block encoder errors.
- ret = coder->thread_error;
- if (ret != LZMA_OK) {
- assert(ret != LZMA_STREAM_END);
- break;
- }
-
- // Try to read compressed data to out[].
- ret = lzma_outq_read(&coder->outq,
- out, out_pos, out_size,
- &unpadded_size,
- &uncompressed_size);
- }
-
- if (ret == LZMA_STREAM_END) {
- // End of Block. Add it to the Index.
- ret = lzma_index_append(coder->index,
- allocator, unpadded_size,
- uncompressed_size);
-
- // If we didn't fill the output buffer yet,
- // try to read more data. Maybe the next
- // outbuf has been finished already too.
- if (*out_pos < out_size)
- continue;
- }
-
- if (ret != LZMA_OK) {
- // coder->thread_error was set or
- // lzma_index_append() failed.
- threads_stop(coder, false);
- return ret;
- }
-
- // Check if the last Block was finished.
- if (action == LZMA_FINISH
- && *in_pos == in_size
- && lzma_outq_is_empty(
- &coder->outq))
- break;
-
- // Try to give uncompressed data to a worker thread.
- ret = stream_encode_in(coder, allocator,
- in, in_pos, in_size, action);
- if (ret != LZMA_OK) {
- threads_stop(coder, false);
- return ret;
- }
-
- // Return if
- // - we have used all the input and expect to
- // get more input; or
- // - the output buffer has been filled.
- //
- // TODO: Support flushing.
- if ((*in_pos == in_size && action != LZMA_FINISH)
- || *out_pos == out_size)
- return LZMA_OK;
-
- // Neither in nor out has been used completely.
- // Wait until there's something we can do.
- if (wait_for_work(coder, &wait_abs, &has_blocked,
- *in_pos < in_size))
- return LZMA_TIMED_OUT;
- }
-
- // All Blocks have been encoded and the threads have stopped.
- // Prepare to encode the Index field.
- return_if_error(lzma_index_encoder_init(
- &coder->index_encoder, allocator,
- coder->index));
- coder->sequence = SEQ_INDEX;
- }
-
- // Fall through
-
- case SEQ_INDEX: {
- // Call the Index encoder. It doesn't take any input, so
- // those pointers can be NULL.
- const lzma_ret ret = coder->index_encoder.code(
- coder->index_encoder.coder, allocator,
- NULL, NULL, 0,
- out, out_pos, out_size, LZMA_RUN);
- if (ret != LZMA_STREAM_END)
- return ret;
-
- // Encode the Stream Footer into coder->buffer.
- coder->stream_flags.backward_size
- = lzma_index_size(coder->index);
- if (lzma_stream_footer_encode(&coder->stream_flags,
- coder->header) != LZMA_OK)
- return LZMA_PROG_ERROR;
-
- coder->sequence = SEQ_STREAM_FOOTER;
- }
-
- // Fall through
-
- case SEQ_STREAM_FOOTER:
- lzma_bufcpy(coder->header, &coder->header_pos,
- sizeof(coder->header),
- out, out_pos, out_size);
- return coder->header_pos < sizeof(coder->header)
- ? LZMA_OK : LZMA_STREAM_END;
- }
-
- assert(0);
- return LZMA_PROG_ERROR;
-}
-
-
-static void
-stream_encoder_mt_end(lzma_coder *coder, lzma_allocator *allocator)
-{
- // Threads must be killed before the output queue can be freed.
- threads_end(coder, allocator);
- lzma_outq_end(&coder->outq, allocator);
-
- for (size_t i = 0; coder->filters[i].id != LZMA_VLI_UNKNOWN; ++i)
- lzma_free(coder->filters[i].options, allocator);
-
- lzma_next_end(&coder->index_encoder, allocator);
- lzma_index_end(coder->index, allocator);
-
- mythread_cond_destroy(&coder->cond);
- pthread_mutex_destroy(&coder->mutex);
-
- lzma_free(coder, allocator);
- return;
-}
-
-
-/// Options handling for lzma_stream_encoder_mt_init() and
-/// lzma_stream_encoder_mt_memusage()
-static lzma_ret
-get_options(const lzma_mt *options, lzma_options_easy *opt_easy,
- const lzma_filter **filters, uint64_t *block_size,
- uint64_t *outbuf_size_max)
-{
- // Validate some of the options.
- if (options == NULL)
- return LZMA_PROG_ERROR;
-
- if (options->flags != 0 || options->threads == 0
- || options->threads > LZMA_THREADS_MAX)
- return LZMA_OPTIONS_ERROR;
-
- if (options->filters != NULL) {
- // Filter chain was given, use it as is.
- *filters = options->filters;
- } else {
- // Use a preset.
- if (lzma_easy_preset(opt_easy, options->preset))
- return LZMA_OPTIONS_ERROR;
-
- *filters = opt_easy->filters;
- }
-
- // Block size
- if (options->block_size > 0) {
- if (options->block_size > BLOCK_SIZE_MAX)
- return LZMA_OPTIONS_ERROR;
-
- *block_size = options->block_size;
- } else {
- // Determine the Block size from the filter chain.
- *block_size = lzma_mt_block_size(*filters);
- if (*block_size == 0)
- return LZMA_OPTIONS_ERROR;
-
- assert(*block_size <= BLOCK_SIZE_MAX);
- }
-
- // Calculate the maximum amount output that a single output buffer
- // may need to hold. This is the same as the maximum total size of
- // a Block.
- //
- // FIXME: As long as the encoder keeps the whole input buffer
- // available and doesn't start writing output before finishing
- // the Block, it could use lzma_stream_buffer_bound() and use
- // uncompressed LZMA2 chunks if the data doesn't compress.
- *outbuf_size_max = *block_size + *block_size / 16 + 16384;
-
- return LZMA_OK;
-}
-
-
-static lzma_ret
-stream_encoder_mt_init(lzma_next_coder *next, lzma_allocator *allocator,
- const lzma_mt *options)
-{
- lzma_next_coder_init(&stream_encoder_mt_init, next, allocator);
-
- // Get the filter chain.
- lzma_options_easy easy;
- const lzma_filter *filters;
- uint64_t block_size;
- uint64_t outbuf_size_max;
- return_if_error(get_options(options, &easy, &filters,
- &block_size, &outbuf_size_max));
-
-#if SIZE_MAX < UINT64_MAX
- if (block_size > SIZE_MAX)
- return LZMA_MEM_ERROR;
-#endif
-
- // FIXME TODO: Validate the filter chain so that we can give
- // an error in this function instead of delaying it to the first
- // call to lzma_code().
-
- // Validate the Check ID.
- if ((unsigned int)(options->check) > LZMA_CHECK_ID_MAX)
- return LZMA_PROG_ERROR;
-
- if (!lzma_check_is_supported(options->check))
- return LZMA_UNSUPPORTED_CHECK;
-
- // Allocate and initialize the base structure if needed.
- if (next->coder == NULL) {
- next->coder = lzma_alloc(sizeof(lzma_coder), allocator);
- if (next->coder == NULL)
- return LZMA_MEM_ERROR;
-
- // For the mutex and condition variable initializations
- // the error handling has to be done here because
- // stream_encoder_mt_end() doesn't know if they have
- // already been initialized or not.
- if (pthread_mutex_init(&next->coder->mutex, NULL)) {
- lzma_free(next->coder, allocator);
- next->coder = NULL;
- return LZMA_MEM_ERROR;
- }
-
- if (mythread_cond_init(&next->coder->cond)) {
- pthread_mutex_destroy(&next->coder->mutex);
- lzma_free(next->coder, allocator);
- next->coder = NULL;
- return LZMA_MEM_ERROR;
- }
-
- next->code = &stream_encode_mt;
- next->end = &stream_encoder_mt_end;
-// next->update = &stream_encoder_mt_update;
-
- next->coder->filters[0].id = LZMA_VLI_UNKNOWN;
- next->coder->index_encoder = LZMA_NEXT_CODER_INIT;
- next->coder->index = NULL;
- memzero(&next->coder->outq, sizeof(next->coder->outq));
- next->coder->threads = NULL;
- next->coder->threads_max = 0;
- next->coder->threads_initialized = 0;
- }
-
- // Basic initializations
- next->coder->sequence = SEQ_STREAM_HEADER;
- next->coder->block_size = (size_t)(block_size);
- next->coder->thread_error = LZMA_OK;
- next->coder->thr = NULL;
-
- // Allocate the thread-specific base structures.
- assert(options->threads > 0);
- if (next->coder->threads_max != options->threads) {
- threads_end(next->coder, allocator);
-
- next->coder->threads = NULL;
- next->coder->threads_max = 0;
-
- next->coder->threads_initialized = 0;
- next->coder->threads_free = NULL;
-
- next->coder->threads = lzma_alloc(
- options->threads * sizeof(worker_thread),
- allocator);
- if (next->coder->threads == NULL)
- return LZMA_MEM_ERROR;
-
- next->coder->threads_max = options->threads;
- } else {
- // Reuse the old structures and threads. Tell the running
- // threads to stop and wait until they have stopped.
- threads_stop(next->coder, true);
- }
-
- // Output queue
- return_if_error(lzma_outq_init(&next->coder->outq, allocator,
- outbuf_size_max, options->threads));
-
- // Timeout
- if (options->timeout > 0) {
- next->coder->wait_max.tv_sec = options->timeout / 1000;
- next->coder->wait_max.tv_nsec
- = (options->timeout % 1000) * 1000000L;
- next->coder->has_timeout = true;
- } else {
- next->coder->has_timeout = false;
- }
-
- // Free the old filter chain and copy the new one.
- for (size_t i = 0; next->coder->filters[i].id != LZMA_VLI_UNKNOWN; ++i)
- lzma_free(next->coder->filters[i].options, allocator);
-
- return_if_error(lzma_filters_copy(options->filters,
- next->coder->filters, allocator));
-
- // Index
- lzma_index_end(next->coder->index, allocator);
- next->coder->index = lzma_index_init(allocator);
- if (next->coder->index == NULL)
- return LZMA_MEM_ERROR;
-
- // Stream Header
- next->coder->stream_flags.version = 0;
- next->coder->stream_flags.check = options->check;
- return_if_error(lzma_stream_header_encode(
- &next->coder->stream_flags, next->coder->header));
-
- next->coder->header_pos = 0;
-
- return LZMA_OK;
-}
-
-
-extern LZMA_API(lzma_ret)
-lzma_stream_encoder_mt(lzma_stream *strm, const lzma_mt *options)
-{
- lzma_next_strm_init(stream_encoder_mt_init, strm, options);
-
- strm->internal->supported_actions[LZMA_RUN] = true;
-// strm->internal->supported_actions[LZMA_SYNC_FLUSH] = true;
-// strm->internal->supported_actions[LZMA_FULL_FLUSH] = true;
-// strm->internal->supported_actions[LZMA_FULL_BARRIER] = true;
- strm->internal->supported_actions[LZMA_FINISH] = true;
-
- return LZMA_OK;
-}
-
-
-// This function name is a monster but it's consistent with the older
-// monster names. :-( 31 chars is the max that C99 requires so in that
-// sense it's not too long. ;-)
-extern LZMA_API(uint64_t)
-lzma_stream_encoder_mt_memusage(const lzma_mt *options)
-{
- lzma_options_easy easy;
- const lzma_filter *filters;
- uint64_t block_size;
- uint64_t outbuf_size_max;
-
- if (get_options(options, &easy, &filters, &block_size,
- &outbuf_size_max) != LZMA_OK)
- return UINT64_MAX;
-
- // Memory usage of the input buffers
- const uint64_t inbuf_memusage = options->threads * block_size;
-
- // Memory usage of the filter encoders
- uint64_t filters_memusage
- = lzma_raw_encoder_memusage(options->filters);
- if (filters_memusage == UINT64_MAX)
- return UINT64_MAX;
-
- filters_memusage *= options->threads;
-
- // Memory usage of the output queue
- const uint64_t outq_memusage = lzma_outq_memusage(
- outbuf_size_max, options->threads);
- if (outq_memusage == UINT64_MAX)
- return UINT64_MAX;
-
- // Sum them with overflow checking.
- uint64_t total_memusage = LZMA_MEMUSAGE_BASE + sizeof(lzma_coder)
- + options->threads * sizeof(worker_thread);
-
- if (UINT64_MAX - total_memusage < inbuf_memusage)
- return UINT64_MAX;
-
- total_memusage += inbuf_memusage;
-
- if (UINT64_MAX - total_memusage < filters_memusage)
- return UINT64_MAX;
-
- total_memusage += filters_memusage;
-
- if (UINT64_MAX - total_memusage < outq_memusage)
- return UINT64_MAX;
-
- return total_memusage + outq_memusage;
-}
diff --git a/src/liblzma/liblzma.map b/src/liblzma/liblzma.map
index 835eb26..47a7c22 100644
--- a/src/liblzma/liblzma.map
+++ b/src/liblzma/liblzma.map
@@ -93,13 +93,7 @@
lzma_vli_decode;
lzma_vli_encode;
lzma_vli_size;
-};
-
-XZ_5.1.1alpha {
-global:
- lzma_stream_encoder_mt;
- lzma_stream_encoder_mt_memusage;
local:
*;
-} XZ_5.0;
+};
diff --git a/src/xz/args.c b/src/xz/args.c
index 54b3ff3..1b88c1e 100644
--- a/src/xz/args.c
+++ b/src/xz/args.c
@@ -179,9 +179,8 @@
break;
case 'T':
- // The max is from src/liblzma/common/common.h.
- hardware_threads_set(str_to_uint64("threads",
- optarg, 0, 16384));
+ hardware_threadlimit_set(str_to_uint64(
+ "threads", optarg, 0, UINT32_MAX));
break;
// --version
diff --git a/src/xz/coder.c b/src/xz/coder.c
index 2ed88cd..a3366d0 100644
--- a/src/xz/coder.c
+++ b/src/xz/coder.c
@@ -55,14 +55,6 @@
/// This becomes false if the --check=CHECK option is used.
static bool check_default = true;
-#ifdef HAVE_PTHREAD
-static lzma_mt mt_options = {
- .flags = 0,
- .timeout = 300,
- .filters = filters,
-};
-#endif
-
extern void
coder_set_check(lzma_check new_check)
@@ -125,15 +117,6 @@
extern void
coder_set_compression_settings(void)
{
- // The default check type is CRC64, but fallback to CRC32
- // if CRC64 isn't supported by the copy of liblzma we are
- // using. CRC32 is always supported.
- if (check_default) {
- check = LZMA_CHECK_CRC64;
- if (!lzma_check_is_supported(check))
- check = LZMA_CHECK_CRC32;
- }
-
// Options for LZMA1 or LZMA2 in case we are using a preset.
static lzma_options_lzma opt_lzma;
@@ -187,30 +170,15 @@
// Print the selected filter chain.
message_filters_show(V_DEBUG, filters);
- // Get the memory usage. Note that if --format=raw was used,
- // we can be decompressing.
+ // If using --format=raw, we can be decoding. The memusage function
+ // also validates the filter chain and the options used for the
+ // filters.
const uint64_t memory_limit = hardware_memlimit_get(opt_mode);
uint64_t memory_usage;
- if (opt_mode == MODE_COMPRESS) {
-#ifdef HAVE_PTHREAD
- if (opt_format == FORMAT_XZ && hardware_threads_get() > 1) {
- mt_options.threads = hardware_threads_get();
- mt_options.block_size = opt_block_size;
- mt_options.check = check;
- memory_usage = lzma_stream_encoder_mt_memusage(
- &mt_options);
- if (memory_usage != UINT64_MAX)
- message(V_DEBUG, _("Using up to %" PRIu32
- " threads."),
- mt_options.threads);
- } else
-#endif
- {
- memory_usage = lzma_raw_encoder_memusage(filters);
- }
- } else {
+ if (opt_mode == MODE_COMPRESS)
+ memory_usage = lzma_raw_encoder_memusage(filters);
+ else
memory_usage = lzma_raw_decoder_memusage(filters);
- }
if (memory_usage == UINT64_MAX)
message_fatal(_("Unsupported filter chain or filter options"));
@@ -226,99 +194,90 @@
round_up_to_mib(decmem), 0));
}
- if (memory_usage <= memory_limit)
- return;
+ if (memory_usage > memory_limit) {
+ // If --no-auto-adjust was used or we didn't find LZMA1 or
+ // LZMA2 as the last filter, give an error immediately.
+ // --format=raw implies --no-auto-adjust.
+ if (!opt_auto_adjust || opt_format == FORMAT_RAW)
+ memlimit_too_small(memory_usage);
- // If --no-auto-adjust was used or we didn't find LZMA1 or
- // LZMA2 as the last filter, give an error immediately.
- // --format=raw implies --no-auto-adjust.
- if (!opt_auto_adjust || opt_format == FORMAT_RAW)
- memlimit_too_small(memory_usage);
+ assert(opt_mode == MODE_COMPRESS);
- assert(opt_mode == MODE_COMPRESS);
-
-#ifdef HAVE_PTHREAD
- if (opt_format == FORMAT_XZ && mt_options.threads > 1) {
- // Try to reduce the number of threads before
- // adjusting the compression settings down.
- do {
- // FIXME? The real single-threaded mode has
- // lower memory usage, but it's not comparable
- // because it doesn't write the size info
- // into Block Headers.
- if (--mt_options.threads == 0)
+ // Look for the last filter if it is LZMA2 or LZMA1, so
+ // we can make it use less RAM. With other filters we don't
+ // know what to do.
+ size_t i = 0;
+ while (filters[i].id != LZMA_FILTER_LZMA2
+ && filters[i].id != LZMA_FILTER_LZMA1) {
+ if (filters[i].id == LZMA_VLI_UNKNOWN)
memlimit_too_small(memory_usage);
- memory_usage = lzma_stream_encoder_mt_memusage(
- &mt_options);
+ ++i;
+ }
+
+ // Decrease the dictionary size until we meet the memory
+ // usage limit. First round down to full mebibytes.
+ lzma_options_lzma *opt = filters[i].options;
+ const uint32_t orig_dict_size = opt->dict_size;
+ opt->dict_size &= ~((UINT32_C(1) << 20) - 1);
+ while (true) {
+ // If it is below 1 MiB, auto-adjusting failed. We
+ // could be more sophisticated and scale it down even
+ // more, but let's see if many complain about this
+ // version.
+ //
+ // FIXME: Displays the scaled memory usage instead
+ // of the original.
+ if (opt->dict_size < (UINT32_C(1) << 20))
+ memlimit_too_small(memory_usage);
+
+ memory_usage = lzma_raw_encoder_memusage(filters);
if (memory_usage == UINT64_MAX)
message_bug();
- } while (memory_usage > memory_limit);
+ // Accept it if it is low enough.
+ if (memory_usage <= memory_limit)
+ break;
- message(V_WARNING, _("Adjusted the number of threads "
- "from %s to %s to not exceed "
- "the memory usage limit of %s MiB"),
- uint64_to_str(hardware_threads_get(), 0),
- uint64_to_str(mt_options.threads, 1),
- uint64_to_str(round_up_to_mib(
- memory_limit), 2));
- }
-#endif
+ // Otherwise 1 MiB down and try again. I hope this
+ // isn't too slow method for cases where the original
+ // dict_size is very big.
+ opt->dict_size -= UINT32_C(1) << 20;
+ }
- if (memory_usage <= memory_limit)
- return;
-
- // Look for the last filter if it is LZMA2 or LZMA1, so we can make
- // it use less RAM. With other filters we don't know what to do.
- size_t i = 0;
- while (filters[i].id != LZMA_FILTER_LZMA2
- && filters[i].id != LZMA_FILTER_LZMA1) {
- if (filters[i].id == LZMA_VLI_UNKNOWN)
- memlimit_too_small(memory_usage);
-
- ++i;
+ // Tell the user that we decreased the dictionary size.
+ message(V_WARNING, _("Adjusted LZMA%c dictionary size "
+ "from %s MiB to %s MiB to not exceed "
+ "the memory usage limit of %s MiB"),
+ filters[i].id == LZMA_FILTER_LZMA2
+ ? '2' : '1',
+ uint64_to_str(orig_dict_size >> 20, 0),
+ uint64_to_str(opt->dict_size >> 20, 1),
+ uint64_to_str(round_up_to_mib(
+ memory_limit), 2));
}
- // Decrease the dictionary size until we meet the memory
- // usage limit. First round down to full mebibytes.
- lzma_options_lzma *opt = filters[i].options;
- const uint32_t orig_dict_size = opt->dict_size;
- opt->dict_size &= ~((UINT32_C(1) << 20) - 1);
- while (true) {
- // If it is below 1 MiB, auto-adjusting failed. We could be
- // more sophisticated and scale it down even more, but let's
- // see if many complain about this version.
- //
- // FIXME: Displays the scaled memory usage instead
- // of the original.
- if (opt->dict_size < (UINT32_C(1) << 20))
- memlimit_too_small(memory_usage);
+/*
+ // Limit the number of worker threads so that memory usage
+ // limit isn't exceeded.
+ assert(memory_usage > 0);
+ size_t thread_limit = memory_limit / memory_usage;
+ if (thread_limit == 0)
+ thread_limit = 1;
- memory_usage = lzma_raw_encoder_memusage(filters);
- if (memory_usage == UINT64_MAX)
- message_bug();
+ if (opt_threads > thread_limit)
+ opt_threads = thread_limit;
+*/
- // Accept it if it is low enough.
- if (memory_usage <= memory_limit)
- break;
-
- // Otherwise 1 MiB down and try again. I hope this
- // isn't too slow method for cases where the original
- // dict_size is very big.
- opt->dict_size -= UINT32_C(1) << 20;
+ if (check_default) {
+ // The default check type is CRC64, but fallback to CRC32
+ // if CRC64 isn't supported by the copy of liblzma we are
+ // using. CRC32 is always supported.
+ check = LZMA_CHECK_CRC64;
+ if (!lzma_check_is_supported(check))
+ check = LZMA_CHECK_CRC32;
}
- // Tell the user that we decreased the dictionary size.
- message(V_WARNING, _("Adjusted LZMA%c dictionary size "
- "from %s MiB to %s MiB to not exceed "
- "the memory usage limit of %s MiB"),
- filters[i].id == LZMA_FILTER_LZMA2
- ? '2' : '1',
- uint64_to_str(orig_dict_size >> 20, 0),
- uint64_to_str(opt->dict_size >> 20, 1),
- uint64_to_str(round_up_to_mib(memory_limit), 2));
-
return;
}
@@ -400,14 +359,7 @@
break;
case FORMAT_XZ:
-#ifdef HAVE_PTHREAD
- if (hardware_threads_get() > 1)
- ret = lzma_stream_encoder_mt(
- &strm, &mt_options);
- else
-#endif
- ret = lzma_stream_encoder(
- &strm, filters, check);
+ ret = lzma_stream_encoder(&strm, filters, check);
break;
case FORMAT_LZMA:
@@ -528,8 +480,8 @@
// to the .xz format. If block_remaining == UINT64_MAX, only
// a single block is created.
uint64_t block_remaining = UINT64_MAX;
- if (hardware_threads_get() == 1 && opt_mode == MODE_COMPRESS
- && opt_format == FORMAT_XZ && opt_block_size > 0)
+ if (opt_mode == MODE_COMPRESS && opt_format == FORMAT_XZ
+ && opt_block_size > 0)
block_remaining = opt_block_size;
strm.next_out = out_buf.u8;
diff --git a/src/xz/hardware.c b/src/xz/hardware.c
index 925926c..a4733c2 100644
--- a/src/xz/hardware.c
+++ b/src/xz/hardware.c
@@ -14,9 +14,9 @@
#include "tuklib_cpucores.h"
-/// Maximum number of worker threads. This can be set with
+/// Maximum number of free *coder* threads. This can be set with
/// the --threads=NUM command line option.
-static uint32_t threads_max = 1;
+static uint32_t threadlimit;
/// Memory usage limit for compression
static uint64_t memlimit_compress;
@@ -29,16 +29,15 @@
extern void
-hardware_threads_set(uint32_t n)
+hardware_threadlimit_set(uint32_t new_threadlimit)
{
- if (n == 0) {
- // Automatic number of threads was requested.
- // Use the number of available CPU cores.
- threads_max = tuklib_cpucores();
- if (threads_max == 0)
- threads_max = 1;
+ if (new_threadlimit == 0) {
+ // The default is the number of available CPU cores.
+ threadlimit = tuklib_cpucores();
+ if (threadlimit == 0)
+ threadlimit = 1;
} else {
- threads_max = n;
+ threadlimit = new_threadlimit;
}
return;
@@ -46,9 +45,9 @@
extern uint32_t
-hardware_threads_get(void)
+hardware_threadlimit_get(void)
{
- return threads_max;
+ return threadlimit;
}
@@ -140,5 +139,6 @@
// Set the defaults.
hardware_memlimit_set(0, true, true, false);
+ hardware_threadlimit_set(0);
return;
}
diff --git a/src/xz/hardware.h b/src/xz/hardware.h
index 4fae618..ad526f2 100644
--- a/src/xz/hardware.h
+++ b/src/xz/hardware.h
@@ -15,11 +15,12 @@
extern void hardware_init(void);
-/// Set the maximum number of worker threads.
-extern void hardware_threads_set(uint32_t threadlimit);
+/// Set custom value for maximum number of coder threads.
+extern void hardware_threadlimit_set(uint32_t threadlimit);
-/// Get the maximum number of worker threads.
-extern uint32_t hardware_threads_get(void);
+/// Get the maximum number of coder threads. Some additional helper threads
+/// are allowed on top of this).
+extern uint32_t hardware_threadlimit_get(void);
/// Set the memory usage limit. There are separate limits for compression
diff --git a/src/xz/private.h b/src/xz/private.h
index 978f81a..6b01e51 100644
--- a/src/xz/private.h
+++ b/src/xz/private.h
@@ -12,8 +12,6 @@
#include "sysdefs.h"
#include "mythread.h"
-
-#define LZMA_UNSTABLE
#include "lzma.h"
#include <sys/types.h>
diff --git a/src/xz/xz.1 b/src/xz/xz.1
index 4da09ba..0952f2d 100644
--- a/src/xz/xz.1
+++ b/src/xz/xz.1
@@ -907,30 +907,24 @@
.TP
\fB\-T\fR \fIthreads\fR, \fB\-\-threads=\fIthreads
Specify the number of worker threads to use.
-Setting
-.I threads
-to a special value
-.B 0
-makes
-.B xz
-use as many threads as there are CPU cores on the system.
The actual number of threads can be less than
.I threads
-if the input file is not big enough
-for threading with the given settings or
if using more threads would exceed the memory usage limit.
.IP ""
-Currently the only threading method is to split the input into
-blocks and compress them independently from each other.
-The default block size depends on the compression level and
-can be overriden with the
-.BI \-\-block\-size= size
-option.
+.B "Multithreaded compression and decompression are not"
+.B "implemented yet, so this option has no effect for now."
.IP ""
-.B "It is possible that the details of this option change before"
-.B "the next stable XZ Utils release."
-.B "This may include the meaning of the special value 0."
-.\" FIXME
+.B "As of writing (2010-09-27), it hasn't been decided"
+.B "if threads will be used by default on multicore systems"
+.B "once support for threading has been implemented."
+.B "Comments are welcome."
+The complicating factor is that using many threads
+will increase the memory usage dramatically.
+Note that if multithreading will be the default,
+it will probably be done so that single-threaded and
+multithreaded modes produce the same output,
+so compression ratio won't be significantly affected
+if threading will be enabled by default.
.
.SS "Custom compressor filter chains"
A custom filter chain allows specifying
