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