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 "formats-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 void execute_directories(const char* const* directories, usec_t timeout, char *argv[]);
  69
  70 #if 0 /// UNNEEDED by elogind
  71 bool plymouth_running(void);
  72 #endif // 0
  73
  74 bool display_is_local(const char *display) _pure_;
  75 int socket_from_display(const char *display, char **path);
  76
  77 #if 0 /// UNNEEDED by elogind
  78 int block_get_whole_disk(dev_t d, dev_t *ret);
  79 #endif // 0
  80
  81 #define NULSTR_FOREACH(i, l)                                    \
  82         for ((i) = (l); (i) && *(i); (i) = strchr((i), 0)+1)
  83
  84 #define NULSTR_FOREACH_PAIR(i, j, l)                             \
  85         for ((i) = (l), (j) = strchr((i), 0)+1; (i) && *(i); (i) = strchr((j), 0)+1, (j) = *(i) ? strchr((i), 0)+1 : (i))
  86
  87 extern int saved_argc;
  88 extern char **saved_argv;
  89
  90 #if 0 /// UNNEEDED by elogind
  91 bool kexec_loaded(void);
  92
  93 int prot_from_flags(int flags) _const_;
  94 #endif // 0
  95
  96 int fork_agent(pid_t *pid, const int except[], unsigned n_except, const char *path, ...);
  97
  98 bool in_initrd(void);
  99 void in_initrd_force(bool value);
 100
 101 #if 0 /// UNNEEDED by elogind
 102 void *xbsearch_r(const void *key, const void *base, size_t nmemb, size_t size,
 103                  int (*compar) (const void *, const void *, void *),
 104                  void *arg);
 105 #endif // 0
 106
 107 /**
 108  * Normal qsort requires base to be nonnull. Here were require
 109  * that only if nmemb > 0.
 110  */
 111 static inline void qsort_safe(void *base, size_t nmemb, size_t size, comparison_fn_t compar) {
 112         if (nmemb <= 1)
 113                 return;
 114
 115         assert(base);
 116         qsort(base, nmemb, size, compar);
 117 }
 118
 119 /**
 120  * Normal memcpy requires src to be nonnull. We do nothing if n is 0.
 121  */
 122 static inline void memcpy_safe(void *dst, const void *src, size_t n) {
 123         if (n == 0)
 124                 return;
 125         assert(src);
 126         memcpy(dst, src, n);
 127 }
 128
 129 #if 0 /// UNNEEDED by elogind
 130 int on_ac_power(void);
 131 #endif // 0
 132
 133 #define memzero(x,l) (memset((x), 0, (l)))
 134 #define zero(x) (memzero(&(x), sizeof(x)))
 135
 136 static inline void *mempset(void *s, int c, size_t n) {
 137         memset(s, c, n);
 138         return (uint8_t*)s + n;
 139 }
 140
 141 static inline void _reset_errno_(int *saved_errno) {
 142         errno = *saved_errno;
 143 }
 144
 145 #define PROTECT_ERRNO _cleanup_(_reset_errno_) __attribute__((unused)) int _saved_errno_ = errno
 146
 147 static inline int negative_errno(void) {
 148         /* This helper should be used to shut up gcc if you know 'errno' is
 149          * negative. Instead of "return -errno;", use "return negative_errno();"
 150          * It will suppress bogus gcc warnings in case it assumes 'errno' might
 151          * be 0 and thus the caller's error-handling might not be triggered. */
 152         assert_return(errno > 0, -EINVAL);
 153         return -errno;
 154 }
 155
 156 static inline unsigned u64log2(uint64_t n) {
 157 #if __SIZEOF_LONG_LONG__ == 8
 158         return (n > 1) ? (unsigned) __builtin_clzll(n) ^ 63U : 0;
 159 #else
 160 #error "Wut?"
 161 #endif
 162 }
 163
 164 static inline unsigned u32ctz(uint32_t n) {
 165 #if __SIZEOF_INT__ == 4
 166         return __builtin_ctz(n);
 167 #else
 168 #error "Wut?"
 169 #endif
 170 }
 171
 172 static inline unsigned log2i(int x) {
 173         assert(x > 0);
 174
 175         return __SIZEOF_INT__ * 8 - __builtin_clz(x) - 1;
 176 }
 177
 178 static inline unsigned log2u(unsigned x) {
 179         assert(x > 0);
 180
 181         return sizeof(unsigned) * 8 - __builtin_clz(x) - 1;
 182 }
 183
 184 static inline unsigned log2u_round_up(unsigned x) {
 185         assert(x > 0);
 186
 187         if (x == 1)
 188                 return 0;
 189
 190         return log2u(x - 1) + 1;
 191 }
 192
 193 #if 0 /// UNNEEDED by elogind
 194 #endif // 0
 195 int container_get_leader(const char *machine, pid_t *pid);
 196
 197 int namespace_open(pid_t pid, int *pidns_fd, int *mntns_fd, int *netns_fd, int *userns_fd, int *root_fd);
 198 int namespace_enter(int pidns_fd, int mntns_fd, int netns_fd, int userns_fd, int root_fd);
 199
 200 uint64_t physical_memory(void);
 201 uint64_t physical_memory_scale(uint64_t v, uint64_t max);
 202
 203 uint64_t system_tasks_max(void);
 204 uint64_t system_tasks_max_scale(uint64_t v, uint64_t max);
 205
 206 #if 0 /// UNNEEDED by elogind
 207 #endif // 0
 208 int update_reboot_parameter_and_warn(const char *param);
 209
 210 int version(void);