openkylin
/
libvirt
mirror of https://gitee.com/openkylin/libvirt.git
9
0
Fork 0
Code Issues Projects Releases Wiki Activity

qemu: add code for handling virtiofsd 

Start virtiofsd for each <filesystem> device using it.

Pre-create the socket for communication with QEMU and pass it
to virtiofsd.

Note that virtiofsd needs to run as root.

https://bugzilla.redhat.com/show_bug.cgi?id=1694166

Introduced by QEMU commit a43efa34c7d7b628cbf1ec0fe60043e5c91043ea

Signed-off-by: Ján Tomko <jtomko@redhat.com>
Reviewed-by: Peter Krempa <pkrempa@redhat.com>
Tested-by: Andrea Bolognani <abologna@redhat.com>
This commit is contained in:
Ján Tomko 2019-11-01 12:34:52 +01:00
parent 5c0444a38b
commit f0f986efa8
8 changed files with 376 additions and 3 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

1
po/POTFILES.in
View File

@ -172,6 +172,7 @@
@SRCDIR@/src/qemu/qemu_tpm.c
@SRCDIR@/src/qemu/qemu_vhost_user.c
@SRCDIR@/src/qemu/qemu_vhost_user_gpu.c
@SRCDIR@/src/qemu/qemu_virtiofs.c
@SRCDIR@/src/remote/remote_daemon.c
@SRCDIR@/src/remote/remote_daemon_config.c
@SRCDIR@/src/remote/remote_daemon_dispatch.c

2
src/qemu/Makefile.inc.am
View File

@ -67,6 +67,8 @@ QEMU_DRIVER_SOURCES = \
qemu/qemu_vhost_user.h \
qemu/qemu_vhost_user_gpu.c \
qemu/qemu_vhost_user_gpu.h \
qemu/qemu_virtiofs.c \
qemu/qemu_virtiofs.h \
qemu/qemu_checkpoint.c \
qemu/qemu_checkpoint.h \
qemu/qemu_backup.c \

5
src/qemu/qemu_domain.c
View File

@ -1433,8 +1433,11 @@ qemuDomainFSPrivateNew(void)
static void
qemuDomainFSPrivateDispose(void *obj G_GNUC_UNUSED)
qemuDomainFSPrivateDispose(void *obj)
{
qemuDomainFSPrivatePtr priv = obj;
g_free(priv->vhostuser_fs_sock);
}
static virClassPtr qemuDomainVideoPrivateClass;

2
src/qemu/qemu_domain.h
View File

@ -568,7 +568,7 @@ typedef qemuDomainFSPrivate *qemuDomainFSPrivatePtr;
struct _qemuDomainFSPrivate {
virObject parent;
int dummy;
char *vhostuser_fs_sock;
};

20
src/qemu/qemu_extdevice.c
View File

@ -20,11 +20,13 @@
#include <config.h>
#include "qemu_command.h"
#include "qemu_extdevice.h"
#include "qemu_vhost_user_gpu.h"
#include "qemu_domain.h"
#include "qemu_tpm.h"
#include "qemu_slirp.h"
#include "qemu_virtiofs.h"
#include "viralloc.h"
#include "virlog.h"
@ -153,7 +155,7 @@ qemuExtDevicesCleanupHost(virQEMUDriverPtr driver,
int
qemuExtDevicesStart(virQEMUDriverPtr driver,
virDomainObjPtr vm,
virLogManagerPtr logManager G_GNUC_UNUSED,
virLogManagerPtr logManager,
bool incomingMigration)
{
virDomainDefPtr def = vm->def;
@ -183,6 +185,15 @@ qemuExtDevicesStart(virQEMUDriverPtr driver,
return -1;
}
for (i = 0; i < def->nfss; i++) {
virDomainFSDefPtr fs = def->fss[i];
if (fs->fsdriver == VIR_DOMAIN_FS_DRIVER_TYPE_VIRTIOFS) {
if (qemuVirtioFSStart(logManager, driver, vm, fs) < 0)
return -1;
}
}
return 0;
}
@ -214,6 +225,13 @@ qemuExtDevicesStop(virQEMUDriverPtr driver,
if (slirp)
qemuSlirpStop(slirp, vm, driver, net, false);
}
for (i = 0; i < def->nfss; i++) {
virDomainFSDefPtr fs = def->fss[i];
if (fs->fsdriver == VIR_DOMAIN_FS_DRIVER_TYPE_VIRTIOFS)
qemuVirtioFSStop(driver, vm, fs);
}
}

