tree-wide: Fix declaration/definition parameter name mismatches

src/basic/cgroup-util.c

@@ -1628,18 +1628,18 @@ int cg_mask_to_string(CGroupMask mask, char **ret) {
         return 0;
 }
 
-int cg_mask_from_string(const char *value, CGroupMask *ret) {
+int cg_mask_from_string(const char *s, CGroupMask *ret) {
         CGroupMask m = 0;
 
         assert(ret);
-        assert(value);
+        assert(s);
 
         for (;;) {
                 _cleanup_free_ char *n = NULL;
                 CGroupController v;
                 int r;
 
-                r = extract_first_word(&value, &n, NULL, 0);
+                r = extract_first_word(&s, &n, NULL, 0);
                 if (r < 0)
                         return r;
                 if (r == 0)

src/basic/cleanup-util.h

@@ -27,31 +27,33 @@ typedef void* (*mfree_func_t)(void *p);
                 0;                               \
         })
 
-#define _DEFINE_TRIVIAL_REF_FUNC(type, name, scope)             \
-        scope type *name##_ref(type *p) {                       \
-                if (!p)                                         \
-                        return NULL;                            \
-                                                                \
-                /* For type check. */                           \
-                unsigned *q = &p->n_ref;                        \
-                assert(*q > 0);                                 \
-                assert_se(*q < UINT_MAX);                       \
-                                                                \
-                (*q)++;                                         \
-                return p;                                       \
+#define _DEFINE_TRIVIAL_REF_FUNC(type, name, scope)                                     \
+        /* NOLINTNEXTLINE (readability-inconsistent-declaration-parameter-name) */      \
+        scope type *name##_ref(type *p) {                                               \
+                if (!p)                                                                 \
+                        return NULL;                                                    \
+                                                                                        \
+                /* For type check. */                                                   \
+                unsigned *q = &p->n_ref;                                                \
+                assert(*q > 0);                                                         \
+                assert_se(*q < UINT_MAX);                                               \
+                                                                                        \
+                (*q)++;                                                                 \
+                return p;                                                               \
         }
 
-#define _DEFINE_TRIVIAL_UNREF_FUNC(type, name, free_func, scope) \
-        scope type *name##_unref(type *p) {                      \
-                if (!p)                                          \
-                        return NULL;                             \
-                                                                 \
-                assert(p->n_ref > 0);                            \
-                p->n_ref--;                                      \
-                if (p->n_ref > 0)                                \
-                        return NULL;                             \
-                                                                 \
-                return free_func(p);                             \
+#define _DEFINE_TRIVIAL_UNREF_FUNC(type, name, free_func, scope)                        \
+        /* NOLINTNEXTLINE (readability-inconsistent-declaration-parameter-name) */      \
+        scope type *name##_unref(type *p) {                                             \
+                if (!p)                                                                 \
+                        return NULL;                                                    \
+                                                                                        \
+                assert(p->n_ref > 0);                                                   \
+                p->n_ref--;                                                             \
+                if (p->n_ref > 0)                                                       \
+                        return NULL;                                                    \
+                                                                                        \
+                return free_func(p);                                                    \
         }
 
 #define DEFINE_TRIVIAL_REF_FUNC(type, name)     \

src/basic/compress.c

@@ -1029,7 +1029,7 @@ int decompress_stream_xz(int fdf, int fdt, uint64_t max_bytes) {
 #endif
 }
 
