debug.h (17353B)
1 /* 2 * 3 * 4 * This license is set out in https://raw.githubusercontent.com/Broadcom-Network-Switching-Software/OpenBCM/master/Legal/LICENSE file. 5 * 6 * Copyright 2007-2020 Broadcom Inc. All rights reserved. 7 */ 8 9 #ifndef __BCM_DEBUG_EX_H__ 10 #define __BCM_DEBUG_EX_H__ 11 12 #include <bcm/debug.h> 13 #if (defined(BCM_DPP_SUPPORT) || defined(BCM_DFE_SUPPORT)) && defined(BCM_GEN_ERR_MECHANISM) 14 #include <soc/dcmn/dcmn_gen_err.h> 15 #endif 16 17 #if defined(BROADCOM_DEBUG) 18 19 /* 20 * Unified message format for all modules 21 * In order to use this format _ERR_MSG_MODULE_NAME must be defined 22 * For example in Fabric module the following will be in top of the c file: 23 * #ifdef _ERR_MSG_MODULE_NAME 24 * #error "_ERR_MSG_MODULE_NAME redefined" 25 * #endif 26 * #define _ERR_MSG_MODULE_NAME FABRIC 27 * And in the bottom: 28 * #undef _ERR_MSG_MODULE_NAME 29 */ 30 #define _BCM_MSG(string) "%s[%d]%s unit %d: " string "\n", __FILE__, __LINE__, FUNCTION_NAME(), unit 31 #define _BCM_MSG_NO_UNIT(string) "%s[%d]%s: " string "\n", __FILE__, __LINE__, FUNCTION_NAME() 32 #define _BSL_BCM_MSG(string) _ERR_MSG_MODULE_NAME, unit, string "\n" 33 #define _BSL_BCM_MSG_NO_UNIT(string) _ERR_MSG_MODULE_NAME, BSL_UNIT_UNKNOWN, string "\n" 34 35 #else 36 #define _BCM_MSG(string) string 37 #define _BCM_MSG_NO_UNIT(string) string 38 39 #define _BSL_BCM_MSG(string) _ERR_MSG_MODULE_NAME, unit, string 40 #define _BSL_BCM_MSG_NO_UNIT(string) _ERR_MSG_MODULE_NAME, BSL_UNIT_UNKNOWN, string 41 #endif 42 #define _BSL_BCM_MSG_STR(string) _ERR_MSG_MODULE_NAME, unit, string 43 44 /*Single point of exit*/ 45 #define BCM_EXIT goto exit 46 47 /* Must appear at each function right after parameters definition */ 48 #define BCM_INIT_FUNC_DEFS \ 49 int _rv = BCM_E_NONE, _lock_taken = 0; \ 50 (void)_lock_taken; \ 51 LOG_DEBUG(_ERR_MSG_MODULE_NAME, (BSL_META_U(unit, "enter\n"))); 52 53 #define BCM_INIT_FUNC_DEFS_NO_UNIT \ 54 int _rv = BCM_E_NONE, _lock_taken = 0; \ 55 (void)_lock_taken; \ 56 LOG_DEBUG(_ERR_MSG_MODULE_NAME, (BSL_META("enter\n"))); 57 58 #define BCM_FUNC_ERROR \ 59 BCM_FAILURE(_rv) 60 61 #if (defined(BCM_DPP_SUPPORT) || defined(BCM_DFE_SUPPORT)) && defined(BCM_GEN_ERR_MECHANISM) 62 #define BCM_FUNC_IF_ERR(_rv) \ 63 GEN_ERR_CHK(unit, GEN_ERR_TYPE_BCM, _rv); \ 64 if (BCM_FAILURE(_rv)) 65 #else 66 #define BCM_FUNC_IF_ERR(_rv) \ 67 if (BCM_FAILURE(_rv)) 68 #endif 69 70 #define BCM_FUNC_RETURN \ 71 LOG_DEBUG(_ERR_MSG_MODULE_NAME, (BSL_META_U(unit, "exit\n"))); \ 72 return _rv; 73 74 #define BCM_RETURN_VAL_EXIT(rv_override) \ 75 _rv = rv_override; \ 76 BCM_EXIT; 77 78 #define BCM_FUNC_RETURN_VOID \ 79 LOG_DEBUG(_ERR_MSG_MODULE_NAME, (BSL_META_U(unit, "exit\n"))); \ 80 COMPILER_REFERENCE(_rv); 81 82 #define BCM_FUNC_RETURN_NO_UNIT \ 83 LOG_DEBUG(_ERR_MSG_MODULE_NAME, (BSL_META("exit\n"))); \ 84 return _rv; 85 86 #define BCM_FUNC_RETURN_VOID_NO_UNIT \ 87 LOG_DEBUG(_ERR_MSG_MODULE_NAME, (BSL_META("exit\n"))); \ 88 COMPILER_REFERENCE(_rv); 89 90 #if (defined(BCM_DPP_SUPPORT) || defined(BCM_DFE_SUPPORT)) && defined(BCM_GEN_ERR_MECHANISM) 91 #define BCM_IF_ERR_CONT(_rc) \ 92 do { \ 93 int __err__rc = _rc; \ 94 GEN_ERR_CHK(unit, GEN_ERR_TYPE_BCM, __err__rc); \ 95 if(__err__rc != BCM_E_NONE) { \ 96 LOG_WARN(_ERR_MSG_MODULE_NAME, \ 97 (BSL_META_U(unit, "%s\n"), \ 98 bcm_errmsg(__err__rc))); \ 99 _rv = __err__rc; \ 100 } \ 101 } while(0) 102 103 #define BCM_IF_ERR_EXIT(_rc) \ 104 do { \ 105 int __err__rc = _rc; \ 106 GEN_ERR_CHK(unit, GEN_ERR_TYPE_BCM, __err__rc); \ 107 if(__err__rc != BCM_E_NONE) { \ 108 LOG_ERROR(_ERR_MSG_MODULE_NAME, \ 109 (BSL_META_U(unit, "%s\n"), \ 110 bcm_errmsg(__err__rc))); \ 111 _rv = __err__rc; \ 112 BCM_EXIT; \ 113 } \ 114 } while(0) 115 116 #define BCM_IF_ERR_NOT_UNAVAIL_EXIT(_rc) \ 117 do { \ 118 int __err__rc = _rc; \ 119 GEN_ERR_CHK(unit, GEN_ERR_TYPE_BCM, __err__rc); \ 120 if(__err__rc != BCM_E_NONE && __err__rc != BCM_E_UNAVAIL) { \ 121 LOG_ERROR(_ERR_MSG_MODULE_NAME, \ 122 (BSL_META_U(unit, "%s\n"), \ 123 bcm_errmsg(__err__rc))); \ 124 _rv = __err__rc; \ 125 BCM_EXIT; \ 126 } \ 127 } while(0) 128 129 #define BCM_IF_ERR_NOT_E_NOT_FOUND_EXIT(_rc) \ 130 do { \ 131 int __err__rc = _rc; \ 132 GEN_ERR_CHK(unit, GEN_ERR_TYPE_BCM, __err__rc); \ 133 if (__err__rc != BCM_E_NONE) { \ 134 if(__err__rc != BCM_E_NOT_FOUND) { \ 135 LOG_ERROR(_ERR_MSG_MODULE_NAME, \ 136 (BSL_META_U(unit, "%s\n"), \ 137 bcm_errmsg(__err__rc))); \ 138 } \ 139 _rv = __err__rc; \ 140 BCM_EXIT; \ 141 } \ 142 } while(0) 143 #else 144 #define BCM_IF_ERR_CONT(_rc) \ 145 do { \ 146 int __err__rc = _rc; \ 147 if(__err__rc != BCM_E_NONE) { \ 148 LOG_WARN(_ERR_MSG_MODULE_NAME, \ 149 (BSL_META_U(unit, "%s\n"), \ 150 bcm_errmsg(__err__rc))); \ 151 _rv = __err__rc; \ 152 } \ 153 } while(0) 154 155 #define BCM_IF_ERR_EXIT(_rc) \ 156 do { \ 157 int __err__rc = _rc; \ 158 if(__err__rc != BCM_E_NONE) { \ 159 LOG_ERROR(_ERR_MSG_MODULE_NAME, \ 160 (BSL_META_U(unit, "%s\n"), \ 161 bcm_errmsg(__err__rc))); \ 162 _rv = __err__rc; \ 163 BCM_EXIT; \ 164 } \ 165 } while(0) 166 167 #define BCM_IF_ERR_NOT_UNAVAIL_EXIT(_rc) \ 168 do { \ 169 int __err__rc = _rc; \ 170 if(__err__rc != BCM_E_NONE && __err__rc != BCM_E_UNAVAIL) { \ 171 LOG_ERROR(_ERR_MSG_MODULE_NAME, \ 172 (BSL_META_U(unit, "%s\n"), \ 173 bcm_errmsg(__err__rc))); \ 174 _rv = __err__rc; \ 175 BCM_EXIT; \ 176 } \ 177 } while(0) 178 179 #define BCM_IF_ERR_NOT_E_NOT_FOUND_EXIT(_rc) \ 180 do { \ 181 int __err__rc = _rc; \ 182 if (__err__rc != BCM_E_NONE) { \ 183 if(__err__rc != BCM_E_NOT_FOUND) { \ 184 LOG_ERROR(_ERR_MSG_MODULE_NAME, \ 185 (BSL_META_U(unit, "%s\n"), \ 186 bcm_errmsg(__err__rc))); \ 187 } \ 188 else \ 189 { \ 190 LOG_VERBOSE(_ERR_MSG_MODULE_NAME, \ 191 (BSL_META_U(unit, "%s\n"), \ 192 bcm_errmsg(__err__rc))); \ 193 } \ 194 _rv = __err__rc; \ 195 BCM_EXIT; \ 196 } \ 197 } while(0) 198 #endif 199 200 #define BCM_IF_ERR_EXIT_NO_UNIT(_rc) \ 201 do { \ 202 int __err__rc = _rc; \ 203 if(__err__rc != BCM_E_NONE) { \ 204 LOG_ERROR(_ERR_MSG_MODULE_NAME, \ 205 (BSL_META("%s\n"), \ 206 bcm_errmsg(__err__rc))); \ 207 _rv = __err__rc; \ 208 BCM_EXIT; \ 209 } \ 210 } while(0) 211 212 #define BCM_IF_ERR_EXIT_MSG(_rc, stuff) \ 213 do { \ 214 int __err__rc = _rc; \ 215 if(__err__rc != BCM_E_NONE) { \ 216 LOG_ERROR(_ERR_MSG_MODULE_NAME, stuff); \ 217 _rv = __err__rc; \ 218 BCM_EXIT; \ 219 } \ 220 } while(0) 221 222 #define BCM_ERR_EXIT_MSG(_rc, stuff) \ 223 do { \ 224 LOG_ERROR(_ERR_MSG_MODULE_NAME, stuff); \ 225 _rv = _rc; \ 226 BCM_EXIT; \ 227 } while(0) 228 229 #define BCM_ERR_EXIT_NO_MSG(_rc) \ 230 do { \ 231 _rv = _rc; \ 232 BCM_EXIT; \ 233 } while(0) 234 #define BCM_NULL_CHECK(arg) \ 235 do { \ 236 if ((arg) == NULL) \ 237 { BCM_ERR_EXIT_MSG(BCM_E_PARAM,(BSL_META_U(unit, "null parameter\n"))); } \ 238 } while (0) 239 240 #define BCM_NULL_CHECK_NO_UNIT(arg) \ 241 do { \ 242 if ((arg) == NULL) \ 243 { BCM_ERR_EXIT_MSG(BCM_E_PARAM,(BSL_META("null parameter\n"))); } \ 244 } while (0) 245 246 #define BCM_ALLOC(pointer, mem_size, alloc_comment) \ 247 do { \ 248 if((pointer) == NULL) { \ 249 (pointer) = sal_alloc((mem_size), (alloc_comment)); \ 250 } else {\ 251 BCM_ERR_EXIT_MSG(BCM_E_PARAM,(BSL_META("attempted to allocate to a non NULL pointer: %s\n"), (alloc_comment))); \ 252 } \ 253 } while (0) 254 255 #define BCM_FREE(pointer) \ 256 do { \ 257 if((pointer) != NULL) { \ 258 sal_free((void*)(pointer)); \ 259 (pointer) = NULL; \ 260 } \ 261 } while (0) 262 263 #ifdef BROADCOM_DEBUG 264 /* If expr is false, then an error will be thrown and the error message will be the expression failed. */ 265 /* This is a version of assert without exit. */ 266 # define BCM_VERIFY(expr) do { if (!(expr)) { BCM_ERR_EXIT_MSG(BCM_E_FAIL, ("ASSERTION FAILED (%s:%d): %s\n", __FILE__, __LINE__, #expr)); } } while(0) 267 #else 268 # define BCM_VERIFY(expr) ((void)0) 269 #endif /* BROADCOM_DEBUG */ 270 271 #define BCMDNX_FUNC_ERROR \ 272 BCM_FAILURE(_rv) 273 274 /* Must appear at each function right after parameters definition */ 275 #define BCMDNX_INIT_FUNC_DEFS \ 276 int _rv = BCM_E_NONE, _lock_taken = 0; \ 277 (void)_lock_taken; \ 278 _bsl_vverbose(_ERR_MSG_MODULE_NAME, unit, _BCM_MSG("enter")); 279 280 #define BCMDNX_INIT_FUNC_DEFS_NO_UNIT \ 281 int unit; \ 282 int _rv = BCM_E_NONE, _lock_taken = 0; \ 283 (void)_lock_taken; \ 284 unit = BSL_UNIT_UNKNOWN; \ 285 _bsl_vverbose(_ERR_MSG_MODULE_NAME, unit, _BCM_MSG_NO_UNIT("enter")); 286 287 #define BCMDNX_FUNC_RETURN \ 288 _bsl_vverbose(_ERR_MSG_MODULE_NAME, unit, _BCM_MSG("exit")); \ 289 return _rv; 290 291 #define BCMDNX_FUNC_RETURN_VOID \ 292 _bsl_vverbose(_ERR_MSG_MODULE_NAME, unit, _BCM_MSG("exit"));\ 293 COMPILER_REFERENCE(_rv); 294 295 #define BCMDNX_FUNC_RETURN_NO_UNIT \ 296 _bsl_vverbose(_ERR_MSG_MODULE_NAME, BSL_UNIT_UNKNOWN, _BCM_MSG_NO_UNIT("exit")); \ 297 return _rv; 298 299 #define BCMDNX_FUNC_RETURN_VOID_NO_UNIT \ 300 _bsl_vverbose(_ERR_MSG_MODULE_NAME, BSL_UNIT_UNKNOWN, _BCM_MSG_NO_UNIT("exit"));\ 301 COMPILER_REFERENCE(_rv); 302 303 #if (defined(BCM_DPP_SUPPORT) || defined(BCM_DFE_SUPPORT)) && defined(BCM_GEN_ERR_MECHANISM) 304 #define BCMDNX_IF_ERR_CONT(_rc) \ 305 do { \ 306 int __err__rc = _rc; \ 307 GEN_ERR_CHK(unit, GEN_ERR_TYPE_BCM, __err__rc); \ 308 if(__err__rc != BCM_E_NONE) { \ 309 _bsl_warn(_BSL_BCM_MSG("%s"),bcm_errmsg(__err__rc)); \ 310 _rv = __err__rc; \ 311 } \ 312 } while(0) 313 314 #define BCMDNX_IF_ERR_VERB_EXIT(_rc) \ 315 do { \ 316 int __err__rc = _rc; \ 317 GEN_ERR_CHK(unit, GEN_ERR_TYPE_BCM, __err__rc); \ 318 if(__err__rc != BCM_E_NONE) { \ 319 _bsl_verbose(_BSL_BCM_MSG("%s"),bcm_errmsg(__err__rc)); \ 320 _rv = __err__rc; \ 321 BCM_EXIT; \ 322 } \ 323 } while(0) 324 325 #define BCMDNX_IF_ERR_EXIT(_rc) \ 326 do { \ 327 int __err__rc = _rc; \ 328 GEN_ERR_CHK(unit, GEN_ERR_TYPE_BCM, __err__rc); \ 329 if(__err__rc != BCM_E_NONE) { \ 330 _bsl_error(_BSL_BCM_MSG("%s"),bcm_errmsg(__err__rc)); \ 331 _rv = __err__rc; \ 332 BCM_EXIT; \ 333 } \ 334 } while(0) 335 336 /* meant for use after exit: , In case of error log it and if it is the first error, update _rv */ 337 #define BCMDNX_IF_ERR_REPORT(_rc) \ 338 do { \ 339 int __err__rc = _rc; \ 340 GEN_ERR_CHK(unit, GEN_ERR_TYPE_BCM, __err__rc); \ 341 if(__err__rc != BCM_E_NONE) { \ 342 _bsl_error(_BSL_BCM_MSG("%s"),bcm_errmsg(__err__rc)); \ 343 if (_rv != BCM_E_NONE) _rv = __err__rc; \ 344 } \ 345 } while(0) 346 347 #define BCMDNX_IF_ERR_NOT_UNAVAIL_EXIT(_rc) \ 348 do { \ 349 int __err__rc = _rc; \ 350 GEN_ERR_CHK(unit, GEN_ERR_TYPE_BCM, __err__rc); \ 351 if(__err__rc != BCM_E_NONE && __err__rc != BCM_E_UNAVAIL) { \ 352 _bsl_error(_BSL_BCM_MSG("%s"),bcm_errmsg(__err__rc)); \ 353 _rv = __err__rc; \ 354 BCM_EXIT; \ 355 } \ 356 } while(0) 357 358 #define BCMDNX_IF_ERR_NOT_E_NOT_FOUND_EXIT(_rc) \ 359 do { \ 360 int __err__rc = _rc; \ 361 GEN_ERR_CHK(unit, GEN_ERR_TYPE_BCM, __err__rc); \ 362 if (__err__rc != BCM_E_NONE) { \ 363 if(__err__rc != BCM_E_NOT_FOUND) { \ 364 _bsl_error(_BSL_BCM_MSG("%s"),bcm_errmsg(__err__rc)); \ 365 } \ 366 _rv = __err__rc; \ 367 BCM_EXIT; \ 368 } \ 369 } while(0) 370 #define BCMDNX_IF_ERR_NOT_E_FAIL_EXIT(_rc) \ 371 do { \ 372 int __err__rc = _rc; \ 373 if (__err__rc != BCM_E_NONE) { \ 374 if(__err__rc != BCM_E_FAIL) { \ 375 _bsl_error(_BSL_BCM_MSG("%s"),bcm_errmsg(__err__rc)); \ 376 } else { \ 377 _bsl_verbose(_BSL_BCM_MSG("%s"),bcm_errmsg(__err__rc)); \ 378 }\ 379 _rv = __err__rc; \ 380 BCM_EXIT; \ 381 } \ 382 } while(0) 383 #else 384 #define BCMDNX_IF_ERR_CONT(_rc) \ 385 do { \ 386 int __err__rc = _rc; \ 387 if(__err__rc != BCM_E_NONE) { \ 388 _bsl_warn(_BSL_BCM_MSG("%s"),bcm_errmsg(__err__rc)); \ 389 _rv = __err__rc; \ 390 } \ 391 } while(0) 392 393 #define BCMDNX_IF_ERR_VERB_EXIT(_rc) \ 394 do { \ 395 int __err__rc = _rc; \ 396 if(__err__rc != BCM_E_NONE) { \ 397 _bsl_verbose(_BSL_BCM_MSG("%s"),bcm_errmsg(__err__rc)); \ 398 _rv = __err__rc; \ 399 BCM_EXIT; \ 400 } \ 401 } while(0) 402 #define BCMDNX_IF_ERR_EXIT(_rc) \ 403 do { \ 404 int __err__rc = _rc; \ 405 if(__err__rc != BCM_E_NONE) { \ 406 _bsl_error(_BSL_BCM_MSG("%s"),bcm_errmsg(__err__rc)); \ 407 _rv = __err__rc; \ 408 BCM_EXIT; \ 409 } \ 410 } while(0) 411 /* meant for use after exit: , In case of error log it and if it is the first error, update _rv */ 412 #define BCMDNX_IF_ERR_REPORT(_rc) \ 413 do { \ 414 int __err__rc = _rc; \ 415 if(__err__rc != BCM_E_NONE) { \ 416 _bsl_error(_BSL_BCM_MSG("%s"),bcm_errmsg(__err__rc)); \ 417 if (_rv != BCM_E_NONE) _rv = __err__rc; \ 418 } \ 419 } while(0) 420 421 #define BCMDNX_IF_ERR_NOT_UNAVAIL_EXIT(_rc) \ 422 do { \ 423 int __err__rc = _rc; \ 424 if(__err__rc != BCM_E_NONE && __err__rc != BCM_E_UNAVAIL) { \ 425 _bsl_error(_BSL_BCM_MSG("%s"),bcm_errmsg(__err__rc)); \ 426 _rv = __err__rc; \ 427 BCM_EXIT; \ 428 } \ 429 } while(0) 430 431 #define BCMDNX_IF_ERR_NOT_E_NOT_FOUND_EXIT(_rc) \ 432 do { \ 433 int __err__rc = _rc; \ 434 if (__err__rc != BCM_E_NONE) { \ 435 if(__err__rc != BCM_E_NOT_FOUND) { \ 436 _bsl_error(_BSL_BCM_MSG("%s"),bcm_errmsg(__err__rc)); \ 437 } \ 438 _rv = __err__rc; \ 439 BCM_EXIT; \ 440 } \ 441 } while(0) 442 443 #define BCMDNX_IF_ERR_NOT_E_FAIL_EXIT(_rc) \ 444 do { \ 445 int __err__rc = _rc; \ 446 if (__err__rc != BCM_E_NONE) { \ 447 if(__err__rc != BCM_E_FAIL) { \ 448 _bsl_error(_BSL_BCM_MSG("%s"),bcm_errmsg(__err__rc)); \ 449 } else { \ 450 _bsl_verbose(_BSL_BCM_MSG("%s"),bcm_errmsg(__err__rc)); \ 451 }\ 452 _rv = __err__rc; \ 453 BCM_EXIT; \ 454 } \ 455 } while(0) 456 #endif 457 458 #define BCMDNX_IF_ERR_EXIT_NO_UNIT(_rc) \ 459 do { \ 460 int __err__rc = _rc; \ 461 if(__err__rc != BCM_E_NONE) { \ 462 _bsl_error(_BSL_BCM_MSG_NO_UNIT("%s"),bcm_errmsg(__err__rc)); \ 463 _rv = __err__rc; \ 464 BCM_EXIT; \ 465 } \ 466 } while(0) 467 468 #define BCMDNX_IF_ERR_EXIT_MSG(_rc, stuff) \ 469 do { \ 470 int __err__rc = _rc; \ 471 if(__err__rc != BCM_E_NONE) { \ 472 _bsl_error stuff ; \ 473 _rv = __err__rc; \ 474 BCM_EXIT; \ 475 } \ 476 } while(0) 477 478 #define BCMDNX_ERR_EXIT_MSG(_rc, stuff) \ 479 do { \ 480 _bsl_error stuff ; \ 481 _rv = _rc; \ 482 BCM_EXIT; \ 483 } while(0) 484 485 #define BCMDNX_ERR_EXIT_VERB_MSG(_rc, stuff) \ 486 do { \ 487 _bsl_verbose stuff ; \ 488 _rv = _rc; \ 489 BCM_EXIT; \ 490 } while(0) 491 492 #define BCMDNX_NULL_CHECK(arg) \ 493 do { \ 494 if ((arg) == NULL) \ 495 { BCMDNX_ERR_EXIT_MSG(BCM_E_PARAM,(_BSL_BCM_MSG("null parameter" ))); } \ 496 } while (0) 497 498 #define BCMDNX_NULL_CHECK_NO_UNIT(arg) \ 499 do { \ 500 if ((arg) == NULL) \ 501 { BCMDNX_ERR_EXIT_MSG_NO_UNIT(BCM_E_PARAM,(_BSL_BCM_MSG_NO_UNIT("null parameter" ))); } \ 502 } while (0) 503 504 #define BCMDNX_ALLOC(pointer, mem_size, alloc_comment) \ 505 do { \ 506 if((pointer) == NULL) { \ 507 (pointer) = sal_alloc((mem_size), (alloc_comment)); \ 508 } else {\ 509 BCMDNX_ERR_EXIT_MSG(BCM_E_PARAM,(_BSL_BCM_MSG_NO_UNIT("attempted to allocate to a non NULL pointer: %s"), (alloc_comment))); \ 510 } \ 511 } while (0) 512 513 #define BCMDNX_ALLOC_AND_CLEAR(pointer, mem_size, alloc_comment) \ 514 do { \ 515 if((pointer) == NULL) { \ 516 (pointer) = sal_alloc((mem_size), (alloc_comment)); \ 517 if ((pointer) == NULL) { \ 518 BCMDNX_ERR_EXIT_MSG(BCM_E_MEMORY, (_BSL_BCM_MSG("failed to allocate memory"))); \ 519 } \ 520 sal_memset((pointer), 0x00, mem_size); \ 521 } else {\ 522 BCMDNX_ERR_EXIT_MSG(BCM_E_PARAM,(_BSL_BCM_MSG_NO_UNIT("attempted to allocate to a non NULL pointer: %s"), (alloc_comment))); \ 523 } \ 524 } while (0) 525 526 #ifdef BROADCOM_DEBUG 527 /* If expr is false, then an error will be thrown and the error message will be the expression failed. */ 528 /* This is a version of assert without exit. */ 529 # define BCMDNX_VERIFY(expr) do { if (!(expr)) { BCMDNX_ERR_EXIT_MSG(BCM_E_FAIL, (_ERR_MSG_MODULE_NAME, BSL_UNIT_UNKNOWN, "ASSERTION FAILED (%s:%d): %s\n", __FILE__, __LINE__, #expr)); } } while(0) 530 #else 531 # define BCMDNX_VERIFY(expr) ((void)0) 532 #endif /* BROADCOM_DEBUG */ 533 534 #endif /* __BCM_DEBUG_EX_H__ */