已合并
fix: ASCEND_WORK_PATH路径过长，trace模块报错 (#769) #3903
GuoWenbo创建于 7月28日
fix: ASCEND_WORK_PATH路径过长，trace模块报错 (#769) #3903
已合并
共 6 个文件变更+509-124
| @@ -13,6 +13,7 @@ | |||
| 13 | 13 | ||
| 14 | 14 | ||
| 15 | 15 | ||
| 16 | + | ||
| 16 | 17 | ||
| 17 | 18 | ||
| 18 | 19 | ||
| @@ -364,22 +365,84 @@ STATIC void TraceRecorderSaveNode(const TraceDirInfo *dirInfo, TraceDirNode *dir | |||
| 364 | TraceRecorderListAppend(dirList, dirNew); | 365 | TraceRecorderListAppend(dirList, dirNew); |
| 365 | } | 366 | } |
| 366 | 367 | ||
| 367 | -STATIC TraStatus TraceRecorderCreateDirWithCheck(const char *path) | 368 | +STATIC TraStatus TraceRecorderCreateDirWithCheck(const char *path, int32_t *errCode) |
| 368 | { | 369 | { |
| 369 | TraStatus ret = TraceMkdir(path, TRACE_DIR_MODE, TraceAttrGetUid(), TraceAttrGetGid()); | 370 | TraStatus ret = TraceMkdir(path, TRACE_DIR_MODE, TraceAttrGetUid(), TraceAttrGetGid()); |
| 370 | if (ret != TRACE_SUCCESS) { | 371 | if (ret != TRACE_SUCCESS) { |
| 371 | - ADIAG_ERR("mkdir %s failed, strerr=%s.", path, strerror(AdiagGetErrorCode())); | 372 | + int32_t code = AdiagGetErrorCode(); |
| 373 | + if (errCode != NULL) { | ||
| 374 | + *errCode = code; | ||
| 375 | + } | ||
| 376 | + ADIAG_ERR("mkdir %s failed, strerr=%s.", path, strerror(code)); | ||
| 372 | return TRACE_FAILURE; | 377 | return TRACE_FAILURE; |
| 373 | } | 378 | } |
| 374 | return ret; | 379 | return ret; |
| 375 | } | 380 | } |
| 376 | 381 | ||
| 382 | +STATIC void TraceRecorderLogBuildFailure(const char *label, const char *stage, const TraceDirInfo *dirInfo, | ||
| 383 | + int32_t errCode) | ||
| 384 | +{ | ||
| 385 | + ADIAG_ERR("create trace %s failed, stage=%s, reason=snprintf_s, rootPath=%s, " | ||
| 386 | + "eventName=%s, pid=%d, dirTime=%s, limit=%zu, strerr=%s.", | ||
| 387 | + label, stage, g_recorderMgr->rootPath, dirInfo->eventName, dirInfo->pid, dirInfo->dirTime, | ||
| 388 | + (size_t)MAX_FILEPATH_LEN, strerror(errCode)); | ||
| 389 | +} | ||
| 390 | + | ||
| 391 | +STATIC void TraceRecorderLogMkdirFailure(const char *label, const char *stage, const char *dirPath, int32_t errCode) | ||
| 392 | +{ | ||
| 393 | + ADIAG_ERR("create trace %s failed, stage=%s, reason=mkdir, " | ||
 | |||
| 394 | + "rootPath=%s, dirPath=%s, dirPathLen=%zu, limit=%zu, strerr=%s.", | ||
| 395 | + label, stage, g_recorderMgr->rootPath, dirPath, strlen(dirPath), | ||
| 396 | + (size_t)MAX_FILEPATH_LEN, strerror(errCode)); | ||
| 397 | +} | ||
| 398 | + | ||
| 399 | +STATIC TraStatus TraceRecorderCreateRootDir(void) | ||
| 400 | +{ | ||
| 401 | + TraStatus ret = TraceMkdir(g_recorderMgr->rootPath, TRACE_DIR_MODE, TraceAttrGetUid(), TraceAttrGetGid()); | ||
| 402 | + if (ret != TRACE_SUCCESS) { | ||
| 403 | + int32_t errCode = AdiagGetErrorCode(); | ||
| 404 | + ADIAG_ERR("create trace root directory failed, stage=root_dir, reason=mkdir, " | ||
| 405 | + "rootPath=%s, rootPathLen=%zu, limit=%zu, strerr=%s.", | ||
| 406 | + g_recorderMgr->rootPath, strlen(g_recorderMgr->rootPath), (size_t)MAX_FILEPATH_LEN, | ||
| 407 | + strerror(errCode)); | ||
| 408 | + return TRACE_FAILURE; | ||
| 409 | + } | ||
| 410 | + return TRACE_SUCCESS; | ||
| 411 | +} | ||
| 412 | + | ||
| 413 | +STATIC TraStatus TraceRecorderCreateFormattedDir(TraceDirNode *dirNew, const char *label, const char *stage, | ||
| 414 | + const TraceDirInfo *dirInfo, const char *format, ...) | ||
| 415 | +{ | ||
| 416 | + va_list args; | ||
| 417 | + va_start(args, format); | ||
| 418 | + int32_t ret = vsnprintf_s(dirNew->dirPath, MAX_FILEPATH_LEN + 1U, MAX_FILEPATH_LEN, format, args); | ||
| 419 | + va_end(args); | ||
| 420 | + if (ret == -1) { | ||
| 421 | + int32_t errCode = AdiagGetErrorCode(); | ||
| 422 | + TraceRecorderLogBuildFailure(label, stage, dirInfo, errCode); | ||
| 423 | + return TRACE_FAILURE; | ||
| 424 | + } | ||
| 425 | + int32_t errCode = 0; | ||
| 426 | + if (TraceRecorderCreateDirWithCheck(dirNew->dirPath, &errCode) != TRACE_SUCCESS) { | ||
| 427 | + TraceRecorderLogMkdirFailure(label, stage, dirNew->dirPath, errCode); | ||
| 428 | + return TRACE_FAILURE; | ||
| 429 | + } | ||
| 430 | + return TRACE_SUCCESS; | ||
| 431 | +} | ||
| 432 | + | ||
| 433 | +STATIC TraceDirNode *TraceRecorderFindExistingDir(const TraceDirInfo *dirInfo, TraceDirNode *dirNew) | ||
| 434 | +{ | ||
| 435 | + if (strncmp(dirInfo->eventName, TRACER_EVENT_EXIT, strlen(TRACER_EVENT_EXIT)) == 0) { | ||
| 436 | + return NULL; | ||
| 437 | + } | ||
| 438 | + TraceDirList *dirList = (dirInfo->isDevice) ? &g_recorderMgr->deviceDirList : &g_recorderMgr->hostDirList; | ||
| 439 | + return TraceRecorderListFind(dirList, dirNew->dirPath); | ||
| 440 | +} | ||
| 441 | + | ||
| 377 | const TraceDirNode *TraceRecorderGetDirPath(const TraceDirInfo *dirInfo) | 442 | const TraceDirNode *TraceRecorderGetDirPath(const TraceDirInfo *dirInfo) |
| 378 | { | 443 | { |
| 379 | // ~/ascend | 444 | // ~/ascend |
| 380 | - int32_t ret = TraceMkdir(g_recorderMgr->rootPath, TRACE_DIR_MODE, TraceAttrGetUid(), TraceAttrGetGid()); | 445 | + if (TraceRecorderCreateRootDir() != TRACE_SUCCESS) { |
| 381 | - if (ret != TRACE_SUCCESS) { | ||
| 382 | - ADIAG_ERR("mkdir %s failed, strerr=%s.", g_recorderMgr->rootPath, strerror(AdiagGetErrorCode())); | ||
| 383 | return NULL; | 446 | return NULL; |
| 384 | } | 447 | } |
| 385 | 448 | ||
| @@ -387,46 +450,39 @@ const TraceDirNode *TraceRecorderGetDirPath(const TraceDirInfo *dirInfo) | |||
| 387 | ADIAG_CHK_EXPR_ACTION(dirNew == NULL, return NULL, "create dir failed."); | 450 | ADIAG_CHK_EXPR_ACTION(dirNew == NULL, return NULL, "create dir failed."); |
| 388 | 451 | ||
| 389 | // ~/ascend/atrace | 452 | // ~/ascend/atrace |
| 390 | - ret = snprintf_s(dirNew->dirPath, MAX_FILEPATH_LEN + 1U, MAX_FILEPATH_LEN, "%s/%s", | 453 | + if (TraceRecorderCreateFormattedDir(dirNew, "atrace directory", "atrace_dir", dirInfo, "%s/%s", |
| 391 | - g_recorderMgr->rootPath, TRACE_FILE_SUB_PATH); | 454 | + g_recorderMgr->rootPath, TRACE_FILE_SUB_PATH) != TRACE_SUCCESS) { |
| 392 | - if ((ret == -1) || (TraceRecorderCreateDirWithCheck(dirNew->dirPath) != TRACE_SUCCESS)) { | 455 | + goto failed; |
| 393 | - ADIAG_ERR("failed at atrace directory, strerr=%s.", strerror(AdiagGetErrorCode())); | ||
| 394 | - ADIAG_SAFE_FREE(dirNew); | ||
| 395 | - return NULL; | ||
| 396 | } | 456 | } |
| 397 | 457 | ||
| 398 | // ~/ascend/atrace/trace_{attr_group_id}_{attr_pid}_{attr_time} | 458 | // ~/ascend/atrace/trace_{attr_group_id}_{attr_pid}_{attr_time} |
| 399 | - ret = snprintf_s(dirNew->dirPath, MAX_FILEPATH_LEN + 1U, MAX_FILEPATH_LEN, "%s/%s/%s_%d_%d_%s", | 459 | + if (TraceRecorderCreateFormattedDir(dirNew, "first directory", "first_trace_dir", dirInfo, "%s/%s/%s_%d_%d_%s", |
| 400 | g_recorderMgr->rootPath, TRACE_FILE_SUB_PATH, | 460 | g_recorderMgr->rootPath, TRACE_FILE_SUB_PATH, |
| 401 | - TRACE_DIR_HEAD, TraceAttrGetPgid(), TraceAttrGetPid(), TraceAttrGetTime()); | 461 | + TRACE_DIR_HEAD, TraceAttrGetPgid(), TraceAttrGetPid(), TraceAttrGetTime()) != TRACE_SUCCESS) { |
| 402 | - if ((ret == -1) || (TraceRecorderCreateDirWithCheck(dirNew->dirPath) != TRACE_SUCCESS)) { | 462 | + goto failed; |
| 403 | - ADIAG_ERR("failed at first directory, strerr=%s.", strerror(AdiagGetErrorCode())); | ||
| 404 | - ADIAG_SAFE_FREE(dirNew); | ||
| 405 | - return NULL; | ||
| 406 | } | 463 | } |
| 407 | 464 | ||
| 408 | // ~/ascend/atrace/trace_{attr_group_id}_{attr_pid}_{attr_time}/{tracer_name}_event_{pid}_time | 465 | // ~/ascend/atrace/trace_{attr_group_id}_{attr_pid}_{attr_time}/{tracer_name}_event_{pid}_time |
| 409 | - ret = snprintf_s(dirNew->dirPath, MAX_FILEPATH_LEN + 1U, MAX_FILEPATH_LEN, "%s/%s/%s_%d_%d_%s/%s_event_%d_%s", | 466 | + if (TraceRecorderCreateFormattedDir(dirNew, "second directory", "second_event_dir", dirInfo, |
| 467 | + "%s/%s/%s_%d_%d_%s/%s_event_%d_%s", | ||
| 410 | g_recorderMgr->rootPath, TRACE_FILE_SUB_PATH, | 468 | g_recorderMgr->rootPath, TRACE_FILE_SUB_PATH, |
| 411 | TRACE_DIR_HEAD, TraceAttrGetPgid(), TraceAttrGetPid(), TraceAttrGetTime(), | 469 | TRACE_DIR_HEAD, TraceAttrGetPgid(), TraceAttrGetPid(), TraceAttrGetTime(), |
| 412 | - dirInfo->eventName,dirInfo->pid, dirInfo->dirTime); | 470 | + dirInfo->eventName, dirInfo->pid, dirInfo->dirTime) != TRACE_SUCCESS) { |
| 413 | - if ((ret == -1) || (TraceRecorderCreateDirWithCheck(dirNew->dirPath) != TRACE_SUCCESS)) { | 471 | + goto failed; |
| 414 | - ADIAG_ERR("failed at second directory, strerr=%s.", strerror(AdiagGetErrorCode())); | ||
| 415 | - ADIAG_SAFE_FREE(dirNew); | ||
| 416 | - return NULL; | ||
| 417 | } | 472 | } |
| 418 | 473 | ||
| 419 | - if (strncmp(dirInfo->eventName, TRACER_EVENT_EXIT, strlen(TRACER_EVENT_EXIT)) != 0) { | 474 | + TraceDirNode *existNode = TraceRecorderFindExistingDir(dirInfo, dirNew); |
| 420 | - TraceDirList *dirList = (dirInfo->isDevice) ? &g_recorderMgr->deviceDirList : &g_recorderMgr->hostDirList; | 475 | + if (existNode != NULL) { |
| 421 | - TraceDirNode *existNode = TraceRecorderListFind(dirList, dirNew->dirPath); | 476 | + ADIAG_SAFE_FREE(dirNew); |
| 422 | - if (existNode != NULL) { | 477 | + return existNode; |
| 423 | - ADIAG_SAFE_FREE(dirNew); | ||
| 424 | - return existNode; | ||
| 425 | - } | ||
| 426 | } | 478 | } |
| 427 | 479 | ||
| 428 | TraceRecorderSaveNode(dirInfo, dirNew); | 480 | TraceRecorderSaveNode(dirInfo, dirNew); |
| 429 | return dirNew; | 481 | return dirNew; |
| 482 | + | ||
| 483 | +failed: | ||
| 484 | + ADIAG_SAFE_FREE(dirNew); | ||
| 485 | + return NULL; | ||
| 430 | } | 486 | } |
| 431 | 487 | ||
| 432 | TraStatus TraceRecorderGetFd(const TraceDirInfo *dirInfo, const TraceFileInfo *fileInfo, int32_t *fd) | 488 | TraStatus TraceRecorderGetFd(const TraceDirInfo *dirInfo, const TraceFileInfo *fileInfo, int32_t *fd) |
| @@ -470,16 +526,17 @@ TraStatus TraceRecorderWrite(int32_t fd, const char *msg, uint32_t len) | |||
| 470 | return TRACE_SUCCESS; | 526 | return TRACE_SUCCESS; |
| 471 | } | 527 | } |
| 472 | 528 | ||
| 473 | -TraStatus TraceRecorderSafeMkdirPath(const TraceDirInfo *dirInfo) | 529 | +STATIC TraStatus TraceRecorderSafeMkdirPathWithBuffer(const TraceDirInfo *dirInfo, char *path, size_t len) |
| 474 | { | 530 | { |
| 531 | + if ((path == NULL) || (len == 0)) { | ||
| 532 | + return TRACE_INVALID_PARAM; | ||
| 533 | + } | ||
| 475 | int32_t ret = TraceMkdir(g_recorderMgr->rootPath, TRACE_DIR_MODE, TraceAttrGetUid(), TraceAttrGetGid()); | 534 | int32_t ret = TraceMkdir(g_recorderMgr->rootPath, TRACE_DIR_MODE, TraceAttrGetUid(), TraceAttrGetGid()); |
| 476 | if (ret != TRACE_SUCCESS) { | 535 | if (ret != TRACE_SUCCESS) { |
| 477 | return TRACE_FAILURE; | 536 | return TRACE_FAILURE; |
| 478 | } | 537 | } |
| 479 | 538 | ||
| 480 | - char path[MAX_FULLPATH_LEN + 1U] = { 0 }; | 539 | + ret = snprintf_s(path, len, len - 1U, "%s/%s", g_recorderMgr->rootPath, TRACE_FILE_SUB_PATH); |
| 481 | - ret = snprintf_s(path, MAX_FULLPATH_LEN + 1U, MAX_FULLPATH_LEN, "%s/%s", | ||
| 482 | - g_recorderMgr->rootPath, TRACE_FILE_SUB_PATH); | ||
| 483 | if (ret == -1) { | 540 | if (ret == -1) { |
| 484 | return TRACE_FAILURE; | 541 | return TRACE_FAILURE; |
| 485 | } | 542 | } |
| @@ -488,7 +545,7 @@ TraStatus TraceRecorderSafeMkdirPath(const TraceDirInfo *dirInfo) | |||
| 488 | return TRACE_FAILURE; | 545 | return TRACE_FAILURE; |
| 489 | } | 546 | } |
| 490 | 547 | ||
| 491 | - ret = snprintf_s(path, MAX_FULLPATH_LEN + 1U, MAX_FULLPATH_LEN, "%s/%s/%s_%d_%d_%s", | 548 | + ret = snprintf_s(path, len, len - 1U, "%s/%s/%s_%d_%d_%s", |
| 492 | g_recorderMgr->rootPath, TRACE_FILE_SUB_PATH, | 549 | g_recorderMgr->rootPath, TRACE_FILE_SUB_PATH, |
| 493 | TRACE_DIR_HEAD, TraceAttrGetPgid(), TraceAttrGetPid(), TraceAttrGetTime()); | 550 | TRACE_DIR_HEAD, TraceAttrGetPgid(), TraceAttrGetPid(), TraceAttrGetTime()); |
| 494 | if (ret == -1) { | 551 | if (ret == -1) { |
| @@ -499,7 +556,7 @@ TraStatus TraceRecorderSafeMkdirPath(const TraceDirInfo *dirInfo) | |||
| 499 | return TRACE_FAILURE; | 556 | return TRACE_FAILURE; |
| 500 | } | 557 | } |
| 501 | 558 | ||
| 502 | - ret = TraceRecorderSafeGetDirPath(dirInfo, path, MAX_FULLPATH_LEN + 1U); | 559 | + ret = TraceRecorderSafeGetDirPath(dirInfo, path, len); |
| 503 | if (ret != TRACE_SUCCESS) { | 560 | if (ret != TRACE_SUCCESS) { |
| 504 | return TRACE_FAILURE; | 561 | return TRACE_FAILURE; |
| 505 | } | 562 | } |
| @@ -510,6 +567,12 @@ TraStatus TraceRecorderSafeMkdirPath(const TraceDirInfo *dirInfo) | |||
| 510 | return TRACE_SUCCESS; | 567 | return TRACE_SUCCESS; |
| 511 | } | 568 | } |
| 512 | 569 | ||
| 570 | +TraStatus TraceRecorderSafeMkdirPath(const TraceDirInfo *dirInfo) | ||
| 571 | +{ | ||
| 572 | + char path[MAX_FULLPATH_LEN + 1U] = { 0 }; | ||
| 573 | + return TraceRecorderSafeMkdirPathWithBuffer(dirInfo, path, MAX_FULLPATH_LEN + 1U); | ||
| 574 | +} | ||
| 575 | + | ||
| 513 | TraStatus TraceRecorderSafeGetDirPath(const TraceDirInfo *dirInfo, char *path, size_t len) | 576 | TraStatus TraceRecorderSafeGetDirPath(const TraceDirInfo *dirInfo, char *path, size_t len) |
| 514 | { | 577 | { |
| 515 | if ((dirInfo == NULL) || (path == NULL) || (len == 0)) { | 578 | if ((dirInfo == NULL) || (path == NULL) || (len == 0)) { |
| @@ -540,28 +603,23 @@ TraStatus TraceRecorderSafeGetFd(const TraceDirInfo *dirInfo, const TraceFileInf | |||
| 540 | } | 603 | } |
| 541 | 604 | ||
| 542 | char path[MAX_FULLPATH_LEN + 1U] = { 0 }; | 605 | char path[MAX_FULLPATH_LEN + 1U] = { 0 }; |
| 543 | - TraStatus ret = TraceRecorderSafeGetDirPath(dirInfo, path, MAX_FULLPATH_LEN + 1U); | 606 | + TraStatus ret = TraceRecorderSafeMkdirPathWithBuffer(dirInfo, path, MAX_FULLPATH_LEN + 1U); |
| 544 | if (ret != TRACE_SUCCESS) { | 607 | if (ret != TRACE_SUCCESS) { |
| 545 | return ret; | 608 | return ret; |
| 546 | } | 609 | } |
| 547 | 610 | ||
| 548 | - ret = TraceRecorderSafeMkdirPath(dirInfo); | 611 | + size_t pathLen = strlen(path); |
| 549 | - if (ret != TRACE_SUCCESS) { | 612 | + if (pathLen >= MAX_FULLPATH_LEN) { |
| 550 | - return ret; | 613 | + return TRACE_FAILURE; |
| 551 | } | 614 | } |
| 552 | - | 615 | + ret = snprintf_s(path + pathLen, MAX_FULLPATH_LEN + 1U - pathLen, MAX_FULLPATH_LEN - pathLen, |
| 553 | - char tmp[MAX_FILEDIR_LEN] = { 0 }; | 616 | + "/%s_tracer_%s%s", |
| 554 | - ret = snprintf_s(tmp, MAX_FILEDIR_LEN, MAX_FULLPATH_LEN - 1U, "/%s_tracer_%s%s", | ||
| 555 | fileInfo->tracerName, fileInfo->objName, fileInfo->suffix); | 617 | fileInfo->tracerName, fileInfo->objName, fileInfo->suffix); |
| 556 | if (ret == -1) { | 618 | if (ret == -1) { |
| 557 | return TRACE_FAILURE; | 619 | return TRACE_FAILURE; |
| 558 | } | 620 | } |
| 559 | - errno_t err = strncat_s(path, MAX_FULLPATH_LEN + 1U, tmp, strlen(tmp)); | ||
| 560 | - if (err != EOK) { | ||
| 561 | - return TRACE_FAILURE; | ||
| 562 | - } | ||
| 563 | 621 | ||
| 564 | - err = strncpy_s(g_recorderMgr->corePath, MAX_FULLPATH_LEN + 1U, path, strlen(path)); | 622 | + errno_t err = strncpy_s(g_recorderMgr->corePath, MAX_FULLPATH_LEN + 1U, path, strlen(path)); |
| 565 | if (err != EOK) { | 623 | if (err != EOK) { |
| 566 | return TRACE_FAILURE; | 624 | return TRACE_FAILURE; |
| 567 | } | 625 | } |
| @@ -13,6 +13,7 @@ | |||
| 13 | 13 | ||
| 14 | 14 | ||
| 15 | 15 | ||
| 16 | + | ||
| 16 | 17 | ||
| 17 | 18 | ||
| 18 | extern "C" { | 19 | extern "C" { |
| @@ -28,9 +29,18 @@ enum { | |||
| 28 | // file length | 29 | // file length |
| 29 | 30 | ||
| 30 | 31 | ||
J 问题：将 MAX_FILEDIR_LEN、MAX_FILEPATH_LEN、MAX_FULLPATH_LEN 都设为 TRACE_MAX_PATH - 1U 后，rootPath 本身可以接近系统路径上限，但后续 TraceRecorderGetDirPath 还会继续拼接 /atrace、trace_* 和 event，TraceRecorderGetFd 还会继续拼接文件名。这样 TraceRecorderInit 可能接受一个合法存在但已接近 PATH_MAX 的 ASCEND_WORK_PATH，随后所有 trace 目录或文件路径构造都会因超长失败。
  | |||
| 31 | -#define MAX_FILEDIR_LEN 255U | 32 | +#define MAX_FULLPATH_LEN (TRACE_MAX_PATH - 1U) |
| 32 | -#define MAX_FILEPATH_LEN (MAX_FILEDIR_LEN + MAX_NAME_HEAD_LEN) | 33 | +#define TRACE_RECORDER_INT32_MAX_LEN 11U |
| 33 | -#define MAX_FULLPATH_LEN (MAX_FILEPATH_LEN + MAX_FILENAME_LEN) | 34 | +#define TRACE_RECORDER_TIMESTAMP_MAX_LEN 28U |
| 35 | + | ||
| 36 | + | ||
| 37 | + | ||
| 38 | + (TRACE_RECORDER_INT32_MAX_LEN * 3U) + (TRACE_RECORDER_TIMESTAMP_MAX_LEN * 2U) + \ | ||
| 39 | + (MAX_FILENAME_LEN * 4U)) | ||
级别：一般 问题：MAX_FILEPATH_LEN 与 MAX_FULLPATH_LEN 均被定义为 (TRACE_MAX_PATH - 1U),二者完全相等,语义上"目录路径最大长度"与"完整文件路径最大长度"的区分丢失。 影响：后续维护者若以 MAX_FILEPATH_LEN 作为目录路径缓冲区大小、再向其尾部拼接文件名,可能越界;同时不利于静态分析与代码审查发现潜在溢出。 修复建议：保留二者语义差异,例如令 MAX_FULLPATH_LEN = MAX_FILEPATH_LEN + MAX_FILENAME_LEN,或在头文件中加注释明确说明二者相等的约束前提(MAX_FILEDIR_LEN 已做预留)。 | |||
| 40 | + | ||
| 41 | + (MAX_FULLPATH_LEN - TRACE_RECORDER_FILE_RESERVED_LEN) : 0U) | ||
| 42 | + | ||
| 43 | + (MAX_FULLPATH_LEN - TRACE_RECORDER_ROOT_RESERVED_LEN) : 0U) | ||
| 34 | 44 | ||
| 35 | 45 | ||
| 36 | typedef struct { | 46 | typedef struct { |
| @@ -84,4 +94,4 @@ const char* TraceRecorderSafeGetFilePath(void); | |||
| 84 | 94 | ||
| 85 | } | 95 | } |
| 86 | 96 | ||
| 87 | -#endif | 97 | +#endif |
| @@ -15,6 +15,7 @@ | |||
| 15 | 15 | ||
| 16 | 16 | ||
| 17 | 17 | ||
| 18 | + | ||
| 18 | 19 | ||
| 19 | 20 | ||
| 20 | 21 | ||
| @@ -24,9 +25,12 @@ | |||
| 24 | 25 | ||
| 25 | 26 | ||
| 26 | 27 | ||
| 27 | -#define SCD_MAX_FILEDIR_LEN 255U | 28 | +#define SCD_MAX_FULLPATH_LEN (TRACE_MAX_PATH - 1U) |
| 28 | -#define SCD_MAX_FILEPATH_LEN (SCD_MAX_FILEDIR_LEN + SCD_MAX_NAME_HEAD_LEN) | 29 | +#define SCD_FILE_SUFFIX_MAX_LEN 4U |
| 29 | -#define SCD_MAX_FULLPATH_LEN (SCD_MAX_FILEPATH_LEN + SCD_MAX_FILENAME_LEN) | 30 | +#define SCD_FILE_RESERVED_LEN (1U + SCD_MAX_FILENAME_LEN + SCD_FILE_SUFFIX_MAX_LEN) |
| 31 | + | ||
| 32 | + (SCD_MAX_FULLPATH_LEN - SCD_FILE_RESERVED_LEN) : 0U) | ||
| 33 | + | ||
| 30 | 34 | ||
| 31 | /* | 35 | /* |
| 32 | * [parent process] ---fork---> [child process] ---execv---> [new process] | 36 | * [parent process] ---fork---> [child process] ---execv---> [new process] |
| @@ -74,18 +74,27 @@ protected: | |||
| 74 | } | 74 | } |
| 75 | }; | 75 | }; |
| 76 | 76 | ||
| 77 | -TEST_F(TraceStackcoreUtest, TraceStackInfoInit_failed) | 77 | +TEST_F(TraceStackcoreUtest, TraceStackInfoInit_failed) |
| 78 | -{ | 78 | +{ |
| 79 | MOCKER(mmCreateTaskWithThreadAttr).stubs().will(returnValue(-1)); | 79 | MOCKER(mmCreateTaskWithThreadAttr).stubs().will(returnValue(-1)); |
| 80 | MOCKER(pthread_getattr_np).stubs().will(returnValue(-1)); | 80 | MOCKER(pthread_getattr_np).stubs().will(returnValue(-1)); |
| 81 | TraceExit(); | 81 | TraceExit(); |
| 82 | TraceInit(); | 82 | TraceInit(); |
| 83 | auto ret = TraceGetStackBaseAddr(); | 83 | auto ret = TraceGetStackBaseAddr(); |
| 84 | - EXPECT_EQ(0, ret); | 84 | + EXPECT_EQ(0, ret); |
| 85 | -} | 85 | +} |
| 86 | - | 86 | + |
| 87 | -TEST_F(TraceStackcoreUtest, TestTraceStackFp_failed) | 87 | +TEST_F(TraceStackcoreUtest, TestStacktracePathLimitsUseTraceMaxPath) |
| 88 | -{ | 88 | +{ |
| 89 | + EXPECT_LT(static_cast<size_t>(SCD_MAX_FILEDIR_LEN), static_cast<size_t>(SCD_MAX_FULLPATH_LEN)); | ||
| 90 | + EXPECT_LT(static_cast<size_t>(SCD_MAX_FILEPATH_LEN), static_cast<size_t>(SCD_MAX_FULLPATH_LEN)); | ||
| 91 | + EXPECT_LE(static_cast<size_t>(SCD_MAX_FILEPATH_LEN) + static_cast<size_t>(SCD_FILE_RESERVED_LEN), | ||
| 92 | + static_cast<size_t>(SCD_MAX_FULLPATH_LEN)); | ||
| 93 | + EXPECT_EQ(static_cast<size_t>(TRACE_MAX_PATH - 1U), static_cast<size_t>(SCD_MAX_FULLPATH_LEN)); | ||
| 94 | +} | ||
| 95 | + | ||
| 96 | +TEST_F(TraceStackcoreUtest, TestTraceStackFp_failed) | ||
| 97 | +{ | ||
| 89 | TraStatus ret = TRACE_FAILURE; | 98 | TraStatus ret = TRACE_FAILURE; |
| 90 | ThreadArgument arg = { 0 }; | 99 | ThreadArgument arg = { 0 }; |
| 91 | TraceStackInfo info = { 0 }; | 100 | TraceStackInfo info = { 0 }; |
| @@ -20,6 +20,7 @@ | |||
| 20 | 20 | ||
| 21 | 21 | ||
| 22 | 22 | ||
| 23 | + | ||
| 23 | 24 | ||
| 24 | extern "C" { | 25 | extern "C" { |
| 25 | TraStatus ScdProcessInit(ScdProcess **process, ScdProcessArgs *args); | 26 | TraStatus ScdProcessInit(ScdProcess **process, ScdProcessArgs *args); |
| @@ -27,6 +28,30 @@ extern "C" { | |||
| 27 | TraStatus ScdProcessRecordProcInfo(int32_t fd, pid_t pid, const char *name); | 28 | TraStatus ScdProcessRecordProcInfo(int32_t fd, pid_t pid, const char *name); |
| 28 | } | 29 | } |
| 29 | 30 | ||
| 31 | +static std::string BuildNestedPathForAbsLength(const std::string &basePath, size_t targetAbsLen) | ||
| 32 | +{ | ||
| 33 | + std::string path = basePath + "/scd_long_path_ut"; | ||
| 34 | + if (targetAbsLen < path.size()) { | ||
| 35 | + return ""; | ||
| 36 | + } | ||
| 37 | + const std::string segment = "/segment_for_stacktrace"; | ||
| 38 | + while (path.size() + segment.size() <= targetAbsLen) { | ||
| 39 | + path += segment; | ||
| 40 | + } | ||
| 41 | + if (path.size() < targetAbsLen) { | ||
| 42 | + path += "/"; | ||
| 43 | + path += std::string(targetAbsLen - path.size(), 'x'); | ||
| 44 | + } | ||
| 45 | + return path; | ||
| 46 | +} | ||
| 47 | + | ||
| 48 | +TEST(ScdProcessPathHelperTest, BuildNestedPathRejectsLongBasePath) | ||
| 49 | +{ | ||
| 50 | + const std::string basePath = "/tmp"; | ||
| 51 | + const size_t tooShortForInitialDir = basePath.size() + strlen("/scd_long_path_ut") - 1U; | ||
| 52 | + EXPECT_TRUE(BuildNestedPathForAbsLength(basePath, tooShortForInitialDir).empty()); | ||
| 53 | +} | ||
| 54 | + | ||
| 30 | class ScdProcessUtest: public testing::Test { | 55 | class ScdProcessUtest: public testing::Test { |
| 31 | protected: | 56 | protected: |
| 32 | virtual void SetUp() | 57 | virtual void SetUp() |
| @@ -261,6 +286,32 @@ TEST_F(ScdProcessUtest, TestScdProcessCreateFile_Failed) | |||
| 261 | GlobalMockObject::verify(); | 286 | GlobalMockObject::verify(); |
| 262 | } | 287 | } |
| 263 | 288 | ||
| 289 | +TEST_F(ScdProcessUtest, TestScdProcessDump_LongFilePathCreatesTxt) | ||
| 290 | +{ | ||
| 291 | + const size_t longPathLen = 360U; | ||
| 292 | + std::string longPath = BuildNestedPathForAbsLength(LLT_TEST_DIR, longPathLen); | ||
| 293 | + ASSERT_FALSE(longPath.empty()); | ||
| 294 | + std::string mkdirCmd = "mkdir -p " + longPath; | ||
| 295 | + ASSERT_EQ(0, system(mkdirCmd.c_str())); | ||
| 296 | + | ||
| 297 | + ScdProcessArgs arg = {0}; | ||
| 298 | + arg.pid = getpid(); | ||
| 299 | + arg.crashTid = gettid(); | ||
| 300 | + arg.handleType = SCD_DUMP_THREADS_TXT; | ||
| 301 | + const char fileName[] = "stackcore_tracer_long_path"; | ||
| 302 | + ASSERT_EQ(EOK, strncpy_s(arg.filePath, SCD_MAX_FILEPATH_LEN + 1U, longPath.c_str(), longPath.size())); | ||
| 303 | + ASSERT_EQ(EOK, strncpy_s(arg.fileName, SCD_MAX_FILENAME_LEN + 1U, fileName, strlen(fileName))); | ||
| 304 | + | ||
| 305 | + MOCKER(ScdMapsLoad).stubs().will(returnValue(TRACE_SUCCESS)); | ||
| 306 | + MOCKER(ScdThreadsLoad).stubs().will(returnValue(TRACE_SUCCESS)); | ||
| 307 | + MOCKER(ScdThreadsRecord).stubs().will(returnValue(TRACE_SUCCESS)); | ||
| 308 | + EXPECT_EQ(TRACE_SUCCESS, ScdProcessDump(&arg)); | ||
| 309 | + GlobalMockObject::verify(); | ||
| 310 | + | ||
| 311 | + std::string txtPath = longPath + "/" + fileName + ".txt"; | ||
| 312 | + EXPECT_EQ(0, access(txtPath.c_str(), F_OK)); | ||
| 313 | +} | ||
| 314 | + | ||
| 264 | TEST_F(ScdProcessUtest, TestScdProcessRecordInfo_Failed) | 315 | TEST_F(ScdProcessUtest, TestScdProcessRecordInfo_Failed) |
| 265 | { | 316 | { |
| 266 | ScdProcess pro = {0}; | 317 | ScdProcess pro = {0}; |
| @@ -471,4 +522,4 @@ TEST_F(ScdProcessUtest, TestScdSectionStackRecord) | |||
| 471 | free(readPoint); | 522 | free(readPoint); |
| 472 | ScdThreadsUninit(&tmpProcess->thds); | 523 | ScdThreadsUninit(&tmpProcess->thds); |
| 473 | free(tmpProcess); | 524 | free(tmpProcess); |
| 474 | -} | 525 | +} |
| @@ -45,6 +45,20 @@ typedef struct { | |||
| 45 | bool success; | 45 | bool success; |
| 46 | } TraceAgingThreadArg; | 46 | } TraceAgingThreadArg; |
| 47 | 47 | ||
| 48 | +const char *GetSafeDirTime(uint32_t index) | ||
| 49 | +{ | ||
| 50 | + static const char *const dirTimes[] = { | ||
| 51 | + "19701111111111111111", "19701111111111111112", "19701111111111111113", | ||
| 52 | + "19701111111111111114", "19701111111111111115", "19701111111111111116", | ||
| 53 | + "19701111111111111117", "19701111111111111118", "19701111111111111119", | ||
| 54 | + "19701111111111111121", "19701111111111111122", "19701111111111111123", | ||
| 55 | + "19701111111111111124", "19701111111111111125", "19701111111111111126", | ||
| 56 | + "19701111111111111127", "19701111111111111128", "19701111111111111129", | ||
| 57 | + "19701111111111111131", "19701111111111111132", "19701111111111111133" | ||
| 58 | + }; | ||
| 59 | + return dirTimes[index]; | ||
| 60 | +} | ||
| 61 | + | ||
| 48 | int32_t TraceOpenBlockFirstThenOpen(const char *filePath, int32_t flag, uint32_t mode) | 62 | int32_t TraceOpenBlockFirstThenOpen(const char *filePath, int32_t flag, uint32_t mode) |
| 49 | { | 63 | { |
| 50 | uint32_t callIndex = g_traceOpenCallIndex.fetch_add(1); | 64 | uint32_t callIndex = g_traceOpenCallIndex.fetch_add(1); |
| @@ -112,14 +126,7 @@ void *TraceRecorderCreateAgingDirsThread(void *arg) | |||
| 112 | TraceAgingThreadArg *threadArg = static_cast<TraceAgingThreadArg *>(arg); | 126 | TraceAgingThreadArg *threadArg = static_cast<TraceAgingThreadArg *>(arg); |
| 113 | threadArg->success = true; | 127 | threadArg->success = true; |
| 114 | for (uint32_t i = 0; i < 10U; i++) { | 128 | for (uint32_t i = 0; i < 10U; i++) { |
| 115 | - char timeStr[TIMESTAMP_MAX_LENGTH] = {0}; | 129 | + TraceDirInfo dirInfo = { TRACER_SCHEDULE_NAME, getpid(), GetSafeDirTime(i), true }; |
| 116 | - int32_t ret = snprintf_s(timeStr, TIMESTAMP_MAX_LENGTH, TIMESTAMP_MAX_LENGTH - 1U, | ||
| 117 | - "1970010108000001%04u", i); | ||
| 118 | - if (ret == -1) { | ||
| 119 | - threadArg->success = false; | ||
| 120 | - break; | ||
| 121 | - } | ||
| 122 | - TraceDirInfo dirInfo = { TRACER_SCHEDULE_NAME, getpid(), timeStr, true }; | ||
| 123 | TraceFileInfo fileInfo = { TRACER_SCHEDULE_NAME, "other", TRACE_FILE_TXT_SUFFIX }; | 130 | TraceFileInfo fileInfo = { TRACER_SCHEDULE_NAME, "other", TRACE_FILE_TXT_SUFFIX }; |
| 124 | int32_t fd = -1; | 131 | int32_t fd = -1; |
| 125 | if (TraceRecorderGetFd(&dirInfo, &fileInfo, &fd) != TRACE_SUCCESS) { | 132 | if (TraceRecorderGetFd(&dirInfo, &fileInfo, &fd) != TRACE_SUCCESS) { |
| @@ -159,6 +166,47 @@ bool BuildRecorderFilePathWithRoot(char *path, size_t len, const char *rootPath, | |||
| 159 | return ret != -1; | 166 | return ret != -1; |
| 160 | } | 167 | } |
| 161 | 168 | ||
| 169 | +std::string BuildNestedRelativePathForAbsLength(size_t targetAbsLen) | ||
| 170 | +{ | ||
| 171 | + char cwd[TRACE_MAX_PATH] = {0}; | ||
| 172 | + if (getcwd(cwd, sizeof(cwd)) == nullptr) { | ||
| 173 | + return ""; | ||
| 174 | + } | ||
| 175 | + const size_t cwdLen = strlen(cwd); | ||
| 176 | + std::string relativeDir = "trace_recorder_long_path_ut"; | ||
| 177 | + if (targetAbsLen < cwdLen + 1U + relativeDir.size()) { | ||
| 178 | + return ""; | ||
| 179 | + } | ||
| 180 | + const std::string segment = "/segment_for_trace_recorder"; | ||
| 181 | + while (cwdLen + 1U + relativeDir.size() + segment.size() <= targetAbsLen) { | ||
| 182 | + relativeDir += segment; | ||
| 183 | + } | ||
| 184 | + const size_t currentAbsLen = cwdLen + 1U + relativeDir.size(); | ||
| 185 | + if (currentAbsLen < targetAbsLen) { | ||
| 186 | + if (!relativeDir.empty()) { | ||
| 187 | + relativeDir += "/"; | ||
| 188 | + } | ||
| 189 | + relativeDir += std::string(targetAbsLen - currentAbsLen - 1U, 'x'); | ||
| 190 | + } | ||
| 191 | + return relativeDir; | ||
| 192 | +} | ||
| 193 | + | ||
| 194 | +TEST(TraceRecorderPathHelperTest, BuildNestedRelativePathRejectsDeepCwd) | ||
| 195 | +{ | ||
| 196 | + char cwd[TRACE_MAX_PATH] = {0}; | ||
| 197 | + ASSERT_NE(nullptr, getcwd(cwd, sizeof(cwd))); | ||
| 198 | + const size_t tooShortForInitialDir = strlen(cwd) + strlen("/trace_recorder_long_path_ut") - 1U; | ||
| 199 | + EXPECT_TRUE(BuildNestedRelativePathForAbsLength(tooShortForInitialDir).empty()); | ||
| 200 | +} | ||
| 201 | + | ||
| 202 | +TEST(TraceRecorderPathLimitTest, RecorderPathLimitsReserveFinalFileName) | ||
| 203 | +{ | ||
| 204 | + EXPECT_LT(static_cast<size_t>(MAX_FILEDIR_LEN), static_cast<size_t>(MAX_FILEPATH_LEN)); | ||
| 205 | + EXPECT_LT(static_cast<size_t>(MAX_FILEPATH_LEN), static_cast<size_t>(MAX_FULLPATH_LEN)); | ||
| 206 | + EXPECT_LE(static_cast<size_t>(MAX_FILEPATH_LEN) + static_cast<size_t>(TRACE_RECORDER_FILE_RESERVED_LEN), | ||
| 207 | + static_cast<size_t>(MAX_FULLPATH_LEN)); | ||
| 208 | +} | ||
| 209 | + | ||
| 162 | void RemoveTestPath(const std::string &path) | 210 | void RemoveTestPath(const std::string &path) |
| 163 | { | 211 | { |
| 164 | if (path.empty()) { | 212 | if (path.empty()) { |
| @@ -295,7 +343,7 @@ TEST_F(TraceRecorderUtest, TestRecordEnvRelativePath) | |||
| 295 | setenv("ASCEND_WORK_PATH", ("./" + relativeDir).c_str(), 1); | 343 | setenv("ASCEND_WORK_PATH", ("./" + relativeDir).c_str(), 1); |
| 296 | ASSERT_EQ(TRACE_SUCCESS, TraceRecorderInit()); | 344 | ASSERT_EQ(TRACE_SUCCESS, TraceRecorderInit()); |
| 297 | 345 | ||
| 298 | - const char *dirTime = "19700101080004000001"; | 346 | + const char *dirTime = GetSafeDirTime(0U); |
| 299 | TraceDirInfo dirInfo = { TRACER_SCHEDULE_NAME, getpid(), dirTime, true }; | 347 | TraceDirInfo dirInfo = { TRACER_SCHEDULE_NAME, getpid(), dirTime, true }; |
| 300 | TraceFileInfo fileInfo = { TRACER_SCHEDULE_NAME, "relative", TRACE_FILE_TXT_SUFFIX }; | 348 | TraceFileInfo fileInfo = { TRACER_SCHEDULE_NAME, "relative", TRACE_FILE_TXT_SUFFIX }; |
| 301 | int32_t fd = -1; | 349 | int32_t fd = -1; |
| @@ -326,7 +374,7 @@ TEST_F(TraceRecorderUtest, TestRecordEnvRelativePathWithParentDir) | |||
| 326 | setenv("ASCEND_WORK_PATH", (parentDir + "/../" + targetDir).c_str(), 1); | 374 | setenv("ASCEND_WORK_PATH", (parentDir + "/../" + targetDir).c_str(), 1); |
| 327 | ASSERT_EQ(TRACE_SUCCESS, TraceRecorderInit()); | 375 | ASSERT_EQ(TRACE_SUCCESS, TraceRecorderInit()); |
| 328 | 376 | ||
| 329 | - const char *dirTime = "19700101080004000002"; | 377 | + const char *dirTime = GetSafeDirTime(1U); |
| 330 | TraceDirInfo dirInfo = { TRACER_SCHEDULE_NAME, getpid(), dirTime, true }; | 378 | TraceDirInfo dirInfo = { TRACER_SCHEDULE_NAME, getpid(), dirTime, true }; |
| 331 | TraceFileInfo fileInfo = { TRACER_SCHEDULE_NAME, "dotdot", TRACE_FILE_TXT_SUFFIX }; | 379 | TraceFileInfo fileInfo = { TRACER_SCHEDULE_NAME, "dotdot", TRACE_FILE_TXT_SUFFIX }; |
| 332 | int32_t fd = -1; | 380 | int32_t fd = -1; |
| @@ -345,6 +393,38 @@ TEST_F(TraceRecorderUtest, TestRecordEnvRelativePathWithParentDir) | |||
| 345 | EXPECT_EQ(0, access(filePath, F_OK)); | 393 | EXPECT_EQ(0, access(filePath, F_OK)); |
| 346 | } | 394 | } |
| 347 | 395 | ||
| 396 | +TEST_F(TraceRecorderUtest, TestRecordEnvRelativePathAround240BytesWritesToEnvPath) | ||
| 397 | +{ | ||
| 398 | + TraceRecorderExit(); | ||
| 399 | + ScopedEnvAndPathCleanup envGuard("ASCEND_WORK_PATH"); | ||
| 400 | + const size_t issuePathLen = 240U; | ||
| 401 | + const std::string relativeDir = BuildNestedRelativePathForAbsLength(issuePathLen); | ||
| 402 | + ASSERT_FALSE(relativeDir.empty()); | ||
| 403 | + envGuard.AddPath(relativeDir); | ||
| 404 | + setenv("ASCEND_WORK_PATH", ("./" + relativeDir).c_str(), 1); | ||
| 405 | + ASSERT_EQ(TRACE_SUCCESS, TraceRecorderInit()); | ||
| 406 | + | ||
| 407 | + const char *dirTime = GetSafeDirTime(2U); | ||
| 408 | + TraceDirInfo dirInfo = { TRACER_SCHEDULE_NAME, getpid(), dirTime, true }; | ||
| 409 | + TraceFileInfo fileInfo = { TRACER_SCHEDULE_NAME, "longpath", TRACE_FILE_TXT_SUFFIX }; | ||
| 410 | + int32_t fd = -1; | ||
| 411 | + auto ret = TraceRecorderGetFd(&dirInfo, &fileInfo, &fd); | ||
| 412 | + ASSERT_EQ(TRACE_SUCCESS, ret); | ||
| 413 | + EXPECT_EQ(TRACE_SUCCESS, TraceRecorderWrite(fd, "longpath", 8U)); | ||
| 414 | + if (fd >= 0) { | ||
| 415 | + close(fd); | ||
| 416 | + } | ||
| 417 | + | ||
| 418 | + char cwd[TRACE_MAX_PATH] = {0}; | ||
| 419 | + ASSERT_NE(nullptr, getcwd(cwd, sizeof(cwd))); | ||
| 420 | + std::string expectedRoot = std::string(cwd) + "/" + relativeDir; | ||
| 421 | + ASSERT_EQ(issuePathLen, expectedRoot.size()); | ||
| 422 | + char filePath[MAX_FULLPATH_LEN + 1U] = {0}; | ||
| 423 | + ASSERT_TRUE(BuildRecorderFilePathWithRoot(filePath, MAX_FULLPATH_LEN + 1U, expectedRoot.c_str(), | ||
| 424 | + TRACER_SCHEDULE_NAME, dirTime, TRACER_SCHEDULE_NAME, "longpath", TRACE_FILE_TXT_SUFFIX)); | ||
| 425 | + EXPECT_EQ(0, access(filePath, F_OK)); | ||
| 426 | +} | ||
| 427 | + | ||
| 348 | TEST_F(TraceRecorderUtest, TestRecordEnvEmptyPathFallbackToHome) | 428 | TEST_F(TraceRecorderUtest, TestRecordEnvEmptyPathFallbackToHome) |
| 349 | { | 429 | { |
| 350 | TraceRecorderExit(); | 430 | TraceRecorderExit(); |
| @@ -352,7 +432,7 @@ TEST_F(TraceRecorderUtest, TestRecordEnvEmptyPathFallbackToHome) | |||
| 352 | setenv("ASCEND_WORK_PATH", "", 1); | 432 | setenv("ASCEND_WORK_PATH", "", 1); |
| 353 | ASSERT_EQ(TRACE_SUCCESS, TraceRecorderInit()); | 433 | ASSERT_EQ(TRACE_SUCCESS, TraceRecorderInit()); |
| 354 | 434 | ||
| 355 | - const char *dirTime = "19700101080004000003"; | 435 | + const char *dirTime = GetSafeDirTime(3U); |
| 356 | TraceDirInfo dirInfo = { TRACER_SCHEDULE_NAME, getpid(), dirTime, true }; | 436 | TraceDirInfo dirInfo = { TRACER_SCHEDULE_NAME, getpid(), dirTime, true }; |
| 357 | TraceFileInfo fileInfo = { TRACER_SCHEDULE_NAME, "empty", TRACE_FILE_TXT_SUFFIX }; | 437 | TraceFileInfo fileInfo = { TRACER_SCHEDULE_NAME, "empty", TRACE_FILE_TXT_SUFFIX }; |
| 358 | int32_t fd = -1; | 438 | int32_t fd = -1; |
| @@ -402,26 +482,42 @@ TEST_F(TraceRecorderUtest, TestRecordEnvRelativePathMaxLengthInitSucceeds) | |||
| 402 | { | 482 | { |
| 403 | TraceRecorderExit(); | 483 | TraceRecorderExit(); |
| 404 | ScopedEnvAndPathCleanup envGuard("ASCEND_WORK_PATH"); | 484 | ScopedEnvAndPathCleanup envGuard("ASCEND_WORK_PATH"); |
| 405 | - char cwd[MAX_FILEDIR_LEN + 1U] = {0}; | 485 | + std::string relativeDir = BuildNestedRelativePathForAbsLength(static_cast<size_t>(MAX_FILEDIR_LEN)); |
| 406 | - ASSERT_NE(nullptr, getcwd(cwd, sizeof(cwd))); | 486 | + ASSERT_FALSE(relativeDir.empty()); |
| 407 | - ASSERT_LT(strlen(cwd) + 1U, static_cast<size_t>(MAX_FILEDIR_LEN)); | ||
| 408 | - size_t relativeLen = static_cast<size_t>(MAX_FILEDIR_LEN) - strlen(cwd) - 1U; | ||
| 409 | - std::string relativeDir(relativeLen, 'a'); | ||
| 410 | envGuard.AddPath(relativeDir); | 487 | envGuard.AddPath(relativeDir); |
| 411 | setenv("ASCEND_WORK_PATH", relativeDir.c_str(), 1); | 488 | setenv("ASCEND_WORK_PATH", relativeDir.c_str(), 1); |
| 412 | EXPECT_EQ(TRACE_SUCCESS, TraceRecorderInit()); | 489 | EXPECT_EQ(TRACE_SUCCESS, TraceRecorderInit()); |
| 413 | EXPECT_EQ(0, access(relativeDir.c_str(), F_OK)); | 490 | EXPECT_EQ(0, access(relativeDir.c_str(), F_OK)); |
| 491 | + | ||
| 492 | + const char *dirTime = GetSafeDirTime(14U); | ||
| 493 | + TraceDirInfo dirInfo = { TRACER_SCHEDULE_NAME, getpid(), dirTime, true }; | ||
| 494 | + TraceFileInfo fileInfo = { TRACER_SCHEDULE_NAME, "rootmax", TRACE_FILE_TXT_SUFFIX }; | ||
| 495 | + int32_t fd = -1; | ||
| 496 | + auto ret = TraceRecorderGetFd(&dirInfo, &fileInfo, &fd); | ||
| 497 | + ASSERT_EQ(TRACE_SUCCESS, ret); | ||
| 498 | + EXPECT_EQ(TRACE_SUCCESS, TraceRecorderWrite(fd, "rootmax", 7U)); | ||
| 499 | + if (fd >= 0) { | ||
| 500 | + close(fd); | ||
| 501 | + } | ||
| 502 | + | ||
| 503 | + const char *safeDirTime = GetSafeDirTime(15U); | ||
| 504 | + TraceDirInfo safeDirInfo = { TRACER_STACKCORE_NAME, getpid(), safeDirTime, false }; | ||
| 505 | + TraceFileInfo safeFileInfo = { TRACER_STACKCORE_NAME, "safemax", TRACE_FILE_TXT_SUFFIX }; | ||
| 506 | + int32_t safeFd = -1; | ||
| 507 | + ret = TraceRecorderSafeGetFd(&safeDirInfo, &safeFileInfo, &safeFd); | ||
| 508 | + ASSERT_EQ(TRACE_SUCCESS, ret); | ||
| 509 | + EXPECT_EQ(TRACE_SUCCESS, TraceRecorderWrite(safeFd, "safemax", 7U)); | ||
| 510 | + if (safeFd >= 0) { | ||
| 511 | + close(safeFd); | ||
| 512 | + } | ||
| 414 | } | 513 | } |
| 415 | 514 | ||
| 416 | TEST_F(TraceRecorderUtest, TestRecordEnvRelativePathTooLongFallbackToHome) | 515 | TEST_F(TraceRecorderUtest, TestRecordEnvRelativePathTooLongFallbackToHome) |
| 417 | { | 516 | { |
| 418 | TraceRecorderExit(); | 517 | TraceRecorderExit(); |
| 419 | ScopedEnvAndPathCleanup envGuard("ASCEND_WORK_PATH"); | 518 | ScopedEnvAndPathCleanup envGuard("ASCEND_WORK_PATH"); |
| 420 | - char cwd[MAX_FILEDIR_LEN + 1U] = {0}; | 519 | + std::string relativeDir = BuildNestedRelativePathForAbsLength(static_cast<size_t>(MAX_FILEDIR_LEN) + 1U); |
| 421 | - ASSERT_NE(nullptr, getcwd(cwd, sizeof(cwd))); | 520 | + ASSERT_FALSE(relativeDir.empty()); |
| 422 | - ASSERT_LT(strlen(cwd), static_cast<size_t>(MAX_FILEDIR_LEN)); | ||
| 423 | - size_t relativeLen = static_cast<size_t>(MAX_FILEDIR_LEN) - strlen(cwd) + 1U; | ||
| 424 | - std::string relativeDir(relativeLen, 'b'); | ||
| 425 | envGuard.AddPath(relativeDir); | 521 | envGuard.AddPath(relativeDir); |
| 426 | setenv("ASCEND_WORK_PATH", relativeDir.c_str(), 1); | 522 | setenv("ASCEND_WORK_PATH", relativeDir.c_str(), 1); |
| 427 | EXPECT_EQ(TRACE_SUCCESS, TraceRecorderInit()); | 523 | EXPECT_EQ(TRACE_SUCCESS, TraceRecorderInit()); |
| @@ -538,23 +634,44 @@ TEST_F(TraceRecorderUtest, TestSafeGetFdMkdirFailed) | |||
| 538 | EXPECT_EQ(TRACE_FAILURE, ret); | 634 | EXPECT_EQ(TRACE_FAILURE, ret); |
| 539 | } | 635 | } |
| 540 | 636 | ||
| 541 | -TEST_F(TraceRecorderUtest, TestSafeGetFd) | 637 | +TEST_F(TraceRecorderUtest, TestSafeGetFd) |
| 542 | -{ | 638 | +{ |
| 543 | - char dirTimeStr[TIMESTAMP_MAX_LENGTH] = {0}; | 639 | + char dirTimeStr[TIMESTAMP_MAX_LENGTH] = {0}; |
| 544 | - auto ret = TimestampToFileStr(std::time(0), dirTimeStr, TIMESTAMP_MAX_LENGTH); | 640 | + auto ret = TimestampToFileStr(std::time(0), dirTimeStr, TIMESTAMP_MAX_LENGTH); |
| 545 | - EXPECT_EQ(TRACE_SUCCESS, ret); | 641 | + EXPECT_EQ(TRACE_SUCCESS, ret); |
| 546 | TraceDirInfo dirInfo = { TRACER_STACKCORE_NAME, getpid(), dirTimeStr}; | 642 | TraceDirInfo dirInfo = { TRACER_STACKCORE_NAME, getpid(), dirTimeStr}; |
| 547 | TraceFileInfo fileInfo = { TRACER_SCHEDULE_NAME, "HCCL", TRACE_FILE_TXT_SUFFIX }; | 643 | TraceFileInfo fileInfo = { TRACER_SCHEDULE_NAME, "HCCL", TRACE_FILE_TXT_SUFFIX }; |
| 548 | int32_t fd; | 644 | int32_t fd; |
| 549 | - ret = TraceRecorderSafeGetFd(&dirInfo, &fileInfo, &fd); | 645 | + ret = TraceRecorderSafeGetFd(&dirInfo, &fileInfo, &fd); |
| 550 | - EXPECT_EQ(TRACE_SUCCESS, ret); | 646 | + EXPECT_EQ(TRACE_SUCCESS, ret); |
| 551 | -} | 647 | +} |
| 552 | - | 648 | + |
| 553 | -TEST_F(TraceRecorderUtest, TestSafeGetBinFd) | 649 | +TEST_F(TraceRecorderUtest, TestSafeGetFdLongObjNameWithinFullPathSucceeds) |
| 554 | -{ | 650 | +{ |
| 555 | - char dirTimeStr[TIMESTAMP_MAX_LENGTH] = {0}; | 651 | + char dirTimeStr[TIMESTAMP_MAX_LENGTH] = {0}; |
| 556 | - auto ret = TimestampToFileStr(std::time(0), dirTimeStr, TIMESTAMP_MAX_LENGTH); | 652 | + auto ret = TimestampToFileStr(std::time(0), dirTimeStr, TIMESTAMP_MAX_LENGTH); |
| 557 | - EXPECT_EQ(TRACE_SUCCESS, ret); | 653 | + EXPECT_EQ(TRACE_SUCCESS, ret); |
| 654 | + TraceDirInfo dirInfo = { TRACER_STACKCORE_NAME, getpid(), dirTimeStr }; | ||
| 655 | + std::string objName(TRACE_RECORDER_FILE_RESERVED_LEN + 1U, 'a'); | ||
| 656 | + TraceFileInfo fileInfo = { TRACER_SCHEDULE_NAME, objName.c_str(), TRACE_FILE_TXT_SUFFIX }; | ||
| 657 | + char dirPath[MAX_FULLPATH_LEN + 1U] = {0}; | ||
| 658 | + ASSERT_EQ(TRACE_SUCCESS, TraceRecorderSafeGetDirPath(&dirInfo, dirPath, MAX_FULLPATH_LEN + 1U)); | ||
| 659 | + ASSERT_LT(strlen(dirPath) + strlen("/") + strlen(fileInfo.tracerName) + strlen("_tracer_") + objName.size() + | ||
| 660 | + strlen(fileInfo.suffix), static_cast<size_t>(MAX_FULLPATH_LEN)); | ||
| 661 | + | ||
| 662 | + int32_t fd = -1; | ||
| 663 | + ret = TraceRecorderSafeGetFd(&dirInfo, &fileInfo, &fd); | ||
| 664 | + EXPECT_EQ(TRACE_SUCCESS, ret); | ||
| 665 | + if (fd >= 0) { | ||
| 666 | + close(fd); | ||
| 667 | + } | ||
| 668 | +} | ||
| 669 | + | ||
| 670 | +TEST_F(TraceRecorderUtest, TestSafeGetBinFd) | ||
| 671 | +{ | ||
| 672 | + char dirTimeStr[TIMESTAMP_MAX_LENGTH] = {0}; | ||
| 673 | + auto ret = TimestampToFileStr(std::time(0), dirTimeStr, TIMESTAMP_MAX_LENGTH); | ||
| 674 | + EXPECT_EQ(TRACE_SUCCESS, ret); | ||
| 558 | TraceDirInfo dirInfo = { TRACER_STACKCORE_NAME, getpid(), dirTimeStr}; | 675 | TraceDirInfo dirInfo = { TRACER_STACKCORE_NAME, getpid(), dirTimeStr}; |
| 559 | TraceFileInfo fileInfo = { TRACER_SCHEDULE_NAME, "HCCL", TRACE_FILE_TXT_SUFFIX }; | 676 | TraceFileInfo fileInfo = { TRACER_SCHEDULE_NAME, "HCCL", TRACE_FILE_TXT_SUFFIX }; |
| 560 | int32_t fd; | 677 | int32_t fd; |
| @@ -620,7 +737,7 @@ TEST_F(TraceRecorderUtest, TraceRecorderGetFd_ConcurrentDirAgingKeepsFirstOpen) | |||
| 620 | 737 | ||
| 621 | TraceGetFdThreadArg firstArg = {}; | 738 | TraceGetFdThreadArg firstArg = {}; |
| 622 | int32_t ret = snprintf_s(firstArg.dirTime, TIMESTAMP_MAX_LENGTH, TIMESTAMP_MAX_LENGTH - 1U, | 739 | int32_t ret = snprintf_s(firstArg.dirTime, TIMESTAMP_MAX_LENGTH, TIMESTAMP_MAX_LENGTH - 1U, |
| 623 | - "19700101080000000001"); | 740 | + "%s", GetSafeDirTime(10U)); |
| 624 | EXPECT_NE(-1, ret); | 741 | EXPECT_NE(-1, ret); |
| 625 | firstArg.dirInfo = { TRACER_SCHEDULE_NAME, getpid(), firstArg.dirTime, true }; | 742 | firstArg.dirInfo = { TRACER_SCHEDULE_NAME, getpid(), firstArg.dirTime, true }; |
| 626 | firstArg.fileInfo = { TRACER_SCHEDULE_NAME, "first", TRACE_FILE_TXT_SUFFIX }; | 743 | firstArg.fileInfo = { TRACER_SCHEDULE_NAME, "first", TRACE_FILE_TXT_SUFFIX }; |
| @@ -659,7 +776,7 @@ TEST_F(TraceRecorderUtest, TraceRecorderGetFd_WriteCreatesExpectedFile) | |||
| 659 | setenv("ASCEND_WORK_PATH", LLT_TEST_DIR, 1); | 776 | setenv("ASCEND_WORK_PATH", LLT_TEST_DIR, 1); |
| 660 | EXPECT_EQ(TRACE_SUCCESS, TraceRecorderInit()); | 777 | EXPECT_EQ(TRACE_SUCCESS, TraceRecorderInit()); |
| 661 | 778 | ||
| 662 | - const char *dirTime = "19700101080002000001"; | 779 | + const char *dirTime = GetSafeDirTime(4U); |
| 663 | TraceDirInfo dirInfo = { TRACER_SCHEDULE_NAME, getpid(), dirTime, true }; | 780 | TraceDirInfo dirInfo = { TRACER_SCHEDULE_NAME, getpid(), dirTime, true }; |
| 664 | TraceFileInfo fileInfo = { TRACER_SCHEDULE_NAME, "normal", TRACE_FILE_TXT_SUFFIX }; | 781 | TraceFileInfo fileInfo = { TRACER_SCHEDULE_NAME, "normal", TRACE_FILE_TXT_SUFFIX }; |
| 665 | int32_t fd = -1; | 782 | int32_t fd = -1; |
| @@ -683,7 +800,7 @@ TEST_F(TraceRecorderUtest, TraceRecorderGetFd_SameDirWithinLimitKeepsWritable) | |||
| 683 | setenv("ASCEND_TRACE_RECORD_NUM", "10", 1); | 800 | setenv("ASCEND_TRACE_RECORD_NUM", "10", 1); |
| 684 | EXPECT_EQ(TRACE_SUCCESS, TraceRecorderInit()); | 801 | EXPECT_EQ(TRACE_SUCCESS, TraceRecorderInit()); |
| 685 | 802 | ||
| 686 | - const char *dirTime = "19700101080002000002"; | 803 | + const char *dirTime = GetSafeDirTime(5U); |
| 687 | TraceDirInfo dirInfo = { TRACER_SCHEDULE_NAME, getpid(), dirTime, true }; | 804 | TraceDirInfo dirInfo = { TRACER_SCHEDULE_NAME, getpid(), dirTime, true }; |
| 688 | TraceFileInfo fileInfo = { TRACER_SCHEDULE_NAME, "repeat", TRACE_FILE_TXT_SUFFIX }; | 805 | TraceFileInfo fileInfo = { TRACER_SCHEDULE_NAME, "repeat", TRACE_FILE_TXT_SUFFIX }; |
| 689 | for (uint32_t i = 0; i < 2U; i++) { | 806 | for (uint32_t i = 0; i < 2U; i++) { |
| @@ -712,10 +829,7 @@ TEST_F(TraceRecorderUtest, TraceRecorderGetFd_UniqueDirAgingRemovesOldestOnly) | |||
| 712 | 829 | ||
| 713 | char dirPaths[11][MAX_FULLPATH_LEN + 1U] = {}; | 830 | char dirPaths[11][MAX_FULLPATH_LEN + 1U] = {}; |
| 714 | for (uint32_t i = 0; i < 11U; i++) { | 831 | for (uint32_t i = 0; i < 11U; i++) { |
| 715 | - char dirTime[TIMESTAMP_MAX_LENGTH] = {0}; | 832 | + const char *dirTime = GetSafeDirTime(i); |
| 716 | - int32_t ret = snprintf_s(dirTime, TIMESTAMP_MAX_LENGTH, TIMESTAMP_MAX_LENGTH - 1U, | ||
| 717 | - "1970010108000201%04u", i); | ||
| 718 | - EXPECT_NE(-1, ret); | ||
| 719 | ASSERT_TRUE(BuildRecorderDirPath(dirPaths[i], MAX_FULLPATH_LEN + 1U, TRACER_SCHEDULE_NAME, dirTime)); | 833 | ASSERT_TRUE(BuildRecorderDirPath(dirPaths[i], MAX_FULLPATH_LEN + 1U, TRACER_SCHEDULE_NAME, dirTime)); |
| 720 | 834 | ||
| 721 | TraceDirInfo dirInfo = { TRACER_SCHEDULE_NAME, getpid(), dirTime, true }; | 835 | TraceDirInfo dirInfo = { TRACER_SCHEDULE_NAME, getpid(), dirTime, true }; |
| @@ -742,32 +856,27 @@ TEST_F(TraceRecorderUtest, TraceRecorderGetFd_ReusedOldDirDoesNotRefreshAgingOrd | |||
| 742 | EXPECT_EQ(TRACE_SUCCESS, TraceRecorderInit()); | 856 | EXPECT_EQ(TRACE_SUCCESS, TraceRecorderInit()); |
| 743 | 857 | ||
| 744 | char dirPaths[11][MAX_FULLPATH_LEN + 1U] = {}; | 858 | char dirPaths[11][MAX_FULLPATH_LEN + 1U] = {}; |
| 745 | - char dirTimes[11][TIMESTAMP_MAX_LENGTH] = {}; | ||
| 746 | for (uint32_t i = 0; i < 10U; i++) { | 859 | for (uint32_t i = 0; i < 10U; i++) { |
| 747 | - int32_t ret = snprintf_s(dirTimes[i], TIMESTAMP_MAX_LENGTH, TIMESTAMP_MAX_LENGTH - 1U, | 860 | + ASSERT_TRUE(BuildRecorderDirPath(dirPaths[i], MAX_FULLPATH_LEN + 1U, TRACER_SCHEDULE_NAME, |
| 748 | - "1970010108000301%04u", i); | 861 | + GetSafeDirTime(i))); |
| 749 | - EXPECT_NE(-1, ret); | ||
| 750 | - ASSERT_TRUE(BuildRecorderDirPath(dirPaths[i], MAX_FULLPATH_LEN + 1U, TRACER_SCHEDULE_NAME, dirTimes[i])); | ||
| 751 | 862 | ||
| 752 | - TraceDirInfo dirInfo = { TRACER_SCHEDULE_NAME, getpid(), dirTimes[i], true }; | 863 | + TraceDirInfo dirInfo = { TRACER_SCHEDULE_NAME, getpid(), GetSafeDirTime(i), true }; |
| 753 | TraceFileInfo fileInfo = { TRACER_SCHEDULE_NAME, "timestamp", TRACE_FILE_TXT_SUFFIX }; | 864 | TraceFileInfo fileInfo = { TRACER_SCHEDULE_NAME, "timestamp", TRACE_FILE_TXT_SUFFIX }; |
| 754 | int32_t fd = -1; | 865 | int32_t fd = -1; |
| 755 | EXPECT_EQ(TRACE_SUCCESS, TraceRecorderGetFd(&dirInfo, &fileInfo, &fd)); | 866 | EXPECT_EQ(TRACE_SUCCESS, TraceRecorderGetFd(&dirInfo, &fileInfo, &fd)); |
| 756 | close(fd); | 867 | close(fd); |
| 757 | } | 868 | } |
| 758 | 869 | ||
| 759 | - TraceDirInfo reusedDirInfo = { TRACER_SCHEDULE_NAME, getpid(), dirTimes[0], true }; | 870 | + TraceDirInfo reusedDirInfo = { TRACER_SCHEDULE_NAME, getpid(), GetSafeDirTime(0U), true }; |
| 760 | TraceFileInfo reusedFileInfo = { TRACER_SCHEDULE_NAME, "reuse", TRACE_FILE_TXT_SUFFIX }; | 871 | TraceFileInfo reusedFileInfo = { TRACER_SCHEDULE_NAME, "reuse", TRACE_FILE_TXT_SUFFIX }; |
| 761 | int32_t reusedFd = -1; | 872 | int32_t reusedFd = -1; |
| 762 | EXPECT_EQ(TRACE_SUCCESS, TraceRecorderGetFd(&reusedDirInfo, &reusedFileInfo, &reusedFd)); | 873 | EXPECT_EQ(TRACE_SUCCESS, TraceRecorderGetFd(&reusedDirInfo, &reusedFileInfo, &reusedFd)); |
| 763 | close(reusedFd); | 874 | close(reusedFd); |
| 764 | 875 | ||
| 765 | - int32_t ret = snprintf_s(dirTimes[10], TIMESTAMP_MAX_LENGTH, TIMESTAMP_MAX_LENGTH - 1U, | 876 | + ASSERT_TRUE(BuildRecorderDirPath(dirPaths[10], MAX_FULLPATH_LEN + 1U, TRACER_SCHEDULE_NAME, |
| 766 | - "1970010108000301%04u", 10U); | 877 | + GetSafeDirTime(10U))); |
| 767 | - EXPECT_NE(-1, ret); | ||
| 768 | - ASSERT_TRUE(BuildRecorderDirPath(dirPaths[10], MAX_FULLPATH_LEN + 1U, TRACER_SCHEDULE_NAME, dirTimes[10])); | ||
| 769 | 878 | ||
| 770 | - TraceDirInfo newDirInfo = { TRACER_SCHEDULE_NAME, getpid(), dirTimes[10], true }; | 879 | + TraceDirInfo newDirInfo = { TRACER_SCHEDULE_NAME, getpid(), GetSafeDirTime(10U), true }; |
| 771 | TraceFileInfo newFileInfo = { TRACER_SCHEDULE_NAME, "timestamp", TRACE_FILE_TXT_SUFFIX }; | 880 | TraceFileInfo newFileInfo = { TRACER_SCHEDULE_NAME, "timestamp", TRACE_FILE_TXT_SUFFIX }; |
| 772 | int32_t newFd = -1; | 881 | int32_t newFd = -1; |
| 773 | EXPECT_EQ(TRACE_SUCCESS, TraceRecorderGetFd(&newDirInfo, &newFileInfo, &newFd)); | 882 | EXPECT_EQ(TRACE_SUCCESS, TraceRecorderGetFd(&newDirInfo, &newFileInfo, &newFd)); |
| @@ -782,6 +891,150 @@ TEST_F(TraceRecorderUtest, TraceRecorderGetFd_ReusedOldDirDoesNotRefreshAgingOrd | |||
| 782 | unsetenv("ASCEND_WORK_PATH"); | 891 | unsetenv("ASCEND_WORK_PATH"); |
| 783 | } | 892 | } |
| 784 | 893 | ||
| 894 | +TEST_F(TraceRecorderUtest, TraceRecorderGetDirPath_SecondDirectoryFailureLogsPathContext) | ||
| 895 | +{ | ||
| 896 | + TraceRecorderExit(); | ||
| 897 | + setenv("ASCEND_WORK_PATH", LLT_TEST_DIR, 1); | ||
| 898 | + ASSERT_EQ(TRACE_SUCCESS, TraceRecorderInit()); | ||
| 899 | + | ||
| 900 | + const char *dirTime = GetSafeDirTime(6U); | ||
| 901 | + TraceDirInfo dirInfo = { TRACER_SCHEDULE_NAME, getpid(), dirTime, true }; | ||
| 902 | + MOCKER(TraceMkdir).stubs() | ||
| 903 | + .will(returnValue(TRACE_SUCCESS)) | ||
| 904 | + .then(returnValue(TRACE_SUCCESS)) | ||
| 905 | + .then(returnValue(TRACE_SUCCESS)) | ||
| 906 | + .then(returnValue(TRACE_FAILURE)); | ||
| 907 | + | ||
| 908 | + testing::internal::CaptureStdout(); | ||
| 909 | + const TraceDirNode *dir = TraceRecorderGetDirPath(&dirInfo); | ||
| 910 | + std::string output = testing::internal::GetCapturedStdout(); | ||
| 911 | + | ||
| 912 | + EXPECT_EQ(nullptr, dir); | ||
| 913 | + EXPECT_NE(std::string::npos, output.find("create trace second directory failed")); | ||
| 914 | + EXPECT_NE(std::string::npos, output.find("stage=second_event_dir")); | ||
| 915 | + EXPECT_NE(std::string::npos, output.find("reason=mkdir")); | ||
| 916 | + EXPECT_NE(std::string::npos, output.find("rootPath=")); | ||
| 917 | + EXPECT_NE(std::string::npos, output.find("dirPath=")); | ||
| 918 | + EXPECT_NE(std::string::npos, output.find("dirPathLen=")); | ||
| 919 | + EXPECT_NE(std::string::npos, output.find("limit=")); | ||
| 920 | + GlobalMockObject::verify(); | ||
| 921 | +} | ||
| 922 | + | ||
| 923 | +void ExpectGetDirPathFailureLog(const TraceDirInfo &dirInfo, const std::vector<std::string> &expected) | ||
| 924 | +{ | ||
| 925 | + testing::internal::CaptureStdout(); | ||
| 926 | + const TraceDirNode *dir = TraceRecorderGetDirPath(&dirInfo); | ||
| 927 | + std::string output = testing::internal::GetCapturedStdout(); | ||
| 928 | + | ||
| 929 | + EXPECT_EQ(nullptr, dir); | ||
| 930 | + for (const auto &text : expected) { | ||
| 931 | + EXPECT_NE(std::string::npos, output.find(text)) << output; | ||
| 932 | + } | ||
| 933 | +} | ||
| 934 | + | ||
| 935 | +TEST_F(TraceRecorderUtest, TraceRecorderGetDirPath_RootDirectoryFailureLogsPathContext) | ||
| 936 | +{ | ||
| 937 | + TraceRecorderExit(); | ||
| 938 | + setenv("ASCEND_WORK_PATH", LLT_TEST_DIR, 1); | ||
| 939 | + ASSERT_EQ(TRACE_SUCCESS, TraceRecorderInit()); | ||
| 940 | + | ||
| 941 | + const char *dirTime = GetSafeDirTime(7U); | ||
| 942 | + TraceDirInfo dirInfo = { TRACER_SCHEDULE_NAME, getpid(), dirTime, true }; | ||
| 943 | + MOCKER(TraceMkdir).stubs().will(returnValue(TRACE_FAILURE)); | ||
| 944 | + | ||
| 945 | + ExpectGetDirPathFailureLog(dirInfo, { | ||
| 946 | + "create trace root directory failed", "stage=root_dir", "reason=mkdir", "rootPath=", "rootPathLen=", "limit=" | ||
| 947 | + }); | ||
| 948 | + GlobalMockObject::verify(); | ||
| 949 | +} | ||
| 950 | + | ||
| 951 | +TEST_F(TraceRecorderUtest, TraceRecorderGetDirPath_AtraceDirectorySnprintfFailureLogsPathContext) | ||
| 952 | +{ | ||
| 953 | + TraceRecorderExit(); | ||
| 954 | + setenv("ASCEND_WORK_PATH", LLT_TEST_DIR, 1); | ||
| 955 | + ASSERT_EQ(TRACE_SUCCESS, TraceRecorderInit()); | ||
| 956 | + | ||
| 957 | + const char *dirTime = GetSafeDirTime(8U); | ||
| 958 | + TraceDirInfo dirInfo = { TRACER_SCHEDULE_NAME, getpid(), dirTime, true }; | ||
| 959 | + MOCKER(TraceMkdir).stubs().will(returnValue(TRACE_SUCCESS)); | ||
| 960 | + MOCKER(vsnprintf_s).stubs().will(returnValue(-1)); | ||
| 961 | + | ||
| 962 | + ExpectGetDirPathFailureLog(dirInfo, { | ||
| 963 | + "create trace atrace directory failed", "stage=atrace_dir", "reason=snprintf_s", "rootPath=", "limit=" | ||
| 964 | + }); | ||
| 965 | + GlobalMockObject::verify(); | ||
| 966 | +} | ||
| 967 | + | ||
| 968 | +TEST_F(TraceRecorderUtest, TraceRecorderGetDirPath_AtraceDirectoryMkdirFailureLogsPathContext) | ||
| 969 | +{ | ||
| 970 | + TraceRecorderExit(); | ||
| 971 | + setenv("ASCEND_WORK_PATH", LLT_TEST_DIR, 1); | ||
| 972 | + ASSERT_EQ(TRACE_SUCCESS, TraceRecorderInit()); | ||
| 973 | + | ||
| 974 | + const char *dirTime = GetSafeDirTime(9U); | ||
| 975 | + TraceDirInfo dirInfo = { TRACER_SCHEDULE_NAME, getpid(), dirTime, true }; | ||
| 976 | + MOCKER(TraceMkdir).stubs().will(returnValue(TRACE_SUCCESS)).then(returnValue(TRACE_FAILURE)); | ||
| 977 | + | ||
| 978 | + ExpectGetDirPathFailureLog(dirInfo, { | ||
| 979 | + "create trace atrace directory failed", "stage=atrace_dir", "reason=mkdir", "dirPath=", "dirPathLen=", "limit=" | ||
| 980 | + }); | ||
| 981 | + GlobalMockObject::verify(); | ||
| 982 | +} | ||
| 983 | + | ||
| 984 | +TEST_F(TraceRecorderUtest, TraceRecorderGetDirPath_FirstDirectorySnprintfFailureLogsPathContext) | ||
| 985 | +{ | ||
| 986 | + TraceRecorderExit(); | ||
| 987 | + setenv("ASCEND_WORK_PATH", LLT_TEST_DIR, 1); | ||
| 988 | + ASSERT_EQ(TRACE_SUCCESS, TraceRecorderInit()); | ||
| 989 | + | ||
| 990 | + const char *dirTime = GetSafeDirTime(11U); | ||
| 991 | + TraceDirInfo dirInfo = { TRACER_SCHEDULE_NAME, getpid(), dirTime, true }; | ||
| 992 | + MOCKER(TraceMkdir).stubs().will(returnValue(TRACE_SUCCESS)); | ||
| 993 | + MOCKER(vsnprintf_s).stubs().will(returnValue(0)).then(returnValue(-1)); | ||
| 994 | + | ||
| 995 | + ExpectGetDirPathFailureLog(dirInfo, { | ||
| 996 | + "create trace first directory failed", "stage=first_trace_dir", "reason=snprintf_s", "rootPath=", "limit=" | ||
| 997 | + }); | ||
| 998 | + GlobalMockObject::verify(); | ||
| 999 | +} | ||
| 1000 | + | ||
| 1001 | +TEST_F(TraceRecorderUtest, TraceRecorderGetDirPath_FirstDirectoryMkdirFailureLogsPathContext) | ||
| 1002 | +{ | ||
| 1003 | + TraceRecorderExit(); | ||
| 1004 | + setenv("ASCEND_WORK_PATH", LLT_TEST_DIR, 1); | ||
| 1005 | + ASSERT_EQ(TRACE_SUCCESS, TraceRecorderInit()); | ||
| 1006 | + | ||
| 1007 | + const char *dirTime = GetSafeDirTime(12U); | ||
| 1008 | + TraceDirInfo dirInfo = { TRACER_SCHEDULE_NAME, getpid(), dirTime, true }; | ||
| 1009 | + MOCKER(TraceMkdir).stubs() | ||
| 1010 | + .will(returnValue(TRACE_SUCCESS)) | ||
| 1011 | + .then(returnValue(TRACE_SUCCESS)) | ||
| 1012 | + .then(returnValue(TRACE_FAILURE)); | ||
| 1013 | + | ||
| 1014 | + ExpectGetDirPathFailureLog(dirInfo, { | ||
| 1015 | + "create trace first directory failed", "stage=first_trace_dir", "reason=mkdir", "dirPath=", "dirPathLen=", | ||
| 1016 | + "limit=" | ||
| 1017 | + }); | ||
| 1018 | + GlobalMockObject::verify(); | ||
| 1019 | +} | ||
| 1020 | + | ||
| 1021 | +TEST_F(TraceRecorderUtest, TraceRecorderGetDirPath_SecondDirectorySnprintfFailureLogsPathContext) | ||
| 1022 | +{ | ||
| 1023 | + TraceRecorderExit(); | ||
| 1024 | + setenv("ASCEND_WORK_PATH", LLT_TEST_DIR, 1); | ||
| 1025 | + ASSERT_EQ(TRACE_SUCCESS, TraceRecorderInit()); | ||
| 1026 | + | ||
| 1027 | + const char *dirTime = GetSafeDirTime(13U); | ||
| 1028 | + TraceDirInfo dirInfo = { TRACER_SCHEDULE_NAME, getpid(), dirTime, true }; | ||
| 1029 | + MOCKER(TraceMkdir).stubs().will(returnValue(TRACE_SUCCESS)); | ||
| 1030 | + MOCKER(vsnprintf_s).stubs().will(returnValue(0)).then(returnValue(0)).then(returnValue(-1)); | ||
| 1031 | + | ||
| 1032 | + ExpectGetDirPathFailureLog(dirInfo, { | ||
| 1033 | + "create trace second directory failed", "stage=second_event_dir", "reason=snprintf_s", "rootPath=", "limit=" | ||
| 1034 | + }); | ||
| 1035 | + GlobalMockObject::verify(); | ||
| 1036 | +} | ||
| 1037 | + | ||
| 785 | TEST_F(TraceRecorderUtest, TestTraceRecorderSafeGetFd_Failed) | 1038 | TEST_F(TraceRecorderUtest, TestTraceRecorderSafeGetFd_Failed) |
| 786 | { | 1039 | { |
| 787 | auto ret = TraceRecorderSafeGetFd(NULL, NULL, NULL); | 1040 | auto ret = TraceRecorderSafeGetFd(NULL, NULL, NULL); |
| @@ -800,13 +1053,13 @@ TEST_F(TraceRecorderUtest, TestTraceRecorderSafeGetFd_Failed) | |||
| 800 | EXPECT_EQ(status, ret); | 1053 | EXPECT_EQ(status, ret); |
| 801 | GlobalMockObject::verify(); | 1054 | GlobalMockObject::verify(); |
| 802 | 1055 | ||
| 803 | - MOCKER(strncat_s).stubs().will(returnValue(-1)); | 1056 | + std::string tooLongObjName(MAX_FULLPATH_LEN, 'a'); |
| 804 | - ret = TraceRecorderSafeGetFd(&dirInfo, &fileInfo, &fd); | 1057 | + TraceFileInfo tooLongFileInfo = { TRACER_SCHEDULE_NAME, tooLongObjName.c_str(), ".txt" }; |
| 805 | - EXPECT_EQ(TRACE_FAILURE, ret); | 1058 | + ret = TraceRecorderSafeGetFd(&dirInfo, &tooLongFileInfo, &fd); |
| 806 | - GlobalMockObject::verify(); | 1059 | + EXPECT_EQ(TRACE_FAILURE, ret); |
| 807 | - | 1060 | + |
| 808 | - MOCKER(TraceOpen).stubs().will(returnValue(-1)); | 1061 | + MOCKER(TraceOpen).stubs().will(returnValue(-1)); |
| 809 | - ret = TraceRecorderSafeGetFd(&dirInfo, &fileInfo, &fd); | 1062 | + ret = TraceRecorderSafeGetFd(&dirInfo, &fileInfo, &fd); |
| 810 | EXPECT_EQ(TRACE_FAILURE, ret); | 1063 | EXPECT_EQ(TRACE_FAILURE, ret); |
| 811 | GlobalMockObject::verify(); | 1064 | GlobalMockObject::verify(); |
| 812 | } | 1065 | } |
级别：提示 问题：TraceRecorderLogBuildFailure 在 vsnprintf_s 失败之后调用,内部使用 strerror(AdiagGetErrorCode()) 读取错误码,但中间经历了函数调用边界,errno 可能已被覆盖。 影响：日志中 strerr 字段可能不是真正触发 vsnprintf_s 失败的错误码,降低问题定位准确性。 修复建议：在 TraceRecorderCreateFormattedDir 中检测到 ret == -1 时立即缓存 errno(或 AdiagGetErrorCode() 的返回值),再传入日志函数输出。