src/basic/util.h

   1 /* SPDX-License-Identifier: LGPL-2.1+ */
   2 #pragma once
   3
   4 #include <alloca.h>
   5 #include <errno.h>
   6 #include <fcntl.h>
   7 #include <inttypes.h>
   8 #include <limits.h>
   9 #include <locale.h>
  10 #include <stdarg.h>
  11 #include <stdbool.h>
  12 #include <stddef.h>
  13 #include <stdint.h>
  14 #include <stdio.h>
  15 #include <stdlib.h>
  16 #include <string.h>
  17 #include <sys/inotify.h>
  18 #include <sys/socket.h>
  19 #include <sys/stat.h>
  20 #include <sys/statfs.h>
  21 #include <sys/sysmacros.h>
  22 #include <sys/types.h>
  23 #include <time.h>
  24 #include <unistd.h>
  25
  26 #include "format-util.h"
  27 #include "macro.h"
  28 #include "time-util.h"
  29
  30 size_t page_size(void) _pure_;
  31 #define PAGE_ALIGN(l) ALIGN_TO((l), page_size())
  32
  33 static inline const char* yes_no(bool b) {
  34         return b ? "yes" : "no";
  35 }
  36
  37 static inline const char* true_false(bool b) {
  38         return b ? "true" : "false";
  39 }
  40
  41 static inline const char* one_zero(bool b) {
  42         return b ? "1" : "0";
  43 }
  44
  45 static inline const char* enable_disable(bool b) {
  46         return b ? "enable" : "disable";
  47 }
  48
  49 bool plymouth_running(void);
  50
  51 bool display_is_local(const char *display) _pure_;
  52
  53 #define NULSTR_FOREACH(i, l)                                    \
  54         for ((i) = (l); (i) && *(i); (i) = strchr((i), 0)+1)
  55
  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))
  58
  59 extern int saved_argc;
  60 extern char **saved_argv;
  61
  62 bool kexec_loaded(void);
  63
  64 int prot_from_flags(int flags) _const_;
  65
  66 bool in_initrd(void);
  67 void in_initrd_force(bool value);
  68
  69 void *xbsearch_r(const void *key, const void *base, size_t nmemb, size_t size,
  70                  __compar_d_fn_t compar, void *arg);
  71
  72 #define typesafe_bsearch_r(k, b, n, func, userdata)                     \
  73         ({                                                              \
  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); \
  77         })
  78
  79 /**
  80  * Normal bsearch requires base to be nonnull. Here were require
  81  * that only if nmemb > 0.
  82  */
  83 static inline void* bsearch_safe(const void *key, const void *base,
  84                                  size_t nmemb, size_t size, __compar_fn_t compar) {
  85         if (nmemb <= 0)
  86                 return NULL;
  87
  88         assert(base);
  89         return bsearch(key, base, nmemb, size, compar);
  90 }
  91
  92 #define typesafe_bsearch(k, b, n, func)                                 \
  93         ({                                                              \
  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_); \
  97         })
  98
  99 /**
 100  * Normal qsort requires base to be nonnull. Here were require
 101  * that only if nmemb > 0.
 102  */
 103 static inline void qsort_safe(void *base, size_t nmemb, size_t size, __compar_fn_t compar) {
 104         if (nmemb <= 1)
 105                 return;
 106
 107         assert(base);
 108         qsort(base, nmemb, size, compar);
 109 }
 110
 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)                                      \
 114         ({                                                              \
 115                 int (*_func_)(const typeof(p[0])*, const typeof(p[0])*) = func; \
 116                 qsort_safe((p), (n), sizeof((p)[0]), (__compar_fn_t) _func_); \
 117         })
 118
 119 static inline void qsort_r_safe(void *base, size_t nmemb, size_t size, __compar_d_fn_t compar, void *userdata) {
 120         if (nmemb <= 1)
 121                 return;
 122
 123         assert(base);
 124         qsort_r(base, nmemb, size, compar, userdata);
 125 }
 126
 127 #define typesafe_qsort_r(p, n, func, userdata)                          \
 128         ({                                                              \
 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); \
 131         })
 132
 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) {
 135         if (n == 0)
 136                 return;
 137         assert(src);
 138         memcpy(dst, src, n);
 139 }
 140
 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) {
 143         if (n == 0)
 144                 return 0;
 145         assert(s1);
 146         assert(s2);
 147         return memcmp(s1, s2, n);
 148 }
 149
 150 /* Compare s1 (length n1) with s2 (length n2) in lexicographic order. */
 151 static inline int memcmp_nn(const void *s1, size_t n1, const void *s2, size_t n2) {
 152         return memcmp_safe(s1, s2, MIN(n1, n2))
 153             ?: CMP(n1, n2);
 154 }
 155
 156 int on_ac_power(void);
 157
 158 #define memzero(x,l)                                            \
 159         ({                                                      \
 160                 size_t _l_ = (l);                               \
 161                 void *_x_ = (x);                                \
 162                 _l_ == 0 ? _x_ : memset(_x_, 0, _l_);           \
 163         })
 164
 165 #define zero(x) (memzero(&(x), sizeof(x)))
 166
 167 bool memeqzero(const void *data, size_t length);
 168
 169 #define eqzero(x) memeqzero(x, sizeof(x))
 170
 171 static inline void *mempset(void *s, int c, size_t n) {
 172         memset(s, c, n);
 173         return (uint8_t*)s + n;
 174 }
 175
 176 static inline void _reset_errno_(int *saved_errno) {
 177         errno = *saved_errno;
 178 }
 179
 180 #define PROTECT_ERRNO                                                   \
 181         _cleanup_(_reset_errno_) _unused_ int _saved_errno_ = errno
 182
 183 static inline int negative_errno(void) {
 184         /* This helper should be used to shut up gcc if you know 'errno' is
 185          * negative. Instead of "return -errno;", use "return negative_errno();"
 186          * It will suppress bogus gcc warnings in case it assumes 'errno' might
 187          * be 0 and thus the caller's error-handling might not be triggered. */
 188         assert_return(errno > 0, -EINVAL);
 189         return -errno;
 190 }
 191
 192 static inline unsigned u64log2(uint64_t n) {
 193 #if __SIZEOF_LONG_LONG__ == 8
 194         return (n > 1) ? (unsigned) __builtin_clzll(n) ^ 63U : 0;
 195 #else
 196 #error "Wut?"
 197 #endif
 198 }
 199
 200 static inline unsigned u32ctz(uint32_t n) {
 201 #if __SIZEOF_INT__ == 4
 202         return n != 0 ? __builtin_ctz(n) : 32;
 203 #else
 204 #error "Wut?"
 205 #endif
 206 }
 207
 208 static inline unsigned log2i(int x) {
 209         assert(x > 0);
 210
 211         return __SIZEOF_INT__ * 8 - __builtin_clz(x) - 1;
 212 }
 213
 214 static inline unsigned log2u(unsigned x) {
 215         assert(x > 0);
 216
 217         return sizeof(unsigned) * 8 - __builtin_clz(x) - 1;
 218 }
 219
 220 static inline unsigned log2u_round_up(unsigned x) {
 221         assert(x > 0);
 222
 223         if (x == 1)
 224                 return 0;
 225
 226         return log2u(x - 1) + 1;
 227 }
 228
 229 int container_get_leader(const char *machine, pid_t *pid);
 230
 231 int namespace_open(pid_t pid, int *pidns_fd, int *mntns_fd, int *netns_fd, int *userns_fd, int *root_fd);
 232 int namespace_enter(int pidns_fd, int mntns_fd, int netns_fd, int userns_fd, int root_fd);
 233
 234 uint64_t physical_memory(void);
 235 uint64_t physical_memory_scale(uint64_t v, uint64_t max);
 236
 237 uint64_t system_tasks_max(void);
 238 uint64_t system_tasks_max_scale(uint64_t v, uint64_t max);
 239
 240 int version(void);
 241
 242 int str_verscmp(const char *s1, const char *s2);
 243
 244 void disable_coredumps(void);