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