Merge libcompress.a into libsquashfs.a

Signed-off-by: David Oberhollenzer <david.oberhollenzer@sigma-star.at>

11 files changed, 2154 insertions, 0 deletions

diff --git a/lib/sqfs/comp/block_processor.c b/lib/sqfs/comp/block_processor.c
new file mode 100644
index 0000000..06dc384
--- /dev/null
+++ b/lib/sqfs/comp/block_processor.c
@@ -0,0 +1,72 @@
+/* SPDX-License-Identifier: GPL-3.0-or-later */
+/*
+ * block_processor.c
+ *
+ * Copyright (C) 2019 David Oberhollenzer <goliath@infraroot.at>
+ */
+#include "config.h"
+
+#include "block_processor.h"
+#include "util.h"
+
+#include <string.h>
+#include <stdlib.h>
+#include <stdio.h>
+
+struct block_processor_t {
+	size_t max_block_size;
+	compressor_t *cmp;
+	block_cb cb;
+	void *user;
+	int status;
+
+	uint8_t scratch[];
+};
+
+block_processor_t *block_processor_create(size_t max_block_size,
+					  compressor_t *cmp,
+					  unsigned int num_workers,
+					  void *user,
+					  block_cb callback)
+{
+	block_processor_t *proc = alloc_flex(sizeof(*proc), 1, max_block_size);
+	(void)num_workers;
+
+	if (proc == NULL) {
+		perror("Creating block processor");
+		return NULL;
+	}
+
+	proc->max_block_size = max_block_size;
+	proc->cmp = cmp;
+	proc->cb = callback;
+	proc->user = user;
+	return proc;
+}
+
+void block_processor_destroy(block_processor_t *proc)
+{
+	free(proc);
+}
+
+int block_processor_enqueue(block_processor_t *proc, block_t *block)
+{
+	if (process_block(block, proc->cmp,
+			  proc->scratch, proc->max_block_size))
+		goto fail;
+
+	if (proc->cb(proc->user, block))
+		goto fail;
+
+	free(block);
+	return 0;
+fail:
+	free(block);
+	proc->status = -1;
+	return -1;
+}
+
+int block_processor_finish(block_processor_t *proc)
+{
+	return proc->status;
+}
diff --git a/lib/sqfs/comp/block_processor_parallel.c b/lib/sqfs/comp/block_processor_parallel.c
new file mode 100644
index 0000000..b58ad5c
--- /dev/null
+++ b/lib/sqfs/comp/block_processor_parallel.c
@@ -0,0 +1,340 @@
+/* SPDX-License-Identifier: GPL-3.0-or-later */
+/*
+ * block_processor.c
+ *
+ * Copyright (C) 2019 David Oberhollenzer <goliath@infraroot.at>
+ */
+#include "config.h"
+
+#include "block_processor.h"
+#include "util.h"
+
+#include <pthread.h>
+#include <string.h>
+#include <stdlib.h>
+#include <stdio.h>
+
+#define MAX_BACKLOG_FACTOR (10)
+
+typedef struct {
+	block_processor_t *shared;
+	compressor_t *cmp;
+	pthread_t thread;
+	uint8_t scratch[];
+} compress_worker_t;
+
+struct block_processor_t {
+	pthread_mutex_t mtx;
+	pthread_cond_t queue_cond;
+	pthread_cond_t done_cond;
+
+	/* needs rw access by worker and main thread */
+	block_t *queue;
+	block_t *queue_last;
+
+	block_t *done;
+	bool terminate;
+	size_t backlog;
+
+	/* used by main thread only */
+	uint32_t enqueue_id;
+	uint32_t dequeue_id;
+
+	unsigned int num_workers;
+	block_cb cb;
+	void *user;
+	int status;
+
+	/* used only by workers */
+	size_t max_block_size;
+
+	compress_worker_t *workers[];
+};
+
+static void store_completed_block(block_processor_t *shared, block_t *blk)
+{
+	block_t *it = shared->done, *prev = NULL;
+
+	while (it != NULL) {
+		if (it->sequence_number >= blk->sequence_number)
+			break;
+		prev = it;
+		it = it->next;
+	}
+
+	if (prev == NULL) {
+		blk->next = shared->done;
+		shared->done = blk;
+	} else {
+		blk->next = prev->next;
+		prev->next = blk;
+	}
+}
+
+static void *worker_proc(void *arg)
+{
+	compress_worker_t *worker = arg;
+	block_processor_t *shared = worker->shared;
+	block_t *blk = NULL;
+
+	for (;;) {
+		pthread_mutex_lock(&shared->mtx);
+		if (blk != NULL) {
+			store_completed_block(shared, blk);
+			shared->backlog -= 1;
+			pthread_cond_broadcast(&shared->done_cond);
+		}
+
+		while (shared->queue == NULL && !shared->terminate) {
+			pthread_cond_wait(&shared->queue_cond,
+					  &shared->mtx);
+		}
+
+		if (shared->terminate) {
+			pthread_mutex_unlock(&shared->mtx);
+			break;
+		}
+
+		blk = shared->queue;
+		shared->queue = blk->next;
+		blk->next = NULL;
+
+		if (shared->queue == NULL)
+			shared->queue_last = NULL;
+		pthread_mutex_unlock(&shared->mtx);
+
+		if (process_block(blk, worker->cmp, worker->scratch,
+				  shared->max_block_size)) {
+			blk->flags |= BLK_COMPRESS_ERROR;
+		}
+	}
+	return NULL;
+}
+
+block_processor_t *block_processor_create(size_t max_block_size,
+					  compressor_t *cmp,
+					  unsigned int num_workers,
+					  void *user,
+					  block_cb callback)
+{
+	block_processor_t *proc;
+	unsigned int i;
+	int ret;
+
+	if (num_workers < 1)
+		num_workers = 1;
+
+	proc = alloc_flex(sizeof(*proc),
+			  sizeof(proc->workers[0]), num_workers);
+	if (proc == NULL) {
+		perror("Creating block processor");
+		return NULL;
+	}
+
+	proc->max_block_size = max_block_size;
+	proc->cb = callback;
+	proc->user = user;
+	proc->num_workers = num_workers;
+
+	if (pthread_mutex_init(&proc->mtx, NULL)) {
+		perror("Creating block processor mutex");
+		goto fail_free;
+	}
+
+	if (pthread_cond_init(&proc->queue_cond, NULL)) {
+		perror("Creating block processor conditional");
+		goto fail_mtx;
+	}
+
+	if (pthread_cond_init(&proc->done_cond, NULL)) {
+		perror("Creating block processor completion conditional");
+		goto fail_cond;
+	}
+
+	for (i = 0; i < num_workers; ++i) {
+		proc->workers[i] = alloc_flex(sizeof(compress_worker_t),
+					      1, max_block_size);
+
+		if (proc->workers[i] == NULL) {
+			perror("Creating block worker data");
+			goto fail_init;
+		}
+
+		proc->workers[i]->shared = proc;
+		proc->workers[i]->cmp = cmp->create_copy(cmp);
+
+		if (proc->workers[i]->cmp == NULL)
+			goto fail_init;
+	}
+
+	for (i = 0; i < num_workers; ++i) {
+		ret = pthread_create(&proc->workers[i]->thread, NULL,
+				     worker_proc, proc->workers[i]);
+
+		if (ret != 0) {
+			perror("Creating block processor thread");
+			goto fail_thread;
+		}
+	}
+
+	return proc;
+fail_thread:
+	pthread_mutex_lock(&proc->mtx);
+	proc->terminate = true;
+	pthread_cond_broadcast(&proc->queue_cond);
+	pthread_mutex_unlock(&proc->mtx);
+
+	for (i = 0; i < num_workers; ++i) {
+		if (proc->workers[i]->thread > 0) {
+			pthread_join(proc->workers[i]->thread, NULL);
+		}
+	}
+fail_init:
+	for (i = 0; i < num_workers; ++i) {
+		if (proc->workers[i] != NULL) {
+			if (proc->workers[i]->cmp != NULL) {
+				proc->workers[i]->cmp->
+					destroy(proc->workers[i]->cmp);
+			}
+
+			free(proc->workers[i]);
+		}
+	}
+	pthread_cond_destroy(&proc->done_cond);
+fail_cond:
+	pthread_cond_destroy(&proc->queue_cond);
+fail_mtx:
+	pthread_mutex_destroy(&proc->mtx);
+fail_free:
+	free(proc);
+	return NULL;
+}
+
+void block_processor_destroy(block_processor_t *proc)
+{
+	unsigned int i;
+	block_t *blk;
+
+	pthread_mutex_lock(&proc->mtx);
+	proc->terminate = true;
+	pthread_cond_broadcast(&proc->queue_cond);
+	pthread_mutex_unlock(&proc->mtx);
+
+	for (i = 0; i < proc->num_workers; ++i) {
+		pthread_join(proc->workers[i]->thread, NULL);
+
+		proc->workers[i]->cmp->destroy(proc->workers[i]->cmp);
+		free(proc->workers[i]);
+	}
+
+	pthread_cond_destroy(&proc->done_cond);
+	pthread_cond_destroy(&proc->queue_cond);
+	pthread_mutex_destroy(&proc->mtx);
+
+	while (proc->queue != NULL) {
+		blk = proc->queue;
+		proc->queue = blk->next;
+		free(blk);
+	}
+
+	while (proc->done != NULL) {
+		blk = proc->done;
+		proc->done = blk->next;
+		free(blk);
+	}
+
+	free(proc);
+}
+
+static int process_completed_blocks(block_processor_t *proc, block_t *queue)
+{
+	block_t *it;
+
+	while (queue != NULL) {
+		it = queue;
+		queue = queue->next;
+
+		if (it->flags & BLK_COMPRESS_ERROR) {
+			proc->status = -1;
+		} else {
+			if (proc->cb(proc->user, it))
+				proc->status = -1;
+		}
+
+		free(it);
+	}
+
+	return proc->status;
+}
+
+int block_processor_enqueue(block_processor_t *proc, block_t *block)
+{
+	block_t *queue = NULL, *it, *prev;
+
+	block->sequence_number = proc->enqueue_id++;
+	block->next = NULL;
+
+	pthread_mutex_lock(&proc->mtx);
+	if ((block->flags & BLK_DONT_COMPRESS) &&
+	    (block->flags & BLK_DONT_CHECKSUM)) {
+		store_completed_block(proc, block);
+	} else {
+		while (proc->backlog > proc->num_workers * MAX_BACKLOG_FACTOR)
+			pthread_cond_wait(&proc->done_cond, &proc->mtx);
+
+		if (proc->queue_last == NULL) {
+			proc->queue = proc->queue_last = block;
+		} else {
+			proc->queue_last->next = block;
+			proc->queue_last = block;
+		}
+
+		proc->backlog += 1;
+	}
+
+	it = proc->done;
+	prev = NULL;
+
+	while (it != NULL && it->sequence_number == proc->dequeue_id) {
+		prev = it;
+		it = it->next;
+		proc->dequeue_id += 1;
+	}
+
+	if (prev != NULL) {
+		queue = proc->done;
+		prev->next = NULL;
+		proc->done = it;
+	}
+
+	pthread_cond_broadcast(&proc->queue_cond);
+	pthread_mutex_unlock(&proc->mtx);
+
+	return process_completed_blocks(proc, queue);
+}
+
+int block_processor_finish(block_processor_t *proc)
+{
+	block_t *queue, *it;
+
+	pthread_mutex_lock(&proc->mtx);
+	while (proc->backlog > 0)
+		pthread_cond_wait(&proc->done_cond, &proc->mtx);
+
+	for (it = proc->done; it != NULL; it = it->next) {
+		if (it->sequence_number != proc->dequeue_id++) {
+			pthread_mutex_unlock(&proc->mtx);
+			goto bug_seqnum;
+		}
+	}
+
+	queue = proc->done;
+	proc->done = NULL;
+	pthread_mutex_unlock(&proc->mtx);
+
+	return process_completed_blocks(proc, queue);
+bug_seqnum:
+	fputs("[BUG][parallel block processor] "
+	      "gap in sequence numbers!\n", stderr);
+	return -1;
+}
diff --git a/lib/sqfs/comp/compressor.c b/lib/sqfs/comp/compressor.c
new file mode 100644
index 0000000..e59d948
--- /dev/null
+++ b/lib/sqfs/comp/compressor.c
@@ -0,0 +1,183 @@
+/* SPDX-License-Identifier: GPL-3.0-or-later */
+/*
+ * compressor.c
+ *
+ * Copyright (C) 2019 David Oberhollenzer <goliath@infraroot.at>
+ */
+#include "config.h"
+
+#include <string.h>
+#include <stdlib.h>
+#include <stdio.h>
+
+#include "internal.h"
+#include "util.h"
+
+typedef compressor_t *(*compressor_fun_t)(bool compress, size_t block_size,
+					  char *options);
+
+typedef void (*compressor_help_fun_t)(void);
+
+static compressor_fun_t compressors[SQFS_COMP_MAX + 1] = {
+#ifdef WITH_GZIP
+	[SQFS_COMP_GZIP] = create_gzip_compressor,
+#endif
+#ifdef WITH_XZ
+	[SQFS_COMP_XZ] = create_xz_compressor,
+#endif
+#ifdef WITH_LZO
+	[SQFS_COMP_LZO] = create_lzo_compressor,
+#endif
+#ifdef WITH_LZ4
+	[SQFS_COMP_LZ4] = create_lz4_compressor,
+#endif
+#ifdef WITH_ZSTD
+	[SQFS_COMP_ZSTD] = create_zstd_compressor,
+#endif
+};
+
+static const compressor_help_fun_t helpfuns[SQFS_COMP_MAX + 1] = {
+#ifdef WITH_GZIP
+	[SQFS_COMP_GZIP] = compressor_gzip_print_help,
+#endif
+#ifdef WITH_XZ
+	[SQFS_COMP_XZ] = compressor_xz_print_help,
+#endif
+#ifdef WITH_LZO
+	[SQFS_COMP_LZO] = compressor_lzo_print_help,
+#endif
+#ifdef WITH_LZ4
+	[SQFS_COMP_LZ4] = compressor_lz4_print_help,
+#endif
+#ifdef WITH_ZSTD
+	[SQFS_COMP_ZSTD] = compressor_zstd_print_help,
+#endif
+};
+
+static const char *names[] = {
+	[SQFS_COMP_GZIP] = "gzip",
+	[SQFS_COMP_LZMA] = "lzma",
+	[SQFS_COMP_LZO] = "lzo",
+	[SQFS_COMP_XZ] = "xz",
+	[SQFS_COMP_LZ4] = "lz4",
+	[SQFS_COMP_ZSTD] = "zstd",
+};
+
+int generic_write_options(int fd, const void *data, size_t size)
+{
+	uint8_t buffer[size + 2];
+
+	*((uint16_t *)buffer) = htole16(0x8000 | size);
+	memcpy(buffer + 2, data, size);
+
+	if (write_data("writing compressor options",
+		       fd, buffer, sizeof(buffer))) {
+		return -1;
+	}
+
+	return sizeof(buffer);
+}
+
+int generic_read_options(int fd, void *data, size_t size)
+{
+	uint8_t buffer[size + 2];
+
+	if (read_data_at("reading compressor options", sizeof(sqfs_super_t),
+			 fd, buffer, sizeof(buffer))) {
+		return -1;
+	}
+
+	if (le16toh(*((uint16_t *)buffer)) != (0x8000 | size)) {
+		fputs("reading compressor options: invalid meta data header\n",
+		      stderr);
+		return -1;
+	}
+
+	memcpy(data, buffer + 2, size);
+	return 0;
+}
+
+bool compressor_exists(E_SQFS_COMPRESSOR id)
+{
+	if (id < SQFS_COMP_MIN || id > SQFS_COMP_MAX)
+		return false;
+
+	return (compressors[id] != NULL);
+}
+
+compressor_t *compressor_create(E_SQFS_COMPRESSOR id, bool compress,
+				size_t block_size, char *options)
+{
+	if (id < SQFS_COMP_MIN || id > SQFS_COMP_MAX)
+		return NULL;
+
+	if (compressors[id] == NULL)
+		return NULL;
+
+	return compressors[id](compress, block_size, options);
+}
+
+void compressor_print_help(E_SQFS_COMPRESSOR id)
+{
+	if (id < SQFS_COMP_MIN || id > SQFS_COMP_MAX)
+		return;
+
+	if (compressors[id] == NULL)
+		return;
+
+	helpfuns[id]();
+}
+
+void compressor_print_available(void)
+{
+	size_t i;
+
+	fputs("Available compressors:\n", stdout);
+
+	for (i = 0; i < sizeof(names) / sizeof(names[0]); ++i) {
+		if (compressor_exists(i))
+			printf("\t%s\n", names[i]);
+	}
+
+	printf("\nDefault compressor: %s\n", names[compressor_get_default()]);
+}
+
+const char *compressor_name_from_id(E_SQFS_COMPRESSOR id)
+{
+	if (id < 0 || (size_t)id >= sizeof(names) / sizeof(names[0]))
+		return NULL;
+
+	return names[id];
+}
+
+int compressor_id_from_name(const char *name, E_SQFS_COMPRESSOR *out)
+{
+	size_t i;
+
+	for (i = 0; i < sizeof(names) / sizeof(names[0]); ++i) {
+		if (names[i] != NULL && strcmp(names[i], name) == 0) {
+			*out = i;
+			return 0;
+		}
+	}
+
+	return -1;
+}
+
+E_SQFS_COMPRESSOR compressor_get_default(void)
+{
+#if defined(WITH_XZ)
+	return SQFS_COMP_XZ;
+#elif defined(WITH_ZSTD)
+	return SQFS_COMP_ZSTD;
+#elif defined(WITH_GZIP)
+	return SQFS_COMP_GZIP;
+#elif defined(WITH_LZO)
+	return SQFS_COMP_LZO;
+#elif defined(WITH_LZ4)
+	return SQFS_COMP_LZ4;
+#else
+	fputs("No compressor implementation available!\n", stderr);
+	exit(EXIT_FAILURE);
+#endif
+}
diff --git a/lib/sqfs/comp/create_block.c b/lib/sqfs/comp/create_block.c
new file mode 100644
index 0000000..90344bb
--- /dev/null
+++ b/lib/sqfs/comp/create_block.c
@@ -0,0 +1,37 @@
+/* SPDX-License-Identifier: GPL-3.0-or-later */
+/*
+ * create_block.c
+ *
+ * Copyright (C) 2019 David Oberhollenzer <goliath@infraroot.at>
+ */
+#include "config.h"
+
+#include "block_processor.h"
+#include "util.h"
+
+#include <string.h>
+#include <stdlib.h>
+#include <stdio.h>
+
+block_t *create_block(const char *filename, int fd, size_t size,
+		      void *user, uint32_t flags)
+{
+	block_t *blk = alloc_flex(sizeof(*blk), 1, size);
+
+	if (blk == NULL) {
+		perror(filename);
+		return NULL;
+	}
+
+	if (fd >= 0) {
+		if (read_data(filename, fd, blk->data, size)) {
+			free(blk);
+			return NULL;
+		}
+	}
+
+	blk->size = size;
+	blk->user = user;
+	blk->flags = flags;
+	return blk;
+}
diff --git a/lib/sqfs/comp/gzip.c b/lib/sqfs/comp/gzip.c
new file mode 100644
index 0000000..1fdc051
--- /dev/null
+++ b/lib/sqfs/comp/gzip.c
@@ -0,0 +1,412 @@
+/* SPDX-License-Identifier: GPL-3.0-or-later */
+/*
+ * gzip.c
+ *
+ * Copyright (C) 2019 David Oberhollenzer <goliath@infraroot.at>
+ */
+#include "config.h"
+
+#include <stdbool.h>
+#include <stdlib.h>
+#include <string.h>
+#include <stdio.h>
+#include <ctype.h>
+#include <zlib.h>
+
+#include "internal.h"
+
+#define GZIP_DEFAULT_LEVEL 9
+#define GZIP_DEFAULT_WINDOW 15
+#define GZIP_NUM_STRATEGIES (sizeof(strategies) / sizeof(strategies[0]))
+
+typedef enum {
+	GZIP_STRATEGY_DEFAULT = 0x01,
+	GZIP_STRATEGY_FILTERED = 0x02,
+	GZIP_STRATEGY_HUFFMAN = 0x04,
+	GZIP_STARTEGY_RLE = 0x08,
+	GZIP_STRATEGY_FIXED = 0x10,
+
+	GZIP_ALL_STRATEGIES = 0x1F,
+} GZIP_STRATEGIES;
+
+static const struct {
+	const char *name;
+	int flag;
+	int zlib;
+} strategies[] = {
+	{ "default", GZIP_STRATEGY_DEFAULT, Z_DEFAULT_STRATEGY },
+	{ "filtered", GZIP_STRATEGY_FILTERED, Z_FILTERED },
+	{ "huffman", GZIP_STRATEGY_HUFFMAN, Z_HUFFMAN_ONLY },
+	{ "rle", GZIP_STARTEGY_RLE, Z_RLE },
+	{ "fixed", GZIP_STRATEGY_FIXED, Z_FIXED },
+};
+
+typedef struct {
+	uint32_t level;
+	uint16_t window;
+	uint16_t strategies;
+} gzip_options_t;
+
+typedef struct {
+	compressor_t base;
+
+	z_stream strm;
+	bool compress;
+
+	size_t block_size;
+	gzip_options_t opt;
+} gzip_compressor_t;
+
+static void gzip_destroy(compressor_t *base)
+{
+	gzip_compressor_t *gzip = (gzip_compressor_t *)base;
+
+	if (gzip->compress) {
+		deflateEnd(&gzip->strm);
+	} else {
+		inflateEnd(&gzip->strm);
+	}
+
+	free(gzip);
+}
+
+static int gzip_write_options(compressor_t *base, int fd)
+{
+	gzip_compressor_t *gzip = (gzip_compressor_t *)base;
+	gzip_options_t opt;
+
+	if (gzip->opt.level == GZIP_DEFAULT_LEVEL &&
+	    gzip->opt.window == GZIP_DEFAULT_WINDOW &&
+	    gzip->opt.strategies == 0) {
+		return 0;
+	}
+
+	opt.level = htole32(gzip->opt.level);
+	opt.window = htole16(gzip->opt.window);
+	opt.strategies = htole16(gzip->opt.strategies);
+
+	return generic_write_options(fd, &opt, sizeof(opt));
+}
+
+static int gzip_read_options(compressor_t *base, int fd)
+{
+	gzip_compressor_t *gzip = (gzip_compressor_t *)base;
+	gzip_options_t opt;
+
+	if (generic_read_options(fd, &opt, sizeof(opt)))
+		return -1;
+
+	gzip->opt.level = le32toh(opt.level);
+	gzip->opt.window = le16toh(opt.window);
+	gzip->opt.strategies = le16toh(opt.strategies);
+
+	if (gzip->opt.level < 1 || gzip->opt.level > 9) {
+		fprintf(stderr, "Invalid gzip compression level '%d'.\n",
+			gzip->opt.level);
+		return -1;
+	}
+
+	if (gzip->opt.window < 8 || gzip->opt.window > 15) {
+		fprintf(stderr, "Invalid gzip window size '%d'.\n",
+			gzip->opt.window);
+		return -1;
+	}
+
+	if (gzip->opt.strategies & ~GZIP_ALL_STRATEGIES) {
+		fputs("Unknown gzip strategies selected.\n", stderr);
+		return -1;
+	}
+
+	return 0;
+}
+
+static int find_strategy(gzip_compressor_t *gzip, const uint8_t *in,
+			 size_t size, uint8_t *out, size_t outsize)
+{
+	int ret, selected = Z_DEFAULT_STRATEGY;
+	size_t i, length, minlength = 0;
+
+	for (i = 0; i < GZIP_NUM_STRATEGIES; ++i) {
+		if (!(strategies[i].flag & gzip->opt.strategies))
+			continue;
+
+		ret = deflateReset(&gzip->strm);
+		if (ret != Z_OK) {
+			fputs("resetting zlib stream failed\n",
+			      stderr);
+			return -1;
+		}
+
+		gzip->strm.next_in = (void *)in;
+		gzip->strm.avail_in = size;
+		gzip->strm.next_out = out;
+		gzip->strm.avail_out = outsize;
+
+		ret = deflateParams(&gzip->strm, gzip->opt.level,
+				    strategies[i].zlib);
+		if (ret != Z_OK) {
+			fputs("setting deflate parameters failed\n",
+			      stderr);
+			return -1;
+		}
+
+		ret = deflate(&gzip->strm, Z_FINISH);
+
+		if (ret == Z_STREAM_END) {
+			length = gzip->strm.total_out;
+
+			if (minlength == 0 || length < minlength) {
+				minlength = length;
+				selected = strategies[i].zlib;
+			}
+		} else if (ret != Z_OK && ret != Z_BUF_ERROR) {
+			fputs("gzip block processing failed\n", stderr);
+			return -1;
+		}
+	}
+
+	return selected;
+}
+
+static ssize_t gzip_do_block(compressor_t *base, const uint8_t *in,
+			     size_t size, uint8_t *out, size_t outsize)
+{
+	gzip_compressor_t *gzip = (gzip_compressor_t *)base;
+	int ret, strategy = 0;
+	size_t written;
+
+	if (gzip->compress && gzip->opt.strategies != 0) {
+		strategy = find_strategy(gzip, in, size, out, outsize);
+		if (strategy < 0)
+			return -1;
+	}
+
+	if (gzip->compress) {
+		ret = deflateReset(&gzip->strm);
+	} else {
+		ret = inflateReset(&gzip->strm);
+	}
+
+	if (ret != Z_OK) {
+		fputs("resetting zlib stream failed\n", stderr);
+		return -1;
+	}
+
+	gzip->strm.next_in = (void *)in;
+	gzip->strm.avail_in = size;
+	gzip->strm.next_out = out;
+	gzip->strm.avail_out = outsize;
+
+	if (gzip->compress && gzip->opt.strategies != 0) {
+		ret = deflateParams(&gzip->strm, gzip->opt.level, strategy);
+		if (ret != Z_OK) {
+			fputs("setting selcted deflate parameters failed\n",
+			      stderr);
+			return -1;
+		}
+	}
+
+	if (gzip->compress) {
+		ret = deflate(&gzip->strm, Z_FINISH);
+	} else {
+		ret = inflate(&gzip->strm, Z_FINISH);
+	}
+
+	if (ret == Z_STREAM_END) {
+		written = gzip->strm.total_out;
+
+		if (gzip->compress && written >= size)
+			return 0;
+
+		return (ssize_t)written;
+	}
+
+	if (ret != Z_OK && ret != Z_BUF_ERROR) {
+		fputs("gzip block processing failed\n", stderr);
+		return -1;
+	}
+
+	return 0;
+}
+
+static int process_options(char *options, int *level, int *window, int *flags)
+{
+	enum {
+		OPT_WINDOW = 0,
+		OPT_LEVEL,
+	};
+	char *const token[] = {
+		[OPT_WINDOW] = (char *)"window",
+		[OPT_LEVEL] = (char *)"level",
+		NULL
+	};
+	char *subopts, *value;
+	size_t i;
+	int opt;
+
+	subopts = options;
+
+	while (*subopts != '\0') {
+		opt = getsubopt(&subopts, token, &value);
+
+		switch (opt) {
+		case OPT_WINDOW:
+			if (value == NULL)
+				goto fail_value;
+
+			for (i = 0; isdigit(value[i]); ++i)
+				;
+
+			if (i < 1 || i > 3 || value[i] != '\0')
+				goto fail_window;
+
+			*window = atoi(value);
+
+			if (*window < 8 || *window > 15)
+				goto fail_window;
+			break;
+		case OPT_LEVEL:
+			if (value == NULL)
+				goto fail_value;
+
+			for (i = 0; isdigit(value[i]); ++i)
+				;
+
+			if (i < 1 || i > 3 || value[i] != '\0')
+				goto fail_level;
+
+			*level = atoi(value);
+
+			if (*level < 1 || *level > 9)
+				goto fail_level;
+			break;
+		default:
+			for (i = 0; i < GZIP_NUM_STRATEGIES; ++i) {
+				if (strcmp(value, strategies[i].name) == 0) {
+					*flags |= strategies[i].flag;
+					break;
+				}
+			}
+			if (i == GZIP_NUM_STRATEGIES)
+				goto fail_opt;
+			break;
+		}
+	}
+
+	return 0;
+fail_window:
+	fputs("Window size must be a number between 8 and 15.\n", stderr);
+	return -1;
+fail_level:
+	fputs("Compression level must be a number between 1 and 9.\n", stderr);
+	return -1;
+fail_opt:
+	fprintf(stderr, "Unknown option '%s'.\n", value);
+	return -1;
+fail_value:
+	fprintf(stderr, "Missing value for '%s'.\n", token[opt]);
+	return -1;
+}
+
+static compressor_t *gzip_create_copy(compressor_t *cmp)
+{
+	gzip_compressor_t *gzip = malloc(sizeof(*gzip));
+	int ret;
+
+	if (gzip == NULL) {
+		perror("creating additional gzip compressor");
+		return NULL;
+	}
+
+	memcpy(gzip, cmp, sizeof(*gzip));
+	memset(&gzip->strm, 0, sizeof(gzip->strm));
+
+	if (gzip->compress) {
+		ret = deflateInit2(&gzip->strm, gzip->opt.level, Z_DEFLATED,
+				   gzip->opt.window, 8, Z_DEFAULT_STRATEGY);
+	} else {
+		ret = inflateInit(&gzip->strm);
+	}
+
+	if (ret != Z_OK) {
+		fputs("internal error creating additional zlib stream\n",
+		      stderr);
+		free(gzip);
+		return NULL;
+	}
+
+	return (compressor_t *)gzip;
+}
+
+compressor_t *create_gzip_compressor(bool compress, size_t block_size,
+				     char *options)
+{
+	int window = GZIP_DEFAULT_WINDOW;
+	int level = GZIP_DEFAULT_LEVEL;
+	gzip_compressor_t *gzip;
+	compressor_t *base;
+	int flags = 0;
+	int ret;
+
+	if (options != NULL) {
+		if (process_options(options, &level, &window, &flags))
+			return NULL;
+	}
+
+	gzip = calloc(1, sizeof(*gzip));
+	base = (compressor_t *)gzip;
+
+	if (gzip == NULL) {
+		perror("creating gzip compressor");
+		return NULL;
+	}
+
+	gzip->opt.level = level;
+	gzip->opt.window = window;
+	gzip->opt.strategies = flags;
+	gzip->compress = compress;
+	gzip->block_size = block_size;
+	base->do_block = gzip_do_block;
+	base->destroy = gzip_destroy;
+	base->write_options = gzip_write_options;
+	base->read_options = gzip_read_options;
+	base->create_copy = gzip_create_copy;
+
+	if (compress) {
+		ret = deflateInit2(&gzip->strm, level, Z_DEFLATED, window, 8,
+				   Z_DEFAULT_STRATEGY);
+	} else {
+		ret = inflateInit(&gzip->strm);
+	}
+
+	if (ret != Z_OK) {
+		fputs("internal error creating zlib stream\n", stderr);
+		free(gzip);
+		return NULL;
+	}
+
+	return base;
+}
+
+void compressor_gzip_print_help(void)
+{
+	size_t i;
+
+	printf(
+"Available options for gzip compressor:\n"
+"\n"
+"    level=<value>    Compression level. Value from 1 to 9.\n"
+"                     Defaults to %d.\n"
+"    window=<size>    Deflate compression window size. Value from 8 to 15.\n"
+"                     Defaults to %d.\n"
+"\n"
+"In additon to the options, one or more strategies can be specified.\n"
+"If multiple stratgies are provided, the one yielding the best compression\n"
+"ratio will be used.\n"
+"\n"
+"The following strategies are available:\n",
+	GZIP_DEFAULT_LEVEL, GZIP_DEFAULT_WINDOW);
+
+	for (i = 0; i < GZIP_NUM_STRATEGIES; ++i)
+		printf("\t%s\n", strategies[i].name);
+}
diff --git a/lib/sqfs/comp/internal.h b/lib/sqfs/comp/internal.h
new file mode 100644
index 0000000..986266d
--- /dev/null
+++ b/lib/sqfs/comp/internal.h
@@ -0,0 +1,44 @@
+/* SPDX-License-Identifier: GPL-3.0-or-later */
+/*
+ * internal.h
+ *
+ * Copyright (C) 2019 David Oberhollenzer <goliath@infraroot.at>
+ */
+#ifndef INTERNAL_H
+#define INTERNAL_H
+
+#include "config.h"
+
+#include "compress.h"
+#include "util.h"
+
+int generic_write_options(int fd, const void *data, size_t size);
+
+int generic_read_options(int fd, void *data, size_t size);
+
+compressor_t *create_xz_compressor(bool compress, size_t block_size,
+				   char *options);
+
+compressor_t *create_gzip_compressor(bool compress, size_t block_size,
+				     char *options);
+
+compressor_t *create_lzo_compressor(bool compress, size_t block_size,
+				    char *options);
+
+compressor_t *create_lz4_compressor(bool compress, size_t block_size,
+				    char *options);
+
+compressor_t *create_zstd_compressor(bool compress, size_t block_size,
+				     char *options);
+
+void compressor_xz_print_help(void);
+
+void compressor_gzip_print_help(void);
+
+void compressor_lzo_print_help(void);
+
+void compressor_lz4_print_help(void);
+
+void compressor_zstd_print_help(void);
+
+#endif /* INTERNAL_H */
diff --git a/lib/sqfs/comp/lz4.c b/lib/sqfs/comp/lz4.c
new file mode 100644
index 0000000..abb6c5c
--- /dev/null
+++ b/lib/sqfs/comp/lz4.c
@@ -0,0 +1,159 @@
+/* SPDX-License-Identifier: GPL-3.0-or-later */
+/*
+ * lz4.c
+ *
+ * Copyright (C) 2019 David Oberhollenzer <goliath@infraroot.at>
+ */
+#include "config.h"
+
+#include <stdbool.h>
+#include <stdlib.h>
+#include <string.h>
+#include <stdio.h>
+
+#include <lz4.h>
+#include <lz4hc.h>
+
+#include "internal.h"
+
+typedef struct {
+	compressor_t base;
+	bool high_compression;
+} lz4_compressor_t;
+
+typedef struct {
+	uint32_t version;
+	uint32_t flags;
+} lz4_options;
+
+#define LZ4LEGACY 1
+#define LZ4_FLAG_HC 0x01
+
+static int lz4_write_options(compressor_t *base, int fd)
+{
+	lz4_compressor_t *lz4 = (lz4_compressor_t *)base;
+	lz4_options opt = {
+		.version = htole32(LZ4LEGACY),
+		.flags = htole32(lz4->high_compression ? LZ4_FLAG_HC : 0),
+	};
+
+	return generic_write_options(fd, &opt, sizeof(opt));
+}
+
+static int lz4_read_options(compressor_t *base, int fd)
+{
+	lz4_options opt;
+	(void)base;
+
+	if (generic_read_options(fd, &opt, sizeof(opt)))
+		return -1;
+
+	opt.version = le32toh(opt.version);
+	opt.flags = le32toh(opt.flags);
+
+	if (opt.version != LZ4LEGACY) {
+		fprintf(stderr, "unsupported lz4 version '%d'\n", opt.version);
+		return -1;
+	}
+
+	return 0;
+}
+
+static ssize_t lz4_comp_block(compressor_t *base, const uint8_t *in,
+			      size_t size, uint8_t *out, size_t outsize)
+{
+	lz4_compressor_t *lz4 = (lz4_compressor_t *)base;
+	int ret;
+
+	if (lz4->high_compression) {
+		ret = LZ4_compress_HC((void *)in, (void *)out,
+				      size, outsize, LZ4HC_CLEVEL_MAX);
+	} else {
+		ret = LZ4_compress_default((void *)in, (void *)out,
+					   size, outsize);
+	}
+
+	if (ret < 0) {
+		fputs("internal error in lz4 compressor\n", stderr);
+		return -1;
+	}
+
+	return ret;
+}
+
+static ssize_t lz4_uncomp_block(compressor_t *base, const uint8_t *in,
+				size_t size, uint8_t *out, size_t outsize)
+{
+	int ret;
+	(void)base;
+
+	ret = LZ4_decompress_safe((void *)in, (void *)out, size, outsize);
+
+	if (ret < 0) {
+		fputs("internal error in lz4 decompressor\n", stderr);
+		return -1;
+	}
+
+	return ret;
+}
+
+static compressor_t *lz4_create_copy(compressor_t *cmp)
+{
+	lz4_compressor_t *lz4 = malloc(sizeof(*lz4));
+
+	if (lz4 == NULL) {
+		perror("creating additional lz4 compressor");
+		return NULL;
+	}
+
+	memcpy(lz4, cmp, sizeof(*lz4));
+	return (compressor_t *)lz4;
+}
+
+static void lz4_destroy(compressor_t *base)
+{
+	free(base);
+}
+
+compressor_t *create_lz4_compressor(bool compress, size_t block_size,
+				    char *options)
+{
+	lz4_compressor_t *lz4 = calloc(1, sizeof(*lz4));
+	compressor_t *base = (compressor_t *)lz4;
+	(void)block_size;
+
+	if (lz4 == NULL) {
+		perror("creating lz4 compressor");
+		return NULL;
+	}
+
+	lz4->high_compression = false;
+
+	if (options != NULL) {
+		if (strcmp(options, "hc") == 0) {
+			lz4->high_compression = true;
+		} else {
+			fputs("Unsupported extra options for lz4 "
+			      "compressor.\n", stderr);
+			free(lz4);
+			return NULL;
+		}
+	}
+
+	base->destroy = lz4_destroy;
+	base->do_block = compress ? lz4_comp_block : lz4_uncomp_block;
+	base->write_options = lz4_write_options;
+	base->read_options = lz4_read_options;
+	base->create_copy = lz4_create_copy;
+	return base;
+}
+
+void compressor_lz4_print_help(void)
+{
+	fputs("Available options for lz4 compressor:\n"
+	      "\n"
+	      "    hc    If present, use slower but better compressing\n"
+	      "          variant of lz4.\n"
+	      "\n",
+	      stdout);
+}
diff --git a/lib/sqfs/comp/lzo.c b/lib/sqfs/comp/lzo.c
new file mode 100644
index 0000000..09ef75c
--- /dev/null
+++ b/lib/sqfs/comp/lzo.c
@@ -0,0 +1,321 @@
+/* SPDX-License-Identifier: GPL-3.0-or-later */
+/*
+ * lzo.c
+ *
+ * Copyright (C) 2019 David Oberhollenzer <goliath@infraroot.at>
+ */
+#include "config.h"
+
+#include <stdbool.h>
+#include <stdlib.h>
+#include <string.h>
+#include <stdio.h>
+#include <ctype.h>
+
+#include <lzo/lzo1x.h>
+
+#include "internal.h"
+
+
+typedef enum {
+	LZO_ALGORITHM_LZO1X_1 = 0,
+	LZO_ALGORITHM_LZO1X_1_11 = 1,
+	LZO_ALGORITHM_LZO1X_1_12 = 2,
+	LZO_ALGORITHM_LZO1X_1_15 = 3,
+	LZO_ALGORITHM_LZO1X_999	= 4,
+} LZO_ALGORITHM;
+
+#define LZO_DEFAULT_ALG LZO_ALGORITHM_LZO1X_999
+#define LZO_DEFAULT_LEVEL 8
+#define LZO_NUM_ALGS (sizeof(lzo_algs) / sizeof(lzo_algs[0]))
+
+typedef int (*lzo_cb_t)(const lzo_bytep src, lzo_uint src_len, lzo_bytep dst,
+			lzo_uintp dst_len, lzo_voidp wrkmem);
+
+static const struct {
+	const char *name;
+	lzo_cb_t compress;
+	size_t bufsize;
+} lzo_algs[] = {
+	[LZO_ALGORITHM_LZO1X_1] = {
+		.name = "lzo1x_1",
+		.compress = lzo1x_1_compress,
+		.bufsize = LZO1X_1_MEM_COMPRESS,
+	},
+	[LZO_ALGORITHM_LZO1X_1_11] = {
+		.name = "lzo1x_1_11",
+		.compress = lzo1x_1_11_compress,
+		.bufsize = LZO1X_1_11_MEM_COMPRESS,
+	},
+	[LZO_ALGORITHM_LZO1X_1_12] = {
+		.name = "lzo1x_1_12",
+		.compress = lzo1x_1_12_compress,
+		.bufsize = LZO1X_1_12_MEM_COMPRESS,
+	},
+	[LZO_ALGORITHM_LZO1X_1_15] = {
+		.name = "lzo1x_1_15",
+		.compress = lzo1x_1_15_compress,
+		.bufsize = LZO1X_1_15_MEM_COMPRESS,
+	},
+	[LZO_ALGORITHM_LZO1X_999] = {
+		.name = "lzo1x_999",
+		.compress = lzo1x_999_compress,
+		.bufsize = LZO1X_999_MEM_COMPRESS,
+	},
+};
+
+typedef struct {
+	compressor_t base;
+	int algorithm;
+	int level;
+
+	uint8_t buffer[];
+} lzo_compressor_t;
+
+typedef struct {
+	uint32_t algorithm;
+	uint32_t level;
+} lzo_options_t;
+
+static int lzo_write_options(compressor_t *base, int fd)
+{
+	lzo_compressor_t *lzo = (lzo_compressor_t *)base;
+	lzo_options_t opt;
+
+	if (lzo->algorithm == LZO_DEFAULT_ALG &&
+	    lzo->level == LZO_DEFAULT_LEVEL) {
+		return 0;
+	}
+
+	opt.algorithm = htole32(lzo->algorithm);
+
+	if (lzo->algorithm == LZO_ALGORITHM_LZO1X_999) {
+		opt.level = htole32(lzo->level);
+	} else {
+		opt.level = 0;
+	}
+
+	return generic_write_options(fd, &opt, sizeof(opt));
+}
+
+static int lzo_read_options(compressor_t *base, int fd)
+{
+	lzo_compressor_t *lzo = (lzo_compressor_t *)base;
+	lzo_options_t opt;
+
+	if (generic_read_options(fd, &opt, sizeof(opt)))
+		return -1;
+
+	lzo->algorithm = le32toh(opt.algorithm);
+	lzo->level = le32toh(opt.level);
+
+	switch(lzo->algorithm) {
+	case LZO_ALGORITHM_LZO1X_1:
+	case LZO_ALGORITHM_LZO1X_1_11:
+	case LZO_ALGORITHM_LZO1X_1_12:
+	case LZO_ALGORITHM_LZO1X_1_15:
+		if (lzo->level != 0)
+			goto fail_level;
+		break;
+	case LZO_ALGORITHM_LZO1X_999:
+		if (lzo->level < 1 || lzo->level > 9)
+			goto fail_level;
+		break;
+	default:
+		fputs("Unsupported LZO variant specified.\n", stderr);
+		return -1;
+	}
+
+	return 0;
+fail_level:
+	fputs("Unsupported LZO compression level specified.\n", stderr);
+	return -1;
+}
+
+static ssize_t lzo_comp_block(compressor_t *base, const uint8_t *in,
+			      size_t size, uint8_t *out, size_t outsize)
+{
+	lzo_compressor_t *lzo = (lzo_compressor_t *)base;
+	lzo_uint len = outsize;
+	int ret;
+
+	if (lzo->algorithm == LZO_ALGORITHM_LZO1X_999 &&
+	    lzo->level != LZO_DEFAULT_LEVEL) {
+		ret = lzo1x_999_compress_level(in, size, out, &len,
+					       lzo->buffer, NULL, 0, 0,
+					       lzo->level);
+	} else {
+		ret = lzo_algs[lzo->algorithm].compress(in, size, out,
+							&len, lzo->buffer);
+	}
+
+	if (ret != LZO_E_OK) {
+		fputs("LZO compression failed.\n", stderr);
+		return -1;
+	}
+
+	if (len < size)
+		return len;
+
+	return 0;
+}
+
+static ssize_t lzo_uncomp_block(compressor_t *base, const uint8_t *in,
+				size_t size, uint8_t *out, size_t outsize)
+{
+	lzo_compressor_t *lzo = (lzo_compressor_t *)base;
+	lzo_uint len = outsize;
+	int ret;
+
+	ret = lzo1x_decompress_safe(in, size, out, &len, lzo->buffer);
+
+	if (ret != LZO_E_OK) {
+		fputs("lzo decompress: input data is corrupted\n", stderr);
+		return -1;
+	}
+
+	return len;
+}
+
+static compressor_t *lzo_create_copy(compressor_t *cmp)
+{
+	lzo_compressor_t *other = (lzo_compressor_t *)cmp;
+	lzo_compressor_t *lzo;
+
+	lzo = alloc_flex(sizeof(*lzo), 1, lzo_algs[other->algorithm].bufsize);
+
+	if (lzo == NULL) {
+		perror("creating additional lzo compressor");
+		return NULL;
+	}
+
+	memcpy(lzo, other, sizeof(*lzo));
+	return (compressor_t *)lzo;
+}
+
+static void lzo_destroy(compressor_t *base)
+{
+	free(base);
+}
+
+static int process_options(char *options, int *algorithm, int *level)
+{
+	enum {
+		OPT_ALG = 0,
+		OPT_LEVEL,
+	};
+	char *const token[] = {
+		[OPT_ALG] = (char *)"algorithm",
+		[OPT_LEVEL] = (char *)"level",
+		NULL
+	};
+	char *subopts, *value;
+	size_t i;
+	int opt;
+
+	subopts = options;
+
+	while (*subopts != '\0') {
+		opt = getsubopt(&subopts, token, &value);
+
+		switch (opt) {
+		case OPT_ALG:
+			if (value == NULL)
+				goto fail_value;
+
+			for (i = 0; i < LZO_NUM_ALGS; ++i) {
+				if (strcmp(lzo_algs[i].name, value) == 0) {
+					*algorithm = i;
+					break;
+				}
+			}
+
+			if (i == LZO_NUM_ALGS) {
+				fprintf(stderr, "Unknown lzo variant '%s'.\n",
+					value);
+				return -1;
+			}
+			break;
+		case OPT_LEVEL:
+			if (value == NULL)
+				goto fail_value;
+
+			for (i = 0; isdigit(value[i]); ++i)
+				;
+
+			if (i < 1 || i > 3 || value[i] != '\0')
+				goto fail_level;
+
+			*level = atoi(value);
+
+			if (*level < 1 || *level > 9)
+				goto fail_level;
+			break;
+		default:
+			goto fail_opt;
+		}
+	}
+
+	return 0;
+fail_level:
+	fputs("Compression level must be a number between 1 and 9.\n", stderr);
+	return -1;
+fail_opt:
+	fprintf(stderr, "Unknown option '%s'.\n", value);
+	return -1;
+fail_value:
+	fprintf(stderr, "Missing value for '%s'.\n", token[opt]);
+	return -1;
+}
+
+compressor_t *create_lzo_compressor(bool compress, size_t block_size,
+				    char *options)
+{
+	lzo_compressor_t *lzo;
+	compressor_t *base;
+	int level, alg;
+	(void)block_size;
+
+	alg = LZO_DEFAULT_ALG;
+	level = LZO_DEFAULT_LEVEL;
+
+	if (options != NULL && process_options(options, &alg, &level) != 0)
+		return NULL;
+
+	lzo = alloc_flex(sizeof(*lzo), 1, lzo_algs[alg].bufsize);
+	base = (compressor_t *)lzo;
+
+	if (lzo == NULL) {
+		perror("creating lzo compressor");
+		return NULL;
+	}
+
+	lzo->algorithm = alg;
+	lzo->level = level;
+
+	base->destroy = lzo_destroy;
+	base->do_block = compress ? lzo_comp_block : lzo_uncomp_block;
+	base->write_options = lzo_write_options;
+	base->read_options = lzo_read_options;
+	base->create_copy = lzo_create_copy;
+	return base;
+}
+
+void compressor_lzo_print_help(void)
+{
+	size_t i;
+
+	fputs("Available options for lzo compressor:\n"
+	      "\n"
+	      "    algorithm=<name>  Specify the variant of lzo to use.\n"
+	      "                      Defaults to 'lzo1x_999'.\n"
+	      "    level=<value>     For lzo1x_999, the compression level.\n"
+	      "                      Value from 1 to 9. Defaults to 8.\n"
+	      "                      Ignored if algorithm is not lzo1x_999.\n"
+	      "\n"
+	      "Available algorithms:\n",
+	      stdout);
+
+	for (i = 0; i < LZO_NUM_ALGS; ++i)
+		printf("\t%s\n", lzo_algs[i].name);
+}
diff --git a/lib/sqfs/comp/process_block.c b/lib/sqfs/comp/process_block.c
new file mode 100644
index 0000000..0fcbae0
--- /dev/null
+++ b/lib/sqfs/comp/process_block.c
@@ -0,0 +1,38 @@
+/* SPDX-License-Identifier: GPL-3.0-or-later */
+/*
+ * process_block.c
+ *
+ * Copyright (C) 2019 David Oberhollenzer <goliath@infraroot.at>
+ */
+#include "config.h"
+
+#include "block_processor.h"
+#include "util.h"
+
+#include <string.h>
+#include <zlib.h>
+
+int process_block(block_t *block, compressor_t *cmp,
+		  uint8_t *scratch, size_t scratch_size)
+{
+	ssize_t ret;
+
+	if (!(block->flags & BLK_DONT_CHECKSUM))
+		block->checksum = crc32(0, block->data, block->size);
+
+	if (!(block->flags & BLK_DONT_COMPRESS)) {
+		ret = cmp->do_block(cmp, block->data, block->size,
+				    scratch, scratch_size);
+
+		if (ret < 0)
+			return -1;
+
+		if (ret > 0) {
+			memcpy(block->data, scratch, ret);
+			block->size = ret;
+			block->flags |= BLK_IS_COMPRESSED;
+		}
+	}
+
+	return 0;
+}
diff --git a/lib/sqfs/comp/xz.c b/lib/sqfs/comp/xz.c
new file mode 100644
index 0000000..d38aab6
--- /dev/null
+++ b/lib/sqfs/comp/xz.c
@@ -0,0 +1,360 @@
+/* SPDX-License-Identifier: GPL-3.0-or-later */
+/*
+ * xz.c
+ *
+ * Copyright (C) 2019 David Oberhollenzer <goliath@infraroot.at>
+ */
+#include "config.h"
+
+#include <stdbool.h>
+#include <stdlib.h>
+#include <string.h>
+#include <stdio.h>
+#include <ctype.h>
+#include <lzma.h>
+
+#include "internal.h"
+
+typedef enum {
+	XZ_FILTER_X86 = 0x01,
+	XZ_FILTER_POWERPC = 0x02,
+	XZ_FILTER_IA64 = 0x04,
+	XZ_FILTER_ARM = 0x08,
+	XZ_FILTER_ARMTHUMB = 0x10,
+	XZ_FILTER_SPARC = 0x20,
+
+	XZ_FILTER_ALL = 0x3F,
+} XZ_FILTER_FLAG;
+
+typedef struct {
+	compressor_t base;
+	size_t block_size;
+	size_t dict_size;
+	int flags;
+} xz_compressor_t;
+
+typedef struct {
+	uint32_t dict_size;
+	uint32_t flags;
+} xz_options_t;
+
+static const struct {
+	const char *name;
+	lzma_vli filter;
+	int flag;
+} xz_filters[] = {
+	{ "x86", LZMA_FILTER_X86, XZ_FILTER_X86 },
+	{ "powerpc", LZMA_FILTER_POWERPC, XZ_FILTER_POWERPC },
+	{ "ia64", LZMA_FILTER_IA64, XZ_FILTER_IA64 },
+	{ "arm", LZMA_FILTER_ARM, XZ_FILTER_ARM },
+	{ "armthumb", LZMA_FILTER_ARMTHUMB, XZ_FILTER_ARMTHUMB },
+	{ "sparc", LZMA_FILTER_SPARC, XZ_FILTER_SPARC },
+};
+
+#define XZ_NUM_FILTERS (sizeof(xz_filters) / sizeof(xz_filters[0]))
+
+static int xz_write_options(compressor_t *base, int fd)
+{
+	xz_compressor_t *xz = (xz_compressor_t *)base;
+	xz_options_t opt;
+
+	if (xz->flags == 0 && xz->dict_size == xz->block_size)
+		return 0;
+
+	opt.dict_size = htole32(xz->dict_size);
+	opt.flags = htole32(xz->flags);
+
+	return generic_write_options(fd, &opt, sizeof(opt));
+}
+
+static int xz_read_options(compressor_t *base, int fd)
+{
+	xz_compressor_t *xz = (xz_compressor_t *)base;
+	xz_options_t opt;
+	uint32_t mask;
+
+	if (generic_read_options(fd, &opt, sizeof(opt)))
+		return -1;
+
+	opt.dict_size = le32toh(opt.dict_size);
+	opt.flags = le32toh(opt.flags);
+
+	mask = opt.dict_size & (opt.dict_size - 1);
+
+	if (mask != 0 && ((mask & (mask - 1)) != 0)) {
+		fputs("Invalid lzma dictionary size.\n", stderr);
+		return -1;
+	}
+
+	if (opt.flags & ~XZ_FILTER_ALL) {
+		fputs("Unknown BCJ filter used.\n", stderr);
+		return -1;
+	}
+
+	xz->flags = opt.flags;
+	xz->dict_size = opt.dict_size;
+	return 0;
+}
+
+static ssize_t compress(xz_compressor_t *xz, lzma_vli filter,
+			const uint8_t *in, size_t size,
+			uint8_t *out, size_t outsize)
+{
+	lzma_filter filters[5];
+	lzma_options_lzma opt;
+	size_t written = 0;
+	lzma_ret ret;
+	int i = 0;
+
+	if (lzma_lzma_preset(&opt, LZMA_PRESET_DEFAULT)) {
+		fputs("error initializing xz options\n", stderr);
+		return -1;
+	}
+
+	opt.dict_size = xz->dict_size;
+
+	if (filter != LZMA_VLI_UNKNOWN) {
+		filters[i].id = filter;
+		filters[i].options = NULL;
+		++i;
+	}
+
+	filters[i].id = LZMA_FILTER_LZMA2;
+	filters[i].options = &opt;
+	++i;
+
+	filters[i].id = LZMA_VLI_UNKNOWN;
+	filters[i].options = NULL;
+	++i;
+
+	ret = lzma_stream_buffer_encode(filters, LZMA_CHECK_CRC32, NULL,
+					in, size, out, &written, outsize);
+
+	if (ret == LZMA_OK)
+		return (written >= size) ? 0 : written;
+
+	if (ret != LZMA_BUF_ERROR) {
+		fputs("xz block compress failed\n", stderr);
+		return -1;
+	}
+
+	return 0;
+}
+
+static ssize_t xz_comp_block(compressor_t *base, const uint8_t *in,
+			       size_t size, uint8_t *out, size_t outsize)
+{
+	xz_compressor_t *xz = (xz_compressor_t *)base;
+	lzma_vli selected = LZMA_VLI_UNKNOWN;
+	size_t i, smallest;
+	ssize_t ret;
+
+	ret = compress(xz, LZMA_VLI_UNKNOWN, in, size, out, outsize);
+	if (ret < 0 || xz->flags == 0)
+		return ret;
+
+	smallest = ret;
+
+	for (i = 0; i < XZ_NUM_FILTERS; ++i) {
+		if (!(xz->flags & xz_filters[i].flag))
+			continue;
+
+		ret = compress(xz, xz_filters[i].filter, in, size, out, outsize);
+		if (ret < 0)
+			return -1;
+
+		if (ret > 0 && (smallest == 0 || (size_t)ret < smallest)) {
+			smallest = ret;
+			selected = xz_filters[i].filter;
+		}
+	}
+
+	if (smallest == 0)
+		return 0;
+
+	return compress(xz, selected, in, size, out, outsize);
+}
+
+static ssize_t xz_uncomp_block(compressor_t *base, const uint8_t *in,
+			       size_t size, uint8_t *out, size_t outsize)
+{
+	uint64_t memlimit = 32 * 1024 * 1024;
+	size_t dest_pos = 0;
+	size_t src_pos = 0;
+	lzma_ret ret;
+	(void)base;
+
+	ret = lzma_stream_buffer_decode(&memlimit, 0, NULL,
+					in, &src_pos, size,
+					out, &dest_pos, outsize);
+
+	if (ret == LZMA_OK && size == src_pos)
+		return (ssize_t)dest_pos;
+
+	fputs("xz block extract failed\n", stderr);
+	return -1;
+}
+
+static compressor_t *xz_create_copy(compressor_t *cmp)
+{
+	xz_compressor_t *xz = malloc(sizeof(*xz));
+
+	if (xz == NULL) {
+		perror("creating additional xz compressor");
+		return NULL;
+	}
+
+	memcpy(xz, cmp, sizeof(*xz));
+	return (compressor_t *)xz;
+}
+
+static void xz_destroy(compressor_t *base)
+{
+	free(base);
+}
+
+static int process_options(char *options, size_t blocksize,
+			   int *flags, uint64_t *dictsize)
+{
+	enum {
+		OPT_DICT = 0,
+	};
+	char *const token[] = {
+		[OPT_DICT] = (char *)"dictsize",
+		NULL
+	};
+	char *subopts, *value;
+	uint64_t mask;
+	size_t i;
+	int opt;
+
+	subopts = options;
+
+	while (*subopts != '\0') {
+		opt = getsubopt(&subopts, token, &value);
+
+		switch (opt) {
+		case OPT_DICT:
+			if (value == NULL)
+				goto fail_value;
+
+			for (i = 0; isdigit(value[i]); ++i)
+				;
+
+			if (i < 1 || i > 9)
+				goto fail_dict;
+
+			*dictsize = atol(value);
+
+			switch (value[i]) {
+			case '\0':
+				break;
+			case 'm':
+			case 'M':
+				*dictsize <<= 20;
+				break;
+			case 'k':
+			case 'K':
+				*dictsize <<= 10;
+				break;
+			case '%':
+				*dictsize = ((*dictsize) * blocksize) / 100;
+				break;
+			default:
+				goto fail_dict;
+			}
+
+			if (*dictsize > 0x0FFFFFFFFUL)
+				goto fail_dict_ov;
+
+			mask = *dictsize & (*dictsize - 1);
+
+			if (mask != 0 && ((mask & (mask - 1)) != 0))
+				goto fail_dict_pot;
+			break;
+		default:
+			for (i = 0; i < XZ_NUM_FILTERS; ++i) {
+				if (strcmp(value, xz_filters[i].name) == 0) {
+					*flags |= xz_filters[i].flag;
+					break;
+				}
+			}
+			if (i == XZ_NUM_FILTERS)
+				goto fail_opt;
+			break;
+		}
+	}
+
+	return 0;
+fail_dict_pot:
+	fputs("dictionary size must be either 2^n or 2^n + 2^(n-1)\n", stderr);
+	return -1;
+fail_dict_ov:
+	fputs("dictionary size too large.\n", stderr);
+	return -1;
+fail_dict:
+	fputs("dictionary size must be a number with the optional "
+	      "suffix 'm','k' or '%'.\n", stderr);
+	return -1;
+fail_opt:
+	fprintf(stderr, "Unknown option '%s'.\n", value);
+	return -1;
+fail_value:
+	fprintf(stderr, "Missing value for '%s'.\n", token[opt]);
+	return -1;
+}
+
+compressor_t *create_xz_compressor(bool compress, size_t block_size,
+				   char *options)
+{
+	uint64_t dictsize = block_size;
+	xz_compressor_t *xz;
+	compressor_t *base;
+	int flags = 0;
+
+	if (options != NULL) {
+		if (process_options(options, block_size, &flags, &dictsize))
+			return NULL;
+	}
+
+	xz = calloc(1, sizeof(*xz));
+	base = (compressor_t *)xz;
+	if (xz == NULL) {
+		perror("creating xz compressor");
+		return NULL;
+	}
+
+	xz->flags = flags;
+	xz->dict_size = dictsize;
+	xz->block_size = block_size;
+	base->destroy = xz_destroy;
+	base->do_block = compress ? xz_comp_block : xz_uncomp_block;
+	base->write_options = xz_write_options;
+	base->read_options = xz_read_options;
+	base->create_copy = xz_create_copy;
+	return base;
+}
+
+void compressor_xz_print_help(void)
+{
+	size_t i;
+
+	fputs(
+"Available options for xz compressor:\n"
+"\n"
+"    dictsize=<value>  Dictionary size. Either a value in bytes or a\n"
+"                      percentage of the block size. Defaults to 100%.\n"
+"                      The suffix '%' indicates a percentage. 'K' and 'M'\n"
+"                      can also be used for kibi and mebi bytes\n"
+"                      respecitively.\n"
+"\n"
+"In additon to the options, one or more bcj filters can be specified.\n"
+"If multiple filters are provided, the one yielding the best compression\n"
+"ratio will be used.\n"
+"\n"
+"The following filters are available:\n",
+	stdout);
+
+	for (i = 0; i < XZ_NUM_FILTERS; ++i)
+		printf("\t%s\n", xz_filters[i].name);
+}
diff --git a/lib/sqfs/comp/zstd.c b/lib/sqfs/comp/zstd.c
new file mode 100644
index 0000000..e206338
--- /dev/null
+++ b/lib/sqfs/comp/zstd.c
@@ -0,0 +1,188 @@
+/* SPDX-License-Identifier: GPL-3.0-or-later */
+/*
+ * zstd.c
+ *
+ * Copyright (C) 2019 David Oberhollenzer <goliath@infraroot.at>
+ */
+#include "config.h"
+
+#include <stdbool.h>
+#include <stdlib.h>
+#include <string.h>
+#include <stdio.h>
+#include <ctype.h>
+
+#include <zstd.h>
+
+#include "internal.h"
+
+#define ZSTD_DEFAULT_COMPRESSION_LEVEL 15
+
+typedef struct {
+	compressor_t base;
+	ZSTD_CCtx *zctx;
+	int level;
+} zstd_compressor_t;
+
+typedef struct {
+	uint32_t level;
+} zstd_options_t;
+
+static int zstd_write_options(compressor_t *base, int fd)
+{
+	zstd_compressor_t *zstd = (zstd_compressor_t *)base;
+	zstd_options_t opt;
+	(void)fd;
+
+	if (zstd->level == ZSTD_DEFAULT_COMPRESSION_LEVEL)
+		return 0;
+
+	opt.level = htole32(zstd->level);
+	return generic_write_options(fd, &opt, sizeof(opt));
+}
+
+static int zstd_read_options(compressor_t *base, int fd)
+{
+	zstd_options_t opt;
+	(void)base;
+
+	if (generic_read_options(fd, &opt, sizeof(opt)))
+		return -1;
+
+	opt.level = le32toh(opt.level);
+	return 0;
+}
+
+static ssize_t zstd_comp_block(compressor_t *base, const uint8_t *in,
+			       size_t size, uint8_t *out, size_t outsize)
+{
+	zstd_compressor_t *zstd = (zstd_compressor_t *)base;
+	size_t ret;
+
+	ret = ZSTD_compressCCtx(zstd->zctx, out, outsize, in, size,
+				zstd->level);
+
+	if (ZSTD_isError(ret)) {
+		fprintf(stderr, "internal error in ZSTD compressor: %s\n",
+			ZSTD_getErrorName(ret));
+		return -1;
+	}
+
+	return ret < size ? ret : 0;
+}
+
+static ssize_t zstd_uncomp_block(compressor_t *base, const uint8_t *in,
+				 size_t size, uint8_t *out, size_t outsize)
+{
+	size_t ret;
+	(void)base;
+
+	ret = ZSTD_decompress(out, outsize, in, size);
+
+	if (ZSTD_isError(ret)) {
+		fprintf(stderr, "error uncompressing ZSTD compressed data: %s",
+			ZSTD_getErrorName(ret));
+		return -1;
+	}
+
+	return ret;
+}
+
+static compressor_t *zstd_create_copy(compressor_t *cmp)
+{
+	zstd_compressor_t *zstd = malloc(sizeof(*zstd));
+
+	if (zstd == NULL) {
+		perror("creating additional zstd compressor");
+		return NULL;
+	}
+
+	memcpy(zstd, cmp, sizeof(*zstd));
+
+	zstd->zctx = ZSTD_createCCtx();
+
+	if (zstd->zctx == NULL) {
+		fputs("error creating addtional zstd compression context\n",
+		      stderr);
+		free(zstd);
+		return NULL;
+	}
+
+	return (compressor_t *)zstd;
+}
+
+static void zstd_destroy(compressor_t *base)
+{
+	zstd_compressor_t *zstd = (zstd_compressor_t *)base;
+
+	ZSTD_freeCCtx(zstd->zctx);
+	free(zstd);
+}
+
+compressor_t *create_zstd_compressor(bool compress, size_t block_size,
+				     char *options)
+{
+	zstd_compressor_t *zstd = calloc(1, sizeof(*zstd));
+	compressor_t *base = (compressor_t *)zstd;
+	size_t i;
+	(void)block_size;
+
+	if (zstd == NULL) {
+		perror("creating zstd compressor");
+		return NULL;
+	}
+
+	zstd->level = ZSTD_DEFAULT_COMPRESSION_LEVEL;
+
+	if (options != NULL) {
+		if (strncmp(options, "level=", 6) == 0) {
+			options += 6;
+
+			for (i = 0; isdigit(options[i]); ++i)
+				;
+
+			if (i == 0 || options[i] != '\0' || i > 6)
+				goto fail_level;
+
+			zstd->level = atoi(options);
+
+			if (zstd->level < 1 || zstd->level > ZSTD_maxCLevel())
+				goto fail_level;
+		} else {
+			goto fail_opt;
+		}
+	}
+
+	zstd->zctx = ZSTD_createCCtx();
+	if (zstd->zctx == NULL) {
+		fputs("error creating zstd compression context\n", stderr);
+		free(zstd);
+		return NULL;
+	}
+
+	base->destroy = zstd_destroy;
+	base->do_block = compress ? zstd_comp_block : zstd_uncomp_block;
+	base->write_options = zstd_write_options;
+	base->read_options = zstd_read_options;
+	base->create_copy = zstd_create_copy;
+	return base;
+fail_level:
+	fprintf(stderr, "zstd compression level must be a number in the range "
+		"1...%d\n", ZSTD_maxCLevel());
+	free(zstd);
+	return NULL;
+fail_opt:
+	fputs("Unsupported extra options for zstd compressor\n", stderr);
+	free(zstd);
+	return NULL;
+}
+
+void compressor_zstd_print_help(void)
+{
+	printf("Available options for zstd compressor:\n"
+	       "\n"
+	       "    level=<value>    Set compression level. Defaults to %d.\n"
+	       "                     Maximum is %d.\n"
+	       "\n",
+	       ZSTD_DEFAULT_COMPRESSION_LEVEL, ZSTD_maxCLevel());
+}