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_attr_(a,b) __attribute__ ((format (printf, a, b)))
  31 #define _sentinel_ __attribute__ ((sentinel))
  32 #define _noreturn_ __attribute__((noreturn))
  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 _introspect_(x) __attribute__((section("introspect." x)))
  47 #define _alignas_(x) __attribute__((aligned(__alignof(x))))
  48 #define _cleanup_(x) __attribute__((cleanup(x)))
  49
  50 /* automake test harness */
  51 #define EXIT_TEST_SKIP 77
  52
  53 #define XSTRINGIFY(x) #x
  54 #define STRINGIFY(x) XSTRINGIFY(x)
  55
  56 /* Rounds up */
  57
  58 #define ALIGN4(l) (((l) + 3) & ~3)
  59 #define ALIGN8(l) (((l) + 7) & ~7)
  60
  61 #if __SIZEOF_POINTER__ == 8
  62 #define ALIGN(l) ALIGN8(l)
  63 #elif __SIZEOF_POINTER__ == 4
  64 #define ALIGN(l) ALIGN4(l)
  65 #else
  66 #error "Wut? Pointers are neither 4 nor 8 bytes long?"
  67 #endif
  68
  69 #define ALIGN8_PTR(p) ((void*) ALIGN8((unsigned long) p))
  70
  71 static inline size_t ALIGN_TO(size_t l, size_t ali) {
  72         return ((l + ali - 1) & ~(ali - 1));
  73 }
  74
  75 #define ELEMENTSOF(x) (sizeof(x)/sizeof((x)[0]))
  76
  77 /*
  78  * container_of - cast a member of a structure out to the containing structure
  79  * @ptr: the pointer to the member.
  80  * @type: the type of the container struct this is embedded in.
  81  * @member: the name of the member within the struct.
  82  *
  83  */
  84 #define container_of(ptr, type, member)                                 \
  85         __extension__ ({                                                \
  86                         const typeof( ((type *)0)->member ) *__mptr = (ptr); \
  87                         (type *)( (char *)__mptr - offsetof(type,member) ); \
  88                 })
  89
  90 #undef MAX
  91 #define MAX(a,b)                                 \
  92         __extension__ ({                         \
  93                         typeof(a) _a = (a);      \
  94                         typeof(b) _b = (b);      \
  95                         _a > _b ? _a : _b;       \
  96                 })
  97
  98 #define MAX3(x,y,z)                              \
  99         __extension__ ({                         \
 100                         typeof(x) _c = MAX(x,y); \
 101                         MAX(_c, z);              \
 102                 })
 103
 104 #undef MIN
 105 #define MIN(a,b)                                \
 106         __extension__ ({                        \
 107                         typeof(a) _a = (a);     \
 108                         typeof(b) _b = (b);     \
 109                         _a < _b ? _a : _b;      \
 110                 })
 111
 112 #ifndef CLAMP
 113 #define CLAMP(x, low, high)                                             \
 114         __extension__ ({                                                \
 115                         typeof(x) _x = (x);                             \
 116                         typeof(low) _low = (low);                       \
 117                         typeof(high) _high = (high);                    \
 118                         ((_x > _high) ? _high : ((_x < _low) ? _low : _x)); \
 119                 })
 120 #endif
 121
 122 #define assert_se(expr)                                                 \
 123         do {                                                            \
 124                 if (_unlikely_(!(expr)))                                \
 125                         log_assert_failed(#expr, __FILE__, __LINE__, __PRETTY_FUNCTION__); \
 126         } while (false)                                                 \
 127
 128 /* We override the glibc assert() here. */
 129 #undef assert
 130 #ifdef NDEBUG
 131 #define assert(expr) do {} while(false)
 132 #else
 133 #define assert(expr) assert_se(expr)
 134 #endif
 135
 136 #define assert_not_reached(t)                                           \
 137         do {                                                            \
 138                 log_assert_failed_unreachable(t, __FILE__, __LINE__, __PRETTY_FUNCTION__); \
 139         } while (false)
 140
 141 #if defined(static_assert)
 142 #define assert_cc(expr)                         \
 143         do {                                    \
 144                 static_assert(expr, #expr);     \
 145         } while (false)
 146 #else
 147 #define assert_cc(expr)                         \
 148         do {                                    \
 149                 switch (0) {                    \
 150                 case 0:                         \
 151                 case !!(expr):                  \
 152                         ;                       \
 153                 }                               \
 154         } while (false)
 155 #endif
 156
 157 #define PTR_TO_UINT(p) ((unsigned int) ((uintptr_t) (p)))
 158 #define UINT_TO_PTR(u) ((void*) ((uintptr_t) (u)))
 159
 160 #define PTR_TO_UINT32(p) ((uint32_t) ((uintptr_t) (p)))
 161 #define UINT32_TO_PTR(u) ((void*) ((uintptr_t) (u)))
 162
 163 #define PTR_TO_ULONG(p) ((unsigned long) ((uintptr_t) (p)))
 164 #define ULONG_TO_PTR(u) ((void*) ((uintptr_t) (u)))
 165
 166 #define PTR_TO_INT(p) ((int) ((intptr_t) (p)))
 167 #define INT_TO_PTR(u) ((void*) ((intptr_t) (u)))
 168
 169 #define TO_INT32(p) ((int32_t) ((intptr_t) (p)))
 170 #define INT32_TO_PTR(u) ((void*) ((intptr_t) (u)))
 171
 172 #define PTR_TO_LONG(p) ((long) ((intptr_t) (p)))
 173 #define LONG_TO_PTR(u) ((void*) ((intptr_t) (u)))
 174
 175 #define memzero(x,l) (memset((x), 0, (l)))
 176 #define zero(x) (memzero(&(x), sizeof(x)))
 177
 178 #define CHAR_TO_STR(x) ((char[2]) { x, 0 })
 179
 180 #define char_array_0(x) x[sizeof(x)-1] = 0;
 181
 182 #define IOVEC_SET_STRING(i, s)                  \
 183         do {                                    \
 184                 struct iovec *_i = &(i);        \
 185                 char *_s = (char *)(s);         \
 186                 _i->iov_base = _s;              \
 187                 _i->iov_len = strlen(_s);       \
 188         } while(false)
 189
 190 static inline size_t IOVEC_TOTAL_SIZE(const struct iovec *i, unsigned n) {
 191         unsigned j;
 192         size_t r = 0;
 193
 194         for (j = 0; j < n; j++)
 195                 r += i[j].iov_len;
 196
 197         return r;
 198 }
 199
 200 static inline size_t IOVEC_INCREMENT(struct iovec *i, unsigned n, size_t k) {
 201         unsigned j;
 202
 203         for (j = 0; j < n; j++) {
 204                 size_t sub;
 205
 206                 if (_unlikely_(k <= 0))
 207                         break;
 208
 209                 sub = MIN(i[j].iov_len, k);
 210                 i[j].iov_len -= sub;
 211                 i[j].iov_base = (uint8_t*) i[j].iov_base + sub;
 212                 k -= sub;
 213         }
 214
 215         return k;
 216 }
 217
 218 #define VA_FORMAT_ADVANCE(format, ap)                                   \
 219 do {                                                                    \
 220         int _argtypes[128];                                             \
 221         size_t _i, _k;                                                  \
 222         _k = parse_printf_format((format), ELEMENTSOF(_argtypes), _argtypes); \
 223         assert(_k < ELEMENTSOF(_argtypes));                             \
 224         for (_i = 0; _i < _k; _i++) {                                   \
 225                 if (_argtypes[_i] & PA_FLAG_PTR)  {                     \
 226                         (void) va_arg(ap, void*);                       \
 227                         continue;                                       \
 228                 }                                                       \
 229                                                                         \
 230                 switch (_argtypes[_i]) {                                \
 231                 case PA_INT:                                            \
 232                 case PA_INT|PA_FLAG_SHORT:                              \
 233                 case PA_CHAR:                                           \
 234                         (void) va_arg(ap, int);                         \
 235                         break;                                          \
 236                 case PA_INT|PA_FLAG_LONG:                               \
 237                         (void) va_arg(ap, long int);                    \
 238                         break;                                          \
 239                 case PA_INT|PA_FLAG_LONG_LONG:                          \
 240                         (void) va_arg(ap, long long int);               \
 241                         break;                                          \
 242                 case PA_WCHAR:                                          \
 243                         (void) va_arg(ap, wchar_t);                     \
 244                         break;                                          \
 245                 case PA_WSTRING:                                        \
 246                 case PA_STRING:                                         \
 247                 case PA_POINTER:                                        \
 248                         (void) va_arg(ap, void*);                       \
 249                         break;                                          \
 250                 case PA_FLOAT:                                          \
 251                 case PA_DOUBLE:                                         \
 252                         (void) va_arg(ap, double);                      \
 253                         break;                                          \
 254                 case PA_DOUBLE|PA_FLAG_LONG_DOUBLE:                     \
 255                         (void) va_arg(ap, long double);                 \
 256                         break;                                          \
 257                 default:                                                \
 258                         assert_not_reached("Unknown format string argument."); \
 259                 }                                                       \
 260         }                                                               \
 261 } while(false)
 262
 263 /* Returns the number of chars needed to format variables of the
 264  * specified type as a decimal string. Adds in extra space for a
 265  * negative '-' prefix. */
 266
 267 #define DECIMAL_STR_MAX(type)                                           \
 268         (1+(sizeof(type) <= 1 ? 3 :                                     \
 269             sizeof(type) <= 2 ? 5 :                                     \
 270             sizeof(type) <= 4 ? 10 :                                    \
 271             sizeof(type) <= 8 ? 20 : sizeof(int[-2*(sizeof(type) > 8)])))
 272
 273 #include "log.h"