void libxl__xc_domain_save(libxl__egc *egc, libxl__domain_save_state *dss,
libxl__save_helper_state *shs)
{
STATE_AO_GC(dss->ao);
unsigned cbflags =
libxl__srm_callout_enumcallbacks_save(&shs->callbacks.save.a);
const unsigned long argnums[] = {
dss->domid, dss->xcflags, dss->hvm, cbflags,
dss->checkpointed_stream,
};
shs->ao = ao;
shs->domid = dss->domid;
shs->recv_callback = libxl__srm_callout_received_save;
shs->completion_callback = libxl__xc_domain_save_done;
shs->caller_state = dss;
shs->need_results = 0;
run_helper(egc, shs, "--save-domain", dss->fd, dss->recv_fd,
NULL, 0,
argnums, ARRAY_SIZE(argnums));
return;
}
static int tuntap_open_tramp(char *gate, int *fd_out, int me, int remote,
char *buffer, int buffer_len, int *used_out)
{
struct tuntap_pre_exec_data data;
char version_buf[sizeof("nnnnn\0")];
char *argv[] = { "uml_net", version_buf, "tuntap", "up", gate,
NULL };
char buf[CMSG_SPACE(sizeof(*fd_out))];
struct msghdr msg;
struct cmsghdr *cmsg;
struct iovec iov;
int pid, n, err;
sprintf(version_buf, "%d", UML_NET_VERSION);
data.stdout = remote;
data.close_me = me;
pid = run_helper(tuntap_pre_exec, &data, argv);
if (pid < 0)
return -pid;
close(remote);
msg.msg_name = NULL;
msg.msg_namelen = 0;
if (buffer != NULL) {
iov = ((struct iovec) { buffer, buffer_len });
static int change_tramp(char **argv, char *output, int output_len)
{
int pid, fds[2], err;
struct change_pre_exec_data pe_data;
err = os_pipe(fds, 1, 0);
if (err < 0) {
printk(UM_KERN_ERR "change_tramp - pipe failed, err = %d\n",
-err);
return err;
}
pe_data.close_me = fds[0];
pe_data.stdout = fds[1];
pid = run_helper(change_pre_exec, &pe_data, argv);
if (pid > 0) /* Avoid hang as we won't get data in failure case. */
read_output(fds[0], output, output_len);
close(fds[0]);
close(fds[1]);
if (pid > 0)
helper_wait(pid);
return pid;
}
void libxl__xc_domain_restore(libxl__egc *egc, libxl__domain_create_state *dcs,
int hvm, int pae, int superpages,
int no_incr_generationid)
{
STATE_AO_GC(dcs->ao);
/* Convenience aliases */
const uint32_t domid = dcs->guest_domid;
const int restore_fd = dcs->restore_fd;
libxl__domain_build_state *const state = &dcs->build_state;
unsigned cbflags = libxl__srm_callout_enumcallbacks_restore
(&dcs->shs.callbacks.restore.a);
const unsigned long argnums[] = {
domid,
state->store_port,
state->store_domid, state->console_port,
state->console_domid,
hvm, pae, superpages, no_incr_generationid,
cbflags, dcs->checkpointed_stream,
};
dcs->shs.ao = ao;
dcs->shs.domid = domid;
dcs->shs.recv_callback = libxl__srm_callout_received_restore;
dcs->shs.completion_callback = libxl__xc_domain_restore_done;
dcs->shs.caller_state = dcs;
dcs->shs.need_results = 1;
dcs->shs.toolstack_data_file = 0;
run_helper(egc, &dcs->shs, "--restore-domain", restore_fd, 0,0,
argnums, ARRAY_SIZE(argnums));
}
void libxl__xc_domain_save(libxl__egc *egc, libxl__domain_suspend_state *dss,
unsigned long vm_generationid_addr)
{
STATE_AO_GC(dss->ao);
int r, rc, toolstack_data_fd = -1;
uint32_t toolstack_data_len = 0;
/* Resources we need to free */
uint8_t *toolstack_data_buf = 0;
unsigned cbflags = libxl__srm_callout_enumcallbacks_save
(&dss->shs.callbacks.save.a);
if (dss->shs.callbacks.save.toolstack_save) {
r = dss->shs.callbacks.save.toolstack_save
(dss->domid, &toolstack_data_buf, &toolstack_data_len, dss);
if (r) { rc = ERROR_FAIL; goto out; }
dss->shs.toolstack_data_file = tmpfile();
if (!dss->shs.toolstack_data_file) {
LOGE(ERROR, "cannot create toolstack data tmpfile");
rc = ERROR_FAIL;
goto out;
}
toolstack_data_fd = fileno(dss->shs.toolstack_data_file);
r = libxl_write_exactly(CTX, toolstack_data_fd,
toolstack_data_buf, toolstack_data_len,
"toolstack data tmpfile", 0);
if (r) { rc = ERROR_FAIL; goto out; }
}
const unsigned long argnums[] = {
dss->domid, 0, 0, dss->xcflags, dss->hvm, vm_generationid_addr,
toolstack_data_fd, toolstack_data_len,
cbflags,
};
dss->shs.ao = ao;
dss->shs.domid = dss->domid;
dss->shs.recv_callback = libxl__srm_callout_received_save;
dss->shs.completion_callback = libxl__xc_domain_save_done;
dss->shs.caller_state = dss;
dss->shs.need_results = 0;
free(toolstack_data_buf);
run_helper(egc, &dss->shs, "--save-domain", dss->fd,
&toolstack_data_fd, 1,
argnums, ARRAY_SIZE(argnums));
return;
out:
free(toolstack_data_buf);
if (dss->shs.toolstack_data_file) fclose(dss->shs.toolstack_data_file);
libxl__xc_domain_save_done(egc, dss, rc, 0, 0);
}
static int slip_tramp(char **argv, int fd)
{
struct slip_pre_exec_data pe_data;
char *output;
int status, pid, fds[2], err, output_len;
err = os_pipe(fds, 1, 0);
if(err < 0){
printk("slip_tramp : pipe failed, err = %d\n", -err);
goto out;
}
err = 0;
pe_data.stdin = fd;
pe_data.stdout = fds[1];
pe_data.close_me = fds[0];
err = run_helper(slip_pre_exec, &pe_data, argv, NULL);
if(err < 0)
goto out_close;
pid = err;
output_len = page_size();
output = um_kmalloc(output_len);
if(output == NULL){
printk("slip_tramp : failed to allocate output buffer\n");
os_kill_process(pid, 1);
err = -ENOMEM;
goto out_free;
}
os_close_file(fds[1]);
read_output(fds[0], output, output_len);
printk("%s", output);
CATCH_EINTR(err = waitpid(pid, &status, 0));
if(err < 0)
err = errno;
else if(!WIFEXITED(status) || (WEXITSTATUS(status) != 0)){
printk("'%s' didn't exit with status 0\n", argv[0]);
err = -EINVAL;
}
else err = 0;
os_close_file(fds[0]);
out_free:
kfree(output);
return err;
out_close:
os_close_file(fds[0]);
os_close_file(fds[1]);
out:
return err;
}
static int slirp_tramp(char **argv, int fd)
{
struct slirp_pre_exec_data pe_data;
int pid;
pe_data.stdin = fd;
pe_data.stdout = fd;
pid = run_helper(slirp_pre_exec, &pe_data, argv);
return pid;
}
bool smbcontrol_reconfigure(const char * daemon)
{
const char * smbcontrol_cmd[] =
{
"/usr/bin/smbcontrol",
NULL,
"reload-config",
NULL
};
smbcontrol_cmd[1] = daemon;
return run_helper(smbcontrol_cmd);
}
bool launchd_load_job(const LaunchService& svc)
{
const char * unload_cmd[] =
{
"/bin/launchctl",
"load",
"-w",
NULL,
NULL
};
unload_cmd[3] = svc.plist().c_str();
return run_helper(unload_cmd);
}
static int slip_tramp(char **argv, int fd)
{
struct slip_pre_exec_data pe_data;
char *output;
int pid, fds[2], err, output_len;
err = os_pipe(fds, 1, 0);
if (err < 0) {
printk(UM_KERN_ERR "slip_tramp : pipe failed, err = %d\n",
-err);
goto out;
}
err = 0;
pe_data.stdin = fd;
pe_data.stdout = fds[1];
pe_data.close_me = fds[0];
err = run_helper(slip_pre_exec, &pe_data, argv);
if (err < 0)
goto out_close;
pid = err;
output_len = UM_KERN_PAGE_SIZE;
output = kmalloc(output_len, UM_GFP_KERNEL);
if (output == NULL) {
printk(UM_KERN_ERR "slip_tramp : failed to allocate output "
"buffer\n");
os_kill_process(pid, 1);
err = -ENOMEM;
goto out_free;
}
close(fds[1]);
read_output(fds[0], output, output_len);
printk("%s", output);
err = helper_wait(pid, 0, argv[0]);
close(fds[0]);
out_free:
kfree(output);
return err;
out_close:
close(fds[0]);
close(fds[1]);
out:
return err;
}
static int etap_tramp(char *dev, char *gate, int control_me,
int control_remote, int data_me, int data_remote)
{
struct etap_pre_exec_data pe_data;
int pid, status, err, n;
char version_buf[sizeof("nnnnn\0")];
char data_fd_buf[sizeof("nnnnnn\0")];
char gate_buf[sizeof("nnn.nnn.nnn.nnn\0")];
char *setup_args[] = { "uml_net", version_buf, "ethertap", dev,
data_fd_buf, gate_buf, NULL };
char *nosetup_args[] = { "uml_net", version_buf, "ethertap",
dev, data_fd_buf, NULL };
char **args, c;
sprintf(data_fd_buf, "%d", data_remote);
sprintf(version_buf, "%d", UML_NET_VERSION);
if(gate != NULL){
strcpy(gate_buf, gate);
args = setup_args;
}
else args = nosetup_args;
err = 0;
pe_data.control_remote = control_remote;
pe_data.control_me = control_me;
pe_data.data_me = data_me;
pid = run_helper(etap_pre_exec, &pe_data, args, NULL);
if(pid < 0) err = pid;
os_close_file(data_remote);
os_close_file(control_remote);
n = os_read_file(control_me, &c, sizeof(c));
if(n != sizeof(c)){
printk("etap_tramp : read of status failed, err = %d\n", -n);
return(-EINVAL);
}
if(c != 1){
printk("etap_tramp : uml_net failed\n");
err = -EINVAL;
CATCH_EINTR(n = waitpid(pid, &status, 0));
if(n < 0)
err = -errno;
else if(!WIFEXITED(status) || (WEXITSTATUS(status) != 1))
printk("uml_net didn't exit with status 1\n");
}
return(err);
}
static int etap_tramp(char *dev, char *gate, int control_me,
int control_remote, int data_me, int data_remote)
{
struct etap_pre_exec_data pe_data;
int pid, err, n;
char version_buf[sizeof("nnnnn\0")];
char data_fd_buf[sizeof("nnnnnn\0")];
char gate_buf[sizeof("nnn.nnn.nnn.nnn\0")];
char *setup_args[] = { "uml_net", version_buf, "ethertap", dev,
data_fd_buf, gate_buf, NULL };
char *nosetup_args[] = { "uml_net", version_buf, "ethertap",
dev, data_fd_buf, NULL };
char **args, c;
sprintf(data_fd_buf, "%d", data_remote);
sprintf(version_buf, "%d", UML_NET_VERSION);
if (gate != NULL) {
strcpy(gate_buf, gate);
args = setup_args;
}
else args = nosetup_args;
err = 0;
pe_data.control_remote = control_remote;
pe_data.control_me = control_me;
pe_data.data_me = data_me;
pid = run_helper(etap_pre_exec, &pe_data, args);
if (pid < 0)
err = pid;
close(data_remote);
close(control_remote);
CATCH_EINTR(n = read(control_me, &c, sizeof(c)));
if (n != sizeof(c)) {
err = -errno;
printk(UM_KERN_ERR "etap_tramp : read of status failed, "
"err = %d\n", -err);
return err;
}
if (c != 1) {
printk(UM_KERN_ERR "etap_tramp : uml_net failed\n");
err = helper_wait(pid);
}
return err;
}
static int change_tramp(char **argv, char *output, int output_len)
{
int pid, fds[2], err;
struct change_pre_exec_data pe_data;
err = os_pipe(fds, 1, 0);
if(err){
printk("change_tramp - pipe failed, errno = %d\n", -err);
return(err);
}
pe_data.close_me = fds[0];
pe_data.stdout = fds[1];
pid = run_helper(change_pre_exec, &pe_data, argv, NULL);
close(fds[1]);
read_output(fds[0], output, output_len);
waitpid(pid, NULL, 0);
return(pid);
}
int run_tests() {
int entry;
int result;
task_entry_t* task;
fprintf(stderr, "Run Helpers...\r\n");
entry = 0;
while (HELPERS[entry].task_name) {
task = &HELPERS[entry];
fprintf(stderr, "[%-30s]...", task->task_name);
result = run_helper(task);
fprintf(stderr, "%s\r\n", result ? "failed" : "OK");
entry++;
}
entry = 0;
while (TASKS[entry].task_name) {
task = &TASKS[entry];
fprintf(stderr, "[%-30s]...", task->task_name);
result = run_test_one(task);
fprintf(stderr, "%s\r\n", result ? "failed" : "OK");
entry++;
}
fprintf(stderr, "Waiting Helpers to end...\r\n");
entry = 0;
while (HELPERS[entry].task_name) {
task = &HELPERS[entry];
fprintf(stderr, "[%-30s]...", task->task_name);
result = wait_helper(task);
fprintf(stderr, "%s\r\n", result ? "failed" : "OK");
entry++;
}
fprintf(stderr, "run_tests end\r\n");
return 0;
}
static int slip_tramp(char **argv, int fd)
{
struct slip_pre_exec_data pe_data;
char *output;
int status, pid, fds[2], err, output_len;
err = os_pipe(fds, 1, 0);
if(err){
printk("slip_tramp : pipe failed, errno = %d\n", -err);
return(err);
}
err = 0;
pe_data.stdin = fd;
pe_data.stdout = fds[1];
pe_data.close_me = fds[0];
pid = run_helper(slip_pre_exec, &pe_data, argv, NULL);
if(pid < 0) err = pid;
else {
output_len = page_size();
output = um_kmalloc(output_len);
if(output == NULL)
printk("slip_tramp : failed to allocate output "
"buffer\n");
close(fds[1]);
read_output(fds[0], output, output_len);
if(output != NULL){
printk("%s", output);
kfree(output);
}
if(waitpid(pid, &status, 0) < 0) err = errno;
else if(!WIFEXITED(status) || (WEXITSTATUS(status) != 0)){
printk("'%s' didn't exit with status 0\n", argv[0]);
err = EINVAL;
}
}
return(err);
}
void run_tests_one(void) {
task_entry_t* task_group = NULL;
task_entry_t* task = NULL;
while (1) {
switch (cur_task) {
case 0 :
if (!cur_entry)
fprintf(stderr, "Run Helpers...\r\n");
task_group = HELPERS;
break;
case 2 :
if (!cur_entry)
fprintf(stderr, "Stopping Helpers...\r\n");
task_group = HELPERS;
break;
case 1 :
task_group = TASKS;
break;
default:
run_test_one(NULL);
return;
}
task = &task_group[cur_entry];
if (task && task->task_name) {
fprintf(stderr, "[%-30s]\r\n", task->task_name);
switch (cur_task) {
case 0 : run_helper(task); break;
case 1 : run_test_one(task); break;
case 2 : wait_helper(task); break;
}
cur_entry++;
return;
}
cur_entry = 0;
cur_task++;
}
}
void libxl__xc_domain_restore(libxl__egc *egc, libxl__domain_create_state *dcs,
libxl__save_helper_state *shs,
int hvm, int pae)
{
STATE_AO_GC(dcs->ao);
/* Convenience aliases */
const uint32_t domid = dcs->guest_domid;
const int restore_fd = dcs->libxc_fd;
const int send_back_fd = dcs->send_back_fd;
libxl__domain_build_state *const state = &dcs->build_state;
unsigned cbflags =
libxl__srm_callout_enumcallbacks_restore(&shs->callbacks.restore.a);
const unsigned long argnums[] = {
domid,
state->store_port,
state->store_domid, state->console_port,
state->console_domid,
hvm, pae,
cbflags, dcs->restore_params.checkpointed_stream,
};
shs->ao = ao;
shs->domid = domid;
shs->recv_callback = libxl__srm_callout_received_restore;
if (dcs->restore_params.checkpointed_stream ==
LIBXL_CHECKPOINTED_STREAM_COLO)
shs->completion_callback = libxl__colo_restore_teardown;
else
shs->completion_callback = libxl__xc_domain_restore_done;
shs->caller_state = dcs;
shs->need_results = 1;
run_helper(egc, shs, "--restore-domain", restore_fd, send_back_fd, 0, 0,
argnums, ARRAY_SIZE(argnums));
}
int start_watchdog(int *in_fd_ret, int *out_fd_ret, char *sock)
{
struct dog_data data;
int in_fds[2], out_fds[2], pid, n, err;
char pid_buf[sizeof("nnnnn\0")], c;
char *pid_args[] = { "/usr/bin/uml_watchdog", "-pid", pid_buf, NULL };
char *mconsole_args[] = { "/usr/bin/uml_watchdog", "-mconsole", NULL,
NULL };
char **args = NULL;
err = os_pipe(in_fds, 1, 0);
if (err < 0) {
printk("harddog_open - os_pipe failed, err = %d\n", -err);
goto out;
}
err = os_pipe(out_fds, 1, 0);
if (err < 0) {
printk("harddog_open - os_pipe failed, err = %d\n", -err);
goto out_close_in;
}
data.stdin = out_fds[0];
data.stdout = in_fds[1];
data.close_me[0] = out_fds[1];
data.close_me[1] = in_fds[0];
if (sock != NULL) {
mconsole_args[2] = sock;
args = mconsole_args;
}
else {
/* XXX The os_getpid() is not SMP correct */
sprintf(pid_buf, "%d", os_getpid());
args = pid_args;
}
pid = run_helper(pre_exec, &data, args);
close(out_fds[0]);
close(in_fds[1]);
if (pid < 0) {
err = -pid;
printk("harddog_open - run_helper failed, errno = %d\n", -err);
goto out_close_out;
}
n = read(in_fds[0], &c, sizeof(c));
if (n == 0) {
printk("harddog_open - EOF on watchdog pipe\n");
helper_wait(pid);
err = -EIO;
goto out_close_out;
}
else if (n < 0) {
printk("harddog_open - read of watchdog pipe failed, "
"err = %d\n", errno);
helper_wait(pid);
err = n;
goto out_close_out;
}
*in_fd_ret = in_fds[0];
*out_fd_ret = out_fds[1];
return 0;
out_close_in:
close(in_fds[0]);
close(in_fds[1]);
out_close_out:
close(out_fds[0]);
close(out_fds[1]);
out:
return err;
}
