/***************************************************************//**
Commits a mini-transaction. */
UNIV_INTERN
void
mtr_commit(
/*=======*/
mtr_t* mtr) /*!< in: mini-transaction */
{
#ifndef UNIV_HOTBACKUP
ibool write_log;
#endif /* !UNIV_HOTBACKUP */
ut_ad(mtr);
ut_ad(mtr->magic_n == MTR_MAGIC_N);
ut_ad(mtr->state == MTR_ACTIVE);
ut_d(mtr->state = MTR_COMMITTING);
#ifndef UNIV_HOTBACKUP
/* This is a dirty read, for debugging. */
ut_ad(!recv_no_log_write);
write_log = mtr->modifications && mtr->n_log_recs;
if (write_log) {
mtr_log_reserve_and_write(mtr);
mtr_memo_note_modification_all(mtr);
}
/* We first update the modification info to buffer pages, and only
after that release the log mutex: this guarantees that when the log
mutex is free, all buffer pages contain an up-to-date info of their
modifications. This fact is used in making a checkpoint when we look
at the oldest modification of any page in the buffer pool. It is also
required when we insert modified buffer pages in to the flush list
which must be sorted on oldest_modification. */
if (write_log) {
log_release();
}
/* All unlocking has been moved here, after log_sys mutex release. */
mtr_memo_pop_all(mtr);
#endif /* !UNIV_HOTBACKUP */
ut_d(mtr->state = MTR_COMMITTED);
dyn_array_free(&(mtr->memo));
dyn_array_free(&(mtr->log));
}
static void kill_squeal()
{
LOG_TRACE("Releasing networking");
/*if (event_base_loopexit(evbase_accept, NULL)) {
perror("Error shutting down server");
}*/
LOG_TRACE("Shutting down IO threads");
squeal_tp_destroy(server->pool);
LOG_TRACE("Freeing all resources");
squeal_config_free(server->config);
LOG_CRIT("Shutting down Squeal");
log_release();
}
void core_release(int report_leaks)
{
sock_release();
timer_releasemgr();
fio_releasemgr();
json_release();
err_release();
log_release();
/* dump memory leaks before releasing memory manager and log
* because memory leak report dumps leakage data to logger */
if (report_leaks)
mem_reportleaks();
mem_release();
}
int main(int argc, char *argv[])
{
cli_init();
log_init();
thread_init();
cmd_init();
dev_addr_mgr_init();
addr_sock_init();
socket_init();
dev_router_init();
cli_commands_init();
broadcast_msg_t msg;
dev_addr_mgr_add_support_dev_type(1);
dev_addr_mgr_set_network_type(NETWORK_TYPE_CENTER);
dev_addr_mgr_set_addr_mac(0x89ABCDE0);
dev_router_set_mac_local(0x89ABCDE0);
#ifdef TEST_CLIENT
ex_memzero_one(&msg);
strcpy(msg.dev_name, "1004");
msg.router_list_lens[0] = 3;
msg.router_list_lens[1] = 3;
msg.router_list_lens[2] = 0;
msg.router_list_lens[3] = 0;
msg.router_cnt = 7;
msg.router_list_cnt = 2;
msg.network_nodes[0].dev_type = 1;
msg.network_nodes[0].addr_mac = 0x89ABCDE0;
msg.network_nodes[0].subnet_cnt = 4;
msg.network_nodes[0].network_type = NETWORK_TYPE_ROUTER;
strcpy(msg.network_nodes[0].dev_name, "1004");
msg.network_nodes[1].dev_type = 1;
msg.network_nodes[1].addr_mac = 0x89ABCDE1;
msg.network_nodes[1].subnet_cnt = 4;
msg.network_nodes[1].network_type = NETWORK_TYPE_ROUTER;
strcpy(msg.network_nodes[1].dev_name, "1003");
msg.network_nodes[2].dev_type = 1;
msg.network_nodes[2].addr_mac = 0x89ABCDE2;
msg.network_nodes[2].subnet_cnt = 4;
msg.network_nodes[2].network_type = NETWORK_TYPE_ROUTER;
strcpy(msg.network_nodes[2].dev_name, "1002");
msg.network_nodes[3].dev_type = 1;
msg.network_nodes[3].addr_mac = 0x89ABCDE3;
msg.network_nodes[3].subnet_cnt = 4;
msg.network_nodes[3].network_type = NETWORK_TYPE_ROUTER;
strcpy(msg.network_nodes[3].dev_name, "1001");
msg.network_nodes[4].dev_type = 1;
msg.network_nodes[4].addr_mac = 0x89ABCDE4;
msg.network_nodes[4].subnet_cnt = 4;
msg.network_nodes[4].network_type = NETWORK_TYPE_ROUTER;
strcpy(msg.network_nodes[4].dev_name, "1005");
msg.network_nodes[5].dev_type = 1;
msg.network_nodes[5].addr_mac = 0x89ABCDE5;
msg.network_nodes[5].subnet_cnt = 4;
msg.network_nodes[5].network_type = NETWORK_TYPE_ROUTER;
strcpy(msg.network_nodes[5].dev_name, "1006");
msg.network_nodes[6].dev_type = 1;
msg.network_nodes[6].addr_mac = 0x89ABCDE6;
msg.network_nodes[6].subnet_cnt = 4;
msg.network_nodes[6].network_type = NETWORK_TYPE_ROUTER;
strcpy(msg.network_nodes[6].dev_name, "1007");
#endif
socket_listen_async(50002);
socket_listen_cli(49999);
socket_recv_start();
#ifdef TEST_SERVER
socket_bc_tx_start("test", 50000, 50001, 50002);
#endif
#ifdef TEST_CLIENT
socket_bc_rx_start("test", 50000, 50001, &msg);
#endif
#if 0
cstr *json = cstr_new();
int fd = 0;
fd = socket_cli_send_request("127.0.0.1", 49999, "test");
socket_cli_recv_response(fd, json);
cstr_clear(json);
fd = socket_cli_send_request("127.0.0.1", 49999, "test f**k");
socket_cli_recv_response(fd, json);
cstr_clear(json);
fd = socket_cli_send_request("127.0.0.1", 49999, "f**k f**k f**k you test f**k");
socket_cli_recv_response(fd, json);
cstr_free(json);
#endif
cli_loop();
dev_addr_mgr_release();
socket_release();
cmd_release();
thread_release();
log_release();
cli_release();
#if 0
cli_cmd_t cmd;
int i = 0;
command_init(&cmd, argv[0], "0.0.1");
command_option(&cmd, "-v", "--verbose", "enable verbose stuff", verbose);
command_option(&cmd, "-r", "--required <arg>", "required arg", required);
command_option(&cmd, "-o", "--optional [arg]", "optional arg", optional);
command_parse(&cmd, argc, argv);
printf("additional args:\n");
for (i = 0; i < cmd.argc; ++i) {
printf(" - '%s'\n", cmd.argv[i]);
}
command_free(&cmd);
#endif
return 0;
}
/************************************************************//**
Writes the contents of a mini-transaction log, if any, to the database log. */
static
void
mtr_log_reserve_and_write(
/*======================*/
mtr_t* mtr) /*!< in: mtr */
{
dyn_array_t* mlog;
dyn_block_t* block;
ulint data_size;
byte* first_data;
ut_ad(mtr);
mlog = &(mtr->log);
first_data = dyn_block_get_data(mlog);
if (mtr->n_log_recs > 1) {
mlog_catenate_ulint(mtr, MLOG_MULTI_REC_END, MLOG_1BYTE);
} else {
*first_data = (byte)((ulint)*first_data
| MLOG_SINGLE_REC_FLAG);
}
if (mlog->heap == NULL) {
mtr->end_lsn = log_reserve_and_write_fast(
first_data, dyn_block_get_used(mlog),
&mtr->start_lsn);
if (mtr->end_lsn) {
/* Success. We have the log mutex.
Add pages to flush list and exit */
goto func_exit;
}
}
data_size = dyn_array_get_data_size(mlog);
/* Open the database log for log_write_low */
mtr->start_lsn = log_reserve_and_open(data_size);
if (mtr->log_mode == MTR_LOG_ALL) {
block = mlog;
while (block != NULL) {
log_write_low(dyn_block_get_data(block),
dyn_block_get_used(block));
block = dyn_array_get_next_block(mlog, block);
}
} else {
ut_ad(mtr->log_mode == MTR_LOG_NONE);
/* Do nothing */
}
mtr->end_lsn = log_close();
func_exit:
log_flush_order_mutex_enter();
/* It is now safe to release the log mutex because the
flush_order mutex will ensure that we are the first one
to insert into the flush list. */
log_release();
if (mtr->modifications) {
mtr_memo_note_modifications(mtr);
}
log_flush_order_mutex_exit();
}
