diff --git a/pkg/src/cluster/dtc_backup.c b/pkg/src/cluster/dtc_backup.c index 6a9d196611a68d95095fdc00d3a5cdc540fda554..a8afa54f266f2721f8b6a8af191f3da6f71fb495 100644 --- a/pkg/src/cluster/dtc_backup.c +++ b/pkg/src/cluster/dtc_backup.c @@ -302,41 +302,42 @@ status_t bak_get_arch_asn_file(knl_session_t *session, log_start_end_info_t arch uint32 rst_id = session->kernel->db.ctrl.core.resetlogs.rst_id; local_arch_file_info_t file_info; DIR *arch_dir; - struct dirent *arch_dirent; + struct dirent arch_dirent = {0}; arch_attr_t *arch_attr = &session->kernel->attr.arch_attr[0]; char *arch_path = arch_attr->local_path; log_file_head_t head; char tmp_file_name[CT_FILE_NAME_BUFFER_SIZE]; - if ((arch_dir = opendir(arch_path)) == NULL) { + device_type_t type = cm_device_type(arch_path); + if ((arch_dir = cm_open_device_dir(type, arch_path)) == NULL) { CT_LOG_RUN_ERR("[BACKUP] can not open arch_dir %s.", arch_path); return CT_ERROR; } - while ((arch_dirent = readdir(arch_dir)) != NULL) { + while ((cm_read_device_dir(type, arch_dir, &arch_dirent)) != CT_SUCCESS) { if (bak_check_arch_file_num(arch_info) != CT_SUCCESS) { - closedir(arch_dir); + cm_close_device_dir(type, arch_dir); return CT_ERROR; } - if (bak_convert_archfile_name(arch_dirent->d_name, &file_info, inst_id, rst_id, + if (bak_convert_archfile_name(arch_dirent.d_name, &file_info, inst_id, rst_id, BAK_IS_DBSOTR(&session->kernel->backup_ctx.bak)) == CT_FALSE) { continue; } - if (bak_get_arch_file_head(session, arch_path, arch_dirent->d_name, &head) != CT_SUCCESS) { - closedir(arch_dir); + if (bak_get_arch_file_head(session, arch_path, arch_dirent.d_name, &head) != CT_SUCCESS) { + cm_close_device_dir(type, arch_dir); return CT_ERROR; } if (head.dbid != session->kernel->db.ctrl.core.dbid) { CT_LOG_RUN_WAR("[BACKUP] the dbid %u of archive logfile %s is different from the bak dbid %u", - head.dbid, arch_dirent->d_name, session->kernel->db.ctrl.core.dbid); + head.dbid, arch_dirent.d_name, session->kernel->db.ctrl.core.dbid); continue; } arch_info.result_asn->max_asn = MAX(arch_info.result_asn->max_asn, file_info.local_asn); - bak_set_file_name(tmp_file_name, arch_path, arch_dirent->d_name); + bak_set_file_name(tmp_file_name, arch_path, arch_dirent.d_name); if (bak_set_archfile_info_file(arch_info, file_info, tmp_file_name, &head) != CT_SUCCESS) { return CT_ERROR; } } - closedir(arch_dir); + cm_close_device_dir(type, arch_dir); return CT_SUCCESS; } diff --git a/pkg/src/common/cm_device.c b/pkg/src/common/cm_device.c index 6f35ab1aa4dbe345e9cea885d3c537245230aca4..fbfa224036893922ee4ee6c17fa5226df88fc2e3 100644 --- a/pkg/src/common/cm_device.c +++ b/pkg/src/common/cm_device.c @@ -697,6 +697,70 @@ bool32 cm_create_device_dir_ex(device_type_t type, const char *name) return CT_SUCCESS; } +DIR *cm_open_device_dir(device_type_t type, const char *name) +{ + if (type == DEV_TYPE_FILE) { + return opendir(name); + } + + if (type == DEV_TYPE_RAW) { + raw_dir_handle *dss_dir_handle = (raw_dir_handle*)malloc(sizeof(raw_dir_handle)); + if (dss_dir_handle == NULL) { + CT_LOG_RUN_ERR("malloc dss dir handle failed"); + return NULL; + } + if (g_raw_device_op.raw_open_dir == NULL) { + CT_THROW_ERROR(ERR_DEVICE_NOT_SUPPORT); + return NULL; + } + *dss_dir_handle = g_raw_device_op.raw_open_dir(name); + return (DIR*)dss_dir_handle; + } + CT_THROW_ERROR(ERR_DEVICE_NOT_SUPPORT); + return NULL; +} + +int cm_close_device_dir(device_type_t type, DIR *dir_handle) +{ + if (type == DEV_TYPE_RAW) { + raw_dir_handle *dss_dir_handle = (raw_dir_handle *)dir_handle; + int result = g_raw_device_op.raw_close_dir(*dss_dir_handle); + free(dss_dir_handle); + return result; + } + + return closedir(dir_handle); +} + +status_t cm_read_device_dir(device_type_t type, DIR *dirp, struct dirent *arch_dir) +{ + if (dirp == NULL) { + return CT_ERROR; + } + + if (type == DEV_TYPE_RAW) { + raw_dir_handle *dss_dir_handle = (raw_dir_handle *)dirp; + raw_dirent_t raw_dirent; + raw_dir_item_t raw_item; + if (g_raw_device_op.raw_read_dir(*dss_dir_handle, &raw_dirent, &raw_item) != CT_SUCCESS) { + return CT_ERROR; + } + + errno_t ret = strcpy_sp(arch_dir->d_name, DSS_MAX_NAME_LEN, raw_dirent.d_name); + if (ret != CT_SUCCESS) { + CT_LOG_RUN_ERR("Failed to copy d_name"); + return CT_ERROR; + } + return CT_SUCCESS; + } + + arch_dir = readdir(dirp); + if (arch_dir == NULL) { + return CT_ERROR; + } + return CT_SUCCESS; +} + bool32 cm_exist_device(device_type_t type, const char *name) { if (type == DEV_TYPE_FILE) { diff --git a/pkg/src/common/cm_device.h b/pkg/src/common/cm_device.h index b8283708a18d827ec2ce6c1ac4b26463cf96d143..5ebd567fb38abdecd4b829df73ccf2190e51e16a 100644 --- a/pkg/src/common/cm_device.h +++ b/pkg/src/common/cm_device.h @@ -27,12 +27,12 @@ #include "cm_defs.h" #include +#include #ifndef WIN32 #include "libaio.h" #endif - typedef enum en_device_type { DEV_TYPE_FILE = 1, DEV_TYPE_RAW = 2, @@ -104,6 +104,16 @@ typedef struct st_aio_lib { #define DSS_MAX_NAME_LEN 64 /* Consistent with dss_def.h */ typedef enum en_dss_item_type { DSS_PATH, DSS_FILE, DSS_LINK } dss_item_type_t; +struct __dss_dir; +typedef struct __dss_dir *raw_dir_handle; + +typedef struct st_dss_dirent { + dss_item_type_t d_type; + char d_name[DSS_MAX_NAME_LEN]; +} raw_dirent_t; + +typedef struct st_dss_dirent *raw_dir_item_t; + typedef struct st_dss_stat { unsigned long long size; unsigned long long written_size; @@ -164,6 +174,9 @@ status_t cm_access_device(device_type_t type, const char *file_name, uint32 mode status_t cm_create_device_dir(device_type_t type, const char *name); bool32 cm_exist_device_dir(device_type_t type, const char *name); bool32 cm_create_device_dir_ex(device_type_t type, const char *name); +DIR *cm_open_device_dir(device_type_t type, const char *name); +int cm_close_device_dir(device_type_t type, DIR *dirp); +status_t cm_read_device_dir(device_type_t type, DIR *dirp, struct dirent *arch_dir); status_t cm_check_device_size(device_type_t type, int32 size); int32 cm_align_device_size(device_type_t type, int32 size); status_t cm_device_get_used_cap(device_type_t type, int32 handle, uint64_t startLsn, uint32_t *sizeKb); @@ -188,6 +201,10 @@ typedef status_t (*raw_remove_device)(const char *name); typedef void (*raw_close_device)(int32 handle); typedef status_t (*raw_exist_device)(const char *name, bool32 *result); typedef status_t (*raw_create_device_dir)(const char *name); +typedef raw_dir_handle (*raw_open_device_dir)(const char *name); +typedef int (*raw_read_device_dir)(raw_dir_handle dir, raw_dirent_t *item, raw_dir_item_t *result); +typedef int (*raw_close_device_dir)(raw_dir_handle dir); +typedef int (*raw_remove_device_dir)(const char *name); typedef status_t (*raw_exist_device_dir)(const char *name, bool32 *result); typedef status_t (*raw_rename_device)(const char *src, const char *dst); typedef status_t (*raw_check_device_size)(int32 size); @@ -221,6 +238,10 @@ typedef struct st_raw_device_op { raw_close_device raw_close; raw_exist_device raw_exist; raw_create_device_dir raw_create_dir; + raw_close_device_dir raw_close_dir; + raw_open_device_dir raw_open_dir; + raw_read_device_dir raw_read_dir; + raw_remove_device_dir raw_remove_dir; raw_exist_device_dir raw_exist_dir; raw_rename_device raw_rename; raw_check_device_size raw_check_size; diff --git a/pkg/src/kernel/backup/knl_backup.c b/pkg/src/kernel/backup/knl_backup.c index 66ce8dd09c328346f110120cb3dc6b2de5f73dae..32888e2135e7b59c857e1d9785ee2af85bd2ae73 100644 --- a/pkg/src/kernel/backup/knl_backup.c +++ b/pkg/src/kernel/backup/knl_backup.c @@ -3373,21 +3373,11 @@ status_t bak_set_increment_unblock(knl_session_t *session) status_t bak_check_increment_unblock(knl_session_t *session, bool32 *unblock) { - ctrl_page_t *page = (ctrl_page_t *)cm_push(session->stack, - session->kernel->db.ctrlfiles.items[0].block_size); - if (dtc_read_core_ctrl(session, page) != CT_SUCCESS) { - CT_LOG_RUN_ERR("[BACKUP] read core control file failed"); - CT_THROW_ERROR(ERR_LOAD_CONTROL_FILE, "no usable control file"); - cm_pop(session->stack); - return CT_ERROR; - } - if (((core_ctrl_t *)&page->buf[0])->inc_backup_block == CT_TRUE) { + if (session->kernel->db.ctrl.core.inc_backup_block == CT_TRUE) { *unblock = CT_FALSE; } else { *unblock = CT_TRUE; } - cm_pop(session->stack); - CT_LOG_RUN_INF("[BACKUP] get inc_backup_block value from core control file succ"); return CT_SUCCESS; } diff --git a/pkg/src/kernel/persist/knl_archive.c b/pkg/src/kernel/persist/knl_archive.c index e1d194a704a4974052962ce3de0d9b97c71fbe00..07358265ff237a1982676507f38a7afe977c08cf 100644 --- a/pkg/src/kernel/persist/knl_archive.c +++ b/pkg/src/kernel/persist/knl_archive.c @@ -1483,7 +1483,7 @@ static status_t arch_archive_tmp_file(knl_session_t *session, aligned_buf_t buf, logfile, logfile->ctrl->name, logfile->ctrl->type, knl_redo_io_flag(session)); SYNC_POINT_GLOBAL_END; if (status != CT_SUCCESS) { - CT_LOG_RUN_ERR_LIMIT(60, "[ARCH] failed to open log file %s", logfile->ctrl->name); + CT_LOG_RUN_ERR("[ARCH] failed to open log file %s", logfile->ctrl->name); return CT_ERROR; } @@ -1492,17 +1492,21 @@ static status_t arch_archive_tmp_file(knl_session_t *session, aligned_buf_t buf, CT_XPURPOSE_BUFFER_SIZE, CM_CALC_ALIGN(sizeof(log_file_head_t), logfile->ctrl->block_size), knl_arch_io_flag(session, compress), CT_FALSE, &arch_files.dst_file) != CT_SUCCESS) { cm_close_device(logfile->ctrl->type, &arch_files.src_file); + CT_LOG_RUN_ERR("[ARCH] failed to cm_build_device file %s", tmp_arch_file_name); return CT_ERROR; } if (cm_open_device(tmp_arch_file_name, logfile->ctrl->type, knl_arch_io_flag(session, compress), &arch_files.dst_file) != CT_SUCCESS) { - CT_LOG_RUN_ERR("[ARCH] failed to create temp archive log file %s", tmp_arch_file_name); + CT_LOG_RUN_ERR("[ARCH] failed to create temp archive log file %s , type %u", tmp_arch_file_name, logfile->ctrl->type); cm_close_device(logfile->ctrl->type, &arch_files.src_file); return CT_ERROR; } status = arch_write_arch_file(session, buf, logfile, &arch_files, compress_ctx); + if (status != CT_SUCCESS) { + CT_LOG_RUN_ERR("[ARCH] failed to arch_write_arch_file %s", logfile->ctrl->name); + } cm_close_device(logfile->ctrl->type, &arch_files.src_file); cm_close_device(logfile->ctrl->type, &arch_files.dst_file); diff --git a/pkg/src/server/srv_device_adpt.c b/pkg/src/server/srv_device_adpt.c index 7a49fbf99042dbdbb17e4f40372fdc77fede5de6..2e5ea71d6a1c3d2886fd0a17e6195c8fcf7e5b3d 100644 --- a/pkg/src/server/srv_device_adpt.c +++ b/pkg/src/server/srv_device_adpt.c @@ -67,6 +67,10 @@ status_t srv_device_init(const char *conn_path) CT_RETURN_IFERR(cm_load_symbol(device_op.handle, "dss_fseek", (void **)&device_op.raw_seek)); CT_RETURN_IFERR(cm_load_symbol(device_op.handle, "dss_fwrite", (void **)&device_op.raw_write)); CT_RETURN_IFERR(cm_load_symbol(device_op.handle, "dss_dmake", (void **)&device_op.raw_create_dir)); + CT_RETURN_IFERR(cm_load_symbol(device_op.handle, "dss_dopen", (void **)&device_op.raw_open_dir)); + CT_RETURN_IFERR(cm_load_symbol(device_op.handle, "dss_dread", (void **)&device_op.raw_read_dir)); + CT_RETURN_IFERR(cm_load_symbol(device_op.handle, "dss_dclose", (void **)&device_op.raw_close_dir)); + CT_RETURN_IFERR(cm_load_symbol(device_op.handle, "dss_dremove", (void **)&device_op.raw_remove_dir)); CT_RETURN_IFERR(cm_load_symbol(device_op.handle, "dss_frename", (void **)&device_op.raw_rename)); CT_RETURN_IFERR(cm_load_symbol(device_op.handle, "dss_check_size", (void **)&device_op.raw_check_size)); CT_RETURN_IFERR(cm_load_symbol(device_op.handle, "dss_align_size", (void **)&device_op.raw_align_size));