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