diff --git a/SOURCES/0236-journal-def-fix-type-of-signature-to-match-the-actua.patch b/SOURCES/0236-journal-def-fix-type-of-signature-to-match-the-actua.patch new file mode 100644 index 0000000..8a14d47 --- /dev/null +++ b/SOURCES/0236-journal-def-fix-type-of-signature-to-match-the-actua.patch @@ -0,0 +1,26 @@ +From 6b6f61668c539329bc95fb7f3c3b644b793dfb52 Mon Sep 17 00:00:00 2001 +From: Lennart Poettering +Date: Wed, 25 Jan 2023 18:47:05 +0100 +Subject: [PATCH] journal-def: fix type of signature to match the actual field + in the Header structure + +(cherry picked from commit 6fe167d0a77f72086b457125fad6931ca02a4baf) + +Related: #2184929 +--- + src/libsystemd/sd-journal/journal-def.h | 2 +- + 1 file changed, 1 insertion(+), 1 deletion(-) + +diff --git a/src/libsystemd/sd-journal/journal-def.h b/src/libsystemd/sd-journal/journal-def.h +index 8f994b0178..ab4880761b 100644 +--- a/src/libsystemd/sd-journal/journal-def.h ++++ b/src/libsystemd/sd-journal/journal-def.h +@@ -195,7 +195,7 @@ enum { + #endif + + #define HEADER_SIGNATURE \ +- ((const char[]) { 'L', 'P', 'K', 'S', 'H', 'H', 'R', 'H' }) ++ ((const uint8_t[]) { 'L', 'P', 'K', 'S', 'H', 'H', 'R', 'H' }) + + #define struct_Header__contents { \ + uint8_t signature[8]; /* "LPKSHHRH" */ \ diff --git a/SOURCES/0237-journal-use-compound-initialization-for-journal-file.patch b/SOURCES/0237-journal-use-compound-initialization-for-journal-file.patch new file mode 100644 index 0000000..721ae3c --- /dev/null +++ b/SOURCES/0237-journal-use-compound-initialization-for-journal-file.patch @@ -0,0 +1,63 @@ +From de2a4abb178021ab6700f0bc4038daf88f92cb03 Mon Sep 17 00:00:00 2001 +From: Lennart Poettering +Date: Wed, 25 Jan 2023 18:48:31 +0100 +Subject: [PATCH] journal: use compound initialization for journal file Header + structure + +(cherry picked from commit c3dd0dcb888fd8da7ce4e5299caf45e90ddcd41b) + +Related: #2184929 +--- + src/libsystemd/sd-journal/journal-file.c | 23 +++++++++++------------ + 1 file changed, 11 insertions(+), 12 deletions(-) + +diff --git a/src/libsystemd/sd-journal/journal-file.c b/src/libsystemd/sd-journal/journal-file.c +index c489436a1e..cf86bab2dc 100644 +--- a/src/libsystemd/sd-journal/journal-file.c ++++ b/src/libsystemd/sd-journal/journal-file.c +@@ -320,9 +320,8 @@ static bool compact_mode_requested(void) { + } + + static int journal_file_init_header(JournalFile *f, JournalFileFlags file_flags, JournalFile *template) { +- Header h = {}; +- ssize_t k; + bool seal = false; ++ ssize_t k; + int r; + + assert(f); +@@ -332,16 +331,17 @@ static int journal_file_init_header(JournalFile *f, JournalFileFlags file_flags, + seal = FLAGS_SET(file_flags, JOURNAL_SEAL) && journal_file_fss_load(f) >= 0; + #endif + +- memcpy(h.signature, HEADER_SIGNATURE, 8); +- h.header_size = htole64(ALIGN64(sizeof(h))); +- +- h.incompatible_flags |= htole32( +- FLAGS_SET(file_flags, JOURNAL_COMPRESS) * +- COMPRESSION_TO_HEADER_INCOMPATIBLE_FLAG(DEFAULT_COMPRESSION) | +- keyed_hash_requested() * HEADER_INCOMPATIBLE_KEYED_HASH | +- compact_mode_requested() * HEADER_INCOMPATIBLE_COMPACT); ++ Header h = { ++ .header_size = htole64(ALIGN64(sizeof(h))), ++ .incompatible_flags = htole32( ++ FLAGS_SET(file_flags, JOURNAL_COMPRESS) * COMPRESSION_TO_HEADER_INCOMPATIBLE_FLAG(DEFAULT_COMPRESSION) | ++ keyed_hash_requested() * HEADER_INCOMPATIBLE_KEYED_HASH | ++ compact_mode_requested() * HEADER_INCOMPATIBLE_COMPACT), ++ .compatible_flags = htole32(seal * HEADER_COMPATIBLE_SEALED), ++ }; + +- h.compatible_flags = htole32(seal * HEADER_COMPATIBLE_SEALED); ++ assert_cc(sizeof(h.signature) == sizeof(HEADER_SIGNATURE)); ++ memcpy(h.signature, HEADER_SIGNATURE, sizeof(HEADER_SIGNATURE)); + + r = sd_id128_randomize(&h.file_id); + if (r < 0) +@@ -356,7 +356,6 @@ static int journal_file_init_header(JournalFile *f, JournalFileFlags file_flags, + k = pwrite(f->fd, &h, sizeof(h), 0); + if (k < 0) + return -errno; +- + if (k != sizeof(h)) + return -EIO; + diff --git a/SOURCES/0238-journald-fix-log-message.patch b/SOURCES/0238-journald-fix-log-message.patch new file mode 100644 index 0000000..e9f779f --- /dev/null +++ b/SOURCES/0238-journald-fix-log-message.patch @@ -0,0 +1,25 @@ +From de88fa23f060ab5f554f4c0d41b0f93430f1db8a Mon Sep 17 00:00:00 2001 +From: Yu Watanabe +Date: Tue, 4 Apr 2023 17:11:28 +0900 +Subject: [PATCH] journald: fix log message + +(cherry picked from commit 01aa59979bc61125f599a5b8a6c911fff5daaee7) + +Resolves: #2184929 +--- + src/journal/journald-server.c | 2 +- + 1 file changed, 1 insertion(+), 1 deletion(-) + +diff --git a/src/journal/journald-server.c b/src/journal/journald-server.c +index 71d7a59bda..cbcf1e9d9e 100644 +--- a/src/journal/journald-server.c ++++ b/src/journal/journald-server.c +@@ -2011,7 +2011,7 @@ static int vl_method_synchronize(Varlink *link, JsonVariant *parameters, Varlink + if (json_variant_elements(parameters) > 0) + return varlink_error_invalid_parameter(link, parameters); + +- log_info("Received client request to rotate journal."); ++ log_info("Received client request to sync journal."); + + /* We don't do the main work now, but instead enqueue a deferred event loop job which will do + * it. That job is scheduled at low priority, so that we return from this method call only after all diff --git a/SOURCES/0239-sd-journal-cache-results-of-parsing-environment-vari.patch b/SOURCES/0239-sd-journal-cache-results-of-parsing-environment-vari.patch new file mode 100644 index 0000000..9f71699 --- /dev/null +++ b/SOURCES/0239-sd-journal-cache-results-of-parsing-environment-vari.patch @@ -0,0 +1,66 @@ +From c7919b02b504e2c0ccacf02c6f21f65c3f18ea4c Mon Sep 17 00:00:00 2001 +From: Yu Watanabe +Date: Tue, 4 Apr 2023 16:43:44 +0900 +Subject: [PATCH] sd-journal: cache results of parsing environment variables + +(cherry picked from commit 9dfbae203e3afa500163bc46e0070c4cb2180aac) + +Resolves: #2184929 +--- + src/libsystemd/sd-journal/journal-file.c | 34 +++++++++++++++--------- + 1 file changed, 22 insertions(+), 12 deletions(-) + +diff --git a/src/libsystemd/sd-journal/journal-file.c b/src/libsystemd/sd-journal/journal-file.c +index cf86bab2dc..00de564499 100644 +--- a/src/libsystemd/sd-journal/journal-file.c ++++ b/src/libsystemd/sd-journal/journal-file.c +@@ -296,27 +296,37 @@ JournalFile* journal_file_close(JournalFile *f) { + } + + static bool keyed_hash_requested(void) { ++ static thread_local int cached = -1; + int r; + +- r = getenv_bool("SYSTEMD_JOURNAL_KEYED_HASH"); +- if (r >= 0) +- return r; +- if (r != -ENXIO) +- log_debug_errno(r, "Failed to parse $SYSTEMD_JOURNAL_KEYED_HASH environment variable, ignoring: %m"); ++ if (cached < 0) { ++ r = getenv_bool("SYSTEMD_JOURNAL_KEYED_HASH"); ++ if (r < 0) { ++ if (r != -ENXIO) ++ log_debug_errno(r, "Failed to parse $SYSTEMD_JOURNAL_KEYED_HASH environment variable, ignoring: %m"); ++ cached = true; ++ } else ++ cached = r; ++ } + +- return true; ++ return cached; + } + + static bool compact_mode_requested(void) { ++ static thread_local int cached = -1; + int r; + +- r = getenv_bool("SYSTEMD_JOURNAL_COMPACT"); +- if (r >= 0) +- return r; +- if (r != -ENXIO) +- log_debug_errno(r, "Failed to parse $SYSTEMD_JOURNAL_COMPACT environment variable, ignoring: %m"); ++ if (cached < 0) { ++ r = getenv_bool("SYSTEMD_JOURNAL_COMPACT"); ++ if (r < 0) { ++ if (r != -ENXIO) ++ log_debug_errno(r, "Failed to parse $SYSTEMD_JOURNAL_COMPACT environment variable, ignoring: %m"); ++ cached = true; ++ } else ++ cached = r; ++ } + +- return true; ++ return cached; + } + + static int journal_file_init_header(JournalFile *f, JournalFileFlags file_flags, JournalFile *template) { diff --git a/SOURCES/0240-compress-introduce-compression_supported-helper-func.patch b/SOURCES/0240-compress-introduce-compression_supported-helper-func.patch new file mode 100644 index 0000000..9983288 --- /dev/null +++ b/SOURCES/0240-compress-introduce-compression_supported-helper-func.patch @@ -0,0 +1,55 @@ +From c926e4ff48022a71665e7e7833fd59a1bf2ad5fb Mon Sep 17 00:00:00 2001 +From: Yu Watanabe +Date: Tue, 4 Apr 2023 14:34:32 +0900 +Subject: [PATCH] compress: introduce compression_supported() helper function + +(cherry picked from commit 83f3d73da8d132773dd91aae0fa7babb74920774) + +Resolves: #2184929 +--- + src/basic/compress.c | 10 ++++++++++ + src/basic/compress.h | 3 +++ + 2 files changed, 13 insertions(+) + +diff --git a/src/basic/compress.c b/src/basic/compress.c +index 1e94635397..dce0ebf222 100644 +--- a/src/basic/compress.c ++++ b/src/basic/compress.c +@@ -66,6 +66,16 @@ static const char* const compression_table[_COMPRESSION_MAX] = { + + DEFINE_STRING_TABLE_LOOKUP(compression, Compression); + ++bool compression_supported(Compression c) { ++ static const unsigned supported = ++ (1U << COMPRESSION_NONE) | ++ (1U << COMPRESSION_XZ) * HAVE_XZ | ++ (1U << COMPRESSION_LZ4) * HAVE_LZ4 | ++ (1U << COMPRESSION_ZSTD) * HAVE_ZSTD; ++ ++ return c >= 0 && c < _COMPRESSION_MAX && FLAGS_SET(supported, 1U << c); ++} ++ + int compress_blob_xz(const void *src, uint64_t src_size, + void *dst, size_t dst_alloc_size, size_t *dst_size) { + #if HAVE_XZ +diff --git a/src/basic/compress.h b/src/basic/compress.h +index 583b105c66..2201bca74c 100644 +--- a/src/basic/compress.h ++++ b/src/basic/compress.h +@@ -2,6 +2,7 @@ + #pragma once + + #include ++#include + #include + #include + +@@ -17,6 +18,8 @@ typedef enum Compression { + const char* compression_to_string(Compression compression); + Compression compression_from_string(const char *compression); + ++bool compression_supported(Compression c); ++ + int compress_blob_xz(const void *src, uint64_t src_size, + void *dst, size_t dst_alloc_size, size_t *dst_size); + int compress_blob_lz4(const void *src, uint64_t src_size, diff --git a/SOURCES/0241-sd-journal-always-use-the-compression-algorithm-spec.patch b/SOURCES/0241-sd-journal-always-use-the-compression-algorithm-spec.patch new file mode 100644 index 0000000..8972152 --- /dev/null +++ b/SOURCES/0241-sd-journal-always-use-the-compression-algorithm-spec.patch @@ -0,0 +1,115 @@ +From 3baac68b2bcad46062b12aa11e15adf8e6d80a40 Mon Sep 17 00:00:00 2001 +From: Yu Watanabe +Date: Tue, 4 Apr 2023 18:22:50 +0900 +Subject: [PATCH] sd-journal: always use the compression algorithm specified in + the header + +Previously, data object may be compressed with an algorithm that is not +mentioned in the header. + +(cherry picked from commit 2360352ef02548723ac0c8eaf5ff6905eb9eeca5) + +Resolves: #2184929 +--- + src/libsystemd/sd-journal/journal-file.c | 40 ++++++++++++++---------- + src/libsystemd/sd-journal/journal-file.h | 12 +++++-- + 2 files changed, 33 insertions(+), 19 deletions(-) + +diff --git a/src/libsystemd/sd-journal/journal-file.c b/src/libsystemd/sd-journal/journal-file.c +index 00de564499..1b8f0abf97 100644 +--- a/src/libsystemd/sd-journal/journal-file.c ++++ b/src/libsystemd/sd-journal/journal-file.c +@@ -1593,24 +1593,31 @@ static int journal_file_append_field( + } + + static Compression maybe_compress_payload(JournalFile *f, uint8_t *dst, const uint8_t *src, uint64_t size, size_t *rsize) { +- Compression compression = COMPRESSION_NONE; +- + assert(f); + assert(f->header); + + #if HAVE_COMPRESSION +- if (JOURNAL_FILE_COMPRESS(f) && size >= f->compress_threshold_bytes) { +- compression = compress_blob(src, size, dst, size - 1, rsize); +- if (compression > 0) +- log_debug("Compressed data object %"PRIu64" -> %zu using %s", +- size, *rsize, compression_to_string(compression)); +- else +- /* Compression didn't work, we don't really care why, let's continue without compression */ +- compression = COMPRESSION_NONE; ++ Compression c; ++ int r; ++ ++ c = JOURNAL_FILE_COMPRESSION(f); ++ if (c == COMPRESSION_NONE || size < f->compress_threshold_bytes) ++ return COMPRESSION_NONE; ++ ++ 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; + } +-#endif + +- return compression; ++ assert(r == c); ++ log_debug("Compressed data object %"PRIu64" -> %zu using %s", size, *rsize, compression_to_string(c)); ++ ++ return c; ++#else ++ return COMPRESSION_NONE; ++#endif + } + + static int journal_file_append_data( +@@ -3887,20 +3894,21 @@ int journal_file_open( + f->close_fd = true; + + if (DEBUG_LOGGING) { +- static int last_seal = -1, last_compress = -1, last_keyed_hash = -1; ++ static int last_seal = -1, last_keyed_hash = -1; ++ static Compression last_compression = _COMPRESSION_INVALID; + static uint64_t last_bytes = UINT64_MAX; + + if (last_seal != JOURNAL_HEADER_SEALED(f->header) || + last_keyed_hash != JOURNAL_HEADER_KEYED_HASH(f->header) || +- last_compress != JOURNAL_FILE_COMPRESS(f) || ++ last_compression != JOURNAL_FILE_COMPRESSION(f) || + last_bytes != f->compress_threshold_bytes) { + + log_debug("Journal effective settings seal=%s keyed_hash=%s compress=%s compress_threshold_bytes=%s", + yes_no(JOURNAL_HEADER_SEALED(f->header)), yes_no(JOURNAL_HEADER_KEYED_HASH(f->header)), +- yes_no(JOURNAL_FILE_COMPRESS(f)), FORMAT_BYTES(f->compress_threshold_bytes)); ++ compression_to_string(JOURNAL_FILE_COMPRESSION(f)), FORMAT_BYTES(f->compress_threshold_bytes)); + last_seal = JOURNAL_HEADER_SEALED(f->header); + last_keyed_hash = JOURNAL_HEADER_KEYED_HASH(f->header); +- last_compress = JOURNAL_FILE_COMPRESS(f); ++ last_compression = JOURNAL_FILE_COMPRESSION(f); + last_bytes = f->compress_threshold_bytes; + } + } +diff --git a/src/libsystemd/sd-journal/journal-file.h b/src/libsystemd/sd-journal/journal-file.h +index 1f3c80c912..0321da4a16 100644 +--- a/src/libsystemd/sd-journal/journal-file.h ++++ b/src/libsystemd/sd-journal/journal-file.h +@@ -305,10 +305,16 @@ bool journal_file_rotate_suggested(JournalFile *f, usec_t max_file_usec, int log + int journal_file_map_data_hash_table(JournalFile *f); + int journal_file_map_field_hash_table(JournalFile *f); + +-static inline bool JOURNAL_FILE_COMPRESS(JournalFile *f) { ++static inline Compression JOURNAL_FILE_COMPRESSION(JournalFile *f) { + assert(f); +- return JOURNAL_HEADER_COMPRESSED_XZ(f->header) || JOURNAL_HEADER_COMPRESSED_LZ4(f->header) || +- JOURNAL_HEADER_COMPRESSED_ZSTD(f->header); ++ ++ if (JOURNAL_HEADER_COMPRESSED_XZ(f->header)) ++ return COMPRESSION_XZ; ++ if (JOURNAL_HEADER_COMPRESSED_LZ4(f->header)) ++ return COMPRESSION_LZ4; ++ if (JOURNAL_HEADER_COMPRESSED_ZSTD(f->header)) ++ return COMPRESSION_ZSTD; ++ return COMPRESSION_NONE; + } + + uint64_t journal_file_hash_data(JournalFile *f, const void *data, size_t sz); diff --git a/SOURCES/0242-sd-journal-allow-to-specify-compression-algorithm-th.patch b/SOURCES/0242-sd-journal-allow-to-specify-compression-algorithm-th.patch new file mode 100644 index 0000000..4a7998d --- /dev/null +++ b/SOURCES/0242-sd-journal-allow-to-specify-compression-algorithm-th.patch @@ -0,0 +1,100 @@ +From 6d0fb28f2d7b64146361673be99bc2586e3763ce Mon Sep 17 00:00:00 2001 +From: Yu Watanabe +Date: Tue, 4 Apr 2023 14:19:51 +0900 +Subject: [PATCH] sd-journal: allow to specify compression algorithm through + env + +Fixes RHBZ#2183546 (https://bugzilla.redhat.com/show_bug.cgi?id=2183546). + +Previously, journal file is always compressed with the default algorithm +set at compile time. So, if a newer algorithm is used, journal files +cannot be read by older version of journalctl that does not support the +algorithm. + +Co-authored-by: Colin Walters +(cherry picked from commit 1f06ea747b5939a1083c436dd7dae97b37bedee7) + +Resolves: #2184929 +--- + docs/ENVIRONMENT.md | 8 +++++ + src/libsystemd/sd-journal/journal-file.c | 44 +++++++++++++++++++++++- + 2 files changed, 51 insertions(+), 1 deletion(-) + +diff --git a/docs/ENVIRONMENT.md b/docs/ENVIRONMENT.md +index ab3add6031..70fac2e361 100644 +--- a/docs/ENVIRONMENT.md ++++ b/docs/ENVIRONMENT.md +@@ -471,3 +471,11 @@ SYSTEMD_HOME_DEBUG_SUFFIX=foo \ + in a more compact format that reduces the amount of disk space required by the + journal. Note that journal files in compact mode are limited to 4G to allow use of + 32-bit offsets. Enabled by default. ++ ++* `$SYSTEMD_JOURNAL_COMPRESS` – Takes a boolean, or one of the compression ++ algorithms "XZ", "LZ4", and "ZSTD". If enabled, the default compression ++ algorithm set at compile time will be used when opening a new journal file. ++ If disabled, the journal file compression will be disabled. Note that the ++ compression mode of existing journal files are not changed. To make the ++ specified algorithm takes an effect immediately, you need to explicitly run ++ `journalctl --rotate`. +diff --git a/src/libsystemd/sd-journal/journal-file.c b/src/libsystemd/sd-journal/journal-file.c +index 1b8f0abf97..3c1385ddb0 100644 +--- a/src/libsystemd/sd-journal/journal-file.c ++++ b/src/libsystemd/sd-journal/journal-file.c +@@ -329,6 +329,48 @@ static bool compact_mode_requested(void) { + return cached; + } + ++#if HAVE_COMPRESSION ++static Compression getenv_compression(void) { ++ Compression c; ++ const char *e; ++ int r; ++ ++ e = getenv("SYSTEMD_JOURNAL_COMPRESS"); ++ if (!e) ++ return DEFAULT_COMPRESSION; ++ ++ r = parse_boolean(e); ++ if (r >= 0) ++ return r ? DEFAULT_COMPRESSION : COMPRESSION_NONE; ++ ++ c = compression_from_string(e); ++ if (c < 0) { ++ log_debug_errno(c, "Failed to parse SYSTEMD_JOURNAL_COMPRESS value, ignoring: %s", e); ++ return DEFAULT_COMPRESSION; ++ } ++ ++ if (!compression_supported(c)) { ++ log_debug("Unsupported compression algorithm specified, ignoring: %s", e); ++ return DEFAULT_COMPRESSION; ++ } ++ ++ return c; ++} ++#endif ++ ++static Compression compression_requested(void) { ++#if HAVE_COMPRESSION ++ static thread_local Compression cached = _COMPRESSION_INVALID; ++ ++ if (cached < 0) ++ cached = getenv_compression(); ++ ++ return cached; ++#else ++ return COMPRESSION_NONE; ++#endif ++} ++ + static int journal_file_init_header(JournalFile *f, JournalFileFlags file_flags, JournalFile *template) { + bool seal = false; + ssize_t k; +@@ -344,7 +386,7 @@ static int journal_file_init_header(JournalFile *f, JournalFileFlags file_flags, + Header h = { + .header_size = htole64(ALIGN64(sizeof(h))), + .incompatible_flags = htole32( +- FLAGS_SET(file_flags, JOURNAL_COMPRESS) * COMPRESSION_TO_HEADER_INCOMPATIBLE_FLAG(DEFAULT_COMPRESSION) | ++ FLAGS_SET(file_flags, JOURNAL_COMPRESS) * COMPRESSION_TO_HEADER_INCOMPATIBLE_FLAG(compression_requested()) | + keyed_hash_requested() * HEADER_INCOMPATIBLE_KEYED_HASH | + compact_mode_requested() * HEADER_INCOMPATIBLE_COMPACT), + .compatible_flags = htole32(seal * HEADER_COMPATIBLE_SEALED), diff --git a/SOURCES/0243-test-add-test-case-that-journal-file-is-created-with.patch b/SOURCES/0243-test-add-test-case-that-journal-file-is-created-with.patch new file mode 100644 index 0000000..69e12fd --- /dev/null +++ b/SOURCES/0243-test-add-test-case-that-journal-file-is-created-with.patch @@ -0,0 +1,54 @@ +From 7c20d0bfec62de66e81f6b6e1c7ce9f3a3b3d5cf Mon Sep 17 00:00:00 2001 +From: Yu Watanabe +Date: Tue, 4 Apr 2023 15:03:35 +0900 +Subject: [PATCH] test: add test case that journal file is created with the + requested compression algorithm + +(cherry picked from commit d23a1c52a93206b0dbabcb4336752ccb796c11c3) + +Resolves: #2184929 +--- + test/units/testsuite-04.sh | 32 ++++++++++++++++++++++++++++++++ + 1 file changed, 32 insertions(+) + +diff --git a/test/units/testsuite-04.sh b/test/units/testsuite-04.sh +index fdc3273fea..bb41045809 100755 +--- a/test/units/testsuite-04.sh ++++ b/test/units/testsuite-04.sh +@@ -179,4 +179,36 @@ sleep 3 + # https://github.com/systemd/systemd/issues/15528 + journalctl --follow --file=/var/log/journal/*/* | head -n1 || [[ $? -eq 1 ]] + ++# https://bugzilla.redhat.com/show_bug.cgi?id=2183546 ++mkdir /run/systemd/system/systemd-journald.service.d ++MID=$(cat /etc/machine-id) ++for c in "NONE" "XZ" "LZ4" "ZSTD"; do ++ cat >/run/systemd/system/systemd-journald.service.d/compress.conf <&1 | grep -q -F 'compress=${c}'; do sleep .5; done" ++ ++ # $SYSTEMD_JOURNAL_COMPRESS= also works for journal-remote ++ if [[ -x /usr/lib/systemd/systemd-journal-remote ]]; then ++ for cc in "NONE" "XZ" "LZ4" "ZSTD"; do ++ rm -f /tmp/foo.journal ++ SYSTEMD_JOURNAL_COMPRESS="${cc}" /usr/lib/systemd/systemd-journal-remote --split-mode=none -o /tmp/foo.journal --getter="journalctl -b -o export -t $ID" ++ SYSTEMD_LOG_LEVEL=debug journalctl --verify --quiet --file /tmp/foo.journal 2>&1 | grep -q -F "compress=${cc}" ++ journalctl -t "$ID" -o cat --file /tmp/foo.journal | grep -q -F "hoge with ${c}" ++ done ++ fi ++done ++rm /run/systemd/system/systemd-journald.service.d/compress.conf ++systemctl daemon-reload ++systemctl restart systemd-journald.service ++journalctl --rotate ++ + touch /testok diff --git a/SOURCES/0244-ci-workflow-for-gathering-metadata-for-source-git-au.patch b/SOURCES/0244-ci-workflow-for-gathering-metadata-for-source-git-au.patch new file mode 100644 index 0000000..3a9d249 --- /dev/null +++ b/SOURCES/0244-ci-workflow-for-gathering-metadata-for-source-git-au.patch @@ -0,0 +1,51 @@ +From 15d494b7ee019ab3e3a2a8e61c73ea8693ddb8ba Mon Sep 17 00:00:00 2001 +From: Jan Macku +Date: Mon, 17 Apr 2023 14:51:19 +0200 +Subject: [PATCH] ci: workflow for gathering metadata for source-git automation + +Workflow gathers metadata like pull request numbers and information about commits. +This metadata is used for commit validation and other actions. +This workflow also triggers for rest of the source-git automation workflows. + +rhel-only + +Related: #2184929 +--- + .github/workflows/gather-metadata.yml | 28 +++++++++++++++++++++++++++ + 1 file changed, 28 insertions(+) + create mode 100644 .github/workflows/gather-metadata.yml + +diff --git a/.github/workflows/gather-metadata.yml b/.github/workflows/gather-metadata.yml +new file mode 100644 +index 0000000000..635708a71f +--- /dev/null ++++ b/.github/workflows/gather-metadata.yml +@@ -0,0 +1,28 @@ ++name: Gather Pull Request Metadata ++on: ++ pull_request: ++ types: [ opened, reopened, synchronize ] ++ branches: ++ - main ++ - rhel-9.*.0 ++ ++permissions: ++ contents: read ++ ++jobs: ++ gather-metadata: ++ runs-on: ubuntu-latest ++ ++ steps: ++ - name: Repository checkout ++ uses: actions/checkout@v3 ++ ++ - id: Metadata ++ name: Gather Pull Request Metadata ++ uses: redhat-plumbers-in-action/gather-pull-request-metadata@v1 ++ ++ - name: Upload artifact with gathered metadata ++ uses: actions/upload-artifact@v3 ++ with: ++ name: pr-metadata ++ path: ${{ steps.Metadata.outputs.metadata-file }} diff --git a/SOURCES/0245-ci-first-part-of-the-source-git-automation-commit-li.patch b/SOURCES/0245-ci-first-part-of-the-source-git-automation-commit-li.patch new file mode 100644 index 0000000..b90b6c3 --- /dev/null +++ b/SOURCES/0245-ci-first-part-of-the-source-git-automation-commit-li.patch @@ -0,0 +1,103 @@ +From 47c1a02ba0e669484e93dd78dd475592ecaa4cbd Mon Sep 17 00:00:00 2001 +From: Jan Macku +Date: Mon, 17 Apr 2023 14:59:55 +0200 +Subject: [PATCH] ci: first part of the source-git automation - commit linter + +Add a GitHub Workflow that is triggered on `workflow_run` events. +It uses metadata provided by `redhat-plumbers-in-action/gather-pull-request-metadata` +GitHub Action to get the PR number and the commit metadata. +The commit metadata is then used to check if the commit message contains +all required information (tracker and upstream reference). GitHub Action +responsible for commit verification `redhat-plumbers-in-action/advanced-commit-linter` +is configured via the `advanced-commit-linter.yml` file. + +rhel-only + +Related: #2184929 +--- + .github/advanced-commit-linter.yml | 23 +++++++++++ + .github/workflows/source-git-automation.yml | 45 +++++++++++++++++++++ + 2 files changed, 68 insertions(+) + create mode 100644 .github/advanced-commit-linter.yml + create mode 100644 .github/workflows/source-git-automation.yml + +diff --git a/.github/advanced-commit-linter.yml b/.github/advanced-commit-linter.yml +new file mode 100644 +index 0000000000..491836abbb +--- /dev/null ++++ b/.github/advanced-commit-linter.yml +@@ -0,0 +1,23 @@ ++policy: ++ cherry-pick: ++ upstream: ++ - github: systemd/systemd ++ - github: systemd/systemd-stable ++ exception: ++ note: ++ - rhel-only ++ tracker: ++ - keyword: ++ - 'Resolves: #?' ++ - 'Related: #?' ++ - 'Reverts: #?' ++ issue-format: ++ - '\d+$' ++ url: 'https://bugzilla.redhat.com/show_bug.cgi?id=' ++ - keyword: ++ - 'Resolves: ' ++ - 'Related: ' ++ - 'Reverts: ' ++ issue-format: ++ - 'RHEL-\d+$' ++ url: 'https://issues.redhat.com/browse/' +diff --git a/.github/workflows/source-git-automation.yml b/.github/workflows/source-git-automation.yml +new file mode 100644 +index 0000000000..140f21b116 +--- /dev/null ++++ b/.github/workflows/source-git-automation.yml +@@ -0,0 +1,45 @@ ++name: Source git Automation ++on: ++ workflow_run: ++ workflows: [ Gather Pull Request Metadata ] ++ types: ++ - completed ++ ++permissions: ++ contents: read ++ ++jobs: ++ download-metadata: ++ if: > ++ github.event.workflow_run.event == 'pull_request' && ++ github.event.workflow_run.conclusion == 'success' ++ runs-on: ubuntu-latest ++ ++ outputs: ++ pr-metadata: ${{ steps.Artifact.outputs.pr-metadata-json }} ++ ++ steps: ++ - id: Artifact ++ name: Download Artifact ++ uses: redhat-plumbers-in-action/download-artifact@v1 ++ with: ++ name: pr-metadata ++ ++ commit-linter: ++ needs: [ download-metadata ] ++ runs-on: ubuntu-latest ++ ++ outputs: ++ validated-pr-metadata: ${{ steps.commit-linter.outputs.validated-pr-metadata }} ++ ++ permissions: ++ statuses: write ++ pull-requests: write ++ ++ steps: ++ - id: commit-linter ++ name: Lint Commits ++ uses: redhat-plumbers-in-action/advanced-commit-linter@v1 ++ with: ++ pr-metadata: ${{ needs.download-metadata.outputs.pr-metadata }} ++ token: ${{ secrets.GITHUB_TOKEN }} diff --git a/SPECS/systemd.spec b/SPECS/systemd.spec index 5e356c9..72b5af1 100644 --- a/SPECS/systemd.spec +++ b/SPECS/systemd.spec @@ -21,7 +21,7 @@ Name: systemd Url: https://systemd.io Version: 252 -Release: 13%{?dist} +Release: 14%{?dist}.1 # For a breakdown of the licensing, see README License: LGPLv2+ and MIT and GPLv2+ Summary: System and Service Manager @@ -313,6 +313,16 @@ Patch0232: 0232-meson-Store-fuzz-tests-in-structured-way.patch Patch0233: 0233-meson-Generate-fuzzer-inputs-with-directives.patch Patch0234: 0234-oss-fuzz-include-generated-corpora-in-the-final-zip-.patch Patch0235: 0235-unit-In-cgroupv1-gracefully-terminate-delegated-scop.patch +Patch0236: 0236-journal-def-fix-type-of-signature-to-match-the-actua.patch +Patch0237: 0237-journal-use-compound-initialization-for-journal-file.patch +Patch0238: 0238-journald-fix-log-message.patch +Patch0239: 0239-sd-journal-cache-results-of-parsing-environment-vari.patch +Patch0240: 0240-compress-introduce-compression_supported-helper-func.patch +Patch0241: 0241-sd-journal-always-use-the-compression-algorithm-spec.patch +Patch0242: 0242-sd-journal-allow-to-specify-compression-algorithm-th.patch +Patch0243: 0243-test-add-test-case-that-journal-file-is-created-with.patch +Patch0244: 0244-ci-workflow-for-gathering-metadata-for-source-git-au.patch +Patch0245: 0245-ci-first-part-of-the-source-git-automation-commit-li.patch # Downstream-only patches (9000–9999) @@ -1134,6 +1144,21 @@ getent passwd systemd-oom &>/dev/null || useradd -r -l -g systemd-oom -d / -s /s %files standalone-sysusers -f .file-list-standalone-sysusers %changelog +* Wed May 24 2023 systemd maintenance team - 252-14.1 +- Bump version to 252-14.1 to make sure that NEVRA is higher than systemd-252-14.el9.rhaos4.13 (#2184929) + +* Thu May 18 2023 systemd maintenance team - 252-13.1 +- journal-def: fix type of signature to match the actual field in the Header structure (#2184929) +- journal: use compound initialization for journal file Header structure (#2184929) +- journald: fix log message (#2184929) +- sd-journal: cache results of parsing environment variables (#2184929) +- compress: introduce compression_supported() helper function (#2184929) +- sd-journal: always use the compression algorithm specified in the header (#2184929) +- sd-journal: allow to specify compression algorithm through env (#2184929) +- test: add test case that journal file is created with the requested compression algorithm (#2184929) +- ci: workflow for gathering metadata for source-git automation (#2184929) +- ci: first part of the source-git automation - commit linter (#2184929) + * Mon Mar 20 2023 systemd maintenance team - 252-13 - spec: release bump (#2179165)