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