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