src/shared/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 <sys/param.h>
  26 #include <sys/types.h>
  27 #include <sys/uio.h>
  28 #include <inttypes.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 REENABLE_WARNING                                                \
  71         _Pragma("GCC diagnostic pop")
  72
  73 /* automake test harness */
  74 #define EXIT_TEST_SKIP 77
  75
  76 #define XSTRINGIFY(x) #x
  77 #define STRINGIFY(x) XSTRINGIFY(x)
  78
  79 #define XCONCATENATE(x, y) x ## y
  80 #define CONCATENATE(x, y) XCONCATENATE(x, y)
  81
  82 #define UNIQ_T(x, uniq) CONCATENATE(__unique_prefix_, CONCATENATE(x, uniq))
  83 #define UNIQ __COUNTER__
  84
  85 /* Rounds up */
  86
  87 #define ALIGN4(l) (((l) + 3) & ~3)
  88 #define ALIGN8(l) (((l) + 7) & ~7)
  89
  90 #if __SIZEOF_POINTER__ == 8
  91 #define ALIGN(l) ALIGN8(l)
  92 #elif __SIZEOF_POINTER__ == 4
  93 #define ALIGN(l) ALIGN4(l)
  94 #else
  95 #error "Wut? Pointers are neither 4 nor 8 bytes long?"
  96 #endif
  97
  98 #define ALIGN_PTR(p) ((void*) ALIGN((unsigned long) (p)))
  99 #define ALIGN4_PTR(p) ((void*) ALIGN4((unsigned long) (p)))
 100 #define ALIGN8_PTR(p) ((void*) ALIGN8((unsigned long) (p)))
 101
 102 static inline size_t ALIGN_TO(size_t l, size_t ali) {
 103         return ((l + ali - 1) & ~(ali - 1));
 104 }
 105
 106 #define ALIGN_TO_PTR(p, ali) ((void*) ALIGN_TO((unsigned long) (p), (ali)))
 107
 108 /* align to next higher power-of-2 (except for: 0 => 0, overflow => 0) */
 109 static inline unsigned long ALIGN_POWER2(unsigned long u) {
 110         /* clz(0) is undefined */
 111         if (u == 1)
 112                 return 1;
 113
 114         /* left-shift overflow is undefined */
 115         if (__builtin_clzl(u - 1UL) < 1)
 116                 return 0;
 117
 118         return 1UL << (sizeof(u) * 8 - __builtin_clzl(u - 1UL));
 119 }
 120
 121 #define ELEMENTSOF(x) (sizeof(x)/sizeof((x)[0]))
 122
 123 /*
 124  * container_of - cast a member of a structure out to the containing structure
 125  * @ptr: the pointer to the member.
 126  * @type: the type of the container struct this is embedded in.
 127  * @member: the name of the member within the struct.
 128  */
 129 #define container_of(ptr, type, member) __container_of(UNIQ, (ptr), type, member)
 130 #define __container_of(uniq, ptr, type, member)                         \
 131         __extension__ ({                                                \
 132                 const typeof( ((type*)0)->member ) *UNIQ_T(A, uniq) = (ptr); \
 133                 (type*)( (char *)UNIQ_T(A, uniq) - offsetof(type,member) ); \
 134         })
 135
 136 #undef MAX
 137 #define MAX(a, b) __MAX(UNIQ, (a), UNIQ, (b))
 138 #define __MAX(aq, a, bq, b)                             \
 139         __extension__ ({                                \
 140                 const typeof(a) UNIQ_T(A, aq) = (a);    \
 141                 const typeof(b) UNIQ_T(B, bq) = (b);    \
 142                 UNIQ_T(A,aq) > UNIQ_T(B,bq) ? UNIQ_T(A,aq) : UNIQ_T(B,bq); \
 143         })
 144
 145 /* evaluates to (void) if _A or _B are not constant or of different types */
 146 #define CONST_MAX(_A, _B) \
 147         __extension__ (__builtin_choose_expr(                           \
 148                 __builtin_constant_p(_A) &&                             \
 149                 __builtin_constant_p(_B) &&                             \
 150                 __builtin_types_compatible_p(typeof(_A), typeof(_B)),   \
 151                 ((_A) > (_B)) ? (_A) : (_B),                            \
 152                 (void)0))
 153
 154 /* takes two types and returns the size of the larger one */
 155 #define MAXSIZE(A, B) (sizeof(union _packed_ { typeof(A) a; typeof(B) b; }))
 156
 157 #define MAX3(x,y,z)                                     \
 158         __extension__ ({                                \
 159                         const typeof(x) _c = MAX(x,y);  \
 160                         MAX(_c, z);                     \
 161                 })
 162
 163 #undef MIN
 164 #define MIN(a, b) __MIN(UNIQ, (a), UNIQ, (b))
 165 #define __MIN(aq, a, bq, b)                             \
 166         __extension__ ({                                \
 167                 const typeof(a) UNIQ_T(A, aq) = (a);    \
 168                 const typeof(b) UNIQ_T(B, bq) = (b);    \
 169                 UNIQ_T(A,aq) < UNIQ_T(B,bq) ? UNIQ_T(A,aq) : UNIQ_T(B,bq); \
 170         })
 171
 172 #define MIN3(x,y,z)                                     \
 173         __extension__ ({                                \
 174                         const typeof(x) _c = MIN(x,y);  \
 175                         MIN(_c, z);                     \
 176                 })
 177
 178 #define LESS_BY(a, b) __LESS_BY(UNIQ, (a), UNIQ, (b))
 179 #define __LESS_BY(aq, a, bq, b)                         \
 180         __extension__ ({                                \
 181                 const typeof(a) UNIQ_T(A, aq) = (a);    \
 182                 const typeof(b) UNIQ_T(B, bq) = (b);    \
 183                 UNIQ_T(A,aq) > UNIQ_T(B,bq) ? UNIQ_T(A,aq) - UNIQ_T(B,bq) : 0; \
 184         })
 185
 186 #undef CLAMP
 187 #define CLAMP(x, low, high) __CLAMP(UNIQ, (x), UNIQ, (low), UNIQ, (high))
 188 #define __CLAMP(xq, x, lowq, low, highq, high)                          \
 189         __extension__ ({                                                \
 190                 const typeof(x) UNIQ_T(X,xq) = (x);                     \
 191                 const typeof(low) UNIQ_T(LOW,lowq) = (low);             \
 192                 const typeof(high) UNIQ_T(HIGH,highq) = (high);         \
 193                         UNIQ_T(X,xq) > UNIQ_T(HIGH,highq) ?             \
 194                                 UNIQ_T(HIGH,highq) :                    \
 195                                 UNIQ_T(X,xq) < UNIQ_T(LOW,lowq) ?       \
 196                                         UNIQ_T(LOW,lowq) :              \
 197                                         UNIQ_T(X,xq);                   \
 198         })
 199
 200 /* [(x + y - 1) / y] suffers from an integer overflow, even though the
 201  * computation should be possible in the given type. Therefore, we use
 202  * [x / y + !!(x % y)]. Note that on "Real CPUs" a division returns both the
 203  * quotient and the remainder, so both should be equally fast. */
 204 #define DIV_ROUND_UP(_x, _y)                                            \
 205         __extension__ ({                                                \
 206                 const typeof(_x) __x = (_x);                            \
 207                 const typeof(_y) __y = (_y);                            \
 208                 (__x / __y + !!(__x % __y));                            \
 209         })
 210
 211 #define assert_se(expr)                                                 \
 212         do {                                                            \
 213                 if (_unlikely_(!(expr)))                                \
 214                         log_assert_failed(#expr, __FILE__, __LINE__, __PRETTY_FUNCTION__); \
 215         } while (false)                                                 \
 216
 217 /* We override the glibc assert() here. */
 218 #undef assert
 219 #ifdef NDEBUG
 220 #define assert(expr) do {} while(false)
 221 #else
 222 #define assert(expr) assert_se(expr)
 223 #endif
 224
 225 #define assert_not_reached(t)                                           \
 226         do {                                                            \
 227                 log_assert_failed_unreachable(t, __FILE__, __LINE__, __PRETTY_FUNCTION__); \
 228         } while (false)
 229
 230 #if defined(static_assert)
 231 /* static_assert() is sometimes defined in a way that trips up
 232  * -Wdeclaration-after-statement, hence let's temporarily turn off
 233  * this warning around it. */
 234 #define assert_cc(expr)                                                 \
 235         DISABLE_WARNING_DECLARATION_AFTER_STATEMENT;                    \
 236         static_assert(expr, #expr);                                     \
 237         REENABLE_WARNING
 238 #else
 239 #define assert_cc(expr)                                                 \
 240         DISABLE_WARNING_DECLARATION_AFTER_STATEMENT;                    \
 241         struct CONCATENATE(_assert_struct_, __LINE__) {                 \
 242                 char x[(expr) ? 0 : -1];                                \
 243         };                                                              \
 244         REENABLE_WARNING
 245 #endif
 246
 247 #define assert_return(expr, r)                                          \
 248         do {                                                            \
 249                 if (_unlikely_(!(expr))) {                              \
 250                         log_assert_failed_return(#expr, __FILE__, __LINE__, __PRETTY_FUNCTION__); \
 251                         return (r);                                     \
 252                 }                                                       \
 253         } while (false)
 254
 255 #define PTR_TO_INT(p) ((int) ((intptr_t) (p)))
 256 #define INT_TO_PTR(u) ((void *) ((intptr_t) (u)))
 257 #define PTR_TO_UINT(p) ((unsigned int) ((uintptr_t) (p)))
 258 #define UINT_TO_PTR(u) ((void *) ((uintptr_t) (u)))
 259
 260 #define PTR_TO_LONG(p) ((long) ((intptr_t) (p)))
 261 #define LONG_TO_PTR(u) ((void *) ((intptr_t) (u)))
 262 #define PTR_TO_ULONG(p) ((unsigned long) ((uintptr_t) (p)))
 263 #define ULONG_TO_PTR(u) ((void *) ((uintptr_t) (u)))
 264
 265 #define PTR_TO_INT32(p) ((int32_t) ((intptr_t) (p)))
 266 #define INT32_TO_PTR(u) ((void *) ((intptr_t) (u)))
 267 #define PTR_TO_UINT32(p) ((uint32_t) ((uintptr_t) (p)))
 268 #define UINT32_TO_PTR(u) ((void *) ((uintptr_t) (u)))
 269
 270 #define PTR_TO_INT64(p) ((int64_t) ((intptr_t) (p)))
 271 #define INT64_TO_PTR(u) ((void *) ((intptr_t) (u)))
 272 #define PTR_TO_UINT64(p) ((uint64_t) ((uintptr_t) (p)))
 273 #define UINT64_TO_PTR(u) ((void *) ((uintptr_t) (u)))
 274
 275 #define PTR_TO_SIZE(p) ((size_t) ((uintptr_t) (p)))
 276 #define SIZE_TO_PTR(u) ((void *) ((uintptr_t) (u)))
 277
 278 #define memzero(x,l) (memset((x), 0, (l)))
 279 #define zero(x) (memzero(&(x), sizeof(x)))
 280
 281 #define CHAR_TO_STR(x) ((char[2]) { x, 0 })
 282
 283 #define char_array_0(x) x[sizeof(x)-1] = 0;
 284
 285 #define IOVEC_SET_STRING(i, s)                  \
 286         do {                                    \
 287                 struct iovec *_i = &(i);        \
 288                 char *_s = (char *)(s);         \
 289                 _i->iov_base = _s;              \
 290                 _i->iov_len = strlen(_s);       \
 291         } while(false)
 292
 293 static inline size_t IOVEC_TOTAL_SIZE(const struct iovec *i, unsigned n) {
 294         unsigned j;
 295         size_t r = 0;
 296
 297         for (j = 0; j < n; j++)
 298                 r += i[j].iov_len;
 299
 300         return r;
 301 }
 302
 303 static inline size_t IOVEC_INCREMENT(struct iovec *i, unsigned n, size_t k) {
 304         unsigned j;
 305
 306         for (j = 0; j < n; j++) {
 307                 size_t sub;
 308
 309                 if (_unlikely_(k <= 0))
 310                         break;
 311
 312                 sub = MIN(i[j].iov_len, k);
 313                 i[j].iov_len -= sub;
 314                 i[j].iov_base = (uint8_t*) i[j].iov_base + sub;
 315                 k -= sub;
 316         }
 317
 318         return k;
 319 }
 320
 321 #define VA_FORMAT_ADVANCE(format, ap)                                   \
 322 do {                                                                    \
 323         int _argtypes[128];                                             \
 324         size_t _i, _k;                                                  \
 325         _k = parse_printf_format((format), ELEMENTSOF(_argtypes), _argtypes); \
 326         assert(_k < ELEMENTSOF(_argtypes));                             \
 327         for (_i = 0; _i < _k; _i++) {                                   \
 328                 if (_argtypes[_i] & PA_FLAG_PTR)  {                     \
 329                         (void) va_arg(ap, void*);                       \
 330                         continue;                                       \
 331                 }                                                       \
 332                                                                         \
 333                 switch (_argtypes[_i]) {                                \
 334                 case PA_INT:                                            \
 335                 case PA_INT|PA_FLAG_SHORT:                              \
 336                 case PA_CHAR:                                           \
 337                         (void) va_arg(ap, int);                         \
 338                         break;                                          \
 339                 case PA_INT|PA_FLAG_LONG:                               \
 340                         (void) va_arg(ap, long int);                    \
 341                         break;                                          \
 342                 case PA_INT|PA_FLAG_LONG_LONG:                          \
 343                         (void) va_arg(ap, long long int);               \
 344                         break;                                          \
 345                 case PA_WCHAR:                                          \
 346                         (void) va_arg(ap, wchar_t);                     \
 347                         break;                                          \
 348                 case PA_WSTRING:                                        \
 349                 case PA_STRING:                                         \
 350                 case PA_POINTER:                                        \
 351                         (void) va_arg(ap, void*);                       \
 352                         break;                                          \
 353                 case PA_FLOAT:                                          \
 354                 case PA_DOUBLE:                                         \
 355                         (void) va_arg(ap, double);                      \
 356                         break;                                          \
 357                 case PA_DOUBLE|PA_FLAG_LONG_DOUBLE:                     \
 358                         (void) va_arg(ap, long double);                 \
 359                         break;                                          \
 360                 default:                                                \
 361                         assert_not_reached("Unknown format string argument."); \
 362                 }                                                       \
 363         }                                                               \
 364 } while(false)
 365
 366  /* Because statfs.t_type can be int on some architectures, we have to cast
 367   * the const magic to the type, otherwise the compiler warns about
 368   * signed/unsigned comparison, because the magic can be 32 bit unsigned.
 369  */
 370 #define F_TYPE_EQUAL(a, b) (a == (typeof(a)) b)
 371
 372 /* Returns the number of chars needed to format variables of the
 373  * specified type as a decimal string. Adds in extra space for a
 374  * negative '-' prefix. */
 375 #define DECIMAL_STR_MAX(type)                                           \
 376         (2+(sizeof(type) <= 1 ? 3 :                                     \
 377             sizeof(type) <= 2 ? 5 :                                     \
 378             sizeof(type) <= 4 ? 10 :                                    \
 379             sizeof(type) <= 8 ? 20 : sizeof(int[-2*(sizeof(type) > 8)])))
 380
 381 #define SET_FLAG(v, flag, b) \
 382         (v) = (b) ? ((v) | (flag)) : ((v) & ~(flag))
 383
 384 #define IN_SET(x, y, ...)                                               \
 385         ({                                                              \
 386                 const typeof(y) _y = (y);                               \
 387                 const typeof(_y) _x = (x);                              \
 388                 unsigned _i;                                            \
 389                 bool _found = false;                                    \
 390                 for (_i = 0; _i < 1 + sizeof((const typeof(_x)[]) { __VA_ARGS__ })/sizeof(const typeof(_x)); _i++) \
 391                         if (((const typeof(_x)[]) { _y, __VA_ARGS__ })[_i] == _x) { \
 392                                 _found = true;                          \
 393                                 break;                                  \
 394                         }                                               \
 395                 _found;                                                 \
 396         })
 397
 398 /* Return a nulstr for a standard cascade of configuration directories,
 399  * suitable to pass to conf_files_list_nulstr or config_parse_many. */
 400 #define CONF_DIRS_NULSTR(n) \
 401         "/etc/" n ".d\0" \
 402         "/run/" n ".d\0" \
 403         "/usr/local/lib/" n ".d\0" \
 404         "/usr/lib/" n ".d\0" \
 405         CONF_DIR_SPLIT_USR(n)
 406
 407 #ifdef HAVE_SPLIT_USR
 408 #define CONF_DIR_SPLIT_USR(n) "/lib/" n ".d\0"
 409 #else
 410 #define CONF_DIR_SPLIT_USR(n)
 411 #endif
 412
 413 /* Define C11 thread_local attribute even on older gcc compiler
 414  * version */
 415 #ifndef thread_local
 416 /*
 417  * Don't break on glibc < 2.16 that doesn't define __STDC_NO_THREADS__
 418  * see http://gcc.gnu.org/bugzilla/show_bug.cgi?id=53769
 419  */
 420 #if __STDC_VERSION__ >= 201112L && !(defined(__STDC_NO_THREADS__) || (defined(__GNU_LIBRARY__) && __GLIBC__ == 2 && __GLIBC_MINOR__ < 16))
 421 #define thread_local _Thread_local
 422 #else
 423 #define thread_local __thread
 424 #endif
 425 #endif
 426
 427 /* Define C11 noreturn without <stdnoreturn.h> and even on older gcc
 428  * compiler versions */
 429 #ifndef noreturn
 430 #if __STDC_VERSION__ >= 201112L
 431 #define noreturn _Noreturn
 432 #else
 433 #define noreturn __attribute__((noreturn))
 434 #endif
 435 #endif
 436
 437 #define UID_INVALID ((uid_t) -1)
 438 #define GID_INVALID ((gid_t) -1)
 439 #define MODE_INVALID ((mode_t) -1)
 440
 441 #include "log.h"