1 // SPDX-License-Identifier: BSD-2-Clause 2 /* 3 * Copyright (c) 2014, STMicroelectronics International N.V. 4 * Copyright (c) 2025, Linaro Limited. 5 */ 6 #include <assert.h> 7 #include <config.h> 8 #include <kernel/dt_driver.h> 9 #include <kernel/linker.h> 10 #include <kernel/panic.h> 11 #include <malloc.h> 12 #include <mm/core_memprot.h> 13 #include <stdbool.h> 14 #include <trace.h> 15 #include <util.h> 16 17 #include "misc.h" 18 19 /* 20 * Enable expect LOG macro to enable/disable self tests traces. 21 * 22 * #define LOG DMSG_RAW 23 * #define LOG(...) 24 */ 25 #define LOG(...) 26 27 static int self_test_add_overflow(void) 28 { 29 uint32_t r_u32; 30 int32_t r_s32; 31 uintmax_t r_um; 32 intmax_t r_sm; 33 34 if (ADD_OVERFLOW(8U, 0U, &r_s32)) 35 return -1; 36 if (r_s32 != 8) 37 return -1; 38 if (ADD_OVERFLOW(32U, 30U, &r_u32)) 39 return -1; 40 if (r_u32 != 62) 41 return -1; 42 if (!ADD_OVERFLOW(UINT32_MAX, UINT32_MAX, &r_u32)) 43 return -1; 44 if (!ADD_OVERFLOW(UINT32_MAX / 2 + 1, UINT32_MAX / 2 + 1, &r_u32)) 45 return -1; 46 if (ADD_OVERFLOW(UINT32_MAX / 2, UINT32_MAX / 2 + 1, &r_u32)) 47 return -1; 48 if (r_u32 != UINT32_MAX) 49 return -1; 50 51 if (ADD_OVERFLOW((uint32_t)30, (int32_t)-31, &r_s32)) 52 return -1; 53 if (r_s32 != -1) 54 return -1; 55 if (ADD_OVERFLOW((int32_t)30, (int32_t)-31, &r_s32)) 56 return -1; 57 if (r_s32 != -1) 58 return -1; 59 if (ADD_OVERFLOW((int32_t)-31, (uint32_t)30, &r_s32)) 60 return -1; 61 if (r_s32 != -1) 62 return -1; 63 64 if (ADD_OVERFLOW(INT32_MIN + 1, -1, &r_s32)) 65 return -1; 66 if (r_s32 != INT32_MIN) 67 return -1; 68 if (!ADD_OVERFLOW(INT32_MIN, -1, &r_s32)) 69 return -1; 70 if (!ADD_OVERFLOW(INT32_MIN + 1, -2, &r_s32)) 71 return -1; 72 if (!ADD_OVERFLOW(INT32_MAX, INT32_MAX, &r_s32)) 73 return -1; 74 if (ADD_OVERFLOW(INT32_MAX, INT32_MAX, &r_u32)) 75 return -1; 76 if (!ADD_OVERFLOW(INTMAX_MAX, INTMAX_MAX, &r_sm)) 77 return -1; 78 if (ADD_OVERFLOW(INTMAX_MAX, INTMAX_MAX, &r_um)) 79 return -1; 80 if (!ADD_OVERFLOW(INT32_MAX / 2 + 1, INT32_MAX / 2 + 1, &r_s32)) 81 return -1; 82 if (ADD_OVERFLOW(INT32_MAX / 2, INT32_MAX / 2 + 1, &r_s32)) 83 return -1; 84 if (r_s32 != INT32_MAX) 85 return -1; 86 87 return 0; 88 } 89 90 static int self_test_sub_overflow(void) 91 { 92 uint32_t r_u32; 93 int32_t r_s32; 94 intmax_t r_sm; 95 96 if (SUB_OVERFLOW(8U, 1U, &r_s32)) 97 return -1; 98 if (r_s32 != 7) 99 return -1; 100 if (SUB_OVERFLOW(32U, 30U, &r_u32)) 101 return -1; 102 if (r_u32 != 2) 103 return -1; 104 if (!SUB_OVERFLOW(30U, 31U, &r_u32)) 105 return -1; 106 107 if (SUB_OVERFLOW(30, 31, &r_s32)) 108 return -1; 109 if (r_s32 != -1) 110 return -1; 111 if (SUB_OVERFLOW(-1, INT32_MAX, &r_s32)) 112 return -1; 113 if (r_s32 != INT32_MIN) 114 return -1; 115 if (!SUB_OVERFLOW(-2, INT32_MAX, &r_s32)) 116 return -1; 117 118 if (SUB_OVERFLOW((uint32_t)30, (int32_t)-31, &r_s32)) 119 return -1; 120 if (r_s32 != 61) 121 return -1; 122 if (SUB_OVERFLOW((int32_t)30, (int32_t)-31, &r_s32)) 123 return -1; 124 if (r_s32 != 61) 125 return -1; 126 if (SUB_OVERFLOW((int32_t)-31, (uint32_t)30, &r_s32)) 127 return -1; 128 if (r_s32 != -61) 129 return -1; 130 if (SUB_OVERFLOW((int32_t)-31, (int32_t)-30, &r_s32)) 131 return -1; 132 if (r_s32 != -1) 133 return -1; 134 135 if (SUB_OVERFLOW((int32_t)31, -(INTMAX_MIN + 1), &r_sm)) 136 return -1; 137 if (r_sm != (INTMAX_MIN + 32)) 138 return -1; 139 140 return 0; 141 } 142 143 static int self_test_mul_unsigned_overflow(void) 144 { 145 const size_t um_half_shift = sizeof(uintmax_t) * 8 / 2; 146 const uintmax_t um_half_mask = UINTMAX_MAX >> um_half_shift; 147 uint32_t r_u32; 148 uintmax_t r_um; 149 150 if (MUL_OVERFLOW(32, 30, &r_u32)) 151 return -1; 152 if (r_u32 != 960) 153 return -1; 154 if (MUL_OVERFLOW(-32, -30, &r_u32)) 155 return -1; 156 if (r_u32 != 960) 157 return -1; 158 159 if (MUL_OVERFLOW(UINTMAX_MAX, 1, &r_um)) 160 return -1; 161 if (r_um != UINTMAX_MAX) 162 return -1; 163 if (MUL_OVERFLOW(UINTMAX_MAX / 4, 4, &r_um)) 164 return -1; 165 if (r_um != (UINTMAX_MAX - 3)) 166 return -1; 167 if (!MUL_OVERFLOW(UINTMAX_MAX / 4 + 1, 4, &r_um)) 168 return -1; 169 if (!MUL_OVERFLOW(UINTMAX_MAX, UINTMAX_MAX, &r_um)) 170 return -1; 171 if (!MUL_OVERFLOW(um_half_mask << um_half_shift, 172 um_half_mask << um_half_shift, &r_um)) 173 return -1; 174 175 return 0; 176 } 177 178 static int self_test_mul_signed_overflow(void) 179 { 180 intmax_t r; 181 182 if (MUL_OVERFLOW(32, -30, &r)) 183 return -1; 184 if (r != -960) 185 return -1; 186 if (MUL_OVERFLOW(-32, 30, &r)) 187 return -1; 188 if (r != -960) 189 return -1; 190 if (MUL_OVERFLOW(32, 30, &r)) 191 return -1; 192 if (r != 960) 193 return -1; 194 195 if (MUL_OVERFLOW(INTMAX_MAX, 1, &r)) 196 return -1; 197 if (r != INTMAX_MAX) 198 return -1; 199 if (MUL_OVERFLOW(INTMAX_MAX / 4, 4, &r)) 200 return -1; 201 if (r != (INTMAX_MAX - 3)) 202 return -1; 203 if (!MUL_OVERFLOW(INTMAX_MAX / 4 + 1, 4, &r)) 204 return -1; 205 if (!MUL_OVERFLOW(INTMAX_MAX, INTMAX_MAX, &r)) 206 return -1; 207 if (MUL_OVERFLOW(INTMAX_MIN + 1, 1, &r)) 208 return -1; 209 if (r != INTMAX_MIN + 1) 210 return -1; 211 if (MUL_OVERFLOW(1, INTMAX_MIN + 1, &r)) 212 return -1; 213 if (r != INTMAX_MIN + 1) 214 return -1; 215 if (MUL_OVERFLOW(0, INTMAX_MIN, &r)) 216 return -1; 217 if (r != 0) 218 return -1; 219 if (MUL_OVERFLOW(1, INTMAX_MIN, &r)) 220 return -1; 221 if (r != INTMAX_MIN) 222 return -1; 223 224 return 0; 225 } 226 227 /* test division support. resulting trace shall be manually checked */ 228 static int self_test_division(void) 229 { 230 signed a, b, c, d; 231 bool r; 232 int ret = 0; 233 234 LOG(""); 235 LOG("division tests (division and modulo):"); 236 /* get some unpredicted values to prevent compilation optimizations: */ 237 /* => use the stack address */ 238 239 LOG("- test with unsigned small integers:"); 240 a = (signed)((unsigned)(vaddr_t)&a & 0xFFFFF); 241 b = (signed)((unsigned)(vaddr_t)&b & 0x00FFF) + 1; 242 c = a / b; 243 d = a % b; 244 r = ((b * c + d) == a); 245 if (!r) 246 ret = -1; 247 LOG(" 0x%08x / 0x%08x = %u / %u = %u = 0x%x)", 248 (unsigned)a, (unsigned)b, (unsigned)a, (unsigned)b, (unsigned)c, 249 (unsigned)c); 250 LOG(" 0x%08x %% 0x%08x = %u %% %u = %u = 0x%x)", (unsigned)a, 251 (unsigned)b, (unsigned)a, (unsigned)b, (unsigned)d, (unsigned)d); 252 LOG(" check results => %s", r ? "ok" : "FAILED !!!"); 253 LOG(""); 254 255 LOG("- test with signed small integers, negative numerator:"); 256 a = (signed)(vaddr_t)&a; 257 b = (signed)((unsigned)(vaddr_t)&b & 0x00FFF) - 1; 258 c = a / b; 259 d = a % b; 260 r = ((b * c + d) == a); 261 if (!r) 262 ret = -1; 263 LOG(" 0x%08x / 0x%08x = %d / %d = %d = 0x%x)", 264 (unsigned)a, (unsigned)b, (signed)a, (signed)b, (signed)c, 265 (unsigned)c); 266 LOG(" 0x%08x %% 0x%08x = %d %% %d = %d = 0x%x)", (unsigned)a, 267 (unsigned)b, (signed)a, (signed)b, (signed)d, (unsigned)d); 268 LOG(" check results => %s", r ? "ok" : "FAILED !!!"); 269 LOG(""); 270 271 LOG("- test with signed small integers, negative denominator:"); 272 a = (signed)((unsigned)(vaddr_t)&a & 0xFFFFF); 273 b = -(signed)((unsigned)(vaddr_t)&b & 0x00FFF) + 1; 274 c = a / b; 275 d = a % b; 276 277 LOG("- test with unsigned integers, big numerator (> 0x80000000):"); 278 a = (signed)(vaddr_t)&a; 279 b = (signed)((unsigned)(vaddr_t)&b & 0x00FFF) + 1; 280 c = (signed)((unsigned)a / (unsigned)b); 281 d = (signed)((unsigned)a % (unsigned)b); 282 r = (((unsigned)b * (unsigned)c + (unsigned)d) == (unsigned)a); 283 if (!r) 284 ret = -1; 285 LOG(" 0x%08x / 0x%08x = %u / %u = %u = 0x%x)", 286 (unsigned)a, (unsigned)b, (unsigned)a, (unsigned)b, (unsigned)c, 287 (unsigned)c); 288 LOG(" 0x%08x %% 0x%08x = %u %% %u = %u = 0x%x)", (unsigned)a, 289 (unsigned)b, (unsigned)a, (unsigned)b, (unsigned)d, (unsigned)d); 290 LOG(" check results => %s", r ? "ok" : "FAILED !!!"); 291 LOG(""); 292 293 LOG("- test with unsigned integers, big num. & denom. (> 0x80000000):"); 294 a = (signed)(vaddr_t)&a; 295 b = (signed)((unsigned)(vaddr_t)&a - 1); 296 c = (signed)((unsigned)a / (unsigned)b); 297 d = (signed)((unsigned)a % (unsigned)b); 298 r = (((unsigned)b * (unsigned)c + (unsigned)d) == (unsigned)a); 299 if (!r) 300 ret = -1; 301 LOG(" 0x%08x / 0x%08x = %u / %u = %u = 0x%x)", 302 (unsigned)a, (unsigned)b, (unsigned)a, (unsigned)b, (unsigned)c, 303 (unsigned)c); 304 LOG(" 0x%08x %% 0x%08x = %u %% %u = %u = 0x%x)", (unsigned)a, 305 (unsigned)b, (unsigned)a, (unsigned)b, (unsigned)d, (unsigned)d); 306 LOG(" check results => %s", r ? "ok" : "FAILED !!!"); 307 LOG(""); 308 309 return ret; 310 } 311 312 /* test malloc support. resulting trace shall be manually checked */ 313 static int self_test_malloc(void) 314 { 315 char *p1 = NULL, *p2 = NULL; 316 int *p3 = NULL, *p4 = NULL; 317 bool r; 318 int ret = 0; 319 320 LOG("malloc tests:"); 321 LOG(" p1=%p p2=%p p3=%p p4=%p", 322 (void *)p1, (void *)p2, (void *)p3, (void *)p4); 323 /* test malloc */ 324 p1 = malloc(1024); 325 LOG("- p1 = malloc(1024)"); 326 p2 = malloc(1024); 327 LOG("- p2 = malloc(1024)"); 328 LOG(" p1=%p p2=%p p3=%p p4=%p", 329 (void *)p1, (void *)p2, (void *)p3, (void *)p4); 330 r = (p1 && p2 && malloc_buffer_is_within_alloced(p1, 1024) && 331 !malloc_buffer_is_within_alloced(p1 + 25, 1000) && 332 !malloc_buffer_is_within_alloced(p1 - 25, 500) && 333 malloc_buffer_overlaps_heap(p1 - 25, 500)); 334 if (!r) 335 ret = -1; 336 LOG(" => test %s", r ? "ok" : "FAILED"); 337 LOG(""); 338 339 /* test realloc */ 340 p3 = realloc(p1, 3 * 1024); 341 if (p3) 342 p1 = NULL; 343 LOG("- p3 = realloc(p1, 3*1024)"); 344 LOG("- free p2"); 345 free(p2); 346 p2 = malloc(1024); 347 LOG("- p2 = malloc(1024)"); 348 LOG(" p1=%p p2=%p p3=%p p4=%p", 349 (void *)p1, (void *)p2, (void *)p3, (void *)p4); 350 r = (p2 && p3); 351 if (!r) 352 ret = -1; 353 LOG(" => test %s", r ? "ok" : "FAILED"); 354 LOG(""); 355 LOG("- free p1, p2, p3"); 356 free(p1); 357 free(p2); 358 free(p3); 359 p1 = NULL; 360 p2 = NULL; 361 p3 = NULL; 362 363 /* test calloc */ 364 p3 = calloc(4, 1024); 365 p4 = calloc(0x100, 1024 * 1024); 366 LOG("- p3 = calloc(4, 1024)"); 367 LOG("- p4 = calloc(0x100, 1024*1024) too big: should fail!"); 368 LOG(" p1=%p p2=%p p3=%p p4=%p", 369 (void *)p1, (void *)p2, (void *)p3, (void *)p4); 370 r = (p3 && !p4); 371 if (!r) 372 ret = -1; 373 LOG(" => test %s", r ? "ok" : "FAILED"); 374 LOG(""); 375 LOG("- free p3, p4"); 376 free(p3); 377 free(p4); 378 p3 = NULL; 379 p4 = NULL; 380 381 /* test memalign */ 382 p3 = memalign(0x1000, 1024); 383 LOG("- p3 = memalign(%d, 1024)", 0x1000); 384 p1 = malloc(1024); 385 LOG("- p1 = malloc(1024)"); 386 p4 = memalign(0x100, 512); 387 LOG("- p4 = memalign(%d, 512)", 0x100); 388 LOG(" p1=%p p2=%p p3=%p p4=%p", 389 (void *)p1, (void *)p2, (void *)p3, (void *)p4); 390 r = (p1 && p3 && p4 && 391 !((vaddr_t)p3 % 0x1000) && !((vaddr_t)p4 % 0x100)); 392 if (!r) 393 ret = -1; 394 LOG(" => test %s", r ? "ok" : "FAILED"); 395 LOG(""); 396 LOG("- free p1, p3, p4"); 397 free(p1); 398 free(p3); 399 free(p4); 400 p1 = NULL; 401 p3 = NULL; 402 p4 = NULL; 403 404 /* test memalign with invalid alignments */ 405 p3 = memalign(100, 1024); 406 LOG("- p3 = memalign(%d, 1024)", 100); 407 p4 = memalign(0, 1024); 408 LOG("- p4 = memalign(%d, 1024)", 0); 409 LOG(" p1=%p p2=%p p3=%p p4=%p", 410 (void *)p1, (void *)p2, (void *)p3, (void *)p4); 411 r = (!p3 && !p4); 412 if (!r) 413 ret = -1; 414 LOG(" => test %s", r ? "ok" : "FAILED"); 415 LOG(""); 416 LOG("- free p3, p4"); 417 free(p3); 418 free(p4); 419 p3 = NULL; 420 p4 = NULL; 421 422 /* test free(NULL) */ 423 LOG("- free NULL"); 424 free(NULL); 425 LOG(""); 426 LOG("malloc test done"); 427 428 return ret; 429 } 430 431 #ifdef CFG_NS_VIRTUALIZATION 432 /* test nex_malloc support. resulting trace shall be manually checked */ 433 static int self_test_nex_malloc(void) 434 { 435 char *p1 = NULL, *p2 = NULL; 436 int *p3 = NULL, *p4 = NULL; 437 bool r; 438 int ret = 0; 439 440 LOG("nex_malloc tests:"); 441 LOG(" p1=%p p2=%p p3=%p p4=%p", 442 (void *)p1, (void *)p2, (void *)p3, (void *)p4); 443 /* test malloc */ 444 p1 = nex_malloc(1024); 445 LOG("- p1 = nex_malloc(1024)"); 446 p2 = nex_malloc(1024); 447 LOG("- p2 = nex_malloc(1024)"); 448 LOG(" p1=%p p2=%p p3=%p p4=%p", 449 (void *)p1, (void *)p2, (void *)p3, (void *)p4); 450 r = (p1 && p2 && nex_malloc_buffer_is_within_alloced(p1, 1024) && 451 !nex_malloc_buffer_is_within_alloced(p1 + 25, 1000) && 452 !nex_malloc_buffer_is_within_alloced(p1 - 25, 500) && 453 nex_malloc_buffer_overlaps_heap(p1 - 25, 500)); 454 if (!r) 455 ret = -1; 456 LOG(" => test %s", r ? "ok" : "FAILED"); 457 LOG(""); 458 459 /* test realloc */ 460 p3 = nex_realloc(p1, 3 * 1024); 461 if (p3) 462 p1 = NULL; 463 LOG("- p3 = nex_realloc(p1, 3*1024)"); 464 LOG("- nex_free p2"); 465 nex_free(p2); 466 p2 = nex_malloc(1024); 467 LOG("- p2 = nex_malloc(1024)"); 468 LOG(" p1=%p p2=%p p3=%p p4=%p", 469 (void *)p1, (void *)p2, (void *)p3, (void *)p4); 470 r = (p2 && p3); 471 if (!r) 472 ret = -1; 473 LOG(" => test %s", r ? "ok" : "FAILED"); 474 LOG(""); 475 LOG("- nex_free p1, p2, p3"); 476 nex_free(p1); 477 nex_free(p2); 478 nex_free(p3); 479 p1 = NULL; 480 p2 = NULL; 481 p3 = NULL; 482 483 /* test calloc */ 484 p3 = nex_calloc(4, 1024); 485 p4 = nex_calloc(0x100, 1024 * 1024); 486 LOG("- p3 = nex_calloc(4, 1024)"); 487 LOG("- p4 = nex_calloc(0x100, 1024*1024) too big: should fail!"); 488 LOG(" p1=%p p2=%p p3=%p p4=%p", 489 (void *)p1, (void *)p2, (void *)p3, (void *)p4); 490 r = (p3 && !p4); 491 if (!r) 492 ret = -1; 493 LOG(" => test %s", r ? "ok" : "FAILED"); 494 LOG(""); 495 LOG("- nex_free p3, p4"); 496 nex_free(p3); 497 nex_free(p4); 498 p3 = NULL; 499 p4 = NULL; 500 501 /* test memalign */ 502 p3 = nex_memalign(0x1000, 1024); 503 LOG("- p3 = nex_memalign(%d, 1024)", 0x1000); 504 p1 = nex_malloc(1024); 505 LOG("- p1 = nex_malloc(1024)"); 506 p4 = nex_memalign(0x100, 512); 507 LOG("- p4 = nex_memalign(%d, 512)", 0x100); 508 LOG(" p1=%p p2=%p p3=%p p4=%p", 509 (void *)p1, (void *)p2, (void *)p3, (void *)p4); 510 r = (p1 && p3 && p4 && 511 !((vaddr_t)p3 % 0x1000) && !((vaddr_t)p4 % 0x100)); 512 if (!r) 513 ret = -1; 514 LOG(" => test %s", r ? "ok" : "FAILED"); 515 LOG(""); 516 LOG("- nex_free p1, p3, p4"); 517 nex_free(p1); 518 nex_free(p3); 519 nex_free(p4); 520 p1 = NULL; 521 p3 = NULL; 522 p4 = NULL; 523 524 /* test memalign with invalid alignments */ 525 p3 = nex_memalign(100, 1024); 526 LOG("- p3 = nex_memalign(%d, 1024)", 100); 527 p4 = nex_memalign(0, 1024); 528 LOG("- p4 = nex_memalign(%d, 1024)", 0); 529 LOG(" p1=%p p2=%p p3=%p p4=%p", 530 (void *)p1, (void *)p2, (void *)p3, (void *)p4); 531 r = (!p3 && !p4); 532 if (!r) 533 ret = -1; 534 LOG(" => test %s", r ? "ok" : "FAILED"); 535 LOG(""); 536 LOG("- nex_free p3, p4"); 537 nex_free(p3); 538 nex_free(p4); 539 p3 = NULL; 540 p4 = NULL; 541 542 /* test free(NULL) */ 543 LOG("- nex_free NULL"); 544 nex_free(NULL); 545 LOG(""); 546 LOG("nex_malloc test done"); 547 548 return ret; 549 } 550 #else /* CFG_NS_VIRTUALIZATION */ 551 static int self_test_nex_malloc(void) 552 { 553 return 0; 554 } 555 #endif 556 557 static int check_virt_to_phys(vaddr_t va, paddr_t exp_pa, 558 enum teecore_memtypes m) 559 { 560 paddr_t pa = 0; 561 void *v = NULL; 562 563 pa = virt_to_phys((void *)va); 564 LOG("virt_to_phys(%#"PRIxVA") => %#"PRIxPA" (expect %#"PRIxPA")", 565 va, pa, exp_pa); 566 if (pa != exp_pa) 567 goto fail; 568 569 if (!exp_pa) 570 return 0; 571 572 v = phys_to_virt(pa, m, 1); 573 LOG("phys_to_virt(%#"PRIxPA") => %p (expect %#"PRIxVA")", 574 pa, v, va); 575 if ((vaddr_t)v != va) 576 goto fail; 577 return 0; 578 579 fail: 580 LOG("Fail"); 581 return -1; 582 } 583 584 static int check_phys_to_virt(paddr_t pa, void *exp_va, 585 enum teecore_memtypes m) 586 { 587 paddr_t new_pa = 0; 588 void *v = NULL; 589 590 v = phys_to_virt(pa, m, 1); 591 LOG("phys_to_virt(%#"PRIxPA") => %p (expect %p)", 592 pa, v, exp_va); 593 if (v != exp_va) 594 goto fail; 595 596 if (!exp_va) 597 return 0; 598 599 new_pa = virt_to_phys(v); 600 LOG("virt_to_phys(%p) => %#"PRIxPA" (expect %#"PRIxPA")", 601 v, new_pa, pa); 602 if (new_pa != pa) 603 goto fail; 604 return 0; 605 606 fail: 607 LOG("Fail"); 608 return -1; 609 } 610 611 static int self_test_va2pa(void) 612 { 613 void *ptr = self_test_va2pa; 614 int ret = 0; 615 616 if (IS_ENABLED(CFG_DYN_CONFIG) && VCORE_FREE_SZ) { 617 vaddr_t va_base = VCORE_FREE_PA; 618 paddr_t pa_base = 0; 619 620 pa_base = virt_to_phys((void *)va_base); 621 if (!pa_base) { 622 LOG("virt_to_phys(%#"PRIxVA") => 0 Fail!", va_base); 623 return -1; 624 } 625 626 /* 627 * boot_mem_release_unused() and 628 * boot_mem_release_tmp_alloc() has been called during 629 * boot. 630 * 631 * First pages of VCORE_FREE are expected to be allocated 632 * with boot_mem_alloc() while the end of VCORE_FREE should 633 * have been freed by the two mentioned release functions. 634 */ 635 if (check_virt_to_phys(va_base, pa_base, MEM_AREA_TEE_RAM)) 636 ret = -1; 637 if (check_virt_to_phys(va_base + 16, pa_base + 16, 638 MEM_AREA_TEE_RAM)) 639 ret = -1; 640 if (check_virt_to_phys(va_base + VCORE_FREE_SZ - 641 SMALL_PAGE_SIZE, 0, MEM_AREA_TEE_RAM)) 642 ret = -1; 643 if (check_virt_to_phys(va_base + VCORE_FREE_SZ - 16, 0, 644 MEM_AREA_TEE_RAM)) 645 ret = -1; 646 } 647 648 if (!IS_ENABLED(CFG_WITH_PAGER) && 649 check_phys_to_virt(virt_to_phys(ptr), ptr, MEM_AREA_TEE_RAM)) 650 ret = -1; 651 if (check_phys_to_virt(virt_to_phys(ptr), NULL, MEM_AREA_IO_SEC)) 652 ret = -1; 653 if (check_virt_to_phys(0, 0, MEM_AREA_TEE_RAM)) 654 ret = -1; 655 if (check_phys_to_virt(0, NULL, MEM_AREA_TEE_RAM)) 656 ret = -1; 657 658 return ret; 659 } 660 661 /* exported entry points for some basic test */ 662 TEE_Result core_self_tests(uint32_t nParamTypes __unused, 663 TEE_Param pParams[TEE_NUM_PARAMS] __unused) 664 { 665 if (self_test_mul_signed_overflow() || self_test_add_overflow() || 666 self_test_sub_overflow() || self_test_mul_unsigned_overflow() || 667 self_test_division() || self_test_malloc() || 668 self_test_nex_malloc() || self_test_va2pa()) { 669 EMSG("some self_test_xxx failed! you should enable local LOG"); 670 return TEE_ERROR_GENERIC; 671 } 672 return TEE_SUCCESS; 673 } 674 675 /* Exported entrypoint for dt_driver tests */ 676 TEE_Result core_dt_driver_tests(uint32_t nParamTypes __unused, 677 TEE_Param pParams[TEE_NUM_PARAMS] __unused) 678 { 679 if (IS_ENABLED(CFG_DT_DRIVER_EMBEDDED_TEST)) { 680 if (dt_driver_test_status()) 681 return TEE_ERROR_GENERIC; 682 } else { 683 IMSG("dt_driver tests are not embedded"); 684 } 685 686 return TEE_SUCCESS; 687 } 688