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;
}