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