301
src/qemu/qemu_virtiofs.c Normal file
View File

@ -0,0 +1,301 @@
/*
* qemu_virtiofs.c: virtiofs support
*
* This library is free software; you can redistribute it and/or
* modify it under the terms of the GNU Lesser General Public
* License as published by the Free Software Foundation; either
* version 2.1 of the License, or (at your option) any later version.
*
* This library is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public
* License along with this library. If not, see
* <http://www.gnu.org/licenses/>.
*/
#include <config.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
#include "logging/log_manager.h"
#include "virlog.h"
#include "qemu_command.h"
#include "qemu_conf.h"
#include "qemu_extdevice.h"
#include "qemu_security.h"
#include "qemu_virtiofs.h"
#include "virpidfile.h"
#include "virqemu.h"
#include "virutil.h"
#define VIR_FROM_THIS VIR_FROM_QEMU
char *
qemuVirtioFSCreatePidFilename(virDomainObjPtr vm,
const char *alias)
{
qemuDomainObjPrivatePtr priv = vm->privateData;
g_autofree char *shortName = NULL;
g_autofree char *name = NULL;
if (!(shortName = virDomainDefGetShortName(vm->def)))
return NULL;
name = g_strdup_printf("%s-%s-virtiofsd", shortName, alias);
return virPidFileBuildPath(priv->libDir, name);
}
char *
qemuVirtioFSCreateSocketFilename(virDomainObjPtr vm,
const char *alias)
{
qemuDomainObjPrivatePtr priv = vm->privateData;
return virFileBuildPath(priv->libDir, alias, "-virtiofsd.sock");
}
static char *
qemuVirtioFSCreateLogFilename(virQEMUDriverConfigPtr cfg,
const virDomainDef *def,
const char *alias)
{
g_autofree char *name = NULL;
name = g_strdup_printf("%s-%s", def->name, alias);
return virFileBuildPath(cfg->logDir, name, "-virtiofsd.log");
}
static int
qemuVirtioFSOpenChardev(virQEMUDriverPtr driver,
virDomainObjPtr vm,
const char *socket_path)
{
virDomainChrSourceDefPtr chrdev = virDomainChrSourceDefNew(NULL);
virDomainChrDef chr = { .source = chrdev };
VIR_AUTOCLOSE fd = -1;
int ret = -1;
chrdev->type = VIR_DOMAIN_CHR_TYPE_UNIX;
chrdev->data.nix.listen = true;
chrdev->data.nix.path = g_strdup(socket_path);
if (qemuSecuritySetDaemonSocketLabel(driver->securityManager, vm->def) < 0)
goto cleanup;
fd = qemuOpenChrChardevUNIXSocket(chrdev);
if (fd < 0) {
ignore_value(qemuSecurityClearSocketLabel(driver->securityManager, vm->def));
goto cleanup;
}
if (qemuSecurityClearSocketLabel(driver->securityManager, vm->def) < 0)
goto cleanup;
if (qemuSecuritySetChardevLabel(driver, vm, &chr) < 0)
goto cleanup;
ret = fd;
fd = -1;
cleanup:
virObjectUnref(chrdev);
return ret;
}
static virCommandPtr
qemuVirtioFSBuildCommandLine(virQEMUDriverConfigPtr cfg,
virDomainFSDefPtr fs,
int *fd)
{
g_autoptr(virCommand) cmd = NULL;
g_auto(virBuffer) opts = VIR_BUFFER_INITIALIZER;
if (!(cmd = virCommandNew(fs->binary)))
return NULL;
virCommandAddArgFormat(cmd, "--fd=%d", *fd);
virCommandPassFD(cmd, *fd, VIR_COMMAND_PASS_FD_CLOSE_PARENT);
*fd = -1;
virCommandAddArg(cmd, "-o");
virBufferAddLit(&opts, "source=");
virQEMUBuildBufferEscapeComma(&opts, fs->src->path);
if (fs->cache)
virBufferAsprintf(&opts, ",cache=%s", virDomainFSCacheModeTypeToString(fs->cache));
if (fs->xattr == VIR_TRISTATE_SWITCH_ON)
virBufferAddLit(&opts, ",xattr");
else if (fs->xattr == VIR_TRISTATE_SWITCH_OFF)
virBufferAddLit(&opts, ",no_xattr");
if (fs->flock == VIR_TRISTATE_SWITCH_ON)
virBufferAddLit(&opts, ",flock");
else if (fs->flock == VIR_TRISTATE_SWITCH_OFF)
virBufferAddLit(&opts, ",no_flock");
if (fs->posix_lock == VIR_TRISTATE_SWITCH_ON)
virBufferAddLit(&opts, ",posix_lock");
else if (fs->posix_lock == VIR_TRISTATE_SWITCH_OFF)
virBufferAddLit(&opts, ",no_posix_lock");
virCommandAddArgBuffer(cmd, &opts);
if (cfg->virtiofsdDebug)
virCommandAddArg(cmd, "-d");
return g_steal_pointer(&cmd);
}
int
qemuVirtioFSStart(virLogManagerPtr logManager,
virQEMUDriverPtr driver,
virDomainObjPtr vm,
virDomainFSDefPtr fs)
{
g_autoptr(virQEMUDriverConfig) cfg = virQEMUDriverGetConfig(driver);
g_autoptr(virCommand) cmd = NULL;
g_autofree char *socket_path = NULL;
g_autofree char *pidfile = NULL;
g_autofree char *logpath = NULL;
pid_t pid = (pid_t) -1;
VIR_AUTOCLOSE fd = -1;
VIR_AUTOCLOSE logfd = -1;
int ret = -1;
int rc;
if (!virFileExists(fs->src->path)) {
virReportError(VIR_ERR_INTERNAL_ERROR,
_("the virtiofs export directory '%s' does not exist"),
fs->src->path);
return -1;
}
if (!(pidfile = qemuVirtioFSCreatePidFilename(vm, fs->info.alias)))
goto cleanup;
if (!(socket_path = qemuVirtioFSCreateSocketFilename(vm, fs->info.alias)))
goto cleanup;
if ((fd = qemuVirtioFSOpenChardev(driver, vm, socket_path)) < 0)
goto cleanup;
logpath = qemuVirtioFSCreateLogFilename(cfg, vm->def, fs->info.alias);
if (cfg->stdioLogD) {
if ((logfd = virLogManagerDomainOpenLogFile(logManager,
"qemu",
vm->def->uuid,
vm->def->name,
logpath,
0,
NULL, NULL)) < 0)
goto cleanup;
} else {
if ((logfd = open(logpath, O_WRONLY | O_CREAT | O_APPEND, S_IRUSR | S_IWUSR)) < 0) {
virReportSystemError(errno, _("failed to create logfile %s"),
logpath);
goto cleanup;
}
if (virSetCloseExec(logfd) < 0) {
virReportSystemError(errno, _("failed to set close-on-exec flag on %s"),
logpath);
goto error;
}
}
if (!(cmd = qemuVirtioFSBuildCommandLine(cfg, fs, &fd)))
goto cleanup;
/* so far only running as root is supported */
virCommandSetUID(cmd, 0);
virCommandSetGID(cmd, 0);
virCommandSetPidFile(cmd, pidfile);
virCommandSetOutputFD(cmd, &logfd);
virCommandSetErrorFD(cmd, &logfd);
virCommandNonblockingFDs(cmd);
virCommandDaemonize(cmd);
if (qemuExtDeviceLogCommand(driver, vm, cmd, "virtiofsd") < 0)
goto cleanup;
rc = virCommandRun(cmd, NULL);
if (rc < 0) {
virReportError(VIR_ERR_INTERNAL_ERROR, "%s",
_("Could not start 'virtiofsd'"));
goto error;
}
rc = virPidFileReadPath(pidfile, &pid);
if (rc < 0) {
virReportSystemError(-rc,
_("Unable to read virtiofsd pidfile '%s'"),
pidfile);
goto error;
}
if (virProcessKill(pid, 0) != 0) {
virReportSystemError(errno, "%s",
_("virtiofsd died unexpectedly"));
goto error;
}
QEMU_DOMAIN_FS_PRIVATE(fs)->vhostuser_fs_sock = g_steal_pointer(&socket_path);
ret = 0;
cleanup:
if (socket_path)
unlink(socket_path);
return ret;
error:
if (pid != -1)
virProcessKillPainfully(pid, true);
if (pidfile)
unlink(pidfile);
goto cleanup;
}
void
qemuVirtioFSStop(virQEMUDriverPtr driver G_GNUC_UNUSED,
virDomainObjPtr vm,
virDomainFSDefPtr fs)
{
g_autofree char *pidfile = NULL;
virErrorPtr orig_err;
pid_t pid = -1;
int rc;
virErrorPreserveLast(&orig_err);
if (!(pidfile = qemuVirtioFSCreatePidFilename(vm, fs->info.alias)))
goto cleanup;
rc = virPidFileReadPathIfAlive(pidfile, &pid, NULL);
if (rc >= 0 && pid != (pid_t) -1)
virProcessKillPainfully(pid, true);
if (unlink(pidfile) < 0 &&
errno != ENOENT) {
virReportSystemError(errno,
_("Unable to remove stale pidfile %s"),
pidfile);
}
if (QEMU_DOMAIN_FS_PRIVATE(fs)->vhostuser_fs_sock)
unlink(QEMU_DOMAIN_FS_PRIVATE(fs)->vhostuser_fs_sock);
cleanup:
virErrorRestore(&orig_err);
}

