int main(int argc, char **args) { //初始化树 s_avl_tree tree; avl_tree_init(&tree); avl_tree_put(&tree, 0, NULL); avl_tree_put(&tree, 1, NULL); avl_tree_put(&tree, 2, NULL); avl_tree_put(&tree, 3, NULL); avl_tree_put(&tree, 4, NULL); avl_tree_put(&tree, 5, NULL); avl_tree_put(&tree, 6, NULL); avl_tree_put(&tree, 7, NULL); avl_tree_put(&tree, 8, NULL); avl_tree_put(&tree, 9, NULL); //中序遍历 avl_tree_inorder_visit(&tree, tree.root); //显示树型结构 avl_tree_inorder_display(&tree, tree.root, 0); //销毁树 avl_tree_destroy(&tree); return 0; }
int main(int argc, char *argv[]) { int idx; avl_tree_t *tree; if (!(tree = avl_tree_init((cmp_t *)cmp))) { fprintf(stderr, "error on avl_tree_init\n"); return -1; } for (idx = 0; idx < sizeof(test_ints)/sizeof(test_ints[0]); idx++) { #if RAND_TEST test_ints[idx] = rand(); if (test_ints[idx] == 0) { test_ints[idx]++; } #endif if (avl_tree_insert(tree, &test_ints[idx]) < 0) { fprintf(stderr, "error on avl_tree_insert\n"); return -1; } } /* printf("%s", avl_tree_str(tree, node2s)); */ if (iter_list(tree, !RAND_TEST)) { return -1; } /* printf("\n"); */ for (idx = 0; idx < 20; idx++) { if (*(int *)avl_tree_search(tree, &test_ints[idx]) != test_ints[idx]) { fprintf(stderr, "error on avl_tree_search\n"); return -1; } } #if RAND_TEST for (idx = 0; idx < sizeof(test_ints)/sizeof(test_ints[0])/2; idx++) { avl_tree_delete(tree, &test_ints[idx]); } #else avl_tree_delete(tree, &test_ints[6]); avl_tree_delete(tree, &test_ints[2]); avl_tree_delete(tree, &test_ints[1]); avl_tree_delete(tree, &test_ints[9]); avl_tree_delete(tree, &test_ints[11]); avl_tree_delete(tree, &test_ints[4]); #endif /* printf("%s", avl_tree_str(tree, node2s)); */ if (iter_list(tree, !RAND_TEST)) { return -1; } printf("Test successful!\n"); return 0; }
void master_init_(master_t *m, io_service_t *iosvc) { m->iosvc = iosvc; timer_init(&m->tmr, m->iosvc); memset(&m->sum, 0, sizeof(m->sum)); memset(&m->avg, 0, sizeof(m->avg)); avl_tree_init(&m->slaves, true, sizeof(slave_description_t)); }
int trunk_free_block_checker_init() { int result; if ((result=avl_tree_init(&tree_info_by_id, free, \ storage_trunk_node_compare_entry)) != 0) { logError("file: "__FILE__", line: %d, " \ "avl_tree_init fail, " \ "errno: %d, error info: %s", \ __LINE__, result, STRERROR(result)); return result; } return 0; }
void perform_avl_tree_test (avl_tree_t *avlt, int use_odd_numbers) { int i, lo, hi, d, fail_search; int rv; int fine, not_fine; char *oddness = use_odd_numbers ? "odd" : "even"; char *reverse = use_odd_numbers ? "even" : "odd"; unsigned long long int bytes_used; double megabytes_used; void *fwdata, *searched, *found, *removed; chunk_manager_parameters_t chparams; printf("size of ONE avl node is: %lu bytes\n", sizeof(avl_node_t)); /* ** Fill opposing ends of array, converge in middle. ** This gives some sort of randomness to data. */ printf("filling array of size %d with %s number data\n", MAX_SZ, oddness); d = use_odd_numbers ? 1 : 0; lo = 0; hi = MAX_SZ - 1; while (1) { data[lo++] = d; d += 2; data[hi--] = d; d += 2; if (lo > hi) break; } if (max_value_reached < d) { max_value_reached = d + 10; printf("max value recorded so far is %d\n", max_value_reached); } chparams.initial_number_of_chunks = max_value_reached + 10; chparams.grow_size = 1024; avl_tree_init(avlt, 1, int_compare, NULL, &chparams); /* enter all array data into avl tree */ printf("now entering all %s number data into the avl tree\n", oddness); timer_start(&timr); for (i = 0; i < MAX_SZ; i++) { fwdata = &data[i]; rv = avl_tree_insert(avlt, fwdata, &found); if (rv != 0) { printf("populate_data: avl_tree_insert error: %d failed\n", i); } } timer_end(&timr); timer_report(&timr, MAX_SZ, NULL); OBJECT_MEMORY_USAGE(avlt, bytes_used, megabytes_used); printf("total memory used by the avl tree of %d nodes: %llu bytes (%lf Mbytes)\n", avlt->n, bytes_used, megabytes_used); printf("searching for non existant data\n"); fine = not_fine = 0; timer_start(&timr); for (i = max_value_reached; i < (max_value_reached + EXTRA); i++) { searched = &i; rv = avl_tree_search(avlt, searched, &found); if ((rv == 0) || found) { not_fine++; } else { fine++; } } timer_end(&timr); timer_report(&timr, EXTRA, NULL); printf("expected %d, NOT expected %d\n", fine, not_fine); /* now search all data that should be found (all of them) */ printf("now searching all %s numbers in the avl tree\n", oddness); fine = not_fine = 0; timer_start(&timr); for (i = 0; i < MAX_SZ; i++) { searched = &data[i]; rv = avl_tree_search(avlt, searched, &found); if ((rv != 0) || (data[i] != *((int*) found))) { not_fine++; } else { fine++; } } timer_end(&timr); timer_report(&timr, MAX_SZ, NULL); printf("found %d as expected and %d as NOT expected\n", fine, not_fine); /* now search for all entries that should NOT be in the tree */ printf("now searching for all %s numbers in the avl tree\n", reverse); fine = not_fine = 0; d = use_odd_numbers ? 0 : 1; timer_start(&timr); for (i = 0; i < MAX_SZ; i++) { searched = &d; rv = avl_tree_search(avlt, searched, &found); if ((rv == 0) || found) { not_fine++; } else { fine++; } d += 2; } timer_end(&timr); timer_report(&timr, MAX_SZ, NULL); printf("%d as expected and %d as NOT expected\n", fine, not_fine); #if 0 int tree_nodes = avlt->n; printf("now deleting the whole tree (%d nodes)\n", tree_nodes); timer_start(&timr); avl_tree_destroy(avlt); timer_end(&timr); timer_report(&timr, tree_nodes, NULL); return; #endif // 0 /* now delete one entry at a time and search it (should not be there) */ printf("now deleting and searching\n"); fine = not_fine = fail_search = 0; timer_start(&timr); for (i = 0; i < MAX_SZ; i++) { searched = &data[i]; rv = avl_tree_remove(avlt, searched, &removed); if ((rv != 0) || (data[i] != *((int*) removed))) { not_fine++; } else { fine++; } rv = avl_tree_search(avlt, searched, &found); if ((rv == 0) || found) { fail_search++; } } timer_end(&timr); timer_report(&timr, MAX_SZ*2, NULL); printf("deleted %d, could NOT delete %d, erroneous search %d\n", fine, not_fine, fail_search); OBJECT_MEMORY_USAGE(avlt, bytes_used, megabytes_used); printf("total memory used by the avl tree (%d nodes) after deletes: " "%llu bytes (%f Mbytes)\n", avlt->n, bytes_used, megabytes_used); avl_tree_destroy(avlt); }
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; }
bool driver_core_init_(io_service_t *iosvc, driver_core_t *core, driver_payload_t *payload) { size_t path_len = BASE_DIR_LEN + SLASH_LEN + payload->name_len + DOT_LEN + MAX_DIGITS + DOT_LEN + SUFFIX_LEN + 1; char path[path_len]; size_t offset = 0; uint8_t idx; uint8_t cmd_number; pr_driver_info_t *drv_info; pr_driver_command_info_t *cmd_info; driver_command_t *cmd; memset(core, 0, sizeof(core)); if (path_len > UNIX_PATH_MAX) return false; memcpy(path + offset, BASE_DIR, BASE_DIR_LEN); offset += BASE_DIR_LEN; memcpy(path + offset, SLASH, SLASH_LEN); offset += SLASH_LEN; memcpy(path + offset, payload->name, payload->name_len); offset += payload->name_len; memcpy(path + offset, DOT, DOT_LEN); offset += DOT_LEN; offset += snprintf(path + offset, MAX_DIGITS + 1, "%u", payload->slot_number); memcpy(path + offset, DOT, DOT_LEN); offset += DOT_LEN; memcpy(path + offset, SUFFIX, SUFFIX_LEN); offset += SUFFIX_LEN; *(path + offset) = '\0'; core->path = strdup(path); core->iosvc = iosvc; core->payload = payload; /* allocate memroy for greeting (driver info) */ cmd_number = vector_count(&(core->payload->commands)) > 255 ? 255 : vector_count(&(core->payload->commands)); core->greeting_length = sizeof(pr_driver_info_t) + cmd_number * sizeof(pr_driver_command_info_t); core->greeting = malloc(core->greeting_length); if (!core->greeting) return false; drv_info = (pr_driver_info_t *)core->greeting; drv_info->s.s = PR_DRV_INFO; drv_info->commands_number = vector_count(&(core->payload->commands)); cmd_info = (pr_driver_command_info_t *)(drv_info + 1); for (idx = 0; idx < cmd_number; ++idx, ++cmd_info) { cmd = vector_get(&(core->payload->commands), idx); memset(cmd_info, 0, sizeof(*cmd_info)); memcpy(cmd_info->name, cmd->name, cmd->name_len < MAX_COMMAND_NAME_LEN ? cmd->name_len : MAX_COMMAND_NAME_LEN); memcpy(cmd_info->descr, cmd->description, cmd->description_len < MAX_COMMAND_DESCRIPTION_LEN ? cmd->description_len : MAX_COMMAND_DESCRIPTION_LEN); cmd_info->arity = cmd->max_arity; } avl_tree_init(&core->connection_state, true, sizeof(driver_core_connection_state_t)); return unix_socket_server_init(&core->uss, path, offset, iosvc); }
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 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; }