diff --git a/buildlib/tools/coverity.sh b/buildlib/tools/coverity.sh index a67c4f93bc4..bcd7e89c294 100755 --- a/buildlib/tools/coverity.sh +++ b/buildlib/tools/coverity.sh @@ -104,21 +104,18 @@ run_coverity() { fi cov-analyze --jobs $parallel_jobs $COV_OPT --security --concurrency --dir $cov_build nerrors=$(cov-format-errors --dir $cov_build | awk '/Processing [0-9]+ errors?/ { print $2 }') - rc=$(($rc+$nerrors)) if [ $nerrors -gt 0 ]; then - cov-format-errors --dir $cov_build --emacs-style + cov_error_log="$(echo -e "\n$(cov-format-errors --dir $cov_build --emacs-style)")" if [ -d "$WORKSPACE/$cov_build_id" ]; then rm -rf $WORKSPACE/$cov_build_id fi cp -ar $cov_build $WORKSPACE/$cov_build_id - echo "not ok 1 Coverity Detected $nerrors failures" else - echo "ok 1 Coverity found no issues" rm -rf $cov_build fi modules_for_coverity_unload - return $rc + return $nerrors } parse_args $* @@ -135,4 +132,9 @@ else cd "${ucx_build_dir}" fi -run_coverity "$mode" +run_coverity "$mode" || { + set +x + azure_log_error "Coverity found $nerrors issues: $cov_error_log" + azure_log_error "To debug, rerun with: $0 $mode" + exit 1 +} diff --git a/config/m4/compiler.m4 b/config/m4/compiler.m4 index 50907433cab..ebc2c9f52a5 100644 --- a/config/m4/compiler.m4 +++ b/config/m4/compiler.m4 @@ -449,6 +449,26 @@ AS_IF([test "x$enable_gcov" = xyes], [AC_LANG_SOURCE([[int main(int argc, char** argv){return 0;}]])])], [:]) +# +# Enable stack usage check +# +# To suppress -Wframe-larger-than=8192 for specific functions, use: +# #pragma GCC diagnostic push +# #pragma GCC diagnostic ignored "-Wframe-larger-than=" +# void specific_function() { +# /* Function code */ +# } +# #pragma GCC diagnostic pop +# +AC_ARG_ENABLE([stack-usage-check], + AS_HELP_STRING([--enable-stack-usage-check], [Enable stack usage check with -Wframe-larger-than=8192]), + [], + [enable_stack_usage_check=yes]) + +AS_IF([test "x$enable_stack_usage_check" = xyes], + [ADD_COMPILER_FLAG_IF_SUPPORTED([stack_usage_check], [-Wframe-larger-than=8192], + [AC_LANG_SOURCE([[int main(int argc, char** argv){return 0;}]])])], + [:]) # # Check for C++ support diff --git a/contrib/test_jenkins.sh b/contrib/test_jenkins.sh index 70095486d2e..7b4ae3634f5 100755 --- a/contrib/test_jenkins.sh +++ b/contrib/test_jenkins.sh @@ -1119,7 +1119,19 @@ run_tests() { do_distributed_task 0 4 run_nt_buffer_transfer_tests } +error_handler() { + set +x + local exit_code=$? + local test_name="$1" + local flag="$2" + + azure_log_error "$test_name failed" + azure_log_error "To debug, rerun with: $flag $0" + exit $exit_code +} + run_test_proto_disable() { + trap 'error_handler "Proto V1 test" "PROTO_ENABLE=no"' ERR # build for devel tests and gtest build devel --enable-gtest @@ -1130,11 +1142,13 @@ run_test_proto_disable() { } run_asan_check() { + trap 'error_handler "AddressSanitizer check" "ASAN_CHECK=yes"' ERR build devel --enable-gtest --enable-asan --without-valgrind run_gtest "default" } run_valgrind_check() { + trap 'error_handler "Valgrind check" "VALGRIND_CHECK=yes"' ERR if [[ $(uname -m) =~ "aarch" ]] || [[ $(uname -m) =~ "ppc" ]]; then echo "==== Skip valgrind tests on `uname -m` ====" return diff --git a/src/tools/info/type_info.c b/src/tools/info/type_info.c index 8e41996d50b..6739df5b70c 100644 --- a/src/tools/info/type_info.c +++ b/src/tools/info/type_info.c @@ -87,7 +87,7 @@ static void print_size(const char *name, size_t size) print_size(UCS_PP_QUOTE(_type) "." UCS_PP_QUOTE(_field), \ ucs_field_sizeof(_type, _field)) -void print_type_info(const char * tl_name) +static void print_ucs(const char *tl_name) { if (tl_name == NULL) { printf("UCS:\n"); @@ -131,8 +131,13 @@ void print_type_info(const char * tl_name) PRINT_SIZE(ucs_rcache_region_t); PRINT_SIZE(ucs_conn_match_elem_t); PRINT_SIZE(ucs_memory_info_t); + } +} - printf("\nUCT:\n"); +static void print_uct(const char *tl_name) +{ + if (tl_name == NULL) { + printf("UCT:\n"); PRINT_SIZE(uct_am_handler_t); PRINT_SIZE(uct_base_iface_t); PRINT_SIZE(uct_completion_t); @@ -152,13 +157,11 @@ void print_type_info(const char * tl_name) PRINT_SIZE(uct_rkey_bundle_t); PRINT_SIZE(uct_tcp_ep_t); PRINT_SIZE(uct_self_ep_t); + } +} -#ifdef HAVE_TL_UGNI - PRINT_SIZE(uct_sockaddr_ugni_t); - PRINT_SIZE(uct_sockaddr_smsg_ugni_t); - PRINT_SIZE(uct_devaddr_ugni_t); -#endif - +static void print_ib(const char *tl_name) +{ #if HAVE_IB printf("\nIB:\n"); PRINT_SIZE(uct_ib_address_t); @@ -170,13 +173,13 @@ void print_type_info(const char * tl_name) PRINT_SIZE(uct_ib_iface_recv_desc_t); PRINT_SIZE(uct_ib_recv_wr_t); #endif - printf("\n"); - } +} +static void print_rc(const char *tl_name) +{ #if HAVE_TL_RC if (tl_name == NULL || !strcasecmp(tl_name, "rc_verbs") || - !strcasecmp(tl_name, "rc_mlx5")) - { + !strcasecmp(tl_name, "rc_mlx5")) { printf("RC:\n"); PRINT_SIZE(uct_rc_am_short_hdr_t); PRINT_SIZE(uct_rc_ep_t); @@ -185,14 +188,12 @@ void print_type_info(const char * tl_name) PRINT_SIZE(uct_rc_iface_config_t); PRINT_SIZE(uct_rc_iface_send_op_t); PRINT_SIZE(uct_rc_iface_send_desc_t); - PRINT_SIZE(uct_rc_iface_send_desc_t); if (tl_name == NULL || !strcasecmp(tl_name, "rc_verbs")) { PRINT_SIZE(uct_rc_verbs_ep_t); PRINT_SIZE(uct_rc_verbs_iface_config_t); PRINT_SIZE(uct_rc_verbs_iface_t); } - #ifdef HAVE_MLX5_DV if (tl_name == NULL || !strcasecmp(tl_name, "rc_mlx5")) { PRINT_SIZE(uct_rc_mlx5_am_short_hdr_t); @@ -205,7 +206,10 @@ void print_type_info(const char * tl_name) printf("\n"); } #endif +} +static void print_dc(const char *tl_name) +{ #if HAVE_TL_DC if (tl_name == NULL || !strcasecmp(tl_name, "dc_mlx5")) { @@ -217,11 +221,13 @@ void print_type_info(const char * tl_name) printf("\n"); } #endif +} +static void print_ud(const char *tl_name) +{ #if HAVE_TL_UD if (tl_name == NULL || !strcasecmp(tl_name, "ud_verbs") || - !strcasecmp(tl_name, "ud_mlx5")) - { + !strcasecmp(tl_name, "ud_mlx5")) { printf("UD:\n"); PRINT_SIZE(uct_ud_ep_t); PRINT_SIZE(uct_ud_neth_t); @@ -230,13 +236,11 @@ void print_type_info(const char * tl_name) PRINT_SIZE(uct_ud_ep_pending_op_t); PRINT_SIZE(uct_ud_send_skb_t); PRINT_SIZE(uct_ud_recv_skb_t); - PRINT_SIZE(uct_rc_iface_send_desc_t); if (tl_name == NULL || !strcasecmp(tl_name, "ud_verbs")) { PRINT_SIZE(uct_ud_verbs_ep_t); PRINT_SIZE(uct_ud_verbs_iface_t); } - #ifdef HAVE_MLX5_HW_UD if (tl_name == NULL || !strcasecmp(tl_name, "ud_mlx5")) { PRINT_SIZE(uct_ud_mlx5_ep_t); @@ -246,20 +250,28 @@ void print_type_info(const char * tl_name) printf("\n"); } #endif +} +static void print_ugni(const char *tl_name) +{ #ifdef HAVE_TL_UGNI if (tl_name == NULL || !strcasecmp(tl_name, "ugni")) { printf("UGNI:\n"); + PRINT_SIZE(uct_sockaddr_ugni_t); + PRINT_SIZE(uct_sockaddr_smsg_ugni_t); + PRINT_SIZE(uct_devaddr_ugni_t); PRINT_SIZE(uct_ugni_device_t); PRINT_SIZE(uct_ugni_ep_t); PRINT_SIZE(uct_ugni_iface_t); PRINT_SIZE(uct_ugni_md_t); PRINT_SIZE(uct_ugni_compact_smsg_attr_t); - printf("\n"); } #endif +} +static void print_ucp() +{ printf("\nUCP:\n"); PRINT_SIZE(ucp_context_t); PRINT_SIZE(ucp_worker_t); @@ -291,5 +303,16 @@ void print_type_info(const char * tl_name) PRINT_SIZE(ucp_mem_t); PRINT_SIZE(ucp_rkey_t); PRINT_SIZE(ucp_wireup_msg_t); +} +void print_type_info(const char *tl_name) +{ + print_ucs(tl_name); + print_uct(tl_name); + print_ib(tl_name); + print_rc(tl_name); + print_dc(tl_name); + print_ud(tl_name); + print_ugni(tl_name); + print_ucp(); } diff --git a/src/tools/perf/lib/ucp_tests.cc b/src/tools/perf/lib/ucp_tests.cc index 63b336e47e4..9bf04eb3a8e 100644 --- a/src/tools/perf/lib/ucp_tests.cc +++ b/src/tools/perf/lib/ucp_tests.cc @@ -1033,35 +1033,69 @@ class ucp_perf_test_runner { #define TEST_CASE_ALL_AM(_perf, _case) \ TEST_CASE(_perf, UCS_PP_TUPLE_0 _case, UCS_PP_TUPLE_1 _case, 0, 0) -ucs_status_t ucp_perf_test_dispatch(ucx_perf_context_t *perf) +static ucs_status_t dispatch_osd(ucx_perf_context_t *perf) { UCS_PP_FOREACH(TEST_CASE_ALL_OSD, perf, - (UCX_PERF_CMD_PUT, UCX_PERF_TEST_TYPE_PINGPONG), - (UCX_PERF_CMD_PUT, UCX_PERF_TEST_TYPE_PINGPONG_WAIT_MEM), - (UCX_PERF_CMD_PUT, UCX_PERF_TEST_TYPE_STREAM_UNI), - (UCX_PERF_CMD_GET, UCX_PERF_TEST_TYPE_STREAM_UNI), - (UCX_PERF_CMD_ADD, UCX_PERF_TEST_TYPE_STREAM_UNI), - (UCX_PERF_CMD_FADD, UCX_PERF_TEST_TYPE_STREAM_UNI), - (UCX_PERF_CMD_SWAP, UCX_PERF_TEST_TYPE_STREAM_UNI), - (UCX_PERF_CMD_CSWAP, UCX_PERF_TEST_TYPE_STREAM_UNI) - ); + (UCX_PERF_CMD_PUT, UCX_PERF_TEST_TYPE_PINGPONG), + (UCX_PERF_CMD_PUT, UCX_PERF_TEST_TYPE_PINGPONG_WAIT_MEM), + (UCX_PERF_CMD_PUT, UCX_PERF_TEST_TYPE_STREAM_UNI), + (UCX_PERF_CMD_GET, UCX_PERF_TEST_TYPE_STREAM_UNI), + (UCX_PERF_CMD_ADD, UCX_PERF_TEST_TYPE_STREAM_UNI), + (UCX_PERF_CMD_FADD, UCX_PERF_TEST_TYPE_STREAM_UNI), + (UCX_PERF_CMD_SWAP, UCX_PERF_TEST_TYPE_STREAM_UNI), + (UCX_PERF_CMD_CSWAP, UCX_PERF_TEST_TYPE_STREAM_UNI) + ); + return UCS_ERR_INVALID_PARAM; +} +static ucs_status_t dispatch_tag(ucx_perf_context_t *perf) +{ UCS_PP_FOREACH(TEST_CASE_ALL_TAG, perf, - (UCX_PERF_CMD_TAG, UCX_PERF_TEST_TYPE_PINGPONG), - (UCX_PERF_CMD_TAG, UCX_PERF_TEST_TYPE_STREAM_UNI), - (UCX_PERF_CMD_TAG_SYNC, UCX_PERF_TEST_TYPE_PINGPONG), - (UCX_PERF_CMD_TAG_SYNC, UCX_PERF_TEST_TYPE_STREAM_UNI) - ); + (UCX_PERF_CMD_TAG, UCX_PERF_TEST_TYPE_PINGPONG), + (UCX_PERF_CMD_TAG, UCX_PERF_TEST_TYPE_STREAM_UNI), + (UCX_PERF_CMD_TAG_SYNC, UCX_PERF_TEST_TYPE_PINGPONG), + (UCX_PERF_CMD_TAG_SYNC, UCX_PERF_TEST_TYPE_STREAM_UNI) + ); + return UCS_ERR_INVALID_PARAM; +} +static ucs_status_t dispatch_stream(ucx_perf_context_t *perf) +{ UCS_PP_FOREACH(TEST_CASE_ALL_STREAM, perf, - (UCX_PERF_CMD_STREAM, UCX_PERF_TEST_TYPE_STREAM_UNI), - (UCX_PERF_CMD_STREAM, UCX_PERF_TEST_TYPE_PINGPONG) - ); + (UCX_PERF_CMD_STREAM, UCX_PERF_TEST_TYPE_STREAM_UNI), + (UCX_PERF_CMD_STREAM, UCX_PERF_TEST_TYPE_PINGPONG) + ); + return UCS_ERR_INVALID_PARAM; +} +static ucs_status_t dispatch_am(ucx_perf_context_t *perf) +{ UCS_PP_FOREACH(TEST_CASE_ALL_AM, perf, - (UCX_PERF_CMD_AM, UCX_PERF_TEST_TYPE_PINGPONG), - (UCX_PERF_CMD_AM, UCX_PERF_TEST_TYPE_STREAM_UNI) - ); + (UCX_PERF_CMD_AM, UCX_PERF_TEST_TYPE_PINGPONG), + (UCX_PERF_CMD_AM, UCX_PERF_TEST_TYPE_STREAM_UNI) + ); + return UCS_ERR_INVALID_PARAM; +} + +typedef ucs_status_t (*ucp_dispatch_func_t)(ucx_perf_context_t *perf); + +static ucp_dispatch_func_t dispatchers[] = { + dispatch_osd, + dispatch_tag, + dispatch_stream, + dispatch_am +}; + +ucs_status_t ucp_perf_test_dispatch(ucx_perf_context_t *perf) { + ucs_status_t status; + int num_dispatchers = sizeof(dispatchers) / sizeof(dispatchers[0]); + + for (int i = 0; i < num_dispatchers; ++i) { + status = dispatchers[i](perf); + if (status != UCS_ERR_INVALID_PARAM) { + return status; + } + } ucs_error("Invalid test case: %d/%d/0x%x", perf->params.command, perf->params.test_type, diff --git a/src/tools/perf/lib/uct_tests.cc b/src/tools/perf/lib/uct_tests.cc index df3ebeb6764..adcaded49a9 100644 --- a/src/tools/perf/lib/uct_tests.cc +++ b/src/tools/perf/lib/uct_tests.cc @@ -783,6 +783,8 @@ class uct_perf_test_runner { TEST_CASE_ALL_OSD(_perf, _case, UCT_PERF_DATA_LAYOUT_BCOPY) \ TEST_CASE_ALL_OSD(_perf, _case, UCT_PERF_DATA_LAYOUT_ZCOPY) +#pragma GCC diagnostic push +#pragma GCC diagnostic ignored "-Wframe-larger-than=" ucs_status_t uct_perf_test_dispatch(ucx_perf_context_t *perf) { UCS_PP_FOREACH(TEST_CASE_ALL_DATA, perf, @@ -801,3 +803,4 @@ ucs_status_t uct_perf_test_dispatch(ucx_perf_context_t *perf) ucs_error("Invalid test case"); return UCS_ERR_INVALID_PARAM; } +#pragma GCC diagnostic pop diff --git a/src/tools/vfs/vfs_main.c b/src/tools/vfs/vfs_main.c index 27d6b604999..e879dfdd697 100644 --- a/src/tools/vfs/vfs_main.c +++ b/src/tools/vfs/vfs_main.c @@ -10,7 +10,9 @@ #include "vfs_daemon.h" +#include #include +#include #include #include #include @@ -151,10 +153,17 @@ static const char *vfs_get_process_name(int pid, char *buf, size_t max_length) int vfs_mount(int pid) { - char mountpoint[PATH_MAX]; char mountopts[1024]; char name[NAME_MAX]; + char *mountpoint; int fuse_fd, ret; + ucs_status_t status; + + status = ucs_string_alloc_path_buffer(&mountpoint, "mountpoint"); + if (status != UCS_OK) { + ret = -ENOMEM; + goto out; + } /* Add common mount options: * - File system name (source) : process name and pid @@ -168,39 +177,53 @@ int vfs_mount(int pid) vfs_get_process_name(pid, name, sizeof(name)), (strlen(g_opts.mount_opts) > 0) ? "," : "", g_opts.mount_opts); if (ret >= sizeof(mountopts)) { - return -ENOMEM; + ret = -ENOMEM; + goto out_free_mountpoint; } /* Create the mount point directory, and ignore "already exists" error */ - vfs_get_mountpoint(pid, mountpoint, sizeof(mountpoint)); + vfs_get_mountpoint(pid, mountpoint, PATH_MAX); ret = mkdir(mountpoint, S_IRWXU); if ((ret < 0) && (errno != EEXIST)) { ret = -errno; vfs_error("failed to create directory '%s': %m", mountpoint); - return ret; + goto out_free_mountpoint; } /* Mount a new FUSE filesystem in the mount point directory */ vfs_log("mounting directory '%s' with options '%s'", mountpoint, mountopts); fuse_fd = fuse_open_channel(mountpoint, mountopts); if (fuse_fd < 0) { + ret = fuse_fd; vfs_error("fuse_open_channel(%s,opts=%s) failed: %m", mountpoint, mountopts); - return fuse_fd; + goto out_free_mountpoint; } vfs_log("mounted directory '%s' with fd %d", mountpoint, fuse_fd); - return fuse_fd; + ret = fuse_fd; + +out_free_mountpoint: + ucs_free(mountpoint); +out: + return ret; } int vfs_unmount(int pid) { - char mountpoint[PATH_MAX]; + char *mountpoint; char *argv[5]; int ret; + ucs_status_t status; + + status = ucs_string_alloc_path_buffer(&mountpoint, "mountpoint"); + if (status != UCS_OK) { + ret = -ENOMEM; + goto out; + } /* Unmount FUSE file system */ - vfs_get_mountpoint(pid, mountpoint, sizeof(mountpoint)); + vfs_get_mountpoint(pid, mountpoint, PATH_MAX); argv[0] = "-u"; argv[1] = "-z"; argv[2] = "--"; @@ -208,7 +231,7 @@ int vfs_unmount(int pid) argv[4] = NULL; ret = vfs_run_fusermount(argv); if (ret < 0) { - return ret; + goto out_free_mountpoint; } /* Remove mount point directory */ @@ -216,10 +239,13 @@ int vfs_unmount(int pid) ret = rmdir(mountpoint); if (ret < 0) { vfs_error("failed to remove directory '%s': %m", mountpoint); - return ret; + goto out_free_mountpoint; } - return 0; +out_free_mountpoint: + ucs_free(mountpoint); +out: + return ret; } static int vfs_unlink_socket(int silent_notexist) diff --git a/src/ucp/proto/proto_debug.c b/src/ucp/proto/proto_debug.c index 75b09319d05..68e249d90e6 100644 --- a/src/ucp/proto/proto_debug.c +++ b/src/ucp/proto/proto_debug.c @@ -984,24 +984,30 @@ ucp_proto_select_write_info(ucp_worker_h worker, ucp_proto_query_attr_t proto_attr; size_t range_start, range_end; ucs_string_buffer_t dot_strb; - char dir_path[PATH_MAX]; + ucs_status_t status; + char *dir_path; FILE *fp; int ret; + status = ucs_string_alloc_path_buffer(&dir_path, "dir_path"); + if (status != UCS_OK) { + goto out; + } + ucp_proto_select_param_dump(worker, ep_cfg_index, rkey_cfg_index, select_param, ucp_operation_names, &ep_cfg_strb, &sel_param_strb); if (!ucp_proto_debug_is_info_enabled( worker->context, ucs_string_buffer_cstr(&sel_param_strb))) { - return; + goto out_free_dir_path; } ucs_fill_filename_template(worker->context->config.ext.proto_info_dir, - dir_path, sizeof(dir_path)); + dir_path, PATH_MAX); ret = mkdir(dir_path, S_IRWXU | S_IRGRP | S_IXGRP); if ((ret != 0) && (errno != EEXIST)) { ucs_debug("failed to create directory %s: %m", dir_path); - return; + goto out_free_dir_path; } ucs_string_buffer_translate(&ep_cfg_strb, ucp_proto_debug_fix_filename); @@ -1040,6 +1046,11 @@ ucp_proto_select_write_info(ucp_worker_h worker, fclose(fp); } while (range_end != SIZE_MAX); + +out_free_dir_path: + ucs_free(dir_path); +out: + return; } void ucp_proto_select_elem_trace(ucp_worker_h worker, diff --git a/src/ucp/proto/proto_multi.c b/src/ucp/proto/proto_multi.c index 0689866c2a3..5f89144c955 100644 --- a/src/ucp/proto/proto_multi.c +++ b/src/ucp/proto/proto_multi.c @@ -26,9 +26,8 @@ ucs_status_t ucp_proto_multi_init(const ucp_proto_multi_init_params_t *params, { ucp_context_h context = params->super.super.worker->context; const double max_bw_ratio = context->config.ext.multi_lane_max_ratio; - ucp_proto_perf_node_t *lanes_perf_nodes[UCP_PROTO_MAX_LANES]; - ucp_proto_common_tl_perf_t lanes_perf[UCP_PROTO_MAX_LANES]; - ucp_proto_common_tl_perf_t *lane_perf, perf; + ucp_proto_perf_node_t **lanes_perf_nodes; + ucp_proto_common_tl_perf_t *lanes_perf, *lane_perf, perf; ucp_lane_index_t lanes[UCP_PROTO_MAX_LANES]; double max_bandwidth, max_frag_ratio, min_bandwidth; ucp_lane_index_t i, lane, num_lanes; @@ -40,17 +39,29 @@ ucs_status_t ucp_proto_multi_init(const ucp_proto_multi_init_params_t *params, uint32_t weight_sum; ucs_status_t status; + lanes_perf_nodes = ucs_malloc(UCP_PROTO_MAX_LANES * + sizeof(*lanes_perf_nodes), + "lanes_perf_nodes"); + lanes_perf = ucs_malloc(UCP_PROTO_MAX_LANES * sizeof(*lanes_perf), + "lanes_perf"); + if ((lanes_perf_nodes == NULL) || (lanes_perf == NULL)) { + status = UCS_ERR_NO_MEMORY; + goto out; + } + ucs_assert(params->max_lanes >= 1); ucs_assert(params->max_lanes <= UCP_PROTO_MAX_LANES); if ((ucp_proto_select_op_flags(params->super.super.select_param) & UCP_PROTO_SELECT_OP_FLAG_RESUME) && !(params->super.flags & UCP_PROTO_COMMON_INIT_FLAG_RESUME)) { - return UCS_ERR_UNSUPPORTED; + status = UCS_ERR_UNSUPPORTED; + goto out; } if (!ucp_proto_common_init_check_err_handling(¶ms->super)) { - return UCS_ERR_UNSUPPORTED; + status = UCS_ERR_UNSUPPORTED; + goto out; } /* Find first lane */ @@ -60,7 +71,8 @@ ucs_status_t ucp_proto_multi_init(const ucp_proto_multi_init_params_t *params, if (num_lanes == 0) { ucs_trace("no lanes for %s", ucp_proto_id_field(params->super.super.proto_id, name)); - return UCS_ERR_NO_ELEM; + status = UCS_ERR_NO_ELEM; + goto out; } /* Find rest of the lanes */ @@ -78,7 +90,7 @@ ucs_status_t ucp_proto_multi_init(const ucp_proto_multi_init_params_t *params, status = ucp_proto_common_get_lane_perf(¶ms->super, lane, lane_perf, &lanes_perf_nodes[lane]); if (status != UCS_OK) { - return status; + goto out; } /* Calculate maximal bandwidth of all lanes, to skip slow lanes */ @@ -248,6 +260,10 @@ ucs_status_t ucp_proto_multi_init(const ucp_proto_multi_init_params_t *params, } ucp_proto_perf_node_deref(&perf_node); +out: + ucs_free(lanes_perf_nodes); + ucs_free(lanes_perf); + return status; } diff --git a/src/ucs/config/parser.c b/src/ucs/config/parser.c index f3d452e6809..5d4c20edce5 100644 --- a/src/ucs/config/parser.c +++ b/src/ucs/config/parser.c @@ -1614,15 +1614,21 @@ void ucs_config_parse_config_file(const char *dir_path, const char *file_name, .section_info = {.name = "", .skip = 0} }; - char file_path[MAXPATHLEN]; + char *file_path; int parse_result; FILE* file; + ucs_status_t status; + + status = ucs_string_alloc_path_buffer(&file_path, "file_path"); + if (status != UCS_OK) { + goto out; + } ucs_snprintf_safe(file_path, MAXPATHLEN, "%s/%s", dir_path, file_name); file = fopen(file_path, "r"); if (file == NULL) { ucs_debug("failed to open config file %s: %m", file_path); - return; + goto out_free_file_path; } parse_result = ini_parse_file(file, ucs_config_parse_config_file_line, @@ -1633,6 +1639,11 @@ void ucs_config_parse_config_file(const char *dir_path, const char *file_name, ucs_debug("parsed config file %s", file_path); fclose(file); + +out_free_file_path: + ucs_free(file_path); +out: + return; } static ucs_status_t @@ -1750,8 +1761,14 @@ static ucs_status_t ucs_config_parser_get_sub_prefix(const char *env_prefix, void ucs_config_parse_config_files() { + char *path; const char *path_p; - char path[PATH_MAX]; + ucs_status_t status; + + status = ucs_string_alloc_path_buffer(&path, "path"); + if (status != UCS_OK) { + goto out; + } /* System-wide configuration file */ ucs_config_parse_config_file(UCX_CONFIG_DIR, UCX_CONFIG_FILE_NAME, 1); @@ -1778,6 +1795,11 @@ void ucs_config_parse_config_files() /* Current working dir */ ucs_config_parse_config_file(".", UCX_CONFIG_FILE_NAME, 1); + +out_free_path: + ucs_free(path); +out: + return; } ucs_status_t diff --git a/src/ucs/debug/log.c b/src/ucs/debug/log.c index 110c1576115..8da585db7f1 100644 --- a/src/ucs/debug/log.c +++ b/src/ucs/debug/log.c @@ -145,15 +145,27 @@ static void ucs_log_get_file_name(char *log_file_name, size_t max, int idx) static void ucs_log_file_rotate() { - char old_log_file_name[PATH_MAX]; - char new_log_file_name[PATH_MAX]; + char *old_log_file_name, *new_log_file_name; int idx, ret; + ucs_status_t status; + + status = ucs_string_alloc_path_buffer(&old_log_file_name, + "old_log_file_name"); + if (status != UCS_OK) { + goto out; + } + + status = ucs_string_alloc_path_buffer(&new_log_file_name, + "new_log_file_name"); + if (status != UCS_OK) { + goto out_free_old_log_file_name; + } if (ucs_log_file_last_idx == ucs_global_opts.log_file_rotate) { /* remove the last file and log rotation from the * `log_file_rotate - 1` file */ ucs_log_get_file_name(old_log_file_name, - sizeof(old_log_file_name), + PATH_MAX, ucs_log_file_last_idx); unlink(old_log_file_name); } else { @@ -164,9 +176,9 @@ static void ucs_log_file_rotate() for (idx = ucs_log_file_last_idx - 1; idx >= 0; --idx) { ucs_log_get_file_name(old_log_file_name, - sizeof(old_log_file_name), idx); + PATH_MAX, idx); ucs_log_get_file_name(new_log_file_name, - sizeof(new_log_file_name), idx + 1); + PATH_MAX, idx + 1); if (access(old_log_file_name, W_OK) != 0) { ucs_fatal("unable to write to %s", old_log_file_name); @@ -188,6 +200,13 @@ static void ucs_log_file_rotate() ucs_fatal("unable to write to %s", new_log_file_name); } } + +out_free_new_log_file_name: + ucs_free(new_log_file_name); +out_free_old_log_file_name: + ucs_free(old_log_file_name); +out: + return; } static void ucs_log_handle_file_max_size(int log_entry_len) diff --git a/src/ucs/debug/memtrack.c b/src/ucs/debug/memtrack.c index 973a3e44e1b..d39f562a7d5 100644 --- a/src/ucs/debug/memtrack.c +++ b/src/ucs/debug/memtrack.c @@ -433,10 +433,10 @@ void ucs_memtrack_init() return; } + ucs_memtrack_vfs_init(); + ucs_debug("memtrack enabled"); ucs_memtrack_context.enabled = 1; - - ucs_memtrack_vfs_init(); } void ucs_memtrack_cleanup() @@ -447,12 +447,11 @@ void ucs_memtrack_cleanup() return; } - ucs_vfs_obj_remove(&ucs_memtrack_context); - ucs_memtrack_generate_report(); - /* disable before releasing the stats node */ + /* disable before releasing the vfs object and the stats node */ ucs_memtrack_context.enabled = 0; + ucs_vfs_obj_remove(&ucs_memtrack_context); UCS_STATS_NODE_FREE(ucs_memtrack_context.stats); /* cleanup entries */ diff --git a/src/ucs/memory/numa.c b/src/ucs/memory/numa.c index 6ce4f3aa4b0..41c6d376f4f 100644 --- a/src/ucs/memory/numa.c +++ b/src/ucs/memory/numa.c @@ -125,16 +125,25 @@ ucs_numa_node_t ucs_numa_node_of_cpu(int cpu) { /* Used for caching to improve performance */ static ucs_numa_node_t cpu_numa_node[__CPU_SETSIZE] = {0}; + char *core_dir_path; ucs_numa_node_t node; - char core_dir_path[PATH_MAX]; + ucs_status_t status; ucs_assert(cpu < __CPU_SETSIZE); if (cpu_numa_node[cpu] == 0) { + status = ucs_string_alloc_path_buffer(&core_dir_path, "core_dir_path"); + if (status != UCS_OK) { + return UCS_NUMA_NODE_UNDEFINED; + } + ucs_snprintf_safe(core_dir_path, PATH_MAX, UCS_NUMA_CORE_DIR_PATH, cpu); - node = ucs_numa_get_max_dirent(core_dir_path, "node", - ucs_numa_num_configured_nodes(), - UCS_NUMA_NODE_DEFAULT); + node = ucs_numa_get_max_dirent(core_dir_path, "node", + ucs_numa_num_configured_nodes(), + UCS_NUMA_NODE_DEFAULT); + + ucs_free(core_dir_path); + cpu_numa_node[cpu] = node + 1; } diff --git a/src/ucs/sys/module.c b/src/ucs/sys/module.c index a4e6e742983..a52d36c91ec 100644 --- a/src/ucs/sys/module.c +++ b/src/ucs/sys/module.c @@ -175,17 +175,26 @@ static void ucs_module_init(const char *module_path, void *dl) const char *module_init_name = UCS_PP_MAKE_STRING(UCS_MODULE_CONSTRUCTOR_NAME); - char *fullpath, buffer[PATH_MAX]; + char *fullpath, *buffer; init_func_t init_func; ucs_status_t status; + status = ucs_string_alloc_path_buffer(&buffer, "buffer"); + if (status != UCS_OK) { + goto out; + } + fullpath = realpath(module_path, buffer); + if (fullpath == NULL) { + goto out_free_buffer; + } + ucs_module_trace("loaded %s [%p]", fullpath, dl); init_func = (init_func_t)ucs_module_dlsym_shallow(module_path, dl, module_init_name); if (init_func == NULL) { - return; + goto out_free_buffer; } ucs_module_trace("calling '%s' in '%s': [%p]", module_init_name, fullpath, @@ -196,6 +205,11 @@ static void ucs_module_init(const char *module_path, void *dl) ucs_status_string(status)); dlclose(dl); } + +out_free_buffer: + ucs_free(buffer); +out: + return; } @@ -217,16 +231,22 @@ static int ucs_module_is_enabled(const char *module_name) static void ucs_module_load_one(const char *framework, const char *module_name, unsigned flags) { - char module_path[PATH_MAX] = {0}; + char *module_path; const char *error; unsigned i; void *dl; int mode; + ucs_status_t status; + + status = ucs_string_alloc_path_buffer(&module_path, "module_path"); + if (status != UCS_OK) { + goto out; + } if (!ucs_module_is_enabled(module_name)) { ucs_module_trace("module '%s' is disabled by configuration", module_name); - return; + goto out_free_module_path; } mode = RTLD_LAZY; @@ -242,7 +262,7 @@ static void ucs_module_load_one(const char *framework, const char *module_name, ucs_module_trace("loading module '%s' with mode 0x%x", module_name, mode); for (i = 0; i < ucs_module_loader_state.srchpath_cnt; ++i) { - snprintf(module_path, sizeof(module_path) - 1, "%s/lib%s_%s%s", + snprintf(module_path, PATH_MAX, "%s/lib%s_%s%s", ucs_module_loader_state.srch_path[i], framework, module_name, ucs_module_loader_state.module_ext); @@ -251,7 +271,7 @@ static void ucs_module_load_one(const char *framework, const char *module_name, dl = dlopen(module_path, mode); if (dl != NULL) { ucs_module_init(module_path, dl); - break; + goto out_free_module_path; } else { /* If a module fails to load, silently give up */ error = dlerror(); @@ -260,6 +280,10 @@ static void ucs_module_load_one(const char *framework, const char *module_name, } } +out_free_module_path: + ucs_free(module_path); +out: + return; /* coverity[leaked_storage] : a loaded module is never unloaded */ } #endif /* UCX_SHARED_LIB */ diff --git a/src/ucs/sys/sock.c b/src/ucs/sys/sock.c index a2a65b74987..56b4df76797 100644 --- a/src/ucs/sys/sock.c +++ b/src/ucs/sys/sock.c @@ -170,15 +170,23 @@ int ucs_netif_is_active(const char *if_name, sa_family_t af) unsigned ucs_netif_bond_ad_num_ports(const char *bond_name) { + char *lowest_path_buf; ucs_status_t status; long ad_num_ports; const char *bond_path; - char lowest_path_buf[PATH_MAX]; + unsigned ret; + + status = ucs_string_alloc_path_buffer(&lowest_path_buf, "lowest_path_buf"); + if (status != UCS_OK) { + ret = 1; + goto out_free_lowest_path_buf; + } status = ucs_netif_get_lowest_device_path(bond_name, lowest_path_buf, PATH_MAX); if (status != UCS_OK) { - return 1; + ret = 1; + goto out_free_lowest_path_buf; } bond_path = ucs_dirname(lowest_path_buf, 1); @@ -189,10 +197,16 @@ unsigned ucs_netif_bond_ad_num_ports(const char *bond_name) ucs_trace("failed to read from %s/%s: %m, " "assuming 802.3ad bonding is disabled", bond_path, UCS_BOND_NUM_PORTS_FILE); - return 1; + ret = 1; + goto out_free_lowest_path_buf; } - return (unsigned)ad_num_ports; + ret = (unsigned)ad_num_ports; + +out_free_lowest_path_buf: + ucs_free(lowest_path_buf); +out: + return ret; } ucs_status_t ucs_socket_create(int domain, int type, int *fd_p) diff --git a/src/ucs/vfs/base/vfs_obj.c b/src/ucs/vfs/base/vfs_obj.c index 2a089411930..ed526ffd343 100644 --- a/src/ucs/vfs/base/vfs_obj.c +++ b/src/ucs/vfs/base/vfs_obj.c @@ -223,17 +223,28 @@ static void ucs_vfs_node_build_path(ucs_vfs_node_t *parent_node, static ucs_vfs_node_t * ucs_vfs_node_add_subdir(ucs_vfs_node_t *parent_node, const char *name) { - char path_buf[PATH_MAX]; - ucs_vfs_node_t *node; + ucs_vfs_node_t *node = NULL; + char *path_buf; + ucs_status_t status; + + status = ucs_string_alloc_path_buffer(&path_buf, "path_buf"); + if (status != UCS_OK) { + goto out; + } - ucs_vfs_node_build_path(parent_node, name, path_buf, sizeof(path_buf)); + ucs_vfs_node_build_path(parent_node, name, path_buf, PATH_MAX); node = ucs_vfs_node_find_by_path(path_buf); if (node != NULL) { - return node; + goto out_free_path_buf; } - return ucs_vfs_node_create(parent_node, path_buf, UCS_VFS_NODE_TYPE_SUBDIR, + node = ucs_vfs_node_create(parent_node, path_buf, UCS_VFS_NODE_TYPE_SUBDIR, NULL); + +out_free_path_buf: + ucs_free(path_buf); +out: + return node; } static int ucs_vfs_node_need_update_path(ucs_vfs_node_type_t type, @@ -258,18 +269,28 @@ static ucs_status_t ucs_vfs_node_add(void *parent_obj, ucs_vfs_node_type_t type, void *obj, const char *rel_path, va_list ap, ucs_vfs_node_t **new_node) { + char *rel_path_buf, *abs_path_buf, *token, *next_token; ucs_vfs_node_t *current_node; - char rel_path_buf[PATH_MAX]; - char abs_path_buf[PATH_MAX]; - char *token, *next_token; + ucs_status_t status; + + status = ucs_string_alloc_path_buffer(&rel_path_buf, "rel_path_buf"); + if (status != UCS_OK) { + goto out; + } + + status = ucs_string_alloc_path_buffer(&abs_path_buf, "abs_path_buf"); + if (status != UCS_OK) { + goto out_free_rel_path_buf; + } current_node = ucs_vfs_node_get_by_obj(parent_obj); if (current_node == NULL) { - return UCS_ERR_INVALID_PARAM; + status = UCS_ERR_INVALID_PARAM; + goto out_free_abs_path_buf; } /* generate the relative path */ - ucs_vsnprintf_safe(rel_path_buf, sizeof(rel_path_buf), rel_path, ap); + ucs_vsnprintf_safe(rel_path_buf, PATH_MAX, rel_path, ap); /* Build parent nodes along the rel_path, without associated object */ next_token = rel_path_buf; @@ -277,31 +298,39 @@ static ucs_status_t ucs_vfs_node_add(void *parent_obj, ucs_vfs_node_type_t type, while (next_token != NULL) { current_node = ucs_vfs_node_add_subdir(current_node, token); if (current_node == NULL) { - return UCS_ERR_NO_MEMORY; + status = UCS_ERR_NO_MEMORY; + goto out_free_abs_path_buf; } token = strsep(&next_token, "/"); } ucs_vfs_node_build_path(current_node, token, abs_path_buf, - sizeof(abs_path_buf)); + PATH_MAX); if (ucs_vfs_node_need_update_path(type, abs_path_buf, obj)) { - ucs_vfs_node_update_path(obj, abs_path_buf, sizeof(abs_path_buf)); + ucs_vfs_node_update_path(obj, abs_path_buf, PATH_MAX); } if (ucs_vfs_node_find_by_path(abs_path_buf) != NULL) { - return UCS_ERR_ALREADY_EXISTS; + status = UCS_ERR_ALREADY_EXISTS; + goto out_free_abs_path_buf; } current_node = ucs_vfs_node_create(current_node, abs_path_buf, type, obj); if (current_node == NULL) { - return UCS_ERR_NO_MEMORY; + status = UCS_ERR_NO_MEMORY; + goto out_free_abs_path_buf; } *new_node = current_node; - return UCS_OK; +out_free_abs_path_buf: + ucs_free(abs_path_buf); +out_free_rel_path_buf: + ucs_free(rel_path_buf); +out: + return status; } /* must be called with lock held */ diff --git a/src/ucs/vfs/fuse/vfs_fuse.c b/src/ucs/vfs/fuse/vfs_fuse.c index a2c684d919f..8d60ee11d7f 100644 --- a/src/ucs/vfs/fuse/vfs_fuse.c +++ b/src/ucs/vfs/fuse/vfs_fuse.c @@ -242,16 +242,21 @@ static void ucs_vfs_fuse_main() static ucs_status_t ucs_vfs_fuse_wait_for_path(const char *path) { #ifdef HAVE_INOTIFY + char *dir_buf; char event_buf[sizeof(struct inotify_event) + NAME_MAX]; const struct inotify_event *event; char watch_filename[NAME_MAX]; const char *watch_dirname; - char dir_buf[PATH_MAX]; ucs_status_t status; ssize_t nread; size_t offset; int ret; + status = ucs_string_alloc_path_buffer(&dir_buf, "dir_buf"); + if (status != UCS_OK) { + goto out; + } + pthread_mutex_lock(&ucs_vfs_fuse_context.mutex); /* Check 'stop' flag before entering the loop. If the main thread sets @@ -261,14 +266,14 @@ static ucs_status_t ucs_vfs_fuse_wait_for_path(const char *path) */ if (ucs_vfs_fuse_context.stop) { status = UCS_ERR_CANCELED; - goto out; + goto out_unlock; } /* Create directory path */ ret = ucs_vfs_sock_mkdir(path, UCS_LOG_LEVEL_DIAG); if (ret != 0) { status = UCS_ERR_IO_ERROR; - goto out; + goto out_unlock; } /* Create inotify channel */ @@ -283,11 +288,11 @@ static ucs_status_t ucs_vfs_fuse_wait_for_path(const char *path) ucs_error("inotify_init() failed: %m"); } status = UCS_ERR_IO_ERROR; - goto out; + goto out_unlock; } /* copy path components to 'dir_buf' and 'watch_filename' */ - ucs_strncpy_safe(dir_buf, path, sizeof(dir_buf)); + ucs_strncpy_safe(dir_buf, path, PATH_MAX); ucs_strncpy_safe(watch_filename, ucs_basename(path), sizeof(watch_filename)); watch_dirname = dirname(dir_buf); @@ -366,8 +371,11 @@ static ucs_status_t ucs_vfs_fuse_wait_for_path(const char *path) out_close_inotify_fd: close(ucs_vfs_fuse_context.inotify_fd); ucs_vfs_fuse_context.inotify_fd = -1; -out: +out_unlock: pthread_mutex_unlock(&ucs_vfs_fuse_context.mutex); +out_free_dir_buf: + ucs_free(dir_buf); +out: return status; #else return UCS_ERR_UNSUPPORTED; diff --git a/src/ucs/vfs/sock/vfs_sock.c b/src/ucs/vfs/sock/vfs_sock.c index 189029ccfd9..614e6dbd9fa 100644 --- a/src/ucs/vfs/sock/vfs_sock.c +++ b/src/ucs/vfs/sock/vfs_sock.c @@ -12,6 +12,7 @@ #include #include +#include #include #include #include @@ -40,18 +41,29 @@ void ucs_vfs_sock_get_address(struct sockaddr_un *un_addr) int ucs_vfs_sock_mkdir(const char *sock_path, ucs_log_level_t log_level) { - char sock_path_dir[PATH_MAX]; + char *sock_path_dir; int ret; + ucs_status_t status; - ucs_strncpy_safe(sock_path_dir, sock_path, sizeof(sock_path_dir)); + status = ucs_string_alloc_path_buffer(&sock_path_dir, "sock_path_dir"); + if (status != UCS_OK) { + ret = -ENOMEM; + goto out; + } + + ucs_strncpy_safe(sock_path_dir, sock_path, PATH_MAX); ret = mkdir(dirname(sock_path_dir), S_IRWXU); if ((ret < 0) && (errno != EEXIST)) { ucs_log(log_level, "failed to create directory '%s': %m", sock_path_dir); - return -errno; + ret = -errno; + goto out_free_sock_path_dir; } - return 0; +out_free_sock_path_dir: + ucs_free(sock_path_dir); +out: + return ret; } int ucs_vfs_sock_setopt_passcred(int sockfd) diff --git a/src/uct/ib/base/ib_device.c b/src/uct/ib/base/ib_device.c index d88918e4fe6..8e68025117b 100644 --- a/src/uct/ib/base/ib_device.c +++ b/src/uct/ib/base/ib_device.c @@ -504,18 +504,23 @@ ucs_status_t uct_ib_device_query(uct_ib_device_t *dev, const char *dev_name = uct_ib_device_name(dev); const char *dev_path = dev->ibv_context->device->ibdev_path; const unsigned sys_device_priority = 20; - char path_buffer[PATH_MAX]; - const char *sysfs_path; ucs_status_t status; + char *path_buffer; + const char *sysfs_path; uint8_t i; int ret; + status = ucs_string_alloc_path_buffer(&path_buffer, "path_buffer"); + if (status != UCS_OK) { + goto out; + } + status = uct_ib_query_device(dev->ibv_context, &dev->dev_attr); if (status != UCS_OK) { - return status; + goto out_free_path_buffer; } - /* Check device type*/ + /* Check device type */ switch (ibv_device->node_type) { case IBV_NODE_SWITCH: dev->first_port = 0; @@ -540,7 +545,8 @@ ucs_status_t uct_ib_device_query(uct_ib_device_t *dev, &dev->port_attr[i]); if (ret != 0) { ucs_error("ibv_query_port() returned %d: %m", ret); - return UCS_ERR_IO_ERROR; + status = UCS_ERR_IO_ERROR; + goto out_free_path_buffer; } } @@ -550,7 +556,10 @@ ucs_status_t uct_ib_device_query(uct_ib_device_t *dev, uct_ib_device_set_pci_id(dev, sysfs_path); dev->pci_bw = ucs_topo_get_pci_bw(dev_name, sysfs_path); - return UCS_OK; +out_free_path_buffer: + ucs_free(path_buffer); +out: + return status; } ucs_status_t uct_ib_device_init(uct_ib_device_t *dev, diff --git a/src/uct/ib/mlx5/dv/ib_mlx5dv_md.c b/src/uct/ib/mlx5/dv/ib_mlx5dv_md.c index d3fc8774319..e185b33235e 100644 --- a/src/uct/ib/mlx5/dv/ib_mlx5dv_md.c +++ b/src/uct/ib/mlx5/dv/ib_mlx5dv_md.c @@ -2107,11 +2107,13 @@ ucs_status_t uct_ib_mlx5_devx_md_open(struct ibv_device *ibv_device, const uct_ib_md_config_t *md_config, uct_ib_md_t **p_md) { - char out[UCT_IB_MLX5DV_ST_SZ_BYTES(query_hca_cap_out)] = {}; - char in[UCT_IB_MLX5DV_ST_SZ_BYTES(query_hca_cap_in)] = {}; - char cap_2_out[UCT_IB_MLX5DV_ST_SZ_BYTES(query_hca_cap_out)] = {}; - ucs_status_t status = UCS_OK; - uint8_t lag_state = 0; + size_t out_len = UCT_IB_MLX5DV_ST_SZ_BYTES(query_hca_cap_out); + size_t in_len = UCT_IB_MLX5DV_ST_SZ_BYTES(query_hca_cap_in); + char *out = ucs_calloc(1, out_len, "out"); + char *in = ucs_calloc(1, in_len, "in"); + char *cap_2_out = ucs_calloc(1, out_len, "cap_2_out"); + ucs_status_t status = UCS_OK; + uint8_t lag_state = 0; void *cap_2; uint8_t log_max_qp; uint16_t vhca_id; @@ -2125,20 +2127,26 @@ ucs_status_t uct_ib_mlx5_devx_md_open(struct ibv_device *ibv_device, ucs_mpool_params_t mp_params; int ksm_atomic; + if ((out == NULL) || (in == NULL) || (cap_2_out == NULL)) { + ucs_error("Failed to allocate memory for HCA capability buffers"); + status = UCS_ERR_NO_MEMORY; + goto err; + } + if (!mlx5dv_is_supported(ibv_device)) { status = UCS_ERR_UNSUPPORTED; - goto err; + goto err_free_buffers; } if (md_config->devx == UCS_NO) { status = UCS_ERR_UNSUPPORTED; - goto err; + goto err_free_buffers; } ctx = uct_ib_mlx5_devx_open_device(ibv_device); if (ctx == NULL) { status = UCS_ERR_UNSUPPORTED; - goto err; + goto err_free_buffers; } md = ucs_derived_of(uct_ib_md_alloc(sizeof(*md), "ib_mlx5_devx_md", ctx), @@ -2166,7 +2174,7 @@ ucs_status_t uct_ib_mlx5_devx_md_open(struct ibv_device *ibv_device, UCT_IB_MLX5DV_SET(query_hca_cap_in, in, opcode, UCT_IB_MLX5_CMD_OP_QUERY_HCA_CAP); UCT_IB_MLX5DV_SET(query_hca_cap_in, in, op_mod, UCT_IB_MLX5_HCA_CAP_OPMOD_GET_CUR | (UCT_IB_MLX5_CAP_GENERAL << 1)); - ret = mlx5dv_devx_general_cmd(ctx, in, sizeof(in), out, sizeof(out)); + ret = mlx5dv_devx_general_cmd(ctx, in, in_len, out, out_len); if (ret != 0) { if ((errno == EPERM) || (errno == EPROTONOSUPPORT) || (errno == EOPNOTSUPP)) { @@ -2285,7 +2293,7 @@ ucs_status_t uct_ib_mlx5_devx_md_open(struct ibv_device *ibv_device, vhca_id = UCT_IB_MLX5DV_GET(cmd_hca_cap, cap, vhca_id); - status = uct_ib_mlx5_devx_query_cap_2(ctx, cap_2_out, sizeof(cap_2_out)); + status = uct_ib_mlx5_devx_query_cap_2(ctx, cap_2_out, out_len); if (status == UCS_OK) { cap_2 = UCT_IB_MLX5DV_ADDR_OF(query_hca_cap_out, cap_2_out, capability); @@ -2303,8 +2311,7 @@ ucs_status_t uct_ib_mlx5_devx_md_open(struct ibv_device *ibv_device, UCT_IB_MLX5DV_SET(query_hca_cap_in, in, op_mod, UCT_IB_MLX5_HCA_CAP_OPMOD_GET_CUR | (UCT_IB_MLX5_CAP_ATOMIC << 1)); - status = uct_ib_mlx5_devx_general_cmd(ctx, in, sizeof(in), out, - sizeof(out), + status = uct_ib_mlx5_devx_general_cmd(ctx, in, in_len, out, out_len, "QUERY_HCA_CAP, ATOMIC", 0); if (status != UCS_OK) { goto err_lru_cleanup; @@ -2406,6 +2413,9 @@ ucs_status_t uct_ib_mlx5_devx_md_open(struct ibv_device *ibv_device, uct_ib_mlx5_devx_init_flush_mr(md); *p_md = &md->super; + ucs_free(out); + ucs_free(in); + ucs_free(cap_2_out); return UCS_OK; err_dbrec_mpool_cleanup: @@ -2419,6 +2429,10 @@ ucs_status_t uct_ib_mlx5_devx_md_open(struct ibv_device *ibv_device, uct_ib_md_free(&md->super); err_free_context: uct_ib_md_device_context_close(ctx); +err_free_buffers: + ucs_free(out); + ucs_free(in); + ucs_free(cap_2_out); err: if ((status == UCS_ERR_UNSUPPORTED) && (md_config->devx == UCS_YES)) { ucs_error("DEVX requested but not supported by %s", diff --git a/src/uct/sm/mm/posix/mm_posix.c b/src/uct/sm/mm/posix/mm_posix.c index ba6de3c4bd6..d5614c8d11b 100644 --- a/src/uct/sm/mm/posix/mm_posix.c +++ b/src/uct/sm/mm/posix/mm_posix.c @@ -255,24 +255,44 @@ static ucs_status_t uct_posix_shm_open(uint64_t mmid, int open_flags, int *fd_p) static ucs_status_t uct_posix_file_open(const char *dir, uint64_t mmid, int open_flags, int* fd_p) { - char file_path[PATH_MAX]; + char *file_path; int ret; + ucs_status_t status; - ucs_snprintf_safe(file_path, sizeof(file_path), "%s" UCT_POSIX_FILE_FMT, - dir, mmid); + status = ucs_string_alloc_path_buffer(&file_path, "file_path"); + if (status != UCS_OK) { + goto out; + } + + ucs_snprintf_safe(file_path, PATH_MAX, "%s" UCT_POSIX_FILE_FMT, dir, mmid); ret = open(file_path, open_flags | O_RDWR, UCT_POSIX_SHM_OPEN_MODE); - return uct_posix_open_check_result("open", file_path, open_flags, ret, fd_p); + status = uct_posix_open_check_result("open", file_path, open_flags, ret, fd_p); + +out_free_file_path: + ucs_free(file_path); +out: + return status; } static ucs_status_t uct_posix_procfs_open(int pid, int peer_fd, int* fd_p) { - char file_path[PATH_MAX]; + char *file_path; int ret; + ucs_status_t status; + + status = ucs_string_alloc_path_buffer(&file_path, "file_path"); + if (status != UCS_OK) { + goto out; + } - ucs_snprintf_safe(file_path, sizeof(file_path), UCT_POSIX_PROCFS_FILE_FMT, - pid, peer_fd); + ucs_snprintf_safe(file_path, PATH_MAX, UCT_POSIX_PROCFS_FILE_FMT, pid, peer_fd); ret = open(file_path, O_RDWR, UCT_POSIX_SHM_OPEN_MODE); - return uct_posix_open_check_result("open", file_path, 0, ret, fd_p); + status = uct_posix_open_check_result("open", file_path, 0, ret, fd_p); + +out_free_file_path: + ucs_free(file_path); +out: + return status; } static ucs_status_t @@ -280,28 +300,40 @@ uct_posix_unlink(uct_mm_md_t *md, uint64_t seg_id, ucs_log_level_t err_level) { uct_posix_md_config_t *posix_config = ucs_derived_of(md->config, uct_posix_md_config_t); - char file_path[PATH_MAX]; + char *file_path; int ret; + ucs_status_t status; + + + status = ucs_string_alloc_path_buffer(&file_path, "file_path"); + if (status != UCS_OK) { + goto out; + } if (seg_id & UCT_POSIX_SEG_FLAG_SHM_OPEN) { - ucs_snprintf_safe(file_path, sizeof(file_path), UCT_POSIX_FILE_FMT, + ucs_snprintf_safe(file_path, PATH_MAX, UCT_POSIX_FILE_FMT, seg_id & UCT_POSIX_SEG_MMID_MASK); ret = shm_unlink(file_path); if (ret < 0) { ucs_log(err_level, "shm_unlink(%s) failed: %m", file_path); - return UCS_ERR_SHMEM_SEGMENT; + status = UCS_ERR_SHMEM_SEGMENT; + goto out_free_file_path; } } else { - ucs_snprintf_safe(file_path, sizeof(file_path), "%s" UCT_POSIX_FILE_FMT, + ucs_snprintf_safe(file_path, PATH_MAX, "%s" UCT_POSIX_FILE_FMT, posix_config->dir, seg_id & UCT_POSIX_SEG_MMID_MASK); ret = unlink(file_path); if (ret < 0) { ucs_error("unlink(%s) failed: %m", file_path); - return UCS_ERR_SHMEM_SEGMENT; + status = UCS_ERR_SHMEM_SEGMENT; + goto out_free_file_path; } } - return UCS_OK; +out_free_file_path: + ucs_free(file_path); +out: + return status; } static ucs_status_t diff --git a/src/uct/tcp/tcp_iface.c b/src/uct/tcp/tcp_iface.c index 38c31bfac81..5c1488ad640 100644 --- a/src/uct/tcp/tcp_iface.c +++ b/src/uct/tcp/tcp_iface.c @@ -244,9 +244,14 @@ uct_tcp_iface_is_reachable_v2(const uct_iface_h tl_iface, static const char * uct_tcp_iface_get_sysfs_path(const char *dev_name, char *path_buffer) { + const char *sysfs_path = NULL; ucs_status_t status; - const char *sysfs_path; - char lowest_path_buf[PATH_MAX]; + char *lowest_path_buf; + + status = ucs_string_alloc_path_buffer(&lowest_path_buf, "lowest_path_buf"); + if (status != UCS_OK) { + goto out; + } /* Deep search to find the lowest device sysfs path: * 1) For regular device, use regular sysfs form. @@ -255,11 +260,15 @@ uct_tcp_iface_get_sysfs_path(const char *dev_name, char *path_buffer) status = ucs_netif_get_lowest_device_path(dev_name, lowest_path_buf, PATH_MAX); if (status != UCS_OK) { - return NULL; + goto out_free_lowest_path_buf; } /* 'path_buffer' size is PATH_MAX */ sysfs_path = ucs_topo_resolve_sysfs_path(lowest_path_buf, path_buffer); + +out_free_lowest_path_buf: + ucs_free(lowest_path_buf); +out: return sysfs_path; } @@ -272,14 +281,19 @@ static ucs_status_t uct_tcp_iface_query(uct_iface_h tl_iface, ucs_status_t status; int is_default; double pci_bw, network_bw, calculated_bw; - char path_buffer[PATH_MAX]; + char *path_buffer; const char *sysfs_path; + status = ucs_string_alloc_path_buffer(&path_buffer, "path_buffer"); + if (status != UCS_OK) { + goto out; + } + uct_base_iface_query(&iface->super, attr); status = uct_tcp_netif_caps(iface->if_name, &attr->latency.c, &network_bw); if (status != UCS_OK) { - return status; + goto out_free_path_buffer; } sysfs_path = uct_tcp_iface_get_sysfs_path(iface->if_name, path_buffer); @@ -339,7 +353,7 @@ static ucs_status_t uct_tcp_iface_query(uct_iface_h tl_iface, if (iface->config.prefer_default) { status = uct_tcp_netif_is_default(iface->if_name, &is_default); if (status != UCS_OK) { - return status; + goto out_free_path_buffer; } attr->priority = is_default ? 0 : 1; @@ -347,7 +361,10 @@ static ucs_status_t uct_tcp_iface_query(uct_iface_h tl_iface, attr->priority = 0; } - return UCS_OK; +out_free_path_buffer: + ucs_free(path_buffer); +out: + return status; } static ucs_status_t uct_tcp_iface_event_fd_get(uct_iface_h tl_iface, int *fd_p) @@ -882,13 +899,26 @@ static UCS_CLASS_DEFINE_NEW_FUNC(uct_tcp_iface_t, uct_iface_t, uct_md_h, static int uct_tcp_is_bridge(const char *if_name) { - char path[PATH_MAX]; + char *path; + int ret; struct stat st; + ucs_status_t status; + + status = ucs_string_alloc_path_buffer(&path, "path"); + if (status != UCS_OK) { + ret = 0; + goto out; + } ucs_snprintf_safe(path, PATH_MAX, UCT_TCP_IFACE_NETDEV_DIR "/%s/bridge", if_name); - return (stat(path, &st) == 0) && S_ISDIR(st.st_mode); + ret = (stat(path, &st) == 0) && S_ISDIR(st.st_mode); + +out_free_path: + ucs_free(path); +out: + return ret; } ucs_status_t uct_tcp_query_devices(uct_md_h md, @@ -903,14 +933,20 @@ ucs_status_t uct_tcp_query_devices(uct_md_h md, int is_active, i, n; ucs_status_t status; const char *sysfs_path; - char path_buffer[PATH_MAX]; + char *path_buffer = ucs_malloc(PATH_MAX, "path_buffer"); ucs_sys_device_t sys_dev; + if (path_buffer == NULL) { + ucs_error("Failed to allocate memory for path buffer"); + status = UCS_ERR_NO_MEMORY; + goto out; + } + n = scandir(UCT_TCP_IFACE_NETDEV_DIR, &entries, NULL, alphasort); if (n == -1) { ucs_error("scandir(%s) failed: %m", UCT_TCP_IFACE_NETDEV_DIR); status = UCS_ERR_IO_ERROR; - goto out; + goto out_free_buffer; } devices = NULL; @@ -977,6 +1013,8 @@ ucs_status_t uct_tcp_query_devices(uct_md_h md, } free(entries); +out_free_buffer: + ucs_free(path_buffer); out: return status; } diff --git a/test/gtest/common/googletest/gtest-param-test.h b/test/gtest/common/googletest/gtest-param-test.h index 3bd14a67f52..c4fd37e6647 100644 --- a/test/gtest/common/googletest/gtest-param-test.h +++ b/test/gtest/common/googletest/gtest-param-test.h @@ -457,38 +457,51 @@ internal::CartesianProductHolder Combine(const Generator&... g) { #define GTEST_GET_FIRST_(first, ...) first #define GTEST_GET_SECOND_(first, second, ...) second -#define INSTANTIATE_TEST_SUITE_P(prefix, test_suite_name, ...) \ - static ::testing::internal::ParamGenerator \ - gtest_##prefix##test_suite_name##_EvalGenerator_() { \ - return GTEST_EXPAND_(GTEST_GET_FIRST_(__VA_ARGS__, DUMMY_PARAM_)); \ - } \ - static ::std::string gtest_##prefix##test_suite_name##_EvalGenerateName_( \ - const ::testing::TestParamInfo& info) { \ - if (::testing::internal::AlwaysFalse()) { \ - ::testing::internal::TestNotEmpty(GTEST_EXPAND_(GTEST_GET_SECOND_( \ - __VA_ARGS__, \ - ::testing::internal::DefaultParamName, \ - DUMMY_PARAM_))); \ - auto t = std::make_tuple(__VA_ARGS__); \ - static_assert(std::tuple_size::value <= 2, \ - "Too Many Args!"); \ - } \ - return ((GTEST_EXPAND_(GTEST_GET_SECOND_( \ - __VA_ARGS__, \ - ::testing::internal::DefaultParamName, \ - DUMMY_PARAM_))))(info); \ - } \ - static int gtest_##prefix##test_suite_name##_dummy_ \ - GTEST_ATTRIBUTE_UNUSED_ = \ - ::testing::UnitTest::GetInstance() \ - ->parameterized_test_registry() \ - .GetTestSuitePatternHolder( \ - #test_suite_name, \ - ::testing::internal::CodeLocation(__FILE__, __LINE__)) \ - ->AddTestSuiteInstantiation( \ - #prefix, >est_##prefix##test_suite_name##_EvalGenerator_, \ - >est_##prefix##test_suite_name##_EvalGenerateName_, \ - __FILE__, __LINE__) +// Modified to reduce stack frame size per test file. +// The registration logic is moved to a separate function (gen_##prefix##test_suite_name) +// to minimize the complexity of static initialization. +// This defers execution of complex logic, reduces the initial stack frame, +// and prevents inlining, leading to a more efficient initialization process. +#define INSTANTIATE_TEST_SUITE_P(prefix, test_suite_name, ...) \ + static ::testing::internal::ParamGenerator \ + gtest_##prefix##test_suite_name##_EvalGenerator_() \ + { \ + return GTEST_EXPAND_(GTEST_GET_FIRST_(__VA_ARGS__, DUMMY_PARAM_)); \ + } \ + static ::std::string gtest_##prefix##test_suite_name##_EvalGenerateName_( \ + const ::testing::TestParamInfo &info) \ + { \ + if (::testing::internal::AlwaysFalse()) { \ + ::testing::internal::TestNotEmpty(GTEST_EXPAND_( \ + GTEST_GET_SECOND_(__VA_ARGS__, \ + ::testing::internal::DefaultParamName< \ + test_suite_name::ParamType>, \ + DUMMY_PARAM_))); \ + auto t = std::make_tuple(__VA_ARGS__); \ + static_assert(std::tuple_size::value <= 2, \ + "Too Many Args!"); \ + } \ + return ((GTEST_EXPAND_( \ + GTEST_GET_SECOND_(__VA_ARGS__, \ + ::testing::internal::DefaultParamName< \ + test_suite_name::ParamType>, \ + DUMMY_PARAM_))))(info); \ + } \ + int __attribute__((noinline)) gen_##prefix##test_suite_name() \ + { \ + return ::testing::UnitTest::GetInstance() \ + ->parameterized_test_registry() \ + .GetTestSuitePatternHolder( \ + #test_suite_name, \ + ::testing::internal::CodeLocation(__FILE__, __LINE__)) \ + ->AddTestSuiteInstantiation( \ + #prefix, \ + >est_##prefix##test_suite_name##_EvalGenerator_, \ + >est_##prefix##test_suite_name##_EvalGenerateName_, \ + __FILE__, __LINE__); \ + } \ + static int gtest_##prefix##test_suite_name##_dummy_ \ + GTEST_ATTRIBUTE_UNUSED_ = gen_##prefix##test_suite_name(); // Legacy API is deprecated but still available #ifndef GTEST_REMOVE_LEGACY_TEST_CASEAPI_ diff --git a/test/gtest/common/test.h b/test/gtest/common/test.h index a50341a4e5e..d65942ae375 100644 --- a/test/gtest/common/test.h +++ b/test/gtest/common/test.h @@ -265,43 +265,54 @@ class clear_dontcopy_regions { /* * Helper macro */ -#define UCS_TEST_(test_case_name, test_name, parent_id, \ - num_threads, skip_cond, skip_reason, ...) \ -class GTEST_TEST_CLASS_NAME_(test_case_name, test_name) : public test_case_name { \ - public: \ - GTEST_TEST_CLASS_NAME_(test_case_name, test_name)() { \ - set_num_threads(num_threads); \ - } \ - protected: \ - virtual void init() { \ - UCS_PP_FOREACH(UCS_TEST_SET_CONFIG, _, __VA_ARGS__) \ - test_case_name::init(); \ - } \ - private: \ - virtual void check_skip_test() { \ - if (skip_cond) { \ - UCS_TEST_SKIP_R(skip_reason); \ - } \ - } \ - virtual void test_body(); \ - static ::testing::TestInfo* const test_info_;\ - GTEST_DISALLOW_COPY_AND_ASSIGN_(\ - GTEST_TEST_CLASS_NAME_(test_case_name, test_name));\ -}; \ -\ -::testing::TestInfo* const GTEST_TEST_CLASS_NAME_(test_case_name, test_name)\ - ::test_info_ = \ - ::testing::internal::MakeAndRegisterTestInfo( \ - #test_case_name, \ - (num_threads == 1) ? #test_name : #test_name "/mt_" #num_threads, \ - "", "", \ - ::testing::internal::CodeLocation(__FILE__, __LINE__), \ - (parent_id), \ - test_case_name::SetUpTestCase, \ - test_case_name::TearDownTestCase, \ - new ::testing::internal::TestFactoryImpl< \ - GTEST_TEST_CLASS_NAME_(test_case_name, test_name)>); \ -void GTEST_TEST_CLASS_NAME_(test_case_name, test_name)::test_body() +#define UCS_TEST_(test_case_name, test_name, parent_id, num_threads, \ + skip_cond, skip_reason, ...) \ + class GTEST_TEST_CLASS_NAME_(test_case_name, test_name) : \ + public test_case_name { \ + public: \ + GTEST_TEST_CLASS_NAME_(test_case_name, test_name)() \ + { \ + set_num_threads(num_threads); \ + } \ + \ + protected: \ + virtual void init() \ + { \ + UCS_PP_FOREACH(UCS_TEST_SET_CONFIG, _, __VA_ARGS__) \ + test_case_name::init(); \ + } \ + \ + private: \ + virtual void check_skip_test() \ + { \ + if (skip_cond) { \ + UCS_TEST_SKIP_R(skip_reason); \ + } \ + } \ + virtual void test_body(); \ + static ::testing::TestInfo *const test_info_; \ + GTEST_DISALLOW_COPY_AND_ASSIGN_(GTEST_TEST_CLASS_NAME_(test_case_name, \ + test_name)); \ + \ + static ::testing::TestInfo *__attribute__((noinline)) \ + create_test_info() \ + { \ + return ::testing::internal::MakeAndRegisterTestInfo( \ + #test_case_name, \ + (num_threads == 1) ? #test_name : \ + #test_name "/mt_" #num_threads, \ + "", "", \ + ::testing::internal::CodeLocation(__FILE__, __LINE__), \ + (parent_id), test_case_name::SetUpTestCase, \ + test_case_name::TearDownTestCase, \ + new ::testing::internal::TestFactoryImpl< \ + GTEST_TEST_CLASS_NAME_(test_case_name, test_name)>); \ + } \ + }; \ + \ + ::testing::TestInfo *const GTEST_TEST_CLASS_NAME_( \ + test_case_name, test_name)::test_info_ = create_test_info(); \ + void GTEST_TEST_CLASS_NAME_(test_case_name, test_name)::test_body() /* @@ -334,44 +345,58 @@ void GTEST_TEST_CLASS_NAME_(test_case_name, test_name)::test_body() /* * Helper macro */ -#define UCS_TEST_P_(test_case_name, test_name, num_threads, \ - skip_cond, skip_reason, ...) \ - class GTEST_TEST_CLASS_NAME_(test_case_name, test_name) \ - : public test_case_name { \ - public: \ - GTEST_TEST_CLASS_NAME_(test_case_name, test_name)() { \ - set_num_threads(num_threads); \ - } \ - virtual void test_body(); \ - protected: \ - virtual void init() { \ - UCS_PP_FOREACH(UCS_TEST_SET_CONFIG, _, __VA_ARGS__) \ - test_case_name::init(); \ - } \ - private: \ - virtual void check_skip_test() { \ - if (skip_cond) { \ - UCS_TEST_SKIP_R(skip_reason); \ +#define UCS_TEST_P_(test_case_name, test_name, num_threads, skip_cond, \ + skip_reason, ...) \ + class GTEST_TEST_CLASS_NAME_(test_case_name, test_name) : \ + public test_case_name { \ + public: \ + GTEST_TEST_CLASS_NAME_(test_case_name, test_name)() \ + { \ + set_num_threads(num_threads); \ } \ - } \ - static int AddToRegistry() { \ - ::testing::UnitTest::GetInstance()->parameterized_test_registry(). \ - GetTestCasePatternHolder( \ - #test_case_name, ::testing::internal::CodeLocation(__FILE__, __LINE__))->AddTestPattern( \ - #test_case_name, \ - (num_threads == 1) ? #test_name : #test_name "/mt_" #num_threads, \ - new ::testing::internal::TestMetaFactory< \ - GTEST_TEST_CLASS_NAME_(test_case_name, test_name)>()); \ - return 0; \ - } \ - static int gtest_registering_dummy_; \ - GTEST_DISALLOW_COPY_AND_ASSIGN_(\ - GTEST_TEST_CLASS_NAME_(test_case_name, test_name)); \ - }; \ - int GTEST_TEST_CLASS_NAME_(test_case_name, \ - test_name)::gtest_registering_dummy_ = \ - GTEST_TEST_CLASS_NAME_(test_case_name, test_name)::AddToRegistry(); \ - void GTEST_TEST_CLASS_NAME_(test_case_name, test_name)::test_body() + virtual void test_body(); \ + \ + protected: \ + virtual void init() \ + { \ + UCS_PP_FOREACH(UCS_TEST_SET_CONFIG, _, __VA_ARGS__) \ + test_case_name::init(); \ + } \ + \ + private: \ + virtual void check_skip_test() \ + { \ + if (skip_cond) { \ + UCS_TEST_SKIP_R(skip_reason); \ + } \ + } \ + static int AddToRegistry() \ + { \ + ::testing::UnitTest::GetInstance() \ + ->parameterized_test_registry() \ + .GetTestCasePatternHolder( \ + #test_case_name, \ + ::testing::internal::CodeLocation(__FILE__, \ + __LINE__)) \ + ->AddTestPattern( \ + #test_case_name, \ + (num_threads == 1) ? #test_name : \ + #test_name \ + "/mt_" #num_threads, \ + new ::testing::internal::TestMetaFactory< \ + GTEST_TEST_CLASS_NAME_(test_case_name, \ + test_name)>()); \ + return 0; \ + } \ + static int gtest_registering_dummy_; \ + GTEST_DISALLOW_COPY_AND_ASSIGN_(GTEST_TEST_CLASS_NAME_(test_case_name, \ + test_name)); \ + }; \ + int GTEST_TEST_CLASS_NAME_(test_case_name, \ + test_name)::gtest_registering_dummy_ = \ + GTEST_TEST_CLASS_NAME_(test_case_name, \ + test_name)::AddToRegistry(); \ + void GTEST_TEST_CLASS_NAME_(test_case_name, test_name)::test_body() /* diff --git a/test/gtest/common/test_helpers.cc b/test/gtest/common/test_helpers.cc index c484be0b20b..4917533df45 100644 --- a/test/gtest/common/test_helpers.cc +++ b/test/gtest/common/test_helpers.cc @@ -456,12 +456,13 @@ bool is_inet_addr(const struct sockaddr* ifa_addr) { static bool netif_has_sysfs_file(const char *ifa_name, const char *file_name) { - char path[PATH_MAX]; - ucs_snprintf_safe(path, sizeof(path), "/sys/class/net/%s/%s", ifa_name, - file_name); + std::string path(PATH_MAX, '\0'); + + ucs_snprintf_safe(&path[0], path.size(), "/sys/class/net/%s/%s", + ifa_name, file_name); struct stat st; - return stat(path, &st) >= 0; + return stat(path.c_str(), &st) >= 0; } bool is_interface_usable(struct ifaddrs *ifa) diff --git a/test/gtest/ucm/malloc_hook.cc b/test/gtest/ucm/malloc_hook.cc index 18519ec0844..4c4aae92f8a 100644 --- a/test/gtest/ucm/malloc_hook.cc +++ b/test/gtest/ucm/malloc_hook.cc @@ -301,7 +301,7 @@ class test_thread { private: typedef std::pair range; - bool is_ptr_in_range(void *ptr, size_t size, const std::vector &ranges) { + bool __attribute__((noinline)) is_ptr_in_range(void *ptr, size_t size, const std::vector &ranges) { uintptr_t p = (uintptr_t)ptr; for (std::vector::const_iterator iter = ranges.begin(); iter != ranges.end(); ++iter) { @@ -353,6 +353,39 @@ void test_thread::mem_event(ucm_event_type_t event_type, ucm_event_t *event) pthread_mutex_unlock(&m_stats_lock); } +static void* perform_mmap(size_t size, char fill_value) { + void *ptr = mmap(NULL, size, + PROT_READ | PROT_WRITE, MAP_PRIVATE | MAP_ANONYMOUS, + -1, 0); + EXPECT_NE(MAP_FAILED, ptr); + memset(ptr, fill_value, size); + return ptr; +} + +static void* perform_mremap(void *old_ptr, size_t old_size, size_t new_size, + void *new_addr) { + void *new_ptr = mremap(old_ptr, old_size, new_size, + MREMAP_MAYMOVE | MREMAP_FIXED, new_addr); + EXPECT_NE(MAP_FAILED, new_ptr) << strerror(errno); + return new_ptr; +} + +static void set_and_check_env_variable(pthread_mutex_t* lock, + const std::string& var_name, + const std::string& value) { + pthread_mutex_lock(lock); + setenv(var_name.c_str(), value.c_str(), 1); + char* test_str = getenv(var_name.c_str()); + + if (test_str != NULL) { + EXPECT_EQ(value, std::string(test_str)); + } else { + UCS_TEST_ABORT("getenv(\"" + var_name + "\") returned NULL"); + } + + pthread_mutex_unlock(lock); +} + void test_thread::test() { static const size_t large_alloc_size = 40 * 1024 * 1024; ucs_status_t result; @@ -363,7 +396,6 @@ void test_thread::test() { const size_t small_alloc_size = malloc_hook::small_alloc_size; int num_ptrs_in_range; static volatile uint32_t total_ptrs_in_range = 0; - char *test_str; /* Allocate some pointers with old heap manager */ for (unsigned i = 0; i < 10; ++i) { @@ -425,15 +457,7 @@ void test_thread::test() { free(s); /* Test setenv */ - pthread_mutex_lock(&lock); - setenv("TEST", "VALUE", 1); - test_str = getenv("TEST"); - if (test_str != NULL) { - EXPECT_EQ(std::string("VALUE"), test_str); - } else { - UCS_TEST_ABORT("getenv(\"TEST\") returned NULL"); - } - pthread_mutex_unlock(&lock); + set_and_check_env_variable(&lock, "TEST", "VALUE"); /* Test username */ ucs_get_user_name(); @@ -515,19 +539,11 @@ void test_thread::test() { /* mremap(FIXED) */ { - ptr = mmap(NULL, shm_seg_size, PROT_READ | PROT_WRITE, - MAP_PRIVATE | MAP_ANONYMOUS, -1, 0); - EXPECT_NE(MAP_FAILED, ptr); - memset(ptr, 'a', shm_seg_size); + ptr = perform_mmap(shm_seg_size, 'a'); - void *ptr2 = mmap(NULL, shm_seg_size, PROT_READ | PROT_WRITE, - MAP_PRIVATE | MAP_ANONYMOUS, -1, 0); - EXPECT_NE(MAP_FAILED, ptr2) << strerror(errno); - memset(ptr2, 'b', shm_seg_size); + void *ptr2 = perform_mmap(shm_seg_size, 'b'); - ptr_r = mremap(ptr, shm_seg_size, shm_seg_size, - MREMAP_MAYMOVE | MREMAP_FIXED, ptr2); - EXPECT_NE(MAP_FAILED, ptr_r) << strerror(errno); + ptr_r = perform_mremap(ptr, shm_seg_size, shm_seg_size, ptr2); EXPECT_EQ(ptr2, ptr_r); EXPECT_TRUE(is_ptr_in_range(ptr, shm_seg_size, m_unmap_ranges)); diff --git a/test/gtest/ucp/test_ucp_worker.cc b/test/gtest/ucp/test_ucp_worker.cc index 6cf01e6d229..10a43143e08 100644 --- a/test/gtest/ucp/test_ucp_worker.cc +++ b/test/gtest/ucp/test_ucp_worker.cc @@ -903,17 +903,18 @@ UCS_TEST_P(test_pci_bw, get_pci_bw) { ucp_worker_h worker = sender().worker(); ucp_context_h ctx = worker->context; - char path_buffer[PATH_MAX]; + std::string path_buffer(PATH_MAX, '\0'); const ucp_worker_iface_t *wiface; for (auto i = 0; i < worker->num_ifaces; ++i) { - wiface = worker->ifaces[i]; - const auto dev_name = ctx->tl_rscs[wiface->rsc_index].tl_rsc.dev_name; - const auto tcp_device = get_tcp_device(dev_name); - const auto dev_path = !tcp_device.empty() ? tcp_device : - get_ib_device(dev_name); + wiface = worker->ifaces[i]; + const auto dev_name = ctx->tl_rscs[wiface->rsc_index].tl_rsc.dev_name; + const auto tcp_device = get_tcp_device(dev_name); + const auto dev_path = !tcp_device.empty() ? tcp_device : + get_ib_device(dev_name); + const char *sysfs_path = ucs_topo_resolve_sysfs_path(dev_path.c_str(), - path_buffer); + &path_buffer[0]); const double pci_bw = ucs_topo_get_pci_bw(dev_name, sysfs_path); uct_iface_attr_t attr; diff --git a/test/gtest/ucs/test_bitops.cc b/test/gtest/ucs/test_bitops.cc index 0e5bcccfb09..37dd5c27f11 100644 --- a/test/gtest/ucs/test_bitops.cc +++ b/test/gtest/ucs/test_bitops.cc @@ -90,112 +90,52 @@ UCS_TEST_F(test_bitops, ptr_ctz) { ASSERT_EQ(88, ucs_count_ptr_trailing_zero_bits(buffer, 160)); } +void check_bitwise_equality(const uint8_t *buffer1, + const uint8_t *buffer2, + const std::vector& indices, + int max_equal_index) { + for (int i : indices) { + if (i <= max_equal_index) { + ASSERT_TRUE(ucs_bitwise_is_equal(buffer1, buffer2, i)); + } else { + ASSERT_FALSE(ucs_bitwise_is_equal(buffer1, buffer2, i)); + } + } +} + UCS_TEST_F(test_bitops, is_equal) { - uint8_t buffer1[20] = {0}; - uint8_t buffer2[20] = {0}; - - ASSERT_TRUE(ucs_bitwise_is_equal(buffer1, buffer2, 0)); - ASSERT_TRUE(ucs_bitwise_is_equal(buffer1, buffer2, 1)); - ASSERT_TRUE(ucs_bitwise_is_equal(buffer1, buffer2, 8)); - ASSERT_TRUE(ucs_bitwise_is_equal(buffer1, buffer2, 64)); - ASSERT_TRUE(ucs_bitwise_is_equal(buffer1, buffer2, 65)); - ASSERT_TRUE(ucs_bitwise_is_equal(buffer1, buffer2, 128)); - ASSERT_TRUE(ucs_bitwise_is_equal(buffer1, buffer2, 130)); - ASSERT_TRUE(ucs_bitwise_is_equal(buffer1, buffer2, 159)); - ASSERT_TRUE(ucs_bitwise_is_equal(buffer1, buffer2, 160)); + uint8_t buffer1[20] = {0}; + uint8_t buffer2[20] = {0}; + std::vector indices = {0, 1, 8, 64, 65, 128, 130, 159, 160}; - buffer1[19] = 0x1; /* 00000001 */ + check_bitwise_equality(buffer1, buffer2, indices, 160); - ASSERT_TRUE(ucs_bitwise_is_equal(buffer1, buffer2, 0)); - ASSERT_TRUE(ucs_bitwise_is_equal(buffer1, buffer2, 1)); - ASSERT_TRUE(ucs_bitwise_is_equal(buffer1, buffer2, 8)); - ASSERT_TRUE(ucs_bitwise_is_equal(buffer1, buffer2, 64)); - ASSERT_TRUE(ucs_bitwise_is_equal(buffer1, buffer2, 65)); - ASSERT_TRUE(ucs_bitwise_is_equal(buffer1, buffer2, 128)); - ASSERT_TRUE(ucs_bitwise_is_equal(buffer1, buffer2, 130)); - ASSERT_TRUE(ucs_bitwise_is_equal(buffer1, buffer2, 159)); - ASSERT_FALSE(ucs_bitwise_is_equal(buffer1, buffer2, 160)); + buffer1[19] = 0x1; /* 00000001 */ + check_bitwise_equality(buffer1, buffer2, indices, 159); buffer1[19] = 0x10; /* 00010000 */ - - ASSERT_TRUE(ucs_bitwise_is_equal(buffer1, buffer2, 0)); - ASSERT_TRUE(ucs_bitwise_is_equal(buffer1, buffer2, 1)); - ASSERT_TRUE(ucs_bitwise_is_equal(buffer1, buffer2, 8)); - ASSERT_TRUE(ucs_bitwise_is_equal(buffer1, buffer2, 64)); - ASSERT_TRUE(ucs_bitwise_is_equal(buffer1, buffer2, 65)); - ASSERT_TRUE(ucs_bitwise_is_equal(buffer1, buffer2, 128)); - ASSERT_TRUE(ucs_bitwise_is_equal(buffer1, buffer2, 130)); - ASSERT_FALSE(ucs_bitwise_is_equal(buffer1, buffer2, 159)); - ASSERT_FALSE(ucs_bitwise_is_equal(buffer1, buffer2, 160)); + check_bitwise_equality(buffer1, buffer2, indices, 130); buffer1[16] = 0xff; /* 11111111 */ - - ASSERT_TRUE(ucs_bitwise_is_equal(buffer1, buffer2, 0)); - ASSERT_TRUE(ucs_bitwise_is_equal(buffer1, buffer2, 1)); - ASSERT_TRUE(ucs_bitwise_is_equal(buffer1, buffer2, 8)); - ASSERT_TRUE(ucs_bitwise_is_equal(buffer1, buffer2, 64)); - ASSERT_TRUE(ucs_bitwise_is_equal(buffer1, buffer2, 65)); - ASSERT_TRUE(ucs_bitwise_is_equal(buffer1, buffer2, 128)); - ASSERT_FALSE(ucs_bitwise_is_equal(buffer1, buffer2, 130)); - ASSERT_FALSE(ucs_bitwise_is_equal(buffer1, buffer2, 159)); - ASSERT_FALSE(ucs_bitwise_is_equal(buffer1, buffer2, 160)); + check_bitwise_equality(buffer1, buffer2, indices, 128); buffer1[9] = 0xff; /* 11111111 */ - - ASSERT_TRUE(ucs_bitwise_is_equal(buffer1, buffer2, 0)); - ASSERT_TRUE(ucs_bitwise_is_equal(buffer1, buffer2, 1)); - ASSERT_TRUE(ucs_bitwise_is_equal(buffer1, buffer2, 8)); - ASSERT_TRUE(ucs_bitwise_is_equal(buffer1, buffer2, 64)); - ASSERT_TRUE(ucs_bitwise_is_equal(buffer1, buffer2, 65)); - ASSERT_FALSE(ucs_bitwise_is_equal(buffer1, buffer2, 128)); - ASSERT_FALSE(ucs_bitwise_is_equal(buffer1, buffer2, 130)); - ASSERT_FALSE(ucs_bitwise_is_equal(buffer1, buffer2, 159)); - ASSERT_FALSE(ucs_bitwise_is_equal(buffer1, buffer2, 160)); + check_bitwise_equality(buffer1, buffer2, indices, 65); buffer1[7] = 0xff; /* 11111111 */ - - ASSERT_TRUE(ucs_bitwise_is_equal(buffer1, buffer2, 0)); - ASSERT_TRUE(ucs_bitwise_is_equal(buffer1, buffer2, 1)); - ASSERT_TRUE(ucs_bitwise_is_equal(buffer1, buffer2, 8)); - ASSERT_FALSE(ucs_bitwise_is_equal(buffer1, buffer2, 64)); - ASSERT_FALSE(ucs_bitwise_is_equal(buffer1, buffer2, 65)); - ASSERT_FALSE(ucs_bitwise_is_equal(buffer1, buffer2, 128)); - ASSERT_FALSE(ucs_bitwise_is_equal(buffer1, buffer2, 130)); - ASSERT_FALSE(ucs_bitwise_is_equal(buffer1, buffer2, 159)); - ASSERT_FALSE(ucs_bitwise_is_equal(buffer1, buffer2, 160)); + check_bitwise_equality(buffer1, buffer2, indices, 8); buffer1[1] = 0xff; /* 11111111 */ - - ASSERT_TRUE(ucs_bitwise_is_equal(buffer1, buffer2, 0)); - ASSERT_TRUE(ucs_bitwise_is_equal(buffer1, buffer2, 1)); - ASSERT_TRUE(ucs_bitwise_is_equal(buffer1, buffer2, 8)); - ASSERT_FALSE(ucs_bitwise_is_equal(buffer1, buffer2, 64)); - ASSERT_FALSE(ucs_bitwise_is_equal(buffer1, buffer2, 65)); - ASSERT_FALSE(ucs_bitwise_is_equal(buffer1, buffer2, 128)); - ASSERT_FALSE(ucs_bitwise_is_equal(buffer1, buffer2, 130)); - ASSERT_FALSE(ucs_bitwise_is_equal(buffer1, buffer2, 159)); - ASSERT_FALSE(ucs_bitwise_is_equal(buffer1, buffer2, 160)); + check_bitwise_equality(buffer1, buffer2, indices, 8); buffer1[0] = 0x1; /* 00000001 */ - - ASSERT_TRUE(ucs_bitwise_is_equal(buffer1, buffer2, 0)); - ASSERT_TRUE(ucs_bitwise_is_equal(buffer1, buffer2, 1)); - ASSERT_FALSE(ucs_bitwise_is_equal(buffer1, buffer2, 8)); - ASSERT_FALSE(ucs_bitwise_is_equal(buffer1, buffer2, 64)); + check_bitwise_equality(buffer1, buffer2, indices, 1); buffer2[0] = 0x1; /* 00000001 */ - - ASSERT_TRUE(ucs_bitwise_is_equal(buffer1, buffer2, 0)); - ASSERT_TRUE(ucs_bitwise_is_equal(buffer1, buffer2, 1)); - ASSERT_TRUE(ucs_bitwise_is_equal(buffer1, buffer2, 8)); - ASSERT_FALSE(ucs_bitwise_is_equal(buffer1, buffer2, 64)); + check_bitwise_equality(buffer1, buffer2, indices, 8); buffer2[0] = 0xff; /* 11111111 */ - - ASSERT_TRUE(ucs_bitwise_is_equal(buffer1, buffer2, 0)); - ASSERT_FALSE(ucs_bitwise_is_equal(buffer1, buffer2, 1)); - ASSERT_FALSE(ucs_bitwise_is_equal(buffer1, buffer2, 8)); - ASSERT_FALSE(ucs_bitwise_is_equal(buffer1, buffer2, 64)); + check_bitwise_equality(buffer1, buffer2, indices, 0); } template void test_mask() diff --git a/test/gtest/ucs/test_string.cc b/test/gtest/ucs/test_string.cc index b87a44fcc30..c9d8c01f0fe 100644 --- a/test/gtest/ucs/test_string.cc +++ b/test/gtest/ucs/test_string.cc @@ -64,9 +64,10 @@ UCS_TEST_F(test_string, common_prefix_len) { } UCS_TEST_F(test_string, path) { - char path[PATH_MAX]; - ucs_path_get_common_parent("/sys/dev/one", "/sys/dev/two", path); - EXPECT_STREQ("/sys/dev", path); + std::string path(PATH_MAX, '\0'); + + ucs_path_get_common_parent("/sys/dev/one", "/sys/dev/two", &path[0]); + EXPECT_STREQ("/sys/dev", path.c_str()); EXPECT_EQ(4, ucs_path_calc_distance("/root/foo/bar", "/root/charlie/fox")); EXPECT_EQ(2, ucs_path_calc_distance("/a/b/c/d", "/a/b/c/e")); diff --git a/test/gtest/ucs/test_time.cc b/test/gtest/ucs/test_time.cc index 2766ff46003..cd17cb7ad66 100644 --- a/test/gtest/ucs/test_time.cc +++ b/test/gtest/ucs/test_time.cc @@ -53,15 +53,18 @@ UCS_TEST_SKIP_COND_F(test_time, get_time, } #endif -UCS_TEST_F(test_time, timerq) { - static const int TIMER_ID_1 = 100; - static const int TIMER_ID_2 = 200; +void init_timerq(ucs_timer_queue_t *timerq) { + ASSERT_UCS_OK(ucs_timerq_init(timerq)); + EXPECT_TRUE(ucs_timerq_is_empty(timerq)); + EXPECT_EQ(UCS_TIME_INFINITY, ucs_timerq_min_interval(timerq)); +} +UCS_TEST_F(test_time, timerq) { + static const int TIMER_ID_1 = 100; + static const int TIMER_ID_2 = 200; ucs_timer_queue_t timerq; - ucs_status_t status; for (unsigned test_count = 0; test_count < 500; ++test_count) { - const ucs_time_t interval1 = (ucs::rand() % 20) + 1; const ucs_time_t interval2 = (ucs::rand() % 20) + 1; const ucs_time_t test_time = ucs::rand() % 10000; @@ -69,11 +72,7 @@ UCS_TEST_F(test_time, timerq) { ucs_timer_t *timer; unsigned counter1, counter2; - status = ucs_timerq_init(&timerq); - ASSERT_UCS_OK(status); - - EXPECT_TRUE(ucs_timerq_is_empty(&timerq)); - EXPECT_EQ(UCS_TIME_INFINITY, ucs_timerq_min_interval(&timerq)); + init_timerq(&timerq); ucs_time_t current_time = time_base; @@ -103,8 +102,7 @@ UCS_TEST_F(test_time, timerq) { */ counter1 = 0; counter2 = 0; - status = ucs_timerq_remove(&timerq, TIMER_ID_1); - ASSERT_UCS_OK(status); + ASSERT_UCS_OK(ucs_timerq_remove(&timerq, TIMER_ID_1)); for (unsigned count = 0; count < test_time; ++count) { ++current_time; ucs_timerq_for_each_expired(timer, &timerq, current_time, { @@ -133,13 +131,9 @@ UCS_TEST_F(test_time, timerq) { EXPECT_NEAR(test_time / interval1, counter1, 1); EXPECT_NEAR(test_time / interval2, counter2, 1); - status = ucs_timerq_remove(&timerq, TIMER_ID_1); - ASSERT_UCS_OK(status); - status = ucs_timerq_remove(&timerq, TIMER_ID_2); - ASSERT_UCS_OK(status); + ASSERT_UCS_OK(ucs_timerq_remove(&timerq, TIMER_ID_1)); + ASSERT_UCS_OK(ucs_timerq_remove(&timerq, TIMER_ID_2)); ucs_timerq_cleanup(&timerq); } } - - diff --git a/test/gtest/uct/ib/test_ud.cc b/test/gtest/uct/ib/test_ud.cc index c4a8dde2cc4..6b35d0d3174 100644 --- a/test/gtest/uct/ib/test_ud.cc +++ b/test/gtest/uct/ib/test_ud.cc @@ -8,6 +8,8 @@ #include +#include + extern "C" { #include #include @@ -757,10 +759,9 @@ UCS_TEST_P(test_ud, connect_iface_sim2v2) { * - flush() will also progress pending CREQs */ UCS_TEST_P(test_ud, connect_iface_2k) { - unsigned i; - unsigned cids[2000]; unsigned count = 2000 / ucs::test_time_multiplier(); + std::vector cids(count, 0); /* create 2k connections */ for (i = 0; i < count; i++) {