-int decompress_stream_lz4(int in, int out, uint64_t max_bytes) {
+int decompress_stream_lz4(int fdf, int fdt, uint64_t max_bytes) {
 #if HAVE_LZ4
         size_t c;
         _cleanup_(LZ4F_freeDecompressionContextp) LZ4F_decompressionContext_t ctx = NULL;
@@ -1047,7 +1047,7 @@ int decompress_stream_lz4(int in, int out, uint64_t max_bytes) {
         if (sym_LZ4F_isError(c))
                 return -ENOMEM;
 
-        if (fstat(in, &st) < 0)
+        if (fstat(fdf, &st) < 0)
                 return log_debug_errno(errno, "fstat() failed: %m");
 
         if (file_offset_beyond_memory_size(st.st_size))
@@ -1057,7 +1057,7 @@ int decompress_stream_lz4(int in, int out, uint64_t max_bytes) {
         if (!buf)
                 return -ENOMEM;
 
-        src = mmap(NULL, st.st_size, PROT_READ, MAP_PRIVATE, in, 0);
+        src = mmap(NULL, st.st_size, PROT_READ, MAP_PRIVATE, fdf, 0);
         if (src == MAP_FAILED)
                 return -errno;
 
@@ -1080,7 +1080,7 @@ int decompress_stream_lz4(int in, int out, uint64_t max_bytes) {
                         goto cleanup;
                 }
 
-                r = loop_write(out, buf, produced);
+                r = loop_write(fdt, buf, produced);
                 if (r < 0)
                         goto cleanup;
         }

src/basic/compress.h

@@ -13,9 +13,9 @@ typedef enum Compression {
 } Compression;
 
 const char* compression_to_string(Compression compression) _const_;
-Compression compression_from_string(const char *compression) _pure_;
+Compression compression_from_string(const char *s) _pure_;
 const char* compression_lowercase_to_string(Compression compression) _const_;
-Compression compression_lowercase_from_string(const char *compression) _pure_;
+Compression compression_lowercase_from_string(const char *s) _pure_;
 
 bool compression_supported(Compression c);
 
@@ -58,9 +58,9 @@ int compress_stream_xz(int fdf, int fdt, uint64_t max_bytes, uint64_t *ret_uncom
 int compress_stream_lz4(int fdf, int fdt, uint64_t max_bytes, uint64_t *ret_uncompressed_size);
 int compress_stream_zstd(int fdf, int fdt, uint64_t max_bytes, uint64_t *ret_uncompressed_size);
 
-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);
+int decompress_stream_xz(int fdf, int fdt, uint64_t max_bytes);
+int decompress_stream_lz4(int fdf, int fdt, uint64_t max_bytes);
+int decompress_stream_zstd(int fdf, int fdt, uint64_t max_bytes);
 
 int dlopen_lz4(void);
 int dlopen_zstd(void);

src/basic/efivars.h

@@ -43,7 +43,7 @@ int efi_get_variable(const char *variable, uint32_t *attribute, void **ret_value
 int efi_get_variable_string(const char *variable, char **ret);
 int efi_get_variable_path(const char *variable, char **ret);
 int efi_set_variable(const char *variable, const void *value, size_t size) _nonnull_if_nonzero_(2, 3);
-int efi_set_variable_string(const char *variable, const char *p);
+int efi_set_variable_string(const char *variable, const char *value);
 
 bool is_efi_boot(void);
 bool is_efi_secure_boot(void);

src/basic/env-util.c

@@ -605,10 +605,10 @@ int strv_env_get_merged(char **l, char ***ret) {
         return 0;
 }
 
-char** strv_env_clean_with_callback(char **e, void (*invalid_callback)(const char *p, void *userdata), void *userdata) {
+char** strv_env_clean_with_callback(char **l, void (*invalid_callback)(const char *p, void *userdata), void *userdata) {
         int k = 0;
 
-        STRV_FOREACH(p, e) {
+        STRV_FOREACH(p, l) {
                 size_t n;
                 bool duplicate = false;
 
@@ -631,13 +631,13 @@ char** strv_env_clean_with_callback(char **e, void (*invalid_callback)(const cha
                         continue;
                 }
 
-                e[k++] = *p;
+                l[k++] = *p;
         }
 
-        if (e)
-                e[k] = NULL;
+        if (l)
+                l[k] = NULL;
 
-        return e;
+        return l;
 }
 
 static int strv_extend_with_length(char ***l, const char *s, size_t n) {

src/basic/fd-util.h

@@ -79,7 +79,7 @@ void close_many_and_free(int *fds, size_t n_fds);
 
 int fclose_nointr(FILE *f);
 FILE* safe_fclose(FILE *f);
-DIR* safe_closedir(DIR *f);
+DIR* safe_closedir(DIR *d);
 
 static inline void closep(int *fd) {
         safe_close(*fd);

src/basic/fs-util.c

@@ -528,7 +528,7 @@ int mknodat_atomic(int atfd, const char *path, mode_t mode, dev_t dev) {
         return 0;
 }
 
-int mkfifoat_atomic(int atfd, const char *path, mode_t mode) {
+int mkfifoat_atomic(int dir_fd, const char *path, mode_t mode) {
         _cleanup_free_ char *t = NULL;
         int r;
 
@@ -539,12 +539,12 @@ int mkfifoat_atomic(int atfd, const char *path, mode_t mode) {
         if (r < 0)
                 return r;
 
-        if (mkfifoat(atfd, t, mode) < 0)
+        if (mkfifoat(dir_fd, t, mode) < 0)
                 return -errno;
 
-        r = RET_NERRNO(renameat(atfd, t, atfd, path));
+        r = RET_NERRNO(renameat(dir_fd, t, dir_fd, path));
         if (r < 0) {
-                (void) unlinkat(atfd, t, 0);
+                (void) unlinkat(dir_fd, t, 0);
                 return r;
         }
 

src/basic/hash-funcs.c

@@ -31,10 +31,10 @@ DEFINE_HASH_OPS_FULL(
                 char, string_hash_func, string_compare_func, free,
                 char*, strv_free);
 
-void path_hash_func(const char *q, struct siphash *state) {
+void path_hash_func(const char *p, struct siphash *state) {
         bool add_slash = false;
 
-        assert(q);
+        assert(p);
         assert(state);
 
         /* Calculates a hash for a path in a way this duplicate inner slashes don't make a differences, and also
@@ -43,14 +43,14 @@ void path_hash_func(const char *q, struct siphash *state) {
          * which begin in a slash or not) will hash differently though. */
 
         /* if path is absolute, add one "/" to the hash. */
-        if (path_is_absolute(q))
+        if (path_is_absolute(p))
                 siphash24_compress_byte('/', state);
 
         for (;;) {
                 const char *e;
                 int r;
 
-                r = path_find_first_component(&q, true, &e);
+                r = path_find_first_component(&p, true, &e);
                 if (r == 0)
                         return;
 
@@ -59,7 +59,7 @@ void path_hash_func(const char *q, struct siphash *state) {
 
                 if (r < 0) {
                         /* if a component is invalid, then add remaining part as a string. */
-                        string_hash_func(q, state);
+                        string_hash_func(p, state);
                         return;
                 }
 

src/basic/hashmap.c

@@ -1372,7 +1372,7 @@ void* _hashmap_get(HashmapBase *h, const void *key) {
         return entry_value(h, e);
 }
 
-void* hashmap_get2(Hashmap *h, const void *key, void **key2) {
+void* hashmap_get2(Hashmap *h, const void *key, void **ret) {
         struct plain_hashmap_entry *e;
         unsigned hash, idx;
 
@@ -1385,8 +1385,8 @@ void* hashmap_get2(Hashmap *h, const void *key, void **key2) {
                 return NULL;
 
         e = plain_bucket_at(h, idx);
-        if (key2)
-                *key2 = (void*) e->b.key;
+        if (ret)
+                *ret = (void*) e->b.key;
 
         return e->value;
 }
@@ -1421,29 +1421,29 @@ void* _hashmap_remove(HashmapBase *h, const void *key) {
         return data;
 }
 
-void* hashmap_remove2(Hashmap *h, const void *key, void **rkey) {
+void* hashmap_remove2(Hashmap *h, const void *key, void **ret) {
         struct plain_hashmap_entry *e;
         unsigned hash, idx;
         void *data;
 
         if (!h) {
-                if (rkey)
-                        *rkey = NULL;
+                if (ret)
+                        *ret = NULL;
                 return NULL;
         }
 
         hash = bucket_hash(h, key);
         idx = bucket_scan(h, hash, key);
         if (idx == IDX_NIL) {
-                if (rkey)
-                        *rkey = NULL;
+                if (ret)
+                        *ret = NULL;
                 return NULL;
         }
 
         e = plain_bucket_at(h, idx);
         data = e->value;
-        if (rkey)
-                *rkey = (void*) e->b.key;
+        if (ret)
+                *ret = (void*) e->b.key;
 
         remove_entry(h, idx);
 

src/basic/hashmap.h

@@ -123,9 +123,9 @@ static inline void *ordered_hashmap_get(OrderedHashmap *h, const void *key) {
         return _hashmap_get(HASHMAP_BASE(h), key);
 }
 
-void* hashmap_get2(Hashmap *h, const void *key, void **rkey);
-static inline void *ordered_hashmap_get2(OrderedHashmap *h, const void *key, void **rkey) {
-        return hashmap_get2(PLAIN_HASHMAP(h), key, rkey);
+void* hashmap_get2(Hashmap *h, const void *key, void **ret);
+static inline void *ordered_hashmap_get2(OrderedHashmap *h, const void *key, void **ret) {
+        return hashmap_get2(PLAIN_HASHMAP(h), key, ret);
 }
 
 bool _hashmap_contains(HashmapBase *h, const void *key);
@@ -144,9 +144,9 @@ static inline void *ordered_hashmap_remove(OrderedHashmap *h, const void *key) {
         return _hashmap_remove(HASHMAP_BASE(h), key);
 }
 
-void* hashmap_remove2(Hashmap *h, const void *key, void **rkey);
-static inline void *ordered_hashmap_remove2(OrderedHashmap *h, const void *key, void **rkey) {
-        return hashmap_remove2(PLAIN_HASHMAP(h), key, rkey);
+void* hashmap_remove2(Hashmap *h, const void *key, void **ret);
+static inline void *ordered_hashmap_remove2(OrderedHashmap *h, const void *key, void **ret) {
+        return hashmap_remove2(PLAIN_HASHMAP(h), key, ret);
 }
 
 void* _hashmap_remove_value(HashmapBase *h, const void *key, void *value);

src/basic/hexdecoct.c

@@ -112,7 +112,7 @@ int unhexmem_full(
                 size_t l,
                 bool secure,
                 void **ret_data,
-                size_t *ret_len) {
+                size_t *ret_size) {
 
         _cleanup_free_ uint8_t *buf = NULL;
         size_t buf_size;
@@ -150,8 +150,8 @@ int unhexmem_full(
 
         *z = 0;
 
-        if (ret_len)
-                *ret_len = (size_t) (z - buf);
+        if (ret_size)
+                *ret_size = (size_t) (z - buf);
         if (ret_data)
                 *ret_data = TAKE_PTR(buf);
 

src/basic/hexdecoct.h

@@ -38,7 +38,7 @@ ssize_t base64_append(
                 size_t plen,
                 const void *p,
                 size_t l,
-                size_t margin,
+                size_t indent,
                 size_t width);
 int unbase64mem_full(const char *p, size_t l, bool secure, void **ret_data, size_t *ret_size) _nonnull_if_nonzero_(1, 2);
 static inline int unbase64mem(const char *p, void **ret_data, size_t *ret_size) {

src/basic/locale-util.h

@@ -27,7 +27,7 @@ typedef enum LocaleVariable {
         _VARIABLE_LC_INVALID = -EINVAL,
 } LocaleVariable;
 
-int get_locales(char ***l);
+int get_locales(char ***ret);
 bool locale_is_valid(const char *name);
 int locale_is_installed(const char *name);
 

src/basic/nulstr-util.h

@@ -34,5 +34,5 @@ static inline int strv_from_nulstr(char ***ret, const char *nulstr) {
         return 0;
 }
 
-int strv_make_nulstr(char * const *l, char **p, size_t *n);
+int strv_make_nulstr(char * const *l, char **ret, size_t *ret_size);
 int set_make_nulstr(Set *s, char **ret, size_t *ret_size);

src/basic/parse-util.c

@@ -685,10 +685,10 @@ int parse_fractional_part_u(const char **p, size_t digits, unsigned *res) {
         return 0;
 }
 
-int parse_nice(const char *p, int *ret) {
+int parse_nice(const char *s, int *ret) {
         int n, r;
 
-        r = safe_atoi(p, &n);
+        r = safe_atoi(s, &n);
         if (r < 0)
                 return r;
 

src/basic/parse-util.h

@@ -22,7 +22,7 @@ int parse_errno(const char *t);
 int parse_fd(const char *t);
 int parse_user_shell(const char *s, char **ret_sh, bool *ret_copy);
 
-int parse_capability_set(const char *s, uint64_t initial, uint64_t *capability_set);
+int parse_capability_set(const char *s, uint64_t initial, uint64_t *current);
 
 #define SAFE_ATO_REFUSE_PLUS_MINUS (1U << 30)
 #define SAFE_ATO_REFUSE_LEADING_ZERO (1U << 29)
@@ -38,7 +38,7 @@ static inline int safe_atou(const char *s, unsigned *ret_u) {
 int safe_atou_bounded(const char *s, unsigned min, unsigned max, unsigned *ret);
 
 int safe_atoi(const char *s, int *ret_i);
-int safe_atolli(const char *s, long long *ret_i);
+int safe_atolli(const char *s, long long *ret_lli);
 
 int safe_atou8_full(const char *s, unsigned base, uint8_t *ret);
 
@@ -131,9 +131,9 @@ static inline int safe_atozu(const char *s, size_t *ret_u) {
 
 int safe_atod(const char *s, double *ret_d);
 
-int parse_fractional_part_u(const char **s, size_t digits, unsigned *res);
+int parse_fractional_part_u(const char **p, size_t digits, unsigned *res);
 
-int parse_nice(const char *p, int *ret);
+int parse_nice(const char *s, int *ret);
 
 int parse_ip_port(const char *s, uint16_t *ret);
 int parse_ip_port_range(const char *s, uint16_t *low, uint16_t *high, bool allow_zero);

src/basic/pidref.h

@@ -96,7 +96,7 @@ int pidref_kill(const PidRef *pidref, int sig);
 int pidref_kill_and_sigcont(const PidRef *pidref, int sig);
 int pidref_sigqueue(const PidRef *pidref, int sig, int value);
 
-int pidref_wait(PidRef *pidref, siginfo_t *siginfo, int options);
+int pidref_wait(PidRef *pidref, siginfo_t *ret, int options);
 int pidref_wait_for_terminate(PidRef *pidref, siginfo_t *ret);
 
 static inline void pidref_done_sigkill_wait(PidRef *pidref) {

src/basic/proc-cmdline.h

@@ -19,7 +19,7 @@ int proc_cmdline_strv(char ***ret);
 
 int proc_cmdline_parse(proc_cmdline_parse_t parse, void *userdata, ProcCmdlineFlags flags);
 
-int proc_cmdline_get_key(const char *parameter, ProcCmdlineFlags flags, char **ret_value);
+int proc_cmdline_get_key(const char *key, ProcCmdlineFlags flags, char **ret_value);
 int proc_cmdline_get_bool(const char *key, ProcCmdlineFlags flags, bool *ret);
 
 int proc_cmdline_get_key_many_internal(ProcCmdlineFlags flags, ...);

src/basic/process-util.h

@@ -86,7 +86,7 @@ int kill_and_sigcont(pid_t pid, int sig);
 int pid_is_kernel_thread(pid_t pid);
 int pidref_is_kernel_thread(const PidRef *pid);
 
-int getenv_for_pid(pid_t pid, const char *field, char **_value);
+int getenv_for_pid(pid_t pid, const char *field, char **ret);
 
 int pid_is_alive(pid_t pid);
 int pidref_is_alive(const PidRef *pidref);
@@ -121,7 +121,7 @@ int opinionated_personality(unsigned long *ret);
 const char* sigchld_code_to_string(int i) _const_;
 int sigchld_code_from_string(const char *s) _pure_;
 
-int sched_policy_to_string_alloc(int i, char **s);
+int sched_policy_to_string_alloc(int i, char **ret);
 int sched_policy_from_string(const char *s);
 
 static inline pid_t PTR_TO_PID(const void *p) {

src/basic/procfs-util.h

@@ -16,4 +16,4 @@ static inline int procfs_memory_get_used(uint64_t *ret) {
         return procfs_memory_get(NULL, ret);
 }
 
-int convert_meminfo_value_to_uint64_bytes(const char *word, uint64_t *ret);
+int convert_meminfo_value_to_uint64_bytes(const char *s, uint64_t *ret);

src/basic/sha256.h

@@ -7,6 +7,6 @@
 
 int sha256_fd(int fd, uint64_t max_size, uint8_t ret[static SHA256_DIGEST_SIZE]);
 
-int parse_sha256(const char *s, uint8_t res[static SHA256_DIGEST_SIZE]);
+int parse_sha256(const char *s, uint8_t ret[static SHA256_DIGEST_SIZE]);
 
 bool sha256_is_valid(const char *s) _pure_;

src/basic/signal-util.c

@@ -89,7 +89,7 @@ int sigset_add_many_internal(sigset_t *ss, ...) {
         return r;
 }
 
-int sigprocmask_many_internal(int how, sigset_t *old, ...) {
+int sigprocmask_many_internal(int how, sigset_t *ret_old_mask, ...) {
         va_list ap;
         sigset_t ss;
         int r;
@@ -97,14 +97,14 @@ int sigprocmask_many_internal(int how, sigset_t *old, ...) {
         if (sigemptyset(&ss) < 0)
                 return -errno;
 
-        va_start(ap, old);
+        va_start(ap, ret_old_mask);
         r = sigset_add_many_ap(&ss, ap);
         va_end(ap);
 
         if (r < 0)
                 return r;
 
-        return RET_NERRNO(sigprocmask(how, &ss, old));
+        return RET_NERRNO(sigprocmask(how, &ss, ret_old_mask));
 }
 
 static const char *const static_signal_table[] = {

src/basic/signal-util.h

@@ -31,7 +31,7 @@ int sigset_add_many_internal(sigset_t *ss, ...);
 int sigprocmask_many_internal(int how, sigset_t *ret_old_mask, ...);
 #define sigprocmask_many(...) sigprocmask_many_internal(__VA_ARGS__, -1)
 
-const char* signal_to_string(int i) _const_;
+const char* signal_to_string(int signo) _const_;
 int signal_from_string(const char *s) _pure_;
 
 void nop_signal_handler(int sig);

src/basic/socket-util.h

@@ -67,7 +67,7 @@ static inline int socket_address_unlink(const SocketAddress *a) {
 bool socket_address_can_accept(const SocketAddress *a) _pure_;
 
 int socket_address_verify(const SocketAddress *a, bool strict) _pure_;
-int socket_address_print(const SocketAddress *a, char **p);
+int socket_address_print(const SocketAddress *a, char **ret);
 bool socket_address_matches_fd(const SocketAddress *a, int fd);
 
 bool socket_address_equal(const SocketAddress *a, const SocketAddress *b) _pure_;
@@ -87,7 +87,7 @@ int getsockname_pretty(int fd, char **ret);
 
 int socknameinfo_pretty(const struct sockaddr *sa, socklen_t salen, char **_ret);
 
-int netlink_family_to_string_alloc(int b, char **s);
+int netlink_family_to_string_alloc(int i, char **ret);
 int netlink_family_from_string(const char *s) _pure_;
 
 bool sockaddr_equal(const union sockaddr_union *a, const union sockaddr_union *b);
@@ -101,7 +101,7 @@ static inline int fd_increase_rxbuf(int fd, size_t n) {
         return fd_set_rcvbuf(fd, n, true);
 }
 
-int ip_tos_to_string_alloc(int i, char **s);
+int ip_tos_to_string_alloc(int i, char **ret);
 int ip_tos_from_string(const char *s);
 
 typedef enum {

src/basic/string-table.h

@@ -14,9 +14,10 @@ int string_table_lookup_to_string_fallback(const char * const *table, size_t len
 ssize_t string_table_lookup_from_string_fallback(const char * const *table, size_t len, const char *s, size_t max);
 
 /* For basic lookup tables with strictly enumerated entries */
-#define _DEFINE_STRING_TABLE_LOOKUP_TO_STRING(name, type, scope) \
-        scope const char* name##_to_string(type i) {             \
-                return string_table_lookup_to_string(name##_table, ELEMENTSOF(name##_table), i); \
+#define _DEFINE_STRING_TABLE_LOOKUP_TO_STRING(name, type, scope)                                        \
+        /* NOLINTNEXTLINE (readability-inconsistent-declaration-parameter-name) */                      \
+        scope const char* name##_to_string(type i) {                                                    \
+                return string_table_lookup_to_string(name##_table, ELEMENTSOF(name##_table), i);        \
         }
 
 #define _DEFINE_STRING_TABLE_LOOKUP_FROM_STRING(name, type, scope) \
@@ -29,8 +30,9 @@ ssize_t string_table_lookup_from_string_fallback(const char * const *table, size
                 return (type) string_table_lookup_from_string_with_boolean(name##_table, ELEMENTSOF(name##_table), s, yes); \
         }
 
-#define _DEFINE_STRING_TABLE_LOOKUP_TO_STRING_FALLBACK(name, type, max, scope) \
-        scope int name##_to_string_alloc(type i, char **ret) {                 \
+#define _DEFINE_STRING_TABLE_LOOKUP_TO_STRING_FALLBACK(name, type, max, scope)                          \
+        /* NOLINTNEXTLINE (readability-inconsistent-declaration-parameter-name) */                      \
+        scope int name##_to_string_alloc(type i, char **ret) {                                          \
                 return string_table_lookup_to_string_fallback(name##_table, ELEMENTSOF(name##_table), i, max, ret); \
         }
 

src/basic/string-util.c

@@ -144,32 +144,32 @@ char ascii_toupper(char x) {
         return x;
 }
 
-char* ascii_strlower(char *t) {
-        assert(t);
+char* ascii_strlower(char *s) {
+        assert(s);
 
-        for (char *p = t; *p; p++)
+        for (char *p = s; *p; p++)
                 *p = ascii_tolower(*p);
 
-        return t;
+        return s;
 }
 
-char* ascii_strupper(char *t) {
-        assert(t);
+char* ascii_strupper(char *s) {
+        assert(s);
 
-        for (char *p = t; *p; p++)
+        for (char *p = s; *p; p++)
                 *p = ascii_toupper(*p);
 
-        return t;
+        return s;
 }
 
-char* ascii_strlower_n(char *t, size_t n) {
+char* ascii_strlower_n(char *s, size_t n) {
         if (n <= 0)
-                return t;
+                return s;
 
         for (size_t i = 0; i < n; i++)
-                t[i] = ascii_tolower(t[i]);
+                s[i] = ascii_tolower(s[i]);
 
-        return t;
+        return s;
 }
 
 int ascii_strcasecmp_n(const char *a, const char *b, size_t n) {

src/basic/strv.c

@@ -159,17 +159,17 @@ void strv_free_many(char ***strvs, size_t n) {
         free(strvs);
 }
 
-char** strv_copy_n(char * const *l, size_t m) {
+char** strv_copy_n(char * const *l, size_t n) {
         _cleanup_strv_free_ char **result = NULL;
         char **k;
 
-        result = new(char*, MIN(strv_length(l), m) + 1);
+        result = new(char*, MIN(strv_length(l), n) + 1);
         if (!result)
                 return NULL;
 
         k = result;
         STRV_FOREACH(i, l) {
-                if (m == 0)
+                if (n == 0)
                         break;
 
                 *k = strdup(*i);
@@ -177,8 +177,8 @@ char** strv_copy_n(char * const *l, size_t m) {
                         return NULL;
                 k++;
 
-                if (m != SIZE_MAX)
-                        m--;
+                if (n != SIZE_MAX)
+                        n--;
         }
 
         *k = NULL;

src/basic/sysctl-util.h

@@ -6,7 +6,7 @@
 #include "stdio-util.h"
 
 char* sysctl_normalize(char *s);
-int sysctl_read(const char *property, char **value);
+int sysctl_read(const char *property, char **ret);
 int sysctl_write_full(const char *property, const char *value, Hashmap **shadow);
 int sysctl_writef(const char *property, const char *format, ...) _printf_(2, 3);
 static inline int sysctl_write(const char *property, const char *value) {

src/basic/syslog-util.h

@@ -3,11 +3,11 @@
 
 #include "basic-forward.h"
 
-int log_facility_unshifted_to_string_alloc(int i, char **s);
+int log_facility_unshifted_to_string_alloc(int i, char **ret);
 int log_facility_unshifted_from_string(const char *s);
 bool log_facility_unshifted_is_valid(int faciliy);
 
-int log_level_to_string_alloc(int i, char **s);
+int log_level_to_string_alloc(int i, char **ret);
 int log_level_from_string(const char *s);
 bool log_level_is_valid(int level);
 

src/basic/terminal-util.h

@@ -86,16 +86,16 @@ int proc_cmdline_tty_size(const char *tty, unsigned *ret_rows, unsigned *ret_col
 int chvt(int vt);
 
 int read_one_char(FILE *f, char *ret, usec_t timeout, bool echo, bool *need_nl);
-int ask_char(char *ret, const char *replies, const char *text, ...) _printf_(3, 4);
+int ask_char(char *ret, const char *replies, const char *fmt, ...) _printf_(3, 4);
 
 typedef int (*GetCompletionsCallback)(const char *key, char ***ret_list, void *userdata);
-int ask_string_full(char **ret, GetCompletionsCallback cb, void *userdata, const char *text, ...) _printf_(4, 5);
+int ask_string_full(char **ret, GetCompletionsCallback get_completions, void *userdata, const char *text, ...) _printf_(4, 5);
 #define ask_string(ret, text, ...) ask_string_full(ret, NULL, NULL, text, ##__VA_ARGS__)
 
 bool any_key_to_proceed(void);
 int show_menu(char **x, size_t n_columns, size_t column_width, unsigned ellipsize_percentage, const char *grey_prefix, bool with_numbers);
 
-int vt_disallocate(const char *name);
+int vt_disallocate(const char *tty_path);
 
 int resolve_dev_console(char **ret);
 int get_kernel_consoles(char ***ret);

src/basic/unit-def.h

@@ -325,7 +325,7 @@ UnitActiveState unit_active_state_from_string(const char *s) _pure_;
 
 const char* freezer_state_to_string(FreezerState i) _const_;
 FreezerState freezer_state_from_string(const char *s) _pure_;
-FreezerState freezer_state_finish(FreezerState i) _const_;
+FreezerState freezer_state_finish(FreezerState state) _const_;
 FreezerState freezer_state_objective(FreezerState state) _const_;
 
 const char* unit_marker_to_string(UnitMarker m) _const_;

src/basic/unit-name.h

@@ -67,7 +67,7 @@ static inline int unit_name_mangle(const char *name, UnitNameMangle flags, char
 }
 
 int slice_build_parent_slice(const char *slice, char **ret);
-int slice_build_subslice(const char *slice, const char *name, char **subslice);
+int slice_build_subslice(const char *slice, const char *name, char **ret);
 bool slice_name_is_valid(const char *name);
 
 bool unit_name_prefix_equal(const char *a, const char *b);

src/basic/user-util.h

@@ -71,7 +71,7 @@ char* gid_to_name(gid_t gid);
 int in_gid(gid_t gid);
 int in_group(const char *name);
 
-int merge_gid_lists(const gid_t *list1, size_t size1, const gid_t *list2, size_t size2, gid_t **result);
+int merge_gid_lists(const gid_t *list1, size_t size1, const gid_t *list2, size_t size2, gid_t **ret);
 int getgroups_alloc(gid_t **ret);
 
 int get_home_dir(char **ret);

src/boot/boot.c

@@ -1607,7 +1607,7 @@ static void config_load_type1_entries(
                                 /* offset= */ 0,
                                 /* size= */ 0,
                                 &content,
-                                /* content_size= */ NULL);
+                                /* ret_size= */ NULL);
                 if (err != EFI_SUCCESS)
                         continue;
 

src/boot/chid.h

@@ -98,4 +98,8 @@ static inline const char* device_get_fwid(const void *base, const Device *device
         return off == 0 ? NULL : (const char *) ((const uint8_t *) base + off);
 }
 
-EFI_STATUS chid_match(const void *chids_buffer, size_t chids_length, uint32_t match_type, const Device **ret_device);
+EFI_STATUS chid_match(
+                const void *hwid_buffer,
+                size_t hwid_length,
+                uint32_t match_type,
+                const Device **ret_device);

src/boot/efi-string-table.h

@@ -4,10 +4,11 @@
 #include "efi-string.h"
 #include "macro-fundamental.h"
 
-#define _DEFINE_STRING_TABLE_LOOKUP_TO_STRING(name,type,scope)          \
-        scope const char* name##_to_string(type i) {                    \
-                assert(i >= 0 && i < (type) ELEMENTSOF(name##_table));  \
-                return name##_table[i];                                 \
+#define _DEFINE_STRING_TABLE_LOOKUP_TO_STRING(name,type,scope)                          \
+        /* NOLINTNEXTLINE (readability-inconsistent-declaration-parameter-name) */      \
+        scope const char* name##_to_string(type i) {                                    \
+                assert(i >= 0 && i < (type) ELEMENTSOF(name##_table));                  \
+                return name##_table[i];                                                 \
         }
 
 #define _DEFINE_STRING_TABLE_LOOKUP_FROM_STRING(name, type, scope)    \

src/boot/measure.h

@@ -21,7 +21,7 @@ char *description, bool *ret_measured);
 /* New stuff is logged as EV_EVENT_TAG */
 EFI_STATUS tpm_log_tagged_event(uint32_t pcrindex, EFI_PHYSICAL_ADDRESS buffer, size_t buffer_size, uint32_t event_id, const char16_t *description, bool *ret_measured);
 
-EFI_STATUS tpm_log_load_options(const char16_t *cmdline, bool *ret_measured);
+EFI_STATUS tpm_log_load_options(const char16_t *load_options, bool *ret_measured);
 
 #else
 
@@ -51,7 +51,7 @@ static inline EFI_STATUS tpm_log_tagged_event(uint32_t pcrindex, EFI_PHYSICAL_AD
         return EFI_SUCCESS;
 }
 
-static inline EFI_STATUS tpm_log_load_options(const char16_t *cmdline, bool *ret_measured) {
+static inline EFI_STATUS tpm_log_load_options(const char16_t *load_options, bool *ret_measured) {
         if (ret_measured)
                 *ret_measured = false;
         return EFI_SUCCESS;

src/boot/util.c

@@ -324,14 +324,14 @@ bool is_ascii(const char16_t *f) {
         return true;
 }
 
-char16_t **strv_free(char16_t **v) {
-        if (!v)
+char16_t **strv_free(char16_t **l) {
+        if (!l)
                 return NULL;
 
-        for (char16_t **i = v; *i; i++)
+        for (char16_t **i = l; *i; i++)
                 free(*i);
 
-        return mfree(v);
+        return mfree(l);
 }
 
 EFI_STATUS open_directory(

src/boot/util.h

@@ -126,11 +126,11 @@ static inline Pages xmalloc_initrd_pages(size_t n_pages) {
 }
 
 void convert_efi_path(char16_t *path);
-char16_t *xstr8_to_path(const char *stra);
+char16_t *xstr8_to_path(const char *str8);
 char16_t *mangle_stub_cmdline(char16_t *cmdline);
 
 EFI_STATUS chunked_read(EFI_FILE *file, size_t *size, void *buf);
-EFI_STATUS file_read(EFI_FILE *dir, const char16_t *name, uint64_t offset, size_t size, char **content, size_t *content_size);
+EFI_STATUS file_read(EFI_FILE *dir, const char16_t *name, uint64_t offset, size_t size, char **ret, size_t *ret_size);
 EFI_STATUS file_handle_read(EFI_FILE *handle, uint64_t offset, size_t size, char **ret, size_t *ret_size);
 
 static inline void file_closep(EFI_FILE **handle) {

src/core/crash-handler.h

@@ -12,7 +12,7 @@ typedef enum CrashAction {
 } CrashAction;
 
 const char* crash_action_to_string(CrashAction action);
-CrashAction crash_action_from_string(const char *action);
+CrashAction crash_action_from_string(const char *s);
 
 _noreturn_ void freeze_or_exit_or_reboot(void);
 void install_crash_handler(void);

src/core/dbus-path.c

@@ -148,7 +148,7 @@ int bus_path_set_property(
                 Unit *u,
                 const char *name,
                 sd_bus_message *message,
-                UnitWriteFlags mode,
+                UnitWriteFlags flags,
                 sd_bus_error *reterr_error) {
 
         Path *p = PATH(u);
@@ -158,7 +158,7 @@ int bus_path_set_property(
         assert(message);
 
         if (u->transient && u->load_state == UNIT_STUB)
-                return bus_path_set_transient_property(p, name, message, mode, reterr_error);
+                return bus_path_set_transient_property(p, name, message, flags, reterr_error);
 
         return 0;
 }

src/core/dbus-timer.c

@@ -358,7 +358,7 @@ int bus_timer_set_property(
                 Unit *u,
                 const char *name,
                 sd_bus_message *message,
-                UnitWriteFlags mode,
+                UnitWriteFlags flags,
                 sd_bus_error *reterr_error) {
 
         Timer *t = TIMER(u);
@@ -368,7 +368,7 @@ int bus_timer_set_property(
         assert(message);
 
         if (u->transient && u->load_state == UNIT_STUB)
-                return bus_timer_set_transient_property(t, name, message, mode, reterr_error);
+                return bus_timer_set_transient_property(t, name, message, flags, reterr_error);
 
         return 0;
 }

src/core/exec-credential.h

@@ -29,7 +29,7 @@ DEFINE_TRIVIAL_CLEANUP_FUNC(ExecSetCredential*, exec_set_credential_free);
 ExecLoadCredential* exec_load_credential_free(ExecLoadCredential *lc);
 DEFINE_TRIVIAL_CLEANUP_FUNC(ExecLoadCredential*, exec_load_credential_free);
 
-ExecImportCredential* exec_import_credential_free(ExecImportCredential *lc);
+ExecImportCredential* exec_import_credential_free(ExecImportCredential *ic);
 DEFINE_TRIVIAL_CLEANUP_FUNC(ExecImportCredential*, exec_import_credential_free);
 
 int exec_context_put_load_credential(ExecContext *c, const char *id, const char *path, bool encrypted);
@@ -51,7 +51,7 @@ int exec_context_get_credential_directory(
                 const char *unit,
                 char **ret);
 
-int exec_context_destroy_credentials(const ExecContext *c, const char *runtime_root, const char *unit);
+int exec_context_destroy_credentials(const ExecContext *c, const char *runtime_prefix, const char *unit);
 
 int exec_setup_credentials(
                 const ExecContext *context,

src/core/execute.c

@@ -465,7 +465,7 @@ static void log_command_line(Unit *unit, const char *msg, const char *executable
                         LOG_UNIT_INVOCATION_ID(unit));
 }
 
-static int exec_context_load_environment(const Unit *unit, const ExecContext *c, char ***l);
+static int exec_context_load_environment(const Unit *unit, const ExecContext *c, char ***ret);
 
 int exec_spawn(
                 Unit *unit,

src/core/execute.h

@@ -508,7 +508,7 @@ void exec_context_init(ExecContext *c);
 void exec_context_done(ExecContext *c);
 void exec_context_dump(const ExecContext *c, FILE* f, const char *prefix);
 
-int exec_context_destroy_runtime_directory(const ExecContext *c, const char *runtime_root);
+int exec_context_destroy_runtime_directory(const ExecContext *c, const char *runtime_prefix);
 int exec_context_destroy_mount_ns_dir(Unit *u);
 
 const char* exec_context_fdname(const ExecContext *c, int fd_index) _pure_;
@@ -557,7 +557,7 @@ void exec_status_handoff(ExecStatus *s, const struct ucred *ucred, const dual_ti
 void exec_status_dump(const ExecStatus *s, FILE *f, const char *prefix);
 void exec_status_reset(ExecStatus *s);
 
-int exec_shared_runtime_acquire(Manager *m, const ExecContext *c, const char *name, bool create, ExecSharedRuntime **ret);
+int exec_shared_runtime_acquire(Manager *m, const ExecContext *c, const char *id, bool create, ExecSharedRuntime **ret);
 ExecSharedRuntime *exec_shared_runtime_destroy(ExecSharedRuntime *r);
 ExecSharedRuntime *exec_shared_runtime_unref(ExecSharedRuntime *r);
 DEFINE_TRIVIAL_CLEANUP_FUNC(ExecSharedRuntime*, exec_shared_runtime_unref);

src/core/manager-dump.c

@@ -15,13 +15,13 @@
 #include "unit-serialize.h"
 #include "version.h"
 
-void manager_dump_jobs(Manager *s, FILE *f, char **patterns, const char *prefix) {
+void manager_dump_jobs(Manager *m, FILE *f, char **patterns, const char *prefix) {
         Job *j;
 
-        assert(s);
+        assert(m);
         assert(f);
 
-        HASHMAP_FOREACH(j, s->jobs) {
+        HASHMAP_FOREACH(j, m->jobs) {
 
                 if (!strv_fnmatch_or_empty(patterns, j->unit->id, FNM_NOESCAPE))
                         continue;
@@ -46,14 +46,14 @@ int manager_get_dump_jobs_string(Manager *m, char **patterns, const char *prefix
         return memstream_finalize(&ms, ret, NULL);
 }
 
-void manager_dump_units(Manager *s, FILE *f, char **patterns, const char *prefix) {
+void manager_dump_units(Manager *m, FILE *f, char **patterns, const char *prefix) {
         Unit *u;
         const char *t;
 
-        assert(s);
+        assert(m);
         assert(f);
 
-        HASHMAP_FOREACH_KEY(u, t, s->units) {
+        HASHMAP_FOREACH_KEY(u, t, m->units) {
                 if (u->id != t)
                         continue;
 

src/core/manager-dump.h

@@ -3,9 +3,9 @@
 
 #include "core-forward.h"
 
-void manager_dump_jobs(Manager *s, FILE *f, char **patterns, const char *prefix);
+void manager_dump_jobs(Manager *m, FILE *f, char **patterns, const char *prefix);
 int manager_get_dump_jobs_string(Manager *m, char **patterns, const char *prefix, char **ret);
-void manager_dump_units(Manager *s, FILE *f, char **patterns, const char *prefix);
-void manager_dump(Manager *s, FILE *f, char **patterns, const char *prefix);
+void manager_dump_units(Manager *m, FILE *f, char **patterns, const char *prefix);
+void manager_dump(Manager *m, FILE *f, char **patterns, const char *prefix);
 int manager_get_dump_string(Manager *m, char **patterns, char **ret);
 void manager_test_summary(Manager *m);

src/core/manager.h

@@ -514,7 +514,7 @@ static inline usec_t manager_default_timeout_abort_usec(Manager *m) {
 
 usec_t manager_default_timeout(RuntimeScope scope);
 
-int manager_new(RuntimeScope scope, ManagerTestRunFlags test_run_flags, Manager **m);
+int manager_new(RuntimeScope scope, ManagerTestRunFlags test_run_flags, Manager **ret);
 Manager* manager_free(Manager *m);
 DEFINE_TRIVIAL_CLEANUP_FUNC(Manager*, manager_free);
 

src/core/show-status.c

@@ -22,16 +22,16 @@ static const char* const show_status_table[_SHOW_STATUS_MAX] = {
 
 DEFINE_STRING_TABLE_LOOKUP_WITH_BOOLEAN(show_status, ShowStatus, SHOW_STATUS_YES);
 
-int parse_show_status(const char *v, ShowStatus *ret) {
-        ShowStatus s;
+int parse_show_status(const char *s, ShowStatus *ret) {
+        ShowStatus status;
 
         assert(ret);
 
-        s = show_status_from_string(v);
-        if (s < 0 || s == SHOW_STATUS_TEMPORARY)
+        status = show_status_from_string(s);
+        if (status < 0 || status == SHOW_STATUS_TEMPORARY)
                 return -EINVAL;
 
-        *ret = s;
+        *ret = status;
         return 0;
 }
 

src/core/show-status.h

@@ -31,11 +31,11 @@ typedef enum StatusUnitFormat {
 static inline bool show_status_on(ShowStatus s) {
         return IN_SET(s, SHOW_STATUS_TEMPORARY, SHOW_STATUS_YES);
 }
-ShowStatus show_status_from_string(const char *v) _const_;
+ShowStatus show_status_from_string(const char *s) _const_;
 const char* show_status_to_string(ShowStatus s) _pure_;
-int parse_show_status(const char *v, ShowStatus *ret);
+int parse_show_status(const char *s, ShowStatus *ret);
 
-StatusUnitFormat status_unit_format_from_string(const char *v) _const_;
+StatusUnitFormat status_unit_format_from_string(const char *s) _const_;
 const char* status_unit_format_to_string(StatusUnitFormat s) _pure_;
 
 int status_vprintf(const char *status, ShowStatusFlags flags, const char *format, va_list ap) _printf_(3,0);

src/core/socket.c

@@ -3683,25 +3683,25 @@ static const char* const socket_timestamping_table[_SOCKET_TIMESTAMPING_MAX] = {
 
 DEFINE_STRING_TABLE_LOOKUP(socket_timestamping, SocketTimestamping);
 
-SocketTimestamping socket_timestamping_from_string_harder(const char *p) {
+SocketTimestamping socket_timestamping_from_string_harder(const char *s) {
         SocketTimestamping t;
         int r;
 
-        if (!p)
+        if (!s)
                 return _SOCKET_TIMESTAMPING_INVALID;
 
-        t = socket_timestamping_from_string(p);
+        t = socket_timestamping_from_string(s);
         if (t >= 0)
                 return t;
 
         /* Let's alternatively support the various other aliases parse_time() accepts for ns and µs here,
          * too. */
-        if (streq(p, "nsec"))
+        if (streq(s, "nsec"))
                 return SOCKET_TIMESTAMPING_NS;
-        if (STR_IN_SET(p, "usec", "µs", "μs")) /* Accept both small greek letter mu + micro sign unicode codepoints */
+        if (STR_IN_SET(s, "usec", "µs", "μs")) /* Accept both small greek letter mu + micro sign unicode codepoints */
                 return SOCKET_TIMESTAMPING_US;
 
-        r = parse_boolean(p);
+        r = parse_boolean(s);
         if (r < 0)
                 return _SOCKET_TIMESTAMPING_INVALID;
 

src/core/socket.h

@@ -181,7 +181,7 @@ typedef struct Socket {
 
 SocketPeer *socket_peer_ref(SocketPeer *p);
 SocketPeer *socket_peer_unref(SocketPeer *p);
-int socket_acquire_peer(Socket *s, int fd, SocketPeer **p);
+int socket_acquire_peer(Socket *s, int fd, SocketPeer **ret);
 
 DEFINE_TRIVIAL_CLEANUP_FUNC(SocketPeer*, socket_peer_unref);
 
@@ -196,7 +196,7 @@ DEFINE_TRIVIAL_CLEANUP_FUNC(SocketPort*, socket_port_free);
 
 void socket_free_ports(Socket *s);
 
-int socket_port_to_address(const SocketPort *s, char **ret);
+int socket_port_to_address(const SocketPort *p, char **ret);
 
 int socket_load_service_unit(Socket *s, int cfd, Unit **ret);
 
@@ -211,11 +211,11 @@ const char* socket_result_to_string(SocketResult i) _const_;
 SocketResult socket_result_from_string(const char *s) _pure_;
 
 const char* socket_port_type_to_string(SocketPort *p) _pure_;
-SocketType socket_port_type_from_string(const char *p) _pure_;
+SocketType socket_port_type_from_string(const char *s) _pure_;
 
 const char* socket_timestamping_to_string(SocketTimestamping p) _const_;
-SocketTimestamping socket_timestamping_from_string(const char *p) _pure_;
-SocketTimestamping socket_timestamping_from_string_harder(const char *p) _pure_;
+SocketTimestamping socket_timestamping_from_string(const char *s) _pure_;
+SocketTimestamping socket_timestamping_from_string_harder(const char *s) _pure_;
 
 const char* socket_defer_trigger_to_string(SocketDeferTrigger i) _const_;
 SocketDeferTrigger socket_defer_trigger_from_string(const char *s) _pure_;

src/core/unit-printf.c

@@ -142,7 +142,7 @@ static int specifier_shared_data_dir(char specifier, const void *data, const cha
         return sd_path_lookup(MANAGER_IS_SYSTEM(u->manager) ? SD_PATH_SYSTEM_SHARED : SD_PATH_USER_SHARED, NULL, ret);
 }
 
-int unit_name_printf(const Unit *u, const char* format, char **ret) {
+int unit_name_printf(const Unit *u, const char *format, char **ret) {
         /*
          * This will use the passed string as format string and replace the following specifiers (which should all be
          * safe for inclusion in unit names):

src/core/unit-printf.h

@@ -3,8 +3,8 @@
 
 #include "core-forward.h"
 
-int unit_name_printf(const Unit *u, const char* text, char **ret);
-int unit_full_printf_full(const Unit *u, const char *text, size_t max_length, char **ret);
+int unit_name_printf(const Unit *u, const char *format, char **ret);
+int unit_full_printf_full(const Unit *u, const char *format, size_t max_length, char **ret);
 int unit_full_printf(const Unit *u, const char *text, char **ret);
 int unit_path_printf(const Unit *u, const char *text, char **ret);
 int unit_fd_printf(const Unit *u, const char *text, char **ret);

src/core/unit-serialize.h

@@ -6,7 +6,7 @@
 /* These functions serialize state for our own usage, i.e.: across a reload/reexec, rather than for being
  * passed to a child process. */
 
-int unit_serialize_state(Unit *u, FILE *f, FDSet *fds, bool serialize_jobs);
+int unit_serialize_state(Unit *u, FILE *f, FDSet *fds, bool switching_root);
 int unit_deserialize_state(Unit *u, FILE *f, FDSet *fds);
 int unit_deserialize_state_skip(FILE *f);
 

src/core/unit.h

@@ -163,10 +163,10 @@ typedef struct ActivationDetails {
 ActivationDetails *activation_details_new(Unit *trigger_unit);
 ActivationDetails *activation_details_ref(ActivationDetails *p);
 ActivationDetails *activation_details_unref(ActivationDetails *p);
-void activation_details_serialize(const ActivationDetails *p, FILE *f);
-int activation_details_deserialize(const char *key, const char *value, ActivationDetails **info);
-int activation_details_append_env(const ActivationDetails *info, char ***strv);
-int activation_details_append_pair(const ActivationDetails *info, char ***strv);
+void activation_details_serialize(const ActivationDetails *details, FILE *f);
+int activation_details_deserialize(const char *key, const char *value, ActivationDetails **details);
+int activation_details_append_env(const ActivationDetails *details, char ***strv);
+int activation_details_append_pair(const ActivationDetails *details, char ***strv);
 DEFINE_TRIVIAL_CLEANUP_FUNC(ActivationDetails*, activation_details_unref);
 
 typedef struct ActivationDetailsVTable {
@@ -175,24 +175,24 @@ typedef struct ActivationDetailsVTable {
 
         /* This should reset all type-specific variables. This should not allocate memory, and is called
          * with zero-initialized data. It should hence only initialize variables that need to be set != 0. */
-        void (*init)(ActivationDetails *info, Unit *trigger_unit);
+        void (*init)(ActivationDetails *details, Unit *trigger_unit);
 
         /* This should free all type-specific variables. It should be idempotent. */
-        void (*done)(ActivationDetails *info);
+        void (*done)(ActivationDetails *details);
 
         /* This should serialize all type-specific variables. */
-        void (*serialize)(const ActivationDetails *info, FILE *f);
+        void (*serialize)(const ActivationDetails *details, FILE *f);
 
         /* This should deserialize all type-specific variables, one at a time. */
-        int (*deserialize)(const char *key, const char *value, ActivationDetails **info);
+        int (*deserialize)(const char *key, const char *value, ActivationDetails **details);
 
         /* This should format the type-specific variables for the env block of the spawned service,
          * and return the number of added items. */
-        int (*append_env)(const ActivationDetails *info, char ***strv);
+        int (*append_env)(const ActivationDetails *details, char ***strv);
 
         /* This should append type-specific variables as key/value pairs for the D-Bus property of the job,
          * and return the number of added pairs. */
-        int (*append_pair)(const ActivationDetails *info, char ***strv);
+        int (*append_pair)(const ActivationDetails *details, char ***strv);
 } ActivationDetailsVTable;
 
 extern const ActivationDetailsVTable * const activation_details_vtable[_UNIT_TYPE_MAX];
@@ -819,7 +819,7 @@ Unit* unit_free(Unit *u);
 DEFINE_TRIVIAL_CLEANUP_FUNC(Unit *, unit_free);
 
 int unit_new_for_name(Manager *m, size_t size, const char *name, Unit **ret);
-int unit_add_name(Unit *u, const char *name);
+int unit_add_name(Unit *u, const char *text);
 
 int unit_add_dependency(Unit *u, UnitDependency d, Unit *other, bool add_reference, UnitDependencyMask mask);
 int unit_add_two_dependencies(Unit *u, UnitDependency d, UnitDependency e, Unit *other, bool add_reference, UnitDependencyMask mask);
@@ -860,7 +860,7 @@ void unit_add_to_stop_notify_queue(Unit *u);
 void unit_remove_from_stop_notify_queue(Unit *u);
 
 int unit_merge(Unit *u, Unit *other);
-int unit_merge_by_name(Unit *u, const char *other);
+int unit_merge_by_name(Unit *u, const char *name);
 
 Unit *unit_follow_merge(Unit *u) _pure_;
 
@@ -871,7 +871,7 @@ int unit_set_slice(Unit *u, Unit *slice);
 int unit_set_default_slice(Unit *u);
 
 const char* unit_description(Unit *u) _pure_;
-const char* unit_status_string(Unit *u, char **combined);
+const char* unit_status_string(Unit *u, char **ret_combined_buffer);
 
 bool unit_has_name(const Unit *u, const char *name);
 
@@ -967,7 +967,7 @@ const char* unit_escape_setting(const char *s, UnitWriteFlags flags, char **buf)
 char* unit_concat_strv(char **l, UnitWriteFlags flags);
 
 int unit_write_setting(Unit *u, UnitWriteFlags flags, const char *name, const char *data);
-int unit_write_settingf(Unit *u, UnitWriteFlags mode, const char *name, const char *format, ...) _printf_(4,5);
+int unit_write_settingf(Unit *u, UnitWriteFlags flags, const char *name, const char *format, ...) _printf_(4,5);
 
 int unit_kill_context(Unit *u, KillOperation k);
 
@@ -1003,7 +1003,7 @@ void unit_notify_user_lookup(Unit *u, uid_t uid, gid_t gid);
 int unit_set_invocation_id(Unit *u, sd_id128_t id);
 int unit_acquire_invocation_id(Unit *u);
 
-int unit_set_exec_params(Unit *s, ExecParameters *p);
+int unit_set_exec_params(Unit *u, ExecParameters *p);
 
 int unit_fork_helper_process(Unit *u, const char *name, bool into_cgroup, PidRef *ret);
 int unit_fork_and_watch_rm_rf(Unit *u, char **paths, PidRef *ret);

src/coredump/coredump-config.h

@@ -58,6 +58,6 @@ int coredump_parse_config(CoredumpConfig *config);
 uint64_t coredump_storage_size_max(const CoredumpConfig *config);
 
 /* Defined in generated coredump-gperf.c */
-const struct ConfigPerfItem* coredump_gperf_lookup(const char *key, GPERF_LEN_TYPE length);
+const struct ConfigPerfItem* coredump_gperf_lookup(const char *str, GPERF_LEN_TYPE length);
 
 CONFIG_PARSER_PROTOTYPE(config_parse_coredump_storage);

src/home/homed-conf.h

@@ -5,7 +5,7 @@
 
 int manager_parse_config_file(Manager *m);
 
-const struct ConfigPerfItem* homed_gperf_lookup(const char *key, GPERF_LEN_TYPE length);
+const struct ConfigPerfItem* homed_gperf_lookup(const char *str, GPERF_LEN_TYPE length);
 
 CONFIG_PARSER_PROTOTYPE(config_parse_default_storage);
 CONFIG_PARSER_PROTOTYPE(config_parse_default_file_system_type);

src/home/homed-home.h

@@ -190,7 +190,7 @@ int home_authenticate(Home *h, UserRecord *secret, sd_bus_error *error);
 int home_deactivate(Home *h, bool force, sd_bus_error *error);
 int home_create(Home *h, UserRecord *secret, Hashmap *blobs, uint64_t flags, sd_bus_error *error);
 int home_remove(Home *h, sd_bus_error *error);
-int home_update(Home *h, UserRecord *new_record, Hashmap *blobs, uint64_t flags, sd_bus_error *error);
+int home_update(Home *h, UserRecord *hr, Hashmap *blobs, uint64_t flags, sd_bus_error *error);
 int home_resize(Home *h, uint64_t disk_size, UserRecord *secret, sd_bus_error *error);
 int home_passwd(Home *h, UserRecord *new_secret, UserRecord *old_secret, sd_bus_error *error);
 int home_unregister(Home *h, sd_bus_error *error);

src/home/homework-mount.h

@@ -6,5 +6,5 @@
 int home_mount_node(const char *node, const char *fstype, bool discard, unsigned long flags, const char *extra_mount_options);
 int home_unshare_and_mkdir(void);
 int home_unshare_and_mount(const char *node, const char *fstype, bool discard, unsigned long flags, const char *extra_mount_options);
-int home_move_mount(const char *user_name_and_realm, const char *target);
+int home_move_mount(const char *mount_suffix, const char *target);
 int home_shift_uid(int dir_fd, const char *target, uid_t stored_uid, uid_t exposed_uid, int *ret_mount_fd);

src/home/user-record-util.h

@@ -9,7 +9,7 @@
 #define HOMEWORK_BLOB_FDMAP_FIELD "__systemd_homework_internal_blob_fdmap"
 
 int user_record_synthesize(UserRecord *h, const char *user_name, const char *realm, const char *image_path, UserStorage storage, uid_t uid, gid_t gid);
-int group_record_synthesize(GroupRecord *g, UserRecord *u);
+int group_record_synthesize(GroupRecord *g, UserRecord *h);
 
 typedef enum UserReconcileMode {
         USER_RECONCILE_ANY,
@@ -49,7 +49,7 @@ int user_record_test_recovery_key(UserRecord *h, UserRecord *secret);
 int user_record_update_last_changed(UserRecord *h, bool with_password);
 int user_record_set_disk_size(UserRecord *h, uint64_t disk_size);
 int user_record_set_password(UserRecord *h, char **password, bool prepend);
-int user_record_make_hashed_password(UserRecord *h, char **password, bool extend);
+int user_record_make_hashed_password(UserRecord *h, char **secret, bool extend);
 int user_record_set_token_pin(UserRecord *h, char **pin, bool prepend);
 int user_record_set_pkcs11_protected_authentication_path_permitted(UserRecord *h, int b);
 int user_record_set_fido2_user_presence_permitted(UserRecord *h, int b);

src/import/pull-common.h

@@ -9,14 +9,50 @@
 typedef struct CurlGlue CurlGlue;
 typedef struct PullJob PullJob;
 
-int pull_find_old_etags(const char *url, const char *root, int dt, const char *prefix, const char *suffix, char ***etags);
+int pull_find_old_etags(
+                const char *url,
+                const char *root,
+                int dt,
+                const char *prefix,
+                const char *suffix,
+                char ***etags);
 
-int pull_make_path(const char *url, const char *etag, const char *image_root, const char *prefix, const char *suffix, char **ret);
+int pull_make_path(
+                const char *url,
+                const char *etag,
+                const char *image_root,
+                const char *prefix,
+                const char *suffix,
+                char **ret);
 
-int pull_make_auxiliary_job(PullJob **ret, const char *url, int (*strip_suffixes)(const char *name, char **ret), const char *suffix, ImportVerify verify, CurlGlue *glue, PullJobOpenDisk on_open_disk, PullJobFinished on_finished, void *userdata);
-int pull_make_verification_jobs(PullJob **ret_checksum_job, PullJob **ret_signature_job, ImportVerify verify, const char *url, CurlGlue *glue, PullJobFinished on_finished, void *userdata);
+int pull_make_auxiliary_job(
+                PullJob **ret,
+                const char *url,
+                int (*strip_suffixes)(const char *name, char **ret),
+                const char *suffix,
+                ImportVerify verify,
+                CurlGlue *glue,
+                PullJobOpenDisk on_open_disk,
+                PullJobFinished on_finished,
+                void *userdata);
+int pull_make_verification_jobs(
+                PullJob **ret_checksum_job,
+                PullJob **ret_signature_job,
+                ImportVerify verify,
+                const char *url,
+                CurlGlue *glue,
+                PullJobFinished on_finished,
+                void *userdata);
 
-int pull_verify(ImportVerify verify, PullJob *main_job, PullJob *checksum_job, PullJob *signature_job, PullJob *settings_job, PullJob *roothash_job, PullJob *roothash_signature_job, PullJob *verity_job);
+int pull_verify(
+                ImportVerify verify,
+                PullJob *main_job,
+                PullJob *checksum_job,
+                PullJob *signature_job,
+                PullJob *settings_job,
+                PullJob *roothash_job,
+                PullJob *roothash_signature_job,
+                PullJob *verity_job);
 
 typedef enum VerificationStyle {
         VERIFICATION_PER_FILE,      /* SUSE-style ".sha256" files with detached gpg signature */
@@ -25,7 +61,7 @@ typedef enum VerificationStyle {
         _VERIFICATION_STYLE_INVALID = -EINVAL,
 } VerificationStyle;
 
-int verification_style_from_url(const char *url, VerificationStyle *style);
+int verification_style_from_url(const char *url, VerificationStyle *ret);
 
 typedef enum SignatureStyle {
         SIGNATURE_GPG_PER_FILE,      /* ".sha256" files with detached .gpg signature */
@@ -36,7 +72,7 @@ typedef enum SignatureStyle {
         _SIGNATURE_STYLE_INVALID = -EINVAL,
 } SignatureStyle;
 
-int signature_style_from_url(const char *url, SignatureStyle *style, char **ret_filename);
+int signature_style_from_url(const char *url, SignatureStyle *ret, char **ret_filename);
 
 int pull_job_restart_with_sha256sum(PullJob *job, char **ret);
 int pull_job_restart_with_signature(PullJob *job, char **ret);

src/journal-remote/journal-remote-main.c

@@ -192,13 +192,8 @@ static int spawn_getter(const char *getter) {
 
 #if HAVE_MICROHTTPD
 
-static int null_timer_event_handler(sd_event_source *s,
-                                uint64_t usec,
-                                void *userdata);
-static int dispatch_http_event(sd_event_source *event,
-                               int fd,
-                               uint32_t revents,
-                               void *userdata);
+static int null_timer_event_handler(sd_event_source *timer_event, uint64_t usec, void *userdata);
+static int dispatch_http_event(sd_event_source *event, int fd, uint32_t revents, void *userdata);
 
 static int build_accept_encoding(char **ret) {
         assert(ret);

src/journal-remote/journal-remote-write.h

@@ -25,7 +25,7 @@ Writer* writer_unref(Writer *w);
 
 DEFINE_TRIVIAL_CLEANUP_FUNC(Writer*, writer_unref);
 
-int writer_write(Writer *s,
+int writer_write(Writer *w,
                  const struct iovec_wrapper *iovw,
                  const dual_timestamp *ts,
                  const sd_id128_t *boot_id,

src/journal/journald-config.h

@@ -97,7 +97,7 @@ void manager_load_config(Manager *m);
 int manager_dispatch_reload_signal(sd_event_source *s, const struct signalfd_siginfo *si, void *userdata);
 
 /* Defined in generated journald-gperf.c */
-const struct ConfigPerfItem* journald_gperf_lookup(const char *key, GPERF_LEN_TYPE length);
+const struct ConfigPerfItem* journald_gperf_lookup(const char *str, GPERF_LEN_TYPE length);
 
 const char* storage_to_string(Storage s) _const_;
 Storage storage_from_string(const char *s) _pure_;

src/journal/journald-context.h

@@ -81,7 +81,7 @@ void client_context_maybe_refresh(
                 const struct ucred *ucred,
                 const char *label, size_t label_size,
                 const char *unit_id,
-                usec_t tstamp);
+                usec_t timestamp);
 
 void manager_refresh_client_contexts_on_reload(Manager *m, usec_t old_interval, unsigned old_burst);
 void client_context_acquire_default(Manager *m);

src/journal/journald-manager.h

@@ -167,7 +167,7 @@ typedef struct Manager {
 /* audit: Maximum number of extra fields we'll import from audit messages */
 #define N_IOVEC_AUDIT_FIELDS 64
 
-void manager_dispatch_message(Manager *m, struct iovec *iovec, size_t n, size_t k, ClientContext *c, const struct timeval *tv, int priority, pid_t object_pid);
+void manager_dispatch_message(Manager *m, struct iovec *iovec, size_t n, size_t mm, ClientContext *c, const struct timeval *tv, int priority, pid_t object_pid);
 void manager_driver_message_internal(Manager *m, pid_t object_pid, const char *format, ...) _sentinel_;
 #define manager_driver_message(...) manager_driver_message_internal(__VA_ARGS__, NULL)
 

src/journal/journald-syslog.h

@@ -9,7 +9,7 @@ size_t syslog_parse_identifier(const char **buf, char **identifier, char **pid);
 
 void manager_forward_syslog(Manager *m, int priority, const char *identifier, const char *message, const struct ucred *ucred, const struct timeval *tv);
 
-void manager_process_syslog_message(Manager *m, const char *buf, size_t buf_len, const struct ucred *ucred, const struct timeval *tv, const char *label, size_t label_len);
+void manager_process_syslog_message(Manager *m, const char *buf, size_t raw_len, const struct ucred *ucred, const struct timeval *tv, const char *label, size_t label_len);
 int manager_open_syslog_socket(Manager *m, const char *syslog_socket);
 
 void manager_maybe_warn_forward_syslog_missed(Manager *m);

src/libsystemd-network/dhcp-option.h

@@ -31,7 +31,7 @@ int dhcp_option_append(
                 size_t optlen,
                 const void *optval);
 int dhcp_option_find_option(uint8_t *options, size_t length, uint8_t wanted_code, size_t *ret_offset);
-int dhcp_option_remove_option(uint8_t *options, size_t buflen, uint8_t option_code);
+int dhcp_option_remove_option(uint8_t *options, size_t length, uint8_t option_code);
 
 typedef int (*dhcp_option_callback_t)(uint8_t code, uint8_t len, const void *option, void *userdata);
 

src/libsystemd-network/fuzz-dhcp-server-relay.c

@@ -5,11 +5,11 @@
 #include "fuzz.h"
 #include "sd-dhcp-server.c"
 
-ssize_t sendto(int sockfd, const void *buf, size_t len, int flags, const struct sockaddr *dest_addr, socklen_t addrlen) {
-        return len;
+ssize_t sendto(int __fd, const void *__buf, size_t __n, int flags, const struct sockaddr *__addr, socklen_t __addr_len) {
+        return __n;
 }
 
-ssize_t sendmsg(int sockfd, const struct msghdr *msg, int flags) {
+ssize_t sendmsg(int __fd, const struct msghdr *__message, int flags) {
         return 0;
 }
 

src/libsystemd-network/fuzz-dhcp-server.c

@@ -9,11 +9,11 @@
 #include "tmpfile-util.h"
 
 /* stub out network so that the server doesn't send */
-ssize_t sendto(int sockfd, const void *buf, size_t len, int flags, const struct sockaddr *dest_addr, socklen_t addrlen) {
-        return len;
+ssize_t sendto(int __fd, const void *__buf, size_t __n, int flags, const struct sockaddr *__addr, socklen_t __addr_len) {
+        return __n;
 }
 
-ssize_t sendmsg(int sockfd, const struct msghdr *msg, int flags) {
+ssize_t sendmsg(int __fd, const struct msghdr *__message, int flags) {
         return 0;
 }
 

src/libsystemd-network/icmp6-test-util.c

@@ -30,12 +30,12 @@ int icmp6_send(int fd, const struct in6_addr *dst, const struct iovec *iov, size
 
 int icmp6_receive(
                 int fd,
-                void *iov_base,
-                size_t iov_len,
+                void *buffer,
+                size_t size,
                 struct in6_addr *ret_sender,
                 triple_timestamp *ret_timestamp) {
 
-        assert_se(read (fd, iov_base, iov_len) == (ssize_t) iov_len);
+        assert_se(read(fd, buffer, size) == (ssize_t) size);
 
         if (ret_timestamp)
                 triple_timestamp_now(ret_timestamp);

src/libsystemd-network/network-internal.h

@@ -8,11 +8,11 @@ size_t serialize_in_addrs(FILE *f,
                           size_t size,
                           bool *with_leading_space,
                           bool (*predicate)(const struct in_addr *addr));
-int deserialize_in_addrs(struct in_addr **addresses, const char *string);
+int deserialize_in_addrs(struct in_addr **ret, const char *string);
 void serialize_in6_addrs(FILE *f, const struct in6_addr *addresses,
                          size_t size,
                          bool *with_leading_space);
-int deserialize_in6_addrs(struct in6_addr **addresses, const char *string);
+int deserialize_in6_addrs(struct in6_addr **ret, const char *string);
 
 int serialize_dnr(FILE *f, const sd_dns_resolver *dnr, size_t n_dnr, bool *with_leading_space);
 int deserialize_dnr(sd_dns_resolver **ret, const char *string);

src/libsystemd-network/sd-dhcp-lease.c

@@ -1799,14 +1799,14 @@ int dhcp_lease_set_client_id(sd_dhcp_lease *lease, const sd_dhcp_client_id *clie
         return 0;
 }
 
-int sd_dhcp_lease_get_timezone(sd_dhcp_lease *lease, const char **tz) {
+int sd_dhcp_lease_get_timezone(sd_dhcp_lease *lease, const char **ret) {
         assert_return(lease, -EINVAL);
-        assert_return(tz, -EINVAL);
+        assert_return(ret, -EINVAL);
 
         if (!lease->timezone)
                 return -ENODATA;
 
-        *tz = lease->timezone;
+        *ret = lease->timezone;
         return 0;
 }
 

src/libsystemd/sd-bus/bus-convenience.c

@@ -10,12 +10,12 @@
 #include "bus-type.h"
 #include "string-util.h"
 
-_public_ int sd_bus_message_send(sd_bus_message *reply) {
-        assert_return(reply, -EINVAL);
-        assert_return(reply->bus, -EINVAL);
-        assert_return(!bus_origin_changed(reply->bus), -ECHILD);
+_public_ int sd_bus_message_send(sd_bus_message *m) {
+        assert_return(m, -EINVAL);
+        assert_return(m->bus, -EINVAL);
+        assert_return(!bus_origin_changed(m->bus), -ECHILD);
 
-        return sd_bus_send(reply->bus, reply, NULL);
+        return sd_bus_send(m->bus, m, NULL);
 }
 
 _public_ int sd_bus_emit_signal_tov(
@@ -325,7 +325,7 @@ _public_ int sd_bus_reply_method_errorf(
 _public_ int sd_bus_reply_method_errno(
                 sd_bus_message *call,
                 int error,
-                const sd_bus_error *p) {
+                const sd_bus_error *e) {
 
         _cleanup_(sd_bus_error_free) sd_bus_error berror = SD_BUS_ERROR_NULL;
 
@@ -341,8 +341,8 @@ _public_ int sd_bus_reply_method_errno(
         if (call->header->flags & BUS_MESSAGE_NO_REPLY_EXPECTED)
                 return 0;
 
-        if (sd_bus_error_is_set(p))
-                return sd_bus_reply_method_error(call, p);
+        if (sd_bus_error_is_set(e))
+                return sd_bus_reply_method_error(call, e);
 
         sd_bus_error_set_errno(&berror, error);
 
@@ -640,20 +640,20 @@ _public_ int sd_bus_set_property(
         return r;
 }
 
-_public_ int sd_bus_query_sender_creds(sd_bus_message *call, uint64_t mask, sd_bus_creds **ret) {
+_public_ int sd_bus_query_sender_creds(sd_bus_message *m, uint64_t mask, sd_bus_creds **ret) {
         uint64_t missing;
         sd_bus_creds *c;
 
-        assert_return(call, -EINVAL);
-        assert_return(call->sealed, -EPERM);
-        assert_return(call->bus, -EINVAL);
-        assert_return(!bus_origin_changed(call->bus), -ECHILD);
+        assert_return(m, -EINVAL);
+        assert_return(m->sealed, -EPERM);
+        assert_return(m->bus, -EINVAL);
+        assert_return(!bus_origin_changed(m->bus), -ECHILD);
         assert_return(ret, -EINVAL);
 
-        if (!BUS_IS_OPEN(call->bus->state))
+        if (!BUS_IS_OPEN(m->bus->state))
                 return -ENOTCONN;
 
-        c = sd_bus_message_get_creds(call);
+        c = sd_bus_message_get_creds(m);
         if (c)
                 missing = mask & ~SD_BUS_CREDS_AUGMENT & ~c->mask;
         else
@@ -664,31 +664,31 @@ _public_ int sd_bus_query_sender_creds(sd_bus_message *call, uint64_t mask, sd_b
         }
 
         /* There's a sender, use that */
-        if (call->sender && call->bus->bus_client)
-                return sd_bus_get_name_creds(call->bus, call->sender, mask, ret);
+        if (m->sender && m->bus->bus_client)
+                return sd_bus_get_name_creds(m->bus, m->sender, mask, ret);
 
         /* There's no sender. For direct connections the credentials of the AF_UNIX peer matter, which may be
          * queried via sd_bus_get_owner_creds(). */
-        return sd_bus_get_owner_creds(call->bus, mask, ret);
+        return sd_bus_get_owner_creds(m->bus, mask, ret);
 }
 
-_public_ int sd_bus_query_sender_privilege(sd_bus_message *call, int capability) {
+_public_ int sd_bus_query_sender_privilege(sd_bus_message *m, int capability) {
         _cleanup_(sd_bus_creds_unrefp) sd_bus_creds *creds = NULL;
         uid_t our_uid;
         bool know_caps = false;
         int r;
 
-        assert_return(call, -EINVAL);
-        assert_return(call->sealed, -EPERM);
-        assert_return(call->bus, -EINVAL);
-        assert_return(!bus_origin_changed(call->bus), -ECHILD);
+        assert_return(m, -EINVAL);
+        assert_return(m->sealed, -EPERM);
+        assert_return(m->bus, -EINVAL);
+        assert_return(!bus_origin_changed(m->bus), -ECHILD);
 
-        if (!BUS_IS_OPEN(call->bus->state))
+        if (!BUS_IS_OPEN(m->bus->state))
                 return -ENOTCONN;
 
         if (capability >= 0) {
 
-                r = sd_bus_query_sender_creds(call, SD_BUS_CREDS_UID|SD_BUS_CREDS_EUID|SD_BUS_CREDS_EFFECTIVE_CAPS, &creds);
+                r = sd_bus_query_sender_creds(m, SD_BUS_CREDS_UID|SD_BUS_CREDS_EUID|SD_BUS_CREDS_EFFECTIVE_CAPS, &creds);
                 if (r < 0)
                         return r;
 
@@ -705,7 +705,7 @@ _public_ int sd_bus_query_sender_privilege(sd_bus_message *call, int capability)
                 if (r == 0)
                         know_caps = true;
         } else {
-                r = sd_bus_query_sender_creds(call, SD_BUS_CREDS_UID|SD_BUS_CREDS_EUID, &creds);
+                r = sd_bus_query_sender_creds(m, SD_BUS_CREDS_UID|SD_BUS_CREDS_EUID, &creds);
                 if (r < 0)
                         return r;
         }

src/libsystemd/sd-bus/bus-dump.h

@@ -5,5 +5,5 @@
 
 int bus_creds_dump(sd_bus_creds *c, FILE *f, bool terse);
 
-int bus_pcap_header(size_t snaplen, const char *os, const char *app, FILE *f);
+int bus_pcap_header(size_t snaplen, const char *os, const char *info, FILE *f);
 int bus_message_pcap_frame(sd_bus_message *m, size_t snaplen, FILE *f);

src/libsystemd/sd-bus/bus-match.h

@@ -77,7 +77,7 @@ typedef enum BusMatchScope {
         BUS_MATCH_DRIVER,
 } BusMatchScope;
 
-int bus_match_run(sd_bus *bus, BusMatchNode *root, sd_bus_message *m);
+int bus_match_run(sd_bus *bus, BusMatchNode *node, sd_bus_message *m);
 
 int bus_match_add(BusMatchNode *root, BusMatchComponent *components, size_t n_components, BusMatchCallback *callback);
 int bus_match_remove(BusMatchNode *root, BusMatchCallback *callback);

src/libsystemd/sd-bus/bus-message.c

@@ -700,12 +700,12 @@ _public_ int sd_bus_message_new_method_errno(
                 sd_bus_message *call,
                 sd_bus_message **ret,
                 int error,
-                const sd_bus_error *p) {
+                const sd_bus_error *e) {
 
         _cleanup_(sd_bus_error_free) sd_bus_error berror = SD_BUS_ERROR_NULL;
 
-        if (sd_bus_error_is_set(p))
-                return sd_bus_message_new_method_error(call, ret, p);
+        if (sd_bus_error_is_set(e))
+                return sd_bus_message_new_method_error(call, ret, e);
 
         sd_bus_error_set_errno(&berror, error);
 

src/libsystemd/sd-bus/bus-message.h

@@ -189,7 +189,7 @@ int bus_message_get_arg_strv(sd_bus_message *m, unsigned i, char ***strv);
 int bus_body_part_map(BusMessageBodyPart *part);
 void bus_body_part_unmap(BusMessageBodyPart *part);
 
-int bus_message_new_synthetic_error(sd_bus *bus, uint64_t serial, const sd_bus_error *e, sd_bus_message **m);
+int bus_message_new_synthetic_error(sd_bus *bus, uint64_t cookie, const sd_bus_error *e, sd_bus_message **m);
 
 int bus_message_remarshal(sd_bus *bus, sd_bus_message **m);
 

src/libsystemd/sd-bus/sd-bus.c

@@ -3972,18 +3972,18 @@ _public_ int sd_bus_default(sd_bus **ret) {
         return bus_default(bus_open, busp, ret);
 }
 
-_public_ int sd_bus_get_tid(sd_bus *b, pid_t *tid) {
+_public_ int sd_bus_get_tid(sd_bus *b, pid_t *ret) {
         assert_return(b, -EINVAL);
-        assert_return(tid, -EINVAL);
+        assert_return(ret, -EINVAL);
         assert_return(!bus_origin_changed(b), -ECHILD);
 
         if (b->tid != 0) {
-                *tid = b->tid;
+                *ret = b->tid;
                 return 0;
         }
 
         if (b->event)
-                return sd_event_get_tid(b->event, tid);
+                return sd_event_get_tid(b->event, ret);
 
         return -ENXIO;
 }

src/libsystemd/sd-device/device-internal.h

@@ -109,7 +109,7 @@ static inline int device_add_property_internal(sd_device *device, const char *ke
 }
 
 int device_set_syspath(sd_device *device, const char *_syspath, bool verify);
-int device_set_ifindex(sd_device *device, const char *ifindex);
+int device_set_ifindex(sd_device *device, const char *name);
 int device_set_devuid(sd_device *device, const char *uid);
 int device_set_devgid(sd_device *device, const char *gid);
 int device_set_devmode(sd_device *device, const char *devmode);

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

@@ -41,7 +41,7 @@ int device_ensure_usec_initialized(sd_device *device, sd_device *device_old);
 int device_add_devlink(sd_device *device, const char *devlink);
 int device_remove_devlink(sd_device *device, const char *devlink);
 bool device_has_devlink(sd_device *device, const char *devlink);
-int device_add_property(sd_device *device, const char *property, const char *value);
+int device_add_property(sd_device *device, const char *key, const char *value);
 int device_add_propertyf(sd_device *device, const char *key, const char *format, ...) _printf_(3, 4);
 int device_add_tag(sd_device *device, const char *tag, bool both);
 void device_remove_tag(sd_device *device, const char *tag);

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

@@ -1139,24 +1139,24 @@ static int device_new_from_child(sd_device **ret, sd_device *child) {
         }
 }
 
-_public_ int sd_device_get_parent(sd_device *child, sd_device **ret) {
+_public_ int sd_device_get_parent(sd_device *device, sd_device **ret) {
         int r;
 
-        assert_return(child, -EINVAL);
+        assert_return(device, -EINVAL);
 
-        if (!child->parent_set) {
-                r = device_new_from_child(&child->parent, child);
+        if (!device->parent_set) {
+                r = device_new_from_child(&device->parent, device);
                 if (r < 0 && r != -ENODEV)
                         return r;
 
-                child->parent_set = true;
+                device->parent_set = true;
         }
 
-        if (!child->parent)
+        if (!device->parent)
                 return -ENOENT;
 
         if (ret)
-                *ret = child->parent;
+                *ret = device->parent;
         return 0;
 }
 
@@ -1276,7 +1276,7 @@ _public_ int sd_device_get_driver_subsystem(sd_device *device, const char **ret)
         return 0;
 }
 
-_public_ int sd_device_get_devtype(sd_device *device, const char **devtype) {
+_public_ int sd_device_get_devtype(sd_device *device, const char **ret) {
         int r;
 
         assert_return(device, -EINVAL);
@@ -1288,8 +1288,8 @@ _public_ int sd_device_get_devtype(sd_device *device, const char **devtype) {
         if (!device->devtype)
                 return -ENOENT;
 
-        if (devtype)
-                *devtype = device->devtype;
+        if (ret)
+                *ret = device->devtype;
 
         return 0;
 }
@@ -1398,7 +1398,7 @@ _public_ int sd_device_get_devpath(sd_device *device, const char **ret) {
         return 0;
 }
 
-_public_ int sd_device_get_devname(sd_device *device, const char **devname) {
+_public_ int sd_device_get_devname(sd_device *device, const char **ret) {
         int r;
 
         assert_return(device, -EINVAL);
@@ -1412,8 +1412,8 @@ _public_ int sd_device_get_devname(sd_device *device, const char **devname) {
 
         assert(!isempty(path_startswith(device->devname, "/dev/")));
 
-        if (devname)
-                *devname = device->devname;
+        if (ret)
+                *ret = device->devname;
         return 0;
 }
 

src/libsystemd/sd-event/sd-event.c

@@ -3026,13 +3026,13 @@ static int event_source_online(
         return 1;
 }
 
-_public_ int sd_event_source_set_enabled(sd_event_source *s, int m) {
+_public_ int sd_event_source_set_enabled(sd_event_source *s, int enabled) {
         int r;
 
-        assert_return(IN_SET(m, SD_EVENT_OFF, SD_EVENT_ON, SD_EVENT_ONESHOT), -EINVAL);
+        assert_return(IN_SET(enabled, SD_EVENT_OFF, SD_EVENT_ON, SD_EVENT_ONESHOT), -EINVAL);
 
         /* Quick mode: if the source doesn't exist, SD_EVENT_OFF is a noop. */
-        if (m == SD_EVENT_OFF && !s)
+        if (enabled == SD_EVENT_OFF && !s)
                 return 0;
 
         assert_return(s, -EINVAL);
@@ -3040,15 +3040,15 @@ _public_ int sd_event_source_set_enabled(sd_event_source *s, int m) {
 
         /* If we are dead anyway, we are fine with turning off sources, but everything else needs to fail. */
         if (s->event->state == SD_EVENT_FINISHED)
-                return m == SD_EVENT_OFF ? 0 : -ESTALE;
+                return enabled == SD_EVENT_OFF ? 0 : -ESTALE;
 
-        if (s->enabled == m) /* No change? */
+        if (s->enabled == enabled) /* No change? */
                 return 0;
 
-        if (m == SD_EVENT_OFF)
-                r = event_source_offline(s, m, s->ratelimited);
+        if (enabled == SD_EVENT_OFF)
+                r = event_source_offline(s, enabled, s->ratelimited);
         else
-                r = event_source_online(s, m, s->ratelimited);
+                r = event_source_online(s, enabled, s->ratelimited);
         if (r < 0)
                 return r;
 

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

@@ -17,6 +17,6 @@ int journal_file_fss_load(JournalFile *f);
 int journal_file_parse_verification_key(JournalFile *f, const char *key);
 
 int journal_file_fsprg_evolve(JournalFile *f, uint64_t realtime);
-int journal_file_fsprg_seek(JournalFile *f, uint64_t epoch);
+int journal_file_fsprg_seek(JournalFile *f, uint64_t goal);
 
 bool journal_file_next_evolve_usec(JournalFile *f, usec_t *u);

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

@@ -150,7 +150,7 @@ int journal_file_open(
                 JournalFile **ret);
 
 int journal_file_set_offline_thread_join(JournalFile *f);
-JournalFile* journal_file_close(JournalFile *j);
+JournalFile* journal_file_close(JournalFile *f);
 int journal_file_fstat(JournalFile *f);
 DEFINE_TRIVIAL_CLEANUP_FUNC(JournalFile*, journal_file_close);
 

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

@@ -2324,14 +2324,14 @@ static sd_journal *journal_new(int flags, const char *path, const char *namespac
          SD_JOURNAL_INCLUDE_DEFAULT_NAMESPACE |         \
          SD_JOURNAL_ASSUME_IMMUTABLE)
 
-_public_ int sd_journal_open_namespace(sd_journal **ret, const char *namespace, int flags) {
+_public_ int sd_journal_open_namespace(sd_journal **ret, const char *name_space, int flags) {
         _cleanup_(sd_journal_closep) sd_journal *j = NULL;
         int r;
 
         assert_return(ret, -EINVAL);
         assert_return((flags & ~OPEN_ALLOWED_FLAGS) == 0, -EINVAL);
 
-        j = journal_new(flags, NULL, namespace);
+        j = journal_new(flags, NULL, name_space);
         if (!j)
                 return -ENOMEM;
 
@@ -2813,7 +2813,7 @@ static bool field_is_valid(const char *field) {
         return true;
 }
 
-_public_ int sd_journal_get_data(sd_journal *j, const char *field, const void **data, size_t *size) {
+_public_ int sd_journal_get_data(sd_journal *j, const char *field, const void **data, size_t *length) {
         JournalFile *f;
         size_t field_length;
         Object *o;
@@ -2823,7 +2823,7 @@ _public_ int sd_journal_get_data(sd_journal *j, const char *field, const void **
         assert_return(!journal_origin_changed(j), -ECHILD);
         assert_return(field, -EINVAL);
         assert_return(data, -EINVAL);
-        assert_return(size, -EINVAL);
+        assert_return(length, -EINVAL);
         assert_return(field_is_valid(field), -EINVAL);
 
         f = j->current_file;
@@ -2857,7 +2857,7 @@ _public_ int sd_journal_get_data(sd_journal *j, const char *field, const void **
                         return r;
 
                 *data = d;
-                *size = l;
+                *length = l;
 
                 return 0;
         }
@@ -2865,7 +2865,7 @@ _public_ int sd_journal_get_data(sd_journal *j, const char *field, const void **
         return -ENOENT;
 }
 
-_public_ int sd_journal_enumerate_data(sd_journal *j, const void **data, size_t *size) {
+_public_ int sd_journal_enumerate_data(sd_journal *j, const void **data, size_t *length) {
         JournalFile *f;
         Object *o;
         int r;
@@ -2873,7 +2873,7 @@ _public_ int sd_journal_enumerate_data(sd_journal *j, const void **data, size_t
         assert_return(j, -EINVAL);
         assert_return(!journal_origin_changed(j), -ECHILD);
         assert_return(data, -EINVAL);
-        assert_return(size, -EINVAL);
+        assert_return(length, -EINVAL);
 
         f = j->current_file;
         if (!f)
@@ -2902,7 +2902,7 @@ _public_ int sd_journal_enumerate_data(sd_journal *j, const void **data, size_t
                 assert(r > 0);
 
                 *data = d;
-                *size = l;
+                *length = l;
 
                 j->current_field++;
 
@@ -2912,11 +2912,11 @@ _public_ int sd_journal_enumerate_data(sd_journal *j, const void **data, size_t
         return 0;
 }
 
-_public_ int sd_journal_enumerate_available_data(sd_journal *j, const void **data, size_t *size) {
+_public_ int sd_journal_enumerate_available_data(sd_journal *j, const void **data, size_t *length) {
         for (;;) {
                 int r;
 
-                r = sd_journal_enumerate_data(j, data, size);
+                r = sd_journal_enumerate_data(j, data, length);
                 if (r >= 0)
                         return r;
                 if (!JOURNAL_ERRNO_IS_UNAVAILABLE_FIELD(r))
@@ -3300,13 +3300,13 @@ void journal_print_header(sd_journal *j) {
         }
 }
 
-_public_ int sd_journal_get_usage(sd_journal *j, uint64_t *ret) {
+_public_ int sd_journal_get_usage(sd_journal *j, uint64_t *ret_bytes) {
         JournalFile *f;
         uint64_t sum = 0;
 
         assert_return(j, -EINVAL);
         assert_return(!journal_origin_changed(j), -ECHILD);
-        assert_return(ret, -EINVAL);
+        assert_return(ret_bytes, -EINVAL);
 
         ORDERED_HASHMAP_FOREACH(f, j->files) {
                 struct stat st;
@@ -3325,7 +3325,7 @@ _public_ int sd_journal_get_usage(sd_journal *j, uint64_t *ret) {
                 sum += b;
         }
 
-        *ret = sum;
+        *ret_bytes = sum;
         return 0;
 }
 

src/libsystemd/sd-json/sd-json.c

@@ -1277,7 +1277,7 @@ mismatch:
         return 0;
 }
 
-_public_ sd_json_variant *sd_json_variant_by_index(sd_json_variant *v, size_t idx) {
+_public_ sd_json_variant *sd_json_variant_by_index(sd_json_variant *v, size_t index) {
         if (!v)
                 return NULL;
         if (v == JSON_VARIANT_MAGIC_EMPTY_ARRAY ||
@@ -1288,11 +1288,11 @@ _public_ sd_json_variant *sd_json_variant_by_index(sd_json_variant *v, size_t id
         if (!IN_SET(v->type, SD_JSON_VARIANT_ARRAY, SD_JSON_VARIANT_OBJECT))
                 goto mismatch;
         if (v->is_reference)
-                return sd_json_variant_by_index(v->reference, idx);
-        if (idx >= v->n_elements)
+                return sd_json_variant_by_index(v->reference, index);
+        if (index >= v->n_elements)
                 return NULL;
 
-        return json_variant_conservative_formalize(v + 1 + idx);
+        return json_variant_conservative_formalize(v + 1 + index);
 
 mismatch:
         log_debug("Element in non-array/non-object JSON variant requested by index, returning NULL.");
@@ -2079,22 +2079,22 @@ _public_ int sd_json_variant_set_field_uuid(sd_json_variant **v, const char *fie
         return sd_json_variant_set_field_string(v, field, SD_ID128_TO_UUID_STRING(value));
 }
 
-_public_ int sd_json_variant_set_field_integer(sd_json_variant **v, const char *field, int64_t i) {
+_public_ int sd_json_variant_set_field_integer(sd_json_variant **v, const char *field, int64_t value) {
         _cleanup_(sd_json_variant_unrefp) sd_json_variant *m = NULL;
         int r;
 
-        r = sd_json_variant_new_integer(&m, i);
+        r = sd_json_variant_new_integer(&m, value);
         if (r < 0)
                 return r;
 
         return sd_json_variant_set_field(v, field, m);
 }
 
-_public_ int sd_json_variant_set_field_unsigned(sd_json_variant **v, const char *field, uint64_t u) {
+_public_ int sd_json_variant_set_field_unsigned(sd_json_variant **v, const char *field, uint64_t value) {
         _cleanup_(sd_json_variant_unrefp) sd_json_variant *m = NULL;
         int r;
 
-        r = sd_json_variant_new_unsigned(&m, u);
+        r = sd_json_variant_new_unsigned(&m, value);
         if (r < 0)
                 return r;
 
@@ -3379,7 +3379,7 @@ finish:
 }
 
 _public_ int sd_json_parse_with_source(
-                const char *input,
+                const char *string,
                 const char *source,
                 sd_json_parse_flags_t flags,
                 sd_json_variant **ret,
@@ -3388,7 +3388,7 @@ _public_ int sd_json_parse_with_source(
 
         _cleanup_(json_source_unrefp) JsonSource *s = NULL;
 
-        if (isempty(input))
+        if (isempty(string))
                 return -ENODATA;
 
         if (source) {
@@ -3397,7 +3397,7 @@ _public_ int sd_json_parse_with_source(
                         return -ENOMEM;
         }
 
-        return json_parse_internal(&input, s, flags, ret, reterr_line, reterr_column, false);
+        return json_parse_internal(&string, s, flags, ret, reterr_line, reterr_column, false);
 }
 
 _public_ int sd_json_parse_with_source_continue(

src/libsystemd/sd-login/sd-login.c

@@ -63,12 +63,12 @@ _public_ int sd_pid_get_user_unit(pid_t pid, char **ret_unit) {
         return IN_SET(r, -ENXIO, -ENOMEDIUM) ? -ENODATA : r;
 }
 
-_public_ int sd_pid_get_machine_name(pid_t pid, char **ret_name) {
+_public_ int sd_pid_get_machine_name(pid_t pid, char **ret_machine) {
         int r;
 
         assert_return(pid >= 0, -EINVAL);
 
-        r = cg_pid_get_machine_name(pid, ret_name);
+        r = cg_pid_get_machine_name(pid, ret_machine);
         return IN_SET(r, -ENXIO, -ENOMEDIUM) ? -ENODATA : r;
 }
 
@@ -196,7 +196,7 @@ _public_ int sd_pidfd_get_user_unit(int pidfd, char **ret_unit) {
         return 0;
 }
 
-_public_ int sd_pidfd_get_machine_name(int pidfd, char **ret_name) {
+_public_ int sd_pidfd_get_machine_name(int pidfd, char **ret_machine) {
         _cleanup_free_ char *name = NULL;
         pid_t pid;
         int r;
@@ -215,8 +215,8 @@ _public_ int sd_pidfd_get_machine_name(int pidfd, char **ret_name) {
         if (r < 0)
                 return r;
 
-        if (ret_name)
-                *ret_name = TAKE_PTR(name);
+        if (ret_machine)
+                *ret_machine = TAKE_PTR(name);
         return 0;
 }
 
@@ -469,7 +469,7 @@ _public_ int sd_uid_get_state(uid_t uid, char **ret_state) {
         return 0;
 }
 
-_public_ int sd_uid_get_display(uid_t uid, char **ret_session) {
+_public_ int sd_uid_get_display(uid_t uid, char **ret_display) {
         _cleanup_free_ char *p = NULL, *s = NULL;
         int r;
 
@@ -485,8 +485,8 @@ _public_ int sd_uid_get_display(uid_t uid, char **ret_session) {
         if (isempty(s))
                 return -ENODATA;
 
-        if (ret_session)
-                *ret_session = TAKE_PTR(s);
+        if (ret_display)
+                *ret_display = TAKE_PTR(s);
         return 0;
 }
 
@@ -790,8 +790,8 @@ _public_ int sd_session_get_type(const char *session, char **ret_type) {
         return session_get_string(session, "TYPE", ret_type);
 }
 
-_public_ int sd_session_get_class(const char *session, char **ret_class) {
-        return session_get_string(session, "CLASS", ret_class);
+_public_ int sd_session_get_class(const char *session, char **ret_clazz) {
+        return session_get_string(session, "CLASS", ret_clazz);
 }
 
 _public_ int sd_session_get_desktop(const char *session, char **ret_desktop) {
@@ -1059,7 +1059,7 @@ _public_ int sd_get_machine_names(char ***ret_machines) {
         return r;
 }
 
-_public_ int sd_machine_get_class(const char *machine, char **ret_class) {
+_public_ int sd_machine_get_class(const char *machine, char **ret_clazz) {
         _cleanup_free_ char *c = NULL;
         int r;
 
@@ -1084,8 +1084,8 @@ _public_ int sd_machine_get_class(const char *machine, char **ret_class) {
                         return -EIO;
         }
 
-        if (ret_class)
-                *ret_class = TAKE_PTR(c);
+        if (ret_clazz)
+                *ret_clazz = TAKE_PTR(c);
 
         return 0;
 }

src/libsystemd/sd-netlink/netlink-internal.h

@@ -175,7 +175,7 @@ int sd_nfnl_socket_open(sd_netlink **ret);
 int sd_nfnl_send_batch(
                 sd_netlink *nfnl,
                 sd_netlink_message **messages,
-                size_t msgcount,
+                size_t n_messages,
                 uint32_t **ret_serials);
 int sd_nfnl_call_batch(
                 sd_netlink *nfnl,
@@ -199,7 +199,7 @@ int sd_nfnl_nft_message_new_rule(sd_netlink *nfnl, sd_netlink_message **ret,
                                  int nfproto, const char *table, const char *chain);
 int sd_nfnl_nft_message_new_set(sd_netlink *nfnl, sd_netlink_message **ret,
                                 int nfproto, const char *table, const char *set_name,
-                                uint32_t setid, uint32_t klen);
+                                uint32_t set_id, uint32_t klen);
 int sd_nfnl_nft_message_new_setelems(sd_netlink *nfnl, sd_netlink_message **ret,
                                      int add, int nfproto, const char *table, const char *set_name);
 int sd_nfnl_nft_message_append_setelem(sd_netlink_message *m,

src/libsystemd/sd-netlink/netlink-message-rtnl.c

@@ -54,7 +54,8 @@ static bool rtnl_message_type_is_nsid(uint16_t type) {
         return IN_SET(type, RTM_NEWNSID, RTM_DELNSID, RTM_GETNSID);
 }
 
-#define DEFINE_RTNL_MESSAGE_SETTER(class, header_type, element, name, value_type) \
+#define DEFINE_RTNL_MESSAGE_SETTER(class, header_type, element, name, value_type)  \
+        /* NOLINTNEXTLINE (readability-inconsistent-declaration-parameter-name) */ \
         int sd_rtnl_message_##class##_set_##name(sd_netlink_message *m, value_type value) { \
                 assert_return(m, -EINVAL);                              \
                 assert_return(m->hdr, -EINVAL);                         \
@@ -66,6 +67,7 @@ static bool rtnl_message_type_is_nsid(uint16_t type) {
         }
 
 #define DEFINE_RTNL_MESSAGE_PREFIXLEN_SETTER(class, header_type, family_element, element, name, value_type) \
+        /* NOLINTNEXTLINE (readability-inconsistent-declaration-parameter-name) */                          \
         int sd_rtnl_message_##class##_set_##name(sd_netlink_message *m, value_type value) { \
                 assert_return(m, -EINVAL);                              \
                 assert_return(m->hdr, -EINVAL);                         \

src/libsystemd/sd-netlink/netlink-types.h

@@ -56,8 +56,8 @@ int netlink_get_policy_set_and_header_size(
                 size_t *ret_header_size);
 
 const NLAPolicy *policy_set_get_policy(const NLAPolicySet *policy_set, uint16_t attr_type);
-const NLAPolicySet *policy_set_get_policy_set(const NLAPolicySet *type_system, uint16_t attr_type);
-const NLAPolicySetUnion *policy_set_get_policy_set_union(const NLAPolicySet *type_system, uint16_t attr_type);
+const NLAPolicySet *policy_set_get_policy_set(const NLAPolicySet *policy_set, uint16_t attr_type);
+const NLAPolicySetUnion *policy_set_get_policy_set_union(const NLAPolicySet *policy_set, uint16_t attr_type);
 uint16_t policy_set_union_get_match_attribute(const NLAPolicySetUnion *policy_set_union);
-const NLAPolicySet *policy_set_union_get_policy_set_by_string(const NLAPolicySetUnion *type_system_union, const char *string);
-const NLAPolicySet *policy_set_union_get_policy_set_by_family(const NLAPolicySetUnion *type_system_union, int family);
+const NLAPolicySet *policy_set_union_get_policy_set_by_string(const NLAPolicySetUnion *policy_set_union, const char *string);
+const NLAPolicySet *policy_set_union_get_policy_set_by_family(const NLAPolicySetUnion *policy_set_union, int family);

src/libsystemd/sd-netlink/netlink-util.h

@@ -157,8 +157,8 @@ int netlink_message_append_hw_addr(sd_netlink_message *m, unsigned short type, c
 int netlink_message_append_in_addr_union(sd_netlink_message *m, unsigned short type, int family, const union in_addr_union *data);
 int netlink_message_append_sockaddr_union(sd_netlink_message *m, unsigned short type, const union sockaddr_union *data);
 
-int netlink_message_read_hw_addr(sd_netlink_message *m, unsigned short type, struct hw_addr_data *data);
-int netlink_message_read_in_addr_union(sd_netlink_message *m, unsigned short type, int family, union in_addr_union *data);
+int netlink_message_read_hw_addr(sd_netlink_message *m, unsigned short type, struct hw_addr_data *ret);
+int netlink_message_read_in_addr_union(sd_netlink_message *m, unsigned short type, int family, union in_addr_union *ret);
 
 void rtattr_append_attribute_internal(struct rtattr *rta, unsigned short type, const void *data, size_t data_length);
 int rtattr_append_attribute(struct rtattr **rta, unsigned short type, const void *data, size_t data_length);
@@ -168,4 +168,4 @@ void netlink_seal_message(sd_netlink *nl, sd_netlink_message *m);
 size_t netlink_get_reply_callback_count(sd_netlink *nl);
 
 /* TODO: to be exported later */
-int sd_netlink_sendv(sd_netlink *nl, sd_netlink_message **messages, size_t msgcnt, uint32_t **ret_serial);
+int sd_netlink_sendv(sd_netlink *nl, sd_netlink_message **messages, size_t msgcount, uint32_t **ret_serial);

src/libsystemd/sd-netlink/sd-netlink.c

@@ -540,16 +540,16 @@ int sd_netlink_call_async(
 int sd_netlink_read(
                 sd_netlink *nl,
                 uint32_t serial,
-                uint64_t usec,
+                uint64_t timeout,
                 sd_netlink_message **ret) {
 
-        usec_t timeout;
+        usec_t usec;
         int r;
 
         assert_return(nl, -EINVAL);
         assert_return(!netlink_pid_changed(nl), -ECHILD);
 
-        timeout = timespan_to_timestamp(usec);
+        usec = timespan_to_timestamp(timeout);
 
         for (;;) {
                 _cleanup_(sd_netlink_message_unrefp) sd_netlink_message *m = NULL;
@@ -588,14 +588,14 @@ int sd_netlink_read(
                         /* received message, so try to process straight away */
                         continue;
 
-                if (timeout != USEC_INFINITY) {
+                if (usec != USEC_INFINITY) {
                         usec_t n;
 
                         n = now(CLOCK_MONOTONIC);
-                        if (n >= timeout)
+                        if (n >= usec)
                                 return -ETIMEDOUT;
 
-                        left = usec_sub_unsigned(timeout, n);
+                        left = usec_sub_unsigned(usec, n);
                 } else
                         left = USEC_INFINITY;
 
@@ -610,7 +610,7 @@ int sd_netlink_read(
 int sd_netlink_call(
                 sd_netlink *nl,
                 sd_netlink_message *message,
-                uint64_t usec,
+                uint64_t timeout,
                 sd_netlink_message **ret) {
 
         uint32_t serial;
@@ -624,7 +624,7 @@ int sd_netlink_call(
         if (r < 0)
                 return r;
 
-        return sd_netlink_read(nl, serial, usec, ret);
+        return sd_netlink_read(nl, serial, timeout, ret);
 }
 
 int sd_netlink_get_events(sd_netlink *nl) {

src/libsystemd/sd-network/sd-network.c

@@ -379,12 +379,12 @@ static int monitor_add_inotify_watch(int fd) {
         return wd;
 }
 
-int sd_network_monitor_new(sd_network_monitor **m, const char *category) {
+int sd_network_monitor_new(sd_network_monitor **ret, const char *category) {
         _cleanup_close_ int fd = -EBADF;
         int k;
         bool good = false;
 
-        assert_return(m, -EINVAL);
+        assert_return(ret, -EINVAL);
 
         fd = inotify_init1(IN_NONBLOCK|IN_CLOEXEC);
         if (fd < 0)
@@ -401,7 +401,7 @@ int sd_network_monitor_new(sd_network_monitor **m, const char *category) {
         if (!good)
                 return -EINVAL;
 
-        *m = FD_TO_MONITOR(TAKE_FD(fd));
+        *ret = FD_TO_MONITOR(TAKE_FD(fd));
         return 0;
 }
 

src/libsystemd/sd-resolve/resolve-private.h

@@ -4,12 +4,12 @@
 #include "sd-resolve.h"
 
 int resolve_getaddrinfo_with_destroy_callback(
-                sd_resolve *resolve, sd_resolve_query **q,
+                sd_resolve *resolve, sd_resolve_query **ret,
                 const char *node, const char *service, const struct addrinfo *hints,
                 sd_resolve_getaddrinfo_handler_t callback,
                 sd_resolve_destroy_t destroy_callback, void *userdata);
 int resolve_getnameinfo_with_destroy_callback(
-                sd_resolve *resolve, sd_resolve_query **q,
+                sd_resolve *resolve, sd_resolve_query **ret,
                 const struct sockaddr *sa, socklen_t salen, int flags, uint64_t get,
                 sd_resolve_getnameinfo_handler_t callback,
                 sd_resolve_destroy_t destroy_callback, void *userdata);

src/libsystemd/sd-resolve/sd-resolve.c

@@ -1011,7 +1011,7 @@ static int getaddrinfo_done(sd_resolve_query* q) {
 
 int resolve_getnameinfo_with_destroy_callback(
                 sd_resolve *resolve,
-                sd_resolve_query **ret_query,
+                sd_resolve_query **ret,
                 const struct sockaddr *sa, socklen_t salen,
                 int flags,
                 uint64_t get,
@@ -1033,7 +1033,7 @@ int resolve_getnameinfo_with_destroy_callback(
         assert_return(callback, -EINVAL);
         assert_return(!resolve_pid_changed(resolve), -ECHILD);
 
-        r = alloc_query(resolve, !ret_query, &q);
+        r = alloc_query(resolve, !ret, &q);
         if (r < 0)
                 return r;
 
@@ -1068,8 +1068,8 @@ int resolve_getnameinfo_with_destroy_callback(
         resolve->n_outstanding++;
         q->destroy_callback = destroy_callback;
 
-        if (ret_query)
-                *ret_query = q;
+        if (ret)
+                *ret = q;
 
         TAKE_PTR(q);
 

src/libsystemd/sd-varlink/sd-varlink.c

@@ -2797,13 +2797,13 @@ _public_ int sd_varlink_dispatch(sd_varlink *v, sd_json_variant *parameters, con
         return 0;
 }
 
-_public_ int sd_varlink_bind_reply(sd_varlink *v, sd_varlink_reply_t callback) {
+_public_ int sd_varlink_bind_reply(sd_varlink *v, sd_varlink_reply_t reply) {
         assert_return(v, -EINVAL);
 
-        if (callback && v->reply_callback && callback != v->reply_callback)
+        if (reply && v->reply_callback && reply != v->reply_callback)
                 return varlink_log_errno(v, SYNTHETIC_ERRNO(EBUSY), "A different callback was already set.");
 
-        v->reply_callback = callback;
+        v->reply_callback = reply;
 
         return 0;
 }
@@ -4085,23 +4085,23 @@ _public_ int sd_varlink_server_bind_method_many_internal(sd_varlink_server *s, .
         return r;
 }
 
-_public_ int sd_varlink_server_bind_connect(sd_varlink_server *s, sd_varlink_connect_t callback) {
+_public_ int sd_varlink_server_bind_connect(sd_varlink_server *s, sd_varlink_connect_t connect) {
         assert_return(s, -EINVAL);
 
-        if (callback && s->connect_callback && callback != s->connect_callback)
+        if (connect && s->connect_callback && connect != s->connect_callback)
                 return varlink_server_log_errno(s, SYNTHETIC_ERRNO(EBUSY), "A different callback was already set.");
 
-        s->connect_callback = callback;
+        s->connect_callback = connect;
         return 0;
 }
 
-_public_ int sd_varlink_server_bind_disconnect(sd_varlink_server *s, sd_varlink_disconnect_t callback) {
+_public_ int sd_varlink_server_bind_disconnect(sd_varlink_server *s, sd_varlink_disconnect_t disconnect) {
         assert_return(s, -EINVAL);
 
-        if (callback && s->disconnect_callback && callback != s->disconnect_callback)
+        if (disconnect && s->disconnect_callback && disconnect != s->disconnect_callback)
                 return varlink_server_log_errno(s, SYNTHETIC_ERRNO(EBUSY), "A different callback was already set.");
 
-        s->disconnect_callback = callback;
+        s->disconnect_callback = disconnect;
         return 0;
 }
 

src/login/logind-action.c

@@ -348,16 +348,16 @@ static int manager_handle_action_secure_attention_key(
 int manager_handle_action(
                 Manager *m,
                 InhibitWhat inhibit_key,
-                HandleAction handle,
+                HandleAction action,
                 bool ignore_inhibited,
                 bool is_edge,
                 const char *action_seat) {
 
         assert(m);
-        assert(handle_action_valid(handle));
+        assert(handle_action_valid(action));
 
         /* If the key handling is turned off, don't do anything */
-        if (handle == HANDLE_IGNORE) {
+        if (action == HANDLE_IGNORE) {
                 log_debug("Handling of %s (%s) is disabled, taking no action.",
                           inhibit_key == 0 ? "idle timeout" : inhibit_what_to_string(inhibit_key),
                           is_edge ? "edge" : "level");
@@ -377,14 +377,14 @@ int manager_handle_action(
         if (inhibit_key > 0) {
                 if (manager_is_inhibited(m, inhibit_key, NULL, MANAGER_IS_INHIBITED_IGNORE_INACTIVE, UID_INVALID, NULL)) {
                         log_debug("Refusing %s operation, %s is inhibited.",
-                                  handle_action_to_string(handle),
+                                  handle_action_to_string(action),
                                   inhibit_what_to_string(inhibit_key));
                         return 0;
                 }
         }
 
         /* Locking and greeter activation is handled differently from the rest. */
-        if (handle == HANDLE_LOCK) {
+        if (action == HANDLE_LOCK) {
                 if (!is_edge)
                         return 0;
 
@@ -393,13 +393,13 @@ int manager_handle_action(
                 return 1;
         }
 
-        if (handle == HANDLE_SECURE_ATTENTION_KEY)
+        if (action == HANDLE_SECURE_ATTENTION_KEY)
                 return manager_handle_action_secure_attention_key(m, is_edge, action_seat);
 
-        if (HANDLE_ACTION_IS_SLEEP(handle))
-                return handle_action_sleep_execute(m, handle, ignore_inhibited, is_edge);
+        if (HANDLE_ACTION_IS_SLEEP(action))
+                return handle_action_sleep_execute(m, action, ignore_inhibited, is_edge);
 
-        return handle_action_execute(m, handle, ignore_inhibited, is_edge);
+        return handle_action_execute(m, action, ignore_inhibited, is_edge);
 }
 
 static const char* const handle_action_verb_table[_HANDLE_ACTION_MAX] = {