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