]>
Commit | Line | Data |
---|---|---|
064af421 | 1 | /* |
4e022ec0 | 2 | * Copyright (c) 2008, 2009, 2010, 2011, 2012, 2013 Nicira, Inc. |
064af421 | 3 | * |
a14bc59f BP |
4 | * Licensed under the Apache License, Version 2.0 (the "License"); |
5 | * you may not use this file except in compliance with the License. | |
6 | * You may obtain a copy of the License at: | |
064af421 | 7 | * |
a14bc59f BP |
8 | * http://www.apache.org/licenses/LICENSE-2.0 |
9 | * | |
10 | * Unless required by applicable law or agreed to in writing, software | |
11 | * distributed under the License is distributed on an "AS IS" BASIS, | |
12 | * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. | |
13 | * See the License for the specific language governing permissions and | |
14 | * limitations under the License. | |
064af421 BP |
15 | */ |
16 | ||
17 | #ifndef UTIL_H | |
18 | #define UTIL_H 1 | |
19 | ||
a656cb77 | 20 | #include <limits.h> |
064af421 BP |
21 | #include <stdarg.h> |
22 | #include <stdbool.h> | |
23 | #include <stddef.h> | |
24 | #include <stdint.h> | |
25 | #include <stdio.h> | |
ccc09689 | 26 | #include <stdlib.h> |
064af421 BP |
27 | #include <string.h> |
28 | #include "compiler.h" | |
4e022ec0 | 29 | #include "openvswitch/types.h" |
064af421 BP |
30 | |
31 | #ifndef va_copy | |
32 | #ifdef __va_copy | |
33 | #define va_copy __va_copy | |
34 | #else | |
35 | #define va_copy(dst, src) ((dst) = (src)) | |
36 | #endif | |
37 | #endif | |
38 | ||
0b9275b2 BP |
39 | #ifdef __CHECKER__ |
40 | #define BUILD_ASSERT(EXPR) ((void) 0) | |
41 | #define BUILD_ASSERT_DECL(EXPR) extern int (*build_assert(void))[1] | |
42 | #elif !defined(__cplusplus) | |
064af421 BP |
43 | /* Build-time assertion building block. */ |
44 | #define BUILD_ASSERT__(EXPR) \ | |
45 | sizeof(struct { unsigned int build_assert_failed : (EXPR) ? 1 : -1; }) | |
46 | ||
47 | /* Build-time assertion for use in a statement context. */ | |
48 | #define BUILD_ASSERT(EXPR) (void) BUILD_ASSERT__(EXPR) | |
49 | ||
50 | /* Build-time assertion for use in a declaration context. */ | |
51 | #define BUILD_ASSERT_DECL(EXPR) \ | |
52 | extern int (*build_assert(void))[BUILD_ASSERT__(EXPR)] | |
53 | #else /* __cplusplus */ | |
54 | #include <boost/static_assert.hpp> | |
55 | #define BUILD_ASSERT BOOST_STATIC_ASSERT | |
56 | #define BUILD_ASSERT_DECL BOOST_STATIC_ASSERT | |
57 | #endif /* __cplusplus */ | |
58 | ||
320232ec BP |
59 | #ifdef __GNUC__ |
60 | #define BUILD_ASSERT_GCCONLY(EXPR) BUILD_ASSERT(EXPR) | |
61 | #define BUILD_ASSERT_DECL_GCCONLY(EXPR) BUILD_ASSERT_DECL(EXPR) | |
62 | #else | |
63 | #define BUILD_ASSERT_GCCONLY(EXPR) ((void) 0) | |
64 | #define BUILD_ASSERT_DECL_GCCONLY(EXPR) ((void) 0) | |
65 | #endif | |
66 | ||
4749f73d BP |
67 | /* Like the standard assert macro, except: |
68 | * | |
69 | * - Writes the failure message to the log. | |
70 | * | |
71 | * - Not affected by NDEBUG. */ | |
72 | #define ovs_assert(CONDITION) \ | |
73 | if (!OVS_LIKELY(CONDITION)) { \ | |
74 | ovs_assert_failure(SOURCE_LOCATOR, __func__, #CONDITION); \ | |
75 | } | |
76 | void ovs_assert_failure(const char *, const char *, const char *) NO_RETURN; | |
77 | ||
ebc56baa BP |
78 | /* Casts 'pointer' to 'type' and issues a compiler warning if the cast changes |
79 | * anything other than an outermost "const" or "volatile" qualifier. | |
80 | * | |
81 | * The cast to int is present only to suppress an "expression using sizeof | |
82 | * bool" warning from "sparse" (see | |
83 | * http://permalink.gmane.org/gmane.comp.parsers.sparse/2967). */ | |
84 | #define CONST_CAST(TYPE, POINTER) \ | |
85 | ((void) sizeof ((int) ((POINTER) == (TYPE) (POINTER))), \ | |
86 | (TYPE) (POINTER)) | |
87 | ||
064af421 BP |
88 | extern const char *program_name; |
89 | ||
ba25c9d1 | 90 | /* Returns the number of elements in ARRAY. */ |
064af421 | 91 | #define ARRAY_SIZE(ARRAY) (sizeof ARRAY / sizeof *ARRAY) |
ba25c9d1 BP |
92 | |
93 | /* Returns X / Y, rounding up. X must be nonnegative to round correctly. */ | |
bbb18ba7 | 94 | #define DIV_ROUND_UP(X, Y) (((X) + ((Y) - 1)) / (Y)) |
ba25c9d1 BP |
95 | |
96 | /* Returns X rounded up to the nearest multiple of Y. */ | |
bbb18ba7 | 97 | #define ROUND_UP(X, Y) (DIV_ROUND_UP(X, Y) * (Y)) |
ba25c9d1 BP |
98 | |
99 | /* Returns X rounded down to the nearest multiple of Y. */ | |
064af421 | 100 | #define ROUND_DOWN(X, Y) ((X) / (Y) * (Y)) |
ba25c9d1 BP |
101 | |
102 | /* Returns true if X is a power of 2, otherwise false. */ | |
064af421 BP |
103 | #define IS_POW2(X) ((X) && !((X) & ((X) - 1))) |
104 | ||
27527aa0 BP |
105 | static inline bool |
106 | is_pow2(uintmax_t x) | |
107 | { | |
108 | return IS_POW2(x); | |
109 | } | |
110 | ||
e93ab553 BP |
111 | /* Returns X rounded up to a power of 2. X must be a constant expression. */ |
112 | #define ROUND_UP_POW2(X) RUP2__(X) | |
113 | #define RUP2__(X) (RUP2_1(X) + 1) | |
114 | #define RUP2_1(X) (RUP2_2(X) | (RUP2_2(X) >> 16)) | |
115 | #define RUP2_2(X) (RUP2_3(X) | (RUP2_3(X) >> 8)) | |
116 | #define RUP2_3(X) (RUP2_4(X) | (RUP2_4(X) >> 4)) | |
117 | #define RUP2_4(X) (RUP2_5(X) | (RUP2_5(X) >> 2)) | |
118 | #define RUP2_5(X) (RUP2_6(X) | (RUP2_6(X) >> 1)) | |
119 | #define RUP2_6(X) ((X) - 1) | |
120 | ||
121 | /* Returns X rounded down to a power of 2. X must be a constant expression. */ | |
122 | #define ROUND_DOWN_POW2(X) RDP2__(X) | |
123 | #define RDP2__(X) (RDP2_1(X) - (RDP2_1(X) >> 1)) | |
124 | #define RDP2_1(X) (RDP2_2(X) | (RDP2_2(X) >> 16)) | |
125 | #define RDP2_2(X) (RDP2_3(X) | (RDP2_3(X) >> 8)) | |
126 | #define RDP2_3(X) (RDP2_4(X) | (RDP2_4(X) >> 4)) | |
127 | #define RDP2_4(X) (RDP2_5(X) | (RDP2_5(X) >> 2)) | |
128 | #define RDP2_5(X) ( (X) | ( (X) >> 1)) | |
129 | ||
064af421 BP |
130 | #ifndef MIN |
131 | #define MIN(X, Y) ((X) < (Y) ? (X) : (Y)) | |
132 | #endif | |
133 | ||
134 | #ifndef MAX | |
135 | #define MAX(X, Y) ((X) > (Y) ? (X) : (Y)) | |
136 | #endif | |
137 | ||
138 | #define NOT_REACHED() abort() | |
064af421 | 139 | |
f89ffb0e BP |
140 | /* Expands to a string that looks like "<file>:<line>", e.g. "tmp.c:10". |
141 | * | |
142 | * See http://c-faq.com/ansi/stringize.html for an explanation of STRINGIZE and | |
143 | * STRINGIZE2. */ | |
144 | #define SOURCE_LOCATOR __FILE__ ":" STRINGIZE(__LINE__) | |
145 | #define STRINGIZE(ARG) STRINGIZE2(ARG) | |
146 | #define STRINGIZE2(ARG) #ARG | |
147 | ||
17e42975 BP |
148 | /* Given a pointer-typed lvalue OBJECT, expands to a pointer type that may be |
149 | * assigned to OBJECT. */ | |
150 | #ifdef __GNUC__ | |
151 | #define OVS_TYPEOF(OBJECT) typeof(OBJECT) | |
152 | #else | |
153 | #define OVS_TYPEOF(OBJECT) void * | |
154 | #endif | |
155 | ||
4e6ca956 BP |
156 | /* Given OBJECT of type pointer-to-structure, expands to the offset of MEMBER |
157 | * within an instance of the structure. | |
158 | * | |
159 | * The GCC-specific version avoids the technicality of undefined behavior if | |
160 | * OBJECT is null, invalid, or not yet initialized. This makes some static | |
161 | * checkers (like Coverity) happier. But the non-GCC version does not actually | |
162 | * dereference any pointer, so it would be surprising for it to cause any | |
163 | * problems in practice. | |
164 | */ | |
165 | #ifdef __GNUC__ | |
166 | #define OBJECT_OFFSETOF(OBJECT, MEMBER) offsetof(typeof(*(OBJECT)), MEMBER) | |
167 | #else | |
168 | #define OBJECT_OFFSETOF(OBJECT, MEMBER) \ | |
169 | ((char *) &(OBJECT)->MEMBER - (char *) (OBJECT)) | |
170 | #endif | |
171 | ||
064af421 BP |
172 | /* Given POINTER, the address of the given MEMBER in a STRUCT object, returns |
173 | the STRUCT object. */ | |
174 | #define CONTAINER_OF(POINTER, STRUCT, MEMBER) \ | |
26adc8dd | 175 | ((STRUCT *) (void *) ((char *) (POINTER) - offsetof (STRUCT, MEMBER))) |
064af421 | 176 | |
adf7cfd8 | 177 | /* Given POINTER, the address of the given MEMBER within an object of the type |
17e42975 BP |
178 | * that that OBJECT points to, returns OBJECT as an assignment-compatible |
179 | * pointer type (either the correct pointer type or "void *"). OBJECT must be | |
180 | * an lvalue. | |
adf7cfd8 BP |
181 | * |
182 | * This is the same as CONTAINER_OF except that it infers the structure type | |
183 | * from the type of '*OBJECT'. */ | |
184 | #define OBJECT_CONTAINING(POINTER, OBJECT, MEMBER) \ | |
17e42975 | 185 | ((OVS_TYPEOF(OBJECT)) (void *) \ |
4e6ca956 | 186 | ((char *) (POINTER) - OBJECT_OFFSETOF(OBJECT, MEMBER))) |
adf7cfd8 | 187 | |
772ec52b BP |
188 | /* Given POINTER, the address of the given MEMBER within an object of the type |
189 | * that that OBJECT points to, assigns the address of the outer object to | |
190 | * OBJECT, which must be an lvalue. | |
191 | * | |
192 | * Evaluates to 1. */ | |
193 | #define ASSIGN_CONTAINER(OBJECT, POINTER, MEMBER) \ | |
194 | ((OBJECT) = OBJECT_CONTAINING(POINTER, OBJECT, MEMBER), 1) | |
195 | ||
064af421 BP |
196 | #ifdef __cplusplus |
197 | extern "C" { | |
198 | #endif | |
199 | ||
e385ef55 EJ |
200 | void set_program_name__(const char *name, const char *version, |
201 | const char *date, const char *time); | |
55d5bb44 | 202 | #define set_program_name(name) \ |
e385ef55 | 203 | set_program_name__(name, VERSION, __DATE__, __TIME__) |
064af421 | 204 | |
bc9fb3a9 BP |
205 | const char *get_subprogram_name(void); |
206 | void set_subprogram_name(const char *name); | |
207 | ||
55d5bb44 JP |
208 | const char *get_program_version(void); |
209 | void ovs_print_version(uint8_t min_ofp, uint8_t max_ofp); | |
064af421 BP |
210 | |
211 | void out_of_memory(void) NO_RETURN; | |
212 | void *xmalloc(size_t) MALLOC_LIKE; | |
213 | void *xcalloc(size_t, size_t) MALLOC_LIKE; | |
ec6fde61 | 214 | void *xzalloc(size_t) MALLOC_LIKE; |
064af421 BP |
215 | void *xrealloc(void *, size_t); |
216 | void *xmemdup(const void *, size_t) MALLOC_LIKE; | |
217 | char *xmemdup0(const char *, size_t) MALLOC_LIKE; | |
218 | char *xstrdup(const char *) MALLOC_LIKE; | |
219 | char *xasprintf(const char *format, ...) PRINTF_FORMAT(1, 2) MALLOC_LIKE; | |
220 | char *xvasprintf(const char *format, va_list) PRINTF_FORMAT(1, 0) MALLOC_LIKE; | |
221 | void *x2nrealloc(void *p, size_t *n, size_t s); | |
222 | ||
223 | void ovs_strlcpy(char *dst, const char *src, size_t size); | |
71d7c22f | 224 | void ovs_strzcpy(char *dst, const char *src, size_t size); |
064af421 | 225 | |
c1c8308a BP |
226 | void ovs_abort(int err_no, const char *format, ...) |
227 | PRINTF_FORMAT(2, 3) NO_RETURN; | |
d41d4b71 BP |
228 | void ovs_abort_valist(int err_no, const char *format, va_list) |
229 | PRINTF_FORMAT(2, 0) NO_RETURN; | |
064af421 BP |
230 | void ovs_fatal(int err_no, const char *format, ...) |
231 | PRINTF_FORMAT(2, 3) NO_RETURN; | |
fcaddd4d BP |
232 | void ovs_fatal_valist(int err_no, const char *format, va_list) |
233 | PRINTF_FORMAT(2, 0) NO_RETURN; | |
064af421 | 234 | void ovs_error(int err_no, const char *format, ...) PRINTF_FORMAT(2, 3); |
c1c8308a BP |
235 | void ovs_error_valist(int err_no, const char *format, va_list) |
236 | PRINTF_FORMAT(2, 0); | |
c18ea70d | 237 | const char *ovs_retval_to_string(int); |
5fcbed74 | 238 | const char *ovs_strerror(int); |
064af421 BP |
239 | void ovs_hex_dump(FILE *, const void *, size_t, uintptr_t offset, bool ascii); |
240 | ||
241 | bool str_to_int(const char *, int base, int *); | |
242 | bool str_to_long(const char *, int base, long *); | |
243 | bool str_to_llong(const char *, int base, long long *); | |
244 | bool str_to_uint(const char *, int base, unsigned int *); | |
245 | bool str_to_ulong(const char *, int base, unsigned long *); | |
246 | bool str_to_ullong(const char *, int base, unsigned long long *); | |
247 | ||
f38b84ea BP |
248 | bool str_to_double(const char *, double *); |
249 | ||
250 | int hexit_value(int c); | |
bf971267 | 251 | unsigned int hexits_value(const char *s, size_t n, bool *ok); |
f38b84ea | 252 | |
44b4d050 BP |
253 | const char *english_list_delimiter(size_t index, size_t total); |
254 | ||
daf03c53 | 255 | char *get_cwd(void); |
29d4af60 | 256 | char *dir_name(const char *file_name); |
e1aff6f9 | 257 | char *base_name(const char *file_name); |
daf03c53 | 258 | char *abs_file_name(const char *dir, const char *file_name); |
29d4af60 | 259 | |
fee0c963 BP |
260 | char *xreadlink(const char *filename); |
261 | char *follow_symlinks(const char *filename); | |
262 | ||
c69ee87c | 263 | void ignore(bool x OVS_UNUSED); |
fe9d0898 BP |
264 | \f |
265 | /* Bitwise tests. */ | |
0ee140fb BP |
266 | |
267 | /* Returns the number of trailing 0-bits in 'n'. Undefined if 'n' == 0. | |
268 | * | |
269 | * This compiles to a single machine instruction ("bsf") with GCC on x86. */ | |
270 | #if !defined(UINT_MAX) || !defined(UINT32_MAX) | |
271 | #error "Someone screwed up the #includes." | |
272 | #elif __GNUC__ >= 4 && UINT_MAX == UINT32_MAX | |
273 | static inline int | |
274 | raw_ctz(uint32_t n) | |
275 | { | |
276 | return __builtin_ctz(n); | |
277 | } | |
278 | #else | |
279 | /* Defined in util.c. */ | |
280 | int raw_ctz(uint32_t n); | |
281 | #endif | |
282 | ||
283 | /* Returns the number of trailing 0-bits in 'n', or 32 if 'n' is 0. */ | |
284 | static inline int | |
285 | ctz(uint32_t n) | |
286 | { | |
287 | return n ? raw_ctz(n) : 32; | |
288 | } | |
289 | ||
aad29cd1 | 290 | int log_2_floor(uint32_t); |
300c6946 | 291 | int log_2_ceil(uint32_t); |
4ed6a64c | 292 | unsigned int popcount(uint32_t); |
18b9283b | 293 | |
fe9d0898 BP |
294 | /* Returns the rightmost 1-bit in 'x' (e.g. 01011000 => 00001000), or 0 if 'x' |
295 | * is 0. */ | |
296 | static inline uintmax_t | |
297 | rightmost_1bit(uintmax_t x) | |
298 | { | |
299 | return x & -x; | |
300 | } | |
301 | ||
302 | /* Returns 'x' with its rightmost 1-bit changed to a zero (e.g. 01011000 => | |
303 | * 01010000), or 0 if 'x' is 0. */ | |
304 | static inline uintmax_t | |
305 | zero_rightmost_1bit(uintmax_t x) | |
306 | { | |
307 | return x & (x - 1); | |
308 | } | |
35bedb61 BP |
309 | |
310 | /* Returns the index of the rightmost 1-bit in 'x' (e.g. 01011000 => 3), or 32 | |
311 | * if 'x' is 0. | |
312 | * | |
313 | * Unlike the other functions for rightmost 1-bits, this function only works | |
314 | * with 32-bit integers. */ | |
315 | static inline uint32_t | |
316 | rightmost_1bit_idx(uint32_t x) | |
317 | { | |
318 | return x ? ctz(x) : 32; | |
319 | } | |
320 | ||
321 | /* Returns the index of the rightmost 1-bit in 'x' (e.g. 01011000 => 6), or 32 | |
322 | * if 'x' is 0. | |
323 | * | |
324 | * This function only works with 32-bit integers. */ | |
325 | static inline uint32_t | |
326 | leftmost_1bit_idx(uint32_t x) | |
327 | { | |
328 | return x ? log_2_floor(x) : 32; | |
329 | } | |
fe9d0898 | 330 | \f |
75a75043 BP |
331 | bool is_all_zeros(const uint8_t *, size_t); |
332 | bool is_all_ones(const uint8_t *, size_t); | |
ddc4f8e2 BP |
333 | void bitwise_copy(const void *src, unsigned int src_len, unsigned int src_ofs, |
334 | void *dst, unsigned int dst_len, unsigned int dst_ofs, | |
335 | unsigned int n_bits); | |
6cc7ea5e BP |
336 | void bitwise_zero(void *dst_, unsigned int dst_len, unsigned dst_ofs, |
337 | unsigned int n_bits); | |
c2dd4932 BP |
338 | void bitwise_one(void *dst_, unsigned int dst_len, unsigned dst_ofs, |
339 | unsigned int n_bits); | |
79a010aa BP |
340 | bool bitwise_is_all_zeros(const void *, unsigned int len, unsigned int ofs, |
341 | unsigned int n_bits); | |
ddc4f8e2 BP |
342 | void bitwise_put(uint64_t value, |
343 | void *dst, unsigned int dst_len, unsigned int dst_ofs, | |
344 | unsigned int n_bits); | |
345 | uint64_t bitwise_get(const void *src, unsigned int src_len, | |
346 | unsigned int src_ofs, unsigned int n_bits); | |
75a75043 | 347 | |
064af421 BP |
348 | #ifdef __cplusplus |
349 | } | |
350 | #endif | |
351 | ||
352 | #endif /* util.h */ |