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