mirror of
https://github.com/systemd/systemd
synced 2024-10-01 13:55:20 +00:00
Merge pull request #30639 from mrc0mmand/more-cocci-shenanigans
Another batch of Coccinelle tweaks
This commit is contained in:
Yu Watanabe
GitHub
commit
51dfa75c6e
|
|
@ -1,231 +0,0 @@
|
|||
/* SPDX-License-Identifier: LGPL-2.1-or-later */
|
||||
/*
|
||||
* Collected macros from our systemd codebase to make the cocci semantic
|
||||
* parser happy. Inspired by the original cocci macros file
|
||||
* /usr/lib64/coccinelle/standard.h (including the YACFE_* symbols)
|
||||
*/
|
||||
|
||||
// General
|
||||
#define PTR_TO_PID(x)
|
||||
|
||||
// src/basic/macro.h
|
||||
#define _printf_(a, b) __attribute__((__format__(printf, a, b)))
|
||||
#define _alloc_(...) __attribute__((__alloc_size__(__VA_ARGS__)))
|
||||
#define _sentinel_ __attribute__((__sentinel__))
|
||||
#define _section_(x) __attribute__((__section__(x)))
|
||||
#define _used_ __attribute__((__used__))
|
||||
#define _unused_ __attribute__((__unused__))
|
||||
#define _destructor_ __attribute__((__destructor__))
|
||||
#define _pure_ __attribute__((__pure__))
|
||||
#define _const_ __attribute__((__const__))
|
||||
#define _deprecated_ __attribute__((__deprecated__))
|
||||
#define _packed_ __attribute__((__packed__))
|
||||
#define _malloc_ __attribute__((__malloc__))
|
||||
#define _weak_ __attribute__((__weak__))
|
||||
#define _likely_(x) (__builtin_expect(!!(x), 1))
|
||||
#define _unlikely_(x) (__builtin_expect(!!(x), 0))
|
||||
#define _public_ __attribute__((__visibility__("default")))
|
||||
#define _hidden_ __attribute__((__visibility__("hidden")))
|
||||
#define _weakref_(x) __attribute__((__weakref__(#x)))
|
||||
#define _align_(x) __attribute__((__aligned__(x)))
|
||||
#define _alignas_(x) __attribute__((__aligned__(__alignof(x))))
|
||||
#define _alignptr_ __attribute__((__aligned__(sizeof(void*))))
|
||||
#define _cleanup_(x) __attribute__((__cleanup__(x)))
|
||||
#define _fallthrough_
|
||||
#define _noreturn_ __attribute__((__noreturn__))
|
||||
#define thread_local __thread
|
||||
|
||||
#define ELEMENTSOF(x) \
|
||||
(__builtin_choose_expr( \
|
||||
!__builtin_types_compatible_p(typeof(x), typeof(&*(x))), \
|
||||
sizeof(x)/sizeof((x)[0]), \
|
||||
VOID_0))
|
||||
|
||||
// src/basic/umask-util.h
|
||||
#define _cleanup_umask_
|
||||
#define WITH_UMASK(mask) \
|
||||
for (_cleanup_umask_ mode_t _saved_umask_ = umask(mask) | S_IFMT; \
|
||||
FLAGS_SET(_saved_umask_, S_IFMT); \
|
||||
_saved_umask_ &= 0777)
|
||||
|
||||
// src/basic/hashmap.h
|
||||
#define _IDX_ITERATOR_FIRST (UINT_MAX - 1)
|
||||
#define HASHMAP_FOREACH(e, h) YACFE_ITERATOR
|
||||
#define ORDERED_HASHMAP_FOREACH(e, h) YACFE_ITERATOR
|
||||
#define HASHMAP_FOREACH_KEY(e, k, h) YACFE_ITERATOR
|
||||
#define ORDERED_HASHMAP_FOREACH_KEY(e, k, h) YACFE_ITERATOR
|
||||
|
||||
// src/basic/list.h
|
||||
#define LIST_HEAD(t,name) \
|
||||
t *name
|
||||
#define LIST_FIELDS(t,name) \
|
||||
t *name##_next, *name##_prev
|
||||
#define LIST_HEAD_INIT(head) \
|
||||
do { \
|
||||
(head) = NULL; \
|
||||
} while (false)
|
||||
#define LIST_INIT(name,item) \
|
||||
do { \
|
||||
typeof(*(item)) *_item = (item); \
|
||||
assert(_item); \
|
||||
_item->name##_prev = _item->name##_next = NULL; \
|
||||
} while (false)
|
||||
#define LIST_PREPEND(name,head,item) \
|
||||
do { \
|
||||
typeof(*(head)) **_head = &(head), *_item = (item); \
|
||||
assert(_item); \
|
||||
if ((_item->name##_next = *_head)) \
|
||||
_item->name##_next->name##_prev = _item; \
|
||||
_item->name##_prev = NULL; \
|
||||
*_head = _item; \
|
||||
} while (false)
|
||||
#define LIST_APPEND(name,head,item) \
|
||||
do { \
|
||||
typeof(*(head)) **_hhead = &(head), *_tail; \
|
||||
LIST_FIND_TAIL(name, *_hhead, _tail); \
|
||||
LIST_INSERT_AFTER(name, *_hhead, _tail, item); \
|
||||
} while (false)
|
||||
#define LIST_REMOVE(name,head,item) \
|
||||
do { \
|
||||
typeof(*(head)) **_head = &(head), *_item = (item); \
|
||||
assert(_item); \
|
||||
if (_item->name##_next) \
|
||||
_item->name##_next->name##_prev = _item->name##_prev; \
|
||||
if (_item->name##_prev) \
|
||||
_item->name##_prev->name##_next = _item->name##_next; \
|
||||
else { \
|
||||
assert(*_head == _item); \
|
||||
*_head = _item->name##_next; \
|
||||
} \
|
||||
_item->name##_next = _item->name##_prev = NULL; \
|
||||
} while (false)
|
||||
#define LIST_FIND_HEAD(name,item,head) \
|
||||
do { \
|
||||
typeof(*(item)) *_item = (item); \
|
||||
if (!_item) \
|
||||
(head) = NULL; \
|
||||
else { \
|
||||
while (_item->name##_prev) \
|
||||
_item = _item->name##_prev; \
|
||||
(head) = _item; \
|
||||
} \
|
||||
} while (false)
|
||||
#define LIST_FIND_TAIL(name,item,tail) \
|
||||
do { \
|
||||
typeof(*(item)) *_item = (item); \
|
||||
if (!_item) \
|
||||
(tail) = NULL; \
|
||||
else { \
|
||||
while (_item->name##_next) \
|
||||
_item = _item->name##_next; \
|
||||
(tail) = _item; \
|
||||
} \
|
||||
} while (false)
|
||||
#define LIST_INSERT_AFTER(name,head,a,b) \
|
||||
do { \
|
||||
typeof(*(head)) **_head = &(head), *_a = (a), *_b = (b); \
|
||||
assert(_b); \
|
||||
if (!_a) { \
|
||||
if ((_b->name##_next = *_head)) \
|
||||
_b->name##_next->name##_prev = _b; \
|
||||
_b->name##_prev = NULL; \
|
||||
*_head = _b; \
|
||||
} else { \
|
||||
if ((_b->name##_next = _a->name##_next)) \
|
||||
_b->name##_next->name##_prev = _b; \
|
||||
_b->name##_prev = _a; \
|
||||
_a->name##_next = _b; \
|
||||
} \
|
||||
} while (false)
|
||||
#define LIST_INSERT_BEFORE(name,head,a,b) \
|
||||
do { \
|
||||
typeof(*(head)) **_head = &(head), *_a = (a), *_b = (b); \
|
||||
assert(_b); \
|
||||
if (!_a) { \
|
||||
if (!*_head) { \
|
||||
_b->name##_next = NULL; \
|
||||
_b->name##_prev = NULL; \
|
||||
*_head = _b; \
|
||||
} else { \
|
||||
typeof(*(head)) *_tail = (head); \
|
||||
while (_tail->name##_next) \
|
||||
_tail = _tail->name##_next; \
|
||||
_b->name##_next = NULL; \
|
||||
_b->name##_prev = _tail; \
|
||||
_tail->name##_next = _b; \
|
||||
} \
|
||||
} else { \
|
||||
if ((_b->name##_prev = _a->name##_prev)) \
|
||||
_b->name##_prev->name##_next = _b; \
|
||||
else \
|
||||
*_head = _b; \
|
||||
_b->name##_next = _a; \
|
||||
_a->name##_prev = _b; \
|
||||
} \
|
||||
} while (false)
|
||||
|
||||
#define LIST_JUST_US(name,item) \
|
||||
(!(item)->name##_prev && !(item)->name##_next)
|
||||
#define LIST_FOREACH(name,i,head) \
|
||||
for ((i) = (head); (i); (i) = (i)->name##_next)
|
||||
#define LIST_FOREACH_SAFE(name,i,n,head) \
|
||||
for ((i) = (head); (i) && (((n) = (i)->name##_next), 1); (i) = (n))
|
||||
#define LIST_FOREACH_BEFORE(name,i,p) \
|
||||
for ((i) = (p)->name##_prev; (i); (i) = (i)->name##_prev)
|
||||
#define LIST_FOREACH_AFTER(name,i,p) \
|
||||
for ((i) = (p)->name##_next; (i); (i) = (i)->name##_next)
|
||||
#define LIST_FOREACH_OTHERS(name,i,p) \
|
||||
for (({ \
|
||||
(i) = (p); \
|
||||
while ((i) && (i)->name##_prev) \
|
||||
(i) = (i)->name##_prev; \
|
||||
if ((i) == (p)) \
|
||||
(i) = (p)->name##_next; \
|
||||
}); \
|
||||
(i); \
|
||||
(i) = (i)->name##_next == (p) ? (p)->name##_next : (i)->name##_next)
|
||||
#define LIST_LOOP_BUT_ONE(name,i,head,p) \
|
||||
for ((i) = (p)->name##_next ? (p)->name##_next : (head); \
|
||||
(i) != (p); \
|
||||
(i) = (i)->name##_next ? (i)->name##_next : (head))
|
||||
|
||||
#define LIST_JOIN(name,a,b) \
|
||||
do { \
|
||||
assert(b); \
|
||||
if (!(a)) \
|
||||
(a) = (b); \
|
||||
else { \
|
||||
typeof(*(a)) *_head = (b), *_tail; \
|
||||
LIST_FIND_TAIL(name, (a), _tail); \
|
||||
_tail->name##_next = _head; \
|
||||
_head->name##_prev = _tail; \
|
||||
} \
|
||||
(b) = NULL; \
|
||||
} while (false)
|
||||
|
||||
// src/basic/strv.h
|
||||
#define STRV_FOREACH(s, l) YACFE_ITERATOR
|
||||
#define STRV_FOREACH_BACKWARDS(s, l) YACFE_ITERATOR
|
||||
#define STRV_FOREACH_PAIR(x, y, l) YACFE_ITERATOR
|
||||
|
||||
// src/basic/socket-util.h
|
||||
#define CMSG_BUFFER_TYPE(size) \
|
||||
union { \
|
||||
struct cmsghdr cmsghdr; \
|
||||
uint8_t buf[size]; \
|
||||
uint8_t align_check[(size) >= CMSG_SPACE(0) && \
|
||||
(size) == CMSG_ALIGN(size) ? 1 : -1]; \
|
||||
}
|
||||
|
||||
// src/libsystemd/sd-device/device-util.h
|
||||
#define FOREACH_DEVICE_PROPERTY(device, key, value) YACFE_ITERATOR
|
||||
#define FOREACH_DEVICE_TAG(device, tag) YACFE_ITERATOR
|
||||
#define FOREACH_DEVICE_CURRENT_TAG(device, tag) YACFE_ITERATOR
|
||||
#define FOREACH_DEVICE_SYSATTR(device, attr) YACFE_ITERATOR
|
||||
#define FOREACH_DEVICE_DEVLINK(device, devlink) YACFE_ITERATOR
|
||||
#define FOREACH_DEVICE(enumerator, device) YACFE_ITERATOR
|
||||
#define FOREACH_SUBSYSTEM(enumerator, device) YACFE_ITERATOR
|
||||
|
||||
// src/basic/dirent-util.h
|
||||
#define FOREACH_DIRENT(de, d, on_error) YACFE_ITERATOR
|
||||
#define FOREACH_DIRENT_ALL(de, d, on_error) YACFE_ITERATOR
|
||||
80
coccinelle/parsing_hacks.h
Normal file
80
coccinelle/parsing_hacks.h
Normal file
|
|
@ -0,0 +1,80 @@
|
|||
/* SPDX-License-Identifier: LGPL-2.1-or-later */
|
||||
|
||||
/* FIXME
|
||||
* - issues with parsing stuff like
|
||||
* * int foo[ELEMENTSOF(bar)] = {};
|
||||
* * validchars = UPPERCASE_LETTERS DIGITS;
|
||||
* * multiline compound literals (some instances)
|
||||
* * compound literals in function calls (some instances)
|
||||
* * keywords in macro invocations like FOREACH_DIRENT_ALL(de, d, return -errno)
|
||||
* (also, see FIXME in the TEST stuff below)
|
||||
*/
|
||||
|
||||
/* This file contains parsing hacks for Coccinelle (spatch), to make it happy with some of our more complex
|
||||
* macros - it is intended to be used with the --macro-file-builtins option for spatch.
|
||||
*
|
||||
* Coccinelle's macro support is somewhat limited and the parser trips over some of our more complex macros.
|
||||
* In most cases this doesn't really matter, as the parsing errors are silently ignored, but there are
|
||||
* special cases in which the parser incorrectly infers information that then causes issues in valid code
|
||||
* later down the line.
|
||||
*
|
||||
* Inspired by a similarly named file [0] from the Coccinelle sources, and the original bultin macros [1].
|
||||
*
|
||||
* [0] https://github.com/coccinelle/coccinelle/blob/master/parsing_c/parsing_hacks.ml
|
||||
* [1] https://github.com/coccinelle/coccinelle/blob/master/standard.h
|
||||
*
|
||||
*/
|
||||
|
||||
/* Coccinelle really doesn't like our way of registering unit test cases, and incorrectly assumes that "id"
|
||||
* from TEST(id) is the actual function identifier. This then causes name conflicts, since the unit tests
|
||||
* are usually named after the functions they test.
|
||||
*
|
||||
* For example, a unit test for xsetxattr() is defined using TEST(xsetxattr), which eventually yields a
|
||||
* procedure with following declaration:
|
||||
*
|
||||
* static const void test_xsetxattr(void);
|
||||
*
|
||||
* However, Coccinelle fails to parse the chain of macros behind TEST(x) and assumes the test function is
|
||||
* named "xsetxattr", which then causes a name conflict when the actual "xsetxattr" function is called:
|
||||
*
|
||||
* (ONCE) SEMANTIC:parameter name omitted, but I continue
|
||||
* Warning: PARSING: src/test/test-xattr-util.c:57: type defaults to 'int'; ...
|
||||
* ERROR-RECOV: found sync '}' at line 127
|
||||
* Parsing pass2: try again
|
||||
* ERROR-RECOV: found sync '}' at line 127
|
||||
* Parsing pass3: try again
|
||||
* ERROR-RECOV: found sync '}' at line 127
|
||||
* Parse error
|
||||
* = File "src/test/test-xattr-util.c", line 101, column 12, charpos = 3152
|
||||
* around = 'xsetxattr',
|
||||
* whole content = r = xsetxattr(AT_FDCWD, x, "user.foo", "fullpath", SIZE_MAX, 0);
|
||||
* Badcount: 40
|
||||
*
|
||||
* The easy way out here is to just provide a simplified version of the TEST(x) macro that pinpoints the most
|
||||
* important detail - that the actual function name is prefixed with test_.
|
||||
*
|
||||
* FIXME: even with this Coccinelle still fails to process TEST(x) instances where x is a keyword, e.g.
|
||||
* TEST(float), TEST(default), ...
|
||||
*/
|
||||
#define TEST(x, ...) static void test_##x(void)
|
||||
#define TEST_RET(x, ...) static int test_##x(void)
|
||||
|
||||
/* Coccinelle doesn't know this keyword, so just drop it, since it's not important for any of our rules. */
|
||||
#define thread_local
|
||||
|
||||
/* Coccinelle fails to get this one from the included headers, so let's just drop it. */
|
||||
#define PAM_EXTERN
|
||||
|
||||
/* Mark a couple of iterator explicitly as iterators, otherwise Coccinelle gets a bit confused. Coccinelle
|
||||
* can usually infer this information automagically, but in these specific cases it needs a bit of help. */
|
||||
#define FOREACH_ARRAY(i, array, num) YACFE_ITERATOR
|
||||
#define FOREACH_DIRENT_ALL(de, d, on_error) YACFE_ITERATOR
|
||||
#define FOREACH_STRING(x, y, ...) YACFE_ITERATOR
|
||||
#define HASHMAP_FOREACH(e, h) YACFE_ITERATOR
|
||||
#define LIST_FOREACH(name, i, head) YACFE_ITERATOR
|
||||
#define ORDERED_HASHMAP_FOREACH(e, h) YACFE_ITERATOR
|
||||
#define SET_FOREACH(e, s) YACFE_ITERATOR
|
||||
|
||||
/* Coccinelle really doesn't like multiline macros that are not in the "usual" do { ... } while(0) format, so
|
||||
* let's help it a little here by providing simplified one-line versions. */
|
||||
#define CMSG_BUFFER_TYPE(x) union { uint8_t align_check[(size) >= CMSG_SPACE(0) && (size) == CMSG_ALIGN(size) ? 1 : -1]; }
|
||||
|
|
@ -2,14 +2,6 @@
|
|||
# SPDX-License-Identifier: LGPL-2.1-or-later
|
||||
set -e
|
||||
|
||||
# FIXME:
|
||||
# - Coccinelle doesn't like our TEST() macros, which then causes name conflicts; i.e. Cocci can't process
|
||||
# that TEST(xsetxattr) yields test_xsetxattr() and uses just xsetxattr() in this case, which then conflicts
|
||||
# with the tested xsetxattr() function, leading up to the whole test case getting skipped due to
|
||||
# conflicting typedefs
|
||||
# - something keeps pulling in src/boot/efi/*.h stuff, even though it's excluded
|
||||
# - Coccinelle has issues with some of our more complex macros
|
||||
|
||||
# Exclude following paths from the Coccinelle transformations
|
||||
EXCLUDED_PATHS=(
|
||||
"src/boot/efi/*"
|
||||
|
|
@ -51,10 +43,6 @@ fi
|
|||
|
||||
mkdir -p "$CACHE_DIR"
|
||||
echo "--x-- Using Coccinelle cache directory: $CACHE_DIR"
|
||||
echo "--x--"
|
||||
echo "--x-- Note: running spatch for the first time without populated cache takes"
|
||||
echo "--x-- a _long_ time (15-30 minutes). Also, the cache is quite large"
|
||||
echo "--x-- (~15 GiB), so make sure you have enough free space."
|
||||
echo
|
||||
|
||||
for script in "${SCRIPTS[@]}"; do
|
||||
|
|
@ -67,21 +55,26 @@ for script in "${SCRIPTS[@]}"; do
|
|||
# at once one spatch process can take around 2.5 GiB of RAM, which can easily eat up all available RAM
|
||||
# when paired together with parallel
|
||||
#
|
||||
# 2) Make sure spatch can find our includes via -I <dir>, similarly as we do when compiling stuff
|
||||
# 2) Make sure spatch can find our includes via -I <dir>, similarly as we do when compiling stuff.
|
||||
# Also, include the system include path as well, since we're not kernel and we make use of the stdlib
|
||||
# (and other libraries).
|
||||
#
|
||||
# 3) Make sure to include includes from includes (--recursive-includes), but use them only to get type
|
||||
# definitions (--include-headers-for-types) - otherwise we'd start formatting them as well, which might
|
||||
# be unwanted, especially for includes we fetch verbatim from third-parties
|
||||
#
|
||||
# 4) Use cache, since generating the full AST is _very_ expensive, i.e. the uncached run takes 15 - 30
|
||||
# minutes (for one rule(!)), vs 30 - 90 seconds when the cache is populated. One major downside of the
|
||||
# cache is that it's quite big - ATTOW the cache takes around 15 GiB, but the performance boost is
|
||||
# definitely worth it
|
||||
# 4) Explicitly undefine the SD_BOOT symbol, so Coccinelle ignores includes guarded by #if SD_BOOT
|
||||
#
|
||||
# 5) Use cache, since generating the full AST is expensive. With cache we can do that only once and then
|
||||
# reuse the cached ASTs for other rules. This cuts down the time needed to run each rule by ~60%.
|
||||
parallel --halt now,fail=1 --keep-order --noswap --max-args=10 \
|
||||
spatch --cache-prefix "$CACHE_DIR" \
|
||||
-I src \
|
||||
-I /usr/include \
|
||||
--recursive-includes \
|
||||
--include-headers-for-types \
|
||||
--undefined SD_BOOT \
|
||||
--macro-file-builtins "coccinelle/parsing_hacks.h" \
|
||||
--smpl-spacing \
|
||||
--sp-file "$script" \
|
||||
"${ARGS[@]}" ::: "${FILES[@]}" \
|
||||
|
|
|
|||
|
|
@ -221,7 +221,7 @@ int get_locales(char ***ret) {
|
|||
locales = set_free(locales);
|
||||
|
||||
r = getenv_bool("SYSTEMD_LIST_NON_UTF8_LOCALES");
|
||||
if (r == -ENXIO || r == 0) {
|
||||
if (IN_SET(r, -ENXIO, 0)) {
|
||||
char **a, **b;
|
||||
|
||||
/* Filter out non-UTF-8 locales, because it's 2019, by default */
|
||||
|
|
|
|||
|
|
@ -1018,7 +1018,7 @@ static int remove_loader_variables(void) {
|
|||
EFI_LOADER_VARIABLE(LoaderEntryDefault),
|
||||
EFI_LOADER_VARIABLE(LoaderEntryLastBooted),
|
||||
EFI_LOADER_VARIABLE(LoaderEntryOneShot),
|
||||
EFI_LOADER_VARIABLE(LoaderSystemToken)){
|
||||
EFI_LOADER_VARIABLE(LoaderSystemToken)) {
|
||||
|
||||
int q;
|
||||
|
||||
|
|
|
|||
|
|
@ -348,7 +348,7 @@ static int parse_package_metadata(const char *name, JsonVariant *id_json, Elf *e
|
|||
|
||||
/* Package metadata is in PT_NOTE headers. */
|
||||
program_header = sym_gelf_getphdr(elf, i, &mem);
|
||||
if (!program_header || (program_header->p_type != PT_NOTE && program_header->p_type != PT_INTERP))
|
||||
if (!program_header || !IN_SET(program_header->p_type, PT_NOTE, PT_INTERP))
|
||||
continue;
|
||||
|
||||
if (program_header->p_type == PT_INTERP) {
|
||||
|
|
|
|||
|
|
@ -665,7 +665,7 @@ int pkcs11_token_find_private_key(
|
|||
optional_attributes[1].ulValueLen = sizeof(derive_value);
|
||||
|
||||
rv = m->C_GetAttributeValue(session, candidate, optional_attributes, ELEMENTSOF(optional_attributes));
|
||||
if (rv != CKR_OK && rv != CKR_ATTRIBUTE_TYPE_INVALID)
|
||||
if (!IN_SET(rv, CKR_OK, CKR_ATTRIBUTE_TYPE_INVALID))
|
||||
return log_error_errno(SYNTHETIC_ERRNO(EIO),
|
||||
"Failed to get attributes of a selected private key: %s", sym_p11_kit_strerror(rv));
|
||||
|
||||
|
|
@ -737,7 +737,7 @@ int pkcs11_token_find_related_object(
|
|||
CK_RV rv;
|
||||
|
||||
rv = m->C_GetAttributeValue(session, prototype, attributes, ELEMENTSOF(attributes));
|
||||
if (rv != CKR_OK && rv != CKR_ATTRIBUTE_TYPE_INVALID)
|
||||
if (!IN_SET(rv, CKR_OK, CKR_ATTRIBUTE_TYPE_INVALID))
|
||||
return log_debug_errno(SYNTHETIC_ERRNO(EIO), "Failed to retrieve length of attributes: %s", sym_p11_kit_strerror(rv));
|
||||
|
||||
if (attributes[0].ulValueLen != CK_UNAVAILABLE_INFORMATION) {
|
||||
|
|
@ -812,7 +812,7 @@ static int ecc_convert_to_compressed(
|
|||
int r;
|
||||
|
||||
rv = m->C_GetAttributeValue(session, object, &ec_params_attr, 1);
|
||||
if (rv != CKR_OK && rv != CKR_ATTRIBUTE_TYPE_INVALID)
|
||||
if (!IN_SET(rv, CKR_OK, CKR_ATTRIBUTE_TYPE_INVALID))
|
||||
return log_error_errno(SYNTHETIC_ERRNO(EIO),
|
||||
"Failed to retrieve length of CKA_EC_PARAMS: %s", sym_p11_kit_strerror(rv));
|
||||
|
||||
|
|
@ -834,7 +834,7 @@ static int ecc_convert_to_compressed(
|
|||
|
||||
ec_params_attr.ulValueLen = 0;
|
||||
rv = m->C_GetAttributeValue(session, public_key, &ec_params_attr, 1);
|
||||
if (rv != CKR_OK && rv != CKR_ATTRIBUTE_TYPE_INVALID)
|
||||
if (!IN_SET(rv, CKR_OK, CKR_ATTRIBUTE_TYPE_INVALID))
|
||||
return log_error_errno(SYNTHETIC_ERRNO(EIO),
|
||||
"Failed to retrieve length of CKA_EC_PARAMS: %s", sym_p11_kit_strerror(rv));
|
||||
|
||||
|
|
|
|||
|
|
@ -7569,7 +7569,7 @@ int tpm2_util_pbkdf2_hmac_sha256(const void *pass,
|
|||
size_t saltlen,
|
||||
uint8_t ret_key[static SHA256_DIGEST_SIZE]) {
|
||||
|
||||
uint8_t _cleanup_(erase_and_freep) *buffer = NULL;
|
||||
_cleanup_(erase_and_freep) uint8_t *buffer = NULL;
|
||||
uint8_t u[SHA256_DIGEST_SIZE];
|
||||
|
||||
/* To keep this simple, since derived KeyLen (dkLen in docs)
|
||||
|
|
|
|||
|
|
@ -328,23 +328,23 @@ TEST(mount_option_supported) {
|
|||
|
||||
r = mount_option_supported("tmpfs", "size", "64M");
|
||||
log_info("tmpfs supports size=64M: %s (%i)", r < 0 ? "don't know" : yes_no(r), r);
|
||||
assert_se(r > 0 || r == -EAGAIN || (r < 0 && ERRNO_IS_PRIVILEGE(r)));
|
||||
assert_se(r > 0 || r == -EAGAIN || ERRNO_IS_NEG_PRIVILEGE(r));
|
||||
|
||||
r = mount_option_supported("ext4", "discard", NULL);
|
||||
log_info("ext4 supports discard: %s (%i)", r < 0 ? "don't know" : yes_no(r), r);
|
||||
assert_se(r > 0 || r == -EAGAIN || (r < 0 && ERRNO_IS_PRIVILEGE(r)));
|
||||
assert_se(r > 0 || r == -EAGAIN || ERRNO_IS_NEG_PRIVILEGE(r));
|
||||
|
||||
r = mount_option_supported("tmpfs", "idontexist", "64M");
|
||||
log_info("tmpfs supports idontexist: %s (%i)", r < 0 ? "don't know" : yes_no(r), r);
|
||||
assert_se(r == 0 || r == -EAGAIN || (r < 0 && ERRNO_IS_PRIVILEGE(r)));
|
||||
assert_se(IN_SET(r, 0, -EAGAIN) || ERRNO_IS_NEG_PRIVILEGE(r));
|
||||
|
||||
r = mount_option_supported("tmpfs", "ialsodontexist", NULL);
|
||||
log_info("tmpfs supports ialsodontexist: %s (%i)", r < 0 ? "don't know" : yes_no(r), r);
|
||||
assert_se(r == 0 || r == -EAGAIN || (r < 0 && ERRNO_IS_PRIVILEGE(r)));
|
||||
assert_se(IN_SET(r, 0, -EAGAIN) || ERRNO_IS_NEG_PRIVILEGE(r));
|
||||
|
||||
r = mount_option_supported("proc", "hidepid", "1");
|
||||
log_info("proc supports hidepid=1: %s (%i)", r < 0 ? "don't know" : yes_no(r), r);
|
||||
assert_se(r >= 0 || r == -EAGAIN || (r < 0 && ERRNO_IS_PRIVILEGE(r)));
|
||||
assert_se(r >= 0 || r == -EAGAIN || ERRNO_IS_NEG_PRIVILEGE(r));
|
||||
}
|
||||
|
||||
TEST(fstype_can_discard) {
|
||||
|
|
|
|||
|
|
@ -141,7 +141,7 @@ TEST(set_ensure_allocated) {
|
|||
assert_se(set_ensure_allocated(&m, &string_hash_ops) == 1);
|
||||
assert_se(set_ensure_allocated(&m, &string_hash_ops) == 0);
|
||||
assert_se(set_ensure_allocated(&m, NULL) == 0);
|
||||
assert_se(set_size(m) == 0);
|
||||
assert_se(set_isempty(m));
|
||||
}
|
||||
|
||||
TEST(set_copy) {
|
||||
|
|
|
|||
|
|
@ -1089,9 +1089,9 @@ TEST(map_clock_usec) {
|
|||
assert_se(nowr < USEC_INFINITY - USEC_PER_DAY*7); /* overflow check */
|
||||
x = nowr + USEC_PER_DAY*7; /* 1 week from now */
|
||||
y = map_clock_usec(x, CLOCK_REALTIME, CLOCK_MONOTONIC);
|
||||
assert_se(y > 0 && y < USEC_INFINITY);
|
||||
assert_se(timestamp_is_set(y));
|
||||
z = map_clock_usec(y, CLOCK_MONOTONIC, CLOCK_REALTIME);
|
||||
assert_se(z > 0 && z < USEC_INFINITY);
|
||||
assert_se(timestamp_is_set(z));
|
||||
assert_se((z > x ? z - x : x - z) < USEC_PER_HOUR);
|
||||
|
||||
assert_se(nowr > USEC_PER_DAY * 7); /* underflow check */
|
||||
|
|
@ -1100,7 +1100,7 @@ TEST(map_clock_usec) {
|
|||
if (y != 0) { /* might underflow if machine is not up long enough for the monotonic clock to be beyond 1w */
|
||||
assert_se(y < USEC_INFINITY);
|
||||
z = map_clock_usec(y, CLOCK_MONOTONIC, CLOCK_REALTIME);
|
||||
assert_se(z > 0 && z < USEC_INFINITY);
|
||||
assert_se(timestamp_is_set(z));
|
||||
assert_se((z > x ? z - x : x - z) < USEC_PER_HOUR);
|
||||
}
|
||||
}
|
||||
|
|
|
|||
|
|
@ -45,7 +45,7 @@ TEST(getxattr_at_malloc) {
|
|||
fd = open("/", O_RDONLY|O_DIRECTORY|O_CLOEXEC|O_NOCTTY);
|
||||
assert_se(fd >= 0);
|
||||
r = getxattr_at_malloc(fd, "usr", "user.idontexist", 0, &value);
|
||||
assert_se(r < 0 && ERRNO_IS_XATTR_ABSENT(r));
|
||||
assert_se(ERRNO_IS_NEG_XATTR_ABSENT(r));
|
||||
|
||||
safe_close(fd);
|
||||
fd = open(x, O_PATH|O_CLOEXEC);
|
||||
|
|
@ -99,7 +99,7 @@ TEST(xsetxattr) {
|
|||
|
||||
/* by full path */
|
||||
r = xsetxattr(AT_FDCWD, x, "user.foo", "fullpath", SIZE_MAX, 0);
|
||||
if (r < 0 && ERRNO_IS_NOT_SUPPORTED(r))
|
||||
if (ERRNO_IS_NEG_NOT_SUPPORTED(r))
|
||||
return (void) log_tests_skipped_errno(r, "no xattrs supported on /var/tmp");
|
||||
assert_se(r >= 0);
|
||||
verify_xattr(dfd, "fullpath");
|
||||
|
|
|
|||
Loading…
Reference in a new issue