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) static_assert(expr, #expr)
 147 #else
 148 #define assert_cc(expr) struct _assert_struct_ ## __LINE__ { char x[(expr) ? 0 : -1]; }
 149 #endif
 150
 151 #define assert_return(expr, r)                    \
 152         do {                                      \
 153                 if (_unlikely_(!(expr)))          \
 154                         return (r);               \
 155         } while (false)
 156
 157 #define PTR_TO_INT(p) ((int) ((intptr_t) (p)))
 158 #define INT_TO_PTR(u) ((void *) ((intptr_t) (u)))
 159 #define PTR_TO_UINT(p) ((unsigned int) ((uintptr_t) (p)))
 160 #define UINT_TO_PTR(u) ((void *) ((uintptr_t) (u)))
 161
 162 #define PTR_TO_LONG(p) ((long) ((intptr_t) (p)))
 163 #define LONG_TO_PTR(u) ((void *) ((intptr_t) (u)))
 164 #define PTR_TO_ULONG(p) ((unsigned long) ((uintptr_t) (p)))
 165 #define ULONG_TO_PTR(u) ((void *) ((uintptr_t) (u)))
 166
 167 #define PTR_TO_INT32(p) ((int32_t) ((intptr_t) (p)))
 168 #define INT32_TO_PTR(u) ((void *) ((intptr_t) (u)))
 169 #define PTR_TO_UINT32(p) ((uint32_t) ((uintptr_t) (p)))
 170 #define UINT32_TO_PTR(u) ((void *) ((uintptr_t) (u)))
 171
 172 #define PTR_TO_INT64(p) ((int64_t) ((intptr_t) (p)))
 173 #define INT64_TO_PTR(u) ((void *) ((intptr_t) (u)))
 174 #define PTR_TO_UINT64(p) ((uint64_t) ((uintptr_t) (p)))
 175 #define UINT64_TO_PTR(u) ((void *) ((uintptr_t) (u)))
 176
 177 #define memzero(x,l) (memset((x), 0, (l)))
 178 #define zero(x) (memzero(&(x), sizeof(x)))
 179
 180 #define CHAR_TO_STR(x) ((char[2]) { x, 0 })
 181
 182 #define char_array_0(x) x[sizeof(x)-1] = 0;
 183
 184 #define IOVEC_SET_STRING(i, s)                  \
 185         do {                                    \
 186                 struct iovec *_i = &(i);        \
 187                 char *_s = (char *)(s);         \
 188                 _i->iov_base = _s;              \
 189                 _i->iov_len = strlen(_s);       \
 190         } while(false)
 191
 192 static inline size_t IOVEC_TOTAL_SIZE(const struct iovec *i, unsigned n) {
 193         unsigned j;
 194         size_t r = 0;
 195
 196         for (j = 0; j < n; j++)
 197                 r += i[j].iov_len;
 198
 199         return r;
 200 }
 201
 202 static inline size_t IOVEC_INCREMENT(struct iovec *i, unsigned n, size_t k) {
 203         unsigned j;
 204
 205         for (j = 0; j < n; j++) {
 206                 size_t sub;
 207
 208                 if (_unlikely_(k <= 0))
 209                         break;
 210
 211                 sub = MIN(i[j].iov_len, k);
 212                 i[j].iov_len -= sub;
 213                 i[j].iov_base = (uint8_t*) i[j].iov_base + sub;
 214                 k -= sub;
 215         }
 216
 217         return k;
 218 }
 219
 220 #define VA_FORMAT_ADVANCE(format, ap)                                   \
 221 do {                                                                    \
 222         int _argtypes[128];                                             \
 223         size_t _i, _k;                                                  \
 224         _k = parse_printf_format((format), ELEMENTSOF(_argtypes), _argtypes); \
 225         assert(_k < ELEMENTSOF(_argtypes));                             \
 226         for (_i = 0; _i < _k; _i++) {                                   \
 227                 if (_argtypes[_i] & PA_FLAG_PTR)  {                     \
 228                         (void) va_arg(ap, void*);                       \
 229                         continue;                                       \
 230                 }                                                       \
 231                                                                         \
 232                 switch (_argtypes[_i]) {                                \
 233                 case PA_INT:                                            \
 234                 case PA_INT|PA_FLAG_SHORT:                              \
 235                 case PA_CHAR:                                           \
 236                         (void) va_arg(ap, int);                         \
 237                         break;                                          \
 238                 case PA_INT|PA_FLAG_LONG:                               \
 239                         (void) va_arg(ap, long int);                    \
 240                         break;                                          \
 241                 case PA_INT|PA_FLAG_LONG_LONG:                          \
 242                         (void) va_arg(ap, long long int);               \
 243                         break;                                          \
 244                 case PA_WCHAR:                                          \
 245                         (void) va_arg(ap, wchar_t);                     \
 246                         break;                                          \
 247                 case PA_WSTRING:                                        \
 248                 case PA_STRING:                                         \
 249                 case PA_POINTER:                                        \
 250                         (void) va_arg(ap, void*);                       \
 251                         break;                                          \
 252                 case PA_FLOAT:                                          \
 253                 case PA_DOUBLE:                                         \
 254                         (void) va_arg(ap, double);                      \
 255                         break;                                          \
 256                 case PA_DOUBLE|PA_FLAG_LONG_DOUBLE:                     \
 257                         (void) va_arg(ap, long double);                 \
 258                         break;                                          \
 259                 default:                                                \
 260                         assert_not_reached("Unknown format string argument."); \
 261                 }                                                       \
 262         }                                                               \
 263 } while(false)
 264
 265  /* Because statfs.t_type can be int on some architecures, we have to cast
 266   * the const magic to the type, otherwise the compiler warns about
 267   * signed/unsigned comparison, because the magic can be 32 bit unsigned.
 268  */
 269 #define F_TYPE_EQUAL(a, b) (a == (typeof(a)) b)
 270
 271 /* Returns the number of chars needed to format variables of the
 272  * specified type as a decimal string. Adds in extra space for a
 273  * negative '-' prefix. */
 274 #define DECIMAL_STR_MAX(type)                                           \
 275         (1+(sizeof(type) <= 1 ? 3 :                                     \
 276             sizeof(type) <= 2 ? 5 :                                     \
 277             sizeof(type) <= 4 ? 10 :                                    \
 278             sizeof(type) <= 8 ? 20 : sizeof(int[-2*(sizeof(type) > 8)])))
 279
 280 #define SET_FLAG(v, flag, b) \
 281         (v) = (b) ? ((v) | (flag)) : ((v) & ~(flag))
 282
 283 #include "log.h"