]>
git.ipfire.org Git - thirdparty/systemd.git/blob - src/basic/util.h
1 /* SPDX-License-Identifier: LGPL-2.1+ */
17 #include <sys/inotify.h>
18 #include <sys/socket.h>
20 #include <sys/statfs.h>
21 #include <sys/sysmacros.h>
22 #include <sys/types.h>
26 #include "format-util.h"
28 #include "time-util.h"
30 size_t page_size(void) _pure_
;
31 #define PAGE_ALIGN(l) ALIGN_TO((l), page_size())
33 static inline const char* yes_no(bool b
) {
34 return b
? "yes" : "no";
37 static inline const char* true_false(bool b
) {
38 return b
? "true" : "false";
41 static inline const char* one_zero(bool b
) {
45 static inline const char* enable_disable(bool b
) {
46 return b
? "enable" : "disable";
49 bool plymouth_running(void);
51 bool display_is_local(const char *display
) _pure_
;
53 #define NULSTR_FOREACH(i, l) \
54 for ((i) = (l); (i) && *(i); (i) = strchr((i), 0)+1)
56 #define NULSTR_FOREACH_PAIR(i, j, l) \
57 for ((i) = (l), (j) = strchr((i), 0)+1; (i) && *(i); (i) = strchr((j), 0)+1, (j) = *(i) ? strchr((i), 0)+1 : (i))
59 extern int saved_argc
;
60 extern char **saved_argv
;
62 bool kexec_loaded(void);
64 int prot_from_flags(int flags
) _const_
;
67 void in_initrd_force(bool value
);
69 void *xbsearch_r(const void *key
, const void *base
, size_t nmemb
, size_t size
,
70 __compar_d_fn_t compar
, void *arg
);
72 #define typesafe_bsearch_r(k, b, n, func, userdata) \
74 const typeof(b[0]) *_k = k; \
75 int (*_func_)(const typeof(b[0])*, const typeof(b[0])*, typeof(userdata)) = func; \
76 xbsearch_r((const void*) _k, (b), (n), sizeof((b)[0]), (__compar_d_fn_t) _func_, userdata); \
80 * Normal bsearch requires base to be nonnull. Here were require
81 * that only if nmemb > 0.
83 static inline void* bsearch_safe(const void *key
, const void *base
,
84 size_t nmemb
, size_t size
, __compar_fn_t compar
) {
89 return bsearch(key
, base
, nmemb
, size
, compar
);
92 #define typesafe_bsearch(k, b, n, func) \
94 const typeof(b[0]) *_k = k; \
95 int (*_func_)(const typeof(b[0])*, const typeof(b[0])*) = func; \
96 bsearch_safe((const void*) _k, (b), (n), sizeof((b)[0]), (__compar_fn_t) _func_); \
100 * Normal qsort requires base to be nonnull. Here were require
101 * that only if nmemb > 0.
103 static inline void qsort_safe(void *base
, size_t nmemb
, size_t size
, __compar_fn_t compar
) {
108 qsort(base
, nmemb
, size
, compar
);
111 /* A wrapper around the above, but that adds typesafety: the element size is automatically derived from the type and so
112 * is the prototype for the comparison function */
113 #define typesafe_qsort(p, n, func) \
115 int (*_func_)(const typeof(p[0])*, const typeof(p[0])*) = func; \
116 qsort_safe((p), (n), sizeof((p)[0]), (__compar_fn_t) _func_); \
119 static inline void qsort_r_safe(void *base
, size_t nmemb
, size_t size
, __compar_d_fn_t compar
, void *userdata
) {
124 qsort_r(base
, nmemb
, size
, compar
, userdata
);
127 #define typesafe_qsort_r(p, n, func, userdata) \
129 int (*_func_)(const typeof(p[0])*, const typeof(p[0])*, typeof(userdata)) = func; \
130 qsort_r_safe((p), (n), sizeof((p)[0]), (__compar_d_fn_t) _func_, userdata); \
133 /* Normal memcpy requires src to be nonnull. We do nothing if n is 0. */
134 static inline void memcpy_safe(void *dst
, const void *src
, size_t n
) {
141 /* Normal memcmp requires s1 and s2 to be nonnull. We do nothing if n is 0. */
142 static inline int memcmp_safe(const void *s1
, const void *s2
, size_t n
) {
147 return memcmp(s1
, s2
, n
);
150 int on_ac_power(void);
152 #define memzero(x,l) \
156 _l_ == 0 ? _x_ : memset(_x_, 0, _l_); \
159 #define zero(x) (memzero(&(x), sizeof(x)))
161 bool memeqzero(const void *data
, size_t length
);
163 #define eqzero(x) memeqzero(x, sizeof(x))
165 static inline void *mempset(void *s
, int c
, size_t n
) {
167 return (uint8_t*)s
+ n
;
170 static inline void _reset_errno_(int *saved_errno
) {
171 errno
= *saved_errno
;
174 #define PROTECT_ERRNO \
175 _cleanup_(_reset_errno_) _unused_ int _saved_errno_ = errno
177 static inline int negative_errno(void) {
178 /* This helper should be used to shut up gcc if you know 'errno' is
179 * negative. Instead of "return -errno;", use "return negative_errno();"
180 * It will suppress bogus gcc warnings in case it assumes 'errno' might
181 * be 0 and thus the caller's error-handling might not be triggered. */
182 assert_return(errno
> 0, -EINVAL
);
186 static inline unsigned u64log2(uint64_t n
) {
187 #if __SIZEOF_LONG_LONG__ == 8
188 return (n
> 1) ? (unsigned) __builtin_clzll(n
) ^ 63U : 0;
194 static inline unsigned u32ctz(uint32_t n
) {
195 #if __SIZEOF_INT__ == 4
196 return __builtin_ctz(n
);
202 static inline unsigned log2i(int x
) {
205 return __SIZEOF_INT__
* 8 - __builtin_clz(x
) - 1;
208 static inline unsigned log2u(unsigned x
) {
211 return sizeof(unsigned) * 8 - __builtin_clz(x
) - 1;
214 static inline unsigned log2u_round_up(unsigned x
) {
220 return log2u(x
- 1) + 1;
223 int container_get_leader(const char *machine
, pid_t
*pid
);
225 int namespace_open(pid_t pid
, int *pidns_fd
, int *mntns_fd
, int *netns_fd
, int *userns_fd
, int *root_fd
);
226 int namespace_enter(int pidns_fd
, int mntns_fd
, int netns_fd
, int userns_fd
, int root_fd
);
228 uint64_t physical_memory(void);
229 uint64_t physical_memory_scale(uint64_t v
, uint64_t max
);
231 uint64_t system_tasks_max(void);
232 uint64_t system_tasks_max_scale(uint64_t v
, uint64_t max
);
236 int str_verscmp(const char *s1
, const char *s2
);
238 void disable_coredumps(void);