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)                                                    \
 128         __extension__ (__builtin_choose_expr(                            \
 129                 !__builtin_types_compatible_p(typeof(x), typeof(&*(x))), \
 130                 sizeof(x)/sizeof((x)[0]),                                \
 131                 (void)0))
 132 /*
 133  * container_of - cast a member of a structure out to the containing structure
 134  * @ptr: the pointer to the member.
 135  * @type: the type of the container struct this is embedded in.
 136  * @member: the name of the member within the struct.
 137  */
 138 #define container_of(ptr, type, member) __container_of(UNIQ, (ptr), type, member)
 139 #define __container_of(uniq, ptr, type, member)                         \
 140         __extension__ ({                                                \
 141                 const typeof( ((type*)0)->member ) *UNIQ_T(A, uniq) = (ptr); \
 142                 (type*)( (char *)UNIQ_T(A, uniq) - offsetof(type,member) ); \
 143         })
 144
 145 #undef MAX
 146 #define MAX(a, b) __MAX(UNIQ, (a), UNIQ, (b))
 147 #define __MAX(aq, a, bq, b)                             \
 148         __extension__ ({                                \
 149                 const typeof(a) UNIQ_T(A, aq) = (a);    \
 150                 const typeof(b) UNIQ_T(B, bq) = (b);    \
 151                 UNIQ_T(A,aq) > UNIQ_T(B,bq) ? UNIQ_T(A,aq) : UNIQ_T(B,bq); \
 152         })
 153
 154 /* evaluates to (void) if _A or _B are not constant or of different types */
 155 #define CONST_MAX(_A, _B) \
 156         __extension__ (__builtin_choose_expr(                           \
 157                 __builtin_constant_p(_A) &&                             \
 158                 __builtin_constant_p(_B) &&                             \
 159                 __builtin_types_compatible_p(typeof(_A), typeof(_B)),   \
 160                 ((_A) > (_B)) ? (_A) : (_B),                            \
 161                 (void)0))
 162
 163 /* takes two types and returns the size of the larger one */
 164 #define MAXSIZE(A, B) (sizeof(union _packed_ { typeof(A) a; typeof(B) b; }))
 165
 166 #define MAX3(x,y,z)                                     \
 167         __extension__ ({                                \
 168                         const typeof(x) _c = MAX(x,y);  \
 169                         MAX(_c, z);                     \
 170                 })
 171
 172 #undef MIN
 173 #define MIN(a, b) __MIN(UNIQ, (a), UNIQ, (b))
 174 #define __MIN(aq, a, bq, b)                             \
 175         __extension__ ({                                \
 176                 const typeof(a) UNIQ_T(A, aq) = (a);    \
 177                 const typeof(b) UNIQ_T(B, bq) = (b);    \
 178                 UNIQ_T(A,aq) < UNIQ_T(B,bq) ? UNIQ_T(A,aq) : UNIQ_T(B,bq); \
 179         })
 180
 181 #define MIN3(x,y,z)                                     \
 182         __extension__ ({                                \
 183                         const typeof(x) _c = MIN(x,y);  \
 184                         MIN(_c, z);                     \
 185                 })
 186
 187 #define LESS_BY(a, b) __LESS_BY(UNIQ, (a), UNIQ, (b))
 188 #define __LESS_BY(aq, a, bq, b)                         \
 189         __extension__ ({                                \
 190                 const typeof(a) UNIQ_T(A, aq) = (a);    \
 191                 const typeof(b) UNIQ_T(B, bq) = (b);    \
 192                 UNIQ_T(A,aq) > UNIQ_T(B,bq) ? UNIQ_T(A,aq) - UNIQ_T(B,bq) : 0; \
 193         })
 194
 195 #undef CLAMP
 196 #define CLAMP(x, low, high) __CLAMP(UNIQ, (x), UNIQ, (low), UNIQ, (high))
 197 #define __CLAMP(xq, x, lowq, low, highq, high)                          \
 198         __extension__ ({                                                \
 199                 const typeof(x) UNIQ_T(X,xq) = (x);                     \
 200                 const typeof(low) UNIQ_T(LOW,lowq) = (low);             \
 201                 const typeof(high) UNIQ_T(HIGH,highq) = (high);         \
 202                         UNIQ_T(X,xq) > UNIQ_T(HIGH,highq) ?             \
 203                                 UNIQ_T(HIGH,highq) :                    \
 204                                 UNIQ_T(X,xq) < UNIQ_T(LOW,lowq) ?       \
 205                                         UNIQ_T(LOW,lowq) :              \
 206                                         UNIQ_T(X,xq);                   \
 207         })
 208
 209 /* [(x + y - 1) / y] suffers from an integer overflow, even though the
 210  * computation should be possible in the given type. Therefore, we use
 211  * [x / y + !!(x % y)]. Note that on "Real CPUs" a division returns both the
 212  * quotient and the remainder, so both should be equally fast. */
 213 #define DIV_ROUND_UP(_x, _y)                                            \
 214         __extension__ ({                                                \
 215                 const typeof(_x) __x = (_x);                            \
 216                 const typeof(_y) __y = (_y);                            \
 217                 (__x / __y + !!(__x % __y));                            \
 218         })
 219
 220 #define assert_message_se(expr, message)                                \
 221         do {                                                            \
 222                 if (_unlikely_(!(expr)))                                \
 223                         log_assert_failed(message, __FILE__, __LINE__, __PRETTY_FUNCTION__); \
 224         } while (false)
 225
 226 #define assert_se(expr) assert_message_se(expr, #expr)
 227
 228 /* We override the glibc assert() here. */
 229 #undef assert
 230 #ifdef NDEBUG
 231 #define assert(expr) do {} while(false)
 232 #else
 233 #define assert(expr) assert_message_se(expr, #expr)
 234 #endif
 235
 236 #define assert_not_reached(t)                                           \
 237         do {                                                            \
 238                 log_assert_failed_unreachable(t, __FILE__, __LINE__, __PRETTY_FUNCTION__); \
 239         } while (false)
 240
 241 #if defined(static_assert)
 242 /* static_assert() is sometimes defined in a way that trips up
 243  * -Wdeclaration-after-statement, hence let's temporarily turn off
 244  * this warning around it. */
 245 #define assert_cc(expr)                                                 \
 246         DISABLE_WARNING_DECLARATION_AFTER_STATEMENT;                    \
 247         static_assert(expr, #expr);                                     \
 248         REENABLE_WARNING
 249 #else
 250 #define assert_cc(expr)                                                 \
 251         DISABLE_WARNING_DECLARATION_AFTER_STATEMENT;                    \
 252         struct CONCATENATE(_assert_struct_, __COUNTER__) {              \
 253                 char x[(expr) ? 0 : -1];                                \
 254         };                                                              \
 255         REENABLE_WARNING
 256 #endif
 257
 258 #define assert_log(expr, message) ((_likely_(expr))                     \
 259         ? (true)                                                        \
 260         : (log_assert_failed_return(message, __FILE__, __LINE__, __PRETTY_FUNCTION__), false))
 261
 262 #define assert_return(expr, r)                                          \
 263         do {                                                            \
 264                 if (!assert_log(expr, #expr))                           \
 265                         return (r);                                     \
 266         } while (false)
 267
 268 #define assert_return_errno(expr, r, err)                               \
 269         do {                                                            \
 270                 if (!assert_log(expr, #expr)) {                         \
 271                         errno = err;                                    \
 272                         return (r);                                     \
 273                 }                                                       \
 274         } while (false)
 275
 276 #define PTR_TO_INT(p) ((int) ((intptr_t) (p)))
 277 #define INT_TO_PTR(u) ((void *) ((intptr_t) (u)))
 278 #define PTR_TO_UINT(p) ((unsigned int) ((uintptr_t) (p)))
 279 #define UINT_TO_PTR(u) ((void *) ((uintptr_t) (u)))
 280
 281 #define PTR_TO_LONG(p) ((long) ((intptr_t) (p)))
 282 #define LONG_TO_PTR(u) ((void *) ((intptr_t) (u)))
 283 #define PTR_TO_ULONG(p) ((unsigned long) ((uintptr_t) (p)))
 284 #define ULONG_TO_PTR(u) ((void *) ((uintptr_t) (u)))
 285
 286 #define PTR_TO_INT32(p) ((int32_t) ((intptr_t) (p)))
 287 #define INT32_TO_PTR(u) ((void *) ((intptr_t) (u)))
 288 #define PTR_TO_UINT32(p) ((uint32_t) ((uintptr_t) (p)))
 289 #define UINT32_TO_PTR(u) ((void *) ((uintptr_t) (u)))
 290
 291 #define PTR_TO_INT64(p) ((int64_t) ((intptr_t) (p)))
 292 #define INT64_TO_PTR(u) ((void *) ((intptr_t) (u)))
 293 #define PTR_TO_UINT64(p) ((uint64_t) ((uintptr_t) (p)))
 294 #define UINT64_TO_PTR(u) ((void *) ((uintptr_t) (u)))
 295
 296 #define PTR_TO_SIZE(p) ((size_t) ((uintptr_t) (p)))
 297 #define SIZE_TO_PTR(u) ((void *) ((uintptr_t) (u)))
 298
 299 /* The following macros add 1 when converting things, since UID 0 is a
 300  * valid UID, while the pointer NULL is special */
 301 #define PTR_TO_UID(p) ((uid_t) (((uintptr_t) (p))-1))
 302 #define UID_TO_PTR(u) ((void*) (((uintptr_t) (u))+1))
 303
 304 #define PTR_TO_GID(p) ((gid_t) (((uintptr_t) (p))-1))
 305 #define GID_TO_PTR(u) ((void*) (((uintptr_t) (u))+1))
 306
 307 #define PTR_TO_PID(p) ((pid_t) ((uintptr_t) p))
 308 #define PID_TO_PTR(p) ((void*) ((uintptr_t) p))
 309
 310 #define memzero(x,l) (memset((x), 0, (l)))
 311 #define zero(x) (memzero(&(x), sizeof(x)))
 312
 313 #define CHAR_TO_STR(x) ((char[2]) { x, 0 })
 314
 315 #define char_array_0(x) x[sizeof(x)-1] = 0;
 316
 317 #define IOVEC_SET_STRING(i, s)                  \
 318         do {                                    \
 319                 struct iovec *_i = &(i);        \
 320                 char *_s = (char *)(s);         \
 321                 _i->iov_base = _s;              \
 322                 _i->iov_len = strlen(_s);       \
 323         } while(false)
 324
 325 static inline size_t IOVEC_TOTAL_SIZE(const struct iovec *i, unsigned n) {
 326         unsigned j;
 327         size_t r = 0;
 328
 329         for (j = 0; j < n; j++)
 330                 r += i[j].iov_len;
 331
 332         return r;
 333 }
 334
 335 static inline size_t IOVEC_INCREMENT(struct iovec *i, unsigned n, size_t k) {
 336         unsigned j;
 337
 338         for (j = 0; j < n; j++) {
 339                 size_t sub;
 340
 341                 if (_unlikely_(k <= 0))
 342                         break;
 343
 344                 sub = MIN(i[j].iov_len, k);
 345                 i[j].iov_len -= sub;
 346                 i[j].iov_base = (uint8_t*) i[j].iov_base + sub;
 347                 k -= sub;
 348         }
 349
 350         return k;
 351 }
 352
 353 #define VA_FORMAT_ADVANCE(format, ap)                                   \
 354 do {                                                                    \
 355         int _argtypes[128];                                             \
 356         size_t _i, _k;                                                  \
 357         _k = parse_printf_format((format), ELEMENTSOF(_argtypes), _argtypes); \
 358         assert(_k < ELEMENTSOF(_argtypes));                             \
 359         for (_i = 0; _i < _k; _i++) {                                   \
 360                 if (_argtypes[_i] & PA_FLAG_PTR)  {                     \
 361                         (void) va_arg(ap, void*);                       \
 362                         continue;                                       \
 363                 }                                                       \
 364                                                                         \
 365                 switch (_argtypes[_i]) {                                \
 366                 case PA_INT:                                            \
 367                 case PA_INT|PA_FLAG_SHORT:                              \
 368                 case PA_CHAR:                                           \
 369                         (void) va_arg(ap, int);                         \
 370                         break;                                          \
 371                 case PA_INT|PA_FLAG_LONG:                               \
 372                         (void) va_arg(ap, long int);                    \
 373                         break;                                          \
 374                 case PA_INT|PA_FLAG_LONG_LONG:                          \
 375                         (void) va_arg(ap, long long int);               \
 376                         break;                                          \
 377                 case PA_WCHAR:                                          \
 378                         (void) va_arg(ap, wchar_t);                     \
 379                         break;                                          \
 380                 case PA_WSTRING:                                        \
 381                 case PA_STRING:                                         \
 382                 case PA_POINTER:                                        \
 383                         (void) va_arg(ap, void*);                       \
 384                         break;                                          \
 385                 case PA_FLOAT:                                          \
 386                 case PA_DOUBLE:                                         \
 387                         (void) va_arg(ap, double);                      \
 388                         break;                                          \
 389                 case PA_DOUBLE|PA_FLAG_LONG_DOUBLE:                     \
 390                         (void) va_arg(ap, long double);                 \
 391                         break;                                          \
 392                 default:                                                \
 393                         assert_not_reached("Unknown format string argument."); \
 394                 }                                                       \
 395         }                                                               \
 396 } while(false)
 397
 398  /* Because statfs.t_type can be int on some architectures, we have to cast
 399   * the const magic to the type, otherwise the compiler warns about
 400   * signed/unsigned comparison, because the magic can be 32 bit unsigned.
 401  */
 402 #define F_TYPE_EQUAL(a, b) (a == (typeof(a)) b)
 403
 404 /* Returns the number of chars needed to format variables of the
 405  * specified type as a decimal string. Adds in extra space for a
 406  * negative '-' prefix (hence works correctly on signed
 407  * types). Includes space for the trailing NUL. */
 408 #define DECIMAL_STR_MAX(type)                                           \
 409         (2+(sizeof(type) <= 1 ? 3 :                                     \
 410             sizeof(type) <= 2 ? 5 :                                     \
 411             sizeof(type) <= 4 ? 10 :                                    \
 412             sizeof(type) <= 8 ? 20 : sizeof(int[-2*(sizeof(type) > 8)])))
 413
 414 #define SET_FLAG(v, flag, b) \
 415         (v) = (b) ? ((v) | (flag)) : ((v) & ~(flag))
 416
 417 #define IN_SET(x, y, ...)                                               \
 418         ({                                                              \
 419                 static const typeof(y) _array[] = { (y), __VA_ARGS__ }; \
 420                 const typeof(y) _x = (x);                               \
 421                 unsigned _i;                                            \
 422                 bool _found = false;                                    \
 423                 for (_i = 0; _i < ELEMENTSOF(_array); _i++)             \
 424                         if (_array[_i] == _x) {                         \
 425                                 _found = true;                          \
 426                                 break;                                  \
 427                         }                                               \
 428                 _found;                                                 \
 429         })
 430
 431 /* Return a nulstr for a standard cascade of configuration directories,
 432  * suitable to pass to conf_files_list_nulstr or config_parse_many. */
 433 #define CONF_DIRS_NULSTR(n) \
 434         "/etc/" n ".d\0" \
 435         "/run/" n ".d\0" \
 436         "/usr/local/lib/" n ".d\0" \
 437         "/usr/lib/" n ".d\0" \
 438         CONF_DIR_SPLIT_USR(n)
 439
 440 #ifdef HAVE_SPLIT_USR
 441 #define CONF_DIR_SPLIT_USR(n) "/lib/" n ".d\0"
 442 #else
 443 #define CONF_DIR_SPLIT_USR(n)
 444 #endif
 445
 446 /* Define C11 thread_local attribute even on older gcc compiler
 447  * version */
 448 #ifndef thread_local
 449 /*
 450  * Don't break on glibc < 2.16 that doesn't define __STDC_NO_THREADS__
 451  * see http://gcc.gnu.org/bugzilla/show_bug.cgi?id=53769
 452  */
 453 #if __STDC_VERSION__ >= 201112L && !(defined(__STDC_NO_THREADS__) || (defined(__GNU_LIBRARY__) && __GLIBC__ == 2 && __GLIBC_MINOR__ < 16))
 454 #define thread_local _Thread_local
 455 #else
 456 #define thread_local __thread
 457 #endif
 458 #endif
 459
 460 /* Define C11 noreturn without <stdnoreturn.h> and even on older gcc
 461  * compiler versions */
 462 #ifndef noreturn
 463 #if __STDC_VERSION__ >= 201112L
 464 #define noreturn _Noreturn
 465 #else
 466 #define noreturn __attribute__((noreturn))
 467 #endif
 468 #endif
 469
 470 #define UID_INVALID ((uid_t) -1)
 471 #define GID_INVALID ((gid_t) -1)
 472 #define MODE_INVALID ((mode_t) -1)
 473
 474 static inline bool UID_IS_INVALID(uid_t uid) {
 475         /* We consider both the old 16bit -1 user and the newer 32bit
 476          * -1 user invalid, since they are or used to be incompatible
 477          * with syscalls such as setresuid() or chown(). */
 478
 479         return uid == (uid_t) ((uint32_t) -1) || uid == (uid_t) ((uint16_t) -1);
 480 }
 481
 482 static inline bool GID_IS_INVALID(gid_t gid) {
 483         return gid == (gid_t) ((uint32_t) -1) || gid == (gid_t) ((uint16_t) -1);
 484 }
 485
 486 #define DEFINE_TRIVIAL_CLEANUP_FUNC(type, func)                 \
 487         static inline void func##p(type *p) {                   \
 488                 if (*p)                                         \
 489                         func(*p);                               \
 490         }                                                       \
 491         struct __useless_struct_to_allow_trailing_semicolon__
 492
 493 #define CMSG_FOREACH(cmsg, mh)                                          \
 494         for ((cmsg) = CMSG_FIRSTHDR(mh); (cmsg); (cmsg) = CMSG_NXTHDR((mh), (cmsg)))
 495
 496 #include "log.h"