2007-02-14 01:40:09 +00:00
|
|
|
/*
|
2009-05-21 14:16:55 +00:00
|
|
|
* qemu_conf.c: QEMU configuration management
|
2007-02-14 01:40:09 +00:00
|
|
|
*
|
2012-06-18 08:22:07 +00:00
|
|
|
* Copyright (C) 2006-2012 Red Hat, Inc.
|
2007-02-14 01:40:09 +00:00
|
|
|
* Copyright (C) 2006 Daniel P. Berrange
|
|
|
|
*
|
|
|
|
* 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
|
2012-09-20 22:30:55 +00:00
|
|
|
* License along with this library. If not, see
|
2012-07-21 10:06:23 +00:00
|
|
|
* <http://www.gnu.org/licenses/>.
|
2007-02-14 01:40:09 +00:00
|
|
|
*
|
|
|
|
* Author: Daniel P. Berrange <berrange@redhat.com>
|
|
|
|
*/
|
|
|
|
|
2008-01-29 18:15:54 +00:00
|
|
|
#include <config.h>
|
2007-11-26 11:50:16 +00:00
|
|
|
|
2007-02-14 01:40:09 +00:00
|
|
|
#include <string.h>
|
|
|
|
#include <limits.h>
|
|
|
|
#include <sys/types.h>
|
|
|
|
#include <sys/stat.h>
|
2008-10-10 16:52:20 +00:00
|
|
|
#include <stdlib.h>
|
2007-02-14 01:40:09 +00:00
|
|
|
#include <unistd.h>
|
|
|
|
#include <errno.h>
|
|
|
|
#include <fcntl.h>
|
2007-02-23 17:15:18 +00:00
|
|
|
#include <sys/wait.h>
|
2007-04-10 23:17:46 +00:00
|
|
|
#include <arpa/inet.h>
|
2007-02-14 01:40:09 +00:00
|
|
|
|
2008-11-04 22:30:33 +00:00
|
|
|
#include "virterror_internal.h"
|
2007-06-27 00:12:29 +00:00
|
|
|
#include "qemu_conf.h"
|
2012-06-18 08:22:07 +00:00
|
|
|
#include "qemu_command.h"
|
2010-12-16 15:07:07 +00:00
|
|
|
#include "qemu_capabilities.h"
|
2009-11-03 22:41:23 +00:00
|
|
|
#include "qemu_bridge_filter.h"
|
2007-02-26 15:32:27 +00:00
|
|
|
#include "uuid.h"
|
2007-06-27 00:12:29 +00:00
|
|
|
#include "buf.h"
|
2007-10-12 16:05:44 +00:00
|
|
|
#include "conf.h"
|
2007-12-03 14:30:46 +00:00
|
|
|
#include "util.h"
|
2008-05-22 15:29:50 +00:00
|
|
|
#include "memory.h"
|
2008-12-20 13:09:45 +00:00
|
|
|
#include "datatypes.h"
|
|
|
|
#include "xml.h"
|
make NUMA-initialization code more portable and more robust
qemudCapsInitNUMA and umlCapsInitNUMA were identical, so this change
factors them into a new function, virCapsInitNUMA, and puts it in
nodeinfo.c.
In addition to factoring out the duplicates, this change also
adjusts that function definition (along with its macros) so
that it works with Fedora 9's numactl version 1, and makes it
so the code will work even if someone builds the kernel with
CONFIG_NR_CPUS > 4096.
Finally, also perform this NUMA initialization for the lxc
and openvz drivers.
* src/nodeinfo.c: Include <stdint.h>, <numa.h> and "memory.h".
(virCapsInitNUMA): Rename from qemudCapsInitNUMA and umlCapsInitNUMA.
(NUMA_MAX_N_CPUS): Define depending on NUMA API version.
(n_bits, MASK_CPU_ISSET): Define, adjust, use uint64 rather than long.
* src/nodeinfo.h: Include "capabilities.h".
(virCapsInitNUMA): Declare it.
* examples/domain-events/events-c/Makefile.am:
* src/Makefile.am: Add $(NUMACTL_CFLAGS) and $(NUMACTL_LIBS) to various
compile/link-related variables.
* src/qemu_conf.c: Include "nodeinfo.h".
(qemudCapsInitNUMA): Remove duplicate code. Adjust caller.
* src/uml_conf.c (umlCapsInitNUMA): Likewise.
Include "nodeinfo.h".
* src/lxc_conf.c: Include "nodeinfo.h".
(lxcCapsInit): Perform NUMA initialization here, too.
* src/openvz_conf.c (openvzCapsInit): And here.
Include "nodeinfo.h".
* src/libvirt_sym.version.in: Add virCapsInitNUMA so that libvirtd
can link to this function.
2008-12-21 18:55:09 +00:00
|
|
|
#include "nodeinfo.h"
|
2009-03-03 11:40:08 +00:00
|
|
|
#include "logging.h"
|
2009-12-18 15:24:14 +00:00
|
|
|
#include "cpu/cpu.h"
|
2010-06-21 18:18:31 +00:00
|
|
|
#include "domain_nwfilter.h"
|
2011-07-19 18:32:58 +00:00
|
|
|
#include "virfile.h"
|
2010-11-16 14:54:17 +00:00
|
|
|
#include "configmake.h"
|
2008-07-11 19:34:11 +00:00
|
|
|
|
2009-01-23 16:22:20 +00:00
|
|
|
#define VIR_FROM_THIS VIR_FROM_QEMU
|
|
|
|
|
2012-03-19 13:28:10 +00:00
|
|
|
struct _qemuDriverCloseDef {
|
|
|
|
virConnectPtr conn;
|
|
|
|
qemuDriverCloseCallback cb;
|
|
|
|
};
|
|
|
|
|
2012-11-28 16:43:10 +00:00
|
|
|
void qemuDriverLock(virQEMUDriverPtr driver)
|
2010-12-16 16:11:48 +00:00
|
|
|
{
|
|
|
|
virMutexLock(&driver->lock);
|
|
|
|
}
|
2012-11-28 16:43:10 +00:00
|
|
|
void qemuDriverUnlock(virQEMUDriverPtr driver)
|
2010-12-16 16:11:48 +00:00
|
|
|
{
|
|
|
|
virMutexUnlock(&driver->lock);
|
|
|
|
}
|
|
|
|
|
|
|
|
|
2012-11-28 16:43:10 +00:00
|
|
|
int qemuLoadDriverConfig(virQEMUDriverPtr driver,
|
2012-10-31 19:03:48 +00:00
|
|
|
const char *filename) {
|
2012-11-29 11:25:07 +00:00
|
|
|
virConfPtr conf = NULL;
|
2007-10-12 16:05:44 +00:00
|
|
|
virConfValuePtr p;
|
2012-11-29 11:25:07 +00:00
|
|
|
char *user = NULL;
|
|
|
|
char *group = NULL;
|
|
|
|
int ret = -1;
|
2009-07-22 15:08:04 +00:00
|
|
|
int i;
|
2007-10-12 16:05:44 +00:00
|
|
|
|
2010-01-13 17:41:36 +00:00
|
|
|
/* Setup critical defaults */
|
Add two new security label types
Curently security labels can be of type 'dynamic' or 'static'.
If no security label is given, then 'dynamic' is assumed. The
current code takes advantage of this default, and avoids even
saving <seclabel> elements with type='dynamic' to disk. This
means if you temporarily change security driver, the guests
can all still start.
With the introduction of sVirt to LXC though, there needs to be
a new default of 'none' to allow unconfined LXC containers.
This patch introduces two new security label types
- default: the host configuration decides whether to run the
guest with type 'none' or 'dynamic' at guest start
- none: the guest will run unconfined by security policy
The 'none' label type will obviously be undesirable for some
deployments, so a new qemu.conf option allows a host admin to
mandate confined guests. It is also possible to turn off default
confinement
security_default_confined = 1|0 (default == 1)
security_require_confined = 1|0 (default == 0)
* src/conf/domain_conf.c, src/conf/domain_conf.h: Add new
seclabel types
* src/security/security_manager.c, src/security/security_manager.h:
Set default sec label types
* src/security/security_selinux.c: Handle 'none' seclabel type
* src/qemu/qemu.conf, src/qemu/qemu_conf.c, src/qemu/qemu_conf.h,
src/qemu/libvirtd_qemu.aug: New security config options
* src/qemu/qemu_driver.c: Tell security driver about default
config
2012-01-25 14:12:52 +00:00
|
|
|
driver->securityDefaultConfined = true;
|
|
|
|
driver->securityRequireConfined = false;
|
2010-01-13 17:41:36 +00:00
|
|
|
driver->dynamicOwnership = 1;
|
2010-05-27 23:17:55 +00:00
|
|
|
driver->clearEmulatorCapabilities = 1;
|
2010-01-13 17:41:36 +00:00
|
|
|
|
2012-11-29 11:25:07 +00:00
|
|
|
if (!(driver->vncListen = strdup("127.0.0.1")))
|
|
|
|
goto no_memory;
|
2012-06-18 08:22:07 +00:00
|
|
|
|
|
|
|
driver->remotePortMin = QEMU_REMOTE_PORT_MIN;
|
|
|
|
driver->remotePortMax = QEMU_REMOTE_PORT_MAX;
|
|
|
|
|
2012-11-29 11:25:07 +00:00
|
|
|
if (!(driver->vncTLSx509certdir = strdup(SYSCONFDIR "/pki/libvirt-vnc")))
|
|
|
|
goto no_memory;
|
|
|
|
|
|
|
|
if (!(driver->spiceListen = strdup("127.0.0.1")))
|
|
|
|
goto no_memory;
|
2007-10-12 16:05:44 +00:00
|
|
|
|
2010-11-16 14:54:17 +00:00
|
|
|
if (!(driver->spiceTLSx509certdir
|
2012-11-29 11:25:07 +00:00
|
|
|
= strdup(SYSCONFDIR "/pki/libvirt-spice")))
|
|
|
|
goto no_memory;
|
2010-03-05 20:31:50 +00:00
|
|
|
|
2010-04-23 09:34:17 +00:00
|
|
|
#if defined HAVE_MNTENT_H && defined HAVE_GETMNTENT_R
|
Support configuration of huge pages in guests
Add option to domain XML for
<memoryBacking>
<hugepages/>
</memoryBacking>
* configure.in: Add check for mntent.h
* qemud/libvirtd_qemu.aug, qemud/test_libvirtd_qemu.aug, src/qemu.conf
Add 'hugetlbfs_mount' config parameter
* src/qemu_conf.c, src/qemu_conf.h: Check for -mem-path flag in QEMU,
and pass it when hugepages are requested.
Load hugetlbfs_mount config parameter, search for mount if not given.
* src/qemu_driver.c: Free hugetlbfs_mount/path parameter in driver shutdown.
Create directory for QEMU hugepage usage, chowning if required.
* docs/formatdomain.html.in: Document memoryBacking/hugepages elements
* docs/schemas/domain.rng: Add memoryBacking/hugepages elements to schema
* src/util.c, src/util.h, src/libvirt_private.syms: Add virFileFindMountPoint
helper API
* tests/qemuhelptest.c: Add -mem-path constants
* tests/qemuxml2argvtest.c, tests/qemuxml2xmltest.c: Add tests for hugepage
handling
* tests/qemuxml2argvdata/qemuxml2argv-hugepages.xml,
tests/qemuxml2argvdata/qemuxml2argv-hugepages.args: Data files for
hugepage tests
2009-08-25 14:05:18 +00:00
|
|
|
/* For privileged driver, try and find hugepage mount automatically.
|
|
|
|
* Non-privileged driver requires admin to create a dir for the
|
|
|
|
* user, chown it, and then let user configure it manually */
|
|
|
|
if (driver->privileged &&
|
|
|
|
!(driver->hugetlbfs_mount = virFileFindMountPoint("hugetlbfs"))) {
|
|
|
|
if (errno != ENOENT) {
|
2010-02-04 20:02:58 +00:00
|
|
|
virReportSystemError(errno, "%s",
|
Support configuration of huge pages in guests
Add option to domain XML for
<memoryBacking>
<hugepages/>
</memoryBacking>
* configure.in: Add check for mntent.h
* qemud/libvirtd_qemu.aug, qemud/test_libvirtd_qemu.aug, src/qemu.conf
Add 'hugetlbfs_mount' config parameter
* src/qemu_conf.c, src/qemu_conf.h: Check for -mem-path flag in QEMU,
and pass it when hugepages are requested.
Load hugetlbfs_mount config parameter, search for mount if not given.
* src/qemu_driver.c: Free hugetlbfs_mount/path parameter in driver shutdown.
Create directory for QEMU hugepage usage, chowning if required.
* docs/formatdomain.html.in: Document memoryBacking/hugepages elements
* docs/schemas/domain.rng: Add memoryBacking/hugepages elements to schema
* src/util.c, src/util.h, src/libvirt_private.syms: Add virFileFindMountPoint
helper API
* tests/qemuhelptest.c: Add -mem-path constants
* tests/qemuxml2argvtest.c, tests/qemuxml2xmltest.c: Add tests for hugepage
handling
* tests/qemuxml2argvdata/qemuxml2argv-hugepages.xml,
tests/qemuxml2argvdata/qemuxml2argv-hugepages.args: Data files for
hugepage tests
2009-08-25 14:05:18 +00:00
|
|
|
_("unable to find hugetlbfs mountpoint"));
|
2012-11-29 11:25:07 +00:00
|
|
|
goto cleanup;
|
Support configuration of huge pages in guests
Add option to domain XML for
<memoryBacking>
<hugepages/>
</memoryBacking>
* configure.in: Add check for mntent.h
* qemud/libvirtd_qemu.aug, qemud/test_libvirtd_qemu.aug, src/qemu.conf
Add 'hugetlbfs_mount' config parameter
* src/qemu_conf.c, src/qemu_conf.h: Check for -mem-path flag in QEMU,
and pass it when hugepages are requested.
Load hugetlbfs_mount config parameter, search for mount if not given.
* src/qemu_driver.c: Free hugetlbfs_mount/path parameter in driver shutdown.
Create directory for QEMU hugepage usage, chowning if required.
* docs/formatdomain.html.in: Document memoryBacking/hugepages elements
* docs/schemas/domain.rng: Add memoryBacking/hugepages elements to schema
* src/util.c, src/util.h, src/libvirt_private.syms: Add virFileFindMountPoint
helper API
* tests/qemuhelptest.c: Add -mem-path constants
* tests/qemuxml2argvtest.c, tests/qemuxml2xmltest.c: Add tests for hugepage
handling
* tests/qemuxml2argvdata/qemuxml2argv-hugepages.xml,
tests/qemuxml2argvdata/qemuxml2argv-hugepages.args: Data files for
hugepage tests
2009-08-25 14:05:18 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
#endif
|
|
|
|
|
2012-12-11 15:59:21 +00:00
|
|
|
if (!(driver->lockManager = virLockManagerPluginNew("nop",
|
|
|
|
"qemu",
|
|
|
|
driver->configBaseDir,
|
|
|
|
0)))
|
2012-11-29 11:25:07 +00:00
|
|
|
goto cleanup;
|
Support configuration of huge pages in guests
Add option to domain XML for
<memoryBacking>
<hugepages/>
</memoryBacking>
* configure.in: Add check for mntent.h
* qemud/libvirtd_qemu.aug, qemud/test_libvirtd_qemu.aug, src/qemu.conf
Add 'hugetlbfs_mount' config parameter
* src/qemu_conf.c, src/qemu_conf.h: Check for -mem-path flag in QEMU,
and pass it when hugepages are requested.
Load hugetlbfs_mount config parameter, search for mount if not given.
* src/qemu_driver.c: Free hugetlbfs_mount/path parameter in driver shutdown.
Create directory for QEMU hugepage usage, chowning if required.
* docs/formatdomain.html.in: Document memoryBacking/hugepages elements
* docs/schemas/domain.rng: Add memoryBacking/hugepages elements to schema
* src/util.c, src/util.h, src/libvirt_private.syms: Add virFileFindMountPoint
helper API
* tests/qemuhelptest.c: Add -mem-path constants
* tests/qemuxml2argvtest.c, tests/qemuxml2xmltest.c: Add tests for hugepage
handling
* tests/qemuxml2argvdata/qemuxml2argv-hugepages.xml,
tests/qemuxml2argvdata/qemuxml2argv-hugepages.args: Data files for
hugepage tests
2009-08-25 14:05:18 +00:00
|
|
|
|
2011-09-16 11:50:56 +00:00
|
|
|
driver->keepAliveInterval = 5;
|
|
|
|
driver->keepAliveCount = 5;
|
2012-09-17 07:59:53 +00:00
|
|
|
driver->seccompSandbox = -1;
|
2011-09-16 11:50:56 +00:00
|
|
|
|
2007-10-12 16:05:44 +00:00
|
|
|
/* Just check the file is readable before opening it, otherwise
|
|
|
|
* libvirt emits an error.
|
|
|
|
*/
|
2012-10-17 09:23:12 +00:00
|
|
|
if (access(filename, R_OK) == -1) {
|
2010-06-30 18:14:37 +00:00
|
|
|
VIR_INFO("Could not read qemu config file %s", filename);
|
2012-11-29 11:25:07 +00:00
|
|
|
ret = 0;
|
|
|
|
goto cleanup;
|
2010-06-30 18:14:37 +00:00
|
|
|
}
|
2007-10-12 16:05:44 +00:00
|
|
|
|
2012-11-29 11:25:07 +00:00
|
|
|
if (!(conf = virConfReadFile(filename, 0)))
|
|
|
|
goto cleanup;
|
2007-10-12 16:05:44 +00:00
|
|
|
|
2012-11-27 16:59:34 +00:00
|
|
|
#define CHECK_TYPE(name,typ) \
|
|
|
|
if (p && p->type != (typ)) { \
|
|
|
|
virReportError(VIR_ERR_INTERNAL_ERROR, \
|
|
|
|
"%s: %s: expected type " #typ, \
|
|
|
|
filename, (name)); \
|
2012-11-29 11:25:07 +00:00
|
|
|
goto cleanup; \
|
2012-11-27 16:59:34 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
#define GET_VALUE_LONG(NAME, VAR) \
|
|
|
|
p = virConfGetValue(conf, NAME); \
|
|
|
|
CHECK_TYPE(NAME, VIR_CONF_LONG); \
|
|
|
|
if (p) \
|
|
|
|
VAR = p->l;
|
|
|
|
|
|
|
|
#define GET_VALUE_STR(NAME, VAR) \
|
|
|
|
p = virConfGetValue(conf, NAME); \
|
|
|
|
CHECK_TYPE(NAME, VIR_CONF_STRING); \
|
|
|
|
if (p && p->str) { \
|
|
|
|
VIR_FREE(VAR); \
|
2012-11-29 11:25:07 +00:00
|
|
|
if (!(VAR = strdup(p->str))) \
|
|
|
|
goto no_memory; \
|
2012-11-27 16:59:34 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
GET_VALUE_LONG("vnc_auto_unix_socket", driver->vncAutoUnixSocket);
|
|
|
|
GET_VALUE_LONG("vnc_tls", driver->vncTLS);
|
|
|
|
GET_VALUE_LONG("vnc_tls_x509_verify", driver->vncTLSx509verify);
|
|
|
|
GET_VALUE_STR("vnc_tls_x509_cert_dir", driver->vncTLSx509certdir);
|
|
|
|
GET_VALUE_STR("vnc_listen", driver->vncListen);
|
|
|
|
GET_VALUE_STR("vnc_password", driver->vncPassword);
|
|
|
|
GET_VALUE_LONG("vnc_sasl", driver->vncSASL);
|
|
|
|
GET_VALUE_STR("vnc_sasl_dir", driver->vncSASLdir);
|
|
|
|
GET_VALUE_LONG("vnc_allow_host_audio", driver->vncAllowHostAudio);
|
2009-01-29 17:50:00 +00:00
|
|
|
|
2012-10-17 09:23:12 +00:00
|
|
|
p = virConfGetValue(conf, "security_driver");
|
2012-08-15 22:10:38 +00:00
|
|
|
if (p && p->type == VIR_CONF_LIST) {
|
|
|
|
size_t len;
|
|
|
|
virConfValuePtr pp;
|
|
|
|
|
2012-10-11 16:31:20 +00:00
|
|
|
/* Calc length and check items */
|
2012-08-15 22:10:38 +00:00
|
|
|
for (len = 0, pp = p->list; pp; len++, pp = pp->next) {
|
|
|
|
if (pp->type != VIR_CONF_STRING) {
|
2012-11-29 11:25:07 +00:00
|
|
|
virReportError(VIR_ERR_CONF_SYNTAX, "%s",
|
|
|
|
_("security_driver must be a list of strings"));
|
|
|
|
goto cleanup;
|
2012-08-15 22:10:38 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2012-11-29 11:25:07 +00:00
|
|
|
if (VIR_ALLOC_N(driver->securityDriverNames, len + 1) < 0)
|
|
|
|
goto no_memory;
|
2012-08-15 22:10:38 +00:00
|
|
|
|
|
|
|
for (i = 0, pp = p->list; pp; i++, pp = pp->next) {
|
2012-11-29 11:25:07 +00:00
|
|
|
if (!(driver->securityDriverNames[i] = strdup(pp->str)))
|
|
|
|
goto no_memory;
|
2012-08-15 22:10:38 +00:00
|
|
|
}
|
|
|
|
driver->securityDriverNames[len] = NULL;
|
|
|
|
} else {
|
2012-10-17 09:23:12 +00:00
|
|
|
CHECK_TYPE("security_driver", VIR_CONF_STRING);
|
2012-08-15 22:10:38 +00:00
|
|
|
if (p && p->str) {
|
|
|
|
if (VIR_ALLOC_N(driver->securityDriverNames, 2) < 0 ||
|
2012-11-29 11:25:07 +00:00
|
|
|
!(driver->securityDriverNames[0] = strdup(p->str)))
|
|
|
|
goto no_memory;
|
|
|
|
|
2012-08-15 22:10:38 +00:00
|
|
|
driver->securityDriverNames[1] = NULL;
|
|
|
|
}
|
2009-03-03 12:03:44 +00:00
|
|
|
}
|
|
|
|
|
2012-11-27 16:59:34 +00:00
|
|
|
GET_VALUE_LONG("security_default_confined", driver->securityDefaultConfined);
|
|
|
|
GET_VALUE_LONG("security_require_confined", driver->securityRequireConfined);
|
2010-03-05 20:31:50 +00:00
|
|
|
|
2012-11-27 16:59:34 +00:00
|
|
|
GET_VALUE_LONG("spice_tls", driver->spiceTLS);
|
|
|
|
GET_VALUE_STR("spice_tls_x509_cert_dir", driver->spiceTLSx509certdir);
|
|
|
|
GET_VALUE_STR("spice_listen", driver->spiceListen);
|
|
|
|
GET_VALUE_STR("spice_password", driver->spicePassword);
|
2010-03-05 20:31:50 +00:00
|
|
|
|
|
|
|
|
2012-11-27 16:59:34 +00:00
|
|
|
GET_VALUE_LONG("remote_display_port_min", driver->remotePortMin);
|
|
|
|
if (driver->remotePortMin < QEMU_REMOTE_PORT_MIN) {
|
|
|
|
/* if the port is too low, we can't get the display name
|
|
|
|
* to tell to vnc (usually subtract 5900, e.g. localhost:1
|
|
|
|
* for port 5901) */
|
|
|
|
virReportError(VIR_ERR_INTERNAL_ERROR,
|
|
|
|
_("%s: remote_display_port_min: port must be greater "
|
|
|
|
"than or equal to %d"),
|
|
|
|
filename, QEMU_REMOTE_PORT_MIN);
|
2012-11-29 11:25:07 +00:00
|
|
|
goto cleanup;
|
2012-06-18 08:22:07 +00:00
|
|
|
}
|
|
|
|
|
2012-11-27 16:59:34 +00:00
|
|
|
GET_VALUE_LONG("remote_display_port_max", driver->remotePortMax);
|
|
|
|
if (driver->remotePortMax > QEMU_REMOTE_PORT_MAX ||
|
|
|
|
driver->remotePortMax < driver->remotePortMin) {
|
|
|
|
virReportError(VIR_ERR_INTERNAL_ERROR,
|
|
|
|
_("%s: remote_display_port_max: port must be between "
|
|
|
|
"the minimal port and %d"),
|
|
|
|
filename, QEMU_REMOTE_PORT_MAX);
|
2012-11-29 11:25:07 +00:00
|
|
|
goto cleanup;
|
2012-06-18 08:22:07 +00:00
|
|
|
}
|
2012-11-27 16:59:34 +00:00
|
|
|
/* increasing the value by 1 makes all the loops going through
|
|
|
|
the bitmap (i = remotePortMin; i < remotePortMax; i++), work as
|
|
|
|
expected. */
|
|
|
|
driver->remotePortMax++;
|
2012-06-18 08:22:07 +00:00
|
|
|
|
|
|
|
if (driver->remotePortMin > driver->remotePortMax) {
|
|
|
|
virReportError(VIR_ERR_INTERNAL_ERROR,
|
2012-11-27 16:59:34 +00:00
|
|
|
_("%s: remote_display_port_min: min port must not be "
|
|
|
|
"greater than max port"), filename);
|
2012-11-29 11:25:07 +00:00
|
|
|
goto cleanup;
|
2012-06-18 08:22:07 +00:00
|
|
|
}
|
|
|
|
|
2012-10-17 09:23:12 +00:00
|
|
|
p = virConfGetValue(conf, "user");
|
|
|
|
CHECK_TYPE("user", VIR_CONF_STRING);
|
2012-11-29 11:25:07 +00:00
|
|
|
if (!(user = strdup(p && p->str ? p->str : QEMU_USER)))
|
|
|
|
goto no_memory;
|
2009-07-15 21:25:01 +00:00
|
|
|
|
2012-11-29 11:25:07 +00:00
|
|
|
if (virGetUserID(user, &driver->user) < 0)
|
|
|
|
goto cleanup;
|
2010-01-13 17:41:36 +00:00
|
|
|
|
2012-10-17 09:23:12 +00:00
|
|
|
p = virConfGetValue(conf, "group");
|
|
|
|
CHECK_TYPE("group", VIR_CONF_STRING);
|
2012-11-29 11:25:07 +00:00
|
|
|
if (!(group = strdup(p && p->str ? p->str : QEMU_GROUP)))
|
|
|
|
goto no_memory;
|
|
|
|
|
|
|
|
if (virGetGroupID(group, &driver->group) < 0)
|
|
|
|
goto cleanup;
|
2009-07-15 21:25:01 +00:00
|
|
|
|
2012-11-27 16:59:34 +00:00
|
|
|
GET_VALUE_LONG("dynamic_ownership", driver->dynamicOwnership);
|
2010-01-13 17:41:36 +00:00
|
|
|
|
2012-10-17 09:23:12 +00:00
|
|
|
p = virConfGetValue(conf, "cgroup_controllers");
|
|
|
|
CHECK_TYPE("cgroup_controllers", VIR_CONF_LIST);
|
2009-07-22 15:08:04 +00:00
|
|
|
if (p) {
|
|
|
|
virConfValuePtr pp;
|
|
|
|
for (i = 0, pp = p->list; pp; ++i, pp = pp->next) {
|
|
|
|
int ctl;
|
|
|
|
if (pp->type != VIR_CONF_STRING) {
|
2012-11-29 11:25:07 +00:00
|
|
|
virReportError(VIR_ERR_CONF_SYNTAX, "%s",
|
|
|
|
_("cgroup_controllers must be a "
|
|
|
|
"list of strings"));
|
|
|
|
goto cleanup;
|
2009-07-22 15:08:04 +00:00
|
|
|
}
|
2012-11-29 11:25:07 +00:00
|
|
|
|
|
|
|
if ((ctl = virCgroupControllerTypeFromString(pp->str)) < 0) {
|
|
|
|
virReportError(VIR_ERR_CONF_SYNTAX,
|
|
|
|
_("Unknown cgroup controller '%s'"), pp->str);
|
|
|
|
goto cleanup;
|
2009-07-22 15:08:04 +00:00
|
|
|
}
|
|
|
|
driver->cgroupControllers |= (1 << ctl);
|
|
|
|
}
|
|
|
|
} else {
|
|
|
|
driver->cgroupControllers =
|
|
|
|
(1 << VIR_CGROUP_CONTROLLER_CPU) |
|
2010-10-12 16:12:31 +00:00
|
|
|
(1 << VIR_CGROUP_CONTROLLER_DEVICES) |
|
2011-02-08 06:59:38 +00:00
|
|
|
(1 << VIR_CGROUP_CONTROLLER_MEMORY) |
|
2011-11-17 09:44:12 +00:00
|
|
|
(1 << VIR_CGROUP_CONTROLLER_BLKIO) |
|
2012-03-02 02:54:23 +00:00
|
|
|
(1 << VIR_CGROUP_CONTROLLER_CPUSET) |
|
|
|
|
(1 << VIR_CGROUP_CONTROLLER_CPUACCT);
|
2009-07-22 15:08:04 +00:00
|
|
|
}
|
|
|
|
for (i = 0 ; i < VIR_CGROUP_CONTROLLER_LAST ; i++) {
|
|
|
|
if (driver->cgroupControllers & (1 << i)) {
|
|
|
|
VIR_INFO("Configured cgroup controller '%s'",
|
|
|
|
virCgroupControllerTypeToString(i));
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2012-10-17 09:23:12 +00:00
|
|
|
p = virConfGetValue(conf, "cgroup_device_acl");
|
|
|
|
CHECK_TYPE("cgroup_device_acl", VIR_CONF_LIST);
|
2009-07-22 15:08:04 +00:00
|
|
|
if (p) {
|
|
|
|
int len = 0;
|
|
|
|
virConfValuePtr pp;
|
|
|
|
for (pp = p->list; pp; pp = pp->next)
|
|
|
|
len++;
|
2012-11-29 11:25:07 +00:00
|
|
|
if (VIR_ALLOC_N(driver->cgroupDeviceACL, 1+len) < 0)
|
|
|
|
goto no_memory;
|
|
|
|
|
2009-07-22 15:08:04 +00:00
|
|
|
for (i = 0, pp = p->list; pp; ++i, pp = pp->next) {
|
|
|
|
if (pp->type != VIR_CONF_STRING) {
|
2012-11-29 11:25:07 +00:00
|
|
|
virReportError(VIR_ERR_CONF_SYNTAX, "%s",
|
|
|
|
_("cgroup_device_acl must be a "
|
|
|
|
"list of strings"));
|
|
|
|
goto cleanup;
|
2009-07-22 15:08:04 +00:00
|
|
|
}
|
2012-11-29 11:25:07 +00:00
|
|
|
if (!(driver->cgroupDeviceACL[i] = strdup(pp->str)))
|
|
|
|
goto no_memory;
|
2009-07-22 15:08:04 +00:00
|
|
|
}
|
|
|
|
driver->cgroupDeviceACL[i] = NULL;
|
|
|
|
}
|
|
|
|
|
2012-11-27 16:59:34 +00:00
|
|
|
GET_VALUE_STR("save_image_format", driver->saveImageFormat);
|
|
|
|
GET_VALUE_STR("dump_image_format", driver->dumpImageFormat);
|
|
|
|
GET_VALUE_STR("auto_dump_path", driver->autoDumpPath);
|
|
|
|
GET_VALUE_LONG("auto_dump_bypass_cache", driver->autoDumpBypassCache);
|
|
|
|
GET_VALUE_LONG("auto_start_bypass_cache", driver->autoStartBypassCache);
|
2011-07-19 21:54:48 +00:00
|
|
|
|
2012-11-27 16:59:34 +00:00
|
|
|
GET_VALUE_STR("hugetlbfs_mount", driver->hugetlbfs_mount);
|
Support configuration of huge pages in guests
Add option to domain XML for
<memoryBacking>
<hugepages/>
</memoryBacking>
* configure.in: Add check for mntent.h
* qemud/libvirtd_qemu.aug, qemud/test_libvirtd_qemu.aug, src/qemu.conf
Add 'hugetlbfs_mount' config parameter
* src/qemu_conf.c, src/qemu_conf.h: Check for -mem-path flag in QEMU,
and pass it when hugepages are requested.
Load hugetlbfs_mount config parameter, search for mount if not given.
* src/qemu_driver.c: Free hugetlbfs_mount/path parameter in driver shutdown.
Create directory for QEMU hugepage usage, chowning if required.
* docs/formatdomain.html.in: Document memoryBacking/hugepages elements
* docs/schemas/domain.rng: Add memoryBacking/hugepages elements to schema
* src/util.c, src/util.h, src/libvirt_private.syms: Add virFileFindMountPoint
helper API
* tests/qemuhelptest.c: Add -mem-path constants
* tests/qemuxml2argvtest.c, tests/qemuxml2xmltest.c: Add tests for hugepage
handling
* tests/qemuxml2argvdata/qemuxml2argv-hugepages.xml,
tests/qemuxml2argvdata/qemuxml2argv-hugepages.args: Data files for
hugepage tests
2009-08-25 14:05:18 +00:00
|
|
|
|
2012-10-17 09:23:12 +00:00
|
|
|
p = virConfGetValue(conf, "mac_filter");
|
|
|
|
CHECK_TYPE("mac_filter", VIR_CONF_LONG);
|
2009-11-11 11:59:54 +00:00
|
|
|
if (p && p->l) {
|
2009-11-03 22:41:23 +00:00
|
|
|
driver->macFilter = p->l;
|
|
|
|
if (!(driver->ebtables = ebtablesContextNew("qemu"))) {
|
|
|
|
driver->macFilter = 0;
|
2010-02-04 20:02:58 +00:00
|
|
|
virReportSystemError(errno,
|
2010-02-19 14:41:30 +00:00
|
|
|
_("failed to enable mac filter in '%s'"),
|
2009-11-03 22:41:23 +00:00
|
|
|
__FILE__);
|
2012-11-29 11:25:07 +00:00
|
|
|
goto cleanup;
|
2009-11-03 22:41:23 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
if ((errno = networkDisableAllFrames(driver))) {
|
2010-02-04 20:02:58 +00:00
|
|
|
virReportSystemError(errno,
|
2009-11-03 22:41:23 +00:00
|
|
|
_("failed to add rule to drop all frames in '%s'"),
|
|
|
|
__FILE__);
|
2012-11-29 11:25:07 +00:00
|
|
|
goto cleanup;
|
2009-11-03 22:41:23 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2012-11-27 16:59:34 +00:00
|
|
|
GET_VALUE_LONG("relaxed_acs_check", driver->relaxedACS);
|
|
|
|
GET_VALUE_LONG("clear_emulator_capabilities", driver->clearEmulatorCapabilities);
|
|
|
|
GET_VALUE_LONG("allow_disk_format_probing", driver->allowDiskFormatProbing);
|
|
|
|
GET_VALUE_LONG("set_process_name", driver->setProcessName);
|
|
|
|
GET_VALUE_LONG("max_processes", driver->maxProcesses);
|
|
|
|
GET_VALUE_LONG("max_files", driver->maxFiles);
|
2011-12-22 11:22:31 +00:00
|
|
|
|
2012-10-17 09:23:12 +00:00
|
|
|
p = virConfGetValue(conf, "lock_manager");
|
|
|
|
CHECK_TYPE("lock_manager", VIR_CONF_STRING);
|
2010-10-26 14:04:46 +00:00
|
|
|
if (p && p->str) {
|
|
|
|
virLockManagerPluginUnref(driver->lockManager);
|
|
|
|
if (!(driver->lockManager =
|
2012-12-11 15:59:21 +00:00
|
|
|
virLockManagerPluginNew(p->str, "qemu", driver->configBaseDir, 0)))
|
2010-10-26 14:04:46 +00:00
|
|
|
VIR_ERROR(_("Failed to load lock manager %s"), p->str);
|
|
|
|
}
|
|
|
|
|
2012-11-27 16:59:34 +00:00
|
|
|
GET_VALUE_LONG("max_queued", driver->max_queued);
|
|
|
|
GET_VALUE_LONG("keepalive_interval", driver->keepAliveInterval);
|
|
|
|
GET_VALUE_LONG("keepalive_count", driver->keepAliveCount);
|
|
|
|
GET_VALUE_LONG("seccomp_sandbox", driver->seccompSandbox);
|
2012-09-17 07:59:53 +00:00
|
|
|
|
2012-11-29 11:25:07 +00:00
|
|
|
ret = 0;
|
|
|
|
|
|
|
|
cleanup:
|
|
|
|
VIR_FREE(user);
|
|
|
|
VIR_FREE(group);
|
2012-10-17 09:23:12 +00:00
|
|
|
virConfFree(conf);
|
2012-11-29 11:25:07 +00:00
|
|
|
return ret;
|
|
|
|
|
|
|
|
no_memory:
|
|
|
|
virReportOOMError();
|
|
|
|
goto cleanup;
|
2007-10-12 16:05:44 +00:00
|
|
|
}
|
2012-11-27 16:59:34 +00:00
|
|
|
#undef GET_VALUE_LONG
|
|
|
|
#undef GET_VALUE_STRING
|
2012-03-19 13:28:10 +00:00
|
|
|
|
|
|
|
static void
|
|
|
|
qemuDriverCloseCallbackFree(void *payload,
|
|
|
|
const void *name ATTRIBUTE_UNUSED)
|
|
|
|
{
|
|
|
|
VIR_FREE(payload);
|
|
|
|
}
|
|
|
|
|
|
|
|
int
|
2012-11-28 16:43:10 +00:00
|
|
|
qemuDriverCloseCallbackInit(virQEMUDriverPtr driver)
|
2012-03-19 13:28:10 +00:00
|
|
|
{
|
|
|
|
driver->closeCallbacks = virHashCreate(5, qemuDriverCloseCallbackFree);
|
|
|
|
if (!driver->closeCallbacks)
|
|
|
|
return -1;
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
void
|
2012-11-28 16:43:10 +00:00
|
|
|
qemuDriverCloseCallbackShutdown(virQEMUDriverPtr driver)
|
2012-03-19 13:28:10 +00:00
|
|
|
{
|
|
|
|
virHashFree(driver->closeCallbacks);
|
|
|
|
}
|
|
|
|
|
|
|
|
int
|
2012-11-28 16:43:10 +00:00
|
|
|
qemuDriverCloseCallbackSet(virQEMUDriverPtr driver,
|
2012-03-19 13:28:10 +00:00
|
|
|
virDomainObjPtr vm,
|
|
|
|
virConnectPtr conn,
|
|
|
|
qemuDriverCloseCallback cb)
|
|
|
|
{
|
|
|
|
char uuidstr[VIR_UUID_STRING_BUFLEN];
|
|
|
|
qemuDriverCloseDefPtr closeDef;
|
|
|
|
|
|
|
|
virUUIDFormat(vm->def->uuid, uuidstr);
|
|
|
|
VIR_DEBUG("vm=%s, uuid=%s, conn=%p, cb=%p",
|
|
|
|
vm->def->name, uuidstr, conn, cb);
|
|
|
|
|
|
|
|
closeDef = virHashLookup(driver->closeCallbacks, uuidstr);
|
|
|
|
if (closeDef) {
|
|
|
|
if (closeDef->conn != conn) {
|
2012-07-18 15:22:03 +00:00
|
|
|
virReportError(VIR_ERR_INTERNAL_ERROR,
|
|
|
|
_("Close callback for domain %s already registered"
|
|
|
|
" with another connection %p"),
|
|
|
|
vm->def->name, closeDef->conn);
|
2012-03-19 13:28:10 +00:00
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
if (closeDef->cb && closeDef->cb != cb) {
|
2012-07-18 15:22:03 +00:00
|
|
|
virReportError(VIR_ERR_INTERNAL_ERROR,
|
|
|
|
_("Another close callback is already defined for"
|
|
|
|
" domain %s"), vm->def->name);
|
2012-03-19 13:28:10 +00:00
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
|
|
|
|
closeDef->cb = cb;
|
|
|
|
} else {
|
|
|
|
if (VIR_ALLOC(closeDef) < 0) {
|
|
|
|
virReportOOMError();
|
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
|
|
|
|
closeDef->conn = conn;
|
|
|
|
closeDef->cb = cb;
|
|
|
|
if (virHashAddEntry(driver->closeCallbacks, uuidstr, closeDef) < 0) {
|
|
|
|
VIR_FREE(closeDef);
|
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
int
|
2012-11-28 16:43:10 +00:00
|
|
|
qemuDriverCloseCallbackUnset(virQEMUDriverPtr driver,
|
2012-03-19 13:28:10 +00:00
|
|
|
virDomainObjPtr vm,
|
|
|
|
qemuDriverCloseCallback cb)
|
|
|
|
{
|
|
|
|
char uuidstr[VIR_UUID_STRING_BUFLEN];
|
|
|
|
qemuDriverCloseDefPtr closeDef;
|
|
|
|
|
|
|
|
virUUIDFormat(vm->def->uuid, uuidstr);
|
|
|
|
VIR_DEBUG("vm=%s, uuid=%s, cb=%p",
|
|
|
|
vm->def->name, uuidstr, cb);
|
|
|
|
|
|
|
|
closeDef = virHashLookup(driver->closeCallbacks, uuidstr);
|
|
|
|
if (!closeDef)
|
|
|
|
return -1;
|
|
|
|
|
|
|
|
if (closeDef->cb && closeDef->cb != cb) {
|
2012-07-18 15:22:03 +00:00
|
|
|
virReportError(VIR_ERR_INTERNAL_ERROR,
|
|
|
|
_("Trying to remove mismatching close callback for"
|
|
|
|
" domain %s"), vm->def->name);
|
2012-03-19 13:28:10 +00:00
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
|
|
|
|
return virHashRemoveEntry(driver->closeCallbacks, uuidstr);
|
|
|
|
}
|
|
|
|
|
|
|
|
qemuDriverCloseCallback
|
2012-11-28 16:43:10 +00:00
|
|
|
qemuDriverCloseCallbackGet(virQEMUDriverPtr driver,
|
2012-03-19 13:28:10 +00:00
|
|
|
virDomainObjPtr vm,
|
|
|
|
virConnectPtr conn)
|
|
|
|
{
|
|
|
|
char uuidstr[VIR_UUID_STRING_BUFLEN];
|
|
|
|
qemuDriverCloseDefPtr closeDef;
|
|
|
|
qemuDriverCloseCallback cb = NULL;
|
|
|
|
|
|
|
|
virUUIDFormat(vm->def->uuid, uuidstr);
|
|
|
|
VIR_DEBUG("vm=%s, uuid=%s, conn=%p",
|
|
|
|
vm->def->name, uuidstr, conn);
|
|
|
|
|
|
|
|
closeDef = virHashLookup(driver->closeCallbacks, uuidstr);
|
|
|
|
if (closeDef && (!conn || closeDef->conn == conn))
|
|
|
|
cb = closeDef->cb;
|
|
|
|
|
|
|
|
VIR_DEBUG("cb=%p", cb);
|
|
|
|
return cb;
|
|
|
|
}
|
|
|
|
|
|
|
|
struct qemuDriverCloseCallbackData {
|
2012-11-28 16:43:10 +00:00
|
|
|
virQEMUDriverPtr driver;
|
2012-03-19 13:28:10 +00:00
|
|
|
virConnectPtr conn;
|
|
|
|
};
|
|
|
|
|
|
|
|
static void
|
|
|
|
qemuDriverCloseCallbackRun(void *payload,
|
|
|
|
const void *name,
|
|
|
|
void *opaque)
|
|
|
|
{
|
|
|
|
struct qemuDriverCloseCallbackData *data = opaque;
|
|
|
|
qemuDriverCloseDefPtr closeDef = payload;
|
|
|
|
const char *uuidstr = name;
|
|
|
|
unsigned char uuid[VIR_UUID_BUFLEN];
|
|
|
|
virDomainObjPtr dom;
|
|
|
|
|
|
|
|
VIR_DEBUG("conn=%p, thisconn=%p, uuid=%s, cb=%p",
|
|
|
|
closeDef->conn, data->conn, uuidstr, closeDef->cb);
|
|
|
|
|
|
|
|
if (data->conn != closeDef->conn || !closeDef->cb)
|
|
|
|
return;
|
|
|
|
|
|
|
|
if (virUUIDParse(uuidstr, uuid) < 0) {
|
|
|
|
VIR_WARN("Failed to parse %s", uuidstr);
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (!(dom = virDomainFindByUUID(&data->driver->domains, uuid))) {
|
|
|
|
VIR_DEBUG("No domain object with UUID %s", uuidstr);
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
dom = closeDef->cb(data->driver, dom, data->conn);
|
|
|
|
if (dom)
|
|
|
|
virDomainObjUnlock(dom);
|
|
|
|
|
|
|
|
virHashRemoveEntry(data->driver->closeCallbacks, uuidstr);
|
|
|
|
}
|
|
|
|
|
|
|
|
void
|
2012-11-28 16:43:10 +00:00
|
|
|
qemuDriverCloseCallbackRunAll(virQEMUDriverPtr driver,
|
2012-03-19 13:28:10 +00:00
|
|
|
virConnectPtr conn)
|
|
|
|
{
|
|
|
|
struct qemuDriverCloseCallbackData data = {
|
|
|
|
driver, conn
|
|
|
|
};
|
|
|
|
VIR_DEBUG("conn=%p", conn);
|
|
|
|
|
|
|
|
virHashForEach(driver->closeCallbacks, qemuDriverCloseCallbackRun, &data);
|
|
|
|
}
|