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 _noreturn_ __attribute__((noreturn))
  34 #define _unused_ __attribute__ ((unused))
  35 #define _destructor_ __attribute__ ((destructor))
  36 #define _pure_ __attribute__ ((pure))
  37 #define _const_ __attribute__ ((const))
  38 #define _deprecated_ __attribute__ ((deprecated))
  39 #define _packed_ __attribute__ ((packed))
  40 #define _malloc_ __attribute__ ((malloc))
  41 #define _weak_ __attribute__ ((weak))
  42 #define _likely_(x) (__builtin_expect(!!(x),1))
  43 #define _unlikely_(x) (__builtin_expect(!!(x),0))
  44 #define _public_ __attribute__ ((visibility("default")))
  45 #define _hidden_ __attribute__ ((visibility("hidden")))
  46 #define _weakref_(x) __attribute__((weakref(#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 ALIGN_PTR(p) ((void*) ALIGN((unsigned long) p))
  70 #define ALIGN4_PTR(p) ((void*) ALIGN4((unsigned long) p))
  71 #define ALIGN8_PTR(p) ((void*) ALIGN8((unsigned long) p))
  72
  73 static inline size_t ALIGN_TO(size_t l, size_t ali) {
  74         return ((l + ali - 1) & ~(ali - 1));
  75 }
  76
  77 #define ALIGN_TO_PTR(p, ali) ((void*) ALIGN_TO((unsigned long) p))
  78
  79 #define ELEMENTSOF(x) (sizeof(x)/sizeof((x)[0]))
  80
  81 /*
  82  * container_of - cast a member of a structure out to the containing structure
  83  * @ptr: the pointer to the member.
  84  * @type: the type of the container struct this is embedded in.
  85  * @member: the name of the member within the struct.
  86  *
  87  */
  88 #define container_of(ptr, type, member)                                 \
  89         __extension__ ({                                                \
  90                         const typeof( ((type *)0)->member ) *__mptr = (ptr); \
  91                         (type *)( (char *)__mptr - offsetof(type,member) ); \
  92                 })
  93
  94 #undef MAX
  95 #define MAX(a,b)                                 \
  96         __extension__ ({                         \
  97                         typeof(a) _a = (a);      \
  98                         typeof(b) _b = (b);      \
  99                         _a > _b ? _a : _b;       \
 100                 })
 101
 102 #define MAX3(x,y,z)                              \
 103         __extension__ ({                         \
 104                         typeof(x) _c = MAX(x,y); \
 105                         MAX(_c, z);              \
 106                 })
 107
 108 #undef MIN
 109 #define MIN(a,b)                                \
 110         __extension__ ({                        \
 111                         typeof(a) _a = (a);     \
 112                         typeof(b) _b = (b);     \
 113                         _a < _b ? _a : _b;      \
 114                 })
 115
 116 #ifndef CLAMP
 117 #define CLAMP(x, low, high)                                             \
 118         __extension__ ({                                                \
 119                         typeof(x) _x = (x);                             \
 120                         typeof(low) _low = (low);                       \
 121                         typeof(high) _high = (high);                    \
 122                         ((_x > _high) ? _high : ((_x < _low) ? _low : _x)); \
 123                 })
 124 #endif
 125
 126 #define assert_se(expr)                                                 \
 127         do {                                                            \
 128                 if (_unlikely_(!(expr)))                                \
 129                         log_assert_failed(#expr, __FILE__, __LINE__, __PRETTY_FUNCTION__); \
 130         } while (false)                                                 \
 131
 132 /* We override the glibc assert() here. */
 133 #undef assert
 134 #ifdef NDEBUG
 135 #define assert(expr) do {} while(false)
 136 #else
 137 #define assert(expr) assert_se(expr)
 138 #endif
 139
 140 #define assert_not_reached(t)                                           \
 141         do {                                                            \
 142                 log_assert_failed_unreachable(t, __FILE__, __LINE__, __PRETTY_FUNCTION__); \
 143         } while (false)
 144
 145 #if defined(static_assert)
 146 #define assert_cc(expr)                         \
 147         do {                                    \
 148                 static_assert(expr, #expr);     \
 149         } while (false)
 150 #else
 151 #define assert_cc(expr)                         \
 152         do {                                    \
 153                 switch (0) {                    \
 154                 case 0:                         \
 155                 case !!(expr):                  \
 156                         ;                       \
 157                 }                               \
 158         } while (false)
 159 #endif
 160
 161 #define assert_return(expr, r)                    \
 162         do {                                      \
 163                 if (!(expr))                      \
 164                         return (r);               \
 165         } while (false)
 166
 167 #define PTR_TO_INT(p) ((int) ((intptr_t) (p)))
 168 #define INT_TO_PTR(u) ((void *) ((intptr_t) (u)))
 169 #define PTR_TO_UINT(p) ((unsigned int) ((uintptr_t) (p)))
 170 #define UINT_TO_PTR(u) ((void *) ((uintptr_t) (u)))
 171
 172 #define PTR_TO_LONG(p) ((long) ((intptr_t) (p)))
 173 #define LONG_TO_PTR(u) ((void *) ((intptr_t) (u)))
 174 #define PTR_TO_ULONG(p) ((unsigned long) ((uintptr_t) (p)))
 175 #define ULONG_TO_PTR(u) ((void *) ((uintptr_t) (u)))
 176
 177 #define PTR_TO_INT32(p) ((int32_t) ((intptr_t) (p)))
 178 #define INT32_TO_PTR(u) ((void *) ((intptr_t) (u)))
 179 #define PTR_TO_UINT32(p) ((uint32_t) ((uintptr_t) (p)))
 180 #define UINT32_TO_PTR(u) ((void *) ((uintptr_t) (u)))
 181
 182 #define PTR_TO_INT64(p) ((int64_t) ((intptr_t) (p)))
 183 #define INT64_TO_PTR(u) ((void *) ((intptr_t) (u)))
 184 #define PTR_TO_UINT64(p) ((uint64_t) ((uintptr_t) (p)))
 185 #define UINT64_TO_PTR(u) ((void *) ((uintptr_t) (u)))
 186
 187 #define memzero(x,l) (memset((x), 0, (l)))
 188 #define zero(x) (memzero(&(x), sizeof(x)))
 189
 190 #define CHAR_TO_STR(x) ((char[2]) { x, 0 })
 191
 192 #define char_array_0(x) x[sizeof(x)-1] = 0;
 193
 194 #define IOVEC_SET_STRING(i, s)                  \
 195         do {                                    \
 196                 struct iovec *_i = &(i);        \
 197                 char *_s = (char *)(s);         \
 198                 _i->iov_base = _s;              \
 199                 _i->iov_len = strlen(_s);       \
 200         } while(false)
 201
 202 static inline size_t IOVEC_TOTAL_SIZE(const struct iovec *i, unsigned n) {
 203         unsigned j;
 204         size_t r = 0;
 205
 206         for (j = 0; j < n; j++)
 207                 r += i[j].iov_len;
 208
 209         return r;
 210 }
 211
 212 static inline size_t IOVEC_INCREMENT(struct iovec *i, unsigned n, size_t k) {
 213         unsigned j;
 214
 215         for (j = 0; j < n; j++) {
 216                 size_t sub;
 217
 218                 if (_unlikely_(k <= 0))
 219                         break;
 220
 221                 sub = MIN(i[j].iov_len, k);
 222                 i[j].iov_len -= sub;
 223                 i[j].iov_base = (uint8_t*) i[j].iov_base + sub;
 224                 k -= sub;
 225         }
 226
 227         return k;
 228 }
 229
 230 #define VA_FORMAT_ADVANCE(format, ap)                                   \
 231 do {                                                                    \
 232         int _argtypes[128];                                             \
 233         size_t _i, _k;                                                  \
 234         _k = parse_printf_format((format), ELEMENTSOF(_argtypes), _argtypes); \
 235         assert(_k < ELEMENTSOF(_argtypes));                             \
 236         for (_i = 0; _i < _k; _i++) {                                   \
 237                 if (_argtypes[_i] & PA_FLAG_PTR)  {                     \
 238                         (void) va_arg(ap, void*);                       \
 239                         continue;                                       \
 240                 }                                                       \
 241                                                                         \
 242                 switch (_argtypes[_i]) {                                \
 243                 case PA_INT:                                            \
 244                 case PA_INT|PA_FLAG_SHORT:                              \
 245                 case PA_CHAR:                                           \
 246                         (void) va_arg(ap, int);                         \
 247                         break;                                          \
 248                 case PA_INT|PA_FLAG_LONG:                               \
 249                         (void) va_arg(ap, long int);                    \
 250                         break;                                          \
 251                 case PA_INT|PA_FLAG_LONG_LONG:                          \
 252                         (void) va_arg(ap, long long int);               \
 253                         break;                                          \
 254                 case PA_WCHAR:                                          \
 255                         (void) va_arg(ap, wchar_t);                     \
 256                         break;                                          \
 257                 case PA_WSTRING:                                        \
 258                 case PA_STRING:                                         \
 259                 case PA_POINTER:                                        \
 260                         (void) va_arg(ap, void*);                       \
 261                         break;                                          \
 262                 case PA_FLOAT:                                          \
 263                 case PA_DOUBLE:                                         \
 264                         (void) va_arg(ap, double);                      \
 265                         break;                                          \
 266                 case PA_DOUBLE|PA_FLAG_LONG_DOUBLE:                     \
 267                         (void) va_arg(ap, long double);                 \
 268                         break;                                          \
 269                 default:                                                \
 270                         assert_not_reached("Unknown format string argument."); \
 271                 }                                                       \
 272         }                                                               \
 273 } while(false)
 274
 275  /* Because statfs.t_type can be int on some architecures, we have to cast
 276   * the const magic to the type, otherwise the compiler warns about
 277   * signed/unsigned comparison, because the magic can be 32 bit unsigned.
 278  */
 279 #define F_TYPE_EQUAL(a, b) (a == (typeof(a)) b)
 280
 281
 282 /* Returns the number of chars needed to format variables of the
 283  * specified type as a decimal string. Adds in extra space for a
 284  * negative '-' prefix. */
 285
 286 #define DECIMAL_STR_MAX(type)                                           \
 287         (1+(sizeof(type) <= 1 ? 3 :                                     \
 288             sizeof(type) <= 2 ? 5 :                                     \
 289             sizeof(type) <= 4 ? 10 :                                    \
 290             sizeof(type) <= 8 ? 20 : sizeof(int[-2*(sizeof(type) > 8)])))
 291
 292 #define SET_FLAG(v, flag, b) \
 293         (v) = (b) ? ((v) | (flag)) : ((v) & ~(flag))
 294
 295 #include "log.h"