chiark / gitweb /
core: rework how we flush incoming traffic when a socket unit goes down
[elogind.git] / src / basic / macro.h
1 #pragma once
2
3 /***
4   This file is part of systemd.
5
6   Copyright 2010 Lennart Poettering
7
8   systemd is free software; you can redistribute it and/or modify it
9   under the terms of the GNU Lesser General Public License as published by
10   the Free Software Foundation; either version 2.1 of the License, or
11   (at your option) any later version.
12
13   systemd is distributed in the hope that it will be useful, but
14   WITHOUT ANY WARRANTY; without even the implied warranty of
15   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
16   Lesser General Public License for more details.
17
18   You should have received a copy of the GNU Lesser General Public License
19   along with systemd; If not, see <http://www.gnu.org/licenses/>.
20 ***/
21
22 #include <assert.h>
23 #include <inttypes.h>
24 #include <stdbool.h>
25 #include <sys/param.h>
26 #include <sys/sysmacros.h>
27 #include <sys/types.h>
28
29 #define _printf_(a,b) __attribute__ ((format (printf, a, b)))
30 #ifdef __clang__
31 #  define _alloc_(...)
32 #else
33 #  define _alloc_(...) __attribute__ ((alloc_size(__VA_ARGS__)))
34 #endif
35 #define _sentinel_ __attribute__ ((sentinel))
36 #define _unused_ __attribute__ ((unused))
37 #define _destructor_ __attribute__ ((destructor))
38 #define _pure_ __attribute__ ((pure))
39 #define _const_ __attribute__ ((const))
40 #define _deprecated_ __attribute__ ((deprecated))
41 #define _packed_ __attribute__ ((packed))
42 #define _malloc_ __attribute__ ((malloc))
43 #define _weak_ __attribute__ ((weak))
44 #define _likely_(x) (__builtin_expect(!!(x),1))
45 #define _unlikely_(x) (__builtin_expect(!!(x),0))
46 #define _public_ __attribute__ ((visibility("default")))
47 #define _hidden_ __attribute__ ((visibility("hidden")))
48 #define _weakref_(x) __attribute__((weakref(#x)))
49 #define _alignas_(x) __attribute__((aligned(__alignof(x))))
50 #define _cleanup_(x) __attribute__((cleanup(x)))
51
52 /* Temporarily disable some warnings */
53 #define DISABLE_WARNING_DECLARATION_AFTER_STATEMENT                     \
54         _Pragma("GCC diagnostic push");                                 \
55         _Pragma("GCC diagnostic ignored \"-Wdeclaration-after-statement\"")
56
57 #define DISABLE_WARNING_FORMAT_NONLITERAL                               \
58         _Pragma("GCC diagnostic push");                                 \
59         _Pragma("GCC diagnostic ignored \"-Wformat-nonliteral\"")
60
61 #define DISABLE_WARNING_MISSING_PROTOTYPES                              \
62         _Pragma("GCC diagnostic push");                                 \
63         _Pragma("GCC diagnostic ignored \"-Wmissing-prototypes\"")
64
65 #define DISABLE_WARNING_NONNULL                                         \
66         _Pragma("GCC diagnostic push");                                 \
67         _Pragma("GCC diagnostic ignored \"-Wnonnull\"")
68
69 #define DISABLE_WARNING_SHADOW                                          \
70         _Pragma("GCC diagnostic push");                                 \
71         _Pragma("GCC diagnostic ignored \"-Wshadow\"")
72
73 #define DISABLE_WARNING_INCOMPATIBLE_POINTER_TYPES                      \
74         _Pragma("GCC diagnostic push");                                 \
75         _Pragma("GCC diagnostic ignored \"-Wincompatible-pointer-types\"")
76
77 #define REENABLE_WARNING                                                \
78         _Pragma("GCC diagnostic pop")
79
80 /* automake test harness */
81 #define EXIT_TEST_SKIP 77
82
83 #define XSTRINGIFY(x) #x
84 #define STRINGIFY(x) XSTRINGIFY(x)
85
86 #define XCONCATENATE(x, y) x ## y
87 #define CONCATENATE(x, y) XCONCATENATE(x, y)
88
89 #define UNIQ_T(x, uniq) CONCATENATE(__unique_prefix_, CONCATENATE(x, uniq))
90 #define UNIQ __COUNTER__
91
92 /* Rounds up */
93
94 #define ALIGN4(l) (((l) + 3) & ~3)
95 #define ALIGN8(l) (((l) + 7) & ~7)
96
97 #if __SIZEOF_POINTER__ == 8
98 #define ALIGN(l) ALIGN8(l)
99 #elif __SIZEOF_POINTER__ == 4
100 #define ALIGN(l) ALIGN4(l)
101 #else
102 #error "Wut? Pointers are neither 4 nor 8 bytes long?"
103 #endif
104
105 #define ALIGN_PTR(p) ((void*) ALIGN((unsigned long) (p)))
106 #define ALIGN4_PTR(p) ((void*) ALIGN4((unsigned long) (p)))
107 #define ALIGN8_PTR(p) ((void*) ALIGN8((unsigned long) (p)))
108
109 static inline size_t ALIGN_TO(size_t l, size_t ali) {
110         return ((l + ali - 1) & ~(ali - 1));
111 }
112
113 #define ALIGN_TO_PTR(p, ali) ((void*) ALIGN_TO((unsigned long) (p), (ali)))
114
115 /* align to next higher power-of-2 (except for: 0 => 0, overflow => 0) */
116 static inline unsigned long ALIGN_POWER2(unsigned long u) {
117         /* clz(0) is undefined */
118         if (u == 1)
119                 return 1;
120
121         /* left-shift overflow is undefined */
122         if (__builtin_clzl(u - 1UL) < 1)
123                 return 0;
124
125         return 1UL << (sizeof(u) * 8 - __builtin_clzl(u - 1UL));
126 }
127
128 #define ELEMENTSOF(x)                                                    \
129         __extension__ (__builtin_choose_expr(                            \
130                 !__builtin_types_compatible_p(typeof(x), typeof(&*(x))), \
131                 sizeof(x)/sizeof((x)[0]),                                \
132                 (void)0))
133 /*
134  * container_of - cast a member of a structure out to the containing structure
135  * @ptr: the pointer to the member.
136  * @type: the type of the container struct this is embedded in.
137  * @member: the name of the member within the struct.
138  */
139 #define container_of(ptr, type, member) __container_of(UNIQ, (ptr), type, member)
140 #define __container_of(uniq, ptr, type, member)                         \
141         __extension__ ({                                                \
142                 const typeof( ((type*)0)->member ) *UNIQ_T(A, uniq) = (ptr); \
143                 (type*)( (char *)UNIQ_T(A, uniq) - offsetof(type,member) ); \
144         })
145
146 #undef MAX
147 #define MAX(a, b) __MAX(UNIQ, (a), UNIQ, (b))
148 #define __MAX(aq, a, bq, b)                             \
149         __extension__ ({                                \
150                 const typeof(a) UNIQ_T(A, aq) = (a);    \
151                 const typeof(b) UNIQ_T(B, bq) = (b);    \
152                 UNIQ_T(A,aq) > UNIQ_T(B,bq) ? UNIQ_T(A,aq) : UNIQ_T(B,bq); \
153         })
154
155 /* evaluates to (void) if _A or _B are not constant or of different types */
156 #define CONST_MAX(_A, _B) \
157         __extension__ (__builtin_choose_expr(                           \
158                 __builtin_constant_p(_A) &&                             \
159                 __builtin_constant_p(_B) &&                             \
160                 __builtin_types_compatible_p(typeof(_A), typeof(_B)),   \
161                 ((_A) > (_B)) ? (_A) : (_B),                            \
162                 (void)0))
163
164 /* takes two types and returns the size of the larger one */
165 #define MAXSIZE(A, B) (sizeof(union _packed_ { typeof(A) a; typeof(B) b; }))
166
167 #define MAX3(x,y,z)                                     \
168         __extension__ ({                                \
169                         const typeof(x) _c = MAX(x,y);  \
170                         MAX(_c, z);                     \
171                 })
172
173 #undef MIN
174 #define MIN(a, b) __MIN(UNIQ, (a), UNIQ, (b))
175 #define __MIN(aq, a, bq, b)                             \
176         __extension__ ({                                \
177                 const typeof(a) UNIQ_T(A, aq) = (a);    \
178                 const typeof(b) UNIQ_T(B, bq) = (b);    \
179                 UNIQ_T(A,aq) < UNIQ_T(B,bq) ? UNIQ_T(A,aq) : UNIQ_T(B,bq); \
180         })
181
182 #define MIN3(x,y,z)                                     \
183         __extension__ ({                                \
184                         const typeof(x) _c = MIN(x,y);  \
185                         MIN(_c, z);                     \
186                 })
187
188 #define LESS_BY(a, b) __LESS_BY(UNIQ, (a), UNIQ, (b))
189 #define __LESS_BY(aq, a, bq, b)                         \
190         __extension__ ({                                \
191                 const typeof(a) UNIQ_T(A, aq) = (a);    \
192                 const typeof(b) UNIQ_T(B, bq) = (b);    \
193                 UNIQ_T(A,aq) > UNIQ_T(B,bq) ? UNIQ_T(A,aq) - UNIQ_T(B,bq) : 0; \
194         })
195
196 #undef CLAMP
197 #define CLAMP(x, low, high) __CLAMP(UNIQ, (x), UNIQ, (low), UNIQ, (high))
198 #define __CLAMP(xq, x, lowq, low, highq, high)                          \
199         __extension__ ({                                                \
200                 const typeof(x) UNIQ_T(X,xq) = (x);                     \
201                 const typeof(low) UNIQ_T(LOW,lowq) = (low);             \
202                 const typeof(high) UNIQ_T(HIGH,highq) = (high);         \
203                         UNIQ_T(X,xq) > UNIQ_T(HIGH,highq) ?             \
204                                 UNIQ_T(HIGH,highq) :                    \
205                                 UNIQ_T(X,xq) < UNIQ_T(LOW,lowq) ?       \
206                                         UNIQ_T(LOW,lowq) :              \
207                                         UNIQ_T(X,xq);                   \
208         })
209
210 /* [(x + y - 1) / y] suffers from an integer overflow, even though the
211  * computation should be possible in the given type. Therefore, we use
212  * [x / y + !!(x % y)]. Note that on "Real CPUs" a division returns both the
213  * quotient and the remainder, so both should be equally fast. */
214 #define DIV_ROUND_UP(_x, _y)                                            \
215         __extension__ ({                                                \
216                 const typeof(_x) __x = (_x);                            \
217                 const typeof(_y) __y = (_y);                            \
218                 (__x / __y + !!(__x % __y));                            \
219         })
220
221 #define assert_message_se(expr, message)                                \
222         do {                                                            \
223                 if (_unlikely_(!(expr)))                                \
224                         log_assert_failed(message, __FILE__, __LINE__, __PRETTY_FUNCTION__); \
225         } while (false)
226
227 #define assert_se(expr) assert_message_se(expr, #expr)
228
229 /* We override the glibc assert() here. */
230 #undef assert
231 #ifdef NDEBUG
232 #define assert(expr) do {} while (false)
233 #else
234 #define assert(expr) assert_message_se(expr, #expr)
235 #endif
236
237 #define assert_not_reached(t)                                           \
238         do {                                                            \
239                 log_assert_failed_unreachable(t, __FILE__, __LINE__, __PRETTY_FUNCTION__); \
240         } while (false)
241
242 #if defined(static_assert)
243 /* static_assert() is sometimes defined in a way that trips up
244  * -Wdeclaration-after-statement, hence let's temporarily turn off
245  * this warning around it. */
246 #define assert_cc(expr)                                                 \
247         DISABLE_WARNING_DECLARATION_AFTER_STATEMENT;                    \
248         static_assert(expr, #expr);                                     \
249         REENABLE_WARNING
250 #else
251 #define assert_cc(expr)                                                 \
252         DISABLE_WARNING_DECLARATION_AFTER_STATEMENT;                    \
253         struct CONCATENATE(_assert_struct_, __COUNTER__) {              \
254                 char x[(expr) ? 0 : -1];                                \
255         };                                                              \
256         REENABLE_WARNING
257 #endif
258
259 #define assert_log(expr, message) ((_likely_(expr))                     \
260         ? (true)                                                        \
261         : (log_assert_failed_return(message, __FILE__, __LINE__, __PRETTY_FUNCTION__), false))
262
263 #define assert_return(expr, r)                                          \
264         do {                                                            \
265                 if (!assert_log(expr, #expr))                           \
266                         return (r);                                     \
267         } while (false)
268
269 #define assert_return_errno(expr, r, err)                               \
270         do {                                                            \
271                 if (!assert_log(expr, #expr)) {                         \
272                         errno = err;                                    \
273                         return (r);                                     \
274                 }                                                       \
275         } while (false)
276
277 #define PTR_TO_INT(p) ((int) ((intptr_t) (p)))
278 #define INT_TO_PTR(u) ((void *) ((intptr_t) (u)))
279 #define PTR_TO_UINT(p) ((unsigned int) ((uintptr_t) (p)))
280 #define UINT_TO_PTR(u) ((void *) ((uintptr_t) (u)))
281
282 #define PTR_TO_LONG(p) ((long) ((intptr_t) (p)))
283 #define LONG_TO_PTR(u) ((void *) ((intptr_t) (u)))
284 #define PTR_TO_ULONG(p) ((unsigned long) ((uintptr_t) (p)))
285 #define ULONG_TO_PTR(u) ((void *) ((uintptr_t) (u)))
286
287 #define PTR_TO_INT32(p) ((int32_t) ((intptr_t) (p)))
288 #define INT32_TO_PTR(u) ((void *) ((intptr_t) (u)))
289 #define PTR_TO_UINT32(p) ((uint32_t) ((uintptr_t) (p)))
290 #define UINT32_TO_PTR(u) ((void *) ((uintptr_t) (u)))
291
292 #define PTR_TO_INT64(p) ((int64_t) ((intptr_t) (p)))
293 #define INT64_TO_PTR(u) ((void *) ((intptr_t) (u)))
294 #define PTR_TO_UINT64(p) ((uint64_t) ((uintptr_t) (p)))
295 #define UINT64_TO_PTR(u) ((void *) ((uintptr_t) (u)))
296
297 #define PTR_TO_SIZE(p) ((size_t) ((uintptr_t) (p)))
298 #define SIZE_TO_PTR(u) ((void *) ((uintptr_t) (u)))
299
300 #define CHAR_TO_STR(x) ((char[2]) { x, 0 })
301
302 #define char_array_0(x) x[sizeof(x)-1] = 0;
303
304 /* Returns the number of chars needed to format variables of the
305  * specified type as a decimal string. Adds in extra space for a
306  * negative '-' prefix (hence works correctly on signed
307  * types). Includes space for the trailing NUL. */
308 #define DECIMAL_STR_MAX(type)                                           \
309         (2+(sizeof(type) <= 1 ? 3 :                                     \
310             sizeof(type) <= 2 ? 5 :                                     \
311             sizeof(type) <= 4 ? 10 :                                    \
312             sizeof(type) <= 8 ? 20 : sizeof(int[-2*(sizeof(type) > 8)])))
313
314 #define DECIMAL_STR_WIDTH(x)                            \
315         ({                                              \
316                 typeof(x) _x_ = (x);                    \
317                 unsigned ans = 1;                       \
318                 while (_x_ /= 10)                       \
319                         ans++;                          \
320                 ans;                                    \
321         })
322
323 #define SET_FLAG(v, flag, b) \
324         (v) = (b) ? ((v) | (flag)) : ((v) & ~(flag))
325
326 #define CASE_F(X) case X:
327 #define CASE_F_1(CASE, X) CASE_F(X)
328 #define CASE_F_2(CASE, X, ...)  CASE(X) CASE_F_1(CASE, __VA_ARGS__)
329 #define CASE_F_3(CASE, X, ...)  CASE(X) CASE_F_2(CASE, __VA_ARGS__)
330 #define CASE_F_4(CASE, X, ...)  CASE(X) CASE_F_3(CASE, __VA_ARGS__)
331 #define CASE_F_5(CASE, X, ...)  CASE(X) CASE_F_4(CASE, __VA_ARGS__)
332 #define CASE_F_6(CASE, X, ...)  CASE(X) CASE_F_5(CASE, __VA_ARGS__)
333 #define CASE_F_7(CASE, X, ...)  CASE(X) CASE_F_6(CASE, __VA_ARGS__)
334 #define CASE_F_8(CASE, X, ...)  CASE(X) CASE_F_7(CASE, __VA_ARGS__)
335 #define CASE_F_9(CASE, X, ...)  CASE(X) CASE_F_8(CASE, __VA_ARGS__)
336 #define CASE_F_10(CASE, X, ...) CASE(X) CASE_F_9(CASE, __VA_ARGS__)
337 #define CASE_F_11(CASE, X, ...) CASE(X) CASE_F_10(CASE, __VA_ARGS__)
338 #define CASE_F_12(CASE, X, ...) CASE(X) CASE_F_11(CASE, __VA_ARGS__)
339 #define CASE_F_13(CASE, X, ...) CASE(X) CASE_F_12(CASE, __VA_ARGS__)
340 #define CASE_F_14(CASE, X, ...) CASE(X) CASE_F_13(CASE, __VA_ARGS__)
341 #define CASE_F_15(CASE, X, ...) CASE(X) CASE_F_14(CASE, __VA_ARGS__)
342 #define CASE_F_16(CASE, X, ...) CASE(X) CASE_F_15(CASE, __VA_ARGS__)
343 #define CASE_F_17(CASE, X, ...) CASE(X) CASE_F_16(CASE, __VA_ARGS__)
344 #define CASE_F_18(CASE, X, ...) CASE(X) CASE_F_17(CASE, __VA_ARGS__)
345 #define CASE_F_19(CASE, X, ...) CASE(X) CASE_F_18(CASE, __VA_ARGS__)
346 #define CASE_F_20(CASE, X, ...) CASE(X) CASE_F_19(CASE, __VA_ARGS__)
347
348 #define GET_CASE_F(_1,_2,_3,_4,_5,_6,_7,_8,_9,_10,_11,_12,_13,_14,_15,_16,_17,_18,_19,_20,NAME,...) NAME
349 #define FOR_EACH_MAKE_CASE(...) \
350         GET_CASE_F(__VA_ARGS__,CASE_F_20,CASE_F_19,CASE_F_18,CASE_F_17,CASE_F_16,CASE_F_15,CASE_F_14,CASE_F_13,CASE_F_12,CASE_F_11, \
351                                CASE_F_10,CASE_F_9,CASE_F_8,CASE_F_7,CASE_F_6,CASE_F_5,CASE_F_4,CASE_F_3,CASE_F_2,CASE_F_1) \
352                    (CASE_F,__VA_ARGS__)
353
354 #define IN_SET(x, ...)                          \
355         ({                                      \
356                 bool _found = false;            \
357                 /* If the build breaks in the line below, you need to extend the case macros */ \
358                 static _unused_ char _static_assert__macros_need_to_be_extended[20 - sizeof((int[]){__VA_ARGS__})/sizeof(int)]; \
359                 switch(x) {                     \
360                 FOR_EACH_MAKE_CASE(__VA_ARGS__) \
361                         _found = true;          \
362                         break;                  \
363                 default:                        \
364                         break;                  \
365                 }                               \
366                 _found;                         \
367         })
368
369 #define SWAP_TWO(x, y) do {                        \
370                 typeof(x) _t = (x);                \
371                 (x) = (y);                         \
372                 (y) = (_t);                        \
373         } while (false)
374
375 /* Define C11 thread_local attribute even on older gcc compiler
376  * version */
377 #ifndef thread_local
378 /*
379  * Don't break on glibc < 2.16 that doesn't define __STDC_NO_THREADS__
380  * see http://gcc.gnu.org/bugzilla/show_bug.cgi?id=53769
381  */
382 #if __STDC_VERSION__ >= 201112L && !(defined(__STDC_NO_THREADS__) || (defined(__GNU_LIBRARY__) && __GLIBC__ == 2 && __GLIBC_MINOR__ < 16))
383 #define thread_local _Thread_local
384 #else
385 #define thread_local __thread
386 #endif
387 #endif
388
389 /* Define C11 noreturn without <stdnoreturn.h> and even on older gcc
390  * compiler versions */
391 #ifndef noreturn
392 #if __STDC_VERSION__ >= 201112L
393 #define noreturn _Noreturn
394 #else
395 #define noreturn __attribute__((noreturn))
396 #endif
397 #endif
398
399 #define DEFINE_TRIVIAL_CLEANUP_FUNC(type, func)                 \
400         static inline void func##p(type *p) {                   \
401                 if (*p)                                         \
402                         func(*p);                               \
403         }                                                       \
404         struct __useless_struct_to_allow_trailing_semicolon__
405
406 #include "log.h"