From b3e19aa3e9606138b78397a1881da35a518fba2a Mon Sep 17 00:00:00 2001 From: zhaodu <545211984@qq.com> Date: Thu, 8 Dec 2022 15:58:13 +0800 Subject: [PATCH] DSS 1130 patch --- install/common_func.sh | 8 +- src/cmd/dsscmd.c | 352 +++-------------------------- src/cmd/dsscmd_cli_msg.c | 47 ---- src/cmd/dsscmd_cli_msg.h | 2 - src/cmd/dsscmd_find.c | 4 +- src/cmd/dsscmd_inq.c | 2 + src/common/dss_defs.c | 2 - src/common/dss_defs.h | 56 +++-- src/common/dss_diskgroup.c | 144 ++++-------- src/common/dss_file.c | 85 +++++-- src/common/dss_file.h | 2 + src/common/dss_io_fence.c | 138 ++++-------- src/common/dss_log.c | 2 + src/common/dss_open_file.c | 64 +++++- src/common/dss_open_file.h | 5 +- src/common/dss_param.c | 141 +++++------- src/common/dss_param_verify.c | 24 +- src/common/dss_protocol.c | 37 ++- src/common/dss_redo.c | 408 +++++++++------------------------- src/common/dss_session.c | 23 +- src/common/dss_session.h | 1 + src/common/dss_signal.c | 60 ++++- src/common/dss_signal.h | 3 +- src/common/dss_volume.c | 39 ++++ src/common_api/dss_api_impl.c | 121 +++------- src/interface/dss_api.c | 6 + src/interface/dss_errno.h | 2 + src/service/dss_instance.c | 185 ++++----------- src/service/dss_mes.c | 24 +- src/service/dss_service.c | 110 +++------ src/service/dss_service.h | 11 + src/service/dss_srv_proc.c | 8 +- src/service/dssserver.c | 28 ++- 33 files changed, 742 insertions(+), 1402 deletions(-) diff --git a/install/common_func.sh b/install/common_func.sh index 89268c4..c9e88b2 100644 --- a/install/common_func.sh +++ b/install/common_func.sh @@ -83,7 +83,7 @@ check_dss_start() fi } -function clear_script_log +function clear_script_log() { local _log_dir=$1 local _log_name=$2 @@ -113,7 +113,7 @@ check_log_file() log_file_size=$(ls -l ${log_file} |awk '{print $5}') if [ -f ${log_file} ];then if [ ${log_file_size} -ge ${MAX_LOG_SIZE} ];then - mv -f ${log_file} "${log_path}/${operation}-`date +%Y-%m-%d_%H%M%S`.log" 2>/dev/null + mv -f ${log_file} "${log_path}/${operation}-$(date +%Y-%m-%d_%H%M%S).log" 2>/dev/null clear_script_log "${log_path}" "${operation}-" $MAX_LOG_BACKUP fi fi @@ -122,8 +122,8 @@ check_log_file() touch_logfile() { log_file=$1 - if [ ! -f $log_file ] + if [ ! -f "$log_file" ] then - touch $log_file + touch "$log_file" fi } diff --git a/src/cmd/dsscmd.c b/src/cmd/dsscmd.c index 2267cae..527c642 100644 --- a/src/cmd/dsscmd.c +++ b/src/cmd/dsscmd.c @@ -68,7 +68,6 @@ // cmd format : cmd subcmd [-f val] #define CMD_ARGS_AT_LEAST 2 -#define DSS_TEMP_OPEN_FILES 100 #define DSS_DEFAULT_MEASURE "B" #define DSS_SUBSTR_UDS_PATH "UDS:" #define DSS_DEFAULT_VG_TYPE 't' /* show vg information in table format by default */ @@ -297,9 +296,7 @@ void cmd_clean_check_convert(char *convert_result, int convert_size) { if (convert_result != NULL) { free(convert_result); - return; } - return; } static status_t cmd_check_struct_name(const char *struct_name) @@ -1337,13 +1334,13 @@ static status_t ls_proc(void) } char type = node->type == GFT_PATH ? 'd' : node->type == GFT_FILE ? '-' : 'l'; #ifndef OPENGAUSS - (void)printf("%-5c%-20s%-14.0lf%-64s\n", type, time, size, node->name); + (void)printf("%-5c%-20s%-14.05f%-64s\n", type, time, size, node->name); #else double written_size = (double)node->written_size; if (node->written_size != 0) { written_size = dss_convert_size(written_size, measure); } - (void)printf("%-5c%-20s%-14.0lf%-14.0lf%-64s\n", type, time, size, written_size, node->name); + (void)printf("%-5c%-20s%-14.05f%-14.05f%-64s\n", type, time, size, written_size, node->name); #endif } @@ -1631,79 +1628,6 @@ static status_t lscli_proc(void) return CM_SUCCESS; } -static dss_args_t cmd_regh_args[] = { - {'U', "UDS", CM_FALSE, CM_TRUE, cmd_check_uds, cmd_check_convert_uds_home, cmd_clean_check_convert, 0, NULL, NULL, - 0}, -}; -static dss_args_set_t cmd_regh_args_set = { - cmd_regh_args, - sizeof(cmd_regh_args) / sizeof(dss_args_t), - NULL, -}; - -static void regh_help(char *prog_name) -{ - (void)printf("\nUsage:%s regh [-U UDS:socket_domain]\n", prog_name); - (void)printf("[client command] register host to array\n"); - (void)printf("-U/--UDS , [optional], the unix socket path of dssserver, " - "default vaule is UDS:/tmp/.dss_unix_d_socket\n"); -} - -static status_t regh_proc(void) -{ - dss_conn_t connection; - status_t status = get_connection_by_input_args(cmd_regh_args[DSS_ARG_IDX_0].input_args, &connection); - if (status != CM_SUCCESS) { - return status; - } - - status = dss_register_host_sync(&connection); - if (status != CM_SUCCESS) { - DSS_PRINT_ERROR("Failed to register host to array.\n"); - } else { - DSS_PRINT_INF("Succeed to register host to array.\n"); - } - dss_disconnect_ex(&connection); - return status; -} - -static dss_args_t cmd_unregh_args[] = { - {'U', "UDS", CM_FALSE, CM_TRUE, cmd_check_uds, cmd_check_convert_uds_home, cmd_clean_check_convert, 0, NULL, NULL, - 0}, -}; -static dss_args_set_t cmd_unregh_args_set = { - cmd_unregh_args, - sizeof(cmd_unregh_args) / sizeof(dss_args_t), - NULL, -}; - -static void unregh_help(char *prog_name) -{ - (void)printf("\nUsage:%s unregh [-U UDS:socket_domain]\n", prog_name); - (void)printf("[client command] unregister host from array\n"); - (void)printf("-U/--UDS , [optional], the unix socket path of dssserver, " - "default vaule is UDS:/tmp/.dss_unix_d_socket\n"); -} - -static status_t unregh_proc(void) -{ - dss_conn_t connection; - status_t status = get_connection_by_input_args(cmd_unregh_args[DSS_ARG_IDX_0].input_args, &connection); - if (status != CM_SUCCESS) { - return status; - } - - status = dss_unregister_host_sync(&connection); - if (status != CM_SUCCESS) { - DSS_PRINT_ERROR("Failed to unregister host from array.\n"); - } else { - DSS_PRINT_INF("Succeed to unregister host from array.\n"); - } - - dss_disconnect_ex(&connection); - return status; -} - static dss_args_t cmd_kickh_args[] = { {'i', "inst_id", CM_TRUE, CM_TRUE, cmd_check_inst_id, NULL, NULL, 0, NULL, NULL, 0}, {'U', "UDS", CM_FALSE, CM_TRUE, cmd_check_uds, cmd_check_convert_uds_home, cmd_clean_check_convert, 0, NULL, NULL, @@ -1815,153 +1739,6 @@ static status_t unreghl_proc(void) return status; } -static dss_args_t cmd_reg_args[] = { - {'i', "inst_id", CM_TRUE, CM_TRUE, cmd_check_inst_id, NULL, NULL, 0, NULL, NULL, 0}, - {'v', "vol_name", CM_TRUE, CM_TRUE, dss_check_path, NULL, NULL, 0, NULL, NULL, 0}, -}; -static dss_args_set_t cmd_reg_args_set = { - cmd_reg_args, - sizeof(cmd_reg_args) / sizeof(dss_args_t), - NULL, -}; - -static void reg_help(char *prog_name) -{ - (void)printf("\nUsage:%s reg <-i inst_id> <-v vol_name>\n", prog_name); - (void)printf("[raid command] register a reservation key and create a persistent reservation\n"); - (void)printf("-i/--inst_id , , the id of the host need to register\n"); - (void)printf("-v/--vol_name , , the volume name need to register\n"); -} - -static status_t reg_proc(void) -{ - int32 ret = 0; - iof_reg_out_t reg_info; - - reg_info.rk = atoll(cmd_reg_args[DSS_ARG_IDX_0].input_args); - reg_info.dev = cmd_reg_args[DSS_ARG_IDX_1].input_args; - ret = cm_iof_register(®_info); - reg_info.dev = cmd_reg_args[DSS_ARG_IDX_1].input_args; - if (ret != CM_SUCCESS) { - if (ret == CM_IOF_ERR_DUP_OP) { - DSS_PRINT_ERROR("The current host has been registered for dev %s.\n", reg_info.dev); - } else { - DSS_PRINT_ERROR("Failed to register to array.\n"); - } - return -1; - } - DSS_PRINT_INF("Succeed to register to array.\n"); - return CM_SUCCESS; -} - -static dss_args_t cmd_unreg_args[] = { - {'i', "inst_id", CM_TRUE, CM_TRUE, cmd_check_inst_id, NULL, NULL, 0, NULL, NULL, 0}, - {'v', "vol_name", CM_TRUE, CM_TRUE, dss_check_path, NULL, NULL, 0, NULL, NULL, 0}, -}; -static dss_args_set_t cmd_unreg_args_set = { - cmd_unreg_args, - sizeof(cmd_unreg_args) / sizeof(dss_args_t), - NULL, -}; - -static void unreg_help(char *prog_name) -{ - (void)printf("\nUsage:%s unreg <-i inst_id> <-v vol_name>\n", prog_name); - (void)printf("[raid command] unregister and release the specified persistent reservation\n"); - (void)printf("-i/--inst_id , , the id of the host need to unregister\n"); - (void)printf("-v/--vol_name , , the volume name need to unregister\n"); -} - -static status_t unreg_proc(void) -{ - int32 ret = 0; - iof_reg_out_t reg_info; - reg_info.rk = atoll(cmd_unreg_args[DSS_ARG_IDX_0].input_args); - reg_info.dev = cmd_unreg_args[DSS_ARG_IDX_1].input_args; - ret = cm_iof_unregister(®_info); - if (ret != CM_SUCCESS) { - if (ret == CM_IOF_ERR_DUP_OP) { - DSS_PRINT_ERROR( - "The current host has been unregistered for dev %s, or the hostid is wrong.\n", reg_info.dev); - } else { - DSS_PRINT_ERROR("Failed to unregister to array.\n"); - } - return CM_ERROR; - } - DSS_PRINT_INF("Succeed to unregister to array.\n"); - return CM_SUCCESS; -} - -static dss_args_t cmd_clrreg_args[] = { - {'i', "inst_id", CM_TRUE, CM_TRUE, cmd_check_inst_id, NULL, NULL, 0, NULL, NULL, 0}, - {'v', "vol_name", CM_TRUE, CM_TRUE, dss_check_path, NULL, NULL, 0, NULL, NULL, 0}, -}; -static dss_args_set_t cmd_clrreg_args_set = { - cmd_clrreg_args, - sizeof(cmd_clrreg_args) / sizeof(dss_args_t), - NULL, -}; - -static void clrreg_help(char *prog_name) -{ - (void)printf("\nUsage:%s clrreg <-i inst_id> <-v vol_name>\n", prog_name); - (void)printf("[raid command] clears all reservation keys\n"); - (void)printf("-i/--inst_id , , the id of the host need to unregister\n"); - (void)printf("-v/--vol_name , , the volume name need to unregister\n"); -} - -static status_t clrreg_proc(void) -{ - status_t status; - iof_reg_out_t reg_info; - reg_info.rk = atoll(cmd_clrreg_args[DSS_ARG_IDX_0].input_args); - reg_info.dev = cmd_clrreg_args[DSS_ARG_IDX_1].input_args; - status = cm_iof_clear(®_info); - if (status != CM_SUCCESS) { - DSS_PRINT_ERROR("Failed to clear to array.\n"); - return status; - } - - DSS_PRINT_INF("Succeed to clear registrations.\n"); - return CM_SUCCESS; -} - -static dss_args_t cmd_kick_args[] = { - {'i', "inst_id", CM_TRUE, CM_TRUE, cmd_check_inst_id, NULL, NULL, 0, NULL, NULL, 0}, - {'k', "kicked_inst_id", CM_TRUE, CM_TRUE, cmd_check_inst_id, NULL, NULL, 0, NULL, NULL, 0}, - {'v', "vol_name", CM_TRUE, CM_TRUE, dss_check_path, NULL, NULL, 0, NULL, NULL, 0}, -}; -static dss_args_set_t cmd_kick_args_set = { - cmd_kick_args, - sizeof(cmd_kick_args) / sizeof(dss_args_t), - NULL, -}; - -static void kick_help(char *prog_name) -{ - (void)printf("\nUsage:%s kick <-i inst_id> <-k kicked_inst_id> <-v vol_name>\n", prog_name); - (void)printf("[raid command] preempts persistent reservations and remove registrations\n"); - (void)printf("-i/--inst_id , , the id of the host need to kill other\n"); - (void)printf("-k/--kicked_inst_id , , the id of the host need to kick off\n"); - (void)printf("-v/--vol_name , , the volume name need to unregister\n"); -} - -static status_t kick_proc(void) -{ - status_t status; - iof_reg_out_t reg_info; - reg_info.rk = atoll(cmd_kick_args[DSS_ARG_IDX_0].input_args); - reg_info.rk_kick = atoll(cmd_kick_args[DSS_ARG_IDX_1].input_args); - reg_info.dev = cmd_kick_args[DSS_ARG_IDX_2].input_args; - status = cm_iof_kick(®_info); - if (status != CM_SUCCESS) { - DSS_PRINT_ERROR("Failed to preempt reservations.\n"); - return status; - } - DSS_PRINT_INF("Succeed to preempt reservations.\n"); - return CM_SUCCESS; -} - static dss_args_t cmd_auid_args[] = { {'a', "auid", CM_TRUE, CM_TRUE, cmd_check_disk_id, NULL, NULL, 0, NULL, NULL, 0}, }; @@ -1990,48 +1767,6 @@ static status_t auid_proc(void) return CM_SUCCESS; } -static dss_args_t cmd_kickhl_args[] = { - {'i', "inst_id", CM_TRUE, CM_TRUE, cmd_check_inst_id, NULL, NULL, 0, NULL, NULL, 0}, - {'k', "kicked_inst_id", CM_TRUE, CM_TRUE, cmd_check_inst_id, NULL, NULL, 0, NULL, NULL, 0}, - {'D', "DSS_HOME", CM_FALSE, CM_TRUE, cmd_check_dss_home, cmd_check_convert_dss_home, cmd_clean_check_convert, 0, - NULL, NULL, 0}, -}; -static dss_args_set_t cmd_kickhl_args_set = { - cmd_kickhl_args, - sizeof(cmd_kickhl_args) / sizeof(dss_args_t), - NULL, -}; - -static void kickhl_help(char *prog_name) -{ - (void)printf("\nUsage:%s kickhl <-i inst_id> <-k kicked_inst_id> [-D DSS_HOME]\n", prog_name); - (void)printf("[raid command] preempts persistent reservations and remove registrations\n"); - (void)printf("-i/--inst_id , , the id of the host need to kill other\n"); - (void)printf("-k/--kicked_inst_id , , the id of the host need to kick off\n"); - (void)printf("-D/--DSS_HOME , [optional], the run path of dssserver, default value is $DSS_HOME\n"); -} - -static status_t kickhl_proc(void) -{ - int64 curr_hostid = atoll(cmd_kickhl_args[DSS_ARG_IDX_0].input_args); - int64 kick_hostid = atoll(cmd_kickhl_args[DSS_ARG_IDX_1].input_args); - char *home = cmd_kickhl_args[DSS_ARG_IDX_2].input_args; - status_t status = dss_init(DSS_TEMP_OPEN_FILES, home); - if (status != CM_SUCCESS) { - DSS_PRINT_ERROR("Failed to initialize, errcode is %d.\n", status); - return status; - } - status = dss_iof_kick_all(curr_hostid, kick_hostid, CM_FALSE); - if (status != CM_SUCCESS) { - DSS_PRINT_ERROR("Failed to kick host.\n"); - return status; - } - - DSS_PRINT_INF("Succeed to kick host %s.\n", cmd_kickhl_args[DSS_ARG_IDX_1].input_args); - dss_destroy(); - return CM_SUCCESS; -} - #define DSS_CMD_PRINT_BLOCK_SIZE SIZE_K(4) #define DSS_PRINT_RETURN_BYTES 16 #define DSS_PRINT_FMT_NUM 6 @@ -2930,9 +2665,9 @@ static status_t getcfg_proc(void) char value[DSS_PARAM_BUFFER_SIZE] = {0}; status = dss_getcfg_impl(&connection, name, value, DSS_PARAM_BUFFER_SIZE); if (status != CM_SUCCESS) { - DSS_PRINT_ERROR("Failed to get cfg, name is %s, value is %s.\n", name, value); + DSS_PRINT_ERROR("Failed to get cfg, name is %s, value is %s.\n", name, (strlen(value) == 0) ? NULL : value); } else { - DSS_PRINT_INF("Succeed to get cfg, name is %s, value is %s.\n", name, value); + DSS_PRINT_INF("Succeed to get cfg, name is %s, value is %s.\n", name, (strlen(value) == 0) ? NULL : value); } dss_disconnect_ex(&connection); @@ -2975,34 +2710,6 @@ static status_t stopdss_proc(void) return status; } -static dss_args_set_t cmd_version_args_set = { - NULL, - 0, - NULL, -}; - -static void show_version_help(char *prog_name) -{ - (void)printf("\nUsage:%s show_version\n", prog_name); - (void)printf("[client command] show dss version\n"); -} - -static status_t show_version_proc(void) -{ - errno_t errcode; - char version[DSS_VERSION_MAX_LEN] = {0}; - errcode = - snprintf_s((char *)version, DSS_VERSION_MAX_LEN, DSS_VERSION_MAX_LEN - 1, "dsscmd %s", (char *)DEF_DSS_VERSION); - if (errcode < 0) { - DSS_THROW_ERROR(ERR_SYSTEM_CALL, errcode); - DSS_PRINT_ERROR("Failed to show dss version.\n"); - return CM_ERROR; - } - (void)printf("%s\n", version); - - return CM_SUCCESS; -} - // clang-format off dss_admin_cmd_t g_dss_admin_cmd[] = { {"cv", cv_help, cv_proc, &cmd_cv_args_set}, {"lsvg", lsvg_help, lsvg_proc, &cmd_lsvg_args_set}, @@ -3017,17 +2724,10 @@ dss_admin_cmd_t g_dss_admin_cmd[] = { {"cv", cv_help, cv_proc, &cmd_cv_args_set} {"inq", inq_help, inq_proc, &cmd_inq_args_set}, {"inq_reg", inq_reg_help, inq_reg_proc, &cmd_inq_req_args_set}, {"lscli", lscli_help, lscli_proc, &cmd_lscli_args_set}, - {"regh", regh_help, regh_proc, &cmd_regh_args_set}, - {"unregh", unregh_help, unregh_proc, &cmd_unregh_args_set}, {"kickh", kickh_help, kickh_proc, &cmd_kickh_args_set}, {"reghl", reghl_help, reghl_proc, &cmd_reghl_args_set}, {"unreghl", unreghl_help, unreghl_proc, &cmd_unreghl_args_set}, - {"reg", reg_help, reg_proc, &cmd_reg_args_set}, - {"unreg", unreg_help, unreg_proc, &cmd_unreg_args_set}, - {"clrreg", clrreg_help, clrreg_proc, &cmd_clrreg_args_set}, - {"kick", kick_help, kick_proc, &cmd_kick_args_set}, {"auid", auid_help, auid_proc, &cmd_auid_args_set}, - {"kickhl", kickhl_help, kickhl_proc, &cmd_kickhl_args_set}, {"examine", examine_help, examine_proc, &cmd_examine_args_set}, {"dev", dev_help, dev_proc, &cmd_dev_args_set}, {"showdisk", showdisk_help, showdisk_proc, &cmd_showdisk_args_set}, @@ -3041,13 +2741,13 @@ dss_admin_cmd_t g_dss_admin_cmd[] = { {"cv", cv_help, cv_proc, &cmd_cv_args_set} {"setcfg", setcfg_help, setcfg_proc, &cmd_setcfg_args_set}, {"getcfg", getcfg_help, getcfg_proc, &cmd_getcfg_args_set}, {"stopdss", stopdss_help, stopdss_proc, &cmd_stopdss_args_set}, - {"show_version", show_version_help, show_version_proc, &cmd_version_args_set}, }; // clang-format on static void help(char *prog_name) { - (void)printf("%s help\n", prog_name); + (void)printf("Usage:%s -h/--help show help information of dsscmd\n", prog_name); + (void)printf("Usage:%s -v/--version show version information of dsscmd\n", prog_name); for (uint32 i = 0; i < sizeof(g_dss_admin_cmd) / sizeof(g_dss_admin_cmd[0]); ++i) { g_dss_admin_cmd[i].help(prog_name); } @@ -3056,11 +2756,6 @@ static void help(char *prog_name) static status_t execute_one_cmd(int argc, char **argv, uint32 cmd_idx) { - if (argc > DSS_ARG_IDX_2 && - (strcmp(argv[DSS_ARG_IDX_2], "-h") == 0 || strcmp(argv[DSS_ARG_IDX_2], "--help") == 0)) { - g_dss_admin_cmd[cmd_idx].help(argv[0]); - return CM_SUCCESS; - } cmd_parse_init(g_dss_admin_cmd[cmd_idx].args_set->cmd_args, g_dss_admin_cmd[cmd_idx].args_set->args_size); if (cmd_parse_args(argc, argv, g_dss_admin_cmd[cmd_idx].args_set) != CM_SUCCESS) { int32 code; @@ -3132,23 +2827,36 @@ static bool32 get_cmd_idx(int argc, char **argv, uint32_t *idx) return CM_FALSE; } -static status_t execute_cmd(int argc, char **argv) +void execute_help_cmd(int argc, char **argv, uint32_t *idx) { if (argc < CMD_ARGS_AT_LEAST) { + (void)printf("dsscmd: no operation specified.\n"); + (void)printf("dsscmd: Try \"dsscmd -h/--help\" for more information.\n"); + exit(EXIT_FAILURE); + } + if (cm_str_equal(argv[1], "-v") || cm_str_equal(argv[1], "--version")) { + (void)printf("dsscmd %s\n", (char *)DEF_DSS_VERSION); + exit(EXIT_SUCCESS); + } + if (cm_str_equal(argv[1], "-h") || cm_str_equal(argv[1], "--help") || argc < CMD_ARGS_AT_LEAST) { help(argv[0]); - dss_cmd_oper_log(argc, argv, CM_ERROR); - return CM_ERROR; + exit(EXIT_SUCCESS); } - - uint32 idx; - status_t status = CM_ERROR; - if (get_cmd_idx(argc, argv, &idx)) { - status = execute_one_cmd(argc, argv, idx); - } else { + if (!get_cmd_idx(argc, argv, idx)) { (void)printf("cmd:%s can not find.\n", argv[DSS_ARG_IDX_1]); help(argv[0]); + exit(EXIT_FAILURE); } + if (argc > DSS_ARG_IDX_2 && + (strcmp(argv[DSS_ARG_IDX_2], "-h") == 0 || strcmp(argv[DSS_ARG_IDX_2], "--help") == 0)) { + g_dss_admin_cmd[*idx].help(argv[0]); + exit(EXIT_SUCCESS); + } +} +static status_t execute_cmd(int argc, char **argv, uint32 idx) +{ + status_t status = execute_one_cmd(argc, argv, idx); dss_cmd_oper_log(argc, argv, status); return status; } @@ -3168,6 +2876,8 @@ int main(int argc, char **argv) return CM_ERROR; } #endif + uint32 idx; + execute_help_cmd(argc, argv, &idx); dss_config_t inst_cfg; if (dss_set_cfg_dir(NULL, &inst_cfg) != CM_SUCCESS) { (void)printf("Environment variant DSS_HOME not found!\n"); @@ -3191,5 +2901,5 @@ int main(int argc, char **argv) return ret; } cm_reset_error(); - return execute_cmd(argc, argv); + return execute_cmd(argc, argv, idx); } diff --git a/src/cmd/dsscmd_cli_msg.c b/src/cmd/dsscmd_cli_msg.c index b63a0a8..4d570cd 100644 --- a/src/cmd/dsscmd_cli_msg.c +++ b/src/cmd/dsscmd_cli_msg.c @@ -70,53 +70,6 @@ status_t dsscmd_rmv_impl(dss_conn_t *conn, const char *vg_name, const char *volu return dsscmd_add_or_remove_volumn(conn, vg_name, volume_name, DSS_CMD_REMOVE_VOLUME); } -status_t dss_register_host_sync(dss_conn_t *connection) -{ - dss_packet_t *send_pack; - dss_packet_t *ack_pack; - int32 errcode = -1; - char *errmsg = NULL; - // make up packet - dss_init_set(&connection->pack); - send_pack = &connection->pack; - send_pack->head->cmd = DSS_CMD_REGH; - send_pack->head->flags = 0; - - // send it and wait for ack - ack_pack = &connection->pack; - DSS_RETURN_IF_ERROR(dss_call_ex(&connection->pipe, send_pack, ack_pack)); - // check return state - if (ack_pack->head->result != CM_SUCCESS) { - dss_cli_get_err(ack_pack, &errcode, &errmsg); - DSS_THROW_ERROR_EX(errcode, "%s", errmsg); - return CM_ERROR; - } - return CM_SUCCESS; -} - -status_t dss_unregister_host_sync(dss_conn_t *connection) -{ - dss_packet_t *send_pack; - dss_packet_t *ack_pack; - int32 errcode = -1; - char *errmsg = NULL; - // make up packet - dss_init_set(&connection->pack); - send_pack = &connection->pack; - send_pack->head->cmd = DSS_CMD_UNREGH; - send_pack->head->flags = 0; - // send it and wait for ack - ack_pack = &connection->pack; - DSS_RETURN_IF_ERROR(dss_call_ex(&connection->pipe, send_pack, ack_pack)); - // check return state - if (ack_pack->head->result != CM_SUCCESS) { - dss_cli_get_err(ack_pack, &errcode, &errmsg); - DSS_THROW_ERROR(ERR_DSS_CLI_EXEC_FAIL, dss_get_cmd_desc(DSS_CMD_UNREGH), errcode, errmsg); - return CM_ERROR; - } - return CM_SUCCESS; -} - status_t dss_kick_host_sync(dss_conn_t *connection, int64 kick_hostid) { dss_packet_t *send_pack; diff --git a/src/cmd/dsscmd_cli_msg.h b/src/cmd/dsscmd_cli_msg.h index 216d956..d43e3c3 100644 --- a/src/cmd/dsscmd_cli_msg.h +++ b/src/cmd/dsscmd_cli_msg.h @@ -29,8 +29,6 @@ status_t dsscmd_adv_impl(dss_conn_t *conn, const char *vg_name, const char *volume_name); status_t dsscmd_rmv_impl(dss_conn_t *conn, const char *vg_name, const char *volume_name); -status_t dss_unregister_host_sync(dss_conn_t *connection); status_t dss_kick_host_sync(dss_conn_t *connection, int64 kick_hostid); -status_t dss_register_host_sync(dss_conn_t *connection); #endif diff --git a/src/cmd/dsscmd_find.c b/src/cmd/dsscmd_find.c index c4d225d..bbe4cde 100644 --- a/src/cmd/dsscmd_find.c +++ b/src/cmd/dsscmd_find.c @@ -67,7 +67,7 @@ static void find_traverse_node(gft_node_t *node, dss_vg_info_item_t *vg_item, co } } -static status_t find_try_match_link(dss_conn_t *conn, char *path, const char *name) +static status_t find_try_match_link(char *path, const char *name) { size_t len = strlen(path); if (len > 0 && path[len - 1] != '/') { @@ -91,7 +91,7 @@ status_t find_traverse_path(dss_conn_t *conn, char *path, size_t path_size, char gft_node_t *node = NULL; size_t len = strlen(path); - DSS_RETURN_IF_SUCCESS(find_try_match_link(conn, path, name)); + DSS_RETURN_IF_SUCCESS(find_try_match_link(path, name)); dss_exist_file_impl(conn, path, &exist); if (exist) { diff --git a/src/cmd/dsscmd_inq.c b/src/cmd/dsscmd_inq.c index 01730ec..9851c11 100644 --- a/src/cmd/dsscmd_inq.c +++ b/src/cmd/dsscmd_inq.c @@ -149,6 +149,8 @@ static bool32 is_register(iof_reg_in_t *reg, int64 host_id, int64 *iofence_key) { for (int32 i = 0; i < reg->key_count; i++) { iofence_key[reg->reg_keys[i] - 1]++; + } + for (int32 i = 0; i < reg->key_count; i++) { if (reg->reg_keys[i] == host_id + 1) { return DSS_TRUE; } diff --git a/src/common/dss_defs.c b/src/common/dss_defs.c index 87534f3..15ca7eb 100644 --- a/src/common/dss_defs.c +++ b/src/common/dss_defs.c @@ -49,9 +49,7 @@ static char *g_dss_cmd_desc[DSS_CMD_TYPE_OFFSET(DSS_CMD_END)] = { [DSS_CMD_TYPE_OFFSET(DSS_CMD_ADD_VOLUME)] = "add volume", [DSS_CMD_TYPE_OFFSET(DSS_CMD_REMOVE_VOLUME)] = "remove volume", [DSS_CMD_TYPE_OFFSET(DSS_CMD_REFRESH_VOLUME)] = "refresh volume", - [DSS_CMD_TYPE_OFFSET(DSS_CMD_REGH)] = "register host", [DSS_CMD_TYPE_OFFSET(DSS_CMD_KICKH)] = "kick off host", - [DSS_CMD_TYPE_OFFSET(DSS_CMD_UNREGH)] = "unregister host", [DSS_CMD_TYPE_OFFSET(DSS_CMD_LOAD_CTRL)] = "load ctrl", [DSS_CMD_TYPE_OFFSET(DSS_CMD_SET_SESSIONID)] = "set session id", [DSS_CMD_TYPE_OFFSET(DSS_CMD_UPDATE_WRITTEN_SIZE)] = "update written size", diff --git a/src/common/dss_defs.h b/src/common/dss_defs.h index 9be73ef..776e5cd 100644 --- a/src/common/dss_defs.h +++ b/src/common/dss_defs.h @@ -93,9 +93,7 @@ typedef enum { DSS_CMD_ADD_VOLUME, DSS_CMD_REMOVE_VOLUME, DSS_CMD_REFRESH_VOLUME, - DSS_CMD_REGH, // 20 - DSS_CMD_KICKH, - DSS_CMD_UNREGH, + DSS_CMD_KICKH, // 20 DSS_CMD_LOAD_CTRL, DSS_CMD_SET_SESSIONID, DSS_CMD_UPDATE_WRITTEN_SIZE, @@ -103,11 +101,11 @@ typedef enum { DSS_CMD_SETCFG, DSS_CMD_SET_STATUS, DSS_CMD_SYMLINK, - DSS_CMD_UNLINK, // 30 + DSS_CMD_UNLINK, DSS_CMD_MODIFY_END, DSS_CMD_QUERY_BEGIN = DSS_CMD_MODIFY_END, DSS_CMD_GET_HOME = DSS_CMD_QUERY_BEGIN, - DSS_CMD_EXIST_FILE, + DSS_CMD_EXIST_FILE, // 30 DSS_CMD_EXIST_DIR, DSS_CMD_ISLINK, DSS_CMD_READLINK, @@ -267,6 +265,17 @@ typedef enum { } \ } while (0) +#define DSS_RETURN_IFERR4(func, hook1, hook2, hook3) \ + do { \ + int _status_ = (func); \ + if (SECUREC_UNLIKELY(_status_ != CM_SUCCESS)) { \ + hook1; \ + hook2; \ + hook3; \ + return _status_; \ + } \ + } while (0) + #define DSS_RETURN_IF_FALSE3(ret, hook1, hook2) \ do { \ if (SECUREC_UNLIKELY((ret) != CM_TRUE)) { \ @@ -300,6 +309,15 @@ typedef enum { } \ } +#define DSS_SECUREC_RETURN_IF_ERROR2(err, hook, ret) \ + { \ + if ((err) != EOK) { \ + hook; \ + DSS_THROW_ERROR(ERR_SYSTEM_CALL, (err)); \ + return ret; \ + } \ + } + #define DSS_SECUREC_SS_RETURN_IF_ERROR(err, ret) \ { \ if ((err) == -1) { \ @@ -320,24 +338,18 @@ typedef enum { break; \ } -#define DSS_BREAK_IFERR2(func, hook) \ - do { \ - int _status_ = (func); \ - if (SECUREC_UNLIKELY(_status_ != CM_SUCCESS)) { \ - hook; \ - break; \ - } \ - } while (0) +#define DSS_BREAK_IFERR2(func, hook) \ + if (SECUREC_UNLIKELY((func) != CM_SUCCESS)) { \ + hook; \ + break; \ + } -#define DSS_BREAK_IFERR3(func, hook1, hook2) \ - do { \ - int _status_ = (func); \ - if (SECUREC_UNLIKELY(_status_ != CM_SUCCESS)) { \ - hook1; \ - hook2; \ - break; \ - } \ - } while (0) +#define DSS_BREAK_IFERR3(func, hook1, hook2) \ + if (SECUREC_UNLIKELY((func) != CM_SUCCESS)) { \ + hook1; \ + hook2; \ + break; \ + } #define DSS_RETURN_DRIECT_IFERR(ret) \ do { \ diff --git a/src/common/dss_diskgroup.c b/src/common/dss_diskgroup.c index 47700f7..bc7ec4c 100644 --- a/src/common/dss_diskgroup.c +++ b/src/common/dss_diskgroup.c @@ -127,28 +127,17 @@ status_t dss_read_vg_config_file(const char *file_name, char *buf, uint32 *buf_l return CM_ERROR; } - if (cm_open_file(file_name, mode, &file_fd) != CM_SUCCESS) { - return CM_ERROR; - } + DSS_RETURN_IF_ERROR(cm_open_file(file_name, mode, &file_fd)); int64 size = cm_file_size(file_fd); - if (size == -1) { - cm_close_file(file_fd); - DSS_THROW_ERROR(ERR_SEEK_FILE, 0, SEEK_END, errno); - return CM_ERROR; - } + bool32 result = (bool32)(size != -1); + DSS_RETURN_IF_FALSE3(result, cm_close_file(file_fd), DSS_THROW_ERROR(ERR_SEEK_FILE, 0, SEEK_END, errno)); - if (size > (int64)(*buf_len)) { - cm_close_file(file_fd); - DSS_THROW_ERROR(ERR_DSS_CONFIG_FILE_OVERSIZED, file_name); - return CM_ERROR; - } + result = (bool32)(size <= (int64)(*buf_len)); + DSS_RETURN_IF_FALSE3(result, cm_close_file(file_fd), DSS_THROW_ERROR(ERR_DSS_CONFIG_FILE_OVERSIZED, file_name)); - if (cm_seek_file(file_fd, 0, SEEK_SET) != 0) { - cm_close_file(file_fd); - DSS_THROW_ERROR(ERR_SEEK_FILE, 0, SEEK_SET, errno); - return CM_ERROR; - } + result = (bool32)(cm_seek_file(file_fd, 0, SEEK_SET) == 0); + DSS_RETURN_IF_FALSE3(result, cm_close_file(file_fd), DSS_THROW_ERROR(ERR_SEEK_FILE, 0, SEEK_SET, errno)); status = cm_read_file(file_fd, buf, (int32)size, (int32 *)buf_len); cm_close_file(file_fd); @@ -163,10 +152,9 @@ status_t dss_load_vg_conf_inner(dss_vg_info_t *vgs_info, const dss_config_t *ins status_t status; int32 errcode = sprintf_s(vg_config_path, DSS_FILE_PATH_MAX_LENGTH, "%s/cfg/%s", inst_cfg->home, DSS_VG_CONF_NAME); - if (errcode == -1) { - CM_THROW_ERROR(ERR_SYSTEM_CALL, errcode); - return CM_ERROR; - } + bool32 result = (bool32)(errcode != -1); + DSS_RETURN_IF_FALSE2(result, CM_THROW_ERROR(ERR_SYSTEM_CALL, errcode)); + uint32_t len = DSS_MAX_CONFIG_FILE_SIZE; status = dss_read_vg_config_file(vg_config_path, file_buf, &len, DSS_TRUE); if (status != CM_SUCCESS) { @@ -174,27 +162,20 @@ status_t dss_load_vg_conf_inner(dss_vg_info_t *vgs_info, const dss_config_t *ins } status = dss_parse_vg_config(vgs_info, file_buf, len); - if (status != CM_SUCCESS) { - return status; - } - - return CM_SUCCESS; + return status; } status_t dss_load_vg_conf_info(dss_vg_info_t **vgs, const dss_config_t *inst_cfg) { status_t status; dss_vg_info_t *vgs_info = (dss_vg_info_t *)cm_malloc(sizeof(dss_vg_info_t)); - if (vgs_info == NULL) { - DSS_THROW_ERROR(ERR_ALLOC_MEMORY, sizeof(dss_vg_info_t), "dss_load_vg_conf_info"); - return CM_ERROR; - } + bool32 result = (bool32)(vgs_info != NULL); + DSS_RETURN_IF_FALSE2(result, DSS_THROW_ERROR(ERR_ALLOC_MEMORY, sizeof(dss_vg_info_t), "dss_load_vg_conf_info")); + errno_t errcode = memset_s(vgs_info, sizeof(dss_vg_info_t), 0, sizeof(dss_vg_info_t)); - if (errcode != EOK) { - CM_THROW_ERROR(ERR_SYSTEM_CALL, errcode); - DSS_FREE_POINT(vgs_info); - return CM_ERROR; - } + result = (bool32)(errcode == EOK); + DSS_RETURN_IF_FALSE3(result, DSS_FREE_POINT(vgs_info), CM_THROW_ERROR(ERR_SYSTEM_CALL, errcode)); + status = dss_load_vg_conf_inner(vgs_info, inst_cfg); if (status != CM_SUCCESS) { DSS_FREE_POINT(vgs_info); @@ -369,11 +350,9 @@ status_t dss_get_vg_info(dss_share_vg_info_t *share_vg_info, dss_vg_info_t **inf continue; } g_vgs_info->volume_group[i].stack.buff = (char *)cm_malloc_align(DSS_ALIGN_SIZE, DSS_MAX_STACK_BUF_SIZE); - if (!g_vgs_info->volume_group[i].stack.buff) { - LOG_DEBUG_ERR( - "cm_malloc_align stack failed, align size:%u, size:%u.", DSS_ALIGN_SIZE, DSS_MAX_STACK_BUF_SIZE); - return CM_ERROR; - } + bool32 result = (bool32)(g_vgs_info->volume_group[i].stack.buff != NULL); + DSS_RETURN_IF_FALSE2(result, + LOG_DEBUG_ERR("malloc stack failed, align size:%u, size:%u.", DSS_ALIGN_SIZE, DSS_MAX_STACK_BUF_SIZE)); g_vgs_info->volume_group[i].stack.size = DSS_MAX_STACK_BUF_SIZE; int32 ret = shm_hashmap_init( @@ -698,11 +677,7 @@ status_t dss_lock_disk_vg(const char *entry_path, dss_config_t *inst_cfg) // if get the timeout(ERR_SCSI_LOCK_OCCUPIED) error from scsi lock, we'll try lock vg again for (;;) { status = cm_init_dlock(&lock, DSS_CTRL_VG_LOCK_OFFSET, inst_cfg->params.inst_id); - if (status != CM_SUCCESS) { - LOG_DEBUG_ERR("Failed to init lock."); - cm_destory_dlock(&lock); - return CM_ERROR; - } + DSS_RETURN_IFERR3(status, cm_destory_dlock(&lock), LOG_DEBUG_ERR("Failed to init lock.")); status = cm_disk_timed_lock_s( &lock, entry_path, DSS_LOCK_VG_TIMEOUT, inst_cfg->params.lock_interval, inst_cfg->params.dlock_retry_count); @@ -715,11 +690,9 @@ status_t dss_lock_disk_vg(const char *entry_path, dss_config_t *inst_cfg) LOG_DEBUG_INF("Lock vg timeout, get current lock info, entry_path %s.", entry_path); // get old lock info from disk status = cm_get_dlock_info_s(&lock, entry_path); - if (status != CM_SUCCESS) { - LOG_DEBUG_ERR("Failed to get old lock info, entry path %s.", entry_path); - cm_destory_dlock(&lock); - return status; - } + DSS_RETURN_IFERR3(status, cm_destory_dlock(&lock), + LOG_DEBUG_ERR("Failed to get old lock info, entry path %s.", entry_path)); + // Get the status of the instance that owns the lock LOG_DEBUG_INF("The node that owns the lock is online, contine to get vg lock, entry path %s.", entry_path); continue; @@ -870,13 +843,8 @@ status_t dss_update_volume_ctrl(dss_vg_info_item_t *vg_item) status_t dss_update_volume_id_info(dss_vg_info_item_t *vg_item, uint32 id) { - if (dss_update_core_ctrl_disk(vg_item) != CM_SUCCESS) { - return CM_ERROR; - } - - if (dss_update_volume_ctrl(vg_item) != CM_SUCCESS) { - return CM_ERROR; - } + DSS_RETURN_IF_ERROR(dss_update_core_ctrl_disk(vg_item)); + DSS_RETURN_IF_ERROR(dss_update_volume_ctrl(vg_item) != CM_SUCCESS); uint64 attr_offset = id * sizeof(dss_volume_attr_t); char *align_buf = @@ -886,21 +854,14 @@ status_t dss_update_volume_id_info(dss_vg_info_item_t *vg_item, uint32 id) return CM_ERROR; } // write to backup area - if (dss_write_ctrl_to_disk(vg_item, DSS_CTRL_BAK_ADDR + offset, align_buf, DSS_DISK_UNIT_SIZE) != CM_SUCCESS) { - return CM_ERROR; - } + DSS_RETURN_IF_ERROR(dss_write_ctrl_to_disk(vg_item, DSS_CTRL_BAK_ADDR + offset, align_buf, DSS_DISK_UNIT_SIZE)); attr_offset = id * sizeof(dss_volume_def_t); align_buf = (char *)vg_item->dss_ctrl->volume.defs + (attr_offset / DSS_DISK_UNIT_SIZE) * DSS_DISK_UNIT_SIZE; offset = align_buf - (char *)vg_item->dss_ctrl; - if (dss_write_ctrl_to_disk(vg_item, offset, align_buf, DSS_DISK_UNIT_SIZE) != CM_SUCCESS) { - return CM_ERROR; - } + DSS_RETURN_IF_ERROR(dss_write_ctrl_to_disk(vg_item, offset, align_buf, DSS_DISK_UNIT_SIZE)); // write to backup area - if (dss_write_ctrl_to_disk(vg_item, DSS_CTRL_BAK_ADDR + offset, align_buf, DSS_DISK_UNIT_SIZE) != CM_SUCCESS) { - return CM_ERROR; - } - return CM_SUCCESS; + return dss_write_ctrl_to_disk(vg_item, DSS_CTRL_BAK_ADDR + offset, align_buf, DSS_DISK_UNIT_SIZE); } status_t dss_write_volume_inst( @@ -1028,10 +989,8 @@ static status_t dss_add_volume_impl_generate_redo( CM_RETURN_IFERR(dss_gen_volume_head(vol_head, vg_item, volume_name, id)); int32 ret = snprintf_s(redo.name, DSS_MAX_NAME_LEN, strlen(volume_name), "%s", volume_name); - if (ret == -1) { - DSS_THROW_ERROR(ERR_SYSTEM_CALL, ret); - return CM_ERROR; - } + bool32 result = (bool32)(ret != -1); + DSS_RETURN_IF_FALSE2(result, DSS_THROW_ERROR(ERR_SYSTEM_CALL, ret)); dss_put_log(session, vg_item, DSS_RT_UPDATE_VOLHEAD, &redo, sizeof(redo)); return CM_SUCCESS; } @@ -1039,11 +998,9 @@ static status_t dss_add_volume_impl_generate_redo( static status_t dss_add_volume_impl(dss_session_t *session, dss_vg_info_item_t *vg_item, const char *volume_name) { uint32 id = dss_find_free_volume_id(vg_item); - if (id >= DSS_MAX_VOLUMES) { - // EXCEED MAX_VOLUMES - LOG_DEBUG_ERR("Failed to add volume, exceed max volumes %d.", DSS_MAX_VOLUMES); - return CM_ERROR; - } + bool32 result = (bool32)(id < DSS_MAX_VOLUMES); + DSS_RETURN_IF_FALSE2(result, LOG_DEBUG_ERR("Failed to add volume, exceed max volumes %d.", DSS_MAX_VOLUMES)); + CM_RETURN_IFERR(dss_open_volume(volume_name, NULL, DSS_INSTANCE_OPEN_FLAG, &vg_item->volume_handle[id])); status_t status = dss_add_volume_impl_generate_redo(session, vg_item, volume_name, id); uint64 vol_size = dss_get_volume_size(&vg_item->volume_handle[id]); @@ -1051,10 +1008,9 @@ static status_t dss_add_volume_impl(dss_session_t *session, dss_vg_info_item_t * if (status != CM_SUCCESS) { return CM_ERROR; } - if (vol_size == DSS_INVALID_64) { - LOG_DEBUG_ERR("Failed to get volume size when add volume:%s.", volume_name); - return CM_ERROR; - } + + result = (bool32)(vol_size != DSS_INVALID_64); + DSS_RETURN_IF_FALSE2(result, LOG_DEBUG_ERR("Failed to get volume size when add volume:%s.", volume_name)); return dss_add_volume_vg_ctrl(session, id, vol_size, vg_item, volume_name); } @@ -1094,6 +1050,7 @@ status_t dss_add_volume_core(dss_session_t *session, dss_vg_info_item_t *vg_item dss_unlock_vg_storage(vg_item, vg_item->entry_path, inst_cfg); LOG_RUN_ERR("[DSS] ABORT INFO: redo log process failed, errcode:%d, OS errno:%d, OS errmsg:%s.", cm_get_error_code(), errno, strerror(errno)); + cm_fync_logfile(); _exit(1); } return CM_SUCCESS; @@ -1220,6 +1177,7 @@ status_t dss_remove_volume_core(dss_session_t *session, dss_vg_info_item_t *vg_i dss_unlock_vg_storage(vg_item, vg_item->entry_path, inst_cfg); LOG_RUN_ERR("[DSS] ABORT INFO: redo log process failed, errcode:%d, OS errno:%d, OS errmsg:%s.", cm_get_error_code(), errno, strerror(errno)); + cm_fync_logfile(); _exit(1); } return CM_SUCCESS; @@ -1495,10 +1453,8 @@ static status_t dss_check_free_volume(dss_vg_info_item_t *vg_item, uint32 volume } dss_volume_ctrl_t *volume = (dss_volume_ctrl_t *)cm_malloc_align(DSS_ALIGN_SIZE, DSS_VOLUME_CTRL_SIZE); - if (volume == NULL) { - LOG_DEBUG_ERR("Can not allocate memory in stack."); - return CM_ERROR; - } + bool32 result = (bool32)(volume != NULL); + DSS_RETURN_IF_FALSE2(result, LOG_DEBUG_ERR("Can not allocate memory in stack.")); status_t status = dss_load_volume_ctrl(vg_item, volume); if (status != CM_SUCCESS) { @@ -1533,10 +1489,8 @@ status_t dss_check_volume(dss_vg_info_item_t *vg_item, uint32 volumeid) if (volumeid == CM_INVALID_ID32) { volume = (dss_volume_ctrl_t *)cm_malloc_align(DSS_ALIGN_SIZE, DSS_VOLUME_CTRL_SIZE); - if (volume == NULL) { - LOG_DEBUG_ERR("Can not allocate memory in stack."); - return CM_ERROR; - } + bool32 result = (bool32)(volume != NULL); + DSS_RETURN_IF_FALSE2(result, LOG_DEBUG_ERR("Can not allocate memory in stack.")); status = dss_load_volume_ctrl(vg_item, volume); if (status != CM_SUCCESS) { @@ -1560,11 +1514,7 @@ status_t dss_check_volume(dss_vg_info_item_t *vg_item, uint32 volumeid) status_t dss_check_write_volume(dss_vg_info_item_t *vg_item, uint32 volumeid, int64 offset, void *buf, uint32 size) { dss_volume_t *volume; - status_t status; - status = dss_check_volume(vg_item, volumeid); - if (status != CM_SUCCESS) { - return status; - } + DSS_RETURN_IF_ERROR(dss_check_volume(vg_item, volumeid)); volume = &vg_item->volume_handle[volumeid]; return dss_write_volume_inst(vg_item, volume, offset, buf, size); } @@ -1573,11 +1523,7 @@ status_t dss_check_write_volume(dss_vg_info_item_t *vg_item, uint32 volumeid, in status_t dss_check_read_volume(dss_vg_info_item_t *vg_item, uint32 volumeid, int64 offset, void *buf, int32 size) { dss_volume_t *volume; - status_t status; - status = dss_check_volume(vg_item, volumeid); - if (status != CM_SUCCESS) { - return status; - } + DSS_RETURN_IF_ERROR(dss_check_volume(vg_item, volumeid)); volume = &vg_item->volume_handle[volumeid]; return dss_read_volume_inst(vg_item, volume, offset, buf, size); } diff --git a/src/common/dss_file.c b/src/common/dss_file.c index 184223a..b203905 100644 --- a/src/common/dss_file.c +++ b/src/common/dss_file.c @@ -25,6 +25,7 @@ #include "cm_date.h" #include "dss_ga.h" #include "cm_hash.h" +#include "dss_defs.h" #include "dss_hashmap.h" #include "dss_shm.h" #include "dss_alloc_unit.h" @@ -430,14 +431,19 @@ status_t dss_read_link(dss_session_t *session, char *link_path, char *out_filepa status = dss_read_link_file(vg_item, node, dst_path, sizeof(dst_path) - 1); dss_unlock_vg_mem_and_shm(session, vg_item); if (status != CM_SUCCESS) { - CM_RETURN_IFERR(dss_delete_open_file_index(vg_item, *(uint64 *)&node->id, session->cli_info.cli_pid)); + status = dss_delete_open_file_index( + vg_item, *(uint64 *)&node->id, session->cli_info.cli_pid, session->cli_info.start_time); + if (status == CM_SUCCESS) { + LOG_RUN_INF("Success to delete open file index, ftid:%llu.", *(uint64 *)&node->id); + } return CM_ERROR; } *out_len = (uint32)strlen(dst_path); errno_t errcode = strcpy_s(out_filepath, DSS_FILE_PATH_MAX_LENGTH, dst_path); securec_check_ret(errcode); - status = dss_delete_open_file_index(vg_item, *(uint64 *)&node->id, session->cli_info.cli_pid); + status = dss_delete_open_file_index( + vg_item, *(uint64 *)&node->id, session->cli_info.cli_pid, session->cli_info.start_time); if (status != CM_SUCCESS) { LOG_DEBUG_ERR("Failed to delete open file index."); return CM_ERROR; @@ -488,26 +494,41 @@ status_t dss_write_link_file(dss_session_t *session, char *link_path, char *dst_ dss_vg_info_item_t *vg_item; gft_node_t *node = NULL; status_t status = CM_ERROR; - CM_RETURN_IFERR(dss_open_link(session, link_path, &vg_item, &node)); + char name[DSS_MAX_NAME_LEN]; + CM_RETURN_IFERR(dss_find_vg_by_dir(link_path, name, &vg_item)); + dss_lock_vg_mem_and_shm_s(session, vg_item); + status = dss_open_link(session, link_path, &vg_item, &node); + dss_unlock_vg_mem_and_shm(session, vg_item); + CM_RETURN_IFERR(status); CM_RETURN_IF_FALSE(node->type == GFT_LINK); status = dss_extend(session, node->fid, node->id, 0, vg_item->vg_name, vg_item->id, DSS_FALSE); if (status != CM_SUCCESS) { - CM_RETURN_IFERR(dss_delete_open_file_index(vg_item, *(uint64 *)&node->id, session->cli_info.cli_pid)); + status = dss_delete_open_file_index( + vg_item, *(uint64 *)&node->id, session->cli_info.cli_pid, session->cli_info.start_time); + if (status == CM_SUCCESS) { + LOG_RUN_INF("Success to delete open file index, ftid:%llu.", *(uint64 *)&node->id); + } return CM_ERROR; } auid_t auid; status = dss_get_link_auid(vg_item, node, &auid, DSS_FALSE); if (status != CM_SUCCESS) { - CM_RETURN_IFERR(dss_delete_open_file_index(vg_item, *(uint64 *)&node->id, session->cli_info.cli_pid)); + CM_RETURN_IFERR(dss_delete_open_file_index( + vg_item, *(uint64 *)&node->id, session->cli_info.cli_pid, session->cli_info.start_time)); return CM_ERROR; } status = dss_write_link_file_content(session, vg_item, auid, dst_path); if (status != CM_SUCCESS) { - CM_RETURN_IFERR(dss_delete_open_file_index(vg_item, *(uint64 *)&node->id, session->cli_info.cli_pid)); + CM_RETURN_IFERR(dss_delete_open_file_index( + vg_item, *(uint64 *)&node->id, session->cli_info.cli_pid, session->cli_info.start_time)); + if (status == CM_SUCCESS) { + LOG_RUN_INF("Success to delete open file index, ftid:%llu.", *(uint64 *)&node->id); + } return CM_ERROR; } - status = dss_delete_open_file_index(vg_item, *(uint64 *)&node->id, session->cli_info.cli_pid); + status = dss_delete_open_file_index( + vg_item, *(uint64 *)&node->id, session->cli_info.cli_pid, session->cli_info.start_time); if (status != CM_SUCCESS) { LOG_DEBUG_ERR("Failed to delete open file index."); return CM_ERROR; @@ -564,6 +585,7 @@ static status_t dss_check_dir_core( status_t status; output_param->vg_item = dss_find_vg_item(name); if (output_param->vg_item == NULL) { + DSS_THROW_ERROR(ERR_DSS_VG_NOT_EXIST, name); LOG_DEBUG_ERR("Failed to find vg, %s.", name); return CM_ERROR; } @@ -753,7 +775,8 @@ status_t dss_open_dir(dss_session_t *session, const char *dir_path, bool32 is_re break; } } - status = dss_insert_open_file_index(vg_item, *(uint64 *)&node->id, session->cli_info.cli_pid); + status = dss_insert_open_file_index( + vg_item, *(uint64 *)&node->id, session->cli_info.cli_pid, session->cli_info.start_time); if (status != CM_SUCCESS) { LOG_DEBUG_ERR("Failed to insert open file index vg:%s, ftid:%llu, pid:%llu.", vg_item->vg_name, *(uint64 *)&node->id, session->cli_info.cli_pid); @@ -774,7 +797,8 @@ void dss_close_dir(dss_session_t *session, char *vg_name, uint64 ftid) return; } - status_t status = dss_delete_open_file_index(vg_item, ftid, session->cli_info.cli_pid); + status_t status = + dss_delete_open_file_index(vg_item, ftid, session->cli_info.cli_pid, session->cli_info.start_time); if (status != CM_SUCCESS) { LOG_DEBUG_ERR("Failed to delete open file index."); return; @@ -1153,7 +1177,8 @@ static status_t dss_open_file_find_block_and_insert_index( return CM_ERROR; } - status = dss_insert_open_file_index(vg_item, *(uint64 *)&out_node->id, session->cli_info.cli_pid); + status = dss_insert_open_file_index( + vg_item, *(uint64 *)&out_node->id, session->cli_info.cli_pid, session->cli_info.start_time); if (status != CM_SUCCESS) { LOG_DEBUG_ERR("Failed to insert open file index."); return CM_ERROR; @@ -1196,6 +1221,7 @@ status_t dss_open_file_core(dss_session_t *session, const char *path, uint32 typ dss_unlock_vg_mem_and_shm(session, vg_item); LOG_RUN_ERR("[DSS API] ABORT INFO : redo log process failed, errcode:%d, OS errno:%d, OS errmsg:%s.", cm_get_error_code(), errno, strerror(errno)); + cm_fync_logfile(); _exit(1); } dss_unlock_vg_mem_and_shm(session, vg_item); @@ -1299,7 +1325,8 @@ gft_node_t *dss_find_parent_node_by_node(dss_vg_info_item_t *vg_item, gft_node_t status_t dss_close_file(dss_session_t *session, dss_vg_info_item_t *vg_item, uint64 ftid) { - status_t status = dss_delete_open_file_index(vg_item, ftid, session->cli_info.cli_pid); + status_t status = + dss_delete_open_file_index(vg_item, ftid, session->cli_info.cli_pid, session->cli_info.start_time); if (status != CM_SUCCESS) { LOG_DEBUG_ERR("Failed to delete open file index."); return CM_ERROR; @@ -1906,7 +1933,7 @@ gft_node_t *dss_alloc_ft_node_when_create_vg( /* file or link */ dss_set_blockid(&node->entry, CM_INVALID_ID64); } - if (strcpy_s(node->name, sizeof(node->name) - 1, name) != EOK) { + if (strcpy_s(node->name, sizeof(node->name), name) != EOK) { cm_panic(0); } dss_init_alloc_ft_node(gft, node, flags, parent_node); @@ -1938,6 +1965,19 @@ status_t dss_init_ft_node_entry(dss_session_t *session, dss_vg_info_item_t *vg_i return CM_SUCCESS; } +status_t dss_alloc_ft_au_when_no_free( + dss_session_t *session, dss_vg_info_item_t *vg_item, gft_root_t *gft, bool32 *check_version) +{ + if (gft->free_list.count == 0) { + ftid_t id; + status_t status = dss_alloc_ft_au(session, vg_item, &id); + DSS_RETURN_IFERR2(status, LOG_DEBUG_ERR("Failed to allocate au when allocating file table node.")); + *check_version = CM_FALSE; + DSS_LOG_DEBUG_OP("Succeed to allocate au:%llu when allocating file table node.", DSS_ID_TO_U64(id)); + } + return CM_SUCCESS; +} + gft_node_t *dss_alloc_ft_node(dss_session_t *session, dss_vg_info_item_t *vg_item, gft_node_t *parent_node, const char *name, gft_item_type_t type) { @@ -1952,14 +1992,9 @@ gft_node_t *dss_alloc_ft_node(dss_session_t *session, dss_vg_info_item_t *vg_ite gft_root_t *gft = &ft_block->ft_root; bool32 check_version = CM_TRUE; - if (gft->free_list.count == 0) { - status = dss_alloc_ft_au(session, vg_item, &id); - if (status != CM_SUCCESS) { - LOG_DEBUG_ERR("Failed to allocate au when allocating file table node."); - return NULL; - } - check_version = CM_FALSE; - DSS_LOG_DEBUG_OP("Succeed to allocate au:%llu when allocating file table node.", DSS_ID_TO_U64(id)); + status = dss_alloc_ft_au_when_no_free(session, vg_item, gft, &check_version); + if (status != CM_SUCCESS) { + return NULL; } id = gft->free_list.first; gft_node_t *node = dss_get_ft_node_by_ftid(vg_item, id, check_version, CM_FALSE); @@ -2646,6 +2681,7 @@ status_t dss_extend( dss_vg_info_item_t *vg_item = dss_find_vg_item(vg_name); if (!vg_item) { LOG_DEBUG_ERR("Failed to find vg,vg name %s.", vg_name); + DSS_THROW_ERROR(ERR_DSS_VG_NOT_EXIST, vg_name); return CM_ERROR; } @@ -2662,6 +2698,7 @@ status_t dss_extend_inner( dss_config_t *inst_cfg = dss_get_inst_cfg(); if (vg_item == NULL) { LOG_DEBUG_ERR("Failed to find vg,vg name %s.", vg_name); + DSS_THROW_ERROR(ERR_DSS_VG_NOT_EXIST, vg_name); return CM_ERROR; } @@ -2776,6 +2813,7 @@ status_t dss_extend_inner( if (status != CM_SUCCESS) { LOG_RUN_ERR("[DSS] ABORT INFO: redo log process failed, errcode:%d, OS errno:%d, OS errmsg:%s.", cm_get_error_code(), errno, strerror(errno)); + cm_fync_logfile(); _exit(1); } @@ -2999,6 +3037,7 @@ static status_t dss_prepare_truncate(dss_session_t *session, char *vg_name, uint dss_vg_info_item_t *vg_item = dss_find_vg_item(vg_name); if (vg_item == NULL) { LOG_DEBUG_ERR("Failed to find vg with name %s.", vg_name); + DSS_THROW_ERROR(ERR_DSS_VG_NOT_EXIST, vg_name); return CM_ERROR; } dss_lock_vg_mem_and_shm_x(session, vg_item); @@ -3029,6 +3068,7 @@ static status_t dss_init_trunc_ftn(dss_session_t *session, dss_vg_info_item_t *v if (status != CM_SUCCESS) { LOG_RUN_ERR("[DSS] ABORT INFO: redo log process failed, errcode:%d, OS errno:%d, OS errmsg:%s.", cm_get_error_code(), errno, strerror(errno)); + cm_fync_logfile(); _exit(1); } if (*truncated_ftn == NULL) { @@ -3147,6 +3187,7 @@ status_t dss_truncate(dss_session_t *session, uint64 fid, ftid_t ftid, int64 off dss_unlock_vg_mem_and_shm(session, vg_item); LOG_RUN_ERR("[DSS] ABORT INFO: redo log process failed, errcode:%d, OS errno:%d, OS errmsg:%s.", cm_get_error_code(), errno, strerror(errno)); + cm_fync_logfile(); _exit(1); } @@ -3192,6 +3233,7 @@ status_t dss_refresh_file(dss_session_t *session, uint64 fid, ftid_t ftid, char dss_vg_info_item_t *vg_item = dss_find_vg_item(vg_name); if (vg_item == NULL) { LOG_DEBUG_ERR("Failed to find vg,vg name %s.", vg_name); + DSS_THROW_ERROR(ERR_DSS_VG_NOT_EXIST, vg_name); return CM_ERROR; } @@ -3220,6 +3262,7 @@ status_t dss_refresh_volume(dss_session_t *session, const char *name_str, uint32 #endif dss_vg_info_item_t *vg_item = dss_find_vg_item(name_str); if (!vg_item) { + DSS_THROW_ERROR(ERR_DSS_VG_NOT_EXIST, name_str); return CM_ERROR; } status_t status; @@ -3321,6 +3364,7 @@ status_t dss_refresh_ft_block(dss_session_t *session, char *vg_name, uint32 vgid dss_vg_info_item_t *vg_item = dss_find_vg_item(vg_name); if (!vg_item) { LOG_DEBUG_ERR("Failed to find vg,vg name %s.", vg_name); + DSS_THROW_ERROR(ERR_DSS_VG_NOT_EXIST, vg_name); return CM_ERROR; } dss_lock_vg_mem_and_shm_x(session, vg_item); @@ -3350,6 +3394,7 @@ status_t dss_update_file_written_size( dss_vg_info_item_t *vg_item = dss_find_vg_item(vg_name); if (!vg_item) { LOG_DEBUG_ERR("Failed to find vg,vg name %s.", vg_name); + DSS_THROW_ERROR(ERR_DSS_VG_NOT_EXIST, vg_name); return CM_ERROR; } dss_lock_vg_mem_x(vg_item); diff --git a/src/common/dss_file.h b/src/common/dss_file.h index 417224f..dcf96e6 100644 --- a/src/common/dss_file.h +++ b/src/common/dss_file.h @@ -63,6 +63,8 @@ status_t dss_update_file_written_size( dss_session_t *session, char *vg_name, uint64 written_size, dss_block_id_t blockid); status_t dss_get_ftid_by_path(dss_session_t *session, const char *path, ftid_t *ftid, dss_vg_info_item_t **dir_vg_item); // for dss internal call +status_t dss_alloc_ft_au_when_no_free( + dss_session_t *session, dss_vg_info_item_t *vg_item, gft_root_t *gft, bool32 *check_version); gft_node_t *dss_alloc_ft_node(dss_session_t *session, dss_vg_info_item_t *vg_item, gft_node_t *parent_node, const char *name, gft_item_type_t type); gft_node_t *dss_alloc_ft_node_when_create_vg( diff --git a/src/common/dss_io_fence.c b/src/common/dss_io_fence.c index ef653fa..ef8af79 100644 --- a/src/common/dss_io_fence.c +++ b/src/common/dss_io_fence.c @@ -212,35 +212,25 @@ status_t dss_iof_kick_all(int64 rk, int64 rk_kick, bool32 is_server) inst_cfg = &dss_env->inst_cfg; } - if (dss_vg_info == NULL) { - LOG_DEBUG_ERR("Can't get vgs info, is_server %u.", (uint32)is_server); - return CM_ERROR; - } + bool32 result = (bool32)(dss_vg_info != NULL); + DSS_RETURN_IF_FALSE2(result, LOG_DEBUG_ERR("Can't get vgs info, is_server %u.", (uint32)is_server)); if (rk_kick == inst_cfg->params.inst_id) { LOG_DEBUG_ERR("Can't kick current node, rk_kick %lld, inst id %lld.", rk_kick, inst_cfg->params.inst_id); return CM_ERROR; } - if (rk != inst_cfg->params.inst_id) { - LOG_DEBUG_ERR( - "Must use the inst id of current node as rk, rk %lld, inst id %lld.", rk, inst_cfg->params.inst_id); - return CM_ERROR; - } + result = (bool32)(rk == inst_cfg->params.inst_id); + DSS_RETURN_IF_FALSE2(result, + LOG_DEBUG_ERR("Must use inst id of current node as rk, rk %lld, inst id %lld.", rk, inst_cfg->params.inst_id)); cm_ptlist_init(®_list); status = dss_iof_inql_regs(®_list, is_server); - if (status != CM_SUCCESS) { - LOG_DEBUG_ERR("Inquiry regs info failed, is_server %u.", (uint32)is_server); - cm_destroy_ptlist(®_list); - return status; - } + DSS_RETURN_IFERR3(status, cm_destroy_ptlist(®_list), + LOG_DEBUG_ERR("Inquiry regs info failed, is_server %u.", (uint32)is_server)); status = dss_iof_kick_all_volumes(dss_vg_info, rk, rk_kick, ®_list); - if (status != CM_SUCCESS) { - cm_destroy_ptlist(®_list); - return status; - } + DSS_RETURN_IFERR2(status, cm_destroy_ptlist(®_list)); cm_destroy_ptlist(®_list); #endif @@ -307,10 +297,7 @@ status_t dss_iof_register_core(int64 rk, dss_vg_info_t *dss_vg_info) if (item->dss_ctrl->core.volume_attrs[j].flag == VOLUME_FREE) { continue; } - ret = dss_iof_register_single(rk, item->dss_ctrl->volume.defs[j].name); - if (ret != CM_SUCCESS) { - return ret; - } + DSS_RETURN_IF_ERROR(dss_iof_register_single(rk, item->dss_ctrl->volume.defs[j].name)); } } return CM_SUCCESS; @@ -324,10 +311,8 @@ status_t dss_iof_register_all(int64 rk, bool32 is_server) LOG_DEBUG_INF("Begin register all, rk %lld, is server %u.", rk + 1, (uint32)is_server); dss_get_vg_info_is_server(is_server, &dss_vg_info); - if (dss_vg_info == NULL) { - LOG_DEBUG_ERR("Can't get vgs info, is_server %u.", (uint32)is_server); - return CM_ERROR; - } + bool32 result = (bool32)(dss_vg_info != NULL); + DSS_RETURN_IF_FALSE2(result, LOG_DEBUG_ERR("Can't get vgs info, is_server %u.", (uint32)is_server)); status_t ret = dss_iof_register_core(rk, dss_vg_info); if (ret != CM_SUCCESS) { return ret; @@ -351,10 +336,7 @@ status_t dss_iof_unregister_core(int64 rk, dss_vg_info_t *dss_vg_info) if (item->dss_ctrl->core.volume_attrs[j].flag == VOLUME_FREE) { continue; } - ret = dss_iof_unregister_single(rk, item->dss_ctrl->volume.defs[j].name); - if (ret != CM_SUCCESS) { - return ret; - } + DSS_RETURN_IF_ERROR(dss_iof_unregister_single(rk, item->dss_ctrl->volume.defs[j].name)); } } LOG_DEBUG_INF("Unregister all succ."); @@ -369,10 +351,8 @@ status_t dss_iof_unregister_all(int64 rk, bool32 is_server) LOG_DEBUG_INF("Begin Unregister all, rk %lld, is server %u.", rk + 1, (uint32)is_server); dss_get_vg_info_is_server(is_server, &dss_vg_info); - if (dss_vg_info == NULL) { - LOG_DEBUG_ERR("Can't get vgs info, is_server %u.", (uint32)is_server); - return CM_ERROR; - } + bool32 result = (bool32)(dss_vg_info != NULL); + DSS_RETURN_IF_FALSE2(result, LOG_DEBUG_ERR("Can't get vgs info, is_server %u.", (uint32)is_server)); status_t ret = dss_iof_unregister_core(rk, dss_vg_info); if (ret != CM_SUCCESS) { return ret; @@ -412,30 +392,20 @@ status_t dss_inquiry_luns_from_ctrl(dss_vg_info_item_t *item, ptlist_t *lunlist) } dev_info_t *dev_info = (dev_info_t *)malloc(sizeof(dev_info_t)); - if (dev_info == NULL) { - LOG_DEBUG_ERR("Malloc failed."); - return CM_ERROR; - } + bool32 result = (bool32)(dev_info != NULL); + DSS_RETURN_IF_FALSE2(result, LOG_DEBUG_ERR("Malloc failed.")); errno_t ret = memset_sp(dev_info, sizeof(dev_info_t), 0, sizeof(dev_info_t)); - if (ret != EOK) { - DSS_FREE_POINT(dev_info); - DSS_THROW_ERROR(ERR_SYSTEM_CALL, ret); - return CM_ERROR; - } + result = (bool32)(ret == EOK); + DSS_RETURN_IF_FALSE3(result, DSS_FREE_POINT(dev_info), DSS_THROW_ERROR(ERR_SYSTEM_CALL, ret)); dev_info->dev = item->dss_ctrl->volume.defs[j].name; status = dss_inquiry_lun(dev_info); - if (status != CM_SUCCESS) { - LOG_DEBUG_ERR("Inquiry dev failed, dev %s.", item->dss_ctrl->volume.defs[j].name); - DSS_FREE_POINT(dev_info); - return CM_ERROR; - } + DSS_RETURN_IFERR3(status, DSS_FREE_POINT(dev_info), + LOG_DEBUG_ERR("Inquiry dev failed, dev %s.", item->dss_ctrl->volume.defs[j].name)); - if (cm_ptlist_add(lunlist, dev_info) != CM_SUCCESS) { - DSS_FREE_POINT(dev_info); - return CM_ERROR; - } + status = cm_ptlist_add(lunlist, dev_info); + DSS_RETURN_IFERR2(status, DSS_FREE_POINT(dev_info)); } return CM_SUCCESS; } @@ -460,17 +430,12 @@ status_t dss_inquiry_luns(ptlist_t *lunlist, bool32 is_server) dss_vg_info_item_t *item = &dss_vg_info->volume_group[i]; dev_info = (dev_info_t *)malloc(sizeof(dev_info_t)); - if (dev_info == NULL) { - LOG_DEBUG_ERR("Malloc failed."); - return CM_ERROR; - } + bool32 result = (bool32)(dev_info != NULL); + DSS_RETURN_IF_FALSE2(result, LOG_DEBUG_ERR("Malloc failed.")); ret = memset_sp(dev_info, sizeof(dev_info_t), 0, sizeof(dev_info_t)); - if (ret != EOK) { - DSS_FREE_POINT(dev_info); - DSS_THROW_ERROR(ERR_SYSTEM_CALL, ret); - return CM_ERROR; - } + result = (bool32)(ret == EOK); + DSS_RETURN_IF_FALSE3(result, DSS_FREE_POINT(dev_info), DSS_THROW_ERROR(ERR_SYSTEM_CALL, ret)); dev_info->dev = item->entry_path; status = dss_inquiry_lun(dev_info); @@ -480,16 +445,11 @@ status_t dss_inquiry_luns(ptlist_t *lunlist, bool32 is_server) return CM_ERROR; } - if (cm_ptlist_add(lunlist, dev_info) != CM_SUCCESS) { - DSS_FREE_POINT(dev_info); - return CM_ERROR; - } + status = cm_ptlist_add(lunlist, dev_info); + DSS_RETURN_IFERR2(status, DSS_FREE_POINT(dev_info)); // volume_attrs[0] is the sys dev - status = dss_inquiry_luns_from_ctrl(item, lunlist); - if (status != CM_SUCCESS) { - return status; - } + DSS_RETURN_IF_ERROR(dss_inquiry_luns_from_ctrl(item, lunlist)); } #endif @@ -509,17 +469,12 @@ status_t dss_iof_inql_regs_core(ptlist_t *reglist, dss_vg_info_item_t *item) } reg_info = (iof_reg_in_t *)malloc(sizeof(iof_reg_in_t)); - if (reg_info == NULL) { - LOG_DEBUG_ERR("Malloc failed."); - return CM_ERROR; - } + bool32 result = (bool32)(reg_info != NULL); + DSS_RETURN_IF_FALSE2(result, LOG_DEBUG_ERR("Malloc failed.")); ret = memset_sp(reg_info, sizeof(iof_reg_in_t), 0, sizeof(iof_reg_in_t)); - if (ret != EOK) { - DSS_THROW_ERROR(ERR_SYSTEM_CALL, ret); - DSS_FREE_POINT(reg_info); - return CM_ERROR; - } + result = (bool32)(ret == EOK); + DSS_RETURN_IF_FALSE3(result, DSS_FREE_POINT(reg_info), DSS_THROW_ERROR(ERR_SYSTEM_CALL, ret)); reg_info->dev = item->dss_ctrl->volume.defs[j].name; status = cm_iof_inql(reg_info); @@ -529,10 +484,8 @@ status_t dss_iof_inql_regs_core(ptlist_t *reglist, dss_vg_info_item_t *item) return CM_ERROR; } - if (cm_ptlist_add(reglist, reg_info) != CM_SUCCESS) { - DSS_FREE_POINT(reg_info); - return CM_ERROR; - } + status = cm_ptlist_add(reglist, reg_info); + DSS_RETURN_IFERR2(status, DSS_FREE_POINT(reg_info)); } return CM_SUCCESS; } @@ -555,16 +508,12 @@ status_t dss_iof_inql_regs(ptlist_t *reglist, bool32 is_server) for (uint32 i = 0; i < (uint32)dss_vg_info->group_num; i++) { dss_vg_info_item_t *item = &dss_vg_info->volume_group[i]; reg_info = (iof_reg_in_t *)malloc(sizeof(iof_reg_in_t)); - if (reg_info == NULL) { - LOG_DEBUG_ERR("Malloc failed."); - return CM_ERROR; - } + bool32 result = (bool32)(reg_info != NULL); + DSS_RETURN_IF_FALSE2(result, LOG_DEBUG_ERR("Malloc failed.")); + ret = memset_sp(reg_info, sizeof(iof_reg_in_t), 0, sizeof(iof_reg_in_t)); - if (ret != EOK) { - DSS_FREE_POINT(reg_info); - DSS_THROW_ERROR(ERR_SYSTEM_CALL, ret); - return CM_ERROR; - } + result = (bool32)(ret == EOK); + DSS_RETURN_IF_FALSE3(result, DSS_FREE_POINT(reg_info), DSS_THROW_ERROR(ERR_SYSTEM_CALL, ret)); reg_info->dev = item->entry_path; status = cm_iof_inql(reg_info); @@ -573,10 +522,9 @@ status_t dss_iof_inql_regs(ptlist_t *reglist, bool32 is_server) DSS_FREE_POINT(reg_info); return CM_ERROR; } - if (cm_ptlist_add(reglist, reg_info) != CM_SUCCESS) { - DSS_FREE_POINT(reg_info); - return CM_ERROR; - } + + status = cm_ptlist_add(reglist, reg_info); + DSS_RETURN_IFERR2(status, DSS_FREE_POINT(reg_info)); // volume_attrs[0] is the sys dev DSS_RETURN_IF_ERROR(dss_iof_inql_regs_core(reglist, item)); } diff --git a/src/common/dss_log.c b/src/common/dss_log.c index 28a3153..6f17661 100644 --- a/src/common/dss_log.c +++ b/src/common/dss_log.c @@ -57,6 +57,7 @@ const char *g_dss_error_desc[DSS_ERROR_COUNT] = { [ERR_DSS_FILE_RENAME] = "Rename failed, reason %s", [ERR_DSS_FILE_RENAME_DIFF_VG] = "Failed to rename from vg %s to another vg %s, function not supported", [ERR_DSS_FILE_RENAME_EXIST] = "Rename failed, reason %s", + [ERR_DSS_FILE_RENAME_OPENING_REMOTE] = "Failed to rename %s to %s, while source file is opend by other instance.", [ERR_DSS_FILE_NOT_EXIST] = "The file %s of %s does not exist", [ERR_DSS_FILE_OPENING_REMOTE] = "The file is open in other inst: %d, command:%d exec failed.", [ERR_DSS_FILE_TYPE_MISMATCH] = "The type of directory link or file %s is not matched.", @@ -78,6 +79,7 @@ const char *g_dss_error_desc[DSS_ERROR_COUNT] = { [ERR_DSS_SKLIST_EXIST] = "Error DSS skip list key value exist.", [ERR_DSS_SHM_CREATE] = "Failed to create shared memory, key=0x%08x, size=%llu", [ERR_DSS_SHM_CHECK] = "Failed to check shared memory ctrl, key=0x%08x, reason=%s", + [ERR_DSS_SHM_LOCK] = "Failed to lock vg shared memory, reason=%s", [ERR_DSS_GA_INIT] = "DSS ga init error, reason %s", [ERR_DSS_SESSION_INVALID_ID] = "Invalid session %d", [ERR_DSS_SESSION_CREATE] = "Create new DSS session failed, no free sessions, %d sessions used", diff --git a/src/common/dss_open_file.c b/src/common/dss_open_file.c index 59d8283..434dfaa 100644 --- a/src/common/dss_open_file.c +++ b/src/common/dss_open_file.c @@ -138,12 +138,13 @@ void dss_destroy_open_file_index(dss_vg_info_item_t *vg_item) sklist_destroy(&vg_item->open_pid_list); } -static status_t dss_insert_skiplist_index(skip_list_t *list, uint64 ftid, uint64 pid) +static status_t dss_insert_skiplist_index(skip_list_t *list, uint64 ftid, uint64 pid, int64 start_time) { dss_open_file_info_t key; key.ftid = ftid; key.pid = pid; key.ref = 1; + key.start_time = start_time; dss_open_file_info_t *out_data; int32 ret = sklist_get_value(list, &key, CM_FALSE, NULL, 0, (void **)&out_data); @@ -156,6 +157,7 @@ static status_t dss_insert_skiplist_index(skip_list_t *list, uint64 ftid, uint64 key_ins->ftid = ftid; key_ins->pid = pid; key_ins->ref = 1; + key_ins->start_time = start_time; uint32 err = sklist_insert(list, key_ins, key_ins); if (err != 0) { LOG_DEBUG_ERR("Failed to insert open file index,ftid:%llu, pid:%llu.", key_ins->ftid, key_ins->pid); @@ -198,14 +200,14 @@ static status_t dss_delete_skiplist_index(skip_list_t *list, uint64 ftid, uint64 return CM_SUCCESS; } -status_t dss_insert_open_file_index(dss_vg_info_item_t *vg_item, uint64 ftid, uint64 pid) +status_t dss_insert_open_file_index(dss_vg_info_item_t *vg_item, uint64 ftid, uint64 pid, int64 start_time) { dss_latch_x(&vg_item->open_file_latch); - status_t status = dss_insert_skiplist_index(&vg_item->open_file_list, ftid, pid); + status_t status = dss_insert_skiplist_index(&vg_item->open_file_list, ftid, pid, start_time); DSS_RETURN_IFERR3(status, dss_unlatch(&vg_item->open_file_latch), LOG_DEBUG_ERR("Failed to insert open file index,ftid:%llu, pid:%llu.", ftid, pid)); - status = dss_insert_skiplist_index(&vg_item->open_pid_list, ftid, pid); + status = dss_insert_skiplist_index(&vg_item->open_pid_list, ftid, pid, start_time); if (status != CM_SUCCESS) { (void)dss_delete_skiplist_index(&vg_item->open_file_list, ftid, pid); dss_unlatch(&vg_item->open_file_latch); @@ -217,7 +219,7 @@ status_t dss_insert_open_file_index(dss_vg_info_item_t *vg_item, uint64 ftid, ui return CM_SUCCESS; } -status_t dss_delete_open_file_index(dss_vg_info_item_t *vg_item, uint64 ftid, uint64 pid) +status_t dss_delete_open_file_index(dss_vg_info_item_t *vg_item, uint64 ftid, uint64 pid, int64 start_time) { dss_latch_x(&vg_item->open_file_latch); status_t status = dss_delete_skiplist_index(&vg_item->open_file_list, ftid, pid); @@ -226,7 +228,7 @@ status_t dss_delete_open_file_index(dss_vg_info_item_t *vg_item, uint64 ftid, ui status = dss_delete_skiplist_index(&vg_item->open_pid_list, ftid, pid); if (status != CM_SUCCESS) { - (void)dss_insert_skiplist_index(&vg_item->open_file_list, ftid, pid); + (void)dss_insert_skiplist_index(&vg_item->open_file_list, ftid, pid, start_time); dss_unlatch(&vg_item->open_file_latch); LOG_DEBUG_ERR("Failed to delete open pid index,ftid:%llu, pid:%llu.", ftid, pid); return status; @@ -236,6 +238,42 @@ status_t dss_delete_open_file_index(dss_vg_info_item_t *vg_item, uint64 ftid, ui return CM_SUCCESS; } +static status_t dss_check_open_file_clean_list( + dss_vg_info_item_t *vg_item, dss_open_file_info_t *next_key, skip_list_iterator_t itr, bool32 *is_open) +{ + uint64 ftid = next_key->ftid; + uint64 pid = next_key->pid; + int64 start_time = next_key->start_time; + int32 ret = SKIP_LIST_FOUND; + while (CM_TRUE) { + if ((ret == SKIP_LIST_FOUND) && (!cm_sys_process_alived(pid, start_time))) { + status_t status = dss_delete_skiplist_index(&vg_item->open_file_list, ftid, pid); + if (status != CM_SUCCESS) { + LOG_DEBUG_ERR("Failed to delete open file index when clean dead pid,ftid:%llu, pid:%llu.", ftid, pid); + return status; + } + status = dss_delete_skiplist_index(&vg_item->open_pid_list, ftid, pid); + if (status != CM_SUCCESS) { + LOG_DEBUG_ERR("Failed to delete open pid index when clean dead pid,ftid:%llu, pid:%llu.", ftid, pid); + (void)dss_insert_skiplist_index(&vg_item->open_file_list, ftid, pid, start_time); + return status; + } + } else if (ret == SKLIST_FETCH_END) { + *is_open = CM_FALSE; + return CM_SUCCESS; + } else if (ret == SKIP_LIST_FOUND) { + *is_open = CM_TRUE; + return CM_SUCCESS; + } else { + return CM_ERROR; + } + ret = sklist_fetch_next(&itr, (void **)&next_key, NULL, 0); + ftid = next_key->ftid; + pid = next_key->pid; + start_time = next_key->start_time; + } +} + status_t dss_check_open_file(dss_vg_info_item_t *vg_item, uint64 ftid, bool32 *is_open) { skip_list_t *list = &vg_item->open_file_list; @@ -257,20 +295,22 @@ status_t dss_check_open_file(dss_vg_info_item_t *vg_item, uint64 ftid, bool32 *i range.left_value = NULL; range.right_key = &right_key; range.right_value = NULL; - sklist_create_iterator(list, &range, &itr); - dss_open_file_info_t *next_key; + status_t status = CM_SUCCESS; + + sklist_create_iterator(list, &range, &itr); + dss_latch_x(&vg_item->open_file_latch); int32 ret = sklist_fetch_next(&itr, (void **)&next_key, NULL, 0); if (ret == SKLIST_FETCH_END) { *is_open = CM_FALSE; } else if (ret == SKIP_LIST_FOUND) { LOG_DEBUG_INF("Succeed to find open file index, ftid:%llu, pid:%llu.", ftid, next_key->pid); - *is_open = CM_TRUE; + status = dss_check_open_file_clean_list(vg_item, next_key, itr, is_open); } else { - sklist_close_iterator(&itr); - return CM_ERROR; + status = CM_ERROR; } + dss_unlatch(&vg_item->open_file_latch); sklist_close_iterator(&itr); - return CM_SUCCESS; + return status; } diff --git a/src/common/dss_open_file.h b/src/common/dss_open_file.h index 81a75d0..8be2efb 100644 --- a/src/common/dss_open_file.h +++ b/src/common/dss_open_file.h @@ -33,13 +33,14 @@ typedef struct st_dss_open_file_info_t { uint64 ftid; uint64 pid; uint64 ref; + int64 start_time; } dss_open_file_info_t; status_t dss_init_open_file_index(dss_vg_info_item_t *vg_item); void dss_destroy_open_file_index(dss_vg_info_item_t *vg_item); -status_t dss_insert_open_file_index(dss_vg_info_item_t *vg_item, uint64 fid, uint64 pid); -status_t dss_delete_open_file_index(dss_vg_info_item_t *vg_item, uint64 fid, uint64 pid); +status_t dss_insert_open_file_index(dss_vg_info_item_t *vg_item, uint64 ftid, uint64 pid, int64 start_time); +status_t dss_delete_open_file_index(dss_vg_info_item_t *vg_item, uint64 ftid, uint64 pid, int64 start_time); status_t dss_check_open_file(dss_vg_info_item_t *vg_item, uint64 fid, bool32 *is_open); #endif diff --git a/src/common/dss_param.c b/src/common/dss_param.c index 1b02d88..85f8592 100644 --- a/src/common/dss_param.c +++ b/src/common/dss_param.c @@ -123,10 +123,9 @@ static status_t dss_load_session_cfg(dss_config_t *inst_cfg) { char *value = cm_get_config_value(&inst_cfg->config, "MAX_SESSION_NUMS"); int32 sessions; - if (cm_str2int(value, &sessions) != CM_SUCCESS) { - DSS_THROW_ERROR(ERR_DSS_INVALID_PARAM, "MAX_SESSION_NUMS"); - return CM_ERROR; - } + status_t status = cm_str2int(value, &sessions); + DSS_RETURN_IFERR2(status, DSS_THROW_ERROR(ERR_DSS_INVALID_PARAM, "MAX_SESSION_NUMS")); + if (sessions < DSS_MIN_SESSIONID_CFG || sessions > CM_MAX_SESSIONS) { DSS_THROW_ERROR(ERR_DSS_INVALID_PARAM, "MAX_SESSION_NUMS"); return CM_ERROR; @@ -157,10 +156,8 @@ static status_t dss_load_mes_pool_size(dss_config_t *inst_cfg) { int64 mes_pool_size; char *value = cm_get_config_value(&inst_cfg->config, "RECV_MSG_POOL_SIZE"); - if (cm_str2size(value, &mes_pool_size) != CM_SUCCESS) { - DSS_THROW_ERROR(ERR_DSS_INVALID_PARAM, "RECV_MSG_POOL_SIZE"); - return CM_ERROR; - } + status_t status = cm_str2size(value, &mes_pool_size); + DSS_RETURN_IFERR2(status, DSS_THROW_ERROR(ERR_DSS_INVALID_PARAM, "RECV_MSG_POOL_SIZE")); inst_cfg->params.mes_pool_size = (uint64)mes_pool_size; if ((inst_cfg->params.mes_pool_size < DSS_MIN_RECV_MSG_BUFF_SIZE) || @@ -176,10 +173,7 @@ static status_t dss_load_mes_url(dss_config_t *inst_cfg) { char *value = cm_get_config_value(&inst_cfg->config, "DSS_NODES_LIST"); status_t status = cm_split_mes_urls(inst_cfg->params.nodes, inst_cfg->params.ports, value); - if (status != CM_SUCCESS) { - DSS_THROW_ERROR(ERR_DSS_INVALID_PARAM, "DSS_NODES_LIST"); - return status; - } + DSS_RETURN_IFERR2(status, DSS_THROW_ERROR(ERR_DSS_INVALID_PARAM, "DSS_NODES_LIST")); int32 node_cnt = 0; for (int i = 0; i < DSS_MAX_INSTANCES; i++) { if (inst_cfg->params.ports[i] != 0) { @@ -211,10 +205,9 @@ static status_t dss_load_mes_channel_num(dss_config_t *inst_cfg) { uint32 channel_num; char *value = cm_get_config_value(&inst_cfg->config, "INTERCONNECT_CHANNEL_NUM"); - if (cm_str2uint32(value, &channel_num) != CM_SUCCESS) { - DSS_THROW_ERROR(ERR_DSS_INVALID_PARAM, "invalid parameter value of 'INTERCONNECT_CHANNEL_NUM'"); - return CM_ERROR; - } + status_t status = cm_str2uint32(value, &channel_num); + DSS_RETURN_IFERR2( + status, DSS_THROW_ERROR(ERR_DSS_INVALID_PARAM, "invalid parameter value of 'INTERCONNECT_CHANNEL_NUM'")); if (channel_num < CM_MES_MIN_CHANNEL_NUM || channel_num > CM_MES_MAX_CHANNEL_NUM) { DSS_THROW_ERROR(ERR_DSS_INVALID_PARAM, "INTERCONNECT_CHANNEL_NUM"); @@ -230,10 +223,8 @@ static status_t dss_load_mes_work_thread_cnt(dss_config_t *inst_cfg) { uint32 work_thread_cnt; char *value = cm_get_config_value(&inst_cfg->config, "WORK_THREAD_COUNT"); - if (cm_str2uint32(value, &work_thread_cnt) != CM_SUCCESS) { - DSS_THROW_ERROR(ERR_DSS_INVALID_PARAM, "invalid parameter value of 'WORK_THREAD_COUNT'"); - return CM_ERROR; - } + status_t status = cm_str2uint32(value, &work_thread_cnt); + DSS_RETURN_IFERR2(status, DSS_THROW_ERROR(ERR_DSS_INVALID_PARAM, "invalid parameter value of 'WORK_THREAD_COUNT'")); if (work_thread_cnt < DSS_MIN_WORK_THREAD_COUNT || work_thread_cnt > DSS_MAX_WORK_THREAD_COUNT) { DSS_THROW_ERROR(ERR_DSS_INVALID_PARAM, "WORK_THREAD_COUNT"); @@ -290,10 +281,8 @@ int32 dss_decrypt_pwd_cb(const char *cipher_text, uint32 cipher_len, char *plain return CM_ERROR; } if (cipher.cipher_len > 0) { - if (cm_decrypt_pwd(&cipher, (uchar *)plain_text, &plain_len) != CM_SUCCESS) { - LOG_DEBUG_ERR("[DSS] failed to decrypt ssl pwd."); - return CM_ERROR; - } + status_t status = cm_decrypt_pwd(&cipher, (uchar *)plain_text, &plain_len); + DSS_RETURN_IFERR2(status, LOG_DEBUG_ERR("[DSS] failed to decrypt ssl pwd.")); } else { CM_THROW_ERROR(ERR_INVALID_PARAM, "SSL_PWD_CIPHERTEXT"); LOG_DEBUG_ERR("[DSS] failed to decrypt ssl pwd for the cipher len is invalid."); @@ -305,40 +294,33 @@ int32 dss_decrypt_pwd_cb(const char *cipher_text, uint32 cipher_len, char *plain status_t dss_load_mes_ssl(dss_config_t *inst_cfg) { char *value = cm_get_config_value(&inst_cfg->config, "SSL_CA"); - if (dss_set_ssl_param("SSL_CA", value) != CM_SUCCESS) { - DSS_THROW_ERROR(ERR_DSS_INVALID_PARAM, "SSL_CA"); - return CM_ERROR; - } + status_t status = dss_set_ssl_param("SSL_CA", value); + DSS_RETURN_IFERR2(status, DSS_THROW_ERROR(ERR_DSS_INVALID_PARAM, "SSL_CA")); + value = cm_get_config_value(&inst_cfg->config, "SSL_KEY"); - if (dss_set_ssl_param("SSL_KEY", value) != CM_SUCCESS) { - DSS_THROW_ERROR(ERR_DSS_INVALID_PARAM, "SSL_KEY"); - return CM_ERROR; - } + status = dss_set_ssl_param("SSL_KEY", value); + DSS_RETURN_IFERR2(status, DSS_THROW_ERROR(ERR_DSS_INVALID_PARAM, "SSL_KEY")); + value = cm_get_config_value(&inst_cfg->config, "SSL_CRL"); - if (dss_set_ssl_param("SSL_CRL", value) != CM_SUCCESS) { - DSS_THROW_ERROR(ERR_DSS_INVALID_PARAM, "SSL_CRL"); - return CM_ERROR; - } + status = dss_set_ssl_param("SSL_CRL", value); + DSS_RETURN_IFERR2(status, DSS_THROW_ERROR(ERR_DSS_INVALID_PARAM, "SSL_CRL")); + value = cm_get_config_value(&inst_cfg->config, "SSL_CERT"); - if (dss_set_ssl_param("SSL_CERT", value) != CM_SUCCESS) { - DSS_THROW_ERROR(ERR_DSS_INVALID_PARAM, "SSL_CERT"); - return CM_ERROR; - } + status = dss_set_ssl_param("SSL_CERT", value); + DSS_RETURN_IFERR2(status, DSS_THROW_ERROR(ERR_DSS_INVALID_PARAM, "SSL_CERT")); + value = cm_get_config_value(&inst_cfg->config, "SSL_CIPHER"); - if (dss_set_ssl_param("SSL_CIPHER", value) != CM_SUCCESS) { - DSS_THROW_ERROR(ERR_DSS_INVALID_PARAM, "SSL_CIPHER"); - return CM_ERROR; - } + status = dss_set_ssl_param("SSL_CIPHER", value); + DSS_RETURN_IFERR2(status, DSS_THROW_ERROR(ERR_DSS_INVALID_PARAM, "SSL_CIPHER")); + value = cm_get_config_value(&inst_cfg->config, "SSL_CERT_NOTIFY_TIME"); - if (dss_set_ssl_param("SSL_CERT_NOTIFY_TIME", value) != CM_SUCCESS) { - DSS_THROW_ERROR(ERR_DSS_INVALID_PARAM, "SSL_CERT_NOTIFY_TIME"); - return CM_ERROR; - } + status = dss_set_ssl_param("SSL_CERT_NOTIFY_TIME", value); + DSS_RETURN_IFERR2(status, DSS_THROW_ERROR(ERR_DSS_INVALID_PARAM, "SSL_CERT_NOTIFY_TIME")); + value = cm_get_config_value(&inst_cfg->config, "SSL_PWD_CIPHERTEXT"); - if (dss_set_ssl_param("SSL_PWD_CIPHERTEXT", value) != CM_SUCCESS) { - DSS_THROW_ERROR(ERR_DSS_INVALID_PARAM, "SSL_PWD_CIPHERTEXT"); - return CM_ERROR; - } + status = dss_set_ssl_param("SSL_PWD_CIPHERTEXT", value); + DSS_RETURN_IFERR2(status, DSS_THROW_ERROR(ERR_DSS_INVALID_PARAM, "SSL_PWD_CIPHERTEXT")); + if (!CM_IS_EMPTY_STR(value)) { return mes_register_decrypt_pwd(dss_decrypt_pwd_cb); } @@ -362,10 +344,8 @@ static status_t dss_load_disk_lock_interval(dss_config_t *inst_cfg) char *value = cm_get_config_value(&inst_cfg->config, "DISK_LOCK_INTERVAL"); int32 lock_interval; - if (cm_str2int(value, &lock_interval) != CM_SUCCESS) { - DSS_THROW_ERROR(ERR_DSS_INVALID_PARAM, "DISK_LOCK_INTERVAL"); - return CM_ERROR; - } + status_t status = cm_str2int(value, &lock_interval); + DSS_RETURN_IFERR2(status, DSS_THROW_ERROR(ERR_DSS_INVALID_PARAM, "DISK_LOCK_INTERVAL")); if (lock_interval < DSS_MIN_LOCK_INTERVAL || lock_interval > DSS_MAX_LOCK_INTERVAL) { DSS_THROW_ERROR(ERR_DSS_INVALID_PARAM, "DISK_LOCK_INTERVAL"); @@ -381,10 +361,8 @@ static status_t dss_load_dlock_retry_count(dss_config_t *inst_cfg) char *value = cm_get_config_value(&inst_cfg->config, "DLOCK_RETRY_COUNT"); uint32 dlock_retry_count; - if (cm_str2uint32(value, &dlock_retry_count) != CM_SUCCESS) { - DSS_THROW_ERROR(ERR_DSS_INVALID_PARAM, "DLOCK_RETRY_COUNT"); - return CM_ERROR; - } + status_t status = cm_str2uint32(value, &dlock_retry_count); + DSS_RETURN_IFERR2(status, DSS_THROW_ERROR(ERR_DSS_INVALID_PARAM, "DLOCK_RETRY_COUNT")); if (dlock_retry_count < DSS_MIN_DLOCK_RETRY_COUNT || dlock_retry_count > DSS_MAX_DLOCK_RETRY_COUNT) { DSS_THROW_ERROR(ERR_DSS_INVALID_PARAM, "DLOCK_RETRY_COUNT"); @@ -399,10 +377,8 @@ static status_t dss_load_path(dss_config_t *inst_cfg) { int32 ret; char *value = cm_get_config_value(&inst_cfg->config, "LSNR_PATH"); - if (dss_verify_lsnr_path(value) != CM_SUCCESS) { - DSS_THROW_ERROR(ERR_DSS_INVALID_PARAM, "failed to load params, invalid LSNR_PATH"); - return CM_ERROR; - } + status_t status = dss_verify_lsnr_path(value); + DSS_RETURN_IFERR2(status, DSS_THROW_ERROR(ERR_DSS_INVALID_PARAM, "failed to load params, invalid LSNR_PATH")); ret = snprintf_s(inst_cfg->params.lsnr_path, DSS_UNIX_PATH_MAX, DSS_UNIX_PATH_MAX - 1, "%s/%s", value, DSS_UNIX_DOMAIN_SOCKET_NAME); if (ret == -1) { @@ -417,10 +393,9 @@ static status_t dss_load_disk_lock_file_path(dss_config_t *inst_cfg) { int32 ret; char *value = cm_get_config_value(&inst_cfg->config, "DISK_LOCK_FILE_PATH"); - if (dss_verify_lock_file_path(value) != CM_SUCCESS) { - DSS_THROW_ERROR(ERR_DSS_INVALID_PARAM, "failed to load params, invalid DISK_LOCK_FILE_PATH"); - return CM_ERROR; - } + status_t status = dss_verify_lock_file_path(value); + DSS_RETURN_IFERR2( + status, DSS_THROW_ERROR(ERR_DSS_INVALID_PARAM, "failed to load params, invalid DISK_LOCK_FILE_PATH")); ret = snprintf_s(inst_cfg->params.disk_lock_file_path, DSS_UNIX_PATH_MAX, DSS_UNIX_PATH_MAX - 1, "%s", value); if (ret == -1) { DSS_THROW_ERROR(ERR_DSS_INVALID_PARAM, "failed to load params, invalid DISK_LOCK_FILE_PATH"); @@ -440,10 +415,8 @@ status_t dss_set_cfg_dir(const char *home, dss_config_t *inst_cfg) DSS_THROW_ERROR(ERR_DSS_INVALID_PARAM, "invalid cfg dir"); return CM_ERROR; } - if (realpath_file(home_env, home_realpath, DSS_MAX_PATH_BUFFER_SIZE) != CM_SUCCESS) { - DSS_THROW_ERROR(ERR_DSS_INVALID_PARAM, "invalid cfg dir"); - return CM_ERROR; - } + status_t status = realpath_file(home_env, home_realpath, DSS_MAX_PATH_BUFFER_SIZE); + DSS_RETURN_IFERR2(status, DSS_THROW_ERROR(ERR_DSS_INVALID_PARAM, "invalid cfg dir")); } else { uint32 len = (uint32)strlen(home); if (len >= DSS_MAX_PATH_BUFFER_SIZE) { @@ -461,10 +434,8 @@ status_t dss_set_cfg_dir(const char *home, dss_config_t *inst_cfg) static status_t dss_load_instance_id(dss_config_t *inst_cfg) { char *value = cm_get_config_value(&inst_cfg->config, "INST_ID"); - if (cm_str2bigint(value, &inst_cfg->params.inst_id) != CM_SUCCESS) { - DSS_THROW_ERROR(ERR_DSS_INVALID_PARAM, "the value of 'INST_ID' is invalid"); - return CM_ERROR; - } + status_t status = cm_str2bigint(value, &inst_cfg->params.inst_id); + DSS_RETURN_IFERR2(status, DSS_THROW_ERROR(ERR_DSS_INVALID_PARAM, "the value of 'INST_ID' is invalid")); if (inst_cfg->params.inst_id < DSS_MIN_INST_ID || inst_cfg->params.inst_id >= DSS_MAX_INST_ID) { DSS_THROW_ERROR(ERR_DSS_INVALID_PARAM, "the value of 'INST_ID' is invalid"); @@ -481,10 +452,8 @@ static status_t dss_load_shm_key(dss_config_t *inst_cfg) // 单个机器上最多允许(1<params.shm_key) != CM_SUCCESS) { - LOG_DEBUG_ERR("invalid parameter value of '_SHM_KEY', value:%s.", value); - return CM_ERROR; - } + status_t status = cm_str2uint32(value, &inst_cfg->params.shm_key); + DSS_RETURN_IFERR2(status, LOG_DEBUG_ERR("invalid parameter value of '_SHM_KEY', value:%s.", value)); if (inst_cfg->params.shm_key < DSS_MIN_SHM_KEY || inst_cfg->params.shm_key > DSS_MAX_SHM_KEY) { DSS_THROW_ERROR(ERR_DSS_INVALID_PARAM, "the value of '_SHM_KEY' is invalid"); @@ -510,10 +479,8 @@ status_t dss_load_config(dss_config_t *inst_cfg) return CM_ERROR; } - if (cm_load_config(g_dss_params, DSS_PARAM_COUNT, file_name, &inst_cfg->config, CM_FALSE) != CM_SUCCESS) { - DSS_THROW_ERROR(ERR_DSS_INVALID_PARAM, "failed to load config"); - return CM_ERROR; - } + status_t status = cm_load_config(g_dss_params, DSS_PARAM_COUNT, file_name, &inst_cfg->config, CM_FALSE); + DSS_RETURN_IFERR2(status, DSS_THROW_ERROR(ERR_DSS_INVALID_PARAM, "failed to load config")); CM_RETURN_IFERR(dss_load_path(inst_cfg)); CM_RETURN_IFERR(dss_load_disk_lock_file_path(inst_cfg)); @@ -545,10 +512,8 @@ status_t dss_set_ssl_param(const char *param_name, const char *param_value) cbb_param_t param_type; param_value_t out_value; CM_RETURN_IFERR(mes_chk_md_param(param_name, param_value, ¶m_type, &out_value)); - if (mes_set_md_param(param_type, &out_value) != CM_SUCCESS) { - DSS_THROW_ERROR(ERR_DSS_INVALID_PARAM, param_name); - return CM_ERROR; - } + status_t status = mes_set_md_param(param_type, &out_value); + DSS_RETURN_IFERR2(status, DSS_THROW_ERROR(ERR_DSS_INVALID_PARAM, param_name)); return CM_SUCCESS; } diff --git a/src/common/dss_param_verify.c b/src/common/dss_param_verify.c index 07f7824..d62348a 100644 --- a/src/common/dss_param_verify.c +++ b/src/common/dss_param_verify.c @@ -39,10 +39,8 @@ status_t dss_verify_log_level(void *lex, void *def) uint32 num; text_t text = {.str = value, .len = (uint32)strlen(value)}; cm_trim_text(&text); - if (cm_text2uint32(&text, &num) != CM_SUCCESS) { - CM_THROW_ERROR(ERR_INVALID_PARAM, "_LOG_LEVEL"); - return CM_ERROR; - } + status_t status = cm_text2uint32(&text, &num); + DSS_RETURN_IFERR2(status, CM_THROW_ERROR(ERR_INVALID_PARAM, "_LOG_LEVEL")); if (num > MAX_LOG_LEVEL) { CM_THROW_ERROR(ERR_INVALID_PARAM, "_LOG_LEVEL"); @@ -193,10 +191,8 @@ status_t dss_verify_log_file_size(void *lex, void *def) uint64 num; text_t text = {.str = value, .len = (uint32)strlen(value)}; cm_trim_text(&text); - if (cm_text2size(&text, (int64 *)&num) != CM_SUCCESS) { - DSS_THROW_ERROR(ERR_DSS_INVALID_PARAM, "_LOG_MAX_FILE_SIZE"); - return CM_ERROR; - } + status_t status = cm_text2size(&text, (int64 *)&num); + DSS_RETURN_IFERR2(status, DSS_THROW_ERROR(ERR_DSS_INVALID_PARAM, "_LOG_MAX_FILE_SIZE")); if (num < CM_MIN_LOG_FILE_SIZE || num > CM_MAX_LOG_FILE_SIZE) { DSS_THROW_ERROR(ERR_DSS_INVALID_PARAM, "_LOG_MAX_FILE_SIZE"); return CM_ERROR; @@ -247,10 +243,8 @@ status_t dss_verify_audit_backup_file_count(void *lex, void *def) uint32 num; text_t text = {.str = value, .len = (uint32)strlen(value)}; cm_trim_text(&text); - if (cm_text2uint32(&text, &num) != CM_SUCCESS) { - DSS_THROW_ERROR(ERR_DSS_INVALID_PARAM, "_AUDIT_BACKUP_FILE_COUNT"); - return CM_ERROR; - } + status_t status = cm_text2uint32(&text, &num); + DSS_RETURN_IFERR2(status, DSS_THROW_ERROR(ERR_DSS_INVALID_PARAM, "_AUDIT_BACKUP_FILE_COUNT")); if (num > CM_MAX_LOG_FILE_COUNT) { DSS_THROW_ERROR(ERR_DSS_INVALID_PARAM, "_AUDIT_BACKUP_FILE_COUNT"); return CM_ERROR; @@ -274,10 +268,8 @@ status_t dss_verify_audit_file_size(void *lex, void *def) uint64 num; text_t text = {.str = value, .len = (uint32)strlen(value)}; cm_trim_text(&text); - if (cm_text2size(&text, (int64 *)&num) != CM_SUCCESS) { - DSS_THROW_ERROR(ERR_DSS_INVALID_PARAM, "_AUDIT_MAX_FILE_SIZE"); - return CM_ERROR; - } + status_t status = cm_text2size(&text, (int64 *)&num); + DSS_RETURN_IFERR2(status, DSS_THROW_ERROR(ERR_DSS_INVALID_PARAM, "_AUDIT_MAX_FILE_SIZE")); if (num < CM_MIN_LOG_FILE_SIZE || num > CM_MAX_LOG_FILE_SIZE) { DSS_THROW_ERROR(ERR_DSS_INVALID_PARAM, "_AUDIT_MAX_FILE_SIZE"); return CM_ERROR; diff --git a/src/common/dss_protocol.c b/src/common/dss_protocol.c index 417449f..cd4a739 100644 --- a/src/common/dss_protocol.c +++ b/src/common/dss_protocol.c @@ -133,10 +133,9 @@ status_t dss_write_packet(cs_pipe_t *pipe, dss_packet_t *pack) return CM_ERROR; } - if (VIO_SEND_TIMED(pipe, pack->buf, pack->head->size, DSS_DEFAULT_NULL_VALUE) != CM_SUCCESS) { - CM_THROW_ERROR(ERR_PACKET_SEND, "SEND PACKET FAILED"); - return CM_ERROR; - } + status_t status = VIO_SEND_TIMED(pipe, pack->buf, pack->head->size, DSS_DEFAULT_NULL_VALUE); + DSS_RETURN_IFERR2( + status, CM_THROW_ERROR(ERR_PACKET_SEND, pack->buf_size, pack->head->size, DSS_DEFAULT_NULL_VALUE)); return CM_SUCCESS; } @@ -157,20 +156,17 @@ static status_t dss_read_packet(cs_pipe_t *pipe, dss_packet_t *pack, bool32 cs_c bool32 ready = CM_FALSE; offset = 0; + status_t status; + char *cs_mes = cs_client ? "read wait for server response" : "read wait for client request"; for (;;) { - if (VIO_RECV(pipe, pack->buf + offset, (uint32)(pack->buf_size - offset), &recv_size) != CM_SUCCESS) { - DSS_THROW_ERROR(ERR_TCP_RECV, "Receive protocol failed."); - return CM_ERROR; - } + status = VIO_RECV(pipe, pack->buf + offset, (uint32)(pack->buf_size - offset), &recv_size); + DSS_RETURN_IFERR2(status, DSS_THROW_ERROR(ERR_TCP_RECV, "Receive protocol failed.")); offset += recv_size; if (offset >= (int32)sizeof(dss_packet_head_t)) { break; } - if (VIO_WAIT(pipe, CS_WAIT_FOR_READ, CM_NETWORK_IO_TIMEOUT, &ready) != CM_SUCCESS) { - DSS_THROW_ERROR( - ERR_TCP_TIMEOUT, cs_client ? "read wait for server response" : "read wait for client request"); - return CM_ERROR; - } + status = VIO_WAIT(pipe, CS_WAIT_FOR_READ, CM_NETWORK_IO_TIMEOUT, &ready); + DSS_RETURN_IFERR2(status, DSS_THROW_ERROR(ERR_TCP_TIMEOUT, cs_mes)); if (!ready) { DSS_THROW_ERROR(ERR_DSS_TCP_TIMEOUT_REMAIN, (uint32)(sizeof(uint32) - offset)); return CM_ERROR; @@ -187,20 +183,16 @@ static status_t dss_read_packet(cs_pipe_t *pipe, dss_packet_t *pack, bool32 cs_c return CM_SUCCESS; } - if (VIO_WAIT(pipe, CS_WAIT_FOR_READ, CM_NETWORK_IO_TIMEOUT, &ready) != CM_SUCCESS) { - DSS_THROW_ERROR(ERR_TCP_TIMEOUT, cs_client ? "read wait for server response" : "read wait for client request"); - return CM_ERROR; - } + status = VIO_WAIT(pipe, CS_WAIT_FOR_READ, CM_NETWORK_IO_TIMEOUT, &ready); + DSS_RETURN_IFERR2(status, DSS_THROW_ERROR(ERR_TCP_TIMEOUT, cs_mes)); if (!ready) { - DSS_THROW_ERROR(ERR_TCP_TIMEOUT, cs_client ? "read wait for server response" : "read wait for client request"); + DSS_THROW_ERROR(ERR_TCP_TIMEOUT, cs_mes); return CM_ERROR; } - if (VIO_RECV_TIMED(pipe, pack->buf + offset, (uint32)remain_size, CM_NETWORK_IO_TIMEOUT) != CM_SUCCESS) { - DSS_THROW_ERROR(ERR_TCP_RECV, "Receive protocol failed."); - return CM_ERROR; - } + status = VIO_RECV_TIMED(pipe, pack->buf + offset, (uint32)remain_size, CM_NETWORK_IO_TIMEOUT); + DSS_RETURN_IFERR2(status, DSS_THROW_ERROR(ERR_TCP_RECV, "Receive protocol failed.")); return CM_SUCCESS; } @@ -240,6 +232,7 @@ status_t dss_call_ex(cs_pipe_t *pipe, dss_packet_t *req, dss_packet_t *ack) if (ret != CM_SUCCESS) { LOG_RUN_ERR("[DSS] ABORT INFO: dss call server failed, ack command type:%d, application exit.", ack->head->cmd); cs_disconnect(pipe); + cm_fync_logfile(); _exit(1); } return ret; diff --git a/src/common/dss_redo.c b/src/common/dss_redo.c index bed2d39..b8b19e4 100644 --- a/src/common/dss_redo.c +++ b/src/common/dss_redo.c @@ -45,15 +45,11 @@ status_t dss_set_log_buf_for_first_vg(const char *vg_name, dss_vg_info_item_t *v dss_ctrl->core.volume_attrs[0].free); uint64 log_offset = dss_get_log_offset(au_size); if (dss_ctrl->core.volume_attrs[0].free < log_offset) { - LOG_DEBUG_ERR("The first vg has no enough space for global log."); - return CM_ERROR; + DSS_RETURN_IFERR2(CM_ERROR, LOG_DEBUG_ERR("The first vg has no enough space for global log.")); } dss_ctrl->core.volume_attrs[0].hwm = dss_ctrl->core.volume_attrs[0].hwm + log_offset; dss_ctrl->core.volume_attrs[0].free = dss_ctrl->core.volume_attrs[0].free - log_offset; - status_t status = dss_update_core_ctrl_disk(vg_item); - if (status != CM_SUCCESS) { - return status; - } + DSS_RETURN_IF_ERROR(dss_update_core_ctrl_disk(vg_item)); LOG_DEBUG_INF("Begin to init log slot.au_size:%llu, hwm:%llu, free:%llu", au_size, dss_ctrl->core.volume_attrs[0].hwm, dss_ctrl->core.volume_attrs[0].free); #ifndef WIN32 @@ -62,22 +58,15 @@ status_t dss_set_log_buf_for_first_vg(const char *vg_name, dss_vg_info_item_t *v char log_buf_head[DSS_DISK_UNIT_SIZE]; #endif errno_t rc = memset_s(log_buf_head, DSS_DISK_UNIT_SIZE, 0, DSS_DISK_UNIT_SIZE); - if (rc != EOK) { - LOG_DEBUG_ERR("Init log buf head failed."); - DSS_THROW_ERROR(ERR_SYSTEM_CALL, rc); - return CM_ERROR; - } + DSS_SECUREC_RETURN_IF_ERROR2(rc, LOG_DEBUG_ERR("Init log buf head failed."), CM_ERROR); int64 offset; for (uint32 i = 0; i < DSS_LOG_BUF_SLOT_COUNT; i++) { offset = (int64)au_size + i * DSS_INSTANCE_LOG_SPLIT_SIZE; LOG_DEBUG_INF("Init log slot %u .offset:%lld. log split size:%u", i, offset, DSS_INSTANCE_LOG_SPLIT_SIZE); - status = dss_write_volume(volume, offset, log_buf_head, DSS_DISK_UNIT_SIZE); - if (status != CM_SUCCESS) { - LOG_DEBUG_ERR("Init log slot %u failed.", i); - return status; - } + DSS_RETURN_IFERR2(dss_write_volume(volume, offset, log_buf_head, DSS_DISK_UNIT_SIZE), + LOG_DEBUG_ERR("Init log slot %u failed.", i)); } - return status; + return CM_SUCCESS; } status_t dss_set_log_buf(const char *vg_name, dss_vg_info_item_t *vg_item, dss_volume_t *volume) @@ -135,22 +124,18 @@ status_t dss_reset_log_slot_head(int32_t slot) char *log_buf = (char *)(log_ctrl->log_buf + slot * DSS_INSTANCE_LOG_SPLIT_SIZE); errno_t errcode = memset_s(log_buf, DSS_DISK_UNIT_SIZE, 0, DSS_DISK_UNIT_SIZE); securec_check_ret(errcode); + status_t status; dss_vg_info_item_t *vg_item = dss_get_first_vg_item(); if (vg_item->volume_handle[0].handle == DSS_INVALID_HANDLE) { - if (dss_open_volume(vg_item->entry_path, NULL, DSS_INSTANCE_OPEN_FLAG, &vg_item->volume_handle[0]) != - CM_SUCCESS) { - LOG_DEBUG_ERR("Failed to open volume %s.", vg_item->entry_path); - return CM_ERROR; - } + status = dss_open_volume(vg_item->entry_path, NULL, DSS_INSTANCE_OPEN_FLAG, &vg_item->volume_handle[0]); + DSS_RETURN_IFERR2(status, LOG_DEBUG_ERR("Failed to open volume %s.", vg_item->entry_path)); } uint64 au_size = dss_get_vg_au_size(vg_item->dss_ctrl); int64 offset = au_size + slot * DSS_INSTANCE_LOG_SPLIT_SIZE; CM_ASSERT(offset % DSS_DISK_UNIT_SIZE == 0); - status_t status = dss_write_volume(&vg_item->volume_handle[0], offset, log_buf, DSS_DISK_UNIT_SIZE); - if (status != CM_SUCCESS) { - LOG_DEBUG_ERR("Failed to write log head, slot: %d, offset:%lld, size:%u.", slot, offset, DSS_DISK_UNIT_SIZE); - return status; - } + status = dss_write_volume(&vg_item->volume_handle[0], offset, log_buf, DSS_DISK_UNIT_SIZE); + DSS_RETURN_IFERR2(status, + LOG_DEBUG_ERR("Failed to write log head, slot: %d, offset:%lld, size:%u.", slot, offset, DSS_DISK_UNIT_SIZE)); LOG_DEBUG_INF("Reset head of log slot %d.", slot); return status; } @@ -191,6 +176,7 @@ void dss_imediate_process_redo(dss_session_t *session, dss_vg_info_item_t *vg_it if (status != CM_SUCCESS) { LOG_RUN_ERR("[DSS] ABORT INFO: redo log process failed, errcode:%d, OS errno:%d, OS errmsg:%s.", cm_get_error_code(), errno, strerror(errno)); + cm_fync_logfile(); _exit(1); } } @@ -298,16 +284,10 @@ static status_t rp_redo_update_volhead(dss_vg_info_item_t *vg_item, dss_redo_ent #endif dss_redo_volhead_t *redo = (dss_redo_volhead_t *)entry->data; if (entry->size == 0) { - DSS_THROW_ERROR(ERR_DSS_REDO_ILL, "invalid entry log size 0."); - return CM_ERROR; + DSS_RETURN_IFERR2(CM_ERROR, DSS_THROW_ERROR(ERR_DSS_REDO_ILL, "invalid entry log size 0.")); } - int32 errcode = memcpy_sp(align_buf, DSS_DISK_UNIT_SIZE, redo->head, DSS_DISK_UNIT_SIZE); - if (errcode != EOK) { - DSS_THROW_ERROR(ERR_SYSTEM_CALL, errcode); - return CM_ERROR; - } - + securec_check_ret(errcode); dss_volume_t volume; if (dss_open_volume(redo->name, NULL, DSS_INSTANCE_OPEN_FLAG, &volume) != CM_SUCCESS) { return CM_ERROR; @@ -322,16 +302,14 @@ static status_t rp_redo_add_or_remove_volume(dss_vg_info_item_t *vg_item, dss_re errno_t errcode = 0; dss_redo_volop_t *redo = (dss_redo_volop_t *)entry->data; if (entry->size == 0) { - DSS_THROW_ERROR(ERR_DSS_REDO_ILL, "invalid entry log size 0."); - return CM_ERROR; + DSS_RETURN_IFERR2(CM_ERROR, DSS_THROW_ERROR(ERR_DSS_REDO_ILL, "invalid entry log size 0.")); } dss_volume_attr_t *attr = (dss_volume_attr_t *)redo->attr; uint32 id = attr->id; if (vg_item->status == DSS_STATUS_RECOVERY) { if (dss_refresh_vginfo(vg_item) != CM_SUCCESS) { - DSS_LOG_DEBUG_OP("%s refresh vginfo failed.", "rp_redo_add_or_remove_volume"); - return CM_ERROR; + DSS_RETURN_IFERR2(CM_ERROR, LOG_DEBUG_ERR("%s refresh vginfo failed.", "rp_redo_add_or_remove_volume")); } // in recovery @@ -360,10 +338,7 @@ static status_t rp_redo_add_or_remove_volume(dss_vg_info_item_t *vg_item, dss_re vg_item->dss_ctrl->volume.version = redo->volume_version; } status_t status = dss_update_volume_id_info(vg_item, id); - if (status != CM_SUCCESS) { - LOG_DEBUG_ERR("Failed to update core ctrl and volume to disk, vg:%s.", vg_item->vg_name); - return status; - } + DSS_RETURN_IFERR2(status, LOG_DEBUG_ERR("Failed to update core ctrl and volume to disk, vg:%s.", vg_item->vg_name)); DSS_LOG_DEBUG_OP("Succeed to replay add or remove volume:%u.", id); return CM_SUCCESS; } @@ -392,10 +367,7 @@ static status_t rp_update_core_ctrl(dss_vg_info_item_t *vg_item, dss_redo_entry_ } LOG_DEBUG_INF("replay to update core ctrl, hwm:%llu.", vg_item->dss_ctrl->core.volume_attrs[0].hwm); status_t status = dss_update_core_ctrl_disk(vg_item); - if (status != CM_SUCCESS) { - LOG_DEBUG_ERR("Failed to update core ctrl to disk, vg:%s.", vg_item->vg_name); - return status; - } + DSS_RETURN_IFERR2(status, LOG_DEBUG_ERR("Failed to update core ctrl to disk, vg:%s.", vg_item->vg_name)); DSS_LOG_DEBUG_OP("Succeed to replay update core ctrl:%s.", vg_item->vg_name); return CM_SUCCESS; } @@ -450,8 +422,7 @@ static status_t rp_redo_alloc_ft_node_core( } node = dss_get_ft_node_by_ftid(vg_item, data->node[i].id, check_version, CM_FALSE); if (node == NULL) { - DSS_THROW_ERROR(ERR_DSS_FNODE_CHECK, "invalid ft node."); - return CM_ERROR; + DSS_RETURN_IFERR2(CM_ERROR, DSS_THROW_ERROR(ERR_DSS_FNODE_CHECK, "invalid ft node.")); } if (vg_item->status == DSS_STATUS_RECOVERY) { @@ -465,9 +436,7 @@ static status_t rp_redo_alloc_ft_node_core( continue; // already update the block to disk } status = dss_update_ft_block_disk(vg_item, cur_block, data->node[i].id); - if (status != CM_SUCCESS) { - return status; - } + DSS_RETURN_IF_ERROR(status); rp_insert_block_addr_history(&addr_his, cur_block); } return CM_SUCCESS; @@ -484,8 +453,7 @@ static status_t rp_redo_alloc_ft_node(dss_vg_info_item_t *vg_item, dss_redo_entr bool32 check_version = CM_FALSE; if (entry->size == 0) { - DSS_THROW_ERROR(ERR_DSS_REDO_ILL, "invalid entry log size 0."); - return CM_ERROR; + DSS_RETURN_IFERR2(CM_ERROR, DSS_THROW_ERROR(ERR_DSS_REDO_ILL, "invalid entry log size 0.")); } if (vg_item->status == DSS_STATUS_RECOVERY) { status = dss_refresh_root_ft(vg_item, CM_TRUE, CM_FALSE); @@ -500,11 +468,7 @@ static status_t rp_redo_alloc_ft_node(dss_vg_info_item_t *vg_item, dss_redo_entr } status = dss_update_ft_root(vg_item); - if (status != CM_SUCCESS) { - DSS_THROW_ERROR(ERR_DSS_REDO_ILL, "Failed to update file table root."); - return status; - } - + DSS_RETURN_IFERR2(status, DSS_THROW_ERROR(ERR_DSS_REDO_ILL, "Failed to update file table root.")); DSS_RETURN_IF_ERROR(rp_redo_alloc_ft_node_core(vg_item, data, ft_block, check_version)); DSS_LOG_DEBUG_OP("Succeed to replay alloc ft node, vg name:%s.", vg_item->vg_name); return CM_SUCCESS; @@ -534,8 +498,7 @@ static status_t rb_rollback_ft_block(dss_vg_info_item_t *vg_item, gft_node_t *no } cur_node = dss_get_ft_node_by_ftid(vg_item, node[i].id, check_version, CM_FALSE); if (!cur_node) { - DSS_THROW_ERROR(ERR_DSS_FNODE_CHECK, "invalid ft node."); - return CM_ERROR; + DSS_RETURN_IFERR2(CM_ERROR, DSS_THROW_ERROR(ERR_DSS_FNODE_CHECK, "invalid ft node.")); } cur_block = dss_get_ft_block_by_node(cur_node); @@ -556,8 +519,7 @@ static status_t rb_redo_alloc_ft_node(dss_vg_info_item_t *vg_item, dss_redo_entr dss_redo_alloc_ft_node_t *data = (dss_redo_alloc_ft_node_t *)entry->data; if (entry->size == 0) { - DSS_THROW_ERROR(ERR_DSS_REDO_ILL, "invalid entry log size 0."); - return CM_ERROR; + DSS_RETURN_IFERR2(CM_ERROR, DSS_THROW_ERROR(ERR_DSS_REDO_ILL, "invalid entry log size 0.")); } return rb_rollback_ft_block(vg_item, data->node, DSS_REDO_ALLOC_FT_NODE_NUM); @@ -566,16 +528,10 @@ static status_t rb_redo_alloc_ft_node(dss_vg_info_item_t *vg_item, dss_redo_entr static status_t dss_update_ft_info(dss_vg_info_item_t *vg_item, dss_ft_block_t *block, dss_redo_format_ft_t *data) { status_t status = dss_update_ft_block_disk(vg_item, block, data->old_last_block); - if (status != CM_SUCCESS) { - LOG_DEBUG_ERR("Failed to update file table block to disk, auid:%llu.", DSS_ID_TO_U64(data->old_last_block)); - return status; - } - + DSS_RETURN_IFERR2(status, + LOG_DEBUG_ERR("Failed to update file table block to disk, auid:%llu.", DSS_ID_TO_U64(data->old_last_block))); status = dss_update_ft_root(vg_item); - if (status != CM_SUCCESS) { - LOG_DEBUG_ERR("Failed to update file table root, vg:%s.", vg_item->vg_name); - return status; - } + DSS_RETURN_IFERR2(status, LOG_DEBUG_ERR("Failed to update file table root, vg:%s.", vg_item->vg_name)); return CM_SUCCESS; } @@ -586,58 +542,39 @@ static status_t rp_redo_format_ft_node(dss_vg_info_item_t *vg_item, dss_redo_ent status_t status; dss_redo_format_ft_t *data = (dss_redo_format_ft_t *)entry->data; dss_ft_block_t *block = NULL; - if (vg_item->status == DSS_STATUS_RECOVERY) { status = dss_refresh_root_ft(vg_item, CM_TRUE, CM_FALSE); - if (status != CM_SUCCESS) { - LOG_DEBUG_ERR("Failed to refresh file table root, vg:%s.", vg_item->vg_name); - return status; - } - + DSS_RETURN_IFERR2(status, LOG_DEBUG_ERR("Failed to refresh file table root, vg:%s.", vg_item->vg_name)); // note:first load block = (dss_ft_block_t *)dss_get_ft_block_by_ftid(vg_item, data->old_last_block); if (block == NULL) { - LOG_DEBUG_ERR("Failed to get last file table block, blockid:%llu.", DSS_ID_TO_U64(data->old_last_block)); - return CM_ERROR; + DSS_RETURN_IFERR2(CM_ERROR, LOG_DEBUG_ERR("Failed to get last file table block, blockid:%llu.", + DSS_ID_TO_U64(data->old_last_block))); } dss_root_ft_block_t *root_block = DSS_GET_ROOT_BLOCK(vg_item->dss_ctrl); root_block->ft_root.free_list = data->old_free_list; root_block->ft_root.last = data->old_last_block; status = dss_format_ft_node(NULL, vg_item, data->auid); - if (status != CM_SUCCESS) { - LOG_DEBUG_ERR("Failed to format file table node, auid:%llu.", DSS_ID_TO_U64(data->auid)); - return status; - } + DSS_RETURN_IFERR2( + status, LOG_DEBUG_ERR("Failed to format file table node, auid:%llu.", DSS_ID_TO_U64(data->auid))); } - // when recover, has load old last block. if (vg_item->status != DSS_STATUS_RECOVERY) { // just find the block, it has already in memory. block = (dss_ft_block_t *)dss_get_ft_block_by_ftid(vg_item, data->old_last_block); if (block == NULL) { - LOG_DEBUG_ERR("Failed to get last file table block, blockid:%llu.", DSS_ID_TO_U64(data->old_last_block)); - return CM_ERROR; + DSS_RETURN_IFERR2(CM_ERROR, LOG_DEBUG_ERR("Failed to get last file table block, blockid:%llu.", + DSS_ID_TO_U64(data->old_last_block))); } } - CM_RETURN_IFERR(dss_update_ft_info(vg_item, block, data)); - dss_block_id_t first = data->auid; ga_obj_id_t obj_id; status = dss_find_block_objid_in_shm(vg_item, first, DSS_BLOCK_TYPE_FT, &obj_id); - if (status != CM_SUCCESS) { - LOG_DEBUG_ERR("Failed to find block:%llu.", DSS_ID_TO_U64(first)); - return status; - } - + DSS_RETURN_IFERR2(status, LOG_DEBUG_ERR("Failed to find block:%llu.", DSS_ID_TO_U64(first))); status = dss_update_au_disk(vg_item, data->auid, GA_8K_POOL, obj_id.obj_id, data->count, DSS_BLOCK_SIZE); - if (status != CM_SUCCESS) { - LOG_DEBUG_ERR("Failed to update au to disk, au:%llu.", DSS_ID_TO_U64(data->auid)); - return status; - } - + DSS_RETURN_IFERR2(status, LOG_DEBUG_ERR("Failed to update au to disk, au:%llu.", DSS_ID_TO_U64(data->auid))); DSS_LOG_DEBUG_OP("Succeed to replay formate ft node, auid:%llu, obj_id:%u, count:%u, old_last_block:%llu.", DSS_ID_TO_U64(data->auid), data->obj_id, data->count, DSS_ID_TO_U64(data->old_last_block)); - return CM_SUCCESS; } @@ -662,26 +599,19 @@ static status_t rp_redo_free_fs_block(dss_vg_info_item_t *vg_item, dss_redo_entr block = (dss_fs_block_t *)dss_find_block_in_shm( vg_item, log_block->head.id, DSS_BLOCK_TYPE_FS, CM_TRUE, &obj_id, CM_FALSE); if (block == NULL) { - DSS_THROW_ERROR(ERR_DSS_FNODE_CHECK, "invalid block"); - return CM_ERROR; + DSS_RETURN_IFERR2(CM_ERROR, DSS_THROW_ERROR(ERR_DSS_FNODE_CHECK, "invalid block")); } block->head.next = log_block->head.next; status = dss_update_fs_bitmap_block_disk(vg_item, block, DSS_DISK_UNIT_SIZE, CM_FALSE); - if (status != CM_SUCCESS) { - return status; - } - + DSS_RETURN_IF_ERROR(status); dss_unregister_buffer_cache(vg_item, log_block->head.id); ga_free_object(obj_id.pool_id, obj_id.obj_id); - return CM_SUCCESS; } status = dss_update_fs_bitmap_block_disk(vg_item, log_block, DSS_DISK_UNIT_SIZE, CM_TRUE); - if (status != CM_SUCCESS) { - LOG_DEBUG_ERR("Failed to update fs bitmap block:%llu to disk.", DSS_ID_TO_U64(log_block->head.id)); - return status; - } + DSS_RETURN_IFERR2( + status, LOG_DEBUG_ERR("Failed to update fs bitmap block:%llu to disk.", DSS_ID_TO_U64(log_block->head.id))); DSS_LOG_DEBUG_OP( "Succeed to replay free fs block:%llu, vg name:%s.", DSS_ID_TO_U64(log_block->head.id), vg_item->vg_name); return CM_SUCCESS; @@ -710,15 +640,10 @@ static status_t rp_redo_alloc_fs_block(dss_vg_info_item_t *vg_item, dss_redo_ent if (vg_item->status == DSS_STATUS_RECOVERY) { status = dss_check_refresh_core(vg_item); - if (status != CM_SUCCESS) { - LOG_DEBUG_ERR("Failed to refresh vg core:%s.", vg_item->vg_name); - return status; - } - + DSS_RETURN_IFERR2(status, LOG_DEBUG_ERR("Failed to refresh vg core:%s.", vg_item->vg_name)); block = (dss_fs_block_t *)dss_find_block_in_shm(vg_item, data->id, DSS_BLOCK_TYPE_FS, CM_TRUE, NULL, CM_FALSE); if (block == NULL) { - DSS_THROW_ERROR(ERR_DSS_FNODE_CHECK, "invalid block"); - return CM_ERROR; + DSS_RETURN_IFERR2(CM_ERROR, DSS_THROW_ERROR(ERR_DSS_FNODE_CHECK, "invalid block")); } dss_init_fs_block_head(block); @@ -727,25 +652,18 @@ static status_t rp_redo_alloc_fs_block(dss_vg_info_item_t *vg_item, dss_redo_ent vg_item->dss_ctrl->core.version++; status = dss_update_core_ctrl_disk(vg_item); - if (status != CM_SUCCESS) { - LOG_DEBUG_ERR("Failed to update vg core:%s to disk.", vg_item->vg_name); - return status; - } + DSS_RETURN_IFERR2(status, LOG_DEBUG_ERR("Failed to update vg core:%s to disk.", vg_item->vg_name)); if (block == NULL) { block = (dss_fs_block_t *)dss_find_block_in_shm(vg_item, data->id, DSS_BLOCK_TYPE_FS, CM_FALSE, NULL, CM_FALSE); } if (block == NULL) { - DSS_THROW_ERROR(ERR_DSS_FNODE_CHECK, "invalid block"); - return CM_ERROR; + DSS_RETURN_IFERR2(CM_ERROR, DSS_THROW_ERROR(ERR_DSS_FNODE_CHECK, "invalid block")); } status = dss_update_fs_bitmap_block_disk(vg_item, block, DSS_FILE_SPACE_BLOCK_SIZE, CM_FALSE); - if (status != CM_SUCCESS) { - LOG_DEBUG_ERR("Failed to update fs bitmap block:%llu to disk.", DSS_ID_TO_U64(data->id)); - return status; - } + DSS_RETURN_IFERR2(status, LOG_DEBUG_ERR("Failed to update fs bitmap block:%llu to disk.", DSS_ID_TO_U64(data->id))); DSS_LOG_DEBUG_OP("Succeed to replay alloc fs block:%llu, vg name:%s.", DSS_ID_TO_U64(data->id), vg_item->vg_name); return CM_SUCCESS; } @@ -783,8 +701,7 @@ status_t rp_redo_init_fs_block(dss_vg_info_item_t *vg_item, dss_redo_entry_t *en if (vg_item->status == DSS_STATUS_RECOVERY) { block = (dss_fs_block_t *)dss_find_block_in_shm(vg_item, data->id, DSS_BLOCK_TYPE_FS, CM_TRUE, NULL, CM_FALSE); if (block == NULL) { - DSS_THROW_ERROR(ERR_DSS_FNODE_CHECK, "invalid block"); - return CM_ERROR; + DSS_RETURN_IFERR2(CM_ERROR, DSS_THROW_ERROR(ERR_DSS_FNODE_CHECK, "invalid block")); } block->bitmap[data->index] = data->second_id; block->head.used_num = data->used_num; @@ -793,16 +710,12 @@ status_t rp_redo_init_fs_block(dss_vg_info_item_t *vg_item, dss_redo_entry_t *en if (block == NULL) { block = (dss_fs_block_t *)dss_find_block_in_shm(vg_item, data->id, DSS_BLOCK_TYPE_FS, CM_FALSE, NULL, CM_FALSE); if (block == NULL) { - DSS_THROW_ERROR(ERR_DSS_FNODE_CHECK, "invalid block"); - return CM_ERROR; + DSS_RETURN_IFERR2(CM_ERROR, DSS_THROW_ERROR(ERR_DSS_FNODE_CHECK, "invalid block")); } } status = dss_update_fs_bitmap_block_disk(vg_item, block, DSS_FILE_SPACE_BLOCK_SIZE, CM_FALSE); - if (status != CM_SUCCESS) { - LOG_DEBUG_ERR("Failed to update fs bitmap block:%llu to disk.", DSS_ID_TO_U64(data->id)); - return status; - } + DSS_RETURN_IFERR2(status, LOG_DEBUG_ERR("Failed to update fs bitmap block:%llu to disk.", DSS_ID_TO_U64(data->id))); DSS_LOG_DEBUG_OP("Succeed to replay init fs block:%llu, vg name:%s.", DSS_ID_TO_U64(data->id), vg_item->vg_name); return CM_SUCCESS; } @@ -817,8 +730,7 @@ status_t rb_redo_init_fs_block(dss_vg_info_item_t *vg_item, dss_redo_entry_t *en dss_fs_block_t *block = (dss_fs_block_t *)dss_find_block_in_shm(vg_item, data->id, DSS_BLOCK_TYPE_FS, CM_FALSE, NULL, CM_FALSE); if (block == NULL) { - DSS_THROW_ERROR(ERR_DSS_FNODE_CHECK, "invalid block"); - return CM_ERROR; + DSS_RETURN_IFERR2(CM_ERROR, DSS_THROW_ERROR(ERR_DSS_FNODE_CHECK, "invalid block")); } dss_set_blockid(&block->bitmap[data->index], CM_INVALID_ID64); @@ -833,8 +745,7 @@ status_t rp_redo_rename_file(dss_vg_info_item_t *vg_item, dss_redo_entry_t *entr CM_ASSERT(entry != NULL); if (entry->size == 0) { - DSS_THROW_ERROR(ERR_DSS_REDO_ILL, "invalid entry log size 0."); - return CM_ERROR; + DSS_RETURN_IFERR2(CM_ERROR, DSS_THROW_ERROR(ERR_DSS_REDO_ILL, "invalid entry log size 0.")); } bool32 check_version = CM_FALSE; @@ -844,14 +755,12 @@ status_t rp_redo_rename_file(dss_vg_info_item_t *vg_item, dss_redo_entry_t *entr dss_redo_rename_t *data = (dss_redo_rename_t *)entry->data; if (dss_cmp_auid(data->node.id, CM_INVALID_ID64)) { - DSS_THROW_ERROR(ERR_DSS_FNODE_CHECK, "invalid node 0xFFFFFFFF"); - return CM_ERROR; + DSS_RETURN_IFERR2(CM_ERROR, DSS_THROW_ERROR(ERR_DSS_FNODE_CHECK, "invalid node 0xFFFFFFFF")); } gft_node_t *node = dss_get_ft_node_by_ftid(vg_item, data->node.id, check_version, CM_FALSE); if (!node) { - DSS_THROW_ERROR(ERR_DSS_FNODE_CHECK, "invalid node"); - return CM_ERROR; + DSS_RETURN_IFERR2(CM_ERROR, DSS_THROW_ERROR(ERR_DSS_FNODE_CHECK, "invalid node")); } if (vg_item->status == DSS_STATUS_RECOVERY) { @@ -861,15 +770,11 @@ status_t rp_redo_rename_file(dss_vg_info_item_t *vg_item, dss_redo_entry_t *entr dss_ft_block_t *cur_block = dss_get_ft_block_by_node(node); if (cur_block == NULL) { - DSS_THROW_ERROR(ERR_DSS_FNODE_CHECK, "invalid block"); - return CM_ERROR; + DSS_RETURN_IFERR2(CM_ERROR, DSS_THROW_ERROR(ERR_DSS_FNODE_CHECK, "invalid block")); } status_t status = dss_update_ft_block_disk(vg_item, cur_block, data->node.id); - if (status != CM_SUCCESS) { - LOG_DEBUG_ERR("Failed to update fs block:%llu to disk.", DSS_ID_TO_U64(data->node.id)); - return status; - } + DSS_RETURN_IFERR2(status, LOG_DEBUG_ERR("Failed to update fs block:%llu to disk.", DSS_ID_TO_U64(data->node.id))); DSS_LOG_DEBUG_OP("Succeed to replay rename file:%s, vg name:%s.", data->name, vg_item->vg_name); return CM_SUCCESS; } @@ -882,22 +787,19 @@ status_t rb_redo_rename_file(dss_vg_info_item_t *vg_item, dss_redo_entry_t *entr bool32 check_version = CM_FALSE; if (entry->size == 0) { - DSS_THROW_ERROR(ERR_DSS_REDO_ILL, "invalid entry log size 0."); - return CM_ERROR; + DSS_RETURN_IFERR2(CM_ERROR, DSS_THROW_ERROR(ERR_DSS_REDO_ILL, "invalid entry log size 0.")); } if (vg_item->status == DSS_STATUS_RECOVERY) { check_version = CM_TRUE; } if (dss_cmp_auid(data->node.id, CM_INVALID_ID64)) { - DSS_THROW_ERROR(ERR_DSS_FNODE_CHECK, "invalid node 0xFFFFFFFF"); - return CM_ERROR; + DSS_RETURN_IFERR2(CM_ERROR, DSS_THROW_ERROR(ERR_DSS_FNODE_CHECK, "invalid node 0xFFFFFFFF")); } gft_node_t *node = dss_get_ft_node_by_ftid(vg_item, data->node.id, check_version, CM_FALSE); if (!node) { - DSS_THROW_ERROR(ERR_DSS_FNODE_CHECK, "invalid node"); - return CM_ERROR; + DSS_RETURN_IFERR2(CM_ERROR, DSS_THROW_ERROR(ERR_DSS_FNODE_CHECK, "invalid node")); } int32 ret = snprintf_s(node->name, DSS_MAX_NAME_LEN, strlen(data->old_name), "%s", data->old_name); @@ -922,7 +824,7 @@ status_t rp_redo_set_fs_block(dss_vg_info_item_t *vg_item, dss_redo_entry_t *ent block = (dss_fs_block_t *)dss_find_block_in_shm(vg_item, data->id, DSS_BLOCK_TYPE_FS, check_version, NULL, CM_FALSE); if (block == NULL) { - DSS_THROW_ERROR(ERR_DSS_FNODE_CHECK, "invalid block"); + DSS_RETURN_IFERR2(CM_ERROR, DSS_THROW_ERROR(ERR_DSS_FNODE_CHECK, "invalid block")); return CM_ERROR; } @@ -932,10 +834,7 @@ status_t rp_redo_set_fs_block(dss_vg_info_item_t *vg_item, dss_redo_entry_t *ent } status = dss_update_fs_bitmap_block_disk(vg_item, block, DSS_FILE_SPACE_BLOCK_SIZE, CM_FALSE); - if (status != CM_SUCCESS) { - LOG_DEBUG_ERR("Failed to update fs block:%llu to disk.", DSS_ID_TO_U64(data->id)); - return status; - } + DSS_RETURN_IFERR2(status, LOG_DEBUG_ERR("Failed to update fs block:%llu to disk.", DSS_ID_TO_U64(data->id))); DSS_LOG_DEBUG_OP("Succeed to replay set fs block:%llu, used_num:%hu, vg name:%s.", DSS_ID_TO_U64(data->id), block->head.used_num, vg_item->vg_name); return CM_SUCCESS; @@ -954,7 +853,7 @@ status_t rb_redo_set_fs_block(dss_vg_info_item_t *vg_item, dss_redo_entry_t *ent block = (dss_fs_block_t *)dss_find_block_in_shm(vg_item, data->id, DSS_BLOCK_TYPE_FS, check_version, NULL, CM_FALSE); if (block == NULL) { - DSS_THROW_ERROR(ERR_DSS_FNODE_CHECK, "invalid block"); + DSS_RETURN_IFERR2(CM_ERROR, DSS_THROW_ERROR(ERR_DSS_FNODE_CHECK, "invalid block")); return CM_ERROR; } @@ -1023,7 +922,7 @@ status_t rp_redo_free_ft_node(dss_vg_info_item_t *vg_item, dss_redo_entry_t *ent bool32 check_version = CM_FALSE; if (entry->size == 0) { - return CM_ERROR; + DSS_RETURN_IFERR2(CM_ERROR, DSS_THROW_ERROR(ERR_DSS_REDO_ILL, "invalid entry log size 0.")); } if (vg_item->status == DSS_STATUS_RECOVERY) { CM_RETURN_IFERR_EX(dss_refresh_root_ft(vg_item, CM_TRUE, CM_FALSE), @@ -1043,8 +942,7 @@ status_t rb_redo_free_ft_node(dss_vg_info_item_t *vg_item, dss_redo_entry_t *ent dss_redo_free_ft_node_t *data = (dss_redo_free_ft_node_t *)entry->data; if (entry->size == 0) { - DSS_THROW_ERROR(ERR_DSS_REDO_ILL, "invalid entry log size 0."); - return CM_ERROR; + DSS_RETURN_IFERR2(CM_ERROR, DSS_THROW_ERROR(ERR_DSS_REDO_ILL, "invalid entry log size 0.")); } return rb_rollback_ft_block(vg_item, data->node, DSS_REDO_FREE_FT_NODE_NUM); @@ -1063,8 +961,7 @@ status_t rp_redo_recycle_ft_node(dss_vg_info_item_t *vg_item, dss_redo_entry_t * } if (entry->size == 0) { - DSS_THROW_ERROR(ERR_DSS_REDO_ILL, "invalid entry log size 0."); - return CM_ERROR; + DSS_RETURN_IFERR2(CM_ERROR, DSS_THROW_ERROR(ERR_DSS_REDO_ILL, "invalid entry log size 0.")); } dss_block_addr_his_t addr_his; @@ -1079,8 +976,7 @@ status_t rp_redo_recycle_ft_node(dss_vg_info_item_t *vg_item, dss_redo_entry_t * } node = dss_get_ft_node_by_ftid(vg_item, data->node[i].id, check_version, CM_FALSE); if (!node) { - DSS_THROW_ERROR(ERR_DSS_FNODE_CHECK, "invalid ft node."); - return CM_ERROR; + DSS_RETURN_IFERR2(CM_ERROR, DSS_THROW_ERROR(ERR_DSS_FNODE_CHECK, "invalid ft node.")); } if (vg_item->status == DSS_STATUS_RECOVERY) { @@ -1108,8 +1004,7 @@ status_t rb_redo_recycle_ft_node(dss_vg_info_item_t *vg_item, dss_redo_entry_t * bool32 check_version = CM_FALSE; if (entry->size == 0) { - DSS_THROW_ERROR(ERR_DSS_REDO_ILL, "invalid entry log size 0."); - return CM_ERROR; + DSS_RETURN_IFERR2(CM_ERROR, DSS_THROW_ERROR(ERR_DSS_REDO_ILL, "invalid entry log size 0.")); } gft_node_t *node; @@ -1122,17 +1017,14 @@ status_t rb_redo_recycle_ft_node(dss_vg_info_item_t *vg_item, dss_redo_entry_t * } node = dss_get_ft_node_by_ftid(vg_item, data->node[i].id, check_version, CM_FALSE); if (!node) { - DSS_THROW_ERROR(ERR_DSS_FNODE_CHECK, "invalid ft node."); - return CM_ERROR; + DSS_RETURN_IFERR2(CM_ERROR, DSS_THROW_ERROR(ERR_DSS_FNODE_CHECK, "invalid ft node.")); } cur_block = dss_get_ft_block_by_node(node); int64 offset = dss_get_ft_block_offset(vg_item, data->node[i].id); status = dss_get_block_from_disk( vg_item, data->node[i].id, (char *)cur_block, offset, (int32)DSS_BLOCK_SIZE, CM_TRUE); - if (status != CM_SUCCESS) { - return status; - } + DSS_RETURN_IF_ERROR(status); } return CM_SUCCESS; } @@ -1146,16 +1038,14 @@ static status_t rp_redo_set_file_size_inner(dss_vg_info_item_t *vg_item, dss_red check_version = CM_TRUE; } if (entry->size == 0) { - DSS_THROW_ERROR(ERR_DSS_REDO_ILL, "invalid entry log size 0."); - return CM_ERROR; + DSS_RETURN_IFERR2(CM_ERROR, DSS_THROW_ERROR(ERR_DSS_REDO_ILL, "invalid entry log size 0.")); } gft_node_t *node; dss_ft_block_t *cur_block = NULL; *ftid = ((dss_redo_set_file_size_t *)entry->data)->ftid; node = dss_get_ft_node_by_ftid(vg_item, *ftid, check_version, CM_FALSE); if (!node) { - DSS_THROW_ERROR(ERR_DSS_FNODE_CHECK, "invalid ft node."); - return CM_ERROR; + DSS_RETURN_IFERR2(CM_ERROR, DSS_THROW_ERROR(ERR_DSS_FNODE_CHECK, "invalid ft node.")); } dss_redo_set_file_size_t *size_info = (dss_redo_set_file_size_t *)entry->data; LOG_DEBUG_INF("Begin to replay set file:%llu, size:%llu, oldsize:%llu, vg name:%s.", DSS_ID_TO_U64(size_info->ftid), @@ -1185,14 +1075,12 @@ static status_t rb_redo_get_ft_node( { bool32 check_version = CM_FALSE; if (entry->size == 0) { - DSS_THROW_ERROR(ERR_DSS_REDO_ILL, "invalid entry log size 0."); - return CM_ERROR; + DSS_RETURN_IFERR2(CM_ERROR, DSS_THROW_ERROR(ERR_DSS_REDO_ILL, "invalid entry log size 0.")); } *node = dss_get_ft_node_by_ftid(vg_item, ftid, check_version, CM_FALSE); if (!(*node)) { - DSS_THROW_ERROR(ERR_DSS_FNODE_CHECK, "invalid ft node."); - return CM_ERROR; + DSS_RETURN_IFERR2(CM_ERROR, DSS_THROW_ERROR(ERR_DSS_FNODE_CHECK, "invalid ft node.")); } return CM_SUCCESS; } @@ -1218,38 +1106,24 @@ status_t rp_redo_format_fs_block(dss_vg_info_item_t *vg_item, dss_redo_entry_t * if (vg_item->status == DSS_STATUS_RECOVERY) { status = dss_check_refresh_core(vg_item); - if (status != CM_SUCCESS) { - LOG_DEBUG_ERR("Failed to refresh vg core:%s.", vg_item->vg_name); - return status; - } + DSS_RETURN_IFERR2(status, LOG_DEBUG_ERR("Failed to refresh vg core:%s.", vg_item->vg_name)); dss_fs_block_root_t *block_root = DSS_GET_FS_BLOCK_ROOT(vg_item->dss_ctrl); block_root->free = data->old_free_list; status = dss_format_bitmap_node(NULL, vg_item, data->auid); - if (status != CM_SUCCESS) { - LOG_DEBUG_ERR("Fail to format file space node, auid:%llu.", DSS_ID_TO_U64(data->auid)); - return status; - } + DSS_RETURN_IFERR2( + status, LOG_DEBUG_ERR("Fail to format file space node, auid:%llu.", DSS_ID_TO_U64(data->auid))); } status = dss_update_core_ctrl_disk(vg_item); - if (status != CM_SUCCESS) { - LOG_DEBUG_ERR("Fail to write ctrl to disk, vg:%s.", vg_item->vg_name); - return status; - } + DSS_RETURN_IFERR2(status, LOG_DEBUG_ERR("Fail to write ctrl to disk, vg:%s.", vg_item->vg_name)); dss_block_id_t first = data->auid; ga_obj_id_t obj_id; status = dss_find_block_objid_in_shm(vg_item, first, DSS_BLOCK_TYPE_FS, &obj_id); - if (status != CM_SUCCESS) { - LOG_DEBUG_ERR("Fail to find block:%llu.", DSS_ID_TO_U64(first)); - return status; - } + DSS_RETURN_IFERR2(status, LOG_DEBUG_ERR("Fail to find block:%llu.", DSS_ID_TO_U64(first))); status = dss_update_au_disk(vg_item, data->auid, GA_16K_POOL, obj_id.obj_id, data->count, DSS_FILE_SPACE_BLOCK_SIZE); - if (status != CM_SUCCESS) { - LOG_DEBUG_ERR("Fail to update au:%llu.", DSS_ID_TO_U64(data->auid)); - return status; - } + DSS_RETURN_IFERR2(status, LOG_DEBUG_ERR("Fail to update au:%llu.", DSS_ID_TO_U64(data->auid))); DSS_LOG_DEBUG_OP( "Succeed to replay format au:%llu fs block, vg name:%s.", DSS_ID_TO_U64(data->auid), vg_item->vg_name); return CM_SUCCESS; @@ -1288,19 +1162,11 @@ status_t rb_redo_format_fs_block(dss_vg_info_item_t *vg_item, dss_redo_entry_t * dss_block_id_t first = data->auid; ga_obj_id_t obj_id; status = dss_find_block_objid_in_shm(vg_item, first, DSS_BLOCK_TYPE_FS, &obj_id); - if (status != CM_SUCCESS) { - LOG_DEBUG_ERR("Failed to find block:%llu.", DSS_ID_TO_U64(first)); - return status; - } - + DSS_RETURN_IFERR2(status, LOG_DEBUG_ERR("Failed to find block:%llu.", DSS_ID_TO_U64(first))); rb_redo_clean_resource(vg_item, data->auid, GA_16K_POOL, obj_id.obj_id, data->count); status = dss_load_vg_ctrl_part(vg_item, (int64)DSS_CTRL_CORE_OFFSET, vg_item->dss_ctrl->core_data, DSS_DISK_UNIT_SIZE); - if (status != CM_SUCCESS) { - LOG_DEBUG_ERR("Failed to load vg:%s.", vg_item->vg_name); - return status; - } - + DSS_RETURN_IFERR2(status, LOG_DEBUG_ERR("Failed to load vg:%s.", vg_item->vg_name)); return CM_SUCCESS; } @@ -1355,10 +1221,7 @@ status_t dss_apply_log(dss_vg_info_item_t *vg_item, char *log_buf) while (offset < data_size) { entry = (dss_redo_entry_t *)(batch->data + offset); status = dss_replay(vg_item, entry); - if (status != CM_SUCCESS) { - return status; - } - + DSS_RETURN_IF_ERROR(status); offset += entry->size; dss_execute_syncpoint(DSS_SP_ID_PARTIAL_REDO_BREAK, NULL); } @@ -1372,33 +1235,21 @@ static status_t dss_recover_core_ctrlinfo(dss_vg_info_item_t *vg_item) uint32 checksum; status = dss_load_vg_ctrl_part( vg_item, (int64)DSS_CTRL_CORE_OFFSET, &vg_item->dss_ctrl->core, (int32)DSS_CORE_CTRL_SIZE); - if (status != CM_SUCCESS) { - LOG_DEBUG_ERR("Load dss ctrl core failed."); - return status; - } + DSS_RETURN_IFERR2(status, LOG_DEBUG_ERR("Load dss ctrl core failed.")); checksum = dss_get_checksum(&vg_item->dss_ctrl->core, DSS_CORE_CTRL_SIZE); if (checksum != vg_item->dss_ctrl->core.checksum) { LOG_RUN_INF("Try recover dss ctrl core."); status = dss_load_vg_ctrl_part( vg_item, (int64)DSS_CTRL_BAK_CORE_OFFSET, &vg_item->dss_ctrl->core, (int32)DSS_CORE_CTRL_SIZE); - if (status != CM_SUCCESS) { - LOG_DEBUG_ERR("Load dss ctrl core failed."); - return status; - } + DSS_RETURN_IFERR2(status, LOG_DEBUG_ERR("Load dss ctrl core failed.")); checksum = dss_get_checksum(&vg_item->dss_ctrl->core, DSS_CORE_CTRL_SIZE); dss_check_checksum(checksum, vg_item->dss_ctrl->core.checksum); status = dss_update_core_ctrl_disk(vg_item); - if (status != CM_SUCCESS) { - LOG_DEBUG_ERR("Update dss core ctrl failed."); - return status; - } + DSS_RETURN_IFERR2(status, LOG_DEBUG_ERR("Update dss ctrl core failed.")); } else { status = dss_write_ctrl_to_disk( vg_item, (int64)DSS_CTRL_BAK_CORE_OFFSET, &vg_item->dss_ctrl->core, DSS_CORE_CTRL_SIZE); - if (status != CM_SUCCESS) { - LOG_DEBUG_ERR("Write dss ctrl core failed."); - return status; - } + DSS_RETURN_IFERR2(status, LOG_DEBUG_ERR("Write dss ctrl core failed.")); } return status; } @@ -1409,24 +1260,15 @@ static status_t dss_recover_volume_ctrlinfo(dss_vg_info_item_t *vg_item) uint32 checksum; dss_volume_ctrl_t *volume = (dss_volume_ctrl_t *)cm_malloc_align(DSS_ALIGN_SIZE, DSS_VOLUME_CTRL_SIZE); if (volume == NULL) { - LOG_DEBUG_ERR("Can not allocate memory in stack."); - return CM_ERROR; + DSS_RETURN_IFERR2(CM_ERROR, LOG_DEBUG_ERR("Can not allocate memory in stack.")); } status = dss_load_vg_ctrl_part(vg_item, (int64)DSS_CTRL_VOLUME_OFFSET, volume, (int32)DSS_VOLUME_CTRL_SIZE); - if (status != CM_SUCCESS) { - DSS_FREE_POINT(volume); - LOG_DEBUG_ERR("Load dss ctrl volume failed."); - return status; - } + DSS_RETURN_IFERR3(status, DSS_FREE_POINT(volume), LOG_DEBUG_ERR("Load dss ctrl volume failed.")); checksum = dss_get_checksum(volume, DSS_VOLUME_CTRL_SIZE); if (checksum != volume->checksum) { LOG_RUN_INF("Try recover dss ctrl volume."); status = dss_load_vg_ctrl_part(vg_item, (int64)DSS_CTRL_BAK_VOLUME_OFFSET, volume, (int32)DSS_VOLUME_CTRL_SIZE); - if (status != CM_SUCCESS) { - DSS_FREE_POINT(volume); - LOG_DEBUG_ERR("Load dss ctrl volume failed."); - return status; - } + DSS_RETURN_IFERR3(status, DSS_FREE_POINT(volume), LOG_DEBUG_ERR("Load dss ctrl volume failed.")); checksum = dss_get_checksum(volume, DSS_VOLUME_CTRL_SIZE); dss_check_checksum(checksum, volume->checksum); } @@ -1436,14 +1278,9 @@ static status_t dss_recover_volume_ctrlinfo(dss_vg_info_item_t *vg_item) vg_item->dss_ctrl->volume.version = volume->version; } DSS_FREE_POINT(volume); - if (status != CM_SUCCESS) { - return status; - } + DSS_RETURN_IF_ERROR(status); status = dss_update_volume_ctrl(vg_item); - if (status != CM_SUCCESS) { - LOG_DEBUG_ERR("Update dss ctrl volume failed."); - return status; - } + DSS_RETURN_IFERR2(status, LOG_DEBUG_ERR("Update dss ctrl volume failed.")); return status; } @@ -1453,31 +1290,19 @@ static status_t dss_recover_root_ft_ctrlinfo(dss_vg_info_item_t *vg_item) uint32 checksum; dss_common_block_t *block = (dss_common_block_t *)vg_item->dss_ctrl->root; status = dss_load_vg_ctrl_part(vg_item, (int64)DSS_CTRL_ROOT_OFFSET, block, (int32)DSS_BLOCK_SIZE); - if (status != CM_SUCCESS) { - LOG_DEBUG_ERR("Load dss ctrl root failed."); - return status; - } + DSS_RETURN_IFERR2(status, LOG_DEBUG_ERR("Load dss ctrl root failed.")); checksum = dss_get_checksum(block, DSS_BLOCK_SIZE); if (checksum != block->checksum) { LOG_RUN_INF("Try recover dss ctrl root."); status = dss_load_vg_ctrl_part(vg_item, (int64)DSS_CTRL_BAK_ROOT_OFFSET, block, (int32)DSS_BLOCK_SIZE); - if (status != CM_SUCCESS) { - LOG_DEBUG_ERR("Load dss ctrl root failed."); - return status; - } + DSS_RETURN_IFERR2(status, LOG_DEBUG_ERR("Load dss ctrl root failed.")); checksum = dss_get_checksum(block, DSS_BLOCK_SIZE); dss_check_checksum(checksum, block->checksum); status = dss_update_ft_root(vg_item); - if (status != CM_SUCCESS) { - LOG_DEBUG_ERR("Update dss ctrl root ft block failed."); - return status; - } + DSS_RETURN_IFERR2(status, LOG_DEBUG_ERR("Update dss ctrl root ft block failed.")); } else { status = dss_write_ctrl_to_disk(vg_item, (int64)DSS_CTRL_BAK_ROOT_OFFSET, block, DSS_BLOCK_SIZE); - if (status != CM_SUCCESS) { - LOG_DEBUG_ERR("Write dss ctrl root failed."); - return status; - } + DSS_RETURN_IFERR2(status, LOG_DEBUG_ERR("Write dss ctrl root failed.")); } return status; } @@ -1572,17 +1397,13 @@ status_t dss_recover(dss_vg_info_item_t *vg_item) LOG_RUN_INF("Begin recovering."); vg_item->status = DSS_STATUS_RECOVERY; if (dss_recover_ctrlinfo(vg_item) != CM_SUCCESS) { - LOG_DEBUG_ERR("dss ctrl is invalid."); - return CM_ERROR; + DSS_RETURN_IFERR2(CM_ERROR, LOG_DEBUG_ERR("dss ctrl is invalid.")); } offset = 0; while (offset < data_size) { entry = (dss_redo_entry_t *)(batch->data + offset); status_t status = dss_replay(vg_item, entry); - if (status != CM_SUCCESS) { - LOG_DEBUG_ERR("Failed to replay redo log."); - return status; - } + DSS_RETURN_IFERR2(status, LOG_DEBUG_ERR("Failed to replay redo log.")); offset += entry->size; } (void)dss_reset_log(vg_item); @@ -1625,8 +1446,7 @@ status_t dss_recover_when_instance_start(dss_redo_batch_t *batch, bool32 need_ch dss_redo_entry_t *entry = NULL; dss_sort_handle_t *sort_handle = (dss_sort_handle_t *)cm_malloc(batch->count * (uint32)(sizeof(dss_sort_handle_t))); if (sort_handle == NULL) { - LOG_RUN_ERR("Malloc sort handle failed when recover."); - return CM_ERROR; + DSS_RETURN_IFERR2(CM_ERROR, LOG_DEBUG_ERR("Malloc sort handle failed when recover.")); } uint64 offset = 0; for (uint32 i = 0; i < batch->count; i++) { @@ -1647,18 +1467,12 @@ status_t dss_recover_when_instance_start(dss_redo_batch_t *batch, bool32 need_ch entry = (dss_redo_entry_t *)(batch->data + sort_handle[i].offset); LOG_RUN_INF("Start to replay redo log, entry type %u, vg_id %u.", entry->type, entry->vg_id); status_t status = dss_replay(vg_item, entry); - if (status != CM_SUCCESS) { - DSS_FREE_POINT(sort_handle); - LOG_RUN_ERR("Failed to replay redo log, entry type %u, vg_id %u.", entry->type, entry->vg_id); - return status; - } + DSS_RETURN_IFERR3(status, DSS_FREE_POINT(sort_handle), + LOG_RUN_ERR("Failed to replay redo log, entry type %u, vg_id %u.", entry->type, entry->vg_id)); batch->sort_offset = i; status = dss_write_volume_inst(vg_item, &vg_item->volume_handle[0], au_size, batch, DSS_DISK_UNIT_SIZE); - if (status != CM_SUCCESS) { - DSS_FREE_POINT(sort_handle); - LOG_RUN_ERR("Failed to flush redo log head when recovery."); - return status; - } + DSS_RETURN_IFERR3( + status, DSS_FREE_POINT(sort_handle), LOG_RUN_ERR("Failed to flush redo log head when recovery.")); } DSS_FREE_POINT(sort_handle); dss_reset_all_log_slot(); @@ -1708,10 +1522,7 @@ status_t dss_process_redo_log(dss_session_t *session, dss_vg_info_item_t *vg_ite status_t status; status = dss_flush_log(session->log_split, vg_item, log_buf); - if (status != CM_SUCCESS) { - LOG_DEBUG_ERR("Failed to flush log,errcode:%d.", cm_get_error_code()); - return status; - } + DSS_RETURN_IFERR2(status, LOG_DEBUG_ERR("Failed to flush log,errcode:%d.", cm_get_error_code())); // #ifndef WIN32 dss_execute_syncpoint(DSS_SP_ID_FULL_REDO_BREAK, NULL); @@ -1735,17 +1546,13 @@ status_t dss_check_redo_and_recover(dss_vg_info_item_t *vg_item) LOG_DEBUG_INF("Begin to check redo and recover"); status_t status = dss_load_vg_ctrl_part(vg_item, (int64)DSS_LOG_OFFSET, vg_item->dss_ctrl->log_buf, DSS_DISK_UNIT_SIZE); - if (status != CM_SUCCESS) { - LOG_DEBUG_ERR("Failed to load redo log."); - return status; - } + DSS_RETURN_IFERR2(status, LOG_DEBUG_ERR("Failed to load redo log.")); dss_redo_batch_t *batch = (dss_redo_batch_t *)vg_item->dss_ctrl->log_buf; if (batch->size == 0) { LOG_DEBUG_INF("Redo log batch is empty, check dssctrl before check_redo_and_recover ends."); if (dss_recover_ctrlinfo(vg_item) != CM_SUCCESS) { - LOG_DEBUG_ERR("dss ctrl is invalid."); - return CM_ERROR; + DSS_RETURN_IFERR2(CM_ERROR, LOG_DEBUG_ERR("dss ctrl is invalid.")); } return CM_SUCCESS; } @@ -1755,16 +1562,13 @@ status_t dss_check_redo_and_recover(dss_vg_info_item_t *vg_item) if (load_size > DSS_LOG_BUFFER_SIZE) { // invalid log ,ignored it. (void)dss_reset_log(vg_item); - LOG_DEBUG_ERR("Redo log is invalid, ignored it."); + LOG_DEBUG_INF("Redo log is invalid, ignored it."); return CM_SUCCESS; } if (load_size > DSS_DISK_UNIT_SIZE) { status = dss_load_vg_ctrl_part(vg_item, (int64)DSS_LOG_OFFSET, vg_item->dss_ctrl->log_buf, (int32)load_size); - if (status != CM_SUCCESS) { - LOG_DEBUG_ERR("Failed to load redo log."); - return status; - } + DSS_RETURN_IFERR2(status, LOG_DEBUG_ERR("Failed to load redo log.")); } return dss_recover(vg_item); diff --git a/src/common/dss_session.c b/src/common/dss_session.c index 3f202c1..dccf175 100644 --- a/src/common/dss_session.c +++ b/src/common/dss_session.c @@ -27,6 +27,7 @@ #include "dss_malloc.h" #include "dss_file.h" #include "dss_redo.h" +#include "dss_system.h" #include "dss_session.h" #ifdef __cplusplus @@ -200,12 +201,19 @@ void dss_clean_session_latch(dss_session_ctrl_t *session_ctrl, dss_session_t *se stack_top = (int32)session->latch_stack.stack_top; - for (i = stack_top; i >= DSS_MAX_LATCH_STACK_BOTTON; i--) { + for (i = stack_top; i >= DSS_MAX_LATCH_STACK_BOTTON;) { dss_latch_offset_type_e offset_type = session->latch_stack.latch_offset_stack[i].type; if ((i == stack_top) && (offset_type == DSS_LATCH_OFFSET_INVALID)) { + i--; continue; } + if (cm_sys_process_alived(session->cli_info.cli_pid, session->cli_info.start_time)) { + cm_usleep(DSS_LOCK_CLEAN_SLEEP_TIME); + stack_top = (int32)session->latch_stack.stack_top; + i = stack_top; + continue; + } if (offset_type == DSS_LATCH_OFFSET_SHMOFFSET) { offset = session->latch_stack.latch_offset_stack[i].offset.shm_offset; CM_ASSERT(offset != SHM_INVALID_ADDR); @@ -213,6 +221,7 @@ void dss_clean_session_latch(dss_session_ctrl_t *session_ctrl, dss_session_t *se LOG_DEBUG_INF("Clean session latch,i:%d, offset:%llu.", i, (uint64)offset); } else { LOG_DEBUG_ERR("latch offset type is invalid %u,i:%d.", session->latch_stack.latch_offset_stack[i].type, i); + i--; continue; } @@ -225,6 +234,7 @@ void dss_clean_session_latch(dss_session_ctrl_t *session_ctrl, dss_session_t *se latch->shared_count = (uint16)count; session->latch_stack.latch_offset_stack[i].type = DSS_LATCH_OFFSET_INVALID; cm_spin_unlock(&latch->lock); + i--; } session->latch_stack.stack_top = DSS_MAX_LATCH_STACK_BOTTON; @@ -283,6 +293,12 @@ status_t dss_lock_shm_meta_s(dss_session_t *session, const dss_latch_offset_t *o SPIN_STAT_INC(stat, s_sleeps); cm_usleep(SPIN_SLEEP_TIME); sleep_times++; + if (session->is_closed) { + DSS_THROW_ERROR(ERR_DSS_SHM_LOCK, "uds connection is closed."); + LOG_RUN_ERR("Failed to lock vg share memery because uds connection is closed."); + session->latch_stack.latch_offset_stack[session->latch_stack.stack_top].type = DSS_LATCH_OFFSET_INVALID; + return CM_ERROR; + } if (dss_is_timeout(timeout, sleep_times, SPIN_SLEEP_TIME)) { session->latch_stack.latch_offset_stack[session->latch_stack.stack_top].type = DSS_LATCH_OFFSET_INVALID; return CM_ERROR; @@ -297,6 +313,11 @@ status_t dss_cli_lock_shm_meta_s( dss_session_t *session, dss_latch_offset_t *offset, latch_t *latch, latch_should_exit should_exit) { for (int i = 0; i < DSS_CLIENT_TIMEOUT_COUNT; i++) { + if (session->is_closed) { + DSS_THROW_ERROR(ERR_DSS_SHM_LOCK, "uds connection is closed."); + LOG_RUN_ERR("Failed to lock vg share memery because uds connection is closed."); + return CM_ERROR; + } if (dss_lock_shm_meta_s(session, offset, latch, DSS_CLIENT_TIMEOUT) == CM_SUCCESS) { return CM_SUCCESS; } diff --git a/src/common/dss_session.h b/src/common/dss_session.h index 38d8409..ef4c104 100644 --- a/src/common/dss_session.h +++ b/src/common/dss_session.h @@ -40,6 +40,7 @@ extern "C" { #define DSS_INVALID_SESSIONID CM_INVALID_ID32 #define DSS_MAX_LATCH_STACK_BOTTON 0 #define DSS_MAX_LATCH_STACK_DEPTH 8 +#define DSS_LOCK_CLEAN_SLEEP_TIME 500 typedef struct tagdss_cli_info { uint64 cli_pid; diff --git a/src/common/dss_signal.c b/src/common/dss_signal.c index a5ad920..618d360 100644 --- a/src/common/dss_signal.c +++ b/src/common/dss_signal.c @@ -24,8 +24,15 @@ #ifndef WIN32 #include #include "cm_log.h" +#include "dss_defs.h" #include "dss_signal.h" +#ifndef _NSIG +#define MAX_SIG_NUM 32 +#else +#define MAX_SIG_NUM _NSIG +#endif + #define DSS_SIG_FLAG_ONESHOT (int)((uint32_t)SA_ONESHOT | (uint32_t)SA_RESETHAND) typedef void (*dss_signal_handler)(int32_t); @@ -88,12 +95,53 @@ static void dss_croedump_signal_handler_proc(int32 signo) (void)raise(signo); } -status_t dss_signal_proc(void) +int32 coredump_signal_array[] = {SIGILL, SIGTRAP, SIGABRT, SIGBUS, SIGFPE, SIGSEGV}; +int32 graceful_exit_signal_array[] = {SIGUSR1, SIGTERM}; + +status_t dss_coredump_signal_proc(void) +{ + return dss_register_signal(coredump_signal_array, sizeof(coredump_signal_array) / sizeof(coredump_signal_array[0]), + dss_croedump_signal_handler_proc, DSS_SIG_FLAG_ONESHOT); +} + +bool32 dss_is_coredump_signal(int32 signal) +{ + uint8 size = (uint8)sizeof(coredump_signal_array) / sizeof(coredump_signal_array[0]); + for (uint8 i = 0; i < size; i++) { + if (signal == coredump_signal_array[i]) { + return CM_TRUE; + } + } + return CM_FALSE; +} + +bool32 dss_is_graceful_exit_signal(int32 signal) +{ + uint8 size = (uint8)sizeof(graceful_exit_signal_array) / sizeof(graceful_exit_signal_array[0]); + for (uint8 j = 0; j < size; j++) { + if (signal == graceful_exit_signal_array[j]) { + return CM_TRUE; + } + } + return CM_FALSE; +} + +bool32 dss_is_ignore_signal(int32 signal) +{ + if (signal == SIGINT || dss_is_coredump_signal(signal) || dss_is_graceful_exit_signal(signal)) { + return CM_FALSE; + } + return CM_TRUE; +} + +status_t dss_ignore_signal_proc(void) { - int32 coredump_signal_array[] = {SIGILL, SIGTRAP, SIGABRT, SIGBUS, SIGFPE, SIGSEGV}; - status_t ret = - dss_register_signal(coredump_signal_array, sizeof(coredump_signal_array) / sizeof(coredump_signal_array[0]), - dss_croedump_signal_handler_proc, DSS_SIG_FLAG_ONESHOT); - return ret; + for (uint8 i = 0; i < MAX_SIG_NUM; i++) { + if (dss_is_ignore_signal(i)) { + DSS_RETURN_IF_ERROR(cm_regist_signal(i, SIG_IGN)); + } + } + return CM_SUCCESS; } + #endif diff --git a/src/common/dss_signal.h b/src/common/dss_signal.h index 07c981a..b8784b7 100644 --- a/src/common/dss_signal.h +++ b/src/common/dss_signal.h @@ -30,7 +30,8 @@ extern "C" { #endif -status_t dss_signal_proc(void); +status_t dss_coredump_signal_proc(void); +status_t dss_ignore_signal_proc(void); void dss_output_current_bt(void); #ifdef __cplusplus diff --git a/src/common/dss_volume.c b/src/common/dss_volume.c index a2d3e38..f8a50fb 100644 --- a/src/common/dss_volume.c +++ b/src/common/dss_volume.c @@ -45,6 +45,9 @@ status_t dss_open_volume(const char *name, const char *code, int flags, dss_volu if (volume->handle == INVALID_HANDLE_VALUE) { if (cm_get_os_error() == DSS_IO_ERROR) { DSS_THROW_ERROR(ERR_DSS_VOLUME_SYSTEM_IO, name); + LOG_RUN_ERR("[DSS] ABORT INFO: OPEN VOLUME I/O ERROR"); + cm_fync_logfile(); + _exit(1); } else { DSS_THROW_ERROR(ERR_DSS_VOLUME_OPEN, name, cm_get_os_error()); } @@ -66,6 +69,9 @@ status_t dss_open_simple_volume(const char *name, int flags, dss_simple_volume_t if (volume->handle == INVALID_HANDLE_VALUE) { if (cm_get_os_error() == DSS_IO_ERROR) { DSS_THROW_ERROR(ERR_DSS_VOLUME_SYSTEM_IO, name); + LOG_RUN_ERR("[DSS] ABORT INFO: OPEN SIMPLE VOLUME I/O ERROR"); + cm_fync_logfile(); + _exit(1); } else { DSS_THROW_ERROR(ERR_DSS_VOLUME_OPEN, name, cm_get_os_error()); } @@ -112,6 +118,9 @@ static status_t dss_seek_volume(dss_volume_t *volume, uint64 offset) if (SetFilePointer(volume->handle, low32, &high32, FILE_BEGIN) == INVALID_SET_FILE_POINTER) { if (cm_get_os_error() == DSS_IO_ERROR) { DSS_THROW_ERROR(ERR_DSS_VOLUME_SYSTEM_IO, volume->name_p); + LOG_RUN_ERR("[DSS] ABORT INFO: SEEK VOLUME I/O ERROR"); + cm_fync_logfile(); + _exit(1); } else { DSS_THROW_ERROR(ERR_DSS_VOLUME_SEEK, volume->name_p, volume->id, cm_get_os_error()); } @@ -130,6 +139,9 @@ static status_t dss_try_read_volume(dss_volume_t *volume, char *buffer, int32 si if (!ReadFile(volume->handle, buffer, (DWORD)size, (LPDWORD)read_size, NULL)) { if (cm_get_os_error() == DSS_IO_ERROR) { DSS_THROW_ERROR(ERR_DSS_VOLUME_SYSTEM_IO, volume->name_p); + LOG_RUN_ERR("[DSS] ABORT INFO: READ VOLUME I/O ERROR"); + cm_fync_logfile(); + _exit(1); } else { DSS_THROW_ERROR(ERR_DSS_VOLUME_READ, volume->name_p, volume->id, cm_get_os_error()); } @@ -144,6 +156,9 @@ static status_t dss_try_write_volume(dss_volume_t *volume, char *buffer, int32 s if (!WriteFile(volume->handle, buffer, (DWORD)size, (LPDWORD)written_size, NULL)) { if (cm_get_os_error() == DSS_IO_ERROR) { DSS_THROW_ERROR(ERR_DSS_VOLUME_SYSTEM_IO, volume->name_p); + LOG_RUN_ERR("[DSS] ABORT INFO: WRITE VOLUME I/O ERROR"); + cm_fync_logfile(); + _exit(1); } else { DSS_THROW_ERROR(ERR_DSS_VOLUME_WRITE, volume->name_p, volume->id, cm_get_os_error()); } @@ -161,6 +176,9 @@ status_t dss_open_volume_raw(const char *name, const char *code, int flags, dss_ if (volume->handle == -1) { if (cm_get_os_error() == DSS_IO_ERROR) { DSS_THROW_ERROR(ERR_DSS_VOLUME_SYSTEM_IO, name); + LOG_RUN_ERR("[DSS] ABORT INFO: OPEN VOLUME RAW I/O ERROR"); + cm_fync_logfile(); + _exit(1); } else { DSS_THROW_ERROR(ERR_DSS_VOLUME_OPEN, name, cm_get_os_error()); } @@ -180,6 +198,9 @@ status_t dss_open_simple_volume_raw(const char *name, int flags, dss_simple_volu if (volume->handle == -1) { if (cm_get_os_error() == DSS_IO_ERROR) { DSS_THROW_ERROR(ERR_DSS_VOLUME_SYSTEM_IO, name); + LOG_RUN_ERR("[DSS] ABORT INFO: OPEN SIMPLE VOLUME RAW I/O ERROR"); + cm_fync_logfile(); + _exit(1); } else { DSS_THROW_ERROR(ERR_DSS_VOLUME_OPEN, name, cm_get_os_error()); } @@ -214,6 +235,9 @@ uint64 dss_get_volume_size_raw(dss_volume_t *volume) DSS_LOG_WITH_OS_MSG("failed to seek file with handle %d", volume->handle); if (cm_get_os_error() == DSS_IO_ERROR) { DSS_THROW_ERROR(ERR_DSS_VOLUME_SYSTEM_IO, volume->name_p); + LOG_RUN_ERR("[DSS] ABORT INFO: GET VOLUME SIZE I/O ERROR"); + cm_fync_logfile(); + _exit(1); } else { DSS_THROW_ERROR(ERR_DSS_VOLUME_SEEK, volume->name_p, volume->id, cm_get_os_error()); } @@ -228,6 +252,9 @@ static status_t dss_try_pread_volume_raw(dss_volume_t *volume, int64 offset, cha if (*read_size == -1) { if (cm_get_os_error() == DSS_IO_ERROR) { DSS_THROW_ERROR(ERR_DSS_VOLUME_SYSTEM_IO, volume->name_p); + LOG_RUN_ERR("[DSS] ABORT INFO: PREAD VOLUME I/O ERROR"); + cm_fync_logfile(); + _exit(1); } else { DSS_THROW_ERROR(ERR_DSS_VOLUME_READ, volume->name_p, volume->id, cm_get_os_error()); } @@ -244,6 +271,9 @@ static int32 dss_try_pwrite_volume_raw( if (*written_size == -1) { if (cm_get_os_error() == DSS_IO_ERROR) { DSS_THROW_ERROR(ERR_DSS_VOLUME_SYSTEM_IO, volume->name_p); + LOG_RUN_ERR("[DSS] ABORT INFO: PWRITE VOLUME I/O ERROR"); + cm_fync_logfile(); + _exit(1); } else { DSS_THROW_ERROR(ERR_DSS_VOLUME_WRITE, volume->name_p, volume->id, cm_get_os_error()); } @@ -356,6 +386,9 @@ uint64 dss_get_volume_size_rbd(dss_volume_t *volume) DSS_LOG_WITH_OS_MSG("failed to read size with handle %d", volume->handle); if (cm_get_os_error() == DSS_IO_ERROR) { DSS_THROW_ERROR(ERR_DSS_VOLUME_SYSTEM_IO, volume->name_p); + LOG_RUN_ERR("[DSS] ABORT INFO: GET VOLUME SIZE RBD I/O ERROR"); + cm_fync_logfile(); + _exit(1); } else { DSS_THROW_ERROR(ERR_DSS_VOLUME_SEEK, volume->name_p, volume->id, cm_get_os_error()); } @@ -371,6 +404,9 @@ static status_t dss_try_pread_volume_rbd( if (*read_size < 0) { if (cm_get_os_error() == DSS_IO_ERROR) { DSS_THROW_ERROR(ERR_DSS_VOLUME_SYSTEM_IO, volume->name_p); + LOG_RUN_ERR("[DSS] ABORT INFO: PREAD VOLUME RBD I/O ERROR"); + cm_fync_logfile(); + _exit(1); } else { DSS_THROW_ERROR(ERR_DSS_VOLUME_READ, volume->name_p, volume->id, cm_get_os_error()); } @@ -386,6 +422,9 @@ static int32 dss_try_pwrite_volume_rbd( if (*written_size < 0) { if (cm_get_os_error() == DSS_IO_ERROR) { DSS_THROW_ERROR(ERR_DSS_VOLUME_SYSTEM_IO, volume->name_p); + LOG_RUN_ERR("[DSS] ABORT INFO: PWRITE VOLUME RBD I/O ERROR"); + cm_fync_logfile(); + _exit(1); } else { DSS_THROW_ERROR(ERR_DSS_VOLUME_WRITE, volume->name_p, volume->id, cm_get_os_error()); } diff --git a/src/common_api/dss_api_impl.c b/src/common_api/dss_api_impl.c index 8ebd433..3950119 100644 --- a/src/common_api/dss_api_impl.c +++ b/src/common_api/dss_api_impl.c @@ -84,10 +84,8 @@ status_t dss_apply_extending_file(dss_conn_t *conn, int32 handle, int32 size, bo // send it and wait for ack ack_pack = &conn->pack; - if (dss_call_ex(&conn->pipe, send_pack, ack_pack) != CM_SUCCESS) { - LOG_RUN_ERR("Failed to send message when extend file."); - return CM_ERROR; - } + status_t ret = dss_call_ex(&conn->pipe, send_pack, ack_pack); + DSS_RETURN_IFERR2(ret, LOG_RUN_ERR("Failed to send message when extend file.")); // check return state if (ack_pack->head->result != CM_SUCCESS) { @@ -125,10 +123,7 @@ status_t dss_apply_refresh_file(dss_conn_t *conn, dss_file_context_t *context, d // send it and wait for ack dss_packet_t *ack_pack = &conn->pack; status_t status = dss_call_ex(&conn->pipe, send_pack, ack_pack); - if (status != CM_SUCCESS) { - LOG_RUN_ERR("Failed to send message when refresh file."); - return CM_ERROR; - } + DSS_RETURN_IFERR2(status, LOG_RUN_ERR("Failed to send message when refresh file.")); // check return state if (ack_pack->head->result != CM_SUCCESS) { @@ -483,7 +478,7 @@ status_t dss_set_session_sync(dss_conn_t *conn) LOG_DEBUG_INF("The process start time is:%lld.", cli_info.start_time); errno_t err; - err = strcpy_s(cli_info.process_name, sizeof(cli_info.process_name) - 1, cm_sys_program_name()); + err = strcpy_s(cli_info.process_name, sizeof(cli_info.process_name), cm_sys_program_name()); if (err != EOK) { LOG_DEBUG_ERR("System call strcpy_s error %d.", errcode); return CM_ERROR; @@ -693,6 +688,7 @@ static dss_dir_t *dss_open_dir_impl_core(dss_conn_t *conn, const char *dir_path, dss_vg_info_item_t *vg_item = dss_find_vg_item(name); if (vg_item == NULL) { LOG_DEBUG_ERR("Failed to find vg, %s.", name); + DSS_THROW_ERROR(ERR_DSS_VG_NOT_EXIST, name); return NULL; } @@ -840,32 +836,21 @@ status_t dss_close_dir_impl(dss_conn_t *conn, dss_dir_t *dir) // 1. pftid uint64 pftid = dir->pftid; status = dss_put_int64(send_pack, pftid); - if (status != CM_SUCCESS) { - DSS_FREE_POINT(dir); - return CM_ERROR; - } + DSS_RETURN_IFERR2(status, DSS_FREE_POINT(dir)); // 2. vg name status = dss_put_str(send_pack, dir->vg_item->vg_name); - if (status != CM_SUCCESS) { - DSS_FREE_POINT(dir); - return CM_ERROR; - } + DSS_RETURN_IFERR2(status, DSS_FREE_POINT(dir)); // 3. vgid status = dss_put_int32(send_pack, dir->vg_item->id); DSS_FREE_POINT(dir); - if (status != CM_SUCCESS) { - return CM_ERROR; - } + DSS_RETURN_IF_ERROR(status); // send it and wait for ack ack_pack = &conn->pack; status = dss_call_ex(&conn->pipe, send_pack, ack_pack); - if (status != CM_SUCCESS) { - LOG_DEBUG_ERR("Failed to send message when close path."); - return CM_ERROR; - } + DSS_RETURN_IFERR2(status, LOG_DEBUG_ERR("Failed to send message when close path.")); // check return state if (ack_pack->head->result != CM_SUCCESS) { dss_cli_get_err(ack_pack, &errcode, &errmsg); @@ -957,14 +942,12 @@ status_t dss_find_vg_by_file_path(const char *path, dss_vg_info_item_t **vg_item uint32_t beg_pos = 0; char vg_name[DSS_MAX_NAME_LEN]; status_t status = dss_get_name_from_path(path, &beg_pos, vg_name); - if (status != CM_SUCCESS) { - LOG_DEBUG_ERR("Failed to get name from path:%s, status:%d.", path, status); - return status; - } + DSS_RETURN_IFERR2(status, LOG_DEBUG_ERR("Failed to get name from path:%s, status:%d.", path, status)); *vg_item = dss_find_vg_item(vg_name); if (*vg_item == NULL) { LOG_DEBUG_ERR("Failed to find VG:%s.", vg_name); + DSS_THROW_ERROR(ERR_DSS_VG_NOT_EXIST, vg_name); return CM_ERROR; } return CM_SUCCESS; @@ -1075,10 +1058,7 @@ status_t dss_open_file_inner(dss_vg_info_item_t *vg_item, gft_node_t *ft_node, i uint32 next = context->next; status_t ret = dss_init_file_context(context, ft_node, vg_item); - if (ret != CM_SUCCESS) { - dss_unlatch(&dss_env->latch); - return CM_ERROR; - } + DSS_RETURN_IFERR2(ret, dss_unlatch(&dss_env->latch)); dss_env->file_free_first = next; dss_env->has_opened_files++; dss_unlatch(&dss_env->latch); @@ -1170,24 +1150,6 @@ static status_t dss_check_file_env(dss_conn_t *conn, int32 handle, int32 size, d return CM_SUCCESS; } -static status_t dss_check_fclose_skippable(dss_file_context_t *context) -{ -#ifndef OPENGAUSS - /* - * file should be closed by self thread normally, - * but in openGauss, file handle will be transferred among different threads, - * opened by one thread, and closed by another thread, - * so we skip this in openGauss. - */ - uint32 curr_tid = cm_get_current_thread_id(); - if ((uint32)context->tid != curr_tid) { - LOG_DEBUG_ERR("Invalid fclose thread id, tid:%u, context tid:%u", curr_tid, context->tid); - return CM_ERROR; - } -#endif - return CM_SUCCESS; -} - status_t dss_close_file_impl(dss_conn_t *conn, int handle) { char *fname = NULL; @@ -1200,8 +1162,6 @@ status_t dss_close_file_impl(dss_conn_t *conn, int handle) dss_latch_x(&context->latch); fname = context->node->name; - DSS_RETURN_IFERR2(dss_check_fclose_skippable(context), dss_unlatch(&context->latch)); - status_t ret = dss_close_file_on_server(conn, context->vg_item, context->fid, context->node->id); if (ret != CM_SUCCESS) { dss_unlatch(&context->latch); @@ -1332,10 +1292,7 @@ int64 dss_seek_file_impl_core(dss_rw_param_t *param, int64 offset, int origin) dss_block_id_t blockid; dss_set_blockid(&blockid, DSS_INVALID_ID64); status = dss_apply_refresh_file(conn, context, blockid); - if (status != CM_SUCCESS) { - LOG_DEBUG_ERR("Failed to apply refresh file,fid:%llu.", context->fid); - return CM_ERROR; - } + DSS_RETURN_IFERR2(status, LOG_DEBUG_ERR("Failed to apply refresh file,fid:%llu.", context->fid)); DSS_LOCK_VG_META_S_RETURN_ERROR(context->vg_item, conn->session, NULL); size = (int64)context->node->size; @@ -1424,10 +1381,7 @@ static status_t dss_alloc_block_core( DSS_UNLOCK_VG_META_S(context->vg_item, conn->session); status = dss_apply_extending_file(conn, handle, size, is_read, rw_ctx.offset); - if (status != CM_SUCCESS) { - LOG_RUN_ERR("Failed to extend file."); - return CM_ERROR; - } + DSS_RETURN_IFERR2(status, LOG_RUN_ERR("Failed to extend file.")); DSS_LOCK_VG_META_S_RETURN_ERROR(context->vg_item, conn->session, NULL); second_block_id = entry_fs_block->bitmap[block_count]; @@ -1636,8 +1590,7 @@ status_t dss_read_write_file_core(dss_rw_param_t *param, void *buf, int32 size, dss_fs_block_t *second_block = NULL; uint32 block_au_count = 0; uint32 au_offset = 0; - CM_RETURN_IFERR_EX(dss_alloc_block(rw_ctx, entry_fs_block, &second_block, &block_au_count, &au_offset), - DSS_UNLOCK_VG_META_S(context->vg_item, conn->session)); + CM_RETURN_IFERR(dss_alloc_block(rw_ctx, entry_fs_block, &second_block, &block_au_count, &au_offset)); auid_t auid = second_block->bitmap[block_au_count]; if (dss_cmp_auid(auid, DSS_INVALID_ID64)) { @@ -1648,10 +1601,7 @@ status_t dss_read_write_file_core(dss_rw_param_t *param, void *buf, int32 size, } else { status = dss_apply_extending_file(conn, handle, size, is_read, rw_ctx.offset); } - if (status != CM_SUCCESS) { - LOG_DEBUG_ERR("Failed to extend file or refresh second block."); - return CM_ERROR; - } + DSS_RETURN_IFERR2(status, LOG_DEBUG_ERR("Failed to extend file or refresh second block.")); DSS_LOCK_VG_META_S_RETURN_ERROR(context->vg_item, conn->session, NULL); auid = second_block->bitmap[block_au_count]; @@ -1854,8 +1804,8 @@ status_t dss_pwrite_file_impl(dss_conn_t *conn, int handle, const void *buf, int dss_file_context_t *context = NULL; dss_rw_param_t param; - LOG_DEBUG_INF("dss pwrite file entry, handle:%d, offset:%lld", handle, offset); CM_RETURN_IFERR(dss_check_file_env(conn, handle, size, &context)); + LOG_DEBUG_INF("dss pwrite file %s, handle:%d, offset:%lld", context->node->name, handle, offset); dss_latch_s(&context->latch); dss_init_rw_param(¶m, conn, handle, context, offset, DSS_TRUE); @@ -1949,7 +1899,8 @@ status_t dss_truncate_impl(dss_conn_t *conn, int handle, uint64 length) dss_file_context_t *context = NULL; DSS_RETURN_IF_ERROR(dss_check_file_env(conn, handle, 0, &context)); - LOG_DEBUG_INF("Truncating file via handle(%d).", handle); + LOG_DEBUG_INF("Truncating file via handle(%d), file name: %s, node size: %lld, length: %lld.", handle, + context->node->name, context->node->size, length); dss_latch_x(&context->latch); @@ -2269,10 +2220,8 @@ status_t dss_islink_impl(dss_conn_t *conn, const char *path, bool *result) text_t extra_info = CM_NULL_TEXT; dss_init_get(ack_pack); - if (dss_get_text(ack_pack, &extra_info) != CM_SUCCESS) { - LOG_DEBUG_ERR("islink get result connect error"); - return CM_ERROR; - } + status_t ret = dss_get_text(ack_pack, &extra_info); + DSS_RETURN_IFERR2(ret, LOG_DEBUG_ERR("islink get result connect error")); if (extra_info.len == 0 || extra_info.len > sizeof(bool32)) { LOG_DEBUG_ERR("islink get result length error"); return CM_ERROR; @@ -2407,10 +2356,7 @@ static status_t get_fd(dss_rw_param_t *param, int32 size, bool32 is_read, int *f param->offset + size - 1, au_size, &end_block_count, &end_block_au_count, NULL); } while (0); - if (status != CM_SUCCESS) { - DSS_UNLOCK_VG_META_S(context->vg_item, conn->session); - return status; - } + DSS_RETURN_IFERR2(status, DSS_UNLOCK_VG_META_S(context->vg_item, conn->session)); if (start_block_count != end_block_count || start_block_au_count != end_block_au_count) { DSS_UNLOCK_VG_META_S(context->vg_item, conn->session); @@ -2429,8 +2375,7 @@ static status_t get_fd(dss_rw_param_t *param, int32 size, bool32 is_read, int *f dss_fs_block_t *second_block = NULL; uint32 block_au_count = 0; uint32 au_offset = 0; - CM_RETURN_IFERR_EX(dss_alloc_block(rw_ctx, entry_fs_block, &second_block, &block_au_count, &au_offset), - DSS_UNLOCK_VG_META_S(context->vg_item, conn->session)); + CM_RETURN_IFERR(dss_alloc_block(rw_ctx, entry_fs_block, &second_block, &block_au_count, &au_offset)); auid_t auid = second_block->bitmap[block_au_count]; if (dss_cmp_auid(auid, DSS_INVALID_ID64)) { @@ -2438,10 +2383,7 @@ static status_t get_fd(dss_rw_param_t *param, int32 size, bool32 is_read, int *f DSS_UNLOCK_VG_META_S(context->vg_item, conn->session); status = dss_apply_extending_file(conn, handle, size, is_read, rw_ctx.offset); - if (status != CM_SUCCESS) { - LOG_DEBUG_ERR("Failed to extend file."); - return CM_ERROR; - } + DSS_RETURN_IFERR2(status, LOG_DEBUG_ERR("Failed to extend file.")); DSS_LOCK_VG_META_S_RETURN_ERROR(context->vg_item, conn->session, NULL); auid = second_block->bitmap[block_au_count]; @@ -2522,11 +2464,8 @@ status_t dss_get_fd_by_offset( dss_latch_s(&context->latch); dss_init_rw_param(¶m, conn, handle, context, offset, DSS_TRUE); - if (dss_refresh_file_impl(¶m) != CM_SUCCESS) { - dss_unlatch(&context->latch); - return CM_ERROR; - } - + status_t ret = dss_refresh_file_impl(¶m); + DSS_RETURN_IFERR2(ret, dss_unlatch(&context->latch)); status = get_fd(¶m, size, is_read, fd, vol_offset); dss_unlatch(&context->latch); @@ -2612,10 +2551,9 @@ status_t dss_getcfg_impl(dss_conn_t *conn, const char *name, char *out_str, size uint32_t len = DSS_MAX_PACKET_SIZE - sizeof(dss_packet_head_t) - sizeof(int32); dss_init_get(ack_pack); - if (dss_get_text(ack_pack, &extra_info) != CM_SUCCESS) { - DSS_THROW_ERROR(ERR_DSS_CLI_EXEC_FAIL, dss_get_cmd_desc(DSS_CMD_GETCFG), "get cfg connect error"); - return CM_ERROR; - } + status_t ret = dss_get_text(ack_pack, &extra_info); + DSS_RETURN_IFERR2( + ret, DSS_THROW_ERROR(ERR_DSS_CLI_EXEC_FAIL, dss_get_cmd_desc(DSS_CMD_GETCFG), "get cfg connect error")); if (extra_info.len < sizeof(uint32) || extra_info.len > len) { DSS_THROW_ERROR(ERR_DSS_CLI_EXEC_FAIL, dss_get_cmd_desc(DSS_CMD_GETCFG), "get cfg length error"); return CM_ERROR; @@ -2641,6 +2579,7 @@ void dss_get_api_volume_error(void) // volume open/seek/read write fail for I/O, just exit if (code == ERR_DSS_VOLUME_SYSTEM_IO) { LOG_RUN_ERR("[DSS API] ABORT INFO : volume operate failed for I/O ERROR, errcode:%d.", code); + cm_fync_logfile(); _exit(1); } return; diff --git a/src/interface/dss_api.c b/src/interface/dss_api.c index 1d94bc9..487c6bc 100644 --- a/src/interface/dss_api.c +++ b/src/interface/dss_api.c @@ -191,6 +191,7 @@ static status_t dss_get_conn(dss_conn_t **conn) } if ((*conn)->pipe.link.uds.closed) { LOG_RUN_ERR("[DSS API] ABORT INFO : dss server stoped, application need restart."); + cm_fync_logfile(); _exit(1); } return CM_SUCCESS; @@ -465,6 +466,11 @@ int dss_islink(const char *name, bool *result) int dss_readlink(const char *link_path, char *buf, int bufsize) { + if (bufsize <= 0) { + DSS_THROW_ERROR(ERR_DSS_INVALID_PARAM, "invalid bufsize when get cfg"); + return DSS_ERROR; + } + dss_conn_t *conn = NULL; status_t ret = dss_get_conn(&conn); DSS_RETURN_IFERR2(ret, LOG_RUN_ERR("readlink get conn error.")); diff --git a/src/interface/dss_errno.h b/src/interface/dss_errno.h index 5307457..30de6f5 100644 --- a/src/interface/dss_errno.h +++ b/src/interface/dss_errno.h @@ -65,6 +65,7 @@ extern "C" { #define ERR_DSS_FILE_RENAME 2150 #define ERR_DSS_FILE_RENAME_DIFF_VG 2151 #define ERR_DSS_FILE_RENAME_EXIST 2152 +#define ERR_DSS_FILE_RENAME_OPENING_REMOTE 2153 #define ERR_DSS_FILE_NOT_EXIST 2190 #define ERR_DSS_FILE_OPENING_REMOTE 2191 #define ERR_DSS_FILE_TYPE_MISMATCH 2192 @@ -97,6 +98,7 @@ extern "C" { #define ERR_DSS_SKLIST_EXIST 2363 #define ERR_DSS_SHM_CREATE 2370 #define ERR_DSS_SHM_CHECK 2371 +#define ERR_DSS_SHM_LOCK 2372 #define ERR_DSS_GA_INIT 2380 #define ERR_DSS_SESSION_INVALID_ID 2390 #define ERR_DSS_SESSION_CREATE 2391 diff --git a/src/service/dss_instance.c b/src/service/dss_instance.c index ae9b351..1c283a5 100644 --- a/src/service/dss_instance.c +++ b/src/service/dss_instance.c @@ -25,7 +25,9 @@ #include "dss_ga.h" #include "dss_shm.h" #include "cm_timer.h" +#include "cm_error.h" #include "dss_errno.h" +#include "dss_defs.h" #include "dss_file.h" #include "dss_malloc.h" #include "dss_mes.h" @@ -96,9 +98,7 @@ static status_t instance_init_ga(dss_instance_t *inst) DSS_FILE_SPACE_BLOCK_SIZE + DSS_BLOCK_CTRL_SIZE, GA_MAX_EXTENDED_POOLS); ret = ga_create_global_area(); - if (ret != CM_SUCCESS) { - return CM_ERROR; - } + DSS_RETURN_IF_ERROR(ret); LOG_RUN_INF("Init GA pool and area successfully."); return CM_SUCCESS; } @@ -110,12 +110,9 @@ static status_t dss_init_thread(dss_instance_t *inst) if (inst->threads == NULL) { return CM_ERROR; } - errno_t rc = memset_s(inst->threads, (cfg_session_num * (uint32)sizeof(thread_t)), 0x00, + errno_t errcode = memset_s(inst->threads, (cfg_session_num * (uint32)sizeof(thread_t)), 0x00, (cfg_session_num * (uint32)sizeof(thread_t))); - if (rc != EOK) { - LOG_RUN_ERR("Memset failed."); - return CM_ERROR; - } + securec_check_ret(errcode); return CM_SUCCESS; } @@ -126,15 +123,8 @@ status_t dss_load_log_buffer_sort_and_recover_direct(dss_redo_batch_t *batch, ds uint32 load_size = CM_CALC_ALIGN(tmp_batch->size + sizeof(dss_redo_batch_t), DSS_DISK_UNIT_SIZE); LOG_RUN_INF("Begin to load recovery log buf direct whose size is %u.", load_size); status_t status = dss_load_vg_ctrl_part(vg_item, offset, batch, (int32)load_size); - if (status != CM_SUCCESS) { - LOG_RUN_ERR("Failed to load recovery log buf."); - return status; - } - status = dss_recover_when_instance_start(batch, CM_TRUE); - if (status != CM_SUCCESS) { - return status; - } - return status; + DSS_RETURN_IFERR2(status, LOG_RUN_ERR("Failed to load recovery log buf.")); + return dss_recover_when_instance_start(batch, CM_TRUE); } status_t dss_load_log_buffer(dss_redo_batch_t *batch) @@ -147,17 +137,13 @@ status_t dss_load_log_buffer(dss_redo_batch_t *batch) status_t status; char *tmp_log_buf = (char *)cm_malloc_align(DSS_DISK_UNIT_SIZE, DSS_INSTANCE_LOG_SPLIT_SIZE); if (tmp_log_buf == NULL) { - DSS_THROW_ERROR(ERR_ALLOC_MEMORY, DSS_DISK_UNIT_SIZE, "log_buf"); - return CM_ERROR; + DSS_RETURN_IFERR2(CM_ERROR, DSS_THROW_ERROR(ERR_ALLOC_MEMORY, DSS_DISK_UNIT_SIZE, "log_buf")); } for (uint8 i = 0; i < DSS_LOG_BUF_SLOT_COUNT; i++) { offset = base_offset + i * DSS_INSTANCE_LOG_SPLIT_SIZE; LOG_RUN_INF("begin to load log buf, offset:%lld, size:%u.", offset, DSS_DISK_UNIT_SIZE); status = dss_load_vg_ctrl_part(vg_item, offset, tmp_log_buf, DSS_DISK_UNIT_SIZE); - if (status != CM_SUCCESS) { - LOG_RUN_ERR("Failed to load log_buf from first vg ctrl when recover."); - break; - } + DSS_BREAK_IFERR2(status, LOG_RUN_ERR("Failed to load log_buf from first vg ctrl when recover.")); tmp_batch = (dss_redo_batch_t *)tmp_log_buf; if (tmp_batch->size == 0) { LOG_RUN_INF("size of log slot %u is 0, ignore.", i); @@ -181,10 +167,7 @@ status_t dss_load_log_buffer(dss_redo_batch_t *batch) } if (load_size > DSS_DISK_UNIT_SIZE) { status = dss_load_vg_ctrl_part(vg_item, offset, tmp_batch, (int32)load_size); - if (status != CM_SUCCESS) { - LOG_RUN_ERR("Failed to load redo log."); - break; - } + DSS_BREAK_IFERR2(status, LOG_RUN_ERR("Failed to load redo log.")); } if (!dss_check_redo_log_available(tmp_batch, vg_item, i)) { LOG_RUN_INF("Reset log when find uncompleted redo data, log slot is %u.", i); @@ -209,8 +192,7 @@ status_t dss_check_vg_ctrl_valid(dss_vg_info_item_t *vg_item) { dss_ctrl_t *dss_ctrl = vg_item->dss_ctrl; if (!DSS_VG_IS_VALID(dss_ctrl)) { - DSS_THROW_ERROR(ERR_DSS_VG_CHECK_NOT_INIT); - return CM_ERROR; + DSS_RETURN_IFERR2(CM_ERROR, DSS_THROW_ERROR(ERR_DSS_VG_CHECK_NOT_INIT)); } return CM_SUCCESS; } @@ -220,14 +202,12 @@ status_t dss_alloc_instance_log_buf(dss_instance_t *inst) LOG_RUN_INF("Begin to get instance log buf."); char *log_buf = (char *)cm_malloc_align(DSS_ALIGN_SIZE, DSS_INSTANCE_LOG_BUFFER_SIZE); if (log_buf == NULL) { - DSS_THROW_ERROR(ERR_ALLOC_MEMORY, DSS_INSTANCE_LOG_BUFFER_SIZE, "global log buffer"); - return CM_ERROR; + DSS_RETURN_IFERR2( + CM_ERROR, DSS_THROW_ERROR(ERR_ALLOC_MEMORY, DSS_INSTANCE_LOG_BUFFER_SIZE, "global log buffer")); } errno_t rc = memset_s(log_buf, sizeof(dss_redo_batch_t), 0, sizeof(dss_redo_batch_t)); if (rc != EOK) { - LOG_RUN_ERR("Memset failed."); - DSS_FREE_POINT(log_buf); - return CM_ERROR; + DSS_RETURN_IFERR3(CM_ERROR, LOG_RUN_ERR("Memset failed."), DSS_FREE_POINT(log_buf)); } inst->kernel_instance->log_ctrl.log_buf = log_buf; return CM_SUCCESS; @@ -292,89 +272,50 @@ static status_t instance_init_core(dss_instance_t *inst, uint32 objectid) { g_dss_share_vg_info = (dss_share_vg_info_t *)ga_object_addr(GA_INSTANCE_POOL, objectid); if (g_dss_share_vg_info == NULL) { - DSS_THROW_ERROR(ERR_DSS_GA_INIT, "DSS instance failed to get instance object address!"); - return CM_ERROR; + DSS_RETURN_IFERR2( + CM_ERROR, DSS_THROW_ERROR(ERR_DSS_GA_INIT, "DSS instance failed to get instance object address!")); } status_t status = dss_get_vg_info(g_dss_share_vg_info, NULL); - if (status != CM_SUCCESS) { - DSS_THROW_ERROR(ERR_DSS_GA_INIT, "DSS instance failed to get vg info"); - return status; - } + DSS_RETURN_IFERR2(status, DSS_THROW_ERROR(ERR_DSS_GA_INIT, "DSS instance failed to get vg info")); errno_t errcode = memset_s(&g_dss_kernel_instance, sizeof(g_dss_kernel_instance), 0, sizeof(g_dss_kernel_instance)); securec_check_ret(errcode); inst->kernel_instance = &g_dss_kernel_instance; status = dss_get_instance_log_buf_and_recover(inst); - if (status != CM_SUCCESS) { - DSS_THROW_ERROR(ERR_DSS_GA_INIT, "DSS instance failed to get log buf"); - return status; - } - + DSS_RETURN_IFERR2(status, DSS_THROW_ERROR(ERR_DSS_GA_INIT, "DSS instance failed to get log buf")); uint32 sess_cnt = inst->inst_cfg.params.cfg_session_num + inst->inst_cfg.params.work_thread_cnt + inst->inst_cfg.params.channel_num; status = dss_init_session(sess_cnt); - if (status != CM_SUCCESS) { - DSS_THROW_ERROR(ERR_DSS_GA_INIT, "DSS instance failed to initialize sessions."); - return status; - } - + DSS_RETURN_IFERR2(status, DSS_THROW_ERROR(ERR_DSS_GA_INIT, "DSS instance failed to initialize sessions.")); status = dss_init_thread(inst); - if (status != CM_SUCCESS) { - DSS_THROW_ERROR(ERR_DSS_GA_INIT, "DSS instance failed to initialize thread."); - return status; - } - - if (dss_startup_mes() != CM_SUCCESS) { - DSS_THROW_ERROR(ERR_DSS_GA_INIT, "DSS instance failed to startup mes"); - return CM_ERROR; - } - + DSS_RETURN_IFERR2(status, DSS_THROW_ERROR(ERR_DSS_GA_INIT, "DSS instance failed to initialize thread.")); + status = dss_startup_mes(); + DSS_RETURN_IFERR2(status, DSS_THROW_ERROR(ERR_DSS_GA_INIT, "DSS instance failed to startup mes")); status = dss_start_lsnr(inst); - if (status != CM_SUCCESS) { - LOG_RUN_ERR("DSS instance failed to start lsnr!"); - return status; - } + DSS_RETURN_IFERR2(status, LOG_RUN_ERR("DSS instance failed to start lsnr!")); return CM_SUCCESS; } static status_t instance_init(dss_instance_t *inst) { - status_t status; - if (dss_lock_instance() != CM_SUCCESS) { - LOG_RUN_ERR("Another dssinstance is running"); - return CM_ERROR; - } - + status_t status = dss_lock_instance(); + DSS_RETURN_IFERR2(status, LOG_RUN_ERR("Another dssinstance is running")); uint32 shm_key = (uint32)(inst->inst_cfg.params.shm_key << (uint8)DSS_MAX_SHM_KEY_BITS) + (uint32)inst->inst_cfg.params.inst_id; status = cm_init_shm(shm_key); - if (status != CM_SUCCESS) { - LOG_RUN_ERR("DSS instance failed to initialize shared memory!"); - return status; - } + DSS_RETURN_IFERR2(status, LOG_RUN_ERR("DSS instance failed to initialize shared memory!")); status = instance_init_ga(inst); - if (status != CM_SUCCESS) { - cm_destroy_shm(); - LOG_RUN_ERR("DSS instance failed to initialize ga!"); - return status; - } + DSS_RETURN_IFERR3(status, cm_destroy_shm(), LOG_RUN_ERR("DSS instance failed to initialize ga!")); uint32 objectid = ga_alloc_object(GA_INSTANCE_POOL, CM_INVALID_ID32); if (objectid == CM_INVALID_ID32) { - ga_detach_area(); - cm_destroy_shm(); - DSS_THROW_ERROR(ERR_DSS_GA_INIT, "DSS instance failed to alloc instance object!"); - return CM_ERROR; + DSS_RETURN_IFERR4(CM_ERROR, ga_detach_area(), cm_destroy_shm(), + DSS_THROW_ERROR(ERR_DSS_GA_INIT, "DSS instance failed to alloc instance object!")); } status = instance_init_core(inst, objectid); - if (status != CM_SUCCESS) { - ga_detach_area(); - cm_destroy_shm(); - return status; - } - + DSS_RETURN_IFERR3(status, ga_detach_area(), cm_destroy_shm()); LOG_RUN_INF("DSS instance begin to run."); return CM_SUCCESS; } @@ -385,49 +326,20 @@ status_t dss_startup(dss_instance_t *inst, char *home) errno_t errcode = memset_s(inst, sizeof(dss_instance_t), 0, sizeof(dss_instance_t)); securec_check_ret(errcode); inst->lock_fd = CM_INVALID_INT32; - -#ifndef WIN32 - status = dss_signal_proc(); - if (status != CM_SUCCESS) { - (void)printf("signal proc failed!\n"); - return status; - } -#endif - errcode = memset_s(inst, sizeof(dss_instance_t), 0, sizeof(dss_instance_t)); - securec_check_ret(errcode); dss_set_server_flag(); status = dss_set_cfg_dir(home, &inst->inst_cfg); - if (status != CM_SUCCESS) { - (void)printf("Environment variant DSS_HOME not found!\n"); - return status; - } - + DSS_RETURN_IFERR2(status, (void)printf("Environment variant DSS_HOME not found!\n")); status = dss_load_config(&inst->inst_cfg); - if (status != CM_SUCCESS) { - (void)printf("%s\nFailed to load parameters!\n", cm_get_errormsg(cm_get_error_code())); - return status; - } - - if (cm_start_timer(g_timer()) != CM_SUCCESS) { - (void)printf("Aborted due to starting timer thread.\n"); - return CM_ERROR; - } - + DSS_RETURN_IFERR2(status, (void)printf("%s\nFailed to load parameters!\n", cm_get_errormsg(cm_get_error_code()))); + status = cm_start_timer(g_timer()); + DSS_RETURN_IFERR2(status, (void)printf("Aborted due to starting timer thread.\n")); status = dss_init_loggers( &inst->inst_cfg, g_dss_instance_log, sizeof(g_dss_instance_log) / sizeof(dss_log_def_t), "dssserver"); - if (status != CM_SUCCESS) { - (void)printf("%s\nDSS init loggers failed!\n", cm_get_errormsg(cm_get_error_code())); - return status; - } + DSS_RETURN_IFERR2(status, (void)printf("%s\nDSS init loggers failed!\n", cm_get_errormsg(cm_get_error_code()))); LOG_RUN_INF("DSS instance begin to initialize."); status = instance_init(inst); - if (status != CM_SUCCESS) { - LOG_RUN_ERR("DSS instance failed to initialized!"); - return status; - } - + DSS_RETURN_IFERR2(status, LOG_RUN_ERR("DSS instance failed to initialized!")); cm_set_shm_ctrl_flag(CM_SHM_CTRL_FLAG_TRUE); - inst->abort_status = CM_FALSE; return CM_SUCCESS; } @@ -437,19 +349,12 @@ static status_t dss_lsnr_proc(bool32 is_emerg, uds_lsnr_t *lsnr, cs_pipe_t *pipe dss_session_t *session = NULL; status_t status; status = dss_create_session(pipe, &session); - if (status != CM_SUCCESS) { - LOG_RUN_ERR("dss_lsnr_proc create session failed.\n"); - cs_uds_disconnect(&pipe->link.uds); - return status; - } + DSS_RETURN_IFERR3( + status, LOG_RUN_ERR("dss_lsnr_proc create session failed.\n"), cs_uds_disconnect(&pipe->link.uds)); LOG_DEBUG_INF("create client server thread."); status = cm_create_thread(dss_session_entry, SIZE_K(512), session, &(g_dss_instance.threads[session->id])); - if (status != CM_SUCCESS) { - dss_destroy_session(session); - LOG_RUN_ERR("Session:%u socket:%u closed.", session->id, pipe->link.uds.sock); - return status; - } - + DSS_RETURN_IFERR3(status, dss_destroy_session(session), + LOG_RUN_ERR("Session:%u socket:%u closed.", session->id, pipe->link.uds.sock)); return CM_SUCCESS; } @@ -478,16 +383,10 @@ status_t dss_init_cm(dss_instance_t *inst) } status_t status = cm_res_mgr_init(value, &inst->cm_res.mgr, NULL); - if (status != CM_SUCCESS) { - return status; - } - + DSS_RETURN_IF_ERROR(status); status = (status_t)cm_res_init(&inst->cm_res.mgr, (unsigned int)inst->inst_cfg.params.inst_id, DSS_CMS_RES_TYPE, NULL); - if (status != CM_SUCCESS) { - cm_res_mgr_uninit(&inst->cm_res.mgr); - return status; - } + DSS_RETURN_IFERR2(status, cm_res_mgr_uninit(&inst->cm_res.mgr)); inst->cm_res.is_valid = CM_TRUE; return CM_SUCCESS; } diff --git a/src/service/dss_mes.c b/src/service/dss_mes.c index 9f175c2..d82da8e 100644 --- a/src/service/dss_mes.c +++ b/src/service/dss_mes.c @@ -58,15 +58,17 @@ void dss_proc_broadcast_ack2(dss_session_t *session, mes_message_t *msg) mes_notify_broadcast_msg_recv_and_cahce(msg); } -static inline dss_bcast_ack_cmd_t dss_get_ack_cmd(dss_bcast_req_cmd_t bcast_op) +static dss_bcast_ack_cmd_t dss_get_ack_cmd(dss_bcast_req_cmd_t bcast_op) { switch (bcast_op) { case BCAST_REQ_RENAME: return BCAST_ACK_RENAME; case BCAST_REQ_DEL_DIR_FILE: return BCAST_ACK_DEL_FILE; + case BCAST_REQ_TRUNCATE_FILE: + return BCAST_ACK_TRUNCATE_FILE; default: - CM_ASSERT(0); + LOG_RUN_ERR("Invalid broadcast request type"); break; } return BCAST_ACK_END; @@ -85,8 +87,10 @@ static void dss_ask_server_status(dss_session_t *se, mes_message_t *msg) (uint32)msg->head->src_inst, (uint32)msg->head->dst_inst, ret); return; } - DSS_LOG_DEBUG_OP("send ask server status ack success, src inst(%u), dst inst(%u)", (uint32)msg->head->src_inst, - (uint32)msg->head->dst_inst); + DSS_LOG_DEBUG_OP( + "send ask server status ack success. cmd=%hhu, rsn=%u, src_inst=%hhu, dst_inst=%hhu, src_sid=%hu, dst_sid=%hu.", + msg->head->cmd, msg->head->rsn, msg->head->src_inst, msg->head->dst_inst, msg->head->src_sid, + msg->head->dst_sid); } static void dss_check_file_open(dss_session_t *se, mes_message_t *msg) @@ -133,8 +137,11 @@ static void dss_check_file_open(dss_session_t *se, mes_message_t *msg) (uint32)msg->head->dst_inst, ret); return; } + DSS_LOG_DEBUG_OP("send message succeed, check file %llu open result: %u. cmd=%hhu, rsn=%u, src_inst=%hhu, " + "dst_inst=%hhu, src_sid=%hu, dst_sid=%hu.", + check->ftid, is_open, ack->head.cmd, ack->head.rsn, ack->head.src_inst, ack->head.dst_inst, ack->head.src_sid, + ack->head.dst_sid); DSS_FREE_POINT(send_msg); - DSS_LOG_DEBUG_OP("send message succeed, check file %llu open result: %d", check->ftid, status); } static int32 dss_process_broadcast_ack( @@ -148,6 +155,7 @@ static int32 dss_process_broadcast_ack( switch (bcast_op) { case BCAST_ACK_RENAME: case BCAST_ACK_DEL_FILE: + case BCAST_ACK_TRUNCATE_FILE: ret = *(int32 *)(data + sizeof(dss_bcast_ack_cmd_t)); recv_msg_output->open_flag = *(bool32 *)(data + sizeof(dss_bcast_ack_cmd_t) + sizeof(int32)); break; @@ -172,7 +180,8 @@ void dss_proc_broadcast_req(dss_session_t *session, mes_message_t *msg) { char *data = msg->buffer + sizeof(mes_message_head_t); dss_bcast_req_cmd_t bcast_op = *(dss_bcast_req_cmd_t *)data; - + LOG_DEBUG_INF("Try proc broadcast req, head rsn is %u, head cmd is %u, req cmd is %u.", msg->head->rsn, + msg->head->cmd, bcast_op); switch (bcast_op) { case BCAST_REQ_RENAME: case BCAST_REQ_DEL_DIR_FILE: @@ -266,10 +275,13 @@ static status_t dss_broadcast_msg_with_try(dss_session_t *session, mes_message_h uint64 new_added_inst_map = 0; uint64 vaild_inst = 0; uint64 vaild_inst_mask = 0; + dss_bcast_req_t *req = (dss_bcast_req_t *)buffer; do { // only send the last-send-failed and new added vaild_inst_mask = ((cur_work_inst_map & snd_err_inst_map) | new_added_inst_map); vaild_inst = (param->inst_map) & (~((uint64)0x1 << (uint64)(param->inst_id))) & vaild_inst_mask; + LOG_DEBUG_INF("Try broadcast num is %u, head rsn is %u, head cmd is %u, req cmd is %u.", i, head->rsn, + head->cmd, req->type); mes_broadcast2(session->id, vaild_inst, head, (const void *)buffer, &succ_req_inst); if (!recv_msg->handle_recv_msg && timeout > 0) { ret = mes_wait_acks(session->id, timeout); diff --git a/src/service/dss_service.c b/src/service/dss_service.c index 83b20bb..d67d3dc 100644 --- a/src/service/dss_service.c +++ b/src/service/dss_service.c @@ -77,10 +77,7 @@ static status_t dss_diag_proto_type(dss_session_t *session) int32 size; errno_t rc_memzero; status_t ret = cs_read_bytes(&session->pipe, (char *)&proto_code, sizeof(proto_code), &size); - if (ret != CM_SUCCESS) { - LOG_RUN_ERR("Instance recieve protocol failed, errno:%d.", errno); - return ret; - } + DSS_RETURN_IFERR2(ret, LOG_RUN_ERR("Instance recieve protocol failed, errno:%d.", errno)); if (size != (int32)sizeof(proto_code) || proto_code != DSS_PROTO_CODE) { DSS_THROW_ERROR(ERR_INVALID_PROTOCOL); @@ -141,6 +138,7 @@ void dss_session_entry(thread_t *thread) } LOG_RUN_INF("Session:%u end to do service.", session->id); + session->is_closed = CM_TRUE; dss_clean_session_latch(dss_get_session_ctrl(), session); dss_clean_open_files(session); dss_destroy_session(session); @@ -164,6 +162,7 @@ static void dss_return_error(dss_session_t *session) // volume open/seek/read write fail for I/O, just abort if (code == ERR_DSS_VOLUME_SYSTEM_IO) { LOG_RUN_ERR("[DSS] ABORT INFO: volume operate failed for I/O ERROR, errcode:%d.", code); + cm_fync_logfile(); _exit(1); } (void)dss_put_int32(send_pack, (uint32)code); @@ -250,14 +249,11 @@ static status_t dss_process_create_file(dss_session_t *session) DSS_RETURN_IF_ERROR(dss_set_audit_resource(session->audit_info.resource, DSS_AUDIT_MODIFY, "%s", file_ptr)); cm_str2text(file_ptr, &text); - if (!cm_fetch_rtext(&text, '/', '\0', &sub)) { - LOG_DEBUG_ERR("not a complete absolute path name(%s %s)", T2S(&sub), T2S(&text)); - return CM_ERROR; - } - if (text.len >= DSS_MAX_NAME_LEN) { - DSS_THROW_ERROR(ERR_DSS_FILE_PATH_ILL, text.str, "name length should less than 64."); - return CM_ERROR; - } + bool32 result = cm_fetch_rtext(&text, '/', '\0', &sub); + DSS_RETURN_IF_FALSE2(result, LOG_DEBUG_ERR("not a complete absolute path name(%s %s)", T2S(&sub), T2S(&text))); + + result = (bool32)(text.len < DSS_MAX_NAME_LEN); + DSS_RETURN_IF_FALSE2(result, DSS_THROW_ERROR(ERR_DSS_FILE_PATH_ILL, text.str, "name length should less than 64.")); char parent_str[DSS_FILE_PATH_MAX_LENGTH]; char name_str[DSS_MAX_NAME_LEN]; @@ -271,10 +267,8 @@ static status_t dss_process_delete_file(dss_session_t *session) { char *name = NULL; dss_init_get(&session->recv_pack); - if (dss_get_str(&session->recv_pack, &name) != CM_SUCCESS) { - LOG_DEBUG_ERR("delete file get file name failed."); - return CM_ERROR; - } + status_t status = dss_get_str(&session->recv_pack, &name); + DSS_RETURN_IFERR2(status, LOG_DEBUG_ERR("delete file get file name failed.")); DSS_RETURN_IF_ERROR(dss_set_audit_resource(session->audit_info.resource, DSS_AUDIT_MODIFY, "%s", name)); return dss_remove_file(session, (const char *)name); } @@ -351,10 +345,9 @@ static status_t dss_process_close_file(dss_session_t *session) "vg_name:%s, fid:%llu, ftid:%llu", vg_name, fid, *(uint64 *)&ftid)); dss_vg_info_item_t *vg_item = dss_find_vg_item(vg_name); - if (vg_item == NULL) { - LOG_DEBUG_ERR("Failed to find vg, %s.", vg_name); - return CM_ERROR; - } + bool32 result = (bool32)(vg_item != NULL); + DSS_RETURN_IF_FALSE2(result, DSS_THROW_ERROR(ERR_DSS_VG_NOT_EXIST, vg_name)); + DSS_RETURN_IF_ERROR(dss_close_file(session, vg_item, *(uint64 *)&ftid)); DSS_LOG_DEBUG_OP( "Succeed to close file, ftid:%llu, fid:%llu, vg: %s, session pid:%llu, v:%u, au:%llu, block:%u, item:%u.", @@ -373,10 +366,7 @@ static status_t dss_process_close_file(dss_session_t *session) } #endif status_t status = dss_remove_dir_file_by_node(session, vg_item, node); - if (status != CM_SUCCESS) { - LOG_DEBUG_INF("Failed to remove delay file when close file, fid: %llu", fid); - return CM_SUCCESS; - } + DSS_RETURN_IFERR2(status, LOG_DEBUG_INF("Failed to remove delay file when close file, fid: %llu", fid)); DSS_LOG_DEBUG_OP("Succeed to remove file when close file, ftid%llu, fid:%llu, vg: %s, session pid:%llu, v:%u, " "au:%llu, block:%u, item:%u.", *(int64 *)&ftid, fid, vg_item->vg_name, session->cli_info.cli_pid, ftid.volume, (uint64)ftid.au, ftid.block, @@ -486,40 +476,6 @@ static status_t dss_process_remove_volume(dss_session_t *session) return dss_remove_volume(session, vg_name, volume_name); } -static status_t dss_process_register_host(dss_session_t *session) -{ - status_t status = CM_SUCCESS; - dss_init_get(&session->recv_pack); - DSS_RETURN_IF_ERROR(dss_set_audit_resource( - session->audit_info.resource, DSS_AUDIT_MODIFY, "%lld", ZFS_INST->inst_cfg.params.inst_id)); - - status = dss_iof_register_all(ZFS_INST->inst_cfg.params.inst_id, CM_TRUE); - if (status != CM_SUCCESS) { - LOG_DEBUG_ERR( - "Failed to register to array, hostid %lld, status %d.", ZFS_INST->inst_cfg.params.inst_id, status); - return status; - } - - return CM_SUCCESS; -} - -static status_t dss_process_unregister_host(dss_session_t *session) -{ - status_t status = CM_SUCCESS; - dss_init_get(&session->recv_pack); - DSS_RETURN_IF_ERROR(dss_set_audit_resource( - session->audit_info.resource, DSS_AUDIT_MODIFY, "%lld", ZFS_INST->inst_cfg.params.inst_id)); - - status = dss_iof_unregister_all(ZFS_INST->inst_cfg.params.inst_id, CM_TRUE); - if (status != CM_SUCCESS) { - LOG_DEBUG_ERR( - "Failed to unregister from array, hostid %lld, status %d.", ZFS_INST->inst_cfg.params.inst_id, status); - return status; - } - - return CM_SUCCESS; -} - static status_t dss_process_kick_host(dss_session_t *session) { int64 kick_hostid = 0; @@ -530,10 +486,7 @@ static status_t dss_process_kick_host(dss_session_t *session) session->audit_info.resource, DSS_AUDIT_MODIFY, "%lld, %lld", ZFS_INST->inst_cfg.params.inst_id, kick_hostid)); status = dss_iof_sync_all_vginfo(session, VGS_INFO); - if (status != CM_SUCCESS) { - LOG_DEBUG_ERR("Sync all vginfo failed, status %d.", status); - return status; - } + DSS_RETURN_IFERR2(status, LOG_DEBUG_ERR("Sync all vginfo failed, status %d.", status)); status = dss_iof_kick_all(ZFS_INST->inst_cfg.params.inst_id, kick_hostid, CM_TRUE); if (status != CM_SUCCESS) { @@ -681,10 +634,8 @@ static status_t dss_process_symlink(dss_session_t *session) dss_set_audit_resource(session->audit_info.resource, DSS_AUDIT_MODIFY, "%s, %s", dst_path, new_path)); cm_str2text(new_path, &text); - if (!cm_fetch_rtext(&text, '/', '\0', &sub)) { - LOG_DEBUG_ERR("not a complete absolute path name(%s %s)", T2S(&sub), T2S(&text)); - return CM_ERROR; - } + bool32 result = cm_fetch_rtext(&text, '/', '\0', &sub); + DSS_RETURN_IF_FALSE2(result, LOG_DEBUG_ERR("not a complete absolute path name(%s %s)", T2S(&sub), T2S(&text))); char parent_str[DSS_FILE_PATH_MAX_LENGTH]; char name_str[DSS_MAX_NAME_LEN]; @@ -755,15 +706,12 @@ static status_t dss_process_get_ftid_by_path(dss_session_t *session) dss_find_node_t find_node; find_node.ftid = ftid; errno_t err = strncpy_sp(find_node.vg_name, DSS_MAX_NAME_LEN, vg_item->vg_name, DSS_MAX_NAME_LEN); - if (err != EOK) { - DSS_THROW_ERROR(ERR_SYSTEM_CALL, err); - return CM_ERROR; - } + bool32 result = (bool32)(err == EOK); + DSS_RETURN_IF_FALSE2(result, DSS_THROW_ERROR(ERR_SYSTEM_CALL, err)); + err = memcpy_sp(session->send_info.str, sizeof(dss_find_node_t), (char *)&find_node, sizeof(dss_find_node_t)); - if (err != EOK) { - DSS_THROW_ERROR(ERR_SYSTEM_CALL, err); - return CM_ERROR; - } + result = (bool32)(err == EOK); + DSS_RETURN_IF_FALSE2(result, DSS_THROW_ERROR(ERR_SYSTEM_CALL, err)); return CM_SUCCESS; } @@ -772,16 +720,14 @@ static status_t dss_process_set_status(dss_session_t *session) int32 dss_status; dss_init_get(&session->recv_pack); DSS_RETURN_IF_ERROR(dss_get_int32(&session->recv_pack, &dss_status)); - DSS_RETURN_IF_ERROR(dss_set_audit_resource(session->audit_info.resource, DSS_AUDIT_MODIFY, "%u", session->id)); + DSS_RETURN_IF_ERROR(dss_set_audit_resource(session->audit_info.resource, DSS_AUDIT_MODIFY, "%d", dss_status)); LOG_DEBUG_INF("dss server current status(%d), set status(%d).", dss_get_server_status_flag(), dss_status); if ((dss_status == DSS_STATUS_READWRITE) && !dss_is_readwrite()) { status_t status = dss_refresh_meta_info(session); - if (status != CM_SUCCESS) { - LOG_DEBUG_ERR("dss server set status(%d) refresh meta fialed, result(%d).", dss_status, status); - return status; - } + DSS_RETURN_IFERR2( + status, LOG_DEBUG_ERR("dss server set status(%d) refresh meta fialed, result(%d).", dss_status, status)); } - LOG_DEBUG_INF("Dss set server status %d.", dss_status); + LOG_RUN_INF("Dss set server status %d.", dss_status); dss_set_server_status_flag(dss_status); return CM_SUCCESS; } @@ -843,15 +789,13 @@ static dss_cmd_hdl_t g_dss_cmd_handle[] = { { DSS_CMD_DETACH_FILE, NULL, NULL, CM_FALSE }, { DSS_CMD_RENAME_FILE, dss_process_rename, NULL, CM_TRUE }, { DSS_CMD_REFRESH_FILE, dss_process_refresh_file, NULL, CM_FALSE }, - { DSS_CMD_TRUNCATE_FILE, dss_process_truncate_file, NULL, CM_FALSE }, + { DSS_CMD_TRUNCATE_FILE, dss_process_truncate_file, NULL, CM_TRUE }, { DSS_CMD_REFRESH_FILE_TABLE, dss_process_refresh_file_table, NULL, CM_FALSE }, { DSS_CMD_CONSOLE, NULL, NULL, CM_FALSE }, { DSS_CMD_ADD_VOLUME, dss_process_add_volume, NULL, CM_TRUE }, { DSS_CMD_REMOVE_VOLUME, dss_process_remove_volume, NULL, CM_TRUE }, { DSS_CMD_REFRESH_VOLUME, dss_process_refresh_volume, NULL, CM_FALSE }, - { DSS_CMD_REGH, dss_process_register_host, NULL, CM_FALSE }, { DSS_CMD_KICKH, dss_process_kick_host, NULL, CM_FALSE }, - { DSS_CMD_UNREGH, dss_process_unregister_host, NULL, CM_FALSE }, { DSS_CMD_LOAD_CTRL, dss_process_loadctrl, NULL, CM_FALSE }, { DSS_CMD_SET_SESSIONID, dss_process_set_sessionid, NULL, CM_FALSE }, { DSS_CMD_UPDATE_WRITTEN_SIZE, dss_process_update_file_written_size, NULL, CM_TRUE }, diff --git a/src/service/dss_service.h b/src/service/dss_service.h index 2adff66..9125e1a 100644 --- a/src/service/dss_service.h +++ b/src/service/dss_service.h @@ -27,6 +27,10 @@ #include "dss_latch.h" #include "dss_session.h" +#ifdef __cplusplus +extern "C" { +#endif + typedef status_t (*dss_srv_proc)(dss_session_t *session); typedef status_t (*dss_srv_proc_err)(dss_session_t *session); @@ -36,8 +40,15 @@ typedef struct st_dss_cmd_hdl { dss_srv_proc_err proc_err; bool32 exec_on_active; } dss_cmd_hdl_t; +#ifndef WIN32 +status_t dss_signal_proc(void); +status_t dss_signal_proc_with_graceful_exit(void); +#endif status_t dss_process_command(dss_session_t *session); void dss_session_entry(thread_t *thread); status_t dss_proc_standby_req(dss_session_t *session); +#ifdef __cplusplus +} +#endif #endif diff --git a/src/service/dss_srv_proc.c b/src/service/dss_srv_proc.c index bfa6b78..fc409a6 100644 --- a/src/service/dss_srv_proc.c +++ b/src/service/dss_srv_proc.c @@ -130,6 +130,7 @@ status_t dss_rename_file_put_redo_log(dss_session_t *session, gft_node_t *out_no dss_unlock_vg_mem_and_shm(session, vg_item); LOG_RUN_ERR("[DSS] ABORT INFO: redo log process failed, errcode:%d, OS errno:%d, OS errmsg:%s.", cm_get_error_code(), errno, strerror(errno)); + cm_fync_logfile(); _exit(1); } return CM_SUCCESS; @@ -170,7 +171,6 @@ status_t dss_rename_file(dss_session_t *session, const char *file, const char *d DSS_BREAK_IF_ERROR(dss_rename_file_check(session, file, dst, &vg_item, &out_node)); if (out_node == NULL) { LOG_DEBUG_ERR("Failed to rename file %s.", file); - ret = CM_ERROR; break; } bool32 is_open = CM_FALSE; @@ -178,8 +178,7 @@ status_t dss_rename_file(dss_session_t *session, const char *file, const char *d dss_notify_check_file_open(vg_item, session, BCAST_REQ_RENAME, *(uint64 *)&out_node->id, &is_open)); if (is_open) { // logic same as before - LOG_DEBUG_ERR( - "Rename file failed, beacuse file is opened by other instance src path: %s, dst path %s.", file, dst); + DSS_THROW_ERROR(ERR_DSS_FILE_RENAME_OPENING_REMOTE, file, dst); break; } DSS_BREAK_IF_ERROR(dss_rename_file_put_redo_log(session, out_node, dst_name, vg_item, inst_cfg)); @@ -408,6 +407,7 @@ static status_t dss_rm_dir_file(dss_session_t *session, const char *dir_name, gf dss_unlock_vg_mem_and_shm(session, vg_item); if (need_abort) { + cm_fync_logfile(); _exit(1); } return status; @@ -460,6 +460,7 @@ static status_t dss_remove_dir_file_by_node_inner( if (dss_process_redo_log(session, vg_item) != CM_SUCCESS) { LOG_RUN_ERR("[DSS] ABORT INFO: redo log process failed, errcode:%d, OS errno:%d, OS errmsg:%s.", cm_get_error_code(), errno, strerror(errno)); + cm_fync_logfile(); _exit(1); } DSS_LOG_DEBUG_OP("Succeed to rm %s in vg:%s.", node->name, vg_item->vg_name); @@ -545,6 +546,7 @@ static status_t dss_make_dir_file_core(dss_session_t *session, const char *paren dss_unlock_vg_mem_and_shm(session, *vg_item); LOG_RUN_ERR("[DSS] ABORT INFO: redo log process failed, errcode:%d, OS errno:%d, OS errmsg:%s.", cm_get_error_code(), errno, strerror(errno)); + cm_fync_logfile(); _exit(1); } return CM_SUCCESS; diff --git a/src/service/dssserver.c b/src/service/dssserver.c index ff46b58..a143019 100644 --- a/src/service/dssserver.c +++ b/src/service/dssserver.c @@ -32,6 +32,7 @@ #include "cm_signal.h" #include "cm_utils.h" #include "dss_errno.h" +#include "dss_signal.h" #include "dss_instance.h" #include "dss_mes.h" @@ -45,25 +46,28 @@ extern "C" { #endif +#ifndef WIN32 static void handle_signal_terminal(int sig_no) { g_dss_instance.abort_status = CM_TRUE; } -static int handle_all_signal(void) +status_t dss_signal_proc_with_graceful_exit(void) { - status_t ret; - for (int i = 0; i < MAX_SIG_NUM; i++) { - ret = cm_regist_signal(i, SIG_IGN); - DSS_RETURN_IF_ERROR(ret); - } - ret = cm_regist_signal(SIGINT, SIG_DFL); - DSS_RETURN_IF_ERROR(ret); - ret = cm_regist_signal(SIGUSR1, handle_signal_terminal); + status_t ret = cm_regist_signal(SIGUSR1, handle_signal_terminal); DSS_RETURN_IF_ERROR(ret); return cm_regist_signal(SIGTERM, handle_signal_terminal); } +status_t dss_signal_proc(void) +{ + DSS_RETURN_IF_ERROR(dss_ignore_signal_proc()); + DSS_RETURN_IF_ERROR(cm_regist_signal(SIGINT, SIG_DFL)); + DSS_RETURN_IF_ERROR(dss_coredump_signal_proc()); + return dss_signal_proc_with_graceful_exit(); +} +#endif + static void dss_close_thread(dss_instance_t *inst) { // pause lsnr thread @@ -211,15 +215,15 @@ int main(int argc, char **argv) LOG_RUN_ERR("dss failed to startup."); return CM_ERROR; } - - if (handle_all_signal() != CM_SUCCESS) { +#ifndef WIN32 + if (dss_signal_proc() != CM_SUCCESS) { printf("dss instance startup failed.\n"); fflush(stdout); dss_clean_server(); LOG_RUN_ERR("dss failed to startup."); return CM_ERROR; } - +#endif (void)printf("DSS SERVER STARTED.\n"); LOG_RUN_INF("DSS SERVER STARTED.\n"); handle_main_wait(); -- Gitee