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