[systemd-devel] [RFC/PATCH 2/3] journal/compress: add stream compression function

[Zbigniew Jędrzejewski-Szmek]

---
 src/journal/compress.c      | 83 +++++++++++++++++++++++++++++++++++++++++++--
 src/journal/compress.h      |  3 ++
 src/journal/test-compress.c | 23 +++++++++++++
 src/shared/copy.c           |  4 +--
 4 files changed, 107 insertions(+), 6 deletions(-)

diff --git a/src/journal/compress.c b/src/journal/compress.c
index cafe8f4f..f29ef812 100644
--- a/src/journal/compress.c
+++ b/src/journal/compress.c
@@ -22,10 +22,12 @@
 #include <assert.h>
 #include <stdlib.h>
 #include <string.h>
+#include <unistd.h>
 #include <lzma.h>
 
-#include "macro.h"
 #include "compress.h"
+#include "macro.h"
+#include "util.h"
 
 bool compress_blob(const void *src, uint64_t src_size, void *dst, uint64_t *dst_size) {
         lzma_ret ret;
@@ -40,18 +42,93 @@ bool compress_blob(const void *src, uint64_t src_size, void *dst, uint64_t *dst_
          * compressed result is longer than the original */
 
         ret = lzma_easy_buffer_encode(LZMA_PRESET_DEFAULT, LZMA_CHECK_NONE, NULL,
-                                      src, src_size, dst, &out_pos, *dst_size);
+                                      src, src_size, dst, &out_pos, src_size);
         if (ret != LZMA_OK)
                 return false;
 
         /* Is it actually shorter? */
-        if (out_pos == *dst_size)
+        if (out_pos == src_size)
                 return false;
 
         *dst_size = out_pos;
         return true;
 }
 
+int compress_stream(int fdf, int fdt, off_t max_bytes) {
+        _cleanup_(lzma_end) lzma_stream s = LZMA_STREAM_INIT;
+        lzma_ret ret;
+
+        uint8_t buf[BUFSIZ], out[BUFSIZ];
+        lzma_action action = LZMA_RUN;
+
+        assert(fdf >= 0);
+        assert(fdt >= 0);
+
+        ret = lzma_easy_encoder(&s, LZMA_PRESET_DEFAULT, LZMA_CHECK_CRC64);
+        if (ret != LZMA_OK) {
+                log_error("Failed to initialize XZ encoder: code %d", ret);
+                return -EINVAL;
+        }
+
+
+        for (;;) {
+                if (s.avail_in == 0 && action == LZMA_RUN) {
+                        size_t m = sizeof(buf);
+                        ssize_t n;
+
+                        if (max_bytes != -1 && m > (size_t) max_bytes)
+                                m = max_bytes;
+
+                        n = read(fdf, buf, m);
+                        if (n < 0)
+                                return -errno;
+                        if (n == 0)
+                                action = LZMA_FINISH;
+                        else {
+                                s.next_in = buf;
+                                s.avail_in = n;
+
+                                if (max_bytes != -1) {
+                                        assert(max_bytes >= n);
+                                        max_bytes -= n;
+                                }
+                        }
+                }
+
+                if (s.avail_out == 0) {
+                        s.next_out = out;
+                        s.avail_out = sizeof(out);
+                }
+
+                ret = lzma_code(&s, action);
+                if (ret != LZMA_OK && ret != LZMA_STREAM_END) {
+                        log_error("Compression failed: code %d", ret);
+                        return -EBADMSG;
+                }
+
+                if (s.avail_out == 0 || ret == LZMA_STREAM_END) {
+                        ssize_t n, k;
+
+                        n = sizeof(out) - s.avail_out;
+
+                        errno = 0;
+                        k = loop_write(fdt, out, n, false);
+                        if (k < 0)
+                                return k;
+                        if (k != n)
+                                return errno ? -errno : -EIO;
+
+                        if (ret == LZMA_STREAM_END) {
+                                log_debug("Compression finished (%zu -> %zu bytes, %.1f%%)",
+                                          s.total_in, s.total_out,
+                                          (double) s.total_out / s.total_in * 100);
+
+                                return 0;
+                        }
+                }
+        }
+}
+
 bool uncompress_blob(const void *src, uint64_t src_size,
                      void **dst, uint64_t *dst_alloc_size, uint64_t* dst_size, uint64_t dst_max) {
 
diff --git a/src/journal/compress.h b/src/journal/compress.h
index 2b87e73a..f516d330 100644
--- a/src/journal/compress.h
+++ b/src/journal/compress.h
@@ -23,9 +23,12 @@
 
 #include <inttypes.h>
 #include <stdbool.h>
+#include <unistd.h>
 
 bool compress_blob(const void *src, uint64_t src_size, void *dst, uint64_t *dst_size);
 
+int compress_stream(int fdf, int fdt, off_t max_size);
+
 bool uncompress_blob(const void *src, uint64_t src_size,
                      void **dst, uint64_t *dst_alloc_size, uint64_t* dst_size, uint64_t dst_max);
 
diff --git a/src/journal/test-compress.c b/src/journal/test-compress.c
index 15b3f9aa..f9543b92 100644
--- a/src/journal/test-compress.c
+++ b/src/journal/test-compress.c
@@ -68,9 +68,32 @@ static void test_uncompress_startswith(void) {
                                         "barbarbar", 9, ' '));
 }
 
+static void test_compress_stream(const char *srcfile) {
+        _cleanup_close_ int src = -1, dst = -1;
+        char pattern[] = "/tmp/systemd-test.xz.XXXXXX";
+        int r;
+        _cleanup_free_ char *cmd;
+
+        assert_se((src = open(srcfile, O_RDONLY|O_CLOEXEC)) >= 0);
+
+        assert_se((dst = mkostemp_safe(pattern, O_RDWR|O_CLOEXEC)) >= 0);
+
+        r = compress_stream(src, dst, -1);
+        assert(r == 0);
+
+        assert_se(asprintf(&cmd, "xzcat %s | diff %s -", pattern, srcfile) > 0);
+        assert_se(system(cmd) == 0);
+
+        assert_se(unlink(pattern) == 0);
+}
+
 int main(int argc, char *argv[]) {
+
+        log_set_max_level(LOG_DEBUG);
+
         test_compress_uncompress();
         test_uncompress_startswith();
+        test_compress_stream(argv[0]);
 
         return 0;
 }
diff --git a/src/shared/copy.c b/src/shared/copy.c
index ebd66998..3744797b 100644
--- a/src/shared/copy.c
+++ b/src/shared/copy.c
@@ -29,9 +29,7 @@ int copy_bytes(int fdf, int fdt, off_t max_bytes) {
         for (;;) {
                 char buf[PIPE_BUF];
                 ssize_t n, k;
-                size_t m;
-
-                m = sizeof(buf);
+                size_t m = sizeof(buf);
 
                 if (max_bytes != (off_t) -1) {
 
-- 
2.0.0.rc4