src/basic/util.h

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