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 #define assert_se(expr)                                                 \
 201         do {                                                            \
 202                 if (_unlikely_(!(expr)))                                \
 203                         log_assert_failed(#expr, __FILE__, __LINE__, __PRETTY_FUNCTION__); \
 204         } while (false)                                                 \
 205
 206 /* We override the glibc assert() here. */
 207 #undef assert
 208 #ifdef NDEBUG
 209 #define assert(expr) do {} while(false)
 210 #else
 211 #define assert(expr) assert_se(expr)
 212 #endif
 213
 214 #define assert_not_reached(t)                                           \
 215         do {                                                            \
 216                 log_assert_failed_unreachable(t, __FILE__, __LINE__, __PRETTY_FUNCTION__); \
 217         } while (false)
 218
 219 #if defined(static_assert)
 220 /* static_assert() is sometimes defined in a way that trips up
 221  * -Wdeclaration-after-statement, hence let's temporarily turn off
 222  * this warning around it. */
 223 #define assert_cc(expr)                                                 \
 224         DISABLE_WARNING_DECLARATION_AFTER_STATEMENT;                    \
 225         static_assert(expr, #expr);                                     \
 226         REENABLE_WARNING
 227 #else
 228 #define assert_cc(expr)                                                 \
 229         DISABLE_WARNING_DECLARATION_AFTER_STATEMENT;                    \
 230         struct CONCATENATE(_assert_struct_, __LINE__) {                 \
 231                 char x[(expr) ? 0 : -1];                                \
 232         };                                                              \
 233         REENABLE_WARNING
 234 #endif
 235
 236 #define assert_return(expr, r)                                          \
 237         do {                                                            \
 238                 if (_unlikely_(!(expr))) {                              \
 239                         log_assert_failed_return(#expr, __FILE__, __LINE__, __PRETTY_FUNCTION__); \
 240                         return (r);                                     \
 241                 }                                                       \
 242         } while (false)
 243
 244 #define PTR_TO_INT(p) ((int) ((intptr_t) (p)))
 245 #define INT_TO_PTR(u) ((void *) ((intptr_t) (u)))
 246 #define PTR_TO_UINT(p) ((unsigned int) ((uintptr_t) (p)))
 247 #define UINT_TO_PTR(u) ((void *) ((uintptr_t) (u)))
 248
 249 #define PTR_TO_LONG(p) ((long) ((intptr_t) (p)))
 250 #define LONG_TO_PTR(u) ((void *) ((intptr_t) (u)))
 251 #define PTR_TO_ULONG(p) ((unsigned long) ((uintptr_t) (p)))
 252 #define ULONG_TO_PTR(u) ((void *) ((uintptr_t) (u)))
 253
 254 #define PTR_TO_INT32(p) ((int32_t) ((intptr_t) (p)))
 255 #define INT32_TO_PTR(u) ((void *) ((intptr_t) (u)))
 256 #define PTR_TO_UINT32(p) ((uint32_t) ((uintptr_t) (p)))
 257 #define UINT32_TO_PTR(u) ((void *) ((uintptr_t) (u)))
 258
 259 #define PTR_TO_INT64(p) ((int64_t) ((intptr_t) (p)))
 260 #define INT64_TO_PTR(u) ((void *) ((intptr_t) (u)))
 261 #define PTR_TO_UINT64(p) ((uint64_t) ((uintptr_t) (p)))
 262 #define UINT64_TO_PTR(u) ((void *) ((uintptr_t) (u)))
 263
 264 #define PTR_TO_SIZE(p) ((size_t) ((uintptr_t) (p)))
 265 #define SIZE_TO_PTR(u) ((void *) ((uintptr_t) (u)))
 266
 267 #define memzero(x,l) (memset((x), 0, (l)))
 268 #define zero(x) (memzero(&(x), sizeof(x)))
 269
 270 #define CHAR_TO_STR(x) ((char[2]) { x, 0 })
 271
 272 #define char_array_0(x) x[sizeof(x)-1] = 0;
 273
 274 #define IOVEC_SET_STRING(i, s)                  \
 275         do {                                    \
 276                 struct iovec *_i = &(i);        \
 277                 char *_s = (char *)(s);         \
 278                 _i->iov_base = _s;              \
 279                 _i->iov_len = strlen(_s);       \
 280         } while(false)
 281
 282 static inline size_t IOVEC_TOTAL_SIZE(const struct iovec *i, unsigned n) {
 283         unsigned j;
 284         size_t r = 0;
 285
 286         for (j = 0; j < n; j++)
 287                 r += i[j].iov_len;
 288
 289         return r;
 290 }
 291
 292 static inline size_t IOVEC_INCREMENT(struct iovec *i, unsigned n, size_t k) {
 293         unsigned j;
 294
 295         for (j = 0; j < n; j++) {
 296                 size_t sub;
 297
 298                 if (_unlikely_(k <= 0))
 299                         break;
 300
 301                 sub = MIN(i[j].iov_len, k);
 302                 i[j].iov_len -= sub;
 303                 i[j].iov_base = (uint8_t*) i[j].iov_base + sub;
 304                 k -= sub;
 305         }
 306
 307         return k;
 308 }
 309
 310 #define VA_FORMAT_ADVANCE(format, ap)                                   \
 311 do {                                                                    \
 312         int _argtypes[128];                                             \
 313         size_t _i, _k;                                                  \
 314         _k = parse_printf_format((format), ELEMENTSOF(_argtypes), _argtypes); \
 315         assert(_k < ELEMENTSOF(_argtypes));                             \
 316         for (_i = 0; _i < _k; _i++) {                                   \
 317                 if (_argtypes[_i] & PA_FLAG_PTR)  {                     \
 318                         (void) va_arg(ap, void*);                       \
 319                         continue;                                       \
 320                 }                                                       \
 321                                                                         \
 322                 switch (_argtypes[_i]) {                                \
 323                 case PA_INT:                                            \
 324                 case PA_INT|PA_FLAG_SHORT:                              \
 325                 case PA_CHAR:                                           \
 326                         (void) va_arg(ap, int);                         \
 327                         break;                                          \
 328                 case PA_INT|PA_FLAG_LONG:                               \
 329                         (void) va_arg(ap, long int);                    \
 330                         break;                                          \
 331                 case PA_INT|PA_FLAG_LONG_LONG:                          \
 332                         (void) va_arg(ap, long long int);               \
 333                         break;                                          \
 334                 case PA_WCHAR:                                          \
 335                         (void) va_arg(ap, wchar_t);                     \
 336                         break;                                          \
 337                 case PA_WSTRING:                                        \
 338                 case PA_STRING:                                         \
 339                 case PA_POINTER:                                        \
 340                         (void) va_arg(ap, void*);                       \
 341                         break;                                          \
 342                 case PA_FLOAT:                                          \
 343                 case PA_DOUBLE:                                         \
 344                         (void) va_arg(ap, double);                      \
 345                         break;                                          \
 346                 case PA_DOUBLE|PA_FLAG_LONG_DOUBLE:                     \
 347                         (void) va_arg(ap, long double);                 \
 348                         break;                                          \
 349                 default:                                                \
 350                         assert_not_reached("Unknown format string argument."); \
 351                 }                                                       \
 352         }                                                               \
 353 } while(false)
 354
 355  /* Because statfs.t_type can be int on some architectures, we have to cast
 356   * the const magic to the type, otherwise the compiler warns about
 357   * signed/unsigned comparison, because the magic can be 32 bit unsigned.
 358  */
 359 #define F_TYPE_EQUAL(a, b) (a == (typeof(a)) b)
 360
 361 /* Returns the number of chars needed to format variables of the
 362  * specified type as a decimal string. Adds in extra space for a
 363  * negative '-' prefix. */
 364 #define DECIMAL_STR_MAX(type)                                           \
 365         (2+(sizeof(type) <= 1 ? 3 :                                     \
 366             sizeof(type) <= 2 ? 5 :                                     \
 367             sizeof(type) <= 4 ? 10 :                                    \
 368             sizeof(type) <= 8 ? 20 : sizeof(int[-2*(sizeof(type) > 8)])))
 369
 370 #define SET_FLAG(v, flag, b) \
 371         (v) = (b) ? ((v) | (flag)) : ((v) & ~(flag))
 372
 373 #define IN_SET(x, y, ...)                                               \
 374         ({                                                              \
 375                 const typeof(y) _y = (y);                               \
 376                 const typeof(_y) _x = (x);                              \
 377                 unsigned _i;                                            \
 378                 bool _found = false;                                    \
 379                 for (_i = 0; _i < 1 + sizeof((const typeof(_x)[]) { __VA_ARGS__ })/sizeof(const typeof(_x)); _i++) \
 380                         if (((const typeof(_x)[]) { _y, __VA_ARGS__ })[_i] == _x) { \
 381                                 _found = true;                          \
 382                                 break;                                  \
 383                         }                                               \
 384                 _found;                                                 \
 385         })
 386
 387 /* Return a nulstr for a standard cascade of configuration directories,
 388  * suitable to pass to conf_files_list_nulstr or config_parse_many. */
 389 #define CONF_DIRS_NULSTR(n) \
 390         "/etc/" n ".d\0" \
 391         "/run/" n ".d\0" \
 392         "/usr/local/lib/" n ".d\0" \
 393         "/usr/lib/" n ".d\0" \
 394         CONF_DIR_SPLIT_USR(n)
 395
 396 #ifdef HAVE_SPLIT_USR
 397 #define CONF_DIR_SPLIT_USR(n) "/lib/" n ".d\0"
 398 #else
 399 #define CONF_DIR_SPLIT_USR(n)
 400 #endif
 401
 402 /* Define C11 thread_local attribute even on older gcc compiler
 403  * version */
 404 #ifndef thread_local
 405 /*
 406  * Don't break on glibc < 2.16 that doesn't define __STDC_NO_THREADS__
 407  * see http://gcc.gnu.org/bugzilla/show_bug.cgi?id=53769
 408  */
 409 #if __STDC_VERSION__ >= 201112L && !(defined(__STDC_NO_THREADS__) || (defined(__GNU_LIBRARY__) && __GLIBC__ == 2 && __GLIBC_MINOR__ < 16))
 410 #define thread_local _Thread_local
 411 #else
 412 #define thread_local __thread
 413 #endif
 414 #endif
 415
 416 /* Define C11 noreturn without <stdnoreturn.h> and even on older gcc
 417  * compiler versions */
 418 #ifndef noreturn
 419 #if __STDC_VERSION__ >= 201112L
 420 #define noreturn _Noreturn
 421 #else
 422 #define noreturn __attribute__((noreturn))
 423 #endif
 424 #endif
 425
 426 #define UID_INVALID ((uid_t) -1)
 427 #define GID_INVALID ((gid_t) -1)
 428 #define MODE_INVALID ((mode_t) -1)
 429
 430 #include "log.h"