update

decompressor_lzma.c

@@ -0,0 +1,181 @@
+// SPDX-License-Identifier: GPL-2.0-only
+/*
+ * EROFS MicroLZMA wrapper around FreeBSD's bundled XZ Embedded decoder.
+ * The decoder source is compiled with private symbol names because the
+ * stock xz.ko does not enable its optional MicroLZMA entry points.
+ */
+
+#include <sys/param.h>
+#include <sys/malloc.h>
+#include <sys/systm.h>
+
+#include "compress.h"
+
+#define XZ_DEC_MICROLZMA
+#define xz_dec_lzma2_create erofs_xz_dec_lzma2_create
+#define xz_dec_lzma2_reset erofs_xz_dec_lzma2_reset
+#define xz_dec_lzma2_run erofs_xz_dec_lzma2_run
+#define xz_dec_lzma2_end erofs_xz_dec_lzma2_end
+#define xz_dec_microlzma_alloc erofs_xz_dec_microlzma_alloc
+#define xz_dec_microlzma_reset erofs_xz_dec_microlzma_reset
+#define xz_dec_microlzma_run erofs_xz_dec_microlzma_run
+#define xz_dec_microlzma_end erofs_xz_dec_microlzma_end
+#define xz_malloc erofs_xz_malloc
+#define xz_free erofs_xz_free
+
+static void *
+erofs_xz_malloc(unsigned long size)
+{
+	return (malloc(size, M_EROFS, M_NOWAIT));
+}
+
+static void
+erofs_xz_free(void *ptr)
+{
+	free(ptr, M_EROFS);
+}
+
+#include <contrib/xz-embedded/linux/lib/xz/xz_dec_lzma2.c>
+
+#undef bool
+#undef false
+#undef true
+#undef min
+
+struct z_erofs_lzma_ctx {
+	struct erofs_stream_ctx pool;
+	struct xz_dec_microlzma *state;
+	size_t state_bytes;
+};
+
+_Static_assert(sizeof(struct z_erofs_lzma_ctx) <=
+    EROFS_STREAM_CTX_WRAPPER_SIZE, "LZMA stream wrapper exceeds UMA item");
+
+static int
+z_erofs_lzma_ctx_init(struct erofs_stream_ctx *pool)
+{
+	struct z_erofs_lzma_ctx *ctx;
+	int error;
+
+	ctx = (struct z_erofs_lzma_ctx *)pool;
+	ctx->state_bytes = sizeof(*ctx->state);
+	error = z_erofs_stream_ctx_charge(pool, ctx->state_bytes);
+	if (error != 0)
+		return (error);
+	ctx->state = xz_dec_microlzma_alloc(XZ_SINGLE,
+	    pool->sbi->lzma_dict_size);
+	if (ctx->state == NULL) {
+		z_erofs_stream_ctx_uncharge(pool, ctx->state_bytes);
+		ctx->state_bytes = 0;
+		pool->allocation_failed = 1;
+		return (ENOMEM);
+	}
+	return (0);
+}
+
+static void
+z_erofs_lzma_ctx_fini(struct erofs_stream_ctx *pool)
+{
+	struct z_erofs_lzma_ctx *ctx;
+
+	ctx = (struct z_erofs_lzma_ctx *)pool;
+	if (ctx->state != NULL) {
+		xz_dec_microlzma_end(ctx->state);
+		ctx->state = NULL;
+	}
+	if (ctx->state_bytes != 0) {
+		z_erofs_stream_ctx_uncharge(pool, ctx->state_bytes);
+		ctx->state_bytes = 0;
+	}
+}
+
+static int
+z_erofs_load_lzma_config(struct erofs_sb_info *sbi,
+    const struct erofs_super_block *dsb, const void *data, size_t size)
+{
+	const struct z_erofs_lzma_cfgs *lzma;
+	uint32_t dict_size;
+
+	(void)dsb;
+	if (size < sizeof(*lzma))
+		return (EINTEGRITY);
+	lzma = data;
+	if (le16toh(lzma->format) != 0)
+		return (EOPNOTSUPP);
+	dict_size = le32toh(lzma->dict_size);
+	if (dict_size < 4096)
+		return (EINTEGRITY);
+	if (dict_size > Z_EROFS_LZMA_MAX_DICT_SIZE)
+		return (EOPNOTSUPP);
+	sbi->lzma_dict_size = dict_size;
+	return (0);
+}
+
+static int
+z_erofs_lzma_error(enum xz_ret ret)
+{
+
+	switch (ret) {
+	case XZ_MEM_ERROR:
+		return (ENOMEM);
+	case XZ_MEMLIMIT_ERROR:
+	case XZ_OPTIONS_ERROR:
+	case XZ_UNSUPPORTED_CHECK:
+		return (EOPNOTSUPP);
+	default:
+		return (EINTEGRITY);
+	}
+}
+
+static int
+z_erofs_lzma_finish(const struct z_erofs_decompress_req *rq, enum xz_ret ret,
+    size_t input_pos)
+{
+
+	if (rq->partial_decoding &&
+	    (ret == XZ_OK || ret == XZ_STREAM_END))
+		return (0);
+	if (!rq->partial_decoding && ret == XZ_STREAM_END &&
+	    input_pos == rq->inputsize)
+		return (0);
+	return (z_erofs_lzma_error(ret));
+}
+
+static int
+z_erofs_lzma_decompress(const struct z_erofs_decompress_req *rq)
+{
+	struct erofs_stream_ctx *pool;
+	struct z_erofs_lzma_ctx *ctx;
+	struct xz_buf buffer;
+	enum xz_ret ret;
+	int error;
+
+	if (rq->inputsize > UINT32_MAX || rq->outputsize > UINT32_MAX)
+		return (EOVERFLOW);
+	error = z_erofs_stream_ctx_get(rq->sbi, Z_EROFS_COMPRESSION_LZMA,
+	    sizeof(*ctx), z_erofs_lzma_ctx_init, z_erofs_lzma_ctx_fini, &pool);
+	if (error != 0)
+		return (error);
+	ctx = (struct z_erofs_lzma_ctx *)pool;
+	bzero(&buffer, sizeof(buffer));
+	buffer.in = rq->in;
+	buffer.in_size = rq->inputsize;
+	buffer.out = rq->out;
+	buffer.out_size = rq->outputsize;
+	xz_dec_microlzma_reset(ctx->state, (uint32_t)rq->inputsize,
+	    (uint32_t)rq->outputsize, !rq->partial_decoding);
+	ret = xz_dec_microlzma_run(ctx->state, &buffer);
+	if (buffer.out_pos != rq->outputsize)
+		error = EINTEGRITY;
+	else
+		error = z_erofs_lzma_finish(rq, ret, buffer.in_pos);
+	z_erofs_stream_ctx_put(pool, error == 0);
+	return (error);
+}
+
+const struct z_erofs_decompressor z_erofs_lzma_decomp = {
+	.config = z_erofs_load_lzma_config,
+	.decompress = z_erofs_lzma_decompress,
+	.supports_subextent = 1,
+	.name = "lzma",
+};