37
src/qemu/qemu_virtiofs.h Normal file
View File

@ -0,0 +1,37 @@
/*
* qemu_virtiofs.h: virtiofs support
*
* This library is free software; you can redistribute it and/or
* modify it under the terms of the GNU Lesser General Public
* License as published by the Free Software Foundation; either
* version 2.1 of the License, or (at your option) any later version.
*
* This library is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public
* License along with this library. If not, see
* <http://www.gnu.org/licenses/>.
*/
#pragma once
char *
qemuVirtioFSCreatePidFilename(virDomainObjPtr vm,
const char *alias);
char *
qemuVirtioFSCreateSocketFilename(virDomainObjPtr vm,
const char *alias);
int
qemuVirtioFSStart(virLogManagerPtr logManager,
virQEMUDriverPtr driver,
virDomainObjPtr vm,
virDomainFSDefPtr fs);
void
qemuVirtioFSStop(virQEMUDriverPtr driver,
virDomainObjPtr vm,
virDomainFSDefPtr fs);

11
tests/qemuxml2argvtest.c
View File

@ -496,6 +496,17 @@ testCompareXMLToArgv(const void *data)
}
}
for (i = 0; i < vm->def->nfss; i++) {
virDomainFSDefPtr fs = vm->def->fss[i];
char *s;
if (fs->fsdriver != VIR_DOMAIN_FS_DRIVER_TYPE_VIRTIOFS)
continue;
s = g_strdup_printf("/tmp/lib/domain--1-guest/fs%zu.vhost-fs.sock", i);
QEMU_DOMAIN_FS_PRIVATE(fs)->vhostuser_fs_sock = s;
}
if (vm->def->vsock) {
virDomainVsockDefPtr vsock = vm->def->vsock;
qemuDomainVsockPrivatePtr vsockPriv =