static int setup_xenconsoled_pty(libxl__egc *egc, libxl__bootloader_state *bl,
char *slave_path, size_t slave_path_len)
{
STATE_AO_GC(bl->ao);
struct termios termattr;
int r, rc;
int slave = libxl__carefd_fd(bl->ptys[1].slave);
int master = libxl__carefd_fd(bl->ptys[1].master);
r = ttyname_r(slave, slave_path, slave_path_len);
if (r == -1) {
LOGE(ERROR,"ttyname_r failed");
rc = ERROR_FAIL;
goto out;
}
/*
* On Solaris, the pty master side will get cranky if we try
* to write to it while there is no slave. To work around this,
* keep the slave descriptor open until we're done. Set it
* to raw terminal parameters, otherwise it will echo back
* characters, which will confuse the I/O loop below.
* Furthermore, a raw master pty device has no terminal
* semantics on Solaris, so don't try to set any attributes
* for it.
*/
tcgetattr(master, &termattr);
cfmakeraw(&termattr);
tcsetattr(master, TCSANOW, &termattr);
return 0;
out:
return rc;
}
void libxl__stream_read_start(libxl__egc *egc,
libxl__stream_read_state *stream)
{
libxl__datacopier_state *dc = &stream->dc;
STATE_AO_GC(stream->ao);
int rc = 0;
libxl__stream_read_init(stream);
stream->running = true;
stream->phase = SRS_PHASE_NORMAL;
if (stream->legacy) {
/* Convert the legacy stream. */
libxl__conversion_helper_state *chs = &stream->chs;
chs->legacy_fd = stream->fd;
chs->hvm =
(stream->dcs->guest_config->b_info.type == LIBXL_DOMAIN_TYPE_HVM);
chs->completion_callback = conversion_done;
rc = libxl__convert_legacy_stream(egc, &stream->chs);
if (rc) {
LOG(ERROR, "Failed to start the legacy stream conversion helper");
goto err;
}
assert(stream->chs.v2_carefd);
stream->fd = libxl__carefd_fd(stream->chs.v2_carefd);
stream->dcs->libxc_fd = stream->fd;
}
/* stream->fd is now a v2 stream. */
dc->ao = stream->ao;
dc->copywhat = "restore v2 stream";
dc->readfd = stream->fd;
dc->writefd = -1;
/* Start reading the stream header. */
rc = setup_read(stream, "stream header",
&stream->hdr, sizeof(stream->hdr),
stream_header_done);
if (rc)
goto err;
assert(!rc);
return;
err:
assert(rc);
stream_complete(egc, stream, rc);
}
void libxl__srm_callout_sendreply(int r, void *user)
{
libxl__save_helper_state *shs = user;
libxl__egc *egc = shs->egc;
STATE_AO_GC(shs->ao);
int errnoval;
errnoval = libxl_write_exactly(CTX, libxl__carefd_fd(shs->pipes[0]),
&r, sizeof(r), shs->stdin_what,
"callback return value");
if (errnoval)
helper_failed(egc, shs, ERROR_FAIL);
}
static void bootloader_gotptys(libxl__egc *egc, libxl__openpty_state *op)
{
libxl__bootloader_state *bl = CONTAINER_OF(op, *bl, openpty);
STATE_AO_GC(bl->ao);
int rc, r;
char *const env[] = { "TERM", "vt100", NULL };
if (bl->openpty.rc) {
rc = bl->openpty.rc;
goto out;
}
/*
* We need to present the bootloader's tty as a pty slave that xenconsole
* can access. Since the bootloader itself needs a pty slave,
* we end up with a connection like this:
*
* xenconsole -- (slave pty1 master) <-> (master pty2 slave) -- bootloader
*
* where we copy characters between the two master fds, as well as
* listening on the bootloader's fifo for the results.
*/
char *dom_console_xs_path;
char dom_console_slave_tty_path[PATH_MAX];
rc = setup_xenconsoled_pty(egc, bl,
&dom_console_slave_tty_path[0],
sizeof(dom_console_slave_tty_path));
if (rc) goto out;
char *dompath = libxl__xs_get_dompath(gc, bl->domid);
if (!dompath) {
rc = ERROR_FAIL;
goto out;
}
dom_console_xs_path = GCSPRINTF("%s/console/tty", dompath);
rc = libxl__xs_write(gc, XBT_NULL, dom_console_xs_path, "%s",
dom_console_slave_tty_path);
if (rc) {
LOGE(ERROR,"xs write console path %s := %s failed",
dom_console_xs_path, dom_console_slave_tty_path);
rc = ERROR_FAIL;
goto out;
}
bl->deathcheck.what = "stopping bootloader";
bl->deathcheck.domid = bl->domid;
bl->deathcheck.callback = bootloader_domaindeath;
rc = libxl__domaindeathcheck_start(gc, &bl->deathcheck);
if (rc) goto out;
if (bl->console_available)
bl->console_available(egc, bl);
int bootloader_master = libxl__carefd_fd(bl->ptys[0].master);
int xenconsole_master = libxl__carefd_fd(bl->ptys[1].master);
libxl_fd_set_nonblock(CTX, bootloader_master, 1);
libxl_fd_set_nonblock(CTX, xenconsole_master, 1);
bl->keystrokes.writefd = bl->display.readfd = bootloader_master;
bl->keystrokes.writewhat = bl->display.readwhat = "bootloader pty";
bl->keystrokes.readfd = bl->display.writefd = xenconsole_master;
bl->keystrokes.readwhat = bl->display.writewhat = "xenconsole client pty";
bl->keystrokes.ao = ao;
bl->keystrokes.maxsz = BOOTLOADER_BUF_OUT;
bl->keystrokes.copywhat =
GCSPRINTF("bootloader input for domain %"PRIu32, bl->domid);
bl->keystrokes.callback = bootloader_keystrokes_copyfail;
bl->keystrokes.callback_pollhup = bootloader_keystrokes_copyfail;
/* pollhup gets called with errnoval==-1 which is not otherwise
* possible since errnos are nonnegative, so it's unambiguous */
rc = libxl__datacopier_start(&bl->keystrokes);
if (rc) goto out;
bl->display.ao = ao;
bl->display.maxsz = BOOTLOADER_BUF_IN;
bl->display.copywhat =
GCSPRINTF("bootloader output for domain %"PRIu32, bl->domid);
bl->display.callback = bootloader_display_copyfail;
bl->display.callback_pollhup = bootloader_display_copyfail;
rc = libxl__datacopier_start(&bl->display);
if (rc) goto out;
LOG(DEBUG, "executing bootloader: %s", bl->args[0]);
for (const char **blarg = bl->args;
*blarg;
blarg++)
LOG(DEBUG, " bootloader arg: %s", *blarg);
struct termios termattr;
pid_t pid = libxl__ev_child_fork(gc, &bl->child, bootloader_finished);
if (pid == -1) {
rc = ERROR_FAIL;
goto out;
}
if (!pid) {
/* child */
r = login_tty(libxl__carefd_fd(bl->ptys[0].slave));
if (r) {
LOGE(ERROR, "login_tty failed");
exit(-1);
}
libxl__exec(gc, -1, -1, -1, bl->args[0], (char **) bl->args, env);
exit(-1);
}
/* parent */
/*
* On Solaris, the master pty side does not have terminal semantics,
* so don't try to set any attributes, as it will fail.
*/
#if !defined(__sun__)
tcgetattr(bootloader_master, &termattr);
cfmakeraw(&termattr);
tcsetattr(bootloader_master, TCSANOW, &termattr);
#endif
return;
out:
bootloader_callback(egc, bl, rc);
}
static void run_helper(libxl__egc *egc, libxl__save_helper_state *shs,
const char *mode_arg, int stream_fd,
const int *preserve_fds, int num_preserve_fds,
const unsigned long *argnums, int num_argnums)
{
STATE_AO_GC(shs->ao);
const char *args[4 + num_argnums];
const char **arg = args;
int i, rc;
/* Resources we must free */
libxl__carefd *childs_pipes[2] = { 0,0 };
/* Convenience aliases */
const uint32_t domid = shs->domid;
shs->rc = 0;
shs->completed = 0;
shs->pipes[0] = shs->pipes[1] = 0;
libxl__ev_fd_init(&shs->readable);
libxl__ev_child_init(&shs->child);
shs->stdin_what = GCSPRINTF("domain %"PRIu32" save/restore helper"
" stdin pipe", domid);
shs->stdout_what = GCSPRINTF("domain %"PRIu32" save/restore helper"
" stdout pipe", domid);
*arg++ = getenv("LIBXL_SAVE_HELPER") ?: PRIVATE_BINDIR "/" "libxl-save-helper";
*arg++ = mode_arg;
const char **stream_fd_arg = arg++;
for (i=0; i<num_argnums; i++)
*arg++ = GCSPRINTF("%lu", argnums[i]);
*arg++ = 0;
assert(arg == args + ARRAY_SIZE(args));
libxl__carefd_begin();
int childfd;
for (childfd=0; childfd<2; childfd++) {
/* Setting up the pipe for the child's fd childfd */
int fds[2];
if (libxl_pipe(CTX,fds)) {
rc = ERROR_FAIL;
libxl__carefd_unlock();
goto out;
}
int childs_end = childfd==0 ? 0 /*read*/ : 1 /*write*/;
int our_end = childfd==0 ? 1 /*write*/ : 0 /*read*/;
childs_pipes[childfd] = libxl__carefd_record(CTX, fds[childs_end]);
shs->pipes[childfd] = libxl__carefd_record(CTX, fds[our_end]);
}
libxl__carefd_unlock();
pid_t pid = libxl__ev_child_fork(gc, &shs->child, helper_exited);
if (!pid) {
if (stream_fd <= 2) {
stream_fd = dup(stream_fd);
if (stream_fd < 0) {
LOGE(ERROR,"dup migration stream fd");
exit(-1);
}
}
libxl_fd_set_cloexec(CTX, stream_fd, 0);
*stream_fd_arg = GCSPRINTF("%d", stream_fd);
for (i=0; i<num_preserve_fds; i++)
if (preserve_fds[i] >= 0) {
assert(preserve_fds[i] > 2);
libxl_fd_set_cloexec(CTX, preserve_fds[i], 0);
}
libxl__exec(gc,
libxl__carefd_fd(childs_pipes[0]),
libxl__carefd_fd(childs_pipes[1]),
-1,
args[0], (char**)args, 0);
}
libxl__carefd_close(childs_pipes[0]);
libxl__carefd_close(childs_pipes[1]);
rc = libxl__ev_fd_register(gc, &shs->readable, helper_stdout_readable,
libxl__carefd_fd(shs->pipes[1]), POLLIN|POLLPRI);
if (rc) goto out;
return;
out:
libxl__carefd_close(childs_pipes[0]);
libxl__carefd_close(childs_pipes[1]);
helper_failed(egc, shs, rc);;
}