static void test_migrate(void)
{
TestServer *s = test_server_new("src");
TestServer *dest = test_server_new("dest");
char *uri = g_strdup_printf("%s%s", "unix:", dest->mig_path);
QTestState *global = global_qtest, *from, *to;
GSource *source;
gchar *cmd;
QDict *rsp;
guint8 *log;
guint64 size;
test_server_listen(s);
test_server_listen(dest);
cmd = GET_QEMU_CMDE(s, 2, "", "");
from = qtest_start(cmd);
g_free(cmd);
init_virtio_dev(s);
wait_for_fds(s);
size = get_log_size(s);
g_assert_cmpint(size, ==, (2 * 1024 * 1024) / (VHOST_LOG_PAGE * 8));
cmd = GET_QEMU_CMDE(dest, 2, "", " -incoming %s", uri);
to = qtest_init(cmd);
g_free(cmd);
source = g_source_new(&test_migrate_source_funcs,
sizeof(TestMigrateSource));
((TestMigrateSource *)source)->src = s;
((TestMigrateSource *)source)->dest = dest;
g_source_attach(source, NULL);
/* slow down migration to have time to fiddle with log */
/* TODO: qtest could learn to break on some places */
rsp = qmp("{ 'execute': 'migrate_set_speed',"
"'arguments': { 'value': 10 } }");
g_assert(qdict_haskey(rsp, "return"));
QDECREF(rsp);
cmd = g_strdup_printf("{ 'execute': 'migrate',"
"'arguments': { 'uri': '%s' } }",
uri);
rsp = qmp(cmd);
g_free(cmd);
g_assert(qdict_haskey(rsp, "return"));
QDECREF(rsp);
wait_for_log_fd(s);
log = mmap(0, size, PROT_READ | PROT_WRITE, MAP_SHARED, s->log_fd, 0);
g_assert(log != MAP_FAILED);
/* modify first page */
write_guest_mem(s, 0x42);
log[0] = 1;
munmap(log, size);
/* speed things up */
rsp = qmp("{ 'execute': 'migrate_set_speed',"
"'arguments': { 'value': 0 } }");
g_assert(qdict_haskey(rsp, "return"));
QDECREF(rsp);
qmp_eventwait("STOP");
global_qtest = to;
qmp_eventwait("RESUME");
read_guest_mem(dest);
g_source_destroy(source);
g_source_unref(source);
qtest_quit(to);
test_server_free(dest);
qtest_quit(from);
test_server_free(s);
g_free(uri);
global_qtest = global;
}
KeyboardEventRepeating::~KeyboardEventRepeating()
{
g_source_destroy(m_source);
g_source_unref(m_source);
}
/*
* Frees the CandidateDiscovery structure pointed to
* by 'user data'. Compatible with g_slist_free_full().
*/
static void refresh_free_item (CandidateRefresh *cand)
{
NiceAgent *agent = cand->agent;
uint8_t *username;
gsize username_len;
uint8_t *password;
gsize password_len;
size_t buffer_len = 0;
StunUsageTurnCompatibility turn_compat = agent_to_turn_compatibility (agent);
if (cand->timer_source != NULL) {
g_source_destroy (cand->timer_source);
g_source_unref (cand->timer_source);
cand->timer_source = NULL;
}
if (cand->tick_source != NULL) {
g_source_destroy (cand->tick_source);
g_source_unref (cand->tick_source);
cand->tick_source = NULL;
}
username = (uint8_t *)cand->candidate->turn->username;
username_len = (size_t) strlen (cand->candidate->turn->username);
password = (uint8_t *)cand->candidate->turn->password;
password_len = (size_t) strlen (cand->candidate->turn->password);
if (turn_compat == STUN_USAGE_TURN_COMPATIBILITY_MSN ||
turn_compat == STUN_USAGE_TURN_COMPATIBILITY_OC2007) {
username = g_base64_decode ((gchar *)username, &username_len);
password = g_base64_decode ((gchar *)password, &password_len);
}
buffer_len = stun_usage_turn_create_refresh (&cand->stun_agent,
&cand->stun_message, cand->stun_buffer, sizeof(cand->stun_buffer),
cand->stun_resp_msg.buffer == NULL ? NULL : &cand->stun_resp_msg, 0,
username, username_len,
password, password_len,
agent_to_turn_compatibility (agent));
if (buffer_len > 0) {
StunTransactionId id;
/* forget the transaction since we don't care about the result and
* we don't implement retransmissions/timeout */
stun_message_id (&cand->stun_message, id);
stun_agent_forget_transaction (&cand->stun_agent, id);
/* send the refresh twice since we won't do retransmissions */
agent_socket_send (cand->nicesock, &cand->server,
buffer_len, (gchar *)cand->stun_buffer);
if (!nice_socket_is_reliable (cand->nicesock)) {
agent_socket_send (cand->nicesock, &cand->server,
buffer_len, (gchar *)cand->stun_buffer);
}
}
if (turn_compat == STUN_USAGE_TURN_COMPATIBILITY_MSN ||
turn_compat == STUN_USAGE_TURN_COMPATIBILITY_OC2007) {
g_free (username);
g_free (password);
}
g_slice_free (CandidateRefresh, cand);
}
static void
spawn_data_free (SpawnData *data)
{
if (data->timeout_source != NULL)
{
g_source_destroy (data->timeout_source);
data->timeout_source = NULL;
}
/* Nuke the child, if necessary */
if (data->child_watch_source != NULL)
{
g_source_destroy (data->child_watch_source);
data->child_watch_source = NULL;
}
if (data->child_pid != 0)
{
GSource *source;
kill (data->child_pid, SIGTERM);
/* OK, we need to reap for the child ourselves - we don't want
* to use waitpid() because that might block the calling
* thread (the child might handle SIGTERM and use several
* seconds for cleanup/rollback).
*
* So we use GChildWatch instead.
*
* Avoid taking a references to ourselves. but note that we need
* to pass the GSource so we can nuke it once handled.
*/
source = g_child_watch_source_new (data->child_pid);
g_source_set_callback (source,
(GSourceFunc) child_watch_from_release_cb,
source,
(GDestroyNotify) g_source_destroy);
g_source_attach (source, data->main_context);
g_source_unref (source);
data->child_pid = 0;
}
if (data->child_stdout != NULL)
{
g_string_free (data->child_stdout, TRUE);
data->child_stdout = NULL;
}
if (data->child_stderr != NULL)
{
g_string_free (data->child_stderr, TRUE);
data->child_stderr = NULL;
}
if (data->child_stdout_channel != NULL)
{
g_io_channel_unref (data->child_stdout_channel);
data->child_stdout_channel = NULL;
}
if (data->child_stderr_channel != NULL)
{
g_io_channel_unref (data->child_stderr_channel);
data->child_stderr_channel = NULL;
}
if (data->child_stdout_source != NULL)
{
g_source_destroy (data->child_stdout_source);
data->child_stdout_source = NULL;
}
if (data->child_stderr_source != NULL)
{
g_source_destroy (data->child_stderr_source);
data->child_stderr_source = NULL;
}
if (data->child_stdout_fd != -1)
{
g_warn_if_fail (close (data->child_stdout_fd) == 0);
data->child_stdout_fd = -1;
}
if (data->child_stderr_fd != -1)
{
g_warn_if_fail (close (data->child_stderr_fd) == 0);
data->child_stderr_fd = -1;
}
if (data->cancellable_handler_id > 0)
{
g_cancellable_disconnect (data->cancellable, data->cancellable_handler_id);
data->cancellable_handler_id = 0;
}
if (data->main_context != NULL)
g_main_context_unref (data->main_context);
if (data->cancellable != NULL)
g_object_unref (data->cancellable);
g_free (data->command_line);
g_slice_free (SpawnData, data);
}