compress: replace compress_blob() with compress_blob_explicit()

And make compress_xyz() return 0 on success, as we know which compression
algorithm is used when calling compress_blob().

Follow-up for 2360352ef02548723ac0c8eaf5ff6905eb9eeca5.

diff --git a/src/basic/compress.c b/src/basic/compress.c
index 59621dc05ba069b1d880181231abfdf0767f517b..10e7aaec59d6227b042de6c74eaf5267171503e6 100644 (file)
--- a/src/basic/compress.c
+++ b/src/basic/compress.c
@@ -107,7 +107,7 @@ int compress_blob_xz(const void *src, uint64_t src_size,
                 return -ENOBUFS;
 
         *dst_size = out_pos;
-        return COMPRESSION_XZ;
+        return 0;
 #else
         return -EPROTONOSUPPORT;
 #endif
@@ -137,7 +137,7 @@ int compress_blob_lz4(const void *src, uint64_t src_size,
         unaligned_write_le64(dst, src_size);
         *dst_size = r + 8;
 
-        return COMPRESSION_LZ4;
+        return 0;
 #else
         return -EPROTONOSUPPORT;
 #endif
@@ -160,7 +160,7 @@ int compress_blob_zstd(
                 return zstd_ret_to_errno(k);
 
         *dst_size = k;
-        return COMPRESSION_ZSTD;
+        return 0;
 #else
         return -EPROTONOSUPPORT;
 #endif
@@ -626,7 +626,7 @@ int compress_stream_xz(int fdf, int fdt, uint64_t max_bytes, uint64_t *ret_uncom
                                           s.total_in, s.total_out,
                                           (double) s.total_out / s.total_in * 100);
 
-                                return COMPRESSION_XZ;
+                                return 0;
                         }
                 }
         }
@@ -717,7 +717,7 @@ int compress_stream_lz4(int fdf, int fdt, uint64_t max_bytes, uint64_t *ret_unco
                   total_in, total_out,
                   (double) total_out / total_in * 100);
 
-        return COMPRESSION_LZ4;
+        return 0;
 #else
         return -EPROTONOSUPPORT;
 #endif
