src/basic/macro.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 <inttypes.h>
  23 #include <stdbool.h>
  24 #include <sys/param.h>
  25 #include <sys/sysmacros.h>
  26 #include <sys/types.h>
  27
  28 #define _printf_(a,b) __attribute__ ((format (printf, a, b)))
  29 #ifdef __clang__
  30 #  define _alloc_(...)
  31 #else
  32 #  define _alloc_(...) __attribute__ ((alloc_size(__VA_ARGS__)))
  33 #endif
  34 #define _sentinel_ __attribute__ ((sentinel))
  35 #define _unused_ __attribute__ ((unused))
  36 #define _destructor_ __attribute__ ((destructor))
  37 #define _pure_ __attribute__ ((pure))
  38 #define _const_ __attribute__ ((const))
  39 #define _deprecated_ __attribute__ ((deprecated))
  40 #define _packed_ __attribute__ ((packed))
  41 #define _malloc_ __attribute__ ((malloc))
  42 #define _weak_ __attribute__ ((weak))
  43 #define _likely_(x) (__builtin_expect(!!(x),1))
  44 #define _unlikely_(x) (__builtin_expect(!!(x),0))
  45 #define _public_ __attribute__ ((visibility("default")))
  46 #define _hidden_ __attribute__ ((visibility("hidden")))
  47 #define _weakref_(x) __attribute__((weakref(#x)))
  48 #define _alignas_(x) __attribute__((aligned(__alignof(x))))
  49 #define _cleanup_(x) __attribute__((cleanup(x)))
  50 #if __GNUC__ >= 7
  51 #define _fallthrough_ __attribute__((fallthrough))
  52 #else
  53 #define _fallthrough_
  54 #endif
  55
  56 /* Temporarily disable some warnings */
  57 #define DISABLE_WARNING_DECLARATION_AFTER_STATEMENT                     \
  58         _Pragma("GCC diagnostic push");                                 \
  59         _Pragma("GCC diagnostic ignored \"-Wdeclaration-after-statement\"")
  60
  61 #define DISABLE_WARNING_FORMAT_NONLITERAL                               \
  62         _Pragma("GCC diagnostic push");                                 \
  63         _Pragma("GCC diagnostic ignored \"-Wformat-nonliteral\"")
  64
  65 #define DISABLE_WARNING_MISSING_PROTOTYPES                              \
  66         _Pragma("GCC diagnostic push");                                 \
  67         _Pragma("GCC diagnostic ignored \"-Wmissing-prototypes\"")
  68
  69 #define DISABLE_WARNING_NONNULL                                         \
  70         _Pragma("GCC diagnostic push");                                 \
  71         _Pragma("GCC diagnostic ignored \"-Wnonnull\"")
  72
  73 #define DISABLE_WARNING_SHADOW                                          \
  74         _Pragma("GCC diagnostic push");                                 \
  75         _Pragma("GCC diagnostic ignored \"-Wshadow\"")
  76
  77 #define DISABLE_WARNING_INCOMPATIBLE_POINTER_TYPES                      \
  78         _Pragma("GCC diagnostic push");                                 \
  79         _Pragma("GCC diagnostic ignored \"-Wincompatible-pointer-types\"")
  80
  81 #define REENABLE_WARNING                                                \
  82         _Pragma("GCC diagnostic pop")
  83
  84 /* automake test harness */
  85 #define EXIT_TEST_SKIP 77
  86
  87 #define XSTRINGIFY(x) #x
  88 #define STRINGIFY(x) XSTRINGIFY(x)
  89
  90 #define XCONCATENATE(x, y) x ## y
  91 #define CONCATENATE(x, y) XCONCATENATE(x, y)
  92
  93 #define UNIQ_T(x, uniq) CONCATENATE(__unique_prefix_, CONCATENATE(x, uniq))
  94 #define UNIQ __COUNTER__
  95
  96 /* builtins */
  97 #if __SIZEOF_INT__ == 4
  98 #define BUILTIN_FFS_U32(x) __builtin_ffs(x);
  99 #elif __SIZEOF_LONG__ == 4
 100 #define BUILTIN_FFS_U32(x) __builtin_ffsl(x);
 101 #else
 102 #error "neither int nor long are four bytes long?!?"
 103 #endif
 104
 105 /* Rounds up */
 106
 107 #define ALIGN4(l) (((l) + 3) & ~3)
 108 #define ALIGN8(l) (((l) + 7) & ~7)
 109
 110 #if __SIZEOF_POINTER__ == 8
 111 #define ALIGN(l) ALIGN8(l)
 112 #elif __SIZEOF_POINTER__ == 4
 113 #define ALIGN(l) ALIGN4(l)
 114 #else
 115 #error "Wut? Pointers are neither 4 nor 8 bytes long?"
 116 #endif
 117
 118 #define ALIGN_PTR(p) ((void*) ALIGN((unsigned long) (p)))
 119 #define ALIGN4_PTR(p) ((void*) ALIGN4((unsigned long) (p)))
 120 #define ALIGN8_PTR(p) ((void*) ALIGN8((unsigned long) (p)))
 121
 122 static inline size_t ALIGN_TO(size_t l, size_t ali) {
 123         return ((l + ali - 1) & ~(ali - 1));
 124 }
 125
 126 #define ALIGN_TO_PTR(p, ali) ((void*) ALIGN_TO((unsigned long) (p), (ali)))
 127
 128 /* align to next higher power-of-2 (except for: 0 => 0, overflow => 0) */
 129 static inline unsigned long ALIGN_POWER2(unsigned long u) {
 130         /* clz(0) is undefined */
 131         if (u == 1)
 132                 return 1;
 133
 134         /* left-shift overflow is undefined */
 135         if (__builtin_clzl(u - 1UL) < 1)
 136                 return 0;
 137
 138         return 1UL << (sizeof(u) * 8 - __builtin_clzl(u - 1UL));
 139 }
 140
 141 #define ELEMENTSOF(x)                                                    \
 142         __extension__ (__builtin_choose_expr(                            \
 143                 !__builtin_types_compatible_p(typeof(x), typeof(&*(x))), \
 144                 sizeof(x)/sizeof((x)[0]),                                \
 145                 (void)0))
 146
 147 /*
 148  * STRLEN - return the length of a string literal, minus the trailing NUL byte.
 149  *          Contrary to strlen(), this is a constant expression.
 150  * @x: a string literal.
 151  */
 152 #define STRLEN(x) (sizeof(""x"") - 1)
 153
 154 /*
 155  * container_of - cast a member of a structure out to the containing structure
 156  * @ptr: the pointer to the member.
 157  * @type: the type of the container struct this is embedded in.
 158  * @member: the name of the member within the struct.
 159  */
 160 #define container_of(ptr, type, member) __container_of(UNIQ, (ptr), type, member)
 161 #define __container_of(uniq, ptr, type, member)                         \
 162         __extension__ ({                                                \
 163                 const typeof( ((type*)0)->member ) *UNIQ_T(A, uniq) = (ptr); \
 164                 (type*)( (char *)UNIQ_T(A, uniq) - offsetof(type,member) ); \
 165         })
 166
 167 #undef MAX
 168 #define MAX(a, b) __MAX(UNIQ, (a), UNIQ, (b))
 169 #define __MAX(aq, a, bq, b)                             \
 170         __extension__ ({                                \
 171                 const typeof(a) UNIQ_T(A, aq) = (a);    \
 172                 const typeof(b) UNIQ_T(B, bq) = (b);    \
 173                 UNIQ_T(A,aq) > UNIQ_T(B,bq) ? UNIQ_T(A,aq) : UNIQ_T(B,bq); \
 174         })
 175
 176 /* evaluates to (void) if _A or _B are not constant or of different types */
 177 #define CONST_MAX(_A, _B) \
 178         __extension__ (__builtin_choose_expr(                           \
 179                 __builtin_constant_p(_A) &&                             \
 180                 __builtin_constant_p(_B) &&                             \
 181                 __builtin_types_compatible_p(typeof(_A), typeof(_B)),   \
 182                 ((_A) > (_B)) ? (_A) : (_B),                            \
 183                 (void)0))
 184
 185 /* takes two types and returns the size of the larger one */
 186 #define MAXSIZE(A, B) (sizeof(union _packed_ { typeof(A) a; typeof(B) b; }))
 187
 188 #define MAX3(x,y,z)                                     \
 189         __extension__ ({                                \
 190                         const typeof(x) _c = MAX(x,y);  \
 191                         MAX(_c, z);                     \
 192                 })
 193
 194 #undef MIN
 195 #define MIN(a, b) __MIN(UNIQ, (a), UNIQ, (b))
 196 #define __MIN(aq, a, bq, b)                             \
 197         __extension__ ({                                \
 198                 const typeof(a) UNIQ_T(A, aq) = (a);    \
 199                 const typeof(b) UNIQ_T(B, bq) = (b);    \
 200                 UNIQ_T(A,aq) < UNIQ_T(B,bq) ? UNIQ_T(A,aq) : UNIQ_T(B,bq); \
 201         })
 202
 203 #define MIN3(x,y,z)                                     \
 204         __extension__ ({                                \
 205                         const typeof(x) _c = MIN(x,y);  \
 206                         MIN(_c, z);                     \
 207                 })
 208
 209 #define LESS_BY(a, b) __LESS_BY(UNIQ, (a), UNIQ, (b))
 210 #define __LESS_BY(aq, a, bq, b)                         \
 211         __extension__ ({                                \
 212                 const typeof(a) UNIQ_T(A, aq) = (a);    \
 213                 const typeof(b) UNIQ_T(B, bq) = (b);    \
 214                 UNIQ_T(A,aq) > UNIQ_T(B,bq) ? UNIQ_T(A,aq) - UNIQ_T(B,bq) : 0; \
 215         })
 216
 217 #undef CLAMP
 218 #define CLAMP(x, low, high) __CLAMP(UNIQ, (x), UNIQ, (low), UNIQ, (high))
 219 #define __CLAMP(xq, x, lowq, low, highq, high)                          \
 220         __extension__ ({                                                \
 221                 const typeof(x) UNIQ_T(X,xq) = (x);                     \
 222                 const typeof(low) UNIQ_T(LOW,lowq) = (low);             \
 223                 const typeof(high) UNIQ_T(HIGH,highq) = (high);         \
 224                         UNIQ_T(X,xq) > UNIQ_T(HIGH,highq) ?             \
 225                                 UNIQ_T(HIGH,highq) :                    \
 226                                 UNIQ_T(X,xq) < UNIQ_T(LOW,lowq) ?       \
 227                                         UNIQ_T(LOW,lowq) :              \
 228                                         UNIQ_T(X,xq);                   \
 229         })
 230
 231 /* [(x + y - 1) / y] suffers from an integer overflow, even though the
 232  * computation should be possible in the given type. Therefore, we use
 233  * [x / y + !!(x % y)]. Note that on "Real CPUs" a division returns both the
 234  * quotient and the remainder, so both should be equally fast. */
 235 #define DIV_ROUND_UP(_x, _y)                                            \
 236         __extension__ ({                                                \
 237                 const typeof(_x) __x = (_x);                            \
 238                 const typeof(_y) __y = (_y);                            \
 239                 (__x / __y + !!(__x % __y));                            \
 240         })
 241
 242 #define assert_message_se(expr, message)                                \
 243         do {                                                            \
 244                 if (_unlikely_(!(expr)))                                \
 245                         log_assert_failed(message, __FILE__, __LINE__, __PRETTY_FUNCTION__); \
 246         } while (false)
 247
 248 #define assert_se(expr) assert_message_se(expr, #expr)
 249
 250 /* We override the glibc assert() here. */
 251 #undef assert
 252 #ifdef NDEBUG
 253 #define assert(expr) do {} while (false)
 254 #else
 255 #define assert(expr) assert_message_se(expr, #expr)
 256 #endif
 257
 258 #define assert_not_reached(t)                                           \
 259         do {                                                            \
 260                 log_assert_failed_unreachable(t, __FILE__, __LINE__, __PRETTY_FUNCTION__); \
 261         } while (false)
 262
 263 #if defined(static_assert)
 264 /* static_assert() is sometimes defined in a way that trips up
 265  * -Wdeclaration-after-statement, hence let's temporarily turn off
 266  * this warning around it. */
 267 #define assert_cc(expr)                                                 \
 268         DISABLE_WARNING_DECLARATION_AFTER_STATEMENT;                    \
 269         static_assert(expr, #expr);                                     \
 270         REENABLE_WARNING
 271 #else
 272 #define assert_cc(expr)                                                 \
 273         DISABLE_WARNING_DECLARATION_AFTER_STATEMENT;                    \
 274         struct CONCATENATE(_assert_struct_, __COUNTER__) {              \
 275                 char x[(expr) ? 0 : -1];                                \
 276         };                                                              \
 277         REENABLE_WARNING
 278 #endif
 279
 280 #define assert_log(expr, message) ((_likely_(expr))                     \
 281         ? (true)                                                        \
 282         : (log_assert_failed_return(message, __FILE__, __LINE__, __PRETTY_FUNCTION__), false))
 283
 284 #define assert_return(expr, r)                                          \
 285         do {                                                            \
 286                 if (!assert_log(expr, #expr))                           \
 287                         return (r);                                     \
 288         } while (false)
 289
 290 #define assert_return_errno(expr, r, err)                               \
 291         do {                                                            \
 292                 if (!assert_log(expr, #expr)) {                         \
 293                         errno = err;                                    \
 294                         return (r);                                     \
 295                 }                                                       \
 296         } while (false)
 297
 298 #define PTR_TO_INT(p) ((int) ((intptr_t) (p)))
 299 #define INT_TO_PTR(u) ((void *) ((intptr_t) (u)))
 300 #define PTR_TO_UINT(p) ((unsigned int) ((uintptr_t) (p)))
 301 #define UINT_TO_PTR(u) ((void *) ((uintptr_t) (u)))
 302
 303 #define PTR_TO_LONG(p) ((long) ((intptr_t) (p)))
 304 #define LONG_TO_PTR(u) ((void *) ((intptr_t) (u)))
 305 #define PTR_TO_ULONG(p) ((unsigned long) ((uintptr_t) (p)))
 306 #define ULONG_TO_PTR(u) ((void *) ((uintptr_t) (u)))
 307
 308 #define PTR_TO_INT32(p) ((int32_t) ((intptr_t) (p)))
 309 #define INT32_TO_PTR(u) ((void *) ((intptr_t) (u)))
 310 #define PTR_TO_UINT32(p) ((uint32_t) ((uintptr_t) (p)))
 311 #define UINT32_TO_PTR(u) ((void *) ((uintptr_t) (u)))
 312
 313 #define PTR_TO_INT64(p) ((int64_t) ((intptr_t) (p)))
 314 #define INT64_TO_PTR(u) ((void *) ((intptr_t) (u)))
 315 #define PTR_TO_UINT64(p) ((uint64_t) ((uintptr_t) (p)))
 316 #define UINT64_TO_PTR(u) ((void *) ((uintptr_t) (u)))
 317
 318 #define PTR_TO_SIZE(p) ((size_t) ((uintptr_t) (p)))
 319 #define SIZE_TO_PTR(u) ((void *) ((uintptr_t) (u)))
 320
 321 #define CHAR_TO_STR(x) ((char[2]) { x, 0 })
 322
 323 #define char_array_0(x) x[sizeof(x)-1] = 0;
 324
 325 /* Returns the number of chars needed to format variables of the
 326  * specified type as a decimal string. Adds in extra space for a
 327  * negative '-' prefix (hence works correctly on signed
 328  * types). Includes space for the trailing NUL. */
 329 #define DECIMAL_STR_MAX(type)                                           \
 330         (2+(sizeof(type) <= 1 ? 3 :                                     \
 331             sizeof(type) <= 2 ? 5 :                                     \
 332             sizeof(type) <= 4 ? 10 :                                    \
 333             sizeof(type) <= 8 ? 20 : sizeof(int[-2*(sizeof(type) > 8)])))
 334
 335 #define DECIMAL_STR_WIDTH(x)                            \
 336         ({                                              \
 337                 typeof(x) _x_ = (x);                    \
 338                 unsigned ans = 1;                       \
 339                 while (_x_ /= 10)                       \
 340                         ans++;                          \
 341                 ans;                                    \
 342         })
 343
 344 #define SET_FLAG(v, flag, b) \
 345         (v) = (b) ? ((v) | (flag)) : ((v) & ~(flag))
 346
 347 #define CASE_F(X) case X:
 348 #define CASE_F_1(CASE, X) CASE_F(X)
 349 #define CASE_F_2(CASE, X, ...)  CASE(X) CASE_F_1(CASE, __VA_ARGS__)
 350 #define CASE_F_3(CASE, X, ...)  CASE(X) CASE_F_2(CASE, __VA_ARGS__)
 351 #define CASE_F_4(CASE, X, ...)  CASE(X) CASE_F_3(CASE, __VA_ARGS__)
 352 #define CASE_F_5(CASE, X, ...)  CASE(X) CASE_F_4(CASE, __VA_ARGS__)
 353 #define CASE_F_6(CASE, X, ...)  CASE(X) CASE_F_5(CASE, __VA_ARGS__)
 354 #define CASE_F_7(CASE, X, ...)  CASE(X) CASE_F_6(CASE, __VA_ARGS__)
 355 #define CASE_F_8(CASE, X, ...)  CASE(X) CASE_F_7(CASE, __VA_ARGS__)
 356 #define CASE_F_9(CASE, X, ...)  CASE(X) CASE_F_8(CASE, __VA_ARGS__)
 357 #define CASE_F_10(CASE, X, ...) CASE(X) CASE_F_9(CASE, __VA_ARGS__)
 358 #define CASE_F_11(CASE, X, ...) CASE(X) CASE_F_10(CASE, __VA_ARGS__)
 359 #define CASE_F_12(CASE, X, ...) CASE(X) CASE_F_11(CASE, __VA_ARGS__)
 360 #define CASE_F_13(CASE, X, ...) CASE(X) CASE_F_12(CASE, __VA_ARGS__)
 361 #define CASE_F_14(CASE, X, ...) CASE(X) CASE_F_13(CASE, __VA_ARGS__)
 362 #define CASE_F_15(CASE, X, ...) CASE(X) CASE_F_14(CASE, __VA_ARGS__)
 363 #define CASE_F_16(CASE, X, ...) CASE(X) CASE_F_15(CASE, __VA_ARGS__)
 364 #define CASE_F_17(CASE, X, ...) CASE(X) CASE_F_16(CASE, __VA_ARGS__)
 365 #define CASE_F_18(CASE, X, ...) CASE(X) CASE_F_17(CASE, __VA_ARGS__)
 366 #define CASE_F_19(CASE, X, ...) CASE(X) CASE_F_18(CASE, __VA_ARGS__)
 367 #define CASE_F_20(CASE, X, ...) CASE(X) CASE_F_19(CASE, __VA_ARGS__)
 368
 369 #define GET_CASE_F(_1,_2,_3,_4,_5,_6,_7,_8,_9,_10,_11,_12,_13,_14,_15,_16,_17,_18,_19,_20,NAME,...) NAME
 370 #define FOR_EACH_MAKE_CASE(...) \
 371         GET_CASE_F(__VA_ARGS__,CASE_F_20,CASE_F_19,CASE_F_18,CASE_F_17,CASE_F_16,CASE_F_15,CASE_F_14,CASE_F_13,CASE_F_12,CASE_F_11, \
 372                                CASE_F_10,CASE_F_9,CASE_F_8,CASE_F_7,CASE_F_6,CASE_F_5,CASE_F_4,CASE_F_3,CASE_F_2,CASE_F_1) \
 373                    (CASE_F,__VA_ARGS__)
 374
 375 #define IN_SET(x, ...)                          \
 376         ({                                      \
 377                 bool _found = false;            \
 378                 /* If the build breaks in the line below, you need to extend the case macros */ \
 379                 static _unused_ char _static_assert__macros_need_to_be_extended[20 - sizeof((int[]){__VA_ARGS__})/sizeof(int)]; \
 380                 switch(x) {                     \
 381                 FOR_EACH_MAKE_CASE(__VA_ARGS__) \
 382                         _found = true;          \
 383                         break;                  \
 384                 default:                        \
 385                         break;                  \
 386                 }                               \
 387                 _found;                         \
 388         })
 389
 390 #define SWAP_TWO(x, y) do {                        \
 391                 typeof(x) _t = (x);                \
 392                 (x) = (y);                         \
 393                 (y) = (_t);                        \
 394         } while (false)
 395
 396 /* Define C11 thread_local attribute even on older gcc compiler
 397  * version */
 398 #ifndef thread_local
 399 /*
 400  * Don't break on glibc < 2.16 that doesn't define __STDC_NO_THREADS__
 401  * see http://gcc.gnu.org/bugzilla/show_bug.cgi?id=53769
 402  */
 403 #if __STDC_VERSION__ >= 201112L && !(defined(__STDC_NO_THREADS__) || (defined(__GNU_LIBRARY__) && __GLIBC__ == 2 && __GLIBC_MINOR__ < 16))
 404 #define thread_local _Thread_local
 405 #else
 406 #define thread_local __thread
 407 #endif
 408 #endif
 409
 410 /* Define C11 noreturn without <stdnoreturn.h> and even on older gcc
 411  * compiler versions */
 412 #ifndef noreturn
 413 #if __STDC_VERSION__ >= 201112L
 414 #define noreturn _Noreturn
 415 #else
 416 #define noreturn __attribute__((noreturn))
 417 #endif
 418 #endif
 419
 420 #define DEFINE_TRIVIAL_CLEANUP_FUNC(type, func)                 \
 421         static inline void func##p(type *p) {                   \
 422                 if (*p)                                         \
 423                         func(*p);                               \
 424         }                                                       \
 425         struct __useless_struct_to_allow_trailing_semicolon__
 426
 427 #include "log.h"