static int storage_trunk_restore(const int64_t restore_offset) { int64_t trunk_binlog_size; int64_t line_count; TrunkBinLogReader reader; TrunkBinLogRecord record; char trunk_mark_filename[MAX_PATH_SIZE]; char buff[256]; int record_length; int result; AVLTreeInfo tree_info_by_offset; struct fast_mblock_node *pMblockNode; FDFSTrunkNode *pTrunkNode; FDFSTrunkNode trunkNode; bool trunk_init_reload_from_binlog; trunk_binlog_size = storage_trunk_get_binlog_size(); if (trunk_binlog_size < 0) { return errno != 0 ? errno : EPERM; } if (restore_offset == trunk_binlog_size) { return 0; } if (restore_offset > trunk_binlog_size) { logWarning("file: "__FILE__", line: %d, " \ "restore_offset: %"PRId64 \ " > trunk_binlog_size: %"PRId64, \ __LINE__, restore_offset, trunk_binlog_size); return storage_trunk_save(); } logDebug("file: "__FILE__", line: %d, " \ "trunk metadata recovering, start offset: " \ "%"PRId64", need recovery binlog bytes: " \ "%"PRId64, __LINE__, \ restore_offset, trunk_binlog_size - restore_offset); trunk_init_reload_from_binlog = (restore_offset == 0); if (trunk_init_reload_from_binlog) { memset(&trunkNode, 0, sizeof(trunkNode)); if ((result=avl_tree_init(&tree_info_by_offset, \ storage_trunk_free_node, \ storage_trunk_node_compare_offset)) != 0) { logError("file: "__FILE__", line: %d, " \ "avl_tree_init fail, " \ "errno: %d, error info: %s", \ __LINE__, result, STRERROR(result)); return result; } } memset(&record, 0, sizeof(record)); memset(&reader, 0, sizeof(reader)); reader.binlog_offset = restore_offset; if ((result=trunk_reader_init(NULL, &reader)) != 0) { return result; } line_count = 0; while (1) { record_length = 0; result = trunk_binlog_read(&reader, &record, &record_length); if (result != 0) { if (result == ENOENT) { if (record_length > 0) //skip incorrect record { line_count++; reader.binlog_offset += record_length; continue; } result = (reader.binlog_offset >= \ trunk_binlog_size) ? 0 : EINVAL; if (result != 0) { logError("file: "__FILE__", line: %d, " \ "binlog offset: %"PRId64 \ " < binlog size: %"PRId64 \ ", please check the end of trunk " \ "binlog", __LINE__, \ reader.binlog_offset, trunk_binlog_size); } } break; } line_count++; if (record.op_type == TRUNK_OP_TYPE_ADD_SPACE) { record.trunk.status = FDFS_TRUNK_STATUS_FREE; if (trunk_init_reload_from_binlog) { pMblockNode = fast_mblock_alloc(&free_blocks_man); if (pMblockNode == NULL) { result = errno != 0 ? errno : EIO; logError("file: "__FILE__", line: %d, "\ "malloc %d bytes fail, " \ "errno: %d, error info: %s", \ __LINE__, \ (int)sizeof(FDFSTrunkNode), \ result, STRERROR(result)); return result; } pTrunkNode = (FDFSTrunkNode *)pMblockNode->data; memcpy(&pTrunkNode->trunk, &(record.trunk), \ sizeof(FDFSTrunkFullInfo)); pTrunkNode->pMblockNode = pMblockNode; pTrunkNode->next = NULL; result = avl_tree_insert(&tree_info_by_offset,\ pTrunkNode); if (result < 0) //error { result *= -1; logError("file: "__FILE__", line: %d, "\ "avl_tree_insert fail, " \ "errno: %d, error info: %s", \ __LINE__, result, \ STRERROR(result)); return result; } else if (result == 0) { trunk_info_dump(&(record.trunk), \ buff, sizeof(buff)); logWarning("file: "__FILE__", line: %d"\ ", trunk data line: " \ "%"PRId64", trunk "\ "space already exist, "\ "trunk info: %s", \ __LINE__, line_count, buff); } } else if ((result=trunk_add_space_by_trunk( \ &record.trunk)) != 0) { break; } } else if (record.op_type == TRUNK_OP_TYPE_DEL_SPACE) { record.trunk.status = FDFS_TRUNK_STATUS_FREE; if (trunk_init_reload_from_binlog) { memcpy(&trunkNode.trunk, &record.trunk, \ sizeof(FDFSTrunkFullInfo)); if (avl_tree_delete(&tree_info_by_offset,\ &trunkNode) != 1) { trunk_info_dump(&(record.trunk), \ buff, sizeof(buff)); logWarning("file: "__FILE__", line: %d"\ ", binlog offset: %"PRId64 \ ", trunk data line: %"PRId64 \ " trunk node not exist, " \ "trunk info: %s", __LINE__, \ reader.binlog_offset, \ line_count, buff); } } else if ((result=trunk_delete_space( \ &record.trunk, false)) != 0) { if (result == ENOENT) { logDebug("file: "__FILE__", line: %d, "\ "binlog offset: %"PRId64 \ ", trunk data line: %"PRId64,\ __LINE__, reader.binlog_offset, \ line_count); result = 0; } else { break; } } } reader.binlog_offset += record_length; } trunk_reader_destroy(&reader); trunk_mark_filename_by_reader(&reader, trunk_mark_filename); if (unlink(trunk_mark_filename) != 0) { logError("file: "__FILE__", line: %d, " \ "unlink file %s fail, " \ "errno: %d, error info: %s", __LINE__, \ trunk_mark_filename, errno, STRERROR(errno)); } if (result != 0) { if (trunk_init_reload_from_binlog) { avl_tree_destroy(&tree_info_by_offset); } logError("file: "__FILE__", line: %d, " \ "trunk load fail, errno: %d, error info: %s", \ __LINE__, result, STRERROR(result)); return result; } if (trunk_init_reload_from_binlog) { logInfo("file: "__FILE__", line: %d, " \ "free tree node count: %d", \ __LINE__, avl_tree_count(&tree_info_by_offset)); result = avl_tree_walk(&tree_info_by_offset, \ storage_trunk_add_free_blocks_callback, NULL); tree_info_by_offset.free_data_func = NULL; avl_tree_destroy(&tree_info_by_offset); } if (result == 0) { logDebug("file: "__FILE__", line: %d, " \ "trunk metadata recovery done. start offset: " \ "%"PRId64", recovery file size: " \ "%"PRId64, __LINE__, \ restore_offset, trunk_binlog_size - restore_offset); return storage_trunk_save(); } return result; }
int storage_trunk_init() { int result; int i; int count; if (!g_if_trunker_self) { logError("file: "__FILE__", line: %d, " \ "I am not trunk server!", __LINE__); return 0; } if (trunk_init_flag != STORAGE_TRUNK_INIT_FLAG_NONE) { logWarning("file: "__FILE__", line: %d, " \ "trunk already inited!", __LINE__); return 0; } logDebug("file: "__FILE__", line: %d, " \ "storage trunk init ...", __LINE__); g_trunk_server.sock = -1; g_trunk_server.port = g_server_port; if ((result=init_pthread_lock(&trunk_file_lock)) != 0) { logError("file: "__FILE__", line: %d, " \ "init_pthread_lock fail, " \ "errno: %d, error info: %s", \ __LINE__, result, STRERROR(result)); return result; } if ((result=init_pthread_lock(&trunk_mem_lock)) != 0) { logError("file: "__FILE__", line: %d, " \ "init_pthread_lock fail, " \ "errno: %d, error info: %s", \ __LINE__, result, STRERROR(result)); return result; } if ((result=fast_mblock_init(&free_blocks_man, \ sizeof(FDFSTrunkNode), 0)) != 0) { return result; } if ((result=fast_mblock_init(&tree_nodes_man, \ sizeof(FDFSTrunkSlot), 0)) != 0) { return result; } tree_info_by_sizes = (AVLTreeInfo *)malloc(sizeof(AVLTreeInfo) * \ g_fdfs_store_paths.count); if (tree_info_by_sizes == NULL) { result = errno != 0 ? errno : ENOMEM; logError("file: "__FILE__", line: %d, " \ "malloc %d bytes fail, errno: %d, error info: %s", \ __LINE__, (int)(sizeof(AVLTreeInfo) * \ g_fdfs_store_paths.count), result, STRERROR(result)); return result; } for (i=0; i<g_fdfs_store_paths.count; i++) { if ((result=avl_tree_init(tree_info_by_sizes + i, NULL, \ storage_trunk_node_compare_size)) != 0) { logError("file: "__FILE__", line: %d, " \ "avl_tree_init fail, " \ "errno: %d, error info: %s", \ __LINE__, result, STRERROR(result)); return result; } } if ((result=trunk_free_block_checker_init()) != 0) { return result; } if ((result=storage_trunk_load()) != 0) { return result; } count = 0; for (i=0; i<g_fdfs_store_paths.count; i++) { count += avl_tree_count(tree_info_by_sizes + i); } logInfo("file: "__FILE__", line: %d, " \ "tree by space size node count: %d, tree by trunk file id " \ "node count: %d, free block count: %d, " \ "trunk_total_free_space: %"PRId64, __LINE__, \ count, trunk_free_block_tree_node_count(), \ trunk_free_block_total_count(), \ g_trunk_total_free_space); /* { char filename[MAX_PATH_SIZE]; sprintf(filename, "%s/logs/tttt.dat", g_fdfs_base_path); trunk_free_block_tree_print(filename); } */ trunk_init_flag = STORAGE_TRUNK_INIT_FLAG_DONE; return 0; }
static int storage_do_split_trunk_binlog(const int store_path_index, StorageBinLogReader *pReader) { FILE *fp; char *pBasePath; FDFSTrunkFileIdInfo *pFound; char binlogFullFilename[MAX_PATH_SIZE]; char tmpFullFilename[MAX_PATH_SIZE]; FDFSTrunkFullInfo trunk_info; FDFSTrunkFileIdInfo trunkFileId; StorageBinLogRecord record; AVLTreeInfo tree_unique_trunks; int record_length; int result; pBasePath = g_fdfs_store_paths.paths[store_path_index]; recovery_get_full_filename(pBasePath, \ RECOVERY_BINLOG_FILENAME".tmp", tmpFullFilename); fp = fopen(tmpFullFilename, "w"); if (fp == NULL) { result = errno != 0 ? errno : EPERM; logError("file: "__FILE__", line: %d, " \ "open file: %s fail, " \ "errno: %d, error info: %s.", \ __LINE__, tmpFullFilename, result, STRERROR(result)); return result; } if ((result=avl_tree_init(&tree_unique_trunks, free, \ storage_compare_trunk_id_info)) != 0) { logError("file: "__FILE__", line: %d, " \ "avl_tree_init fail, " \ "errno: %d, error info: %s", \ __LINE__, result, STRERROR(result)); fclose(fp); return result; } memset(&trunk_info, 0, sizeof(trunk_info)); memset(&trunkFileId, 0, sizeof(trunkFileId)); result = 0; while (g_continue_flag) { result=storage_binlog_read(pReader, &record, &record_length); if (result != 0) { if (result == ENOENT) { result = 0; } break; } if (fdfs_is_trunk_file(record.filename, record.filename_len)) { if (fdfs_decode_trunk_info(store_path_index, \ record.true_filename, record.true_filename_len,\ &trunk_info) != 0) { continue; } trunkFileId.path = trunk_info.path; trunkFileId.id = trunk_info.file.id; pFound = (FDFSTrunkFileIdInfo *)avl_tree_find( \ &tree_unique_trunks, &trunkFileId); if (pFound != NULL) { continue; } pFound = (FDFSTrunkFileIdInfo *)malloc( \ sizeof(FDFSTrunkFileIdInfo)); if (pFound == NULL) { result = errno != 0 ? errno : ENOMEM; logError("file: "__FILE__", line: %d, " \ "malloc %d bytes fail, " \ "errno: %d, error info: %s", __LINE__,\ (int)sizeof(FDFSTrunkFileIdInfo), \ result, STRERROR(result)); break; } sprintf(trunkFileId.line, "%d %c %s", \ (int)record.timestamp, \ record.op_type, record.filename); memcpy(pFound, &trunkFileId, sizeof(FDFSTrunkFileIdInfo)); if (avl_tree_insert(&tree_unique_trunks, pFound) != 1) { result = errno != 0 ? errno : ENOMEM; logError("file: "__FILE__", line: %d, " \ "avl_tree_insert fail, " \ "errno: %d, error info: %s", \ __LINE__, result, STRERROR(result)); break; } } else { if (record.op_type == STORAGE_OP_TYPE_SOURCE_CREATE_FILE || record.op_type == STORAGE_OP_TYPE_REPLICA_CREATE_FILE) { if (fprintf(fp, "%d %c %s\n", \ (int)record.timestamp, \ record.op_type, record.filename) < 0) { result = errno != 0 ? errno : EIO; logError("file: "__FILE__", line: %d, " \ "write to file: %s fail, " \ "errno: %d, error info: %s.", \ __LINE__, tmpFullFilename, result, STRERROR(result)); break; } } else { if (fprintf(fp, "%d %c %s %s\n", \ (int)record.timestamp, \ record.op_type, record.filename, \ record.src_filename) < 0) { result = errno != 0 ? errno : EIO; logError("file: "__FILE__", line: %d, " \ "write to file: %s fail, " \ "errno: %d, error info: %s.", \ __LINE__, tmpFullFilename, result, STRERROR(result)); break; } } } } if (result == 0) { int tree_node_count; tree_node_count = avl_tree_count(&tree_unique_trunks); if (tree_node_count > 0) { logInfo("file: "__FILE__", line: %d, " \ "recovering trunk file count: %d", __LINE__, \ tree_node_count); result = avl_tree_walk(&tree_unique_trunks, \ tree_write_file_walk_callback, fp); } } avl_tree_destroy(&tree_unique_trunks); fclose(fp); if (!g_continue_flag) { return EINTR; } if (result != 0) { return result; } recovery_get_full_filename(pBasePath, \ RECOVERY_BINLOG_FILENAME, binlogFullFilename); if (rename(tmpFullFilename, binlogFullFilename) != 0) { logError("file: "__FILE__", line: %d, " \ "rename file %s to %s fail, " \ "errno: %d, error info: %s", __LINE__, \ tmpFullFilename, binlogFullFilename, \ errno, STRERROR(errno)); return errno != 0 ? errno : EPERM; } return 0; }
int trunk_free_block_tree_node_count() { return avl_tree_count(&tree_info_by_id); }
int storage_trunk_init() { int result; if (!g_if_trunker_self) { logError("file: "__FILE__", line: %d, " \ "I am not trunk server!", __LINE__); return 0; } if (trunk_init_flag != STORAGE_TRUNK_INIT_FLAG_NONE) { logWarning("file: "__FILE__", line: %d, " \ "trunk already inited!", __LINE__); return 0; } logDebug("file: "__FILE__", line: %d, " \ "storage trunk init ...", __LINE__); g_trunk_server.sock = -1; g_trunk_server.port = g_server_port; if ((result=init_pthread_lock(&trunk_file_lock)) != 0) { logError("file: "__FILE__", line: %d, " \ "init_pthread_lock fail, " \ "errno: %d, error info: %s", \ __LINE__, result, STRERROR(result)); return result; } if ((result=init_pthread_lock(&trunk_mem_lock)) != 0) { logError("file: "__FILE__", line: %d, " \ "init_pthread_lock fail, " \ "errno: %d, error info: %s", \ __LINE__, result, STRERROR(result)); return result; } if ((result=fast_mblock_init(&free_blocks_man, \ sizeof(FDFSTrunkNode), 0)) != 0) { return result; } if ((result=fast_mblock_init(&tree_nodes_man, \ sizeof(FDFSTrunkSlot), 0)) != 0) { return result; } if ((result=avl_tree_init(&tree_info_by_size, NULL, \ storage_trunk_node_compare_size)) != 0) { logError("file: "__FILE__", line: %d, " \ "avl_tree_init fail, " \ "errno: %d, error info: %s", \ __LINE__, result, STRERROR(result)); return result; } if ((result=trunk_free_block_checker_init()) != 0) { return result; } if ((result=storage_trunk_load()) != 0) { return result; } logInfo("file: "__FILE__", line: %d, " \ "tree by space size node count: %d, tree by trunk file id " \ "node count: %d, free block count: %d, " \ "trunk_total_free_space: "INT64_PRINTF_FORMAT, __LINE__, \ avl_tree_count(&tree_info_by_size), \ trunk_free_block_tree_node_count(), \ trunk_free_block_total_count(), \ g_trunk_total_free_space); /* { char filename[MAX_PATH_SIZE]; sprintf(filename, "%s/logs/tttt.dat", g_fdfs_base_path); trunk_free_block_tree_print(filename); } */ trunk_init_flag = STORAGE_TRUNK_INIT_FLAG_DONE; return 0; }