src/basic/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/sysmacros.h>
  27 #include <sys/types.h>
  28 #include <sys/uio.h>
  29 #include <inttypes.h>
  30 #include <stdbool.h>
  31
  32 #define _printf_(a,b) __attribute__ ((format (printf, a, b)))
  33 #define _alloc_(...) __attribute__ ((alloc_size(__VA_ARGS__)))
  34 #define _sentinel_ __attribute__ ((sentinel))
  35 #define _unused_ __attribute__ ((unused))
  36 #define _destructor_ __attribute__ ((destructor))
  37 #define _pure_ __attribute__ ((pure))
  38 #define _const_ __attribute__ ((const))
  39 #define _deprecated_ __attribute__ ((deprecated))
  40 #define _packed_ __attribute__ ((packed))
  41 #define _malloc_ __attribute__ ((malloc))
  42 #define _weak_ __attribute__ ((weak))
  43 #define _likely_(x) (__builtin_expect(!!(x),1))
  44 #define _unlikely_(x) (__builtin_expect(!!(x),0))
  45 #define _public_ __attribute__ ((visibility("default")))
  46 #define _hidden_ __attribute__ ((visibility("hidden")))
  47 #define _weakref_(x) __attribute__((weakref(#x)))
  48 #define _alignas_(x) __attribute__((aligned(__alignof(x))))
  49 #define _cleanup_(x) __attribute__((cleanup(x)))
  50
  51 /* Temporarily disable some warnings */
  52 #define DISABLE_WARNING_DECLARATION_AFTER_STATEMENT                     \
  53         _Pragma("GCC diagnostic push");                                 \
  54         _Pragma("GCC diagnostic ignored \"-Wdeclaration-after-statement\"")
  55
  56 #define DISABLE_WARNING_FORMAT_NONLITERAL                               \
  57         _Pragma("GCC diagnostic push");                                 \
  58         _Pragma("GCC diagnostic ignored \"-Wformat-nonliteral\"")
  59
  60 #define DISABLE_WARNING_MISSING_PROTOTYPES                              \
  61         _Pragma("GCC diagnostic push");                                 \
  62         _Pragma("GCC diagnostic ignored \"-Wmissing-prototypes\"")
  63
  64 #define DISABLE_WARNING_NONNULL                                         \
  65         _Pragma("GCC diagnostic push");                                 \
  66         _Pragma("GCC diagnostic ignored \"-Wnonnull\"")
  67
  68 #define DISABLE_WARNING_SHADOW                                          \
  69         _Pragma("GCC diagnostic push");                                 \
  70         _Pragma("GCC diagnostic ignored \"-Wshadow\"")
  71
  72 #define DISABLE_WARNING_INCOMPATIBLE_POINTER_TYPES                      \
  73         _Pragma("GCC diagnostic push");                                 \
  74         _Pragma("GCC diagnostic ignored \"-Wincompatible-pointer-types\"")
  75
  76 #define REENABLE_WARNING                                                \
  77         _Pragma("GCC diagnostic pop")
  78
  79 /* automake test harness */
  80 #define EXIT_TEST_SKIP 77
  81
  82 #define XSTRINGIFY(x) #x
  83 #define STRINGIFY(x) XSTRINGIFY(x)
  84
  85 #define XCONCATENATE(x, y) x ## y
  86 #define CONCATENATE(x, y) XCONCATENATE(x, y)
  87
  88 #define UNIQ_T(x, uniq) CONCATENATE(__unique_prefix_, CONCATENATE(x, uniq))
  89 #define UNIQ __COUNTER__
  90
  91 /* Rounds up */
  92
  93 #define ALIGN4(l) (((l) + 3) & ~3)
  94 #define ALIGN8(l) (((l) + 7) & ~7)
  95
  96 #if __SIZEOF_POINTER__ == 8
  97 #define ALIGN(l) ALIGN8(l)
  98 #elif __SIZEOF_POINTER__ == 4
  99 #define ALIGN(l) ALIGN4(l)
 100 #else
 101 #error "Wut? Pointers are neither 4 nor 8 bytes long?"
 102 #endif
 103
 104 #define ALIGN_PTR(p) ((void*) ALIGN((unsigned long) (p)))
 105 #define ALIGN4_PTR(p) ((void*) ALIGN4((unsigned long) (p)))
 106 #define ALIGN8_PTR(p) ((void*) ALIGN8((unsigned long) (p)))
 107
 108 static inline size_t ALIGN_TO(size_t l, size_t ali) {
 109         return ((l + ali - 1) & ~(ali - 1));
 110 }
 111
 112 #define ALIGN_TO_PTR(p, ali) ((void*) ALIGN_TO((unsigned long) (p), (ali)))
 113
 114 /* align to next higher power-of-2 (except for: 0 => 0, overflow => 0) */
 115 static inline unsigned long ALIGN_POWER2(unsigned long u) {
 116         /* clz(0) is undefined */
 117         if (u == 1)
 118                 return 1;
 119
 120         /* left-shift overflow is undefined */
 121         if (__builtin_clzl(u - 1UL) < 1)
 122                 return 0;
 123
 124         return 1UL << (sizeof(u) * 8 - __builtin_clzl(u - 1UL));
 125 }
 126
 127 #define ELEMENTSOF(x) (sizeof(x)/sizeof((x)[0]))
 128
 129 /*
 130  * container_of - cast a member of a structure out to the containing structure
 131  * @ptr: the pointer to the member.
 132  * @type: the type of the container struct this is embedded in.
 133  * @member: the name of the member within the struct.
 134  */
 135 #define container_of(ptr, type, member) __container_of(UNIQ, (ptr), type, member)
 136 #define __container_of(uniq, ptr, type, member)                         \
 137         __extension__ ({                                                \
 138                 const typeof( ((type*)0)->member ) *UNIQ_T(A, uniq) = (ptr); \
 139                 (type*)( (char *)UNIQ_T(A, uniq) - offsetof(type,member) ); \
 140         })
 141
 142 #undef MAX
 143 #define MAX(a, b) __MAX(UNIQ, (a), UNIQ, (b))
 144 #define __MAX(aq, a, bq, b)                             \
 145         __extension__ ({                                \
 146                 const typeof(a) UNIQ_T(A, aq) = (a);    \
 147                 const typeof(b) UNIQ_T(B, bq) = (b);    \
 148                 UNIQ_T(A,aq) > UNIQ_T(B,bq) ? UNIQ_T(A,aq) : UNIQ_T(B,bq); \
 149         })
 150
 151 /* evaluates to (void) if _A or _B are not constant or of different types */
 152 #define CONST_MAX(_A, _B) \
 153         __extension__ (__builtin_choose_expr(                           \
 154                 __builtin_constant_p(_A) &&                             \
 155                 __builtin_constant_p(_B) &&                             \
 156                 __builtin_types_compatible_p(typeof(_A), typeof(_B)),   \
 157                 ((_A) > (_B)) ? (_A) : (_B),                            \
 158                 (void)0))
 159
 160 /* takes two types and returns the size of the larger one */
 161 #define MAXSIZE(A, B) (sizeof(union _packed_ { typeof(A) a; typeof(B) b; }))
 162
 163 #define MAX3(x,y,z)                                     \
 164         __extension__ ({                                \
 165                         const typeof(x) _c = MAX(x,y);  \
 166                         MAX(_c, z);                     \
 167                 })
 168
 169 #undef MIN
 170 #define MIN(a, b) __MIN(UNIQ, (a), UNIQ, (b))
 171 #define __MIN(aq, a, bq, b)                             \
 172         __extension__ ({                                \
 173                 const typeof(a) UNIQ_T(A, aq) = (a);    \
 174                 const typeof(b) UNIQ_T(B, bq) = (b);    \
 175                 UNIQ_T(A,aq) < UNIQ_T(B,bq) ? UNIQ_T(A,aq) : UNIQ_T(B,bq); \
 176         })
 177
 178 #define MIN3(x,y,z)                                     \
 179         __extension__ ({                                \
 180                         const typeof(x) _c = MIN(x,y);  \
 181                         MIN(_c, z);                     \
 182                 })
 183
 184 #define LESS_BY(a, b) __LESS_BY(UNIQ, (a), UNIQ, (b))
 185 #define __LESS_BY(aq, a, bq, b)                         \
 186         __extension__ ({                                \
 187                 const typeof(a) UNIQ_T(A, aq) = (a);    \
 188                 const typeof(b) UNIQ_T(B, bq) = (b);    \
 189                 UNIQ_T(A,aq) > UNIQ_T(B,bq) ? UNIQ_T(A,aq) - UNIQ_T(B,bq) : 0; \
 190         })
 191
 192 #undef CLAMP
 193 #define CLAMP(x, low, high) __CLAMP(UNIQ, (x), UNIQ, (low), UNIQ, (high))
 194 #define __CLAMP(xq, x, lowq, low, highq, high)                          \
 195         __extension__ ({                                                \
 196                 const typeof(x) UNIQ_T(X,xq) = (x);                     \
 197                 const typeof(low) UNIQ_T(LOW,lowq) = (low);             \
 198                 const typeof(high) UNIQ_T(HIGH,highq) = (high);         \
 199                         UNIQ_T(X,xq) > UNIQ_T(HIGH,highq) ?             \
 200                                 UNIQ_T(HIGH,highq) :                    \
 201                                 UNIQ_T(X,xq) < UNIQ_T(LOW,lowq) ?       \
 202                                         UNIQ_T(LOW,lowq) :              \
 203                                         UNIQ_T(X,xq);                   \
 204         })
 205
 206 /* [(x + y - 1) / y] suffers from an integer overflow, even though the
 207  * computation should be possible in the given type. Therefore, we use
 208  * [x / y + !!(x % y)]. Note that on "Real CPUs" a division returns both the
 209  * quotient and the remainder, so both should be equally fast. */
 210 #define DIV_ROUND_UP(_x, _y)                                            \
 211         __extension__ ({                                                \
 212                 const typeof(_x) __x = (_x);                            \
 213                 const typeof(_y) __y = (_y);                            \
 214                 (__x / __y + !!(__x % __y));                            \
 215         })
 216
 217 #define assert_se(expr)                                                 \
 218         do {                                                            \
 219                 if (_unlikely_(!(expr)))                                \
 220                         log_assert_failed(#expr, __FILE__, __LINE__, __PRETTY_FUNCTION__); \
 221         } while (false)                                                 \
 222
 223 /* We override the glibc assert() here. */
 224 #undef assert
 225 #ifdef NDEBUG
 226 #define assert(expr) do {} while(false)
 227 #else
 228 #define assert(expr) assert_se(expr)
 229 #endif
 230
 231 #define assert_not_reached(t)                                           \
 232         do {                                                            \
 233                 log_assert_failed_unreachable(t, __FILE__, __LINE__, __PRETTY_FUNCTION__); \
 234         } while (false)
 235
 236 #if defined(static_assert)
 237 /* static_assert() is sometimes defined in a way that trips up
 238  * -Wdeclaration-after-statement, hence let's temporarily turn off
 239  * this warning around it. */
 240 #define assert_cc(expr)                                                 \
 241         DISABLE_WARNING_DECLARATION_AFTER_STATEMENT;                    \
 242         static_assert(expr, #expr);                                     \
 243         REENABLE_WARNING
 244 #else
 245 #define assert_cc(expr)                                                 \
 246         DISABLE_WARNING_DECLARATION_AFTER_STATEMENT;                    \
 247         struct CONCATENATE(_assert_struct_, __COUNTER__) {              \
 248                 char x[(expr) ? 0 : -1];                                \
 249         };                                                              \
 250         REENABLE_WARNING
 251 #endif
 252
 253 #define assert_log(expr) ((_likely_(expr))      \
 254         ? (true)                                \
 255         : (log_assert_failed_return(#expr, __FILE__, __LINE__, __PRETTY_FUNCTION__), false))
 256
 257 #define assert_return(expr, r)                                          \
 258         do {                                                            \
 259                 if (!assert_log(expr))                                  \
 260                         return (r);                                     \
 261         } while (false)
 262
 263 #define assert_return_errno(expr, r, err)                               \
 264         do {                                                            \
 265                 if (!assert_log(expr)) {                                \
 266                         errno = err;                                    \
 267                         return (r);                                     \
 268                 }                                                       \
 269         } while (false)
 270
 271 #define PTR_TO_INT(p) ((int) ((intptr_t) (p)))
 272 #define INT_TO_PTR(u) ((void *) ((intptr_t) (u)))
 273 #define PTR_TO_UINT(p) ((unsigned int) ((uintptr_t) (p)))
 274 #define UINT_TO_PTR(u) ((void *) ((uintptr_t) (u)))
 275
 276 #define PTR_TO_LONG(p) ((long) ((intptr_t) (p)))
 277 #define LONG_TO_PTR(u) ((void *) ((intptr_t) (u)))
 278 #define PTR_TO_ULONG(p) ((unsigned long) ((uintptr_t) (p)))
 279 #define ULONG_TO_PTR(u) ((void *) ((uintptr_t) (u)))
 280
 281 #define PTR_TO_INT32(p) ((int32_t) ((intptr_t) (p)))
 282 #define INT32_TO_PTR(u) ((void *) ((intptr_t) (u)))
 283 #define PTR_TO_UINT32(p) ((uint32_t) ((uintptr_t) (p)))
 284 #define UINT32_TO_PTR(u) ((void *) ((uintptr_t) (u)))
 285
 286 #define PTR_TO_INT64(p) ((int64_t) ((intptr_t) (p)))
 287 #define INT64_TO_PTR(u) ((void *) ((intptr_t) (u)))
 288 #define PTR_TO_UINT64(p) ((uint64_t) ((uintptr_t) (p)))
 289 #define UINT64_TO_PTR(u) ((void *) ((uintptr_t) (u)))
 290
 291 #define PTR_TO_SIZE(p) ((size_t) ((uintptr_t) (p)))
 292 #define SIZE_TO_PTR(u) ((void *) ((uintptr_t) (u)))
 293
 294 /* The following macros add 1 when converting things, since UID 0 is a
 295  * valid UID, while the pointer NULL is special */
 296 #define PTR_TO_UID(p) ((uid_t) (((uintptr_t) (p))-1))
 297 #define UID_TO_PTR(u) ((void*) (((uintptr_t) (u))+1))
 298
 299 #define PTR_TO_GID(p) ((gid_t) (((uintptr_t) (p))-1))
 300 #define GID_TO_PTR(u) ((void*) (((uintptr_t) (u))+1))
 301
 302 #define PTR_TO_PID(p) ((pid_t) ((uintptr_t) p))
 303 #define PID_TO_PTR(p) ((void*) ((uintptr_t) p))
 304
 305 #define memzero(x,l) (memset((x), 0, (l)))
 306 #define zero(x) (memzero(&(x), sizeof(x)))
 307
 308 #define CHAR_TO_STR(x) ((char[2]) { x, 0 })
 309
 310 #define char_array_0(x) x[sizeof(x)-1] = 0;
 311
 312 #define IOVEC_SET_STRING(i, s)                  \
 313         do {                                    \
 314                 struct iovec *_i = &(i);        \
 315                 char *_s = (char *)(s);         \
 316                 _i->iov_base = _s;              \
 317                 _i->iov_len = strlen(_s);       \
 318         } while(false)
 319
 320 static inline size_t IOVEC_TOTAL_SIZE(const struct iovec *i, unsigned n) {
 321         unsigned j;
 322         size_t r = 0;
 323
 324         for (j = 0; j < n; j++)
 325                 r += i[j].iov_len;
 326
 327         return r;
 328 }
 329
 330 static inline size_t IOVEC_INCREMENT(struct iovec *i, unsigned n, size_t k) {
 331         unsigned j;
 332
 333         for (j = 0; j < n; j++) {
 334                 size_t sub;
 335
 336                 if (_unlikely_(k <= 0))
 337                         break;
 338
 339                 sub = MIN(i[j].iov_len, k);
 340                 i[j].iov_len -= sub;
 341                 i[j].iov_base = (uint8_t*) i[j].iov_base + sub;
 342                 k -= sub;
 343         }
 344
 345         return k;
 346 }
 347
 348 #define VA_FORMAT_ADVANCE(format, ap)                                   \
 349 do {                                                                    \
 350         int _argtypes[128];                                             \
 351         size_t _i, _k;                                                  \
 352         _k = parse_printf_format((format), ELEMENTSOF(_argtypes), _argtypes); \
 353         assert(_k < ELEMENTSOF(_argtypes));                             \
 354         for (_i = 0; _i < _k; _i++) {                                   \
 355                 if (_argtypes[_i] & PA_FLAG_PTR)  {                     \
 356                         (void) va_arg(ap, void*);                       \
 357                         continue;                                       \
 358                 }                                                       \
 359                                                                         \
 360                 switch (_argtypes[_i]) {                                \
 361                 case PA_INT:                                            \
 362                 case PA_INT|PA_FLAG_SHORT:                              \
 363                 case PA_CHAR:                                           \
 364                         (void) va_arg(ap, int);                         \
 365                         break;                                          \
 366                 case PA_INT|PA_FLAG_LONG:                               \
 367                         (void) va_arg(ap, long int);                    \
 368                         break;                                          \
 369                 case PA_INT|PA_FLAG_LONG_LONG:                          \
 370                         (void) va_arg(ap, long long int);               \
 371                         break;                                          \
 372                 case PA_WCHAR:                                          \
 373                         (void) va_arg(ap, wchar_t);                     \
 374                         break;                                          \
 375                 case PA_WSTRING:                                        \
 376                 case PA_STRING:                                         \
 377                 case PA_POINTER:                                        \
 378                         (void) va_arg(ap, void*);                       \
 379                         break;                                          \
 380                 case PA_FLOAT:                                          \
 381                 case PA_DOUBLE:                                         \
 382                         (void) va_arg(ap, double);                      \
 383                         break;                                          \
 384                 case PA_DOUBLE|PA_FLAG_LONG_DOUBLE:                     \
 385                         (void) va_arg(ap, long double);                 \
 386                         break;                                          \
 387                 default:                                                \
 388                         assert_not_reached("Unknown format string argument."); \
 389                 }                                                       \
 390         }                                                               \
 391 } while(false)
 392
 393  /* Because statfs.t_type can be int on some architectures, we have to cast
 394   * the const magic to the type, otherwise the compiler warns about
 395   * signed/unsigned comparison, because the magic can be 32 bit unsigned.
 396  */
 397 #define F_TYPE_EQUAL(a, b) (a == (typeof(a)) b)
 398
 399 /* Returns the number of chars needed to format variables of the
 400  * specified type as a decimal string. Adds in extra space for a
 401  * negative '-' prefix (hence works correctly on signed
 402  * types). Includes space for the trailing NUL. */
 403 #define DECIMAL_STR_MAX(type)                                           \
 404         (2+(sizeof(type) <= 1 ? 3 :                                     \
 405             sizeof(type) <= 2 ? 5 :                                     \
 406             sizeof(type) <= 4 ? 10 :                                    \
 407             sizeof(type) <= 8 ? 20 : sizeof(int[-2*(sizeof(type) > 8)])))
 408
 409 #define SET_FLAG(v, flag, b) \
 410         (v) = (b) ? ((v) | (flag)) : ((v) & ~(flag))
 411
 412 #define IN_SET(x, y, ...)                                               \
 413         ({                                                              \
 414                 static const typeof(y) _array[] = { (y), __VA_ARGS__ }; \
 415                 const typeof(y) _x = (x);                               \
 416                 unsigned _i;                                            \
 417                 bool _found = false;                                    \
 418                 for (_i = 0; _i < ELEMENTSOF(_array); _i++)             \
 419                         if (_array[_i] == _x) {                         \
 420                                 _found = true;                          \
 421                                 break;                                  \
 422                         }                                               \
 423                 _found;                                                 \
 424         })
 425
 426 /* Return a nulstr for a standard cascade of configuration directories,
 427  * suitable to pass to conf_files_list_nulstr or config_parse_many. */
 428 #define CONF_DIRS_NULSTR(n) \
 429         "/etc/" n ".d\0" \
 430         "/run/" n ".d\0" \
 431         "/usr/local/lib/" n ".d\0" \
 432         "/usr/lib/" n ".d\0" \
 433         CONF_DIR_SPLIT_USR(n)
 434
 435 #ifdef HAVE_SPLIT_USR
 436 #define CONF_DIR_SPLIT_USR(n) "/lib/" n ".d\0"
 437 #else
 438 #define CONF_DIR_SPLIT_USR(n)
 439 #endif
 440
 441 /* Define C11 thread_local attribute even on older gcc compiler
 442  * version */
 443 #ifndef thread_local
 444 /*
 445  * Don't break on glibc < 2.16 that doesn't define __STDC_NO_THREADS__
 446  * see http://gcc.gnu.org/bugzilla/show_bug.cgi?id=53769
 447  */
 448 #if __STDC_VERSION__ >= 201112L && !(defined(__STDC_NO_THREADS__) || (defined(__GNU_LIBRARY__) && __GLIBC__ == 2 && __GLIBC_MINOR__ < 16))
 449 #define thread_local _Thread_local
 450 #else
 451 #define thread_local __thread
 452 #endif
 453 #endif
 454
 455 /* Define C11 noreturn without <stdnoreturn.h> and even on older gcc
 456  * compiler versions */
 457 #ifndef noreturn
 458 #if __STDC_VERSION__ >= 201112L
 459 #define noreturn _Noreturn
 460 #else
 461 #define noreturn __attribute__((noreturn))
 462 #endif
 463 #endif
 464
 465 #define UID_INVALID ((uid_t) -1)
 466 #define GID_INVALID ((gid_t) -1)
 467 #define MODE_INVALID ((mode_t) -1)
 468
 469 static inline bool UID_IS_INVALID(uid_t uid) {
 470         /* We consider both the old 16bit -1 user and the newer 32bit
 471          * -1 user invalid, since they are or used to be incompatible
 472          * with syscalls such as setresuid() or chown(). */
 473
 474         return uid == (uid_t) ((uint32_t) -1) || uid == (uid_t) ((uint16_t) -1);
 475 }
 476
 477 static inline bool GID_IS_INVALID(gid_t gid) {
 478         return gid == (gid_t) ((uint32_t) -1) || gid == (gid_t) ((uint16_t) -1);
 479 }
 480
 481 #define DEFINE_TRIVIAL_CLEANUP_FUNC(type, func)                 \
 482         static inline void func##p(type *p) {                   \
 483                 if (*p)                                         \
 484                         func(*p);                               \
 485         }                                                       \
 486         struct __useless_struct_to_allow_trailing_semicolon__
 487
 488 #define CMSG_FOREACH(cmsg, mh)                                          \
 489         for ((cmsg) = CMSG_FIRSTHDR(mh); (cmsg); (cmsg) = CMSG_NXTHDR((mh), (cmsg)))
 490
 491 #include "log.h"