src/basic/util.h

   1 /* SPDX-License-Identifier: LGPL-2.1+ */
   2 #pragma once
   3
   4 /***
   5   This file is part of systemd.
   6
   7   Copyright 2010 Lennart Poettering
   8
   9   systemd is free software; you can redistribute it and/or modify it
  10   under the terms of the GNU Lesser General Public License as published by
  11   the Free Software Foundation; either version 2.1 of the License, or
  12   (at your option) any later version.
  13
  14   systemd is distributed in the hope that it will be useful, but
  15   WITHOUT ANY WARRANTY; without even the implied warranty of
  16   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
  17   Lesser General Public License for more details.
  18
  19   You should have received a copy of the GNU Lesser General Public License
  20   along with systemd; If not, see <http://www.gnu.org/licenses/>.
  21 ***/
  22
  23 #include <alloca.h>
  24 #include <errno.h>
  25 #include <fcntl.h>
  26 #include <inttypes.h>
  27 #include <limits.h>
  28 #include <locale.h>
  29 #include <stdarg.h>
  30 #include <stdbool.h>
  31 #include <stddef.h>
  32 #include <stdint.h>
  33 #include <stdio.h>
  34 #include <stdlib.h>
  35 #include <string.h>
  36 #include <sys/inotify.h>
  37 #include <sys/socket.h>
  38 #include <sys/stat.h>
  39 #include <sys/statfs.h>
  40 #include <sys/sysmacros.h>
  41 #include <sys/types.h>
  42 #include <time.h>
  43 #include <unistd.h>
  44
  45 #include "format-util.h"
  46 #include "macro.h"
  47 #include "missing.h"
  48 #include "time-util.h"
  49
  50 size_t page_size(void) _pure_;
  51 #define PAGE_ALIGN(l) ALIGN_TO((l), page_size())
  52
  53 static inline const char* yes_no(bool b) {
  54         return b ? "yes" : "no";
  55 }
  56
  57 static inline const char* true_false(bool b) {
  58         return b ? "true" : "false";
  59 }
  60
  61 static inline const char* one_zero(bool b) {
  62         return b ? "1" : "0";
  63 }
  64
  65 static inline const char* enable_disable(bool b) {
  66         return b ? "enable" : "disable";
  67 }
  68
  69 #if 0 /// UNNEEDED by elogind
  70 bool plymouth_running(void);
  71 #endif // 0
  72
  73 bool display_is_local(const char *display) _pure_;
  74 int socket_from_display(const char *display, char **path);
  75
  76 #if 0 /// UNNEEDED by elogind
  77 #endif // 0
  78 #define NULSTR_FOREACH(i, l)                                    \
  79         for ((i) = (l); (i) && *(i); (i) = strchr((i), 0)+1)
  80
  81 #define NULSTR_FOREACH_PAIR(i, j, l)                             \
  82         for ((i) = (l), (j) = strchr((i), 0)+1; (i) && *(i); (i) = strchr((j), 0)+1, (j) = *(i) ? strchr((i), 0)+1 : (i))
  83
  84 extern int saved_argc;
  85 extern char **saved_argv;
  86
  87 #if 0 /// UNNEEDED by elogind
  88 bool kexec_loaded(void);
  89
  90 int prot_from_flags(int flags) _const_;
  91 #endif // 0
  92
  93 bool in_initrd(void);
  94 #if 0 /// UNNEEDED by elogind
  95 void in_initrd_force(bool value);
  96
  97 void *xbsearch_r(const void *key, const void *base, size_t nmemb, size_t size,
  98                  int (*compar) (const void *, const void *, void *),
  99                  void *arg);
 100 #endif // 0
 101
 102 /**
 103  * Normal qsort requires base to be nonnull. Here were require
 104  * that only if nmemb > 0.
 105  */
 106 static inline void qsort_safe(void *base, size_t nmemb, size_t size, comparison_fn_t compar) {
 107         if (nmemb <= 1)
 108                 return;
 109
 110         assert(base);
 111         qsort(base, nmemb, size, compar);
 112 }
 113
 114 /**
 115  * Normal memcpy requires src to be nonnull. We do nothing if n is 0.
 116  */
 117 static inline void memcpy_safe(void *dst, const void *src, size_t n) {
 118         if (n == 0)
 119                 return;
 120         assert(src);
 121         memcpy(dst, src, n);
 122 }
 123
 124 int on_ac_power(void);
 125
 126 #define memzero(x,l) (memset((x), 0, (l)))
 127 #define zero(x) (memzero(&(x), sizeof(x)))
 128
 129 static inline void *mempset(void *s, int c, size_t n) {
 130         memset(s, c, n);
 131         return (uint8_t*)s + n;
 132 }
 133
 134 static inline void _reset_errno_(int *saved_errno) {
 135         errno = *saved_errno;
 136 }
 137
 138 #define PROTECT_ERRNO _cleanup_(_reset_errno_) __attribute__((unused)) int _saved_errno_ = errno
 139
 140 static inline int negative_errno(void) {
 141         /* This helper should be used to shut up gcc if you know 'errno' is
 142          * negative. Instead of "return -errno;", use "return negative_errno();"
 143          * It will suppress bogus gcc warnings in case it assumes 'errno' might
 144          * be 0 and thus the caller's error-handling might not be triggered. */
 145         assert_return(errno > 0, -EINVAL);
 146         return -errno;
 147 }
 148
 149 static inline unsigned u64log2(uint64_t n) {
 150 #if __SIZEOF_LONG_LONG__ == 8
 151         return (n > 1) ? (unsigned) __builtin_clzll(n) ^ 63U : 0;
 152 #else
 153 #error "Wut?"
 154 #endif
 155 }
 156
 157 static inline unsigned u32ctz(uint32_t n) {
 158 #if __SIZEOF_INT__ == 4
 159         return __builtin_ctz(n);
 160 #else
 161 #error "Wut?"
 162 #endif
 163 }
 164
 165 static inline unsigned log2i(int x) {
 166         assert(x > 0);
 167
 168         return __SIZEOF_INT__ * 8 - __builtin_clz(x) - 1;
 169 }
 170
 171 static inline unsigned log2u(unsigned x) {
 172         assert(x > 0);
 173
 174         return sizeof(unsigned) * 8 - __builtin_clz(x) - 1;
 175 }
 176
 177 static inline unsigned log2u_round_up(unsigned x) {
 178         assert(x > 0);
 179
 180         if (x == 1)
 181                 return 0;
 182
 183         return log2u(x - 1) + 1;
 184 }
 185
 186 int container_get_leader(const char *machine, pid_t *pid);
 187
 188 int namespace_open(pid_t pid, int *pidns_fd, int *mntns_fd, int *netns_fd, int *userns_fd, int *root_fd);
 189 int namespace_enter(int pidns_fd, int mntns_fd, int netns_fd, int userns_fd, int root_fd);
 190
 191 uint64_t physical_memory(void);
 192 uint64_t physical_memory_scale(uint64_t v, uint64_t max);
 193
 194 uint64_t system_tasks_max(void);
 195 uint64_t system_tasks_max_scale(uint64_t v, uint64_t max);
 196
 197 int version(void);
 198
 199 #if 0 /// UNNEEDED by elogind
 200 int str_verscmp(const char *s1, const char *s2);
 201
 202 void disable_coredumps(void);
 203 #endif // 0