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