@@ -961,7 +961,7 @@ int compress_stream_zstd(int fdf, int fdt, uint64_t max_bytes, uint64_t *ret_unc
                 log_debug("ZSTD compression finished (%" PRIu64 " -> %" PRIu64 " bytes)",
                           in_bytes, max_bytes - left);
 
-        return COMPRESSION_ZSTD;
+        return 0;
 #else
         return -EPROTONOSUPPORT;
 #endif

diff --git a/src/basic/compress.h b/src/basic/compress.h
index 2201bca74ca0297df067a99f77cc386fad95ed6d..1b5c645e3273ae077ecb6752d32db0ebd78d50ad 100644 (file)
--- a/src/basic/compress.h
+++ b/src/basic/compress.h
@@ -63,7 +63,7 @@ int decompress_stream_xz(int fdf, int fdt, uint64_t max_size);
 int decompress_stream_lz4(int fdf, int fdt, uint64_t max_size);
 int decompress_stream_zstd(int fdf, int fdt, uint64_t max_size);
 
-static inline int compress_blob_explicit(
+static inline int compress_blob(
                 Compression compression,
                 const void *src, uint64_t src_size,
                 void *dst, size_t dst_alloc_size, size_t *dst_size) {
@@ -80,12 +80,6 @@ static inline int compress_blob_explicit(
         }
 }
 
-#define compress_blob(src, src_size, dst, dst_alloc_size, dst_size) \
-        compress_blob_explicit(                                     \
-                DEFAULT_COMPRESSION,                                \
-                src, src_size,                                      \
-                dst, dst_alloc_size, dst_size)
-
 static inline int compress_stream(int fdf, int fdt, uint64_t max_bytes, uint64_t *ret_uncompressed_size) {
         switch (DEFAULT_COMPRESSION) {
         case COMPRESSION_ZSTD:

diff --git a/src/fuzz/fuzz-compress.c b/src/fuzz/fuzz-compress.c
index 10956cc5482b4ecd4d5251db50347039e09b4ab0..9cd571dfb896d177797a72fe046dbea9e5c2f003 100644 (file)
--- a/src/fuzz/fuzz-compress.c
+++ b/src/fuzz/fuzz-compress.c
@@ -45,7 +45,7 @@ int LLVMFuzzerTestOneInput(const uint8_t *data, size_t size) {
         }
 
         size_t csize;
-        r = compress_blob_explicit(alg, h->data, data_len, buf, size, &csize);
+        r = compress_blob(alg, h->data, data_len, buf, size, &csize);
         if (r < 0) {
                 log_error_errno(r, "Compression failed: %m");
                 return 0;

diff --git a/src/libsystemd/sd-journal/journal-file.c b/src/libsystemd/sd-journal/journal-file.c
index a616390ad8429a01dc1312676e00c11751a79aee..3753e29d0d313c83b9054d8e73b7b81fcd2611ff 100644 (file)
--- a/src/libsystemd/sd-journal/journal-file.c
+++ b/src/libsystemd/sd-journal/journal-file.c
@@ -1671,7 +1671,7 @@ static int journal_file_append_field(
         return 0;
 }
 
-static Compression maybe_compress_payload(JournalFile *f, uint8_t *dst, const uint8_t *src, uint64_t size, size_t *rsize) {
+static int maybe_compress_payload(JournalFile *f, uint8_t *dst, const uint8_t *src, uint64_t size, size_t *rsize) {
         assert(f);
         assert(f->header);
 
@@ -1681,21 +1681,17 @@ static Compression maybe_compress_payload(JournalFile *f, uint8_t *dst, const ui
 
         c = JOURNAL_FILE_COMPRESSION(f);
         if (c == COMPRESSION_NONE || size < f->compress_threshold_bytes)
-                return COMPRESSION_NONE;
+                return 0;
 
-        r = compress_blob_explicit(c, src, size, dst, size - 1, rsize);
-        if (r < 0) {
-                log_debug_errno(r, "Failed to compress data object using %s, ignoring: %m", compression_to_string(c));
-                /* Compression didn't work, we don't really care why, let's continue without compression */
-                return COMPRESSION_NONE;
-        }
+        r = compress_blob(c, src, size, dst, size - 1, rsize);
+        if (r < 0)
+                return log_debug_errno(r, "Failed to compress data object using %s, ignoring: %m", compression_to_string(c));
 
-        assert(r == c);
         log_debug("Compressed data object %"PRIu64" -> %zu using %s", size, *rsize, compression_to_string(c));
 
-        return c;
+        return 1; /* compressed */
 #else
-        return COMPRESSION_NONE;
+        return 0;
 #endif
 }
 
@@ -1709,7 +1705,6 @@ static int journal_file_append_data(
         uint64_t hash, p, osize;
         Object *o, *fo;
         size_t rsize = 0;
-        Compression c;
         const void *eq;
         int r;
 
@@ -1737,13 +1732,18 @@ static int journal_file_append_data(
 
         o->data.hash = htole64(hash);
 
-        c = maybe_compress_payload(f, journal_file_data_payload_field(f, o), data, size, &rsize);
+        r = maybe_compress_payload(f, journal_file_data_payload_field(f, o), data, size, &rsize);
+        if (r <= 0)
+                /* We don't really care failures, let's continue without compression */
+                memcpy_safe(journal_file_data_payload_field(f, o), data, size);
+        else {
+                Compression c = JOURNAL_FILE_COMPRESSION(f);
+
+                assert(c >= 0 && c < _COMPRESSION_MAX && c != COMPRESSION_NONE);
 
-        if (c != COMPRESSION_NONE) {
                 o->object.size = htole64(journal_file_data_payload_offset(f) + rsize);
                 o->object.flags |= COMPRESSION_TO_OBJECT_FLAG(c);
-        } else
-                memcpy_safe(journal_file_data_payload_field(f, o), data, size);
+        }
 
         r = journal_file_link_data(f, o, p, hash);
         if (r < 0)

diff --git a/src/test/test-compress-benchmark.c b/src/test/test-compress-benchmark.c
index da0f5e137a75ea669301101d080ae27fc9985ad1..6180e19839ff0f8d402ac750c1624a77f111ebef 100644 (file)
--- a/src/test/test-compress-benchmark.c
+++ b/src/test/test-compress-benchmark.c
@@ -102,7 +102,7 @@ static void test_compress_decompress(const char* label, const char* type,
 
                 r = compress(text, size, buf, size, &j);
                 /* assume compression must be successful except for small or random inputs */
-                assert_se(r > 0 || (size < 2048 && r == -ENOBUFS) || streq(type, "random"));
+                assert_se(r >= 0 || (size < 2048 && r == -ENOBUFS) || streq(type, "random"));
 
                 /* check for overwrites */
                 assert_se(buf[size] == 0);

diff --git a/src/test/test-compress.c b/src/test/test-compress.c
index f5ec47cb3c8a6216a1331e1c3a7a12601b7fef3c..18f8ce3b351e139618ceba79f7600052eaf97ab0 100644 (file)
--- a/src/test/test-compress.c
+++ b/src/test/test-compress.c
@@ -46,7 +46,6 @@ typedef int (decompress_stream_t)(int fdf, int fdt, uint64_t max_size);
 
 #if HAVE_COMPRESSION
 _unused_ static void test_compress_decompress(
-                int flag,
                 const char *compression,
                 compress_blob_t compress,
                 decompress_blob_t decompress,
@@ -67,7 +66,7 @@ _unused_ static void test_compress_decompress(
                 log_info_errno(r, "compression failed: %m");
                 assert_se(may_fail);
         } else {
-                assert_se(r == flag);
+                assert_se(r >= 0);
                 r = decompress(compressed, csize,
                                (void **) &decompressed, &csize, 0);
                 assert_se(r == 0);
@@ -120,7 +119,7 @@ _unused_ static void test_decompress_startswith(const char *compression,
                 assert_se(compressed2);
                 r = compress(data, data_len, compressed, BUFSIZE_2, &csize);
         }
-        assert_se(r > 0);
+        assert_se(r >= 0);
 
         len = strlen(data);
 
@@ -151,7 +150,7 @@ _unused_ static void test_decompress_startswith_short(const char *compression,
         log_info("/* %s with %s */", __func__, compression);
 
         r = compress(TEXT, sizeof TEXT, buf, sizeof buf, &csize);
-        assert_se(r > 0);
+        assert_se(r >= 0);
 
         for (size_t i = 1; i < strlen(TEXT); i++) {
                 _cleanup_free_ void *buf2 = NULL;
@@ -163,8 +162,7 @@ _unused_ static void test_decompress_startswith_short(const char *compression,
         }
 }
 
-_unused_ static void test_compress_stream(int flag,
-                                          const char *compression,
+_unused_ static void test_compress_stream(const char *compression,
                                           const char *cat,
                                           compress_stream_t compress,
                                           decompress_stream_t decompress,
@@ -195,7 +193,7 @@ _unused_ static void test_compress_stream(int flag,
 
         assert_se((dst = mkostemp_safe(pattern)) >= 0);
 
-        assert_se(compress(src, dst, -1, &uncompressed_size) == flag);
+        assert_se(compress(src, dst, -1, &uncompressed_size) >= 0);
 
         if (cat) {
                 assert_se(asprintf(&cmd, "%s %s | diff %s -", cat, pattern, srcfile) > 0);
@@ -293,11 +291,9 @@ int main(int argc, char *argv[]) {
         random_bytes(data + 7, sizeof(data) - 7);
 
 #if HAVE_XZ
-        test_compress_decompress(COMPRESSION_XZ, "XZ",
-                                 compress_blob_xz, decompress_blob_xz,
+        test_compress_decompress("XZ", compress_blob_xz, decompress_blob_xz,
                                  text, sizeof(text), false);
-        test_compress_decompress(COMPRESSION_XZ, "XZ",
-                                 compress_blob_xz, decompress_blob_xz,
+        test_compress_decompress("XZ", compress_blob_xz, decompress_blob_xz,
                                  data, sizeof(data), true);
 
         test_decompress_startswith("XZ",
@@ -310,7 +306,7 @@ int main(int argc, char *argv[]) {
                                    compress_blob_xz, decompress_startswith_xz,
                                    huge, HUGE_SIZE, true);
 
-        test_compress_stream(COMPRESSION_XZ, "XZ", "xzcat",
+        test_compress_stream("XZ", "xzcat",
                              compress_stream_xz, decompress_stream_xz, srcfile);
 
         test_decompress_startswith_short("XZ", compress_blob_xz, decompress_startswith_xz);
@@ -320,11 +316,9 @@ int main(int argc, char *argv[]) {
 #endif
 
 #if HAVE_LZ4
-        test_compress_decompress(COMPRESSION_LZ4, "LZ4",
-                                 compress_blob_lz4, decompress_blob_lz4,
+        test_compress_decompress("LZ4", compress_blob_lz4, decompress_blob_lz4,
                                  text, sizeof(text), false);
-        test_compress_decompress(COMPRESSION_LZ4, "LZ4",
-                                 compress_blob_lz4, decompress_blob_lz4,
+        test_compress_decompress("LZ4", compress_blob_lz4, decompress_blob_lz4,
                                  data, sizeof(data), true);
 
         test_decompress_startswith("LZ4",
@@ -337,7 +331,7 @@ int main(int argc, char *argv[]) {
                                    compress_blob_lz4, decompress_startswith_lz4,
                                    huge, HUGE_SIZE, true);
 
-        test_compress_stream(COMPRESSION_LZ4, "LZ4", "lz4cat",
+        test_compress_stream("LZ4", "lz4cat",
                              compress_stream_lz4, decompress_stream_lz4, srcfile);
 
         test_lz4_decompress_partial();
@@ -349,11 +343,9 @@ int main(int argc, char *argv[]) {
 #endif
 
 #if HAVE_ZSTD
-        test_compress_decompress(COMPRESSION_ZSTD, "ZSTD",
-                                 compress_blob_zstd, decompress_blob_zstd,
+        test_compress_decompress("ZSTD", compress_blob_zstd, decompress_blob_zstd,
                                  text, sizeof(text), false);
-        test_compress_decompress(COMPRESSION_ZSTD, "ZSTD",
-                                 compress_blob_zstd, decompress_blob_zstd,
+        test_compress_decompress("ZSTD", compress_blob_zstd, decompress_blob_zstd,
                                  data, sizeof(data), true);
 
         test_decompress_startswith("ZSTD",
@@ -366,7 +358,7 @@ int main(int argc, char *argv[]) {
                                    compress_blob_zstd, decompress_startswith_zstd,
                                    huge, HUGE_SIZE, true);
 
-        test_compress_stream(COMPRESSION_ZSTD, "ZSTD", "zstdcat",
+        test_compress_stream("ZSTD", "zstdcat",
                              compress_stream_zstd, decompress_stream_zstd, srcfile);
 
         test_decompress_startswith_short("ZSTD", compress_blob_zstd, decompress_startswith_zstd);