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
  49 #define XSTRINGIFY(x) #x
  50 #define STRINGIFY(x) XSTRINGIFY(x)
  51
  52 /* Rounds up */
  53 #define ALIGN(l) ALIGN_TO((l), sizeof(void*))
  54 static inline size_t ALIGN_TO(size_t l, size_t ali) {
  55         return ((l + ali - 1) & ~(ali - 1));
  56 }
  57
  58 #define ELEMENTSOF(x) (sizeof(x)/sizeof((x)[0]))
  59
  60 /*
  61  * container_of - cast a member of a structure out to the containing structure
  62  * @ptr: the pointer to the member.
  63  * @type: the type of the container struct this is embedded in.
  64  * @member: the name of the member within the struct.
  65  *
  66  */
  67 #define container_of(ptr, type, member) ({ \
  68         const typeof( ((type *)0)->member ) *__mptr = (ptr); \
  69         (type *)( (char *)__mptr - offsetof(type,member) );})
  70
  71 #ifndef MAX
  72 #define MAX(a,b)                                \
  73         __extension__ ({                        \
  74                         typeof(a) _a = (a);     \
  75                         typeof(b) _b = (b);     \
  76                         _a > _b ? _a : _b;      \
  77                 })
  78 #endif
  79
  80 #define MAX3(a,b,c)                             \
  81         MAX(MAX(a,b),c)
  82
  83 #ifndef MIN
  84 #define MIN(a,b)                                \
  85         __extension__ ({                        \
  86                         typeof(a) _a = (a);     \
  87                         typeof(b) _b = (b);     \
  88                         _a < _b ? _a : _b;      \
  89                 })
  90 #endif
  91
  92 #define MIN3(a,b,c)                             \
  93         MIN(MIN(a,b),c)
  94
  95 #define CLAMP(x, low, high)                                             \
  96         __extension__ ({                                                \
  97                         typeof(x) _x = (x);                             \
  98                         typeof(low) _low = (low);                       \
  99                         typeof(high) _high = (high);                    \
 100                         ((_x > _high) ? _high : ((_x < _low) ? _low : _x)); \
 101                 })
 102
 103 #define assert_se(expr)                                                 \
 104         do {                                                            \
 105                 if (_unlikely_(!(expr)))                                \
 106                         log_assert_failed(#expr, __FILE__, __LINE__, __PRETTY_FUNCTION__); \
 107         } while (false)                                                 \
 108
 109 /* We override the glibc assert() here. */
 110 #undef assert
 111 #ifdef NDEBUG
 112 #define assert(expr) do {} while(false)
 113 #else
 114 #define assert(expr) assert_se(expr)
 115 #endif
 116
 117 #define assert_not_reached(t)                                           \
 118         do {                                                            \
 119                 log_assert_failed_unreachable(t, __FILE__, __LINE__, __PRETTY_FUNCTION__); \
 120         } while (false)
 121
 122 #if defined(static_assert)
 123 #define assert_cc(expr)                         \
 124         do {                                    \
 125                 static_assert(expr, #expr);     \
 126         } while (false)
 127 #else
 128 #define assert_cc(expr)                         \
 129         do {                                    \
 130                 switch (0) {                    \
 131                 case 0:                         \
 132                 case !!(expr):                  \
 133                         ;                       \
 134                 }                               \
 135         } while (false)
 136 #endif
 137
 138 #define PTR_TO_UINT(p) ((unsigned int) ((uintptr_t) (p)))
 139 #define UINT_TO_PTR(u) ((void*) ((uintptr_t) (u)))
 140
 141 #define PTR_TO_UINT32(p) ((uint32_t) ((uintptr_t) (p)))
 142 #define UINT32_TO_PTR(u) ((void*) ((uintptr_t) (u)))
 143
 144 #define PTR_TO_ULONG(p) ((unsigned long) ((uintptr_t) (p)))
 145 #define ULONG_TO_PTR(u) ((void*) ((uintptr_t) (u)))
 146
 147 #define PTR_TO_INT(p) ((int) ((intptr_t) (p)))
 148 #define INT_TO_PTR(u) ((void*) ((intptr_t) (u)))
 149
 150 #define TO_INT32(p) ((int32_t) ((intptr_t) (p)))
 151 #define INT32_TO_PTR(u) ((void*) ((intptr_t) (u)))
 152
 153 #define PTR_TO_LONG(p) ((long) ((intptr_t) (p)))
 154 #define LONG_TO_PTR(u) ((void*) ((intptr_t) (u)))
 155
 156 #define memzero(x,l) (memset((x), 0, (l)))
 157 #define zero(x) (memzero(&(x), sizeof(x)))
 158
 159 #define char_array_0(x) x[sizeof(x)-1] = 0;
 160
 161 #define IOVEC_SET_STRING(i, s)                  \
 162         do {                                    \
 163                 struct iovec *_i = &(i);        \
 164                 char *_s = (char *)(s);         \
 165                 _i->iov_base = _s;              \
 166                 _i->iov_len = strlen(_s);       \
 167         } while(false)
 168
 169 static inline size_t IOVEC_TOTAL_SIZE(const struct iovec *i, unsigned n) {
 170         unsigned j;
 171         size_t r = 0;
 172
 173         for (j = 0; j < n; j++)
 174                 r += i[j].iov_len;
 175
 176         return r;
 177 }
 178
 179 static inline size_t IOVEC_INCREMENT(struct iovec *i, unsigned n, size_t k) {
 180         unsigned j;
 181
 182         for (j = 0; j < n; j++) {
 183                 size_t sub;
 184
 185                 if (_unlikely_(k <= 0))
 186                         break;
 187
 188                 sub = MIN(i[j].iov_len, k);
 189                 i[j].iov_len -= sub;
 190                 i[j].iov_base = (uint8_t*) i[j].iov_base + sub;
 191                 k -= sub;
 192         }
 193
 194         return k;
 195 }
 196
 197 #define _cleanup_free_ __attribute__((cleanup(freep)))
 198 #define _cleanup_fclose_ __attribute__((cleanup(fclosep)))
 199 #define _cleanup_pclose_ __attribute__((cleanup(pclosep)))
 200 #define _cleanup_close_ __attribute__((cleanup(closep)))
 201 #define _cleanup_closedir_ __attribute__((cleanup(closedirp)))
 202 #define _cleanup_umask_ __attribute__((cleanup(umaskp)))
 203 #define _cleanup_set_free_ __attribute__((cleanup(set_freep)))
 204 #define _cleanup_set_free_free_ __attribute__((cleanup(set_free_freep)))
 205 #define _cleanup_strv_free_ __attribute__((cleanup(strv_freep)))
 206
 207 #define VA_FORMAT_ADVANCE(format, ap)                                   \
 208 do {                                                                    \
 209         int _argtypes[128];                                             \
 210         size_t _i, _k;                                                  \
 211         _k = parse_printf_format((format), ELEMENTSOF(_argtypes), _argtypes); \
 212         assert(_k < ELEMENTSOF(_argtypes));                             \
 213         for (_i = 0; _i < _k; _i++) {                                   \
 214                 if (_argtypes[_i] & PA_FLAG_PTR)  {                     \
 215                         (void) va_arg(ap, void*);                       \
 216                         continue;                                       \
 217                 }                                                       \
 218                                                                         \
 219                 switch (_argtypes[_i]) {                                \
 220                 case PA_INT:                                            \
 221                 case PA_INT|PA_FLAG_SHORT:                              \
 222                 case PA_CHAR:                                           \
 223                         (void) va_arg(ap, int);                         \
 224                         break;                                          \
 225                 case PA_INT|PA_FLAG_LONG:                               \
 226                         (void) va_arg(ap, long int);                    \
 227                         break;                                          \
 228                 case PA_INT|PA_FLAG_LONG_LONG:                          \
 229                         (void) va_arg(ap, long long int);               \
 230                         break;                                          \
 231                 case PA_WCHAR:                                          \
 232                         (void) va_arg(ap, wchar_t);                     \
 233                         break;                                          \
 234                 case PA_WSTRING:                                        \
 235                 case PA_STRING:                                         \
 236                 case PA_POINTER:                                        \
 237                         (void) va_arg(ap, void*);                       \
 238                         break;                                          \
 239                 case PA_FLOAT:                                          \
 240                 case PA_DOUBLE:                                         \
 241                         (void) va_arg(ap, double);                      \
 242                         break;                                          \
 243                 case PA_DOUBLE|PA_FLAG_LONG_DOUBLE:                     \
 244                         (void) va_arg(ap, long double);                 \
 245                         break;                                          \
 246                 default:                                                \
 247                         assert_not_reached("Unknown format string argument."); \
 248                 }                                                       \
 249         }                                                               \
 250 } while(false)
 251
 252 #include "log.h"