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 UNIQUE(prefix) CONCATENATE(prefix, __LINE__)
  83
  84 /* Rounds up */
  85
  86 #define ALIGN4(l) (((l) + 3) & ~3)
  87 #define ALIGN8(l) (((l) + 7) & ~7)
  88
  89 #if __SIZEOF_POINTER__ == 8
  90 #define ALIGN(l) ALIGN8(l)
  91 #elif __SIZEOF_POINTER__ == 4
  92 #define ALIGN(l) ALIGN4(l)
  93 #else
  94 #error "Wut? Pointers are neither 4 nor 8 bytes long?"
  95 #endif
  96
  97 #define ALIGN_PTR(p) ((void*) ALIGN((unsigned long) p))
  98 #define ALIGN4_PTR(p) ((void*) ALIGN4((unsigned long) p))
  99 #define ALIGN8_PTR(p) ((void*) ALIGN8((unsigned long) p))
 100
 101 static inline size_t ALIGN_TO(size_t l, size_t ali) {
 102         return ((l + ali - 1) & ~(ali - 1));
 103 }
 104
 105 #define ALIGN_TO_PTR(p, ali) ((void*) ALIGN_TO((unsigned long) p, ali))
 106
 107 /* align to next higher power-of-2 (except for: 0 => 0, overflow => 0) */
 108 static inline unsigned long ALIGN_POWER2(unsigned long u) {
 109         /* clz(0) is undefined */
 110         if (u == 1)
 111                 return 1;
 112
 113         /* left-shift overflow is undefined */
 114         if (__builtin_clzl(u - 1UL) < 1)
 115                 return 0;
 116
 117         return 1UL << (sizeof(u) * 8 - __builtin_clzl(u - 1UL));
 118 }
 119
 120 #define ELEMENTSOF(x) (sizeof(x)/sizeof((x)[0]))
 121
 122 /*
 123  * container_of - cast a member of a structure out to the containing structure
 124  * @ptr: the pointer to the member.
 125  * @type: the type of the container struct this is embedded in.
 126  * @member: the name of the member within the struct.
 127  *
 128  */
 129 #define container_of(ptr, type, member)                                 \
 130         __extension__ ({                                                \
 131                         const typeof( ((type *)0)->member ) *__mptr = (ptr); \
 132                         (type *)( (char *)__mptr - offsetof(type,member) ); \
 133                 })
 134
 135 #undef MAX
 136 #define MAX(a,b)                                 \
 137         __extension__ ({                         \
 138                         typeof(a) _a = (a);      \
 139                         typeof(b) _b = (b);      \
 140                         _a > _b ? _a : _b;       \
 141                 })
 142
 143 #define MAX3(x,y,z)                              \
 144         __extension__ ({                         \
 145                         typeof(x) _c = MAX(x,y); \
 146                         MAX(_c, z);              \
 147                 })
 148
 149 #undef MIN
 150 #define MIN(a,b)                                \
 151         __extension__ ({                        \
 152                         typeof(a) _a = (a);     \
 153                         typeof(b) _b = (b);     \
 154                         _a < _b ? _a : _b;      \
 155                 })
 156
 157 #define MIN3(x,y,z)                              \
 158         __extension__ ({                         \
 159                         typeof(x) _c = MIN(x,y); \
 160                         MIN(_c, z);              \
 161                 })
 162
 163 #define LESS_BY(A,B)                            \
 164         __extension__ ({                        \
 165                         typeof(A) _A = (A);     \
 166                         typeof(B) _B = (B);     \
 167                         _A > _B ? _A - _B : 0;  \
 168                 })
 169
 170 #ifndef CLAMP
 171 #define CLAMP(x, low, high)                                             \
 172         __extension__ ({                                                \
 173                         typeof(x) _x = (x);                             \
 174                         typeof(low) _low = (low);                       \
 175                         typeof(high) _high = (high);                    \
 176                         ((_x > _high) ? _high : ((_x < _low) ? _low : _x)); \
 177                 })
 178 #endif
 179
 180 #define assert_se(expr)                                                 \
 181         do {                                                            \
 182                 if (_unlikely_(!(expr)))                                \
 183                         log_assert_failed(#expr, __FILE__, __LINE__, __PRETTY_FUNCTION__); \
 184         } while (false)                                                 \
 185
 186 /* We override the glibc assert() here. */
 187 #undef assert
 188 #ifdef NDEBUG
 189 #define assert(expr) do {} while(false)
 190 #else
 191 #define assert(expr) assert_se(expr)
 192 #endif
 193
 194 #define assert_not_reached(t)                                           \
 195         do {                                                            \
 196                 log_assert_failed_unreachable(t, __FILE__, __LINE__, __PRETTY_FUNCTION__); \
 197         } while (false)
 198
 199 #if defined(static_assert)
 200 /* static_assert() is sometimes defined in a way that trips up
 201  * -Wdeclaration-after-statement, hence let's temporarily turn off
 202  * this warning around it. */
 203 #define assert_cc(expr)                                                 \
 204         DISABLE_WARNING_DECLARATION_AFTER_STATEMENT;                    \
 205         static_assert(expr, #expr);                                     \
 206         REENABLE_WARNING
 207 #else
 208 #define assert_cc(expr)                                                 \
 209         DISABLE_WARNING_DECLARATION_AFTER_STATEMENT;                    \
 210         struct UNIQUE(_assert_struct_) {                                \
 211                 char x[(expr) ? 0 : -1];                                \
 212         };                                                              \
 213         REENABLE_WARNING
 214 #endif
 215
 216 #define assert_return(expr, r)                                          \
 217         do {                                                            \
 218                 if (_unlikely_(!(expr))) {                              \
 219                         log_assert_failed_return(#expr, __FILE__, __LINE__, __PRETTY_FUNCTION__); \
 220                         return (r);                                     \
 221                 }                                                       \
 222         } while (false)
 223
 224 #define PTR_TO_INT(p) ((int) ((intptr_t) (p)))
 225 #define INT_TO_PTR(u) ((void *) ((intptr_t) (u)))
 226 #define PTR_TO_UINT(p) ((unsigned int) ((uintptr_t) (p)))
 227 #define UINT_TO_PTR(u) ((void *) ((uintptr_t) (u)))
 228
 229 #define PTR_TO_LONG(p) ((long) ((intptr_t) (p)))
 230 #define LONG_TO_PTR(u) ((void *) ((intptr_t) (u)))
 231 #define PTR_TO_ULONG(p) ((unsigned long) ((uintptr_t) (p)))
 232 #define ULONG_TO_PTR(u) ((void *) ((uintptr_t) (u)))
 233
 234 #define PTR_TO_INT32(p) ((int32_t) ((intptr_t) (p)))
 235 #define INT32_TO_PTR(u) ((void *) ((intptr_t) (u)))
 236 #define PTR_TO_UINT32(p) ((uint32_t) ((uintptr_t) (p)))
 237 #define UINT32_TO_PTR(u) ((void *) ((uintptr_t) (u)))
 238
 239 #define PTR_TO_INT64(p) ((int64_t) ((intptr_t) (p)))
 240 #define INT64_TO_PTR(u) ((void *) ((intptr_t) (u)))
 241 #define PTR_TO_UINT64(p) ((uint64_t) ((uintptr_t) (p)))
 242 #define UINT64_TO_PTR(u) ((void *) ((uintptr_t) (u)))
 243
 244 #define PTR_TO_SIZE(p) ((size_t) ((uintptr_t) (p)))
 245 #define SIZE_TO_PTR(u) ((void *) ((uintptr_t) (u)))
 246
 247 #define memzero(x,l) (memset((x), 0, (l)))
 248 #define zero(x) (memzero(&(x), sizeof(x)))
 249
 250 #define CHAR_TO_STR(x) ((char[2]) { x, 0 })
 251
 252 #define char_array_0(x) x[sizeof(x)-1] = 0;
 253
 254 #define IOVEC_SET_STRING(i, s)                  \
 255         do {                                    \
 256                 struct iovec *_i = &(i);        \
 257                 char *_s = (char *)(s);         \
 258                 _i->iov_base = _s;              \
 259                 _i->iov_len = strlen(_s);       \
 260         } while(false)
 261
 262 static inline size_t IOVEC_TOTAL_SIZE(const struct iovec *i, unsigned n) {
 263         unsigned j;
 264         size_t r = 0;
 265
 266         for (j = 0; j < n; j++)
 267                 r += i[j].iov_len;
 268
 269         return r;
 270 }
 271
 272 static inline size_t IOVEC_INCREMENT(struct iovec *i, unsigned n, size_t k) {
 273         unsigned j;
 274
 275         for (j = 0; j < n; j++) {
 276                 size_t sub;
 277
 278                 if (_unlikely_(k <= 0))
 279                         break;
 280
 281                 sub = MIN(i[j].iov_len, k);
 282                 i[j].iov_len -= sub;
 283                 i[j].iov_base = (uint8_t*) i[j].iov_base + sub;
 284                 k -= sub;
 285         }
 286
 287         return k;
 288 }
 289
 290 #define VA_FORMAT_ADVANCE(format, ap)                                   \
 291 do {                                                                    \
 292         int _argtypes[128];                                             \
 293         size_t _i, _k;                                                  \
 294         _k = parse_printf_format((format), ELEMENTSOF(_argtypes), _argtypes); \
 295         assert(_k < ELEMENTSOF(_argtypes));                             \
 296         for (_i = 0; _i < _k; _i++) {                                   \
 297                 if (_argtypes[_i] & PA_FLAG_PTR)  {                     \
 298                         (void) va_arg(ap, void*);                       \
 299                         continue;                                       \
 300                 }                                                       \
 301                                                                         \
 302                 switch (_argtypes[_i]) {                                \
 303                 case PA_INT:                                            \
 304                 case PA_INT|PA_FLAG_SHORT:                              \
 305                 case PA_CHAR:                                           \
 306                         (void) va_arg(ap, int);                         \
 307                         break;                                          \
 308                 case PA_INT|PA_FLAG_LONG:                               \
 309                         (void) va_arg(ap, long int);                    \
 310                         break;                                          \
 311                 case PA_INT|PA_FLAG_LONG_LONG:                          \
 312                         (void) va_arg(ap, long long int);               \
 313                         break;                                          \
 314                 case PA_WCHAR:                                          \
 315                         (void) va_arg(ap, wchar_t);                     \
 316                         break;                                          \
 317                 case PA_WSTRING:                                        \
 318                 case PA_STRING:                                         \
 319                 case PA_POINTER:                                        \
 320                         (void) va_arg(ap, void*);                       \
 321                         break;                                          \
 322                 case PA_FLOAT:                                          \
 323                 case PA_DOUBLE:                                         \
 324                         (void) va_arg(ap, double);                      \
 325                         break;                                          \
 326                 case PA_DOUBLE|PA_FLAG_LONG_DOUBLE:                     \
 327                         (void) va_arg(ap, long double);                 \
 328                         break;                                          \
 329                 default:                                                \
 330                         assert_not_reached("Unknown format string argument."); \
 331                 }                                                       \
 332         }                                                               \
 333 } while(false)
 334
 335  /* Because statfs.t_type can be int on some architectures, we have to cast
 336   * the const magic to the type, otherwise the compiler warns about
 337   * signed/unsigned comparison, because the magic can be 32 bit unsigned.
 338  */
 339 #define F_TYPE_EQUAL(a, b) (a == (typeof(a)) b)
 340
 341 /* Returns the number of chars needed to format variables of the
 342  * specified type as a decimal string. Adds in extra space for a
 343  * negative '-' prefix. */
 344 #define DECIMAL_STR_MAX(type)                                           \
 345         (2+(sizeof(type) <= 1 ? 3 :                                     \
 346             sizeof(type) <= 2 ? 5 :                                     \
 347             sizeof(type) <= 4 ? 10 :                                    \
 348             sizeof(type) <= 8 ? 20 : sizeof(int[-2*(sizeof(type) > 8)])))
 349
 350 #define SET_FLAG(v, flag, b) \
 351         (v) = (b) ? ((v) | (flag)) : ((v) & ~(flag))
 352
 353 #define IN_SET(x, y, ...)                                               \
 354         ({                                                              \
 355                 const typeof(y) _y = (y);                               \
 356                 const typeof(_y) _x = (x);                              \
 357                 unsigned _i;                                            \
 358                 bool _found = false;                                    \
 359                 for (_i = 0; _i < 1 + sizeof((const typeof(_x)[]) { __VA_ARGS__ })/sizeof(const typeof(_x)); _i++) \
 360                         if (((const typeof(_x)[]) { _y, __VA_ARGS__ })[_i] == _x) { \
 361                                 _found = true;                          \
 362                                 break;                                  \
 363                         }                                               \
 364                 _found;                                                 \
 365         })
 366
 367 /* Define C11 thread_local attribute even on older gcc compiler
 368  * version */
 369 #ifndef thread_local
 370 /*
 371  * Don't break on glibc < 2.16 that doesn't define __STDC_NO_THREADS__
 372  * see http://gcc.gnu.org/bugzilla/show_bug.cgi?id=53769
 373  */
 374 #if __STDC_VERSION__ >= 201112L && !(defined(__STDC_NO_THREADS__) || (defined(__GNU_LIBRARY__) && __GLIBC__ == 2 && __GLIBC_MINOR__ < 16))
 375 #define thread_local _Thread_local
 376 #else
 377 #define thread_local __thread
 378 #endif
 379 #endif
 380
 381 /* Define C11 noreturn without <stdnoreturn.h> and even on older gcc
 382  * compiler versions */
 383 #ifndef noreturn
 384 #if __STDC_VERSION__ >= 201112L
 385 #define noreturn _Noreturn
 386 #else
 387 #define noreturn __attribute__((noreturn))
 388 #endif
 389 #endif
 390
 391 #include "log.h"