meson.build

@@ -1472,7 +1472,7 @@ elif compression == 'xz' and not have_xz
 endif
 conf.set('DEFAULT_COMPRESSION',
          compression == 'none' ? 0 :
-                 'COMPRESSION_@0@'.format(compression.to_upper()))
+                 'OBJECT_COMPRESSED_@0@'.format(compression.to_upper()))
 
 want_xkbcommon = get_option('xkbcommon')
 if want_xkbcommon != 'false' and not skip_deps
@@ -1901,11 +1901,13 @@ libsystemd = shared_library(
         link_args : ['-shared',
                      '-Wl,--version-script=' + libsystemd_sym_path],
         link_with : [libbasic,
-                     libbasic_gcrypt,
+                     libbasic_gcrypt],
-                     libbasic_compress],
         link_whole : [libsystemd_static],
         dependencies : [threads,
-                        librt],
+                        librt,
+                        libxz,
+                        libzstd,
+                        liblz4],
         link_depends : libsystemd_sym,
         install : true,
         install_dir : rootlibdir)
@@ -1915,7 +1917,6 @@ install_libsystemd_static = static_library(
         libsystemd_sources,
         basic_sources,
         basic_gcrypt_sources,
-        basic_compress_sources,
         fundamental_sources,
         disable_mempool_c,
         include_directories : libsystemd_includes,
@@ -3030,8 +3031,7 @@ if conf.get('ENABLE_COREDUMP') == 1
                 'systemd-coredump',
                 systemd_coredump_sources,
                 include_directories : includes,
-                link_with : [libshared,
+                link_with : [libshared],
-                             libbasic_compress],
                 dependencies : [threads,
                                 libacl,
                                 libxz,
@@ -3045,8 +3045,7 @@ if conf.get('ENABLE_COREDUMP') == 1
                 'coredumpctl',
                 coredumpctl_sources,
                 include_directories : includes,
-                link_with : [libshared,
+                link_with : [libshared],
-                             libbasic_compress],
                 dependencies : [threads,
                                 libxz,
                                 liblz4,

src/basic/hashmap.c

@@ -1,7 +1,6 @@
 /* SPDX-License-Identifier: LGPL-2.1-or-later */
 
 #include <errno.h>
-#include <fnmatch.h>
 #include <pthread.h>
 #include <stdint.h>
 #include <stdlib.h>
@@ -2071,27 +2070,3 @@ bool set_equal(Set *a, Set *b) {
 
         return true;
 }
-
-static bool set_fnmatch_one(Set *patterns, const char *needle) {
-        const char *p;
-
-        assert(needle);
-
-        SET_FOREACH(p, patterns)
-                if (fnmatch(p, needle, 0) == 0)
-                        return true;
-
-        return false;
-}
-
-bool set_fnmatch(Set *include_patterns, Set *exclude_patterns, const char *needle) {
-        assert(needle);
-
-        if (set_fnmatch_one(exclude_patterns, needle))
-                return false;
-
-        if (set_isempty(include_patterns))
-                return true;
-
-        return set_fnmatch_one(include_patterns, needle);
-}

src/basic/meson.build

@@ -446,21 +446,3 @@ libbasic_gcrypt = static_library(
         dependencies : [libgcrypt],
         c_args : ['-fvisibility=default'],
         build_by_default : false)
-
-############################################################
-
-basic_compress_sources = files(
-        'compress.c',
-        'compress.h')
-
-# A convenience library that is separate from libbasic to avoid unnecessary
-# linking to the compression libraries.
-libbasic_compress = static_library(
-        'basic-compress',
-        basic_compress_sources,
-        include_directories : basic_includes,
-        dependencies : [libxz,
-                        libzstd,
-                        liblz4],
-        c_args : ['-fvisibility=default'],
-        build_by_default : false)

src/basic/set.h

@@ -153,5 +153,3 @@ DEFINE_TRIVIAL_CLEANUP_FUNC(Set*, set_free_free);
 int set_strjoin(Set *s, const char *separator, bool wrap_with_separator, char **ret);
 
 bool set_equal(Set *a, Set *b);
-
-bool set_fnmatch(Set *include_patterns, Set *exclude_patterns, const char *needle);

src/fuzz/fuzz-compress.c

@@ -6,10 +6,21 @@
 #include "compress.h"
 #include "fuzz.h"
 
+static int compress(int alg,
+                    const void *src, uint64_t src_size,
+                    void *dst, size_t dst_alloc_size, size_t *dst_size) {
+
+        if (alg == OBJECT_COMPRESSED_LZ4)
+                return compress_blob_lz4(src, src_size, dst, dst_alloc_size, dst_size);
+        if (alg == OBJECT_COMPRESSED_XZ)
+                return compress_blob_xz(src, src_size, dst, dst_alloc_size, dst_size);
+        return -EOPNOTSUPP;
+}
+
 typedef struct header {
-        uint32_t alg:2; /* We have only three compression algorithms so far, but we might add more in the
+        uint32_t alg:2; /* We have only two compression algorithms so far, but we might add
-                         * future. Let's make this a bit wider so our fuzzer cases remain stable in the
+                         * more in the future. Let's make this a bit wider so our fuzzer
-                         * future. */
+                         * cases remain stable in the future. */
         uint32_t sw_len;
         uint32_t sw_alloc;
         uint32_t reserved[3]; /* Extra space to keep fuzz cases stable in case we need to
@@ -35,7 +46,7 @@ int LLVMFuzzerTestOneInput(const uint8_t *data, size_t size) {
                 log_set_max_level(LOG_CRIT);
 
         log_info("Using compression %s, data size=%zu",
-                 compression_to_string(alg),
+                 object_compressed_to_string(alg) ?: "(none)",
                  data_len);
 
         buf = malloc(MAX(size, 128u)); /* Make the buffer a bit larger for very small data */
@@ -45,7 +56,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(alg, h->data, data_len, buf, size, &csize);
         if (r < 0) {
                 log_error_errno(r, "Compression failed: %m");
                 return 0;

src/journal/test-journal.c

@@ -203,7 +203,7 @@ static bool check_compressed(uint64_t compress_threshold, uint64_t data_size) {
                 p = p + ALIGN64(le64toh(o->object.size));
         }
 
-        is_compressed = COMPRESSION_FROM_OBJECT(o) != COMPRESSION_NONE;
+        is_compressed = (o->object.flags & OBJECT_COMPRESSION_MASK) != 0;
 
         (void) managed_journal_file_close(f);
 

src/libsystemd/libsystemd.sym

@@ -776,5 +776,4 @@ global:
         sd_device_new_from_devname;
         sd_device_new_from_path;
         sd_device_open;
-        sd_device_enumerator_add_nomatch_sysname;
 } LIBSYSTEMD_250;

src/libsystemd/meson.build

@@ -5,6 +5,8 @@ sd_journal_sources = files(
         'sd-journal/audit-type.h',
         'sd-journal/catalog.c',
         'sd-journal/catalog.h',
+        'sd-journal/compress.c',
+        'sd-journal/compress.h',
         'sd-journal/journal-def.h',
         'sd-journal/journal-file.c',
         'sd-journal/journal-file.h',
@@ -169,8 +171,7 @@ libsystemd_static = static_library(
         libsystemd_sources,
         include_directories : libsystemd_includes,
         c_args : libsystemd_c_args,
-        link_with : [libbasic,
+        link_with : libbasic,
-                     libbasic_compress],
         dependencies : [threads,
                         librt],
         build_by_default : false)
@@ -205,6 +206,19 @@ tests += [
 
         [files('sd-journal/test-catalog.c')],
 
+        [files('sd-journal/test-compress.c'),
+         [],
+         [liblz4,
+          libzstd,
+          libxz]],
+
+        [files('sd-journal/test-compress-benchmark.c'),
+         [],
+         [liblz4,
+          libzstd,
+          libxz],
+         [], '', 'timeout=90'],
+
         [files('sd-journal/test-audit-type.c')],
 ]
 

src/libsystemd/sd-device/device-enumerator-private.h

@@ -1,8 +1,6 @@
 /* SPDX-License-Identifier: LGPL-2.1-or-later */
 #pragma once
 
-#include <stdbool.h>
-
 #include "sd-device.h"
 
 typedef enum MatchInitializedType {

src/libsystemd/sd-device/device-enumerator.c

@@ -42,7 +42,6 @@ struct sd_device_enumerator {
         Hashmap *nomatch_sysattr;
         Hashmap *match_property;
         Set *match_sysname;
-        Set *nomatch_sysname;
         Set *match_tag;
         Set *match_parent;
         MatchInitializedType match_initialized;
@@ -97,7 +96,6 @@ static sd_device_enumerator *device_enumerator_free(sd_device_enumerator *enumer
         hashmap_free(enumerator->nomatch_sysattr);
         hashmap_free(enumerator->match_property);
         set_free(enumerator->match_sysname);
-        set_free(enumerator->nomatch_sysname);
         set_free(enumerator->match_tag);
         set_free(enumerator->match_parent);
 
@@ -185,13 +183,13 @@ _public_ int sd_device_enumerator_add_match_property(sd_device_enumerator *enume
         return 1;
 }
 
-static int device_enumerator_add_match_sysname(sd_device_enumerator *enumerator, const char *sysname, bool match) {
+_public_ int sd_device_enumerator_add_match_sysname(sd_device_enumerator *enumerator, const char *sysname) {
         int r;
 
         assert_return(enumerator, -EINVAL);
         assert_return(sysname, -EINVAL);
 
-        r = set_put_strdup(match ? &enumerator->match_sysname : &enumerator->nomatch_sysname, sysname);
+        r = set_put_strdup(&enumerator->match_sysname, sysname);
         if (r <= 0)
                 return r;
 
@@ -200,14 +198,6 @@ static int device_enumerator_add_match_sysname(sd_device_enumerator *enumerator,
         return 1;
 }
 
-_public_ int sd_device_enumerator_add_match_sysname(sd_device_enumerator *enumerator, const char *sysname) {
-        return device_enumerator_add_match_sysname(enumerator, sysname, true);
-}
-
-_public_ int sd_device_enumerator_add_nomatch_sysname(sd_device_enumerator *enumerator, const char *sysname) {
-        return device_enumerator_add_match_sysname(enumerator, sysname, false);
-}
-
 _public_ int sd_device_enumerator_add_match_tag(sd_device_enumerator *enumerator, const char *tag) {
         int r;
 
@@ -510,10 +500,19 @@ static bool match_tag(sd_device_enumerator *enumerator, sd_device *device) {
 }
 
 static bool match_sysname(sd_device_enumerator *enumerator, const char *sysname) {
+        const char *sysname_match;
+
         assert(enumerator);
         assert(sysname);
 
-        return set_fnmatch(enumerator->match_sysname, enumerator->nomatch_sysname, sysname);
+        if (set_isempty(enumerator->match_sysname))
+                return true;
+
+        SET_FOREACH(sysname_match, enumerator->match_sysname)
+                if (fnmatch(sysname_match, sysname, 0) == 0)
+                        return true;
+
+        return false;
 }
 
 static int match_initialized(sd_device_enumerator *enumerator, sd_device *device) {
@@ -581,12 +580,25 @@ static int test_matches(
 }
 
 static bool match_subsystem(sd_device_enumerator *enumerator, const char *subsystem) {
+        const char *subsystem_match;
+
         assert(enumerator);
 
         if (!subsystem)
                 return false;
 
-        return set_fnmatch(enumerator->match_subsystem, enumerator->nomatch_subsystem, subsystem);
+        SET_FOREACH(subsystem_match, enumerator->nomatch_subsystem)
+                if (fnmatch(subsystem_match, subsystem, 0) == 0)
+                        return false;
+
+        if (set_isempty(enumerator->match_subsystem))
+                return true;
+
+        SET_FOREACH(subsystem_match, enumerator->match_subsystem)
+                if (fnmatch(subsystem_match, subsystem, 0) == 0)
+                        return true;
+
+        return false;
 }
 
 static int enumerator_add_parent_devices(

src/libsystemd/sd-device/test-sd-device.c

@@ -182,10 +182,6 @@ TEST(sd_device_enumerator_devices) {
 
         assert_se(sd_device_enumerator_new(&e) >= 0);
         assert_se(sd_device_enumerator_allow_uninitialized(e) >= 0);
-        /* On some CI environments, it seems some loop block devices and corresponding bdi devices sometimes
-         * disappear during running this test. Let's exclude them here for stability. */
-        assert_se(sd_device_enumerator_add_match_subsystem(e, "bdi", false) >= 0);
-        assert_se(sd_device_enumerator_add_nomatch_sysname(e, "loop*") >= 0);
         FOREACH_DEVICE(e, d)
                 test_sd_device_one(d);
 }
@@ -212,8 +208,6 @@ static void test_sd_device_enumerator_filter_subsystem_one(
 
         assert_se(sd_device_enumerator_new(&e) >= 0);
         assert_se(sd_device_enumerator_add_match_subsystem(e, subsystem, true) >= 0);
-        if (streq(subsystem, "block"))
-                assert_se(sd_device_enumerator_add_nomatch_sysname(e, "loop*") >= 0);
 
         FOREACH_DEVICE(e, d) {
                 const char *syspath;
@@ -256,9 +250,6 @@ TEST(sd_device_enumerator_filter_subsystem) {
 
         assert_se(subsystems = hashmap_new(&string_hash_ops));
         assert_se(sd_device_enumerator_new(&e) >= 0);
-        /* See comments in TEST(sd_device_enumerator_devices). */
-        assert_se(sd_device_enumerator_add_match_subsystem(e, "bdi", false) >= 0);
-        assert_se(sd_device_enumerator_add_nomatch_sysname(e, "loop*") >= 0);
 
         FOREACH_DEVICE(e, d) {
                 const char *syspath, *subsystem;

src/libsystemd/sd-journal/compress.c

@@ -27,6 +27,7 @@
 #include "fd-util.h"
 #include "fileio.h"
 #include "io-util.h"
+#include "journal-def.h"
 #include "macro.h"
 #include "sparse-endian.h"
 #include "string-table.h"
@@ -57,14 +58,15 @@ static int zstd_ret_to_errno(size_t ret) {
 
 #define ALIGN_8(l) ALIGN_TO(l, sizeof(size_t))
 
-static const char* const compression_table[_COMPRESSION_MAX] = {
+static const char* const object_compressed_table[_OBJECT_COMPRESSED_MAX] = {
-        [COMPRESSION_NONE] = "NONE",
+        [OBJECT_COMPRESSED_XZ]   = "XZ",
-        [COMPRESSION_XZ]   = "XZ",
+        [OBJECT_COMPRESSED_LZ4]  = "LZ4",
-        [COMPRESSION_LZ4]  = "LZ4",
+        [OBJECT_COMPRESSED_ZSTD] = "ZSTD",
-        [COMPRESSION_ZSTD] = "ZSTD",
+        /* If we add too many more entries here, it's going to grow quite large (and be mostly sparse), since
+         * the array key is actually a bitmask, not a plain enum */
 };
 
-DEFINE_STRING_TABLE_LOOKUP(compression, Compression);
+DEFINE_STRING_TABLE_LOOKUP(object_compressed, int);
 
 int compress_blob_xz(const void *src, uint64_t src_size,
                      void *dst, size_t dst_alloc_size, size_t *dst_size) {
@@ -98,7 +100,7 @@ int compress_blob_xz(const void *src, uint64_t src_size,
                 return -ENOBUFS;
 
         *dst_size = out_pos;
-        return COMPRESSION_XZ;
+        return OBJECT_COMPRESSED_XZ;
 #else
         return -EPROTONOSUPPORT;
 #endif
@@ -128,7 +130,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 OBJECT_COMPRESSED_LZ4;
 #else
         return -EPROTONOSUPPORT;
 #endif
@@ -151,7 +153,7 @@ int compress_blob_zstd(
                 return zstd_ret_to_errno(k);
 
         *dst_size = k;
-        return COMPRESSION_ZSTD;
+        return OBJECT_COMPRESSED_ZSTD;
 #else
         return -EPROTONOSUPPORT;
 #endif
@@ -311,22 +313,22 @@ int decompress_blob_zstd(
 }
 
 int decompress_blob(
-                Compression compression,
+                int compression,
                 const void *src,
                 uint64_t src_size,
                 void **dst,
                 size_t* dst_size,
                 size_t dst_max) {
 
-        if (compression == COMPRESSION_XZ)
+        if (compression == OBJECT_COMPRESSED_XZ)
                 return decompress_blob_xz(
                                 src, src_size,
                                 dst, dst_size, dst_max);
-        else if (compression == COMPRESSION_LZ4)
+        else if (compression == OBJECT_COMPRESSED_LZ4)
                 return decompress_blob_lz4(
                                 src, src_size,
                                 dst, dst_size, dst_max);
-        else if (compression == COMPRESSION_ZSTD)
+        else if (compression == OBJECT_COMPRESSED_ZSTD)
                 return decompress_blob_zstd(
                                 src, src_size,
                                 dst, dst_size, dst_max);
@@ -518,7 +520,7 @@ int decompress_startswith_zstd(
 }
 
 int decompress_startswith(
-                Compression compression,
+                int compression,
                 const void *src,
                 uint64_t src_size,
                 void **buffer,
@@ -526,20 +528,20 @@ int decompress_startswith(
                 size_t prefix_len,
                 uint8_t extra) {
 
-        if (compression == COMPRESSION_XZ)
+        if (compression == OBJECT_COMPRESSED_XZ)
                 return decompress_startswith_xz(
                                 src, src_size,
                                 buffer,
                                 prefix, prefix_len,
                                 extra);
 
-        else if (compression == COMPRESSION_LZ4)
+        else if (compression == OBJECT_COMPRESSED_LZ4)
                 return decompress_startswith_lz4(
                                 src, src_size,
                                 buffer,
                                 prefix, prefix_len,
                                 extra);
-        else if (compression == COMPRESSION_ZSTD)
+        else if (compression == OBJECT_COMPRESSED_ZSTD)
                 return decompress_startswith_zstd(
                                 src, src_size,
                                 buffer,
@@ -617,7 +619,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 OBJECT_COMPRESSED_XZ;
                         }
                 }
         }
@@ -708,7 +710,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 OBJECT_COMPRESSED_LZ4;
 #else
         return -EPROTONOSUPPORT;
 #endif
@@ -952,7 +954,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 OBJECT_COMPRESSED_ZSTD;
 #else
         return -EPROTONOSUPPORT;
 #endif

src/libsystemd/sd-journal/compress.h

@@ -3,17 +3,10 @@
 
 #include <unistd.h>
 
-typedef enum Compression {
+#include "journal-def.h"
-        COMPRESSION_NONE,
-        COMPRESSION_XZ,
-        COMPRESSION_LZ4,
-        COMPRESSION_ZSTD,
-        _COMPRESSION_MAX,
-        _COMPRESSION_INVALID = -EINVAL,
-} Compression;
 
-const char* compression_to_string(Compression compression);
+const char* object_compressed_to_string(int compression);
-Compression compression_from_string(const char *compression);
+int object_compressed_from_string(const char *compression);
 
 int compress_blob_xz(const void *src, uint64_t src_size,
                      void *dst, size_t dst_alloc_size, size_t *dst_size);
@@ -28,7 +21,7 @@ int decompress_blob_lz4(const void *src, uint64_t src_size,
                         void **dst, size_t* dst_size, size_t dst_max);
 int decompress_blob_zstd(const void *src, uint64_t src_size,
                         void **dst, size_t* dst_size, size_t dst_max);
-int decompress_blob(Compression compression,
+int decompress_blob(int compression,
                     const void *src, uint64_t src_size,
                     void **dst, size_t* dst_size, size_t dst_max);
 
@@ -44,7 +37,7 @@ int decompress_startswith_zstd(const void *src, uint64_t src_size,
                                void **buffer,
                                const void *prefix, size_t prefix_len,
                                uint8_t extra);
-int decompress_startswith(Compression compression,
+int decompress_startswith(int compression,
                           const void *src, uint64_t src_size,
                           void **buffer,
                           const void *prefix, size_t prefix_len,
@@ -58,36 +51,27 @@ 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(const void *src, uint64_t src_size,
-                Compression compression,
-                const void *src, uint64_t src_size,
                                 void *dst, size_t dst_alloc_size, size_t *dst_size) {
-
+        switch (DEFAULT_COMPRESSION) {
-        switch (compression) {
+        case OBJECT_COMPRESSED_ZSTD:
-        case COMPRESSION_ZSTD:
                 return compress_blob_zstd(src, src_size, dst, dst_alloc_size, dst_size);
-        case COMPRESSION_LZ4:
+        case OBJECT_COMPRESSED_LZ4:
                 return compress_blob_lz4(src, src_size, dst, dst_alloc_size, dst_size);
-        case COMPRESSION_XZ:
+        case OBJECT_COMPRESSED_XZ:
                 return compress_blob_xz(src, src_size, dst, dst_alloc_size, dst_size);
         default:
                 return -EOPNOTSUPP;
         }
 }
 
-#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:
+        case OBJECT_COMPRESSED_ZSTD:
                 return compress_stream_zstd(fdf, fdt, max_bytes, ret_uncompressed_size);
-        case COMPRESSION_LZ4:
+        case OBJECT_COMPRESSED_LZ4:
                 return compress_stream_lz4(fdf, fdt, max_bytes, ret_uncompressed_size);
-        case COMPRESSION_XZ:
+        case OBJECT_COMPRESSED_XZ:
                 return compress_stream_xz(fdf, fdt, max_bytes, ret_uncompressed_size);
         default:
                 return -EOPNOTSUPP;
@@ -96,11 +80,11 @@ static inline int compress_stream(int fdf, int fdt, uint64_t max_bytes, uint64_t
 
 static inline const char* default_compression_extension(void) {
         switch (DEFAULT_COMPRESSION) {
-        case COMPRESSION_ZSTD:
+        case OBJECT_COMPRESSED_ZSTD:
                 return ".zst";
-        case COMPRESSION_LZ4:
+        case OBJECT_COMPRESSED_LZ4:
                 return ".lz4";
-        case COMPRESSION_XZ:
+        case OBJECT_COMPRESSED_XZ:
                 return ".xz";
         default:
                 return "";

src/libsystemd/sd-journal/journal-def.h

@@ -42,12 +42,14 @@ typedef enum ObjectType {
         _OBJECT_TYPE_MAX
 } ObjectType;
 
-/* Object flags (note that src/basic/compress.h uses the same values for the compression types) */
+/* Object flags
+ * The per-compression enums are also redefined in meson.build so that config.h is self-contained */
 enum {
         OBJECT_COMPRESSED_XZ   = 1 << 0,
         OBJECT_COMPRESSED_LZ4  = 1 << 1,
         OBJECT_COMPRESSED_ZSTD = 1 << 2,
-        _OBJECT_COMPRESSED_MASK = OBJECT_COMPRESSED_XZ | OBJECT_COMPRESSED_LZ4 | OBJECT_COMPRESSED_ZSTD,
+        OBJECT_COMPRESSION_MASK = OBJECT_COMPRESSED_XZ | OBJECT_COMPRESSED_LZ4 | OBJECT_COMPRESSED_ZSTD,
+        _OBJECT_COMPRESSED_MAX = OBJECT_COMPRESSION_MASK,
 };
 
 struct ObjectHeader {

src/libsystemd/sd-journal/journal-file.c

@@ -1372,7 +1372,6 @@ int journal_file_find_data_object_with_hash(
         p = le64toh(f->data_hash_table[h].head_hash_offset);
 
         while (p > 0) {
-                Compression c;
                 Object *o;
 
                 r = journal_file_move_to_object(f, OBJECT_DATA, p, &o);
@@ -1382,10 +1381,7 @@ int journal_file_find_data_object_with_hash(
                 if (le64toh(o->data.hash) != hash)
                         goto next;
 
-                c = COMPRESSION_FROM_OBJECT(o);
+                if (o->object.flags & OBJECT_COMPRESSION_MASK) {
-                if (c < 0)
-                        return -EPROTONOSUPPORT;
-                if (c != COMPRESSION_NONE) {
 #if HAVE_COMPRESSION
                         uint64_t l;
                         size_t rsize = 0;
@@ -1396,7 +1392,8 @@ int journal_file_find_data_object_with_hash(
 
                         l -= offsetof(Object, data.payload);
 
-                        r = decompress_blob(c, o->data.payload, l, &f->compress_buffer, &rsize, 0);
+                        r = decompress_blob(o->object.flags & OBJECT_COMPRESSION_MASK,
+                                            o->data.payload, l, &f->compress_buffer, &rsize, 0);
                         if (r < 0)
                                 return r;
 
@@ -1587,15 +1584,16 @@ static int journal_file_append_data(
                 size_t rsize = 0;
 
                 compression = compress_blob(data, size, o->data.payload, size - 1, &rsize);
-                if (compression > COMPRESSION_NONE) {
+
+                if (compression >= 0) {
                         o->object.size = htole64(offsetof(Object, data.payload) + rsize);
-                        o->object.flags |= COMPRESSION_TO_MASK(compression);
+                        o->object.flags |= compression;
 
                         log_debug("Compressed data object %"PRIu64" -> %zu using %s",
-                                  size, rsize, compression_to_string(compression));
+                                  size, rsize, object_compressed_to_string(compression));
                 } else
                         /* Compression didn't work, we don't really care why, let's continue without compression */
-                        compression = COMPRESSION_NONE;
+                        compression = 0;
         }
 #endif
 
@@ -3145,7 +3143,6 @@ void journal_file_dump(JournalFile *f) {
         p = le64toh(READ_NOW(f->header->header_size));
         while (p != 0) {
                 const char *s;
-                Compression c;
 
                 r = journal_file_move_to_object(f, OBJECT_UNUSED, p, &o);
                 if (r < 0)
@@ -3183,10 +3180,9 @@ void journal_file_dump(JournalFile *f) {
                         break;
                 }
 
-                c = COMPRESSION_FROM_OBJECT(o);
+                if (o->object.flags & OBJECT_COMPRESSION_MASK)
-                if (c > COMPRESSION_NONE)
                         printf("Flags: %s\n",
-                               compression_to_string(c));
+                               object_compressed_to_string(o->object.flags & OBJECT_COMPRESSION_MASK));
 
                 if (p == le64toh(f->header->tail_object_offset))
                         p = 0;
@@ -3371,11 +3367,11 @@ int journal_file_open(
 #endif
         };
 
-        if (DEFAULT_COMPRESSION == COMPRESSION_ZSTD)
+        if (DEFAULT_COMPRESSION == OBJECT_COMPRESSED_ZSTD)
                 f->compress_zstd = FLAGS_SET(file_flags, JOURNAL_COMPRESS);
-        else if (DEFAULT_COMPRESSION == COMPRESSION_LZ4)
+        else if (DEFAULT_COMPRESSION == OBJECT_COMPRESSED_LZ4)
                 f->compress_lz4 = FLAGS_SET(file_flags, JOURNAL_COMPRESS);
-        else if (DEFAULT_COMPRESSION == COMPRESSION_XZ)
+        else if (DEFAULT_COMPRESSION == OBJECT_COMPRESSED_XZ)
                 f->compress_xz = FLAGS_SET(file_flags, JOURNAL_COMPRESS);
 
         /* We turn on keyed hashes by default, but provide an environment variable to turn them off, if
@@ -3693,7 +3689,6 @@ int journal_file_copy_entry(JournalFile *from, JournalFile *to, Object *o, uint6
         items = newa(EntryItem, n);
 
         for (uint64_t i = 0; i < n; i++) {
-                Compression c;
                 uint64_t l, h;
                 size_t t;
                 void *data;
@@ -3716,15 +3711,12 @@ int journal_file_copy_entry(JournalFile *from, JournalFile *to, Object *o, uint6
                 if ((uint64_t) t != l)
                         return -E2BIG;
 
-                c = COMPRESSION_FROM_OBJECT(o);
+                if (o->object.flags & OBJECT_COMPRESSION_MASK) {
-                if (c < 0)
-                        return -EPROTONOSUPPORT;
-                if (c != COMPRESSION_NONE) {
 #if HAVE_COMPRESSION
                         size_t rsize = 0;
 
                         r = decompress_blob(
-                                        c,
+                                        o->object.flags & OBJECT_COMPRESSION_MASK,
                                         o->data.payload, l,
                                         &from->compress_buffer, &rsize,
                                         0);

src/libsystemd/sd-journal/journal-file.h

@@ -11,7 +11,6 @@
 #include "sd-event.h"
 #include "sd-id128.h"
 
-#include "compress.h"
 #include "hashmap.h"
 #include "journal-def.h"
 #include "mmap-cache.h"
@@ -266,33 +265,3 @@ uint64_t journal_file_hash_data(JournalFile *f, const void *data, size_t sz);
 bool journal_field_valid(const char *p, size_t l, bool allow_protected);
 
 const char* journal_object_type_to_string(ObjectType type) _const_;
-
-static inline Compression COMPRESSION_FROM_OBJECT(const Object *o) {
-        assert(o);
-
-        switch (o->object.flags & _OBJECT_COMPRESSED_MASK) {
-        case 0:
-                return COMPRESSION_NONE;
-        case OBJECT_COMPRESSED_XZ:
-                return COMPRESSION_XZ;
-        case OBJECT_COMPRESSED_LZ4:
-                return COMPRESSION_LZ4;
-        case OBJECT_COMPRESSED_ZSTD:
-                return COMPRESSION_ZSTD;
-        default:
-                return _COMPRESSION_INVALID;
-        }
-}
-
-static inline uint8_t COMPRESSION_TO_MASK(Compression c) {
-        switch (c) {
-        case COMPRESSION_XZ:
-                return OBJECT_COMPRESSED_XZ;
-        case COMPRESSION_LZ4:
-                return OBJECT_COMPRESSED_LZ4;
-        case COMPRESSION_ZSTD:
-                return OBJECT_COMPRESSED_ZSTD;
-        default:
-                return 0;
-        }
-}

src/libsystemd/sd-journal/journal-verify.c

@@ -111,24 +111,21 @@ static void flush_progress(void) {
         } while (0)
 
 static int hash_payload(JournalFile *f, Object *o, uint64_t offset, const uint8_t *src, uint64_t size, uint64_t *res_hash) {
-        Compression c;
+        int compression, r;
-        int r;
 
         assert(o);
         assert(src);
         assert(res_hash);
 
-        c = COMPRESSION_FROM_OBJECT(o);
+        compression = o->object.flags & OBJECT_COMPRESSION_MASK;
-        if (c < 0)
+        if (compression) {
-                return -EBADMSG;
-        if (c != COMPRESSION_NONE) {
                 _cleanup_free_ void *b = NULL;
                 size_t b_size;
 
-                r = decompress_blob(c, src, size, &b, &b_size, 0);
+                r = decompress_blob(compression, src, size, &b, &b_size, 0);
                 if (r < 0) {
                         error_errno(offset, r, "%s decompression failed: %m",
-                                    compression_to_string(c));
+                                    object_compressed_to_string(compression));
                         return r;
                 }
 
@@ -148,7 +145,7 @@ static int journal_file_object_verify(JournalFile *f, uint64_t offset, Object *o
          * possible field values. It does not follow any references to
          * other objects. */
 
-        if ((o->object.flags & _OBJECT_COMPRESSED_MASK) != 0 &&
+        if ((o->object.flags & OBJECT_COMPRESSED_XZ) &&
             o->object.type != OBJECT_DATA) {
                 error(offset,
                       "Found compressed object of type %s that isn't of type data, which is not allowed.",

src/libsystemd/sd-journal/sd-journal.c

@@ -2298,7 +2298,7 @@ _public_ int sd_journal_get_data(sd_journal *j, const char *field, const void **
                 Object *d;
                 uint64_t p, l;
                 size_t t;
-                Compression c;
+                int compression;
 
                 p = le64toh(o->entry.items[i].object_offset);
                 r = journal_file_move_to_object(f, OBJECT_DATA, p, &d);
@@ -2311,25 +2311,21 @@ _public_ int sd_journal_get_data(sd_journal *j, const char *field, const void **
 
                 l = le64toh(d->object.size) - offsetof(Object, data.payload);
 
-                c = COMPRESSION_FROM_OBJECT(d);
+                compression = d->object.flags & OBJECT_COMPRESSION_MASK;
-                if (c < 0)
+                if (compression) {
-                        return -EPROTONOSUPPORT;
-                if (c != COMPRESSION_NONE) {
 #if HAVE_COMPRESSION
-                        r = decompress_startswith(
+                        r = decompress_startswith(compression,
-                                        c,
                                                   d->data.payload, l,
                                                   &f->compress_buffer,
                                                   field, field_length, '=');
                         if (r < 0)
                                 log_debug_errno(r, "Cannot decompress %s object of length %"PRIu64" at offset "OFSfmt": %m",
-                                                compression_to_string(c), l, p);
+                                                object_compressed_to_string(compression), l, p);
                         else if (r > 0) {
 
                                 size_t rsize;
 
-                                r = decompress_blob(
+                                r = decompress_blob(compression,
-                                                c,
                                                     d->data.payload, l,
                                                     &f->compress_buffer, &rsize,
                                                     j->data_threshold);
@@ -2370,9 +2366,9 @@ static int return_data(
                 const void **ret_data,
                 size_t *ret_size) {
 
-        Compression c;
-        uint64_t l;
         size_t t;
+        uint64_t l;
+        int compression;
 
         assert(j);
         assert(f);
@@ -2387,16 +2383,14 @@ static int return_data(
         if ((uint64_t) t != l)
                 return -E2BIG;
 
-        c = COMPRESSION_FROM_OBJECT(o);
+        compression = o->object.flags & OBJECT_COMPRESSION_MASK;
-        if (c < 0)
+        if (compression) {
-                return -EPROTONOSUPPORT;
-        if (c != COMPRESSION_NONE) {
 #if HAVE_COMPRESSION
                 size_t rsize;
                 int r;
 
                 r = decompress_blob(
-                                c,
+                                compression,
                                 o->data.payload, l,
                                 &f->compress_buffer, &rsize,
                                 j->data_threshold);

src/libsystemd/sd-journal/test-compress.c

@@ -293,10 +293,10 @@ int main(int argc, char *argv[]) {
         random_bytes(data + 7, sizeof(data) - 7);
 
 #if HAVE_XZ
-        test_compress_decompress(COMPRESSION_XZ, "XZ",
+        test_compress_decompress(OBJECT_COMPRESSED_XZ, "XZ",
                                  compress_blob_xz, decompress_blob_xz,
                                  text, sizeof(text), false);
-        test_compress_decompress(COMPRESSION_XZ, "XZ",
+        test_compress_decompress(OBJECT_COMPRESSED_XZ, "XZ",
                                  compress_blob_xz, decompress_blob_xz,
                                  data, sizeof(data), true);
 
@@ -310,7 +310,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(OBJECT_COMPRESSED_XZ, "XZ", "xzcat",
                              compress_stream_xz, decompress_stream_xz, srcfile);
 
         test_decompress_startswith_short("XZ", compress_blob_xz, decompress_startswith_xz);
@@ -320,10 +320,10 @@ int main(int argc, char *argv[]) {
 #endif
 
 #if HAVE_LZ4
-        test_compress_decompress(COMPRESSION_LZ4, "LZ4",
+        test_compress_decompress(OBJECT_COMPRESSED_LZ4, "LZ4",
                                  compress_blob_lz4, decompress_blob_lz4,
                                  text, sizeof(text), false);
-        test_compress_decompress(COMPRESSION_LZ4, "LZ4",
+        test_compress_decompress(OBJECT_COMPRESSED_LZ4, "LZ4",
                                  compress_blob_lz4, decompress_blob_lz4,
                                  data, sizeof(data), true);
 
@@ -337,7 +337,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(OBJECT_COMPRESSED_LZ4, "LZ4", "lz4cat",
                              compress_stream_lz4, decompress_stream_lz4, srcfile);
 
         test_lz4_decompress_partial();
@@ -349,10 +349,10 @@ int main(int argc, char *argv[]) {
 #endif
 
 #if HAVE_ZSTD
-        test_compress_decompress(COMPRESSION_ZSTD, "ZSTD",
+        test_compress_decompress(OBJECT_COMPRESSED_ZSTD, "ZSTD",
                                  compress_blob_zstd, decompress_blob_zstd,
                                  text, sizeof(text), false);
-        test_compress_decompress(COMPRESSION_ZSTD, "ZSTD",
+        test_compress_decompress(OBJECT_COMPRESSED_ZSTD, "ZSTD",
                                  compress_blob_zstd, decompress_blob_zstd,
                                  data, sizeof(data), true);
 
@@ -366,7 +366,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(OBJECT_COMPRESSED_ZSTD, "ZSTD", "zstdcat",
                              compress_stream_zstd, decompress_stream_zstd, srcfile);
 
         test_decompress_startswith_short("ZSTD", compress_blob_zstd, decompress_startswith_zstd);

src/systemd/sd-device.h

@@ -126,7 +126,6 @@ int sd_device_enumerator_add_match_subsystem(sd_device_enumerator *enumerator, c
 int sd_device_enumerator_add_match_sysattr(sd_device_enumerator *enumerator, const char *sysattr, const char *value, int match);
 int sd_device_enumerator_add_match_property(sd_device_enumerator *enumerator, const char *property, const char *value);
 int sd_device_enumerator_add_match_sysname(sd_device_enumerator *enumerator, const char *sysname);
-int sd_device_enumerator_add_nomatch_sysname(sd_device_enumerator *enumerator, const char *sysname);
 int sd_device_enumerator_add_match_tag(sd_device_enumerator *enumerator, const char *tag);
 int sd_device_enumerator_add_match_parent(sd_device_enumerator *enumerator, sd_device *parent);
 int sd_device_enumerator_allow_uninitialized(sd_device_enumerator *enumerator);

src/test/meson.build

@@ -172,16 +172,6 @@ tests += [
 
         [files('test-recurse-dir.c')],
 
-        [files('test-compress.c'),
-         [libshared,
-          libbasic_compress]],
-
-        [files('test-compress-benchmark.c'),
-         [libshared,
-          libbasic_compress],
-         [],
-         [], '', 'timeout=90'],
-
         [files('test-data-fd-util.c')],
 
         [files('test-static-destruct.c')],

src/test/test-set.c

@@ -330,50 +330,4 @@ TEST(set_equal) {
         assert_se(set_equal(b, a));
 }
 
-TEST(set_fnmatch) {
-        _cleanup_set_free_ Set *match = NULL, *nomatch = NULL;
-
-        assert_se(set_put_strdup(&match, "aaa") >= 0);
-        assert_se(set_put_strdup(&match, "bbb*") >= 0);
-        assert_se(set_put_strdup(&match, "*ccc") >= 0);
-
-        assert_se(set_put_strdup(&nomatch, "a*") >= 0);
-        assert_se(set_put_strdup(&nomatch, "bbb") >= 0);
-        assert_se(set_put_strdup(&nomatch, "ccc*") >= 0);
-
-        assert_se(set_fnmatch(NULL, NULL, ""));
-        assert_se(set_fnmatch(NULL, NULL, "hoge"));
-
-        assert_se(set_fnmatch(match, NULL, "aaa"));
-        assert_se(set_fnmatch(match, NULL, "bbb"));
-        assert_se(set_fnmatch(match, NULL, "bbbXXX"));
-        assert_se(set_fnmatch(match, NULL, "ccc"));
-        assert_se(set_fnmatch(match, NULL, "XXXccc"));
-        assert_se(!set_fnmatch(match, NULL, ""));
-        assert_se(!set_fnmatch(match, NULL, "aaaa"));
-        assert_se(!set_fnmatch(match, NULL, "XXbbb"));
-        assert_se(!set_fnmatch(match, NULL, "cccXX"));
-
-        assert_se(set_fnmatch(NULL, nomatch, ""));
-        assert_se(set_fnmatch(NULL, nomatch, "Xa"));
-        assert_se(set_fnmatch(NULL, nomatch, "bbbb"));
-        assert_se(set_fnmatch(NULL, nomatch, "XXXccc"));
-        assert_se(!set_fnmatch(NULL, nomatch, "a"));
-        assert_se(!set_fnmatch(NULL, nomatch, "aXXXX"));
-        assert_se(!set_fnmatch(NULL, nomatch, "bbb"));
-        assert_se(!set_fnmatch(NULL, nomatch, "ccc"));
-        assert_se(!set_fnmatch(NULL, nomatch, "cccXXX"));
-
-        assert_se(set_fnmatch(match, nomatch, "bbbbb"));
-        assert_se(set_fnmatch(match, nomatch, "XXccc"));
-        assert_se(!set_fnmatch(match, nomatch, ""));
-        assert_se(!set_fnmatch(match, nomatch, "a"));
-        assert_se(!set_fnmatch(match, nomatch, "aaa"));
-        assert_se(!set_fnmatch(match, nomatch, "b"));
-        assert_se(!set_fnmatch(match, nomatch, "bbb"));
-        assert_se(!set_fnmatch(match, nomatch, "ccc"));
-        assert_se(!set_fnmatch(match, nomatch, "ccccc"));
-        assert_se(!set_fnmatch(match, nomatch, "cccXX"));
-}
-
 DEFINE_TEST_MAIN(LOG_INFO);

src/test/test-tables.c

@@ -122,7 +122,8 @@ int main(int argc, char **argv) {
         test_table(unit_load_state, UNIT_LOAD_STATE);
         test_table(unit_type, UNIT_TYPE);
         test_table(virtualization, VIRTUALIZATION);
-        test_table(compression, COMPRESSION);
+
+        test_table_sparse(object_compressed, OBJECT_COMPRESSED);
 
         assert_cc(sizeof(sd_device_action_t) == sizeof(int64_t));