src/basic/macro.h

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