static void tcp_wait_for_connect(void *opaque) { FdMigrationState *s = opaque; int val, ret; socklen_t valsize = sizeof(val); dprintf("connect completed\n"); do { ret = getsockopt(s->fd, SOL_SOCKET, SO_ERROR, (char *)&val, &valsize); } while (ret == -1 && (s->get_error(s)) == EINTR); if (ret < 0) { migrate_fd_error(s); return; } qemu_set_fd_handler2(s->fd, NULL, NULL, NULL, NULL); if (val == 0) migrate_fd_connect(s); else { dprintf("error connecting %d\n", val); migrate_fd_error(s); } }
int exec_start_outgoing_migration(MigrationState *s, const char *command) { FILE *f; f = popen(command, "w"); if (f == NULL) { DPRINTF("Unable to popen exec target\n"); goto err_after_popen; } s->fd = fileno(f); if (s->fd == -1) { DPRINTF("Unable to retrieve file descriptor for popen'd handle\n"); goto err_after_open; } socket_set_nonblock(s->fd); s->opaque = qemu_popen(f, "w"); s->close = exec_close; s->get_error = file_errno; s->write = file_write; migrate_fd_connect(s); return 0; err_after_open: pclose(f); err_after_popen: return -1; }
int fd_start_outgoing_migration(MigrationState *s, const char *fdname) { s->fd = monitor_get_fd(cur_mon, fdname, NULL); if (s->fd == -1) { DPRINTF("fd_migration: invalid file descriptor identifier\n"); goto err_after_get_fd; } if (fcntl(s->fd, F_SETFL, O_NONBLOCK) == -1) { DPRINTF("Unable to set nonblocking mode on file descriptor\n"); goto err_after_open; } s->get_error = fd_errno; s->write = fd_write; s->close = fd_close; migrate_fd_connect(s); return 0; err_after_open: close(s->fd); err_after_get_fd: return -1; }
MigrationState *exec_start_outgoing_migration(const char *command, int64_t bandwidth_limit, int async) { FdMigrationState *s; FILE *f; s = qemu_mallocz(sizeof(*s)); if (s == NULL) { dprintf("Unable to allocate FdMigrationState\n"); goto err; } f = popen(command, "w"); if (f == NULL) { dprintf("Unable to popen exec target\n"); goto err_after_alloc; } s->fd = fileno(f); if (s->fd == -1) { dprintf("Unable to retrieve file descriptor for popen'd handle\n"); goto err_after_open; } if (fcntl(s->fd, F_SETFD, O_NONBLOCK) == -1) { dprintf("Unable to set nonblocking mode on file descriptor\n"); goto err_after_open; } s->opaque = qemu_popen(f, "w"); s->close = exec_close; s->get_error = file_errno; s->write = file_write; s->mig_state.cancel = migrate_fd_cancel; s->mig_state.get_status = migrate_fd_get_status; s->mig_state.release = migrate_fd_release; s->state = MIG_STATE_ACTIVE; s->detach = !async; s->bandwidth_limit = bandwidth_limit; if (s->detach == 1) { dprintf("detaching from monitor\n"); monitor_suspend(); s->detach = 2; } migrate_fd_connect(s); return &s->mig_state; err_after_open: pclose(f); err_after_alloc: qemu_free(s); err: return NULL; }
int tlc_exec_start_outgoing_migration(MigrationState *s, const char *command) { FILE *f; //int64_t test_timer_start, // test_timer_stop3, // test_timer_stop2, // test_timer_stop1; //test_timer_start = qemu_get_clock_ms(rt_clock); f = popen(command, "w"); if (f == NULL) { DPRINTF("Unable to popen exec target\n"); goto err_after_popen; } //test_timer_stop1 = qemu_get_clock_ms(rt_clock); //DREG{printf("exec: test_timer1: elasp = %" PRId64 " ms\n", test_timer_stop1 - test_timer_start); //fflush(stdout);} s->fd = fileno(f); if (s->fd == -1) { DPRINTF("Unable to retrieve file descriptor for popen'd handle\n"); goto err_after_open; } if(unlikely(mthread)){ //printf("exec_outgoing: set blocking\n"); fflush(stdout); socket_set_block(s->fd); } else{ printf("exec_outgoing: set NON blocking\n"); fflush(stdout); socket_set_nonblock(s->fd); } s->opaque = qemu_popen(f, "w"); //test_timer_stop2 = qemu_get_clock_ms(rt_clock); //DREG{printf("exec: test_timer2: elasp = %" PRId64 " ms\n", test_timer_stop2 - test_timer_stop1); //fflush(stdout);} s->close = exec_close; s->get_error = file_errno; s->write = file_write; migrate_fd_connect(s); //test_timer_stop3 = qemu_get_clock_ms(rt_clock); //DREG{printf("exec: test_timer3: elasp = %" PRId64 " ms\n", test_timer_stop3 - test_timer_stop2); //fflush(stdout);} return 0; err_after_open: pclose(f); err_after_popen: return -1; }
MigrationState *tcp_start_outgoing_migration(const char *host_port, int64_t bandwidth_limit, int detach, int blk, int inc) { struct sockaddr_in addr; FdMigrationState *s; int ret; if (parse_host_port(&addr, host_port) < 0) return NULL; s = qemu_mallocz(sizeof(*s)); s->get_error = socket_errno; s->write = socket_write; s->close = tcp_close; s->mig_state.cancel = migrate_fd_cancel; s->mig_state.get_status = migrate_fd_get_status; s->mig_state.release = migrate_fd_release; s->mig_state.blk = blk; s->mig_state.shared = inc; s->state = MIG_STATE_ACTIVE; s->mon_resume = NULL; s->bandwidth_limit = bandwidth_limit; s->fd = socket(PF_INET, SOCK_STREAM, 0); if (s->fd == -1) { qemu_free(s); return NULL; } socket_set_nonblock(s->fd); if (!detach) migrate_fd_monitor_suspend(s); do { ret = connect(s->fd, (struct sockaddr *)&addr, sizeof(addr)); if (ret == -1) ret = -(s->get_error(s)); if (ret == -EINPROGRESS || ret == -EWOULDBLOCK) qemu_set_fd_handler2(s->fd, NULL, NULL, tcp_wait_for_connect, s); } while (ret == -EINTR); if (ret < 0 && ret != -EINPROGRESS && ret != -EWOULDBLOCK) { dprintf("connect failed\n"); close(s->fd); qemu_free(s); return NULL; } else if (ret >= 0) migrate_fd_connect(s); return &s->mig_state; }
void exec_start_outgoing_migration(MigrationState *s, const char *command, Error **errp) { s->to_dst_file = qemu_popen_cmd(command, "w"); if (s->to_dst_file == NULL) { error_setg_errno(errp, errno, "failed to popen the migration target"); return; } migrate_fd_connect(s); }
MigrationState *exec_start_outgoing_migration(Monitor *mon, const char *command, int64_t bandwidth_limit, int detach, int blk, int inc) { FdMigrationState *s; FILE *f; s = qemu_mallocz(sizeof(*s)); f = popen(command, "w"); if (f == NULL) { dprintf("Unable to popen exec target\n"); goto err_after_alloc; } s->fd = fileno(f); if (s->fd == -1) { dprintf("Unable to retrieve file descriptor for popen'd handle\n"); goto err_after_open; } socket_set_nonblock(s->fd); s->opaque = qemu_popen(f, "w"); s->close = exec_close; s->get_error = file_errno; s->write = file_write; s->mig_state.cancel = migrate_fd_cancel; s->mig_state.get_status = migrate_fd_get_status; s->mig_state.release = migrate_fd_release; s->mig_state.blk = blk; s->mig_state.shared = inc; s->state = MIG_STATE_ACTIVE; s->mon = NULL; s->bandwidth_limit = bandwidth_limit; if (!detach) { migrate_fd_monitor_suspend(s, mon); } migrate_fd_connect(s); return &s->mig_state; err_after_open: pclose(f); err_after_alloc: qemu_free(s); return NULL; }
MigrationState *tcp_start_outgoing_migration(const char *host_port, int64_t bandwidth_limit, int detach) { SockAddress addr; FdMigrationState *s; int ret; if (parse_host_port(&addr, host_port) < 0) return NULL; s = g_malloc0(sizeof(*s)); s->get_error = socket_errno; s->write = socket_write; s->close = tcp_close; s->mig_state.cancel = migrate_fd_cancel; s->mig_state.get_status = migrate_fd_get_status; s->mig_state.release = migrate_fd_release; s->state = MIG_STATE_ACTIVE; s->mon_resume = NULL; s->bandwidth_limit = bandwidth_limit; s->fd = socket_create_inet(SOCKET_STREAM); if (s->fd == -1) { g_free(s); return NULL; } socket_set_nonblock(s->fd); if (!detach) migrate_fd_monitor_suspend(s); do { ret = socket_connect(s->fd, &addr); if (ret == -1) ret = -(s->get_error(s)); if (ret == -EINPROGRESS || ret == -EWOULDBLOCK || ret == -EAGAIN) qemu_set_fd_handler2(s->fd, NULL, NULL, tcp_wait_for_connect, s); } while (ret == -EINTR); if (ret < 0 && ret != -EINPROGRESS && ret != -EWOULDBLOCK && ret != -EAGAIN) { dprintf("connect failed\n"); socket_close(s->fd); g_free(s); return NULL; } else if (ret >= 0) migrate_fd_connect(s); return &s->mig_state; }
static void unix_wait_for_connect(int fd, void *opaque) { MigrationState *s = opaque; if (fd < 0) { DPRINTF("migrate connect error\n"); s->file = NULL; migrate_fd_error(s); } else { DPRINTF("migrate connect success\n"); s->file = qemu_fopen_socket(fd, "wb"); migrate_fd_connect(s); } }
void fd_start_outgoing_migration(MigrationState *s, const char *fdname, Error **errp) { s->fd = monitor_get_fd(cur_mon, fdname, errp); if (s->fd == -1) { return; } fcntl(s->fd, F_SETFL, O_NONBLOCK); s->get_error = fd_errno; s->write = fd_write; s->close = fd_close; migrate_fd_connect(s); }
static void tcp_wait_for_connect(int fd, void *opaque) { FdMigrationState *s = opaque; if (fd < 0) { DPRINTF("migrate connect error\n"); s->fd = -1; migrate_fd_error(s); } else { DPRINTF("migrate connect success\n"); s->fd = fd; migrate_fd_connect(s); } }
MigrationState *fd_start_outgoing_migration(Monitor *mon, const char *fdname, int64_t bandwidth_limit, int detach, int blk, int inc) { FdMigrationState *s; s = qemu_mallocz(sizeof(*s)); s->fd = monitor_get_fd(mon, fdname); if (s->fd == -1) { DPRINTF("fd_migration: invalid file descriptor identifier\n"); goto err_after_alloc; } if (fcntl(s->fd, F_SETFL, O_NONBLOCK) == -1) { DPRINTF("Unable to set nonblocking mode on file descriptor\n"); goto err_after_open; } s->get_error = fd_errno; s->write = fd_write; s->close = fd_close; s->mig_state.cancel = migrate_fd_cancel; s->mig_state.get_status = migrate_fd_get_status; s->mig_state.release = migrate_fd_release; s->mig_state.blk = blk; s->mig_state.shared = inc; s->state = MIG_STATE_ACTIVE; s->mon = NULL; s->bandwidth_limit = bandwidth_limit; if (!detach) { migrate_fd_monitor_suspend(s, mon); } migrate_fd_connect(s); return &s->mig_state; err_after_open: close(s->fd); err_after_alloc: qemu_free(s); return NULL; }
static void unix_wait_for_connect(int fd, void *opaque) { MigrationState *s = opaque; if (fd < 0) { DPRINTF("migrate connect error\n"); s->fd = -1; migrate_fd_error(s); } else { DPRINTF("migrate connect success\n"); s->fd = fd; qemu_set_block(s->fd); migrate_fd_connect(s); } }
static void tcp_wait_for_connect(void *opaque) { FdMigrationState *s = opaque; int ret; dprintf("connect completed\n"); ret = socket_get_error(s->fd); if (ret < 0) { dprintf("error connecting %d\n", val); migrate_fd_error(s); return; } qemu_set_fd_handler2(s->fd, NULL, NULL, NULL, NULL); migrate_fd_connect(s); }
MigrationState *unix_start_outgoing_migration(Monitor *mon, const char *path, int64_t bandwidth_limit, int detach, int blk, int inc) { FdMigrationState *s; struct sockaddr_un addr; int ret; addr.sun_family = AF_UNIX; snprintf(addr.sun_path, sizeof(addr.sun_path), "%s", path); s = g_malloc0(sizeof(*s)); s->get_error = unix_errno; s->write = unix_write; s->close = unix_close; s->mig_state.cancel = migrate_fd_cancel; s->mig_state.get_status = migrate_fd_get_status; s->mig_state.release = migrate_fd_release; s->mig_state.blk = blk; s->mig_state.shared = inc; s->state = MIG_STATE_ACTIVE; s->mon = NULL; s->bandwidth_limit = bandwidth_limit; s->fd = qemu_socket(PF_UNIX, SOCK_STREAM, 0); if (s->fd < 0) { DPRINTF("Unable to open socket"); goto err_after_alloc; } socket_set_nonblock(s->fd); do { ret = connect(s->fd, (struct sockaddr *)&addr, sizeof(addr)); if (ret == -1) ret = -(s->get_error(s)); if (ret == -EINPROGRESS || ret == -EWOULDBLOCK) qemu_set_fd_handler2(s->fd, NULL, NULL, unix_wait_for_connect, s); } while (ret == -EINTR); if (ret < 0 && ret != -EINPROGRESS && ret != -EWOULDBLOCK) { DPRINTF("connect failed\n"); goto err_after_open; } if (!detach) { migrate_fd_monitor_suspend(s, mon); } if (ret >= 0) migrate_fd_connect(s); return &s->mig_state; err_after_open: close(s->fd); err_after_alloc: g_free(s); return NULL; }