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 /* The following macros add 1 when converting things, since UID 0 is a
 279  * valid UID, while the pointer NULL is special */
 280 #define PTR_TO_UID(p) ((uid_t) (((uintptr_t) (p))-1))
 281 #define UID_TO_PTR(u) ((void*) (((uintptr_t) (u))+1))
 282
 283 #define PTR_TO_GID(p) ((gid_t) (((uintptr_t) (p))-1))
 284 #define GID_TO_PTR(u) ((void*) (((uintptr_t) (u))+1))
 285
 286 #define memzero(x,l) (memset((x), 0, (l)))
 287 #define zero(x) (memzero(&(x), sizeof(x)))
 288
 289 #define CHAR_TO_STR(x) ((char[2]) { x, 0 })
 290
 291 #define char_array_0(x) x[sizeof(x)-1] = 0;
 292
 293 #define IOVEC_SET_STRING(i, s)                  \
 294         do {                                    \
 295                 struct iovec *_i = &(i);        \
 296                 char *_s = (char *)(s);         \
 297                 _i->iov_base = _s;              \
 298                 _i->iov_len = strlen(_s);       \
 299         } while(false)
 300
 301 static inline size_t IOVEC_TOTAL_SIZE(const struct iovec *i, unsigned n) {
 302         unsigned j;
 303         size_t r = 0;
 304
 305         for (j = 0; j < n; j++)
 306                 r += i[j].iov_len;
 307
 308         return r;
 309 }
 310
 311 static inline size_t IOVEC_INCREMENT(struct iovec *i, unsigned n, size_t k) {
 312         unsigned j;
 313
 314         for (j = 0; j < n; j++) {
 315                 size_t sub;
 316
 317                 if (_unlikely_(k <= 0))
 318                         break;
 319
 320                 sub = MIN(i[j].iov_len, k);
 321                 i[j].iov_len -= sub;
 322                 i[j].iov_base = (uint8_t*) i[j].iov_base + sub;
 323                 k -= sub;
 324         }
 325
 326         return k;
 327 }
 328
 329 #define VA_FORMAT_ADVANCE(format, ap)                                   \
 330 do {                                                                    \
 331         int _argtypes[128];                                             \
 332         size_t _i, _k;                                                  \
 333         _k = parse_printf_format((format), ELEMENTSOF(_argtypes), _argtypes); \
 334         assert(_k < ELEMENTSOF(_argtypes));                             \
 335         for (_i = 0; _i < _k; _i++) {                                   \
 336                 if (_argtypes[_i] & PA_FLAG_PTR)  {                     \
 337                         (void) va_arg(ap, void*);                       \
 338                         continue;                                       \
 339                 }                                                       \
 340                                                                         \
 341                 switch (_argtypes[_i]) {                                \
 342                 case PA_INT:                                            \
 343                 case PA_INT|PA_FLAG_SHORT:                              \
 344                 case PA_CHAR:                                           \
 345                         (void) va_arg(ap, int);                         \
 346                         break;                                          \
 347                 case PA_INT|PA_FLAG_LONG:                               \
 348                         (void) va_arg(ap, long int);                    \
 349                         break;                                          \
 350                 case PA_INT|PA_FLAG_LONG_LONG:                          \
 351                         (void) va_arg(ap, long long int);               \
 352                         break;                                          \
 353                 case PA_WCHAR:                                          \
 354                         (void) va_arg(ap, wchar_t);                     \
 355                         break;                                          \
 356                 case PA_WSTRING:                                        \
 357                 case PA_STRING:                                         \
 358                 case PA_POINTER:                                        \
 359                         (void) va_arg(ap, void*);                       \
 360                         break;                                          \
 361                 case PA_FLOAT:                                          \
 362                 case PA_DOUBLE:                                         \
 363                         (void) va_arg(ap, double);                      \
 364                         break;                                          \
 365                 case PA_DOUBLE|PA_FLAG_LONG_DOUBLE:                     \
 366                         (void) va_arg(ap, long double);                 \
 367                         break;                                          \
 368                 default:                                                \
 369                         assert_not_reached("Unknown format string argument."); \
 370                 }                                                       \
 371         }                                                               \
 372 } while(false)
 373
 374  /* Because statfs.t_type can be int on some architectures, we have to cast
 375   * the const magic to the type, otherwise the compiler warns about
 376   * signed/unsigned comparison, because the magic can be 32 bit unsigned.
 377  */
 378 #define F_TYPE_EQUAL(a, b) (a == (typeof(a)) b)
 379
 380 /* Returns the number of chars needed to format variables of the
 381  * specified type as a decimal string. Adds in extra space for a
 382  * negative '-' prefix. */
 383 #define DECIMAL_STR_MAX(type)                                           \
 384         (2+(sizeof(type) <= 1 ? 3 :                                     \
 385             sizeof(type) <= 2 ? 5 :                                     \
 386             sizeof(type) <= 4 ? 10 :                                    \
 387             sizeof(type) <= 8 ? 20 : sizeof(int[-2*(sizeof(type) > 8)])))
 388
 389 #define SET_FLAG(v, flag, b) \
 390         (v) = (b) ? ((v) | (flag)) : ((v) & ~(flag))
 391
 392 #define IN_SET(x, y, ...)                                               \
 393         ({                                                              \
 394                 const typeof(y) _y = (y);                               \
 395                 const typeof(_y) _x = (x);                              \
 396                 unsigned _i;                                            \
 397                 bool _found = false;                                    \
 398                 for (_i = 0; _i < 1 + sizeof((const typeof(_x)[]) { __VA_ARGS__ })/sizeof(const typeof(_x)); _i++) \
 399                         if (((const typeof(_x)[]) { _y, __VA_ARGS__ })[_i] == _x) { \
 400                                 _found = true;                          \
 401                                 break;                                  \
 402                         }                                               \
 403                 _found;                                                 \
 404         })
 405
 406 /* Return a nulstr for a standard cascade of configuration directories,
 407  * suitable to pass to conf_files_list_nulstr or config_parse_many. */
 408 #define CONF_DIRS_NULSTR(n) \
 409         "/etc/" n ".d\0" \
 410         "/run/" n ".d\0" \
 411         "/usr/local/lib/" n ".d\0" \
 412         "/usr/lib/" n ".d\0" \
 413         CONF_DIR_SPLIT_USR(n)
 414
 415 #ifdef HAVE_SPLIT_USR
 416 #define CONF_DIR_SPLIT_USR(n) "/lib/" n ".d\0"
 417 #else
 418 #define CONF_DIR_SPLIT_USR(n)
 419 #endif
 420
 421 /* Define C11 thread_local attribute even on older gcc compiler
 422  * version */
 423 #ifndef thread_local
 424 /*
 425  * Don't break on glibc < 2.16 that doesn't define __STDC_NO_THREADS__
 426  * see http://gcc.gnu.org/bugzilla/show_bug.cgi?id=53769
 427  */
 428 #if __STDC_VERSION__ >= 201112L && !(defined(__STDC_NO_THREADS__) || (defined(__GNU_LIBRARY__) && __GLIBC__ == 2 && __GLIBC_MINOR__ < 16))
 429 #define thread_local _Thread_local
 430 #else
 431 #define thread_local __thread
 432 #endif
 433 #endif
 434
 435 /* Define C11 noreturn without <stdnoreturn.h> and even on older gcc
 436  * compiler versions */
 437 #ifndef noreturn
 438 #if __STDC_VERSION__ >= 201112L
 439 #define noreturn _Noreturn
 440 #else
 441 #define noreturn __attribute__((noreturn))
 442 #endif
 443 #endif
 444
 445 #define UID_INVALID ((uid_t) -1)
 446 #define GID_INVALID ((gid_t) -1)
 447 #define MODE_INVALID ((mode_t) -1)
 448
 449 #define DEFINE_TRIVIAL_CLEANUP_FUNC(type, func)                 \
 450         static inline void func##p(type *p) {                   \
 451                 if (*p)                                         \
 452                         func(*p);                               \
 453         }                                                       \
 454         struct __useless_struct_to_allow_trailing_semicolon__
 455
 456 #include "log.h"