mirrors/systemd
0
0
Fork 0
mirror of https://github.com/systemd/systemd.git synced 2024-11-23 10:13:34 +08:00
Code Issues Packages Projects Releases Wiki Activity

Merge pull request #23131 from poettering/shared-compress

Browse Source 
move compress.[ch] → src/basic/
This commit is contained in:
Zbigniew Jędrzejewski-Szmek 2022-04-27 10:47:54 +02:00 committed by GitHub
commit 3d8a7e6f51
No known key found for this signature in database
GPG Key ID: 4AEE18F83AFDEB23
16 changed files with 196 additions and 133 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

17
meson.build
View File

@ -1472,7 +1472,7 @@ elif compression == 'xz' and not have_xz
endif
conf.set('DEFAULT_COMPRESSION',
compression == 'none' ? 0 :
'OBJECT_COMPRESSED_@0@'.format(compression.to_upper()))
'COMPRESSION_@0@'.format(compression.to_upper()))
want_xkbcommon = get_option('xkbcommon')
if want_xkbcommon != 'false' and not skip_deps
@ -1901,13 +1901,11 @@ 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,
libxz,
libzstd,
liblz4],
librt],
link_depends : libsystemd_sym,
install : true,
install_dir : rootlibdir)
@ -1917,6 +1915,7 @@ install_libsystemd_static = static_library(
libsystemd_sources,
basic_sources,
basic_gcrypt_sources,
basic_compress_sources,
fundamental_sources,
disable_mempool_c,
include_directories : libsystemd_includes,
@ -3031,7 +3030,8 @@ 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,7 +3045,8 @@ if conf.get('ENABLE_COREDUMP') == 1
'coredumpctl',
coredumpctl_sources,
include_directories : includes,
link_with : [libshared],
link_with : [libshared,
libbasic_compress],
dependencies : [threads,
libxz,
liblz4,

42
src/libsystemd/sd-journal/compress.c → src/basic/compress.c
View File

@ -27,7 +27,6 @@
#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"
@ -58,15 +57,14 @@ static int zstd_ret_to_errno(size_t ret) {
#define ALIGN_8(l) ALIGN_TO(l, sizeof(size_t))
static const char* const object_compressed_table[_OBJECT_COMPRESSED_MAX] = {
[OBJECT_COMPRESSED_XZ] = "XZ",
[OBJECT_COMPRESSED_LZ4] = "LZ4",
[OBJECT_COMPRESSED_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 */
static const char* const compression_table[_COMPRESSION_MAX] = {
[COMPRESSION_NONE] = "NONE",
[COMPRESSION_XZ] = "XZ",
[COMPRESSION_LZ4] = "LZ4",
[COMPRESSION_ZSTD] = "ZSTD",
};
DEFINE_STRING_TABLE_LOOKUP(object_compressed, int);
DEFINE_STRING_TABLE_LOOKUP(compression, Compression);
int compress_blob_xz(const void *src, uint64_t src_size,
void *dst, size_t dst_alloc_size, size_t *dst_size) {
@ -100,7 +98,7 @@ int compress_blob_xz(const void *src, uint64_t src_size,
return -ENOBUFS;
*dst_size = out_pos;
return OBJECT_COMPRESSED_XZ;
return COMPRESSION_XZ;
#else
return -EPROTONOSUPPORT;
#endif
@ -130,7 +128,7 @@ int compress_blob_lz4(const void *src, uint64_t src_size,
unaligned_write_le64(dst, src_size);
*dst_size = r + 8;
return OBJECT_COMPRESSED_LZ4;
return COMPRESSION_LZ4;
#else
return -EPROTONOSUPPORT;
#endif
@ -153,7 +151,7 @@ int compress_blob_zstd(
return zstd_ret_to_errno(k);
*dst_size = k;
return OBJECT_COMPRESSED_ZSTD;
return COMPRESSION_ZSTD;
#else
return -EPROTONOSUPPORT;
#endif
@ -313,22 +311,22 @@ int decompress_blob_zstd(
}
int decompress_blob(
int compression,
Compression compression,
const void *src,
uint64_t src_size,
void **dst,
size_t* dst_size,
size_t dst_max) {
if (compression == OBJECT_COMPRESSED_XZ)
if (compression == COMPRESSION_XZ)
return decompress_blob_xz(
src, src_size,
dst, dst_size, dst_max);
else if (compression == OBJECT_COMPRESSED_LZ4)
else if (compression == COMPRESSION_LZ4)
return decompress_blob_lz4(
src, src_size,
dst, dst_size, dst_max);
else if (compression == OBJECT_COMPRESSED_ZSTD)
else if (compression == COMPRESSION_ZSTD)
return decompress_blob_zstd(
src, src_size,
dst, dst_size, dst_max);
@ -520,7 +518,7 @@ int decompress_startswith_zstd(
}
int decompress_startswith(
int compression,
Compression compression,
const void *src,
uint64_t src_size,
void **buffer,
@ -528,20 +526,20 @@ int decompress_startswith(
size_t prefix_len,
uint8_t extra) {
if (compression == OBJECT_COMPRESSED_XZ)
if (compression == COMPRESSION_XZ)
return decompress_startswith_xz(
src, src_size,
buffer,
prefix, prefix_len,
extra);
else if (compression == OBJECT_COMPRESSED_LZ4)
else if (compression == COMPRESSION_LZ4)
return decompress_startswith_lz4(
src, src_size,
buffer,
prefix, prefix_len,
extra);
else if (compression == OBJECT_COMPRESSED_ZSTD)
else if (compression == COMPRESSION_ZSTD)
return decompress_startswith_zstd(
src, src_size,
buffer,
@ -619,7 +617,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 OBJECT_COMPRESSED_XZ;
return COMPRESSION_XZ;
}
}
}
@ -710,7 +708,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 OBJECT_COMPRESSED_LZ4;
return COMPRESSION_LZ4;
#else
return -EPROTONOSUPPORT;
#endif
@ -954,7 +952,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 OBJECT_COMPRESSED_ZSTD;
return COMPRESSION_ZSTD;
#else
return -EPROTONOSUPPORT;
#endif

50
src/libsystemd/sd-journal/compress.h → src/basic/compress.h
View File

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

18
src/basic/meson.build
View File

@ -446,3 +446,21 @@ 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)

21
src/fuzz/fuzz-compress.c
View File

@ -6,21 +6,10 @@
#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 two compression algorithms so far, but we might add
* more in the future. Let's make this a bit wider so our fuzzer
* cases remain stable in the future. */
uint32_t alg:2; /* We have only three compression algorithms so far, but we might add more in the
* future. Let's make this a bit wider so our fuzzer 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
@ -46,7 +35,7 @@ int LLVMFuzzerTestOneInput(const uint8_t *data, size_t size) {
log_set_max_level(LOG_CRIT);
log_info("Using compression %s, data size=%zu",
object_compressed_to_string(alg) ?: "(none)",
compression_to_string(alg),
data_len);
buf = malloc(MAX(size, 128u)); /* Make the buffer a bit larger for very small data */
@ -56,7 +45,7 @@ int LLVMFuzzerTestOneInput(const uint8_t *data, size_t size) {
}
size_t csize;
r = compress(alg, h->data, data_len, buf, size, &csize);
r = compress_blob_explicit(alg, h->data, data_len, buf, size, &csize);
if (r < 0) {
log_error_errno(r, "Compression failed: %m");
return 0;

2
src/journal/test-journal.c
View File

@ -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 = (o->object.flags & OBJECT_COMPRESSION_MASK) != 0;
is_compressed = COMPRESSION_FROM_OBJECT(o) != COMPRESSION_NONE;
(void) managed_journal_file_close(f);

18
src/libsystemd/meson.build
View File

@ -5,8 +5,6 @@ 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',
@ -171,7 +169,8 @@ 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)
@ -206,19 +205,6 @@ 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')],
]

6
src/libsystemd/sd-journal/journal-def.h
View File

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

38
src/libsystemd/sd-journal/journal-file.c
View File

@ -1372,6 +1372,7 @@ 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);
@ -1381,7 +1382,10 @@ int journal_file_find_data_object_with_hash(
if (le64toh(o->data.hash) != hash)
goto next;
if (o->object.flags & OBJECT_COMPRESSION_MASK) {
c = COMPRESSION_FROM_OBJECT(o);
if (c < 0)
return -EPROTONOSUPPORT;
if (c != COMPRESSION_NONE) {
#if HAVE_COMPRESSION
uint64_t l;
size_t rsize = 0;
@ -1392,8 +1396,7 @@ int journal_file_find_data_object_with_hash(
l -= offsetof(Object, data.payload);
r = decompress_blob(o->object.flags & OBJECT_COMPRESSION_MASK,
o->data.payload, l, &f->compress_buffer, &rsize, 0);
r = decompress_blob(c, o->data.payload, l, &f->compress_buffer, &rsize, 0);
if (r < 0)
return r;
@ -1584,16 +1587,15 @@ static int journal_file_append_data(
size_t rsize = 0;
compression = compress_blob(data, size, o->data.payload, size - 1, &rsize);
if (compression >= 0) {
if (compression > COMPRESSION_NONE) {
o->object.size = htole64(offsetof(Object, data.payload) + rsize);
o->object.flags |= compression;
o->object.flags |= COMPRESSION_TO_MASK(compression);
log_debug("Compressed data object %"PRIu64" -> %zu using %s",
size, rsize, object_compressed_to_string(compression));
size, rsize, compression_to_string(compression));
} else
/* Compression didn't work, we don't really care why, let's continue without compression */
compression = 0;
compression = COMPRESSION_NONE;
}
#endif
@ -3143,6 +3145,7 @@ 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)
@ -3180,9 +3183,10 @@ void journal_file_dump(JournalFile *f) {
break;
}
if (o->object.flags & OBJECT_COMPRESSION_MASK)
c = COMPRESSION_FROM_OBJECT(o);
if (c > COMPRESSION_NONE)
printf("Flags: %s\n",
object_compressed_to_string(o->object.flags & OBJECT_COMPRESSION_MASK));
compression_to_string(c));
if (p == le64toh(f->header->tail_object_offset))
p = 0;
@ -3367,11 +3371,11 @@ int journal_file_open(
#endif
};
if (DEFAULT_COMPRESSION == OBJECT_COMPRESSED_ZSTD)
if (DEFAULT_COMPRESSION == COMPRESSION_ZSTD)
f->compress_zstd = FLAGS_SET(file_flags, JOURNAL_COMPRESS);
else if (DEFAULT_COMPRESSION == OBJECT_COMPRESSED_LZ4)
else if (DEFAULT_COMPRESSION == COMPRESSION_LZ4)
f->compress_lz4 = FLAGS_SET(file_flags, JOURNAL_COMPRESS);
else if (DEFAULT_COMPRESSION == OBJECT_COMPRESSED_XZ)
else if (DEFAULT_COMPRESSION == COMPRESSION_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
@ -3689,6 +3693,7 @@ 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;
@ -3711,12 +3716,15 @@ int journal_file_copy_entry(JournalFile *from, JournalFile *to, Object *o, uint6
if ((uint64_t) t != l)
return -E2BIG;
if (o->object.flags & OBJECT_COMPRESSION_MASK) {
c = COMPRESSION_FROM_OBJECT(o);
if (c < 0)
return -EPROTONOSUPPORT;
if (c != COMPRESSION_NONE) {
#if HAVE_COMPRESSION
size_t rsize = 0;
r = decompress_blob(
o->object.flags & OBJECT_COMPRESSION_MASK,
c,
o->data.payload, l,
&from->compress_buffer, &rsize,
0);

31
src/libsystemd/sd-journal/journal-file.h
View File

@ -11,6 +11,7 @@
#include "sd-event.h"
#include "sd-id128.h"
#include "compress.h"
#include "hashmap.h"
#include "journal-def.h"
#include "mmap-cache.h"
@ -265,3 +266,33 @@ 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;
}
}

15
src/libsystemd/sd-journal/journal-verify.c
View File

@ -111,21 +111,24 @@ 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) {
int compression, r;
Compression c;
int r;
assert(o);
assert(src);
assert(res_hash);
compression = o->object.flags & OBJECT_COMPRESSION_MASK;
if (compression) {
c = COMPRESSION_FROM_OBJECT(o);
if (c < 0)
return -EBADMSG;
if (c != COMPRESSION_NONE) {
_cleanup_free_ void *b = NULL;
size_t b_size;
r = decompress_blob(compression, src, size, &b, &b_size, 0);
r = decompress_blob(c, src, size, &b, &b_size, 0);
if (r < 0) {
error_errno(offset, r, "%s decompression failed: %m",
object_compressed_to_string(compression));
compression_to_string(c));
return r;
}
@ -145,7 +148,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_XZ) &&
if ((o->object.flags & _OBJECT_COMPRESSED_MASK) != 0 &&
o->object.type != OBJECT_DATA) {
error(offset,
"Found compressed object of type %s that isn't of type data, which is not allowed.",

40
src/libsystemd/sd-journal/sd-journal.c
View File

@ -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;
int compression;
Compression c;
p = le64toh(o->entry.items[i].object_offset);
r = journal_file_move_to_object(f, OBJECT_DATA, p, &d);
@ -2311,24 +2311,28 @@ _public_ int sd_journal_get_data(sd_journal *j, const char *field, const void **
l = le64toh(d->object.size) - offsetof(Object, data.payload);
compression = d->object.flags & OBJECT_COMPRESSION_MASK;
if (compression) {
c = COMPRESSION_FROM_OBJECT(d);
if (c < 0)
return -EPROTONOSUPPORT;
if (c != COMPRESSION_NONE) {
#if HAVE_COMPRESSION
r = decompress_startswith(compression,
d->data.payload, l,
&f->compress_buffer,
field, field_length, '=');
r = decompress_startswith(
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",
object_compressed_to_string(compression), l, p);
compression_to_string(c), l, p);
else if (r > 0) {
size_t rsize;
r = decompress_blob(compression,
d->data.payload, l,
&f->compress_buffer, &rsize,
j->data_threshold);
r = decompress_blob(
c,
d->data.payload, l,
&f->compress_buffer, &rsize,
j->data_threshold);
if (r < 0)
return r;
@ -2366,9 +2370,9 @@ static int return_data(
const void **ret_data,
size_t *ret_size) {
size_t t;
Compression c;
uint64_t l;
int compression;
size_t t;
assert(j);
assert(f);
@ -2383,14 +2387,16 @@ static int return_data(
if ((uint64_t) t != l)
return -E2BIG;
compression = o->object.flags & OBJECT_COMPRESSION_MASK;
if (compression) {
c = COMPRESSION_FROM_OBJECT(o);
if (c < 0)
return -EPROTONOSUPPORT;
if (c != COMPRESSION_NONE) {
#if HAVE_COMPRESSION
size_t rsize;
int r;
r = decompress_blob(
compression,
c,
o->data.payload, l,
&f->compress_buffer, &rsize,
j->data_threshold);

10
src/test/meson.build
View File

@ -172,6 +172,16 @@ 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')],

0
src/libsystemd/sd-journal/test-compress-benchmark.c → src/test/test-compress-benchmark.c
View File

18
src/libsystemd/sd-journal/test-compress.c → src/test/test-compress.c
View File

@ -293,10 +293,10 @@ int main(int argc, char *argv[]) {
random_bytes(data + 7, sizeof(data) - 7);
#if HAVE_XZ
test_compress_decompress(OBJECT_COMPRESSED_XZ, "XZ",
test_compress_decompress(COMPRESSION_XZ, "XZ",
compress_blob_xz, decompress_blob_xz,
text, sizeof(text), false);
test_compress_decompress(OBJECT_COMPRESSED_XZ, "XZ",
test_compress_decompress(COMPRESSION_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(OBJECT_COMPRESSED_XZ, "XZ", "xzcat",
test_compress_stream(COMPRESSION_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(OBJECT_COMPRESSED_LZ4, "LZ4",
test_compress_decompress(COMPRESSION_LZ4, "LZ4",
compress_blob_lz4, decompress_blob_lz4,
text, sizeof(text), false);
test_compress_decompress(OBJECT_COMPRESSED_LZ4, "LZ4",
test_compress_decompress(COMPRESSION_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(OBJECT_COMPRESSED_LZ4, "LZ4", "lz4cat",
test_compress_stream(COMPRESSION_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(OBJECT_COMPRESSED_ZSTD, "ZSTD",
test_compress_decompress(COMPRESSION_ZSTD, "ZSTD",
compress_blob_zstd, decompress_blob_zstd,
text, sizeof(text), false);
test_compress_decompress(OBJECT_COMPRESSED_ZSTD, "ZSTD",
test_compress_decompress(COMPRESSION_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(OBJECT_COMPRESSED_ZSTD, "ZSTD", "zstdcat",
test_compress_stream(COMPRESSION_ZSTD, "ZSTD", "zstdcat",
compress_stream_zstd, decompress_stream_zstd, srcfile);
test_decompress_startswith_short("ZSTD", compress_blob_zstd, decompress_startswith_zstd);

3
src/test/test-tables.c
View File

@ -122,8 +122,7 @@ 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_sparse(object_compressed, OBJECT_COMPRESSED);
test_table(compression, COMPRESSION);
assert_cc(sizeof(sd_device_action_t) == sizeof(int64_t));