virCommandAddArgFormat(cmd, "--use-vnet");
virCommandAddArgFormat(cmd, "--br=%s", brname);
virCommandAddArgFormat(cmd, "--fd=%d", pair[1]);
- virCommandTransferFD(cmd, pair[1]);
+ virCommandPassFD(cmd, pair[1],
+ VIR_COMMAND_PASS_FD_CLOSE_PARENT);
virCommandClearCaps(cmd);
#ifdef CAP_NET_ADMIN
virCommandAllowCap(cmd, CAP_NET_ADMIN);
}
for (i = 0; i < tapfdSize; i++) {
- virCommandTransferFD(cmd, tapfd[i]);
+ virCommandPassFD(cmd, tapfd[i],
+ VIR_COMMAND_PASS_FD_CLOSE_PARENT);
if (virAsprintf(&tapfdName[i], "%d", tapfd[i]) < 0)
goto cleanup;
}
for (i = 0; i < vhostfdSize; i++) {
- virCommandTransferFD(cmd, vhostfd[i]);
+ virCommandPassFD(cmd, vhostfd[i],
+ VIR_COMMAND_PASS_FD_CLOSE_PARENT);
if (virAsprintf(&vhostfdName[i], "%d", vhostfd[i]) < 0)
goto cleanup;
}
goto error;
}
- virCommandTransferFD(cmd, configfd);
+ virCommandPassFD(cmd, configfd,
+ VIR_COMMAND_PASS_FD_CLOSE_PARENT);
}
}
virCommandAddArg(cmd, "-device");
} else if (STREQ(migrateFrom, "stdio")) {
if (virQEMUCapsGet(qemuCaps, QEMU_CAPS_MIGRATE_QEMU_FD)) {
virCommandAddArgFormat(cmd, "fd:%d", migrateFd);
- virCommandPreserveFD(cmd, migrateFd);
+ virCommandPassFD(cmd, migrateFd, 0);
} else if (virQEMUCapsGet(qemuCaps, QEMU_CAPS_MIGRATE_QEMU_EXEC)) {
virCommandAddArg(cmd, "exec:cat");
virCommandSetInputFD(cmd, migrateFd);
goto error;
}
virCommandAddArg(cmd, migrateFrom);
- virCommandPreserveFD(cmd, migrateFd);
+ virCommandPassFD(cmd, migrateFd, 0);
} else if (STRPREFIX(migrateFrom, "unix")) {
if (!virQEMUCapsGet(qemuCaps, QEMU_CAPS_MIGRATE_QEMU_UNIX)) {
virReportError(VIR_ERR_CONFIG_UNSUPPORTED,
VIR_EXEC_ASYNC_IO = (1 << 4),
};
+typedef struct _virCommandFD virCommandFD;
+typedef virCommandFD *virCommandFDPtr;
+
+struct _virCommandFD {
+ int fd;
+ unsigned int flags;
+};
+
struct _virCommand {
int has_error; /* ENOMEM on allocation failure, -1 for anything else. */
char *pwd;
- int *preserve; /* FDs to pass to child. */
- int preserve_size;
- int *transfer; /* FDs to close in parent. */
- int transfer_size;
+ size_t npassfd;
+ virCommandFDPtr passfd;
unsigned int flags;
* false otherwise.
*/
static bool
-virCommandFDIsSet(int fd,
- const int *set,
- int set_size)
+virCommandFDIsSet(virCommandPtr cmd,
+ int fd)
{
size_t i = 0;
+ if (!cmd)
+ return false;
- while (i < set_size)
- if (set[i++] == fd)
+ while (i < cmd->npassfd)
+ if (cmd->passfd[i++].fd == fd)
return true;
return false;
* ENOMEM on OOM
*/
static int
-virCommandFDSet(int fd,
- int **set,
- int *set_size)
+virCommandFDSet(virCommandPtr cmd,
+ int fd,
+ unsigned int flags)
{
- if (fd < 0 || !set || !set_size)
+ if (!cmd || fd < 0)
return -1;
- if (virCommandFDIsSet(fd, *set, *set_size))
+ if (virCommandFDIsSet(cmd, fd))
return 0;
- if (VIR_REALLOC_N(*set, *set_size + 1) < 0) {
+ if (VIR_EXPAND_N(cmd->passfd, cmd->npassfd, 1) < 0)
return ENOMEM;
- }
- (*set)[*set_size] = fd;
- (*set_size)++;
+ cmd->passfd[cmd->npassfd - 1].fd = fd;
+ cmd->passfd[cmd->npassfd - 1].flags = flags;
return 0;
}
for (fd = 3; fd < openmax; fd++) {
if (fd == childin || fd == childout || fd == childerr)
continue;
- if (!cmd->preserve ||
- !virCommandFDIsSet(fd, cmd->preserve, cmd->preserve_size)) {
+ if (!virCommandFDIsSet(cmd, fd)) {
tmpfd = fd;
VIR_MASS_CLOSE(tmpfd);
} else if (virSetInherit(fd, true) < 0) {
}
-/*
- * Preserve the specified file descriptor in the child, instead of
- * closing it. FD must not be one of the three standard streams. If
- * transfer is true, then fd will be closed in the parent after a call
- * to Run/RunAsync/Free, otherwise caller is still responsible for fd.
- * Returns true if a transferring caller should close FD now, and
- * false if the transfer is successfully recorded.
- */
-static bool
-virCommandKeepFD(virCommandPtr cmd, int fd, bool transfer)
-{
- int ret = 0;
-
- if (!cmd)
- return fd > STDERR_FILENO;
-
- if (fd <= STDERR_FILENO ||
- (ret = virCommandFDSet(fd, &cmd->preserve, &cmd->preserve_size)) ||
- (transfer && (ret = virCommandFDSet(fd, &cmd->transfer,
- &cmd->transfer_size)))) {
- if (!cmd->has_error)
- cmd->has_error = ret ? ret : -1;
- VIR_DEBUG("cannot preserve %d", fd);
- return fd > STDERR_FILENO;
- }
-
- return false;
-}
-
-/**
- * virCommandPreserveFD:
- * @cmd: the command to modify
- * @fd: fd to mark for inheritance into child
- *
- * Preserve the specified file descriptor
- * in the child, instead of closing it on exec.
- * The parent is still responsible for managing fd.
- */
-void
-virCommandPreserveFD(virCommandPtr cmd, int fd)
-{
- virCommandKeepFD(cmd, fd, false);
-}
+#define VIR_COMMAND_MAYBE_CLOSE_FD(fd, flags) \
+ if ((fd > STDERR_FILENO) && \
+ (flags & VIR_COMMAND_PASS_FD_CLOSE_PARENT)) \
+ VIR_FORCE_CLOSE(fd)
/**
- * virCommandTransferFD:
+ * virCommandPassFD:
* @cmd: the command to modify
* @fd: fd to reassign to the child
+ * @flags: the flags
*
- * Transfer the specified file descriptor
- * to the child, instead of closing it on exec.
- * The parent should no longer use fd, and the parent's copy will
- * be automatically closed no later than during Run/RunAsync/Free.
+ * Transfer the specified file descriptor to the child, instead
+ * of closing it on exec. @fd must not be one of the three
+ * standard streams.
+ *
+ * If the flag VIR_COMMAND_PASS_FD_CLOSE_PARENT is set then fd will
+ * be closed in the parent no later than Run/RunAsync/Free. The parent
+ * should cease using the @fd when this call completes
*/
void
-virCommandTransferFD(virCommandPtr cmd, int fd)
+virCommandPassFD(virCommandPtr cmd, int fd, unsigned int flags)
{
- if (virCommandKeepFD(cmd, fd, true))
- VIR_FORCE_CLOSE(fd);
-}
+ int ret = 0;
+
+ if (!cmd) {
+ VIR_COMMAND_MAYBE_CLOSE_FD(fd, flags);
+ return;
+ }
+
+ if (fd <= STDERR_FILENO) {
+ VIR_DEBUG("invalid fd %d", fd);
+ VIR_COMMAND_MAYBE_CLOSE_FD(fd, flags);
+ if (!cmd->has_error)
+ cmd->has_error = -1;
+ return;
+ }
+ if ((ret = virCommandFDSet(cmd, fd, flags)) != 0) {
+ if (!cmd->has_error)
+ cmd->has_error = ret;
+ VIR_DEBUG("cannot preserve %d", fd);
+ VIR_COMMAND_MAYBE_CLOSE_FD(fd, flags);
+ return;
+ }
+}
/**
* virCommandSetPidFile:
VIR_DEBUG("Command result %d, with PID %d",
ret, (int)cmd->pid);
- for (i = 0; i < cmd->transfer_size; i++) {
- VIR_FORCE_CLOSE(cmd->transfer[i]);
+ for (i = 0; i < cmd->npassfd; i++) {
+ if (cmd->passfd[i].flags & VIR_COMMAND_PASS_FD_CLOSE_PARENT)
+ VIR_FORCE_CLOSE(cmd->passfd[i].fd);
}
- cmd->transfer_size = 0;
- VIR_FREE(cmd->transfer);
+ cmd->npassfd = 0;
+ VIR_FREE(cmd->passfd);
if (ret == 0 && pid)
*pid = cmd->pid;
"keep handshake wait=%d notify=%d",
cmd->handshakeWait[1], cmd->handshakeNotify[0],
cmd->handshakeWait[0], cmd->handshakeNotify[1]);
- virCommandTransferFD(cmd, cmd->handshakeWait[1]);
- virCommandTransferFD(cmd, cmd->handshakeNotify[0]);
+ virCommandPassFD(cmd, cmd->handshakeWait[1],
+ VIR_COMMAND_PASS_FD_CLOSE_PARENT);
+ virCommandPassFD(cmd, cmd->handshakeNotify[0],
+ VIR_COMMAND_PASS_FD_CLOSE_PARENT);
cmd->handshake = true;
}
if (!cmd)
return;
- for (i = 0; i < cmd->transfer_size; i++) {
- VIR_FORCE_CLOSE(cmd->transfer[i]);
+ for (i = 0; i < cmd->npassfd; i++) {
+ if (cmd->passfd[i].flags & VIR_COMMAND_PASS_FD_CLOSE_PARENT)
+ VIR_FORCE_CLOSE(cmd->passfd[i].fd);
}
+ cmd->npassfd = 0;
+ VIR_FREE(cmd->passfd);
if (cmd->asyncioThread) {
virThreadJoin(cmd->asyncioThread);
if (cmd->handshake) {
/* The other 2 fds in these arrays are closed
- * due to use with virCommandTransferFD
+ * due to use with virCommandPassFD
*/
VIR_FORCE_CLOSE(cmd->handshakeWait[0]);
VIR_FORCE_CLOSE(cmd->handshakeNotify[1]);
if (cmd->reap)
virCommandAbort(cmd);
- VIR_FREE(cmd->transfer);
- VIR_FREE(cmd->preserve);
#if defined(WITH_SECDRIVER_SELINUX)
VIR_FREE(cmd->seLinuxLabel);
#endif
projects / libvirt.git / commitdiff