1 /* 2 * Copyright (c) 2020 iXsystems, Inc. 3 * All rights reserved. 4 * 5 * Redistribution and use in source and binary forms, with or without 6 * modification, are permitted provided that the following conditions 7 * are met: 8 * 1. Redistributions of source code must retain the above copyright 9 * notice, this list of conditions and the following disclaimer. 10 * 2. Redistributions in binary form must reproduce the above copyright 11 * notice, this list of conditions and the following disclaimer in the 12 * documentation and/or other materials provided with the distribution. 13 * 14 * THIS SOFTWARE IS PROVIDED BY THE AUTHORS AND CONTRIBUTORS ``AS IS'' AND 15 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE 16 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE 17 * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHORS OR CONTRIBUTORS BE LIABLE 18 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL 19 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS 20 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) 21 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT 22 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY 23 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF 24 * SUCH DAMAGE. 25 * 26 * $FreeBSD$ 27 */ 28 29 /* 30 * Available Solaris debug functions. All of the ASSERT() macros will be 31 * compiled out when NDEBUG is defined, this is the default behavior for 32 * the SPL. To enable assertions use the --enable-debug with configure. 33 * The VERIFY() functions are never compiled out and cannot be disabled. 34 * 35 * PANIC() - Panic the node and print message. 36 * ASSERT() - Assert X is true, if not panic. 37 * ASSERT3B() - Assert boolean X OP Y is true, if not panic. 38 * ASSERT3S() - Assert signed X OP Y is true, if not panic. 39 * ASSERT3U() - Assert unsigned X OP Y is true, if not panic. 40 * ASSERT3P() - Assert pointer X OP Y is true, if not panic. 41 * ASSERT0() - Assert value is zero, if not panic. 42 * ASSERT0P() - Assert pointer is null, if not panic. 43 * VERIFY() - Verify X is true, if not panic. 44 * VERIFY3B() - Verify boolean X OP Y is true, if not panic. 45 * VERIFY3S() - Verify signed X OP Y is true, if not panic. 46 * VERIFY3U() - Verify unsigned X OP Y is true, if not panic. 47 * VERIFY3P() - Verify pointer X OP Y is true, if not panic. 48 * VERIFY0() - Verify value is zero, if not panic. 49 * VERIFY0P() - Verify pointer is null, if not panic. 50 */ 51 52 #ifndef _SPL_DEBUG_H 53 #define _SPL_DEBUG_H 54 55 56 /* 57 * Common DEBUG functionality. 58 */ 59 #ifdef __FreeBSD__ 60 #include <linux/compiler.h> 61 #endif 62 63 #ifndef __printflike 64 #define __printflike(a, b) __printf(a, b) 65 #endif 66 67 #ifndef __maybe_unused 68 #define __maybe_unused __attribute__((unused)) 69 #endif 70 71 /* 72 * Without this, we see warnings from objtool during normal Linux builds when 73 * the kernel is built with CONFIG_STACK_VALIDATION=y: 74 * 75 * warning: objtool: tsd_create() falls through to next function __list_add() 76 * warning: objtool: .text: unexpected end of section 77 * 78 * Until the toolchain stops doing this, we must only define this attribute on 79 * spl_panic() when doing static analysis. 80 */ 81 #if defined(__COVERITY__) || defined(__clang_analyzer__) 82 __attribute__((__noreturn__)) 83 #endif 84 extern void spl_panic(const char *file, const char *func, int line, 85 const char *fmt, ...); 86 extern void spl_dumpstack(void); 87 88 static inline int 89 spl_assert(const char *buf, const char *file, const char *func, int line) 90 { 91 spl_panic(file, func, line, "%s", buf); 92 return (0); 93 } 94 95 #ifndef expect 96 #define expect(expr, value) (__builtin_expect((expr), (value))) 97 #endif 98 #ifndef __linux__ 99 #define likely(expr) expect((expr) != 0, 1) 100 #define unlikely(expr) expect((expr) != 0, 0) 101 #endif 102 103 #define PANIC(fmt, a...) \ 104 spl_panic(__FILE__, __FUNCTION__, __LINE__, fmt, ## a) 105 106 #define VERIFY(cond) \ 107 (void) (unlikely(!(cond)) && \ 108 spl_assert("VERIFY(" #cond ") failed\n", \ 109 __FILE__, __FUNCTION__, __LINE__)) 110 111 #define VERIFYF(cond, str, ...) do { \ 112 if (unlikely(!cond)) \ 113 spl_panic(__FILE__, __FUNCTION__, __LINE__, \ 114 "VERIFY(" #cond ") failed " str "\n", __VA_ARGS__);\ 115 } while (0) 116 117 #define VERIFY3B(LEFT, OP, RIGHT) do { \ 118 const boolean_t _verify3_left = (boolean_t)(LEFT); \ 119 const boolean_t _verify3_right = (boolean_t)(RIGHT); \ 120 if (unlikely(!(_verify3_left OP _verify3_right))) \ 121 spl_panic(__FILE__, __FUNCTION__, __LINE__, \ 122 "VERIFY3(" #LEFT " " #OP " " #RIGHT ") " \ 123 "failed (%d " #OP " %d)\n", \ 124 (boolean_t)_verify3_left, \ 125 (boolean_t)_verify3_right); \ 126 } while (0) 127 128 #define VERIFY3S(LEFT, OP, RIGHT) do { \ 129 const int64_t _verify3_left = (int64_t)(LEFT); \ 130 const int64_t _verify3_right = (int64_t)(RIGHT); \ 131 if (unlikely(!(_verify3_left OP _verify3_right))) \ 132 spl_panic(__FILE__, __FUNCTION__, __LINE__, \ 133 "VERIFY3(" #LEFT " " #OP " " #RIGHT ") " \ 134 "failed (%lld " #OP " %lld)\n", \ 135 (long long)_verify3_left, \ 136 (long long)_verify3_right); \ 137 } while (0) 138 139 #define VERIFY3U(LEFT, OP, RIGHT) do { \ 140 const uint64_t _verify3_left = (uint64_t)(LEFT); \ 141 const uint64_t _verify3_right = (uint64_t)(RIGHT); \ 142 if (unlikely(!(_verify3_left OP _verify3_right))) \ 143 spl_panic(__FILE__, __FUNCTION__, __LINE__, \ 144 "VERIFY3(" #LEFT " " #OP " " #RIGHT ") " \ 145 "failed (%llu " #OP " %llu)\n", \ 146 (unsigned long long)_verify3_left, \ 147 (unsigned long long)_verify3_right); \ 148 } while (0) 149 150 #define VERIFY3P(LEFT, OP, RIGHT) do { \ 151 const uintptr_t _verify3_left = (uintptr_t)(LEFT); \ 152 const uintptr_t _verify3_right = (uintptr_t)(RIGHT); \ 153 if (unlikely(!(_verify3_left OP _verify3_right))) \ 154 spl_panic(__FILE__, __FUNCTION__, __LINE__, \ 155 "VERIFY3(" #LEFT " " #OP " " #RIGHT ") " \ 156 "failed (%px " #OP " %px)\n", \ 157 (void *)_verify3_left, \ 158 (void *)_verify3_right); \ 159 } while (0) 160 161 #define VERIFY0(RIGHT) do { \ 162 const int64_t _verify0_right = (int64_t)(RIGHT); \ 163 if (unlikely(!(0 == _verify0_right))) \ 164 spl_panic(__FILE__, __FUNCTION__, __LINE__, \ 165 "VERIFY0(" #RIGHT ") " \ 166 "failed (0 == %lld)\n", \ 167 (long long)_verify0_right); \ 168 } while (0) 169 170 #define VERIFY0P(RIGHT) do { \ 171 const uintptr_t _verify0_right = (uintptr_t)(RIGHT); \ 172 if (unlikely(!(0 == _verify0_right))) \ 173 spl_panic(__FILE__, __FUNCTION__, __LINE__, \ 174 "VERIFY0P(" #RIGHT ") " \ 175 "failed (NULL == %px)\n", \ 176 (void *)_verify0_right); \ 177 } while (0) 178 179 /* 180 * Note that you should not put any operations you want to always happen 181 * in the print section for ASSERTs unless you only want them to run on 182 * debug builds! 183 * e.g. ASSERT3UF(2, <, 3, "%s", foo(x)), foo(x) won't run on non-debug 184 * builds. 185 */ 186 187 #define VERIFY3BF(LEFT, OP, RIGHT, STR, ...) do { \ 188 const boolean_t _verify3_left = (boolean_t)(LEFT); \ 189 const boolean_t _verify3_right = (boolean_t)(RIGHT); \ 190 if (unlikely(!(_verify3_left OP _verify3_right))) \ 191 spl_panic(__FILE__, __FUNCTION__, __LINE__, \ 192 "VERIFY3(" #LEFT " " #OP " " #RIGHT ") " \ 193 "failed (%d " #OP " %d) " STR "\n", \ 194 (boolean_t)(_verify3_left), \ 195 (boolean_t)(_verify3_right), \ 196 __VA_ARGS__); \ 197 } while (0) 198 199 #define VERIFY3SF(LEFT, OP, RIGHT, STR, ...) do { \ 200 const int64_t _verify3_left = (int64_t)(LEFT); \ 201 const int64_t _verify3_right = (int64_t)(RIGHT); \ 202 if (unlikely(!(_verify3_left OP _verify3_right))) \ 203 spl_panic(__FILE__, __FUNCTION__, __LINE__, \ 204 "VERIFY3(" #LEFT " " #OP " " #RIGHT ") " \ 205 "failed (%lld " #OP " %lld) " STR "\n", \ 206 (long long)(_verify3_left), \ 207 (long long)(_verify3_right), \ 208 __VA_ARGS); \ 209 } while (0) 210 211 #define VERIFY3UF(LEFT, OP, RIGHT, STR, ...) do { \ 212 const uint64_t _verify3_left = (uint64_t)(LEFT); \ 213 const uint64_t _verify3_right = (uint64_t)(RIGHT); \ 214 if (unlikely(!(_verify3_left OP _verify3_right))) \ 215 spl_panic(__FILE__, __FUNCTION__, __LINE__, \ 216 "VERIFY3(" #LEFT " " #OP " " #RIGHT ") " \ 217 "failed (%llu " #OP " %llu) " STR "\n", \ 218 (unsigned long long)(_verify3_left), \ 219 (unsigned long long)(_verify3_right), \ 220 __VA_ARGS); \ 221 } while (0) 222 223 #define VERIFY3PF(LEFT, OP, RIGHT, STR, ...) do { \ 224 const uintptr_t _verify3_left = (uintptr_t)(LEFT); \ 225 const uintptr_t _verify3_right = (uintptr_t)(RIGHT); \ 226 if (unlikely(!(_verify3_left OP _verify3_right))) \ 227 spl_panic(__FILE__, __FUNCTION__, __LINE__, \ 228 "VERIFY3(" #LEFT " " #OP " " #RIGHT ") " \ 229 "failed (%px " #OP " %px) " STR "\n", \ 230 (void *) (_verify3_left), \ 231 (void *) (_verify3_right), \ 232 __VA_ARGS__); \ 233 } while (0) 234 235 #define VERIFY0PF(RIGHT, STR, ...) do { \ 236 const uintptr_t _verify3_left = (uintptr_t)(0); \ 237 const uintptr_t _verify3_right = (uintptr_t)(RIGHT); \ 238 if (unlikely(!(_verify3_left == _verify3_right))) \ 239 spl_panic(__FILE__, __FUNCTION__, __LINE__, \ 240 "VERIFY0(0 == " #RIGHT ") " \ 241 "failed (0 == %px) " STR "\n", \ 242 (long long) (_verify3_right), \ 243 __VA_ARGS__); \ 244 } while (0) 245 246 #define VERIFY0F(RIGHT, STR, ...) do { \ 247 const int64_t _verify3_left = (int64_t)(0); \ 248 const int64_t _verify3_right = (int64_t)(RIGHT); \ 249 if (unlikely(!(_verify3_left == _verify3_right))) \ 250 spl_panic(__FILE__, __FUNCTION__, __LINE__, \ 251 "VERIFY0(0 == " #RIGHT ") " \ 252 "failed (0 == %lld) " STR "\n", \ 253 (long long) (_verify3_right), \ 254 __VA_ARGS__); \ 255 } while (0) 256 257 #define VERIFY_IMPLY(A, B) \ 258 ((void)(likely((!(A)) || (B)) || \ 259 spl_assert("(" #A ") implies (" #B ")", \ 260 __FILE__, __FUNCTION__, __LINE__))) 261 262 #define VERIFY_EQUIV(A, B) \ 263 ((void)(likely(!!(A) == !!(B)) || \ 264 spl_assert("(" #A ") is equivalent to (" #B ")", \ 265 __FILE__, __FUNCTION__, __LINE__))) 266 267 /* 268 * Debugging disabled (--disable-debug) 269 */ 270 #ifdef NDEBUG 271 272 #define ASSERT(x) ((void) sizeof ((uintptr_t)(x))) 273 #define ASSERT3B(x, y, z) \ 274 ((void) sizeof ((uintptr_t)(x)), (void) sizeof ((uintptr_t)(z))) 275 #define ASSERT3S(x, y, z) \ 276 ((void) sizeof ((uintptr_t)(x)), (void) sizeof ((uintptr_t)(z))) 277 #define ASSERT3U(x, y, z) \ 278 ((void) sizeof ((uintptr_t)(x)), (void) sizeof ((uintptr_t)(z))) 279 #define ASSERT3P(x, y, z) \ 280 ((void) sizeof ((uintptr_t)(x)), (void) sizeof ((uintptr_t)(z))) 281 #define ASSERT0(x) ((void) sizeof ((uintptr_t)(x))) 282 #define ASSERT0P(x) ((void) sizeof ((uintptr_t)(x))) 283 #define ASSERT3BF(x, y, z, str, ...) ASSERT3B(x, y, z) 284 #define ASSERT3SF(x, y, z, str, ...) ASSERT3S(x, y, z) 285 #define ASSERT3UF(x, y, z, str, ...) ASSERT3U(x, y, z) 286 #define ASSERT3PF(x, y, z, str, ...) ASSERT3P(x, y, z) 287 #define ASSERT0PF(x, str, ...) ASSERT0P(x) 288 #define ASSERT0F(x, str, ...) ASSERT0(x) 289 #define ASSERTF(x, str, ...) ASSERT(x) 290 #define IMPLY(A, B) \ 291 ((void) sizeof ((uintptr_t)(A)), (void) sizeof ((uintptr_t)(B))) 292 #define EQUIV(A, B) \ 293 ((void) sizeof ((uintptr_t)(A)), (void) sizeof ((uintptr_t)(B))) 294 295 /* 296 * Debugging enabled (--enable-debug) 297 */ 298 #else 299 300 #define ASSERT3B VERIFY3B 301 #define ASSERT3S VERIFY3S 302 #define ASSERT3U VERIFY3U 303 #define ASSERT3P VERIFY3P 304 #define ASSERT0 VERIFY0 305 #define ASSERT0P VERIFY0P 306 #define ASSERT3BF VERIFY3BF 307 #define ASSERT3SF VERIFY3SF 308 #define ASSERT3UF VERIFY3UF 309 #define ASSERT3PF VERIFY3PF 310 #define ASSERT0PF VERIFY0PF 311 #define ASSERT0F VERIFY0F 312 #define ASSERTF VERIFYF 313 #define ASSERT VERIFY 314 #define IMPLY VERIFY_IMPLY 315 #define EQUIV VERIFY_EQUIV 316 317 #endif /* NDEBUG */ 318 319 #endif /* SPL_DEBUG_H */ 320