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