2007-02-14 01:40:09 +00:00
|
|
|
/*
|
|
|
|
* driver.c: core driver methods for managing qemu guests
|
|
|
|
*
|
2010-01-05 15:32:11 +00:00
|
|
|
* Copyright (C) 2006, 2007, 2008, 2009, 2010 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
|
|
|
|
* License along with this library; if not, write to the Free Software
|
|
|
|
* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
|
|
|
|
*
|
|
|
|
* 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 <sys/types.h>
|
|
|
|
#include <sys/poll.h>
|
2009-11-03 18:26:32 +00:00
|
|
|
#include <sys/time.h>
|
2007-02-14 01:40:09 +00:00
|
|
|
#include <dirent.h>
|
|
|
|
#include <limits.h>
|
|
|
|
#include <string.h>
|
2009-07-21 09:53:17 +00:00
|
|
|
#include <stdbool.h>
|
2007-02-14 01:40:09 +00:00
|
|
|
#include <stdio.h>
|
|
|
|
#include <strings.h>
|
|
|
|
#include <stdarg.h>
|
|
|
|
#include <stdlib.h>
|
|
|
|
#include <unistd.h>
|
|
|
|
#include <errno.h>
|
2007-06-26 19:49:50 +00:00
|
|
|
#include <sys/utsname.h>
|
2007-06-26 20:41:25 +00:00
|
|
|
#include <sys/stat.h>
|
|
|
|
#include <fcntl.h>
|
|
|
|
#include <signal.h>
|
|
|
|
#include <paths.h>
|
2007-06-26 22:13:21 +00:00
|
|
|
#include <pwd.h>
|
|
|
|
#include <stdio.h>
|
2007-06-26 20:41:25 +00:00
|
|
|
#include <sys/wait.h>
|
2008-09-17 14:07:49 +00:00
|
|
|
#include <sys/ioctl.h>
|
Move xen driver code into src/xen/ directory
* src/Makefile.am, src/proxy_internal.c, src/proxy_internal.h
src/sexpr.c, src/sexpr.h, src/xen_unified.c, src/xen_unified.h,
src/xen_internal.c, src/xen_internal.h, src/xen_inotify.c,
src/xen_inotify.h, src/xend_internal.c, src/xend_internal.h,
src/xm_internal.c, src/xm_internal.h, src/xs_internal.c,
src/xs_internal.h: Move to src/xen/ directory
* proxy/Makefile.am, proxy/libvirt_proxy.c, src/Makefile.am,
src/libvirt.c, tests/sexpr2xmltest.c, tests/statstest.c,
tests/xencapstest.c, tests/xmconfigtest.c, tests/xml2sexprtest.c:
Adapt to changed xen location
* src/stats_linux.h, src/stats_linux.c: Remove xen specific block
stats APIs
* src/qemu_driver.c, src/uml_driver.c: Add missing sys/un.h include
uncovered after change to stats_linux.h
* src/xen/block_stats.h, src/xen/block_stats.c: Add xen specific
block stats APIs
2009-09-15 15:38:33 +00:00
|
|
|
#include <sys/un.h>
|
2007-02-14 01:40:09 +00:00
|
|
|
|
2008-11-04 22:30:33 +00:00
|
|
|
#include "virterror_internal.h"
|
2008-11-06 16:36:07 +00:00
|
|
|
#include "logging.h"
|
2008-11-04 23:22:06 +00:00
|
|
|
#include "datatypes.h"
|
2008-07-11 19:34:11 +00:00
|
|
|
#include "qemu_driver.h"
|
|
|
|
#include "qemu_conf.h"
|
2009-10-09 18:07:55 +00:00
|
|
|
#include "qemu_monitor.h"
|
2009-09-22 17:48:40 +00:00
|
|
|
#include "qemu_monitor_text.h"
|
2009-11-03 22:41:23 +00:00
|
|
|
#include "qemu_bridge_filter.h"
|
start using c-ctype functions
Up to now, we've been avoiding ctype functions like isspace, isdigit,
etc. because they are locale-dependent. Now that we have the c-ctype
functions, we can start using *them*, to make the code more readable
with changes like these:
- /* This may not work on EBCDIC. */
- if ((*p >= 'a' && *p <= 'z') ||
- (*p >= 'A' && *p <= 'Z') ||
- (*p >= '0' && *p <= '9'))
+ if (c_isalnum(*p))
- while ((*cur >= '0') && (*cur <= '9')) {
+ while (c_isdigit(*cur)) {
Also, some macros in conf.c used names that conflicted with
standard meaning of "BLANK" and "SPACE", so I've adjusted them
to be in line with the definition of e.g., isblank.
In addition, I've wrapped those statement macros with do {...} while (0),
so that we can't forget the ";" after a use. There was one like that
already (fixed below). The missing semicolon would mess up automatic
indenting.
* src/buf.c (virBufferURIEncodeString):
* src/conf.c (IS_EOL, SKIP_BLANKS_AND_EOL, SKIP_BLANKS)
(virConfParseLong, virConfParseValue, virConfParseName)
(virConfParseSeparator, virConfParseStatement, IS_BLANK, IS_CHAR)
(IS_DIGIT, IS_SPACE, SKIP_SPACES):
* src/nodeinfo.c:
* src/qemu_conf.c (qemudParseInterfaceXML):
* src/qemu_driver.c (qemudDomainBlockStats):
* src/sexpr.c:
* src/stats_linux.c:
* src/util.c (virParseNumber, virDiskNameToIndex):
* src/uuid.c (hextobin, virUUIDParse):
* src/virsh.c:
* src/xml.c (parseCpuNumber, virParseCpuSet):
2008-05-16 09:37:44 +00:00
|
|
|
#include "c-ctype.h"
|
2007-06-26 20:41:25 +00:00
|
|
|
#include "event.h"
|
2007-06-27 00:12:29 +00:00
|
|
|
#include "buf.h"
|
2007-07-19 16:22:40 +00:00
|
|
|
#include "util.h"
|
2007-07-25 23:16:30 +00:00
|
|
|
#include "nodeinfo.h"
|
2007-11-15 17:45:44 +00:00
|
|
|
#include "stats_linux.h"
|
2008-02-27 04:35:08 +00:00
|
|
|
#include "capabilities.h"
|
2008-05-22 16:20:31 +00:00
|
|
|
#include "memory.h"
|
2008-07-25 09:01:25 +00:00
|
|
|
#include "uuid.h"
|
2008-09-03 15:05:31 +00:00
|
|
|
#include "domain_conf.h"
|
2009-03-02 16:32:52 +00:00
|
|
|
#include "node_device_conf.h"
|
|
|
|
#include "pci.h"
|
2009-08-28 12:44:43 +00:00
|
|
|
#include "hostusb.h"
|
2009-11-16 15:22:34 +00:00
|
|
|
#include "processinfo.h"
|
2010-01-13 17:06:57 +00:00
|
|
|
#include "qemu_security_stacked.h"
|
|
|
|
#include "qemu_security_dac.h"
|
2009-07-09 13:10:59 +00:00
|
|
|
#include "cgroup.h"
|
2009-09-30 10:51:54 +00:00
|
|
|
#include "libvirt_internal.h"
|
2009-11-26 17:57:00 +00:00
|
|
|
#include "xml.h"
|
2009-12-18 15:24:14 +00:00
|
|
|
#include "cpu/cpu.h"
|
2009-03-03 12:03:44 +00:00
|
|
|
|
2007-06-26 20:41:25 +00:00
|
|
|
|
2009-01-20 17:13:33 +00:00
|
|
|
#define VIR_FROM_THIS VIR_FROM_QEMU
|
|
|
|
|
2009-10-09 20:13:06 +00:00
|
|
|
typedef struct _qemuDomainObjPrivate qemuDomainObjPrivate;
|
|
|
|
typedef qemuDomainObjPrivate *qemuDomainObjPrivatePtr;
|
|
|
|
struct _qemuDomainObjPrivate {
|
2009-11-03 18:26:32 +00:00
|
|
|
virCond jobCond; /* Use in conjunction with main virDomainObjPtr lock */
|
|
|
|
int jobActive; /* Non-zero if a job is active. Only 1 job is allowed at any time
|
|
|
|
* A job includes *all* monitor commands, even those just querying
|
|
|
|
* information, not merely actions */
|
|
|
|
|
2009-10-09 20:13:06 +00:00
|
|
|
qemuMonitorPtr mon;
|
2009-11-26 17:57:00 +00:00
|
|
|
virDomainChrDefPtr monConfig;
|
2009-11-03 18:59:18 +00:00
|
|
|
int monJSON;
|
2009-11-26 17:57:00 +00:00
|
|
|
|
|
|
|
int nvcpupids;
|
|
|
|
int *vcpupids;
|
2010-01-27 17:03:54 +00:00
|
|
|
|
|
|
|
qemuDomainPCIAddressSetPtr pciaddrs;
|
2009-10-09 20:13:06 +00:00
|
|
|
};
|
|
|
|
|
2007-06-29 13:23:13 +00:00
|
|
|
static int qemudShutdown(void);
|
|
|
|
|
2008-12-04 21:06:41 +00:00
|
|
|
static void qemuDriverLock(struct qemud_driver *driver)
|
|
|
|
{
|
2009-01-15 19:56:05 +00:00
|
|
|
virMutexLock(&driver->lock);
|
2008-12-04 21:06:41 +00:00
|
|
|
}
|
|
|
|
static void qemuDriverUnlock(struct qemud_driver *driver)
|
|
|
|
{
|
2009-01-15 19:56:05 +00:00
|
|
|
virMutexUnlock(&driver->lock);
|
2008-12-04 21:06:41 +00:00
|
|
|
}
|
|
|
|
|
2008-12-04 21:09:20 +00:00
|
|
|
static void qemuDomainEventFlush(int timer, void *opaque);
|
|
|
|
static void qemuDomainEventQueue(struct qemud_driver *driver,
|
|
|
|
virDomainEventPtr event);
|
2008-10-23 13:18:18 +00:00
|
|
|
|
2007-07-12 15:09:01 +00:00
|
|
|
static int qemudStartVMDaemon(virConnectPtr conn,
|
|
|
|
struct qemud_driver *driver,
|
2008-07-11 19:34:11 +00:00
|
|
|
virDomainObjPtr vm,
|
2009-01-29 17:27:54 +00:00
|
|
|
const char *migrateFrom,
|
|
|
|
int stdin_fd);
|
2007-06-26 22:42:47 +00:00
|
|
|
|
2007-07-24 14:24:52 +00:00
|
|
|
static void qemudShutdownVMDaemon(virConnectPtr conn,
|
|
|
|
struct qemud_driver *driver,
|
2008-07-11 19:34:11 +00:00
|
|
|
virDomainObjPtr vm);
|
2007-06-26 22:42:47 +00:00
|
|
|
|
2008-05-07 16:16:44 +00:00
|
|
|
static int qemudDomainGetMaxVcpus(virDomainPtr dom);
|
2008-10-23 13:18:18 +00:00
|
|
|
|
2009-09-23 10:49:14 +00:00
|
|
|
static int qemuDetectVcpuPIDs(virConnectPtr conn,
|
2009-11-18 15:58:32 +00:00
|
|
|
struct qemud_driver *driver,
|
2009-09-23 10:49:14 +00:00
|
|
|
virDomainObjPtr vm);
|
2008-05-07 16:16:44 +00:00
|
|
|
|
2009-08-17 14:05:23 +00:00
|
|
|
static int qemuUpdateActivePciHostdevs(struct qemud_driver *driver,
|
|
|
|
virDomainDefPtr def);
|
|
|
|
|
2008-01-14 14:05:25 +00:00
|
|
|
static struct qemud_driver *qemu_driver = NULL;
|
2007-06-26 22:13:21 +00:00
|
|
|
|
2009-10-09 19:13:29 +00:00
|
|
|
|
|
|
|
static void *qemuDomainObjPrivateAlloc(void)
|
|
|
|
{
|
|
|
|
qemuDomainObjPrivatePtr priv;
|
|
|
|
|
|
|
|
if (VIR_ALLOC(priv) < 0)
|
|
|
|
return NULL;
|
|
|
|
|
|
|
|
return priv;
|
|
|
|
}
|
|
|
|
|
|
|
|
static void qemuDomainObjPrivateFree(void *data)
|
|
|
|
{
|
|
|
|
qemuDomainObjPrivatePtr priv = data;
|
|
|
|
|
2010-01-27 17:03:54 +00:00
|
|
|
qemuDomainPCIAddressSetFree(priv->pciaddrs);
|
2009-11-26 17:57:00 +00:00
|
|
|
virDomainChrDefFree(priv->monConfig);
|
|
|
|
VIR_FREE(priv->vcpupids);
|
|
|
|
|
2009-10-09 19:13:29 +00:00
|
|
|
/* This should never be non-NULL if we get here, but just in case... */
|
|
|
|
if (priv->mon) {
|
|
|
|
VIR_ERROR0("Unexpected QEMU monitor still active during domain deletion");
|
|
|
|
qemuMonitorClose(priv->mon);
|
|
|
|
}
|
|
|
|
VIR_FREE(priv);
|
|
|
|
}
|
|
|
|
|
|
|
|
|
2009-11-26 17:57:00 +00:00
|
|
|
static int qemuDomainObjPrivateXMLFormat(virBufferPtr buf, void *data)
|
|
|
|
{
|
|
|
|
qemuDomainObjPrivatePtr priv = data;
|
|
|
|
const char *monitorpath;
|
|
|
|
|
|
|
|
/* priv->monitor_chr is set only for qemu */
|
|
|
|
if (priv->monConfig) {
|
|
|
|
switch (priv->monConfig->type) {
|
|
|
|
case VIR_DOMAIN_CHR_TYPE_UNIX:
|
|
|
|
monitorpath = priv->monConfig->data.nix.path;
|
|
|
|
break;
|
|
|
|
default:
|
|
|
|
case VIR_DOMAIN_CHR_TYPE_PTY:
|
|
|
|
monitorpath = priv->monConfig->data.file.path;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
|
|
|
virBufferEscapeString(buf, " <monitor path='%s'", monitorpath);
|
2009-11-03 18:59:18 +00:00
|
|
|
if (priv->monJSON)
|
|
|
|
virBufferAddLit(buf, " json='1'");
|
2009-11-26 17:57:00 +00:00
|
|
|
virBufferVSprintf(buf, " type='%s'/>\n",
|
|
|
|
virDomainChrTypeToString(priv->monConfig->type));
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
if (priv->nvcpupids) {
|
|
|
|
int i;
|
|
|
|
virBufferAddLit(buf, " <vcpus>\n");
|
|
|
|
for (i = 0 ; i < priv->nvcpupids ; i++) {
|
|
|
|
virBufferVSprintf(buf, " <vcpu pid='%d'/>\n", priv->vcpupids[i]);
|
|
|
|
}
|
|
|
|
virBufferAddLit(buf, " </vcpus>\n");
|
|
|
|
}
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
static int qemuDomainObjPrivateXMLParse(xmlXPathContextPtr ctxt, void *data)
|
|
|
|
{
|
|
|
|
qemuDomainObjPrivatePtr priv = data;
|
|
|
|
char *monitorpath;
|
|
|
|
char *tmp;
|
|
|
|
int n, i;
|
|
|
|
xmlNodePtr *nodes = NULL;
|
|
|
|
|
|
|
|
if (VIR_ALLOC(priv->monConfig) < 0) {
|
|
|
|
virReportOOMError(NULL);
|
|
|
|
goto error;
|
|
|
|
}
|
|
|
|
|
Convert character devices over to use -device
The current character device syntax uses either
-serial tty,path=/dev/ttyS2
Or
-chardev tty,id=serial0,path=/dev/ttyS2 -serial chardev:serial0
With the new -device support, we now prefer
-chardev file,id=serial0,path=/tmp/serial.log -device isa-serial,chardev=serial0
This patch changes the existing -chardev syntax to use this new
scheme, and fallbacks to the old plain -serial syntax for old
QEMU.
The monitor device changes to
-chardev socket,id=monitor,path=/tmp/test-monitor,server,nowait -mon chardev=monitor
In addition, this patch adds --nodefaults, which kills off the
default serial, parallel, vga and nic devices. THis avoids the
need for us to explicitly turn each off
2009-12-14 18:04:35 +00:00
|
|
|
if (!(priv->monConfig->info.alias = strdup("monitor"))) {
|
|
|
|
virReportOOMError(NULL);
|
|
|
|
goto error;
|
|
|
|
}
|
|
|
|
|
2009-11-26 17:57:00 +00:00
|
|
|
if (!(monitorpath =
|
|
|
|
virXPathString(NULL, "string(./monitor[1]/@path)", ctxt))) {
|
|
|
|
qemudReportError(NULL, NULL, NULL, VIR_ERR_INTERNAL_ERROR,
|
|
|
|
"%s", _("no monitor path"));
|
|
|
|
goto error;
|
|
|
|
}
|
|
|
|
|
|
|
|
tmp = virXPathString(NULL, "string(./monitor[1]/@type)", ctxt);
|
|
|
|
if (tmp)
|
|
|
|
priv->monConfig->type = virDomainChrTypeFromString(tmp);
|
|
|
|
else
|
|
|
|
priv->monConfig->type = VIR_DOMAIN_CHR_TYPE_PTY;
|
|
|
|
VIR_FREE(tmp);
|
|
|
|
|
2009-12-09 18:28:30 +00:00
|
|
|
if (virXPathBoolean(NULL, "count(./monitor[@json = '1']) > 0", ctxt)) {
|
2009-11-03 18:59:18 +00:00
|
|
|
priv->monJSON = 1;
|
2009-12-09 18:28:30 +00:00
|
|
|
} else {
|
|
|
|
priv->monJSON = 0;
|
|
|
|
}
|
2009-11-03 18:59:18 +00:00
|
|
|
|
2009-11-26 17:57:00 +00:00
|
|
|
switch (priv->monConfig->type) {
|
|
|
|
case VIR_DOMAIN_CHR_TYPE_PTY:
|
|
|
|
priv->monConfig->data.file.path = monitorpath;
|
|
|
|
break;
|
|
|
|
case VIR_DOMAIN_CHR_TYPE_UNIX:
|
|
|
|
priv->monConfig->data.nix.path = monitorpath;
|
|
|
|
break;
|
|
|
|
default:
|
|
|
|
VIR_FREE(monitorpath);
|
|
|
|
qemudReportError(NULL, NULL, NULL, VIR_ERR_INTERNAL_ERROR,
|
|
|
|
_("unsupported monitor type '%s'"),
|
|
|
|
virDomainChrTypeToString(priv->monConfig->type));
|
|
|
|
goto error;
|
|
|
|
}
|
|
|
|
|
|
|
|
n = virXPathNodeSet(NULL, "./vcpus/vcpu", ctxt, &nodes);
|
|
|
|
if (n < 0)
|
|
|
|
goto error;
|
|
|
|
if (n) {
|
|
|
|
priv->nvcpupids = n;
|
|
|
|
if (VIR_REALLOC_N(priv->vcpupids, priv->nvcpupids) < 0) {
|
|
|
|
virReportOOMError(NULL);
|
|
|
|
goto error;
|
|
|
|
}
|
|
|
|
|
|
|
|
for (i = 0 ; i < n ; i++) {
|
|
|
|
char *pidstr = virXMLPropString(nodes[i], "pid");
|
|
|
|
if (!pidstr)
|
|
|
|
goto error;
|
|
|
|
|
|
|
|
if (virStrToLong_i(pidstr, NULL, 10, &(priv->vcpupids[i])) < 0) {
|
|
|
|
VIR_FREE(pidstr);
|
|
|
|
goto error;
|
|
|
|
}
|
|
|
|
VIR_FREE(pidstr);
|
|
|
|
}
|
|
|
|
VIR_FREE(nodes);
|
|
|
|
}
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
|
|
|
|
error:
|
Convert character devices over to use -device
The current character device syntax uses either
-serial tty,path=/dev/ttyS2
Or
-chardev tty,id=serial0,path=/dev/ttyS2 -serial chardev:serial0
With the new -device support, we now prefer
-chardev file,id=serial0,path=/tmp/serial.log -device isa-serial,chardev=serial0
This patch changes the existing -chardev syntax to use this new
scheme, and fallbacks to the old plain -serial syntax for old
QEMU.
The monitor device changes to
-chardev socket,id=monitor,path=/tmp/test-monitor,server,nowait -mon chardev=monitor
In addition, this patch adds --nodefaults, which kills off the
default serial, parallel, vga and nic devices. THis avoids the
need for us to explicitly turn each off
2009-12-14 18:04:35 +00:00
|
|
|
virDomainChrDefFree(priv->monConfig);
|
|
|
|
priv->monConfig = NULL;
|
2009-11-26 17:57:00 +00:00
|
|
|
VIR_FREE(nodes);
|
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
|
2009-11-03 18:26:32 +00:00
|
|
|
/*
|
|
|
|
* obj must be locked before calling, qemud_driver must NOT be locked
|
|
|
|
*
|
|
|
|
* This must be called by anything that will change the VM state
|
|
|
|
* in any way, or anything that will use the QEMU monitor.
|
|
|
|
*
|
|
|
|
* Upon successful return, the object will have its ref count increased,
|
|
|
|
* successful calls must be followed by EndJob eventually
|
|
|
|
*/
|
2009-11-03 18:34:20 +00:00
|
|
|
|
|
|
|
/* Give up waiting for mutex after 30 seconds */
|
|
|
|
#define QEMU_JOB_WAIT_TIME (1000ull * 30)
|
|
|
|
|
2009-11-03 18:26:32 +00:00
|
|
|
static int qemuDomainObjBeginJob(virDomainObjPtr obj) ATTRIBUTE_RETURN_CHECK;
|
|
|
|
static int qemuDomainObjBeginJob(virDomainObjPtr obj)
|
|
|
|
{
|
|
|
|
qemuDomainObjPrivatePtr priv = obj->privateData;
|
2009-11-03 18:34:20 +00:00
|
|
|
struct timeval now;
|
|
|
|
unsigned long long then;
|
|
|
|
|
|
|
|
if (gettimeofday(&now, NULL) < 0) {
|
|
|
|
virReportSystemError(NULL, errno, "%s",
|
|
|
|
_("cannot get time of day"));
|
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
then = (now.tv_sec * 1000ull) + (now.tv_usec / 1000);
|
|
|
|
then += QEMU_JOB_WAIT_TIME;
|
2009-11-03 18:26:32 +00:00
|
|
|
|
|
|
|
virDomainObjRef(obj);
|
|
|
|
|
|
|
|
while (priv->jobActive) {
|
2009-11-03 18:34:20 +00:00
|
|
|
if (virCondWaitUntil(&priv->jobCond, &obj->lock, then) < 0) {
|
2009-11-03 18:26:32 +00:00
|
|
|
virDomainObjUnref(obj);
|
2009-11-03 18:34:20 +00:00
|
|
|
if (errno == ETIMEDOUT)
|
|
|
|
qemudReportError(NULL, NULL, NULL, VIR_ERR_OPERATION_TIMEOUT,
|
|
|
|
"%s", _("cannot acquire state change lock"));
|
|
|
|
else
|
|
|
|
virReportSystemError(NULL, errno,
|
|
|
|
"%s", _("cannot acquire job mutex"));
|
2009-11-03 18:26:32 +00:00
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
priv->jobActive = 1;
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* obj must be locked before calling, qemud_driver must be locked
|
|
|
|
*
|
|
|
|
* This must be called by anything that will change the VM state
|
|
|
|
* in any way, or anything that will use the QEMU monitor.
|
|
|
|
*/
|
|
|
|
static int qemuDomainObjBeginJobWithDriver(struct qemud_driver *driver,
|
|
|
|
virDomainObjPtr obj) ATTRIBUTE_RETURN_CHECK;
|
|
|
|
static int qemuDomainObjBeginJobWithDriver(struct qemud_driver *driver,
|
|
|
|
virDomainObjPtr obj)
|
|
|
|
{
|
|
|
|
qemuDomainObjPrivatePtr priv = obj->privateData;
|
2009-11-03 18:34:20 +00:00
|
|
|
struct timeval now;
|
|
|
|
unsigned long long then;
|
|
|
|
|
|
|
|
if (gettimeofday(&now, NULL) < 0) {
|
|
|
|
virReportSystemError(NULL, errno, "%s",
|
|
|
|
_("cannot get time of day"));
|
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
then = (now.tv_sec * 1000ull) + (now.tv_usec / 1000);
|
|
|
|
then += QEMU_JOB_WAIT_TIME;
|
2009-11-03 18:26:32 +00:00
|
|
|
|
|
|
|
virDomainObjRef(obj);
|
|
|
|
qemuDriverUnlock(driver);
|
|
|
|
|
|
|
|
while (priv->jobActive) {
|
2009-11-03 18:34:20 +00:00
|
|
|
if (virCondWaitUntil(&priv->jobCond, &obj->lock, then) < 0) {
|
2009-11-03 18:26:32 +00:00
|
|
|
virDomainObjUnref(obj);
|
2009-11-03 18:34:20 +00:00
|
|
|
if (errno == ETIMEDOUT)
|
|
|
|
qemudReportError(NULL, NULL, NULL, VIR_ERR_OPERATION_TIMEOUT,
|
|
|
|
"%s", _("cannot acquire state change lock"));
|
|
|
|
else
|
|
|
|
virReportSystemError(NULL, errno,
|
|
|
|
"%s", _("cannot acquire job mutex"));
|
2009-12-02 23:03:06 +00:00
|
|
|
qemuDriverLock(driver);
|
2009-11-03 18:26:32 +00:00
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
priv->jobActive = 1;
|
|
|
|
|
|
|
|
virDomainObjUnlock(obj);
|
|
|
|
qemuDriverLock(driver);
|
|
|
|
virDomainObjLock(obj);
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* obj must be locked before calling, qemud_driver does not matter
|
|
|
|
*
|
|
|
|
* To be called after completing the work associated with the
|
|
|
|
* earlier qemuDomainBeginJob() call
|
2009-12-08 14:42:43 +00:00
|
|
|
*
|
|
|
|
* Returns remaining refcount on 'obj', maybe 0 to indicated it
|
|
|
|
* was deleted
|
2009-11-03 18:26:32 +00:00
|
|
|
*/
|
2009-12-08 14:42:43 +00:00
|
|
|
static int ATTRIBUTE_RETURN_CHECK qemuDomainObjEndJob(virDomainObjPtr obj)
|
2009-11-03 18:26:32 +00:00
|
|
|
{
|
|
|
|
qemuDomainObjPrivatePtr priv = obj->privateData;
|
|
|
|
|
|
|
|
priv->jobActive = 0;
|
|
|
|
virCondSignal(&priv->jobCond);
|
|
|
|
|
2009-12-08 14:42:43 +00:00
|
|
|
return virDomainObjUnref(obj);
|
2009-11-03 18:26:32 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
/*
|
|
|
|
* obj must be locked before calling, qemud_driver must be unlocked
|
|
|
|
*
|
|
|
|
* To be called immediately before any QEMU monitor API call
|
|
|
|
* Must have alrady called qemuDomainObjBeginJob().
|
|
|
|
*
|
|
|
|
* To be followed with qemuDomainObjExitMonitor() once complete
|
|
|
|
*/
|
2009-10-13 14:27:58 +00:00
|
|
|
static void qemuDomainObjEnterMonitor(virDomainObjPtr obj)
|
|
|
|
{
|
|
|
|
qemuDomainObjPrivatePtr priv = obj->privateData;
|
|
|
|
|
|
|
|
qemuMonitorLock(priv->mon);
|
2009-11-26 13:29:29 +00:00
|
|
|
qemuMonitorRef(priv->mon);
|
2009-11-03 18:26:32 +00:00
|
|
|
virDomainObjUnlock(obj);
|
2009-10-13 14:27:58 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
|
2009-11-03 18:26:32 +00:00
|
|
|
/* obj must NOT be locked before calling, qemud_driver must be unlocked
|
|
|
|
*
|
|
|
|
* Should be paired with an earlier qemuDomainObjEnterMonitor() call
|
|
|
|
*/
|
2009-10-13 14:27:58 +00:00
|
|
|
static void qemuDomainObjExitMonitor(virDomainObjPtr obj)
|
|
|
|
{
|
|
|
|
qemuDomainObjPrivatePtr priv = obj->privateData;
|
2009-11-26 13:29:29 +00:00
|
|
|
int refs;
|
|
|
|
|
|
|
|
refs = qemuMonitorUnref(priv->mon);
|
|
|
|
|
|
|
|
if (refs > 0)
|
|
|
|
qemuMonitorUnlock(priv->mon);
|
2009-10-13 14:27:58 +00:00
|
|
|
|
2009-11-03 18:26:32 +00:00
|
|
|
virDomainObjLock(obj);
|
2009-11-26 13:29:29 +00:00
|
|
|
|
|
|
|
if (refs == 0) {
|
|
|
|
virDomainObjUnref(obj);
|
|
|
|
priv->mon = NULL;
|
|
|
|
}
|
2009-11-03 18:26:32 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
/*
|
|
|
|
* obj must be locked before calling, qemud_driver must be locked
|
|
|
|
*
|
|
|
|
* To be called immediately before any QEMU monitor API call
|
|
|
|
* Must have alrady called qemuDomainObjBeginJob().
|
|
|
|
*
|
|
|
|
* To be followed with qemuDomainObjExitMonitorWithDriver() once complete
|
|
|
|
*/
|
|
|
|
static void qemuDomainObjEnterMonitorWithDriver(struct qemud_driver *driver, virDomainObjPtr obj)
|
|
|
|
{
|
|
|
|
qemuDomainObjPrivatePtr priv = obj->privateData;
|
|
|
|
|
|
|
|
qemuMonitorLock(priv->mon);
|
2009-11-26 13:29:29 +00:00
|
|
|
qemuMonitorRef(priv->mon);
|
2009-11-03 18:26:32 +00:00
|
|
|
virDomainObjUnlock(obj);
|
|
|
|
qemuDriverUnlock(driver);
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
/* obj must NOT be locked before calling, qemud_driver must be unlocked,
|
|
|
|
* and will be locked after returning
|
|
|
|
*
|
|
|
|
* Should be paired with an earlier qemuDomainObjEnterMonitor() call
|
|
|
|
*/
|
|
|
|
static void qemuDomainObjExitMonitorWithDriver(struct qemud_driver *driver, virDomainObjPtr obj)
|
|
|
|
{
|
|
|
|
qemuDomainObjPrivatePtr priv = obj->privateData;
|
2009-11-26 13:29:29 +00:00
|
|
|
int refs;
|
|
|
|
|
|
|
|
refs = qemuMonitorUnref(priv->mon);
|
|
|
|
|
|
|
|
if (refs > 0)
|
|
|
|
qemuMonitorUnlock(priv->mon);
|
2009-11-03 18:26:32 +00:00
|
|
|
|
|
|
|
qemuDriverLock(driver);
|
|
|
|
virDomainObjLock(obj);
|
2009-11-26 13:29:29 +00:00
|
|
|
|
|
|
|
if (refs == 0) {
|
|
|
|
virDomainObjUnref(obj);
|
|
|
|
priv->mon = NULL;
|
|
|
|
}
|
2009-10-13 14:27:58 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
|
2009-07-22 15:08:04 +00:00
|
|
|
static int qemuCgroupControllerActive(struct qemud_driver *driver,
|
|
|
|
int controller)
|
|
|
|
{
|
|
|
|
if (driver->cgroup == NULL)
|
|
|
|
return 0;
|
|
|
|
if (driver->cgroupControllers & (1 << controller))
|
|
|
|
return 1;
|
|
|
|
return 0;
|
|
|
|
}
|
2007-06-26 22:13:21 +00:00
|
|
|
|
2009-01-11 11:18:31 +00:00
|
|
|
static int
|
2009-06-12 13:20:13 +00:00
|
|
|
qemudLogFD(virConnectPtr conn, struct qemud_driver *driver, const char* name)
|
2009-01-11 11:18:31 +00:00
|
|
|
{
|
|
|
|
char logfile[PATH_MAX];
|
|
|
|
mode_t logmode;
|
2009-01-11 11:21:29 +00:00
|
|
|
int ret, fd = -1;
|
2009-01-11 11:18:31 +00:00
|
|
|
|
2009-06-12 13:20:13 +00:00
|
|
|
if ((ret = snprintf(logfile, sizeof(logfile), "%s/%s.log",
|
|
|
|
driver->logDir, name))
|
2009-01-11 11:21:29 +00:00
|
|
|
< 0 || ret >= sizeof(logfile)) {
|
2009-01-20 17:13:33 +00:00
|
|
|
virReportOOMError(conn);
|
2009-01-11 11:18:31 +00:00
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
|
|
|
|
logmode = O_CREAT | O_WRONLY;
|
2009-06-12 13:20:13 +00:00
|
|
|
/* Only logrotate files in /var/log, so only append if running privileged */
|
|
|
|
if (driver->privileged)
|
2009-01-11 11:18:31 +00:00
|
|
|
logmode |= O_APPEND;
|
2009-06-12 13:20:13 +00:00
|
|
|
else
|
|
|
|
logmode |= O_TRUNC;
|
|
|
|
|
2009-01-11 11:18:31 +00:00
|
|
|
if ((fd = open(logfile, logmode, S_IRUSR | S_IWUSR)) < 0) {
|
2009-01-20 17:13:33 +00:00
|
|
|
virReportSystemError(conn, errno,
|
|
|
|
_("failed to create logfile %s"),
|
|
|
|
logfile);
|
2009-01-11 11:18:31 +00:00
|
|
|
return -1;
|
|
|
|
}
|
2009-02-05 16:27:17 +00:00
|
|
|
if (virSetCloseExec(fd) < 0) {
|
2009-01-20 17:13:33 +00:00
|
|
|
virReportSystemError(conn, errno, "%s",
|
|
|
|
_("Unable to set VM logfile close-on-exec flag"));
|
2009-01-11 11:18:31 +00:00
|
|
|
close(fd);
|
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
return fd;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
2009-01-20 15:52:11 +00:00
|
|
|
static int
|
|
|
|
qemudLogReadFD(virConnectPtr conn, const char* logDir, const char* name, off_t pos)
|
|
|
|
{
|
|
|
|
char logfile[PATH_MAX];
|
|
|
|
mode_t logmode = O_RDONLY;
|
|
|
|
int ret, fd = -1;
|
|
|
|
|
|
|
|
if ((ret = snprintf(logfile, sizeof(logfile), "%s/%s.log", logDir, name))
|
|
|
|
< 0 || ret >= sizeof(logfile)) {
|
|
|
|
qemudReportError(conn, NULL, NULL, VIR_ERR_INTERNAL_ERROR,
|
|
|
|
_("failed to build logfile name %s/%s.log"),
|
|
|
|
logDir, name);
|
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
if ((fd = open(logfile, logmode)) < 0) {
|
2009-02-05 16:11:25 +00:00
|
|
|
virReportSystemError(conn, errno,
|
|
|
|
_("failed to create logfile %s"),
|
|
|
|
logfile);
|
2009-01-20 15:52:11 +00:00
|
|
|
return -1;
|
|
|
|
}
|
2009-02-05 16:27:17 +00:00
|
|
|
if (virSetCloseExec(fd) < 0) {
|
2009-02-05 16:11:25 +00:00
|
|
|
virReportSystemError(conn, errno, "%s",
|
|
|
|
_("Unable to set VM logfile close-on-exec flag"));
|
2009-01-20 15:52:11 +00:00
|
|
|
close(fd);
|
|
|
|
return -1;
|
|
|
|
}
|
2010-02-01 21:17:44 +00:00
|
|
|
if (pos < 0 || lseek(fd, pos, SEEK_SET) < 0) {
|
|
|
|
virReportSystemError(conn, pos < 0 ? 0 : errno,
|
2009-02-05 16:11:25 +00:00
|
|
|
_("Unable to seek to %lld in %s"),
|
|
|
|
(long long) pos, logfile);
|
2009-01-20 15:52:11 +00:00
|
|
|
close(fd);
|
|
|
|
}
|
|
|
|
return fd;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
Convert virDomainObjListPtr to use a hash of domain objects
The current virDomainObjListPtr object stores domain objects in
an array. This means that to find a particular objects requires
O(n) time, and more critically acquiring O(n) mutex locks.
The new impl replaces the array with a virHashTable, keyed off
UUID. Finding a object based on UUID is now O(1) time, and only
requires a single mutex lock. Finding by name/id is unchanged
in complexity.
In changing this, all code which iterates over the array had
to be updated to use a hash table iterator function callback.
Several of the functions which were identically duplicating
across all drivers were pulled into domain_conf.c
* src/conf/domain_conf.h, src/conf/domain_conf.c: Change
virDomainObjListPtr to use virHashTable. Add a initializer
method virDomainObjListInit, and rename virDomainObjListFree
to virDomainObjListDeinit, since its not actually freeing
the container, only its contents. Also add some convenient
methods virDomainObjListGetInactiveNames,
virDomainObjListGetActiveIDs and virDomainObjListNumOfDomains
which can be used to implement the correspondingly named
public API entry points in drivers
* src/libvirt_private.syms: Export new methods from domain_conf.h
* src/lxc/lxc_driver.c, src/opennebula/one_driver.c,
src/openvz/openvz_conf.c, src/openvz/openvz_driver.c,
src/qemu/qemu_driver.c, src/test/test_driver.c,
src/uml/uml_driver.c, src/vbox/vbox_tmpl.c: Update all code
to deal with hash tables instead of arrays for domains
2009-10-09 11:33:51 +00:00
|
|
|
struct qemuAutostartData {
|
|
|
|
struct qemud_driver *driver;
|
|
|
|
virConnectPtr conn;
|
|
|
|
};
|
|
|
|
static void
|
|
|
|
qemuAutostartDomain(void *payload, const char *name ATTRIBUTE_UNUSED, void *opaque)
|
|
|
|
{
|
|
|
|
virDomainObjPtr vm = payload;
|
|
|
|
struct qemuAutostartData *data = opaque;
|
|
|
|
|
|
|
|
virDomainObjLock(vm);
|
|
|
|
if (vm->autostart &&
|
Rename internal APis
Rename virDomainIsActive to virDomainObjIsActive, and
virInterfaceIsActive to virInterfaceObjIsActive and finally
virNetworkIsActive to virNetworkObjIsActive.
* src/conf/domain_conf.c, src/conf/domain_conf.h,
src/conf/interface_conf.h, src/conf/network_conf.c,
src/conf/network_conf.h, src/lxc/lxc_driver.c,
src/network/bridge_driver.c, src/opennebula/one_driver.c,
src/openvz/openvz_driver.c, src/qemu/qemu_driver.c,
src/test/test_driver.c, src/uml/uml_driver.c: Update for
renamed APIs.
2009-10-20 14:51:03 +00:00
|
|
|
!virDomainObjIsActive(vm)) {
|
Convert virDomainObjListPtr to use a hash of domain objects
The current virDomainObjListPtr object stores domain objects in
an array. This means that to find a particular objects requires
O(n) time, and more critically acquiring O(n) mutex locks.
The new impl replaces the array with a virHashTable, keyed off
UUID. Finding a object based on UUID is now O(1) time, and only
requires a single mutex lock. Finding by name/id is unchanged
in complexity.
In changing this, all code which iterates over the array had
to be updated to use a hash table iterator function callback.
Several of the functions which were identically duplicating
across all drivers were pulled into domain_conf.c
* src/conf/domain_conf.h, src/conf/domain_conf.c: Change
virDomainObjListPtr to use virHashTable. Add a initializer
method virDomainObjListInit, and rename virDomainObjListFree
to virDomainObjListDeinit, since its not actually freeing
the container, only its contents. Also add some convenient
methods virDomainObjListGetInactiveNames,
virDomainObjListGetActiveIDs and virDomainObjListNumOfDomains
which can be used to implement the correspondingly named
public API entry points in drivers
* src/libvirt_private.syms: Export new methods from domain_conf.h
* src/lxc/lxc_driver.c, src/opennebula/one_driver.c,
src/openvz/openvz_conf.c, src/openvz/openvz_driver.c,
src/qemu/qemu_driver.c, src/test/test_driver.c,
src/uml/uml_driver.c, src/vbox/vbox_tmpl.c: Update all code
to deal with hash tables instead of arrays for domains
2009-10-09 11:33:51 +00:00
|
|
|
int ret;
|
|
|
|
|
|
|
|
virResetLastError();
|
|
|
|
ret = qemudStartVMDaemon(data->conn, data->driver, vm, NULL, -1);
|
|
|
|
if (ret < 0) {
|
|
|
|
virErrorPtr err = virGetLastError();
|
2010-01-19 13:17:20 +00:00
|
|
|
VIR_ERROR(_("Failed to autostart VM '%s': %s"),
|
Convert virDomainObjListPtr to use a hash of domain objects
The current virDomainObjListPtr object stores domain objects in
an array. This means that to find a particular objects requires
O(n) time, and more critically acquiring O(n) mutex locks.
The new impl replaces the array with a virHashTable, keyed off
UUID. Finding a object based on UUID is now O(1) time, and only
requires a single mutex lock. Finding by name/id is unchanged
in complexity.
In changing this, all code which iterates over the array had
to be updated to use a hash table iterator function callback.
Several of the functions which were identically duplicating
across all drivers were pulled into domain_conf.c
* src/conf/domain_conf.h, src/conf/domain_conf.c: Change
virDomainObjListPtr to use virHashTable. Add a initializer
method virDomainObjListInit, and rename virDomainObjListFree
to virDomainObjListDeinit, since its not actually freeing
the container, only its contents. Also add some convenient
methods virDomainObjListGetInactiveNames,
virDomainObjListGetActiveIDs and virDomainObjListNumOfDomains
which can be used to implement the correspondingly named
public API entry points in drivers
* src/libvirt_private.syms: Export new methods from domain_conf.h
* src/lxc/lxc_driver.c, src/opennebula/one_driver.c,
src/openvz/openvz_conf.c, src/openvz/openvz_driver.c,
src/qemu/qemu_driver.c, src/test/test_driver.c,
src/uml/uml_driver.c, src/vbox/vbox_tmpl.c: Update all code
to deal with hash tables instead of arrays for domains
2009-10-09 11:33:51 +00:00
|
|
|
vm->def->name,
|
|
|
|
err ? err->message : "");
|
|
|
|
} else {
|
|
|
|
virDomainEventPtr event =
|
|
|
|
virDomainEventNewFromObj(vm,
|
|
|
|
VIR_DOMAIN_EVENT_STARTED,
|
|
|
|
VIR_DOMAIN_EVENT_STARTED_BOOTED);
|
|
|
|
if (event)
|
|
|
|
qemuDomainEventQueue(data->driver, event);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
virDomainObjUnlock(vm);
|
|
|
|
}
|
|
|
|
|
2008-10-10 14:20:37 +00:00
|
|
|
static void
|
|
|
|
qemudAutostartConfigs(struct qemud_driver *driver) {
|
2008-12-08 11:18:47 +00:00
|
|
|
/* XXX: Figure out a better way todo this. The domain
|
|
|
|
* startup code needs a connection handle in order
|
|
|
|
* to lookup the bridge associated with a virtual
|
|
|
|
* network
|
|
|
|
*/
|
2009-06-12 13:20:13 +00:00
|
|
|
virConnectPtr conn = virConnectOpen(driver->privileged ?
|
|
|
|
"qemu:///system" :
|
|
|
|
"qemu:///session");
|
2008-12-08 11:18:47 +00:00
|
|
|
/* Ignoring NULL conn which is mostly harmless here */
|
Convert virDomainObjListPtr to use a hash of domain objects
The current virDomainObjListPtr object stores domain objects in
an array. This means that to find a particular objects requires
O(n) time, and more critically acquiring O(n) mutex locks.
The new impl replaces the array with a virHashTable, keyed off
UUID. Finding a object based on UUID is now O(1) time, and only
requires a single mutex lock. Finding by name/id is unchanged
in complexity.
In changing this, all code which iterates over the array had
to be updated to use a hash table iterator function callback.
Several of the functions which were identically duplicating
across all drivers were pulled into domain_conf.c
* src/conf/domain_conf.h, src/conf/domain_conf.c: Change
virDomainObjListPtr to use virHashTable. Add a initializer
method virDomainObjListInit, and rename virDomainObjListFree
to virDomainObjListDeinit, since its not actually freeing
the container, only its contents. Also add some convenient
methods virDomainObjListGetInactiveNames,
virDomainObjListGetActiveIDs and virDomainObjListNumOfDomains
which can be used to implement the correspondingly named
public API entry points in drivers
* src/libvirt_private.syms: Export new methods from domain_conf.h
* src/lxc/lxc_driver.c, src/opennebula/one_driver.c,
src/openvz/openvz_conf.c, src/openvz/openvz_driver.c,
src/qemu/qemu_driver.c, src/test/test_driver.c,
src/uml/uml_driver.c, src/vbox/vbox_tmpl.c: Update all code
to deal with hash tables instead of arrays for domains
2009-10-09 11:33:51 +00:00
|
|
|
struct qemuAutostartData data = { driver, conn };
|
2008-10-10 14:20:37 +00:00
|
|
|
|
2009-05-19 11:06:25 +00:00
|
|
|
qemuDriverLock(driver);
|
Convert virDomainObjListPtr to use a hash of domain objects
The current virDomainObjListPtr object stores domain objects in
an array. This means that to find a particular objects requires
O(n) time, and more critically acquiring O(n) mutex locks.
The new impl replaces the array with a virHashTable, keyed off
UUID. Finding a object based on UUID is now O(1) time, and only
requires a single mutex lock. Finding by name/id is unchanged
in complexity.
In changing this, all code which iterates over the array had
to be updated to use a hash table iterator function callback.
Several of the functions which were identically duplicating
across all drivers were pulled into domain_conf.c
* src/conf/domain_conf.h, src/conf/domain_conf.c: Change
virDomainObjListPtr to use virHashTable. Add a initializer
method virDomainObjListInit, and rename virDomainObjListFree
to virDomainObjListDeinit, since its not actually freeing
the container, only its contents. Also add some convenient
methods virDomainObjListGetInactiveNames,
virDomainObjListGetActiveIDs and virDomainObjListNumOfDomains
which can be used to implement the correspondingly named
public API entry points in drivers
* src/libvirt_private.syms: Export new methods from domain_conf.h
* src/lxc/lxc_driver.c, src/opennebula/one_driver.c,
src/openvz/openvz_conf.c, src/openvz/openvz_driver.c,
src/qemu/qemu_driver.c, src/test/test_driver.c,
src/uml/uml_driver.c, src/vbox/vbox_tmpl.c: Update all code
to deal with hash tables instead of arrays for domains
2009-10-09 11:33:51 +00:00
|
|
|
virHashForEach(driver->domains.objs, qemuAutostartDomain, &data);
|
2009-05-19 11:06:25 +00:00
|
|
|
qemuDriverUnlock(driver);
|
2008-12-08 11:18:47 +00:00
|
|
|
|
2009-03-16 10:30:04 +00:00
|
|
|
if (conn)
|
|
|
|
virConnectClose(conn);
|
2007-06-26 20:45:21 +00:00
|
|
|
}
|
|
|
|
|
2008-12-20 13:17:49 +00:00
|
|
|
|
|
|
|
/**
|
|
|
|
* qemudRemoveDomainStatus
|
|
|
|
*
|
|
|
|
* remove all state files of a domain from statedir
|
|
|
|
*
|
|
|
|
* Returns 0 on success
|
|
|
|
*/
|
|
|
|
static int
|
|
|
|
qemudRemoveDomainStatus(virConnectPtr conn,
|
|
|
|
struct qemud_driver *driver,
|
|
|
|
virDomainObjPtr vm)
|
|
|
|
{
|
2009-08-22 21:56:33 +00:00
|
|
|
char ebuf[1024];
|
2008-12-20 13:17:49 +00:00
|
|
|
char *file = NULL;
|
|
|
|
|
|
|
|
if (virAsprintf(&file, "%s/%s.xml", driver->stateDir, vm->def->name) < 0) {
|
2009-01-29 12:10:32 +00:00
|
|
|
virReportOOMError(conn);
|
2009-11-03 15:24:46 +00:00
|
|
|
return(-1);
|
2008-12-20 13:17:49 +00:00
|
|
|
}
|
|
|
|
|
2009-08-22 21:56:33 +00:00
|
|
|
if (unlink(file) < 0 && errno != ENOENT && errno != ENOTDIR)
|
|
|
|
VIR_WARN(_("Failed to remove domain XML for %s: %s"),
|
2009-11-03 15:24:46 +00:00
|
|
|
vm->def->name, virStrerror(errno, ebuf, sizeof(ebuf)));
|
|
|
|
VIR_FREE(file);
|
|
|
|
|
2009-08-22 21:56:33 +00:00
|
|
|
if (virFileDeletePid(driver->stateDir, vm->def->name) != 0)
|
|
|
|
VIR_WARN(_("Failed to remove PID file for %s: %s"),
|
|
|
|
vm->def->name, virStrerror(errno, ebuf, sizeof(ebuf)));
|
2008-12-20 13:17:49 +00:00
|
|
|
|
2009-11-03 15:24:46 +00:00
|
|
|
|
2009-08-22 21:56:33 +00:00
|
|
|
return 0;
|
2008-12-20 13:17:49 +00:00
|
|
|
}
|
|
|
|
|
2009-10-09 19:13:29 +00:00
|
|
|
|
|
|
|
/*
|
|
|
|
* This is a callback registered with a qemuMonitorPtr instance,
|
|
|
|
* and to be invoked when the monitor console hits an end of file
|
|
|
|
* condition, or error, thus indicating VM shutdown should be
|
|
|
|
* performed
|
|
|
|
*/
|
|
|
|
static void
|
|
|
|
qemuHandleMonitorEOF(qemuMonitorPtr mon ATTRIBUTE_UNUSED,
|
|
|
|
virDomainObjPtr vm,
|
|
|
|
int hasError) {
|
|
|
|
struct qemud_driver *driver = qemu_driver;
|
|
|
|
virDomainEventPtr event = NULL;
|
|
|
|
|
Fully asynchronous monitor I/O processing
Change the QEMU monitor file handle watch to poll for both
read & write events, as well as EOF. All I/O to/from the
QEMU monitor FD is now done in the event callback thread.
When the QEMU driver needs to send a command, it puts the
data to be sent into a qemuMonitorMessagePtr object instance,
queues it for dispatch, and then goes to sleep on a condition
variable. The event thread sends all the data, and then waits
for the reply to arrive, putting the response / error data
back into the qemuMonitorMessagePtr and notifying the condition
variable.
There is a temporary hack in the disk passphrase callback to
avoid acquiring the domain lock. This avoids a deadlock in
the command processing, since the domain lock is still held
when running monitor commands. The next commit will remove
the locking when running commands & thus allow re-introduction
of locking the disk passphrase callback
* src/qemu/qemu_driver.c: Temporarily don't acquire lock in
disk passphrase callback. To be reverted in next commit
* src/qemu/qemu_monitor.c, src/qemu/qemu_monitor.h: Remove
raw I/O functions, and a generic qemuMonitorSend() for
invoking a command
* src/qemu/qemu_monitor_text.c, src/qemu/qemu_monitor_text.h:
Remove all low level I/O, and use the new qemuMonitorSend()
API. Provide a qemuMonitorTextIOProcess() method for detecting
command/reply/prompt boundaries in the monitor data stream
2009-10-14 17:40:51 +00:00
|
|
|
VIR_DEBUG("Received EOF on %p '%s'", vm, vm->def->name);
|
2009-10-09 19:13:29 +00:00
|
|
|
virDomainObjLock(vm);
|
|
|
|
|
|
|
|
event = virDomainEventNewFromObj(vm,
|
|
|
|
VIR_DOMAIN_EVENT_STOPPED,
|
|
|
|
hasError ?
|
|
|
|
VIR_DOMAIN_EVENT_STOPPED_FAILED :
|
|
|
|
VIR_DOMAIN_EVENT_STOPPED_SHUTDOWN);
|
|
|
|
|
|
|
|
qemudShutdownVMDaemon(NULL, driver, vm);
|
|
|
|
if (!vm->persistent)
|
|
|
|
virDomainRemoveInactive(&driver->domains, vm);
|
|
|
|
else
|
|
|
|
virDomainObjUnlock(vm);
|
|
|
|
|
|
|
|
if (event) {
|
|
|
|
qemuDriverLock(driver);
|
|
|
|
qemuDomainEventQueue(driver, event);
|
|
|
|
qemuDriverUnlock(driver);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
|
2009-10-09 19:34:24 +00:00
|
|
|
static virStorageEncryptionPtr
|
|
|
|
findDomainDiskEncryption(virConnectPtr conn, virDomainObjPtr vm,
|
|
|
|
const char *path)
|
|
|
|
{
|
|
|
|
bool seen_volume;
|
|
|
|
int i;
|
|
|
|
|
|
|
|
seen_volume = false;
|
|
|
|
for (i = 0; i < vm->def->ndisks; i++) {
|
|
|
|
virDomainDiskDefPtr disk;
|
|
|
|
|
|
|
|
disk = vm->def->disks[i];
|
|
|
|
if (disk->src != NULL && STREQ(disk->src, path)) {
|
|
|
|
seen_volume = true;
|
|
|
|
if (disk->encryption != NULL)
|
|
|
|
return disk->encryption;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
if (seen_volume)
|
|
|
|
qemudReportError(conn, NULL, NULL, VIR_ERR_INVALID_DOMAIN,
|
|
|
|
_("missing <encryption> for volume %s"), path);
|
|
|
|
else
|
|
|
|
qemudReportError(conn, NULL, NULL, VIR_ERR_INTERNAL_ERROR,
|
|
|
|
_("unexpected passphrase request for volume %s"),
|
|
|
|
path);
|
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
static int
|
|
|
|
findVolumeQcowPassphrase(qemuMonitorPtr mon ATTRIBUTE_UNUSED,
|
|
|
|
virConnectPtr conn,
|
|
|
|
virDomainObjPtr vm,
|
|
|
|
const char *path,
|
|
|
|
char **secretRet,
|
|
|
|
size_t *secretLen)
|
|
|
|
{
|
|
|
|
virStorageEncryptionPtr enc;
|
|
|
|
virSecretPtr secret;
|
|
|
|
char *passphrase;
|
|
|
|
unsigned char *data;
|
|
|
|
size_t size;
|
Fully asynchronous monitor I/O processing
Change the QEMU monitor file handle watch to poll for both
read & write events, as well as EOF. All I/O to/from the
QEMU monitor FD is now done in the event callback thread.
When the QEMU driver needs to send a command, it puts the
data to be sent into a qemuMonitorMessagePtr object instance,
queues it for dispatch, and then goes to sleep on a condition
variable. The event thread sends all the data, and then waits
for the reply to arrive, putting the response / error data
back into the qemuMonitorMessagePtr and notifying the condition
variable.
There is a temporary hack in the disk passphrase callback to
avoid acquiring the domain lock. This avoids a deadlock in
the command processing, since the domain lock is still held
when running monitor commands. The next commit will remove
the locking when running commands & thus allow re-introduction
of locking the disk passphrase callback
* src/qemu/qemu_driver.c: Temporarily don't acquire lock in
disk passphrase callback. To be reverted in next commit
* src/qemu/qemu_monitor.c, src/qemu/qemu_monitor.h: Remove
raw I/O functions, and a generic qemuMonitorSend() for
invoking a command
* src/qemu/qemu_monitor_text.c, src/qemu/qemu_monitor_text.h:
Remove all low level I/O, and use the new qemuMonitorSend()
API. Provide a qemuMonitorTextIOProcess() method for detecting
command/reply/prompt boundaries in the monitor data stream
2009-10-14 17:40:51 +00:00
|
|
|
int ret = -1;
|
|
|
|
|
2009-11-03 18:26:32 +00:00
|
|
|
virDomainObjLock(vm);
|
2009-10-09 19:34:24 +00:00
|
|
|
|
|
|
|
if (!conn) {
|
|
|
|
qemudReportError(NULL, NULL, NULL, VIR_ERR_NO_SUPPORT,
|
|
|
|
"%s", _("cannot find secrets without a connection"));
|
Fully asynchronous monitor I/O processing
Change the QEMU monitor file handle watch to poll for both
read & write events, as well as EOF. All I/O to/from the
QEMU monitor FD is now done in the event callback thread.
When the QEMU driver needs to send a command, it puts the
data to be sent into a qemuMonitorMessagePtr object instance,
queues it for dispatch, and then goes to sleep on a condition
variable. The event thread sends all the data, and then waits
for the reply to arrive, putting the response / error data
back into the qemuMonitorMessagePtr and notifying the condition
variable.
There is a temporary hack in the disk passphrase callback to
avoid acquiring the domain lock. This avoids a deadlock in
the command processing, since the domain lock is still held
when running monitor commands. The next commit will remove
the locking when running commands & thus allow re-introduction
of locking the disk passphrase callback
* src/qemu/qemu_driver.c: Temporarily don't acquire lock in
disk passphrase callback. To be reverted in next commit
* src/qemu/qemu_monitor.c, src/qemu/qemu_monitor.h: Remove
raw I/O functions, and a generic qemuMonitorSend() for
invoking a command
* src/qemu/qemu_monitor_text.c, src/qemu/qemu_monitor_text.h:
Remove all low level I/O, and use the new qemuMonitorSend()
API. Provide a qemuMonitorTextIOProcess() method for detecting
command/reply/prompt boundaries in the monitor data stream
2009-10-14 17:40:51 +00:00
|
|
|
goto cleanup;
|
2009-10-09 19:34:24 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
if (conn->secretDriver == NULL ||
|
|
|
|
conn->secretDriver->lookupByUUID == NULL ||
|
|
|
|
conn->secretDriver->getValue == NULL) {
|
|
|
|
qemudReportError(conn, NULL, NULL, VIR_ERR_NO_SUPPORT, "%s",
|
|
|
|
_("secret storage not supported"));
|
Fully asynchronous monitor I/O processing
Change the QEMU monitor file handle watch to poll for both
read & write events, as well as EOF. All I/O to/from the
QEMU monitor FD is now done in the event callback thread.
When the QEMU driver needs to send a command, it puts the
data to be sent into a qemuMonitorMessagePtr object instance,
queues it for dispatch, and then goes to sleep on a condition
variable. The event thread sends all the data, and then waits
for the reply to arrive, putting the response / error data
back into the qemuMonitorMessagePtr and notifying the condition
variable.
There is a temporary hack in the disk passphrase callback to
avoid acquiring the domain lock. This avoids a deadlock in
the command processing, since the domain lock is still held
when running monitor commands. The next commit will remove
the locking when running commands & thus allow re-introduction
of locking the disk passphrase callback
* src/qemu/qemu_driver.c: Temporarily don't acquire lock in
disk passphrase callback. To be reverted in next commit
* src/qemu/qemu_monitor.c, src/qemu/qemu_monitor.h: Remove
raw I/O functions, and a generic qemuMonitorSend() for
invoking a command
* src/qemu/qemu_monitor_text.c, src/qemu/qemu_monitor_text.h:
Remove all low level I/O, and use the new qemuMonitorSend()
API. Provide a qemuMonitorTextIOProcess() method for detecting
command/reply/prompt boundaries in the monitor data stream
2009-10-14 17:40:51 +00:00
|
|
|
goto cleanup;
|
2009-10-09 19:34:24 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
enc = findDomainDiskEncryption(conn, vm, path);
|
|
|
|
if (enc == NULL)
|
|
|
|
return -1;
|
|
|
|
|
|
|
|
if (enc->format != VIR_STORAGE_ENCRYPTION_FORMAT_QCOW ||
|
|
|
|
enc->nsecrets != 1 ||
|
|
|
|
enc->secrets[0]->type !=
|
|
|
|
VIR_STORAGE_ENCRYPTION_SECRET_TYPE_PASSPHRASE) {
|
|
|
|
qemudReportError(conn, NULL, NULL, VIR_ERR_INVALID_DOMAIN,
|
|
|
|
_("invalid <encryption> for volume %s"), path);
|
Fully asynchronous monitor I/O processing
Change the QEMU monitor file handle watch to poll for both
read & write events, as well as EOF. All I/O to/from the
QEMU monitor FD is now done in the event callback thread.
When the QEMU driver needs to send a command, it puts the
data to be sent into a qemuMonitorMessagePtr object instance,
queues it for dispatch, and then goes to sleep on a condition
variable. The event thread sends all the data, and then waits
for the reply to arrive, putting the response / error data
back into the qemuMonitorMessagePtr and notifying the condition
variable.
There is a temporary hack in the disk passphrase callback to
avoid acquiring the domain lock. This avoids a deadlock in
the command processing, since the domain lock is still held
when running monitor commands. The next commit will remove
the locking when running commands & thus allow re-introduction
of locking the disk passphrase callback
* src/qemu/qemu_driver.c: Temporarily don't acquire lock in
disk passphrase callback. To be reverted in next commit
* src/qemu/qemu_monitor.c, src/qemu/qemu_monitor.h: Remove
raw I/O functions, and a generic qemuMonitorSend() for
invoking a command
* src/qemu/qemu_monitor_text.c, src/qemu/qemu_monitor_text.h:
Remove all low level I/O, and use the new qemuMonitorSend()
API. Provide a qemuMonitorTextIOProcess() method for detecting
command/reply/prompt boundaries in the monitor data stream
2009-10-14 17:40:51 +00:00
|
|
|
goto cleanup;
|
2009-10-09 19:34:24 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
secret = conn->secretDriver->lookupByUUID(conn,
|
|
|
|
enc->secrets[0]->uuid);
|
|
|
|
if (secret == NULL)
|
Fully asynchronous monitor I/O processing
Change the QEMU monitor file handle watch to poll for both
read & write events, as well as EOF. All I/O to/from the
QEMU monitor FD is now done in the event callback thread.
When the QEMU driver needs to send a command, it puts the
data to be sent into a qemuMonitorMessagePtr object instance,
queues it for dispatch, and then goes to sleep on a condition
variable. The event thread sends all the data, and then waits
for the reply to arrive, putting the response / error data
back into the qemuMonitorMessagePtr and notifying the condition
variable.
There is a temporary hack in the disk passphrase callback to
avoid acquiring the domain lock. This avoids a deadlock in
the command processing, since the domain lock is still held
when running monitor commands. The next commit will remove
the locking when running commands & thus allow re-introduction
of locking the disk passphrase callback
* src/qemu/qemu_driver.c: Temporarily don't acquire lock in
disk passphrase callback. To be reverted in next commit
* src/qemu/qemu_monitor.c, src/qemu/qemu_monitor.h: Remove
raw I/O functions, and a generic qemuMonitorSend() for
invoking a command
* src/qemu/qemu_monitor_text.c, src/qemu/qemu_monitor_text.h:
Remove all low level I/O, and use the new qemuMonitorSend()
API. Provide a qemuMonitorTextIOProcess() method for detecting
command/reply/prompt boundaries in the monitor data stream
2009-10-14 17:40:51 +00:00
|
|
|
goto cleanup;
|
2009-10-09 19:34:24 +00:00
|
|
|
data = conn->secretDriver->getValue(secret, &size,
|
|
|
|
VIR_SECRET_GET_VALUE_INTERNAL_CALL);
|
|
|
|
virUnrefSecret(secret);
|
|
|
|
if (data == NULL)
|
Fully asynchronous monitor I/O processing
Change the QEMU monitor file handle watch to poll for both
read & write events, as well as EOF. All I/O to/from the
QEMU monitor FD is now done in the event callback thread.
When the QEMU driver needs to send a command, it puts the
data to be sent into a qemuMonitorMessagePtr object instance,
queues it for dispatch, and then goes to sleep on a condition
variable. The event thread sends all the data, and then waits
for the reply to arrive, putting the response / error data
back into the qemuMonitorMessagePtr and notifying the condition
variable.
There is a temporary hack in the disk passphrase callback to
avoid acquiring the domain lock. This avoids a deadlock in
the command processing, since the domain lock is still held
when running monitor commands. The next commit will remove
the locking when running commands & thus allow re-introduction
of locking the disk passphrase callback
* src/qemu/qemu_driver.c: Temporarily don't acquire lock in
disk passphrase callback. To be reverted in next commit
* src/qemu/qemu_monitor.c, src/qemu/qemu_monitor.h: Remove
raw I/O functions, and a generic qemuMonitorSend() for
invoking a command
* src/qemu/qemu_monitor_text.c, src/qemu/qemu_monitor_text.h:
Remove all low level I/O, and use the new qemuMonitorSend()
API. Provide a qemuMonitorTextIOProcess() method for detecting
command/reply/prompt boundaries in the monitor data stream
2009-10-14 17:40:51 +00:00
|
|
|
goto cleanup;
|
2009-10-09 19:34:24 +00:00
|
|
|
|
|
|
|
if (memchr(data, '\0', size) != NULL) {
|
|
|
|
memset(data, 0, size);
|
|
|
|
VIR_FREE(data);
|
|
|
|
qemudReportError(conn, NULL, NULL, VIR_ERR_INVALID_SECRET,
|
|
|
|
_("format='qcow' passphrase for %s must not contain a "
|
|
|
|
"'\\0'"), path);
|
Fully asynchronous monitor I/O processing
Change the QEMU monitor file handle watch to poll for both
read & write events, as well as EOF. All I/O to/from the
QEMU monitor FD is now done in the event callback thread.
When the QEMU driver needs to send a command, it puts the
data to be sent into a qemuMonitorMessagePtr object instance,
queues it for dispatch, and then goes to sleep on a condition
variable. The event thread sends all the data, and then waits
for the reply to arrive, putting the response / error data
back into the qemuMonitorMessagePtr and notifying the condition
variable.
There is a temporary hack in the disk passphrase callback to
avoid acquiring the domain lock. This avoids a deadlock in
the command processing, since the domain lock is still held
when running monitor commands. The next commit will remove
the locking when running commands & thus allow re-introduction
of locking the disk passphrase callback
* src/qemu/qemu_driver.c: Temporarily don't acquire lock in
disk passphrase callback. To be reverted in next commit
* src/qemu/qemu_monitor.c, src/qemu/qemu_monitor.h: Remove
raw I/O functions, and a generic qemuMonitorSend() for
invoking a command
* src/qemu/qemu_monitor_text.c, src/qemu/qemu_monitor_text.h:
Remove all low level I/O, and use the new qemuMonitorSend()
API. Provide a qemuMonitorTextIOProcess() method for detecting
command/reply/prompt boundaries in the monitor data stream
2009-10-14 17:40:51 +00:00
|
|
|
goto cleanup;
|
2009-10-09 19:34:24 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
if (VIR_ALLOC_N(passphrase, size + 1) < 0) {
|
|
|
|
memset(data, 0, size);
|
|
|
|
VIR_FREE(data);
|
|
|
|
virReportOOMError(conn);
|
Fully asynchronous monitor I/O processing
Change the QEMU monitor file handle watch to poll for both
read & write events, as well as EOF. All I/O to/from the
QEMU monitor FD is now done in the event callback thread.
When the QEMU driver needs to send a command, it puts the
data to be sent into a qemuMonitorMessagePtr object instance,
queues it for dispatch, and then goes to sleep on a condition
variable. The event thread sends all the data, and then waits
for the reply to arrive, putting the response / error data
back into the qemuMonitorMessagePtr and notifying the condition
variable.
There is a temporary hack in the disk passphrase callback to
avoid acquiring the domain lock. This avoids a deadlock in
the command processing, since the domain lock is still held
when running monitor commands. The next commit will remove
the locking when running commands & thus allow re-introduction
of locking the disk passphrase callback
* src/qemu/qemu_driver.c: Temporarily don't acquire lock in
disk passphrase callback. To be reverted in next commit
* src/qemu/qemu_monitor.c, src/qemu/qemu_monitor.h: Remove
raw I/O functions, and a generic qemuMonitorSend() for
invoking a command
* src/qemu/qemu_monitor_text.c, src/qemu/qemu_monitor_text.h:
Remove all low level I/O, and use the new qemuMonitorSend()
API. Provide a qemuMonitorTextIOProcess() method for detecting
command/reply/prompt boundaries in the monitor data stream
2009-10-14 17:40:51 +00:00
|
|
|
goto cleanup;
|
2009-10-09 19:34:24 +00:00
|
|
|
}
|
|
|
|
memcpy(passphrase, data, size);
|
|
|
|
passphrase[size] = '\0';
|
|
|
|
|
|
|
|
memset(data, 0, size);
|
|
|
|
VIR_FREE(data);
|
|
|
|
|
|
|
|
*secretRet = passphrase;
|
|
|
|
*secretLen = size;
|
|
|
|
|
Fully asynchronous monitor I/O processing
Change the QEMU monitor file handle watch to poll for both
read & write events, as well as EOF. All I/O to/from the
QEMU monitor FD is now done in the event callback thread.
When the QEMU driver needs to send a command, it puts the
data to be sent into a qemuMonitorMessagePtr object instance,
queues it for dispatch, and then goes to sleep on a condition
variable. The event thread sends all the data, and then waits
for the reply to arrive, putting the response / error data
back into the qemuMonitorMessagePtr and notifying the condition
variable.
There is a temporary hack in the disk passphrase callback to
avoid acquiring the domain lock. This avoids a deadlock in
the command processing, since the domain lock is still held
when running monitor commands. The next commit will remove
the locking when running commands & thus allow re-introduction
of locking the disk passphrase callback
* src/qemu/qemu_driver.c: Temporarily don't acquire lock in
disk passphrase callback. To be reverted in next commit
* src/qemu/qemu_monitor.c, src/qemu/qemu_monitor.h: Remove
raw I/O functions, and a generic qemuMonitorSend() for
invoking a command
* src/qemu/qemu_monitor_text.c, src/qemu/qemu_monitor_text.h:
Remove all low level I/O, and use the new qemuMonitorSend()
API. Provide a qemuMonitorTextIOProcess() method for detecting
command/reply/prompt boundaries in the monitor data stream
2009-10-14 17:40:51 +00:00
|
|
|
ret = 0;
|
|
|
|
|
|
|
|
cleanup:
|
2009-11-03 18:26:32 +00:00
|
|
|
virDomainObjUnlock(vm);
|
|
|
|
|
Fully asynchronous monitor I/O processing
Change the QEMU monitor file handle watch to poll for both
read & write events, as well as EOF. All I/O to/from the
QEMU monitor FD is now done in the event callback thread.
When the QEMU driver needs to send a command, it puts the
data to be sent into a qemuMonitorMessagePtr object instance,
queues it for dispatch, and then goes to sleep on a condition
variable. The event thread sends all the data, and then waits
for the reply to arrive, putting the response / error data
back into the qemuMonitorMessagePtr and notifying the condition
variable.
There is a temporary hack in the disk passphrase callback to
avoid acquiring the domain lock. This avoids a deadlock in
the command processing, since the domain lock is still held
when running monitor commands. The next commit will remove
the locking when running commands & thus allow re-introduction
of locking the disk passphrase callback
* src/qemu/qemu_driver.c: Temporarily don't acquire lock in
disk passphrase callback. To be reverted in next commit
* src/qemu/qemu_monitor.c, src/qemu/qemu_monitor.h: Remove
raw I/O functions, and a generic qemuMonitorSend() for
invoking a command
* src/qemu/qemu_monitor_text.c, src/qemu/qemu_monitor_text.h:
Remove all low level I/O, and use the new qemuMonitorSend()
API. Provide a qemuMonitorTextIOProcess() method for detecting
command/reply/prompt boundaries in the monitor data stream
2009-10-14 17:40:51 +00:00
|
|
|
return ret;
|
2009-10-09 19:34:24 +00:00
|
|
|
}
|
|
|
|
|
2009-10-15 17:56:52 +00:00
|
|
|
static qemuMonitorCallbacks monitorCallbacks = {
|
|
|
|
.eofNotify = qemuHandleMonitorEOF,
|
|
|
|
.diskSecretLookup = findVolumeQcowPassphrase,
|
|
|
|
};
|
|
|
|
|
2009-10-09 18:07:55 +00:00
|
|
|
static int
|
Fully asynchronous monitor I/O processing
Change the QEMU monitor file handle watch to poll for both
read & write events, as well as EOF. All I/O to/from the
QEMU monitor FD is now done in the event callback thread.
When the QEMU driver needs to send a command, it puts the
data to be sent into a qemuMonitorMessagePtr object instance,
queues it for dispatch, and then goes to sleep on a condition
variable. The event thread sends all the data, and then waits
for the reply to arrive, putting the response / error data
back into the qemuMonitorMessagePtr and notifying the condition
variable.
There is a temporary hack in the disk passphrase callback to
avoid acquiring the domain lock. This avoids a deadlock in
the command processing, since the domain lock is still held
when running monitor commands. The next commit will remove
the locking when running commands & thus allow re-introduction
of locking the disk passphrase callback
* src/qemu/qemu_driver.c: Temporarily don't acquire lock in
disk passphrase callback. To be reverted in next commit
* src/qemu/qemu_monitor.c, src/qemu/qemu_monitor.h: Remove
raw I/O functions, and a generic qemuMonitorSend() for
invoking a command
* src/qemu/qemu_monitor_text.c, src/qemu/qemu_monitor_text.h:
Remove all low level I/O, and use the new qemuMonitorSend()
API. Provide a qemuMonitorTextIOProcess() method for detecting
command/reply/prompt boundaries in the monitor data stream
2009-10-14 17:40:51 +00:00
|
|
|
qemuConnectMonitor(virDomainObjPtr vm)
|
2009-10-09 18:07:55 +00:00
|
|
|
{
|
2009-10-09 19:13:29 +00:00
|
|
|
qemuDomainObjPrivatePtr priv = vm->privateData;
|
2008-12-20 13:17:49 +00:00
|
|
|
|
2009-11-26 13:29:29 +00:00
|
|
|
/* Hold an extra reference because we can't allow 'vm' to be
|
|
|
|
* deleted while the monitor is active */
|
|
|
|
virDomainObjRef(vm);
|
|
|
|
|
2009-11-26 17:57:00 +00:00
|
|
|
if ((priv->mon = qemuMonitorOpen(vm,
|
|
|
|
priv->monConfig,
|
2009-11-03 18:59:18 +00:00
|
|
|
priv->monJSON,
|
2009-10-15 17:56:52 +00:00
|
|
|
&monitorCallbacks)) == NULL) {
|
2010-01-19 13:17:20 +00:00
|
|
|
VIR_ERROR(_("Failed to connect monitor for %s"), vm->def->name);
|
2009-10-09 18:07:55 +00:00
|
|
|
return -1;
|
2009-10-09 19:13:29 +00:00
|
|
|
}
|
2009-01-20 15:52:11 +00:00
|
|
|
|
2009-10-09 18:07:55 +00:00
|
|
|
return 0;
|
|
|
|
}
|
2009-06-12 11:38:50 +00:00
|
|
|
|
|
|
|
/*
|
|
|
|
* Open an existing VM's monitor, re-detect VCPU threads
|
|
|
|
* and re-reserve the security labels in use
|
2009-01-20 15:52:11 +00:00
|
|
|
*/
|
Convert virDomainObjListPtr to use a hash of domain objects
The current virDomainObjListPtr object stores domain objects in
an array. This means that to find a particular objects requires
O(n) time, and more critically acquiring O(n) mutex locks.
The new impl replaces the array with a virHashTable, keyed off
UUID. Finding a object based on UUID is now O(1) time, and only
requires a single mutex lock. Finding by name/id is unchanged
in complexity.
In changing this, all code which iterates over the array had
to be updated to use a hash table iterator function callback.
Several of the functions which were identically duplicating
across all drivers were pulled into domain_conf.c
* src/conf/domain_conf.h, src/conf/domain_conf.c: Change
virDomainObjListPtr to use virHashTable. Add a initializer
method virDomainObjListInit, and rename virDomainObjListFree
to virDomainObjListDeinit, since its not actually freeing
the container, only its contents. Also add some convenient
methods virDomainObjListGetInactiveNames,
virDomainObjListGetActiveIDs and virDomainObjListNumOfDomains
which can be used to implement the correspondingly named
public API entry points in drivers
* src/libvirt_private.syms: Export new methods from domain_conf.h
* src/lxc/lxc_driver.c, src/opennebula/one_driver.c,
src/openvz/openvz_conf.c, src/openvz/openvz_driver.c,
src/qemu/qemu_driver.c, src/test/test_driver.c,
src/uml/uml_driver.c, src/vbox/vbox_tmpl.c: Update all code
to deal with hash tables instead of arrays for domains
2009-10-09 11:33:51 +00:00
|
|
|
static void
|
|
|
|
qemuReconnectDomain(void *payload, const char *name ATTRIBUTE_UNUSED, void *opaque)
|
2009-01-20 15:52:11 +00:00
|
|
|
{
|
Convert virDomainObjListPtr to use a hash of domain objects
The current virDomainObjListPtr object stores domain objects in
an array. This means that to find a particular objects requires
O(n) time, and more critically acquiring O(n) mutex locks.
The new impl replaces the array with a virHashTable, keyed off
UUID. Finding a object based on UUID is now O(1) time, and only
requires a single mutex lock. Finding by name/id is unchanged
in complexity.
In changing this, all code which iterates over the array had
to be updated to use a hash table iterator function callback.
Several of the functions which were identically duplicating
across all drivers were pulled into domain_conf.c
* src/conf/domain_conf.h, src/conf/domain_conf.c: Change
virDomainObjListPtr to use virHashTable. Add a initializer
method virDomainObjListInit, and rename virDomainObjListFree
to virDomainObjListDeinit, since its not actually freeing
the container, only its contents. Also add some convenient
methods virDomainObjListGetInactiveNames,
virDomainObjListGetActiveIDs and virDomainObjListNumOfDomains
which can be used to implement the correspondingly named
public API entry points in drivers
* src/libvirt_private.syms: Export new methods from domain_conf.h
* src/lxc/lxc_driver.c, src/opennebula/one_driver.c,
src/openvz/openvz_conf.c, src/openvz/openvz_driver.c,
src/qemu/qemu_driver.c, src/test/test_driver.c,
src/uml/uml_driver.c, src/vbox/vbox_tmpl.c: Update all code
to deal with hash tables instead of arrays for domains
2009-10-09 11:33:51 +00:00
|
|
|
virDomainObjPtr obj = payload;
|
|
|
|
struct qemud_driver *driver = opaque;
|
2010-01-27 17:03:54 +00:00
|
|
|
qemuDomainObjPrivatePtr priv;
|
Convert virDomainObjListPtr to use a hash of domain objects
The current virDomainObjListPtr object stores domain objects in
an array. This means that to find a particular objects requires
O(n) time, and more critically acquiring O(n) mutex locks.
The new impl replaces the array with a virHashTable, keyed off
UUID. Finding a object based on UUID is now O(1) time, and only
requires a single mutex lock. Finding by name/id is unchanged
in complexity.
In changing this, all code which iterates over the array had
to be updated to use a hash table iterator function callback.
Several of the functions which were identically duplicating
across all drivers were pulled into domain_conf.c
* src/conf/domain_conf.h, src/conf/domain_conf.c: Change
virDomainObjListPtr to use virHashTable. Add a initializer
method virDomainObjListInit, and rename virDomainObjListFree
to virDomainObjListDeinit, since its not actually freeing
the container, only its contents. Also add some convenient
methods virDomainObjListGetInactiveNames,
virDomainObjListGetActiveIDs and virDomainObjListNumOfDomains
which can be used to implement the correspondingly named
public API entry points in drivers
* src/libvirt_private.syms: Export new methods from domain_conf.h
* src/lxc/lxc_driver.c, src/opennebula/one_driver.c,
src/openvz/openvz_conf.c, src/openvz/openvz_driver.c,
src/qemu/qemu_driver.c, src/test/test_driver.c,
src/uml/uml_driver.c, src/vbox/vbox_tmpl.c: Update all code
to deal with hash tables instead of arrays for domains
2009-10-09 11:33:51 +00:00
|
|
|
|
|
|
|
virDomainObjLock(obj);
|
2009-01-20 15:52:11 +00:00
|
|
|
|
Fully asynchronous monitor I/O processing
Change the QEMU monitor file handle watch to poll for both
read & write events, as well as EOF. All I/O to/from the
QEMU monitor FD is now done in the event callback thread.
When the QEMU driver needs to send a command, it puts the
data to be sent into a qemuMonitorMessagePtr object instance,
queues it for dispatch, and then goes to sleep on a condition
variable. The event thread sends all the data, and then waits
for the reply to arrive, putting the response / error data
back into the qemuMonitorMessagePtr and notifying the condition
variable.
There is a temporary hack in the disk passphrase callback to
avoid acquiring the domain lock. This avoids a deadlock in
the command processing, since the domain lock is still held
when running monitor commands. The next commit will remove
the locking when running commands & thus allow re-introduction
of locking the disk passphrase callback
* src/qemu/qemu_driver.c: Temporarily don't acquire lock in
disk passphrase callback. To be reverted in next commit
* src/qemu/qemu_monitor.c, src/qemu/qemu_monitor.h: Remove
raw I/O functions, and a generic qemuMonitorSend() for
invoking a command
* src/qemu/qemu_monitor_text.c, src/qemu/qemu_monitor_text.h:
Remove all low level I/O, and use the new qemuMonitorSend()
API. Provide a qemuMonitorTextIOProcess() method for detecting
command/reply/prompt boundaries in the monitor data stream
2009-10-14 17:40:51 +00:00
|
|
|
VIR_DEBUG("Reconnect monitor to %p '%s'", obj, obj->def->name);
|
|
|
|
|
2010-01-27 17:03:54 +00:00
|
|
|
priv = obj->privateData;
|
|
|
|
|
Fully asynchronous monitor I/O processing
Change the QEMU monitor file handle watch to poll for both
read & write events, as well as EOF. All I/O to/from the
QEMU monitor FD is now done in the event callback thread.
When the QEMU driver needs to send a command, it puts the
data to be sent into a qemuMonitorMessagePtr object instance,
queues it for dispatch, and then goes to sleep on a condition
variable. The event thread sends all the data, and then waits
for the reply to arrive, putting the response / error data
back into the qemuMonitorMessagePtr and notifying the condition
variable.
There is a temporary hack in the disk passphrase callback to
avoid acquiring the domain lock. This avoids a deadlock in
the command processing, since the domain lock is still held
when running monitor commands. The next commit will remove
the locking when running commands & thus allow re-introduction
of locking the disk passphrase callback
* src/qemu/qemu_driver.c: Temporarily don't acquire lock in
disk passphrase callback. To be reverted in next commit
* src/qemu/qemu_monitor.c, src/qemu/qemu_monitor.h: Remove
raw I/O functions, and a generic qemuMonitorSend() for
invoking a command
* src/qemu/qemu_monitor_text.c, src/qemu/qemu_monitor_text.h:
Remove all low level I/O, and use the new qemuMonitorSend()
API. Provide a qemuMonitorTextIOProcess() method for detecting
command/reply/prompt boundaries in the monitor data stream
2009-10-14 17:40:51 +00:00
|
|
|
/* XXX check PID liveliness & EXE path */
|
|
|
|
if (qemuConnectMonitor(obj) < 0)
|
2009-06-12 11:38:50 +00:00
|
|
|
goto error;
|
2009-01-20 15:52:11 +00:00
|
|
|
|
2009-08-17 14:05:23 +00:00
|
|
|
if (qemuUpdateActivePciHostdevs(driver, obj->def) < 0) {
|
|
|
|
goto error;
|
|
|
|
}
|
|
|
|
|
2010-01-27 17:03:54 +00:00
|
|
|
if (!(priv->pciaddrs = qemuDomainPCIAddressSetCreate(obj->def)))
|
|
|
|
goto error;
|
|
|
|
|
2010-01-13 14:03:04 +00:00
|
|
|
if (driver->securityDriver &&
|
2009-06-12 11:38:50 +00:00
|
|
|
driver->securityDriver->domainReserveSecurityLabel &&
|
|
|
|
driver->securityDriver->domainReserveSecurityLabel(NULL, obj) < 0)
|
Convert virDomainObjListPtr to use a hash of domain objects
The current virDomainObjListPtr object stores domain objects in
an array. This means that to find a particular objects requires
O(n) time, and more critically acquiring O(n) mutex locks.
The new impl replaces the array with a virHashTable, keyed off
UUID. Finding a object based on UUID is now O(1) time, and only
requires a single mutex lock. Finding by name/id is unchanged
in complexity.
In changing this, all code which iterates over the array had
to be updated to use a hash table iterator function callback.
Several of the functions which were identically duplicating
across all drivers were pulled into domain_conf.c
* src/conf/domain_conf.h, src/conf/domain_conf.c: Change
virDomainObjListPtr to use virHashTable. Add a initializer
method virDomainObjListInit, and rename virDomainObjListFree
to virDomainObjListDeinit, since its not actually freeing
the container, only its contents. Also add some convenient
methods virDomainObjListGetInactiveNames,
virDomainObjListGetActiveIDs and virDomainObjListNumOfDomains
which can be used to implement the correspondingly named
public API entry points in drivers
* src/libvirt_private.syms: Export new methods from domain_conf.h
* src/lxc/lxc_driver.c, src/opennebula/one_driver.c,
src/openvz/openvz_conf.c, src/openvz/openvz_driver.c,
src/qemu/qemu_driver.c, src/test/test_driver.c,
src/uml/uml_driver.c, src/vbox/vbox_tmpl.c: Update all code
to deal with hash tables instead of arrays for domains
2009-10-09 11:33:51 +00:00
|
|
|
goto error;
|
2009-01-20 15:52:11 +00:00
|
|
|
|
2009-06-12 11:38:50 +00:00
|
|
|
if (obj->def->id >= driver->nextvmid)
|
|
|
|
driver->nextvmid = obj->def->id + 1;
|
2009-01-20 15:52:11 +00:00
|
|
|
|
Convert virDomainObjListPtr to use a hash of domain objects
The current virDomainObjListPtr object stores domain objects in
an array. This means that to find a particular objects requires
O(n) time, and more critically acquiring O(n) mutex locks.
The new impl replaces the array with a virHashTable, keyed off
UUID. Finding a object based on UUID is now O(1) time, and only
requires a single mutex lock. Finding by name/id is unchanged
in complexity.
In changing this, all code which iterates over the array had
to be updated to use a hash table iterator function callback.
Several of the functions which were identically duplicating
across all drivers were pulled into domain_conf.c
* src/conf/domain_conf.h, src/conf/domain_conf.c: Change
virDomainObjListPtr to use virHashTable. Add a initializer
method virDomainObjListInit, and rename virDomainObjListFree
to virDomainObjListDeinit, since its not actually freeing
the container, only its contents. Also add some convenient
methods virDomainObjListGetInactiveNames,
virDomainObjListGetActiveIDs and virDomainObjListNumOfDomains
which can be used to implement the correspondingly named
public API entry points in drivers
* src/libvirt_private.syms: Export new methods from domain_conf.h
* src/lxc/lxc_driver.c, src/opennebula/one_driver.c,
src/openvz/openvz_conf.c, src/openvz/openvz_driver.c,
src/qemu/qemu_driver.c, src/test/test_driver.c,
src/uml/uml_driver.c, src/vbox/vbox_tmpl.c: Update all code
to deal with hash tables instead of arrays for domains
2009-10-09 11:33:51 +00:00
|
|
|
virDomainObjUnlock(obj);
|
|
|
|
return;
|
2009-01-20 15:52:11 +00:00
|
|
|
|
2009-06-12 11:38:50 +00:00
|
|
|
error:
|
Convert virDomainObjListPtr to use a hash of domain objects
The current virDomainObjListPtr object stores domain objects in
an array. This means that to find a particular objects requires
O(n) time, and more critically acquiring O(n) mutex locks.
The new impl replaces the array with a virHashTable, keyed off
UUID. Finding a object based on UUID is now O(1) time, and only
requires a single mutex lock. Finding by name/id is unchanged
in complexity.
In changing this, all code which iterates over the array had
to be updated to use a hash table iterator function callback.
Several of the functions which were identically duplicating
across all drivers were pulled into domain_conf.c
* src/conf/domain_conf.h, src/conf/domain_conf.c: Change
virDomainObjListPtr to use virHashTable. Add a initializer
method virDomainObjListInit, and rename virDomainObjListFree
to virDomainObjListDeinit, since its not actually freeing
the container, only its contents. Also add some convenient
methods virDomainObjListGetInactiveNames,
virDomainObjListGetActiveIDs and virDomainObjListNumOfDomains
which can be used to implement the correspondingly named
public API entry points in drivers
* src/libvirt_private.syms: Export new methods from domain_conf.h
* src/lxc/lxc_driver.c, src/opennebula/one_driver.c,
src/openvz/openvz_conf.c, src/openvz/openvz_driver.c,
src/qemu/qemu_driver.c, src/test/test_driver.c,
src/uml/uml_driver.c, src/vbox/vbox_tmpl.c: Update all code
to deal with hash tables instead of arrays for domains
2009-10-09 11:33:51 +00:00
|
|
|
/* We can't get the monitor back, so must kill the VM
|
|
|
|
* to remove danger of it ending up running twice if
|
|
|
|
* user tries to start it again later */
|
|
|
|
qemudShutdownVMDaemon(NULL, driver, obj);
|
Fully asynchronous monitor I/O processing
Change the QEMU monitor file handle watch to poll for both
read & write events, as well as EOF. All I/O to/from the
QEMU monitor FD is now done in the event callback thread.
When the QEMU driver needs to send a command, it puts the
data to be sent into a qemuMonitorMessagePtr object instance,
queues it for dispatch, and then goes to sleep on a condition
variable. The event thread sends all the data, and then waits
for the reply to arrive, putting the response / error data
back into the qemuMonitorMessagePtr and notifying the condition
variable.
There is a temporary hack in the disk passphrase callback to
avoid acquiring the domain lock. This avoids a deadlock in
the command processing, since the domain lock is still held
when running monitor commands. The next commit will remove
the locking when running commands & thus allow re-introduction
of locking the disk passphrase callback
* src/qemu/qemu_driver.c: Temporarily don't acquire lock in
disk passphrase callback. To be reverted in next commit
* src/qemu/qemu_monitor.c, src/qemu/qemu_monitor.h: Remove
raw I/O functions, and a generic qemuMonitorSend() for
invoking a command
* src/qemu/qemu_monitor_text.c, src/qemu/qemu_monitor_text.h:
Remove all low level I/O, and use the new qemuMonitorSend()
API. Provide a qemuMonitorTextIOProcess() method for detecting
command/reply/prompt boundaries in the monitor data stream
2009-10-14 17:40:51 +00:00
|
|
|
if (!obj->persistent)
|
|
|
|
virDomainRemoveInactive(&driver->domains, obj);
|
|
|
|
else
|
|
|
|
virDomainObjUnlock(obj);
|
2009-06-12 11:38:50 +00:00
|
|
|
}
|
2009-01-20 15:52:11 +00:00
|
|
|
|
2009-06-12 11:38:50 +00:00
|
|
|
/**
|
2009-10-09 19:13:29 +00:00
|
|
|
* qemudReconnectDomains
|
2009-06-12 11:38:50 +00:00
|
|
|
*
|
|
|
|
* Try to re-open the resources for live VMs that we care
|
|
|
|
* about.
|
|
|
|
*/
|
|
|
|
static void
|
|
|
|
qemuReconnectDomains(struct qemud_driver *driver)
|
|
|
|
{
|
Convert virDomainObjListPtr to use a hash of domain objects
The current virDomainObjListPtr object stores domain objects in
an array. This means that to find a particular objects requires
O(n) time, and more critically acquiring O(n) mutex locks.
The new impl replaces the array with a virHashTable, keyed off
UUID. Finding a object based on UUID is now O(1) time, and only
requires a single mutex lock. Finding by name/id is unchanged
in complexity.
In changing this, all code which iterates over the array had
to be updated to use a hash table iterator function callback.
Several of the functions which were identically duplicating
across all drivers were pulled into domain_conf.c
* src/conf/domain_conf.h, src/conf/domain_conf.c: Change
virDomainObjListPtr to use virHashTable. Add a initializer
method virDomainObjListInit, and rename virDomainObjListFree
to virDomainObjListDeinit, since its not actually freeing
the container, only its contents. Also add some convenient
methods virDomainObjListGetInactiveNames,
virDomainObjListGetActiveIDs and virDomainObjListNumOfDomains
which can be used to implement the correspondingly named
public API entry points in drivers
* src/libvirt_private.syms: Export new methods from domain_conf.h
* src/lxc/lxc_driver.c, src/opennebula/one_driver.c,
src/openvz/openvz_conf.c, src/openvz/openvz_driver.c,
src/qemu/qemu_driver.c, src/test/test_driver.c,
src/uml/uml_driver.c, src/vbox/vbox_tmpl.c: Update all code
to deal with hash tables instead of arrays for domains
2009-10-09 11:33:51 +00:00
|
|
|
virHashForEach(driver->domains.objs, qemuReconnectDomain, driver);
|
2009-01-20 15:52:11 +00:00
|
|
|
}
|
|
|
|
|
2009-06-29 10:41:56 +00:00
|
|
|
|
2009-03-03 12:03:44 +00:00
|
|
|
static int
|
|
|
|
qemudSecurityInit(struct qemud_driver *qemud_drv)
|
|
|
|
{
|
|
|
|
int ret;
|
|
|
|
virSecurityDriverPtr security_drv;
|
|
|
|
|
|
|
|
ret = virSecurityDriverStartup(&security_drv,
|
|
|
|
qemud_drv->securityDriverName);
|
|
|
|
if (ret == -1) {
|
|
|
|
VIR_ERROR0(_("Failed to start security driver"));
|
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
/* No security driver wanted to be enabled: just return */
|
|
|
|
if (ret == -2) {
|
|
|
|
VIR_INFO0(_("No security driver available"));
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2010-01-13 17:06:57 +00:00
|
|
|
qemuSecurityStackedSetDriver(qemud_drv);
|
|
|
|
qemuSecurityDACSetDriver(qemud_drv);
|
|
|
|
|
|
|
|
qemud_drv->securityPrimaryDriver = security_drv;
|
|
|
|
qemud_drv->securitySecondaryDriver = &qemuDACSecurityDriver;
|
|
|
|
qemud_drv->securityDriver = &qemuStackedSecurityDriver;
|
2009-03-03 12:03:44 +00:00
|
|
|
|
2009-06-29 10:41:56 +00:00
|
|
|
VIR_INFO("Initialized security driver %s", security_drv->name);
|
2010-01-18 16:24:25 +00:00
|
|
|
return 0;
|
2009-06-29 10:41:56 +00:00
|
|
|
}
|
2009-03-03 12:03:44 +00:00
|
|
|
|
|
|
|
|
2010-01-18 16:24:25 +00:00
|
|
|
static virCapsPtr
|
|
|
|
qemuCreateCapabilities(virCapsPtr oldcaps,
|
|
|
|
virSecurityDriverPtr secDriver)
|
|
|
|
{
|
|
|
|
virCapsPtr caps;
|
|
|
|
|
|
|
|
/* Basic host arch / guest machine capabilities */
|
|
|
|
if (!(caps = qemudCapsInit(oldcaps))) {
|
|
|
|
virReportOOMError(NULL);
|
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Domain XML parser hooks */
|
|
|
|
caps->privateDataAllocFunc = qemuDomainObjPrivateAlloc;
|
|
|
|
caps->privateDataFreeFunc = qemuDomainObjPrivateFree;
|
|
|
|
caps->privateDataXMLFormat = qemuDomainObjPrivateXMLFormat;
|
|
|
|
caps->privateDataXMLParse = qemuDomainObjPrivateXMLParse;
|
|
|
|
|
|
|
|
|
|
|
|
/* Security driver data */
|
|
|
|
if (secDriver) {
|
|
|
|
const char *doi, *model;
|
|
|
|
|
|
|
|
doi = virSecurityDriverGetDOI(secDriver);
|
|
|
|
model = virSecurityDriverGetModel(secDriver);
|
|
|
|
|
|
|
|
if (!(caps->host.secModel.model = strdup(model)))
|
|
|
|
goto no_memory;
|
|
|
|
if (!(caps->host.secModel.doi = strdup(doi)))
|
|
|
|
goto no_memory;
|
|
|
|
|
|
|
|
VIR_DEBUG("Initialized caps for security driver \"%s\" with "
|
|
|
|
"DOI \"%s\"", model, doi);
|
|
|
|
}
|
|
|
|
|
|
|
|
return caps;
|
|
|
|
|
|
|
|
no_memory:
|
|
|
|
virReportOOMError(NULL);
|
|
|
|
virCapabilitiesFree(caps);
|
|
|
|
return NULL;
|
|
|
|
}
|
2009-01-20 15:52:11 +00:00
|
|
|
|
2007-06-29 13:23:13 +00:00
|
|
|
/**
|
|
|
|
* qemudStartup:
|
|
|
|
*
|
|
|
|
* Initialization function for the QEmu daemon
|
|
|
|
*/
|
|
|
|
static int
|
2009-06-12 13:20:13 +00:00
|
|
|
qemudStartup(int privileged) {
|
2007-06-26 22:13:21 +00:00
|
|
|
char *base = NULL;
|
2007-10-12 16:05:44 +00:00
|
|
|
char driverConf[PATH_MAX];
|
2009-07-09 13:10:59 +00:00
|
|
|
int rc;
|
2007-06-26 22:13:21 +00:00
|
|
|
|
2008-05-29 19:20:22 +00:00
|
|
|
if (VIR_ALLOC(qemu_driver) < 0)
|
2007-06-26 22:13:21 +00:00
|
|
|
return -1;
|
|
|
|
|
2009-01-15 19:56:05 +00:00
|
|
|
if (virMutexInit(&qemu_driver->lock) < 0) {
|
2009-03-03 11:40:08 +00:00
|
|
|
VIR_ERROR("%s", _("cannot initialize mutex"));
|
2009-01-15 19:56:05 +00:00
|
|
|
VIR_FREE(qemu_driver);
|
|
|
|
return -1;
|
|
|
|
}
|
2008-12-04 21:06:41 +00:00
|
|
|
qemuDriverLock(qemu_driver);
|
2009-06-12 13:20:13 +00:00
|
|
|
qemu_driver->privileged = privileged;
|
2008-12-04 21:06:41 +00:00
|
|
|
|
2007-06-26 22:13:21 +00:00
|
|
|
/* Don't have a dom0 so start from 1 */
|
|
|
|
qemu_driver->nextvmid = 1;
|
|
|
|
|
Convert virDomainObjListPtr to use a hash of domain objects
The current virDomainObjListPtr object stores domain objects in
an array. This means that to find a particular objects requires
O(n) time, and more critically acquiring O(n) mutex locks.
The new impl replaces the array with a virHashTable, keyed off
UUID. Finding a object based on UUID is now O(1) time, and only
requires a single mutex lock. Finding by name/id is unchanged
in complexity.
In changing this, all code which iterates over the array had
to be updated to use a hash table iterator function callback.
Several of the functions which were identically duplicating
across all drivers were pulled into domain_conf.c
* src/conf/domain_conf.h, src/conf/domain_conf.c: Change
virDomainObjListPtr to use virHashTable. Add a initializer
method virDomainObjListInit, and rename virDomainObjListFree
to virDomainObjListDeinit, since its not actually freeing
the container, only its contents. Also add some convenient
methods virDomainObjListGetInactiveNames,
virDomainObjListGetActiveIDs and virDomainObjListNumOfDomains
which can be used to implement the correspondingly named
public API entry points in drivers
* src/libvirt_private.syms: Export new methods from domain_conf.h
* src/lxc/lxc_driver.c, src/opennebula/one_driver.c,
src/openvz/openvz_conf.c, src/openvz/openvz_driver.c,
src/qemu/qemu_driver.c, src/test/test_driver.c,
src/uml/uml_driver.c, src/vbox/vbox_tmpl.c: Update all code
to deal with hash tables instead of arrays for domains
2009-10-09 11:33:51 +00:00
|
|
|
if (virDomainObjListInit(&qemu_driver->domains) < 0)
|
|
|
|
goto out_of_memory;
|
|
|
|
|
2008-10-23 13:18:18 +00:00
|
|
|
/* Init callback list */
|
Convert virDomainObjListPtr to use a hash of domain objects
The current virDomainObjListPtr object stores domain objects in
an array. This means that to find a particular objects requires
O(n) time, and more critically acquiring O(n) mutex locks.
The new impl replaces the array with a virHashTable, keyed off
UUID. Finding a object based on UUID is now O(1) time, and only
requires a single mutex lock. Finding by name/id is unchanged
in complexity.
In changing this, all code which iterates over the array had
to be updated to use a hash table iterator function callback.
Several of the functions which were identically duplicating
across all drivers were pulled into domain_conf.c
* src/conf/domain_conf.h, src/conf/domain_conf.c: Change
virDomainObjListPtr to use virHashTable. Add a initializer
method virDomainObjListInit, and rename virDomainObjListFree
to virDomainObjListDeinit, since its not actually freeing
the container, only its contents. Also add some convenient
methods virDomainObjListGetInactiveNames,
virDomainObjListGetActiveIDs and virDomainObjListNumOfDomains
which can be used to implement the correspondingly named
public API entry points in drivers
* src/libvirt_private.syms: Export new methods from domain_conf.h
* src/lxc/lxc_driver.c, src/opennebula/one_driver.c,
src/openvz/openvz_conf.c, src/openvz/openvz_driver.c,
src/qemu/qemu_driver.c, src/test/test_driver.c,
src/uml/uml_driver.c, src/vbox/vbox_tmpl.c: Update all code
to deal with hash tables instead of arrays for domains
2009-10-09 11:33:51 +00:00
|
|
|
if (VIR_ALLOC(qemu_driver->domainEventCallbacks) < 0)
|
2008-12-04 21:06:41 +00:00
|
|
|
goto out_of_memory;
|
2008-12-04 21:09:20 +00:00
|
|
|
if (!(qemu_driver->domainEventQueue = virDomainEventQueueNew()))
|
|
|
|
goto out_of_memory;
|
|
|
|
|
|
|
|
if ((qemu_driver->domainEventTimer =
|
|
|
|
virEventAddTimeout(-1, qemuDomainEventFlush, qemu_driver, NULL)) < 0)
|
|
|
|
goto error;
|
2008-10-23 13:18:18 +00:00
|
|
|
|
2009-06-12 13:20:13 +00:00
|
|
|
if (privileged) {
|
2008-12-23 13:03:29 +00:00
|
|
|
if (virAsprintf(&qemu_driver->logDir,
|
|
|
|
"%s/log/libvirt/qemu", LOCAL_STATE_DIR) == -1)
|
2008-07-11 19:34:11 +00:00
|
|
|
goto out_of_memory;
|
2007-06-26 22:13:21 +00:00
|
|
|
|
2007-10-12 16:05:44 +00:00
|
|
|
if ((base = strdup (SYSCONF_DIR "/libvirt")) == NULL)
|
2007-06-26 22:13:21 +00:00
|
|
|
goto out_of_memory;
|
2008-12-18 15:22:49 +00:00
|
|
|
|
|
|
|
if (virAsprintf(&qemu_driver->stateDir,
|
2009-07-30 13:58:16 +00:00
|
|
|
"%s/run/libvirt/qemu", LOCAL_STATE_DIR) == -1)
|
2008-12-18 15:22:49 +00:00
|
|
|
goto out_of_memory;
|
2009-08-25 15:49:09 +00:00
|
|
|
|
|
|
|
if (virAsprintf(&qemu_driver->libDir,
|
|
|
|
"%s/lib/libvirt/qemu", LOCAL_STATE_DIR) == -1)
|
|
|
|
goto out_of_memory;
|
|
|
|
|
|
|
|
if (virAsprintf(&qemu_driver->cacheDir,
|
|
|
|
"%s/cache/libvirt/qemu", LOCAL_STATE_DIR) == -1)
|
|
|
|
goto out_of_memory;
|
2007-06-26 22:13:21 +00:00
|
|
|
} else {
|
2009-06-12 13:20:13 +00:00
|
|
|
uid_t uid = geteuid();
|
2009-01-22 19:41:48 +00:00
|
|
|
char *userdir = virGetUserDirectory(NULL, uid);
|
|
|
|
if (!userdir)
|
2008-12-04 21:06:41 +00:00
|
|
|
goto error;
|
2007-06-26 22:13:21 +00:00
|
|
|
|
2008-12-23 13:03:29 +00:00
|
|
|
if (virAsprintf(&qemu_driver->logDir,
|
2009-01-22 19:41:48 +00:00
|
|
|
"%s/.libvirt/qemu/log", userdir) == -1) {
|
|
|
|
VIR_FREE(userdir);
|
2008-07-11 19:34:11 +00:00
|
|
|
goto out_of_memory;
|
2009-01-22 19:41:48 +00:00
|
|
|
}
|
2007-06-26 22:13:21 +00:00
|
|
|
|
2009-01-22 19:41:48 +00:00
|
|
|
if (virAsprintf(&base, "%s/.libvirt", userdir) == -1) {
|
|
|
|
VIR_FREE(userdir);
|
2007-06-26 22:13:21 +00:00
|
|
|
goto out_of_memory;
|
2009-01-22 19:41:48 +00:00
|
|
|
}
|
|
|
|
VIR_FREE(userdir);
|
2008-12-18 15:22:49 +00:00
|
|
|
|
|
|
|
if (virAsprintf(&qemu_driver->stateDir, "%s/qemu/run", base) == -1)
|
|
|
|
goto out_of_memory;
|
2009-08-25 15:49:09 +00:00
|
|
|
if (virAsprintf(&qemu_driver->libDir, "%s/qemu/lib", base) == -1)
|
|
|
|
goto out_of_memory;
|
|
|
|
if (virAsprintf(&qemu_driver->cacheDir, "%s/qemu/cache", base) == -1)
|
|
|
|
goto out_of_memory;
|
2008-12-18 15:22:49 +00:00
|
|
|
}
|
|
|
|
|
2010-01-20 23:52:13 +00:00
|
|
|
if (virFileMakePath(qemu_driver->stateDir) != 0) {
|
2009-02-05 16:27:28 +00:00
|
|
|
char ebuf[1024];
|
2010-01-19 13:17:20 +00:00
|
|
|
VIR_ERROR(_("Failed to create state dir '%s': %s"),
|
2009-03-03 11:40:08 +00:00
|
|
|
qemu_driver->stateDir, virStrerror(errno, ebuf, sizeof ebuf));
|
2009-01-22 19:41:48 +00:00
|
|
|
goto error;
|
2007-06-26 22:13:21 +00:00
|
|
|
}
|
2010-01-20 23:52:13 +00:00
|
|
|
if (virFileMakePath(qemu_driver->libDir) != 0) {
|
2009-08-25 15:49:09 +00:00
|
|
|
char ebuf[1024];
|
2010-01-19 13:17:20 +00:00
|
|
|
VIR_ERROR(_("Failed to create lib dir '%s': %s"),
|
2009-08-25 15:49:09 +00:00
|
|
|
qemu_driver->libDir, virStrerror(errno, ebuf, sizeof ebuf));
|
|
|
|
goto error;
|
|
|
|
}
|
2010-01-20 23:52:13 +00:00
|
|
|
if (virFileMakePath(qemu_driver->cacheDir) != 0) {
|
2009-08-25 15:49:09 +00:00
|
|
|
char ebuf[1024];
|
2010-01-19 13:17:20 +00:00
|
|
|
VIR_ERROR(_("Failed to create cache dir '%s': %s"),
|
2009-08-25 15:49:09 +00:00
|
|
|
qemu_driver->cacheDir, virStrerror(errno, ebuf, sizeof ebuf));
|
|
|
|
goto error;
|
|
|
|
}
|
2007-06-26 22:13:21 +00:00
|
|
|
|
|
|
|
/* Configuration paths are either ~/.libvirt/qemu/... (session) or
|
|
|
|
* /etc/libvirt/qemu/... (system).
|
|
|
|
*/
|
2007-10-12 16:05:44 +00:00
|
|
|
if (snprintf (driverConf, sizeof(driverConf), "%s/qemu.conf", base) == -1)
|
2007-06-26 22:13:21 +00:00
|
|
|
goto out_of_memory;
|
2007-10-12 16:05:44 +00:00
|
|
|
driverConf[sizeof(driverConf)-1] = '\0';
|
2007-06-26 22:13:21 +00:00
|
|
|
|
2008-12-23 13:03:29 +00:00
|
|
|
if (virAsprintf(&qemu_driver->configDir, "%s/qemu", base) == -1)
|
2007-06-26 22:13:21 +00:00
|
|
|
goto out_of_memory;
|
|
|
|
|
2008-12-23 13:03:29 +00:00
|
|
|
if (virAsprintf(&qemu_driver->autostartDir, "%s/qemu/autostart", base) == -1)
|
2007-06-26 22:13:21 +00:00
|
|
|
goto out_of_memory;
|
|
|
|
|
2008-05-29 19:20:22 +00:00
|
|
|
VIR_FREE(base);
|
2008-02-27 04:35:08 +00:00
|
|
|
|
2009-07-09 13:10:59 +00:00
|
|
|
rc = virCgroupForDriver("qemu", &qemu_driver->cgroup, privileged, 1);
|
|
|
|
if (rc < 0) {
|
|
|
|
char buf[1024];
|
|
|
|
VIR_WARN("Unable to create cgroup for driver: %s",
|
|
|
|
virStrerror(-rc, buf, sizeof(buf)));
|
|
|
|
}
|
|
|
|
|
2010-01-18 16:24:25 +00:00
|
|
|
if (qemudSecurityInit(qemu_driver) < 0)
|
|
|
|
goto error;
|
2007-10-12 16:05:44 +00:00
|
|
|
|
2010-01-18 16:24:25 +00:00
|
|
|
if ((qemu_driver->caps = qemuCreateCapabilities(NULL,
|
|
|
|
qemu_driver->securityDriver)) == NULL)
|
|
|
|
goto error;
|
2009-10-09 19:13:29 +00:00
|
|
|
|
2009-08-17 14:05:23 +00:00
|
|
|
if ((qemu_driver->activePciHostdevs = pciDeviceListNew(NULL)) == NULL)
|
|
|
|
goto error;
|
|
|
|
|
2009-03-16 17:16:04 +00:00
|
|
|
if (qemudLoadDriverConfig(qemu_driver, driverConf) < 0) {
|
2009-03-03 12:03:44 +00:00
|
|
|
goto error;
|
|
|
|
}
|
|
|
|
|
2009-08-26 14:42:31 +00:00
|
|
|
if (privileged) {
|
|
|
|
if (chown(qemu_driver->libDir, qemu_driver->user, qemu_driver->group) < 0) {
|
|
|
|
virReportSystemError(NULL, errno,
|
|
|
|
_("unable to set ownership of '%s' to user %d:%d"),
|
|
|
|
qemu_driver->libDir, qemu_driver->user, qemu_driver->group);
|
|
|
|
goto error;
|
|
|
|
}
|
|
|
|
if (chown(qemu_driver->cacheDir, qemu_driver->user, qemu_driver->group) < 0) {
|
|
|
|
virReportSystemError(NULL, errno,
|
|
|
|
_("unable to set ownership of '%s' to %d:%d"),
|
|
|
|
qemu_driver->cacheDir, qemu_driver->user, qemu_driver->group);
|
|
|
|
goto error;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
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
|
|
|
/* If hugetlbfs is present, then we need to create a sub-directory within
|
|
|
|
* it, since we can't assume the root mount point has permissions that
|
|
|
|
* will let our spawned QEMU instances use it.
|
|
|
|
*
|
|
|
|
* NB the check for '/', since user may config "" to disable hugepages
|
|
|
|
* even when mounted
|
|
|
|
*/
|
|
|
|
if (qemu_driver->hugetlbfs_mount &&
|
|
|
|
qemu_driver->hugetlbfs_mount[0] == '/') {
|
|
|
|
char *mempath = NULL;
|
|
|
|
if (virAsprintf(&mempath, "%s/libvirt/qemu", qemu_driver->hugetlbfs_mount) < 0)
|
|
|
|
goto out_of_memory;
|
|
|
|
|
|
|
|
if ((rc = virFileMakePath(mempath)) != 0) {
|
|
|
|
virReportSystemError(NULL, rc,
|
|
|
|
_("unable to create hugepage path %s"), mempath);
|
|
|
|
VIR_FREE(mempath);
|
|
|
|
goto error;
|
|
|
|
}
|
|
|
|
if (qemu_driver->privileged &&
|
|
|
|
chown(mempath, qemu_driver->user, qemu_driver->group) < 0) {
|
|
|
|
virReportSystemError(NULL, errno,
|
|
|
|
_("unable to set ownership on %s to %d:%d"),
|
|
|
|
mempath, qemu_driver->user, qemu_driver->group);
|
|
|
|
VIR_FREE(mempath);
|
|
|
|
goto error;
|
|
|
|
}
|
|
|
|
|
|
|
|
qemu_driver->hugepage_path = mempath;
|
|
|
|
}
|
|
|
|
|
2009-06-12 11:38:50 +00:00
|
|
|
/* Get all the running persistent or transient configs first */
|
|
|
|
if (virDomainLoadAllConfigs(NULL,
|
|
|
|
qemu_driver->caps,
|
|
|
|
&qemu_driver->domains,
|
|
|
|
qemu_driver->stateDir,
|
|
|
|
NULL,
|
|
|
|
1, NULL, NULL) < 0)
|
|
|
|
goto error;
|
|
|
|
|
|
|
|
qemuReconnectDomains(qemu_driver);
|
|
|
|
|
|
|
|
/* Then inactive persistent configs */
|
2008-07-11 19:34:11 +00:00
|
|
|
if (virDomainLoadAllConfigs(NULL,
|
|
|
|
qemu_driver->caps,
|
|
|
|
&qemu_driver->domains,
|
|
|
|
qemu_driver->configDir,
|
2008-11-17 16:52:32 +00:00
|
|
|
qemu_driver->autostartDir,
|
2009-06-12 11:38:50 +00:00
|
|
|
0, NULL, NULL) < 0)
|
2008-12-04 21:06:41 +00:00
|
|
|
goto error;
|
2009-05-19 11:06:25 +00:00
|
|
|
qemuDriverUnlock(qemu_driver);
|
|
|
|
|
2007-06-26 22:13:21 +00:00
|
|
|
qemudAutostartConfigs(qemu_driver);
|
|
|
|
|
2008-12-04 21:06:41 +00:00
|
|
|
|
2007-06-26 22:13:21 +00:00
|
|
|
return 0;
|
|
|
|
|
2008-12-04 21:06:41 +00:00
|
|
|
out_of_memory:
|
2009-02-05 16:27:40 +00:00
|
|
|
virReportOOMError(NULL);
|
2008-12-04 21:06:41 +00:00
|
|
|
error:
|
|
|
|
if (qemu_driver)
|
|
|
|
qemuDriverUnlock(qemu_driver);
|
2008-05-29 19:20:22 +00:00
|
|
|
VIR_FREE(base);
|
2008-12-04 21:06:41 +00:00
|
|
|
qemudShutdown();
|
2007-06-26 22:13:21 +00:00
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
|
2008-11-17 16:52:32 +00:00
|
|
|
static void qemudNotifyLoadDomain(virDomainObjPtr vm, int newVM, void *opaque)
|
|
|
|
{
|
|
|
|
struct qemud_driver *driver = opaque;
|
|
|
|
|
2008-12-04 21:09:20 +00:00
|
|
|
if (newVM) {
|
|
|
|
virDomainEventPtr event =
|
|
|
|
virDomainEventNewFromObj(vm,
|
|
|
|
VIR_DOMAIN_EVENT_DEFINED,
|
|
|
|
VIR_DOMAIN_EVENT_DEFINED_ADDED);
|
|
|
|
if (event)
|
|
|
|
qemuDomainEventQueue(driver, event);
|
|
|
|
}
|
2008-11-17 16:52:32 +00:00
|
|
|
}
|
|
|
|
|
2007-06-29 13:23:13 +00:00
|
|
|
/**
|
|
|
|
* qemudReload:
|
|
|
|
*
|
|
|
|
* Function to restart the QEmu daemon, it will recheck the configuration
|
|
|
|
* files and update its state and the networking
|
|
|
|
*/
|
|
|
|
static int
|
|
|
|
qemudReload(void) {
|
2008-10-10 14:20:37 +00:00
|
|
|
if (!qemu_driver)
|
|
|
|
return 0;
|
|
|
|
|
2008-12-04 21:06:41 +00:00
|
|
|
qemuDriverLock(qemu_driver);
|
2008-07-11 19:34:11 +00:00
|
|
|
virDomainLoadAllConfigs(NULL,
|
|
|
|
qemu_driver->caps,
|
|
|
|
&qemu_driver->domains,
|
|
|
|
qemu_driver->configDir,
|
2008-11-17 16:52:32 +00:00
|
|
|
qemu_driver->autostartDir,
|
2009-06-12 11:38:50 +00:00
|
|
|
0, qemudNotifyLoadDomain, qemu_driver);
|
2009-05-19 11:06:25 +00:00
|
|
|
qemuDriverUnlock(qemu_driver);
|
2008-07-11 19:34:11 +00:00
|
|
|
|
2007-06-26 22:13:21 +00:00
|
|
|
qemudAutostartConfigs(qemu_driver);
|
2007-06-26 22:56:14 +00:00
|
|
|
|
|
|
|
return 0;
|
2007-06-26 20:45:21 +00:00
|
|
|
}
|
|
|
|
|
2007-06-29 13:23:13 +00:00
|
|
|
/**
|
|
|
|
* qemudActive:
|
|
|
|
*
|
|
|
|
* Checks if the QEmu daemon is active, i.e. has an active domain or
|
|
|
|
* an active network
|
|
|
|
*
|
|
|
|
* Returns 1 if active, 0 otherwise
|
|
|
|
*/
|
|
|
|
static int
|
|
|
|
qemudActive(void) {
|
2008-12-04 21:06:41 +00:00
|
|
|
int active = 0;
|
2008-08-29 07:11:15 +00:00
|
|
|
|
2008-10-10 14:20:37 +00:00
|
|
|
if (!qemu_driver)
|
|
|
|
return 0;
|
|
|
|
|
Convert virDomainObjListPtr to use a hash of domain objects
The current virDomainObjListPtr object stores domain objects in
an array. This means that to find a particular objects requires
O(n) time, and more critically acquiring O(n) mutex locks.
The new impl replaces the array with a virHashTable, keyed off
UUID. Finding a object based on UUID is now O(1) time, and only
requires a single mutex lock. Finding by name/id is unchanged
in complexity.
In changing this, all code which iterates over the array had
to be updated to use a hash table iterator function callback.
Several of the functions which were identically duplicating
across all drivers were pulled into domain_conf.c
* src/conf/domain_conf.h, src/conf/domain_conf.c: Change
virDomainObjListPtr to use virHashTable. Add a initializer
method virDomainObjListInit, and rename virDomainObjListFree
to virDomainObjListDeinit, since its not actually freeing
the container, only its contents. Also add some convenient
methods virDomainObjListGetInactiveNames,
virDomainObjListGetActiveIDs and virDomainObjListNumOfDomains
which can be used to implement the correspondingly named
public API entry points in drivers
* src/libvirt_private.syms: Export new methods from domain_conf.h
* src/lxc/lxc_driver.c, src/opennebula/one_driver.c,
src/openvz/openvz_conf.c, src/openvz/openvz_driver.c,
src/qemu/qemu_driver.c, src/test/test_driver.c,
src/uml/uml_driver.c, src/vbox/vbox_tmpl.c: Update all code
to deal with hash tables instead of arrays for domains
2009-10-09 11:33:51 +00:00
|
|
|
/* XXX having to iterate here is not great because it requires many locks */
|
2008-12-04 21:06:41 +00:00
|
|
|
qemuDriverLock(qemu_driver);
|
Convert virDomainObjListPtr to use a hash of domain objects
The current virDomainObjListPtr object stores domain objects in
an array. This means that to find a particular objects requires
O(n) time, and more critically acquiring O(n) mutex locks.
The new impl replaces the array with a virHashTable, keyed off
UUID. Finding a object based on UUID is now O(1) time, and only
requires a single mutex lock. Finding by name/id is unchanged
in complexity.
In changing this, all code which iterates over the array had
to be updated to use a hash table iterator function callback.
Several of the functions which were identically duplicating
across all drivers were pulled into domain_conf.c
* src/conf/domain_conf.h, src/conf/domain_conf.c: Change
virDomainObjListPtr to use virHashTable. Add a initializer
method virDomainObjListInit, and rename virDomainObjListFree
to virDomainObjListDeinit, since its not actually freeing
the container, only its contents. Also add some convenient
methods virDomainObjListGetInactiveNames,
virDomainObjListGetActiveIDs and virDomainObjListNumOfDomains
which can be used to implement the correspondingly named
public API entry points in drivers
* src/libvirt_private.syms: Export new methods from domain_conf.h
* src/lxc/lxc_driver.c, src/opennebula/one_driver.c,
src/openvz/openvz_conf.c, src/openvz/openvz_driver.c,
src/qemu/qemu_driver.c, src/test/test_driver.c,
src/uml/uml_driver.c, src/vbox/vbox_tmpl.c: Update all code
to deal with hash tables instead of arrays for domains
2009-10-09 11:33:51 +00:00
|
|
|
active = virDomainObjListNumOfDomains(&qemu_driver->domains, 1);
|
2008-12-04 21:06:41 +00:00
|
|
|
qemuDriverUnlock(qemu_driver);
|
|
|
|
return active;
|
2007-06-26 22:56:14 +00:00
|
|
|
}
|
|
|
|
|
2007-06-29 13:23:13 +00:00
|
|
|
/**
|
|
|
|
* qemudShutdown:
|
|
|
|
*
|
|
|
|
* Shutdown the QEmu daemon, it will stop all active domains and networks
|
|
|
|
*/
|
|
|
|
static int
|
|
|
|
qemudShutdown(void) {
|
2009-11-24 11:44:23 +00:00
|
|
|
int i;
|
2007-06-26 20:41:25 +00:00
|
|
|
|
2007-06-26 22:13:21 +00:00
|
|
|
if (!qemu_driver)
|
2007-06-26 22:56:14 +00:00
|
|
|
return -1;
|
2007-06-26 22:13:21 +00:00
|
|
|
|
2008-12-04 21:06:41 +00:00
|
|
|
qemuDriverLock(qemu_driver);
|
2009-08-17 14:05:23 +00:00
|
|
|
pciDeviceListFree(NULL, qemu_driver->activePciHostdevs);
|
2008-02-27 04:35:08 +00:00
|
|
|
virCapabilitiesFree(qemu_driver->caps);
|
|
|
|
|
Convert virDomainObjListPtr to use a hash of domain objects
The current virDomainObjListPtr object stores domain objects in
an array. This means that to find a particular objects requires
O(n) time, and more critically acquiring O(n) mutex locks.
The new impl replaces the array with a virHashTable, keyed off
UUID. Finding a object based on UUID is now O(1) time, and only
requires a single mutex lock. Finding by name/id is unchanged
in complexity.
In changing this, all code which iterates over the array had
to be updated to use a hash table iterator function callback.
Several of the functions which were identically duplicating
across all drivers were pulled into domain_conf.c
* src/conf/domain_conf.h, src/conf/domain_conf.c: Change
virDomainObjListPtr to use virHashTable. Add a initializer
method virDomainObjListInit, and rename virDomainObjListFree
to virDomainObjListDeinit, since its not actually freeing
the container, only its contents. Also add some convenient
methods virDomainObjListGetInactiveNames,
virDomainObjListGetActiveIDs and virDomainObjListNumOfDomains
which can be used to implement the correspondingly named
public API entry points in drivers
* src/libvirt_private.syms: Export new methods from domain_conf.h
* src/lxc/lxc_driver.c, src/opennebula/one_driver.c,
src/openvz/openvz_conf.c, src/openvz/openvz_driver.c,
src/qemu/qemu_driver.c, src/test/test_driver.c,
src/uml/uml_driver.c, src/vbox/vbox_tmpl.c: Update all code
to deal with hash tables instead of arrays for domains
2009-10-09 11:33:51 +00:00
|
|
|
virDomainObjListDeinit(&qemu_driver->domains);
|
2007-06-26 20:41:25 +00:00
|
|
|
|
2009-03-03 12:03:44 +00:00
|
|
|
VIR_FREE(qemu_driver->securityDriverName);
|
2008-07-11 19:34:11 +00:00
|
|
|
VIR_FREE(qemu_driver->logDir);
|
2008-05-29 19:20:22 +00:00
|
|
|
VIR_FREE(qemu_driver->configDir);
|
|
|
|
VIR_FREE(qemu_driver->autostartDir);
|
2008-12-18 15:22:49 +00:00
|
|
|
VIR_FREE(qemu_driver->stateDir);
|
2009-08-25 15:49:09 +00:00
|
|
|
VIR_FREE(qemu_driver->libDir);
|
|
|
|
VIR_FREE(qemu_driver->cacheDir);
|
2008-05-29 19:20:22 +00:00
|
|
|
VIR_FREE(qemu_driver->vncTLSx509certdir);
|
2008-11-05 14:24:21 +00:00
|
|
|
VIR_FREE(qemu_driver->vncListen);
|
2009-01-29 17:50:00 +00:00
|
|
|
VIR_FREE(qemu_driver->vncPassword);
|
2009-03-16 13:54:26 +00:00
|
|
|
VIR_FREE(qemu_driver->vncSASLdir);
|
2009-08-17 10:34:53 +00:00
|
|
|
VIR_FREE(qemu_driver->saveImageFormat);
|
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
|
|
|
VIR_FREE(qemu_driver->hugetlbfs_mount);
|
|
|
|
VIR_FREE(qemu_driver->hugepage_path);
|
2007-12-01 15:45:25 +00:00
|
|
|
|
2009-11-24 11:44:23 +00:00
|
|
|
if (qemu_driver->cgroupDeviceACL) {
|
|
|
|
for (i = 0 ; qemu_driver->cgroupDeviceACL[i] != NULL ; i++)
|
|
|
|
VIR_FREE(qemu_driver->cgroupDeviceACL[i]);
|
|
|
|
VIR_FREE(qemu_driver->cgroupDeviceACL);
|
|
|
|
}
|
|
|
|
|
2008-10-23 13:18:18 +00:00
|
|
|
/* Free domain callback list */
|
|
|
|
virDomainEventCallbackListFree(qemu_driver->domainEventCallbacks);
|
2008-12-04 21:09:20 +00:00
|
|
|
virDomainEventQueueFree(qemu_driver->domainEventQueue);
|
|
|
|
|
|
|
|
if (qemu_driver->domainEventTimer != -1)
|
|
|
|
virEventRemoveTimeout(qemu_driver->domainEventTimer);
|
2008-10-23 13:18:18 +00:00
|
|
|
|
2007-06-26 22:13:21 +00:00
|
|
|
if (qemu_driver->brctl)
|
|
|
|
brShutdown(qemu_driver->brctl);
|
|
|
|
|
2009-07-09 13:10:59 +00:00
|
|
|
virCgroupFree(&qemu_driver->cgroup);
|
|
|
|
|
2008-12-04 21:06:41 +00:00
|
|
|
qemuDriverUnlock(qemu_driver);
|
2009-01-15 19:56:05 +00:00
|
|
|
virMutexDestroy(&qemu_driver->lock);
|
2008-05-29 19:20:22 +00:00
|
|
|
VIR_FREE(qemu_driver);
|
2007-06-26 22:56:14 +00:00
|
|
|
|
|
|
|
return 0;
|
2007-06-26 20:41:25 +00:00
|
|
|
}
|
|
|
|
|
2009-10-09 18:07:55 +00:00
|
|
|
typedef int qemuLogHandleOutput(virConnectPtr conn,
|
|
|
|
virDomainObjPtr vm,
|
|
|
|
const char *output,
|
|
|
|
int fd);
|
2009-02-13 11:35:16 +00:00
|
|
|
|
|
|
|
/*
|
|
|
|
* Returns -1 for error, 0 on success
|
|
|
|
*/
|
|
|
|
static int
|
|
|
|
qemudReadLogOutput(virConnectPtr conn,
|
|
|
|
virDomainObjPtr vm,
|
|
|
|
int fd,
|
|
|
|
char *buf,
|
2009-02-19 08:18:31 +00:00
|
|
|
size_t buflen,
|
2009-10-09 18:07:55 +00:00
|
|
|
qemuLogHandleOutput func,
|
2009-02-13 11:35:16 +00:00
|
|
|
const char *what,
|
|
|
|
int timeout)
|
|
|
|
{
|
2009-05-29 14:12:50 +00:00
|
|
|
int retries = (timeout*10);
|
2009-05-11 13:52:31 +00:00
|
|
|
int got = 0;
|
2009-02-13 11:35:16 +00:00
|
|
|
buf[0] = '\0';
|
|
|
|
|
|
|
|
while (retries) {
|
2009-05-29 14:12:50 +00:00
|
|
|
ssize_t func_ret, ret;
|
2009-05-11 13:52:31 +00:00
|
|
|
int isdead = 0;
|
2009-02-19 08:18:31 +00:00
|
|
|
|
2009-05-29 14:12:50 +00:00
|
|
|
func_ret = func(conn, vm, buf, fd);
|
|
|
|
|
2009-05-11 13:52:31 +00:00
|
|
|
if (kill(vm->pid, 0) == -1 && errno == ESRCH)
|
|
|
|
isdead = 1;
|
2009-02-13 11:35:16 +00:00
|
|
|
|
2009-05-29 14:12:50 +00:00
|
|
|
/* Any failures should be detected before we read the log, so we
|
|
|
|
* always have something useful to report on failure. */
|
2009-05-11 13:52:31 +00:00
|
|
|
ret = saferead(fd, buf+got, buflen-got-1);
|
|
|
|
if (ret < 0) {
|
2009-02-13 11:35:16 +00:00
|
|
|
virReportSystemError(conn, errno,
|
|
|
|
_("Failure while reading %s log output"),
|
|
|
|
what);
|
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
|
2009-05-11 13:52:31 +00:00
|
|
|
got += ret;
|
|
|
|
buf[got] = '\0';
|
|
|
|
if (got == buflen-1) {
|
|
|
|
qemudReportError(conn, NULL, NULL, VIR_ERR_INTERNAL_ERROR,
|
|
|
|
_("Out of space while reading %s log output"),
|
|
|
|
what);
|
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (isdead) {
|
|
|
|
qemudReportError(conn, NULL, NULL, VIR_ERR_INTERNAL_ERROR,
|
|
|
|
_("Process exited while reading %s log output"),
|
|
|
|
what);
|
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
|
2009-05-29 14:12:50 +00:00
|
|
|
if (func_ret <= 0)
|
|
|
|
return func_ret;
|
2009-02-13 11:35:16 +00:00
|
|
|
|
|
|
|
usleep(100*1000);
|
|
|
|
retries--;
|
|
|
|
}
|
2009-11-10 11:56:11 +00:00
|
|
|
|
|
|
|
qemudReportError(conn, NULL, NULL, VIR_ERR_INTERNAL_ERROR,
|
|
|
|
_("Timed out while reading %s log output"), what);
|
2009-02-13 11:35:16 +00:00
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
|
2007-07-23 18:00:33 +00:00
|
|
|
|
2009-10-09 18:07:55 +00:00
|
|
|
/*
|
|
|
|
* Look at a chunk of data from the QEMU stdout logs and try to
|
|
|
|
* find a TTY device, as indicated by a line like
|
|
|
|
*
|
|
|
|
* char device redirected to /dev/pts/3
|
|
|
|
*
|
|
|
|
* Returns -1 for error, 0 success, 1 continue reading
|
|
|
|
*/
|
2009-07-09 15:28:36 +00:00
|
|
|
static int
|
2009-10-09 18:07:55 +00:00
|
|
|
qemudExtractTTYPath(virConnectPtr conn,
|
|
|
|
const char *haystack,
|
|
|
|
size_t *offset,
|
|
|
|
char **path)
|
2009-07-09 15:28:36 +00:00
|
|
|
{
|
2007-06-26 20:41:25 +00:00
|
|
|
static const char needle[] = "char device redirected to";
|
2008-07-11 19:34:11 +00:00
|
|
|
char *tmp, *dev;
|
2007-06-26 20:41:25 +00:00
|
|
|
|
2008-07-11 19:34:11 +00:00
|
|
|
VIR_FREE(*path);
|
2008-04-25 20:46:13 +00:00
|
|
|
/* First look for our magic string */
|
2008-07-11 19:34:11 +00:00
|
|
|
if (!(tmp = strstr(haystack + *offset, needle))) {
|
|
|
|
return 1;
|
|
|
|
}
|
|
|
|
tmp += sizeof(needle);
|
|
|
|
dev = tmp;
|
2008-07-11 09:48:51 +00:00
|
|
|
|
2008-04-25 20:46:13 +00:00
|
|
|
/*
|
|
|
|
* And look for first whitespace character and nul terminate
|
|
|
|
* to mark end of the pty path
|
|
|
|
*/
|
|
|
|
while (*tmp) {
|
2008-05-09 13:50:14 +00:00
|
|
|
if (c_isspace(*tmp)) {
|
2009-08-03 15:07:19 +00:00
|
|
|
*path = strndup(dev, tmp-dev);
|
|
|
|
if (*path == NULL) {
|
2009-01-29 12:10:32 +00:00
|
|
|
virReportOOMError(conn);
|
2008-07-11 19:34:11 +00:00
|
|
|
return -1;
|
|
|
|
}
|
2009-08-03 15:07:19 +00:00
|
|
|
|
2008-07-11 09:48:51 +00:00
|
|
|
/* ... now further update offset till we get EOL */
|
2008-10-02 14:10:20 +00:00
|
|
|
*offset = tmp - haystack;
|
2007-06-26 20:41:25 +00:00
|
|
|
return 0;
|
|
|
|
}
|
2008-04-25 20:46:13 +00:00
|
|
|
tmp++;
|
2007-06-26 20:41:25 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* We found a path, but didn't find any whitespace,
|
|
|
|
* so it must be still incomplete - we should at
|
2008-04-25 20:46:13 +00:00
|
|
|
* least see a \n - indicate that we want to carry
|
|
|
|
* on trying again
|
2007-06-26 20:41:25 +00:00
|
|
|
*/
|
2008-07-11 19:34:11 +00:00
|
|
|
return 1;
|
2007-06-26 20:41:25 +00:00
|
|
|
}
|
|
|
|
|
2009-12-14 09:50:01 +00:00
|
|
|
static int
|
|
|
|
qemudFindCharDevicePTYsMonitor(virConnectPtr conn,
|
|
|
|
virDomainObjPtr vm,
|
|
|
|
virHashTablePtr paths)
|
|
|
|
{
|
|
|
|
int i;
|
|
|
|
|
|
|
|
#define LOOKUP_PTYS(array, arraylen, idprefix) \
|
|
|
|
for (i = 0 ; i < (arraylen) ; i++) { \
|
|
|
|
virDomainChrDefPtr chr = (array)[i]; \
|
|
|
|
if (chr->type == VIR_DOMAIN_CHR_TYPE_PTY) { \
|
|
|
|
char id[16]; \
|
|
|
|
\
|
|
|
|
if (snprintf(id, sizeof(id), idprefix "%i", i) >= sizeof(id)) \
|
|
|
|
return -1; \
|
|
|
|
\
|
|
|
|
const char *path = (const char *) virHashLookup(paths, id); \
|
|
|
|
if (path == NULL) { \
|
2010-01-16 17:32:56 +00:00
|
|
|
if (chr->data.file.path == NULL) { \
|
|
|
|
/* neither the log output nor 'info chardev' had a */ \
|
|
|
|
/* pty path for this chardev, report an error */ \
|
|
|
|
qemudReportError(conn, NULL, NULL, VIR_ERR_INTERNAL_ERROR, \
|
|
|
|
_("no assigned pty for device %s"), id); \
|
|
|
|
return -1; \
|
|
|
|
} else { \
|
|
|
|
/* 'info chardev' had no pty path for this chardev, */\
|
|
|
|
/* but the log output had, so we're fine */ \
|
|
|
|
continue; \
|
|
|
|
} \
|
2009-12-14 09:50:01 +00:00
|
|
|
} \
|
|
|
|
\
|
2010-01-09 20:19:08 +00:00
|
|
|
VIR_FREE(chr->data.file.path); \
|
2009-12-14 09:50:01 +00:00
|
|
|
chr->data.file.path = strdup(path); \
|
2010-01-09 20:19:08 +00:00
|
|
|
\
|
|
|
|
if (chr->data.file.path == NULL) { \
|
|
|
|
virReportOOMError(conn); \
|
|
|
|
return -1; \
|
|
|
|
} \
|
2009-12-14 09:50:01 +00:00
|
|
|
} \
|
|
|
|
}
|
|
|
|
|
|
|
|
LOOKUP_PTYS(vm->def->serials, vm->def->nserials, "serial");
|
|
|
|
LOOKUP_PTYS(vm->def->parallels, vm->def->nparallels, "parallel");
|
|
|
|
LOOKUP_PTYS(vm->def->channels, vm->def->nchannels, "channel");
|
2009-12-14 15:05:45 +00:00
|
|
|
#undef LOOKUP_PTYS
|
2009-12-14 09:50:01 +00:00
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2007-06-26 20:41:25 +00:00
|
|
|
static int
|
2008-04-25 20:46:13 +00:00
|
|
|
qemudFindCharDevicePTYs(virConnectPtr conn,
|
2008-07-11 19:34:11 +00:00
|
|
|
virDomainObjPtr vm,
|
2008-04-25 20:46:13 +00:00
|
|
|
const char *output,
|
|
|
|
int fd ATTRIBUTE_UNUSED)
|
2007-06-26 20:41:25 +00:00
|
|
|
{
|
2008-04-25 20:46:13 +00:00
|
|
|
size_t offset = 0;
|
2008-10-10 16:08:01 +00:00
|
|
|
int ret, i;
|
2008-04-25 20:46:13 +00:00
|
|
|
|
|
|
|
/* The order in which QEMU prints out the PTY paths is
|
2009-07-09 17:33:40 +00:00
|
|
|
the order in which it procsses its serial and parallel
|
|
|
|
device args. This code must match that ordering.... */
|
2007-06-26 20:41:25 +00:00
|
|
|
|
2009-07-09 17:33:40 +00:00
|
|
|
/* first comes the serial devices */
|
2008-10-10 16:08:01 +00:00
|
|
|
for (i = 0 ; i < vm->def->nserials ; i++) {
|
|
|
|
virDomainChrDefPtr chr = vm->def->serials[i];
|
2008-07-11 19:34:11 +00:00
|
|
|
if (chr->type == VIR_DOMAIN_CHR_TYPE_PTY) {
|
2009-10-09 18:07:55 +00:00
|
|
|
if ((ret = qemudExtractTTYPath(conn, output, &offset,
|
|
|
|
&chr->data.file.path)) != 0)
|
2009-07-09 17:33:40 +00:00
|
|
|
return ret;
|
2008-04-25 20:46:13 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2009-07-09 17:33:40 +00:00
|
|
|
/* then the parallel devices */
|
2008-10-10 16:08:01 +00:00
|
|
|
for (i = 0 ; i < vm->def->nparallels ; i++) {
|
|
|
|
virDomainChrDefPtr chr = vm->def->parallels[i];
|
2008-07-11 19:34:11 +00:00
|
|
|
if (chr->type == VIR_DOMAIN_CHR_TYPE_PTY) {
|
2009-10-09 18:07:55 +00:00
|
|
|
if ((ret = qemudExtractTTYPath(conn, output, &offset,
|
|
|
|
&chr->data.file.path)) != 0)
|
2009-07-09 17:33:40 +00:00
|
|
|
return ret;
|
2008-04-25 20:46:13 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2009-12-14 09:42:14 +00:00
|
|
|
/* then the channel devices */
|
|
|
|
for (i = 0 ; i < vm->def->nchannels ; i++) {
|
|
|
|
virDomainChrDefPtr chr = vm->def->channels[i];
|
|
|
|
if (chr->type == VIR_DOMAIN_CHR_TYPE_PTY) {
|
|
|
|
if ((ret = qemudExtractTTYPath(conn, output, &offset,
|
|
|
|
&chr->data.file.path)) != 0)
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2009-07-09 15:02:19 +00:00
|
|
|
return 0;
|
2007-06-26 20:41:25 +00:00
|
|
|
}
|
|
|
|
|
2009-12-14 09:50:01 +00:00
|
|
|
static void qemudFreePtyPath(void *payload, const char *name ATTRIBUTE_UNUSED)
|
|
|
|
{
|
|
|
|
VIR_FREE(payload);
|
|
|
|
}
|
|
|
|
|
2009-07-09 15:28:36 +00:00
|
|
|
static int
|
|
|
|
qemudWaitForMonitor(virConnectPtr conn,
|
|
|
|
struct qemud_driver* driver,
|
|
|
|
virDomainObjPtr vm, off_t pos)
|
2009-01-20 15:52:11 +00:00
|
|
|
{
|
2009-05-11 13:50:38 +00:00
|
|
|
char buf[4096]; /* Plenty of space to get startup greeting */
|
2009-01-20 15:52:11 +00:00
|
|
|
int logfd;
|
2009-12-14 09:50:01 +00:00
|
|
|
int ret = -1;
|
2009-01-20 15:52:11 +00:00
|
|
|
|
|
|
|
if ((logfd = qemudLogReadFD(conn, driver->logDir, vm->def->name, pos))
|
|
|
|
< 0)
|
2009-01-30 17:07:29 +00:00
|
|
|
return -1;
|
2009-01-20 15:52:11 +00:00
|
|
|
|
2009-02-13 11:35:16 +00:00
|
|
|
ret = qemudReadLogOutput(conn, vm, logfd, buf, sizeof(buf),
|
|
|
|
qemudFindCharDevicePTYs,
|
|
|
|
"console", 3);
|
2009-02-05 16:27:28 +00:00
|
|
|
if (close(logfd) < 0) {
|
2009-05-11 13:50:38 +00:00
|
|
|
char ebuf[4096];
|
2010-01-19 13:17:20 +00:00
|
|
|
VIR_WARN(_("Unable to close logfile: %s"),
|
2009-02-05 16:27:28 +00:00
|
|
|
virStrerror(errno, ebuf, sizeof ebuf));
|
|
|
|
}
|
2009-01-30 17:07:29 +00:00
|
|
|
|
2009-07-09 17:33:40 +00:00
|
|
|
if (ret < 0) {
|
|
|
|
/* Unexpected end of file - inform user of QEMU log data */
|
|
|
|
qemudReportError(conn, NULL, NULL, VIR_ERR_INTERNAL_ERROR,
|
|
|
|
_("unable to start guest: %s"), buf);
|
|
|
|
return -1;
|
|
|
|
}
|
2009-01-30 17:07:29 +00:00
|
|
|
|
Fully asynchronous monitor I/O processing
Change the QEMU monitor file handle watch to poll for both
read & write events, as well as EOF. All I/O to/from the
QEMU monitor FD is now done in the event callback thread.
When the QEMU driver needs to send a command, it puts the
data to be sent into a qemuMonitorMessagePtr object instance,
queues it for dispatch, and then goes to sleep on a condition
variable. The event thread sends all the data, and then waits
for the reply to arrive, putting the response / error data
back into the qemuMonitorMessagePtr and notifying the condition
variable.
There is a temporary hack in the disk passphrase callback to
avoid acquiring the domain lock. This avoids a deadlock in
the command processing, since the domain lock is still held
when running monitor commands. The next commit will remove
the locking when running commands & thus allow re-introduction
of locking the disk passphrase callback
* src/qemu/qemu_driver.c: Temporarily don't acquire lock in
disk passphrase callback. To be reverted in next commit
* src/qemu/qemu_monitor.c, src/qemu/qemu_monitor.h: Remove
raw I/O functions, and a generic qemuMonitorSend() for
invoking a command
* src/qemu/qemu_monitor_text.c, src/qemu/qemu_monitor_text.h:
Remove all low level I/O, and use the new qemuMonitorSend()
API. Provide a qemuMonitorTextIOProcess() method for detecting
command/reply/prompt boundaries in the monitor data stream
2009-10-14 17:40:51 +00:00
|
|
|
VIR_DEBUG("Connect monitor to %p '%s'", vm, vm->def->name);
|
|
|
|
if (qemuConnectMonitor(vm) < 0)
|
2009-07-09 17:33:40 +00:00
|
|
|
return -1;
|
|
|
|
|
2009-12-14 09:50:01 +00:00
|
|
|
/* Try to get the pty path mappings again via the monitor. This is much more
|
|
|
|
* reliable if it's available.
|
|
|
|
* Note that the monitor itself can be on a pty, so we still need to try the
|
|
|
|
* log output method. */
|
|
|
|
virHashTablePtr paths = virHashCreate(0);
|
|
|
|
if (paths == NULL) {
|
|
|
|
virReportOOMError(NULL);
|
|
|
|
goto cleanup;
|
|
|
|
}
|
|
|
|
|
2009-12-14 10:05:55 +00:00
|
|
|
qemuDomainObjEnterMonitorWithDriver(driver, vm);
|
2009-12-14 09:50:01 +00:00
|
|
|
qemuDomainObjPrivatePtr priv = vm->privateData;
|
|
|
|
ret = qemuMonitorGetPtyPaths(priv->mon, paths);
|
2009-12-14 10:05:55 +00:00
|
|
|
qemuDomainObjExitMonitorWithDriver(driver, vm);
|
2009-12-14 09:50:01 +00:00
|
|
|
|
|
|
|
VIR_DEBUG("qemuMonitorGetPtyPaths returned %i", ret);
|
|
|
|
if (ret == 0) {
|
|
|
|
ret = qemudFindCharDevicePTYsMonitor(conn, vm, paths);
|
|
|
|
}
|
|
|
|
|
|
|
|
cleanup:
|
|
|
|
if (paths) {
|
|
|
|
virHashFree(paths, qemudFreePtyPath);
|
|
|
|
}
|
|
|
|
|
|
|
|
return ret;
|
2007-06-26 20:41:25 +00:00
|
|
|
}
|
|
|
|
|
2008-05-22 16:20:31 +00:00
|
|
|
static int
|
2009-09-23 10:49:14 +00:00
|
|
|
qemuDetectVcpuPIDs(virConnectPtr conn,
|
2009-11-18 15:58:32 +00:00
|
|
|
struct qemud_driver *driver,
|
2009-09-23 10:49:14 +00:00
|
|
|
virDomainObjPtr vm) {
|
|
|
|
pid_t *cpupids = NULL;
|
|
|
|
int ncpupids;
|
2009-10-09 20:13:06 +00:00
|
|
|
qemuDomainObjPrivatePtr priv = vm->privateData;
|
2008-05-22 16:20:31 +00:00
|
|
|
|
2008-07-11 19:34:11 +00:00
|
|
|
if (vm->def->virtType != VIR_DOMAIN_VIRT_KVM) {
|
2009-11-26 17:57:00 +00:00
|
|
|
priv->nvcpupids = 1;
|
|
|
|
if (VIR_ALLOC_N(priv->vcpupids, priv->nvcpupids) < 0) {
|
2009-09-23 10:49:14 +00:00
|
|
|
virReportOOMError(conn);
|
|
|
|
return -1;
|
|
|
|
}
|
2009-11-26 17:57:00 +00:00
|
|
|
priv->vcpupids[0] = vm->pid;
|
2008-05-22 16:20:31 +00:00
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2009-09-23 10:49:14 +00:00
|
|
|
/* What follows is now all KVM specific */
|
2008-05-22 16:20:31 +00:00
|
|
|
|
2009-11-18 15:58:32 +00:00
|
|
|
qemuDomainObjEnterMonitorWithDriver(driver, vm);
|
2009-10-13 14:27:58 +00:00
|
|
|
if ((ncpupids = qemuMonitorGetCPUInfo(priv->mon, &cpupids)) < 0) {
|
2009-11-18 15:58:32 +00:00
|
|
|
qemuDomainObjExitMonitorWithDriver(driver, vm);
|
2009-09-23 10:49:14 +00:00
|
|
|
return -1;
|
2009-10-13 14:27:58 +00:00
|
|
|
}
|
2009-11-18 15:58:32 +00:00
|
|
|
qemuDomainObjExitMonitorWithDriver(driver, vm);
|
2008-05-22 16:20:31 +00:00
|
|
|
|
2009-09-23 10:49:14 +00:00
|
|
|
/* Treat failure to get VCPU<->PID mapping as non-fatal */
|
|
|
|
if (ncpupids == 0)
|
|
|
|
return 0;
|
2008-05-22 16:20:31 +00:00
|
|
|
|
2009-09-23 10:49:14 +00:00
|
|
|
if (ncpupids != vm->def->vcpus) {
|
|
|
|
qemudReportError(conn, NULL, NULL, VIR_ERR_INTERNAL_ERROR,
|
|
|
|
_("got wrong number of vCPU pids from QEMU monitor. got %d, wanted %d"),
|
|
|
|
ncpupids, (int)vm->def->vcpus);
|
|
|
|
VIR_FREE(cpupids);
|
|
|
|
return -1;
|
|
|
|
}
|
2008-05-22 16:20:31 +00:00
|
|
|
|
2009-11-26 17:57:00 +00:00
|
|
|
priv->nvcpupids = ncpupids;
|
|
|
|
priv->vcpupids = cpupids;
|
2008-05-22 16:20:31 +00:00
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2008-05-22 16:27:20 +00:00
|
|
|
static int
|
2009-11-26 13:51:42 +00:00
|
|
|
qemudInitCpuAffinity(virConnectPtr conn,
|
|
|
|
virDomainObjPtr vm) {
|
2009-11-05 15:21:33 +00:00
|
|
|
int i, hostcpus, maxcpu = QEMUD_CPUMASK_LEN;
|
2008-05-22 16:27:20 +00:00
|
|
|
virNodeInfo nodeinfo;
|
2009-11-16 15:22:34 +00:00
|
|
|
unsigned char *cpumap;
|
|
|
|
int cpumaplen;
|
2009-11-26 17:57:00 +00:00
|
|
|
qemuDomainObjPrivatePtr priv = vm->privateData;
|
2008-05-22 16:27:20 +00:00
|
|
|
|
2009-06-03 13:28:02 +00:00
|
|
|
if (nodeGetInfo(conn, &nodeinfo) < 0)
|
2008-05-22 16:27:20 +00:00
|
|
|
return -1;
|
|
|
|
|
|
|
|
/* setaffinity fails if you set bits for CPUs which
|
|
|
|
* aren't present, so we have to limit ourselves */
|
2009-11-05 15:21:33 +00:00
|
|
|
hostcpus = VIR_NODEINFO_MAXCPUS(nodeinfo);
|
|
|
|
if (maxcpu > hostcpus)
|
|
|
|
maxcpu = hostcpus;
|
2008-05-22 16:27:20 +00:00
|
|
|
|
2009-11-16 15:22:34 +00:00
|
|
|
cpumaplen = VIR_CPU_MAPLEN(maxcpu);
|
|
|
|
if (VIR_ALLOC_N(cpumap, cpumaplen) < 0) {
|
|
|
|
virReportOOMError(conn);
|
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
|
2008-07-25 09:31:24 +00:00
|
|
|
if (vm->def->cpumask) {
|
2009-11-16 15:22:34 +00:00
|
|
|
/* XXX why don't we keep 'cpumask' in the libvirt cpumap
|
|
|
|
* format to start with ?!?! */
|
|
|
|
for (i = 0 ; i < maxcpu && i < vm->def->cpumasklen ; i++)
|
2008-07-25 09:31:24 +00:00
|
|
|
if (vm->def->cpumask[i])
|
2009-11-16 15:22:34 +00:00
|
|
|
VIR_USE_CPU(cpumap, i);
|
2008-07-25 09:31:24 +00:00
|
|
|
} else {
|
2009-11-16 15:22:34 +00:00
|
|
|
/* You may think this is redundant, but we can't assume libvirtd
|
|
|
|
* itself is running on all pCPUs, so we need to explicitly set
|
|
|
|
* the spawned QEMU instance to all pCPUs if no map is given in
|
|
|
|
* its config file */
|
2008-07-25 09:31:24 +00:00
|
|
|
for (i = 0 ; i < maxcpu ; i++)
|
2009-11-16 15:22:34 +00:00
|
|
|
VIR_USE_CPU(cpumap, i);
|
2008-07-25 09:31:24 +00:00
|
|
|
}
|
2008-05-22 16:27:20 +00:00
|
|
|
|
2009-11-16 15:22:34 +00:00
|
|
|
/* The XML config only gives a per-VM affinity, so we apply
|
|
|
|
* the same mapping to all vCPUs */
|
2009-11-26 17:57:00 +00:00
|
|
|
for (i = 0 ; i < priv->nvcpupids ; i++) {
|
|
|
|
if (virProcessInfoSetAffinity(priv->vcpupids[i],
|
2009-11-16 15:22:34 +00:00
|
|
|
cpumap, cpumaplen, maxcpu) < 0) {
|
|
|
|
VIR_FREE(cpumap);
|
2008-05-22 16:27:20 +00:00
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
}
|
2009-11-16 15:22:34 +00:00
|
|
|
VIR_FREE(cpumap);
|
2008-05-22 16:27:20 +00:00
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
2009-01-29 17:50:00 +00:00
|
|
|
static int
|
2009-09-23 11:10:58 +00:00
|
|
|
qemuInitPasswords(struct qemud_driver *driver,
|
|
|
|
virDomainObjPtr vm) {
|
2009-09-23 11:06:57 +00:00
|
|
|
int ret = 0;
|
2009-10-09 20:13:06 +00:00
|
|
|
qemuDomainObjPrivatePtr priv = vm->privateData;
|
2009-01-29 17:50:00 +00:00
|
|
|
|
2009-05-07 07:27:49 +00:00
|
|
|
if ((vm->def->ngraphics == 1) &&
|
|
|
|
vm->def->graphics[0]->type == VIR_DOMAIN_GRAPHICS_TYPE_VNC &&
|
|
|
|
(vm->def->graphics[0]->data.vnc.passwd || driver->vncPassword)) {
|
2009-01-29 17:50:00 +00:00
|
|
|
|
2009-11-18 15:58:32 +00:00
|
|
|
qemuDomainObjEnterMonitorWithDriver(driver, vm);
|
2009-10-09 20:13:06 +00:00
|
|
|
ret = qemuMonitorSetVNCPassword(priv->mon,
|
2009-09-23 11:06:57 +00:00
|
|
|
vm->def->graphics[0]->data.vnc.passwd ?
|
|
|
|
vm->def->graphics[0]->data.vnc.passwd :
|
|
|
|
driver->vncPassword);
|
2009-11-18 15:58:32 +00:00
|
|
|
qemuDomainObjExitMonitorWithDriver(driver, vm);
|
2009-01-29 17:50:00 +00:00
|
|
|
}
|
|
|
|
|
2009-09-23 11:06:57 +00:00
|
|
|
return ret;
|
2009-01-29 17:50:00 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
|
Detect PCI addresses at QEMU startup
Hotunplug of devices requires that we know their PCI address. Even
hotplug of SCSI drives, required that we know the PCI address of
the SCSI controller to attach the drive to. We can find this out
by running 'info pci' and then correlating the vendor/product IDs
with the devices we booted with.
Although this approach is somewhat fragile, it is the only viable
option with QEMU < 0.12, since there is no way for libvirto set
explicit PCI addresses when creating devices in the first place.
For QEMU > 0.12, this code will not be used.
* src/qemu/qemu_driver.c: Assign all dynamic PCI addresses on
startup of QEMU VM, matching vendor/product IDs
* src/qemu/qemu_monitor.c, src/qemu/qemu_monitor.h,
src/qemu/qemu_monitor_json.c, src/qemu/qemu_monitor_json.h,
src/qemu/qemu_monitor_text.c, src/qemu/qemu_monitor_text.h: Add
API for fetching PCI device address mapping
2009-12-09 21:59:04 +00:00
|
|
|
#define QEMU_PCI_VENDOR_INTEL 0x8086
|
|
|
|
#define QEMU_PCI_VENDOR_LSI_LOGIC 0x1000
|
|
|
|
#define QEMU_PCI_VENDOR_REDHAT 0x1af4
|
|
|
|
#define QEMU_PCI_VENDOR_CIRRUS 0x1013
|
|
|
|
#define QEMU_PCI_VENDOR_REALTEK 0x10ec
|
|
|
|
#define QEMU_PCI_VENDOR_AMD 0x1022
|
|
|
|
#define QEMU_PCI_VENDOR_ENSONIQ 0x1274
|
|
|
|
#define QEMU_PCI_VENDOR_VMWARE 0x15ad
|
|
|
|
#define QEMU_PCI_VENDOR_QEMU 0x1234
|
|
|
|
|
|
|
|
#define QEMU_PCI_PRODUCT_DISK_VIRTIO 0x1001
|
|
|
|
|
|
|
|
#define QEMU_PCI_PRODUCT_NIC_NE2K 0x8029
|
|
|
|
#define QEMU_PCI_PRODUCT_NIC_PCNET 0x2000
|
|
|
|
#define QEMU_PCI_PRODUCT_NIC_RTL8139 0x8139
|
|
|
|
#define QEMU_PCI_PRODUCT_NIC_E1000 0x100E
|
|
|
|
#define QEMU_PCI_PRODUCT_NIC_VIRTIO 0x1000
|
|
|
|
|
|
|
|
#define QEMU_PCI_PRODUCT_VGA_CIRRUS 0x00b8
|
|
|
|
#define QEMU_PCI_PRODUCT_VGA_VMWARE 0x0405
|
|
|
|
#define QEMU_PCI_PRODUCT_VGA_STDVGA 0x1111
|
|
|
|
|
|
|
|
#define QEMU_PCI_PRODUCT_AUDIO_AC97 0x2415
|
|
|
|
#define QEMU_PCI_PRODUCT_AUDIO_ES1370 0x5000
|
|
|
|
|
|
|
|
#define QEMU_PCI_PRODUCT_CONTROLLER_PIIX 0x7010
|
|
|
|
#define QEMU_PCI_PRODUCT_CONTROLLER_LSI 0x0012
|
|
|
|
|
|
|
|
#define QEMU_PCI_PRODUCT_WATCHDOG_I63000ESB 0x25ab
|
|
|
|
|
|
|
|
static int
|
|
|
|
qemuAssignNextPCIAddress(virDomainDeviceInfo *info,
|
|
|
|
int vendor,
|
|
|
|
int product,
|
|
|
|
qemuMonitorPCIAddress *addrs,
|
|
|
|
int naddrs)
|
|
|
|
{
|
|
|
|
int found = 0;
|
|
|
|
int i;
|
|
|
|
|
|
|
|
VIR_DEBUG("Look for %x:%x out of %d", vendor, product, naddrs);
|
|
|
|
|
|
|
|
for (i = 0 ; (i < naddrs) && !found; i++) {
|
|
|
|
VIR_DEBUG("Maybe %x:%x", addrs[i].vendor, addrs[i].product);
|
|
|
|
if (addrs[i].vendor == vendor &&
|
|
|
|
addrs[i].product == product) {
|
|
|
|
VIR_DEBUG("Match %d", i);
|
|
|
|
found = 1;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
if (!found) {
|
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Blank it out so this device isn't matched again */
|
|
|
|
addrs[i].vendor = 0;
|
|
|
|
addrs[i].product = 0;
|
|
|
|
|
|
|
|
if (info->type == VIR_DOMAIN_DEVICE_ADDRESS_TYPE_NONE)
|
|
|
|
info->type = VIR_DOMAIN_DEVICE_ADDRESS_TYPE_PCI;
|
|
|
|
|
|
|
|
if (info->type == VIR_DOMAIN_DEVICE_ADDRESS_TYPE_PCI) {
|
|
|
|
info->addr.pci.domain = addrs[i].addr.domain;
|
|
|
|
info->addr.pci.bus = addrs[i].addr.bus;
|
|
|
|
info->addr.pci.slot = addrs[i].addr.slot;
|
|
|
|
info->addr.pci.function = addrs[i].addr.function;
|
|
|
|
}
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
static int
|
|
|
|
qemuGetPCIDiskVendorProduct(virDomainDiskDefPtr def,
|
|
|
|
unsigned *vendor,
|
|
|
|
unsigned *product)
|
|
|
|
{
|
|
|
|
switch (def->bus) {
|
|
|
|
case VIR_DOMAIN_DISK_BUS_VIRTIO:
|
|
|
|
*vendor = QEMU_PCI_VENDOR_REDHAT;
|
|
|
|
*product = QEMU_PCI_PRODUCT_DISK_VIRTIO;
|
|
|
|
break;
|
|
|
|
|
|
|
|
default:
|
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
static int
|
|
|
|
qemuGetPCINetVendorProduct(virDomainNetDefPtr def,
|
|
|
|
unsigned *vendor,
|
|
|
|
unsigned *product)
|
|
|
|
{
|
|
|
|
if (!def->model)
|
|
|
|
return -1;
|
|
|
|
|
|
|
|
if (STREQ(def->model, "ne2k_pci")) {
|
|
|
|
*vendor = QEMU_PCI_VENDOR_REALTEK;
|
|
|
|
*product = QEMU_PCI_PRODUCT_NIC_NE2K;
|
|
|
|
} else if (STREQ(def->model, "pcnet")) {
|
|
|
|
*vendor = QEMU_PCI_VENDOR_AMD;
|
|
|
|
*product = QEMU_PCI_PRODUCT_NIC_PCNET;
|
|
|
|
} else if (STREQ(def->model, "rtl8139")) {
|
|
|
|
*vendor = QEMU_PCI_VENDOR_REALTEK;
|
|
|
|
*product = QEMU_PCI_PRODUCT_NIC_RTL8139;
|
|
|
|
} else if (STREQ(def->model, "e1000")) {
|
|
|
|
*vendor = QEMU_PCI_VENDOR_INTEL;
|
|
|
|
*product = QEMU_PCI_PRODUCT_NIC_E1000;
|
|
|
|
} else if (STREQ(def->model, "virtio")) {
|
|
|
|
*vendor = QEMU_PCI_VENDOR_REDHAT;
|
|
|
|
*product = QEMU_PCI_PRODUCT_NIC_VIRTIO;
|
|
|
|
} else {
|
|
|
|
VIR_INFO("Unexpected NIC model %s, cannot get PCI address",
|
|
|
|
def->model);
|
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
static int
|
|
|
|
qemuGetPCIControllerVendorProduct(virDomainControllerDefPtr def,
|
|
|
|
unsigned *vendor,
|
|
|
|
unsigned *product)
|
|
|
|
{
|
|
|
|
switch (def->type) {
|
|
|
|
case VIR_DOMAIN_CONTROLLER_TYPE_SCSI:
|
|
|
|
*vendor = QEMU_PCI_VENDOR_LSI_LOGIC;
|
|
|
|
*product = QEMU_PCI_PRODUCT_CONTROLLER_LSI;
|
|
|
|
break;
|
|
|
|
|
|
|
|
case VIR_DOMAIN_CONTROLLER_TYPE_FDC:
|
|
|
|
/* XXX we could put in the ISA bridge address, but
|
|
|
|
that's not technically the FDC's address */
|
|
|
|
return -1;
|
|
|
|
|
|
|
|
case VIR_DOMAIN_CONTROLLER_TYPE_IDE:
|
|
|
|
*vendor = QEMU_PCI_VENDOR_INTEL;
|
|
|
|
*product = QEMU_PCI_PRODUCT_CONTROLLER_PIIX;
|
|
|
|
break;
|
|
|
|
|
|
|
|
default:
|
|
|
|
VIR_INFO("Unexpected controller type %s, cannot get PCI address",
|
|
|
|
virDomainControllerTypeToString(def->type));
|
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
static int
|
|
|
|
qemuGetPCIVideoVendorProduct(virDomainVideoDefPtr def,
|
|
|
|
unsigned *vendor,
|
|
|
|
unsigned *product)
|
|
|
|
{
|
|
|
|
switch (def->type) {
|
|
|
|
case VIR_DOMAIN_VIDEO_TYPE_CIRRUS:
|
|
|
|
*vendor = QEMU_PCI_VENDOR_CIRRUS;
|
|
|
|
*product = QEMU_PCI_PRODUCT_VGA_CIRRUS;
|
|
|
|
break;
|
|
|
|
|
|
|
|
case VIR_DOMAIN_VIDEO_TYPE_VGA:
|
|
|
|
*vendor = QEMU_PCI_VENDOR_QEMU;
|
|
|
|
*product = QEMU_PCI_PRODUCT_VGA_STDVGA;
|
|
|
|
break;
|
|
|
|
|
|
|
|
case VIR_DOMAIN_VIDEO_TYPE_VMVGA:
|
|
|
|
*vendor = QEMU_PCI_VENDOR_VMWARE;
|
|
|
|
*product = QEMU_PCI_PRODUCT_VGA_VMWARE;
|
|
|
|
break;
|
|
|
|
|
|
|
|
default:
|
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
static int
|
|
|
|
qemuGetPCISoundVendorProduct(virDomainSoundDefPtr def,
|
|
|
|
unsigned *vendor,
|
|
|
|
unsigned *product)
|
|
|
|
{
|
|
|
|
switch (def->model) {
|
|
|
|
case VIR_DOMAIN_SOUND_MODEL_ES1370:
|
|
|
|
*vendor = QEMU_PCI_VENDOR_ENSONIQ;
|
|
|
|
*product = QEMU_PCI_PRODUCT_AUDIO_ES1370;
|
|
|
|
break;
|
|
|
|
|
|
|
|
case VIR_DOMAIN_SOUND_MODEL_AC97:
|
|
|
|
*vendor = QEMU_PCI_VENDOR_INTEL;
|
|
|
|
*product = QEMU_PCI_PRODUCT_AUDIO_AC97;
|
|
|
|
break;
|
|
|
|
|
|
|
|
default:
|
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
static int
|
|
|
|
qemuGetPCIWatchdogVendorProduct(virDomainWatchdogDefPtr def,
|
|
|
|
unsigned *vendor,
|
|
|
|
unsigned *product)
|
|
|
|
{
|
|
|
|
switch (def->model) {
|
|
|
|
case VIR_DOMAIN_WATCHDOG_MODEL_I6300ESB:
|
|
|
|
*vendor = QEMU_PCI_VENDOR_INTEL;
|
|
|
|
*product = QEMU_PCI_PRODUCT_WATCHDOG_I63000ESB;
|
|
|
|
break;
|
|
|
|
|
|
|
|
default:
|
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
/*
|
|
|
|
* This entire method assumes that PCI devices in 'info pci'
|
|
|
|
* match ordering of devices specified on the command line
|
|
|
|
* wrt to devices of matching vendor+product
|
|
|
|
*
|
|
|
|
* XXXX this might not be a valid assumption if we assign
|
|
|
|
* some static addrs on CLI. Have to check that...
|
|
|
|
*/
|
|
|
|
static int
|
|
|
|
qemuAssignPCIAddresses(virDomainObjPtr vm,
|
|
|
|
qemuMonitorPCIAddress *addrs,
|
|
|
|
int naddrs)
|
|
|
|
{
|
|
|
|
unsigned int vendor = 0, product = 0;
|
|
|
|
int i;
|
|
|
|
|
|
|
|
/* XXX should all these vendor/product IDs be kept in the
|
|
|
|
* actual device data structure instead ?
|
|
|
|
*/
|
|
|
|
|
|
|
|
for (i = 0 ; i < vm->def->ndisks ; i++) {
|
|
|
|
if (qemuGetPCIDiskVendorProduct(vm->def->disks[i], &vendor, &product) < 0)
|
|
|
|
continue;
|
|
|
|
|
|
|
|
if (qemuAssignNextPCIAddress(&(vm->def->disks[i]->info),
|
|
|
|
vendor, product,
|
|
|
|
addrs, naddrs) < 0) {
|
|
|
|
qemudReportError(NULL, NULL, NULL, VIR_ERR_INTERNAL_ERROR,
|
|
|
|
_("cannot find PCI address for VirtIO disk %s"),
|
|
|
|
vm->def->disks[i]->dst);
|
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
for (i = 0 ; i < vm->def->nnets ; i++) {
|
|
|
|
if (qemuGetPCINetVendorProduct(vm->def->nets[i], &vendor, &product) < 0)
|
|
|
|
continue;
|
|
|
|
|
|
|
|
if (qemuAssignNextPCIAddress(&(vm->def->nets[i]->info),
|
|
|
|
vendor, product,
|
|
|
|
addrs, naddrs) < 0) {
|
|
|
|
qemudReportError(NULL, NULL, NULL, VIR_ERR_INTERNAL_ERROR,
|
|
|
|
_("cannot find PCI address for %s NIC"),
|
|
|
|
vm->def->nets[i]->model);
|
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
for (i = 0 ; i < vm->def->ncontrollers ; i++) {
|
|
|
|
if (qemuGetPCIControllerVendorProduct(vm->def->controllers[i], &vendor, &product) < 0)
|
|
|
|
continue;
|
|
|
|
|
|
|
|
if (qemuAssignNextPCIAddress(&(vm->def->controllers[i]->info),
|
|
|
|
vendor, product,
|
|
|
|
addrs, naddrs) < 0) {
|
|
|
|
qemudReportError(NULL, NULL, NULL, VIR_ERR_INTERNAL_ERROR,
|
|
|
|
_("cannot find PCI address for controller %s"),
|
|
|
|
virDomainControllerTypeToString(vm->def->controllers[i]->type));
|
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
for (i = 0 ; i < vm->def->nvideos ; i++) {
|
|
|
|
if (qemuGetPCIVideoVendorProduct(vm->def->videos[i], &vendor, &product) < 0)
|
|
|
|
continue;
|
|
|
|
|
|
|
|
if (qemuAssignNextPCIAddress(&(vm->def->videos[i]->info),
|
|
|
|
vendor, product,
|
|
|
|
addrs, naddrs) < 0) {
|
|
|
|
qemudReportError(NULL, NULL, NULL, VIR_ERR_INTERNAL_ERROR,
|
|
|
|
_("cannot find PCI address for video adapter %s"),
|
|
|
|
virDomainVideoTypeToString(vm->def->videos[i]->type));
|
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
for (i = 0 ; i < vm->def->nsounds ; i++) {
|
|
|
|
if (qemuGetPCISoundVendorProduct(vm->def->sounds[i], &vendor, &product) < 0)
|
|
|
|
continue;
|
|
|
|
|
|
|
|
if (qemuAssignNextPCIAddress(&(vm->def->sounds[i]->info),
|
|
|
|
vendor, product,
|
|
|
|
addrs, naddrs) < 0) {
|
|
|
|
qemudReportError(NULL, NULL, NULL, VIR_ERR_INTERNAL_ERROR,
|
|
|
|
_("cannot find PCI address for sound adapter %s"),
|
|
|
|
virDomainSoundModelTypeToString(vm->def->sounds[i]->model));
|
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
if (vm->def->watchdog &&
|
|
|
|
qemuGetPCIWatchdogVendorProduct(vm->def->watchdog, &vendor, &product) == 0) {
|
|
|
|
if (qemuAssignNextPCIAddress(&(vm->def->watchdog->info),
|
|
|
|
vendor, product,
|
|
|
|
addrs, naddrs) < 0) {
|
|
|
|
qemudReportError(NULL, NULL, NULL, VIR_ERR_INTERNAL_ERROR,
|
|
|
|
_("cannot find PCI address for watchdog %s"),
|
|
|
|
virDomainWatchdogModelTypeToString(vm->def->watchdog->model));
|
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
/* XXX console (virtio) */
|
|
|
|
|
|
|
|
|
|
|
|
/* ... and now things we don't have in our xml */
|
|
|
|
|
|
|
|
/* XXX USB controller ? */
|
|
|
|
|
|
|
|
/* XXXX virtio balloon ? */
|
|
|
|
|
|
|
|
/* XXX what about other PCI devices (ie bridges) */
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
static int
|
|
|
|
qemuInitPCIAddresses(struct qemud_driver *driver,
|
|
|
|
virDomainObjPtr vm)
|
|
|
|
{
|
|
|
|
qemuDomainObjPrivatePtr priv = vm->privateData;
|
|
|
|
int naddrs;
|
|
|
|
int ret;
|
|
|
|
qemuMonitorPCIAddress *addrs = NULL;
|
|
|
|
|
|
|
|
qemuDomainObjEnterMonitorWithDriver(driver, vm);
|
|
|
|
naddrs = qemuMonitorGetAllPCIAddresses(priv->mon,
|
|
|
|
&addrs);
|
|
|
|
qemuDomainObjExitMonitorWithDriver(driver, vm);
|
|
|
|
|
|
|
|
ret = qemuAssignPCIAddresses(vm, addrs, naddrs);
|
|
|
|
|
|
|
|
VIR_FREE(addrs);
|
|
|
|
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
2007-06-26 22:13:21 +00:00
|
|
|
static int qemudNextFreeVNCPort(struct qemud_driver *driver ATTRIBUTE_UNUSED) {
|
2007-06-26 20:41:25 +00:00
|
|
|
int i;
|
|
|
|
|
|
|
|
for (i = 5900 ; i < 6000 ; i++) {
|
|
|
|
int fd;
|
|
|
|
int reuse = 1;
|
|
|
|
struct sockaddr_in addr;
|
|
|
|
addr.sin_family = AF_INET;
|
|
|
|
addr.sin_port = htons(i);
|
|
|
|
addr.sin_addr.s_addr = htonl(INADDR_ANY);
|
|
|
|
fd = socket(PF_INET, SOCK_STREAM, 0);
|
|
|
|
if (fd < 0)
|
|
|
|
return -1;
|
|
|
|
|
|
|
|
if (setsockopt(fd, SOL_SOCKET, SO_REUSEADDR, (void*)&reuse, sizeof(reuse)) < 0) {
|
|
|
|
close(fd);
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (bind(fd, (struct sockaddr*)&addr, sizeof(addr)) == 0) {
|
|
|
|
/* Not in use, lets grab it */
|
|
|
|
close(fd);
|
|
|
|
return i;
|
|
|
|
}
|
|
|
|
close(fd);
|
|
|
|
|
|
|
|
if (errno == EADDRINUSE) {
|
|
|
|
/* In use, try next */
|
|
|
|
continue;
|
|
|
|
}
|
|
|
|
/* Some other bad failure, get out.. */
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
|
2009-08-17 14:05:23 +00:00
|
|
|
static pciDeviceList *
|
|
|
|
qemuGetPciHostDeviceList(virConnectPtr conn,
|
|
|
|
virDomainDefPtr def)
|
|
|
|
{
|
|
|
|
pciDeviceList *list;
|
2009-03-03 08:59:45 +00:00
|
|
|
int i;
|
|
|
|
|
2009-08-17 14:05:23 +00:00
|
|
|
if (!(list = pciDeviceListNew(conn)))
|
|
|
|
return NULL;
|
2009-03-03 08:59:45 +00:00
|
|
|
|
|
|
|
for (i = 0 ; i < def->nhostdevs ; i++) {
|
|
|
|
virDomainHostdevDefPtr hostdev = def->hostdevs[i];
|
|
|
|
pciDevice *dev;
|
|
|
|
|
|
|
|
if (hostdev->mode != VIR_DOMAIN_HOSTDEV_MODE_SUBSYS)
|
|
|
|
continue;
|
|
|
|
if (hostdev->source.subsys.type != VIR_DOMAIN_HOSTDEV_SUBSYS_TYPE_PCI)
|
|
|
|
continue;
|
|
|
|
|
|
|
|
dev = pciGetDevice(conn,
|
|
|
|
hostdev->source.subsys.u.pci.domain,
|
|
|
|
hostdev->source.subsys.u.pci.bus,
|
|
|
|
hostdev->source.subsys.u.pci.slot,
|
|
|
|
hostdev->source.subsys.u.pci.function);
|
2009-08-17 14:05:23 +00:00
|
|
|
if (!dev) {
|
|
|
|
pciDeviceListFree(conn, list);
|
|
|
|
return NULL;
|
|
|
|
}
|
2009-03-03 08:59:45 +00:00
|
|
|
|
2009-08-17 14:05:23 +00:00
|
|
|
if (pciDeviceListAdd(conn, list, dev) < 0) {
|
2009-03-03 08:59:45 +00:00
|
|
|
pciFreeDevice(conn, dev);
|
2009-08-17 14:05:23 +00:00
|
|
|
pciDeviceListFree(conn, list);
|
|
|
|
return NULL;
|
2009-03-03 08:59:45 +00:00
|
|
|
}
|
|
|
|
|
2009-08-17 14:05:23 +00:00
|
|
|
pciDeviceSetManaged(dev, hostdev->managed);
|
2009-03-03 08:59:45 +00:00
|
|
|
}
|
|
|
|
|
2009-08-17 14:05:23 +00:00
|
|
|
return list;
|
|
|
|
}
|
|
|
|
|
|
|
|
static int
|
2009-08-17 14:05:23 +00:00
|
|
|
qemuUpdateActivePciHostdevs(struct qemud_driver *driver,
|
|
|
|
virDomainDefPtr def)
|
|
|
|
{
|
|
|
|
pciDeviceList *pcidevs;
|
2010-01-25 16:13:41 +00:00
|
|
|
int i;
|
2009-10-27 17:30:16 +00:00
|
|
|
int ret = -1;
|
2009-08-17 14:05:23 +00:00
|
|
|
|
|
|
|
if (!def->nhostdevs)
|
|
|
|
return 0;
|
|
|
|
|
|
|
|
if (!(pcidevs = qemuGetPciHostDeviceList(NULL, def)))
|
|
|
|
return -1;
|
|
|
|
|
2010-01-25 16:13:41 +00:00
|
|
|
for (i = 0; i < pciDeviceListCount(pcidevs); i++) {
|
|
|
|
pciDevice *dev = pciDeviceListGet(pcidevs, i);
|
|
|
|
pciDeviceListSteal(NULL, pcidevs, dev);
|
2009-08-17 14:05:23 +00:00
|
|
|
if (pciDeviceListAdd(NULL,
|
|
|
|
driver->activePciHostdevs,
|
2009-10-27 17:30:16 +00:00
|
|
|
dev) < 0) {
|
|
|
|
pciFreeDevice(NULL, dev);
|
|
|
|
goto cleanup;
|
2009-08-17 14:05:23 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2009-10-27 17:30:16 +00:00
|
|
|
ret = 0;
|
|
|
|
|
|
|
|
cleanup:
|
2009-08-17 14:05:23 +00:00
|
|
|
pciDeviceListFree(NULL, pcidevs);
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
|
|
|
static int
|
|
|
|
qemuPrepareHostDevices(virConnectPtr conn,
|
|
|
|
struct qemud_driver *driver,
|
|
|
|
virDomainDefPtr def)
|
2009-08-17 14:05:23 +00:00
|
|
|
{
|
|
|
|
pciDeviceList *pcidevs;
|
|
|
|
int i;
|
2009-10-27 17:30:16 +00:00
|
|
|
int ret = -1;
|
2009-08-17 14:05:23 +00:00
|
|
|
|
|
|
|
if (!def->nhostdevs)
|
|
|
|
return 0;
|
|
|
|
|
|
|
|
if (!(pcidevs = qemuGetPciHostDeviceList(conn, def)))
|
|
|
|
return -1;
|
|
|
|
|
2009-08-17 14:05:23 +00:00
|
|
|
/* We have to use 3 loops here. *All* devices must
|
2009-08-17 14:05:23 +00:00
|
|
|
* be detached before we reset any of them, because
|
|
|
|
* in some cases you have to reset the whole PCI,
|
2009-08-17 14:05:23 +00:00
|
|
|
* which impacts all devices on it. Also, all devices
|
|
|
|
* must be reset before being marked as active.
|
2009-08-17 14:05:23 +00:00
|
|
|
*/
|
|
|
|
|
|
|
|
/* XXX validate that non-managed device isn't in use, eg
|
|
|
|
* by checking that device is either un-bound, or bound
|
|
|
|
* to pci-stub.ko
|
|
|
|
*/
|
|
|
|
|
2009-10-27 17:30:16 +00:00
|
|
|
for (i = 0; i < pciDeviceListCount(pcidevs); i++) {
|
|
|
|
pciDevice *dev = pciDeviceListGet(pcidevs, i);
|
2009-12-22 17:21:16 +00:00
|
|
|
if (!pciDeviceIsAssignable(conn, dev, !driver->relaxedACS))
|
|
|
|
goto cleanup;
|
|
|
|
|
2009-10-27 17:30:16 +00:00
|
|
|
if (pciDeviceGetManaged(dev) &&
|
|
|
|
pciDettachDevice(conn, dev) < 0)
|
|
|
|
goto cleanup;
|
|
|
|
}
|
2009-08-17 14:05:23 +00:00
|
|
|
|
|
|
|
/* Now that all the PCI hostdevs have be dettached, we can safely
|
|
|
|
* reset them */
|
2009-10-27 17:30:16 +00:00
|
|
|
for (i = 0; i < pciDeviceListCount(pcidevs); i++) {
|
|
|
|
pciDevice *dev = pciDeviceListGet(pcidevs, i);
|
|
|
|
if (pciResetDevice(conn, dev,
|
2009-08-17 14:05:23 +00:00
|
|
|
driver->activePciHostdevs) < 0)
|
2009-10-27 17:30:16 +00:00
|
|
|
goto cleanup;
|
|
|
|
}
|
2009-08-17 14:05:23 +00:00
|
|
|
|
2009-08-17 14:05:23 +00:00
|
|
|
/* Now mark all the devices as active */
|
2009-10-27 17:30:16 +00:00
|
|
|
for (i = 0; i < pciDeviceListCount(pcidevs); i++) {
|
|
|
|
pciDevice *dev = pciDeviceListGet(pcidevs, i);
|
|
|
|
pciDeviceListSteal(NULL, pcidevs, dev);
|
2009-08-17 14:05:23 +00:00
|
|
|
if (pciDeviceListAdd(conn,
|
|
|
|
driver->activePciHostdevs,
|
2009-10-27 17:30:16 +00:00
|
|
|
dev) < 0) {
|
|
|
|
pciFreeDevice(NULL, dev);
|
|
|
|
goto cleanup;
|
|
|
|
}
|
2009-08-17 14:05:23 +00:00
|
|
|
}
|
|
|
|
|
2009-10-27 17:30:16 +00:00
|
|
|
ret = 0;
|
2009-03-03 08:59:45 +00:00
|
|
|
|
2009-10-27 17:30:16 +00:00
|
|
|
cleanup:
|
2009-08-17 14:05:23 +00:00
|
|
|
pciDeviceListFree(conn, pcidevs);
|
2009-10-27 17:30:16 +00:00
|
|
|
return ret;
|
2009-03-03 08:59:45 +00:00
|
|
|
}
|
|
|
|
|
2010-01-26 15:01:23 +00:00
|
|
|
static void
|
|
|
|
qemudReattachManagedDevice(pciDevice *dev)
|
|
|
|
{
|
|
|
|
int retries = 100;
|
|
|
|
|
|
|
|
if (pciDeviceGetManaged(dev)) {
|
|
|
|
while (pciWaitForDeviceCleanup(dev, "kvm_assigned_device")
|
|
|
|
&& retries) {
|
|
|
|
usleep(100*1000);
|
|
|
|
retries--;
|
|
|
|
}
|
|
|
|
if (pciReAttachDevice(NULL, dev) < 0) {
|
|
|
|
virErrorPtr err = virGetLastError();
|
|
|
|
VIR_ERROR(_("Failed to re-attach PCI device: %s"),
|
|
|
|
err ? err->message : "");
|
|
|
|
virResetError(err);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2009-08-14 07:31:11 +00:00
|
|
|
static void
|
2009-08-17 14:05:23 +00:00
|
|
|
qemuDomainReAttachHostDevices(virConnectPtr conn,
|
|
|
|
struct qemud_driver *driver,
|
|
|
|
virDomainDefPtr def)
|
2009-08-14 07:31:11 +00:00
|
|
|
{
|
2009-08-17 14:05:23 +00:00
|
|
|
pciDeviceList *pcidevs;
|
2009-08-14 07:31:11 +00:00
|
|
|
int i;
|
|
|
|
|
2009-08-17 14:05:23 +00:00
|
|
|
if (!def->nhostdevs)
|
|
|
|
return;
|
2009-08-14 07:31:11 +00:00
|
|
|
|
2009-08-17 14:05:23 +00:00
|
|
|
if (!(pcidevs = qemuGetPciHostDeviceList(conn, def))) {
|
|
|
|
virErrorPtr err = virGetLastError();
|
2010-01-19 13:17:20 +00:00
|
|
|
VIR_ERROR(_("Failed to allocate pciDeviceList: %s"),
|
2009-08-17 14:05:23 +00:00
|
|
|
err ? err->message : "");
|
|
|
|
virResetError(err);
|
|
|
|
return;
|
2009-08-14 07:31:11 +00:00
|
|
|
}
|
|
|
|
|
2009-08-17 14:05:23 +00:00
|
|
|
/* Again 3 loops; mark all devices as inactive before reset
|
|
|
|
* them and reset all the devices before re-attach */
|
2009-08-14 07:31:11 +00:00
|
|
|
|
2009-10-27 17:30:16 +00:00
|
|
|
for (i = 0; i < pciDeviceListCount(pcidevs); i++) {
|
|
|
|
pciDevice *dev = pciDeviceListGet(pcidevs, i);
|
|
|
|
pciDeviceListDel(conn, driver->activePciHostdevs, dev);
|
|
|
|
}
|
2009-08-17 14:05:23 +00:00
|
|
|
|
2009-10-27 17:30:16 +00:00
|
|
|
for (i = 0; i < pciDeviceListCount(pcidevs); i++) {
|
|
|
|
pciDevice *dev = pciDeviceListGet(pcidevs, i);
|
|
|
|
if (pciResetDevice(conn, dev,
|
2009-08-17 14:05:23 +00:00
|
|
|
driver->activePciHostdevs) < 0) {
|
2009-08-14 07:31:11 +00:00
|
|
|
virErrorPtr err = virGetLastError();
|
2010-01-19 13:17:20 +00:00
|
|
|
VIR_ERROR(_("Failed to reset PCI device: %s"),
|
2009-08-14 07:31:11 +00:00
|
|
|
err ? err->message : "");
|
|
|
|
virResetError(err);
|
|
|
|
}
|
2009-10-27 17:30:16 +00:00
|
|
|
}
|
2009-08-14 07:31:11 +00:00
|
|
|
|
2009-10-27 17:30:16 +00:00
|
|
|
for (i = 0; i < pciDeviceListCount(pcidevs); i++) {
|
|
|
|
pciDevice *dev = pciDeviceListGet(pcidevs, i);
|
2010-01-26 15:01:23 +00:00
|
|
|
qemudReattachManagedDevice(dev);
|
2009-10-27 17:30:16 +00:00
|
|
|
}
|
2009-08-14 07:31:11 +00:00
|
|
|
|
2009-08-17 14:05:23 +00:00
|
|
|
pciDeviceListFree(conn, pcidevs);
|
2009-08-14 07:31:11 +00:00
|
|
|
}
|
|
|
|
|
2009-07-09 13:11:49 +00:00
|
|
|
static const char *const defaultDeviceACL[] = {
|
|
|
|
"/dev/null", "/dev/full", "/dev/zero",
|
|
|
|
"/dev/random", "/dev/urandom",
|
|
|
|
"/dev/ptmx", "/dev/kvm", "/dev/kqemu",
|
|
|
|
"/dev/rtc", "/dev/hpet", "/dev/net/tun",
|
|
|
|
NULL,
|
|
|
|
};
|
|
|
|
#define DEVICE_PTY_MAJOR 136
|
|
|
|
#define DEVICE_SND_MAJOR 116
|
|
|
|
|
2009-07-09 13:10:59 +00:00
|
|
|
static int qemuSetupCgroup(virConnectPtr conn,
|
|
|
|
struct qemud_driver *driver,
|
|
|
|
virDomainObjPtr vm)
|
|
|
|
{
|
|
|
|
virCgroupPtr cgroup = NULL;
|
|
|
|
int rc;
|
2009-07-09 13:11:49 +00:00
|
|
|
unsigned int i;
|
2009-07-22 15:08:04 +00:00
|
|
|
const char *const *deviceACL =
|
|
|
|
driver->cgroupDeviceACL ?
|
|
|
|
(const char *const *)driver->cgroupDeviceACL :
|
|
|
|
defaultDeviceACL;
|
2009-07-09 13:10:59 +00:00
|
|
|
|
|
|
|
if (driver->cgroup == NULL)
|
|
|
|
return 0; /* Not supported, so claim success */
|
|
|
|
|
|
|
|
rc = virCgroupForDomain(driver->cgroup, vm->def->name, &cgroup, 1);
|
|
|
|
if (rc != 0) {
|
|
|
|
virReportSystemError(conn, -rc,
|
|
|
|
_("Unable to create cgroup for %s"),
|
|
|
|
vm->def->name);
|
|
|
|
goto cleanup;
|
|
|
|
}
|
|
|
|
|
2009-07-22 15:08:04 +00:00
|
|
|
if (qemuCgroupControllerActive(driver, VIR_CGROUP_CONTROLLER_DEVICES)) {
|
|
|
|
rc = virCgroupDenyAllDevices(cgroup);
|
2009-07-09 13:11:49 +00:00
|
|
|
if (rc != 0) {
|
2009-07-22 15:08:04 +00:00
|
|
|
if (rc == -EPERM) {
|
|
|
|
VIR_WARN0("Group devices ACL is not accessible, disabling whitelisting");
|
|
|
|
goto done;
|
|
|
|
}
|
|
|
|
|
2009-07-09 13:11:49 +00:00
|
|
|
virReportSystemError(conn, -rc,
|
2009-07-22 15:08:04 +00:00
|
|
|
_("Unable to deny all devices for %s"), vm->def->name);
|
2009-07-09 13:11:49 +00:00
|
|
|
goto cleanup;
|
|
|
|
}
|
|
|
|
|
2009-07-22 15:08:04 +00:00
|
|
|
for (i = 0; i < vm->def->ndisks ; i++) {
|
|
|
|
if (vm->def->disks[i]->type != VIR_DOMAIN_DISK_TYPE_BLOCK ||
|
|
|
|
vm->def->disks[i]->src == NULL)
|
|
|
|
continue;
|
|
|
|
|
|
|
|
rc = virCgroupAllowDevicePath(cgroup,
|
|
|
|
vm->def->disks[i]->src);
|
|
|
|
if (rc != 0) {
|
|
|
|
virReportSystemError(conn, -rc,
|
|
|
|
_("Unable to allow device %s for %s"),
|
|
|
|
vm->def->disks[i]->src, vm->def->name);
|
|
|
|
goto cleanup;
|
|
|
|
}
|
|
|
|
}
|
2009-07-09 13:11:49 +00:00
|
|
|
|
2009-07-22 15:08:04 +00:00
|
|
|
rc = virCgroupAllowDeviceMajor(cgroup, 'c', DEVICE_PTY_MAJOR);
|
2009-07-09 13:11:49 +00:00
|
|
|
if (rc != 0) {
|
|
|
|
virReportSystemError(conn, -rc, "%s",
|
2009-07-22 15:08:04 +00:00
|
|
|
_("unable to allow /dev/pts/ devices"));
|
2009-07-09 13:11:49 +00:00
|
|
|
goto cleanup;
|
|
|
|
}
|
|
|
|
|
2009-07-22 15:08:04 +00:00
|
|
|
if (vm->def->nsounds) {
|
|
|
|
rc = virCgroupAllowDeviceMajor(cgroup, 'c', DEVICE_SND_MAJOR);
|
|
|
|
if (rc != 0) {
|
|
|
|
virReportSystemError(conn, -rc, "%s",
|
|
|
|
_("unable to allow /dev/snd/ devices"));
|
|
|
|
goto cleanup;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
for (i = 0; deviceACL[i] != NULL ; i++) {
|
|
|
|
rc = virCgroupAllowDevicePath(cgroup,
|
|
|
|
deviceACL[i]);
|
|
|
|
if (rc < 0 &&
|
|
|
|
rc != -ENOENT) {
|
|
|
|
virReportSystemError(conn, -rc,
|
|
|
|
_("unable to allow device %s"),
|
|
|
|
deviceACL[i]);
|
|
|
|
goto cleanup;
|
|
|
|
}
|
2009-07-09 13:11:49 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
done:
|
2009-07-09 13:10:59 +00:00
|
|
|
virCgroupFree(&cgroup);
|
|
|
|
return 0;
|
|
|
|
|
|
|
|
cleanup:
|
|
|
|
if (cgroup) {
|
|
|
|
virCgroupRemove(cgroup);
|
|
|
|
virCgroupFree(&cgroup);
|
|
|
|
}
|
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
static int qemuRemoveCgroup(virConnectPtr conn,
|
|
|
|
struct qemud_driver *driver,
|
2009-12-14 09:30:49 +00:00
|
|
|
virDomainObjPtr vm,
|
|
|
|
int quiet)
|
2009-07-09 13:10:59 +00:00
|
|
|
{
|
|
|
|
virCgroupPtr cgroup;
|
|
|
|
int rc;
|
|
|
|
|
|
|
|
if (driver->cgroup == NULL)
|
|
|
|
return 0; /* Not supported, so claim success */
|
|
|
|
|
|
|
|
rc = virCgroupForDomain(driver->cgroup, vm->def->name, &cgroup, 0);
|
|
|
|
if (rc != 0) {
|
2009-12-14 09:30:49 +00:00
|
|
|
if (!quiet)
|
|
|
|
qemudReportError(conn, NULL, NULL, VIR_ERR_INTERNAL_ERROR,
|
|
|
|
_("Unable to find cgroup for %s\n"),
|
|
|
|
vm->def->name);
|
2009-07-09 13:10:59 +00:00
|
|
|
return rc;
|
|
|
|
}
|
|
|
|
|
|
|
|
rc = virCgroupRemove(cgroup);
|
|
|
|
virCgroupFree(&cgroup);
|
|
|
|
return rc;
|
|
|
|
}
|
|
|
|
|
|
|
|
static int qemuAddToCgroup(struct qemud_driver *driver,
|
|
|
|
virDomainDefPtr def)
|
|
|
|
{
|
|
|
|
virCgroupPtr cgroup = NULL;
|
|
|
|
int ret = -1;
|
|
|
|
int rc;
|
|
|
|
|
|
|
|
if (driver->cgroup == NULL)
|
|
|
|
return 0; /* Not supported, so claim success */
|
|
|
|
|
|
|
|
rc = virCgroupForDomain(driver->cgroup, def->name, &cgroup, 0);
|
|
|
|
if (rc != 0) {
|
|
|
|
virReportSystemError(NULL, -rc,
|
|
|
|
_("unable to find cgroup for domain %s"),
|
|
|
|
def->name);
|
|
|
|
goto cleanup;
|
|
|
|
}
|
|
|
|
|
|
|
|
rc = virCgroupAddTask(cgroup, getpid());
|
|
|
|
if (rc != 0) {
|
|
|
|
virReportSystemError(NULL, -rc,
|
|
|
|
_("unable to add domain %s task %d to cgroup"),
|
|
|
|
def->name, getpid());
|
|
|
|
goto cleanup;
|
|
|
|
}
|
|
|
|
|
|
|
|
ret = 0;
|
|
|
|
|
|
|
|
cleanup:
|
|
|
|
virCgroupFree(&cgroup);
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
struct qemudHookData {
|
|
|
|
virConnectPtr conn;
|
|
|
|
virDomainObjPtr vm;
|
|
|
|
struct qemud_driver *driver;
|
2009-03-03 12:03:44 +00:00
|
|
|
};
|
|
|
|
|
|
|
|
static int qemudSecurityHook(void *data) {
|
2009-07-09 13:10:59 +00:00
|
|
|
struct qemudHookData *h = data;
|
|
|
|
|
|
|
|
if (qemuAddToCgroup(h->driver, h->vm->def) < 0)
|
|
|
|
return -1;
|
2009-07-15 21:25:01 +00:00
|
|
|
|
2010-01-13 17:06:57 +00:00
|
|
|
if (h->driver->securityDriver &&
|
|
|
|
h->driver->securityDriver->domainSetSecurityProcessLabel &&
|
|
|
|
h->driver->securityDriver->domainSetSecurityProcessLabel(h->conn, h->driver->securityDriver, h->vm) < 0)
|
2009-07-15 21:25:01 +00:00
|
|
|
return -1;
|
|
|
|
|
|
|
|
return 0;
|
2009-03-03 12:03:44 +00:00
|
|
|
}
|
|
|
|
|
2009-07-09 17:33:40 +00:00
|
|
|
static int
|
|
|
|
qemuPrepareMonitorChr(virConnectPtr conn,
|
|
|
|
struct qemud_driver *driver,
|
2009-11-26 17:57:00 +00:00
|
|
|
virDomainChrDefPtr monConfig,
|
2009-07-09 17:33:40 +00:00
|
|
|
const char *vm)
|
|
|
|
{
|
2009-11-26 17:57:00 +00:00
|
|
|
monConfig->targetType = VIR_DOMAIN_CHR_TARGET_TYPE_MONITOR;
|
2009-11-05 13:19:14 +00:00
|
|
|
|
2009-11-26 17:57:00 +00:00
|
|
|
monConfig->type = VIR_DOMAIN_CHR_TYPE_UNIX;
|
|
|
|
monConfig->data.nix.listen = 1;
|
2009-07-09 17:33:40 +00:00
|
|
|
|
2010-01-07 19:25:41 +00:00
|
|
|
if (!(monConfig->info.alias = strdup("monitor"))) {
|
|
|
|
virReportOOMError(conn);
|
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
|
2009-11-26 17:57:00 +00:00
|
|
|
if (virAsprintf(&monConfig->data.nix.path, "%s/%s.monitor",
|
2009-08-25 15:49:09 +00:00
|
|
|
driver->libDir, vm) < 0) {
|
2009-07-09 17:33:40 +00:00
|
|
|
virReportOOMError(conn);
|
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2007-07-12 15:09:01 +00:00
|
|
|
static int qemudStartVMDaemon(virConnectPtr conn,
|
|
|
|
struct qemud_driver *driver,
|
2008-07-11 19:34:11 +00:00
|
|
|
virDomainObjPtr vm,
|
2009-01-29 17:27:54 +00:00
|
|
|
const char *migrateFrom,
|
|
|
|
int stdin_fd) {
|
2008-08-08 15:43:38 +00:00
|
|
|
const char **argv = NULL, **tmp;
|
2008-10-10 16:52:20 +00:00
|
|
|
const char **progenv = NULL;
|
2008-04-08 12:27:53 +00:00
|
|
|
int i, ret;
|
2008-05-16 16:51:30 +00:00
|
|
|
struct stat sb;
|
2008-07-11 19:34:11 +00:00
|
|
|
int *tapfds = NULL;
|
|
|
|
int ntapfds = 0;
|
2008-08-29 07:11:15 +00:00
|
|
|
unsigned int qemuCmdFlags;
|
2008-08-27 11:42:52 +00:00
|
|
|
fd_set keepfd;
|
2008-09-05 11:52:12 +00:00
|
|
|
const char *emulator;
|
2009-01-19 21:55:54 +00:00
|
|
|
pid_t child;
|
2009-01-20 15:52:11 +00:00
|
|
|
int pos = -1;
|
2009-02-05 16:27:28 +00:00
|
|
|
char ebuf[1024];
|
2009-05-11 13:50:38 +00:00
|
|
|
char *pidfile = NULL;
|
2009-06-12 11:38:50 +00:00
|
|
|
int logfile;
|
2009-10-13 14:27:58 +00:00
|
|
|
qemuDomainObjPrivatePtr priv = vm->privateData;
|
2008-08-27 11:42:52 +00:00
|
|
|
|
2009-07-09 13:10:59 +00:00
|
|
|
struct qemudHookData hookData;
|
2009-03-03 12:03:44 +00:00
|
|
|
hookData.conn = conn;
|
|
|
|
hookData.vm = vm;
|
|
|
|
hookData.driver = driver;
|
|
|
|
|
2008-08-27 11:42:52 +00:00
|
|
|
FD_ZERO(&keepfd);
|
2007-06-26 20:41:25 +00:00
|
|
|
|
Rename internal APis
Rename virDomainIsActive to virDomainObjIsActive, and
virInterfaceIsActive to virInterfaceObjIsActive and finally
virNetworkIsActive to virNetworkObjIsActive.
* src/conf/domain_conf.c, src/conf/domain_conf.h,
src/conf/interface_conf.h, src/conf/network_conf.c,
src/conf/network_conf.h, src/lxc/lxc_driver.c,
src/network/bridge_driver.c, src/opennebula/one_driver.c,
src/openvz/openvz_driver.c, src/qemu/qemu_driver.c,
src/test/test_driver.c, src/uml/uml_driver.c: Update for
renamed APIs.
2009-10-20 14:51:03 +00:00
|
|
|
if (virDomainObjIsActive(vm)) {
|
2009-05-08 09:58:46 +00:00
|
|
|
qemudReportError(conn, NULL, NULL, VIR_ERR_OPERATION_INVALID,
|
Mark many more strings for translation.
* Makefile.maint (err_func_re): Add to the list and make it readable.
* po/POTFILES.in: Add src/util.c and src/xm_internal.c, and sort.
* src/storage_backend.c: Fix comment.
* src/util.c (virFileLinkPointsTo): Mark a string.
* qemud/remote.c (remoteDispatchClientRequest): Mark strings.
(remoteDispatchOpen, CHECK_CONN, remoteDispatchGetType): Likewise.
(remoteDispatchDomainGetSchedulerType): Likewise.
(remoteDispatchDomainGetSchedulerParameters): Likewise.
(remoteDispatchDomainSetSchedulerParameters): Likewise.
(remoteDispatchDomainBlockStats): Likewise.
(remoteDispatchDomainInterfaceStats): Likewise.
(remoteDispatchDomainAttachDevice, remoteDispatchDomainCreate):
(remoteDispatchDomainDestroy, remoteDispatchDomainDetachDevice):
(remoteDispatchDomainDumpXml, remoteDispatchDomainGetAutostart):
(remoteDispatchDomainGetInfo, remoteDispatchDomainGetMaxMemory):
(remoteDispatchDomainGetMaxVcpus, remoteDispatchDomainGetOsType):
(remoteDispatchDomainGetVcpus): Likewise.
(remoteDispatchDomainMigratePerform): Likewise.
(remoteDispatchListDefinedDomains, remoteDispatchDomainPinVcpu):
(remoteDispatchDomainReboot, remoteDispatchDomainResume):
(remoteDispatchDomainSave, remoteDispatchDomainCoreDump):
(remoteDispatchDomainSetAutostart): Likewise.
(remoteDispatchDomainSetMaxMemory, remoteDispatchDomainSetMemory):
(remoteDispatchDomainSetVcpus, remoteDispatchDomainShutdown):
(remoteDispatchDomainSuspend, remoteDispatchDomainUndefine):
(remoteDispatchListDefinedNetworks, remoteDispatchListDomains):
(remoteDispatchListNetworks, remoteDispatchNetworkCreate):
(remoteDispatchNetworkDestroy, remoteDispatchNetworkDumpXml):
(remoteDispatchNetworkGetAutostart, remoteDispatchNetworkGetBridgeName):
(remoteDispatchNetworkSetAutostart, remoteDispatchNetworkUndefine):
(addrToString, remoteDispatchAuthSaslInit, remoteDispatchAuthSaslStart):
(remoteDispatchAuthSaslStep, remoteDispatchListDefinedStoragePools):
(remoteDispatchListStoragePools, remoteDispatchStoragePoolCreate):
(remoteDispatchStoragePoolBuild, remoteDispatchStoragePoolDestroy):
(remoteDispatchStoragePoolDelete, remoteDispatchStoragePoolRefresh):
(remoteDispatchStoragePoolGetInfo, remoteDispatchStoragePoolDumpXml):
(remoteDispatchStoragePoolGetAutostart): Likewise.
(remoteDispatchStoragePoolSetAutostart):
(remoteDispatchStoragePoolListVolumes):
(remoteDispatchStoragePoolNumOfVolumes):
(remoteDispatchStoragePoolUndefine, remoteDispatchStorageVolCreateXml):
(remoteDispatchStorageVolDelete, remoteDispatchStorageVolGetInfo):
(remoteDispatchStorageVolDumpXml, remoteDispatchStorageVolGetPath):
(remoteDispatchStorageVolLookupByName): Likewise.
* src/qemu_driver.c (qemudOpenMonitor, qemudStartVMDaemon):
(dhcpStartDhcpDaemon, qemudStartNetworkDaemon):
(qemudDomainSuspend, qemudDomainResume, qemudDomainShutdown):
(qemudDomainGetOSType, qemudDomainSetMaxMemory):
(qemudDomainSetMemory, qemudDomainGetInfo, qemudDomainSave):
(qemudDomainRestore, qemudDomainDumpXML, qemudDomainStart):
(qemudDomainUndefine, qemudDomainChangeCDROM):
(qemudDomainAttachDevice, qemudDomainGetAutostart):
(qemudDomainSetAutostart, qemudDomainInterfaceStats):
(qemudNetworkLookupByUUID, qemudNetworkLookupByName):
(qemudNetworkUndefine, qemudNetworkStart, qemudNetworkDestroy):
(qemudNetworkDumpXML, qemudNetworkGetAutostart):
(qemudNetworkSetAutostart): Likewise.
* src/virsh.c (cmdVcpupin, cmdAttachDevice, cmdDetachDevice): Likewise.
* src/xm_internal.c (xenXMConfigCacheRefresh, xenXMDomainPinVcpu): Likewise.
2008-03-27 13:43:01 +00:00
|
|
|
"%s", _("VM is already active"));
|
2007-06-26 20:41:25 +00:00
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
|
2009-04-03 14:10:17 +00:00
|
|
|
/* If you are using a SecurityDriver with dynamic labelling,
|
|
|
|
then generate a security label for isolation */
|
2010-01-13 14:03:04 +00:00
|
|
|
if (driver->securityDriver &&
|
2009-04-03 14:10:17 +00:00
|
|
|
driver->securityDriver->domainGenSecurityLabel &&
|
|
|
|
driver->securityDriver->domainGenSecurityLabel(conn, vm) < 0)
|
|
|
|
return -1;
|
|
|
|
|
2010-01-13 16:28:31 +00:00
|
|
|
if (driver->securityDriver &&
|
|
|
|
driver->securityDriver->domainSetSecurityAllLabel &&
|
|
|
|
driver->securityDriver->domainSetSecurityAllLabel(conn, vm) < 0)
|
|
|
|
goto cleanup;
|
|
|
|
|
2009-07-09 13:10:59 +00:00
|
|
|
/* Ensure no historical cgroup for this VM is lieing around bogus settings */
|
2009-12-14 09:30:49 +00:00
|
|
|
qemuRemoveCgroup(conn, driver, vm, 1);
|
2009-07-09 13:10:59 +00:00
|
|
|
|
2009-05-07 07:27:49 +00:00
|
|
|
if ((vm->def->ngraphics == 1) &&
|
|
|
|
vm->def->graphics[0]->type == VIR_DOMAIN_GRAPHICS_TYPE_VNC &&
|
|
|
|
vm->def->graphics[0]->data.vnc.autoport) {
|
2007-06-26 22:13:21 +00:00
|
|
|
int port = qemudNextFreeVNCPort(driver);
|
2007-06-26 20:41:25 +00:00
|
|
|
if (port < 0) {
|
2007-07-12 15:09:01 +00:00
|
|
|
qemudReportError(conn, NULL, NULL, VIR_ERR_INTERNAL_ERROR,
|
Mark many more strings for translation.
* Makefile.maint (err_func_re): Add to the list and make it readable.
* po/POTFILES.in: Add src/util.c and src/xm_internal.c, and sort.
* src/storage_backend.c: Fix comment.
* src/util.c (virFileLinkPointsTo): Mark a string.
* qemud/remote.c (remoteDispatchClientRequest): Mark strings.
(remoteDispatchOpen, CHECK_CONN, remoteDispatchGetType): Likewise.
(remoteDispatchDomainGetSchedulerType): Likewise.
(remoteDispatchDomainGetSchedulerParameters): Likewise.
(remoteDispatchDomainSetSchedulerParameters): Likewise.
(remoteDispatchDomainBlockStats): Likewise.
(remoteDispatchDomainInterfaceStats): Likewise.
(remoteDispatchDomainAttachDevice, remoteDispatchDomainCreate):
(remoteDispatchDomainDestroy, remoteDispatchDomainDetachDevice):
(remoteDispatchDomainDumpXml, remoteDispatchDomainGetAutostart):
(remoteDispatchDomainGetInfo, remoteDispatchDomainGetMaxMemory):
(remoteDispatchDomainGetMaxVcpus, remoteDispatchDomainGetOsType):
(remoteDispatchDomainGetVcpus): Likewise.
(remoteDispatchDomainMigratePerform): Likewise.
(remoteDispatchListDefinedDomains, remoteDispatchDomainPinVcpu):
(remoteDispatchDomainReboot, remoteDispatchDomainResume):
(remoteDispatchDomainSave, remoteDispatchDomainCoreDump):
(remoteDispatchDomainSetAutostart): Likewise.
(remoteDispatchDomainSetMaxMemory, remoteDispatchDomainSetMemory):
(remoteDispatchDomainSetVcpus, remoteDispatchDomainShutdown):
(remoteDispatchDomainSuspend, remoteDispatchDomainUndefine):
(remoteDispatchListDefinedNetworks, remoteDispatchListDomains):
(remoteDispatchListNetworks, remoteDispatchNetworkCreate):
(remoteDispatchNetworkDestroy, remoteDispatchNetworkDumpXml):
(remoteDispatchNetworkGetAutostart, remoteDispatchNetworkGetBridgeName):
(remoteDispatchNetworkSetAutostart, remoteDispatchNetworkUndefine):
(addrToString, remoteDispatchAuthSaslInit, remoteDispatchAuthSaslStart):
(remoteDispatchAuthSaslStep, remoteDispatchListDefinedStoragePools):
(remoteDispatchListStoragePools, remoteDispatchStoragePoolCreate):
(remoteDispatchStoragePoolBuild, remoteDispatchStoragePoolDestroy):
(remoteDispatchStoragePoolDelete, remoteDispatchStoragePoolRefresh):
(remoteDispatchStoragePoolGetInfo, remoteDispatchStoragePoolDumpXml):
(remoteDispatchStoragePoolGetAutostart): Likewise.
(remoteDispatchStoragePoolSetAutostart):
(remoteDispatchStoragePoolListVolumes):
(remoteDispatchStoragePoolNumOfVolumes):
(remoteDispatchStoragePoolUndefine, remoteDispatchStorageVolCreateXml):
(remoteDispatchStorageVolDelete, remoteDispatchStorageVolGetInfo):
(remoteDispatchStorageVolDumpXml, remoteDispatchStorageVolGetPath):
(remoteDispatchStorageVolLookupByName): Likewise.
* src/qemu_driver.c (qemudOpenMonitor, qemudStartVMDaemon):
(dhcpStartDhcpDaemon, qemudStartNetworkDaemon):
(qemudDomainSuspend, qemudDomainResume, qemudDomainShutdown):
(qemudDomainGetOSType, qemudDomainSetMaxMemory):
(qemudDomainSetMemory, qemudDomainGetInfo, qemudDomainSave):
(qemudDomainRestore, qemudDomainDumpXML, qemudDomainStart):
(qemudDomainUndefine, qemudDomainChangeCDROM):
(qemudDomainAttachDevice, qemudDomainGetAutostart):
(qemudDomainSetAutostart, qemudDomainInterfaceStats):
(qemudNetworkLookupByUUID, qemudNetworkLookupByName):
(qemudNetworkUndefine, qemudNetworkStart, qemudNetworkDestroy):
(qemudNetworkDumpXML, qemudNetworkGetAutostart):
(qemudNetworkSetAutostart): Likewise.
* src/virsh.c (cmdVcpupin, cmdAttachDevice, cmdDetachDevice): Likewise.
* src/xm_internal.c (xenXMConfigCacheRefresh, xenXMDomainPinVcpu): Likewise.
2008-03-27 13:43:01 +00:00
|
|
|
"%s", _("Unable to find an unused VNC port"));
|
2009-04-03 14:10:17 +00:00
|
|
|
goto cleanup;
|
2007-06-26 20:41:25 +00:00
|
|
|
}
|
2009-05-07 07:27:49 +00:00
|
|
|
vm->def->graphics[0]->data.vnc.port = port;
|
2008-07-11 19:34:11 +00:00
|
|
|
}
|
2007-06-26 20:41:25 +00:00
|
|
|
|
2010-01-20 23:52:13 +00:00
|
|
|
if (virFileMakePath(driver->logDir) != 0) {
|
2009-01-20 17:13:33 +00:00
|
|
|
virReportSystemError(conn, errno,
|
|
|
|
_("cannot create log directory %s"),
|
|
|
|
driver->logDir);
|
2009-04-03 14:10:17 +00:00
|
|
|
goto cleanup;
|
2007-06-26 20:41:25 +00:00
|
|
|
}
|
|
|
|
|
2009-06-12 13:20:13 +00:00
|
|
|
if ((logfile = qemudLogFD(conn, driver, vm->def->name)) < 0)
|
2009-04-03 14:10:17 +00:00
|
|
|
goto cleanup;
|
2007-06-26 20:41:25 +00:00
|
|
|
|
2008-09-05 11:52:12 +00:00
|
|
|
emulator = vm->def->emulator;
|
|
|
|
|
2008-05-16 16:51:30 +00:00
|
|
|
/* Make sure the binary we are about to try exec'ing exists.
|
|
|
|
* Technically we could catch the exec() failure, but that's
|
|
|
|
* in a sub-process so its hard to feed back a useful error
|
|
|
|
*/
|
2008-09-05 11:52:12 +00:00
|
|
|
if (stat(emulator, &sb) < 0) {
|
2009-01-20 17:13:33 +00:00
|
|
|
virReportSystemError(conn, errno,
|
|
|
|
_("Cannot find QEMU binary %s"),
|
|
|
|
emulator);
|
2009-04-03 14:10:17 +00:00
|
|
|
goto cleanup;
|
2008-05-16 16:51:30 +00:00
|
|
|
}
|
|
|
|
|
2008-09-05 11:52:12 +00:00
|
|
|
if (qemudExtractVersionInfo(emulator,
|
2008-07-11 19:34:11 +00:00
|
|
|
NULL,
|
2009-05-11 15:14:24 +00:00
|
|
|
&qemuCmdFlags) < 0)
|
2009-04-03 14:10:17 +00:00
|
|
|
goto cleanup;
|
2008-05-16 16:51:30 +00:00
|
|
|
|
2009-07-09 13:10:59 +00:00
|
|
|
if (qemuSetupCgroup(conn, driver, vm) < 0)
|
|
|
|
goto cleanup;
|
|
|
|
|
2009-08-17 14:05:23 +00:00
|
|
|
if (qemuPrepareHostDevices(conn, driver, vm->def) < 0)
|
2009-04-03 14:10:17 +00:00
|
|
|
goto cleanup;
|
2009-03-03 08:59:45 +00:00
|
|
|
|
2009-11-26 17:57:00 +00:00
|
|
|
if (VIR_ALLOC(priv->monConfig) < 0) {
|
2009-07-09 17:06:38 +00:00
|
|
|
virReportOOMError(conn);
|
|
|
|
goto cleanup;
|
|
|
|
}
|
|
|
|
|
2009-11-26 17:57:00 +00:00
|
|
|
if (qemuPrepareMonitorChr(conn, driver, priv->monConfig, vm->def->name) < 0)
|
2009-07-09 17:33:40 +00:00
|
|
|
goto cleanup;
|
2009-07-09 17:06:38 +00:00
|
|
|
|
2009-11-03 18:59:18 +00:00
|
|
|
#if HAVE_YAJL
|
|
|
|
if (qemuCmdFlags & QEMUD_CMD_FLAG_MONITOR_JSON)
|
|
|
|
priv->monJSON = 1;
|
2009-12-09 18:28:30 +00:00
|
|
|
else
|
2009-11-03 18:59:18 +00:00
|
|
|
#endif
|
2009-12-09 18:28:30 +00:00
|
|
|
priv->monJSON = 0;
|
2009-11-03 18:59:18 +00:00
|
|
|
|
2009-04-21 19:14:50 +00:00
|
|
|
if ((ret = virFileDeletePid(driver->stateDir, vm->def->name)) != 0) {
|
|
|
|
virReportSystemError(conn, ret,
|
|
|
|
_("Cannot remove stale PID file for %s"),
|
|
|
|
vm->def->name);
|
|
|
|
goto cleanup;
|
|
|
|
}
|
|
|
|
|
2009-05-11 13:50:38 +00:00
|
|
|
if (!(pidfile = virFilePid(driver->stateDir, vm->def->name))) {
|
|
|
|
virReportSystemError(conn, errno,
|
|
|
|
"%s", _("Failed to build pidfile path."));
|
|
|
|
goto cleanup;
|
|
|
|
}
|
2009-04-21 19:14:50 +00:00
|
|
|
|
2010-01-27 17:03:54 +00:00
|
|
|
if (qemuCmdFlags & QEMUD_CMD_FLAG_DEVICE) {
|
|
|
|
if (priv->pciaddrs) {
|
|
|
|
qemuDomainPCIAddressSetFree(priv->pciaddrs);
|
|
|
|
priv->pciaddrs = NULL;
|
|
|
|
}
|
|
|
|
if (!(priv->pciaddrs = qemuDomainPCIAddressSetCreate(vm->def)))
|
|
|
|
goto cleanup;
|
|
|
|
|
|
|
|
if (qemuAssignDevicePCISlots(vm->def, priv->pciaddrs) < 0)
|
|
|
|
goto cleanup;
|
|
|
|
}
|
|
|
|
|
2008-11-04 22:15:30 +00:00
|
|
|
vm->def->id = driver->nextvmid++;
|
2009-11-26 17:57:00 +00:00
|
|
|
if (qemudBuildCommandLine(conn, driver, vm->def, priv->monConfig,
|
2009-11-03 18:59:18 +00:00
|
|
|
priv->monJSON, qemuCmdFlags, &argv, &progenv,
|
2009-04-03 14:10:17 +00:00
|
|
|
&tapfds, &ntapfds, migrateFrom) < 0)
|
|
|
|
goto cleanup;
|
2007-06-26 20:41:25 +00:00
|
|
|
|
2008-10-10 16:52:20 +00:00
|
|
|
tmp = progenv;
|
|
|
|
while (*tmp) {
|
2009-06-12 11:38:50 +00:00
|
|
|
if (safewrite(logfile, *tmp, strlen(*tmp)) < 0)
|
2010-01-19 13:17:20 +00:00
|
|
|
VIR_WARN(_("Unable to write envv to logfile: %s"),
|
2009-02-05 16:27:28 +00:00
|
|
|
virStrerror(errno, ebuf, sizeof ebuf));
|
2009-06-12 11:38:50 +00:00
|
|
|
if (safewrite(logfile, " ", 1) < 0)
|
2010-01-19 13:17:20 +00:00
|
|
|
VIR_WARN(_("Unable to write envv to logfile: %s"),
|
2009-02-05 16:27:28 +00:00
|
|
|
virStrerror(errno, ebuf, sizeof ebuf));
|
2008-10-10 16:52:20 +00:00
|
|
|
tmp++;
|
|
|
|
}
|
2007-06-26 20:41:25 +00:00
|
|
|
tmp = argv;
|
|
|
|
while (*tmp) {
|
2009-06-12 11:38:50 +00:00
|
|
|
if (safewrite(logfile, *tmp, strlen(*tmp)) < 0)
|
2010-01-19 13:17:20 +00:00
|
|
|
VIR_WARN(_("Unable to write argv to logfile: %s"),
|
2009-02-05 16:27:28 +00:00
|
|
|
virStrerror(errno, ebuf, sizeof ebuf));
|
2009-06-12 11:38:50 +00:00
|
|
|
if (safewrite(logfile, " ", 1) < 0)
|
2010-01-19 13:17:20 +00:00
|
|
|
VIR_WARN(_("Unable to write argv to logfile: %s"),
|
2009-02-05 16:27:28 +00:00
|
|
|
virStrerror(errno, ebuf, sizeof ebuf));
|
2007-06-26 20:41:25 +00:00
|
|
|
tmp++;
|
|
|
|
}
|
2009-06-12 11:38:50 +00:00
|
|
|
if (safewrite(logfile, "\n", 1) < 0)
|
2010-01-19 13:17:20 +00:00
|
|
|
VIR_WARN(_("Unable to write argv to logfile: %s"),
|
2009-02-05 16:27:28 +00:00
|
|
|
virStrerror(errno, ebuf, sizeof ebuf));
|
2007-06-26 20:41:25 +00:00
|
|
|
|
2009-06-12 11:38:50 +00:00
|
|
|
if ((pos = lseek(logfile, 0, SEEK_END)) < 0)
|
2010-01-19 13:17:20 +00:00
|
|
|
VIR_WARN(_("Unable to seek to end of logfile: %s"),
|
2009-02-05 16:27:28 +00:00
|
|
|
virStrerror(errno, ebuf, sizeof ebuf));
|
2008-08-20 09:08:17 +00:00
|
|
|
|
2008-08-27 11:42:52 +00:00
|
|
|
for (i = 0 ; i < ntapfds ; i++)
|
|
|
|
FD_SET(tapfds[i], &keepfd);
|
|
|
|
|
2009-05-11 13:34:37 +00:00
|
|
|
ret = virExecDaemonize(conn, argv, progenv, &keepfd, &child,
|
2009-06-12 11:38:50 +00:00
|
|
|
stdin_fd, &logfile, &logfile,
|
2009-06-29 17:00:52 +00:00
|
|
|
VIR_EXEC_NONBLOCK | VIR_EXEC_CLEAR_CAPS,
|
2009-05-11 13:50:38 +00:00
|
|
|
qemudSecurityHook, &hookData,
|
|
|
|
pidfile);
|
|
|
|
VIR_FREE(pidfile);
|
2009-01-19 21:55:54 +00:00
|
|
|
|
|
|
|
/* wait for qemu process to to show up */
|
|
|
|
if (ret == 0) {
|
2009-05-11 13:50:38 +00:00
|
|
|
if (virFileReadPid(driver->stateDir, vm->def->name, &vm->pid)) {
|
2009-01-30 17:07:29 +00:00
|
|
|
qemudReportError(conn, NULL, NULL, VIR_ERR_INTERNAL_ERROR,
|
2009-05-11 13:34:37 +00:00
|
|
|
_("Domain %s didn't show up\n"), vm->def->name);
|
2009-01-30 17:07:29 +00:00
|
|
|
ret = -1;
|
2009-01-19 21:55:54 +00:00
|
|
|
}
|
2009-05-11 13:37:19 +00:00
|
|
|
} else if (ret == -2) {
|
|
|
|
/* The virExec process that launches the daemon failed. Pending on
|
|
|
|
* when it failed (we can't determine for sure), there may be
|
|
|
|
* extra info in the domain log (if the hook failed for example).
|
|
|
|
*
|
|
|
|
* Pretend like things succeeded, and let 'WaitForMonitor' report
|
|
|
|
* the log contents for us.
|
|
|
|
*/
|
|
|
|
vm->pid = child;
|
|
|
|
ret = 0;
|
|
|
|
}
|
2009-05-11 13:34:37 +00:00
|
|
|
|
|
|
|
vm->state = migrateFrom ? VIR_DOMAIN_PAUSED : VIR_DOMAIN_RUNNING;
|
2007-06-26 20:41:25 +00:00
|
|
|
|
2007-06-26 20:45:21 +00:00
|
|
|
for (i = 0 ; argv[i] ; i++)
|
2008-05-29 19:20:22 +00:00
|
|
|
VIR_FREE(argv[i]);
|
|
|
|
VIR_FREE(argv);
|
2007-06-26 20:45:21 +00:00
|
|
|
|
2008-10-10 16:52:20 +00:00
|
|
|
for (i = 0 ; progenv[i] ; i++)
|
|
|
|
VIR_FREE(progenv[i]);
|
|
|
|
VIR_FREE(progenv);
|
|
|
|
|
2008-07-11 19:34:11 +00:00
|
|
|
if (tapfds) {
|
|
|
|
for (i = 0 ; i < ntapfds ; i++) {
|
|
|
|
close(tapfds[i]);
|
2007-06-26 20:41:25 +00:00
|
|
|
}
|
2008-07-11 19:34:11 +00:00
|
|
|
VIR_FREE(tapfds);
|
2007-06-26 20:41:25 +00:00
|
|
|
}
|
|
|
|
|
2009-10-13 14:27:58 +00:00
|
|
|
if (ret == -1) /* The VM failed to start */
|
2009-04-03 14:10:17 +00:00
|
|
|
goto cleanup;
|
|
|
|
|
2009-10-13 14:27:58 +00:00
|
|
|
if (qemudWaitForMonitor(conn, driver, vm, pos) < 0)
|
|
|
|
goto abort;
|
|
|
|
|
2009-11-18 15:58:32 +00:00
|
|
|
if (qemuDetectVcpuPIDs(conn, driver, vm) < 0)
|
2009-10-13 14:27:58 +00:00
|
|
|
goto abort;
|
|
|
|
|
2009-11-26 13:51:42 +00:00
|
|
|
if (qemudInitCpuAffinity(conn, vm) < 0)
|
2009-10-13 14:27:58 +00:00
|
|
|
goto abort;
|
|
|
|
|
|
|
|
if (qemuInitPasswords(driver, vm) < 0)
|
|
|
|
goto abort;
|
|
|
|
|
2010-01-07 19:25:41 +00:00
|
|
|
/* If we have -device, then addresses are assigned explicitly.
|
|
|
|
* If not, then we have to detect dynamic ones here */
|
|
|
|
if (!(qemuCmdFlags & QEMUD_CMD_FLAG_DEVICE)) {
|
|
|
|
if (qemuInitPCIAddresses(driver, vm) < 0)
|
|
|
|
goto abort;
|
|
|
|
}
|
Detect PCI addresses at QEMU startup
Hotunplug of devices requires that we know their PCI address. Even
hotplug of SCSI drives, required that we know the PCI address of
the SCSI controller to attach the drive to. We can find this out
by running 'info pci' and then correlating the vendor/product IDs
with the devices we booted with.
Although this approach is somewhat fragile, it is the only viable
option with QEMU < 0.12, since there is no way for libvirto set
explicit PCI addresses when creating devices in the first place.
For QEMU > 0.12, this code will not be used.
* src/qemu/qemu_driver.c: Assign all dynamic PCI addresses on
startup of QEMU VM, matching vendor/product IDs
* src/qemu/qemu_monitor.c, src/qemu/qemu_monitor.h,
src/qemu/qemu_monitor_json.c, src/qemu/qemu_monitor_json.h,
src/qemu/qemu_monitor_text.c, src/qemu/qemu_monitor_text.h: Add
API for fetching PCI device address mapping
2009-12-09 21:59:04 +00:00
|
|
|
|
2009-11-18 15:58:32 +00:00
|
|
|
qemuDomainObjEnterMonitorWithDriver(driver, vm);
|
2009-10-13 14:27:58 +00:00
|
|
|
if (qemuMonitorSetBalloon(priv->mon, vm->def->memory) < 0) {
|
2009-11-18 15:58:32 +00:00
|
|
|
qemuDomainObjExitMonitorWithDriver(driver, vm);
|
2009-10-13 14:27:58 +00:00
|
|
|
goto abort;
|
2007-06-26 20:45:21 +00:00
|
|
|
}
|
2009-11-26 13:51:42 +00:00
|
|
|
|
|
|
|
if (migrateFrom == NULL) {
|
|
|
|
/* Allow the CPUS to start executing */
|
|
|
|
if (qemuMonitorStartCPUs(priv->mon, conn) < 0) {
|
|
|
|
if (virGetLastError() == NULL)
|
|
|
|
qemudReportError(conn, NULL, NULL, VIR_ERR_INTERNAL_ERROR,
|
|
|
|
"%s", _("resume operation failed"));
|
|
|
|
qemuDomainObjExitMonitorWithDriver(driver, vm);
|
|
|
|
goto abort;
|
|
|
|
}
|
|
|
|
}
|
2009-11-18 15:58:32 +00:00
|
|
|
qemuDomainObjExitMonitorWithDriver(driver, vm);
|
2007-06-26 20:45:21 +00:00
|
|
|
|
2009-11-26 13:51:42 +00:00
|
|
|
|
2009-11-26 17:57:00 +00:00
|
|
|
if (virDomainSaveStatus(conn, driver->caps, driver->stateDir, vm) < 0)
|
2009-10-13 14:27:58 +00:00
|
|
|
goto abort;
|
2009-09-10 09:34:14 +00:00
|
|
|
|
2009-10-13 14:27:58 +00:00
|
|
|
return 0;
|
2009-04-03 14:10:17 +00:00
|
|
|
|
|
|
|
cleanup:
|
2009-10-13 14:27:58 +00:00
|
|
|
/* We jump here if we failed to start the VM for any reason
|
|
|
|
* XXX investigate if we can kill this block and safely call
|
|
|
|
* qemudShutdownVMDaemon even though no PID is running */
|
2010-01-13 17:09:41 +00:00
|
|
|
qemuDomainReAttachHostDevices(conn, driver, vm->def);
|
|
|
|
|
2010-01-13 16:28:31 +00:00
|
|
|
if (driver->securityDriver &&
|
|
|
|
driver->securityDriver->domainRestoreSecurityAllLabel)
|
|
|
|
driver->securityDriver->domainRestoreSecurityAllLabel(conn, vm);
|
2010-01-13 15:30:24 +00:00
|
|
|
if (driver->securityDriver &&
|
|
|
|
driver->securityDriver->domainReleaseSecurityLabel)
|
|
|
|
driver->securityDriver->domainReleaseSecurityLabel(conn, vm);
|
2009-12-14 09:30:49 +00:00
|
|
|
qemuRemoveCgroup(conn, driver, vm, 0);
|
2009-05-07 07:27:49 +00:00
|
|
|
if ((vm->def->ngraphics == 1) &&
|
|
|
|
vm->def->graphics[0]->type == VIR_DOMAIN_GRAPHICS_TYPE_VNC &&
|
|
|
|
vm->def->graphics[0]->data.vnc.autoport)
|
|
|
|
vm->def->graphics[0]->data.vnc.port = -1;
|
2009-06-12 11:38:50 +00:00
|
|
|
if (logfile != -1)
|
|
|
|
close(logfile);
|
2009-04-03 14:10:17 +00:00
|
|
|
vm->def->id = -1;
|
|
|
|
return -1;
|
2009-10-13 14:27:58 +00:00
|
|
|
|
|
|
|
abort:
|
|
|
|
/* We jump here if we failed to initialize the now running VM
|
|
|
|
* killing it off and pretend we never started it */
|
|
|
|
qemudShutdownVMDaemon(conn, driver, vm);
|
|
|
|
|
|
|
|
if (logfile != -1)
|
|
|
|
close(logfile);
|
|
|
|
|
|
|
|
return -1;
|
2007-06-26 20:41:25 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
|
2009-07-09 13:10:59 +00:00
|
|
|
static void qemudShutdownVMDaemon(virConnectPtr conn,
|
2009-02-05 16:11:25 +00:00
|
|
|
struct qemud_driver *driver,
|
|
|
|
virDomainObjPtr vm) {
|
2009-04-21 19:14:50 +00:00
|
|
|
int ret;
|
2009-07-09 13:10:59 +00:00
|
|
|
int retries = 0;
|
2009-10-09 19:13:29 +00:00
|
|
|
qemuDomainObjPrivatePtr priv = vm->privateData;
|
2010-01-09 02:07:37 +00:00
|
|
|
virErrorPtr orig_err;
|
2009-04-21 19:14:50 +00:00
|
|
|
|
Rename internal APis
Rename virDomainIsActive to virDomainObjIsActive, and
virInterfaceIsActive to virInterfaceObjIsActive and finally
virNetworkIsActive to virNetworkObjIsActive.
* src/conf/domain_conf.c, src/conf/domain_conf.h,
src/conf/interface_conf.h, src/conf/network_conf.c,
src/conf/network_conf.h, src/lxc/lxc_driver.c,
src/network/bridge_driver.c, src/opennebula/one_driver.c,
src/openvz/openvz_driver.c, src/qemu/qemu_driver.c,
src/test/test_driver.c, src/uml/uml_driver.c: Update for
renamed APIs.
2009-10-20 14:51:03 +00:00
|
|
|
if (!virDomainObjIsActive(vm))
|
2007-07-24 14:24:52 +00:00
|
|
|
return;
|
2007-06-26 20:41:25 +00:00
|
|
|
|
Fully asynchronous monitor I/O processing
Change the QEMU monitor file handle watch to poll for both
read & write events, as well as EOF. All I/O to/from the
QEMU monitor FD is now done in the event callback thread.
When the QEMU driver needs to send a command, it puts the
data to be sent into a qemuMonitorMessagePtr object instance,
queues it for dispatch, and then goes to sleep on a condition
variable. The event thread sends all the data, and then waits
for the reply to arrive, putting the response / error data
back into the qemuMonitorMessagePtr and notifying the condition
variable.
There is a temporary hack in the disk passphrase callback to
avoid acquiring the domain lock. This avoids a deadlock in
the command processing, since the domain lock is still held
when running monitor commands. The next commit will remove
the locking when running commands & thus allow re-introduction
of locking the disk passphrase callback
* src/qemu/qemu_driver.c: Temporarily don't acquire lock in
disk passphrase callback. To be reverted in next commit
* src/qemu/qemu_monitor.c, src/qemu/qemu_monitor.h: Remove
raw I/O functions, and a generic qemuMonitorSend() for
invoking a command
* src/qemu/qemu_monitor_text.c, src/qemu/qemu_monitor_text.h:
Remove all low level I/O, and use the new qemuMonitorSend()
API. Provide a qemuMonitorTextIOProcess() method for detecting
command/reply/prompt boundaries in the monitor data stream
2009-10-14 17:40:51 +00:00
|
|
|
VIR_DEBUG("Shutting down VM '%s'", vm->def->name);
|
2007-06-26 20:41:25 +00:00
|
|
|
|
2010-01-09 02:07:37 +00:00
|
|
|
/* This method is routinely used in clean up paths. Disable error
|
|
|
|
* reporting so we don't squash a legit error. */
|
|
|
|
orig_err = virSaveLastError();
|
|
|
|
|
2009-11-03 22:41:23 +00:00
|
|
|
if (driver->macFilter) {
|
|
|
|
int i;
|
|
|
|
virDomainDefPtr def = vm->def;
|
|
|
|
for (i = 0 ; i < def->nnets ; i++) {
|
|
|
|
virDomainNetDefPtr net = def->nets[i];
|
|
|
|
if (net->ifname == NULL)
|
|
|
|
continue;
|
|
|
|
if ((errno = networkDisallowMacOnPort(conn, driver, net->ifname,
|
|
|
|
net->mac))) {
|
|
|
|
virReportSystemError(conn, errno,
|
|
|
|
_("failed to remove ebtables rule to allow MAC address on '%s'"),
|
|
|
|
net->ifname);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2009-01-19 21:55:54 +00:00
|
|
|
if (virKillProcess(vm->pid, 0) == 0 &&
|
|
|
|
virKillProcess(vm->pid, SIGTERM) < 0)
|
2009-02-05 16:11:25 +00:00
|
|
|
virReportSystemError(conn, errno,
|
|
|
|
_("Failed to send SIGTERM to %s (%d)"),
|
|
|
|
vm->def->name, vm->pid);
|
2007-06-26 20:41:25 +00:00
|
|
|
|
2009-11-26 13:29:29 +00:00
|
|
|
if (priv->mon &&
|
|
|
|
qemuMonitorClose(priv->mon) == 0) {
|
|
|
|
virDomainObjUnref(vm);
|
2009-10-09 19:13:29 +00:00
|
|
|
priv->mon = NULL;
|
2009-01-30 17:07:29 +00:00
|
|
|
}
|
2007-06-26 20:41:25 +00:00
|
|
|
|
2009-11-26 17:57:00 +00:00
|
|
|
if (priv->monConfig) {
|
|
|
|
if (priv->monConfig->type == VIR_DOMAIN_CHR_TYPE_UNIX)
|
|
|
|
unlink(priv->monConfig->data.nix.path);
|
|
|
|
virDomainChrDefFree(priv->monConfig);
|
|
|
|
priv->monConfig = NULL;
|
2009-08-26 14:38:32 +00:00
|
|
|
}
|
|
|
|
|
2009-01-19 21:55:54 +00:00
|
|
|
/* shut it off for sure */
|
|
|
|
virKillProcess(vm->pid, SIGKILL);
|
2007-06-26 20:41:25 +00:00
|
|
|
|
2009-03-03 12:03:44 +00:00
|
|
|
/* Reset Security Labels */
|
2010-01-13 14:03:04 +00:00
|
|
|
if (driver->securityDriver &&
|
2010-01-11 11:04:40 +00:00
|
|
|
driver->securityDriver->domainRestoreSecurityAllLabel)
|
|
|
|
driver->securityDriver->domainRestoreSecurityAllLabel(conn, vm);
|
|
|
|
if (driver->securityDriver &&
|
|
|
|
driver->securityDriver->domainReleaseSecurityLabel)
|
|
|
|
driver->securityDriver->domainReleaseSecurityLabel(conn, vm);
|
2009-03-03 12:03:44 +00:00
|
|
|
|
2009-03-03 16:53:13 +00:00
|
|
|
/* Clear out dynamically assigned labels */
|
|
|
|
if (vm->def->seclabel.type == VIR_DOMAIN_SECLABEL_DYNAMIC) {
|
|
|
|
VIR_FREE(vm->def->seclabel.model);
|
|
|
|
VIR_FREE(vm->def->seclabel.label);
|
|
|
|
VIR_FREE(vm->def->seclabel.imagelabel);
|
|
|
|
}
|
|
|
|
|
2010-01-06 10:35:30 +00:00
|
|
|
virDomainDefClearPCIAddresses(vm->def);
|
2010-01-08 15:53:53 +00:00
|
|
|
virDomainDefClearDeviceAliases(vm->def);
|
2010-01-27 17:03:54 +00:00
|
|
|
qemuDomainPCIAddressSetFree(priv->pciaddrs);
|
|
|
|
priv->pciaddrs = NULL;
|
2010-01-06 10:35:30 +00:00
|
|
|
|
2009-08-17 14:05:23 +00:00
|
|
|
qemuDomainReAttachHostDevices(conn, driver, vm->def);
|
2009-08-14 07:31:11 +00:00
|
|
|
|
2009-07-09 13:10:59 +00:00
|
|
|
retry:
|
2009-12-14 09:30:49 +00:00
|
|
|
if ((ret = qemuRemoveCgroup(conn, driver, vm, 0)) < 0) {
|
2009-07-09 13:10:59 +00:00
|
|
|
if (ret == -EBUSY && (retries++ < 5)) {
|
|
|
|
usleep(200*1000);
|
|
|
|
goto retry;
|
|
|
|
}
|
|
|
|
VIR_WARN("Failed to remove cgroup for %s",
|
|
|
|
vm->def->name);
|
|
|
|
}
|
|
|
|
|
2009-08-22 21:56:33 +00:00
|
|
|
qemudRemoveDomainStatus(conn, driver, vm);
|
2009-04-21 19:14:50 +00:00
|
|
|
|
2007-06-26 20:41:25 +00:00
|
|
|
vm->pid = -1;
|
2008-07-11 19:34:11 +00:00
|
|
|
vm->def->id = -1;
|
2007-06-26 22:39:53 +00:00
|
|
|
vm->state = VIR_DOMAIN_SHUTOFF;
|
2009-11-26 17:57:00 +00:00
|
|
|
VIR_FREE(priv->vcpupids);
|
|
|
|
priv->nvcpupids = 0;
|
2007-06-26 20:41:25 +00:00
|
|
|
|
|
|
|
if (vm->newDef) {
|
2008-07-11 19:34:11 +00:00
|
|
|
virDomainDefFree(vm->def);
|
2007-06-26 20:41:25 +00:00
|
|
|
vm->def = vm->newDef;
|
2008-07-11 19:34:11 +00:00
|
|
|
vm->def->id = -1;
|
2007-06-26 20:41:25 +00:00
|
|
|
vm->newDef = NULL;
|
|
|
|
}
|
2010-01-09 02:07:37 +00:00
|
|
|
|
|
|
|
if (orig_err) {
|
|
|
|
virSetError(orig_err);
|
|
|
|
virFreeError(orig_err);
|
|
|
|
}
|
2007-06-26 20:41:25 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
|
2007-06-29 13:23:13 +00:00
|
|
|
static virDrvOpenStatus qemudOpen(virConnectPtr conn,
|
2007-12-05 18:28:05 +00:00
|
|
|
virConnectAuthPtr auth ATTRIBUTE_UNUSED,
|
2007-09-21 19:32:02 +00:00
|
|
|
int flags ATTRIBUTE_UNUSED) {
|
2008-11-17 11:44:51 +00:00
|
|
|
if (conn->uri == NULL) {
|
2009-06-12 12:06:15 +00:00
|
|
|
if (qemu_driver == NULL)
|
|
|
|
return VIR_DRV_OPEN_DECLINED;
|
|
|
|
|
2009-06-12 13:20:13 +00:00
|
|
|
conn->uri = xmlParseURI(qemu_driver->privileged ?
|
2009-06-12 12:06:15 +00:00
|
|
|
"qemu:///system" :
|
|
|
|
"qemu:///session");
|
2008-11-17 11:44:51 +00:00
|
|
|
if (!conn->uri) {
|
2009-01-29 12:10:32 +00:00
|
|
|
virReportOOMError(conn);
|
2008-11-17 11:44:51 +00:00
|
|
|
return VIR_DRV_OPEN_ERROR;
|
|
|
|
}
|
2009-06-12 12:06:15 +00:00
|
|
|
} else {
|
|
|
|
/* If URI isn't 'qemu' its definitely not for us */
|
|
|
|
if (conn->uri->scheme == NULL ||
|
|
|
|
STRNEQ(conn->uri->scheme, "qemu"))
|
|
|
|
return VIR_DRV_OPEN_DECLINED;
|
|
|
|
|
|
|
|
/* Allow remote driver to deal with URIs with hostname server */
|
|
|
|
if (conn->uri->server != NULL)
|
|
|
|
return VIR_DRV_OPEN_DECLINED;
|
|
|
|
|
2009-07-08 21:59:22 +00:00
|
|
|
if (qemu_driver == NULL) {
|
|
|
|
qemudReportError(conn, NULL, NULL, VIR_ERR_INTERNAL_ERROR, "%s",
|
|
|
|
_("qemu state driver is not active"));
|
|
|
|
return VIR_DRV_OPEN_ERROR;
|
|
|
|
}
|
|
|
|
|
2009-12-10 16:39:07 +00:00
|
|
|
if (conn->uri->path == NULL) {
|
|
|
|
qemudReportError(conn, NULL, NULL, VIR_ERR_INTERNAL_ERROR,
|
|
|
|
_("no QEMU URI path given, try %s"),
|
|
|
|
qemu_driver->privileged
|
|
|
|
? "qemu:///system"
|
|
|
|
: "qemu:///session");
|
|
|
|
return VIR_DRV_OPEN_ERROR;
|
|
|
|
}
|
|
|
|
|
2009-06-12 13:20:13 +00:00
|
|
|
if (qemu_driver->privileged) {
|
2009-06-12 12:06:15 +00:00
|
|
|
if (STRNEQ (conn->uri->path, "/system") &&
|
|
|
|
STRNEQ (conn->uri->path, "/session")) {
|
|
|
|
qemudReportError(conn, NULL, NULL, VIR_ERR_INTERNAL_ERROR,
|
|
|
|
_("unexpected QEMU URI path '%s', try qemu:///system"),
|
|
|
|
conn->uri->path);
|
|
|
|
return VIR_DRV_OPEN_ERROR;
|
|
|
|
}
|
|
|
|
} else {
|
|
|
|
if (STRNEQ (conn->uri->path, "/session")) {
|
|
|
|
qemudReportError(conn, NULL, NULL, VIR_ERR_INTERNAL_ERROR,
|
|
|
|
_("unexpected QEMU URI path '%s', try qemu:///session"),
|
|
|
|
conn->uri->path);
|
|
|
|
return VIR_DRV_OPEN_ERROR;
|
|
|
|
}
|
|
|
|
}
|
2007-06-26 22:39:53 +00:00
|
|
|
}
|
|
|
|
conn->privateData = qemu_driver;
|
|
|
|
|
|
|
|
return VIR_DRV_OPEN_SUCCESS;
|
|
|
|
}
|
|
|
|
|
|
|
|
static int qemudClose(virConnectPtr conn) {
|
2008-12-04 21:04:30 +00:00
|
|
|
struct qemud_driver *driver = conn->privateData;
|
2008-11-21 10:17:22 +00:00
|
|
|
|
|
|
|
/* Get rid of callbacks registered for this conn */
|
2009-05-19 11:06:25 +00:00
|
|
|
qemuDriverLock(driver);
|
2008-11-21 10:17:22 +00:00
|
|
|
virDomainEventCallbackListRemoveConn(conn, driver->domainEventCallbacks);
|
2009-05-19 11:06:25 +00:00
|
|
|
qemuDriverUnlock(driver);
|
2007-06-26 22:39:53 +00:00
|
|
|
|
|
|
|
conn->privateData = NULL;
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2008-11-14 08:42:47 +00:00
|
|
|
/* Which features are supported by this driver? */
|
|
|
|
static int
|
|
|
|
qemudSupportsFeature (virConnectPtr conn ATTRIBUTE_UNUSED, int feature)
|
|
|
|
{
|
|
|
|
switch (feature) {
|
2009-09-17 17:10:04 +00:00
|
|
|
case VIR_DRV_FEATURE_MIGRATION_V2:
|
|
|
|
case VIR_DRV_FEATURE_MIGRATION_P2P:
|
|
|
|
return 1;
|
|
|
|
default:
|
|
|
|
return 0;
|
2008-11-14 08:42:47 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2007-06-26 22:39:53 +00:00
|
|
|
static const char *qemudGetType(virConnectPtr conn ATTRIBUTE_UNUSED) {
|
2007-07-04 03:59:13 +00:00
|
|
|
return "QEMU";
|
2007-06-26 22:39:53 +00:00
|
|
|
}
|
|
|
|
|
2008-09-17 14:07:49 +00:00
|
|
|
|
Implmentation of new APIs to checking state/persistence of objects
This implements the virConnectIsSecure, virConnectIsEncrypted,
virDomainIsPersistent, virDomainIsActive, virNetworkIsActive,
virNetworkIsPersistent, virStoragePoolIsActive,
virStoragePoolIsPersistent, virInterfaceIsActive APIs in
(nearly) all drivers. Exceptions are:
phyp: missing domainIsActive/Persistent
esx: missing domainIsPersistent
opennebula: missing domainIsActive/Persistent
* src/remote/remote_protocol.x: Define remote wire ABI for newly
added APIs.
* daemon/remote_dispatch*.h: Re-generated from remote_protocol.x
* src/esx/esx_driver.c, src/lxc/lxc_driver.c, src/network/bridge_driver.c,
src/opennebula/one_driver.c, src/openvz/openvz_conf.c,
src/openvz/openvz_driver.c, src/phyp/phyp_driver.c,
src/remote/remote_driver.c, src/storage/storage_driver.c,
src/test/test_driver.c, src/uml/uml_driver.c, src/vbox/vbox_tmpl.c,
src/xen/xen_driver.c, src/xen/xen_driver.h, src/xen/xen_inotify.c,
src/xen/xen_inotify.h: Implement all the new APIs where possible
2009-10-20 14:12:03 +00:00
|
|
|
static int qemuIsSecure(virConnectPtr conn ATTRIBUTE_UNUSED)
|
|
|
|
{
|
|
|
|
/* Trivially secure, since always inside the daemon */
|
|
|
|
return 1;
|
|
|
|
}
|
|
|
|
|
|
|
|
static int qemuIsEncrypted(virConnectPtr conn ATTRIBUTE_UNUSED)
|
|
|
|
{
|
|
|
|
/* Not encrypted, but remote driver takes care of that */
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
2008-09-17 14:07:49 +00:00
|
|
|
static int kvmGetMaxVCPUs(void) {
|
|
|
|
int maxvcpus = 1;
|
|
|
|
|
|
|
|
int r, fd;
|
2008-09-18 08:54:23 +00:00
|
|
|
|
2008-09-17 14:07:49 +00:00
|
|
|
fd = open(KVM_DEVICE, O_RDONLY);
|
|
|
|
if (fd < 0) {
|
2009-02-05 16:11:25 +00:00
|
|
|
virReportSystemError(NULL, errno, _("Unable to open %s"), KVM_DEVICE);
|
|
|
|
return -1;
|
2008-09-17 14:07:49 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
r = ioctl(fd, KVM_CHECK_EXTENSION, KVM_CAP_NR_VCPUS);
|
|
|
|
if (r > 0)
|
|
|
|
maxvcpus = r;
|
|
|
|
|
|
|
|
close(fd);
|
|
|
|
return maxvcpus;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
2008-05-07 16:16:44 +00:00
|
|
|
static int qemudGetMaxVCPUs(virConnectPtr conn, const char *type) {
|
2007-06-26 22:39:53 +00:00
|
|
|
if (!type)
|
|
|
|
return 16;
|
|
|
|
|
2008-05-07 16:16:44 +00:00
|
|
|
if (STRCASEEQ(type, "qemu"))
|
2007-06-26 22:39:53 +00:00
|
|
|
return 16;
|
|
|
|
|
2008-05-07 16:16:44 +00:00
|
|
|
if (STRCASEEQ(type, "kvm"))
|
2008-09-17 14:07:49 +00:00
|
|
|
return kvmGetMaxVCPUs();
|
2007-06-26 22:39:53 +00:00
|
|
|
|
2008-05-07 16:16:44 +00:00
|
|
|
if (STRCASEEQ(type, "kqemu"))
|
2007-06-26 22:39:53 +00:00
|
|
|
return 1;
|
2008-05-07 16:16:44 +00:00
|
|
|
|
|
|
|
qemudReportError(conn, NULL, NULL, VIR_ERR_INVALID_ARG,
|
|
|
|
_("unknown type '%s'"), type);
|
2007-06-26 22:39:53 +00:00
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
|
2007-06-26 19:49:50 +00:00
|
|
|
|
2008-02-27 04:35:08 +00:00
|
|
|
static char *qemudGetCapabilities(virConnectPtr conn) {
|
2008-12-04 21:04:30 +00:00
|
|
|
struct qemud_driver *driver = conn->privateData;
|
2009-12-18 15:24:14 +00:00
|
|
|
virCapsPtr caps = NULL;
|
2009-05-06 14:20:34 +00:00
|
|
|
char *xml = NULL;
|
2007-06-26 19:49:50 +00:00
|
|
|
|
2008-12-04 21:06:41 +00:00
|
|
|
qemuDriverLock(driver);
|
2009-10-09 19:13:29 +00:00
|
|
|
|
2010-01-18 16:24:25 +00:00
|
|
|
if ((caps = qemuCreateCapabilities(qemu_driver->caps,
|
|
|
|
qemu_driver->securityDriver)) == NULL) {
|
|
|
|
virCapabilitiesFree(caps);
|
|
|
|
goto cleanup;
|
|
|
|
}
|
2009-06-29 10:41:56 +00:00
|
|
|
|
2009-05-06 14:20:34 +00:00
|
|
|
virCapabilitiesFree(qemu_driver->caps);
|
2009-06-29 10:41:56 +00:00
|
|
|
qemu_driver->caps = caps;
|
|
|
|
|
|
|
|
if ((xml = virCapabilitiesFormatXML(driver->caps)) == NULL)
|
2009-01-29 12:10:32 +00:00
|
|
|
virReportOOMError(conn);
|
2009-06-29 10:41:56 +00:00
|
|
|
|
|
|
|
cleanup:
|
2008-12-04 21:06:41 +00:00
|
|
|
qemuDriverUnlock(driver);
|
2007-06-26 19:49:50 +00:00
|
|
|
|
2008-02-27 04:35:08 +00:00
|
|
|
return xml;
|
2007-06-26 19:49:50 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
|
2009-07-27 15:30:25 +00:00
|
|
|
static int qemudGetProcessInfo(unsigned long long *cpuTime, int *lastCpu, int pid, int tid) {
|
2007-02-14 01:40:09 +00:00
|
|
|
char proc[PATH_MAX];
|
|
|
|
FILE *pidinfo;
|
2007-04-15 19:58:44 +00:00
|
|
|
unsigned long long usertime, systime;
|
2009-07-27 15:30:25 +00:00
|
|
|
int cpu;
|
|
|
|
int ret;
|
2007-02-14 01:40:09 +00:00
|
|
|
|
2009-07-27 15:30:25 +00:00
|
|
|
if (tid)
|
|
|
|
ret = snprintf(proc, sizeof(proc), "/proc/%d/task/%d/stat", pid, tid);
|
|
|
|
else
|
|
|
|
ret = snprintf(proc, sizeof(proc), "/proc/%d/stat", pid);
|
|
|
|
if (ret >= (int)sizeof(proc)) {
|
|
|
|
errno = E2BIG;
|
2007-02-14 01:40:09 +00:00
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (!(pidinfo = fopen(proc, "r"))) {
|
2008-08-15 01:41:49 +00:00
|
|
|
/*printf("cannot read pid info");*/
|
2007-02-14 01:40:09 +00:00
|
|
|
/* VM probably shut down, so fake 0 */
|
2009-07-27 15:30:25 +00:00
|
|
|
if (cpuTime)
|
|
|
|
*cpuTime = 0;
|
|
|
|
if (lastCpu)
|
|
|
|
*lastCpu = 0;
|
2007-02-14 01:40:09 +00:00
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2009-07-27 15:30:25 +00:00
|
|
|
/* See 'man proc' for information about what all these fields are. We're
|
|
|
|
* only interested in a very few of them */
|
|
|
|
if (fscanf(pidinfo,
|
|
|
|
/* pid -> stime */
|
|
|
|
"%*d %*s %*c %*d %*d %*d %*d %*d %*u %*u %*u %*u %*u %llu %llu"
|
|
|
|
/* cutime -> endcode */
|
|
|
|
"%*d %*d %*d %*d %*d %*u %*u %*d %*u %*u %*u %*u"
|
|
|
|
/* startstack -> processor */
|
|
|
|
"%*u %*u %*u %*u %*u %*u %*u %*u %*u %*u %*d %d",
|
|
|
|
&usertime, &systime, &cpu) != 3) {
|
2009-09-07 14:47:13 +00:00
|
|
|
fclose(pidinfo);
|
2009-07-27 15:30:25 +00:00
|
|
|
VIR_WARN0("cannot parse process status data");
|
|
|
|
errno = -EINVAL;
|
2007-02-14 01:40:09 +00:00
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* We got jiffies
|
|
|
|
* We want nanoseconds
|
|
|
|
* _SC_CLK_TCK is jiffies per second
|
|
|
|
* So calulate thus....
|
|
|
|
*/
|
2009-07-27 15:30:25 +00:00
|
|
|
if (cpuTime)
|
|
|
|
*cpuTime = 1000ull * 1000ull * 1000ull * (usertime + systime) / (unsigned long long)sysconf(_SC_CLK_TCK);
|
|
|
|
if (lastCpu)
|
|
|
|
*lastCpu = cpu;
|
|
|
|
|
2007-02-14 01:40:09 +00:00
|
|
|
|
2009-07-27 15:30:25 +00:00
|
|
|
VIR_DEBUG("Got status for %d/%d user=%llu sys=%llu cpu=%d",
|
|
|
|
pid, tid, usertime, systime, cpu);
|
2007-02-14 01:40:09 +00:00
|
|
|
|
|
|
|
fclose(pidinfo);
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
2007-06-29 13:23:13 +00:00
|
|
|
static virDomainPtr qemudDomainLookupByID(virConnectPtr conn,
|
2008-07-11 19:34:11 +00:00
|
|
|
int id) {
|
2008-12-04 21:04:30 +00:00
|
|
|
struct qemud_driver *driver = conn->privateData;
|
|
|
|
virDomainObjPtr vm;
|
|
|
|
virDomainPtr dom = NULL;
|
|
|
|
|
2008-12-04 21:06:41 +00:00
|
|
|
qemuDriverLock(driver);
|
2008-12-04 21:04:30 +00:00
|
|
|
vm = virDomainFindByID(&driver->domains, id);
|
2008-12-04 21:06:41 +00:00
|
|
|
qemuDriverUnlock(driver);
|
2007-06-26 22:39:53 +00:00
|
|
|
|
|
|
|
if (!vm) {
|
2009-04-19 15:30:50 +00:00
|
|
|
qemudReportError(conn, NULL, NULL, VIR_ERR_NO_DOMAIN,
|
|
|
|
_("no domain with matching id %d"), id);
|
2008-12-04 21:04:30 +00:00
|
|
|
goto cleanup;
|
2007-06-26 22:39:53 +00:00
|
|
|
}
|
|
|
|
|
2007-06-26 23:48:46 +00:00
|
|
|
dom = virGetDomain(conn, vm->def->name, vm->def->uuid);
|
2008-07-11 19:34:11 +00:00
|
|
|
if (dom) dom->id = vm->def->id;
|
2008-12-04 21:04:30 +00:00
|
|
|
|
|
|
|
cleanup:
|
2008-12-04 21:06:41 +00:00
|
|
|
if (vm)
|
|
|
|
virDomainObjUnlock(vm);
|
2007-06-26 22:39:53 +00:00
|
|
|
return dom;
|
|
|
|
}
|
2008-12-04 21:06:41 +00:00
|
|
|
|
2007-06-29 13:23:13 +00:00
|
|
|
static virDomainPtr qemudDomainLookupByUUID(virConnectPtr conn,
|
2008-07-11 19:34:11 +00:00
|
|
|
const unsigned char *uuid) {
|
2008-12-04 21:04:30 +00:00
|
|
|
struct qemud_driver *driver = conn->privateData;
|
|
|
|
virDomainObjPtr vm;
|
|
|
|
virDomainPtr dom = NULL;
|
2007-06-26 22:39:53 +00:00
|
|
|
|
2008-12-04 21:06:41 +00:00
|
|
|
qemuDriverLock(driver);
|
2008-12-04 21:04:30 +00:00
|
|
|
vm = virDomainFindByUUID(&driver->domains, uuid);
|
2008-12-04 21:06:41 +00:00
|
|
|
qemuDriverUnlock(driver);
|
|
|
|
|
2007-06-26 22:39:53 +00:00
|
|
|
if (!vm) {
|
2009-04-19 15:30:50 +00:00
|
|
|
char uuidstr[VIR_UUID_STRING_BUFLEN];
|
|
|
|
virUUIDFormat(uuid, uuidstr);
|
|
|
|
qemudReportError(conn, NULL, NULL, VIR_ERR_NO_DOMAIN,
|
2009-05-29 14:01:55 +00:00
|
|
|
_("no domain with matching uuid '%s'"), uuidstr);
|
2008-12-04 21:04:30 +00:00
|
|
|
goto cleanup;
|
2007-06-26 22:39:53 +00:00
|
|
|
}
|
|
|
|
|
2007-06-26 23:48:46 +00:00
|
|
|
dom = virGetDomain(conn, vm->def->name, vm->def->uuid);
|
2008-07-11 19:34:11 +00:00
|
|
|
if (dom) dom->id = vm->def->id;
|
2008-12-04 21:04:30 +00:00
|
|
|
|
|
|
|
cleanup:
|
2008-12-04 21:06:41 +00:00
|
|
|
if (vm)
|
|
|
|
virDomainObjUnlock(vm);
|
2007-06-26 22:39:53 +00:00
|
|
|
return dom;
|
|
|
|
}
|
2008-12-04 21:06:41 +00:00
|
|
|
|
2007-06-29 13:23:13 +00:00
|
|
|
static virDomainPtr qemudDomainLookupByName(virConnectPtr conn,
|
2008-07-11 19:34:11 +00:00
|
|
|
const char *name) {
|
2008-12-04 21:04:30 +00:00
|
|
|
struct qemud_driver *driver = conn->privateData;
|
|
|
|
virDomainObjPtr vm;
|
|
|
|
virDomainPtr dom = NULL;
|
2007-06-26 22:39:53 +00:00
|
|
|
|
2008-12-04 21:06:41 +00:00
|
|
|
qemuDriverLock(driver);
|
2008-12-04 21:04:30 +00:00
|
|
|
vm = virDomainFindByName(&driver->domains, name);
|
2008-12-04 21:06:41 +00:00
|
|
|
qemuDriverUnlock(driver);
|
|
|
|
|
2007-06-26 22:39:53 +00:00
|
|
|
if (!vm) {
|
2009-04-19 15:30:50 +00:00
|
|
|
qemudReportError(conn, NULL, NULL, VIR_ERR_NO_DOMAIN,
|
|
|
|
_("no domain with matching name '%s'"), name);
|
2008-12-04 21:04:30 +00:00
|
|
|
goto cleanup;
|
2007-06-26 22:39:53 +00:00
|
|
|
}
|
|
|
|
|
2007-06-26 23:48:46 +00:00
|
|
|
dom = virGetDomain(conn, vm->def->name, vm->def->uuid);
|
2008-07-11 19:34:11 +00:00
|
|
|
if (dom) dom->id = vm->def->id;
|
2008-12-04 21:04:30 +00:00
|
|
|
|
|
|
|
cleanup:
|
2008-12-04 21:06:41 +00:00
|
|
|
if (vm)
|
|
|
|
virDomainObjUnlock(vm);
|
2007-06-26 22:39:53 +00:00
|
|
|
return dom;
|
|
|
|
}
|
|
|
|
|
Implmentation of new APIs to checking state/persistence of objects
This implements the virConnectIsSecure, virConnectIsEncrypted,
virDomainIsPersistent, virDomainIsActive, virNetworkIsActive,
virNetworkIsPersistent, virStoragePoolIsActive,
virStoragePoolIsPersistent, virInterfaceIsActive APIs in
(nearly) all drivers. Exceptions are:
phyp: missing domainIsActive/Persistent
esx: missing domainIsPersistent
opennebula: missing domainIsActive/Persistent
* src/remote/remote_protocol.x: Define remote wire ABI for newly
added APIs.
* daemon/remote_dispatch*.h: Re-generated from remote_protocol.x
* src/esx/esx_driver.c, src/lxc/lxc_driver.c, src/network/bridge_driver.c,
src/opennebula/one_driver.c, src/openvz/openvz_conf.c,
src/openvz/openvz_driver.c, src/phyp/phyp_driver.c,
src/remote/remote_driver.c, src/storage/storage_driver.c,
src/test/test_driver.c, src/uml/uml_driver.c, src/vbox/vbox_tmpl.c,
src/xen/xen_driver.c, src/xen/xen_driver.h, src/xen/xen_inotify.c,
src/xen/xen_inotify.h: Implement all the new APIs where possible
2009-10-20 14:12:03 +00:00
|
|
|
|
|
|
|
static int qemuDomainIsActive(virDomainPtr dom)
|
|
|
|
{
|
|
|
|
struct qemud_driver *driver = dom->conn->privateData;
|
|
|
|
virDomainObjPtr obj;
|
|
|
|
int ret = -1;
|
|
|
|
|
|
|
|
qemuDriverLock(driver);
|
|
|
|
obj = virDomainFindByUUID(&driver->domains, dom->uuid);
|
|
|
|
qemuDriverUnlock(driver);
|
|
|
|
if (!obj) {
|
|
|
|
qemudReportError(dom->conn, NULL, NULL, VIR_ERR_NO_DOMAIN, NULL);
|
|
|
|
goto cleanup;
|
|
|
|
}
|
|
|
|
ret = virDomainObjIsActive(obj);
|
|
|
|
|
|
|
|
cleanup:
|
|
|
|
if (obj)
|
|
|
|
virDomainObjUnlock(obj);
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
|
|
|
static int qemuDomainIsPersistent(virDomainPtr dom)
|
|
|
|
{
|
|
|
|
struct qemud_driver *driver = dom->conn->privateData;
|
|
|
|
virDomainObjPtr obj;
|
|
|
|
int ret = -1;
|
|
|
|
|
|
|
|
qemuDriverLock(driver);
|
|
|
|
obj = virDomainFindByUUID(&driver->domains, dom->uuid);
|
|
|
|
qemuDriverUnlock(driver);
|
|
|
|
if (!obj) {
|
|
|
|
qemudReportError(dom->conn, NULL, NULL, VIR_ERR_NO_DOMAIN, NULL);
|
|
|
|
goto cleanup;
|
|
|
|
}
|
|
|
|
ret = obj->persistent;
|
|
|
|
|
|
|
|
cleanup:
|
|
|
|
if (obj)
|
|
|
|
virDomainObjUnlock(obj);
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
2007-06-29 13:23:13 +00:00
|
|
|
static int qemudGetVersion(virConnectPtr conn, unsigned long *version) {
|
2008-12-04 21:04:30 +00:00
|
|
|
struct qemud_driver *driver = conn->privateData;
|
|
|
|
int ret = -1;
|
|
|
|
|
2008-12-04 21:06:41 +00:00
|
|
|
qemuDriverLock(driver);
|
2007-07-12 15:09:01 +00:00
|
|
|
if (qemudExtractVersion(conn, driver) < 0)
|
2008-12-04 21:04:30 +00:00
|
|
|
goto cleanup;
|
2007-02-23 17:15:18 +00:00
|
|
|
|
2007-06-26 22:39:53 +00:00
|
|
|
*version = qemu_driver->qemuVersion;
|
2008-12-04 21:04:30 +00:00
|
|
|
ret = 0;
|
|
|
|
|
|
|
|
cleanup:
|
2008-12-04 21:06:41 +00:00
|
|
|
qemuDriverUnlock(driver);
|
2008-12-04 21:04:30 +00:00
|
|
|
return ret;
|
2007-02-14 01:40:09 +00:00
|
|
|
}
|
|
|
|
|
2007-06-29 13:23:13 +00:00
|
|
|
static int qemudListDomains(virConnectPtr conn, int *ids, int nids) {
|
2008-12-04 21:04:30 +00:00
|
|
|
struct qemud_driver *driver = conn->privateData;
|
Convert virDomainObjListPtr to use a hash of domain objects
The current virDomainObjListPtr object stores domain objects in
an array. This means that to find a particular objects requires
O(n) time, and more critically acquiring O(n) mutex locks.
The new impl replaces the array with a virHashTable, keyed off
UUID. Finding a object based on UUID is now O(1) time, and only
requires a single mutex lock. Finding by name/id is unchanged
in complexity.
In changing this, all code which iterates over the array had
to be updated to use a hash table iterator function callback.
Several of the functions which were identically duplicating
across all drivers were pulled into domain_conf.c
* src/conf/domain_conf.h, src/conf/domain_conf.c: Change
virDomainObjListPtr to use virHashTable. Add a initializer
method virDomainObjListInit, and rename virDomainObjListFree
to virDomainObjListDeinit, since its not actually freeing
the container, only its contents. Also add some convenient
methods virDomainObjListGetInactiveNames,
virDomainObjListGetActiveIDs and virDomainObjListNumOfDomains
which can be used to implement the correspondingly named
public API entry points in drivers
* src/libvirt_private.syms: Export new methods from domain_conf.h
* src/lxc/lxc_driver.c, src/opennebula/one_driver.c,
src/openvz/openvz_conf.c, src/openvz/openvz_driver.c,
src/qemu/qemu_driver.c, src/test/test_driver.c,
src/uml/uml_driver.c, src/vbox/vbox_tmpl.c: Update all code
to deal with hash tables instead of arrays for domains
2009-10-09 11:33:51 +00:00
|
|
|
int n;
|
2008-10-10 14:20:37 +00:00
|
|
|
|
2008-12-04 21:06:41 +00:00
|
|
|
qemuDriverLock(driver);
|
Convert virDomainObjListPtr to use a hash of domain objects
The current virDomainObjListPtr object stores domain objects in
an array. This means that to find a particular objects requires
O(n) time, and more critically acquiring O(n) mutex locks.
The new impl replaces the array with a virHashTable, keyed off
UUID. Finding a object based on UUID is now O(1) time, and only
requires a single mutex lock. Finding by name/id is unchanged
in complexity.
In changing this, all code which iterates over the array had
to be updated to use a hash table iterator function callback.
Several of the functions which were identically duplicating
across all drivers were pulled into domain_conf.c
* src/conf/domain_conf.h, src/conf/domain_conf.c: Change
virDomainObjListPtr to use virHashTable. Add a initializer
method virDomainObjListInit, and rename virDomainObjListFree
to virDomainObjListDeinit, since its not actually freeing
the container, only its contents. Also add some convenient
methods virDomainObjListGetInactiveNames,
virDomainObjListGetActiveIDs and virDomainObjListNumOfDomains
which can be used to implement the correspondingly named
public API entry points in drivers
* src/libvirt_private.syms: Export new methods from domain_conf.h
* src/lxc/lxc_driver.c, src/opennebula/one_driver.c,
src/openvz/openvz_conf.c, src/openvz/openvz_driver.c,
src/qemu/qemu_driver.c, src/test/test_driver.c,
src/uml/uml_driver.c, src/vbox/vbox_tmpl.c: Update all code
to deal with hash tables instead of arrays for domains
2009-10-09 11:33:51 +00:00
|
|
|
n = virDomainObjListGetActiveIDs(&driver->domains, ids, nids);
|
2008-12-04 21:06:41 +00:00
|
|
|
qemuDriverUnlock(driver);
|
2008-10-10 14:20:37 +00:00
|
|
|
|
Convert virDomainObjListPtr to use a hash of domain objects
The current virDomainObjListPtr object stores domain objects in
an array. This means that to find a particular objects requires
O(n) time, and more critically acquiring O(n) mutex locks.
The new impl replaces the array with a virHashTable, keyed off
UUID. Finding a object based on UUID is now O(1) time, and only
requires a single mutex lock. Finding by name/id is unchanged
in complexity.
In changing this, all code which iterates over the array had
to be updated to use a hash table iterator function callback.
Several of the functions which were identically duplicating
across all drivers were pulled into domain_conf.c
* src/conf/domain_conf.h, src/conf/domain_conf.c: Change
virDomainObjListPtr to use virHashTable. Add a initializer
method virDomainObjListInit, and rename virDomainObjListFree
to virDomainObjListDeinit, since its not actually freeing
the container, only its contents. Also add some convenient
methods virDomainObjListGetInactiveNames,
virDomainObjListGetActiveIDs and virDomainObjListNumOfDomains
which can be used to implement the correspondingly named
public API entry points in drivers
* src/libvirt_private.syms: Export new methods from domain_conf.h
* src/lxc/lxc_driver.c, src/opennebula/one_driver.c,
src/openvz/openvz_conf.c, src/openvz/openvz_driver.c,
src/qemu/qemu_driver.c, src/test/test_driver.c,
src/uml/uml_driver.c, src/vbox/vbox_tmpl.c: Update all code
to deal with hash tables instead of arrays for domains
2009-10-09 11:33:51 +00:00
|
|
|
return n;
|
2007-02-14 01:40:09 +00:00
|
|
|
}
|
2008-12-04 21:06:41 +00:00
|
|
|
|
2007-06-29 13:23:13 +00:00
|
|
|
static int qemudNumDomains(virConnectPtr conn) {
|
2008-12-04 21:04:30 +00:00
|
|
|
struct qemud_driver *driver = conn->privateData;
|
Convert virDomainObjListPtr to use a hash of domain objects
The current virDomainObjListPtr object stores domain objects in
an array. This means that to find a particular objects requires
O(n) time, and more critically acquiring O(n) mutex locks.
The new impl replaces the array with a virHashTable, keyed off
UUID. Finding a object based on UUID is now O(1) time, and only
requires a single mutex lock. Finding by name/id is unchanged
in complexity.
In changing this, all code which iterates over the array had
to be updated to use a hash table iterator function callback.
Several of the functions which were identically duplicating
across all drivers were pulled into domain_conf.c
* src/conf/domain_conf.h, src/conf/domain_conf.c: Change
virDomainObjListPtr to use virHashTable. Add a initializer
method virDomainObjListInit, and rename virDomainObjListFree
to virDomainObjListDeinit, since its not actually freeing
the container, only its contents. Also add some convenient
methods virDomainObjListGetInactiveNames,
virDomainObjListGetActiveIDs and virDomainObjListNumOfDomains
which can be used to implement the correspondingly named
public API entry points in drivers
* src/libvirt_private.syms: Export new methods from domain_conf.h
* src/lxc/lxc_driver.c, src/opennebula/one_driver.c,
src/openvz/openvz_conf.c, src/openvz/openvz_driver.c,
src/qemu/qemu_driver.c, src/test/test_driver.c,
src/uml/uml_driver.c, src/vbox/vbox_tmpl.c: Update all code
to deal with hash tables instead of arrays for domains
2009-10-09 11:33:51 +00:00
|
|
|
int n;
|
2008-10-10 14:20:37 +00:00
|
|
|
|
2008-12-04 21:06:41 +00:00
|
|
|
qemuDriverLock(driver);
|
Convert virDomainObjListPtr to use a hash of domain objects
The current virDomainObjListPtr object stores domain objects in
an array. This means that to find a particular objects requires
O(n) time, and more critically acquiring O(n) mutex locks.
The new impl replaces the array with a virHashTable, keyed off
UUID. Finding a object based on UUID is now O(1) time, and only
requires a single mutex lock. Finding by name/id is unchanged
in complexity.
In changing this, all code which iterates over the array had
to be updated to use a hash table iterator function callback.
Several of the functions which were identically duplicating
across all drivers were pulled into domain_conf.c
* src/conf/domain_conf.h, src/conf/domain_conf.c: Change
virDomainObjListPtr to use virHashTable. Add a initializer
method virDomainObjListInit, and rename virDomainObjListFree
to virDomainObjListDeinit, since its not actually freeing
the container, only its contents. Also add some convenient
methods virDomainObjListGetInactiveNames,
virDomainObjListGetActiveIDs and virDomainObjListNumOfDomains
which can be used to implement the correspondingly named
public API entry points in drivers
* src/libvirt_private.syms: Export new methods from domain_conf.h
* src/lxc/lxc_driver.c, src/opennebula/one_driver.c,
src/openvz/openvz_conf.c, src/openvz/openvz_driver.c,
src/qemu/qemu_driver.c, src/test/test_driver.c,
src/uml/uml_driver.c, src/vbox/vbox_tmpl.c: Update all code
to deal with hash tables instead of arrays for domains
2009-10-09 11:33:51 +00:00
|
|
|
n = virDomainObjListNumOfDomains(&driver->domains, 1);
|
2008-12-04 21:06:41 +00:00
|
|
|
qemuDriverUnlock(driver);
|
2008-10-10 14:20:37 +00:00
|
|
|
|
2008-07-11 19:34:11 +00:00
|
|
|
return n;
|
2007-02-14 01:40:09 +00:00
|
|
|
}
|
2008-12-04 21:06:41 +00:00
|
|
|
|
2007-06-29 13:23:13 +00:00
|
|
|
static virDomainPtr qemudDomainCreate(virConnectPtr conn, const char *xml,
|
2009-02-18 01:37:47 +00:00
|
|
|
unsigned int flags ATTRIBUTE_UNUSED) {
|
2008-12-04 21:04:30 +00:00
|
|
|
struct qemud_driver *driver = conn->privateData;
|
2008-07-11 19:34:11 +00:00
|
|
|
virDomainDefPtr def;
|
2008-12-04 21:06:41 +00:00
|
|
|
virDomainObjPtr vm = NULL;
|
2008-12-04 21:04:30 +00:00
|
|
|
virDomainPtr dom = NULL;
|
2008-12-04 21:09:20 +00:00
|
|
|
virDomainEventPtr event = NULL;
|
2007-02-14 01:40:09 +00:00
|
|
|
|
2008-12-04 21:06:41 +00:00
|
|
|
qemuDriverLock(driver);
|
2009-01-08 13:54:20 +00:00
|
|
|
if (!(def = virDomainDefParseString(conn, driver->caps, xml,
|
|
|
|
VIR_DOMAIN_XML_INACTIVE)))
|
2008-12-04 21:04:30 +00:00
|
|
|
goto cleanup;
|
2007-02-23 08:48:02 +00:00
|
|
|
|
2009-04-03 10:55:51 +00:00
|
|
|
if (virSecurityDriverVerify(conn, def) < 0)
|
|
|
|
goto cleanup;
|
|
|
|
|
2009-11-02 18:37:38 +00:00
|
|
|
if (virDomainObjIsDuplicate(&driver->domains, def, 1) < 0)
|
|
|
|
goto cleanup;
|
2008-07-24 07:29:50 +00:00
|
|
|
|
2008-07-11 19:34:11 +00:00
|
|
|
if (!(vm = virDomainAssignDef(conn,
|
2009-10-06 11:50:58 +00:00
|
|
|
driver->caps,
|
2008-07-11 19:34:11 +00:00
|
|
|
&driver->domains,
|
2008-12-04 21:04:30 +00:00
|
|
|
def)))
|
|
|
|
goto cleanup;
|
|
|
|
|
|
|
|
def = NULL;
|
2007-02-14 01:40:09 +00:00
|
|
|
|
2009-11-03 18:26:32 +00:00
|
|
|
if (qemuDomainObjBeginJobWithDriver(driver, vm) < 0)
|
|
|
|
goto cleanup; /* XXXX free the 'vm' we created ? */
|
|
|
|
|
2009-01-29 17:27:54 +00:00
|
|
|
if (qemudStartVMDaemon(conn, driver, vm, NULL, -1) < 0) {
|
2009-12-08 14:42:43 +00:00
|
|
|
if (qemuDomainObjEndJob(vm) > 0)
|
|
|
|
virDomainRemoveInactive(&driver->domains,
|
|
|
|
vm);
|
2008-12-04 21:06:41 +00:00
|
|
|
vm = NULL;
|
2009-11-03 18:26:32 +00:00
|
|
|
goto endjob;
|
2007-02-14 01:40:09 +00:00
|
|
|
}
|
2008-12-04 21:09:20 +00:00
|
|
|
|
|
|
|
event = virDomainEventNewFromObj(vm,
|
|
|
|
VIR_DOMAIN_EVENT_STARTED,
|
|
|
|
VIR_DOMAIN_EVENT_STARTED_BOOTED);
|
2007-02-14 01:40:09 +00:00
|
|
|
|
2007-06-26 23:48:46 +00:00
|
|
|
dom = virGetDomain(conn, vm->def->name, vm->def->uuid);
|
2008-07-11 19:34:11 +00:00
|
|
|
if (dom) dom->id = vm->def->id;
|
2008-12-04 21:04:30 +00:00
|
|
|
|
2009-11-03 18:26:32 +00:00
|
|
|
endjob:
|
2009-12-08 14:42:43 +00:00
|
|
|
if (vm &&
|
|
|
|
qemuDomainObjEndJob(vm) == 0)
|
|
|
|
vm = NULL;
|
2009-11-03 18:26:32 +00:00
|
|
|
|
2008-12-04 21:04:30 +00:00
|
|
|
cleanup:
|
|
|
|
virDomainDefFree(def);
|
2008-12-04 21:06:41 +00:00
|
|
|
if (vm)
|
|
|
|
virDomainObjUnlock(vm);
|
2008-12-04 21:09:20 +00:00
|
|
|
if (event)
|
|
|
|
qemuDomainEventQueue(driver, event);
|
2008-12-04 21:06:41 +00:00
|
|
|
qemuDriverUnlock(driver);
|
2007-06-26 22:39:53 +00:00
|
|
|
return dom;
|
2007-02-14 01:40:09 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
|
2007-06-29 13:23:13 +00:00
|
|
|
static int qemudDomainSuspend(virDomainPtr dom) {
|
2008-12-04 21:04:30 +00:00
|
|
|
struct qemud_driver *driver = dom->conn->privateData;
|
|
|
|
virDomainObjPtr vm;
|
|
|
|
int ret = -1;
|
2008-12-04 21:09:20 +00:00
|
|
|
virDomainEventPtr event = NULL;
|
2008-12-04 21:04:30 +00:00
|
|
|
|
2008-12-04 21:06:41 +00:00
|
|
|
qemuDriverLock(driver);
|
2009-04-19 15:30:50 +00:00
|
|
|
vm = virDomainFindByUUID(&driver->domains, dom->uuid);
|
2008-12-04 21:06:41 +00:00
|
|
|
|
2007-02-14 01:40:09 +00:00
|
|
|
if (!vm) {
|
2009-04-19 15:30:50 +00:00
|
|
|
char uuidstr[VIR_UUID_STRING_BUFLEN];
|
|
|
|
virUUIDFormat(dom->uuid, uuidstr);
|
|
|
|
qemudReportError(dom->conn, dom, NULL, VIR_ERR_NO_DOMAIN,
|
|
|
|
_("no domain with matching uuid '%s'"), uuidstr);
|
2008-12-04 21:04:30 +00:00
|
|
|
goto cleanup;
|
2007-02-14 01:40:09 +00:00
|
|
|
}
|
2009-11-03 18:26:32 +00:00
|
|
|
if (qemuDomainObjBeginJobWithDriver(driver, vm) < 0)
|
|
|
|
goto cleanup;
|
|
|
|
|
Rename internal APis
Rename virDomainIsActive to virDomainObjIsActive, and
virInterfaceIsActive to virInterfaceObjIsActive and finally
virNetworkIsActive to virNetworkObjIsActive.
* src/conf/domain_conf.c, src/conf/domain_conf.h,
src/conf/interface_conf.h, src/conf/network_conf.c,
src/conf/network_conf.h, src/lxc/lxc_driver.c,
src/network/bridge_driver.c, src/opennebula/one_driver.c,
src/openvz/openvz_driver.c, src/qemu/qemu_driver.c,
src/test/test_driver.c, src/uml/uml_driver.c: Update for
renamed APIs.
2009-10-20 14:51:03 +00:00
|
|
|
if (!virDomainObjIsActive(vm)) {
|
2009-05-08 09:58:46 +00:00
|
|
|
qemudReportError(dom->conn, dom, NULL, VIR_ERR_OPERATION_INVALID,
|
Mark many more strings for translation.
* Makefile.maint (err_func_re): Add to the list and make it readable.
* po/POTFILES.in: Add src/util.c and src/xm_internal.c, and sort.
* src/storage_backend.c: Fix comment.
* src/util.c (virFileLinkPointsTo): Mark a string.
* qemud/remote.c (remoteDispatchClientRequest): Mark strings.
(remoteDispatchOpen, CHECK_CONN, remoteDispatchGetType): Likewise.
(remoteDispatchDomainGetSchedulerType): Likewise.
(remoteDispatchDomainGetSchedulerParameters): Likewise.
(remoteDispatchDomainSetSchedulerParameters): Likewise.
(remoteDispatchDomainBlockStats): Likewise.
(remoteDispatchDomainInterfaceStats): Likewise.
(remoteDispatchDomainAttachDevice, remoteDispatchDomainCreate):
(remoteDispatchDomainDestroy, remoteDispatchDomainDetachDevice):
(remoteDispatchDomainDumpXml, remoteDispatchDomainGetAutostart):
(remoteDispatchDomainGetInfo, remoteDispatchDomainGetMaxMemory):
(remoteDispatchDomainGetMaxVcpus, remoteDispatchDomainGetOsType):
(remoteDispatchDomainGetVcpus): Likewise.
(remoteDispatchDomainMigratePerform): Likewise.
(remoteDispatchListDefinedDomains, remoteDispatchDomainPinVcpu):
(remoteDispatchDomainReboot, remoteDispatchDomainResume):
(remoteDispatchDomainSave, remoteDispatchDomainCoreDump):
(remoteDispatchDomainSetAutostart): Likewise.
(remoteDispatchDomainSetMaxMemory, remoteDispatchDomainSetMemory):
(remoteDispatchDomainSetVcpus, remoteDispatchDomainShutdown):
(remoteDispatchDomainSuspend, remoteDispatchDomainUndefine):
(remoteDispatchListDefinedNetworks, remoteDispatchListDomains):
(remoteDispatchListNetworks, remoteDispatchNetworkCreate):
(remoteDispatchNetworkDestroy, remoteDispatchNetworkDumpXml):
(remoteDispatchNetworkGetAutostart, remoteDispatchNetworkGetBridgeName):
(remoteDispatchNetworkSetAutostart, remoteDispatchNetworkUndefine):
(addrToString, remoteDispatchAuthSaslInit, remoteDispatchAuthSaslStart):
(remoteDispatchAuthSaslStep, remoteDispatchListDefinedStoragePools):
(remoteDispatchListStoragePools, remoteDispatchStoragePoolCreate):
(remoteDispatchStoragePoolBuild, remoteDispatchStoragePoolDestroy):
(remoteDispatchStoragePoolDelete, remoteDispatchStoragePoolRefresh):
(remoteDispatchStoragePoolGetInfo, remoteDispatchStoragePoolDumpXml):
(remoteDispatchStoragePoolGetAutostart): Likewise.
(remoteDispatchStoragePoolSetAutostart):
(remoteDispatchStoragePoolListVolumes):
(remoteDispatchStoragePoolNumOfVolumes):
(remoteDispatchStoragePoolUndefine, remoteDispatchStorageVolCreateXml):
(remoteDispatchStorageVolDelete, remoteDispatchStorageVolGetInfo):
(remoteDispatchStorageVolDumpXml, remoteDispatchStorageVolGetPath):
(remoteDispatchStorageVolLookupByName): Likewise.
* src/qemu_driver.c (qemudOpenMonitor, qemudStartVMDaemon):
(dhcpStartDhcpDaemon, qemudStartNetworkDaemon):
(qemudDomainSuspend, qemudDomainResume, qemudDomainShutdown):
(qemudDomainGetOSType, qemudDomainSetMaxMemory):
(qemudDomainSetMemory, qemudDomainGetInfo, qemudDomainSave):
(qemudDomainRestore, qemudDomainDumpXML, qemudDomainStart):
(qemudDomainUndefine, qemudDomainChangeCDROM):
(qemudDomainAttachDevice, qemudDomainGetAutostart):
(qemudDomainSetAutostart, qemudDomainInterfaceStats):
(qemudNetworkLookupByUUID, qemudNetworkLookupByName):
(qemudNetworkUndefine, qemudNetworkStart, qemudNetworkDestroy):
(qemudNetworkDumpXML, qemudNetworkGetAutostart):
(qemudNetworkSetAutostart): Likewise.
* src/virsh.c (cmdVcpupin, cmdAttachDevice, cmdDetachDevice): Likewise.
* src/xm_internal.c (xenXMConfigCacheRefresh, xenXMDomainPinVcpu): Likewise.
2008-03-27 13:43:01 +00:00
|
|
|
"%s", _("domain is not running"));
|
2009-11-03 18:26:32 +00:00
|
|
|
goto endjob;
|
2007-02-14 01:40:09 +00:00
|
|
|
}
|
2008-12-04 21:04:30 +00:00
|
|
|
if (vm->state != VIR_DOMAIN_PAUSED) {
|
2009-10-09 20:13:06 +00:00
|
|
|
qemuDomainObjPrivatePtr priv = vm->privateData;
|
2009-11-03 18:26:32 +00:00
|
|
|
qemuDomainObjEnterMonitorWithDriver(driver, vm);
|
2009-10-13 14:27:58 +00:00
|
|
|
if (qemuMonitorStopCPUs(priv->mon) < 0) {
|
2009-11-03 18:26:32 +00:00
|
|
|
qemuDomainObjExitMonitorWithDriver(driver, vm);
|
|
|
|
goto endjob;
|
2009-10-13 14:27:58 +00:00
|
|
|
}
|
2009-11-03 18:26:32 +00:00
|
|
|
qemuDomainObjExitMonitorWithDriver(driver, vm);
|
2008-12-04 21:04:30 +00:00
|
|
|
vm->state = VIR_DOMAIN_PAUSED;
|
2008-12-04 21:09:20 +00:00
|
|
|
event = virDomainEventNewFromObj(vm,
|
|
|
|
VIR_DOMAIN_EVENT_SUSPENDED,
|
|
|
|
VIR_DOMAIN_EVENT_SUSPENDED_PAUSED);
|
2007-02-14 01:40:09 +00:00
|
|
|
}
|
2009-11-26 17:57:00 +00:00
|
|
|
if (virDomainSaveStatus(dom->conn, driver->caps, driver->stateDir, vm) < 0)
|
2009-11-03 18:26:32 +00:00
|
|
|
goto endjob;
|
2008-12-04 21:04:30 +00:00
|
|
|
ret = 0;
|
|
|
|
|
2009-11-03 18:26:32 +00:00
|
|
|
endjob:
|
2009-12-08 14:42:43 +00:00
|
|
|
if (qemuDomainObjEndJob(vm) == 0)
|
|
|
|
vm = NULL;
|
2009-11-03 18:26:32 +00:00
|
|
|
|
2008-12-04 21:04:30 +00:00
|
|
|
cleanup:
|
2008-12-04 21:06:41 +00:00
|
|
|
if (vm)
|
|
|
|
virDomainObjUnlock(vm);
|
2008-12-04 21:09:20 +00:00
|
|
|
|
2009-05-19 11:06:25 +00:00
|
|
|
if (event)
|
2008-12-04 21:09:20 +00:00
|
|
|
qemuDomainEventQueue(driver, event);
|
2009-05-19 11:06:25 +00:00
|
|
|
qemuDriverUnlock(driver);
|
2008-12-04 21:04:30 +00:00
|
|
|
return ret;
|
2007-02-14 01:40:09 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
|
2007-06-29 13:23:13 +00:00
|
|
|
static int qemudDomainResume(virDomainPtr dom) {
|
2008-12-04 21:04:30 +00:00
|
|
|
struct qemud_driver *driver = dom->conn->privateData;
|
|
|
|
virDomainObjPtr vm;
|
|
|
|
int ret = -1;
|
2008-12-04 21:09:20 +00:00
|
|
|
virDomainEventPtr event = NULL;
|
2008-12-04 21:04:30 +00:00
|
|
|
|
2008-12-04 21:06:41 +00:00
|
|
|
qemuDriverLock(driver);
|
2009-04-19 15:30:50 +00:00
|
|
|
vm = virDomainFindByUUID(&driver->domains, dom->uuid);
|
2008-12-04 21:06:41 +00:00
|
|
|
|
2007-02-14 01:40:09 +00:00
|
|
|
if (!vm) {
|
2009-04-19 15:30:50 +00:00
|
|
|
char uuidstr[VIR_UUID_STRING_BUFLEN];
|
|
|
|
virUUIDFormat(dom->uuid, uuidstr);
|
|
|
|
qemudReportError(dom->conn, dom, NULL, VIR_ERR_NO_DOMAIN,
|
|
|
|
_("no domain with matching uuid '%s'"), uuidstr);
|
2008-12-04 21:04:30 +00:00
|
|
|
goto cleanup;
|
2007-02-14 01:40:09 +00:00
|
|
|
}
|
2009-11-03 18:26:32 +00:00
|
|
|
|
|
|
|
if (qemuDomainObjBeginJobWithDriver(driver, vm) < 0)
|
|
|
|
goto cleanup;
|
|
|
|
|
Rename internal APis
Rename virDomainIsActive to virDomainObjIsActive, and
virInterfaceIsActive to virInterfaceObjIsActive and finally
virNetworkIsActive to virNetworkObjIsActive.
* src/conf/domain_conf.c, src/conf/domain_conf.h,
src/conf/interface_conf.h, src/conf/network_conf.c,
src/conf/network_conf.h, src/lxc/lxc_driver.c,
src/network/bridge_driver.c, src/opennebula/one_driver.c,
src/openvz/openvz_driver.c, src/qemu/qemu_driver.c,
src/test/test_driver.c, src/uml/uml_driver.c: Update for
renamed APIs.
2009-10-20 14:51:03 +00:00
|
|
|
if (!virDomainObjIsActive(vm)) {
|
2009-05-08 09:58:46 +00:00
|
|
|
qemudReportError(dom->conn, dom, NULL, VIR_ERR_OPERATION_INVALID,
|
Mark many more strings for translation.
* Makefile.maint (err_func_re): Add to the list and make it readable.
* po/POTFILES.in: Add src/util.c and src/xm_internal.c, and sort.
* src/storage_backend.c: Fix comment.
* src/util.c (virFileLinkPointsTo): Mark a string.
* qemud/remote.c (remoteDispatchClientRequest): Mark strings.
(remoteDispatchOpen, CHECK_CONN, remoteDispatchGetType): Likewise.
(remoteDispatchDomainGetSchedulerType): Likewise.
(remoteDispatchDomainGetSchedulerParameters): Likewise.
(remoteDispatchDomainSetSchedulerParameters): Likewise.
(remoteDispatchDomainBlockStats): Likewise.
(remoteDispatchDomainInterfaceStats): Likewise.
(remoteDispatchDomainAttachDevice, remoteDispatchDomainCreate):
(remoteDispatchDomainDestroy, remoteDispatchDomainDetachDevice):
(remoteDispatchDomainDumpXml, remoteDispatchDomainGetAutostart):
(remoteDispatchDomainGetInfo, remoteDispatchDomainGetMaxMemory):
(remoteDispatchDomainGetMaxVcpus, remoteDispatchDomainGetOsType):
(remoteDispatchDomainGetVcpus): Likewise.
(remoteDispatchDomainMigratePerform): Likewise.
(remoteDispatchListDefinedDomains, remoteDispatchDomainPinVcpu):
(remoteDispatchDomainReboot, remoteDispatchDomainResume):
(remoteDispatchDomainSave, remoteDispatchDomainCoreDump):
(remoteDispatchDomainSetAutostart): Likewise.
(remoteDispatchDomainSetMaxMemory, remoteDispatchDomainSetMemory):
(remoteDispatchDomainSetVcpus, remoteDispatchDomainShutdown):
(remoteDispatchDomainSuspend, remoteDispatchDomainUndefine):
(remoteDispatchListDefinedNetworks, remoteDispatchListDomains):
(remoteDispatchListNetworks, remoteDispatchNetworkCreate):
(remoteDispatchNetworkDestroy, remoteDispatchNetworkDumpXml):
(remoteDispatchNetworkGetAutostart, remoteDispatchNetworkGetBridgeName):
(remoteDispatchNetworkSetAutostart, remoteDispatchNetworkUndefine):
(addrToString, remoteDispatchAuthSaslInit, remoteDispatchAuthSaslStart):
(remoteDispatchAuthSaslStep, remoteDispatchListDefinedStoragePools):
(remoteDispatchListStoragePools, remoteDispatchStoragePoolCreate):
(remoteDispatchStoragePoolBuild, remoteDispatchStoragePoolDestroy):
(remoteDispatchStoragePoolDelete, remoteDispatchStoragePoolRefresh):
(remoteDispatchStoragePoolGetInfo, remoteDispatchStoragePoolDumpXml):
(remoteDispatchStoragePoolGetAutostart): Likewise.
(remoteDispatchStoragePoolSetAutostart):
(remoteDispatchStoragePoolListVolumes):
(remoteDispatchStoragePoolNumOfVolumes):
(remoteDispatchStoragePoolUndefine, remoteDispatchStorageVolCreateXml):
(remoteDispatchStorageVolDelete, remoteDispatchStorageVolGetInfo):
(remoteDispatchStorageVolDumpXml, remoteDispatchStorageVolGetPath):
(remoteDispatchStorageVolLookupByName): Likewise.
* src/qemu_driver.c (qemudOpenMonitor, qemudStartVMDaemon):
(dhcpStartDhcpDaemon, qemudStartNetworkDaemon):
(qemudDomainSuspend, qemudDomainResume, qemudDomainShutdown):
(qemudDomainGetOSType, qemudDomainSetMaxMemory):
(qemudDomainSetMemory, qemudDomainGetInfo, qemudDomainSave):
(qemudDomainRestore, qemudDomainDumpXML, qemudDomainStart):
(qemudDomainUndefine, qemudDomainChangeCDROM):
(qemudDomainAttachDevice, qemudDomainGetAutostart):
(qemudDomainSetAutostart, qemudDomainInterfaceStats):
(qemudNetworkLookupByUUID, qemudNetworkLookupByName):
(qemudNetworkUndefine, qemudNetworkStart, qemudNetworkDestroy):
(qemudNetworkDumpXML, qemudNetworkGetAutostart):
(qemudNetworkSetAutostart): Likewise.
* src/virsh.c (cmdVcpupin, cmdAttachDevice, cmdDetachDevice): Likewise.
* src/xm_internal.c (xenXMConfigCacheRefresh, xenXMDomainPinVcpu): Likewise.
2008-03-27 13:43:01 +00:00
|
|
|
"%s", _("domain is not running"));
|
2009-11-03 18:26:32 +00:00
|
|
|
goto endjob;
|
2007-02-14 01:40:09 +00:00
|
|
|
}
|
2008-12-04 21:04:30 +00:00
|
|
|
if (vm->state == VIR_DOMAIN_PAUSED) {
|
2009-10-09 20:13:06 +00:00
|
|
|
qemuDomainObjPrivatePtr priv = vm->privateData;
|
2009-11-03 18:26:32 +00:00
|
|
|
qemuDomainObjEnterMonitorWithDriver(driver, vm);
|
2009-10-09 20:13:06 +00:00
|
|
|
if (qemuMonitorStartCPUs(priv->mon, dom->conn) < 0) {
|
2009-11-03 18:26:32 +00:00
|
|
|
qemuDomainObjExitMonitorWithDriver(driver, vm);
|
2009-07-21 09:53:17 +00:00
|
|
|
if (virGetLastError() == NULL)
|
|
|
|
qemudReportError(dom->conn, dom, NULL, VIR_ERR_OPERATION_FAILED,
|
|
|
|
"%s", _("resume operation failed"));
|
2009-11-03 18:26:32 +00:00
|
|
|
goto endjob;
|
2008-12-04 21:04:30 +00:00
|
|
|
}
|
2009-11-03 18:26:32 +00:00
|
|
|
qemuDomainObjExitMonitorWithDriver(driver, vm);
|
2008-12-04 21:04:30 +00:00
|
|
|
vm->state = VIR_DOMAIN_RUNNING;
|
2008-12-04 21:09:20 +00:00
|
|
|
event = virDomainEventNewFromObj(vm,
|
|
|
|
VIR_DOMAIN_EVENT_RESUMED,
|
|
|
|
VIR_DOMAIN_EVENT_RESUMED_UNPAUSED);
|
2007-02-14 01:40:09 +00:00
|
|
|
}
|
2009-11-26 17:57:00 +00:00
|
|
|
if (virDomainSaveStatus(dom->conn, driver->caps, driver->stateDir, vm) < 0)
|
2009-11-03 18:26:32 +00:00
|
|
|
goto endjob;
|
2008-12-04 21:04:30 +00:00
|
|
|
ret = 0;
|
|
|
|
|
2009-11-03 18:26:32 +00:00
|
|
|
endjob:
|
2009-12-08 14:42:43 +00:00
|
|
|
if (qemuDomainObjEndJob(vm) == 0)
|
|
|
|
vm = NULL;
|
2009-11-03 18:26:32 +00:00
|
|
|
|
2008-12-04 21:04:30 +00:00
|
|
|
cleanup:
|
2008-12-04 21:06:41 +00:00
|
|
|
if (vm)
|
|
|
|
virDomainObjUnlock(vm);
|
2009-05-19 11:06:25 +00:00
|
|
|
if (event)
|
2008-12-04 21:09:20 +00:00
|
|
|
qemuDomainEventQueue(driver, event);
|
2009-05-19 11:06:25 +00:00
|
|
|
qemuDriverUnlock(driver);
|
2008-12-04 21:04:30 +00:00
|
|
|
return ret;
|
2007-02-14 01:40:09 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
|
2008-01-09 16:05:21 +00:00
|
|
|
static int qemudDomainShutdown(virDomainPtr dom) {
|
2008-12-04 21:04:30 +00:00
|
|
|
struct qemud_driver *driver = dom->conn->privateData;
|
|
|
|
virDomainObjPtr vm;
|
|
|
|
int ret = -1;
|
2008-01-09 16:05:21 +00:00
|
|
|
|
2008-12-04 21:06:41 +00:00
|
|
|
qemuDriverLock(driver);
|
2009-04-19 15:30:50 +00:00
|
|
|
vm = virDomainFindByUUID(&driver->domains, dom->uuid);
|
2008-12-04 21:06:41 +00:00
|
|
|
qemuDriverUnlock(driver);
|
|
|
|
|
2008-01-09 16:05:21 +00:00
|
|
|
if (!vm) {
|
2009-04-19 15:30:50 +00:00
|
|
|
char uuidstr[VIR_UUID_STRING_BUFLEN];
|
|
|
|
virUUIDFormat(dom->uuid, uuidstr);
|
|
|
|
qemudReportError(dom->conn, dom, NULL, VIR_ERR_NO_DOMAIN,
|
|
|
|
_("no domain with matching uuid '%s'"), uuidstr);
|
2008-12-04 21:04:30 +00:00
|
|
|
goto cleanup;
|
2008-01-09 16:05:21 +00:00
|
|
|
}
|
|
|
|
|
2009-11-03 18:26:32 +00:00
|
|
|
if (qemuDomainObjBeginJob(vm) < 0)
|
|
|
|
goto cleanup;
|
|
|
|
|
Rename internal APis
Rename virDomainIsActive to virDomainObjIsActive, and
virInterfaceIsActive to virInterfaceObjIsActive and finally
virNetworkIsActive to virNetworkObjIsActive.
* src/conf/domain_conf.c, src/conf/domain_conf.h,
src/conf/interface_conf.h, src/conf/network_conf.c,
src/conf/network_conf.h, src/lxc/lxc_driver.c,
src/network/bridge_driver.c, src/opennebula/one_driver.c,
src/openvz/openvz_driver.c, src/qemu/qemu_driver.c,
src/test/test_driver.c, src/uml/uml_driver.c: Update for
renamed APIs.
2009-10-20 14:51:03 +00:00
|
|
|
if (!virDomainObjIsActive(vm)) {
|
2009-07-31 14:50:46 +00:00
|
|
|
qemudReportError(dom->conn, dom, NULL, VIR_ERR_OPERATION_INVALID,
|
|
|
|
"%s", _("domain is not running"));
|
2009-11-03 18:26:32 +00:00
|
|
|
goto endjob;
|
2009-07-31 14:50:46 +00:00
|
|
|
}
|
|
|
|
|
2009-10-09 20:13:06 +00:00
|
|
|
qemuDomainObjPrivatePtr priv = vm->privateData;
|
2009-10-13 14:27:58 +00:00
|
|
|
qemuDomainObjEnterMonitor(vm);
|
|
|
|
ret = qemuMonitorSystemPowerdown(priv->mon);
|
|
|
|
qemuDomainObjExitMonitor(vm);
|
2008-12-04 21:04:30 +00:00
|
|
|
|
2009-11-03 18:26:32 +00:00
|
|
|
endjob:
|
2009-12-08 14:42:43 +00:00
|
|
|
if (qemuDomainObjEndJob(vm) == 0)
|
|
|
|
vm = NULL;
|
2009-11-03 18:26:32 +00:00
|
|
|
|
2008-12-04 21:04:30 +00:00
|
|
|
cleanup:
|
2008-12-04 21:06:41 +00:00
|
|
|
if (vm)
|
|
|
|
virDomainObjUnlock(vm);
|
2008-12-04 21:04:30 +00:00
|
|
|
return ret;
|
2008-01-09 16:05:21 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
|
2007-06-29 13:23:13 +00:00
|
|
|
static int qemudDomainDestroy(virDomainPtr dom) {
|
2008-12-04 21:04:30 +00:00
|
|
|
struct qemud_driver *driver = dom->conn->privateData;
|
|
|
|
virDomainObjPtr vm;
|
|
|
|
int ret = -1;
|
2008-12-04 21:09:20 +00:00
|
|
|
virDomainEventPtr event = NULL;
|
2007-02-23 08:41:23 +00:00
|
|
|
|
2008-12-04 21:06:41 +00:00
|
|
|
qemuDriverLock(driver);
|
2009-04-19 15:30:50 +00:00
|
|
|
vm = virDomainFindByUUID(&driver->domains, dom->uuid);
|
2007-02-14 01:40:09 +00:00
|
|
|
if (!vm) {
|
2009-04-19 15:30:50 +00:00
|
|
|
char uuidstr[VIR_UUID_STRING_BUFLEN];
|
|
|
|
virUUIDFormat(dom->uuid, uuidstr);
|
|
|
|
qemudReportError(dom->conn, dom, NULL, VIR_ERR_NO_DOMAIN,
|
|
|
|
_("no domain with matching uuid '%s'"), uuidstr);
|
2008-12-04 21:04:30 +00:00
|
|
|
goto cleanup;
|
2007-02-14 01:40:09 +00:00
|
|
|
}
|
2009-11-03 18:26:32 +00:00
|
|
|
|
|
|
|
if (qemuDomainObjBeginJobWithDriver(driver, vm) < 0)
|
|
|
|
goto cleanup;
|
|
|
|
|
Rename internal APis
Rename virDomainIsActive to virDomainObjIsActive, and
virInterfaceIsActive to virInterfaceObjIsActive and finally
virNetworkIsActive to virNetworkObjIsActive.
* src/conf/domain_conf.c, src/conf/domain_conf.h,
src/conf/interface_conf.h, src/conf/network_conf.c,
src/conf/network_conf.h, src/lxc/lxc_driver.c,
src/network/bridge_driver.c, src/opennebula/one_driver.c,
src/openvz/openvz_driver.c, src/qemu/qemu_driver.c,
src/test/test_driver.c, src/uml/uml_driver.c: Update for
renamed APIs.
2009-10-20 14:51:03 +00:00
|
|
|
if (!virDomainObjIsActive(vm)) {
|
2009-07-31 14:50:46 +00:00
|
|
|
qemudReportError(dom->conn, dom, NULL, VIR_ERR_OPERATION_INVALID,
|
2009-05-08 10:11:14 +00:00
|
|
|
"%s", _("domain is not running"));
|
2009-11-03 18:26:32 +00:00
|
|
|
goto endjob;
|
2009-05-08 10:11:14 +00:00
|
|
|
}
|
2007-02-23 08:41:23 +00:00
|
|
|
|
2007-07-24 14:24:52 +00:00
|
|
|
qemudShutdownVMDaemon(dom->conn, driver, vm);
|
2008-12-04 21:09:20 +00:00
|
|
|
event = virDomainEventNewFromObj(vm,
|
|
|
|
VIR_DOMAIN_EVENT_STOPPED,
|
|
|
|
VIR_DOMAIN_EVENT_STOPPED_DESTROYED);
|
2008-12-04 21:06:41 +00:00
|
|
|
if (!vm->persistent) {
|
2009-12-08 14:42:43 +00:00
|
|
|
if (qemuDomainObjEndJob(vm) > 0)
|
|
|
|
virDomainRemoveInactive(&driver->domains,
|
|
|
|
vm);
|
2008-12-04 21:06:41 +00:00
|
|
|
vm = NULL;
|
|
|
|
}
|
2008-12-04 21:04:30 +00:00
|
|
|
ret = 0;
|
|
|
|
|
2009-11-03 18:26:32 +00:00
|
|
|
endjob:
|
2009-12-08 14:42:43 +00:00
|
|
|
if (vm &&
|
|
|
|
qemuDomainObjEndJob(vm) == 0)
|
|
|
|
vm = NULL;
|
2009-11-03 18:26:32 +00:00
|
|
|
|
2008-12-04 21:04:30 +00:00
|
|
|
cleanup:
|
2008-12-04 21:06:41 +00:00
|
|
|
if (vm)
|
|
|
|
virDomainObjUnlock(vm);
|
2008-12-04 21:09:20 +00:00
|
|
|
if (event)
|
|
|
|
qemuDomainEventQueue(driver, event);
|
2008-12-04 21:06:41 +00:00
|
|
|
qemuDriverUnlock(driver);
|
2008-12-04 21:04:30 +00:00
|
|
|
return ret;
|
2007-02-14 01:40:09 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
|
2007-06-26 22:39:53 +00:00
|
|
|
static char *qemudDomainGetOSType(virDomainPtr dom) {
|
2008-12-04 21:04:30 +00:00
|
|
|
struct qemud_driver *driver = dom->conn->privateData;
|
|
|
|
virDomainObjPtr vm;
|
|
|
|
char *type = NULL;
|
2007-06-26 22:39:53 +00:00
|
|
|
|
2008-12-04 21:06:41 +00:00
|
|
|
qemuDriverLock(driver);
|
2008-12-04 21:04:30 +00:00
|
|
|
vm = virDomainFindByUUID(&driver->domains, dom->uuid);
|
2008-12-04 21:06:41 +00:00
|
|
|
qemuDriverUnlock(driver);
|
2007-06-26 22:39:53 +00:00
|
|
|
if (!vm) {
|
2009-04-19 15:30:50 +00:00
|
|
|
char uuidstr[VIR_UUID_STRING_BUFLEN];
|
|
|
|
virUUIDFormat(dom->uuid, uuidstr);
|
|
|
|
qemudReportError(dom->conn, dom, NULL, VIR_ERR_NO_DOMAIN,
|
|
|
|
_("no domain with matching uuid '%s'"), uuidstr);
|
2008-12-04 21:04:30 +00:00
|
|
|
goto cleanup;
|
2007-06-26 22:39:53 +00:00
|
|
|
}
|
|
|
|
|
2008-12-04 21:04:30 +00:00
|
|
|
if (!(type = strdup(vm->def->os.type)))
|
2009-01-29 12:10:32 +00:00
|
|
|
virReportOOMError(dom->conn);
|
2008-12-04 21:04:30 +00:00
|
|
|
|
|
|
|
cleanup:
|
2008-12-04 21:06:41 +00:00
|
|
|
if (vm)
|
|
|
|
virDomainObjUnlock(vm);
|
2007-06-26 22:39:53 +00:00
|
|
|
return type;
|
|
|
|
}
|
|
|
|
|
2008-03-19 14:32:50 +00:00
|
|
|
/* Returns max memory in kb, 0 if error */
|
|
|
|
static unsigned long qemudDomainGetMaxMemory(virDomainPtr dom) {
|
2008-12-04 21:04:30 +00:00
|
|
|
struct qemud_driver *driver = dom->conn->privateData;
|
|
|
|
virDomainObjPtr vm;
|
|
|
|
unsigned long ret = 0;
|
2008-03-19 14:32:50 +00:00
|
|
|
|
2008-12-04 21:06:41 +00:00
|
|
|
qemuDriverLock(driver);
|
2008-12-04 21:04:30 +00:00
|
|
|
vm = virDomainFindByUUID(&driver->domains, dom->uuid);
|
2008-12-04 21:06:41 +00:00
|
|
|
qemuDriverUnlock(driver);
|
|
|
|
|
2008-03-19 14:32:50 +00:00
|
|
|
if (!vm) {
|
2008-07-25 09:01:25 +00:00
|
|
|
char uuidstr[VIR_UUID_STRING_BUFLEN];
|
|
|
|
virUUIDFormat(dom->uuid, uuidstr);
|
2009-04-19 15:30:50 +00:00
|
|
|
qemudReportError(dom->conn, dom, NULL, VIR_ERR_NO_DOMAIN,
|
2008-07-25 09:01:25 +00:00
|
|
|
_("no domain with matching uuid '%s'"), uuidstr);
|
2008-12-04 21:04:30 +00:00
|
|
|
goto cleanup;
|
2008-03-19 14:32:50 +00:00
|
|
|
}
|
|
|
|
|
2008-12-04 21:04:30 +00:00
|
|
|
ret = vm->def->maxmem;
|
|
|
|
|
|
|
|
cleanup:
|
2008-12-04 21:06:41 +00:00
|
|
|
if (vm)
|
|
|
|
virDomainObjUnlock(vm);
|
2008-12-04 21:04:30 +00:00
|
|
|
return ret;
|
2008-03-19 14:32:50 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
static int qemudDomainSetMaxMemory(virDomainPtr dom, unsigned long newmax) {
|
2008-12-04 21:04:30 +00:00
|
|
|
struct qemud_driver *driver = dom->conn->privateData;
|
|
|
|
virDomainObjPtr vm;
|
|
|
|
int ret = -1;
|
2008-03-19 14:32:50 +00:00
|
|
|
|
2008-12-04 21:06:41 +00:00
|
|
|
qemuDriverLock(driver);
|
2008-12-04 21:04:30 +00:00
|
|
|
vm = virDomainFindByUUID(&driver->domains, dom->uuid);
|
2008-12-04 21:06:41 +00:00
|
|
|
qemuDriverUnlock(driver);
|
|
|
|
|
2008-03-19 14:32:50 +00:00
|
|
|
if (!vm) {
|
2008-07-25 09:01:25 +00:00
|
|
|
char uuidstr[VIR_UUID_STRING_BUFLEN];
|
|
|
|
virUUIDFormat(dom->uuid, uuidstr);
|
2009-04-19 15:30:50 +00:00
|
|
|
qemudReportError(dom->conn, dom, NULL, VIR_ERR_NO_DOMAIN,
|
2008-07-25 09:01:25 +00:00
|
|
|
_("no domain with matching uuid '%s'"), uuidstr);
|
2008-12-04 21:04:30 +00:00
|
|
|
goto cleanup;
|
2008-03-19 14:32:50 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
if (newmax < vm->def->memory) {
|
|
|
|
qemudReportError(dom->conn, dom, NULL, VIR_ERR_INVALID_ARG,
|
Mark many more strings for translation.
* Makefile.maint (err_func_re): Add to the list and make it readable.
* po/POTFILES.in: Add src/util.c and src/xm_internal.c, and sort.
* src/storage_backend.c: Fix comment.
* src/util.c (virFileLinkPointsTo): Mark a string.
* qemud/remote.c (remoteDispatchClientRequest): Mark strings.
(remoteDispatchOpen, CHECK_CONN, remoteDispatchGetType): Likewise.
(remoteDispatchDomainGetSchedulerType): Likewise.
(remoteDispatchDomainGetSchedulerParameters): Likewise.
(remoteDispatchDomainSetSchedulerParameters): Likewise.
(remoteDispatchDomainBlockStats): Likewise.
(remoteDispatchDomainInterfaceStats): Likewise.
(remoteDispatchDomainAttachDevice, remoteDispatchDomainCreate):
(remoteDispatchDomainDestroy, remoteDispatchDomainDetachDevice):
(remoteDispatchDomainDumpXml, remoteDispatchDomainGetAutostart):
(remoteDispatchDomainGetInfo, remoteDispatchDomainGetMaxMemory):
(remoteDispatchDomainGetMaxVcpus, remoteDispatchDomainGetOsType):
(remoteDispatchDomainGetVcpus): Likewise.
(remoteDispatchDomainMigratePerform): Likewise.
(remoteDispatchListDefinedDomains, remoteDispatchDomainPinVcpu):
(remoteDispatchDomainReboot, remoteDispatchDomainResume):
(remoteDispatchDomainSave, remoteDispatchDomainCoreDump):
(remoteDispatchDomainSetAutostart): Likewise.
(remoteDispatchDomainSetMaxMemory, remoteDispatchDomainSetMemory):
(remoteDispatchDomainSetVcpus, remoteDispatchDomainShutdown):
(remoteDispatchDomainSuspend, remoteDispatchDomainUndefine):
(remoteDispatchListDefinedNetworks, remoteDispatchListDomains):
(remoteDispatchListNetworks, remoteDispatchNetworkCreate):
(remoteDispatchNetworkDestroy, remoteDispatchNetworkDumpXml):
(remoteDispatchNetworkGetAutostart, remoteDispatchNetworkGetBridgeName):
(remoteDispatchNetworkSetAutostart, remoteDispatchNetworkUndefine):
(addrToString, remoteDispatchAuthSaslInit, remoteDispatchAuthSaslStart):
(remoteDispatchAuthSaslStep, remoteDispatchListDefinedStoragePools):
(remoteDispatchListStoragePools, remoteDispatchStoragePoolCreate):
(remoteDispatchStoragePoolBuild, remoteDispatchStoragePoolDestroy):
(remoteDispatchStoragePoolDelete, remoteDispatchStoragePoolRefresh):
(remoteDispatchStoragePoolGetInfo, remoteDispatchStoragePoolDumpXml):
(remoteDispatchStoragePoolGetAutostart): Likewise.
(remoteDispatchStoragePoolSetAutostart):
(remoteDispatchStoragePoolListVolumes):
(remoteDispatchStoragePoolNumOfVolumes):
(remoteDispatchStoragePoolUndefine, remoteDispatchStorageVolCreateXml):
(remoteDispatchStorageVolDelete, remoteDispatchStorageVolGetInfo):
(remoteDispatchStorageVolDumpXml, remoteDispatchStorageVolGetPath):
(remoteDispatchStorageVolLookupByName): Likewise.
* src/qemu_driver.c (qemudOpenMonitor, qemudStartVMDaemon):
(dhcpStartDhcpDaemon, qemudStartNetworkDaemon):
(qemudDomainSuspend, qemudDomainResume, qemudDomainShutdown):
(qemudDomainGetOSType, qemudDomainSetMaxMemory):
(qemudDomainSetMemory, qemudDomainGetInfo, qemudDomainSave):
(qemudDomainRestore, qemudDomainDumpXML, qemudDomainStart):
(qemudDomainUndefine, qemudDomainChangeCDROM):
(qemudDomainAttachDevice, qemudDomainGetAutostart):
(qemudDomainSetAutostart, qemudDomainInterfaceStats):
(qemudNetworkLookupByUUID, qemudNetworkLookupByName):
(qemudNetworkUndefine, qemudNetworkStart, qemudNetworkDestroy):
(qemudNetworkDumpXML, qemudNetworkGetAutostart):
(qemudNetworkSetAutostart): Likewise.
* src/virsh.c (cmdVcpupin, cmdAttachDevice, cmdDetachDevice): Likewise.
* src/xm_internal.c (xenXMConfigCacheRefresh, xenXMDomainPinVcpu): Likewise.
2008-03-27 13:43:01 +00:00
|
|
|
"%s", _("cannot set max memory lower than current memory"));
|
2008-12-04 21:04:30 +00:00
|
|
|
goto cleanup;;
|
2008-03-19 14:32:50 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
vm->def->maxmem = newmax;
|
2008-12-04 21:04:30 +00:00
|
|
|
ret = 0;
|
|
|
|
|
|
|
|
cleanup:
|
2008-12-04 21:06:41 +00:00
|
|
|
if (vm)
|
|
|
|
virDomainObjUnlock(vm);
|
2008-12-04 21:04:30 +00:00
|
|
|
return ret;
|
2008-03-19 14:32:50 +00:00
|
|
|
}
|
|
|
|
|
2009-03-27 11:44:29 +00:00
|
|
|
|
2008-03-19 14:32:50 +00:00
|
|
|
static int qemudDomainSetMemory(virDomainPtr dom, unsigned long newmem) {
|
2008-12-04 21:04:30 +00:00
|
|
|
struct qemud_driver *driver = dom->conn->privateData;
|
|
|
|
virDomainObjPtr vm;
|
|
|
|
int ret = -1;
|
2008-03-19 14:32:50 +00:00
|
|
|
|
2008-12-04 21:06:41 +00:00
|
|
|
qemuDriverLock(driver);
|
2008-12-04 21:04:30 +00:00
|
|
|
vm = virDomainFindByUUID(&driver->domains, dom->uuid);
|
2008-12-04 21:06:41 +00:00
|
|
|
qemuDriverUnlock(driver);
|
2008-03-19 14:32:50 +00:00
|
|
|
if (!vm) {
|
2008-07-25 09:01:25 +00:00
|
|
|
char uuidstr[VIR_UUID_STRING_BUFLEN];
|
|
|
|
virUUIDFormat(dom->uuid, uuidstr);
|
2009-04-19 15:30:50 +00:00
|
|
|
qemudReportError(dom->conn, dom, NULL, VIR_ERR_NO_DOMAIN,
|
2008-07-25 09:01:25 +00:00
|
|
|
_("no domain with matching uuid '%s'"), uuidstr);
|
2008-12-04 21:04:30 +00:00
|
|
|
goto cleanup;
|
2008-03-19 14:32:50 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
if (newmem > vm->def->maxmem) {
|
|
|
|
qemudReportError(dom->conn, dom, NULL, VIR_ERR_INVALID_ARG,
|
Mark many more strings for translation.
* Makefile.maint (err_func_re): Add to the list and make it readable.
* po/POTFILES.in: Add src/util.c and src/xm_internal.c, and sort.
* src/storage_backend.c: Fix comment.
* src/util.c (virFileLinkPointsTo): Mark a string.
* qemud/remote.c (remoteDispatchClientRequest): Mark strings.
(remoteDispatchOpen, CHECK_CONN, remoteDispatchGetType): Likewise.
(remoteDispatchDomainGetSchedulerType): Likewise.
(remoteDispatchDomainGetSchedulerParameters): Likewise.
(remoteDispatchDomainSetSchedulerParameters): Likewise.
(remoteDispatchDomainBlockStats): Likewise.
(remoteDispatchDomainInterfaceStats): Likewise.
(remoteDispatchDomainAttachDevice, remoteDispatchDomainCreate):
(remoteDispatchDomainDestroy, remoteDispatchDomainDetachDevice):
(remoteDispatchDomainDumpXml, remoteDispatchDomainGetAutostart):
(remoteDispatchDomainGetInfo, remoteDispatchDomainGetMaxMemory):
(remoteDispatchDomainGetMaxVcpus, remoteDispatchDomainGetOsType):
(remoteDispatchDomainGetVcpus): Likewise.
(remoteDispatchDomainMigratePerform): Likewise.
(remoteDispatchListDefinedDomains, remoteDispatchDomainPinVcpu):
(remoteDispatchDomainReboot, remoteDispatchDomainResume):
(remoteDispatchDomainSave, remoteDispatchDomainCoreDump):
(remoteDispatchDomainSetAutostart): Likewise.
(remoteDispatchDomainSetMaxMemory, remoteDispatchDomainSetMemory):
(remoteDispatchDomainSetVcpus, remoteDispatchDomainShutdown):
(remoteDispatchDomainSuspend, remoteDispatchDomainUndefine):
(remoteDispatchListDefinedNetworks, remoteDispatchListDomains):
(remoteDispatchListNetworks, remoteDispatchNetworkCreate):
(remoteDispatchNetworkDestroy, remoteDispatchNetworkDumpXml):
(remoteDispatchNetworkGetAutostart, remoteDispatchNetworkGetBridgeName):
(remoteDispatchNetworkSetAutostart, remoteDispatchNetworkUndefine):
(addrToString, remoteDispatchAuthSaslInit, remoteDispatchAuthSaslStart):
(remoteDispatchAuthSaslStep, remoteDispatchListDefinedStoragePools):
(remoteDispatchListStoragePools, remoteDispatchStoragePoolCreate):
(remoteDispatchStoragePoolBuild, remoteDispatchStoragePoolDestroy):
(remoteDispatchStoragePoolDelete, remoteDispatchStoragePoolRefresh):
(remoteDispatchStoragePoolGetInfo, remoteDispatchStoragePoolDumpXml):
(remoteDispatchStoragePoolGetAutostart): Likewise.
(remoteDispatchStoragePoolSetAutostart):
(remoteDispatchStoragePoolListVolumes):
(remoteDispatchStoragePoolNumOfVolumes):
(remoteDispatchStoragePoolUndefine, remoteDispatchStorageVolCreateXml):
(remoteDispatchStorageVolDelete, remoteDispatchStorageVolGetInfo):
(remoteDispatchStorageVolDumpXml, remoteDispatchStorageVolGetPath):
(remoteDispatchStorageVolLookupByName): Likewise.
* src/qemu_driver.c (qemudOpenMonitor, qemudStartVMDaemon):
(dhcpStartDhcpDaemon, qemudStartNetworkDaemon):
(qemudDomainSuspend, qemudDomainResume, qemudDomainShutdown):
(qemudDomainGetOSType, qemudDomainSetMaxMemory):
(qemudDomainSetMemory, qemudDomainGetInfo, qemudDomainSave):
(qemudDomainRestore, qemudDomainDumpXML, qemudDomainStart):
(qemudDomainUndefine, qemudDomainChangeCDROM):
(qemudDomainAttachDevice, qemudDomainGetAutostart):
(qemudDomainSetAutostart, qemudDomainInterfaceStats):
(qemudNetworkLookupByUUID, qemudNetworkLookupByName):
(qemudNetworkUndefine, qemudNetworkStart, qemudNetworkDestroy):
(qemudNetworkDumpXML, qemudNetworkGetAutostart):
(qemudNetworkSetAutostart): Likewise.
* src/virsh.c (cmdVcpupin, cmdAttachDevice, cmdDetachDevice): Likewise.
* src/xm_internal.c (xenXMConfigCacheRefresh, xenXMDomainPinVcpu): Likewise.
2008-03-27 13:43:01 +00:00
|
|
|
"%s", _("cannot set memory higher than max memory"));
|
2008-12-04 21:04:30 +00:00
|
|
|
goto cleanup;
|
2008-03-19 14:32:50 +00:00
|
|
|
}
|
|
|
|
|
2009-11-03 18:26:32 +00:00
|
|
|
if (qemuDomainObjBeginJob(vm) < 0)
|
|
|
|
goto cleanup;
|
|
|
|
|
Rename internal APis
Rename virDomainIsActive to virDomainObjIsActive, and
virInterfaceIsActive to virInterfaceObjIsActive and finally
virNetworkIsActive to virNetworkObjIsActive.
* src/conf/domain_conf.c, src/conf/domain_conf.h,
src/conf/interface_conf.h, src/conf/network_conf.c,
src/conf/network_conf.h, src/lxc/lxc_driver.c,
src/network/bridge_driver.c, src/opennebula/one_driver.c,
src/openvz/openvz_driver.c, src/qemu/qemu_driver.c,
src/test/test_driver.c, src/uml/uml_driver.c: Update for
renamed APIs.
2009-10-20 14:51:03 +00:00
|
|
|
if (virDomainObjIsActive(vm)) {
|
2009-10-09 20:13:06 +00:00
|
|
|
qemuDomainObjPrivatePtr priv = vm->privateData;
|
2009-10-13 14:27:58 +00:00
|
|
|
qemuDomainObjEnterMonitor(vm);
|
2009-10-09 20:13:06 +00:00
|
|
|
int r = qemuMonitorSetBalloon(priv->mon, newmem);
|
2009-10-13 14:27:58 +00:00
|
|
|
qemuDomainObjExitMonitor(vm);
|
2009-10-07 13:33:36 +00:00
|
|
|
if (r < 0)
|
2009-11-03 18:26:32 +00:00
|
|
|
goto endjob;
|
2009-10-07 13:33:36 +00:00
|
|
|
|
|
|
|
/* Lack of balloon support is a fatal error */
|
|
|
|
if (r == 0) {
|
2009-03-27 11:44:29 +00:00
|
|
|
qemudReportError(dom->conn, dom, NULL, VIR_ERR_NO_SUPPORT,
|
|
|
|
"%s", _("cannot set memory of an active domain"));
|
2009-11-03 18:26:32 +00:00
|
|
|
goto endjob;
|
2009-09-23 11:35:10 +00:00
|
|
|
}
|
2009-03-27 11:44:29 +00:00
|
|
|
} else {
|
|
|
|
vm->def->memory = newmem;
|
|
|
|
}
|
2009-10-07 13:33:36 +00:00
|
|
|
ret = 0;
|
2008-12-04 21:04:30 +00:00
|
|
|
|
2009-11-03 18:26:32 +00:00
|
|
|
endjob:
|
2009-12-08 14:42:43 +00:00
|
|
|
if (qemuDomainObjEndJob(vm) == 0)
|
|
|
|
vm = NULL;
|
2009-11-03 18:26:32 +00:00
|
|
|
|
2008-12-04 21:04:30 +00:00
|
|
|
cleanup:
|
2008-12-04 21:06:41 +00:00
|
|
|
if (vm)
|
|
|
|
virDomainObjUnlock(vm);
|
2008-12-04 21:04:30 +00:00
|
|
|
return ret;
|
2008-03-19 14:32:50 +00:00
|
|
|
}
|
|
|
|
|
2007-06-29 13:23:13 +00:00
|
|
|
static int qemudDomainGetInfo(virDomainPtr dom,
|
2008-07-11 19:34:11 +00:00
|
|
|
virDomainInfoPtr info) {
|
2008-12-04 21:04:30 +00:00
|
|
|
struct qemud_driver *driver = dom->conn->privateData;
|
|
|
|
virDomainObjPtr vm;
|
|
|
|
int ret = -1;
|
2009-03-27 11:44:29 +00:00
|
|
|
int err;
|
|
|
|
unsigned long balloon;
|
2008-12-04 21:04:30 +00:00
|
|
|
|
2008-12-04 21:06:41 +00:00
|
|
|
qemuDriverLock(driver);
|
2008-12-04 21:04:30 +00:00
|
|
|
vm = virDomainFindByUUID(&driver->domains, dom->uuid);
|
2008-12-04 21:06:41 +00:00
|
|
|
qemuDriverUnlock(driver);
|
2007-02-14 01:40:09 +00:00
|
|
|
if (!vm) {
|
2009-04-19 15:30:50 +00:00
|
|
|
char uuidstr[VIR_UUID_STRING_BUFLEN];
|
|
|
|
virUUIDFormat(dom->uuid, uuidstr);
|
|
|
|
qemudReportError(dom->conn, dom, NULL, VIR_ERR_NO_DOMAIN,
|
|
|
|
_("no domain with matching uuid '%s'"), uuidstr);
|
2008-12-04 21:04:30 +00:00
|
|
|
goto cleanup;
|
2007-02-14 01:40:09 +00:00
|
|
|
}
|
|
|
|
|
2007-06-26 22:39:53 +00:00
|
|
|
info->state = vm->state;
|
2007-02-14 01:40:09 +00:00
|
|
|
|
Rename internal APis
Rename virDomainIsActive to virDomainObjIsActive, and
virInterfaceIsActive to virInterfaceObjIsActive and finally
virNetworkIsActive to virNetworkObjIsActive.
* src/conf/domain_conf.c, src/conf/domain_conf.h,
src/conf/interface_conf.h, src/conf/network_conf.c,
src/conf/network_conf.h, src/lxc/lxc_driver.c,
src/network/bridge_driver.c, src/opennebula/one_driver.c,
src/openvz/openvz_driver.c, src/qemu/qemu_driver.c,
src/test/test_driver.c, src/uml/uml_driver.c: Update for
renamed APIs.
2009-10-20 14:51:03 +00:00
|
|
|
if (!virDomainObjIsActive(vm)) {
|
2007-06-26 22:39:53 +00:00
|
|
|
info->cpuTime = 0;
|
2007-02-14 01:40:09 +00:00
|
|
|
} else {
|
2009-07-27 15:30:25 +00:00
|
|
|
if (qemudGetProcessInfo(&(info->cpuTime), NULL, vm->pid, 0) < 0) {
|
2008-03-24 10:51:47 +00:00
|
|
|
qemudReportError(dom->conn, dom, NULL, VIR_ERR_OPERATION_FAILED, ("cannot read cputime for domain"));
|
2008-12-04 21:04:30 +00:00
|
|
|
goto cleanup;
|
2007-02-14 01:40:09 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2007-06-26 22:39:53 +00:00
|
|
|
info->maxMem = vm->def->maxmem;
|
2009-06-22 16:35:03 +00:00
|
|
|
|
Rename internal APis
Rename virDomainIsActive to virDomainObjIsActive, and
virInterfaceIsActive to virInterfaceObjIsActive and finally
virNetworkIsActive to virNetworkObjIsActive.
* src/conf/domain_conf.c, src/conf/domain_conf.h,
src/conf/interface_conf.h, src/conf/network_conf.c,
src/conf/network_conf.h, src/lxc/lxc_driver.c,
src/network/bridge_driver.c, src/opennebula/one_driver.c,
src/openvz/openvz_driver.c, src/qemu/qemu_driver.c,
src/test/test_driver.c, src/uml/uml_driver.c: Update for
renamed APIs.
2009-10-20 14:51:03 +00:00
|
|
|
if (virDomainObjIsActive(vm)) {
|
2009-10-09 20:13:06 +00:00
|
|
|
qemuDomainObjPrivatePtr priv = vm->privateData;
|
2009-11-03 18:26:32 +00:00
|
|
|
if (!priv->jobActive) {
|
|
|
|
if (qemuDomainObjBeginJob(vm) < 0)
|
|
|
|
goto cleanup;
|
2009-06-22 16:35:03 +00:00
|
|
|
|
2009-11-03 18:26:32 +00:00
|
|
|
qemuDomainObjEnterMonitor(vm);
|
|
|
|
err = qemuMonitorGetBalloonInfo(priv->mon, &balloon);
|
|
|
|
qemuDomainObjExitMonitor(vm);
|
|
|
|
if (err < 0) {
|
2009-12-08 14:42:43 +00:00
|
|
|
if (qemuDomainObjEndJob(vm) == 0)
|
|
|
|
vm = NULL;
|
2009-11-03 18:26:32 +00:00
|
|
|
goto cleanup;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (err == 0)
|
|
|
|
/* Balloon not supported, so maxmem is always the allocation */
|
|
|
|
info->memory = vm->def->maxmem;
|
|
|
|
else
|
|
|
|
info->memory = balloon;
|
|
|
|
|
2009-12-08 14:42:43 +00:00
|
|
|
if (qemuDomainObjEndJob(vm) == 0) {
|
|
|
|
vm = NULL;
|
|
|
|
goto cleanup;
|
|
|
|
}
|
2009-11-03 18:26:32 +00:00
|
|
|
} else {
|
|
|
|
info->memory = vm->def->memory;
|
|
|
|
}
|
2009-06-22 16:35:03 +00:00
|
|
|
} else {
|
|
|
|
info->memory = vm->def->memory;
|
|
|
|
}
|
|
|
|
|
2007-06-26 22:39:53 +00:00
|
|
|
info->nrVirtCpu = vm->def->vcpus;
|
2008-12-04 21:04:30 +00:00
|
|
|
ret = 0;
|
|
|
|
|
|
|
|
cleanup:
|
2008-12-04 21:06:41 +00:00
|
|
|
if (vm)
|
|
|
|
virDomainObjUnlock(vm);
|
2008-12-04 21:04:30 +00:00
|
|
|
return ret;
|
2007-02-14 01:40:09 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
|
2007-08-14 01:47:24 +00:00
|
|
|
#define QEMUD_SAVE_MAGIC "LibvirtQemudSave"
|
Compressed save image format for Qemu.
Implement a compressed save image format for qemu. While ideally
we would have the choice between compressed/non-compressed
available to the libvirt API, unfortunately there is no "flags"
parameter to the virDomainSave() API. Therefore, implement this
as a qemu.conf option. gzip, bzip2, and lzma are implemented, and
it should be very easy to implement additional compression
methods.
One open question is if/how we should detect the compression
binaries. One way to do it is to do compile-time setting of the
paths (via configure.in), but that doesn't seem like a great thing
to do. My preferred solution is not to detect at all;
when we go to run the commands that need them, if they
aren't available, or aren't available in one of the standard paths,
then we'll fail. That's also the solution implemented in this patch.
In the future, we'll have a more robust (managed) save/restore API,
at which time we can expose this functionality properly in the API.
V2: get rid of redundant dd command and just use >> to append data.
V3: Add back the missing pieces for the enum and bumping the save version.
V4: Make the compressed field in the save_header an int.
Implement LZMA compression.
Signed-off-by: Chris Lalancette <clalance@redhat.com>
2009-08-07 11:34:05 +00:00
|
|
|
#define QEMUD_SAVE_VERSION 2
|
|
|
|
|
|
|
|
enum qemud_save_formats {
|
2009-09-08 18:52:37 +00:00
|
|
|
QEMUD_SAVE_FORMAT_RAW = 0,
|
|
|
|
QEMUD_SAVE_FORMAT_GZIP = 1,
|
|
|
|
QEMUD_SAVE_FORMAT_BZIP2 = 2,
|
2009-09-09 14:44:44 +00:00
|
|
|
/*
|
|
|
|
* Deprecated by xz and never used as part of a release
|
2009-09-10 09:13:33 +00:00
|
|
|
* QEMUD_SAVE_FORMAT_LZMA
|
2009-09-09 14:44:44 +00:00
|
|
|
*/
|
|
|
|
QEMUD_SAVE_FORMAT_XZ = 3,
|
2009-09-10 09:13:33 +00:00
|
|
|
QEMUD_SAVE_FORMAT_LZOP = 4,
|
2009-09-08 18:52:37 +00:00
|
|
|
/* Note: add new members only at the end.
|
|
|
|
These values are used in the on-disk format.
|
|
|
|
Do not change or re-use numbers. */
|
2009-09-09 08:10:38 +00:00
|
|
|
|
|
|
|
QEMUD_SAVE_FORMAT_LAST
|
Compressed save image format for Qemu.
Implement a compressed save image format for qemu. While ideally
we would have the choice between compressed/non-compressed
available to the libvirt API, unfortunately there is no "flags"
parameter to the virDomainSave() API. Therefore, implement this
as a qemu.conf option. gzip, bzip2, and lzma are implemented, and
it should be very easy to implement additional compression
methods.
One open question is if/how we should detect the compression
binaries. One way to do it is to do compile-time setting of the
paths (via configure.in), but that doesn't seem like a great thing
to do. My preferred solution is not to detect at all;
when we go to run the commands that need them, if they
aren't available, or aren't available in one of the standard paths,
then we'll fail. That's also the solution implemented in this patch.
In the future, we'll have a more robust (managed) save/restore API,
at which time we can expose this functionality properly in the API.
V2: get rid of redundant dd command and just use >> to append data.
V3: Add back the missing pieces for the enum and bumping the save version.
V4: Make the compressed field in the save_header an int.
Implement LZMA compression.
Signed-off-by: Chris Lalancette <clalance@redhat.com>
2009-08-07 11:34:05 +00:00
|
|
|
};
|
2007-08-14 01:47:24 +00:00
|
|
|
|
2009-09-09 08:10:38 +00:00
|
|
|
VIR_ENUM_DECL(qemudSaveCompression)
|
|
|
|
VIR_ENUM_IMPL(qemudSaveCompression, QEMUD_SAVE_FORMAT_LAST,
|
|
|
|
"raw",
|
|
|
|
"gzip",
|
|
|
|
"bzip2",
|
2009-09-10 09:13:33 +00:00
|
|
|
"xz",
|
|
|
|
"lzop")
|
2009-09-09 08:10:38 +00:00
|
|
|
|
2007-08-14 01:47:24 +00:00
|
|
|
struct qemud_save_header {
|
|
|
|
char magic[sizeof(QEMUD_SAVE_MAGIC)-1];
|
|
|
|
int version;
|
|
|
|
int xml_len;
|
|
|
|
int was_running;
|
Compressed save image format for Qemu.
Implement a compressed save image format for qemu. While ideally
we would have the choice between compressed/non-compressed
available to the libvirt API, unfortunately there is no "flags"
parameter to the virDomainSave() API. Therefore, implement this
as a qemu.conf option. gzip, bzip2, and lzma are implemented, and
it should be very easy to implement additional compression
methods.
One open question is if/how we should detect the compression
binaries. One way to do it is to do compile-time setting of the
paths (via configure.in), but that doesn't seem like a great thing
to do. My preferred solution is not to detect at all;
when we go to run the commands that need them, if they
aren't available, or aren't available in one of the standard paths,
then we'll fail. That's also the solution implemented in this patch.
In the future, we'll have a more robust (managed) save/restore API,
at which time we can expose this functionality properly in the API.
V2: get rid of redundant dd command and just use >> to append data.
V3: Add back the missing pieces for the enum and bumping the save version.
V4: Make the compressed field in the save_header an int.
Implement LZMA compression.
Signed-off-by: Chris Lalancette <clalance@redhat.com>
2009-08-07 11:34:05 +00:00
|
|
|
int compressed;
|
|
|
|
int unused[15];
|
2007-08-14 01:47:24 +00:00
|
|
|
};
|
|
|
|
|
2007-06-29 13:23:13 +00:00
|
|
|
static int qemudDomainSave(virDomainPtr dom,
|
Compressed save image format for Qemu.
Implement a compressed save image format for qemu. While ideally
we would have the choice between compressed/non-compressed
available to the libvirt API, unfortunately there is no "flags"
parameter to the virDomainSave() API. Therefore, implement this
as a qemu.conf option. gzip, bzip2, and lzma are implemented, and
it should be very easy to implement additional compression
methods.
One open question is if/how we should detect the compression
binaries. One way to do it is to do compile-time setting of the
paths (via configure.in), but that doesn't seem like a great thing
to do. My preferred solution is not to detect at all;
when we go to run the commands that need them, if they
aren't available, or aren't available in one of the standard paths,
then we'll fail. That's also the solution implemented in this patch.
In the future, we'll have a more robust (managed) save/restore API,
at which time we can expose this functionality properly in the API.
V2: get rid of redundant dd command and just use >> to append data.
V3: Add back the missing pieces for the enum and bumping the save version.
V4: Make the compressed field in the save_header an int.
Implement LZMA compression.
Signed-off-by: Chris Lalancette <clalance@redhat.com>
2009-08-07 11:34:05 +00:00
|
|
|
const char *path)
|
|
|
|
{
|
2008-12-04 21:04:30 +00:00
|
|
|
struct qemud_driver *driver = dom->conn->privateData;
|
2009-09-02 13:02:06 +00:00
|
|
|
virDomainObjPtr vm = NULL;
|
2008-12-04 21:04:30 +00:00
|
|
|
int fd = -1;
|
|
|
|
char *xml = NULL;
|
2007-08-14 01:47:24 +00:00
|
|
|
struct qemud_save_header header;
|
2008-12-04 21:04:30 +00:00
|
|
|
int ret = -1;
|
2009-11-11 12:07:00 +00:00
|
|
|
int rc;
|
2008-12-04 21:09:20 +00:00
|
|
|
virDomainEventPtr event = NULL;
|
2007-08-14 01:47:24 +00:00
|
|
|
|
|
|
|
memset(&header, 0, sizeof(header));
|
|
|
|
memcpy(header.magic, QEMUD_SAVE_MAGIC, sizeof(header.magic));
|
|
|
|
header.version = QEMUD_SAVE_VERSION;
|
|
|
|
|
2009-09-02 13:02:06 +00:00
|
|
|
qemuDriverLock(driver);
|
Compressed save image format for Qemu.
Implement a compressed save image format for qemu. While ideally
we would have the choice between compressed/non-compressed
available to the libvirt API, unfortunately there is no "flags"
parameter to the virDomainSave() API. Therefore, implement this
as a qemu.conf option. gzip, bzip2, and lzma are implemented, and
it should be very easy to implement additional compression
methods.
One open question is if/how we should detect the compression
binaries. One way to do it is to do compile-time setting of the
paths (via configure.in), but that doesn't seem like a great thing
to do. My preferred solution is not to detect at all;
when we go to run the commands that need them, if they
aren't available, or aren't available in one of the standard paths,
then we'll fail. That's also the solution implemented in this patch.
In the future, we'll have a more robust (managed) save/restore API,
at which time we can expose this functionality properly in the API.
V2: get rid of redundant dd command and just use >> to append data.
V3: Add back the missing pieces for the enum and bumping the save version.
V4: Make the compressed field in the save_header an int.
Implement LZMA compression.
Signed-off-by: Chris Lalancette <clalance@redhat.com>
2009-08-07 11:34:05 +00:00
|
|
|
if (driver->saveImageFormat == NULL)
|
|
|
|
header.compressed = QEMUD_SAVE_FORMAT_RAW;
|
|
|
|
else {
|
2009-09-09 08:10:38 +00:00
|
|
|
header.compressed =
|
|
|
|
qemudSaveCompressionTypeFromString(driver->saveImageFormat);
|
|
|
|
if (header.compressed < 0) {
|
|
|
|
qemudReportError(dom->conn, dom, NULL, VIR_ERR_OPERATION_FAILED,
|
|
|
|
"%s", _("Invalid save image format specified "
|
|
|
|
"in configuration file"));
|
2009-09-02 13:02:06 +00:00
|
|
|
goto cleanup;
|
2009-09-09 08:10:38 +00:00
|
|
|
}
|
Compressed save image format for Qemu.
Implement a compressed save image format for qemu. While ideally
we would have the choice between compressed/non-compressed
available to the libvirt API, unfortunately there is no "flags"
parameter to the virDomainSave() API. Therefore, implement this
as a qemu.conf option. gzip, bzip2, and lzma are implemented, and
it should be very easy to implement additional compression
methods.
One open question is if/how we should detect the compression
binaries. One way to do it is to do compile-time setting of the
paths (via configure.in), but that doesn't seem like a great thing
to do. My preferred solution is not to detect at all;
when we go to run the commands that need them, if they
aren't available, or aren't available in one of the standard paths,
then we'll fail. That's also the solution implemented in this patch.
In the future, we'll have a more robust (managed) save/restore API,
at which time we can expose this functionality properly in the API.
V2: get rid of redundant dd command and just use >> to append data.
V3: Add back the missing pieces for the enum and bumping the save version.
V4: Make the compressed field in the save_header an int.
Implement LZMA compression.
Signed-off-by: Chris Lalancette <clalance@redhat.com>
2009-08-07 11:34:05 +00:00
|
|
|
}
|
|
|
|
|
2009-04-19 15:30:50 +00:00
|
|
|
vm = virDomainFindByUUID(&driver->domains, dom->uuid);
|
2008-12-04 21:04:30 +00:00
|
|
|
|
2007-02-14 01:40:09 +00:00
|
|
|
if (!vm) {
|
2009-04-19 15:30:50 +00:00
|
|
|
char uuidstr[VIR_UUID_STRING_BUFLEN];
|
|
|
|
virUUIDFormat(dom->uuid, uuidstr);
|
|
|
|
qemudReportError(dom->conn, dom, NULL, VIR_ERR_NO_DOMAIN,
|
|
|
|
_("no domain with matching uuid '%s'"), uuidstr);
|
2008-12-04 21:04:30 +00:00
|
|
|
goto cleanup;
|
2007-02-14 01:40:09 +00:00
|
|
|
}
|
2007-08-14 01:47:24 +00:00
|
|
|
|
2009-11-03 18:26:32 +00:00
|
|
|
if (qemuDomainObjBeginJobWithDriver(driver, vm) < 0)
|
|
|
|
goto cleanup;
|
|
|
|
|
Rename internal APis
Rename virDomainIsActive to virDomainObjIsActive, and
virInterfaceIsActive to virInterfaceObjIsActive and finally
virNetworkIsActive to virNetworkObjIsActive.
* src/conf/domain_conf.c, src/conf/domain_conf.h,
src/conf/interface_conf.h, src/conf/network_conf.c,
src/conf/network_conf.h, src/lxc/lxc_driver.c,
src/network/bridge_driver.c, src/opennebula/one_driver.c,
src/openvz/openvz_driver.c, src/qemu/qemu_driver.c,
src/test/test_driver.c, src/uml/uml_driver.c: Update for
renamed APIs.
2009-10-20 14:51:03 +00:00
|
|
|
if (!virDomainObjIsActive(vm)) {
|
2009-05-08 09:58:46 +00:00
|
|
|
qemudReportError(dom->conn, dom, NULL, VIR_ERR_OPERATION_INVALID,
|
Mark many more strings for translation.
* Makefile.maint (err_func_re): Add to the list and make it readable.
* po/POTFILES.in: Add src/util.c and src/xm_internal.c, and sort.
* src/storage_backend.c: Fix comment.
* src/util.c (virFileLinkPointsTo): Mark a string.
* qemud/remote.c (remoteDispatchClientRequest): Mark strings.
(remoteDispatchOpen, CHECK_CONN, remoteDispatchGetType): Likewise.
(remoteDispatchDomainGetSchedulerType): Likewise.
(remoteDispatchDomainGetSchedulerParameters): Likewise.
(remoteDispatchDomainSetSchedulerParameters): Likewise.
(remoteDispatchDomainBlockStats): Likewise.
(remoteDispatchDomainInterfaceStats): Likewise.
(remoteDispatchDomainAttachDevice, remoteDispatchDomainCreate):
(remoteDispatchDomainDestroy, remoteDispatchDomainDetachDevice):
(remoteDispatchDomainDumpXml, remoteDispatchDomainGetAutostart):
(remoteDispatchDomainGetInfo, remoteDispatchDomainGetMaxMemory):
(remoteDispatchDomainGetMaxVcpus, remoteDispatchDomainGetOsType):
(remoteDispatchDomainGetVcpus): Likewise.
(remoteDispatchDomainMigratePerform): Likewise.
(remoteDispatchListDefinedDomains, remoteDispatchDomainPinVcpu):
(remoteDispatchDomainReboot, remoteDispatchDomainResume):
(remoteDispatchDomainSave, remoteDispatchDomainCoreDump):
(remoteDispatchDomainSetAutostart): Likewise.
(remoteDispatchDomainSetMaxMemory, remoteDispatchDomainSetMemory):
(remoteDispatchDomainSetVcpus, remoteDispatchDomainShutdown):
(remoteDispatchDomainSuspend, remoteDispatchDomainUndefine):
(remoteDispatchListDefinedNetworks, remoteDispatchListDomains):
(remoteDispatchListNetworks, remoteDispatchNetworkCreate):
(remoteDispatchNetworkDestroy, remoteDispatchNetworkDumpXml):
(remoteDispatchNetworkGetAutostart, remoteDispatchNetworkGetBridgeName):
(remoteDispatchNetworkSetAutostart, remoteDispatchNetworkUndefine):
(addrToString, remoteDispatchAuthSaslInit, remoteDispatchAuthSaslStart):
(remoteDispatchAuthSaslStep, remoteDispatchListDefinedStoragePools):
(remoteDispatchListStoragePools, remoteDispatchStoragePoolCreate):
(remoteDispatchStoragePoolBuild, remoteDispatchStoragePoolDestroy):
(remoteDispatchStoragePoolDelete, remoteDispatchStoragePoolRefresh):
(remoteDispatchStoragePoolGetInfo, remoteDispatchStoragePoolDumpXml):
(remoteDispatchStoragePoolGetAutostart): Likewise.
(remoteDispatchStoragePoolSetAutostart):
(remoteDispatchStoragePoolListVolumes):
(remoteDispatchStoragePoolNumOfVolumes):
(remoteDispatchStoragePoolUndefine, remoteDispatchStorageVolCreateXml):
(remoteDispatchStorageVolDelete, remoteDispatchStorageVolGetInfo):
(remoteDispatchStorageVolDumpXml, remoteDispatchStorageVolGetPath):
(remoteDispatchStorageVolLookupByName): Likewise.
* src/qemu_driver.c (qemudOpenMonitor, qemudStartVMDaemon):
(dhcpStartDhcpDaemon, qemudStartNetworkDaemon):
(qemudDomainSuspend, qemudDomainResume, qemudDomainShutdown):
(qemudDomainGetOSType, qemudDomainSetMaxMemory):
(qemudDomainSetMemory, qemudDomainGetInfo, qemudDomainSave):
(qemudDomainRestore, qemudDomainDumpXML, qemudDomainStart):
(qemudDomainUndefine, qemudDomainChangeCDROM):
(qemudDomainAttachDevice, qemudDomainGetAutostart):
(qemudDomainSetAutostart, qemudDomainInterfaceStats):
(qemudNetworkLookupByUUID, qemudNetworkLookupByName):
(qemudNetworkUndefine, qemudNetworkStart, qemudNetworkDestroy):
(qemudNetworkDumpXML, qemudNetworkGetAutostart):
(qemudNetworkSetAutostart): Likewise.
* src/virsh.c (cmdVcpupin, cmdAttachDevice, cmdDetachDevice): Likewise.
* src/xm_internal.c (xenXMConfigCacheRefresh, xenXMDomainPinVcpu): Likewise.
2008-03-27 13:43:01 +00:00
|
|
|
"%s", _("domain is not running"));
|
2009-11-03 18:26:32 +00:00
|
|
|
goto endjob;
|
2007-02-14 01:40:09 +00:00
|
|
|
}
|
2007-08-14 01:47:24 +00:00
|
|
|
|
|
|
|
/* Pause */
|
|
|
|
if (vm->state == VIR_DOMAIN_RUNNING) {
|
2009-10-09 20:13:06 +00:00
|
|
|
qemuDomainObjPrivatePtr priv = vm->privateData;
|
2007-08-14 01:47:24 +00:00
|
|
|
header.was_running = 1;
|
2009-11-03 18:26:32 +00:00
|
|
|
qemuDomainObjEnterMonitorWithDriver(driver, vm);
|
2009-10-13 14:27:58 +00:00
|
|
|
if (qemuMonitorStopCPUs(priv->mon) < 0) {
|
2009-11-03 18:26:32 +00:00
|
|
|
qemuDomainObjExitMonitorWithDriver(driver, vm);
|
|
|
|
goto endjob;
|
2009-10-13 14:27:58 +00:00
|
|
|
}
|
2009-11-03 18:26:32 +00:00
|
|
|
qemuDomainObjExitMonitorWithDriver(driver, vm);
|
2009-01-29 17:27:54 +00:00
|
|
|
vm->state = VIR_DOMAIN_PAUSED;
|
2007-08-14 01:47:24 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
/* Get XML for the domain */
|
2008-07-11 19:34:11 +00:00
|
|
|
xml = virDomainDefFormat(dom->conn, vm->def, VIR_DOMAIN_XML_SECURE);
|
2007-08-14 01:47:24 +00:00
|
|
|
if (!xml) {
|
|
|
|
qemudReportError(dom->conn, dom, NULL, VIR_ERR_OPERATION_FAILED,
|
Mark many more strings for translation.
* Makefile.maint (err_func_re): Add to the list and make it readable.
* po/POTFILES.in: Add src/util.c and src/xm_internal.c, and sort.
* src/storage_backend.c: Fix comment.
* src/util.c (virFileLinkPointsTo): Mark a string.
* qemud/remote.c (remoteDispatchClientRequest): Mark strings.
(remoteDispatchOpen, CHECK_CONN, remoteDispatchGetType): Likewise.
(remoteDispatchDomainGetSchedulerType): Likewise.
(remoteDispatchDomainGetSchedulerParameters): Likewise.
(remoteDispatchDomainSetSchedulerParameters): Likewise.
(remoteDispatchDomainBlockStats): Likewise.
(remoteDispatchDomainInterfaceStats): Likewise.
(remoteDispatchDomainAttachDevice, remoteDispatchDomainCreate):
(remoteDispatchDomainDestroy, remoteDispatchDomainDetachDevice):
(remoteDispatchDomainDumpXml, remoteDispatchDomainGetAutostart):
(remoteDispatchDomainGetInfo, remoteDispatchDomainGetMaxMemory):
(remoteDispatchDomainGetMaxVcpus, remoteDispatchDomainGetOsType):
(remoteDispatchDomainGetVcpus): Likewise.
(remoteDispatchDomainMigratePerform): Likewise.
(remoteDispatchListDefinedDomains, remoteDispatchDomainPinVcpu):
(remoteDispatchDomainReboot, remoteDispatchDomainResume):
(remoteDispatchDomainSave, remoteDispatchDomainCoreDump):
(remoteDispatchDomainSetAutostart): Likewise.
(remoteDispatchDomainSetMaxMemory, remoteDispatchDomainSetMemory):
(remoteDispatchDomainSetVcpus, remoteDispatchDomainShutdown):
(remoteDispatchDomainSuspend, remoteDispatchDomainUndefine):
(remoteDispatchListDefinedNetworks, remoteDispatchListDomains):
(remoteDispatchListNetworks, remoteDispatchNetworkCreate):
(remoteDispatchNetworkDestroy, remoteDispatchNetworkDumpXml):
(remoteDispatchNetworkGetAutostart, remoteDispatchNetworkGetBridgeName):
(remoteDispatchNetworkSetAutostart, remoteDispatchNetworkUndefine):
(addrToString, remoteDispatchAuthSaslInit, remoteDispatchAuthSaslStart):
(remoteDispatchAuthSaslStep, remoteDispatchListDefinedStoragePools):
(remoteDispatchListStoragePools, remoteDispatchStoragePoolCreate):
(remoteDispatchStoragePoolBuild, remoteDispatchStoragePoolDestroy):
(remoteDispatchStoragePoolDelete, remoteDispatchStoragePoolRefresh):
(remoteDispatchStoragePoolGetInfo, remoteDispatchStoragePoolDumpXml):
(remoteDispatchStoragePoolGetAutostart): Likewise.
(remoteDispatchStoragePoolSetAutostart):
(remoteDispatchStoragePoolListVolumes):
(remoteDispatchStoragePoolNumOfVolumes):
(remoteDispatchStoragePoolUndefine, remoteDispatchStorageVolCreateXml):
(remoteDispatchStorageVolDelete, remoteDispatchStorageVolGetInfo):
(remoteDispatchStorageVolDumpXml, remoteDispatchStorageVolGetPath):
(remoteDispatchStorageVolLookupByName): Likewise.
* src/qemu_driver.c (qemudOpenMonitor, qemudStartVMDaemon):
(dhcpStartDhcpDaemon, qemudStartNetworkDaemon):
(qemudDomainSuspend, qemudDomainResume, qemudDomainShutdown):
(qemudDomainGetOSType, qemudDomainSetMaxMemory):
(qemudDomainSetMemory, qemudDomainGetInfo, qemudDomainSave):
(qemudDomainRestore, qemudDomainDumpXML, qemudDomainStart):
(qemudDomainUndefine, qemudDomainChangeCDROM):
(qemudDomainAttachDevice, qemudDomainGetAutostart):
(qemudDomainSetAutostart, qemudDomainInterfaceStats):
(qemudNetworkLookupByUUID, qemudNetworkLookupByName):
(qemudNetworkUndefine, qemudNetworkStart, qemudNetworkDestroy):
(qemudNetworkDumpXML, qemudNetworkGetAutostart):
(qemudNetworkSetAutostart): Likewise.
* src/virsh.c (cmdVcpupin, cmdAttachDevice, cmdDetachDevice): Likewise.
* src/xm_internal.c (xenXMConfigCacheRefresh, xenXMDomainPinVcpu): Likewise.
2008-03-27 13:43:01 +00:00
|
|
|
"%s", _("failed to get domain xml"));
|
2009-11-03 18:26:32 +00:00
|
|
|
goto endjob;
|
2007-08-14 01:47:24 +00:00
|
|
|
}
|
|
|
|
header.xml_len = strlen(xml) + 1;
|
|
|
|
|
|
|
|
/* Write header to file, followed by XML */
|
|
|
|
if ((fd = open(path, O_CREAT|O_TRUNC|O_WRONLY, S_IRUSR|S_IWUSR)) < 0) {
|
|
|
|
qemudReportError(dom->conn, dom, NULL, VIR_ERR_OPERATION_FAILED,
|
2008-03-24 10:51:47 +00:00
|
|
|
_("failed to create '%s'"), path);
|
2009-11-03 18:26:32 +00:00
|
|
|
goto endjob;
|
2007-08-14 01:47:24 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
if (safewrite(fd, &header, sizeof(header)) != sizeof(header)) {
|
|
|
|
qemudReportError(dom->conn, dom, NULL, VIR_ERR_OPERATION_FAILED,
|
Mark many more strings for translation.
* Makefile.maint (err_func_re): Add to the list and make it readable.
* po/POTFILES.in: Add src/util.c and src/xm_internal.c, and sort.
* src/storage_backend.c: Fix comment.
* src/util.c (virFileLinkPointsTo): Mark a string.
* qemud/remote.c (remoteDispatchClientRequest): Mark strings.
(remoteDispatchOpen, CHECK_CONN, remoteDispatchGetType): Likewise.
(remoteDispatchDomainGetSchedulerType): Likewise.
(remoteDispatchDomainGetSchedulerParameters): Likewise.
(remoteDispatchDomainSetSchedulerParameters): Likewise.
(remoteDispatchDomainBlockStats): Likewise.
(remoteDispatchDomainInterfaceStats): Likewise.
(remoteDispatchDomainAttachDevice, remoteDispatchDomainCreate):
(remoteDispatchDomainDestroy, remoteDispatchDomainDetachDevice):
(remoteDispatchDomainDumpXml, remoteDispatchDomainGetAutostart):
(remoteDispatchDomainGetInfo, remoteDispatchDomainGetMaxMemory):
(remoteDispatchDomainGetMaxVcpus, remoteDispatchDomainGetOsType):
(remoteDispatchDomainGetVcpus): Likewise.
(remoteDispatchDomainMigratePerform): Likewise.
(remoteDispatchListDefinedDomains, remoteDispatchDomainPinVcpu):
(remoteDispatchDomainReboot, remoteDispatchDomainResume):
(remoteDispatchDomainSave, remoteDispatchDomainCoreDump):
(remoteDispatchDomainSetAutostart): Likewise.
(remoteDispatchDomainSetMaxMemory, remoteDispatchDomainSetMemory):
(remoteDispatchDomainSetVcpus, remoteDispatchDomainShutdown):
(remoteDispatchDomainSuspend, remoteDispatchDomainUndefine):
(remoteDispatchListDefinedNetworks, remoteDispatchListDomains):
(remoteDispatchListNetworks, remoteDispatchNetworkCreate):
(remoteDispatchNetworkDestroy, remoteDispatchNetworkDumpXml):
(remoteDispatchNetworkGetAutostart, remoteDispatchNetworkGetBridgeName):
(remoteDispatchNetworkSetAutostart, remoteDispatchNetworkUndefine):
(addrToString, remoteDispatchAuthSaslInit, remoteDispatchAuthSaslStart):
(remoteDispatchAuthSaslStep, remoteDispatchListDefinedStoragePools):
(remoteDispatchListStoragePools, remoteDispatchStoragePoolCreate):
(remoteDispatchStoragePoolBuild, remoteDispatchStoragePoolDestroy):
(remoteDispatchStoragePoolDelete, remoteDispatchStoragePoolRefresh):
(remoteDispatchStoragePoolGetInfo, remoteDispatchStoragePoolDumpXml):
(remoteDispatchStoragePoolGetAutostart): Likewise.
(remoteDispatchStoragePoolSetAutostart):
(remoteDispatchStoragePoolListVolumes):
(remoteDispatchStoragePoolNumOfVolumes):
(remoteDispatchStoragePoolUndefine, remoteDispatchStorageVolCreateXml):
(remoteDispatchStorageVolDelete, remoteDispatchStorageVolGetInfo):
(remoteDispatchStorageVolDumpXml, remoteDispatchStorageVolGetPath):
(remoteDispatchStorageVolLookupByName): Likewise.
* src/qemu_driver.c (qemudOpenMonitor, qemudStartVMDaemon):
(dhcpStartDhcpDaemon, qemudStartNetworkDaemon):
(qemudDomainSuspend, qemudDomainResume, qemudDomainShutdown):
(qemudDomainGetOSType, qemudDomainSetMaxMemory):
(qemudDomainSetMemory, qemudDomainGetInfo, qemudDomainSave):
(qemudDomainRestore, qemudDomainDumpXML, qemudDomainStart):
(qemudDomainUndefine, qemudDomainChangeCDROM):
(qemudDomainAttachDevice, qemudDomainGetAutostart):
(qemudDomainSetAutostart, qemudDomainInterfaceStats):
(qemudNetworkLookupByUUID, qemudNetworkLookupByName):
(qemudNetworkUndefine, qemudNetworkStart, qemudNetworkDestroy):
(qemudNetworkDumpXML, qemudNetworkGetAutostart):
(qemudNetworkSetAutostart): Likewise.
* src/virsh.c (cmdVcpupin, cmdAttachDevice, cmdDetachDevice): Likewise.
* src/xm_internal.c (xenXMConfigCacheRefresh, xenXMDomainPinVcpu): Likewise.
2008-03-27 13:43:01 +00:00
|
|
|
"%s", _("failed to write save header"));
|
2009-11-03 18:26:32 +00:00
|
|
|
goto endjob;
|
2007-08-14 01:47:24 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
if (safewrite(fd, xml, header.xml_len) != header.xml_len) {
|
|
|
|
qemudReportError(dom->conn, dom, NULL, VIR_ERR_OPERATION_FAILED,
|
Mark many more strings for translation.
* Makefile.maint (err_func_re): Add to the list and make it readable.
* po/POTFILES.in: Add src/util.c and src/xm_internal.c, and sort.
* src/storage_backend.c: Fix comment.
* src/util.c (virFileLinkPointsTo): Mark a string.
* qemud/remote.c (remoteDispatchClientRequest): Mark strings.
(remoteDispatchOpen, CHECK_CONN, remoteDispatchGetType): Likewise.
(remoteDispatchDomainGetSchedulerType): Likewise.
(remoteDispatchDomainGetSchedulerParameters): Likewise.
(remoteDispatchDomainSetSchedulerParameters): Likewise.
(remoteDispatchDomainBlockStats): Likewise.
(remoteDispatchDomainInterfaceStats): Likewise.
(remoteDispatchDomainAttachDevice, remoteDispatchDomainCreate):
(remoteDispatchDomainDestroy, remoteDispatchDomainDetachDevice):
(remoteDispatchDomainDumpXml, remoteDispatchDomainGetAutostart):
(remoteDispatchDomainGetInfo, remoteDispatchDomainGetMaxMemory):
(remoteDispatchDomainGetMaxVcpus, remoteDispatchDomainGetOsType):
(remoteDispatchDomainGetVcpus): Likewise.
(remoteDispatchDomainMigratePerform): Likewise.
(remoteDispatchListDefinedDomains, remoteDispatchDomainPinVcpu):
(remoteDispatchDomainReboot, remoteDispatchDomainResume):
(remoteDispatchDomainSave, remoteDispatchDomainCoreDump):
(remoteDispatchDomainSetAutostart): Likewise.
(remoteDispatchDomainSetMaxMemory, remoteDispatchDomainSetMemory):
(remoteDispatchDomainSetVcpus, remoteDispatchDomainShutdown):
(remoteDispatchDomainSuspend, remoteDispatchDomainUndefine):
(remoteDispatchListDefinedNetworks, remoteDispatchListDomains):
(remoteDispatchListNetworks, remoteDispatchNetworkCreate):
(remoteDispatchNetworkDestroy, remoteDispatchNetworkDumpXml):
(remoteDispatchNetworkGetAutostart, remoteDispatchNetworkGetBridgeName):
(remoteDispatchNetworkSetAutostart, remoteDispatchNetworkUndefine):
(addrToString, remoteDispatchAuthSaslInit, remoteDispatchAuthSaslStart):
(remoteDispatchAuthSaslStep, remoteDispatchListDefinedStoragePools):
(remoteDispatchListStoragePools, remoteDispatchStoragePoolCreate):
(remoteDispatchStoragePoolBuild, remoteDispatchStoragePoolDestroy):
(remoteDispatchStoragePoolDelete, remoteDispatchStoragePoolRefresh):
(remoteDispatchStoragePoolGetInfo, remoteDispatchStoragePoolDumpXml):
(remoteDispatchStoragePoolGetAutostart): Likewise.
(remoteDispatchStoragePoolSetAutostart):
(remoteDispatchStoragePoolListVolumes):
(remoteDispatchStoragePoolNumOfVolumes):
(remoteDispatchStoragePoolUndefine, remoteDispatchStorageVolCreateXml):
(remoteDispatchStorageVolDelete, remoteDispatchStorageVolGetInfo):
(remoteDispatchStorageVolDumpXml, remoteDispatchStorageVolGetPath):
(remoteDispatchStorageVolLookupByName): Likewise.
* src/qemu_driver.c (qemudOpenMonitor, qemudStartVMDaemon):
(dhcpStartDhcpDaemon, qemudStartNetworkDaemon):
(qemudDomainSuspend, qemudDomainResume, qemudDomainShutdown):
(qemudDomainGetOSType, qemudDomainSetMaxMemory):
(qemudDomainSetMemory, qemudDomainGetInfo, qemudDomainSave):
(qemudDomainRestore, qemudDomainDumpXML, qemudDomainStart):
(qemudDomainUndefine, qemudDomainChangeCDROM):
(qemudDomainAttachDevice, qemudDomainGetAutostart):
(qemudDomainSetAutostart, qemudDomainInterfaceStats):
(qemudNetworkLookupByUUID, qemudNetworkLookupByName):
(qemudNetworkUndefine, qemudNetworkStart, qemudNetworkDestroy):
(qemudNetworkDumpXML, qemudNetworkGetAutostart):
(qemudNetworkSetAutostart): Likewise.
* src/virsh.c (cmdVcpupin, cmdAttachDevice, cmdDetachDevice): Likewise.
* src/xm_internal.c (xenXMConfigCacheRefresh, xenXMDomainPinVcpu): Likewise.
2008-03-27 13:43:01 +00:00
|
|
|
"%s", _("failed to write xml"));
|
2009-11-03 18:26:32 +00:00
|
|
|
goto endjob;
|
2007-08-14 01:47:24 +00:00
|
|
|
}
|
|
|
|
|
2008-12-04 21:04:30 +00:00
|
|
|
if (close(fd) < 0) {
|
2009-01-20 17:13:33 +00:00
|
|
|
virReportSystemError(dom->conn, errno,
|
|
|
|
_("unable to save file %s"),
|
|
|
|
path);
|
2009-11-03 18:26:32 +00:00
|
|
|
goto endjob;
|
2008-12-04 21:04:30 +00:00
|
|
|
}
|
|
|
|
fd = -1;
|
2007-08-14 01:47:24 +00:00
|
|
|
|
2009-11-11 12:07:00 +00:00
|
|
|
if (driver->securityDriver &&
|
|
|
|
driver->securityDriver->domainSetSavedStateLabel &&
|
|
|
|
driver->securityDriver->domainSetSavedStateLabel(dom->conn, vm, path) == -1)
|
|
|
|
goto endjob;
|
|
|
|
|
2009-09-23 14:23:47 +00:00
|
|
|
if (header.compressed == QEMUD_SAVE_FORMAT_RAW) {
|
|
|
|
const char *args[] = { "cat", NULL };
|
2009-10-09 20:13:06 +00:00
|
|
|
qemuDomainObjPrivatePtr priv = vm->privateData;
|
2009-12-02 23:03:06 +00:00
|
|
|
qemuDomainObjEnterMonitorWithDriver(driver, vm);
|
2009-11-11 12:07:00 +00:00
|
|
|
rc = qemuMonitorMigrateToCommand(priv->mon, 0, args, path);
|
2009-12-02 23:03:06 +00:00
|
|
|
qemuDomainObjExitMonitorWithDriver(driver, vm);
|
2009-09-23 14:23:47 +00:00
|
|
|
} else {
|
2009-09-22 06:56:39 +00:00
|
|
|
const char *prog = qemudSaveCompressionTypeToString(header.compressed);
|
2009-10-09 20:13:06 +00:00
|
|
|
qemuDomainObjPrivatePtr priv = vm->privateData;
|
2009-09-23 14:23:47 +00:00
|
|
|
const char *args[] = {
|
|
|
|
prog,
|
|
|
|
"-c",
|
|
|
|
NULL
|
|
|
|
};
|
2009-12-02 23:03:06 +00:00
|
|
|
qemuDomainObjEnterMonitorWithDriver(driver, vm);
|
2009-11-11 12:07:00 +00:00
|
|
|
rc = qemuMonitorMigrateToCommand(priv->mon, 0, args, path);
|
2009-12-02 23:03:06 +00:00
|
|
|
qemuDomainObjExitMonitorWithDriver(driver, vm);
|
2007-08-14 01:47:24 +00:00
|
|
|
}
|
|
|
|
|
2009-11-11 12:07:00 +00:00
|
|
|
if (rc < 0)
|
2009-11-03 18:26:32 +00:00
|
|
|
goto endjob;
|
2008-07-24 07:09:45 +00:00
|
|
|
|
2009-11-11 12:07:00 +00:00
|
|
|
if (driver->securityDriver &&
|
|
|
|
driver->securityDriver->domainRestoreSavedStateLabel &&
|
2010-01-13 14:03:04 +00:00
|
|
|
driver->securityDriver->domainRestoreSavedStateLabel(dom->conn, vm, path) == -1)
|
2009-11-11 12:07:00 +00:00
|
|
|
goto endjob;
|
|
|
|
|
|
|
|
ret = 0;
|
|
|
|
|
2007-08-14 01:47:24 +00:00
|
|
|
/* Shut it down */
|
|
|
|
qemudShutdownVMDaemon(dom->conn, driver, vm);
|
2008-12-04 21:09:20 +00:00
|
|
|
event = virDomainEventNewFromObj(vm,
|
|
|
|
VIR_DOMAIN_EVENT_STOPPED,
|
|
|
|
VIR_DOMAIN_EVENT_STOPPED_SAVED);
|
2008-12-04 21:06:41 +00:00
|
|
|
if (!vm->persistent) {
|
2009-12-08 14:42:43 +00:00
|
|
|
if (qemuDomainObjEndJob(vm) > 0)
|
|
|
|
virDomainRemoveInactive(&driver->domains,
|
|
|
|
vm);
|
2008-12-04 21:06:41 +00:00
|
|
|
vm = NULL;
|
|
|
|
}
|
2008-12-04 21:04:30 +00:00
|
|
|
|
2009-11-03 18:26:32 +00:00
|
|
|
endjob:
|
2009-12-08 14:42:43 +00:00
|
|
|
if (vm &&
|
|
|
|
qemuDomainObjEndJob(vm) == 0)
|
|
|
|
vm = NULL;
|
2009-11-03 18:26:32 +00:00
|
|
|
|
2008-12-04 21:04:30 +00:00
|
|
|
cleanup:
|
|
|
|
if (fd != -1)
|
|
|
|
close(fd);
|
|
|
|
VIR_FREE(xml);
|
|
|
|
if (ret != 0)
|
|
|
|
unlink(path);
|
2008-12-04 21:06:41 +00:00
|
|
|
if (vm)
|
|
|
|
virDomainObjUnlock(vm);
|
2008-12-04 21:09:20 +00:00
|
|
|
if (event)
|
|
|
|
qemuDomainEventQueue(driver, event);
|
2008-12-04 21:06:41 +00:00
|
|
|
qemuDriverUnlock(driver);
|
2008-12-04 21:04:30 +00:00
|
|
|
return ret;
|
2007-02-14 01:40:09 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
|
2009-07-16 14:50:23 +00:00
|
|
|
static int qemudDomainCoreDump(virDomainPtr dom,
|
|
|
|
const char *path,
|
|
|
|
int flags ATTRIBUTE_UNUSED) {
|
|
|
|
struct qemud_driver *driver = dom->conn->privateData;
|
|
|
|
virDomainObjPtr vm;
|
|
|
|
int resume = 0, paused = 0;
|
2009-12-14 10:27:41 +00:00
|
|
|
int ret = -1, fd = -1;
|
2009-12-14 10:59:27 +00:00
|
|
|
virDomainEventPtr event = NULL;
|
2009-09-23 14:23:47 +00:00
|
|
|
const char *args[] = {
|
|
|
|
"cat",
|
|
|
|
NULL,
|
|
|
|
};
|
2009-07-16 14:50:23 +00:00
|
|
|
|
|
|
|
qemuDriverLock(driver);
|
|
|
|
vm = virDomainFindByUUID(&driver->domains, dom->uuid);
|
|
|
|
qemuDriverUnlock(driver);
|
|
|
|
|
|
|
|
if (!vm) {
|
|
|
|
char uuidstr[VIR_UUID_STRING_BUFLEN];
|
|
|
|
virUUIDFormat(dom->uuid, uuidstr);
|
|
|
|
qemudReportError(dom->conn, dom, NULL, VIR_ERR_NO_DOMAIN,
|
|
|
|
_("no domain with matching uuid '%s'"), uuidstr);
|
|
|
|
goto cleanup;
|
|
|
|
}
|
|
|
|
|
2009-11-03 18:26:32 +00:00
|
|
|
if (qemuDomainObjBeginJob(vm) < 0)
|
|
|
|
goto cleanup;
|
|
|
|
|
Rename internal APis
Rename virDomainIsActive to virDomainObjIsActive, and
virInterfaceIsActive to virInterfaceObjIsActive and finally
virNetworkIsActive to virNetworkObjIsActive.
* src/conf/domain_conf.c, src/conf/domain_conf.h,
src/conf/interface_conf.h, src/conf/network_conf.c,
src/conf/network_conf.h, src/lxc/lxc_driver.c,
src/network/bridge_driver.c, src/opennebula/one_driver.c,
src/openvz/openvz_driver.c, src/qemu/qemu_driver.c,
src/test/test_driver.c, src/uml/uml_driver.c: Update for
renamed APIs.
2009-10-20 14:51:03 +00:00
|
|
|
if (!virDomainObjIsActive(vm)) {
|
2009-07-16 14:50:23 +00:00
|
|
|
qemudReportError(dom->conn, dom, NULL, VIR_ERR_OPERATION_INVALID,
|
|
|
|
"%s", _("domain is not running"));
|
2009-11-03 18:26:32 +00:00
|
|
|
goto endjob;
|
2009-07-16 14:50:23 +00:00
|
|
|
}
|
|
|
|
|
2009-12-14 10:27:41 +00:00
|
|
|
/* Create an empty file with appropriate ownership. */
|
|
|
|
if ((fd = open(path, O_CREAT|O_TRUNC|O_WRONLY, S_IRUSR|S_IWUSR)) < 0) {
|
|
|
|
qemudReportError(dom->conn, dom, NULL, VIR_ERR_OPERATION_FAILED,
|
|
|
|
_("failed to create '%s'"), path);
|
|
|
|
goto endjob;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (close(fd) < 0) {
|
|
|
|
virReportSystemError(dom->conn, errno,
|
|
|
|
_("unable to save file %s"),
|
|
|
|
path);
|
|
|
|
goto endjob;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (driver->securityDriver &&
|
|
|
|
driver->securityDriver->domainSetSavedStateLabel &&
|
|
|
|
driver->securityDriver->domainSetSavedStateLabel(dom->conn, vm, path) == -1)
|
|
|
|
goto endjob;
|
|
|
|
|
2009-12-14 11:10:38 +00:00
|
|
|
/* Migrate will always stop the VM, so the resume condition is
|
|
|
|
independent of whether the stop command is issued. */
|
2009-07-16 14:50:23 +00:00
|
|
|
resume = (vm->state == VIR_DOMAIN_RUNNING);
|
|
|
|
|
2009-10-09 20:13:06 +00:00
|
|
|
qemuDomainObjPrivatePtr priv = vm->privateData;
|
|
|
|
|
2009-07-16 14:50:23 +00:00
|
|
|
/* Pause domain for non-live dump */
|
2009-12-14 11:10:38 +00:00
|
|
|
if (!(flags & VIR_DUMP_LIVE) && vm->state == VIR_DOMAIN_RUNNING) {
|
2009-10-13 14:27:58 +00:00
|
|
|
qemuDomainObjEnterMonitor(vm);
|
|
|
|
if (qemuMonitorStopCPUs(priv->mon) < 0) {
|
|
|
|
qemuDomainObjExitMonitor(vm);
|
2009-11-03 18:26:32 +00:00
|
|
|
goto endjob;
|
2009-10-13 14:27:58 +00:00
|
|
|
}
|
|
|
|
qemuDomainObjExitMonitor(vm);
|
2009-07-16 14:50:23 +00:00
|
|
|
paused = 1;
|
|
|
|
}
|
|
|
|
|
2009-10-13 14:27:58 +00:00
|
|
|
qemuDomainObjEnterMonitor(vm);
|
2009-10-09 20:13:06 +00:00
|
|
|
ret = qemuMonitorMigrateToCommand(priv->mon, 0, args, path);
|
2009-10-13 14:27:58 +00:00
|
|
|
qemuDomainObjExitMonitor(vm);
|
2009-12-14 10:27:41 +00:00
|
|
|
paused |= (ret == 0);
|
|
|
|
|
|
|
|
if (driver->securityDriver &&
|
|
|
|
driver->securityDriver->domainRestoreSavedStateLabel &&
|
2010-01-13 14:03:04 +00:00
|
|
|
driver->securityDriver->domainRestoreSavedStateLabel(dom->conn, vm, path) == -1)
|
2009-12-14 10:27:41 +00:00
|
|
|
goto endjob;
|
|
|
|
|
|
|
|
endjob:
|
2009-12-14 10:59:27 +00:00
|
|
|
if ((ret == 0) && (flags & VIR_DUMP_CRASH)) {
|
|
|
|
qemudShutdownVMDaemon(dom->conn, driver, vm);
|
|
|
|
event = virDomainEventNewFromObj(vm,
|
|
|
|
VIR_DOMAIN_EVENT_STOPPED,
|
|
|
|
VIR_DOMAIN_EVENT_STOPPED_CRASHED);
|
|
|
|
}
|
|
|
|
|
2009-07-16 14:50:23 +00:00
|
|
|
/* Since the monitor is always attached to a pty for libvirt, it
|
|
|
|
will support synchronous operations so we always get here after
|
|
|
|
the migration is complete. */
|
2009-12-14 10:59:27 +00:00
|
|
|
else if (resume && paused) {
|
2009-10-13 14:27:58 +00:00
|
|
|
qemuDomainObjEnterMonitor(vm);
|
2009-10-09 20:13:06 +00:00
|
|
|
if (qemuMonitorStartCPUs(priv->mon, dom->conn) < 0) {
|
2009-07-21 09:53:17 +00:00
|
|
|
if (virGetLastError() == NULL)
|
|
|
|
qemudReportError(dom->conn, dom, NULL, VIR_ERR_OPERATION_FAILED,
|
|
|
|
"%s", _("resuming after dump failed"));
|
2009-07-16 14:50:23 +00:00
|
|
|
}
|
2009-10-13 14:27:58 +00:00
|
|
|
qemuDomainObjExitMonitor(vm);
|
2009-07-16 14:50:23 +00:00
|
|
|
}
|
2009-11-03 18:26:32 +00:00
|
|
|
|
2009-12-08 14:42:43 +00:00
|
|
|
if (qemuDomainObjEndJob(vm) == 0)
|
|
|
|
vm = NULL;
|
2009-12-14 13:09:10 +00:00
|
|
|
else if ((ret == 0) && (flags & VIR_DUMP_CRASH) && !vm->persistent) {
|
2009-12-14 10:59:27 +00:00
|
|
|
virDomainRemoveInactive(&driver->domains,
|
|
|
|
vm);
|
|
|
|
vm = NULL;
|
|
|
|
}
|
2009-11-03 18:26:32 +00:00
|
|
|
|
|
|
|
cleanup:
|
2009-12-14 10:27:41 +00:00
|
|
|
if (ret != 0)
|
|
|
|
unlink(path);
|
2009-07-16 14:50:23 +00:00
|
|
|
if (vm)
|
|
|
|
virDomainObjUnlock(vm);
|
2009-12-14 10:59:27 +00:00
|
|
|
if (event)
|
|
|
|
qemuDomainEventQueue(driver, event);
|
2009-07-16 14:50:23 +00:00
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
2008-05-07 16:16:44 +00:00
|
|
|
static int qemudDomainSetVcpus(virDomainPtr dom, unsigned int nvcpus) {
|
2008-12-04 21:04:30 +00:00
|
|
|
struct qemud_driver *driver = dom->conn->privateData;
|
|
|
|
virDomainObjPtr vm;
|
2008-05-07 16:16:44 +00:00
|
|
|
int max;
|
2008-12-04 21:04:30 +00:00
|
|
|
int ret = -1;
|
2009-03-16 11:44:46 +00:00
|
|
|
const char *type;
|
2008-05-07 16:16:44 +00:00
|
|
|
|
2008-12-04 21:06:41 +00:00
|
|
|
qemuDriverLock(driver);
|
2008-12-04 21:04:30 +00:00
|
|
|
vm = virDomainFindByUUID(&driver->domains, dom->uuid);
|
2008-12-04 21:06:41 +00:00
|
|
|
qemuDriverUnlock(driver);
|
|
|
|
|
2008-05-07 16:16:44 +00:00
|
|
|
if (!vm) {
|
2008-07-25 09:01:25 +00:00
|
|
|
char uuidstr[VIR_UUID_STRING_BUFLEN];
|
|
|
|
virUUIDFormat(dom->uuid, uuidstr);
|
2009-04-19 15:30:50 +00:00
|
|
|
qemudReportError(dom->conn, dom, NULL, VIR_ERR_NO_DOMAIN,
|
2008-07-25 09:01:25 +00:00
|
|
|
_("no domain with matching uuid '%s'"), uuidstr);
|
2008-12-04 21:04:30 +00:00
|
|
|
goto cleanup;
|
2008-05-07 16:16:44 +00:00
|
|
|
}
|
|
|
|
|
2009-11-03 18:26:32 +00:00
|
|
|
if (qemuDomainObjBeginJob(vm) < 0)
|
|
|
|
goto cleanup;
|
|
|
|
|
Rename internal APis
Rename virDomainIsActive to virDomainObjIsActive, and
virInterfaceIsActive to virInterfaceObjIsActive and finally
virNetworkIsActive to virNetworkObjIsActive.
* src/conf/domain_conf.c, src/conf/domain_conf.h,
src/conf/interface_conf.h, src/conf/network_conf.c,
src/conf/network_conf.h, src/lxc/lxc_driver.c,
src/network/bridge_driver.c, src/opennebula/one_driver.c,
src/openvz/openvz_driver.c, src/qemu/qemu_driver.c,
src/test/test_driver.c, src/uml/uml_driver.c: Update for
renamed APIs.
2009-10-20 14:51:03 +00:00
|
|
|
if (virDomainObjIsActive(vm)) {
|
2009-05-08 09:58:46 +00:00
|
|
|
qemudReportError(dom->conn, dom, NULL, VIR_ERR_OPERATION_INVALID, "%s",
|
2008-05-07 16:16:44 +00:00
|
|
|
_("cannot change vcpu count of an active domain"));
|
2009-11-03 18:26:32 +00:00
|
|
|
goto endjob;
|
2008-05-07 16:16:44 +00:00
|
|
|
}
|
|
|
|
|
2009-03-16 11:44:46 +00:00
|
|
|
if (!(type = virDomainVirtTypeToString(vm->def->virtType))) {
|
|
|
|
qemudReportError(dom->conn, dom, NULL, VIR_ERR_INTERNAL_ERROR,
|
|
|
|
_("unknown virt type in domain definition '%d'"),
|
|
|
|
vm->def->virtType);
|
2009-11-03 18:26:32 +00:00
|
|
|
goto endjob;
|
2009-03-16 11:44:46 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
if ((max = qemudGetMaxVCPUs(dom->conn, type)) < 0) {
|
2008-05-07 16:16:44 +00:00
|
|
|
qemudReportError(dom->conn, dom, NULL, VIR_ERR_INTERNAL_ERROR, "%s",
|
|
|
|
_("could not determine max vcpus for the domain"));
|
2009-11-03 18:26:32 +00:00
|
|
|
goto endjob;
|
2008-05-07 16:16:44 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
if (nvcpus > max) {
|
|
|
|
qemudReportError(dom->conn, dom, NULL, VIR_ERR_INVALID_ARG,
|
|
|
|
_("requested vcpus is greater than max allowable"
|
|
|
|
" vcpus for the domain: %d > %d"), nvcpus, max);
|
2009-11-03 18:26:32 +00:00
|
|
|
goto endjob;
|
2008-05-07 16:16:44 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
vm->def->vcpus = nvcpus;
|
2008-12-04 21:04:30 +00:00
|
|
|
ret = 0;
|
|
|
|
|
2009-11-03 18:26:32 +00:00
|
|
|
endjob:
|
2009-12-08 14:42:43 +00:00
|
|
|
if (qemuDomainObjEndJob(vm) == 0)
|
|
|
|
vm = NULL;
|
2009-11-03 18:26:32 +00:00
|
|
|
|
2008-12-04 21:04:30 +00:00
|
|
|
cleanup:
|
2008-12-04 21:06:41 +00:00
|
|
|
if (vm)
|
|
|
|
virDomainObjUnlock(vm);
|
2008-12-04 21:04:30 +00:00
|
|
|
return ret;
|
2008-05-07 16:16:44 +00:00
|
|
|
}
|
|
|
|
|
2008-05-22 16:20:31 +00:00
|
|
|
|
|
|
|
static int
|
|
|
|
qemudDomainPinVcpu(virDomainPtr dom,
|
|
|
|
unsigned int vcpu,
|
|
|
|
unsigned char *cpumap,
|
|
|
|
int maplen) {
|
2008-12-04 21:04:30 +00:00
|
|
|
struct qemud_driver *driver = dom->conn->privateData;
|
|
|
|
virDomainObjPtr vm;
|
2009-11-16 15:22:34 +00:00
|
|
|
int maxcpu, hostcpus;
|
2008-05-22 16:20:31 +00:00
|
|
|
virNodeInfo nodeinfo;
|
2008-12-04 21:04:30 +00:00
|
|
|
int ret = -1;
|
2009-11-26 17:57:00 +00:00
|
|
|
qemuDomainObjPrivatePtr priv;
|
2008-05-22 16:20:31 +00:00
|
|
|
|
2008-12-04 21:06:41 +00:00
|
|
|
qemuDriverLock(driver);
|
2008-12-04 21:04:30 +00:00
|
|
|
vm = virDomainFindByUUID(&driver->domains, dom->uuid);
|
2008-12-04 21:06:41 +00:00
|
|
|
qemuDriverUnlock(driver);
|
|
|
|
|
2009-05-08 09:58:46 +00:00
|
|
|
if (!vm) {
|
|
|
|
char uuidstr[VIR_UUID_STRING_BUFLEN];
|
|
|
|
virUUIDFormat(dom->uuid, uuidstr);
|
|
|
|
qemudReportError(dom->conn, dom, NULL, VIR_ERR_NO_DOMAIN,
|
|
|
|
_("no domain with matching uuid '%s'"), uuidstr);
|
|
|
|
goto cleanup;
|
|
|
|
}
|
|
|
|
|
Rename internal APis
Rename virDomainIsActive to virDomainObjIsActive, and
virInterfaceIsActive to virInterfaceObjIsActive and finally
virNetworkIsActive to virNetworkObjIsActive.
* src/conf/domain_conf.c, src/conf/domain_conf.h,
src/conf/interface_conf.h, src/conf/network_conf.c,
src/conf/network_conf.h, src/lxc/lxc_driver.c,
src/network/bridge_driver.c, src/opennebula/one_driver.c,
src/openvz/openvz_driver.c, src/qemu/qemu_driver.c,
src/test/test_driver.c, src/uml/uml_driver.c: Update for
renamed APIs.
2009-10-20 14:51:03 +00:00
|
|
|
if (!virDomainObjIsActive(vm)) {
|
2009-05-08 09:58:46 +00:00
|
|
|
qemudReportError(dom->conn, dom, NULL, VIR_ERR_OPERATION_INVALID,
|
2008-05-22 16:20:31 +00:00
|
|
|
"%s",_("cannot pin vcpus on an inactive domain"));
|
2008-12-04 21:04:30 +00:00
|
|
|
goto cleanup;
|
2008-05-22 16:20:31 +00:00
|
|
|
}
|
|
|
|
|
2009-11-26 17:57:00 +00:00
|
|
|
priv = vm->privateData;
|
|
|
|
|
|
|
|
if (vcpu > (priv->nvcpupids-1)) {
|
2008-05-22 16:20:31 +00:00
|
|
|
qemudReportError(dom->conn, dom, NULL, VIR_ERR_INVALID_ARG,
|
|
|
|
_("vcpu number out of range %d > %d"),
|
2009-11-26 17:57:00 +00:00
|
|
|
vcpu, priv->nvcpupids);
|
2008-12-04 21:04:30 +00:00
|
|
|
goto cleanup;
|
2008-05-22 16:20:31 +00:00
|
|
|
}
|
|
|
|
|
2009-06-03 13:28:02 +00:00
|
|
|
if (nodeGetInfo(dom->conn, &nodeinfo) < 0)
|
2008-12-04 21:04:30 +00:00
|
|
|
goto cleanup;
|
2008-05-22 16:20:31 +00:00
|
|
|
|
2009-11-05 15:21:33 +00:00
|
|
|
hostcpus = VIR_NODEINFO_MAXCPUS(nodeinfo);
|
2008-05-22 16:20:31 +00:00
|
|
|
maxcpu = maplen * 8;
|
2009-11-05 15:21:33 +00:00
|
|
|
if (maxcpu > hostcpus)
|
|
|
|
maxcpu = hostcpus;
|
2008-05-22 16:20:31 +00:00
|
|
|
|
2009-11-26 17:57:00 +00:00
|
|
|
if (priv->vcpupids != NULL) {
|
|
|
|
if (virProcessInfoSetAffinity(priv->vcpupids[vcpu],
|
2009-11-16 15:22:34 +00:00
|
|
|
cpumap, maplen, maxcpu) < 0)
|
2008-12-04 21:04:30 +00:00
|
|
|
goto cleanup;
|
2008-05-22 16:20:31 +00:00
|
|
|
} else {
|
|
|
|
qemudReportError(dom->conn, dom, NULL, VIR_ERR_NO_SUPPORT,
|
|
|
|
"%s", _("cpu affinity is not supported"));
|
2008-12-04 21:04:30 +00:00
|
|
|
goto cleanup;
|
2008-05-22 16:20:31 +00:00
|
|
|
}
|
2008-12-04 21:04:30 +00:00
|
|
|
ret = 0;
|
2008-05-22 16:20:31 +00:00
|
|
|
|
2008-12-04 21:04:30 +00:00
|
|
|
cleanup:
|
2008-12-04 21:06:41 +00:00
|
|
|
if (vm)
|
|
|
|
virDomainObjUnlock(vm);
|
2008-12-04 21:04:30 +00:00
|
|
|
return ret;
|
2008-05-22 16:20:31 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
static int
|
|
|
|
qemudDomainGetVcpus(virDomainPtr dom,
|
|
|
|
virVcpuInfoPtr info,
|
|
|
|
int maxinfo,
|
|
|
|
unsigned char *cpumaps,
|
|
|
|
int maplen) {
|
2008-12-04 21:04:30 +00:00
|
|
|
struct qemud_driver *driver = dom->conn->privateData;
|
|
|
|
virDomainObjPtr vm;
|
2008-05-22 16:20:31 +00:00
|
|
|
virNodeInfo nodeinfo;
|
2009-11-05 15:21:33 +00:00
|
|
|
int i, v, maxcpu, hostcpus;
|
2008-12-04 21:04:30 +00:00
|
|
|
int ret = -1;
|
2009-11-26 17:57:00 +00:00
|
|
|
qemuDomainObjPrivatePtr priv;
|
2008-05-22 16:20:31 +00:00
|
|
|
|
2008-12-04 21:06:41 +00:00
|
|
|
qemuDriverLock(driver);
|
2008-12-04 21:04:30 +00:00
|
|
|
vm = virDomainFindByUUID(&driver->domains, dom->uuid);
|
2008-12-04 21:06:41 +00:00
|
|
|
qemuDriverUnlock(driver);
|
|
|
|
|
2009-05-08 09:58:46 +00:00
|
|
|
if (!vm) {
|
|
|
|
char uuidstr[VIR_UUID_STRING_BUFLEN];
|
|
|
|
virUUIDFormat(dom->uuid, uuidstr);
|
|
|
|
qemudReportError(dom->conn, dom, NULL, VIR_ERR_NO_DOMAIN,
|
|
|
|
_("no domain with matching uuid '%s'"), uuidstr);
|
|
|
|
goto cleanup;
|
|
|
|
}
|
|
|
|
|
Rename internal APis
Rename virDomainIsActive to virDomainObjIsActive, and
virInterfaceIsActive to virInterfaceObjIsActive and finally
virNetworkIsActive to virNetworkObjIsActive.
* src/conf/domain_conf.c, src/conf/domain_conf.h,
src/conf/interface_conf.h, src/conf/network_conf.c,
src/conf/network_conf.h, src/lxc/lxc_driver.c,
src/network/bridge_driver.c, src/opennebula/one_driver.c,
src/openvz/openvz_driver.c, src/qemu/qemu_driver.c,
src/test/test_driver.c, src/uml/uml_driver.c: Update for
renamed APIs.
2009-10-20 14:51:03 +00:00
|
|
|
if (!virDomainObjIsActive(vm)) {
|
2009-05-08 09:58:46 +00:00
|
|
|
qemudReportError(dom->conn, dom, NULL, VIR_ERR_OPERATION_INVALID,
|
2009-10-21 19:03:58 +00:00
|
|
|
"%s",
|
|
|
|
_("cannot list vcpu pinning for an inactive domain"));
|
2008-12-04 21:04:30 +00:00
|
|
|
goto cleanup;
|
2008-05-22 16:20:31 +00:00
|
|
|
}
|
|
|
|
|
2009-11-26 17:57:00 +00:00
|
|
|
priv = vm->privateData;
|
|
|
|
|
2009-06-03 13:28:02 +00:00
|
|
|
if (nodeGetInfo(dom->conn, &nodeinfo) < 0)
|
2008-12-04 21:04:30 +00:00
|
|
|
goto cleanup;
|
2008-05-22 16:20:31 +00:00
|
|
|
|
2009-11-05 15:21:33 +00:00
|
|
|
hostcpus = VIR_NODEINFO_MAXCPUS(nodeinfo);
|
2008-05-22 16:20:31 +00:00
|
|
|
maxcpu = maplen * 8;
|
2009-11-05 15:21:33 +00:00
|
|
|
if (maxcpu > hostcpus)
|
|
|
|
maxcpu = hostcpus;
|
2008-05-22 16:20:31 +00:00
|
|
|
|
|
|
|
/* Clamp to actual number of vcpus */
|
2009-11-26 17:57:00 +00:00
|
|
|
if (maxinfo > priv->nvcpupids)
|
|
|
|
maxinfo = priv->nvcpupids;
|
2008-05-22 16:20:31 +00:00
|
|
|
|
2008-12-04 21:04:30 +00:00
|
|
|
if (maxinfo >= 1) {
|
|
|
|
if (info != NULL) {
|
|
|
|
memset(info, 0, sizeof(*info) * maxinfo);
|
|
|
|
for (i = 0 ; i < maxinfo ; i++) {
|
|
|
|
info[i].number = i;
|
|
|
|
info[i].state = VIR_VCPU_RUNNING;
|
2009-07-27 15:30:25 +00:00
|
|
|
|
2009-11-26 17:57:00 +00:00
|
|
|
if (priv->vcpupids != NULL &&
|
2009-07-27 15:30:25 +00:00
|
|
|
qemudGetProcessInfo(&(info[i].cpuTime),
|
|
|
|
&(info[i].cpu),
|
|
|
|
vm->pid,
|
2009-11-26 17:57:00 +00:00
|
|
|
priv->vcpupids[i]) < 0) {
|
2009-07-27 15:30:25 +00:00
|
|
|
virReportSystemError(dom->conn, errno, "%s",
|
|
|
|
_("cannot get vCPU placement & pCPU time"));
|
|
|
|
goto cleanup;
|
|
|
|
}
|
2008-12-04 21:04:30 +00:00
|
|
|
}
|
2008-05-22 16:20:31 +00:00
|
|
|
}
|
|
|
|
|
2008-12-04 21:04:30 +00:00
|
|
|
if (cpumaps != NULL) {
|
|
|
|
memset(cpumaps, 0, maplen * maxinfo);
|
2009-11-26 17:57:00 +00:00
|
|
|
if (priv->vcpupids != NULL) {
|
2008-12-04 21:04:30 +00:00
|
|
|
for (v = 0 ; v < maxinfo ; v++) {
|
|
|
|
unsigned char *cpumap = VIR_GET_CPUMAP(cpumaps, maplen, v);
|
|
|
|
|
2009-11-26 17:57:00 +00:00
|
|
|
if (virProcessInfoGetAffinity(priv->vcpupids[v],
|
2009-11-16 15:22:34 +00:00
|
|
|
cpumap, maplen, maxcpu) < 0)
|
2008-12-04 21:04:30 +00:00
|
|
|
goto cleanup;
|
2008-05-22 16:20:31 +00:00
|
|
|
}
|
2008-12-04 21:04:30 +00:00
|
|
|
} else {
|
|
|
|
qemudReportError(dom->conn, dom, NULL, VIR_ERR_NO_SUPPORT,
|
|
|
|
"%s", _("cpu affinity is not available"));
|
|
|
|
goto cleanup;
|
2008-05-22 16:20:31 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
2008-12-04 21:04:30 +00:00
|
|
|
ret = maxinfo;
|
2008-05-22 16:20:31 +00:00
|
|
|
|
2008-12-04 21:04:30 +00:00
|
|
|
cleanup:
|
2008-12-04 21:06:41 +00:00
|
|
|
if (vm)
|
|
|
|
virDomainObjUnlock(vm);
|
2008-12-04 21:04:30 +00:00
|
|
|
return ret;
|
2008-05-22 16:20:31 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
|
2008-05-07 16:16:44 +00:00
|
|
|
static int qemudDomainGetMaxVcpus(virDomainPtr dom) {
|
2008-12-04 21:04:30 +00:00
|
|
|
struct qemud_driver *driver = dom->conn->privateData;
|
|
|
|
virDomainObjPtr vm;
|
2008-05-07 16:16:44 +00:00
|
|
|
const char *type;
|
2008-12-04 21:04:30 +00:00
|
|
|
int ret = -1;
|
2008-05-07 16:16:44 +00:00
|
|
|
|
2008-12-04 21:06:41 +00:00
|
|
|
qemuDriverLock(driver);
|
2008-12-04 21:04:30 +00:00
|
|
|
vm = virDomainFindByUUID(&driver->domains, dom->uuid);
|
2008-12-04 21:06:41 +00:00
|
|
|
qemuDriverUnlock(driver);
|
|
|
|
|
2008-05-07 16:16:44 +00:00
|
|
|
if (!vm) {
|
2008-07-25 09:01:25 +00:00
|
|
|
char uuidstr[VIR_UUID_STRING_BUFLEN];
|
|
|
|
virUUIDFormat(dom->uuid, uuidstr);
|
2009-04-19 15:30:50 +00:00
|
|
|
qemudReportError(dom->conn, dom, NULL, VIR_ERR_NO_DOMAIN,
|
2008-07-25 09:01:25 +00:00
|
|
|
_("no domain with matching uuid '%s'"), uuidstr);
|
2008-12-04 21:04:30 +00:00
|
|
|
goto cleanup;
|
2008-05-07 16:16:44 +00:00
|
|
|
}
|
|
|
|
|
2008-07-11 19:34:11 +00:00
|
|
|
if (!(type = virDomainVirtTypeToString(vm->def->virtType))) {
|
2008-05-07 16:16:44 +00:00
|
|
|
qemudReportError(dom->conn, dom, NULL, VIR_ERR_INTERNAL_ERROR,
|
|
|
|
_("unknown virt type in domain definition '%d'"),
|
|
|
|
vm->def->virtType);
|
2008-12-04 21:04:30 +00:00
|
|
|
goto cleanup;
|
2008-05-07 16:16:44 +00:00
|
|
|
}
|
|
|
|
|
2008-12-04 21:04:30 +00:00
|
|
|
ret = qemudGetMaxVCPUs(dom->conn, type);
|
2008-05-07 16:16:44 +00:00
|
|
|
|
2008-12-04 21:04:30 +00:00
|
|
|
cleanup:
|
2008-12-04 21:06:41 +00:00
|
|
|
if (vm)
|
|
|
|
virDomainObjUnlock(vm);
|
2008-05-07 16:16:44 +00:00
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
2009-03-03 12:03:44 +00:00
|
|
|
static int qemudDomainGetSecurityLabel(virDomainPtr dom, virSecurityLabelPtr seclabel)
|
|
|
|
{
|
|
|
|
struct qemud_driver *driver = (struct qemud_driver *)dom->conn->privateData;
|
|
|
|
virDomainObjPtr vm;
|
|
|
|
const char *type;
|
|
|
|
int ret = -1;
|
|
|
|
|
|
|
|
qemuDriverLock(driver);
|
|
|
|
vm = virDomainFindByUUID(&driver->domains, dom->uuid);
|
|
|
|
|
2009-06-25 09:37:22 +00:00
|
|
|
memset(seclabel, 0, sizeof(*seclabel));
|
|
|
|
|
2009-03-03 12:03:44 +00:00
|
|
|
if (!vm) {
|
|
|
|
char uuidstr[VIR_UUID_STRING_BUFLEN];
|
|
|
|
virUUIDFormat(dom->uuid, uuidstr);
|
2009-04-19 15:30:50 +00:00
|
|
|
qemudReportError(dom->conn, dom, NULL, VIR_ERR_NO_DOMAIN,
|
2009-03-03 12:03:44 +00:00
|
|
|
_("no domain with matching uuid '%s'"), uuidstr);
|
|
|
|
goto cleanup;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (!(type = virDomainVirtTypeToString(vm->def->virtType))) {
|
|
|
|
qemudReportError(dom->conn, dom, NULL, VIR_ERR_INTERNAL_ERROR,
|
|
|
|
_("unknown virt type in domain definition '%d'"),
|
|
|
|
vm->def->virtType);
|
|
|
|
goto cleanup;
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Theoretically, the pid can be replaced during this operation and
|
|
|
|
* return the label of a different process. If atomicity is needed,
|
|
|
|
* further validation will be required.
|
|
|
|
*
|
|
|
|
* Comment from Dan Berrange:
|
|
|
|
*
|
|
|
|
* Well the PID as stored in the virDomainObjPtr can't be changed
|
|
|
|
* because you've got a locked object. The OS level PID could have
|
|
|
|
* exited, though and in extreme circumstances have cycled through all
|
|
|
|
* PIDs back to ours. We could sanity check that our PID still exists
|
|
|
|
* after reading the label, by checking that our FD connecting to the
|
|
|
|
* QEMU monitor hasn't seen SIGHUP/ERR on poll().
|
|
|
|
*/
|
Rename internal APis
Rename virDomainIsActive to virDomainObjIsActive, and
virInterfaceIsActive to virInterfaceObjIsActive and finally
virNetworkIsActive to virNetworkObjIsActive.
* src/conf/domain_conf.c, src/conf/domain_conf.h,
src/conf/interface_conf.h, src/conf/network_conf.c,
src/conf/network_conf.h, src/lxc/lxc_driver.c,
src/network/bridge_driver.c, src/opennebula/one_driver.c,
src/openvz/openvz_driver.c, src/qemu/qemu_driver.c,
src/test/test_driver.c, src/uml/uml_driver.c: Update for
renamed APIs.
2009-10-20 14:51:03 +00:00
|
|
|
if (virDomainObjIsActive(vm)) {
|
2010-01-11 11:04:40 +00:00
|
|
|
if (driver->securityDriver && driver->securityDriver->domainGetSecurityProcessLabel) {
|
|
|
|
if (driver->securityDriver->domainGetSecurityProcessLabel(dom->conn, vm, seclabel) == -1) {
|
2009-03-03 12:03:44 +00:00
|
|
|
qemudReportError(dom->conn, dom, NULL, VIR_ERR_INTERNAL_ERROR,
|
2009-07-23 16:27:47 +00:00
|
|
|
"%s", _("Failed to get security label"));
|
2009-03-03 12:03:44 +00:00
|
|
|
goto cleanup;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
ret = 0;
|
|
|
|
|
|
|
|
cleanup:
|
|
|
|
if (vm)
|
|
|
|
virDomainObjUnlock(vm);
|
2009-05-19 11:06:25 +00:00
|
|
|
qemuDriverUnlock(driver);
|
2009-03-03 12:03:44 +00:00
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
2009-05-06 14:20:34 +00:00
|
|
|
static int qemudNodeGetSecurityModel(virConnectPtr conn,
|
|
|
|
virSecurityModelPtr secmodel)
|
2009-03-03 12:03:44 +00:00
|
|
|
{
|
|
|
|
struct qemud_driver *driver = (struct qemud_driver *)conn->privateData;
|
|
|
|
char *p;
|
2009-05-06 14:20:34 +00:00
|
|
|
int ret = 0;
|
2009-03-03 12:03:44 +00:00
|
|
|
|
2009-05-06 14:20:34 +00:00
|
|
|
qemuDriverLock(driver);
|
|
|
|
if (!driver->securityDriver) {
|
2009-06-25 09:37:22 +00:00
|
|
|
memset(secmodel, 0, sizeof (*secmodel));
|
2009-05-06 14:20:34 +00:00
|
|
|
goto cleanup;
|
|
|
|
}
|
2008-05-07 16:16:44 +00:00
|
|
|
|
2009-03-03 12:03:44 +00:00
|
|
|
p = driver->caps->host.secModel.model;
|
|
|
|
if (strlen(p) >= VIR_SECURITY_MODEL_BUFLEN-1) {
|
|
|
|
qemudReportError(conn, NULL, NULL, VIR_ERR_INTERNAL_ERROR,
|
|
|
|
_("security model string exceeds max %d bytes"),
|
|
|
|
VIR_SECURITY_MODEL_BUFLEN-1);
|
2009-05-06 14:20:34 +00:00
|
|
|
ret = -1;
|
|
|
|
goto cleanup;
|
2009-03-03 12:03:44 +00:00
|
|
|
}
|
|
|
|
strcpy(secmodel->model, p);
|
|
|
|
|
|
|
|
p = driver->caps->host.secModel.doi;
|
|
|
|
if (strlen(p) >= VIR_SECURITY_DOI_BUFLEN-1) {
|
|
|
|
qemudReportError(conn, NULL, NULL, VIR_ERR_INTERNAL_ERROR,
|
|
|
|
_("security DOI string exceeds max %d bytes"),
|
|
|
|
VIR_SECURITY_DOI_BUFLEN-1);
|
2009-05-06 14:20:34 +00:00
|
|
|
ret = -1;
|
|
|
|
goto cleanup;
|
2009-03-03 12:03:44 +00:00
|
|
|
}
|
|
|
|
strcpy(secmodel->doi, p);
|
2009-05-06 14:20:34 +00:00
|
|
|
|
|
|
|
cleanup:
|
|
|
|
qemuDriverUnlock(driver);
|
|
|
|
return ret;
|
2009-03-03 12:03:44 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
/* TODO: check seclabel restore */
|
2007-06-29 13:23:13 +00:00
|
|
|
static int qemudDomainRestore(virConnectPtr conn,
|
2008-12-04 21:04:30 +00:00
|
|
|
const char *path) {
|
|
|
|
struct qemud_driver *driver = conn->privateData;
|
|
|
|
virDomainDefPtr def = NULL;
|
2008-12-04 21:06:41 +00:00
|
|
|
virDomainObjPtr vm = NULL;
|
2008-12-04 21:04:30 +00:00
|
|
|
int fd = -1;
|
|
|
|
int ret = -1;
|
|
|
|
char *xml = NULL;
|
2007-08-14 01:47:24 +00:00
|
|
|
struct qemud_save_header header;
|
2008-12-04 21:09:20 +00:00
|
|
|
virDomainEventPtr event = NULL;
|
Compressed save image format for Qemu.
Implement a compressed save image format for qemu. While ideally
we would have the choice between compressed/non-compressed
available to the libvirt API, unfortunately there is no "flags"
parameter to the virDomainSave() API. Therefore, implement this
as a qemu.conf option. gzip, bzip2, and lzma are implemented, and
it should be very easy to implement additional compression
methods.
One open question is if/how we should detect the compression
binaries. One way to do it is to do compile-time setting of the
paths (via configure.in), but that doesn't seem like a great thing
to do. My preferred solution is not to detect at all;
when we go to run the commands that need them, if they
aren't available, or aren't available in one of the standard paths,
then we'll fail. That's also the solution implemented in this patch.
In the future, we'll have a more robust (managed) save/restore API,
at which time we can expose this functionality properly in the API.
V2: get rid of redundant dd command and just use >> to append data.
V3: Add back the missing pieces for the enum and bumping the save version.
V4: Make the compressed field in the save_header an int.
Implement LZMA compression.
Signed-off-by: Chris Lalancette <clalance@redhat.com>
2009-08-07 11:34:05 +00:00
|
|
|
int intermediatefd = -1;
|
|
|
|
pid_t intermediate_pid = -1;
|
|
|
|
int childstat;
|
2007-08-14 01:47:24 +00:00
|
|
|
|
2008-12-04 21:06:41 +00:00
|
|
|
qemuDriverLock(driver);
|
2007-08-14 01:47:24 +00:00
|
|
|
/* Verify the header and read the XML */
|
|
|
|
if ((fd = open(path, O_RDONLY)) < 0) {
|
|
|
|
qemudReportError(conn, NULL, NULL, VIR_ERR_OPERATION_FAILED,
|
Mark many more strings for translation.
* Makefile.maint (err_func_re): Add to the list and make it readable.
* po/POTFILES.in: Add src/util.c and src/xm_internal.c, and sort.
* src/storage_backend.c: Fix comment.
* src/util.c (virFileLinkPointsTo): Mark a string.
* qemud/remote.c (remoteDispatchClientRequest): Mark strings.
(remoteDispatchOpen, CHECK_CONN, remoteDispatchGetType): Likewise.
(remoteDispatchDomainGetSchedulerType): Likewise.
(remoteDispatchDomainGetSchedulerParameters): Likewise.
(remoteDispatchDomainSetSchedulerParameters): Likewise.
(remoteDispatchDomainBlockStats): Likewise.
(remoteDispatchDomainInterfaceStats): Likewise.
(remoteDispatchDomainAttachDevice, remoteDispatchDomainCreate):
(remoteDispatchDomainDestroy, remoteDispatchDomainDetachDevice):
(remoteDispatchDomainDumpXml, remoteDispatchDomainGetAutostart):
(remoteDispatchDomainGetInfo, remoteDispatchDomainGetMaxMemory):
(remoteDispatchDomainGetMaxVcpus, remoteDispatchDomainGetOsType):
(remoteDispatchDomainGetVcpus): Likewise.
(remoteDispatchDomainMigratePerform): Likewise.
(remoteDispatchListDefinedDomains, remoteDispatchDomainPinVcpu):
(remoteDispatchDomainReboot, remoteDispatchDomainResume):
(remoteDispatchDomainSave, remoteDispatchDomainCoreDump):
(remoteDispatchDomainSetAutostart): Likewise.
(remoteDispatchDomainSetMaxMemory, remoteDispatchDomainSetMemory):
(remoteDispatchDomainSetVcpus, remoteDispatchDomainShutdown):
(remoteDispatchDomainSuspend, remoteDispatchDomainUndefine):
(remoteDispatchListDefinedNetworks, remoteDispatchListDomains):
(remoteDispatchListNetworks, remoteDispatchNetworkCreate):
(remoteDispatchNetworkDestroy, remoteDispatchNetworkDumpXml):
(remoteDispatchNetworkGetAutostart, remoteDispatchNetworkGetBridgeName):
(remoteDispatchNetworkSetAutostart, remoteDispatchNetworkUndefine):
(addrToString, remoteDispatchAuthSaslInit, remoteDispatchAuthSaslStart):
(remoteDispatchAuthSaslStep, remoteDispatchListDefinedStoragePools):
(remoteDispatchListStoragePools, remoteDispatchStoragePoolCreate):
(remoteDispatchStoragePoolBuild, remoteDispatchStoragePoolDestroy):
(remoteDispatchStoragePoolDelete, remoteDispatchStoragePoolRefresh):
(remoteDispatchStoragePoolGetInfo, remoteDispatchStoragePoolDumpXml):
(remoteDispatchStoragePoolGetAutostart): Likewise.
(remoteDispatchStoragePoolSetAutostart):
(remoteDispatchStoragePoolListVolumes):
(remoteDispatchStoragePoolNumOfVolumes):
(remoteDispatchStoragePoolUndefine, remoteDispatchStorageVolCreateXml):
(remoteDispatchStorageVolDelete, remoteDispatchStorageVolGetInfo):
(remoteDispatchStorageVolDumpXml, remoteDispatchStorageVolGetPath):
(remoteDispatchStorageVolLookupByName): Likewise.
* src/qemu_driver.c (qemudOpenMonitor, qemudStartVMDaemon):
(dhcpStartDhcpDaemon, qemudStartNetworkDaemon):
(qemudDomainSuspend, qemudDomainResume, qemudDomainShutdown):
(qemudDomainGetOSType, qemudDomainSetMaxMemory):
(qemudDomainSetMemory, qemudDomainGetInfo, qemudDomainSave):
(qemudDomainRestore, qemudDomainDumpXML, qemudDomainStart):
(qemudDomainUndefine, qemudDomainChangeCDROM):
(qemudDomainAttachDevice, qemudDomainGetAutostart):
(qemudDomainSetAutostart, qemudDomainInterfaceStats):
(qemudNetworkLookupByUUID, qemudNetworkLookupByName):
(qemudNetworkUndefine, qemudNetworkStart, qemudNetworkDestroy):
(qemudNetworkDumpXML, qemudNetworkGetAutostart):
(qemudNetworkSetAutostart): Likewise.
* src/virsh.c (cmdVcpupin, cmdAttachDevice, cmdDetachDevice): Likewise.
* src/xm_internal.c (xenXMConfigCacheRefresh, xenXMDomainPinVcpu): Likewise.
2008-03-27 13:43:01 +00:00
|
|
|
"%s", _("cannot read domain image"));
|
2008-12-04 21:04:30 +00:00
|
|
|
goto cleanup;
|
2007-08-14 01:47:24 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
if (saferead(fd, &header, sizeof(header)) != sizeof(header)) {
|
|
|
|
qemudReportError(conn, NULL, NULL, VIR_ERR_OPERATION_FAILED,
|
Mark many more strings for translation.
* Makefile.maint (err_func_re): Add to the list and make it readable.
* po/POTFILES.in: Add src/util.c and src/xm_internal.c, and sort.
* src/storage_backend.c: Fix comment.
* src/util.c (virFileLinkPointsTo): Mark a string.
* qemud/remote.c (remoteDispatchClientRequest): Mark strings.
(remoteDispatchOpen, CHECK_CONN, remoteDispatchGetType): Likewise.
(remoteDispatchDomainGetSchedulerType): Likewise.
(remoteDispatchDomainGetSchedulerParameters): Likewise.
(remoteDispatchDomainSetSchedulerParameters): Likewise.
(remoteDispatchDomainBlockStats): Likewise.
(remoteDispatchDomainInterfaceStats): Likewise.
(remoteDispatchDomainAttachDevice, remoteDispatchDomainCreate):
(remoteDispatchDomainDestroy, remoteDispatchDomainDetachDevice):
(remoteDispatchDomainDumpXml, remoteDispatchDomainGetAutostart):
(remoteDispatchDomainGetInfo, remoteDispatchDomainGetMaxMemory):
(remoteDispatchDomainGetMaxVcpus, remoteDispatchDomainGetOsType):
(remoteDispatchDomainGetVcpus): Likewise.
(remoteDispatchDomainMigratePerform): Likewise.
(remoteDispatchListDefinedDomains, remoteDispatchDomainPinVcpu):
(remoteDispatchDomainReboot, remoteDispatchDomainResume):
(remoteDispatchDomainSave, remoteDispatchDomainCoreDump):
(remoteDispatchDomainSetAutostart): Likewise.
(remoteDispatchDomainSetMaxMemory, remoteDispatchDomainSetMemory):
(remoteDispatchDomainSetVcpus, remoteDispatchDomainShutdown):
(remoteDispatchDomainSuspend, remoteDispatchDomainUndefine):
(remoteDispatchListDefinedNetworks, remoteDispatchListDomains):
(remoteDispatchListNetworks, remoteDispatchNetworkCreate):
(remoteDispatchNetworkDestroy, remoteDispatchNetworkDumpXml):
(remoteDispatchNetworkGetAutostart, remoteDispatchNetworkGetBridgeName):
(remoteDispatchNetworkSetAutostart, remoteDispatchNetworkUndefine):
(addrToString, remoteDispatchAuthSaslInit, remoteDispatchAuthSaslStart):
(remoteDispatchAuthSaslStep, remoteDispatchListDefinedStoragePools):
(remoteDispatchListStoragePools, remoteDispatchStoragePoolCreate):
(remoteDispatchStoragePoolBuild, remoteDispatchStoragePoolDestroy):
(remoteDispatchStoragePoolDelete, remoteDispatchStoragePoolRefresh):
(remoteDispatchStoragePoolGetInfo, remoteDispatchStoragePoolDumpXml):
(remoteDispatchStoragePoolGetAutostart): Likewise.
(remoteDispatchStoragePoolSetAutostart):
(remoteDispatchStoragePoolListVolumes):
(remoteDispatchStoragePoolNumOfVolumes):
(remoteDispatchStoragePoolUndefine, remoteDispatchStorageVolCreateXml):
(remoteDispatchStorageVolDelete, remoteDispatchStorageVolGetInfo):
(remoteDispatchStorageVolDumpXml, remoteDispatchStorageVolGetPath):
(remoteDispatchStorageVolLookupByName): Likewise.
* src/qemu_driver.c (qemudOpenMonitor, qemudStartVMDaemon):
(dhcpStartDhcpDaemon, qemudStartNetworkDaemon):
(qemudDomainSuspend, qemudDomainResume, qemudDomainShutdown):
(qemudDomainGetOSType, qemudDomainSetMaxMemory):
(qemudDomainSetMemory, qemudDomainGetInfo, qemudDomainSave):
(qemudDomainRestore, qemudDomainDumpXML, qemudDomainStart):
(qemudDomainUndefine, qemudDomainChangeCDROM):
(qemudDomainAttachDevice, qemudDomainGetAutostart):
(qemudDomainSetAutostart, qemudDomainInterfaceStats):
(qemudNetworkLookupByUUID, qemudNetworkLookupByName):
(qemudNetworkUndefine, qemudNetworkStart, qemudNetworkDestroy):
(qemudNetworkDumpXML, qemudNetworkGetAutostart):
(qemudNetworkSetAutostart): Likewise.
* src/virsh.c (cmdVcpupin, cmdAttachDevice, cmdDetachDevice): Likewise.
* src/xm_internal.c (xenXMConfigCacheRefresh, xenXMDomainPinVcpu): Likewise.
2008-03-27 13:43:01 +00:00
|
|
|
"%s", _("failed to read qemu header"));
|
2008-12-04 21:04:30 +00:00
|
|
|
goto cleanup;
|
2007-08-14 01:47:24 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
if (memcmp(header.magic, QEMUD_SAVE_MAGIC, sizeof(header.magic)) != 0) {
|
|
|
|
qemudReportError(conn, NULL, NULL, VIR_ERR_OPERATION_FAILED,
|
Mark many more strings for translation.
* Makefile.maint (err_func_re): Add to the list and make it readable.
* po/POTFILES.in: Add src/util.c and src/xm_internal.c, and sort.
* src/storage_backend.c: Fix comment.
* src/util.c (virFileLinkPointsTo): Mark a string.
* qemud/remote.c (remoteDispatchClientRequest): Mark strings.
(remoteDispatchOpen, CHECK_CONN, remoteDispatchGetType): Likewise.
(remoteDispatchDomainGetSchedulerType): Likewise.
(remoteDispatchDomainGetSchedulerParameters): Likewise.
(remoteDispatchDomainSetSchedulerParameters): Likewise.
(remoteDispatchDomainBlockStats): Likewise.
(remoteDispatchDomainInterfaceStats): Likewise.
(remoteDispatchDomainAttachDevice, remoteDispatchDomainCreate):
(remoteDispatchDomainDestroy, remoteDispatchDomainDetachDevice):
(remoteDispatchDomainDumpXml, remoteDispatchDomainGetAutostart):
(remoteDispatchDomainGetInfo, remoteDispatchDomainGetMaxMemory):
(remoteDispatchDomainGetMaxVcpus, remoteDispatchDomainGetOsType):
(remoteDispatchDomainGetVcpus): Likewise.
(remoteDispatchDomainMigratePerform): Likewise.
(remoteDispatchListDefinedDomains, remoteDispatchDomainPinVcpu):
(remoteDispatchDomainReboot, remoteDispatchDomainResume):
(remoteDispatchDomainSave, remoteDispatchDomainCoreDump):
(remoteDispatchDomainSetAutostart): Likewise.
(remoteDispatchDomainSetMaxMemory, remoteDispatchDomainSetMemory):
(remoteDispatchDomainSetVcpus, remoteDispatchDomainShutdown):
(remoteDispatchDomainSuspend, remoteDispatchDomainUndefine):
(remoteDispatchListDefinedNetworks, remoteDispatchListDomains):
(remoteDispatchListNetworks, remoteDispatchNetworkCreate):
(remoteDispatchNetworkDestroy, remoteDispatchNetworkDumpXml):
(remoteDispatchNetworkGetAutostart, remoteDispatchNetworkGetBridgeName):
(remoteDispatchNetworkSetAutostart, remoteDispatchNetworkUndefine):
(addrToString, remoteDispatchAuthSaslInit, remoteDispatchAuthSaslStart):
(remoteDispatchAuthSaslStep, remoteDispatchListDefinedStoragePools):
(remoteDispatchListStoragePools, remoteDispatchStoragePoolCreate):
(remoteDispatchStoragePoolBuild, remoteDispatchStoragePoolDestroy):
(remoteDispatchStoragePoolDelete, remoteDispatchStoragePoolRefresh):
(remoteDispatchStoragePoolGetInfo, remoteDispatchStoragePoolDumpXml):
(remoteDispatchStoragePoolGetAutostart): Likewise.
(remoteDispatchStoragePoolSetAutostart):
(remoteDispatchStoragePoolListVolumes):
(remoteDispatchStoragePoolNumOfVolumes):
(remoteDispatchStoragePoolUndefine, remoteDispatchStorageVolCreateXml):
(remoteDispatchStorageVolDelete, remoteDispatchStorageVolGetInfo):
(remoteDispatchStorageVolDumpXml, remoteDispatchStorageVolGetPath):
(remoteDispatchStorageVolLookupByName): Likewise.
* src/qemu_driver.c (qemudOpenMonitor, qemudStartVMDaemon):
(dhcpStartDhcpDaemon, qemudStartNetworkDaemon):
(qemudDomainSuspend, qemudDomainResume, qemudDomainShutdown):
(qemudDomainGetOSType, qemudDomainSetMaxMemory):
(qemudDomainSetMemory, qemudDomainGetInfo, qemudDomainSave):
(qemudDomainRestore, qemudDomainDumpXML, qemudDomainStart):
(qemudDomainUndefine, qemudDomainChangeCDROM):
(qemudDomainAttachDevice, qemudDomainGetAutostart):
(qemudDomainSetAutostart, qemudDomainInterfaceStats):
(qemudNetworkLookupByUUID, qemudNetworkLookupByName):
(qemudNetworkUndefine, qemudNetworkStart, qemudNetworkDestroy):
(qemudNetworkDumpXML, qemudNetworkGetAutostart):
(qemudNetworkSetAutostart): Likewise.
* src/virsh.c (cmdVcpupin, cmdAttachDevice, cmdDetachDevice): Likewise.
* src/xm_internal.c (xenXMConfigCacheRefresh, xenXMDomainPinVcpu): Likewise.
2008-03-27 13:43:01 +00:00
|
|
|
"%s", _("image magic is incorrect"));
|
2008-12-04 21:04:30 +00:00
|
|
|
goto cleanup;
|
2007-08-14 01:47:24 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
if (header.version > QEMUD_SAVE_VERSION) {
|
|
|
|
qemudReportError(conn, NULL, NULL, VIR_ERR_OPERATION_FAILED,
|
2008-03-24 10:51:47 +00:00
|
|
|
_("image version is not supported (%d > %d)"),
|
2007-08-14 01:47:24 +00:00
|
|
|
header.version, QEMUD_SAVE_VERSION);
|
2008-12-04 21:04:30 +00:00
|
|
|
goto cleanup;
|
2007-08-14 01:47:24 +00:00
|
|
|
}
|
|
|
|
|
2008-05-29 19:20:22 +00:00
|
|
|
if (VIR_ALLOC_N(xml, header.xml_len) < 0) {
|
2009-02-05 16:27:40 +00:00
|
|
|
virReportOOMError(conn);
|
2008-12-04 21:04:30 +00:00
|
|
|
goto cleanup;
|
2007-08-14 01:47:24 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
if (saferead(fd, xml, header.xml_len) != header.xml_len) {
|
|
|
|
qemudReportError(conn, NULL, NULL, VIR_ERR_OPERATION_FAILED,
|
Mark many more strings for translation.
* Makefile.maint (err_func_re): Add to the list and make it readable.
* po/POTFILES.in: Add src/util.c and src/xm_internal.c, and sort.
* src/storage_backend.c: Fix comment.
* src/util.c (virFileLinkPointsTo): Mark a string.
* qemud/remote.c (remoteDispatchClientRequest): Mark strings.
(remoteDispatchOpen, CHECK_CONN, remoteDispatchGetType): Likewise.
(remoteDispatchDomainGetSchedulerType): Likewise.
(remoteDispatchDomainGetSchedulerParameters): Likewise.
(remoteDispatchDomainSetSchedulerParameters): Likewise.
(remoteDispatchDomainBlockStats): Likewise.
(remoteDispatchDomainInterfaceStats): Likewise.
(remoteDispatchDomainAttachDevice, remoteDispatchDomainCreate):
(remoteDispatchDomainDestroy, remoteDispatchDomainDetachDevice):
(remoteDispatchDomainDumpXml, remoteDispatchDomainGetAutostart):
(remoteDispatchDomainGetInfo, remoteDispatchDomainGetMaxMemory):
(remoteDispatchDomainGetMaxVcpus, remoteDispatchDomainGetOsType):
(remoteDispatchDomainGetVcpus): Likewise.
(remoteDispatchDomainMigratePerform): Likewise.
(remoteDispatchListDefinedDomains, remoteDispatchDomainPinVcpu):
(remoteDispatchDomainReboot, remoteDispatchDomainResume):
(remoteDispatchDomainSave, remoteDispatchDomainCoreDump):
(remoteDispatchDomainSetAutostart): Likewise.
(remoteDispatchDomainSetMaxMemory, remoteDispatchDomainSetMemory):
(remoteDispatchDomainSetVcpus, remoteDispatchDomainShutdown):
(remoteDispatchDomainSuspend, remoteDispatchDomainUndefine):
(remoteDispatchListDefinedNetworks, remoteDispatchListDomains):
(remoteDispatchListNetworks, remoteDispatchNetworkCreate):
(remoteDispatchNetworkDestroy, remoteDispatchNetworkDumpXml):
(remoteDispatchNetworkGetAutostart, remoteDispatchNetworkGetBridgeName):
(remoteDispatchNetworkSetAutostart, remoteDispatchNetworkUndefine):
(addrToString, remoteDispatchAuthSaslInit, remoteDispatchAuthSaslStart):
(remoteDispatchAuthSaslStep, remoteDispatchListDefinedStoragePools):
(remoteDispatchListStoragePools, remoteDispatchStoragePoolCreate):
(remoteDispatchStoragePoolBuild, remoteDispatchStoragePoolDestroy):
(remoteDispatchStoragePoolDelete, remoteDispatchStoragePoolRefresh):
(remoteDispatchStoragePoolGetInfo, remoteDispatchStoragePoolDumpXml):
(remoteDispatchStoragePoolGetAutostart): Likewise.
(remoteDispatchStoragePoolSetAutostart):
(remoteDispatchStoragePoolListVolumes):
(remoteDispatchStoragePoolNumOfVolumes):
(remoteDispatchStoragePoolUndefine, remoteDispatchStorageVolCreateXml):
(remoteDispatchStorageVolDelete, remoteDispatchStorageVolGetInfo):
(remoteDispatchStorageVolDumpXml, remoteDispatchStorageVolGetPath):
(remoteDispatchStorageVolLookupByName): Likewise.
* src/qemu_driver.c (qemudOpenMonitor, qemudStartVMDaemon):
(dhcpStartDhcpDaemon, qemudStartNetworkDaemon):
(qemudDomainSuspend, qemudDomainResume, qemudDomainShutdown):
(qemudDomainGetOSType, qemudDomainSetMaxMemory):
(qemudDomainSetMemory, qemudDomainGetInfo, qemudDomainSave):
(qemudDomainRestore, qemudDomainDumpXML, qemudDomainStart):
(qemudDomainUndefine, qemudDomainChangeCDROM):
(qemudDomainAttachDevice, qemudDomainGetAutostart):
(qemudDomainSetAutostart, qemudDomainInterfaceStats):
(qemudNetworkLookupByUUID, qemudNetworkLookupByName):
(qemudNetworkUndefine, qemudNetworkStart, qemudNetworkDestroy):
(qemudNetworkDumpXML, qemudNetworkGetAutostart):
(qemudNetworkSetAutostart): Likewise.
* src/virsh.c (cmdVcpupin, cmdAttachDevice, cmdDetachDevice): Likewise.
* src/xm_internal.c (xenXMConfigCacheRefresh, xenXMDomainPinVcpu): Likewise.
2008-03-27 13:43:01 +00:00
|
|
|
"%s", _("failed to read XML"));
|
2008-12-04 21:04:30 +00:00
|
|
|
goto cleanup;
|
2007-08-14 01:47:24 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
/* Create a domain from this XML */
|
2009-01-08 13:54:20 +00:00
|
|
|
if (!(def = virDomainDefParseString(conn, driver->caps, xml,
|
|
|
|
VIR_DOMAIN_XML_INACTIVE))) {
|
2007-08-14 01:47:24 +00:00
|
|
|
qemudReportError(conn, NULL, NULL, VIR_ERR_OPERATION_FAILED,
|
Mark many more strings for translation.
* Makefile.maint (err_func_re): Add to the list and make it readable.
* po/POTFILES.in: Add src/util.c and src/xm_internal.c, and sort.
* src/storage_backend.c: Fix comment.
* src/util.c (virFileLinkPointsTo): Mark a string.
* qemud/remote.c (remoteDispatchClientRequest): Mark strings.
(remoteDispatchOpen, CHECK_CONN, remoteDispatchGetType): Likewise.
(remoteDispatchDomainGetSchedulerType): Likewise.
(remoteDispatchDomainGetSchedulerParameters): Likewise.
(remoteDispatchDomainSetSchedulerParameters): Likewise.
(remoteDispatchDomainBlockStats): Likewise.
(remoteDispatchDomainInterfaceStats): Likewise.
(remoteDispatchDomainAttachDevice, remoteDispatchDomainCreate):
(remoteDispatchDomainDestroy, remoteDispatchDomainDetachDevice):
(remoteDispatchDomainDumpXml, remoteDispatchDomainGetAutostart):
(remoteDispatchDomainGetInfo, remoteDispatchDomainGetMaxMemory):
(remoteDispatchDomainGetMaxVcpus, remoteDispatchDomainGetOsType):
(remoteDispatchDomainGetVcpus): Likewise.
(remoteDispatchDomainMigratePerform): Likewise.
(remoteDispatchListDefinedDomains, remoteDispatchDomainPinVcpu):
(remoteDispatchDomainReboot, remoteDispatchDomainResume):
(remoteDispatchDomainSave, remoteDispatchDomainCoreDump):
(remoteDispatchDomainSetAutostart): Likewise.
(remoteDispatchDomainSetMaxMemory, remoteDispatchDomainSetMemory):
(remoteDispatchDomainSetVcpus, remoteDispatchDomainShutdown):
(remoteDispatchDomainSuspend, remoteDispatchDomainUndefine):
(remoteDispatchListDefinedNetworks, remoteDispatchListDomains):
(remoteDispatchListNetworks, remoteDispatchNetworkCreate):
(remoteDispatchNetworkDestroy, remoteDispatchNetworkDumpXml):
(remoteDispatchNetworkGetAutostart, remoteDispatchNetworkGetBridgeName):
(remoteDispatchNetworkSetAutostart, remoteDispatchNetworkUndefine):
(addrToString, remoteDispatchAuthSaslInit, remoteDispatchAuthSaslStart):
(remoteDispatchAuthSaslStep, remoteDispatchListDefinedStoragePools):
(remoteDispatchListStoragePools, remoteDispatchStoragePoolCreate):
(remoteDispatchStoragePoolBuild, remoteDispatchStoragePoolDestroy):
(remoteDispatchStoragePoolDelete, remoteDispatchStoragePoolRefresh):
(remoteDispatchStoragePoolGetInfo, remoteDispatchStoragePoolDumpXml):
(remoteDispatchStoragePoolGetAutostart): Likewise.
(remoteDispatchStoragePoolSetAutostart):
(remoteDispatchStoragePoolListVolumes):
(remoteDispatchStoragePoolNumOfVolumes):
(remoteDispatchStoragePoolUndefine, remoteDispatchStorageVolCreateXml):
(remoteDispatchStorageVolDelete, remoteDispatchStorageVolGetInfo):
(remoteDispatchStorageVolDumpXml, remoteDispatchStorageVolGetPath):
(remoteDispatchStorageVolLookupByName): Likewise.
* src/qemu_driver.c (qemudOpenMonitor, qemudStartVMDaemon):
(dhcpStartDhcpDaemon, qemudStartNetworkDaemon):
(qemudDomainSuspend, qemudDomainResume, qemudDomainShutdown):
(qemudDomainGetOSType, qemudDomainSetMaxMemory):
(qemudDomainSetMemory, qemudDomainGetInfo, qemudDomainSave):
(qemudDomainRestore, qemudDomainDumpXML, qemudDomainStart):
(qemudDomainUndefine, qemudDomainChangeCDROM):
(qemudDomainAttachDevice, qemudDomainGetAutostart):
(qemudDomainSetAutostart, qemudDomainInterfaceStats):
(qemudNetworkLookupByUUID, qemudNetworkLookupByName):
(qemudNetworkUndefine, qemudNetworkStart, qemudNetworkDestroy):
(qemudNetworkDumpXML, qemudNetworkGetAutostart):
(qemudNetworkSetAutostart): Likewise.
* src/virsh.c (cmdVcpupin, cmdAttachDevice, cmdDetachDevice): Likewise.
* src/xm_internal.c (xenXMConfigCacheRefresh, xenXMDomainPinVcpu): Likewise.
2008-03-27 13:43:01 +00:00
|
|
|
"%s", _("failed to parse XML"));
|
2008-12-04 21:04:30 +00:00
|
|
|
goto cleanup;
|
2007-08-14 01:47:24 +00:00
|
|
|
}
|
|
|
|
|
2009-11-02 18:37:38 +00:00
|
|
|
if (virDomainObjIsDuplicate(&driver->domains, def, 1) < 0)
|
|
|
|
goto cleanup;
|
2007-08-14 01:47:24 +00:00
|
|
|
|
2008-07-11 19:34:11 +00:00
|
|
|
if (!(vm = virDomainAssignDef(conn,
|
2009-10-06 11:50:58 +00:00
|
|
|
driver->caps,
|
2008-07-11 19:34:11 +00:00
|
|
|
&driver->domains,
|
|
|
|
def))) {
|
2007-08-14 01:47:24 +00:00
|
|
|
qemudReportError(conn, NULL, NULL, VIR_ERR_OPERATION_FAILED,
|
Mark many more strings for translation.
* Makefile.maint (err_func_re): Add to the list and make it readable.
* po/POTFILES.in: Add src/util.c and src/xm_internal.c, and sort.
* src/storage_backend.c: Fix comment.
* src/util.c (virFileLinkPointsTo): Mark a string.
* qemud/remote.c (remoteDispatchClientRequest): Mark strings.
(remoteDispatchOpen, CHECK_CONN, remoteDispatchGetType): Likewise.
(remoteDispatchDomainGetSchedulerType): Likewise.
(remoteDispatchDomainGetSchedulerParameters): Likewise.
(remoteDispatchDomainSetSchedulerParameters): Likewise.
(remoteDispatchDomainBlockStats): Likewise.
(remoteDispatchDomainInterfaceStats): Likewise.
(remoteDispatchDomainAttachDevice, remoteDispatchDomainCreate):
(remoteDispatchDomainDestroy, remoteDispatchDomainDetachDevice):
(remoteDispatchDomainDumpXml, remoteDispatchDomainGetAutostart):
(remoteDispatchDomainGetInfo, remoteDispatchDomainGetMaxMemory):
(remoteDispatchDomainGetMaxVcpus, remoteDispatchDomainGetOsType):
(remoteDispatchDomainGetVcpus): Likewise.
(remoteDispatchDomainMigratePerform): Likewise.
(remoteDispatchListDefinedDomains, remoteDispatchDomainPinVcpu):
(remoteDispatchDomainReboot, remoteDispatchDomainResume):
(remoteDispatchDomainSave, remoteDispatchDomainCoreDump):
(remoteDispatchDomainSetAutostart): Likewise.
(remoteDispatchDomainSetMaxMemory, remoteDispatchDomainSetMemory):
(remoteDispatchDomainSetVcpus, remoteDispatchDomainShutdown):
(remoteDispatchDomainSuspend, remoteDispatchDomainUndefine):
(remoteDispatchListDefinedNetworks, remoteDispatchListDomains):
(remoteDispatchListNetworks, remoteDispatchNetworkCreate):
(remoteDispatchNetworkDestroy, remoteDispatchNetworkDumpXml):
(remoteDispatchNetworkGetAutostart, remoteDispatchNetworkGetBridgeName):
(remoteDispatchNetworkSetAutostart, remoteDispatchNetworkUndefine):
(addrToString, remoteDispatchAuthSaslInit, remoteDispatchAuthSaslStart):
(remoteDispatchAuthSaslStep, remoteDispatchListDefinedStoragePools):
(remoteDispatchListStoragePools, remoteDispatchStoragePoolCreate):
(remoteDispatchStoragePoolBuild, remoteDispatchStoragePoolDestroy):
(remoteDispatchStoragePoolDelete, remoteDispatchStoragePoolRefresh):
(remoteDispatchStoragePoolGetInfo, remoteDispatchStoragePoolDumpXml):
(remoteDispatchStoragePoolGetAutostart): Likewise.
(remoteDispatchStoragePoolSetAutostart):
(remoteDispatchStoragePoolListVolumes):
(remoteDispatchStoragePoolNumOfVolumes):
(remoteDispatchStoragePoolUndefine, remoteDispatchStorageVolCreateXml):
(remoteDispatchStorageVolDelete, remoteDispatchStorageVolGetInfo):
(remoteDispatchStorageVolDumpXml, remoteDispatchStorageVolGetPath):
(remoteDispatchStorageVolLookupByName): Likewise.
* src/qemu_driver.c (qemudOpenMonitor, qemudStartVMDaemon):
(dhcpStartDhcpDaemon, qemudStartNetworkDaemon):
(qemudDomainSuspend, qemudDomainResume, qemudDomainShutdown):
(qemudDomainGetOSType, qemudDomainSetMaxMemory):
(qemudDomainSetMemory, qemudDomainGetInfo, qemudDomainSave):
(qemudDomainRestore, qemudDomainDumpXML, qemudDomainStart):
(qemudDomainUndefine, qemudDomainChangeCDROM):
(qemudDomainAttachDevice, qemudDomainGetAutostart):
(qemudDomainSetAutostart, qemudDomainInterfaceStats):
(qemudNetworkLookupByUUID, qemudNetworkLookupByName):
(qemudNetworkUndefine, qemudNetworkStart, qemudNetworkDestroy):
(qemudNetworkDumpXML, qemudNetworkGetAutostart):
(qemudNetworkSetAutostart): Likewise.
* src/virsh.c (cmdVcpupin, cmdAttachDevice, cmdDetachDevice): Likewise.
* src/xm_internal.c (xenXMConfigCacheRefresh, xenXMDomainPinVcpu): Likewise.
2008-03-27 13:43:01 +00:00
|
|
|
"%s", _("failed to assign new VM"));
|
2008-12-04 21:04:30 +00:00
|
|
|
goto cleanup;
|
2007-08-14 01:47:24 +00:00
|
|
|
}
|
2008-12-04 21:04:30 +00:00
|
|
|
def = NULL;
|
2007-08-14 01:47:24 +00:00
|
|
|
|
2009-11-03 18:26:32 +00:00
|
|
|
if (qemuDomainObjBeginJobWithDriver(driver, vm) < 0)
|
|
|
|
goto cleanup;
|
|
|
|
|
Compressed save image format for Qemu.
Implement a compressed save image format for qemu. While ideally
we would have the choice between compressed/non-compressed
available to the libvirt API, unfortunately there is no "flags"
parameter to the virDomainSave() API. Therefore, implement this
as a qemu.conf option. gzip, bzip2, and lzma are implemented, and
it should be very easy to implement additional compression
methods.
One open question is if/how we should detect the compression
binaries. One way to do it is to do compile-time setting of the
paths (via configure.in), but that doesn't seem like a great thing
to do. My preferred solution is not to detect at all;
when we go to run the commands that need them, if they
aren't available, or aren't available in one of the standard paths,
then we'll fail. That's also the solution implemented in this patch.
In the future, we'll have a more robust (managed) save/restore API,
at which time we can expose this functionality properly in the API.
V2: get rid of redundant dd command and just use >> to append data.
V3: Add back the missing pieces for the enum and bumping the save version.
V4: Make the compressed field in the save_header an int.
Implement LZMA compression.
Signed-off-by: Chris Lalancette <clalance@redhat.com>
2009-08-07 11:34:05 +00:00
|
|
|
if (header.version == 2) {
|
|
|
|
const char *intermediate_argv[3] = { NULL, "-dc", NULL };
|
2009-09-10 09:26:00 +00:00
|
|
|
const char *prog = qemudSaveCompressionTypeToString(header.compressed);
|
|
|
|
if (prog == NULL) {
|
Compressed save image format for Qemu.
Implement a compressed save image format for qemu. While ideally
we would have the choice between compressed/non-compressed
available to the libvirt API, unfortunately there is no "flags"
parameter to the virDomainSave() API. Therefore, implement this
as a qemu.conf option. gzip, bzip2, and lzma are implemented, and
it should be very easy to implement additional compression
methods.
One open question is if/how we should detect the compression
binaries. One way to do it is to do compile-time setting of the
paths (via configure.in), but that doesn't seem like a great thing
to do. My preferred solution is not to detect at all;
when we go to run the commands that need them, if they
aren't available, or aren't available in one of the standard paths,
then we'll fail. That's also the solution implemented in this patch.
In the future, we'll have a more robust (managed) save/restore API,
at which time we can expose this functionality properly in the API.
V2: get rid of redundant dd command and just use >> to append data.
V3: Add back the missing pieces for the enum and bumping the save version.
V4: Make the compressed field in the save_header an int.
Implement LZMA compression.
Signed-off-by: Chris Lalancette <clalance@redhat.com>
2009-08-07 11:34:05 +00:00
|
|
|
qemudReportError(conn, NULL, NULL, VIR_ERR_OPERATION_FAILED,
|
2009-09-10 09:26:00 +00:00
|
|
|
_("Invalid compressed save format %d"),
|
Compressed save image format for Qemu.
Implement a compressed save image format for qemu. While ideally
we would have the choice between compressed/non-compressed
available to the libvirt API, unfortunately there is no "flags"
parameter to the virDomainSave() API. Therefore, implement this
as a qemu.conf option. gzip, bzip2, and lzma are implemented, and
it should be very easy to implement additional compression
methods.
One open question is if/how we should detect the compression
binaries. One way to do it is to do compile-time setting of the
paths (via configure.in), but that doesn't seem like a great thing
to do. My preferred solution is not to detect at all;
when we go to run the commands that need them, if they
aren't available, or aren't available in one of the standard paths,
then we'll fail. That's also the solution implemented in this patch.
In the future, we'll have a more robust (managed) save/restore API,
at which time we can expose this functionality properly in the API.
V2: get rid of redundant dd command and just use >> to append data.
V3: Add back the missing pieces for the enum and bumping the save version.
V4: Make the compressed field in the save_header an int.
Implement LZMA compression.
Signed-off-by: Chris Lalancette <clalance@redhat.com>
2009-08-07 11:34:05 +00:00
|
|
|
header.compressed);
|
2009-11-03 18:26:32 +00:00
|
|
|
goto endjob;
|
Compressed save image format for Qemu.
Implement a compressed save image format for qemu. While ideally
we would have the choice between compressed/non-compressed
available to the libvirt API, unfortunately there is no "flags"
parameter to the virDomainSave() API. Therefore, implement this
as a qemu.conf option. gzip, bzip2, and lzma are implemented, and
it should be very easy to implement additional compression
methods.
One open question is if/how we should detect the compression
binaries. One way to do it is to do compile-time setting of the
paths (via configure.in), but that doesn't seem like a great thing
to do. My preferred solution is not to detect at all;
when we go to run the commands that need them, if they
aren't available, or aren't available in one of the standard paths,
then we'll fail. That's also the solution implemented in this patch.
In the future, we'll have a more robust (managed) save/restore API,
at which time we can expose this functionality properly in the API.
V2: get rid of redundant dd command and just use >> to append data.
V3: Add back the missing pieces for the enum and bumping the save version.
V4: Make the compressed field in the save_header an int.
Implement LZMA compression.
Signed-off-by: Chris Lalancette <clalance@redhat.com>
2009-08-07 11:34:05 +00:00
|
|
|
}
|
2009-09-10 09:26:00 +00:00
|
|
|
|
2009-10-12 19:03:50 +00:00
|
|
|
if (header.compressed != QEMUD_SAVE_FORMAT_RAW) {
|
2009-09-10 09:26:00 +00:00
|
|
|
intermediate_argv[0] = prog;
|
Compressed save image format for Qemu.
Implement a compressed save image format for qemu. While ideally
we would have the choice between compressed/non-compressed
available to the libvirt API, unfortunately there is no "flags"
parameter to the virDomainSave() API. Therefore, implement this
as a qemu.conf option. gzip, bzip2, and lzma are implemented, and
it should be very easy to implement additional compression
methods.
One open question is if/how we should detect the compression
binaries. One way to do it is to do compile-time setting of the
paths (via configure.in), but that doesn't seem like a great thing
to do. My preferred solution is not to detect at all;
when we go to run the commands that need them, if they
aren't available, or aren't available in one of the standard paths,
then we'll fail. That's also the solution implemented in this patch.
In the future, we'll have a more robust (managed) save/restore API,
at which time we can expose this functionality properly in the API.
V2: get rid of redundant dd command and just use >> to append data.
V3: Add back the missing pieces for the enum and bumping the save version.
V4: Make the compressed field in the save_header an int.
Implement LZMA compression.
Signed-off-by: Chris Lalancette <clalance@redhat.com>
2009-08-07 11:34:05 +00:00
|
|
|
intermediatefd = fd;
|
|
|
|
fd = -1;
|
|
|
|
if (virExec(conn, intermediate_argv, NULL, NULL,
|
|
|
|
&intermediate_pid, intermediatefd, &fd, NULL, 0) < 0) {
|
|
|
|
qemudReportError(conn, NULL, NULL, VIR_ERR_INTERNAL_ERROR,
|
|
|
|
_("Failed to start decompression binary %s"),
|
|
|
|
intermediate_argv[0]);
|
2009-11-03 18:26:32 +00:00
|
|
|
goto endjob;
|
Compressed save image format for Qemu.
Implement a compressed save image format for qemu. While ideally
we would have the choice between compressed/non-compressed
available to the libvirt API, unfortunately there is no "flags"
parameter to the virDomainSave() API. Therefore, implement this
as a qemu.conf option. gzip, bzip2, and lzma are implemented, and
it should be very easy to implement additional compression
methods.
One open question is if/how we should detect the compression
binaries. One way to do it is to do compile-time setting of the
paths (via configure.in), but that doesn't seem like a great thing
to do. My preferred solution is not to detect at all;
when we go to run the commands that need them, if they
aren't available, or aren't available in one of the standard paths,
then we'll fail. That's also the solution implemented in this patch.
In the future, we'll have a more robust (managed) save/restore API,
at which time we can expose this functionality properly in the API.
V2: get rid of redundant dd command and just use >> to append data.
V3: Add back the missing pieces for the enum and bumping the save version.
V4: Make the compressed field in the save_header an int.
Implement LZMA compression.
Signed-off-by: Chris Lalancette <clalance@redhat.com>
2009-08-07 11:34:05 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
2007-08-14 01:47:24 +00:00
|
|
|
/* Set the migration source and start it up. */
|
2009-01-29 17:27:54 +00:00
|
|
|
ret = qemudStartVMDaemon(conn, driver, vm, "stdio", fd);
|
Compressed save image format for Qemu.
Implement a compressed save image format for qemu. While ideally
we would have the choice between compressed/non-compressed
available to the libvirt API, unfortunately there is no "flags"
parameter to the virDomainSave() API. Therefore, implement this
as a qemu.conf option. gzip, bzip2, and lzma are implemented, and
it should be very easy to implement additional compression
methods.
One open question is if/how we should detect the compression
binaries. One way to do it is to do compile-time setting of the
paths (via configure.in), but that doesn't seem like a great thing
to do. My preferred solution is not to detect at all;
when we go to run the commands that need them, if they
aren't available, or aren't available in one of the standard paths,
then we'll fail. That's also the solution implemented in this patch.
In the future, we'll have a more robust (managed) save/restore API,
at which time we can expose this functionality properly in the API.
V2: get rid of redundant dd command and just use >> to append data.
V3: Add back the missing pieces for the enum and bumping the save version.
V4: Make the compressed field in the save_header an int.
Implement LZMA compression.
Signed-off-by: Chris Lalancette <clalance@redhat.com>
2009-08-07 11:34:05 +00:00
|
|
|
if (intermediate_pid != -1) {
|
|
|
|
/* Wait for intermediate process to exit */
|
|
|
|
while (waitpid(intermediate_pid, &childstat, 0) == -1 &&
|
|
|
|
errno == EINTR);
|
|
|
|
}
|
|
|
|
if (intermediatefd != -1)
|
|
|
|
close(intermediatefd);
|
2007-10-10 19:46:17 +00:00
|
|
|
close(fd);
|
2008-12-04 21:04:30 +00:00
|
|
|
fd = -1;
|
2007-10-10 19:46:17 +00:00
|
|
|
if (ret < 0) {
|
2008-12-04 21:06:41 +00:00
|
|
|
if (!vm->persistent) {
|
2009-12-08 14:42:43 +00:00
|
|
|
if (qemuDomainObjEndJob(vm) > 0)
|
|
|
|
virDomainRemoveInactive(&driver->domains,
|
|
|
|
vm);
|
2008-12-04 21:06:41 +00:00
|
|
|
vm = NULL;
|
|
|
|
}
|
2009-11-03 18:26:32 +00:00
|
|
|
goto endjob;
|
2007-08-14 01:47:24 +00:00
|
|
|
}
|
|
|
|
|
2008-12-04 21:09:20 +00:00
|
|
|
event = virDomainEventNewFromObj(vm,
|
|
|
|
VIR_DOMAIN_EVENT_STARTED,
|
|
|
|
VIR_DOMAIN_EVENT_STARTED_RESTORED);
|
2008-11-17 16:43:00 +00:00
|
|
|
|
2007-08-14 01:47:24 +00:00
|
|
|
/* If it was running before, resume it now. */
|
|
|
|
if (header.was_running) {
|
2009-10-09 20:13:06 +00:00
|
|
|
qemuDomainObjPrivatePtr priv = vm->privateData;
|
2009-11-03 18:26:32 +00:00
|
|
|
qemuDomainObjEnterMonitorWithDriver(driver, vm);
|
2009-10-09 20:13:06 +00:00
|
|
|
if (qemuMonitorStartCPUs(priv->mon, conn) < 0) {
|
2009-07-21 09:53:17 +00:00
|
|
|
if (virGetLastError() == NULL)
|
|
|
|
qemudReportError(conn, NULL, NULL, VIR_ERR_OPERATION_FAILED,
|
|
|
|
"%s", _("failed to resume domain"));
|
2009-11-03 18:26:32 +00:00
|
|
|
qemuDomainObjExitMonitorWithDriver(driver,vm);
|
|
|
|
goto endjob;
|
2007-08-14 01:47:24 +00:00
|
|
|
}
|
2009-11-03 18:26:32 +00:00
|
|
|
qemuDomainObjExitMonitorWithDriver(driver, vm);
|
2007-08-14 01:47:24 +00:00
|
|
|
vm->state = VIR_DOMAIN_RUNNING;
|
2009-11-26 17:57:00 +00:00
|
|
|
virDomainSaveStatus(conn, driver->caps, driver->stateDir, vm);
|
2007-08-14 01:47:24 +00:00
|
|
|
}
|
2008-12-04 21:04:30 +00:00
|
|
|
ret = 0;
|
2007-08-14 01:47:24 +00:00
|
|
|
|
2009-11-03 18:26:32 +00:00
|
|
|
endjob:
|
2009-12-08 14:42:43 +00:00
|
|
|
if (vm &&
|
|
|
|
qemuDomainObjEndJob(vm) == 0)
|
|
|
|
vm = NULL;
|
2009-11-03 18:26:32 +00:00
|
|
|
|
2008-12-04 21:04:30 +00:00
|
|
|
cleanup:
|
|
|
|
virDomainDefFree(def);
|
|
|
|
VIR_FREE(xml);
|
|
|
|
if (fd != -1)
|
|
|
|
close(fd);
|
2008-12-04 21:06:41 +00:00
|
|
|
if (vm)
|
|
|
|
virDomainObjUnlock(vm);
|
2008-12-04 21:09:20 +00:00
|
|
|
if (event)
|
|
|
|
qemuDomainEventQueue(driver, event);
|
2008-12-04 21:06:41 +00:00
|
|
|
qemuDriverUnlock(driver);
|
2008-12-04 21:04:30 +00:00
|
|
|
return ret;
|
2007-02-14 01:40:09 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
|
2007-06-29 13:23:13 +00:00
|
|
|
static char *qemudDomainDumpXML(virDomainPtr dom,
|
2009-02-18 01:37:47 +00:00
|
|
|
int flags) {
|
2008-12-04 21:04:30 +00:00
|
|
|
struct qemud_driver *driver = dom->conn->privateData;
|
|
|
|
virDomainObjPtr vm;
|
|
|
|
char *ret = NULL;
|
2009-03-27 11:44:29 +00:00
|
|
|
unsigned long balloon;
|
|
|
|
int err;
|
2008-12-04 21:04:30 +00:00
|
|
|
|
2008-12-04 21:06:41 +00:00
|
|
|
qemuDriverLock(driver);
|
2008-12-04 21:04:30 +00:00
|
|
|
vm = virDomainFindByUUID(&driver->domains, dom->uuid);
|
2008-12-04 21:06:41 +00:00
|
|
|
qemuDriverUnlock(driver);
|
|
|
|
|
2007-02-14 01:40:09 +00:00
|
|
|
if (!vm) {
|
2009-04-19 15:30:50 +00:00
|
|
|
char uuidstr[VIR_UUID_STRING_BUFLEN];
|
|
|
|
virUUIDFormat(dom->uuid, uuidstr);
|
|
|
|
qemudReportError(dom->conn, dom, NULL, VIR_ERR_NO_DOMAIN,
|
|
|
|
_("no domain with matching uuid '%s'"), uuidstr);
|
2008-12-04 21:04:30 +00:00
|
|
|
goto cleanup;
|
2007-02-14 01:40:09 +00:00
|
|
|
}
|
|
|
|
|
2009-03-27 11:44:29 +00:00
|
|
|
/* Refresh current memory based on balloon info */
|
Rename internal APis
Rename virDomainIsActive to virDomainObjIsActive, and
virInterfaceIsActive to virInterfaceObjIsActive and finally
virNetworkIsActive to virNetworkObjIsActive.
* src/conf/domain_conf.c, src/conf/domain_conf.h,
src/conf/interface_conf.h, src/conf/network_conf.c,
src/conf/network_conf.h, src/lxc/lxc_driver.c,
src/network/bridge_driver.c, src/opennebula/one_driver.c,
src/openvz/openvz_driver.c, src/qemu/qemu_driver.c,
src/test/test_driver.c, src/uml/uml_driver.c: Update for
renamed APIs.
2009-10-20 14:51:03 +00:00
|
|
|
if (virDomainObjIsActive(vm)) {
|
2009-10-09 20:13:06 +00:00
|
|
|
qemuDomainObjPrivatePtr priv = vm->privateData;
|
2009-11-03 18:26:32 +00:00
|
|
|
/* Don't delay if someone's using the monitor, just use
|
|
|
|
* existing most recent data instead */
|
|
|
|
if (!priv->jobActive) {
|
|
|
|
if (qemuDomainObjBeginJob(vm) < 0)
|
|
|
|
goto cleanup;
|
|
|
|
|
|
|
|
qemuDomainObjEnterMonitor(vm);
|
|
|
|
err = qemuMonitorGetBalloonInfo(priv->mon, &balloon);
|
|
|
|
qemuDomainObjExitMonitor(vm);
|
2009-12-08 14:42:43 +00:00
|
|
|
if (qemuDomainObjEndJob(vm) == 0) {
|
|
|
|
vm = NULL;
|
|
|
|
goto cleanup;
|
|
|
|
}
|
2009-11-03 18:26:32 +00:00
|
|
|
if (err < 0)
|
|
|
|
goto cleanup;
|
|
|
|
if (err > 0)
|
|
|
|
vm->def->memory = balloon;
|
|
|
|
/* err == 0 indicates no balloon support, so ignore it */
|
|
|
|
}
|
2009-09-23 11:29:39 +00:00
|
|
|
}
|
2009-03-27 11:44:29 +00:00
|
|
|
|
2008-12-04 21:04:30 +00:00
|
|
|
ret = virDomainDefFormat(dom->conn,
|
|
|
|
(flags & VIR_DOMAIN_XML_INACTIVE) && vm->newDef ?
|
|
|
|
vm->newDef : vm->def,
|
|
|
|
flags);
|
|
|
|
|
|
|
|
cleanup:
|
2008-12-04 21:06:41 +00:00
|
|
|
if (vm)
|
|
|
|
virDomainObjUnlock(vm);
|
2008-12-04 21:04:30 +00:00
|
|
|
return ret;
|
2007-02-14 01:40:09 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
|
2009-05-21 14:16:55 +00:00
|
|
|
static char *qemuDomainXMLFromNative(virConnectPtr conn,
|
|
|
|
const char *format,
|
|
|
|
const char *config,
|
|
|
|
unsigned int flags ATTRIBUTE_UNUSED) {
|
2009-05-28 13:21:19 +00:00
|
|
|
struct qemud_driver *driver = conn->privateData;
|
2009-05-21 14:16:55 +00:00
|
|
|
virDomainDefPtr def = NULL;
|
|
|
|
char *xml = NULL;
|
|
|
|
|
|
|
|
if (STRNEQ(format, QEMU_CONFIG_FORMAT_ARGV)) {
|
|
|
|
qemudReportError(conn, NULL, NULL, VIR_ERR_INVALID_ARG,
|
|
|
|
_("unsupported config type %s"), format);
|
|
|
|
goto cleanup;
|
|
|
|
}
|
|
|
|
|
2009-09-02 13:02:06 +00:00
|
|
|
qemuDriverLock(driver);
|
2009-05-28 13:21:19 +00:00
|
|
|
def = qemuParseCommandLineString(conn, driver->caps, config);
|
2009-09-02 13:02:06 +00:00
|
|
|
qemuDriverUnlock(driver);
|
2009-05-21 14:16:55 +00:00
|
|
|
if (!def)
|
|
|
|
goto cleanup;
|
|
|
|
|
|
|
|
xml = virDomainDefFormat(conn, def, VIR_DOMAIN_XML_INACTIVE);
|
|
|
|
|
|
|
|
cleanup:
|
|
|
|
virDomainDefFree(def);
|
|
|
|
return xml;
|
|
|
|
}
|
|
|
|
|
2009-05-21 14:14:01 +00:00
|
|
|
static char *qemuDomainXMLToNative(virConnectPtr conn,
|
|
|
|
const char *format,
|
|
|
|
const char *xmlData,
|
|
|
|
unsigned int flags ATTRIBUTE_UNUSED) {
|
|
|
|
struct qemud_driver *driver = conn->privateData;
|
|
|
|
virDomainDefPtr def = NULL;
|
2009-11-26 17:57:00 +00:00
|
|
|
virDomainChrDef monConfig;
|
2009-05-21 14:14:01 +00:00
|
|
|
const char *emulator;
|
|
|
|
unsigned int qemuCmdFlags;
|
|
|
|
struct stat sb;
|
|
|
|
const char **retargv = NULL;
|
|
|
|
const char **retenv = NULL;
|
|
|
|
const char **tmp;
|
|
|
|
virBuffer buf = VIR_BUFFER_INITIALIZER;
|
|
|
|
char *ret = NULL;
|
|
|
|
int i;
|
|
|
|
|
2009-05-21 14:16:55 +00:00
|
|
|
qemuDriverLock(driver);
|
|
|
|
|
2009-05-21 14:14:01 +00:00
|
|
|
if (STRNEQ(format, QEMU_CONFIG_FORMAT_ARGV)) {
|
|
|
|
qemudReportError(conn, NULL, NULL, VIR_ERR_INVALID_ARG,
|
|
|
|
_("unsupported config type %s"), format);
|
|
|
|
goto cleanup;
|
|
|
|
}
|
|
|
|
|
|
|
|
def = virDomainDefParseString(conn, driver->caps, xmlData, 0);
|
|
|
|
if (!def)
|
|
|
|
goto cleanup;
|
|
|
|
|
|
|
|
/* Since we're just exporting args, we can't do bridge/network
|
|
|
|
* setups, since libvirt will normally create TAP devices
|
|
|
|
* directly. We convert those configs into generic 'ethernet'
|
|
|
|
* config and assume the user has suitable 'ifup-qemu' scripts
|
|
|
|
*/
|
|
|
|
for (i = 0 ; i < def->nnets ; i++) {
|
|
|
|
virDomainNetDefPtr net = def->nets[i];
|
|
|
|
if (net->type == VIR_DOMAIN_NET_TYPE_NETWORK) {
|
|
|
|
VIR_FREE(net->data.network.name);
|
|
|
|
|
|
|
|
memset(net, 0, sizeof *net);
|
|
|
|
|
|
|
|
net->type = VIR_DOMAIN_NET_TYPE_ETHERNET;
|
|
|
|
net->data.ethernet.dev = NULL;
|
|
|
|
net->data.ethernet.script = NULL;
|
|
|
|
net->data.ethernet.ipaddr = NULL;
|
|
|
|
} else if (net->type == VIR_DOMAIN_NET_TYPE_BRIDGE) {
|
|
|
|
char *brname = net->data.bridge.brname;
|
|
|
|
char *script = net->data.bridge.script;
|
|
|
|
char *ipaddr = net->data.bridge.ipaddr;
|
|
|
|
|
|
|
|
memset(net, 0, sizeof *net);
|
|
|
|
|
|
|
|
net->type = VIR_DOMAIN_NET_TYPE_ETHERNET;
|
|
|
|
net->data.ethernet.dev = brname;
|
|
|
|
net->data.ethernet.script = script;
|
|
|
|
net->data.ethernet.ipaddr = ipaddr;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
for (i = 0 ; i < def->ngraphics ; i++) {
|
|
|
|
if (def->graphics[i]->type == VIR_DOMAIN_GRAPHICS_TYPE_VNC &&
|
|
|
|
def->graphics[i]->data.vnc.autoport)
|
|
|
|
def->graphics[i]->data.vnc.port = 5900;
|
|
|
|
}
|
|
|
|
emulator = def->emulator;
|
|
|
|
|
|
|
|
/* Make sure the binary we are about to try exec'ing exists.
|
|
|
|
* Technically we could catch the exec() failure, but that's
|
|
|
|
* in a sub-process so its hard to feed back a useful error
|
|
|
|
*/
|
|
|
|
if (stat(emulator, &sb) < 0) {
|
|
|
|
virReportSystemError(conn, errno,
|
|
|
|
_("Cannot find QEMU binary %s"),
|
|
|
|
emulator);
|
|
|
|
goto cleanup;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (qemudExtractVersionInfo(emulator,
|
|
|
|
NULL,
|
|
|
|
&qemuCmdFlags) < 0) {
|
|
|
|
qemudReportError(conn, NULL, NULL, VIR_ERR_INTERNAL_ERROR,
|
|
|
|
_("Cannot determine QEMU argv syntax %s"),
|
|
|
|
emulator);
|
|
|
|
goto cleanup;
|
|
|
|
}
|
|
|
|
|
2009-11-26 17:57:00 +00:00
|
|
|
if (qemuPrepareMonitorChr(conn, driver, &monConfig, def->name) < 0)
|
2009-07-09 17:33:40 +00:00
|
|
|
goto cleanup;
|
2009-05-21 14:14:01 +00:00
|
|
|
|
|
|
|
if (qemudBuildCommandLine(conn, driver, def,
|
2009-11-03 18:59:18 +00:00
|
|
|
&monConfig, 0, qemuCmdFlags,
|
2009-05-21 14:14:01 +00:00
|
|
|
&retargv, &retenv,
|
|
|
|
NULL, NULL, /* Don't want it to create TAP devices */
|
|
|
|
NULL) < 0) {
|
|
|
|
goto cleanup;
|
|
|
|
}
|
|
|
|
|
|
|
|
tmp = retenv;
|
|
|
|
while (*tmp) {
|
|
|
|
virBufferAdd(&buf, *tmp, strlen(*tmp));
|
|
|
|
virBufferAddLit(&buf, " ");
|
|
|
|
tmp++;
|
|
|
|
}
|
|
|
|
tmp = retargv;
|
|
|
|
while (*tmp) {
|
|
|
|
virBufferAdd(&buf, *tmp, strlen(*tmp));
|
|
|
|
virBufferAddLit(&buf, " ");
|
|
|
|
tmp++;
|
|
|
|
}
|
|
|
|
|
2009-12-09 23:00:50 +00:00
|
|
|
if (virBufferError(&buf)) {
|
|
|
|
virBufferFreeAndReset(&buf);
|
|
|
|
virReportOOMError(conn);
|
2009-05-21 14:14:01 +00:00
|
|
|
goto cleanup;
|
2009-12-09 23:00:50 +00:00
|
|
|
}
|
2009-05-21 14:14:01 +00:00
|
|
|
|
|
|
|
ret = virBufferContentAndReset(&buf);
|
|
|
|
|
|
|
|
cleanup:
|
2009-05-21 14:16:55 +00:00
|
|
|
qemuDriverUnlock(driver);
|
2009-05-21 14:14:01 +00:00
|
|
|
for (tmp = retargv ; tmp && *tmp ; tmp++)
|
|
|
|
VIR_FREE(*tmp);
|
|
|
|
VIR_FREE(retargv);
|
|
|
|
|
|
|
|
for (tmp = retenv ; tmp && *tmp ; tmp++)
|
|
|
|
VIR_FREE(*tmp);
|
|
|
|
VIR_FREE(retenv);
|
|
|
|
|
|
|
|
virDomainDefFree(def);
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
2007-06-29 13:23:13 +00:00
|
|
|
static int qemudListDefinedDomains(virConnectPtr conn,
|
2007-06-26 22:39:53 +00:00
|
|
|
char **const names, int nnames) {
|
2008-12-04 21:04:30 +00:00
|
|
|
struct qemud_driver *driver = conn->privateData;
|
Convert virDomainObjListPtr to use a hash of domain objects
The current virDomainObjListPtr object stores domain objects in
an array. This means that to find a particular objects requires
O(n) time, and more critically acquiring O(n) mutex locks.
The new impl replaces the array with a virHashTable, keyed off
UUID. Finding a object based on UUID is now O(1) time, and only
requires a single mutex lock. Finding by name/id is unchanged
in complexity.
In changing this, all code which iterates over the array had
to be updated to use a hash table iterator function callback.
Several of the functions which were identically duplicating
across all drivers were pulled into domain_conf.c
* src/conf/domain_conf.h, src/conf/domain_conf.c: Change
virDomainObjListPtr to use virHashTable. Add a initializer
method virDomainObjListInit, and rename virDomainObjListFree
to virDomainObjListDeinit, since its not actually freeing
the container, only its contents. Also add some convenient
methods virDomainObjListGetInactiveNames,
virDomainObjListGetActiveIDs and virDomainObjListNumOfDomains
which can be used to implement the correspondingly named
public API entry points in drivers
* src/libvirt_private.syms: Export new methods from domain_conf.h
* src/lxc/lxc_driver.c, src/opennebula/one_driver.c,
src/openvz/openvz_conf.c, src/openvz/openvz_driver.c,
src/qemu/qemu_driver.c, src/test/test_driver.c,
src/uml/uml_driver.c, src/vbox/vbox_tmpl.c: Update all code
to deal with hash tables instead of arrays for domains
2009-10-09 11:33:51 +00:00
|
|
|
int n;
|
2008-10-10 14:20:37 +00:00
|
|
|
|
2008-12-04 21:06:41 +00:00
|
|
|
qemuDriverLock(driver);
|
Convert virDomainObjListPtr to use a hash of domain objects
The current virDomainObjListPtr object stores domain objects in
an array. This means that to find a particular objects requires
O(n) time, and more critically acquiring O(n) mutex locks.
The new impl replaces the array with a virHashTable, keyed off
UUID. Finding a object based on UUID is now O(1) time, and only
requires a single mutex lock. Finding by name/id is unchanged
in complexity.
In changing this, all code which iterates over the array had
to be updated to use a hash table iterator function callback.
Several of the functions which were identically duplicating
across all drivers were pulled into domain_conf.c
* src/conf/domain_conf.h, src/conf/domain_conf.c: Change
virDomainObjListPtr to use virHashTable. Add a initializer
method virDomainObjListInit, and rename virDomainObjListFree
to virDomainObjListDeinit, since its not actually freeing
the container, only its contents. Also add some convenient
methods virDomainObjListGetInactiveNames,
virDomainObjListGetActiveIDs and virDomainObjListNumOfDomains
which can be used to implement the correspondingly named
public API entry points in drivers
* src/libvirt_private.syms: Export new methods from domain_conf.h
* src/lxc/lxc_driver.c, src/opennebula/one_driver.c,
src/openvz/openvz_conf.c, src/openvz/openvz_driver.c,
src/qemu/qemu_driver.c, src/test/test_driver.c,
src/uml/uml_driver.c, src/vbox/vbox_tmpl.c: Update all code
to deal with hash tables instead of arrays for domains
2009-10-09 11:33:51 +00:00
|
|
|
n = virDomainObjListGetInactiveNames(&driver->domains, names, nnames);
|
2008-12-04 21:06:41 +00:00
|
|
|
qemuDriverUnlock(driver);
|
Convert virDomainObjListPtr to use a hash of domain objects
The current virDomainObjListPtr object stores domain objects in
an array. This means that to find a particular objects requires
O(n) time, and more critically acquiring O(n) mutex locks.
The new impl replaces the array with a virHashTable, keyed off
UUID. Finding a object based on UUID is now O(1) time, and only
requires a single mutex lock. Finding by name/id is unchanged
in complexity.
In changing this, all code which iterates over the array had
to be updated to use a hash table iterator function callback.
Several of the functions which were identically duplicating
across all drivers were pulled into domain_conf.c
* src/conf/domain_conf.h, src/conf/domain_conf.c: Change
virDomainObjListPtr to use virHashTable. Add a initializer
method virDomainObjListInit, and rename virDomainObjListFree
to virDomainObjListDeinit, since its not actually freeing
the container, only its contents. Also add some convenient
methods virDomainObjListGetInactiveNames,
virDomainObjListGetActiveIDs and virDomainObjListNumOfDomains
which can be used to implement the correspondingly named
public API entry points in drivers
* src/libvirt_private.syms: Export new methods from domain_conf.h
* src/lxc/lxc_driver.c, src/opennebula/one_driver.c,
src/openvz/openvz_conf.c, src/openvz/openvz_driver.c,
src/qemu/qemu_driver.c, src/test/test_driver.c,
src/uml/uml_driver.c, src/vbox/vbox_tmpl.c: Update all code
to deal with hash tables instead of arrays for domains
2009-10-09 11:33:51 +00:00
|
|
|
return n;
|
2007-02-14 01:40:09 +00:00
|
|
|
}
|
|
|
|
|
2007-06-29 13:23:13 +00:00
|
|
|
static int qemudNumDefinedDomains(virConnectPtr conn) {
|
2008-12-04 21:04:30 +00:00
|
|
|
struct qemud_driver *driver = conn->privateData;
|
Convert virDomainObjListPtr to use a hash of domain objects
The current virDomainObjListPtr object stores domain objects in
an array. This means that to find a particular objects requires
O(n) time, and more critically acquiring O(n) mutex locks.
The new impl replaces the array with a virHashTable, keyed off
UUID. Finding a object based on UUID is now O(1) time, and only
requires a single mutex lock. Finding by name/id is unchanged
in complexity.
In changing this, all code which iterates over the array had
to be updated to use a hash table iterator function callback.
Several of the functions which were identically duplicating
across all drivers were pulled into domain_conf.c
* src/conf/domain_conf.h, src/conf/domain_conf.c: Change
virDomainObjListPtr to use virHashTable. Add a initializer
method virDomainObjListInit, and rename virDomainObjListFree
to virDomainObjListDeinit, since its not actually freeing
the container, only its contents. Also add some convenient
methods virDomainObjListGetInactiveNames,
virDomainObjListGetActiveIDs and virDomainObjListNumOfDomains
which can be used to implement the correspondingly named
public API entry points in drivers
* src/libvirt_private.syms: Export new methods from domain_conf.h
* src/lxc/lxc_driver.c, src/opennebula/one_driver.c,
src/openvz/openvz_conf.c, src/openvz/openvz_driver.c,
src/qemu/qemu_driver.c, src/test/test_driver.c,
src/uml/uml_driver.c, src/vbox/vbox_tmpl.c: Update all code
to deal with hash tables instead of arrays for domains
2009-10-09 11:33:51 +00:00
|
|
|
int n;
|
2008-10-10 14:20:37 +00:00
|
|
|
|
2008-12-04 21:06:41 +00:00
|
|
|
qemuDriverLock(driver);
|
Convert virDomainObjListPtr to use a hash of domain objects
The current virDomainObjListPtr object stores domain objects in
an array. This means that to find a particular objects requires
O(n) time, and more critically acquiring O(n) mutex locks.
The new impl replaces the array with a virHashTable, keyed off
UUID. Finding a object based on UUID is now O(1) time, and only
requires a single mutex lock. Finding by name/id is unchanged
in complexity.
In changing this, all code which iterates over the array had
to be updated to use a hash table iterator function callback.
Several of the functions which were identically duplicating
across all drivers were pulled into domain_conf.c
* src/conf/domain_conf.h, src/conf/domain_conf.c: Change
virDomainObjListPtr to use virHashTable. Add a initializer
method virDomainObjListInit, and rename virDomainObjListFree
to virDomainObjListDeinit, since its not actually freeing
the container, only its contents. Also add some convenient
methods virDomainObjListGetInactiveNames,
virDomainObjListGetActiveIDs and virDomainObjListNumOfDomains
which can be used to implement the correspondingly named
public API entry points in drivers
* src/libvirt_private.syms: Export new methods from domain_conf.h
* src/lxc/lxc_driver.c, src/opennebula/one_driver.c,
src/openvz/openvz_conf.c, src/openvz/openvz_driver.c,
src/qemu/qemu_driver.c, src/test/test_driver.c,
src/uml/uml_driver.c, src/vbox/vbox_tmpl.c: Update all code
to deal with hash tables instead of arrays for domains
2009-10-09 11:33:51 +00:00
|
|
|
n = virDomainObjListNumOfDomains(&driver->domains, 0);
|
2008-12-04 21:06:41 +00:00
|
|
|
qemuDriverUnlock(driver);
|
2008-10-10 14:20:37 +00:00
|
|
|
|
2008-07-11 19:34:11 +00:00
|
|
|
return n;
|
2007-02-14 01:40:09 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
|
2007-06-29 13:23:13 +00:00
|
|
|
static int qemudDomainStart(virDomainPtr dom) {
|
2008-12-04 21:04:30 +00:00
|
|
|
struct qemud_driver *driver = dom->conn->privateData;
|
|
|
|
virDomainObjPtr vm;
|
|
|
|
int ret = -1;
|
2008-12-04 21:09:20 +00:00
|
|
|
virDomainEventPtr event = NULL;
|
2007-02-23 08:41:23 +00:00
|
|
|
|
2008-12-04 21:06:41 +00:00
|
|
|
qemuDriverLock(driver);
|
2008-12-04 21:04:30 +00:00
|
|
|
vm = virDomainFindByUUID(&driver->domains, dom->uuid);
|
2008-12-04 21:06:41 +00:00
|
|
|
|
2007-02-23 08:41:23 +00:00
|
|
|
if (!vm) {
|
2009-04-19 15:30:50 +00:00
|
|
|
char uuidstr[VIR_UUID_STRING_BUFLEN];
|
|
|
|
virUUIDFormat(dom->uuid, uuidstr);
|
|
|
|
qemudReportError(dom->conn, dom, NULL, VIR_ERR_NO_DOMAIN,
|
|
|
|
_("no domain with matching uuid '%s'"), uuidstr);
|
2008-12-04 21:04:30 +00:00
|
|
|
goto cleanup;
|
2007-02-23 08:41:23 +00:00
|
|
|
}
|
|
|
|
|
2009-11-03 18:26:32 +00:00
|
|
|
if (qemuDomainObjBeginJobWithDriver(driver, vm) < 0)
|
|
|
|
goto cleanup;
|
|
|
|
|
|
|
|
if (virDomainObjIsActive(vm)) {
|
|
|
|
qemudReportError(dom->conn, dom, NULL, VIR_ERR_OPERATION_INVALID,
|
|
|
|
"%s", _("domain is already running"));
|
|
|
|
goto endjob;
|
|
|
|
}
|
|
|
|
|
2009-01-29 17:27:54 +00:00
|
|
|
ret = qemudStartVMDaemon(dom->conn, driver, vm, NULL, -1);
|
2008-12-04 21:04:30 +00:00
|
|
|
if (ret != -1)
|
2008-12-04 21:09:20 +00:00
|
|
|
event = virDomainEventNewFromObj(vm,
|
|
|
|
VIR_DOMAIN_EVENT_STARTED,
|
|
|
|
VIR_DOMAIN_EVENT_STARTED_BOOTED);
|
2008-12-04 21:04:30 +00:00
|
|
|
|
2009-11-03 18:26:32 +00:00
|
|
|
endjob:
|
2009-12-08 14:42:43 +00:00
|
|
|
if (qemuDomainObjEndJob(vm) == 0)
|
|
|
|
vm = NULL;
|
2009-11-03 18:26:32 +00:00
|
|
|
|
2008-12-04 21:04:30 +00:00
|
|
|
cleanup:
|
2008-12-04 21:06:41 +00:00
|
|
|
if (vm)
|
|
|
|
virDomainObjUnlock(vm);
|
2009-05-19 11:06:25 +00:00
|
|
|
if (event)
|
2008-12-04 21:09:20 +00:00
|
|
|
qemuDomainEventQueue(driver, event);
|
2009-05-19 11:06:25 +00:00
|
|
|
qemuDriverUnlock(driver);
|
2008-12-04 21:04:30 +00:00
|
|
|
return ret;
|
2007-02-14 01:40:09 +00:00
|
|
|
}
|
|
|
|
|
2009-07-23 17:31:34 +00:00
|
|
|
static int
|
|
|
|
qemudCanonicalizeMachineFromInfo(virDomainDefPtr def,
|
|
|
|
virCapsGuestDomainInfoPtr info,
|
|
|
|
char **canonical)
|
|
|
|
{
|
|
|
|
int i;
|
|
|
|
|
|
|
|
*canonical = NULL;
|
|
|
|
|
|
|
|
for (i = 0; i < info->nmachines; i++) {
|
|
|
|
virCapsGuestMachinePtr machine = info->machines[i];
|
|
|
|
|
|
|
|
if (!machine->canonical)
|
|
|
|
continue;
|
|
|
|
|
2009-10-23 10:04:10 +00:00
|
|
|
if (STRNEQ(def->os.machine, machine->name))
|
2009-07-23 17:31:34 +00:00
|
|
|
continue;
|
|
|
|
|
|
|
|
if (!(*canonical = strdup(machine->canonical))) {
|
|
|
|
virReportOOMError(NULL);
|
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2009-07-23 17:31:34 +00:00
|
|
|
static int
|
|
|
|
qemudCanonicalizeMachineDirect(virDomainDefPtr def, char **canonical)
|
|
|
|
{
|
|
|
|
virCapsGuestMachinePtr *machines = NULL;
|
|
|
|
int i, nmachines = 0;
|
|
|
|
|
|
|
|
if (qemudProbeMachineTypes(def->emulator, &machines, &nmachines) < 0) {
|
|
|
|
virReportOOMError(NULL);
|
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
|
|
|
|
for (i = 0; i < nmachines; i++) {
|
|
|
|
if (!machines[i]->canonical)
|
|
|
|
continue;
|
|
|
|
|
2009-10-23 10:04:10 +00:00
|
|
|
if (STRNEQ(def->os.machine, machines[i]->name))
|
2009-07-23 17:31:34 +00:00
|
|
|
continue;
|
|
|
|
|
|
|
|
*canonical = machines[i]->canonical;
|
|
|
|
machines[i]->canonical = NULL;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
|
|
|
virCapabilitiesFreeMachines(machines, nmachines);
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2009-09-10 10:09:06 +00:00
|
|
|
int
|
|
|
|
qemudCanonicalizeMachine(struct qemud_driver *driver, virDomainDefPtr def)
|
2009-07-23 17:31:34 +00:00
|
|
|
{
|
|
|
|
char *canonical = NULL;
|
|
|
|
int i;
|
|
|
|
|
|
|
|
for (i = 0; i < driver->caps->nguests; i++) {
|
|
|
|
virCapsGuestPtr guest = driver->caps->guests[i];
|
2009-09-10 11:19:33 +00:00
|
|
|
virCapsGuestDomainInfoPtr info;
|
2009-07-23 17:31:34 +00:00
|
|
|
int j;
|
|
|
|
|
|
|
|
for (j = 0; j < guest->arch.ndomains; j++) {
|
2009-09-10 11:19:33 +00:00
|
|
|
info = &guest->arch.domains[j]->info;
|
2009-07-23 17:31:34 +00:00
|
|
|
|
2009-09-10 11:19:33 +00:00
|
|
|
if (!info->emulator || !STREQ(info->emulator, def->emulator))
|
|
|
|
continue;
|
|
|
|
|
|
|
|
if (!info->nmachines)
|
|
|
|
info = &guest->arch.defaultInfo;
|
|
|
|
|
|
|
|
if (qemudCanonicalizeMachineFromInfo(def, info, &canonical) < 0)
|
|
|
|
return -1;
|
|
|
|
goto out;
|
2009-07-23 17:31:34 +00:00
|
|
|
}
|
|
|
|
|
2009-09-10 11:19:33 +00:00
|
|
|
info = &guest->arch.defaultInfo;
|
|
|
|
|
|
|
|
if (info->emulator && STREQ(info->emulator, def->emulator)) {
|
|
|
|
if (qemudCanonicalizeMachineFromInfo(def, info, &canonical) < 0)
|
2009-07-23 17:31:34 +00:00
|
|
|
return -1;
|
|
|
|
goto out;
|
|
|
|
}
|
|
|
|
}
|
2009-07-23 17:31:34 +00:00
|
|
|
|
|
|
|
if (qemudCanonicalizeMachineDirect(def, &canonical) < 0)
|
|
|
|
return -1;
|
|
|
|
|
2009-07-23 17:31:34 +00:00
|
|
|
out:
|
|
|
|
if (canonical) {
|
|
|
|
VIR_FREE(def->os.machine);
|
|
|
|
def->os.machine = canonical;
|
|
|
|
}
|
|
|
|
return 0;
|
|
|
|
}
|
2007-02-14 01:40:09 +00:00
|
|
|
|
2007-06-29 13:23:13 +00:00
|
|
|
static virDomainPtr qemudDomainDefine(virConnectPtr conn, const char *xml) {
|
2008-12-04 21:04:30 +00:00
|
|
|
struct qemud_driver *driver = conn->privateData;
|
2008-07-11 19:34:11 +00:00
|
|
|
virDomainDefPtr def;
|
2008-12-04 21:06:41 +00:00
|
|
|
virDomainObjPtr vm = NULL;
|
2008-12-04 21:04:30 +00:00
|
|
|
virDomainPtr dom = NULL;
|
2008-12-04 21:09:20 +00:00
|
|
|
virDomainEventPtr event = NULL;
|
2009-11-02 18:37:38 +00:00
|
|
|
int dupVM;
|
2007-02-23 08:48:02 +00:00
|
|
|
|
2008-12-04 21:06:41 +00:00
|
|
|
qemuDriverLock(driver);
|
2009-01-08 13:54:20 +00:00
|
|
|
if (!(def = virDomainDefParseString(conn, driver->caps, xml,
|
|
|
|
VIR_DOMAIN_XML_INACTIVE)))
|
2008-12-04 21:04:30 +00:00
|
|
|
goto cleanup;
|
2007-02-23 08:48:02 +00:00
|
|
|
|
2009-04-03 10:55:51 +00:00
|
|
|
if (virSecurityDriverVerify(conn, def) < 0)
|
|
|
|
goto cleanup;
|
|
|
|
|
2009-11-02 18:37:38 +00:00
|
|
|
if ((dupVM = virDomainObjIsDuplicate(&driver->domains, def, 0)) < 0)
|
|
|
|
goto cleanup;
|
2008-11-17 16:52:32 +00:00
|
|
|
|
2009-09-10 10:09:06 +00:00
|
|
|
if (qemudCanonicalizeMachine(driver, def) < 0)
|
2009-07-23 17:31:34 +00:00
|
|
|
goto cleanup;
|
|
|
|
|
2008-07-11 19:34:11 +00:00
|
|
|
if (!(vm = virDomainAssignDef(conn,
|
2009-10-06 11:50:58 +00:00
|
|
|
driver->caps,
|
2008-07-11 19:34:11 +00:00
|
|
|
&driver->domains,
|
|
|
|
def))) {
|
2008-12-04 21:04:30 +00:00
|
|
|
goto cleanup;
|
2007-02-23 08:48:02 +00:00
|
|
|
}
|
2009-05-08 10:11:14 +00:00
|
|
|
def = NULL;
|
2008-08-20 19:42:36 +00:00
|
|
|
vm->persistent = 1;
|
2007-02-23 08:48:02 +00:00
|
|
|
|
2008-07-11 19:34:11 +00:00
|
|
|
if (virDomainSaveConfig(conn,
|
|
|
|
driver->configDir,
|
2008-08-20 19:42:36 +00:00
|
|
|
vm->newDef ? vm->newDef : vm->def) < 0) {
|
2008-07-11 19:34:11 +00:00
|
|
|
virDomainRemoveInactive(&driver->domains,
|
|
|
|
vm);
|
2008-12-04 21:06:41 +00:00
|
|
|
vm = NULL;
|
2008-12-04 21:04:30 +00:00
|
|
|
goto cleanup;
|
2007-02-23 08:48:02 +00:00
|
|
|
}
|
|
|
|
|
2008-12-04 21:09:20 +00:00
|
|
|
event = virDomainEventNewFromObj(vm,
|
|
|
|
VIR_DOMAIN_EVENT_DEFINED,
|
2009-11-02 18:37:38 +00:00
|
|
|
!dupVM ?
|
2008-12-04 21:09:20 +00:00
|
|
|
VIR_DOMAIN_EVENT_DEFINED_ADDED :
|
|
|
|
VIR_DOMAIN_EVENT_DEFINED_UPDATED);
|
2008-11-17 16:52:32 +00:00
|
|
|
|
2007-06-26 23:48:46 +00:00
|
|
|
dom = virGetDomain(conn, vm->def->name, vm->def->uuid);
|
2008-07-11 19:34:11 +00:00
|
|
|
if (dom) dom->id = vm->def->id;
|
2008-12-04 21:04:30 +00:00
|
|
|
|
|
|
|
cleanup:
|
2009-05-08 10:11:14 +00:00
|
|
|
virDomainDefFree(def);
|
2008-12-04 21:06:41 +00:00
|
|
|
if (vm)
|
|
|
|
virDomainObjUnlock(vm);
|
2008-12-04 21:09:20 +00:00
|
|
|
if (event)
|
|
|
|
qemuDomainEventQueue(driver, event);
|
2008-12-04 21:06:41 +00:00
|
|
|
qemuDriverUnlock(driver);
|
2007-06-26 22:39:53 +00:00
|
|
|
return dom;
|
2007-02-14 01:40:09 +00:00
|
|
|
}
|
|
|
|
|
2007-06-29 13:23:13 +00:00
|
|
|
static int qemudDomainUndefine(virDomainPtr dom) {
|
2008-12-04 21:04:30 +00:00
|
|
|
struct qemud_driver *driver = dom->conn->privateData;
|
|
|
|
virDomainObjPtr vm;
|
2008-12-04 21:09:20 +00:00
|
|
|
virDomainEventPtr event = NULL;
|
2008-12-04 21:04:30 +00:00
|
|
|
int ret = -1;
|
2007-02-14 01:40:09 +00:00
|
|
|
|
2008-12-04 21:06:41 +00:00
|
|
|
qemuDriverLock(driver);
|
2008-12-04 21:04:30 +00:00
|
|
|
vm = virDomainFindByUUID(&driver->domains, dom->uuid);
|
2008-12-04 21:06:41 +00:00
|
|
|
|
2007-02-14 01:40:09 +00:00
|
|
|
if (!vm) {
|
2009-04-19 15:30:50 +00:00
|
|
|
char uuidstr[VIR_UUID_STRING_BUFLEN];
|
|
|
|
virUUIDFormat(dom->uuid, uuidstr);
|
|
|
|
qemudReportError(dom->conn, dom, NULL, VIR_ERR_NO_DOMAIN,
|
|
|
|
_("no domain with matching uuid '%s'"), uuidstr);
|
2008-12-04 21:04:30 +00:00
|
|
|
goto cleanup;
|
2007-02-14 01:40:09 +00:00
|
|
|
}
|
|
|
|
|
Rename internal APis
Rename virDomainIsActive to virDomainObjIsActive, and
virInterfaceIsActive to virInterfaceObjIsActive and finally
virNetworkIsActive to virNetworkObjIsActive.
* src/conf/domain_conf.c, src/conf/domain_conf.h,
src/conf/interface_conf.h, src/conf/network_conf.c,
src/conf/network_conf.h, src/lxc/lxc_driver.c,
src/network/bridge_driver.c, src/opennebula/one_driver.c,
src/openvz/openvz_driver.c, src/qemu/qemu_driver.c,
src/test/test_driver.c, src/uml/uml_driver.c: Update for
renamed APIs.
2009-10-20 14:51:03 +00:00
|
|
|
if (virDomainObjIsActive(vm)) {
|
2009-05-08 09:58:46 +00:00
|
|
|
qemudReportError(dom->conn, dom, NULL, VIR_ERR_OPERATION_INVALID,
|
Mark many more strings for translation.
* Makefile.maint (err_func_re): Add to the list and make it readable.
* po/POTFILES.in: Add src/util.c and src/xm_internal.c, and sort.
* src/storage_backend.c: Fix comment.
* src/util.c (virFileLinkPointsTo): Mark a string.
* qemud/remote.c (remoteDispatchClientRequest): Mark strings.
(remoteDispatchOpen, CHECK_CONN, remoteDispatchGetType): Likewise.
(remoteDispatchDomainGetSchedulerType): Likewise.
(remoteDispatchDomainGetSchedulerParameters): Likewise.
(remoteDispatchDomainSetSchedulerParameters): Likewise.
(remoteDispatchDomainBlockStats): Likewise.
(remoteDispatchDomainInterfaceStats): Likewise.
(remoteDispatchDomainAttachDevice, remoteDispatchDomainCreate):
(remoteDispatchDomainDestroy, remoteDispatchDomainDetachDevice):
(remoteDispatchDomainDumpXml, remoteDispatchDomainGetAutostart):
(remoteDispatchDomainGetInfo, remoteDispatchDomainGetMaxMemory):
(remoteDispatchDomainGetMaxVcpus, remoteDispatchDomainGetOsType):
(remoteDispatchDomainGetVcpus): Likewise.
(remoteDispatchDomainMigratePerform): Likewise.
(remoteDispatchListDefinedDomains, remoteDispatchDomainPinVcpu):
(remoteDispatchDomainReboot, remoteDispatchDomainResume):
(remoteDispatchDomainSave, remoteDispatchDomainCoreDump):
(remoteDispatchDomainSetAutostart): Likewise.
(remoteDispatchDomainSetMaxMemory, remoteDispatchDomainSetMemory):
(remoteDispatchDomainSetVcpus, remoteDispatchDomainShutdown):
(remoteDispatchDomainSuspend, remoteDispatchDomainUndefine):
(remoteDispatchListDefinedNetworks, remoteDispatchListDomains):
(remoteDispatchListNetworks, remoteDispatchNetworkCreate):
(remoteDispatchNetworkDestroy, remoteDispatchNetworkDumpXml):
(remoteDispatchNetworkGetAutostart, remoteDispatchNetworkGetBridgeName):
(remoteDispatchNetworkSetAutostart, remoteDispatchNetworkUndefine):
(addrToString, remoteDispatchAuthSaslInit, remoteDispatchAuthSaslStart):
(remoteDispatchAuthSaslStep, remoteDispatchListDefinedStoragePools):
(remoteDispatchListStoragePools, remoteDispatchStoragePoolCreate):
(remoteDispatchStoragePoolBuild, remoteDispatchStoragePoolDestroy):
(remoteDispatchStoragePoolDelete, remoteDispatchStoragePoolRefresh):
(remoteDispatchStoragePoolGetInfo, remoteDispatchStoragePoolDumpXml):
(remoteDispatchStoragePoolGetAutostart): Likewise.
(remoteDispatchStoragePoolSetAutostart):
(remoteDispatchStoragePoolListVolumes):
(remoteDispatchStoragePoolNumOfVolumes):
(remoteDispatchStoragePoolUndefine, remoteDispatchStorageVolCreateXml):
(remoteDispatchStorageVolDelete, remoteDispatchStorageVolGetInfo):
(remoteDispatchStorageVolDumpXml, remoteDispatchStorageVolGetPath):
(remoteDispatchStorageVolLookupByName): Likewise.
* src/qemu_driver.c (qemudOpenMonitor, qemudStartVMDaemon):
(dhcpStartDhcpDaemon, qemudStartNetworkDaemon):
(qemudDomainSuspend, qemudDomainResume, qemudDomainShutdown):
(qemudDomainGetOSType, qemudDomainSetMaxMemory):
(qemudDomainSetMemory, qemudDomainGetInfo, qemudDomainSave):
(qemudDomainRestore, qemudDomainDumpXML, qemudDomainStart):
(qemudDomainUndefine, qemudDomainChangeCDROM):
(qemudDomainAttachDevice, qemudDomainGetAutostart):
(qemudDomainSetAutostart, qemudDomainInterfaceStats):
(qemudNetworkLookupByUUID, qemudNetworkLookupByName):
(qemudNetworkUndefine, qemudNetworkStart, qemudNetworkDestroy):
(qemudNetworkDumpXML, qemudNetworkGetAutostart):
(qemudNetworkSetAutostart): Likewise.
* src/virsh.c (cmdVcpupin, cmdAttachDevice, cmdDetachDevice): Likewise.
* src/xm_internal.c (xenXMConfigCacheRefresh, xenXMDomainPinVcpu): Likewise.
2008-03-27 13:43:01 +00:00
|
|
|
"%s", _("cannot delete active domain"));
|
2008-12-04 21:04:30 +00:00
|
|
|
goto cleanup;
|
2007-02-14 01:40:09 +00:00
|
|
|
}
|
|
|
|
|
2008-08-20 19:42:36 +00:00
|
|
|
if (!vm->persistent) {
|
|
|
|
qemudReportError(dom->conn, dom, NULL, VIR_ERR_INTERNAL_ERROR,
|
|
|
|
"%s", _("cannot undefine transient domain"));
|
2008-12-04 21:04:30 +00:00
|
|
|
goto cleanup;
|
2008-08-20 19:42:36 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
if (virDomainDeleteConfig(dom->conn, driver->configDir, driver->autostartDir, vm) < 0)
|
2008-12-04 21:04:30 +00:00
|
|
|
goto cleanup;
|
2007-02-14 01:40:09 +00:00
|
|
|
|
2008-12-04 21:09:20 +00:00
|
|
|
event = virDomainEventNewFromObj(vm,
|
|
|
|
VIR_DOMAIN_EVENT_UNDEFINED,
|
|
|
|
VIR_DOMAIN_EVENT_UNDEFINED_REMOVED);
|
2008-11-17 16:52:32 +00:00
|
|
|
|
2008-07-11 19:34:11 +00:00
|
|
|
virDomainRemoveInactive(&driver->domains,
|
|
|
|
vm);
|
2008-12-04 21:06:41 +00:00
|
|
|
vm = NULL;
|
2008-12-04 21:04:30 +00:00
|
|
|
ret = 0;
|
2007-02-14 01:40:09 +00:00
|
|
|
|
2008-12-04 21:04:30 +00:00
|
|
|
cleanup:
|
2008-12-04 21:06:41 +00:00
|
|
|
if (vm)
|
|
|
|
virDomainObjUnlock(vm);
|
2008-12-04 21:09:20 +00:00
|
|
|
if (event)
|
|
|
|
qemuDomainEventQueue(driver, event);
|
2008-12-04 21:06:41 +00:00
|
|
|
qemuDriverUnlock(driver);
|
2008-12-04 21:04:30 +00:00
|
|
|
return ret;
|
2007-02-14 01:40:09 +00:00
|
|
|
}
|
|
|
|
|
2008-09-03 16:05:25 +00:00
|
|
|
|
2008-12-04 21:04:30 +00:00
|
|
|
static int qemudDomainChangeEjectableMedia(virConnectPtr conn,
|
2009-11-03 18:26:32 +00:00
|
|
|
struct qemud_driver *driver,
|
2008-12-04 21:04:30 +00:00
|
|
|
virDomainObjPtr vm,
|
2010-01-18 18:02:20 +00:00
|
|
|
virDomainDiskDefPtr disk)
|
2008-09-03 16:05:25 +00:00
|
|
|
{
|
2010-01-18 18:02:20 +00:00
|
|
|
virDomainDiskDefPtr origdisk = NULL;
|
2008-10-10 16:08:01 +00:00
|
|
|
int i;
|
2009-09-23 11:51:59 +00:00
|
|
|
int ret;
|
2008-09-03 16:05:25 +00:00
|
|
|
|
2008-10-16 13:44:09 +00:00
|
|
|
origdisk = NULL;
|
2008-10-10 16:08:01 +00:00
|
|
|
for (i = 0 ; i < vm->def->ndisks ; i++) {
|
2010-01-18 18:02:20 +00:00
|
|
|
if (vm->def->disks[i]->bus == disk->bus &&
|
|
|
|
STREQ(vm->def->disks[i]->dst, disk->dst)) {
|
2008-10-10 16:08:01 +00:00
|
|
|
origdisk = vm->def->disks[i];
|
2008-09-03 16:05:25 +00:00
|
|
|
break;
|
2008-10-10 16:08:01 +00:00
|
|
|
}
|
2008-09-03 16:05:25 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
if (!origdisk) {
|
2008-12-04 21:04:30 +00:00
|
|
|
qemudReportError(conn, dom, NULL, VIR_ERR_INTERNAL_ERROR,
|
2008-09-03 16:05:25 +00:00
|
|
|
_("No device with bus '%s' and target '%s'"),
|
2010-01-18 18:02:20 +00:00
|
|
|
virDomainDiskBusTypeToString(disk->bus),
|
|
|
|
disk->dst);
|
2008-09-03 16:05:25 +00:00
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
|
2010-01-06 12:11:26 +00:00
|
|
|
if (!origdisk->info.alias) {
|
|
|
|
qemudReportError(conn, NULL, NULL, VIR_ERR_INTERNAL_ERROR,
|
|
|
|
_("missing disk device alias name for %s"), origdisk->dst);
|
|
|
|
return -1;
|
|
|
|
}
|
2008-09-03 16:05:25 +00:00
|
|
|
|
2010-01-06 12:11:26 +00:00
|
|
|
if (origdisk->device != VIR_DOMAIN_DISK_DEVICE_FLOPPY &&
|
|
|
|
origdisk->device != VIR_DOMAIN_DISK_DEVICE_CDROM) {
|
|
|
|
qemudReportError(conn, dom, NULL, VIR_ERR_INTERNAL_ERROR,
|
|
|
|
_("Removable media not supported for %s device"),
|
2010-01-18 18:02:20 +00:00
|
|
|
virDomainDiskDeviceTypeToString(disk->device));
|
2010-01-06 12:11:26 +00:00
|
|
|
return -1;
|
2008-09-03 16:05:25 +00:00
|
|
|
}
|
2007-10-27 01:21:09 +00:00
|
|
|
|
2010-01-13 17:27:19 +00:00
|
|
|
if (driver->securityDriver &&
|
|
|
|
driver->securityDriver->domainSetSecurityImageLabel &&
|
2010-01-18 18:02:20 +00:00
|
|
|
driver->securityDriver->domainSetSecurityImageLabel(conn, vm, disk) < 0)
|
2010-01-13 17:27:19 +00:00
|
|
|
return -1;
|
|
|
|
|
2009-10-09 20:13:06 +00:00
|
|
|
qemuDomainObjPrivatePtr priv = vm->privateData;
|
2009-11-03 18:26:32 +00:00
|
|
|
qemuDomainObjEnterMonitorWithDriver(driver, vm);
|
2010-01-18 18:02:20 +00:00
|
|
|
if (disk->src) {
|
2009-11-26 13:48:17 +00:00
|
|
|
const char *format = NULL;
|
2010-01-18 18:02:20 +00:00
|
|
|
if (disk->type != VIR_DOMAIN_DISK_TYPE_DIR) {
|
|
|
|
if (disk->driverType)
|
|
|
|
format = disk->driverType;
|
2009-11-26 13:48:17 +00:00
|
|
|
else if (origdisk->driverType)
|
|
|
|
format = origdisk->driverType;
|
|
|
|
}
|
2010-01-06 12:11:26 +00:00
|
|
|
ret = qemuMonitorChangeMedia(priv->mon,
|
|
|
|
origdisk->info.alias,
|
2010-01-18 18:02:20 +00:00
|
|
|
disk->src, format);
|
2009-09-23 11:51:59 +00:00
|
|
|
} else {
|
2010-01-06 12:11:26 +00:00
|
|
|
ret = qemuMonitorEjectMedia(priv->mon, origdisk->info.alias);
|
2007-10-27 01:21:09 +00:00
|
|
|
}
|
2009-11-03 18:26:32 +00:00
|
|
|
qemuDomainObjExitMonitorWithDriver(driver, vm);
|
2008-09-03 14:43:34 +00:00
|
|
|
|
2010-01-13 17:27:19 +00:00
|
|
|
if (ret < 0)
|
|
|
|
goto error;
|
|
|
|
|
|
|
|
if (driver->securityDriver &&
|
|
|
|
driver->securityDriver->domainRestoreSecurityImageLabel &&
|
|
|
|
driver->securityDriver->domainRestoreSecurityImageLabel(conn, vm, origdisk) < 0)
|
|
|
|
VIR_WARN("Unable to restore security label on ejected image %s", origdisk->src);
|
|
|
|
|
|
|
|
VIR_FREE(origdisk->src);
|
2010-01-18 18:02:20 +00:00
|
|
|
origdisk->src = disk->src;
|
|
|
|
disk->src = NULL;
|
|
|
|
origdisk->type = disk->type;
|
|
|
|
|
|
|
|
virDomainDiskDefFree(disk);
|
2008-09-03 12:52:27 +00:00
|
|
|
|
2009-09-23 11:51:59 +00:00
|
|
|
return ret;
|
2010-01-13 17:27:19 +00:00
|
|
|
|
|
|
|
error:
|
|
|
|
if (driver->securityDriver &&
|
|
|
|
driver->securityDriver->domainRestoreSecurityImageLabel &&
|
2010-01-18 18:02:20 +00:00
|
|
|
driver->securityDriver->domainRestoreSecurityImageLabel(conn, vm, disk) < 0)
|
|
|
|
VIR_WARN("Unable to restore security label on new media %s", disk->src);
|
2010-01-13 17:27:19 +00:00
|
|
|
return -1;
|
2007-10-27 01:21:09 +00:00
|
|
|
}
|
|
|
|
|
2009-07-17 21:08:34 +00:00
|
|
|
|
2008-12-04 21:04:30 +00:00
|
|
|
static int qemudDomainAttachPciDiskDevice(virConnectPtr conn,
|
2009-11-03 18:26:32 +00:00
|
|
|
struct qemud_driver *driver,
|
2008-12-04 21:04:30 +00:00
|
|
|
virDomainObjPtr vm,
|
2010-01-26 17:40:19 +00:00
|
|
|
virDomainDiskDefPtr disk,
|
|
|
|
int qemuCmdFlags)
|
2008-10-17 12:36:39 +00:00
|
|
|
{
|
2009-10-13 14:27:58 +00:00
|
|
|
int i, ret;
|
2010-01-18 18:02:20 +00:00
|
|
|
const char* type = virDomainDiskBusTypeToString(disk->bus);
|
2009-10-09 20:13:06 +00:00
|
|
|
qemuDomainObjPrivatePtr priv = vm->privateData;
|
2010-01-26 17:40:19 +00:00
|
|
|
char *devstr = NULL;
|
|
|
|
char *drivestr = NULL;
|
2008-10-17 12:36:39 +00:00
|
|
|
|
|
|
|
for (i = 0 ; i < vm->def->ndisks ; i++) {
|
2010-01-18 18:02:20 +00:00
|
|
|
if (STREQ(vm->def->disks[i]->dst, disk->dst)) {
|
2008-12-04 21:04:30 +00:00
|
|
|
qemudReportError(conn, dom, NULL, VIR_ERR_OPERATION_FAILED,
|
2010-01-18 18:02:20 +00:00
|
|
|
_("target %s already exists"), disk->dst);
|
2008-10-17 12:36:39 +00:00
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2010-01-13 17:27:19 +00:00
|
|
|
if (driver->securityDriver &&
|
|
|
|
driver->securityDriver->domainSetSecurityImageLabel &&
|
2010-01-18 18:02:20 +00:00
|
|
|
driver->securityDriver->domainSetSecurityImageLabel(conn, vm, disk) < 0)
|
2010-01-13 17:27:19 +00:00
|
|
|
return -1;
|
|
|
|
|
2010-01-26 17:40:19 +00:00
|
|
|
if (qemuCmdFlags & QEMUD_CMD_FLAG_DEVICE) {
|
|
|
|
if (!(drivestr = qemuBuildDriveStr(disk, 0, qemuCmdFlags)))
|
|
|
|
goto error;
|
|
|
|
|
|
|
|
if (!(devstr = qemuBuildDriveDevStr(NULL, disk)))
|
|
|
|
goto error;
|
|
|
|
}
|
|
|
|
|
2008-10-17 12:36:39 +00:00
|
|
|
if (VIR_REALLOC_N(vm->def->disks, vm->def->ndisks+1) < 0) {
|
2009-01-29 12:10:32 +00:00
|
|
|
virReportOOMError(conn);
|
2010-01-13 17:27:19 +00:00
|
|
|
goto error;
|
2008-10-17 12:36:39 +00:00
|
|
|
}
|
|
|
|
|
2009-11-03 18:26:32 +00:00
|
|
|
qemuDomainObjEnterMonitorWithDriver(driver, vm);
|
2010-01-26 17:40:19 +00:00
|
|
|
if (qemuCmdFlags & QEMUD_CMD_FLAG_DEVICE) {
|
|
|
|
ret = qemuMonitorAddDrive(priv->mon, drivestr);
|
|
|
|
if (ret == 0)
|
|
|
|
qemuMonitorAddDevice(priv->mon, devstr);
|
|
|
|
/* XXX remove the drive upon fail */
|
|
|
|
} else {
|
|
|
|
virDomainDevicePCIAddress guestAddr;
|
|
|
|
ret = qemuMonitorAddPCIDisk(priv->mon,
|
|
|
|
disk->src,
|
|
|
|
type,
|
|
|
|
&guestAddr);
|
|
|
|
if (ret == 0) {
|
|
|
|
disk->info.type = VIR_DOMAIN_DEVICE_ADDRESS_TYPE_PCI;
|
|
|
|
memcpy(&disk->info.addr.pci, &guestAddr, sizeof(guestAddr));
|
|
|
|
}
|
|
|
|
}
|
2009-11-03 18:26:32 +00:00
|
|
|
qemuDomainObjExitMonitorWithDriver(driver, vm);
|
2009-07-17 21:08:34 +00:00
|
|
|
|
2010-01-13 17:27:19 +00:00
|
|
|
if (ret < 0)
|
|
|
|
goto error;
|
2008-10-17 12:36:39 +00:00
|
|
|
|
2010-01-18 18:02:20 +00:00
|
|
|
virDomainDiskInsertPreAlloced(vm->def, disk);
|
2010-01-13 17:27:19 +00:00
|
|
|
|
2010-01-26 17:40:19 +00:00
|
|
|
VIR_FREE(devstr);
|
|
|
|
VIR_FREE(drivestr);
|
|
|
|
|
2010-01-13 17:27:19 +00:00
|
|
|
return 0;
|
|
|
|
|
|
|
|
error:
|
2010-01-26 17:40:19 +00:00
|
|
|
VIR_FREE(devstr);
|
|
|
|
VIR_FREE(drivestr);
|
|
|
|
|
2010-01-13 17:27:19 +00:00
|
|
|
if (driver->securityDriver &&
|
|
|
|
driver->securityDriver->domainRestoreSecurityImageLabel &&
|
2010-01-18 18:02:20 +00:00
|
|
|
driver->securityDriver->domainRestoreSecurityImageLabel(conn, vm, disk) < 0)
|
|
|
|
VIR_WARN("Unable to restore security label on %s", disk->src);
|
2010-01-13 17:27:19 +00:00
|
|
|
|
|
|
|
return -1;
|
2008-10-17 12:36:39 +00:00
|
|
|
}
|
2007-10-27 01:21:09 +00:00
|
|
|
|
2010-01-18 18:02:20 +00:00
|
|
|
|
2009-12-07 19:28:05 +00:00
|
|
|
static int qemudDomainAttachPciControllerDevice(virConnectPtr conn,
|
|
|
|
struct qemud_driver *driver,
|
|
|
|
virDomainObjPtr vm,
|
2010-01-26 17:40:19 +00:00
|
|
|
virDomainControllerDefPtr controller,
|
|
|
|
int qemuCmdFlags)
|
2009-12-07 19:28:05 +00:00
|
|
|
{
|
2010-01-26 17:40:19 +00:00
|
|
|
int i;
|
|
|
|
int ret = -1;
|
2010-01-18 18:02:20 +00:00
|
|
|
const char* type = virDomainControllerTypeToString(controller->type);
|
2010-01-26 17:40:19 +00:00
|
|
|
char *devstr = NULL;
|
2009-12-07 19:28:05 +00:00
|
|
|
qemuDomainObjPrivatePtr priv = vm->privateData;
|
|
|
|
|
|
|
|
for (i = 0 ; i < vm->def->ncontrollers ; i++) {
|
2010-01-18 18:02:20 +00:00
|
|
|
if ((vm->def->controllers[i]->type == controller->type) &&
|
|
|
|
(vm->def->controllers[i]->idx == controller->idx)) {
|
2009-12-07 19:28:05 +00:00
|
|
|
qemudReportError(conn, dom, NULL, VIR_ERR_OPERATION_FAILED,
|
|
|
|
_("target %s:%d already exists"),
|
2010-01-18 18:02:20 +00:00
|
|
|
type, controller->idx);
|
2009-12-07 19:28:05 +00:00
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2010-01-26 17:40:19 +00:00
|
|
|
if (!(devstr = qemuBuildControllerDevStr(controller))) {
|
|
|
|
virReportOOMError(NULL);
|
|
|
|
goto cleanup;
|
|
|
|
}
|
|
|
|
|
2009-12-07 19:28:05 +00:00
|
|
|
if (VIR_REALLOC_N(vm->def->controllers, vm->def->ncontrollers+1) < 0) {
|
2010-01-26 17:40:19 +00:00
|
|
|
virReportOOMError(NULL);
|
|
|
|
goto cleanup;
|
2009-12-07 19:28:05 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
qemuDomainObjEnterMonitorWithDriver(driver, vm);
|
2010-01-26 17:40:19 +00:00
|
|
|
if (qemuCmdFlags & QEMUD_CMD_FLAG_DEVICE) {
|
|
|
|
ret = qemuMonitorAddDevice(priv->mon, devstr);
|
|
|
|
} else {
|
|
|
|
ret = qemuMonitorAttachPCIDiskController(priv->mon,
|
|
|
|
type,
|
|
|
|
&controller->info.addr.pci);
|
|
|
|
}
|
2009-12-07 19:28:05 +00:00
|
|
|
qemuDomainObjExitMonitorWithDriver(driver, vm);
|
|
|
|
|
|
|
|
if (ret == 0) {
|
2010-01-18 18:02:20 +00:00
|
|
|
controller->info.type = VIR_DOMAIN_DEVICE_ADDRESS_TYPE_PCI;
|
|
|
|
virDomainControllerInsertPreAlloced(vm->def, controller);
|
2009-12-07 19:28:05 +00:00
|
|
|
}
|
|
|
|
|
2010-01-26 17:40:19 +00:00
|
|
|
cleanup:
|
|
|
|
VIR_FREE(devstr);
|
2009-12-07 19:28:05 +00:00
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
2010-01-18 18:02:20 +00:00
|
|
|
|
Properly support SCSI drive hotplug
The current SCSI hotplug support attaches a brand new SCSI controller
for every disk. This is broken because the semantics differ from those
used when starting the VM initially. In the latter case, each SCSI
controller is filled before a new one is added.
If the user specifies an high drive index (sdazz) then at initial
startup, many intermediate SCSI controllers may be added with no
drives.
This patch changes SCSI hotplug so that it exactly matches the
behaviour of initial startup. First the SCSI controller number is
determined for the drive to be hotplugged. If any controller upto
and including that controller number is not yet present, it is
attached. Then finally the drive is attached to the last controller.
NB, this breaks SCSI hotunplug, because there is no 'drive_del'
command in current QEMU. Previous SCSI hotunplug was broken in
any case because it was unplugging the entire controller, not
just the drive in question.
A future QEMU will allow proper SCSI hotunplug of a drive.
This patch is derived from work done by Wolfgang Mauerer on disk
controllers.
* src/qemu/qemu_driver.c: Fix SCSI hotplug to add a drive to
the correct controller, instead of just attaching a new
controller.
* src/qemu/qemu_monitor.c, src/qemu/qemu_monitor.h,
src/qemu/qemu_monitor_json.c, src/qemu/qemu_monitor_json.h,
src/qemu/qemu_monitor_text.c, src/qemu/qemu_monitor_text.h: Add
support for 'drive_add' command
2009-12-09 17:57:09 +00:00
|
|
|
static virDomainControllerDefPtr
|
|
|
|
qemuDomainFindOrCreateSCSIDiskController(virConnectPtr conn,
|
|
|
|
struct qemud_driver *driver,
|
|
|
|
virDomainObjPtr vm,
|
2010-01-26 17:40:19 +00:00
|
|
|
int controller,
|
|
|
|
int qemuCmdFlags)
|
Properly support SCSI drive hotplug
The current SCSI hotplug support attaches a brand new SCSI controller
for every disk. This is broken because the semantics differ from those
used when starting the VM initially. In the latter case, each SCSI
controller is filled before a new one is added.
If the user specifies an high drive index (sdazz) then at initial
startup, many intermediate SCSI controllers may be added with no
drives.
This patch changes SCSI hotplug so that it exactly matches the
behaviour of initial startup. First the SCSI controller number is
determined for the drive to be hotplugged. If any controller upto
and including that controller number is not yet present, it is
attached. Then finally the drive is attached to the last controller.
NB, this breaks SCSI hotunplug, because there is no 'drive_del'
command in current QEMU. Previous SCSI hotunplug was broken in
any case because it was unplugging the entire controller, not
just the drive in question.
A future QEMU will allow proper SCSI hotunplug of a drive.
This patch is derived from work done by Wolfgang Mauerer on disk
controllers.
* src/qemu/qemu_driver.c: Fix SCSI hotplug to add a drive to
the correct controller, instead of just attaching a new
controller.
* src/qemu/qemu_monitor.c, src/qemu/qemu_monitor.h,
src/qemu/qemu_monitor_json.c, src/qemu/qemu_monitor_json.h,
src/qemu/qemu_monitor_text.c, src/qemu/qemu_monitor_text.h: Add
support for 'drive_add' command
2009-12-09 17:57:09 +00:00
|
|
|
{
|
|
|
|
int i;
|
|
|
|
virDomainControllerDefPtr cont;
|
|
|
|
for (i = 0 ; i < vm->def->ncontrollers ; i++) {
|
|
|
|
cont = vm->def->controllers[i];
|
|
|
|
|
|
|
|
if (cont->type != VIR_DOMAIN_CONTROLLER_TYPE_SCSI)
|
|
|
|
continue;
|
|
|
|
|
|
|
|
if (cont->idx == controller)
|
|
|
|
return cont;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* No SCSI controller present, for back compatability we
|
|
|
|
* now hotplug a controller */
|
|
|
|
if (VIR_ALLOC(cont) < 0) {
|
|
|
|
virReportOOMError(conn);
|
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
cont->type = VIR_DOMAIN_CONTROLLER_TYPE_SCSI;
|
|
|
|
cont->idx = 0;
|
|
|
|
|
|
|
|
VIR_INFO0("No SCSI controller present, hotplugging one");
|
|
|
|
if (qemudDomainAttachPciControllerDevice(conn, driver,
|
2010-01-26 17:40:19 +00:00
|
|
|
vm, cont, qemuCmdFlags) < 0) {
|
Properly support SCSI drive hotplug
The current SCSI hotplug support attaches a brand new SCSI controller
for every disk. This is broken because the semantics differ from those
used when starting the VM initially. In the latter case, each SCSI
controller is filled before a new one is added.
If the user specifies an high drive index (sdazz) then at initial
startup, many intermediate SCSI controllers may be added with no
drives.
This patch changes SCSI hotplug so that it exactly matches the
behaviour of initial startup. First the SCSI controller number is
determined for the drive to be hotplugged. If any controller upto
and including that controller number is not yet present, it is
attached. Then finally the drive is attached to the last controller.
NB, this breaks SCSI hotunplug, because there is no 'drive_del'
command in current QEMU. Previous SCSI hotunplug was broken in
any case because it was unplugging the entire controller, not
just the drive in question.
A future QEMU will allow proper SCSI hotunplug of a drive.
This patch is derived from work done by Wolfgang Mauerer on disk
controllers.
* src/qemu/qemu_driver.c: Fix SCSI hotplug to add a drive to
the correct controller, instead of just attaching a new
controller.
* src/qemu/qemu_monitor.c, src/qemu/qemu_monitor.h,
src/qemu/qemu_monitor_json.c, src/qemu/qemu_monitor_json.h,
src/qemu/qemu_monitor_text.c, src/qemu/qemu_monitor_text.h: Add
support for 'drive_add' command
2009-12-09 17:57:09 +00:00
|
|
|
VIR_FREE(cont);
|
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
return cont;
|
|
|
|
}
|
|
|
|
|
2010-01-18 18:02:20 +00:00
|
|
|
|
Properly support SCSI drive hotplug
The current SCSI hotplug support attaches a brand new SCSI controller
for every disk. This is broken because the semantics differ from those
used when starting the VM initially. In the latter case, each SCSI
controller is filled before a new one is added.
If the user specifies an high drive index (sdazz) then at initial
startup, many intermediate SCSI controllers may be added with no
drives.
This patch changes SCSI hotplug so that it exactly matches the
behaviour of initial startup. First the SCSI controller number is
determined for the drive to be hotplugged. If any controller upto
and including that controller number is not yet present, it is
attached. Then finally the drive is attached to the last controller.
NB, this breaks SCSI hotunplug, because there is no 'drive_del'
command in current QEMU. Previous SCSI hotunplug was broken in
any case because it was unplugging the entire controller, not
just the drive in question.
A future QEMU will allow proper SCSI hotunplug of a drive.
This patch is derived from work done by Wolfgang Mauerer on disk
controllers.
* src/qemu/qemu_driver.c: Fix SCSI hotplug to add a drive to
the correct controller, instead of just attaching a new
controller.
* src/qemu/qemu_monitor.c, src/qemu/qemu_monitor.h,
src/qemu/qemu_monitor_json.c, src/qemu/qemu_monitor_json.h,
src/qemu/qemu_monitor_text.c, src/qemu/qemu_monitor_text.h: Add
support for 'drive_add' command
2009-12-09 17:57:09 +00:00
|
|
|
static int qemudDomainAttachSCSIDisk(virConnectPtr conn,
|
|
|
|
struct qemud_driver *driver,
|
|
|
|
virDomainObjPtr vm,
|
2010-01-18 18:02:20 +00:00
|
|
|
virDomainDiskDefPtr disk,
|
Properly support SCSI drive hotplug
The current SCSI hotplug support attaches a brand new SCSI controller
for every disk. This is broken because the semantics differ from those
used when starting the VM initially. In the latter case, each SCSI
controller is filled before a new one is added.
If the user specifies an high drive index (sdazz) then at initial
startup, many intermediate SCSI controllers may be added with no
drives.
This patch changes SCSI hotplug so that it exactly matches the
behaviour of initial startup. First the SCSI controller number is
determined for the drive to be hotplugged. If any controller upto
and including that controller number is not yet present, it is
attached. Then finally the drive is attached to the last controller.
NB, this breaks SCSI hotunplug, because there is no 'drive_del'
command in current QEMU. Previous SCSI hotunplug was broken in
any case because it was unplugging the entire controller, not
just the drive in question.
A future QEMU will allow proper SCSI hotunplug of a drive.
This patch is derived from work done by Wolfgang Mauerer on disk
controllers.
* src/qemu/qemu_driver.c: Fix SCSI hotplug to add a drive to
the correct controller, instead of just attaching a new
controller.
* src/qemu/qemu_monitor.c, src/qemu/qemu_monitor.h,
src/qemu/qemu_monitor_json.c, src/qemu/qemu_monitor_json.h,
src/qemu/qemu_monitor_text.c, src/qemu/qemu_monitor_text.h: Add
support for 'drive_add' command
2009-12-09 17:57:09 +00:00
|
|
|
int qemuCmdFlags)
|
|
|
|
{
|
|
|
|
int i;
|
|
|
|
qemuDomainObjPrivatePtr priv = vm->privateData;
|
|
|
|
virDomainControllerDefPtr cont;
|
|
|
|
char *drivestr = NULL;
|
2010-01-26 17:40:19 +00:00
|
|
|
char *devstr = NULL;
|
Properly support SCSI drive hotplug
The current SCSI hotplug support attaches a brand new SCSI controller
for every disk. This is broken because the semantics differ from those
used when starting the VM initially. In the latter case, each SCSI
controller is filled before a new one is added.
If the user specifies an high drive index (sdazz) then at initial
startup, many intermediate SCSI controllers may be added with no
drives.
This patch changes SCSI hotplug so that it exactly matches the
behaviour of initial startup. First the SCSI controller number is
determined for the drive to be hotplugged. If any controller upto
and including that controller number is not yet present, it is
attached. Then finally the drive is attached to the last controller.
NB, this breaks SCSI hotunplug, because there is no 'drive_del'
command in current QEMU. Previous SCSI hotunplug was broken in
any case because it was unplugging the entire controller, not
just the drive in question.
A future QEMU will allow proper SCSI hotunplug of a drive.
This patch is derived from work done by Wolfgang Mauerer on disk
controllers.
* src/qemu/qemu_driver.c: Fix SCSI hotplug to add a drive to
the correct controller, instead of just attaching a new
controller.
* src/qemu/qemu_monitor.c, src/qemu/qemu_monitor.h,
src/qemu/qemu_monitor_json.c, src/qemu/qemu_monitor_json.h,
src/qemu/qemu_monitor_text.c, src/qemu/qemu_monitor_text.h: Add
support for 'drive_add' command
2009-12-09 17:57:09 +00:00
|
|
|
int ret = -1;
|
|
|
|
|
|
|
|
for (i = 0 ; i < vm->def->ndisks ; i++) {
|
2010-01-18 18:02:20 +00:00
|
|
|
if (STREQ(vm->def->disks[i]->dst, disk->dst)) {
|
Properly support SCSI drive hotplug
The current SCSI hotplug support attaches a brand new SCSI controller
for every disk. This is broken because the semantics differ from those
used when starting the VM initially. In the latter case, each SCSI
controller is filled before a new one is added.
If the user specifies an high drive index (sdazz) then at initial
startup, many intermediate SCSI controllers may be added with no
drives.
This patch changes SCSI hotplug so that it exactly matches the
behaviour of initial startup. First the SCSI controller number is
determined for the drive to be hotplugged. If any controller upto
and including that controller number is not yet present, it is
attached. Then finally the drive is attached to the last controller.
NB, this breaks SCSI hotunplug, because there is no 'drive_del'
command in current QEMU. Previous SCSI hotunplug was broken in
any case because it was unplugging the entire controller, not
just the drive in question.
A future QEMU will allow proper SCSI hotunplug of a drive.
This patch is derived from work done by Wolfgang Mauerer on disk
controllers.
* src/qemu/qemu_driver.c: Fix SCSI hotplug to add a drive to
the correct controller, instead of just attaching a new
controller.
* src/qemu/qemu_monitor.c, src/qemu/qemu_monitor.h,
src/qemu/qemu_monitor_json.c, src/qemu/qemu_monitor_json.h,
src/qemu/qemu_monitor_text.c, src/qemu/qemu_monitor_text.h: Add
support for 'drive_add' command
2009-12-09 17:57:09 +00:00
|
|
|
qemudReportError(conn, dom, NULL, VIR_ERR_OPERATION_FAILED,
|
2010-01-18 18:02:20 +00:00
|
|
|
_("target %s already exists"), disk->dst);
|
2010-01-13 17:27:19 +00:00
|
|
|
return -1;
|
Properly support SCSI drive hotplug
The current SCSI hotplug support attaches a brand new SCSI controller
for every disk. This is broken because the semantics differ from those
used when starting the VM initially. In the latter case, each SCSI
controller is filled before a new one is added.
If the user specifies an high drive index (sdazz) then at initial
startup, many intermediate SCSI controllers may be added with no
drives.
This patch changes SCSI hotplug so that it exactly matches the
behaviour of initial startup. First the SCSI controller number is
determined for the drive to be hotplugged. If any controller upto
and including that controller number is not yet present, it is
attached. Then finally the drive is attached to the last controller.
NB, this breaks SCSI hotunplug, because there is no 'drive_del'
command in current QEMU. Previous SCSI hotunplug was broken in
any case because it was unplugging the entire controller, not
just the drive in question.
A future QEMU will allow proper SCSI hotunplug of a drive.
This patch is derived from work done by Wolfgang Mauerer on disk
controllers.
* src/qemu/qemu_driver.c: Fix SCSI hotplug to add a drive to
the correct controller, instead of just attaching a new
controller.
* src/qemu/qemu_monitor.c, src/qemu/qemu_monitor.h,
src/qemu/qemu_monitor_json.c, src/qemu/qemu_monitor_json.h,
src/qemu/qemu_monitor_text.c, src/qemu/qemu_monitor_text.h: Add
support for 'drive_add' command
2009-12-09 17:57:09 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2010-01-13 17:27:19 +00:00
|
|
|
|
|
|
|
if (driver->securityDriver &&
|
|
|
|
driver->securityDriver->domainSetSecurityImageLabel &&
|
2010-01-18 18:02:20 +00:00
|
|
|
driver->securityDriver->domainSetSecurityImageLabel(conn, vm, disk) < 0)
|
2010-01-13 17:27:19 +00:00
|
|
|
return -1;
|
|
|
|
|
Properly support SCSI drive hotplug
The current SCSI hotplug support attaches a brand new SCSI controller
for every disk. This is broken because the semantics differ from those
used when starting the VM initially. In the latter case, each SCSI
controller is filled before a new one is added.
If the user specifies an high drive index (sdazz) then at initial
startup, many intermediate SCSI controllers may be added with no
drives.
This patch changes SCSI hotplug so that it exactly matches the
behaviour of initial startup. First the SCSI controller number is
determined for the drive to be hotplugged. If any controller upto
and including that controller number is not yet present, it is
attached. Then finally the drive is attached to the last controller.
NB, this breaks SCSI hotunplug, because there is no 'drive_del'
command in current QEMU. Previous SCSI hotunplug was broken in
any case because it was unplugging the entire controller, not
just the drive in question.
A future QEMU will allow proper SCSI hotunplug of a drive.
This patch is derived from work done by Wolfgang Mauerer on disk
controllers.
* src/qemu/qemu_driver.c: Fix SCSI hotplug to add a drive to
the correct controller, instead of just attaching a new
controller.
* src/qemu/qemu_monitor.c, src/qemu/qemu_monitor.h,
src/qemu/qemu_monitor_json.c, src/qemu/qemu_monitor_json.h,
src/qemu/qemu_monitor_text.c, src/qemu/qemu_monitor_text.h: Add
support for 'drive_add' command
2009-12-09 17:57:09 +00:00
|
|
|
/* This func allocates the bus/unit IDs so must be before
|
|
|
|
* we search for controller
|
|
|
|
*/
|
2010-01-18 18:02:20 +00:00
|
|
|
if (!(drivestr = qemuBuildDriveStr(disk, 0, qemuCmdFlags)))
|
2010-01-13 17:27:19 +00:00
|
|
|
goto error;
|
Properly support SCSI drive hotplug
The current SCSI hotplug support attaches a brand new SCSI controller
for every disk. This is broken because the semantics differ from those
used when starting the VM initially. In the latter case, each SCSI
controller is filled before a new one is added.
If the user specifies an high drive index (sdazz) then at initial
startup, many intermediate SCSI controllers may be added with no
drives.
This patch changes SCSI hotplug so that it exactly matches the
behaviour of initial startup. First the SCSI controller number is
determined for the drive to be hotplugged. If any controller upto
and including that controller number is not yet present, it is
attached. Then finally the drive is attached to the last controller.
NB, this breaks SCSI hotunplug, because there is no 'drive_del'
command in current QEMU. Previous SCSI hotunplug was broken in
any case because it was unplugging the entire controller, not
just the drive in question.
A future QEMU will allow proper SCSI hotunplug of a drive.
This patch is derived from work done by Wolfgang Mauerer on disk
controllers.
* src/qemu/qemu_driver.c: Fix SCSI hotplug to add a drive to
the correct controller, instead of just attaching a new
controller.
* src/qemu/qemu_monitor.c, src/qemu/qemu_monitor.h,
src/qemu/qemu_monitor_json.c, src/qemu/qemu_monitor_json.h,
src/qemu/qemu_monitor_text.c, src/qemu/qemu_monitor_text.h: Add
support for 'drive_add' command
2009-12-09 17:57:09 +00:00
|
|
|
|
2010-01-26 17:40:19 +00:00
|
|
|
if ((qemuCmdFlags & QEMUD_CMD_FLAG_DEVICE) &&
|
|
|
|
!(devstr = qemuBuildDriveDevStr(NULL, disk)))
|
|
|
|
goto error;
|
Properly support SCSI drive hotplug
The current SCSI hotplug support attaches a brand new SCSI controller
for every disk. This is broken because the semantics differ from those
used when starting the VM initially. In the latter case, each SCSI
controller is filled before a new one is added.
If the user specifies an high drive index (sdazz) then at initial
startup, many intermediate SCSI controllers may be added with no
drives.
This patch changes SCSI hotplug so that it exactly matches the
behaviour of initial startup. First the SCSI controller number is
determined for the drive to be hotplugged. If any controller upto
and including that controller number is not yet present, it is
attached. Then finally the drive is attached to the last controller.
NB, this breaks SCSI hotunplug, because there is no 'drive_del'
command in current QEMU. Previous SCSI hotunplug was broken in
any case because it was unplugging the entire controller, not
just the drive in question.
A future QEMU will allow proper SCSI hotunplug of a drive.
This patch is derived from work done by Wolfgang Mauerer on disk
controllers.
* src/qemu/qemu_driver.c: Fix SCSI hotplug to add a drive to
the correct controller, instead of just attaching a new
controller.
* src/qemu/qemu_monitor.c, src/qemu/qemu_monitor.h,
src/qemu/qemu_monitor_json.c, src/qemu/qemu_monitor_json.h,
src/qemu/qemu_monitor_text.c, src/qemu/qemu_monitor_text.h: Add
support for 'drive_add' command
2009-12-09 17:57:09 +00:00
|
|
|
|
|
|
|
/* We should have an adddress now, so make sure */
|
2010-01-18 18:02:20 +00:00
|
|
|
if (disk->info.type != VIR_DOMAIN_DEVICE_ADDRESS_TYPE_DRIVE) {
|
Properly support SCSI drive hotplug
The current SCSI hotplug support attaches a brand new SCSI controller
for every disk. This is broken because the semantics differ from those
used when starting the VM initially. In the latter case, each SCSI
controller is filled before a new one is added.
If the user specifies an high drive index (sdazz) then at initial
startup, many intermediate SCSI controllers may be added with no
drives.
This patch changes SCSI hotplug so that it exactly matches the
behaviour of initial startup. First the SCSI controller number is
determined for the drive to be hotplugged. If any controller upto
and including that controller number is not yet present, it is
attached. Then finally the drive is attached to the last controller.
NB, this breaks SCSI hotunplug, because there is no 'drive_del'
command in current QEMU. Previous SCSI hotunplug was broken in
any case because it was unplugging the entire controller, not
just the drive in question.
A future QEMU will allow proper SCSI hotunplug of a drive.
This patch is derived from work done by Wolfgang Mauerer on disk
controllers.
* src/qemu/qemu_driver.c: Fix SCSI hotplug to add a drive to
the correct controller, instead of just attaching a new
controller.
* src/qemu/qemu_monitor.c, src/qemu/qemu_monitor.h,
src/qemu/qemu_monitor_json.c, src/qemu/qemu_monitor_json.h,
src/qemu/qemu_monitor_text.c, src/qemu/qemu_monitor_text.h: Add
support for 'drive_add' command
2009-12-09 17:57:09 +00:00
|
|
|
qemudReportError(conn, NULL, NULL, VIR_ERR_INTERNAL_ERROR,
|
|
|
|
_("unexpected disk address type %s"),
|
2010-01-18 18:02:20 +00:00
|
|
|
virDomainDeviceAddressTypeToString(disk->info.type));
|
2010-01-13 17:27:19 +00:00
|
|
|
goto error;
|
Properly support SCSI drive hotplug
The current SCSI hotplug support attaches a brand new SCSI controller
for every disk. This is broken because the semantics differ from those
used when starting the VM initially. In the latter case, each SCSI
controller is filled before a new one is added.
If the user specifies an high drive index (sdazz) then at initial
startup, many intermediate SCSI controllers may be added with no
drives.
This patch changes SCSI hotplug so that it exactly matches the
behaviour of initial startup. First the SCSI controller number is
determined for the drive to be hotplugged. If any controller upto
and including that controller number is not yet present, it is
attached. Then finally the drive is attached to the last controller.
NB, this breaks SCSI hotunplug, because there is no 'drive_del'
command in current QEMU. Previous SCSI hotunplug was broken in
any case because it was unplugging the entire controller, not
just the drive in question.
A future QEMU will allow proper SCSI hotunplug of a drive.
This patch is derived from work done by Wolfgang Mauerer on disk
controllers.
* src/qemu/qemu_driver.c: Fix SCSI hotplug to add a drive to
the correct controller, instead of just attaching a new
controller.
* src/qemu/qemu_monitor.c, src/qemu/qemu_monitor.h,
src/qemu/qemu_monitor_json.c, src/qemu/qemu_monitor_json.h,
src/qemu/qemu_monitor_text.c, src/qemu/qemu_monitor_text.h: Add
support for 'drive_add' command
2009-12-09 17:57:09 +00:00
|
|
|
}
|
|
|
|
|
2010-01-20 14:53:30 +00:00
|
|
|
for (i = 0 ; i <= disk->info.addr.drive.controller ; i++) {
|
2010-01-26 17:40:19 +00:00
|
|
|
cont = qemuDomainFindOrCreateSCSIDiskController(conn, driver, vm, i, qemuCmdFlags);
|
Properly support SCSI drive hotplug
The current SCSI hotplug support attaches a brand new SCSI controller
for every disk. This is broken because the semantics differ from those
used when starting the VM initially. In the latter case, each SCSI
controller is filled before a new one is added.
If the user specifies an high drive index (sdazz) then at initial
startup, many intermediate SCSI controllers may be added with no
drives.
This patch changes SCSI hotplug so that it exactly matches the
behaviour of initial startup. First the SCSI controller number is
determined for the drive to be hotplugged. If any controller upto
and including that controller number is not yet present, it is
attached. Then finally the drive is attached to the last controller.
NB, this breaks SCSI hotunplug, because there is no 'drive_del'
command in current QEMU. Previous SCSI hotunplug was broken in
any case because it was unplugging the entire controller, not
just the drive in question.
A future QEMU will allow proper SCSI hotunplug of a drive.
This patch is derived from work done by Wolfgang Mauerer on disk
controllers.
* src/qemu/qemu_driver.c: Fix SCSI hotplug to add a drive to
the correct controller, instead of just attaching a new
controller.
* src/qemu/qemu_monitor.c, src/qemu/qemu_monitor.h,
src/qemu/qemu_monitor_json.c, src/qemu/qemu_monitor_json.h,
src/qemu/qemu_monitor_text.c, src/qemu/qemu_monitor_text.h: Add
support for 'drive_add' command
2009-12-09 17:57:09 +00:00
|
|
|
if (!cont)
|
2010-01-13 17:27:19 +00:00
|
|
|
goto error;
|
Properly support SCSI drive hotplug
The current SCSI hotplug support attaches a brand new SCSI controller
for every disk. This is broken because the semantics differ from those
used when starting the VM initially. In the latter case, each SCSI
controller is filled before a new one is added.
If the user specifies an high drive index (sdazz) then at initial
startup, many intermediate SCSI controllers may be added with no
drives.
This patch changes SCSI hotplug so that it exactly matches the
behaviour of initial startup. First the SCSI controller number is
determined for the drive to be hotplugged. If any controller upto
and including that controller number is not yet present, it is
attached. Then finally the drive is attached to the last controller.
NB, this breaks SCSI hotunplug, because there is no 'drive_del'
command in current QEMU. Previous SCSI hotunplug was broken in
any case because it was unplugging the entire controller, not
just the drive in question.
A future QEMU will allow proper SCSI hotunplug of a drive.
This patch is derived from work done by Wolfgang Mauerer on disk
controllers.
* src/qemu/qemu_driver.c: Fix SCSI hotplug to add a drive to
the correct controller, instead of just attaching a new
controller.
* src/qemu/qemu_monitor.c, src/qemu/qemu_monitor.h,
src/qemu/qemu_monitor_json.c, src/qemu/qemu_monitor_json.h,
src/qemu/qemu_monitor_text.c, src/qemu/qemu_monitor_text.h: Add
support for 'drive_add' command
2009-12-09 17:57:09 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
if (cont->info.type != VIR_DOMAIN_DEVICE_ADDRESS_TYPE_PCI) {
|
|
|
|
qemudReportError(conn, NULL, NULL, VIR_ERR_INTERNAL_ERROR,
|
|
|
|
_("SCSI controller %d was missing its PCI address"), cont->idx);
|
2010-01-13 17:27:19 +00:00
|
|
|
goto error;
|
Properly support SCSI drive hotplug
The current SCSI hotplug support attaches a brand new SCSI controller
for every disk. This is broken because the semantics differ from those
used when starting the VM initially. In the latter case, each SCSI
controller is filled before a new one is added.
If the user specifies an high drive index (sdazz) then at initial
startup, many intermediate SCSI controllers may be added with no
drives.
This patch changes SCSI hotplug so that it exactly matches the
behaviour of initial startup. First the SCSI controller number is
determined for the drive to be hotplugged. If any controller upto
and including that controller number is not yet present, it is
attached. Then finally the drive is attached to the last controller.
NB, this breaks SCSI hotunplug, because there is no 'drive_del'
command in current QEMU. Previous SCSI hotunplug was broken in
any case because it was unplugging the entire controller, not
just the drive in question.
A future QEMU will allow proper SCSI hotunplug of a drive.
This patch is derived from work done by Wolfgang Mauerer on disk
controllers.
* src/qemu/qemu_driver.c: Fix SCSI hotplug to add a drive to
the correct controller, instead of just attaching a new
controller.
* src/qemu/qemu_monitor.c, src/qemu/qemu_monitor.h,
src/qemu/qemu_monitor_json.c, src/qemu/qemu_monitor_json.h,
src/qemu/qemu_monitor_text.c, src/qemu/qemu_monitor_text.h: Add
support for 'drive_add' command
2009-12-09 17:57:09 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
if (VIR_REALLOC_N(vm->def->disks, vm->def->ndisks+1) < 0) {
|
|
|
|
virReportOOMError(conn);
|
2010-01-13 17:27:19 +00:00
|
|
|
goto error;
|
Properly support SCSI drive hotplug
The current SCSI hotplug support attaches a brand new SCSI controller
for every disk. This is broken because the semantics differ from those
used when starting the VM initially. In the latter case, each SCSI
controller is filled before a new one is added.
If the user specifies an high drive index (sdazz) then at initial
startup, many intermediate SCSI controllers may be added with no
drives.
This patch changes SCSI hotplug so that it exactly matches the
behaviour of initial startup. First the SCSI controller number is
determined for the drive to be hotplugged. If any controller upto
and including that controller number is not yet present, it is
attached. Then finally the drive is attached to the last controller.
NB, this breaks SCSI hotunplug, because there is no 'drive_del'
command in current QEMU. Previous SCSI hotunplug was broken in
any case because it was unplugging the entire controller, not
just the drive in question.
A future QEMU will allow proper SCSI hotunplug of a drive.
This patch is derived from work done by Wolfgang Mauerer on disk
controllers.
* src/qemu/qemu_driver.c: Fix SCSI hotplug to add a drive to
the correct controller, instead of just attaching a new
controller.
* src/qemu/qemu_monitor.c, src/qemu/qemu_monitor.h,
src/qemu/qemu_monitor_json.c, src/qemu/qemu_monitor_json.h,
src/qemu/qemu_monitor_text.c, src/qemu/qemu_monitor_text.h: Add
support for 'drive_add' command
2009-12-09 17:57:09 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
qemuDomainObjEnterMonitorWithDriver(driver, vm);
|
2010-01-26 17:40:19 +00:00
|
|
|
if (qemuCmdFlags & QEMUD_CMD_FLAG_DEVICE) {
|
|
|
|
ret = qemuMonitorAddDrive(priv->mon,
|
|
|
|
drivestr);
|
|
|
|
if (ret == 0)
|
|
|
|
ret = qemuMonitorAddDevice(priv->mon,
|
|
|
|
devstr);
|
|
|
|
/* XXX should call 'drive_del' on error but this does not exist yet */
|
|
|
|
} else {
|
|
|
|
virDomainDeviceDriveAddress driveAddr;
|
|
|
|
ret = qemuMonitorAttachDrive(priv->mon,
|
|
|
|
drivestr,
|
|
|
|
&cont->info.addr.pci,
|
|
|
|
&driveAddr);
|
|
|
|
if (ret == 0) {
|
|
|
|
/* XXX we should probably validate that the addr matches
|
|
|
|
* our existing defined addr instead of overwriting */
|
|
|
|
disk->info.type = VIR_DOMAIN_DEVICE_ADDRESS_TYPE_DRIVE;
|
|
|
|
memcpy(&disk->info.addr.drive, &driveAddr, sizeof(driveAddr));
|
|
|
|
}
|
|
|
|
}
|
Properly support SCSI drive hotplug
The current SCSI hotplug support attaches a brand new SCSI controller
for every disk. This is broken because the semantics differ from those
used when starting the VM initially. In the latter case, each SCSI
controller is filled before a new one is added.
If the user specifies an high drive index (sdazz) then at initial
startup, many intermediate SCSI controllers may be added with no
drives.
This patch changes SCSI hotplug so that it exactly matches the
behaviour of initial startup. First the SCSI controller number is
determined for the drive to be hotplugged. If any controller upto
and including that controller number is not yet present, it is
attached. Then finally the drive is attached to the last controller.
NB, this breaks SCSI hotunplug, because there is no 'drive_del'
command in current QEMU. Previous SCSI hotunplug was broken in
any case because it was unplugging the entire controller, not
just the drive in question.
A future QEMU will allow proper SCSI hotunplug of a drive.
This patch is derived from work done by Wolfgang Mauerer on disk
controllers.
* src/qemu/qemu_driver.c: Fix SCSI hotplug to add a drive to
the correct controller, instead of just attaching a new
controller.
* src/qemu/qemu_monitor.c, src/qemu/qemu_monitor.h,
src/qemu/qemu_monitor_json.c, src/qemu/qemu_monitor_json.h,
src/qemu/qemu_monitor_text.c, src/qemu/qemu_monitor_text.h: Add
support for 'drive_add' command
2009-12-09 17:57:09 +00:00
|
|
|
qemuDomainObjExitMonitorWithDriver(driver, vm);
|
|
|
|
|
2010-01-13 17:27:19 +00:00
|
|
|
if (ret < 0)
|
|
|
|
goto error;
|
Properly support SCSI drive hotplug
The current SCSI hotplug support attaches a brand new SCSI controller
for every disk. This is broken because the semantics differ from those
used when starting the VM initially. In the latter case, each SCSI
controller is filled before a new one is added.
If the user specifies an high drive index (sdazz) then at initial
startup, many intermediate SCSI controllers may be added with no
drives.
This patch changes SCSI hotplug so that it exactly matches the
behaviour of initial startup. First the SCSI controller number is
determined for the drive to be hotplugged. If any controller upto
and including that controller number is not yet present, it is
attached. Then finally the drive is attached to the last controller.
NB, this breaks SCSI hotunplug, because there is no 'drive_del'
command in current QEMU. Previous SCSI hotunplug was broken in
any case because it was unplugging the entire controller, not
just the drive in question.
A future QEMU will allow proper SCSI hotunplug of a drive.
This patch is derived from work done by Wolfgang Mauerer on disk
controllers.
* src/qemu/qemu_driver.c: Fix SCSI hotplug to add a drive to
the correct controller, instead of just attaching a new
controller.
* src/qemu/qemu_monitor.c, src/qemu/qemu_monitor.h,
src/qemu/qemu_monitor_json.c, src/qemu/qemu_monitor_json.h,
src/qemu/qemu_monitor_text.c, src/qemu/qemu_monitor_text.h: Add
support for 'drive_add' command
2009-12-09 17:57:09 +00:00
|
|
|
|
2010-01-18 18:02:20 +00:00
|
|
|
virDomainDiskInsertPreAlloced(vm->def, disk);
|
2010-01-26 17:40:19 +00:00
|
|
|
|
|
|
|
VIR_FREE(devstr);
|
Properly support SCSI drive hotplug
The current SCSI hotplug support attaches a brand new SCSI controller
for every disk. This is broken because the semantics differ from those
used when starting the VM initially. In the latter case, each SCSI
controller is filled before a new one is added.
If the user specifies an high drive index (sdazz) then at initial
startup, many intermediate SCSI controllers may be added with no
drives.
This patch changes SCSI hotplug so that it exactly matches the
behaviour of initial startup. First the SCSI controller number is
determined for the drive to be hotplugged. If any controller upto
and including that controller number is not yet present, it is
attached. Then finally the drive is attached to the last controller.
NB, this breaks SCSI hotunplug, because there is no 'drive_del'
command in current QEMU. Previous SCSI hotunplug was broken in
any case because it was unplugging the entire controller, not
just the drive in question.
A future QEMU will allow proper SCSI hotunplug of a drive.
This patch is derived from work done by Wolfgang Mauerer on disk
controllers.
* src/qemu/qemu_driver.c: Fix SCSI hotplug to add a drive to
the correct controller, instead of just attaching a new
controller.
* src/qemu/qemu_monitor.c, src/qemu/qemu_monitor.h,
src/qemu/qemu_monitor_json.c, src/qemu/qemu_monitor_json.h,
src/qemu/qemu_monitor_text.c, src/qemu/qemu_monitor_text.h: Add
support for 'drive_add' command
2009-12-09 17:57:09 +00:00
|
|
|
VIR_FREE(drivestr);
|
2010-01-13 17:27:19 +00:00
|
|
|
|
|
|
|
return 0;
|
|
|
|
|
|
|
|
error:
|
2010-01-26 17:40:19 +00:00
|
|
|
VIR_FREE(devstr);
|
2010-01-13 17:27:19 +00:00
|
|
|
VIR_FREE(drivestr);
|
2010-01-26 17:40:19 +00:00
|
|
|
|
2010-01-13 17:27:19 +00:00
|
|
|
if (driver->securityDriver &&
|
|
|
|
driver->securityDriver->domainRestoreSecurityImageLabel &&
|
2010-01-18 18:02:20 +00:00
|
|
|
driver->securityDriver->domainRestoreSecurityImageLabel(conn, vm, disk) < 0)
|
|
|
|
VIR_WARN("Unable to restore security label on %s", disk->src);
|
2010-01-13 17:27:19 +00:00
|
|
|
|
|
|
|
return -1;
|
Properly support SCSI drive hotplug
The current SCSI hotplug support attaches a brand new SCSI controller
for every disk. This is broken because the semantics differ from those
used when starting the VM initially. In the latter case, each SCSI
controller is filled before a new one is added.
If the user specifies an high drive index (sdazz) then at initial
startup, many intermediate SCSI controllers may be added with no
drives.
This patch changes SCSI hotplug so that it exactly matches the
behaviour of initial startup. First the SCSI controller number is
determined for the drive to be hotplugged. If any controller upto
and including that controller number is not yet present, it is
attached. Then finally the drive is attached to the last controller.
NB, this breaks SCSI hotunplug, because there is no 'drive_del'
command in current QEMU. Previous SCSI hotunplug was broken in
any case because it was unplugging the entire controller, not
just the drive in question.
A future QEMU will allow proper SCSI hotunplug of a drive.
This patch is derived from work done by Wolfgang Mauerer on disk
controllers.
* src/qemu/qemu_driver.c: Fix SCSI hotplug to add a drive to
the correct controller, instead of just attaching a new
controller.
* src/qemu/qemu_monitor.c, src/qemu/qemu_monitor.h,
src/qemu/qemu_monitor_json.c, src/qemu/qemu_monitor_json.h,
src/qemu/qemu_monitor_text.c, src/qemu/qemu_monitor_text.h: Add
support for 'drive_add' command
2009-12-09 17:57:09 +00:00
|
|
|
}
|
|
|
|
|
2009-12-07 19:28:05 +00:00
|
|
|
|
2008-12-04 21:04:30 +00:00
|
|
|
static int qemudDomainAttachUsbMassstorageDevice(virConnectPtr conn,
|
2009-11-03 18:26:32 +00:00
|
|
|
struct qemud_driver *driver,
|
2008-12-04 21:04:30 +00:00
|
|
|
virDomainObjPtr vm,
|
2010-01-26 17:40:19 +00:00
|
|
|
virDomainDiskDefPtr disk,
|
|
|
|
int qemuCmdFlags)
|
2008-08-08 15:03:00 +00:00
|
|
|
{
|
2009-10-09 20:13:06 +00:00
|
|
|
qemuDomainObjPrivatePtr priv = vm->privateData;
|
2009-10-13 14:27:58 +00:00
|
|
|
int i, ret;
|
2010-01-26 17:40:19 +00:00
|
|
|
char *drivestr = NULL;
|
|
|
|
char *devstr = NULL;
|
2008-08-08 15:03:00 +00:00
|
|
|
|
2008-10-21 13:09:23 +00:00
|
|
|
for (i = 0 ; i < vm->def->ndisks ; i++) {
|
2010-01-18 18:02:20 +00:00
|
|
|
if (STREQ(vm->def->disks[i]->dst, disk->dst)) {
|
2009-09-23 14:38:43 +00:00
|
|
|
qemudReportError(conn, NULL, NULL, VIR_ERR_OPERATION_FAILED,
|
2010-01-18 18:02:20 +00:00
|
|
|
_("target %s already exists"), disk->dst);
|
2008-10-21 13:09:23 +00:00
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2010-01-13 17:27:19 +00:00
|
|
|
if (driver->securityDriver &&
|
|
|
|
driver->securityDriver->domainSetSecurityImageLabel &&
|
2010-01-18 18:02:20 +00:00
|
|
|
driver->securityDriver->domainSetSecurityImageLabel(conn, vm, disk) < 0)
|
2010-01-13 17:27:19 +00:00
|
|
|
return -1;
|
|
|
|
|
2010-01-18 18:02:20 +00:00
|
|
|
if (!disk->src) {
|
2009-09-23 14:38:43 +00:00
|
|
|
qemudReportError(conn, NULL, NULL, VIR_ERR_INTERNAL_ERROR,
|
|
|
|
"%s", _("disk source path is missing"));
|
2010-01-13 17:27:19 +00:00
|
|
|
goto error;
|
2008-10-21 13:09:23 +00:00
|
|
|
}
|
|
|
|
|
2010-01-26 17:40:19 +00:00
|
|
|
if (qemuCmdFlags & QEMUD_CMD_FLAG_DEVICE) {
|
|
|
|
if (!(drivestr = qemuBuildDriveStr(disk, 0, qemuCmdFlags)))
|
|
|
|
goto error;
|
|
|
|
if (!(devstr = qemuBuildDriveDevStr(NULL, disk)))
|
|
|
|
goto error;
|
|
|
|
}
|
|
|
|
|
2009-09-23 14:38:43 +00:00
|
|
|
if (VIR_REALLOC_N(vm->def->disks, vm->def->ndisks+1) < 0) {
|
2009-01-29 12:10:32 +00:00
|
|
|
virReportOOMError(conn);
|
2010-01-13 17:27:19 +00:00
|
|
|
goto error;
|
2008-08-08 15:03:00 +00:00
|
|
|
}
|
|
|
|
|
2009-11-03 18:26:32 +00:00
|
|
|
qemuDomainObjEnterMonitorWithDriver(driver, vm);
|
2010-01-26 17:40:19 +00:00
|
|
|
if (qemuCmdFlags & QEMUD_CMD_FLAG_DEVICE) {
|
|
|
|
ret = qemuMonitorAddDrive(priv->mon,
|
|
|
|
drivestr);
|
|
|
|
if (ret == 0)
|
|
|
|
ret = qemuMonitorAddDevice(priv->mon,
|
|
|
|
devstr);
|
|
|
|
/* XXX should call 'drive_del' on error but this does not exist yet */
|
|
|
|
} else {
|
|
|
|
ret = qemuMonitorAddUSBDisk(priv->mon, disk->src);
|
|
|
|
}
|
2009-11-03 18:26:32 +00:00
|
|
|
qemuDomainObjExitMonitorWithDriver(driver, vm);
|
2008-09-03 15:05:31 +00:00
|
|
|
|
2010-01-13 17:27:19 +00:00
|
|
|
if (ret < 0)
|
|
|
|
goto error;
|
|
|
|
|
2010-01-18 18:02:20 +00:00
|
|
|
virDomainDiskInsertPreAlloced(vm->def, disk);
|
2008-09-03 15:05:31 +00:00
|
|
|
|
2010-01-26 17:40:19 +00:00
|
|
|
VIR_FREE(devstr);
|
|
|
|
VIR_FREE(drivestr);
|
|
|
|
|
2010-01-13 17:27:19 +00:00
|
|
|
return 0;
|
|
|
|
|
|
|
|
error:
|
2010-01-26 17:40:19 +00:00
|
|
|
VIR_FREE(devstr);
|
|
|
|
VIR_FREE(drivestr);
|
|
|
|
|
2010-01-13 17:27:19 +00:00
|
|
|
if (driver->securityDriver &&
|
|
|
|
driver->securityDriver->domainRestoreSecurityImageLabel &&
|
2010-01-18 18:02:20 +00:00
|
|
|
driver->securityDriver->domainRestoreSecurityImageLabel(conn, vm, disk) < 0)
|
|
|
|
VIR_WARN("Unable to restore security label on %s", disk->src);
|
2010-01-13 17:27:19 +00:00
|
|
|
|
|
|
|
return -1;
|
2008-08-08 15:03:00 +00:00
|
|
|
}
|
|
|
|
|
2010-01-13 17:27:19 +00:00
|
|
|
|
2009-07-17 21:08:34 +00:00
|
|
|
static int qemudDomainAttachNetDevice(virConnectPtr conn,
|
2009-07-22 19:17:14 +00:00
|
|
|
struct qemud_driver *driver,
|
2009-07-17 21:08:34 +00:00
|
|
|
virDomainObjPtr vm,
|
2010-01-18 18:02:20 +00:00
|
|
|
virDomainNetDefPtr net,
|
2009-07-17 21:08:34 +00:00
|
|
|
unsigned int qemuCmdFlags)
|
|
|
|
{
|
2009-10-09 20:13:06 +00:00
|
|
|
qemuDomainObjPrivatePtr priv = vm->privateData;
|
2009-09-23 15:51:10 +00:00
|
|
|
char *tapfd_name = NULL;
|
2009-07-22 19:17:14 +00:00
|
|
|
int i, tapfd = -1;
|
2009-09-23 16:01:39 +00:00
|
|
|
char *nicstr = NULL;
|
2009-09-23 16:25:28 +00:00
|
|
|
char *netstr = NULL;
|
2009-09-23 16:32:50 +00:00
|
|
|
int ret = -1;
|
2009-12-07 19:07:39 +00:00
|
|
|
virDomainDevicePCIAddress guestAddr;
|
2009-07-17 21:08:34 +00:00
|
|
|
|
|
|
|
if (!(qemuCmdFlags & QEMUD_CMD_FLAG_HOST_NET_ADD)) {
|
|
|
|
qemudReportError(conn, dom, NULL, VIR_ERR_NO_SUPPORT, "%s",
|
|
|
|
_("installed qemu version does not support host_net_add"));
|
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (net->type == VIR_DOMAIN_NET_TYPE_BRIDGE ||
|
|
|
|
net->type == VIR_DOMAIN_NET_TYPE_NETWORK) {
|
2009-11-26 17:57:00 +00:00
|
|
|
if (priv->monConfig->type != VIR_DOMAIN_CHR_TYPE_UNIX) {
|
2009-07-22 19:17:14 +00:00
|
|
|
qemudReportError(conn, dom, NULL, VIR_ERR_NO_SUPPORT,
|
|
|
|
_("network device type '%s' cannot be attached: "
|
|
|
|
"qemu is not using a unix socket monitor"),
|
|
|
|
virDomainNetTypeToString(net->type));
|
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
|
|
|
|
if ((tapfd = qemudNetworkIfaceConnect(conn, driver, net, qemuCmdFlags)) < 0)
|
|
|
|
return -1;
|
2009-07-17 21:08:34 +00:00
|
|
|
}
|
|
|
|
|
2009-07-22 19:17:14 +00:00
|
|
|
if (VIR_REALLOC_N(vm->def->nets, vm->def->nnets+1) < 0)
|
|
|
|
goto no_memory;
|
2009-07-17 21:08:34 +00:00
|
|
|
|
|
|
|
if ((qemuCmdFlags & QEMUD_CMD_FLAG_NET_NAME) &&
|
2009-07-22 19:17:14 +00:00
|
|
|
qemuAssignNetNames(vm->def, net) < 0)
|
|
|
|
goto no_memory;
|
2009-07-17 21:08:34 +00:00
|
|
|
|
|
|
|
/* Choose a vlan value greater than all other values since
|
|
|
|
* older versions did not store the value in the state file.
|
|
|
|
*/
|
|
|
|
net->vlan = vm->def->nnets;
|
|
|
|
for (i = 0; i < vm->def->nnets; i++)
|
|
|
|
if (vm->def->nets[i]->vlan >= net->vlan)
|
|
|
|
net->vlan = vm->def->nets[i]->vlan;
|
|
|
|
|
2009-07-22 19:17:14 +00:00
|
|
|
if (tapfd != -1) {
|
|
|
|
if (virAsprintf(&tapfd_name, "fd-%s", net->hostnet_name) < 0)
|
|
|
|
goto no_memory;
|
|
|
|
|
2009-11-03 18:26:32 +00:00
|
|
|
qemuDomainObjEnterMonitorWithDriver(driver, vm);
|
2009-10-13 14:27:58 +00:00
|
|
|
if (qemuMonitorSendFileHandle(priv->mon, tapfd_name, tapfd) < 0) {
|
2009-11-03 18:26:32 +00:00
|
|
|
qemuDomainObjExitMonitorWithDriver(driver, vm);
|
2009-07-22 19:17:14 +00:00
|
|
|
goto cleanup;
|
2009-10-13 14:27:58 +00:00
|
|
|
}
|
2009-11-03 18:26:32 +00:00
|
|
|
qemuDomainObjExitMonitorWithDriver(driver, vm);
|
2009-07-22 19:17:14 +00:00
|
|
|
}
|
|
|
|
|
2010-01-26 13:00:18 +00:00
|
|
|
if (!(netstr = qemuBuildHostNetStr(conn, net, ' ',
|
|
|
|
net->vlan, tapfd_name)))
|
2009-07-22 19:17:14 +00:00
|
|
|
goto try_tapfd_close;
|
2009-07-17 21:08:34 +00:00
|
|
|
|
2009-11-03 18:26:32 +00:00
|
|
|
qemuDomainObjEnterMonitorWithDriver(driver, vm);
|
2009-10-13 14:27:58 +00:00
|
|
|
if (qemuMonitorAddHostNetwork(priv->mon, netstr) < 0) {
|
2009-11-03 18:26:32 +00:00
|
|
|
qemuDomainObjExitMonitorWithDriver(driver, vm);
|
2009-07-22 19:17:14 +00:00
|
|
|
goto try_tapfd_close;
|
2009-10-13 14:27:58 +00:00
|
|
|
}
|
2009-11-03 18:26:32 +00:00
|
|
|
qemuDomainObjExitMonitorWithDriver(driver, vm);
|
2009-07-17 21:08:34 +00:00
|
|
|
|
2009-07-22 19:17:14 +00:00
|
|
|
if (tapfd != -1)
|
|
|
|
close(tapfd);
|
|
|
|
tapfd = -1;
|
2009-07-17 21:08:34 +00:00
|
|
|
|
2010-01-26 13:00:18 +00:00
|
|
|
if (!(nicstr = qemuBuildNicStr(conn, net, NULL, net->vlan)))
|
2009-07-17 21:08:34 +00:00
|
|
|
goto try_remove;
|
2009-07-17 21:08:34 +00:00
|
|
|
|
2009-11-03 18:26:32 +00:00
|
|
|
qemuDomainObjEnterMonitorWithDriver(driver, vm);
|
2009-10-09 20:13:06 +00:00
|
|
|
if (qemuMonitorAddPCINetwork(priv->mon, nicstr,
|
2009-12-07 19:07:39 +00:00
|
|
|
&guestAddr) < 0) {
|
2009-11-03 18:26:32 +00:00
|
|
|
qemuDomainObjExitMonitorWithDriver(driver, vm);
|
2009-07-17 21:08:34 +00:00
|
|
|
goto try_remove;
|
2009-10-13 14:27:58 +00:00
|
|
|
}
|
2009-11-30 18:35:58 +00:00
|
|
|
net->info.type = VIR_DOMAIN_DEVICE_ADDRESS_TYPE_PCI;
|
2009-12-07 19:07:39 +00:00
|
|
|
memcpy(&net->info.addr.pci, &guestAddr, sizeof(guestAddr));
|
2009-11-03 18:26:32 +00:00
|
|
|
qemuDomainObjExitMonitorWithDriver(driver, vm);
|
2009-07-17 21:08:34 +00:00
|
|
|
|
2009-09-23 16:32:50 +00:00
|
|
|
ret = 0;
|
2009-07-17 21:08:34 +00:00
|
|
|
|
|
|
|
vm->def->nets[vm->def->nnets++] = net;
|
|
|
|
|
2009-09-23 16:32:50 +00:00
|
|
|
cleanup:
|
|
|
|
VIR_FREE(nicstr);
|
|
|
|
VIR_FREE(netstr);
|
|
|
|
VIR_FREE(tapfd_name);
|
|
|
|
if (tapfd != -1)
|
|
|
|
close(tapfd);
|
2009-07-17 21:08:34 +00:00
|
|
|
|
2009-09-23 16:32:50 +00:00
|
|
|
return ret;
|
2009-07-17 21:08:34 +00:00
|
|
|
|
2009-09-23 16:32:50 +00:00
|
|
|
try_remove:
|
|
|
|
if (!net->hostnet_name || net->vlan == 0)
|
2010-01-19 13:17:20 +00:00
|
|
|
VIR_WARN0(_("Unable to remove network backend"));
|
2009-10-13 14:27:58 +00:00
|
|
|
else {
|
2009-11-03 18:26:32 +00:00
|
|
|
qemuDomainObjEnterMonitorWithDriver(driver, vm);
|
2009-10-13 14:27:58 +00:00
|
|
|
if (qemuMonitorRemoveHostNetwork(priv->mon, net->vlan, net->hostnet_name) < 0)
|
|
|
|
VIR_WARN(_("Failed to remove network backend for vlan %d, net %s"),
|
|
|
|
net->vlan, net->hostnet_name);
|
2009-11-03 18:26:32 +00:00
|
|
|
qemuDomainObjExitMonitorWithDriver(driver, vm);
|
2009-10-13 14:27:58 +00:00
|
|
|
}
|
2009-07-22 19:17:14 +00:00
|
|
|
goto cleanup;
|
2009-07-17 21:08:34 +00:00
|
|
|
|
2009-07-22 19:17:14 +00:00
|
|
|
try_tapfd_close:
|
2009-10-13 14:27:58 +00:00
|
|
|
if (tapfd_name) {
|
2009-11-03 18:26:32 +00:00
|
|
|
qemuDomainObjEnterMonitorWithDriver(driver, vm);
|
2009-10-13 14:27:58 +00:00
|
|
|
if (qemuMonitorCloseFileHandle(priv->mon, tapfd_name) < 0)
|
2010-01-19 13:17:20 +00:00
|
|
|
VIR_WARN(_("Failed to close tapfd with '%s'"), tapfd_name);
|
2009-11-03 18:26:32 +00:00
|
|
|
qemuDomainObjExitMonitorWithDriver(driver, vm);
|
2009-10-13 14:27:58 +00:00
|
|
|
}
|
2009-09-23 15:51:10 +00:00
|
|
|
|
2009-07-22 19:17:14 +00:00
|
|
|
goto cleanup;
|
|
|
|
|
2009-07-22 19:17:14 +00:00
|
|
|
no_memory:
|
|
|
|
virReportOOMError(conn);
|
2009-09-23 16:32:50 +00:00
|
|
|
goto cleanup;
|
2009-07-17 21:08:34 +00:00
|
|
|
}
|
|
|
|
|
2010-01-18 18:02:20 +00:00
|
|
|
|
2009-08-14 07:31:10 +00:00
|
|
|
static int qemudDomainAttachHostPciDevice(virConnectPtr conn,
|
2009-08-17 14:05:23 +00:00
|
|
|
struct qemud_driver *driver,
|
2009-08-14 07:31:10 +00:00
|
|
|
virDomainObjPtr vm,
|
2010-01-26 17:40:19 +00:00
|
|
|
virDomainHostdevDefPtr hostdev,
|
|
|
|
int qemuCmdFlags)
|
2009-08-14 07:31:10 +00:00
|
|
|
{
|
2009-10-09 20:13:06 +00:00
|
|
|
qemuDomainObjPrivatePtr priv = vm->privateData;
|
2009-08-17 14:05:23 +00:00
|
|
|
pciDevice *pci;
|
2009-10-13 14:27:58 +00:00
|
|
|
int ret;
|
2009-12-07 19:07:39 +00:00
|
|
|
virDomainDevicePCIAddress guestAddr;
|
2010-01-26 17:40:19 +00:00
|
|
|
char *devstr = NULL;
|
2009-08-14 07:31:10 +00:00
|
|
|
|
|
|
|
if (VIR_REALLOC_N(vm->def->hostdevs, vm->def->nhostdevs+1) < 0) {
|
|
|
|
virReportOOMError(conn);
|
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
|
2009-08-17 14:05:23 +00:00
|
|
|
pci = pciGetDevice(conn,
|
|
|
|
hostdev->source.subsys.u.pci.domain,
|
|
|
|
hostdev->source.subsys.u.pci.bus,
|
|
|
|
hostdev->source.subsys.u.pci.slot,
|
|
|
|
hostdev->source.subsys.u.pci.function);
|
2009-12-21 11:32:55 +00:00
|
|
|
if (!pci)
|
2009-08-17 14:05:23 +00:00
|
|
|
return -1;
|
2009-08-14 07:31:10 +00:00
|
|
|
|
2009-12-22 17:21:16 +00:00
|
|
|
if (!pciDeviceIsAssignable(conn, pci, !driver->relaxedACS) ||
|
|
|
|
(hostdev->managed && pciDettachDevice(conn, pci) < 0) ||
|
2009-08-17 14:05:23 +00:00
|
|
|
pciResetDevice(conn, pci, driver->activePciHostdevs) < 0) {
|
|
|
|
pciFreeDevice(conn, pci);
|
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (pciDeviceListAdd(conn, driver->activePciHostdevs, pci) < 0) {
|
2009-08-14 07:31:10 +00:00
|
|
|
pciFreeDevice(conn, pci);
|
2009-08-17 14:05:23 +00:00
|
|
|
return -1;
|
2009-08-14 07:31:10 +00:00
|
|
|
}
|
|
|
|
|
2010-01-26 17:40:19 +00:00
|
|
|
if ((qemuCmdFlags & QEMUD_CMD_FLAG_DEVICE) &&
|
|
|
|
!(devstr = qemuBuildPCIHostdevDevStr(hostdev)))
|
|
|
|
goto error;
|
|
|
|
|
2009-11-03 18:26:32 +00:00
|
|
|
qemuDomainObjEnterMonitorWithDriver(driver, vm);
|
2010-01-26 17:40:19 +00:00
|
|
|
if (qemuCmdFlags & QEMUD_CMD_FLAG_DEVICE)
|
|
|
|
ret = qemuMonitorAddDevice(priv->mon, devstr);
|
|
|
|
else
|
|
|
|
ret = qemuMonitorAddPCIHostDevice(priv->mon,
|
|
|
|
&hostdev->source.subsys.u.pci,
|
|
|
|
&guestAddr);
|
2009-11-03 18:26:32 +00:00
|
|
|
qemuDomainObjExitMonitorWithDriver(driver, vm);
|
2009-10-13 14:27:58 +00:00
|
|
|
if (ret < 0)
|
2009-08-17 14:05:23 +00:00
|
|
|
goto error;
|
2009-11-30 18:35:58 +00:00
|
|
|
hostdev->info.type = VIR_DOMAIN_DEVICE_ADDRESS_TYPE_PCI;
|
2009-12-07 19:07:39 +00:00
|
|
|
memcpy(&hostdev->info.addr.pci, &guestAddr, sizeof(guestAddr));
|
2009-08-14 07:31:10 +00:00
|
|
|
|
|
|
|
vm->def->hostdevs[vm->def->nhostdevs++] = hostdev;
|
|
|
|
|
2010-01-26 17:40:19 +00:00
|
|
|
VIR_FREE(devstr);
|
|
|
|
|
2009-08-14 07:31:10 +00:00
|
|
|
return 0;
|
2009-08-17 14:05:23 +00:00
|
|
|
|
|
|
|
error:
|
2010-01-26 17:40:19 +00:00
|
|
|
VIR_FREE(devstr);
|
2009-08-17 14:05:23 +00:00
|
|
|
pciDeviceListDel(conn, driver->activePciHostdevs, pci);
|
|
|
|
|
|
|
|
return -1;
|
2009-08-14 07:31:10 +00:00
|
|
|
}
|
|
|
|
|
2010-01-18 18:02:20 +00:00
|
|
|
|
2009-08-14 07:31:10 +00:00
|
|
|
static int qemudDomainAttachHostUsbDevice(virConnectPtr conn,
|
2009-11-03 18:26:32 +00:00
|
|
|
struct qemud_driver *driver,
|
2009-08-14 07:31:10 +00:00
|
|
|
virDomainObjPtr vm,
|
2010-01-26 17:40:19 +00:00
|
|
|
virDomainHostdevDefPtr hostdev,
|
|
|
|
int qemuCmdFlags)
|
2008-08-08 14:27:05 +00:00
|
|
|
{
|
|
|
|
int ret;
|
2009-10-09 20:13:06 +00:00
|
|
|
qemuDomainObjPrivatePtr priv = vm->privateData;
|
2010-01-26 17:40:19 +00:00
|
|
|
char *devstr = NULL;
|
|
|
|
|
|
|
|
if ((qemuCmdFlags & QEMUD_CMD_FLAG_DEVICE) &&
|
|
|
|
!(devstr = qemuBuildPCIHostdevDevStr(hostdev)))
|
|
|
|
goto error;
|
2008-08-08 14:27:05 +00:00
|
|
|
|
2008-10-10 16:08:01 +00:00
|
|
|
if (VIR_REALLOC_N(vm->def->hostdevs, vm->def->nhostdevs+1) < 0) {
|
2009-01-29 12:10:32 +00:00
|
|
|
virReportOOMError(conn);
|
2010-01-26 17:40:19 +00:00
|
|
|
goto error;
|
2008-10-10 16:08:01 +00:00
|
|
|
}
|
2008-08-08 14:27:05 +00:00
|
|
|
|
2009-11-03 18:26:32 +00:00
|
|
|
qemuDomainObjEnterMonitorWithDriver(driver, vm);
|
2010-01-26 17:40:19 +00:00
|
|
|
if (qemuCmdFlags & QEMUD_CMD_FLAG_DEVICE)
|
|
|
|
ret = qemuMonitorAddDevice(priv->mon, devstr);
|
|
|
|
else
|
2009-10-09 20:13:06 +00:00
|
|
|
ret = qemuMonitorAddUSBDeviceExact(priv->mon,
|
2010-01-18 18:02:20 +00:00
|
|
|
hostdev->source.subsys.u.usb.bus,
|
|
|
|
hostdev->source.subsys.u.usb.device);
|
2009-11-03 18:26:32 +00:00
|
|
|
qemuDomainObjExitMonitorWithDriver(driver, vm);
|
2010-01-26 17:40:19 +00:00
|
|
|
if (ret < 0)
|
|
|
|
goto error;
|
|
|
|
|
|
|
|
vm->def->hostdevs[vm->def->nhostdevs++] = hostdev;
|
2008-08-08 14:27:05 +00:00
|
|
|
|
2010-01-26 17:40:19 +00:00
|
|
|
VIR_FREE(devstr);
|
2008-09-03 15:05:31 +00:00
|
|
|
|
2010-01-26 17:40:19 +00:00
|
|
|
return 0;
|
|
|
|
|
|
|
|
error:
|
|
|
|
VIR_FREE(devstr);
|
|
|
|
return -1;
|
2007-10-27 01:21:09 +00:00
|
|
|
}
|
|
|
|
|
2010-01-18 18:02:20 +00:00
|
|
|
|
2009-08-14 07:31:10 +00:00
|
|
|
static int qemudDomainAttachHostDevice(virConnectPtr conn,
|
|
|
|
struct qemud_driver *driver,
|
|
|
|
virDomainObjPtr vm,
|
2010-01-26 17:40:19 +00:00
|
|
|
virDomainHostdevDefPtr hostdev,
|
|
|
|
int qemuCmdFlags)
|
2009-08-14 07:31:10 +00:00
|
|
|
{
|
|
|
|
if (hostdev->mode != VIR_DOMAIN_HOSTDEV_MODE_SUBSYS) {
|
|
|
|
qemudReportError(conn, dom, NULL, VIR_ERR_NO_SUPPORT,
|
|
|
|
_("hostdev mode '%s' not supported"),
|
|
|
|
virDomainHostdevModeTypeToString(hostdev->mode));
|
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
|
2009-08-14 13:23:11 +00:00
|
|
|
if (driver->securityDriver &&
|
2010-01-13 14:03:04 +00:00
|
|
|
driver->securityDriver->domainSetSecurityHostdevLabel &&
|
2010-01-18 18:02:20 +00:00
|
|
|
driver->securityDriver->domainSetSecurityHostdevLabel(conn, vm, hostdev) < 0)
|
2009-08-14 13:23:11 +00:00
|
|
|
return -1;
|
2009-08-14 07:31:10 +00:00
|
|
|
|
|
|
|
switch (hostdev->source.subsys.type) {
|
2009-08-14 07:31:10 +00:00
|
|
|
case VIR_DOMAIN_HOSTDEV_SUBSYS_TYPE_PCI:
|
2010-01-26 17:40:19 +00:00
|
|
|
if (qemudDomainAttachHostPciDevice(conn, driver, vm,
|
|
|
|
hostdev, qemuCmdFlags) < 0)
|
2010-01-13 17:27:19 +00:00
|
|
|
goto error;
|
|
|
|
break;
|
|
|
|
|
2009-08-14 07:31:10 +00:00
|
|
|
case VIR_DOMAIN_HOSTDEV_SUBSYS_TYPE_USB:
|
2010-01-26 17:40:19 +00:00
|
|
|
if (qemudDomainAttachHostUsbDevice(conn, driver, vm,
|
|
|
|
hostdev, qemuCmdFlags) < 0)
|
2010-01-13 17:27:19 +00:00
|
|
|
goto error;
|
|
|
|
break;
|
|
|
|
|
2009-08-14 07:31:10 +00:00
|
|
|
default:
|
|
|
|
qemudReportError(conn, dom, NULL, VIR_ERR_NO_SUPPORT,
|
|
|
|
_("hostdev subsys type '%s' not supported"),
|
|
|
|
virDomainHostdevSubsysTypeToString(hostdev->source.subsys.type));
|
2010-01-13 17:27:19 +00:00
|
|
|
goto error;
|
2009-08-14 07:31:10 +00:00
|
|
|
}
|
2010-01-13 17:27:19 +00:00
|
|
|
|
|
|
|
return 0;
|
|
|
|
|
|
|
|
error:
|
|
|
|
if (driver->securityDriver &&
|
|
|
|
driver->securityDriver->domainRestoreSecurityHostdevLabel &&
|
2010-01-18 18:02:20 +00:00
|
|
|
driver->securityDriver->domainRestoreSecurityHostdevLabel(conn, vm, hostdev) < 0)
|
2010-01-13 17:27:19 +00:00
|
|
|
VIR_WARN0("Unable to restore host device labelling on hotplug fail");
|
|
|
|
|
|
|
|
return -1;
|
2009-08-14 07:31:10 +00:00
|
|
|
}
|
|
|
|
|
2010-01-18 18:02:20 +00:00
|
|
|
|
2008-08-08 14:27:05 +00:00
|
|
|
static int qemudDomainAttachDevice(virDomainPtr dom,
|
2010-01-18 18:02:20 +00:00
|
|
|
const char *xml)
|
|
|
|
{
|
2008-12-04 21:04:30 +00:00
|
|
|
struct qemud_driver *driver = dom->conn->privateData;
|
|
|
|
virDomainObjPtr vm;
|
|
|
|
virDomainDeviceDefPtr dev = NULL;
|
2009-07-17 21:08:34 +00:00
|
|
|
unsigned int qemuCmdFlags;
|
2009-07-09 13:11:49 +00:00
|
|
|
virCgroupPtr cgroup = NULL;
|
2008-12-04 21:04:30 +00:00
|
|
|
int ret = -1;
|
2008-08-08 14:27:05 +00:00
|
|
|
|
2008-12-04 21:06:41 +00:00
|
|
|
qemuDriverLock(driver);
|
2008-12-04 21:04:30 +00:00
|
|
|
vm = virDomainFindByUUID(&driver->domains, dom->uuid);
|
2008-08-08 14:27:05 +00:00
|
|
|
if (!vm) {
|
2009-04-19 15:30:50 +00:00
|
|
|
char uuidstr[VIR_UUID_STRING_BUFLEN];
|
|
|
|
virUUIDFormat(dom->uuid, uuidstr);
|
|
|
|
qemudReportError(dom->conn, dom, NULL, VIR_ERR_NO_DOMAIN,
|
|
|
|
_("no domain with matching uuid '%s'"), uuidstr);
|
2008-12-04 21:04:30 +00:00
|
|
|
goto cleanup;
|
2008-08-08 14:27:05 +00:00
|
|
|
}
|
|
|
|
|
2009-11-03 18:26:32 +00:00
|
|
|
if (qemuDomainObjBeginJobWithDriver(driver, vm) < 0)
|
|
|
|
goto cleanup;
|
|
|
|
|
Rename internal APis
Rename virDomainIsActive to virDomainObjIsActive, and
virInterfaceIsActive to virInterfaceObjIsActive and finally
virNetworkIsActive to virNetworkObjIsActive.
* src/conf/domain_conf.c, src/conf/domain_conf.h,
src/conf/interface_conf.h, src/conf/network_conf.c,
src/conf/network_conf.h, src/lxc/lxc_driver.c,
src/network/bridge_driver.c, src/opennebula/one_driver.c,
src/openvz/openvz_driver.c, src/qemu/qemu_driver.c,
src/test/test_driver.c, src/uml/uml_driver.c: Update for
renamed APIs.
2009-10-20 14:51:03 +00:00
|
|
|
if (!virDomainObjIsActive(vm)) {
|
2009-05-08 09:58:46 +00:00
|
|
|
qemudReportError(dom->conn, dom, NULL, VIR_ERR_OPERATION_INVALID,
|
2008-08-08 14:27:05 +00:00
|
|
|
"%s", _("cannot attach device on inactive domain"));
|
2009-11-03 18:26:32 +00:00
|
|
|
goto endjob;
|
2008-08-08 14:27:05 +00:00
|
|
|
}
|
|
|
|
|
2009-01-08 13:54:20 +00:00
|
|
|
dev = virDomainDeviceDefParse(dom->conn, driver->caps, vm->def, xml,
|
|
|
|
VIR_DOMAIN_XML_INACTIVE);
|
2008-12-04 21:04:30 +00:00
|
|
|
if (dev == NULL)
|
2009-11-03 18:26:32 +00:00
|
|
|
goto endjob;
|
2008-12-04 21:04:30 +00:00
|
|
|
|
2009-07-17 21:08:34 +00:00
|
|
|
if (qemudExtractVersionInfo(vm->def->emulator,
|
|
|
|
NULL,
|
|
|
|
&qemuCmdFlags) < 0)
|
2009-11-03 18:26:32 +00:00
|
|
|
goto endjob;
|
2008-08-08 14:27:05 +00:00
|
|
|
|
2008-10-17 12:36:39 +00:00
|
|
|
if (dev->type == VIR_DOMAIN_DEVICE_DISK) {
|
2009-07-22 15:08:04 +00:00
|
|
|
if (qemuCgroupControllerActive(driver, VIR_CGROUP_CONTROLLER_DEVICES)) {
|
2009-07-09 13:11:49 +00:00
|
|
|
if (virCgroupForDomain(driver->cgroup, vm->def->name, &cgroup, 0) !=0 ) {
|
|
|
|
qemudReportError(dom->conn, NULL, NULL, VIR_ERR_INTERNAL_ERROR,
|
|
|
|
_("Unable to find cgroup for %s\n"),
|
|
|
|
vm->def->name);
|
2009-11-03 18:26:32 +00:00
|
|
|
goto endjob;
|
2009-07-09 13:11:49 +00:00
|
|
|
}
|
|
|
|
if (dev->data.disk->src != NULL &&
|
|
|
|
dev->data.disk->type == VIR_DOMAIN_DISK_TYPE_BLOCK &&
|
|
|
|
virCgroupAllowDevicePath(cgroup,
|
|
|
|
dev->data.disk->src) < 0) {
|
|
|
|
qemudReportError(dom->conn, NULL, NULL, VIR_ERR_INTERNAL_ERROR,
|
|
|
|
_("unable to allow device %s"),
|
|
|
|
dev->data.disk->src);
|
2009-11-03 18:26:32 +00:00
|
|
|
goto endjob;
|
2009-07-09 13:11:49 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2008-10-17 12:36:39 +00:00
|
|
|
switch (dev->data.disk->device) {
|
2008-12-04 21:04:30 +00:00
|
|
|
case VIR_DOMAIN_DISK_DEVICE_CDROM:
|
|
|
|
case VIR_DOMAIN_DISK_DEVICE_FLOPPY:
|
2010-01-18 18:02:20 +00:00
|
|
|
ret = qemudDomainChangeEjectableMedia(dom->conn, driver, vm, dev->data.disk);
|
|
|
|
if (ret == 0)
|
|
|
|
dev->data.disk = NULL;
|
2008-12-04 21:04:30 +00:00
|
|
|
break;
|
2009-03-02 17:39:43 +00:00
|
|
|
|
2008-12-04 21:04:30 +00:00
|
|
|
case VIR_DOMAIN_DISK_DEVICE_DISK:
|
|
|
|
if (dev->data.disk->bus == VIR_DOMAIN_DISK_BUS_USB) {
|
2010-01-26 17:40:19 +00:00
|
|
|
ret = qemudDomainAttachUsbMassstorageDevice(dom->conn, driver, vm,
|
|
|
|
dev->data.disk, qemuCmdFlags);
|
2010-01-18 18:02:20 +00:00
|
|
|
if (ret == 0)
|
|
|
|
dev->data.disk = NULL;
|
Properly support SCSI drive hotplug
The current SCSI hotplug support attaches a brand new SCSI controller
for every disk. This is broken because the semantics differ from those
used when starting the VM initially. In the latter case, each SCSI
controller is filled before a new one is added.
If the user specifies an high drive index (sdazz) then at initial
startup, many intermediate SCSI controllers may be added with no
drives.
This patch changes SCSI hotplug so that it exactly matches the
behaviour of initial startup. First the SCSI controller number is
determined for the drive to be hotplugged. If any controller upto
and including that controller number is not yet present, it is
attached. Then finally the drive is attached to the last controller.
NB, this breaks SCSI hotunplug, because there is no 'drive_del'
command in current QEMU. Previous SCSI hotunplug was broken in
any case because it was unplugging the entire controller, not
just the drive in question.
A future QEMU will allow proper SCSI hotunplug of a drive.
This patch is derived from work done by Wolfgang Mauerer on disk
controllers.
* src/qemu/qemu_driver.c: Fix SCSI hotplug to add a drive to
the correct controller, instead of just attaching a new
controller.
* src/qemu/qemu_monitor.c, src/qemu/qemu_monitor.h,
src/qemu/qemu_monitor_json.c, src/qemu/qemu_monitor_json.h,
src/qemu/qemu_monitor_text.c, src/qemu/qemu_monitor_text.h: Add
support for 'drive_add' command
2009-12-09 17:57:09 +00:00
|
|
|
} else if (dev->data.disk->bus == VIR_DOMAIN_DISK_BUS_VIRTIO) {
|
2010-01-26 17:40:19 +00:00
|
|
|
ret = qemudDomainAttachPciDiskDevice(dom->conn, driver, vm,
|
|
|
|
dev->data.disk, qemuCmdFlags);
|
2010-01-18 18:02:20 +00:00
|
|
|
if (ret == 0)
|
|
|
|
dev->data.disk = NULL;
|
Properly support SCSI drive hotplug
The current SCSI hotplug support attaches a brand new SCSI controller
for every disk. This is broken because the semantics differ from those
used when starting the VM initially. In the latter case, each SCSI
controller is filled before a new one is added.
If the user specifies an high drive index (sdazz) then at initial
startup, many intermediate SCSI controllers may be added with no
drives.
This patch changes SCSI hotplug so that it exactly matches the
behaviour of initial startup. First the SCSI controller number is
determined for the drive to be hotplugged. If any controller upto
and including that controller number is not yet present, it is
attached. Then finally the drive is attached to the last controller.
NB, this breaks SCSI hotunplug, because there is no 'drive_del'
command in current QEMU. Previous SCSI hotunplug was broken in
any case because it was unplugging the entire controller, not
just the drive in question.
A future QEMU will allow proper SCSI hotunplug of a drive.
This patch is derived from work done by Wolfgang Mauerer on disk
controllers.
* src/qemu/qemu_driver.c: Fix SCSI hotplug to add a drive to
the correct controller, instead of just attaching a new
controller.
* src/qemu/qemu_monitor.c, src/qemu/qemu_monitor.h,
src/qemu/qemu_monitor_json.c, src/qemu/qemu_monitor_json.h,
src/qemu/qemu_monitor_text.c, src/qemu/qemu_monitor_text.h: Add
support for 'drive_add' command
2009-12-09 17:57:09 +00:00
|
|
|
} else if (dev->data.disk->bus == VIR_DOMAIN_DISK_BUS_SCSI) {
|
2010-01-26 17:40:19 +00:00
|
|
|
ret = qemudDomainAttachSCSIDisk(dom->conn, driver, vm,
|
|
|
|
dev->data.disk, qemuCmdFlags);
|
2010-01-18 18:02:20 +00:00
|
|
|
if (ret == 0)
|
|
|
|
dev->data.disk = NULL;
|
2009-03-02 17:39:43 +00:00
|
|
|
} else {
|
|
|
|
qemudReportError(dom->conn, dom, NULL, VIR_ERR_NO_SUPPORT,
|
|
|
|
_("disk bus '%s' cannot be hotplugged."),
|
|
|
|
virDomainDiskBusTypeToString(dev->data.disk->bus));
|
2009-07-09 13:11:49 +00:00
|
|
|
/* fallthrough */
|
2008-12-04 21:04:30 +00:00
|
|
|
}
|
|
|
|
break;
|
2009-03-02 17:39:43 +00:00
|
|
|
|
2008-12-04 21:04:30 +00:00
|
|
|
default:
|
|
|
|
qemudReportError(dom->conn, dom, NULL, VIR_ERR_NO_SUPPORT,
|
2009-03-02 17:39:43 +00:00
|
|
|
_("disk device type '%s' cannot be hotplugged"),
|
|
|
|
virDomainDiskDeviceTypeToString(dev->data.disk->device));
|
2009-07-09 13:11:49 +00:00
|
|
|
/* Fallthrough */
|
|
|
|
}
|
2009-12-16 13:15:50 +00:00
|
|
|
if (ret != 0 && cgroup) {
|
2009-07-09 13:11:49 +00:00
|
|
|
virCgroupDenyDevicePath(cgroup,
|
|
|
|
dev->data.disk->src);
|
2008-10-17 12:36:39 +00:00
|
|
|
}
|
2009-12-07 19:28:05 +00:00
|
|
|
} else if (dev->type == VIR_DOMAIN_DEVICE_CONTROLLER) {
|
|
|
|
if (dev->data.controller->type == VIR_DOMAIN_CONTROLLER_TYPE_SCSI) {
|
2010-01-26 17:40:19 +00:00
|
|
|
ret = qemudDomainAttachPciControllerDevice(dom->conn, driver, vm,
|
|
|
|
dev->data.controller, qemuCmdFlags);
|
2009-12-07 19:28:05 +00:00
|
|
|
} else {
|
|
|
|
qemudReportError(dom->conn, dom, NULL, VIR_ERR_NO_SUPPORT,
|
|
|
|
_("disk controller bus '%s' cannot be hotplugged."),
|
|
|
|
virDomainControllerTypeToString(dev->data.controller->type));
|
|
|
|
/* fallthrough */
|
|
|
|
}
|
2009-07-17 21:08:34 +00:00
|
|
|
} else if (dev->type == VIR_DOMAIN_DEVICE_NET) {
|
2010-01-26 17:40:19 +00:00
|
|
|
ret = qemudDomainAttachNetDevice(dom->conn, driver, vm,
|
|
|
|
dev->data.net, qemuCmdFlags);
|
2010-01-18 18:02:20 +00:00
|
|
|
if (ret == 0)
|
|
|
|
dev->data.net = NULL;
|
2009-08-14 07:31:10 +00:00
|
|
|
} else if (dev->type == VIR_DOMAIN_DEVICE_HOSTDEV) {
|
2010-01-26 17:40:19 +00:00
|
|
|
ret = qemudDomainAttachHostDevice(dom->conn, driver, vm,
|
|
|
|
dev->data.hostdev, qemuCmdFlags);
|
2010-01-18 18:02:20 +00:00
|
|
|
if (ret == 0)
|
|
|
|
dev->data.hostdev = NULL;
|
2008-12-04 21:04:30 +00:00
|
|
|
} else {
|
2008-08-08 14:27:05 +00:00
|
|
|
qemudReportError(dom->conn, dom, NULL, VIR_ERR_NO_SUPPORT,
|
2009-03-02 17:39:43 +00:00
|
|
|
_("device type '%s' cannot be attached"),
|
|
|
|
virDomainDeviceTypeToString(dev->type));
|
2009-11-03 18:26:32 +00:00
|
|
|
goto endjob;
|
2008-08-08 14:27:05 +00:00
|
|
|
}
|
|
|
|
|
2009-11-26 17:57:00 +00:00
|
|
|
if (!ret && virDomainSaveStatus(dom->conn, driver->caps, driver->stateDir, vm) < 0)
|
2009-02-07 21:36:06 +00:00
|
|
|
ret = -1;
|
|
|
|
|
2009-11-03 18:26:32 +00:00
|
|
|
endjob:
|
2009-12-08 14:42:43 +00:00
|
|
|
if (qemuDomainObjEndJob(vm) == 0)
|
|
|
|
vm = NULL;
|
2009-11-03 18:26:32 +00:00
|
|
|
|
2008-12-04 21:04:30 +00:00
|
|
|
cleanup:
|
2009-07-09 13:11:49 +00:00
|
|
|
if (cgroup)
|
|
|
|
virCgroupFree(&cgroup);
|
|
|
|
|
2010-01-18 18:02:20 +00:00
|
|
|
virDomainDeviceDefFree(dev);
|
2008-12-04 21:06:41 +00:00
|
|
|
if (vm)
|
|
|
|
virDomainObjUnlock(vm);
|
2009-05-19 11:06:25 +00:00
|
|
|
qemuDriverUnlock(driver);
|
2008-08-08 14:27:05 +00:00
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
2008-12-04 21:04:30 +00:00
|
|
|
static int qemudDomainDetachPciDiskDevice(virConnectPtr conn,
|
2009-11-03 18:26:32 +00:00
|
|
|
struct qemud_driver *driver,
|
|
|
|
virDomainObjPtr vm,
|
|
|
|
virDomainDeviceDefPtr dev)
|
2008-10-29 14:32:40 +00:00
|
|
|
{
|
|
|
|
int i, ret = -1;
|
|
|
|
virDomainDiskDefPtr detach = NULL;
|
2009-10-09 20:13:06 +00:00
|
|
|
qemuDomainObjPrivatePtr priv = vm->privateData;
|
2008-10-29 14:32:40 +00:00
|
|
|
|
|
|
|
for (i = 0 ; i < vm->def->ndisks ; i++) {
|
|
|
|
if (STREQ(vm->def->disks[i]->dst, dev->data.disk->dst)) {
|
|
|
|
detach = vm->def->disks[i];
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
if (!detach) {
|
2008-12-04 21:04:30 +00:00
|
|
|
qemudReportError(conn, NULL, NULL, VIR_ERR_OPERATION_FAILED,
|
2008-10-29 14:32:40 +00:00
|
|
|
_("disk %s not found"), dev->data.disk->dst);
|
2008-12-04 21:04:30 +00:00
|
|
|
goto cleanup;
|
2008-10-29 14:32:40 +00:00
|
|
|
}
|
|
|
|
|
2009-11-30 18:35:58 +00:00
|
|
|
if (!virDomainDeviceAddressIsValid(&detach->info,
|
|
|
|
VIR_DOMAIN_DEVICE_ADDRESS_TYPE_PCI)) {
|
|
|
|
qemudReportError(conn, NULL, NULL, VIR_ERR_OPERATION_FAILED, "%s",
|
|
|
|
_("device cannot be detached without a PCI address"));
|
2008-12-04 21:04:30 +00:00
|
|
|
goto cleanup;
|
2008-10-29 14:32:40 +00:00
|
|
|
}
|
|
|
|
|
2009-11-03 18:26:32 +00:00
|
|
|
qemuDomainObjEnterMonitorWithDriver(driver, vm);
|
2009-10-09 20:13:06 +00:00
|
|
|
if (qemuMonitorRemovePCIDevice(priv->mon,
|
2009-12-07 19:07:39 +00:00
|
|
|
&detach->info.addr.pci) < 0) {
|
2009-10-13 14:27:58 +00:00
|
|
|
qemuDomainObjExitMonitor(vm);
|
2008-12-04 21:04:30 +00:00
|
|
|
goto cleanup;
|
2009-10-13 14:27:58 +00:00
|
|
|
}
|
2009-11-03 18:26:32 +00:00
|
|
|
qemuDomainObjExitMonitorWithDriver(driver, vm);
|
2008-10-29 14:32:40 +00:00
|
|
|
|
2009-08-14 09:31:36 +00:00
|
|
|
if (vm->def->ndisks > 1) {
|
|
|
|
memmove(vm->def->disks + i,
|
|
|
|
vm->def->disks + i + 1,
|
|
|
|
sizeof(*vm->def->disks) *
|
|
|
|
(vm->def->ndisks - (i + 1)));
|
|
|
|
vm->def->ndisks--;
|
|
|
|
if (VIR_REALLOC_N(vm->def->disks, vm->def->ndisks) < 0) {
|
|
|
|
/* ignore, harmless */
|
|
|
|
}
|
|
|
|
} else {
|
2009-09-17 14:31:08 +00:00
|
|
|
VIR_FREE(vm->def->disks);
|
2009-08-14 09:31:36 +00:00
|
|
|
vm->def->ndisks = 0;
|
2008-10-29 14:32:40 +00:00
|
|
|
}
|
2009-08-14 09:31:36 +00:00
|
|
|
virDomainDiskDefFree(detach);
|
2009-08-17 14:05:22 +00:00
|
|
|
|
2010-01-13 17:27:19 +00:00
|
|
|
if (driver->securityDriver &&
|
|
|
|
driver->securityDriver->domainRestoreSecurityImageLabel &&
|
|
|
|
driver->securityDriver->domainRestoreSecurityImageLabel(conn, vm, dev->data.disk) < 0)
|
|
|
|
VIR_WARN("Unable to restore security label on %s", dev->data.disk->src);
|
|
|
|
|
2008-10-29 14:32:40 +00:00
|
|
|
ret = 0;
|
2008-12-04 21:04:30 +00:00
|
|
|
|
|
|
|
cleanup:
|
2008-10-29 14:32:40 +00:00
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
2009-12-07 19:28:05 +00:00
|
|
|
static int qemudDomainDetachPciControllerDevice(virConnectPtr conn,
|
|
|
|
struct qemud_driver *driver,
|
|
|
|
virDomainObjPtr vm,
|
|
|
|
virDomainDeviceDefPtr dev)
|
|
|
|
{
|
|
|
|
int i, ret = -1;
|
|
|
|
virDomainControllerDefPtr detach = NULL;
|
|
|
|
qemuDomainObjPrivatePtr priv = vm->privateData;
|
|
|
|
|
|
|
|
for (i = 0 ; i < vm->def->ncontrollers ; i++) {
|
|
|
|
if ((vm->def->controllers[i]->type == dev->data.controller->type) &&
|
|
|
|
(vm->def->controllers[i]->idx == dev->data.controller->idx)) {
|
|
|
|
detach = vm->def->controllers[i];
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
if (!detach) {
|
|
|
|
qemudReportError(conn, NULL, NULL, VIR_ERR_OPERATION_FAILED,
|
|
|
|
_("disk controller %s:%d not found"),
|
|
|
|
virDomainControllerTypeToString(dev->data.controller->type),
|
|
|
|
dev->data.controller->idx);
|
|
|
|
goto cleanup;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (!virDomainDeviceAddressIsValid(&detach->info,
|
|
|
|
VIR_DOMAIN_DEVICE_ADDRESS_TYPE_PCI)) {
|
|
|
|
qemudReportError(conn, NULL, NULL, VIR_ERR_OPERATION_FAILED, "%s",
|
|
|
|
_("device cannot be detached without a PCI address"));
|
|
|
|
goto cleanup;
|
|
|
|
}
|
|
|
|
|
|
|
|
qemuDomainObjEnterMonitorWithDriver(driver, vm);
|
|
|
|
if (qemuMonitorRemovePCIDevice(priv->mon,
|
|
|
|
&detach->info.addr.pci) < 0) {
|
|
|
|
qemuDomainObjExitMonitor(vm);
|
|
|
|
goto cleanup;
|
|
|
|
}
|
|
|
|
qemuDomainObjExitMonitorWithDriver(driver, vm);
|
|
|
|
|
|
|
|
if (vm->def->ncontrollers > 1) {
|
|
|
|
memmove(vm->def->controllers + i,
|
|
|
|
vm->def->controllers + i + 1,
|
|
|
|
sizeof(*vm->def->controllers) *
|
|
|
|
(vm->def->ncontrollers - (i + 1)));
|
|
|
|
vm->def->ncontrollers--;
|
|
|
|
if (VIR_REALLOC_N(vm->def->controllers, vm->def->ncontrollers) < 0) {
|
|
|
|
/* ignore, harmless */
|
|
|
|
}
|
|
|
|
} else {
|
|
|
|
VIR_FREE(vm->def->controllers);
|
|
|
|
vm->def->ncontrollers = 0;
|
|
|
|
}
|
|
|
|
virDomainControllerDefFree(detach);
|
|
|
|
|
|
|
|
ret = 0;
|
|
|
|
|
|
|
|
cleanup:
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
2009-07-17 21:08:34 +00:00
|
|
|
static int
|
|
|
|
qemudDomainDetachNetDevice(virConnectPtr conn,
|
2009-11-03 18:26:32 +00:00
|
|
|
struct qemud_driver *driver,
|
2009-07-17 21:08:34 +00:00
|
|
|
virDomainObjPtr vm,
|
|
|
|
virDomainDeviceDefPtr dev)
|
|
|
|
{
|
|
|
|
int i, ret = -1;
|
|
|
|
virDomainNetDefPtr detach = NULL;
|
2009-10-09 20:13:06 +00:00
|
|
|
qemuDomainObjPrivatePtr priv = vm->privateData;
|
2009-07-17 21:08:34 +00:00
|
|
|
|
|
|
|
for (i = 0 ; i < vm->def->nnets ; i++) {
|
|
|
|
virDomainNetDefPtr net = vm->def->nets[i];
|
|
|
|
|
|
|
|
if (!memcmp(net->mac, dev->data.net->mac, sizeof(net->mac))) {
|
|
|
|
detach = net;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
if (!detach) {
|
|
|
|
qemudReportError(conn, NULL, NULL, VIR_ERR_OPERATION_FAILED,
|
|
|
|
_("network device %02x:%02x:%02x:%02x:%02x:%02x not found"),
|
|
|
|
dev->data.net->mac[0], dev->data.net->mac[1],
|
|
|
|
dev->data.net->mac[2], dev->data.net->mac[3],
|
|
|
|
dev->data.net->mac[4], dev->data.net->mac[5]);
|
|
|
|
goto cleanup;
|
|
|
|
}
|
|
|
|
|
2009-11-30 18:35:58 +00:00
|
|
|
if (!virDomainDeviceAddressIsValid(&detach->info,
|
|
|
|
VIR_DOMAIN_DEVICE_ADDRESS_TYPE_PCI)) {
|
|
|
|
qemudReportError(conn, NULL, NULL, VIR_ERR_OPERATION_FAILED,
|
|
|
|
"%s", _("device cannot be detached without a PCI address"));
|
|
|
|
goto cleanup;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (detach->vlan < 0 || !detach->hostnet_name) {
|
2009-07-17 21:08:34 +00:00
|
|
|
qemudReportError(conn, NULL, NULL, VIR_ERR_OPERATION_FAILED,
|
|
|
|
"%s", _("network device cannot be detached - device state missing"));
|
|
|
|
goto cleanup;
|
|
|
|
}
|
|
|
|
|
2009-11-03 18:26:32 +00:00
|
|
|
qemuDomainObjEnterMonitorWithDriver(driver, vm);
|
2009-10-09 20:13:06 +00:00
|
|
|
if (qemuMonitorRemovePCIDevice(priv->mon,
|
2009-12-07 19:07:39 +00:00
|
|
|
&detach->info.addr.pci) < 0) {
|
2009-11-03 18:26:32 +00:00
|
|
|
qemuDomainObjExitMonitorWithDriver(driver, vm);
|
2009-07-17 21:08:34 +00:00
|
|
|
goto cleanup;
|
2009-10-13 14:27:58 +00:00
|
|
|
}
|
2009-07-17 21:08:34 +00:00
|
|
|
|
2009-10-13 14:27:58 +00:00
|
|
|
if (qemuMonitorRemoveHostNetwork(priv->mon, detach->vlan, detach->hostnet_name) < 0) {
|
2009-11-03 18:26:32 +00:00
|
|
|
qemuDomainObjExitMonitorWithDriver(driver, vm);
|
2009-07-17 21:08:34 +00:00
|
|
|
goto cleanup;
|
2009-10-13 14:27:58 +00:00
|
|
|
}
|
2009-11-03 18:26:32 +00:00
|
|
|
qemuDomainObjExitMonitorWithDriver(driver, vm);
|
2009-07-17 21:08:34 +00:00
|
|
|
|
2009-11-24 10:25:16 +00:00
|
|
|
if ((driver->macFilter) && (detach->ifname != NULL)) {
|
|
|
|
if ((errno = networkDisallowMacOnPort(conn,
|
|
|
|
driver,
|
|
|
|
detach->ifname,
|
|
|
|
detach->mac))) {
|
|
|
|
virReportSystemError(conn, errno,
|
|
|
|
_("failed to remove ebtables rule on '%s'"),
|
|
|
|
detach->ifname);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2009-08-14 09:31:36 +00:00
|
|
|
if (vm->def->nnets > 1) {
|
|
|
|
memmove(vm->def->nets + i,
|
|
|
|
vm->def->nets + i + 1,
|
|
|
|
sizeof(*vm->def->nets) *
|
|
|
|
(vm->def->nnets - (i + 1)));
|
|
|
|
vm->def->nnets--;
|
|
|
|
if (VIR_REALLOC_N(vm->def->nets, vm->def->nnets) < 0) {
|
|
|
|
/* ignore, harmless */
|
|
|
|
}
|
|
|
|
} else {
|
2009-09-17 14:31:08 +00:00
|
|
|
VIR_FREE(vm->def->nets);
|
2009-08-14 09:31:36 +00:00
|
|
|
vm->def->nnets = 0;
|
2009-07-17 21:08:34 +00:00
|
|
|
}
|
2009-08-14 09:31:36 +00:00
|
|
|
virDomainNetDefFree(detach);
|
2009-08-17 14:05:22 +00:00
|
|
|
|
2009-07-17 21:08:34 +00:00
|
|
|
ret = 0;
|
|
|
|
|
|
|
|
cleanup:
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
2009-08-14 07:31:10 +00:00
|
|
|
static int qemudDomainDetachHostPciDevice(virConnectPtr conn,
|
2009-08-17 14:05:23 +00:00
|
|
|
struct qemud_driver *driver,
|
2009-08-14 07:31:10 +00:00
|
|
|
virDomainObjPtr vm,
|
|
|
|
virDomainDeviceDefPtr dev)
|
|
|
|
{
|
2009-09-24 08:00:24 +00:00
|
|
|
virDomainHostdevDefPtr detach = NULL;
|
2009-10-09 20:13:06 +00:00
|
|
|
qemuDomainObjPrivatePtr priv = vm->privateData;
|
2009-08-14 07:31:10 +00:00
|
|
|
int i, ret;
|
2009-08-17 14:05:23 +00:00
|
|
|
pciDevice *pci;
|
2009-08-14 07:31:10 +00:00
|
|
|
|
|
|
|
for (i = 0 ; i < vm->def->nhostdevs ; i++) {
|
|
|
|
unsigned domain = vm->def->hostdevs[i]->source.subsys.u.pci.domain;
|
|
|
|
unsigned bus = vm->def->hostdevs[i]->source.subsys.u.pci.bus;
|
|
|
|
unsigned slot = vm->def->hostdevs[i]->source.subsys.u.pci.slot;
|
|
|
|
unsigned function = vm->def->hostdevs[i]->source.subsys.u.pci.function;
|
|
|
|
|
|
|
|
if (dev->data.hostdev->source.subsys.u.pci.domain == domain &&
|
|
|
|
dev->data.hostdev->source.subsys.u.pci.bus == bus &&
|
|
|
|
dev->data.hostdev->source.subsys.u.pci.slot == slot &&
|
|
|
|
dev->data.hostdev->source.subsys.u.pci.function == function) {
|
|
|
|
detach = vm->def->hostdevs[i];
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
if (!detach) {
|
|
|
|
qemudReportError(conn, NULL, NULL, VIR_ERR_OPERATION_FAILED,
|
|
|
|
_("host pci device %.4x:%.2x:%.2x.%.1x not found"),
|
|
|
|
dev->data.hostdev->source.subsys.u.pci.domain,
|
|
|
|
dev->data.hostdev->source.subsys.u.pci.bus,
|
|
|
|
dev->data.hostdev->source.subsys.u.pci.slot,
|
|
|
|
dev->data.hostdev->source.subsys.u.pci.function);
|
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
|
2009-11-30 18:35:58 +00:00
|
|
|
if (!virDomainDeviceAddressIsValid(&detach->info,
|
|
|
|
VIR_DOMAIN_DEVICE_ADDRESS_TYPE_PCI)) {
|
2009-08-14 07:31:10 +00:00
|
|
|
qemudReportError(conn, NULL, NULL, VIR_ERR_OPERATION_FAILED,
|
2009-11-30 18:35:58 +00:00
|
|
|
"%s", _("device cannot be detached without a PCI address"));
|
2009-08-14 07:31:10 +00:00
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
|
2009-11-03 18:26:32 +00:00
|
|
|
qemuDomainObjEnterMonitorWithDriver(driver, vm);
|
2009-10-09 20:13:06 +00:00
|
|
|
if (qemuMonitorRemovePCIDevice(priv->mon,
|
2009-12-07 19:07:39 +00:00
|
|
|
&detach->info.addr.pci) < 0) {
|
2009-11-03 18:26:32 +00:00
|
|
|
qemuDomainObjExitMonitorWithDriver(driver, vm);
|
2009-08-14 07:31:10 +00:00
|
|
|
return -1;
|
2009-10-13 14:27:58 +00:00
|
|
|
}
|
2009-11-03 18:26:32 +00:00
|
|
|
qemuDomainObjExitMonitorWithDriver(driver, vm);
|
2009-08-14 07:31:10 +00:00
|
|
|
|
|
|
|
ret = 0;
|
|
|
|
|
2009-08-17 14:05:23 +00:00
|
|
|
pci = pciGetDevice(conn,
|
|
|
|
detach->source.subsys.u.pci.domain,
|
|
|
|
detach->source.subsys.u.pci.bus,
|
|
|
|
detach->source.subsys.u.pci.slot,
|
|
|
|
detach->source.subsys.u.pci.function);
|
|
|
|
if (!pci)
|
|
|
|
ret = -1;
|
|
|
|
else {
|
2010-01-26 15:01:23 +00:00
|
|
|
pciDeviceSetManaged(pci, detach->managed);
|
2009-08-17 14:05:23 +00:00
|
|
|
pciDeviceListDel(conn, driver->activePciHostdevs, pci);
|
|
|
|
if (pciResetDevice(conn, pci, driver->activePciHostdevs) < 0)
|
2009-08-17 14:05:23 +00:00
|
|
|
ret = -1;
|
2010-01-26 15:01:23 +00:00
|
|
|
qemudReattachManagedDevice(pci);
|
2009-08-17 14:05:23 +00:00
|
|
|
pciFreeDevice(conn, pci);
|
2009-08-14 07:31:10 +00:00
|
|
|
}
|
|
|
|
|
2009-09-17 14:32:45 +00:00
|
|
|
if (vm->def->nhostdevs > 1) {
|
|
|
|
memmove(vm->def->hostdevs + i,
|
|
|
|
vm->def->hostdevs + i + 1,
|
|
|
|
sizeof(*vm->def->hostdevs) *
|
|
|
|
(vm->def->nhostdevs - (i + 1)));
|
|
|
|
vm->def->nhostdevs--;
|
|
|
|
if (VIR_REALLOC_N(vm->def->hostdevs, vm->def->nhostdevs) < 0) {
|
|
|
|
/* ignore, harmless */
|
|
|
|
}
|
|
|
|
} else {
|
|
|
|
VIR_FREE(vm->def->hostdevs);
|
|
|
|
vm->def->nhostdevs = 0;
|
2009-08-14 07:31:10 +00:00
|
|
|
}
|
2009-09-17 14:32:45 +00:00
|
|
|
virDomainHostdevDefFree(detach);
|
2009-08-14 07:31:10 +00:00
|
|
|
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
|
|
|
static int qemudDomainDetachHostDevice(virConnectPtr conn,
|
|
|
|
struct qemud_driver *driver,
|
|
|
|
virDomainObjPtr vm,
|
|
|
|
virDomainDeviceDefPtr dev)
|
|
|
|
{
|
|
|
|
virDomainHostdevDefPtr hostdev = dev->data.hostdev;
|
|
|
|
int ret;
|
|
|
|
|
|
|
|
if (hostdev->mode != VIR_DOMAIN_HOSTDEV_MODE_SUBSYS) {
|
|
|
|
qemudReportError(conn, dom, NULL, VIR_ERR_NO_SUPPORT,
|
|
|
|
_("hostdev mode '%s' not supported"),
|
|
|
|
virDomainHostdevModeTypeToString(hostdev->mode));
|
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
|
|
|
|
switch (hostdev->source.subsys.type) {
|
|
|
|
case VIR_DOMAIN_HOSTDEV_SUBSYS_TYPE_PCI:
|
2009-08-17 14:05:23 +00:00
|
|
|
ret = qemudDomainDetachHostPciDevice(conn, driver, vm, dev);
|
2009-08-17 14:05:23 +00:00
|
|
|
break;
|
2009-08-14 07:31:10 +00:00
|
|
|
default:
|
|
|
|
qemudReportError(conn, dom, NULL, VIR_ERR_NO_SUPPORT,
|
|
|
|
_("hostdev subsys type '%s' not supported"),
|
|
|
|
virDomainHostdevSubsysTypeToString(hostdev->source.subsys.type));
|
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
|
2009-08-14 13:23:11 +00:00
|
|
|
if (driver->securityDriver &&
|
2010-01-13 17:27:19 +00:00
|
|
|
driver->securityDriver->domainRestoreSecurityHostdevLabel &&
|
|
|
|
driver->securityDriver->domainRestoreSecurityHostdevLabel(conn, vm, dev->data.hostdev) < 0)
|
|
|
|
VIR_WARN0("Failed to restore host device labelling");
|
2009-08-14 13:23:11 +00:00
|
|
|
|
2009-08-14 07:31:10 +00:00
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
2008-10-29 14:32:40 +00:00
|
|
|
static int qemudDomainDetachDevice(virDomainPtr dom,
|
|
|
|
const char *xml) {
|
2008-12-04 21:04:30 +00:00
|
|
|
struct qemud_driver *driver = dom->conn->privateData;
|
|
|
|
virDomainObjPtr vm;
|
|
|
|
virDomainDeviceDefPtr dev = NULL;
|
|
|
|
int ret = -1;
|
2008-10-29 14:32:40 +00:00
|
|
|
|
2008-12-04 21:06:41 +00:00
|
|
|
qemuDriverLock(driver);
|
2008-12-04 21:04:30 +00:00
|
|
|
vm = virDomainFindByUUID(&driver->domains, dom->uuid);
|
2008-10-29 14:32:40 +00:00
|
|
|
if (!vm) {
|
2009-04-19 15:30:50 +00:00
|
|
|
char uuidstr[VIR_UUID_STRING_BUFLEN];
|
|
|
|
virUUIDFormat(dom->uuid, uuidstr);
|
|
|
|
qemudReportError(dom->conn, dom, NULL, VIR_ERR_NO_DOMAIN,
|
|
|
|
_("no domain with matching uuid '%s'"), uuidstr);
|
2008-12-04 21:04:30 +00:00
|
|
|
goto cleanup;
|
2008-10-29 14:32:40 +00:00
|
|
|
}
|
|
|
|
|
2009-11-03 18:26:32 +00:00
|
|
|
if (qemuDomainObjBeginJobWithDriver(driver, vm) < 0)
|
|
|
|
goto cleanup;
|
|
|
|
|
Rename internal APis
Rename virDomainIsActive to virDomainObjIsActive, and
virInterfaceIsActive to virInterfaceObjIsActive and finally
virNetworkIsActive to virNetworkObjIsActive.
* src/conf/domain_conf.c, src/conf/domain_conf.h,
src/conf/interface_conf.h, src/conf/network_conf.c,
src/conf/network_conf.h, src/lxc/lxc_driver.c,
src/network/bridge_driver.c, src/opennebula/one_driver.c,
src/openvz/openvz_driver.c, src/qemu/qemu_driver.c,
src/test/test_driver.c, src/uml/uml_driver.c: Update for
renamed APIs.
2009-10-20 14:51:03 +00:00
|
|
|
if (!virDomainObjIsActive(vm)) {
|
2009-05-08 09:58:46 +00:00
|
|
|
qemudReportError(dom->conn, dom, NULL, VIR_ERR_OPERATION_INVALID,
|
2009-01-06 17:20:27 +00:00
|
|
|
"%s", _("cannot detach device on inactive domain"));
|
2009-11-03 18:26:32 +00:00
|
|
|
goto endjob;
|
2008-10-29 14:32:40 +00:00
|
|
|
}
|
|
|
|
|
2009-01-08 13:54:20 +00:00
|
|
|
dev = virDomainDeviceDefParse(dom->conn, driver->caps, vm->def, xml,
|
|
|
|
VIR_DOMAIN_XML_INACTIVE);
|
2008-12-04 21:04:30 +00:00
|
|
|
if (dev == NULL)
|
2009-11-03 18:26:32 +00:00
|
|
|
goto endjob;
|
2008-12-04 21:04:30 +00:00
|
|
|
|
2008-10-29 14:32:40 +00:00
|
|
|
|
|
|
|
if (dev->type == VIR_DOMAIN_DEVICE_DISK &&
|
|
|
|
dev->data.disk->device == VIR_DOMAIN_DISK_DEVICE_DISK &&
|
Properly support SCSI drive hotplug
The current SCSI hotplug support attaches a brand new SCSI controller
for every disk. This is broken because the semantics differ from those
used when starting the VM initially. In the latter case, each SCSI
controller is filled before a new one is added.
If the user specifies an high drive index (sdazz) then at initial
startup, many intermediate SCSI controllers may be added with no
drives.
This patch changes SCSI hotplug so that it exactly matches the
behaviour of initial startup. First the SCSI controller number is
determined for the drive to be hotplugged. If any controller upto
and including that controller number is not yet present, it is
attached. Then finally the drive is attached to the last controller.
NB, this breaks SCSI hotunplug, because there is no 'drive_del'
command in current QEMU. Previous SCSI hotunplug was broken in
any case because it was unplugging the entire controller, not
just the drive in question.
A future QEMU will allow proper SCSI hotunplug of a drive.
This patch is derived from work done by Wolfgang Mauerer on disk
controllers.
* src/qemu/qemu_driver.c: Fix SCSI hotplug to add a drive to
the correct controller, instead of just attaching a new
controller.
* src/qemu/qemu_monitor.c, src/qemu/qemu_monitor.h,
src/qemu/qemu_monitor_json.c, src/qemu/qemu_monitor_json.h,
src/qemu/qemu_monitor_text.c, src/qemu/qemu_monitor_text.h: Add
support for 'drive_add' command
2009-12-09 17:57:09 +00:00
|
|
|
dev->data.disk->bus == VIR_DOMAIN_DISK_BUS_VIRTIO) {
|
2009-11-03 18:26:32 +00:00
|
|
|
ret = qemudDomainDetachPciDiskDevice(dom->conn, driver, vm, dev);
|
2009-07-17 21:08:34 +00:00
|
|
|
} else if (dev->type == VIR_DOMAIN_DEVICE_NET) {
|
2009-11-03 18:26:32 +00:00
|
|
|
ret = qemudDomainDetachNetDevice(dom->conn, driver, vm, dev);
|
2009-12-07 19:28:05 +00:00
|
|
|
} else if (dev->type == VIR_DOMAIN_DEVICE_CONTROLLER) {
|
|
|
|
if (dev->data.controller->type == VIR_DOMAIN_CONTROLLER_TYPE_SCSI) {
|
|
|
|
ret = qemudDomainDetachPciControllerDevice(dom->conn, driver, vm, dev);
|
|
|
|
} else {
|
|
|
|
qemudReportError(dom->conn, dom, NULL, VIR_ERR_NO_SUPPORT,
|
|
|
|
_("disk controller bus '%s' cannot be hotunplugged."),
|
|
|
|
virDomainControllerTypeToString(dev->data.controller->type));
|
|
|
|
/* fallthrough */
|
|
|
|
}
|
2009-08-14 07:31:10 +00:00
|
|
|
} else if (dev->type == VIR_DOMAIN_DEVICE_HOSTDEV) {
|
|
|
|
ret = qemudDomainDetachHostDevice(dom->conn, driver, vm, dev);
|
Properly support SCSI drive hotplug
The current SCSI hotplug support attaches a brand new SCSI controller
for every disk. This is broken because the semantics differ from those
used when starting the VM initially. In the latter case, each SCSI
controller is filled before a new one is added.
If the user specifies an high drive index (sdazz) then at initial
startup, many intermediate SCSI controllers may be added with no
drives.
This patch changes SCSI hotplug so that it exactly matches the
behaviour of initial startup. First the SCSI controller number is
determined for the drive to be hotplugged. If any controller upto
and including that controller number is not yet present, it is
attached. Then finally the drive is attached to the last controller.
NB, this breaks SCSI hotunplug, because there is no 'drive_del'
command in current QEMU. Previous SCSI hotunplug was broken in
any case because it was unplugging the entire controller, not
just the drive in question.
A future QEMU will allow proper SCSI hotunplug of a drive.
This patch is derived from work done by Wolfgang Mauerer on disk
controllers.
* src/qemu/qemu_driver.c: Fix SCSI hotplug to add a drive to
the correct controller, instead of just attaching a new
controller.
* src/qemu/qemu_monitor.c, src/qemu/qemu_monitor.h,
src/qemu/qemu_monitor_json.c, src/qemu/qemu_monitor_json.h,
src/qemu/qemu_monitor_text.c, src/qemu/qemu_monitor_text.h: Add
support for 'drive_add' command
2009-12-09 17:57:09 +00:00
|
|
|
} else {
|
2008-10-29 14:32:40 +00:00
|
|
|
qemudReportError(dom->conn, dom, NULL, VIR_ERR_NO_SUPPORT,
|
Properly support SCSI drive hotplug
The current SCSI hotplug support attaches a brand new SCSI controller
for every disk. This is broken because the semantics differ from those
used when starting the VM initially. In the latter case, each SCSI
controller is filled before a new one is added.
If the user specifies an high drive index (sdazz) then at initial
startup, many intermediate SCSI controllers may be added with no
drives.
This patch changes SCSI hotplug so that it exactly matches the
behaviour of initial startup. First the SCSI controller number is
determined for the drive to be hotplugged. If any controller upto
and including that controller number is not yet present, it is
attached. Then finally the drive is attached to the last controller.
NB, this breaks SCSI hotunplug, because there is no 'drive_del'
command in current QEMU. Previous SCSI hotunplug was broken in
any case because it was unplugging the entire controller, not
just the drive in question.
A future QEMU will allow proper SCSI hotunplug of a drive.
This patch is derived from work done by Wolfgang Mauerer on disk
controllers.
* src/qemu/qemu_driver.c: Fix SCSI hotplug to add a drive to
the correct controller, instead of just attaching a new
controller.
* src/qemu/qemu_monitor.c, src/qemu/qemu_monitor.h,
src/qemu/qemu_monitor_json.c, src/qemu/qemu_monitor_json.h,
src/qemu/qemu_monitor_text.c, src/qemu/qemu_monitor_text.h: Add
support for 'drive_add' command
2009-12-09 17:57:09 +00:00
|
|
|
"%s", _("This type of device cannot be hot unplugged"));
|
|
|
|
}
|
2008-10-29 14:32:40 +00:00
|
|
|
|
2009-11-26 17:57:00 +00:00
|
|
|
if (!ret && virDomainSaveStatus(dom->conn, driver->caps, driver->stateDir, vm) < 0)
|
2009-02-07 21:36:06 +00:00
|
|
|
ret = -1;
|
|
|
|
|
2009-11-03 18:26:32 +00:00
|
|
|
endjob:
|
2009-12-08 14:42:43 +00:00
|
|
|
if (qemuDomainObjEndJob(vm) == 0)
|
|
|
|
vm = NULL;
|
2009-11-03 18:26:32 +00:00
|
|
|
|
2008-12-04 21:04:30 +00:00
|
|
|
cleanup:
|
|
|
|
virDomainDeviceDefFree(dev);
|
2008-12-04 21:06:41 +00:00
|
|
|
if (vm)
|
|
|
|
virDomainObjUnlock(vm);
|
2009-05-19 11:06:25 +00:00
|
|
|
qemuDriverUnlock(driver);
|
2008-10-29 14:32:40 +00:00
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
2007-06-29 13:23:13 +00:00
|
|
|
static int qemudDomainGetAutostart(virDomainPtr dom,
|
2008-12-04 21:06:41 +00:00
|
|
|
int *autostart) {
|
2008-12-04 21:04:30 +00:00
|
|
|
struct qemud_driver *driver = dom->conn->privateData;
|
|
|
|
virDomainObjPtr vm;
|
|
|
|
int ret = -1;
|
2007-02-23 09:03:25 +00:00
|
|
|
|
2008-12-04 21:06:41 +00:00
|
|
|
qemuDriverLock(driver);
|
2008-12-04 21:04:30 +00:00
|
|
|
vm = virDomainFindByUUID(&driver->domains, dom->uuid);
|
2008-12-04 21:06:41 +00:00
|
|
|
qemuDriverUnlock(driver);
|
|
|
|
|
2007-02-23 09:03:25 +00:00
|
|
|
if (!vm) {
|
2009-04-19 15:30:50 +00:00
|
|
|
char uuidstr[VIR_UUID_STRING_BUFLEN];
|
|
|
|
virUUIDFormat(dom->uuid, uuidstr);
|
|
|
|
qemudReportError(dom->conn, dom, NULL, VIR_ERR_NO_DOMAIN,
|
|
|
|
_("no domain with matching uuid '%s'"), uuidstr);
|
2008-12-04 21:04:30 +00:00
|
|
|
goto cleanup;
|
2007-02-23 09:03:25 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
*autostart = vm->autostart;
|
2008-12-04 21:04:30 +00:00
|
|
|
ret = 0;
|
2007-02-23 09:03:25 +00:00
|
|
|
|
2008-12-04 21:04:30 +00:00
|
|
|
cleanup:
|
2008-12-04 21:06:41 +00:00
|
|
|
if (vm)
|
|
|
|
virDomainObjUnlock(vm);
|
2008-12-04 21:04:30 +00:00
|
|
|
return ret;
|
2007-02-23 09:03:25 +00:00
|
|
|
}
|
|
|
|
|
2007-06-29 13:23:13 +00:00
|
|
|
static int qemudDomainSetAutostart(virDomainPtr dom,
|
2008-08-20 19:42:36 +00:00
|
|
|
int autostart) {
|
2008-12-04 21:04:30 +00:00
|
|
|
struct qemud_driver *driver = dom->conn->privateData;
|
|
|
|
virDomainObjPtr vm;
|
2008-08-20 19:42:36 +00:00
|
|
|
char *configFile = NULL, *autostartLink = NULL;
|
|
|
|
int ret = -1;
|
2007-02-23 09:03:25 +00:00
|
|
|
|
2008-12-04 21:06:41 +00:00
|
|
|
qemuDriverLock(driver);
|
2008-12-04 21:04:30 +00:00
|
|
|
vm = virDomainFindByUUID(&driver->domains, dom->uuid);
|
2008-12-04 21:06:41 +00:00
|
|
|
|
2007-02-23 09:03:25 +00:00
|
|
|
if (!vm) {
|
2009-04-19 15:30:50 +00:00
|
|
|
char uuidstr[VIR_UUID_STRING_BUFLEN];
|
|
|
|
virUUIDFormat(dom->uuid, uuidstr);
|
|
|
|
qemudReportError(dom->conn, dom, NULL, VIR_ERR_NO_DOMAIN,
|
|
|
|
_("no domain with matching uuid '%s'"), uuidstr);
|
2008-12-04 21:04:30 +00:00
|
|
|
goto cleanup;
|
2007-02-23 09:03:25 +00:00
|
|
|
}
|
|
|
|
|
2008-08-20 19:42:36 +00:00
|
|
|
if (!vm->persistent) {
|
|
|
|
qemudReportError(dom->conn, dom, NULL, VIR_ERR_INTERNAL_ERROR,
|
|
|
|
"%s", _("cannot set autostart for transient domain"));
|
2008-12-04 21:04:30 +00:00
|
|
|
goto cleanup;
|
2008-08-20 19:42:36 +00:00
|
|
|
}
|
|
|
|
|
2007-02-23 09:03:25 +00:00
|
|
|
autostart = (autostart != 0);
|
|
|
|
|
2008-12-04 21:04:30 +00:00
|
|
|
if (vm->autostart != autostart) {
|
|
|
|
if ((configFile = virDomainConfigFile(dom->conn, driver->configDir, vm->def->name)) == NULL)
|
|
|
|
goto cleanup;
|
|
|
|
if ((autostartLink = virDomainConfigFile(dom->conn, driver->autostartDir, vm->def->name)) == NULL)
|
|
|
|
goto cleanup;
|
2007-02-23 09:03:25 +00:00
|
|
|
|
2008-12-04 21:04:30 +00:00
|
|
|
if (autostart) {
|
|
|
|
int err;
|
2008-08-20 19:42:36 +00:00
|
|
|
|
2008-12-04 21:04:30 +00:00
|
|
|
if ((err = virFileMakePath(driver->autostartDir))) {
|
2009-01-20 17:13:33 +00:00
|
|
|
virReportSystemError(dom->conn, err,
|
|
|
|
_("cannot create autostart directory %s"),
|
|
|
|
driver->autostartDir);
|
2008-12-04 21:04:30 +00:00
|
|
|
goto cleanup;
|
|
|
|
}
|
2007-02-23 09:07:41 +00:00
|
|
|
|
2008-12-04 21:04:30 +00:00
|
|
|
if (symlink(configFile, autostartLink) < 0) {
|
2009-01-20 17:13:33 +00:00
|
|
|
virReportSystemError(dom->conn, errno,
|
|
|
|
_("Failed to create symlink '%s to '%s'"),
|
|
|
|
autostartLink, configFile);
|
2008-12-04 21:04:30 +00:00
|
|
|
goto cleanup;
|
|
|
|
}
|
|
|
|
} else {
|
|
|
|
if (unlink(autostartLink) < 0 && errno != ENOENT && errno != ENOTDIR) {
|
2009-01-20 17:13:33 +00:00
|
|
|
virReportSystemError(dom->conn, errno,
|
|
|
|
_("Failed to delete symlink '%s'"),
|
|
|
|
autostartLink);
|
2008-12-04 21:04:30 +00:00
|
|
|
goto cleanup;
|
|
|
|
}
|
2007-02-23 09:07:41 +00:00
|
|
|
}
|
|
|
|
|
2008-12-04 21:04:30 +00:00
|
|
|
vm->autostart = autostart;
|
2007-02-23 09:07:41 +00:00
|
|
|
}
|
2008-08-20 19:42:36 +00:00
|
|
|
ret = 0;
|
2007-02-23 09:03:25 +00:00
|
|
|
|
2008-08-20 19:42:36 +00:00
|
|
|
cleanup:
|
|
|
|
VIR_FREE(configFile);
|
|
|
|
VIR_FREE(autostartLink);
|
2008-12-04 21:06:41 +00:00
|
|
|
if (vm)
|
|
|
|
virDomainObjUnlock(vm);
|
2009-05-19 11:06:25 +00:00
|
|
|
qemuDriverUnlock(driver);
|
2008-08-20 19:42:36 +00:00
|
|
|
return ret;
|
2007-02-23 09:03:25 +00:00
|
|
|
}
|
|
|
|
|
2009-07-09 13:11:21 +00:00
|
|
|
|
|
|
|
static char *qemuGetSchedulerType(virDomainPtr dom,
|
|
|
|
int *nparams)
|
|
|
|
{
|
|
|
|
struct qemud_driver *driver = dom->conn->privateData;
|
2009-09-02 13:02:06 +00:00
|
|
|
char *ret = NULL;
|
2009-07-09 13:11:21 +00:00
|
|
|
|
2009-09-02 13:02:06 +00:00
|
|
|
qemuDriverLock(driver);
|
2009-07-22 15:08:04 +00:00
|
|
|
if (!qemuCgroupControllerActive(driver, VIR_CGROUP_CONTROLLER_CPU)) {
|
2009-07-09 13:11:21 +00:00
|
|
|
qemudReportError(dom->conn, dom, NULL, VIR_ERR_NO_SUPPORT,
|
|
|
|
__FUNCTION__);
|
2009-09-02 13:02:06 +00:00
|
|
|
goto cleanup;
|
2009-07-09 13:11:21 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
if (nparams)
|
|
|
|
*nparams = 1;
|
|
|
|
|
|
|
|
ret = strdup("posix");
|
|
|
|
if (!ret)
|
|
|
|
virReportOOMError(dom->conn);
|
2009-09-02 13:02:06 +00:00
|
|
|
|
|
|
|
cleanup:
|
|
|
|
qemuDriverUnlock(driver);
|
2009-07-09 13:11:21 +00:00
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
|
|
|
static int qemuSetSchedulerParameters(virDomainPtr dom,
|
|
|
|
virSchedParameterPtr params,
|
|
|
|
int nparams)
|
|
|
|
{
|
|
|
|
struct qemud_driver *driver = dom->conn->privateData;
|
|
|
|
int i;
|
|
|
|
virCgroupPtr group = NULL;
|
|
|
|
virDomainObjPtr vm = NULL;
|
|
|
|
int ret = -1;
|
|
|
|
|
2009-09-02 13:02:06 +00:00
|
|
|
qemuDriverLock(driver);
|
2009-07-22 15:08:04 +00:00
|
|
|
if (!qemuCgroupControllerActive(driver, VIR_CGROUP_CONTROLLER_CPU)) {
|
2009-07-09 13:11:21 +00:00
|
|
|
qemudReportError(dom->conn, dom, NULL, VIR_ERR_NO_SUPPORT,
|
|
|
|
__FUNCTION__);
|
2009-09-02 13:02:06 +00:00
|
|
|
goto cleanup;
|
2009-07-09 13:11:21 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
vm = virDomainFindByUUID(&driver->domains, dom->uuid);
|
|
|
|
|
|
|
|
if (vm == NULL) {
|
|
|
|
qemudReportError(dom->conn, dom, NULL, VIR_ERR_INTERNAL_ERROR,
|
|
|
|
_("No such domain %s"), dom->uuid);
|
|
|
|
goto cleanup;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (virCgroupForDomain(driver->cgroup, vm->def->name, &group, 0) != 0) {
|
|
|
|
qemudReportError(dom->conn, dom, NULL, VIR_ERR_INTERNAL_ERROR,
|
|
|
|
_("cannot find cgroup for domain %s"), vm->def->name);
|
|
|
|
goto cleanup;
|
|
|
|
}
|
|
|
|
|
|
|
|
for (i = 0; i < nparams; i++) {
|
|
|
|
virSchedParameterPtr param = ¶ms[i];
|
|
|
|
|
|
|
|
if (STREQ(param->field, "cpu_shares")) {
|
|
|
|
int rc;
|
|
|
|
if (param->type != VIR_DOMAIN_SCHED_FIELD_ULLONG) {
|
2009-11-03 12:30:47 +00:00
|
|
|
qemudReportError(dom->conn, dom, NULL, VIR_ERR_INVALID_ARG, "%s",
|
2009-07-09 13:11:21 +00:00
|
|
|
_("invalid type for cpu_shares tunable, expected a 'ullong'"));
|
|
|
|
goto cleanup;
|
|
|
|
}
|
|
|
|
|
|
|
|
rc = virCgroupSetCpuShares(group, params[i].value.ul);
|
|
|
|
if (rc != 0) {
|
|
|
|
virReportSystemError(dom->conn, -rc, "%s",
|
|
|
|
_("unable to set cpu shares tunable"));
|
|
|
|
goto cleanup;
|
|
|
|
}
|
|
|
|
} else {
|
|
|
|
qemudReportError(dom->conn, domain, NULL, VIR_ERR_INVALID_ARG,
|
|
|
|
_("Invalid parameter `%s'"), param->field);
|
|
|
|
goto cleanup;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
ret = 0;
|
|
|
|
|
|
|
|
cleanup:
|
|
|
|
virCgroupFree(&group);
|
|
|
|
if (vm)
|
|
|
|
virDomainObjUnlock(vm);
|
2009-09-02 13:02:06 +00:00
|
|
|
qemuDriverUnlock(driver);
|
2009-07-09 13:11:21 +00:00
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
|
|
|
static int qemuGetSchedulerParameters(virDomainPtr dom,
|
|
|
|
virSchedParameterPtr params,
|
|
|
|
int *nparams)
|
|
|
|
{
|
|
|
|
struct qemud_driver *driver = dom->conn->privateData;
|
|
|
|
virCgroupPtr group = NULL;
|
|
|
|
virDomainObjPtr vm = NULL;
|
|
|
|
unsigned long long val;
|
|
|
|
int ret = -1;
|
|
|
|
int rc;
|
|
|
|
|
2009-09-02 13:02:06 +00:00
|
|
|
qemuDriverLock(driver);
|
2009-07-22 15:08:04 +00:00
|
|
|
if (!qemuCgroupControllerActive(driver, VIR_CGROUP_CONTROLLER_CPU)) {
|
2009-07-09 13:11:21 +00:00
|
|
|
qemudReportError(dom->conn, dom, NULL, VIR_ERR_NO_SUPPORT,
|
|
|
|
__FUNCTION__);
|
2009-09-02 13:02:06 +00:00
|
|
|
goto cleanup;
|
2009-07-09 13:11:21 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
if ((*nparams) != 1) {
|
|
|
|
qemudReportError(dom->conn, domain, NULL, VIR_ERR_INVALID_ARG,
|
|
|
|
"%s", _("Invalid parameter count"));
|
2009-09-02 13:02:06 +00:00
|
|
|
goto cleanup;
|
2009-07-09 13:11:21 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
vm = virDomainFindByUUID(&driver->domains, dom->uuid);
|
|
|
|
|
|
|
|
if (vm == NULL) {
|
|
|
|
qemudReportError(dom->conn, domain, NULL, VIR_ERR_INTERNAL_ERROR,
|
|
|
|
_("No such domain %s"), dom->uuid);
|
|
|
|
goto cleanup;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (virCgroupForDomain(driver->cgroup, vm->def->name, &group, 0) != 0) {
|
|
|
|
qemudReportError(dom->conn, dom, NULL, VIR_ERR_INTERNAL_ERROR,
|
|
|
|
_("cannot find cgroup for domain %s"), vm->def->name);
|
|
|
|
goto cleanup;
|
|
|
|
}
|
|
|
|
|
|
|
|
rc = virCgroupGetCpuShares(group, &val);
|
|
|
|
if (rc != 0) {
|
|
|
|
virReportSystemError(dom->conn, -rc, "%s",
|
|
|
|
_("unable to get cpu shares tunable"));
|
|
|
|
goto cleanup;
|
|
|
|
}
|
|
|
|
params[0].value.ul = val;
|
|
|
|
params[0].type = VIR_DOMAIN_SCHED_FIELD_ULLONG;
|
2009-08-03 12:37:44 +00:00
|
|
|
if (virStrcpyStatic(params[0].field, "cpu_shares") == NULL) {
|
|
|
|
qemudReportError(dom->conn, dom, NULL, VIR_ERR_INTERNAL_ERROR,
|
|
|
|
"%s", _("Field cpu_shares too long for destination"));
|
|
|
|
goto cleanup;
|
|
|
|
}
|
2009-07-09 13:11:21 +00:00
|
|
|
|
|
|
|
ret = 0;
|
|
|
|
|
|
|
|
cleanup:
|
|
|
|
virCgroupFree(&group);
|
|
|
|
if (vm)
|
|
|
|
virDomainObjUnlock(vm);
|
2009-09-02 13:02:06 +00:00
|
|
|
qemuDriverUnlock(driver);
|
2009-07-09 13:11:21 +00:00
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
2008-02-26 18:41:43 +00:00
|
|
|
/* This uses the 'info blockstats' monitor command which was
|
|
|
|
* integrated into both qemu & kvm in late 2007. If the command is
|
|
|
|
* not supported we detect this and return the appropriate error.
|
|
|
|
*/
|
|
|
|
static int
|
|
|
|
qemudDomainBlockStats (virDomainPtr dom,
|
|
|
|
const char *path,
|
|
|
|
struct _virDomainBlockStats *stats)
|
|
|
|
{
|
2008-12-04 21:04:30 +00:00
|
|
|
struct qemud_driver *driver = dom->conn->privateData;
|
2008-10-17 09:29:29 +00:00
|
|
|
int i, ret = -1;
|
2008-12-04 21:04:30 +00:00
|
|
|
virDomainObjPtr vm;
|
2008-10-17 09:29:29 +00:00
|
|
|
virDomainDiskDefPtr disk = NULL;
|
2008-02-26 18:41:43 +00:00
|
|
|
|
2008-12-04 21:06:41 +00:00
|
|
|
qemuDriverLock(driver);
|
2009-04-19 15:30:50 +00:00
|
|
|
vm = virDomainFindByUUID(&driver->domains, dom->uuid);
|
2008-12-04 21:06:41 +00:00
|
|
|
qemuDriverUnlock(driver);
|
2008-02-26 18:41:43 +00:00
|
|
|
if (!vm) {
|
2009-04-19 15:30:50 +00:00
|
|
|
char uuidstr[VIR_UUID_STRING_BUFLEN];
|
|
|
|
virUUIDFormat(dom->uuid, uuidstr);
|
|
|
|
qemudReportError(dom->conn, dom, NULL, VIR_ERR_NO_DOMAIN,
|
|
|
|
_("no domain with matching uuid '%s'"), uuidstr);
|
2008-12-04 21:04:30 +00:00
|
|
|
goto cleanup;
|
2008-02-26 18:41:43 +00:00
|
|
|
}
|
2009-11-03 18:26:32 +00:00
|
|
|
|
|
|
|
if (qemuDomainObjBeginJob(vm) < 0)
|
|
|
|
goto cleanup;
|
|
|
|
|
Rename internal APis
Rename virDomainIsActive to virDomainObjIsActive, and
virInterfaceIsActive to virInterfaceObjIsActive and finally
virNetworkIsActive to virNetworkObjIsActive.
* src/conf/domain_conf.c, src/conf/domain_conf.h,
src/conf/interface_conf.h, src/conf/network_conf.c,
src/conf/network_conf.h, src/lxc/lxc_driver.c,
src/network/bridge_driver.c, src/opennebula/one_driver.c,
src/openvz/openvz_driver.c, src/qemu/qemu_driver.c,
src/test/test_driver.c, src/uml/uml_driver.c: Update for
renamed APIs.
2009-10-20 14:51:03 +00:00
|
|
|
if (!virDomainObjIsActive (vm)) {
|
2009-05-08 09:58:46 +00:00
|
|
|
qemudReportError (dom->conn, dom, NULL, VIR_ERR_OPERATION_INVALID,
|
2008-02-26 18:41:43 +00:00
|
|
|
"%s", _("domain is not running"));
|
2009-11-03 18:26:32 +00:00
|
|
|
goto endjob;
|
2008-02-26 18:41:43 +00:00
|
|
|
}
|
|
|
|
|
2008-10-17 09:29:29 +00:00
|
|
|
for (i = 0 ; i < vm->def->ndisks ; i++) {
|
|
|
|
if (STREQ(path, vm->def->disks[i]->dst)) {
|
|
|
|
disk = vm->def->disks[i];
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
if (!disk) {
|
2008-02-26 18:41:43 +00:00
|
|
|
qemudReportError (dom->conn, dom, NULL, VIR_ERR_INVALID_ARG,
|
|
|
|
_("invalid path: %s"), path);
|
2009-11-03 18:26:32 +00:00
|
|
|
goto endjob;
|
2008-02-26 18:41:43 +00:00
|
|
|
}
|
|
|
|
|
2010-01-06 12:11:26 +00:00
|
|
|
if (!disk->info.alias) {
|
|
|
|
qemudReportError(dom->conn, NULL, NULL, VIR_ERR_INTERNAL_ERROR,
|
|
|
|
_("missing disk device alias name for %s"), disk->dst);
|
2009-11-03 18:26:32 +00:00
|
|
|
goto endjob;
|
2010-01-06 12:11:26 +00:00
|
|
|
}
|
2008-02-26 18:41:43 +00:00
|
|
|
|
2009-10-09 20:13:06 +00:00
|
|
|
qemuDomainObjPrivatePtr priv = vm->privateData;
|
2009-10-13 14:27:58 +00:00
|
|
|
qemuDomainObjEnterMonitor(vm);
|
|
|
|
ret = qemuMonitorGetBlockStatsInfo(priv->mon,
|
2010-01-06 12:11:26 +00:00
|
|
|
disk->info.alias,
|
2009-10-13 14:27:58 +00:00
|
|
|
&stats->rd_req,
|
|
|
|
&stats->rd_bytes,
|
|
|
|
&stats->wr_req,
|
|
|
|
&stats->wr_bytes,
|
|
|
|
&stats->errs);
|
|
|
|
qemuDomainObjExitMonitor(vm);
|
2008-02-26 18:41:43 +00:00
|
|
|
|
2009-11-03 18:26:32 +00:00
|
|
|
endjob:
|
2009-12-08 14:42:43 +00:00
|
|
|
if (qemuDomainObjEndJob(vm) == 0)
|
|
|
|
vm = NULL;
|
2009-11-03 18:26:32 +00:00
|
|
|
|
2009-09-23 12:51:05 +00:00
|
|
|
cleanup:
|
2008-12-04 21:06:41 +00:00
|
|
|
if (vm)
|
|
|
|
virDomainObjUnlock(vm);
|
2008-10-17 09:29:29 +00:00
|
|
|
return ret;
|
2008-02-26 18:41:43 +00:00
|
|
|
}
|
|
|
|
|
2008-12-04 21:04:30 +00:00
|
|
|
#ifdef __linux__
|
2007-11-15 17:45:44 +00:00
|
|
|
static int
|
|
|
|
qemudDomainInterfaceStats (virDomainPtr dom,
|
|
|
|
const char *path,
|
|
|
|
struct _virDomainInterfaceStats *stats)
|
|
|
|
{
|
2008-12-04 21:04:30 +00:00
|
|
|
struct qemud_driver *driver = dom->conn->privateData;
|
|
|
|
virDomainObjPtr vm;
|
2008-10-10 16:08:01 +00:00
|
|
|
int i;
|
2008-12-04 21:04:30 +00:00
|
|
|
int ret = -1;
|
2007-11-15 17:45:44 +00:00
|
|
|
|
2008-12-04 21:06:41 +00:00
|
|
|
qemuDriverLock(driver);
|
2009-04-19 15:30:50 +00:00
|
|
|
vm = virDomainFindByUUID(&driver->domains, dom->uuid);
|
2008-12-04 21:06:41 +00:00
|
|
|
qemuDriverUnlock(driver);
|
|
|
|
|
2007-11-15 17:45:44 +00:00
|
|
|
if (!vm) {
|
2009-04-19 15:30:50 +00:00
|
|
|
char uuidstr[VIR_UUID_STRING_BUFLEN];
|
|
|
|
virUUIDFormat(dom->uuid, uuidstr);
|
|
|
|
qemudReportError(dom->conn, dom, NULL, VIR_ERR_NO_DOMAIN,
|
|
|
|
_("no domain with matching uuid '%s'"), uuidstr);
|
2008-12-04 21:04:30 +00:00
|
|
|
goto cleanup;
|
2007-11-15 17:45:44 +00:00
|
|
|
}
|
|
|
|
|
Rename internal APis
Rename virDomainIsActive to virDomainObjIsActive, and
virInterfaceIsActive to virInterfaceObjIsActive and finally
virNetworkIsActive to virNetworkObjIsActive.
* src/conf/domain_conf.c, src/conf/domain_conf.h,
src/conf/interface_conf.h, src/conf/network_conf.c,
src/conf/network_conf.h, src/lxc/lxc_driver.c,
src/network/bridge_driver.c, src/opennebula/one_driver.c,
src/openvz/openvz_driver.c, src/qemu/qemu_driver.c,
src/test/test_driver.c, src/uml/uml_driver.c: Update for
renamed APIs.
2009-10-20 14:51:03 +00:00
|
|
|
if (!virDomainObjIsActive(vm)) {
|
2009-05-08 09:58:46 +00:00
|
|
|
qemudReportError(dom->conn, dom, NULL, VIR_ERR_OPERATION_INVALID,
|
Mark many more strings for translation.
* Makefile.maint (err_func_re): Add to the list and make it readable.
* po/POTFILES.in: Add src/util.c and src/xm_internal.c, and sort.
* src/storage_backend.c: Fix comment.
* src/util.c (virFileLinkPointsTo): Mark a string.
* qemud/remote.c (remoteDispatchClientRequest): Mark strings.
(remoteDispatchOpen, CHECK_CONN, remoteDispatchGetType): Likewise.
(remoteDispatchDomainGetSchedulerType): Likewise.
(remoteDispatchDomainGetSchedulerParameters): Likewise.
(remoteDispatchDomainSetSchedulerParameters): Likewise.
(remoteDispatchDomainBlockStats): Likewise.
(remoteDispatchDomainInterfaceStats): Likewise.
(remoteDispatchDomainAttachDevice, remoteDispatchDomainCreate):
(remoteDispatchDomainDestroy, remoteDispatchDomainDetachDevice):
(remoteDispatchDomainDumpXml, remoteDispatchDomainGetAutostart):
(remoteDispatchDomainGetInfo, remoteDispatchDomainGetMaxMemory):
(remoteDispatchDomainGetMaxVcpus, remoteDispatchDomainGetOsType):
(remoteDispatchDomainGetVcpus): Likewise.
(remoteDispatchDomainMigratePerform): Likewise.
(remoteDispatchListDefinedDomains, remoteDispatchDomainPinVcpu):
(remoteDispatchDomainReboot, remoteDispatchDomainResume):
(remoteDispatchDomainSave, remoteDispatchDomainCoreDump):
(remoteDispatchDomainSetAutostart): Likewise.
(remoteDispatchDomainSetMaxMemory, remoteDispatchDomainSetMemory):
(remoteDispatchDomainSetVcpus, remoteDispatchDomainShutdown):
(remoteDispatchDomainSuspend, remoteDispatchDomainUndefine):
(remoteDispatchListDefinedNetworks, remoteDispatchListDomains):
(remoteDispatchListNetworks, remoteDispatchNetworkCreate):
(remoteDispatchNetworkDestroy, remoteDispatchNetworkDumpXml):
(remoteDispatchNetworkGetAutostart, remoteDispatchNetworkGetBridgeName):
(remoteDispatchNetworkSetAutostart, remoteDispatchNetworkUndefine):
(addrToString, remoteDispatchAuthSaslInit, remoteDispatchAuthSaslStart):
(remoteDispatchAuthSaslStep, remoteDispatchListDefinedStoragePools):
(remoteDispatchListStoragePools, remoteDispatchStoragePoolCreate):
(remoteDispatchStoragePoolBuild, remoteDispatchStoragePoolDestroy):
(remoteDispatchStoragePoolDelete, remoteDispatchStoragePoolRefresh):
(remoteDispatchStoragePoolGetInfo, remoteDispatchStoragePoolDumpXml):
(remoteDispatchStoragePoolGetAutostart): Likewise.
(remoteDispatchStoragePoolSetAutostart):
(remoteDispatchStoragePoolListVolumes):
(remoteDispatchStoragePoolNumOfVolumes):
(remoteDispatchStoragePoolUndefine, remoteDispatchStorageVolCreateXml):
(remoteDispatchStorageVolDelete, remoteDispatchStorageVolGetInfo):
(remoteDispatchStorageVolDumpXml, remoteDispatchStorageVolGetPath):
(remoteDispatchStorageVolLookupByName): Likewise.
* src/qemu_driver.c (qemudOpenMonitor, qemudStartVMDaemon):
(dhcpStartDhcpDaemon, qemudStartNetworkDaemon):
(qemudDomainSuspend, qemudDomainResume, qemudDomainShutdown):
(qemudDomainGetOSType, qemudDomainSetMaxMemory):
(qemudDomainSetMemory, qemudDomainGetInfo, qemudDomainSave):
(qemudDomainRestore, qemudDomainDumpXML, qemudDomainStart):
(qemudDomainUndefine, qemudDomainChangeCDROM):
(qemudDomainAttachDevice, qemudDomainGetAutostart):
(qemudDomainSetAutostart, qemudDomainInterfaceStats):
(qemudNetworkLookupByUUID, qemudNetworkLookupByName):
(qemudNetworkUndefine, qemudNetworkStart, qemudNetworkDestroy):
(qemudNetworkDumpXML, qemudNetworkGetAutostart):
(qemudNetworkSetAutostart): Likewise.
* src/virsh.c (cmdVcpupin, cmdAttachDevice, cmdDetachDevice): Likewise.
* src/xm_internal.c (xenXMConfigCacheRefresh, xenXMDomainPinVcpu): Likewise.
2008-03-27 13:43:01 +00:00
|
|
|
"%s", _("domain is not running"));
|
2008-12-04 21:04:30 +00:00
|
|
|
goto cleanup;
|
2007-11-15 17:45:44 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
/* Check the path is one of the domain's network interfaces. */
|
2008-10-10 16:08:01 +00:00
|
|
|
for (i = 0 ; i < vm->def->nnets ; i++) {
|
|
|
|
if (vm->def->nets[i]->ifname &&
|
2008-12-04 21:04:30 +00:00
|
|
|
STREQ (vm->def->nets[i]->ifname, path)) {
|
|
|
|
ret = 0;
|
|
|
|
break;
|
|
|
|
}
|
2007-11-15 17:45:44 +00:00
|
|
|
}
|
|
|
|
|
2008-12-04 21:04:30 +00:00
|
|
|
if (ret == 0)
|
|
|
|
ret = linuxDomainInterfaceStats (dom->conn, path, stats);
|
|
|
|
else
|
|
|
|
qemudReportError (dom->conn, dom, NULL, VIR_ERR_INVALID_ARG,
|
|
|
|
_("invalid path, '%s' is not a known interface"), path);
|
2007-11-15 17:45:44 +00:00
|
|
|
|
2008-12-04 21:04:30 +00:00
|
|
|
cleanup:
|
2008-12-04 21:06:41 +00:00
|
|
|
if (vm)
|
|
|
|
virDomainObjUnlock(vm);
|
2008-12-04 21:04:30 +00:00
|
|
|
return ret;
|
|
|
|
}
|
2007-11-15 17:45:44 +00:00
|
|
|
#else
|
2008-12-04 21:04:30 +00:00
|
|
|
static int
|
|
|
|
qemudDomainInterfaceStats (virDomainPtr dom,
|
|
|
|
const char *path ATTRIBUTE_UNUSED,
|
|
|
|
struct _virDomainInterfaceStats *stats ATTRIBUTE_UNUSED)
|
2007-11-15 17:45:44 +00:00
|
|
|
qemudReportError (dom->conn, dom, NULL, VIR_ERR_NO_SUPPORT,
|
|
|
|
"%s", __FUNCTION__);
|
|
|
|
return -1;
|
|
|
|
}
|
2008-12-04 21:04:30 +00:00
|
|
|
#endif
|
2007-11-15 17:45:44 +00:00
|
|
|
|
2009-12-20 12:36:28 +00:00
|
|
|
static int
|
|
|
|
qemudDomainMemoryStats (virDomainPtr dom,
|
|
|
|
struct _virDomainMemoryStat *stats,
|
|
|
|
unsigned int nr_stats)
|
|
|
|
{
|
|
|
|
struct qemud_driver *driver = dom->conn->privateData;
|
|
|
|
virDomainObjPtr vm;
|
|
|
|
unsigned int ret = -1;
|
|
|
|
|
|
|
|
qemuDriverLock(driver);
|
|
|
|
vm = virDomainFindByUUID(&driver->domains, dom->uuid);
|
|
|
|
qemuDriverUnlock(driver);
|
|
|
|
|
|
|
|
if (!vm) {
|
|
|
|
char uuidstr[VIR_UUID_STRING_BUFLEN];
|
|
|
|
virUUIDFormat(dom->uuid, uuidstr);
|
|
|
|
qemudReportError(dom->conn, dom, NULL, VIR_ERR_NO_DOMAIN,
|
|
|
|
_("no domain with matching uuid '%s'"), uuidstr);
|
|
|
|
goto cleanup;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (virDomainObjIsActive(vm)) {
|
|
|
|
qemuDomainObjPrivatePtr priv = vm->privateData;
|
|
|
|
qemuDomainObjEnterMonitor(vm);
|
|
|
|
ret = qemuMonitorTextGetMemoryStats(priv->mon, stats, nr_stats);
|
|
|
|
qemuDomainObjExitMonitor(vm);
|
|
|
|
} else {
|
|
|
|
qemudReportError(dom->conn, dom, NULL, VIR_ERR_OPERATION_INVALID,
|
|
|
|
"%s", _("domain is not running"));
|
|
|
|
}
|
|
|
|
|
|
|
|
cleanup:
|
|
|
|
if (vm)
|
|
|
|
virDomainObjUnlock(vm);
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
2008-06-05 21:12:26 +00:00
|
|
|
static int
|
|
|
|
qemudDomainBlockPeek (virDomainPtr dom,
|
|
|
|
const char *path,
|
|
|
|
unsigned long long offset, size_t size,
|
|
|
|
void *buffer,
|
|
|
|
unsigned int flags ATTRIBUTE_UNUSED)
|
|
|
|
{
|
2008-12-04 21:04:30 +00:00
|
|
|
struct qemud_driver *driver = dom->conn->privateData;
|
|
|
|
virDomainObjPtr vm;
|
|
|
|
int fd = -1, ret = -1, i;
|
2008-06-05 21:12:26 +00:00
|
|
|
|
2008-12-04 21:06:41 +00:00
|
|
|
qemuDriverLock(driver);
|
2008-12-04 21:04:30 +00:00
|
|
|
vm = virDomainFindByUUID(&driver->domains, dom->uuid);
|
2008-12-04 21:06:41 +00:00
|
|
|
qemuDriverUnlock(driver);
|
|
|
|
|
2008-06-05 21:12:26 +00:00
|
|
|
if (!vm) {
|
2009-04-19 15:30:50 +00:00
|
|
|
char uuidstr[VIR_UUID_STRING_BUFLEN];
|
|
|
|
virUUIDFormat(dom->uuid, uuidstr);
|
|
|
|
qemudReportError(dom->conn, dom, NULL, VIR_ERR_NO_DOMAIN,
|
|
|
|
_("no domain with matching uuid '%s'"), uuidstr);
|
2008-12-04 21:04:30 +00:00
|
|
|
goto cleanup;
|
2008-06-05 21:12:26 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
if (!path || path[0] == '\0') {
|
|
|
|
qemudReportError(dom->conn, dom, NULL, VIR_ERR_INVALID_ARG,
|
avoid many format string warnings
Building with --disable-nls exposed many new warnings like these:
virsh.c:4952: warning: format not a string literal and no format ...
util.c:163: warning: format not a string literal and no format arguments
All but one of the following changes add a "%s" argument before
the offending _(...) argument.
This was the only manual change:
* src/lxc_driver.c (lxcVersion): Use %s and strerror(errno)
rather than %m, to avoid a warning from gcc -Wformat-security.
Add "%s" before each warned about format-string-with-no-%-directive:
* src/domain_conf.c (virDomainHostdevSubsysUsbDefParseXML)
(virDomainDefParseString, virDomainDefParseFile):
* src/hash.c (virGetConnect, __virGetDomain, virReleaseDomain)
(__virGetNetwork, virReleaseNetwork, __virGetStoragePool)
(virReleaseStoragePool, __virGetStorageVol, virReleaseStorageVol):
* src/lxc_container.c (lxcContainerChild):
* src/lxc_driver.c (lxcDomainDefine, lxcDomainUndefine)
(lxcDomainGetInfo, lxcGetOSType, lxcDomainDumpXML)
(lxcSetupInterfaces, lxcDomainStart, lxcDomainCreateAndStart)
(lxcVersion, lxcGetSchedulerParameters):
* src/network_conf.c (virNetworkDefParseString)
(virNetworkDefParseFile):
* src/openvz_conf.c (openvzReadNetworkConf, openvzLoadDomains):
* src/openvz_driver.c (openvzDomainDefineCmd)
(openvzDomainGetInfo, openvzDomainDumpXML, openvzDomainShutdown)
(openvzDomainReboot, ADD_ARG_LIT, openvzDomainDefineXML)
(openvzDomainCreateXML, openvzDomainCreate, openvzDomainUndefine)
(openvzDomainSetAutostart, openvzDomainGetAutostart)
(openvzDomainSetVcpus):
* src/qemu_driver.c (qemudDomainBlockPeek, qemudDomainMemoryPeek):
* src/remote_internal.c (remoteDomainBlockPeek)
(remoteDomainMemoryPeek, remoteAuthPolkit):
* src/sexpr.c (sexpr_new, _string2sexpr):
* src/storage_backend_disk.c (virStorageBackendDiskMakeDataVol)
(virStorageBackendDiskCreateVol):
* src/storage_backend_fs.c
(virStorageBackendFileSystemNetFindPoolSources):
* src/storage_backend_logical.c (virStorageBackendLogicalFindLVs)
(virStorageBackendLogicalFindPoolSources):
* src/test.c (testOpenDefault, testOpenFromFile, testOpen)
(testGetDomainInfo, testDomainRestore)
(testNodeGetCellsFreeMemory):
* src/util.c (virExec):
* src/virsh.c (cmdAttachDevice, cmdDetachDevice)
(cmdAttachInterface, cmdDetachInterface, cmdAttachDisk)
(cmdDetachDisk, cmdEdit):
* src/xend_internal.c (do_connect, wr_sync, xend_op_ext)
(urlencode, xenDaemonDomainCreateXML)
(xenDaemonDomainLookupByName_ids, xenDaemonDomainLookupByID)
(xenDaemonParseSxprOS, xend_parse_sexp_desc_char)
(xenDaemonParseSxprChar, xenDaemonParseSxprDisks)
(xenDaemonParseSxpr, sexpr_to_xend_topology, sexpr_to_domain)
(xenDaemonDomainFetch, xenDaemonDomainGetAutostart)
(xenDaemonDomainSetAutostart, xenDaemonDomainMigratePerform)
(xenDaemonDomainDefineXML, xenDaemonGetSchedulerType)
(xenDaemonGetSchedulerParameters)
(xenDaemonSetSchedulerParameters, xenDaemonDomainBlockPeek)
(xenDaemonFormatSxprChr, virDomainXMLDevID):
* src/xm_internal.c (xenXMConfigCacheRefresh, xenXMDomainPinVcpu)
(xenXMDomainCreate, xenXMDomainDefineXML)
(xenXMDomainAttachDevice, xenXMDomainDetachDevice):
* src/xml.c (virXPathString, virXPathNumber, virXPathLong)
(virXPathULong, virXPathBoolean, virXPathNode, virXPathNodeSet):
* src/xs_internal.c (xenStoreOpen):
2008-10-13 16:46:28 +00:00
|
|
|
"%s", _("NULL or empty path"));
|
2008-12-04 21:04:30 +00:00
|
|
|
goto cleanup;
|
2008-06-05 21:12:26 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
/* Check the path belongs to this domain. */
|
2008-10-10 16:08:01 +00:00
|
|
|
for (i = 0 ; i < vm->def->ndisks ; i++) {
|
|
|
|
if (vm->def->disks[i]->src != NULL &&
|
2008-12-04 21:04:30 +00:00
|
|
|
STREQ (vm->def->disks[i]->src, path)) {
|
|
|
|
ret = 0;
|
|
|
|
break;
|
|
|
|
}
|
2008-06-05 21:12:26 +00:00
|
|
|
}
|
|
|
|
|
2008-12-04 21:04:30 +00:00
|
|
|
if (ret == 0) {
|
|
|
|
ret = -1;
|
|
|
|
/* The path is correct, now try to open it and get its size. */
|
|
|
|
fd = open (path, O_RDONLY);
|
|
|
|
if (fd == -1) {
|
2009-02-05 16:11:25 +00:00
|
|
|
virReportSystemError (dom->conn, errno,
|
|
|
|
_("%s: failed to open"), path);
|
2008-12-04 21:04:30 +00:00
|
|
|
goto cleanup;
|
|
|
|
}
|
2008-06-05 21:12:26 +00:00
|
|
|
|
2008-12-04 21:04:30 +00:00
|
|
|
/* Seek and read. */
|
|
|
|
/* NB. Because we configure with AC_SYS_LARGEFILE, off_t should
|
|
|
|
* be 64 bits on all platforms.
|
|
|
|
*/
|
|
|
|
if (lseek (fd, offset, SEEK_SET) == (off_t) -1 ||
|
|
|
|
saferead (fd, buffer, size) == (ssize_t) -1) {
|
2009-02-05 16:11:25 +00:00
|
|
|
virReportSystemError (dom->conn, errno,
|
|
|
|
_("%s: failed to seek or read"), path);
|
2008-12-04 21:04:30 +00:00
|
|
|
goto cleanup;
|
|
|
|
}
|
|
|
|
|
|
|
|
ret = 0;
|
|
|
|
} else {
|
|
|
|
qemudReportError (dom->conn, dom, NULL, VIR_ERR_INVALID_ARG,
|
|
|
|
"%s", _("invalid path"));
|
2008-06-05 21:12:26 +00:00
|
|
|
}
|
|
|
|
|
2008-12-04 21:04:30 +00:00
|
|
|
cleanup:
|
|
|
|
if (fd >= 0)
|
|
|
|
close (fd);
|
2008-12-04 21:06:41 +00:00
|
|
|
if (vm)
|
|
|
|
virDomainObjUnlock(vm);
|
2008-06-05 21:12:26 +00:00
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
2008-06-10 10:43:28 +00:00
|
|
|
static int
|
|
|
|
qemudDomainMemoryPeek (virDomainPtr dom,
|
|
|
|
unsigned long long offset, size_t size,
|
|
|
|
void *buffer,
|
|
|
|
unsigned int flags)
|
|
|
|
{
|
2008-12-04 21:04:30 +00:00
|
|
|
struct qemud_driver *driver = dom->conn->privateData;
|
|
|
|
virDomainObjPtr vm;
|
2009-08-25 15:49:09 +00:00
|
|
|
char *tmp = NULL;
|
2008-06-10 10:43:28 +00:00
|
|
|
int fd = -1, ret = -1;
|
|
|
|
|
2008-12-04 21:06:41 +00:00
|
|
|
qemuDriverLock(driver);
|
2009-04-19 15:30:50 +00:00
|
|
|
vm = virDomainFindByUUID(&driver->domains, dom->uuid);
|
2008-12-04 21:06:41 +00:00
|
|
|
qemuDriverUnlock(driver);
|
2008-06-10 10:43:28 +00:00
|
|
|
|
|
|
|
if (!vm) {
|
2009-04-19 15:30:50 +00:00
|
|
|
char uuidstr[VIR_UUID_STRING_BUFLEN];
|
|
|
|
virUUIDFormat(dom->uuid, uuidstr);
|
|
|
|
qemudReportError(dom->conn, dom, NULL, VIR_ERR_NO_DOMAIN,
|
|
|
|
_("no domain with matching uuid '%s'"), uuidstr);
|
2008-12-04 21:04:30 +00:00
|
|
|
goto cleanup;
|
|
|
|
}
|
|
|
|
|
2009-07-22 14:27:09 +00:00
|
|
|
if (flags != VIR_MEMORY_VIRTUAL && flags != VIR_MEMORY_PHYSICAL) {
|
2008-12-04 21:04:30 +00:00
|
|
|
qemudReportError (dom->conn, dom, NULL, VIR_ERR_INVALID_ARG,
|
2009-07-22 14:27:09 +00:00
|
|
|
"%s", _("flags parameter must be VIR_MEMORY_VIRTUAL or VIR_MEMORY_PHYSICAL"));
|
2008-12-04 21:04:30 +00:00
|
|
|
goto cleanup;
|
2008-06-10 10:43:28 +00:00
|
|
|
}
|
|
|
|
|
2009-11-03 18:26:32 +00:00
|
|
|
if (qemuDomainObjBeginJob(vm) < 0)
|
|
|
|
goto cleanup;
|
|
|
|
|
Rename internal APis
Rename virDomainIsActive to virDomainObjIsActive, and
virInterfaceIsActive to virInterfaceObjIsActive and finally
virNetworkIsActive to virNetworkObjIsActive.
* src/conf/domain_conf.c, src/conf/domain_conf.h,
src/conf/interface_conf.h, src/conf/network_conf.c,
src/conf/network_conf.h, src/lxc/lxc_driver.c,
src/network/bridge_driver.c, src/opennebula/one_driver.c,
src/openvz/openvz_driver.c, src/qemu/qemu_driver.c,
src/test/test_driver.c, src/uml/uml_driver.c: Update for
renamed APIs.
2009-10-20 14:51:03 +00:00
|
|
|
if (!virDomainObjIsActive(vm)) {
|
2009-05-08 09:58:46 +00:00
|
|
|
qemudReportError(dom->conn, dom, NULL, VIR_ERR_OPERATION_INVALID,
|
2008-06-10 10:43:28 +00:00
|
|
|
"%s", _("domain is not running"));
|
2009-11-03 18:26:32 +00:00
|
|
|
goto endjob;
|
2008-06-10 10:43:28 +00:00
|
|
|
}
|
|
|
|
|
2009-08-25 15:49:09 +00:00
|
|
|
if (virAsprintf(&tmp, driver->cacheDir, "/qemu.mem.XXXXXX") < 0) {
|
|
|
|
virReportOOMError(dom->conn);
|
2009-11-03 18:26:32 +00:00
|
|
|
goto endjob;
|
2009-08-25 15:49:09 +00:00
|
|
|
}
|
|
|
|
|
2008-06-10 10:43:28 +00:00
|
|
|
/* Create a temporary filename. */
|
|
|
|
if ((fd = mkstemp (tmp)) == -1) {
|
2009-02-05 16:11:25 +00:00
|
|
|
virReportSystemError (dom->conn, errno,
|
|
|
|
_("mkstemp(\"%s\") failed"), tmp);
|
2009-11-03 18:26:32 +00:00
|
|
|
goto endjob;
|
2008-06-10 10:43:28 +00:00
|
|
|
}
|
|
|
|
|
2009-10-09 20:13:06 +00:00
|
|
|
qemuDomainObjPrivatePtr priv = vm->privateData;
|
2009-10-13 14:27:58 +00:00
|
|
|
qemuDomainObjEnterMonitor(vm);
|
2009-09-23 12:33:45 +00:00
|
|
|
if (flags == VIR_MEMORY_VIRTUAL) {
|
2009-10-13 14:27:58 +00:00
|
|
|
if (qemuMonitorSaveVirtualMemory(priv->mon, offset, size, tmp) < 0) {
|
|
|
|
qemuDomainObjExitMonitor(vm);
|
2009-11-03 18:26:32 +00:00
|
|
|
goto endjob;
|
2009-10-13 14:27:58 +00:00
|
|
|
}
|
2009-09-23 12:33:45 +00:00
|
|
|
} else {
|
2009-10-13 14:27:58 +00:00
|
|
|
if (qemuMonitorSavePhysicalMemory(priv->mon, offset, size, tmp) < 0) {
|
|
|
|
qemuDomainObjExitMonitor(vm);
|
2009-11-03 18:26:32 +00:00
|
|
|
goto endjob;
|
2009-10-13 14:27:58 +00:00
|
|
|
}
|
2008-06-10 10:43:28 +00:00
|
|
|
}
|
2009-10-13 14:27:58 +00:00
|
|
|
qemuDomainObjExitMonitor(vm);
|
2008-06-10 10:43:28 +00:00
|
|
|
|
|
|
|
/* Read the memory file into buffer. */
|
|
|
|
if (saferead (fd, buffer, size) == (ssize_t) -1) {
|
2009-02-05 16:11:25 +00:00
|
|
|
virReportSystemError (dom->conn, errno,
|
|
|
|
_("failed to read temporary file "
|
|
|
|
"created with template %s"), tmp);
|
2009-11-03 18:26:32 +00:00
|
|
|
goto endjob;
|
2008-06-10 10:43:28 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
ret = 0;
|
2008-12-04 21:04:30 +00:00
|
|
|
|
2009-11-03 18:26:32 +00:00
|
|
|
endjob:
|
2009-12-08 14:42:43 +00:00
|
|
|
if (qemuDomainObjEndJob(vm) == 0)
|
|
|
|
vm = NULL;
|
2009-11-03 18:26:32 +00:00
|
|
|
|
2008-12-04 21:04:30 +00:00
|
|
|
cleanup:
|
2009-08-25 15:49:09 +00:00
|
|
|
VIR_FREE(tmp);
|
2008-06-10 10:43:28 +00:00
|
|
|
if (fd >= 0) close (fd);
|
|
|
|
unlink (tmp);
|
2008-12-04 21:06:41 +00:00
|
|
|
if (vm)
|
|
|
|
virDomainObjUnlock(vm);
|
2008-06-10 10:43:28 +00:00
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
2007-02-23 09:03:25 +00:00
|
|
|
|
2008-10-23 13:18:18 +00:00
|
|
|
static int
|
|
|
|
qemudDomainEventRegister (virConnectPtr conn,
|
2008-12-17 21:48:20 +00:00
|
|
|
virConnectDomainEventCallback callback,
|
2008-11-19 15:25:24 +00:00
|
|
|
void *opaque,
|
|
|
|
virFreeCallback freecb)
|
2008-10-23 13:18:18 +00:00
|
|
|
{
|
2008-12-04 21:04:30 +00:00
|
|
|
struct qemud_driver *driver = conn->privateData;
|
|
|
|
int ret;
|
|
|
|
|
2008-12-04 21:06:41 +00:00
|
|
|
qemuDriverLock(driver);
|
2008-12-04 21:04:30 +00:00
|
|
|
ret = virDomainEventCallbackListAdd(conn, driver->domainEventCallbacks,
|
|
|
|
callback, opaque, freecb);
|
2008-12-04 21:06:41 +00:00
|
|
|
qemuDriverUnlock(driver);
|
2008-10-23 13:18:18 +00:00
|
|
|
|
2008-12-04 21:04:30 +00:00
|
|
|
return ret;
|
2008-10-23 13:18:18 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
static int
|
|
|
|
qemudDomainEventDeregister (virConnectPtr conn,
|
2008-12-17 21:48:20 +00:00
|
|
|
virConnectDomainEventCallback callback)
|
2008-10-23 13:18:18 +00:00
|
|
|
{
|
2008-12-04 21:04:30 +00:00
|
|
|
struct qemud_driver *driver = conn->privateData;
|
|
|
|
int ret;
|
|
|
|
|
2008-12-04 21:06:41 +00:00
|
|
|
qemuDriverLock(driver);
|
2008-12-04 21:09:20 +00:00
|
|
|
if (driver->domainEventDispatching)
|
|
|
|
ret = virDomainEventCallbackListMarkDelete(conn, driver->domainEventCallbacks,
|
|
|
|
callback);
|
|
|
|
else
|
|
|
|
ret = virDomainEventCallbackListRemove(conn, driver->domainEventCallbacks,
|
|
|
|
callback);
|
2008-12-04 21:06:41 +00:00
|
|
|
qemuDriverUnlock(driver);
|
2008-10-23 13:18:18 +00:00
|
|
|
|
2008-12-04 21:04:30 +00:00
|
|
|
return ret;
|
2008-10-23 13:18:18 +00:00
|
|
|
}
|
|
|
|
|
2008-12-04 21:09:20 +00:00
|
|
|
static void qemuDomainEventDispatchFunc(virConnectPtr conn,
|
|
|
|
virDomainEventPtr event,
|
|
|
|
virConnectDomainEventCallback cb,
|
|
|
|
void *cbopaque,
|
|
|
|
void *opaque)
|
2008-10-23 13:18:18 +00:00
|
|
|
{
|
2008-12-04 21:09:20 +00:00
|
|
|
struct qemud_driver *driver = opaque;
|
2008-10-23 13:18:18 +00:00
|
|
|
|
2008-12-04 21:09:20 +00:00
|
|
|
/* Drop the lock whle dispatching, for sake of re-entrancy */
|
|
|
|
qemuDriverUnlock(driver);
|
|
|
|
virDomainEventDispatchDefaultFunc(conn, event, cb, cbopaque, NULL);
|
|
|
|
qemuDriverLock(driver);
|
|
|
|
}
|
|
|
|
|
|
|
|
static void qemuDomainEventFlush(int timer ATTRIBUTE_UNUSED, void *opaque)
|
|
|
|
{
|
|
|
|
struct qemud_driver *driver = opaque;
|
|
|
|
virDomainEventQueue tempQueue;
|
|
|
|
|
|
|
|
qemuDriverLock(driver);
|
|
|
|
|
|
|
|
driver->domainEventDispatching = 1;
|
|
|
|
|
|
|
|
/* Copy the queue, so we're reentrant safe */
|
|
|
|
tempQueue.count = driver->domainEventQueue->count;
|
|
|
|
tempQueue.events = driver->domainEventQueue->events;
|
|
|
|
driver->domainEventQueue->count = 0;
|
|
|
|
driver->domainEventQueue->events = NULL;
|
|
|
|
|
|
|
|
virEventUpdateTimeout(driver->domainEventTimer, -1);
|
|
|
|
virDomainEventQueueDispatch(&tempQueue,
|
|
|
|
driver->domainEventCallbacks,
|
|
|
|
qemuDomainEventDispatchFunc,
|
|
|
|
driver);
|
|
|
|
|
|
|
|
/* Purge any deleted callbacks */
|
|
|
|
virDomainEventCallbackListPurgeMarked(driver->domainEventCallbacks);
|
|
|
|
|
|
|
|
driver->domainEventDispatching = 0;
|
|
|
|
qemuDriverUnlock(driver);
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
/* driver must be locked before calling */
|
|
|
|
static void qemuDomainEventQueue(struct qemud_driver *driver,
|
|
|
|
virDomainEventPtr event)
|
|
|
|
{
|
|
|
|
if (virDomainEventQueuePush(driver->domainEventQueue,
|
|
|
|
event) < 0)
|
|
|
|
virDomainEventFree(event);
|
|
|
|
if (qemu_driver->domainEventQueue->count == 1)
|
|
|
|
virEventUpdateTimeout(driver->domainEventTimer, 0);
|
2008-10-23 13:18:18 +00:00
|
|
|
}
|
|
|
|
|
2008-11-14 08:42:47 +00:00
|
|
|
/* Migration support. */
|
|
|
|
|
2009-09-30 10:51:54 +00:00
|
|
|
/* Tunnelled migration stream support */
|
|
|
|
struct qemuStreamMigFile {
|
|
|
|
int fd;
|
|
|
|
|
|
|
|
int watch;
|
|
|
|
unsigned int cbRemoved;
|
|
|
|
unsigned int dispatching;
|
|
|
|
virStreamEventCallback cb;
|
|
|
|
void *opaque;
|
|
|
|
virFreeCallback ff;
|
|
|
|
};
|
|
|
|
|
|
|
|
static int qemuStreamMigRemoveCallback(virStreamPtr stream)
|
|
|
|
{
|
|
|
|
struct qemud_driver *driver = stream->conn->privateData;
|
|
|
|
struct qemuStreamMigFile *qemust = stream->privateData;
|
|
|
|
int ret = -1;
|
|
|
|
|
|
|
|
if (!qemust) {
|
|
|
|
qemudReportError(stream->conn, NULL, NULL, VIR_ERR_INTERNAL_ERROR,
|
|
|
|
"%s", _("stream is not open"));
|
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
|
|
|
|
qemuDriverLock(driver);
|
|
|
|
if (qemust->watch == 0) {
|
|
|
|
qemudReportError(stream->conn, NULL, NULL, VIR_ERR_INTERNAL_ERROR,
|
|
|
|
"%s", _("stream does not have a callback registered"));
|
|
|
|
goto cleanup;
|
|
|
|
}
|
|
|
|
|
|
|
|
virEventRemoveHandle(qemust->watch);
|
|
|
|
if (qemust->dispatching)
|
|
|
|
qemust->cbRemoved = 1;
|
|
|
|
else if (qemust->ff)
|
|
|
|
(qemust->ff)(qemust->opaque);
|
|
|
|
|
|
|
|
qemust->watch = 0;
|
|
|
|
qemust->ff = NULL;
|
|
|
|
qemust->cb = NULL;
|
|
|
|
qemust->opaque = NULL;
|
|
|
|
|
|
|
|
ret = 0;
|
|
|
|
|
|
|
|
cleanup:
|
|
|
|
qemuDriverUnlock(driver);
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
|
|
|
static int qemuStreamMigUpdateCallback(virStreamPtr stream, int events)
|
|
|
|
{
|
|
|
|
struct qemud_driver *driver = stream->conn->privateData;
|
|
|
|
struct qemuStreamMigFile *qemust = stream->privateData;
|
|
|
|
int ret = -1;
|
|
|
|
|
|
|
|
if (!qemust) {
|
|
|
|
qemudReportError(stream->conn, NULL, NULL, VIR_ERR_INTERNAL_ERROR,
|
|
|
|
"%s", _("stream is not open"));
|
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
|
|
|
|
qemuDriverLock(driver);
|
|
|
|
if (qemust->watch == 0) {
|
|
|
|
qemudReportError(stream->conn, NULL, NULL, VIR_ERR_INTERNAL_ERROR,
|
|
|
|
"%s", _("stream does not have a callback registered"));
|
|
|
|
goto cleanup;
|
|
|
|
}
|
|
|
|
|
|
|
|
virEventUpdateHandle(qemust->watch, events);
|
|
|
|
|
|
|
|
ret = 0;
|
|
|
|
|
|
|
|
cleanup:
|
|
|
|
qemuDriverUnlock(driver);
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
|
|
|
static void qemuStreamMigEvent(int watch ATTRIBUTE_UNUSED,
|
|
|
|
int fd ATTRIBUTE_UNUSED,
|
|
|
|
int events,
|
|
|
|
void *opaque)
|
|
|
|
{
|
|
|
|
virStreamPtr stream = opaque;
|
|
|
|
struct qemud_driver *driver = stream->conn->privateData;
|
|
|
|
struct qemuStreamMigFile *qemust = stream->privateData;
|
|
|
|
virStreamEventCallback cb;
|
|
|
|
void *cbopaque;
|
|
|
|
virFreeCallback ff;
|
|
|
|
|
|
|
|
qemuDriverLock(driver);
|
|
|
|
if (!qemust || !qemust->cb) {
|
|
|
|
qemuDriverUnlock(driver);
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
cb = qemust->cb;
|
|
|
|
cbopaque = qemust->opaque;
|
|
|
|
ff = qemust->ff;
|
|
|
|
qemust->dispatching = 1;
|
|
|
|
qemuDriverUnlock(driver);
|
|
|
|
|
|
|
|
cb(stream, events, cbopaque);
|
|
|
|
|
|
|
|
qemuDriverLock(driver);
|
|
|
|
qemust->dispatching = 0;
|
|
|
|
if (qemust->cbRemoved && ff)
|
|
|
|
(ff)(cbopaque);
|
|
|
|
qemuDriverUnlock(driver);
|
|
|
|
}
|
|
|
|
|
|
|
|
static int
|
|
|
|
qemuStreamMigAddCallback(virStreamPtr st,
|
|
|
|
int events,
|
|
|
|
virStreamEventCallback cb,
|
|
|
|
void *opaque,
|
|
|
|
virFreeCallback ff)
|
|
|
|
{
|
|
|
|
struct qemud_driver *driver = st->conn->privateData;
|
|
|
|
struct qemuStreamMigFile *qemust = st->privateData;
|
|
|
|
int ret = -1;
|
|
|
|
|
|
|
|
if (!qemust) {
|
|
|
|
qemudReportError(st->conn, NULL, NULL, VIR_ERR_INTERNAL_ERROR,
|
|
|
|
"%s", _("stream is not open"));
|
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
|
|
|
|
qemuDriverLock(driver);
|
|
|
|
if (qemust->watch != 0) {
|
|
|
|
qemudReportError(st->conn, NULL, NULL, VIR_ERR_INTERNAL_ERROR,
|
|
|
|
"%s", _("stream already has a callback registered"));
|
|
|
|
goto cleanup;
|
|
|
|
}
|
|
|
|
|
|
|
|
if ((qemust->watch = virEventAddHandle(qemust->fd,
|
|
|
|
events,
|
|
|
|
qemuStreamMigEvent,
|
|
|
|
st,
|
|
|
|
NULL)) < 0) {
|
|
|
|
qemudReportError(st->conn, NULL, NULL, VIR_ERR_INTERNAL_ERROR,
|
|
|
|
"%s", _("cannot register file watch on stream"));
|
|
|
|
goto cleanup;
|
|
|
|
}
|
|
|
|
|
|
|
|
qemust->cbRemoved = 0;
|
|
|
|
qemust->cb = cb;
|
|
|
|
qemust->opaque = opaque;
|
|
|
|
qemust->ff = ff;
|
|
|
|
virStreamRef(st);
|
|
|
|
|
|
|
|
ret = 0;
|
|
|
|
|
|
|
|
cleanup:
|
|
|
|
qemuDriverUnlock(driver);
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
|
|
|
static void qemuStreamMigFree(struct qemuStreamMigFile *qemust)
|
|
|
|
{
|
|
|
|
if (qemust->fd != -1)
|
|
|
|
close(qemust->fd);
|
|
|
|
VIR_FREE(qemust);
|
|
|
|
}
|
|
|
|
|
|
|
|
static struct qemuStreamMigFile *qemuStreamMigOpen(virStreamPtr st,
|
|
|
|
const char *unixfile)
|
|
|
|
{
|
|
|
|
struct qemuStreamMigFile *qemust = NULL;
|
|
|
|
struct sockaddr_un sa_qemu;
|
|
|
|
int i = 0;
|
|
|
|
int timeout = 3;
|
|
|
|
int ret;
|
|
|
|
|
2009-11-08 21:08:54 +00:00
|
|
|
if (VIR_ALLOC(qemust) < 0) {
|
|
|
|
virReportOOMError(st->conn);
|
2009-09-30 10:51:54 +00:00
|
|
|
return NULL;
|
2009-11-08 21:08:54 +00:00
|
|
|
}
|
2009-09-30 10:51:54 +00:00
|
|
|
|
|
|
|
qemust->fd = socket(AF_UNIX, SOCK_STREAM, 0);
|
|
|
|
if (qemust->fd < 0)
|
|
|
|
goto cleanup;
|
|
|
|
|
|
|
|
memset(&sa_qemu, 0, sizeof(sa_qemu));
|
|
|
|
sa_qemu.sun_family = AF_UNIX;
|
|
|
|
if (virStrcpy(sa_qemu.sun_path, unixfile, sizeof(sa_qemu.sun_path)) == NULL)
|
|
|
|
goto cleanup;
|
|
|
|
|
|
|
|
do {
|
|
|
|
ret = connect(qemust->fd, (struct sockaddr *)&sa_qemu, sizeof(sa_qemu));
|
|
|
|
if (ret == 0)
|
|
|
|
break;
|
|
|
|
|
|
|
|
if (errno == ENOENT || errno == ECONNREFUSED) {
|
|
|
|
/* ENOENT : Socket may not have shown up yet
|
|
|
|
* ECONNREFUSED : Leftover socket hasn't been removed yet */
|
|
|
|
continue;
|
|
|
|
}
|
|
|
|
|
|
|
|
goto cleanup;
|
|
|
|
} while ((++i <= timeout*5) && (usleep(.2 * 1000000) <= 0));
|
|
|
|
|
|
|
|
if ((st->flags & VIR_STREAM_NONBLOCK) && virSetNonBlock(qemust->fd) < 0)
|
|
|
|
goto cleanup;
|
|
|
|
|
|
|
|
return qemust;
|
|
|
|
|
|
|
|
cleanup:
|
|
|
|
qemuStreamMigFree(qemust);
|
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
|
|
|
|
static int
|
|
|
|
qemuStreamMigClose(virStreamPtr st)
|
|
|
|
{
|
|
|
|
struct qemud_driver *driver = st->conn->privateData;
|
|
|
|
struct qemuStreamMigFile *qemust = st->privateData;
|
|
|
|
|
|
|
|
if (!qemust)
|
|
|
|
return 0;
|
|
|
|
|
|
|
|
qemuDriverLock(driver);
|
|
|
|
|
|
|
|
qemuStreamMigFree(qemust);
|
|
|
|
|
|
|
|
st->privateData = NULL;
|
|
|
|
|
|
|
|
qemuDriverUnlock(driver);
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
static int qemuStreamMigWrite(virStreamPtr st, const char *bytes, size_t nbytes)
|
|
|
|
{
|
|
|
|
struct qemud_driver *driver = st->conn->privateData;
|
|
|
|
struct qemuStreamMigFile *qemust = st->privateData;
|
|
|
|
int ret;
|
|
|
|
|
|
|
|
if (!qemust) {
|
|
|
|
qemudReportError(st->conn, NULL, NULL, VIR_ERR_INTERNAL_ERROR,
|
|
|
|
"%s", _("stream is not open"));
|
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
|
|
|
|
qemuDriverLock(driver);
|
|
|
|
|
|
|
|
retry:
|
|
|
|
ret = write(qemust->fd, bytes, nbytes);
|
|
|
|
if (ret < 0) {
|
|
|
|
if (errno == EAGAIN || errno == EWOULDBLOCK) {
|
|
|
|
ret = -2;
|
|
|
|
} else if (errno == EINTR) {
|
|
|
|
goto retry;
|
|
|
|
} else {
|
|
|
|
ret = -1;
|
|
|
|
virReportSystemError(st->conn, errno, "%s",
|
|
|
|
_("cannot write to stream"));
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
qemuDriverUnlock(driver);
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
|
|
|
static virStreamDriver qemuStreamMigDrv = {
|
|
|
|
.streamSend = qemuStreamMigWrite,
|
|
|
|
.streamFinish = qemuStreamMigClose,
|
|
|
|
.streamAbort = qemuStreamMigClose,
|
|
|
|
.streamAddCallback = qemuStreamMigAddCallback,
|
|
|
|
.streamUpdateCallback = qemuStreamMigUpdateCallback,
|
|
|
|
.streamRemoveCallback = qemuStreamMigRemoveCallback
|
|
|
|
};
|
|
|
|
|
|
|
|
/* Prepare is the first step, and it runs on the destination host.
|
|
|
|
*
|
|
|
|
* This version starts an empty VM listening on a localhost TCP port, and
|
|
|
|
* sets up the corresponding virStream to handle the incoming data.
|
|
|
|
*/
|
|
|
|
static int
|
|
|
|
qemudDomainMigratePrepareTunnel(virConnectPtr dconn,
|
|
|
|
virStreamPtr st,
|
|
|
|
unsigned long flags,
|
|
|
|
const char *dname,
|
|
|
|
unsigned long resource ATTRIBUTE_UNUSED,
|
|
|
|
const char *dom_xml)
|
|
|
|
{
|
|
|
|
struct qemud_driver *driver = dconn->privateData;
|
|
|
|
virDomainDefPtr def = NULL;
|
|
|
|
virDomainObjPtr vm = NULL;
|
|
|
|
char *migrateFrom;
|
|
|
|
virDomainEventPtr event = NULL;
|
|
|
|
int ret = -1;
|
|
|
|
int internalret;
|
|
|
|
char *unixfile = NULL;
|
|
|
|
unsigned int qemuCmdFlags;
|
|
|
|
struct qemuStreamMigFile *qemust = NULL;
|
|
|
|
|
|
|
|
qemuDriverLock(driver);
|
|
|
|
if (!dom_xml) {
|
|
|
|
qemudReportError(dconn, NULL, NULL, VIR_ERR_INTERNAL_ERROR,
|
|
|
|
"%s", _("no domain XML passed"));
|
|
|
|
goto cleanup;
|
|
|
|
}
|
|
|
|
if (!(flags & VIR_MIGRATE_TUNNELLED)) {
|
|
|
|
qemudReportError(dconn, NULL, NULL, VIR_ERR_INTERNAL_ERROR,
|
|
|
|
"%s", _("PrepareTunnel called but no TUNNELLED flag set"));
|
|
|
|
goto cleanup;
|
|
|
|
}
|
|
|
|
if (st == NULL) {
|
|
|
|
qemudReportError(dconn, NULL, NULL, VIR_ERR_INTERNAL_ERROR,
|
|
|
|
"%s", _("tunnelled migration requested but NULL stream passed"));
|
|
|
|
goto cleanup;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Parse the domain XML. */
|
|
|
|
if (!(def = virDomainDefParseString(dconn, driver->caps, dom_xml,
|
|
|
|
VIR_DOMAIN_XML_INACTIVE))) {
|
|
|
|
qemudReportError(dconn, NULL, NULL, VIR_ERR_OPERATION_FAILED,
|
|
|
|
"%s", _("failed to parse XML"));
|
|
|
|
goto cleanup;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Target domain name, maybe renamed. */
|
|
|
|
dname = dname ? dname : def->name;
|
|
|
|
|
2009-11-02 19:10:36 +00:00
|
|
|
if (virDomainObjIsDuplicate(&driver->domains, def, 1) < 0)
|
|
|
|
goto cleanup;
|
2009-09-30 10:51:54 +00:00
|
|
|
|
|
|
|
if (!(vm = virDomainAssignDef(dconn,
|
2009-10-06 11:50:58 +00:00
|
|
|
driver->caps,
|
2009-09-30 10:51:54 +00:00
|
|
|
&driver->domains,
|
|
|
|
def))) {
|
|
|
|
qemudReportError(dconn, NULL, NULL, VIR_ERR_OPERATION_FAILED,
|
|
|
|
"%s", _("failed to assign new VM"));
|
|
|
|
goto cleanup;
|
|
|
|
}
|
|
|
|
def = NULL;
|
|
|
|
|
2009-11-03 18:26:32 +00:00
|
|
|
if (qemuDomainObjBeginJobWithDriver(driver, vm) < 0)
|
|
|
|
goto cleanup;
|
|
|
|
|
2009-09-30 10:51:54 +00:00
|
|
|
/* Domain starts inactive, even if the domain XML had an id field. */
|
|
|
|
vm->def->id = -1;
|
|
|
|
|
|
|
|
if (virAsprintf(&unixfile, "%s/qemu.tunnelmigrate.dest.%s",
|
|
|
|
driver->stateDir, vm->def->name) < 0) {
|
|
|
|
virReportOOMError (dconn);
|
2009-11-03 18:26:32 +00:00
|
|
|
goto endjob;
|
2009-09-30 10:51:54 +00:00
|
|
|
}
|
|
|
|
unlink(unixfile);
|
|
|
|
|
|
|
|
/* check that this qemu version supports the interactive exec */
|
|
|
|
if (qemudExtractVersionInfo(vm->def->emulator, NULL, &qemuCmdFlags) < 0) {
|
|
|
|
qemudReportError(dconn, NULL, NULL, VIR_ERR_INTERNAL_ERROR,
|
|
|
|
_("Cannot determine QEMU argv syntax %s"),
|
|
|
|
vm->def->emulator);
|
2009-11-03 18:26:32 +00:00
|
|
|
goto endjob;
|
2009-09-30 10:51:54 +00:00
|
|
|
}
|
|
|
|
if (qemuCmdFlags & QEMUD_CMD_FLAG_MIGRATE_QEMU_UNIX)
|
|
|
|
internalret = virAsprintf(&migrateFrom, "unix:%s", unixfile);
|
|
|
|
else if (qemuCmdFlags & QEMUD_CMD_FLAG_MIGRATE_QEMU_EXEC)
|
|
|
|
internalret = virAsprintf(&migrateFrom, "exec:nc -U -l %s", unixfile);
|
|
|
|
else {
|
|
|
|
qemudReportError(dconn, NULL, NULL, VIR_ERR_OPERATION_FAILED,
|
|
|
|
"%s", _("Destination qemu is too old to support tunnelled migration"));
|
2009-11-03 18:26:32 +00:00
|
|
|
goto endjob;
|
2009-09-30 10:51:54 +00:00
|
|
|
}
|
|
|
|
if (internalret < 0) {
|
|
|
|
virReportOOMError(dconn);
|
2009-11-03 18:26:32 +00:00
|
|
|
goto endjob;
|
2009-09-30 10:51:54 +00:00
|
|
|
}
|
|
|
|
/* Start the QEMU daemon, with the same command-line arguments plus
|
|
|
|
* -incoming unix:/path/to/file or exec:nc -U /path/to/file
|
|
|
|
*/
|
|
|
|
internalret = qemudStartVMDaemon(dconn, driver, vm, migrateFrom, -1);
|
|
|
|
VIR_FREE(migrateFrom);
|
|
|
|
if (internalret < 0) {
|
|
|
|
/* Note that we don't set an error here because qemudStartVMDaemon
|
|
|
|
* should have already done that.
|
|
|
|
*/
|
|
|
|
if (!vm->persistent) {
|
|
|
|
virDomainRemoveInactive(&driver->domains, vm);
|
|
|
|
vm = NULL;
|
|
|
|
}
|
2009-11-03 18:26:32 +00:00
|
|
|
goto endjob;
|
2009-09-30 10:51:54 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
qemust = qemuStreamMigOpen(st, unixfile);
|
|
|
|
if (qemust == NULL) {
|
|
|
|
qemudShutdownVMDaemon(NULL, driver, vm);
|
Fully asynchronous monitor I/O processing
Change the QEMU monitor file handle watch to poll for both
read & write events, as well as EOF. All I/O to/from the
QEMU monitor FD is now done in the event callback thread.
When the QEMU driver needs to send a command, it puts the
data to be sent into a qemuMonitorMessagePtr object instance,
queues it for dispatch, and then goes to sleep on a condition
variable. The event thread sends all the data, and then waits
for the reply to arrive, putting the response / error data
back into the qemuMonitorMessagePtr and notifying the condition
variable.
There is a temporary hack in the disk passphrase callback to
avoid acquiring the domain lock. This avoids a deadlock in
the command processing, since the domain lock is still held
when running monitor commands. The next commit will remove
the locking when running commands & thus allow re-introduction
of locking the disk passphrase callback
* src/qemu/qemu_driver.c: Temporarily don't acquire lock in
disk passphrase callback. To be reverted in next commit
* src/qemu/qemu_monitor.c, src/qemu/qemu_monitor.h: Remove
raw I/O functions, and a generic qemuMonitorSend() for
invoking a command
* src/qemu/qemu_monitor_text.c, src/qemu/qemu_monitor_text.h:
Remove all low level I/O, and use the new qemuMonitorSend()
API. Provide a qemuMonitorTextIOProcess() method for detecting
command/reply/prompt boundaries in the monitor data stream
2009-10-14 17:40:51 +00:00
|
|
|
if (!vm->persistent) {
|
2009-12-08 14:42:43 +00:00
|
|
|
if (qemuDomainObjEndJob(vm) > 0)
|
|
|
|
virDomainRemoveInactive(&driver->domains, vm);
|
Fully asynchronous monitor I/O processing
Change the QEMU monitor file handle watch to poll for both
read & write events, as well as EOF. All I/O to/from the
QEMU monitor FD is now done in the event callback thread.
When the QEMU driver needs to send a command, it puts the
data to be sent into a qemuMonitorMessagePtr object instance,
queues it for dispatch, and then goes to sleep on a condition
variable. The event thread sends all the data, and then waits
for the reply to arrive, putting the response / error data
back into the qemuMonitorMessagePtr and notifying the condition
variable.
There is a temporary hack in the disk passphrase callback to
avoid acquiring the domain lock. This avoids a deadlock in
the command processing, since the domain lock is still held
when running monitor commands. The next commit will remove
the locking when running commands & thus allow re-introduction
of locking the disk passphrase callback
* src/qemu/qemu_driver.c: Temporarily don't acquire lock in
disk passphrase callback. To be reverted in next commit
* src/qemu/qemu_monitor.c, src/qemu/qemu_monitor.h: Remove
raw I/O functions, and a generic qemuMonitorSend() for
invoking a command
* src/qemu/qemu_monitor_text.c, src/qemu/qemu_monitor_text.h:
Remove all low level I/O, and use the new qemuMonitorSend()
API. Provide a qemuMonitorTextIOProcess() method for detecting
command/reply/prompt boundaries in the monitor data stream
2009-10-14 17:40:51 +00:00
|
|
|
vm = NULL;
|
|
|
|
}
|
2009-09-30 10:51:54 +00:00
|
|
|
virReportSystemError(dconn, errno,
|
|
|
|
_("cannot open unix socket '%s' for tunnelled migration"),
|
|
|
|
unixfile);
|
2009-11-03 18:26:32 +00:00
|
|
|
goto endjob;
|
2009-09-30 10:51:54 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
st->driver = &qemuStreamMigDrv;
|
|
|
|
st->privateData = qemust;
|
|
|
|
|
|
|
|
event = virDomainEventNewFromObj(vm,
|
|
|
|
VIR_DOMAIN_EVENT_STARTED,
|
|
|
|
VIR_DOMAIN_EVENT_STARTED_MIGRATED);
|
|
|
|
ret = 0;
|
|
|
|
|
2009-11-03 18:26:32 +00:00
|
|
|
endjob:
|
2009-12-08 14:42:43 +00:00
|
|
|
if (vm &&
|
|
|
|
qemuDomainObjEndJob(vm) == 0)
|
|
|
|
vm = NULL;
|
2009-11-03 18:26:32 +00:00
|
|
|
|
2009-09-30 10:51:54 +00:00
|
|
|
cleanup:
|
|
|
|
virDomainDefFree(def);
|
2009-12-14 15:41:11 +00:00
|
|
|
if (unixfile)
|
|
|
|
unlink(unixfile);
|
2009-09-30 10:51:54 +00:00
|
|
|
VIR_FREE(unixfile);
|
|
|
|
if (vm)
|
|
|
|
virDomainObjUnlock(vm);
|
|
|
|
if (event)
|
|
|
|
qemuDomainEventQueue(driver, event);
|
|
|
|
qemuDriverUnlock(driver);
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
2008-11-14 08:42:47 +00:00
|
|
|
/* Prepare is the first step, and it runs on the destination host.
|
|
|
|
*
|
|
|
|
* This starts an empty VM listening on a TCP port.
|
|
|
|
*/
|
2010-01-05 15:32:11 +00:00
|
|
|
static int ATTRIBUTE_NONNULL (5)
|
2008-11-14 08:42:47 +00:00
|
|
|
qemudDomainMigratePrepare2 (virConnectPtr dconn,
|
|
|
|
char **cookie ATTRIBUTE_UNUSED,
|
|
|
|
int *cookielen ATTRIBUTE_UNUSED,
|
|
|
|
const char *uri_in,
|
|
|
|
char **uri_out,
|
2009-09-30 10:51:54 +00:00
|
|
|
unsigned long flags,
|
2008-11-14 08:42:47 +00:00
|
|
|
const char *dname,
|
|
|
|
unsigned long resource ATTRIBUTE_UNUSED,
|
|
|
|
const char *dom_xml)
|
|
|
|
{
|
|
|
|
static int port = 0;
|
2008-12-04 21:04:30 +00:00
|
|
|
struct qemud_driver *driver = dconn->privateData;
|
|
|
|
virDomainDefPtr def = NULL;
|
2008-11-14 08:42:47 +00:00
|
|
|
virDomainObjPtr vm = NULL;
|
|
|
|
int this_port;
|
2009-07-30 14:41:12 +00:00
|
|
|
char *hostname;
|
2008-11-14 08:42:47 +00:00
|
|
|
char migrateFrom [64];
|
|
|
|
const char *p;
|
2008-12-04 21:09:20 +00:00
|
|
|
virDomainEventPtr event = NULL;
|
2009-07-31 06:56:17 +00:00
|
|
|
int ret = -1;
|
2009-07-30 14:41:12 +00:00
|
|
|
int internalret;
|
2008-12-04 21:04:30 +00:00
|
|
|
|
|
|
|
*uri_out = NULL;
|
2008-11-14 08:42:47 +00:00
|
|
|
|
2008-12-04 21:06:41 +00:00
|
|
|
qemuDriverLock(driver);
|
2009-09-30 10:51:54 +00:00
|
|
|
if (flags & VIR_MIGRATE_TUNNELLED) {
|
|
|
|
/* this is a logical error; we never should have gotten here with
|
|
|
|
* VIR_MIGRATE_TUNNELLED set
|
|
|
|
*/
|
|
|
|
qemudReportError(dconn, NULL, NULL, VIR_ERR_INTERNAL_ERROR,
|
|
|
|
"%s", _("Tunnelled migration requested but invalid RPC method called"));
|
|
|
|
goto cleanup;
|
|
|
|
}
|
|
|
|
|
2008-11-14 08:42:47 +00:00
|
|
|
if (!dom_xml) {
|
|
|
|
qemudReportError (dconn, NULL, NULL, VIR_ERR_INTERNAL_ERROR,
|
|
|
|
"%s", _("no domain XML passed"));
|
2008-12-04 21:04:30 +00:00
|
|
|
goto cleanup;
|
2008-11-14 08:42:47 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
/* The URI passed in may be NULL or a string "tcp://somehostname:port".
|
|
|
|
*
|
|
|
|
* If the URI passed in is NULL then we allocate a port number
|
|
|
|
* from our pool of port numbers and return a URI of
|
|
|
|
* "tcp://ourhostname:port".
|
|
|
|
*
|
|
|
|
* If the URI passed in is not NULL then we try to parse out the
|
|
|
|
* port number and use that (note that the hostname is assumed
|
|
|
|
* to be a correct hostname which refers to the target machine).
|
|
|
|
*/
|
|
|
|
if (uri_in == NULL) {
|
|
|
|
this_port = QEMUD_MIGRATION_FIRST_PORT + port++;
|
|
|
|
if (port == QEMUD_MIGRATION_NUM_PORTS) port = 0;
|
|
|
|
|
|
|
|
/* Get hostname */
|
2009-10-23 17:01:22 +00:00
|
|
|
if ((hostname = virGetHostname(dconn)) == NULL)
|
2008-12-04 21:04:30 +00:00
|
|
|
goto cleanup;
|
2008-11-14 08:42:47 +00:00
|
|
|
|
2009-09-23 14:23:47 +00:00
|
|
|
/* XXX this really should have been a properly well-formed
|
|
|
|
* URI, but we can't add in tcp:// now without breaking
|
|
|
|
* compatability with old targets. We at least make the
|
|
|
|
* new targets accept both syntaxes though.
|
|
|
|
*/
|
2008-11-14 08:42:47 +00:00
|
|
|
/* Caller frees */
|
2009-07-30 14:41:12 +00:00
|
|
|
internalret = virAsprintf(uri_out, "tcp:%s:%d", hostname, this_port);
|
|
|
|
VIR_FREE(hostname);
|
|
|
|
if (internalret < 0) {
|
2009-01-29 12:10:32 +00:00
|
|
|
virReportOOMError (dconn);
|
2008-12-04 21:04:30 +00:00
|
|
|
goto cleanup;
|
2008-11-14 08:42:47 +00:00
|
|
|
}
|
|
|
|
} else {
|
|
|
|
/* Check the URI starts with "tcp:". We will escape the
|
|
|
|
* URI when passing it to the qemu monitor, so bad
|
|
|
|
* characters in hostname part don't matter.
|
|
|
|
*/
|
2009-04-01 09:54:20 +00:00
|
|
|
if (!STRPREFIX (uri_in, "tcp:")) {
|
2008-11-14 08:42:47 +00:00
|
|
|
qemudReportError (dconn, NULL, NULL, VIR_ERR_INVALID_ARG,
|
2009-07-31 06:59:02 +00:00
|
|
|
"%s", _("only tcp URIs are supported for KVM/QEMU migrations"));
|
2008-12-04 21:04:30 +00:00
|
|
|
goto cleanup;
|
2008-11-14 08:42:47 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
/* Get the port number. */
|
|
|
|
p = strrchr (uri_in, ':');
|
2009-10-26 20:08:23 +00:00
|
|
|
if (p == strchr(uri_in, ':')) {
|
|
|
|
/* Generate a port */
|
|
|
|
this_port = QEMUD_MIGRATION_FIRST_PORT + port++;
|
|
|
|
if (port == QEMUD_MIGRATION_NUM_PORTS)
|
|
|
|
port = 0;
|
|
|
|
|
|
|
|
/* Caller frees */
|
|
|
|
if (virAsprintf(uri_out, "%s:%d", uri_in, this_port) < 0) {
|
|
|
|
virReportOOMError (dconn);
|
|
|
|
goto cleanup;
|
|
|
|
}
|
|
|
|
|
|
|
|
} else {
|
|
|
|
p++; /* definitely has a ':' in it, see above */
|
|
|
|
this_port = virParseNumber (&p);
|
|
|
|
if (this_port == -1 || p-uri_in != strlen (uri_in)) {
|
|
|
|
qemudReportError (dconn, NULL, NULL, VIR_ERR_INVALID_ARG,
|
|
|
|
"%s", _("URI ended with incorrect ':port'"));
|
|
|
|
goto cleanup;
|
|
|
|
}
|
2008-11-14 08:42:47 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2010-01-05 15:32:11 +00:00
|
|
|
if (*uri_out)
|
2009-10-26 20:08:23 +00:00
|
|
|
VIR_DEBUG("Generated uri_out=%s", *uri_out);
|
|
|
|
|
2008-11-14 08:42:47 +00:00
|
|
|
/* Parse the domain XML. */
|
2009-01-08 13:54:20 +00:00
|
|
|
if (!(def = virDomainDefParseString(dconn, driver->caps, dom_xml,
|
|
|
|
VIR_DOMAIN_XML_INACTIVE))) {
|
2008-11-14 08:42:47 +00:00
|
|
|
qemudReportError (dconn, NULL, NULL, VIR_ERR_OPERATION_FAILED,
|
|
|
|
"%s", _("failed to parse XML"));
|
2008-12-04 21:04:30 +00:00
|
|
|
goto cleanup;
|
2008-11-14 08:42:47 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
/* Target domain name, maybe renamed. */
|
|
|
|
dname = dname ? dname : def->name;
|
|
|
|
|
2009-11-02 19:10:36 +00:00
|
|
|
if (virDomainObjIsDuplicate(&driver->domains, def, 1) < 0)
|
|
|
|
goto cleanup;
|
2008-11-14 08:42:47 +00:00
|
|
|
|
|
|
|
if (!(vm = virDomainAssignDef(dconn,
|
2009-10-06 11:50:58 +00:00
|
|
|
driver->caps,
|
2008-11-14 08:42:47 +00:00
|
|
|
&driver->domains,
|
|
|
|
def))) {
|
|
|
|
qemudReportError (dconn, NULL, NULL, VIR_ERR_OPERATION_FAILED,
|
|
|
|
"%s", _("failed to assign new VM"));
|
2008-12-04 21:04:30 +00:00
|
|
|
goto cleanup;
|
2008-11-14 08:42:47 +00:00
|
|
|
}
|
2008-12-04 21:04:30 +00:00
|
|
|
def = NULL;
|
2008-11-14 08:42:47 +00:00
|
|
|
|
2009-11-03 18:26:32 +00:00
|
|
|
if (qemuDomainObjBeginJobWithDriver(driver, vm) < 0)
|
|
|
|
goto cleanup;
|
|
|
|
|
2008-11-14 08:42:47 +00:00
|
|
|
/* Domain starts inactive, even if the domain XML had an id field. */
|
|
|
|
vm->def->id = -1;
|
|
|
|
|
|
|
|
/* Start the QEMU daemon, with the same command-line arguments plus
|
|
|
|
* -incoming tcp:0.0.0.0:port
|
|
|
|
*/
|
|
|
|
snprintf (migrateFrom, sizeof (migrateFrom), "tcp:0.0.0.0:%d", this_port);
|
2009-01-29 17:27:54 +00:00
|
|
|
if (qemudStartVMDaemon (dconn, driver, vm, migrateFrom, -1) < 0) {
|
2009-07-31 07:03:55 +00:00
|
|
|
/* Note that we don't set an error here because qemudStartVMDaemon
|
|
|
|
* should have already done that.
|
|
|
|
*/
|
2008-12-04 21:06:41 +00:00
|
|
|
if (!vm->persistent) {
|
2009-12-08 14:42:43 +00:00
|
|
|
if (qemuDomainObjEndJob(vm) > 0)
|
|
|
|
virDomainRemoveInactive(&driver->domains, vm);
|
2008-12-04 21:06:41 +00:00
|
|
|
vm = NULL;
|
|
|
|
}
|
2009-11-03 18:26:32 +00:00
|
|
|
goto endjob;
|
2008-11-14 08:42:47 +00:00
|
|
|
}
|
2008-12-04 21:09:20 +00:00
|
|
|
|
|
|
|
event = virDomainEventNewFromObj(vm,
|
|
|
|
VIR_DOMAIN_EVENT_STARTED,
|
|
|
|
VIR_DOMAIN_EVENT_STARTED_MIGRATED);
|
2008-12-04 21:04:30 +00:00
|
|
|
ret = 0;
|
2008-11-14 08:42:47 +00:00
|
|
|
|
2009-11-03 18:26:32 +00:00
|
|
|
endjob:
|
2009-12-08 14:42:43 +00:00
|
|
|
if (vm &&
|
|
|
|
qemuDomainObjEndJob(vm) == 0)
|
|
|
|
vm = NULL;
|
2009-11-03 18:26:32 +00:00
|
|
|
|
2008-12-04 21:04:30 +00:00
|
|
|
cleanup:
|
|
|
|
virDomainDefFree(def);
|
|
|
|
if (ret != 0) {
|
|
|
|
VIR_FREE(*uri_out);
|
|
|
|
}
|
2008-12-04 21:06:41 +00:00
|
|
|
if (vm)
|
|
|
|
virDomainObjUnlock(vm);
|
2008-12-04 21:09:20 +00:00
|
|
|
if (event)
|
|
|
|
qemuDomainEventQueue(driver, event);
|
2008-12-04 21:06:41 +00:00
|
|
|
qemuDriverUnlock(driver);
|
2008-12-04 21:04:30 +00:00
|
|
|
return ret;
|
2009-09-30 10:51:54 +00:00
|
|
|
|
|
|
|
}
|
|
|
|
|
2009-10-02 14:31:06 +00:00
|
|
|
|
|
|
|
/* Perform migration using QEMU's native TCP migrate support,
|
|
|
|
* not encrypted obviously
|
|
|
|
*/
|
|
|
|
static int doNativeMigrate(virDomainPtr dom,
|
2009-11-03 18:26:32 +00:00
|
|
|
struct qemud_driver *driver,
|
2009-10-02 14:31:06 +00:00
|
|
|
virDomainObjPtr vm,
|
|
|
|
const char *uri,
|
|
|
|
unsigned long flags ATTRIBUTE_UNUSED,
|
|
|
|
const char *dname ATTRIBUTE_UNUSED,
|
|
|
|
unsigned long resource)
|
|
|
|
{
|
|
|
|
int ret = -1;
|
2009-09-17 17:10:04 +00:00
|
|
|
xmlURIPtr uribits = NULL;
|
2009-10-02 14:31:06 +00:00
|
|
|
int status;
|
|
|
|
unsigned long long transferred, remaining, total;
|
2009-10-09 20:13:06 +00:00
|
|
|
qemuDomainObjPrivatePtr priv = vm->privateData;
|
2009-10-02 14:31:06 +00:00
|
|
|
|
|
|
|
/* Issue the migrate command. */
|
|
|
|
if (STRPREFIX(uri, "tcp:") && !STRPREFIX(uri, "tcp://")) {
|
|
|
|
/* HACK: source host generates bogus URIs, so fix them up */
|
|
|
|
char *tmpuri;
|
|
|
|
if (virAsprintf(&tmpuri, "tcp://%s", uri + strlen("tcp:")) < 0) {
|
|
|
|
virReportOOMError(dom->conn);
|
|
|
|
goto cleanup;
|
|
|
|
}
|
|
|
|
uribits = xmlParseURI(tmpuri);
|
|
|
|
VIR_FREE(tmpuri);
|
|
|
|
} else {
|
|
|
|
uribits = xmlParseURI(uri);
|
|
|
|
}
|
|
|
|
if (!uribits) {
|
|
|
|
qemudReportError(dom->conn, dom, NULL, VIR_ERR_INTERNAL_ERROR,
|
|
|
|
_("cannot parse URI %s"), uri);
|
|
|
|
goto cleanup;
|
|
|
|
}
|
|
|
|
|
2009-11-03 18:26:32 +00:00
|
|
|
qemuDomainObjEnterMonitorWithDriver(driver, vm);
|
2009-10-02 14:31:06 +00:00
|
|
|
if (resource > 0 &&
|
2009-10-13 14:27:58 +00:00
|
|
|
qemuMonitorSetMigrationSpeed(priv->mon, resource) < 0) {
|
2009-11-03 18:26:32 +00:00
|
|
|
qemuDomainObjExitMonitorWithDriver(driver, vm);
|
2009-10-02 14:31:06 +00:00
|
|
|
goto cleanup;
|
2009-10-13 14:27:58 +00:00
|
|
|
}
|
2009-10-02 14:31:06 +00:00
|
|
|
|
2009-10-13 14:27:58 +00:00
|
|
|
if (qemuMonitorMigrateToHost(priv->mon, 0, uribits->server, uribits->port) < 0) {
|
2009-11-03 18:26:32 +00:00
|
|
|
qemuDomainObjExitMonitorWithDriver(driver, vm);
|
2009-10-02 14:31:06 +00:00
|
|
|
goto cleanup;
|
2009-10-13 14:27:58 +00:00
|
|
|
}
|
2009-10-02 14:31:06 +00:00
|
|
|
|
|
|
|
/* it is also possible that the migrate didn't fail initially, but
|
|
|
|
* rather failed later on. Check the output of "info migrate"
|
|
|
|
*/
|
2009-10-09 20:13:06 +00:00
|
|
|
if (qemuMonitorGetMigrationStatus(priv->mon,
|
|
|
|
&status,
|
2009-10-02 14:31:06 +00:00
|
|
|
&transferred,
|
|
|
|
&remaining,
|
|
|
|
&total) < 0) {
|
2009-11-03 18:26:32 +00:00
|
|
|
qemuDomainObjExitMonitorWithDriver(driver, vm);
|
2009-10-02 14:31:06 +00:00
|
|
|
goto cleanup;
|
|
|
|
}
|
2009-11-03 18:26:32 +00:00
|
|
|
qemuDomainObjExitMonitorWithDriver(driver, vm);
|
2009-10-02 14:31:06 +00:00
|
|
|
|
|
|
|
if (status != QEMU_MONITOR_MIGRATION_STATUS_COMPLETED) {
|
|
|
|
qemudReportError (dom->conn, dom, NULL, VIR_ERR_OPERATION_FAILED,
|
|
|
|
"%s", _("migrate did not successfully complete"));
|
|
|
|
goto cleanup;
|
|
|
|
}
|
|
|
|
|
|
|
|
ret = 0;
|
|
|
|
|
|
|
|
cleanup:
|
|
|
|
xmlFreeURI(uribits);
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
2009-10-02 15:02:25 +00:00
|
|
|
static int doTunnelSendAll(virDomainPtr dom,
|
|
|
|
virStreamPtr st,
|
|
|
|
int sock)
|
|
|
|
{
|
|
|
|
char buffer[65536];
|
|
|
|
int nbytes = sizeof(buffer);
|
|
|
|
|
|
|
|
/* XXX should honour the 'resource' parameter here */
|
|
|
|
for (;;) {
|
|
|
|
nbytes = saferead(sock, buffer, nbytes);
|
|
|
|
if (nbytes < 0) {
|
|
|
|
virStreamAbort(st);
|
|
|
|
virReportSystemError(dom->conn, errno, "%s",
|
|
|
|
_("tunnelled migration failed to read from qemu"));
|
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
else if (nbytes == 0)
|
|
|
|
/* EOF; get out of here */
|
|
|
|
break;
|
|
|
|
|
|
|
|
if (virStreamSend(st, buffer, nbytes) < 0) {
|
2009-11-03 12:30:47 +00:00
|
|
|
qemudReportError(dom->conn, dom, NULL, VIR_ERR_OPERATION_FAILED, "%s",
|
2009-10-02 15:02:25 +00:00
|
|
|
_("Failed to write migration data to remote libvirtd"));
|
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
if (virStreamFinish(st) < 0)
|
|
|
|
/* virStreamFinish set the error for us */
|
|
|
|
return -1;
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2009-09-30 10:51:54 +00:00
|
|
|
static int doTunnelMigrate(virDomainPtr dom,
|
2009-11-03 18:26:32 +00:00
|
|
|
struct qemud_driver *driver,
|
2009-10-02 14:56:36 +00:00
|
|
|
virConnectPtr dconn,
|
2009-09-30 10:51:54 +00:00
|
|
|
virDomainObjPtr vm,
|
2009-10-02 14:56:36 +00:00
|
|
|
const char *dom_xml,
|
2009-09-30 10:51:54 +00:00
|
|
|
const char *uri,
|
|
|
|
unsigned long flags,
|
|
|
|
const char *dname,
|
|
|
|
unsigned long resource)
|
|
|
|
{
|
2009-10-09 20:13:06 +00:00
|
|
|
qemuDomainObjPrivatePtr priv = vm->privateData;
|
2009-10-02 15:14:27 +00:00
|
|
|
int client_sock = -1;
|
|
|
|
int qemu_sock = -1;
|
2009-09-30 10:51:54 +00:00
|
|
|
struct sockaddr_un sa_qemu, sa_client;
|
|
|
|
socklen_t addrlen;
|
2009-10-02 15:14:27 +00:00
|
|
|
virDomainPtr ddomain = NULL;
|
2009-09-30 10:51:54 +00:00
|
|
|
int retval = -1;
|
2009-10-02 15:14:27 +00:00
|
|
|
virStreamPtr st = NULL;
|
2009-09-30 10:51:54 +00:00
|
|
|
char *unixfile = NULL;
|
|
|
|
int internalret;
|
|
|
|
unsigned int qemuCmdFlags;
|
|
|
|
int status;
|
|
|
|
unsigned long long transferred, remaining, total;
|
|
|
|
|
2009-10-02 15:14:27 +00:00
|
|
|
/*
|
|
|
|
* The order of operations is important here to avoid touching
|
|
|
|
* the source VM until we are very sure we can successfully
|
|
|
|
* start the migration operation.
|
|
|
|
*
|
|
|
|
* 1. setup local support infrastructure (eg sockets)
|
|
|
|
* 2. setup destination fully
|
|
|
|
* 3. start migration on source
|
2009-09-30 10:51:54 +00:00
|
|
|
*/
|
|
|
|
|
2009-10-02 14:56:36 +00:00
|
|
|
|
2009-10-02 15:14:27 +00:00
|
|
|
/* Stage 1. setup local support infrastructure */
|
2009-09-30 10:51:54 +00:00
|
|
|
|
|
|
|
if (virAsprintf(&unixfile, "%s/qemu.tunnelmigrate.src.%s",
|
|
|
|
driver->stateDir, vm->def->name) < 0) {
|
|
|
|
virReportOOMError(dom->conn);
|
2009-10-02 15:14:27 +00:00
|
|
|
goto cleanup;
|
2009-09-30 10:51:54 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
qemu_sock = socket(AF_UNIX, SOCK_STREAM, 0);
|
|
|
|
if (qemu_sock < 0) {
|
|
|
|
virReportSystemError(dom->conn, errno, "%s",
|
|
|
|
_("cannot open tunnelled migration socket"));
|
2009-10-02 15:14:27 +00:00
|
|
|
goto cleanup;
|
2009-09-30 10:51:54 +00:00
|
|
|
}
|
|
|
|
memset(&sa_qemu, 0, sizeof(sa_qemu));
|
|
|
|
sa_qemu.sun_family = AF_UNIX;
|
|
|
|
if (virStrcpy(sa_qemu.sun_path, unixfile,
|
|
|
|
sizeof(sa_qemu.sun_path)) == NULL) {
|
|
|
|
qemudReportError(dom->conn, NULL, NULL, VIR_ERR_INTERNAL_ERROR,
|
|
|
|
_("Unix socket '%s' too big for destination"),
|
|
|
|
unixfile);
|
2009-10-02 15:14:27 +00:00
|
|
|
goto cleanup;
|
2009-09-30 10:51:54 +00:00
|
|
|
}
|
|
|
|
unlink(unixfile);
|
|
|
|
if (bind(qemu_sock, (struct sockaddr *)&sa_qemu, sizeof(sa_qemu)) < 0) {
|
|
|
|
virReportSystemError(dom->conn, errno,
|
|
|
|
_("Cannot bind to unix socket '%s' for tunnelled migration"),
|
|
|
|
unixfile);
|
2009-10-02 15:14:27 +00:00
|
|
|
goto cleanup;
|
2009-09-30 10:51:54 +00:00
|
|
|
}
|
|
|
|
if (listen(qemu_sock, 1) < 0) {
|
|
|
|
virReportSystemError(dom->conn, errno,
|
|
|
|
_("Cannot listen on unix socket '%s' for tunnelled migration"),
|
|
|
|
unixfile);
|
2009-10-02 15:14:27 +00:00
|
|
|
goto cleanup;
|
2009-09-30 10:51:54 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
/* check that this qemu version supports the unix migration */
|
|
|
|
if (qemudExtractVersionInfo(vm->def->emulator, NULL, &qemuCmdFlags) < 0) {
|
|
|
|
qemudReportError(dom->conn, NULL, NULL, VIR_ERR_INTERNAL_ERROR,
|
|
|
|
_("Cannot extract Qemu version from '%s'"),
|
|
|
|
vm->def->emulator);
|
2009-10-02 15:14:27 +00:00
|
|
|
goto cleanup;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (!(qemuCmdFlags & QEMUD_CMD_FLAG_MIGRATE_QEMU_UNIX) &&
|
|
|
|
!(qemuCmdFlags & QEMUD_CMD_FLAG_MIGRATE_QEMU_EXEC)) {
|
|
|
|
qemudReportError(dom->conn, NULL, NULL, VIR_ERR_OPERATION_FAILED,
|
|
|
|
"%s", _("Source qemu is too old to support tunnelled migration"));
|
|
|
|
goto cleanup;
|
2009-09-30 10:51:54 +00:00
|
|
|
}
|
2009-10-02 15:14:27 +00:00
|
|
|
|
|
|
|
|
|
|
|
/* Stage 2. setup destination fully
|
|
|
|
*
|
|
|
|
* Once stage 2 has completed successfully, we *must* call finish
|
|
|
|
* to cleanup the target whether we succeed or fail
|
|
|
|
*/
|
|
|
|
st = virStreamNew(dconn, 0);
|
|
|
|
if (st == NULL)
|
|
|
|
/* virStreamNew only fails on OOM, and it reports the error itself */
|
|
|
|
goto cleanup;
|
|
|
|
|
|
|
|
internalret = dconn->driver->domainMigratePrepareTunnel(dconn, st,
|
|
|
|
flags, dname,
|
|
|
|
resource, dom_xml);
|
|
|
|
|
|
|
|
if (internalret < 0)
|
|
|
|
/* domainMigratePrepareTunnel sets the error for us */
|
|
|
|
goto cleanup;
|
|
|
|
|
|
|
|
/* 3. start migration on source */
|
2009-11-03 18:26:32 +00:00
|
|
|
qemuDomainObjEnterMonitorWithDriver(driver, vm);
|
2009-09-30 10:51:54 +00:00
|
|
|
if (qemuCmdFlags & QEMUD_CMD_FLAG_MIGRATE_QEMU_UNIX)
|
2009-10-09 20:13:06 +00:00
|
|
|
internalret = qemuMonitorMigrateToUnix(priv->mon, 1, unixfile);
|
2009-09-30 10:51:54 +00:00
|
|
|
else if (qemuCmdFlags & QEMUD_CMD_FLAG_MIGRATE_QEMU_EXEC) {
|
|
|
|
const char *args[] = { "nc", "-U", unixfile, NULL };
|
2009-10-09 20:13:06 +00:00
|
|
|
internalret = qemuMonitorMigrateToCommand(priv->mon, 1, args, "/dev/null");
|
2009-10-02 15:14:27 +00:00
|
|
|
} else {
|
|
|
|
internalret = -1;
|
2009-09-30 10:51:54 +00:00
|
|
|
}
|
2009-11-03 18:26:32 +00:00
|
|
|
qemuDomainObjExitMonitorWithDriver(driver, vm);
|
2009-09-30 10:51:54 +00:00
|
|
|
if (internalret < 0) {
|
|
|
|
qemudReportError(dom->conn, dom, NULL, VIR_ERR_OPERATION_FAILED,
|
|
|
|
"%s", _("tunnelled migration monitor command failed"));
|
2009-10-02 15:14:27 +00:00
|
|
|
goto finish;
|
2009-09-30 10:51:54 +00:00
|
|
|
}
|
|
|
|
|
2009-10-02 15:14:27 +00:00
|
|
|
/* From this point onwards we *must* call cancel to abort the
|
|
|
|
* migration on source if anything goes wrong */
|
|
|
|
|
2009-09-30 10:51:54 +00:00
|
|
|
/* it is also possible that the migrate didn't fail initially, but
|
|
|
|
* rather failed later on. Check the output of "info migrate"
|
|
|
|
*/
|
2009-11-03 18:26:32 +00:00
|
|
|
qemuDomainObjEnterMonitorWithDriver(driver, vm);
|
2009-10-09 20:13:06 +00:00
|
|
|
if (qemuMonitorGetMigrationStatus(priv->mon,
|
|
|
|
&status,
|
2009-09-30 10:51:54 +00:00
|
|
|
&transferred,
|
|
|
|
&remaining,
|
|
|
|
&total) < 0) {
|
2009-11-03 18:26:32 +00:00
|
|
|
qemuDomainObjExitMonitorWithDriver(driver, vm);
|
2009-10-02 15:14:27 +00:00
|
|
|
goto cancel;
|
2009-09-30 10:51:54 +00:00
|
|
|
}
|
2009-11-03 18:26:32 +00:00
|
|
|
qemuDomainObjExitMonitorWithDriver(driver, vm);
|
2009-09-30 10:51:54 +00:00
|
|
|
|
|
|
|
if (status == QEMU_MONITOR_MIGRATION_STATUS_ERROR) {
|
|
|
|
qemudReportError(dom->conn, dom, NULL, VIR_ERR_OPERATION_FAILED,
|
|
|
|
"%s",_("migrate failed"));
|
2009-10-02 15:14:27 +00:00
|
|
|
goto cancel;
|
2009-09-30 10:51:54 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
addrlen = sizeof(sa_client);
|
|
|
|
while ((client_sock = accept(qemu_sock, (struct sockaddr *)&sa_client, &addrlen)) < 0) {
|
|
|
|
if (errno == EAGAIN || errno == EINTR)
|
|
|
|
continue;
|
|
|
|
virReportSystemError(dom->conn, errno, "%s",
|
|
|
|
_("tunnelled migration failed to accept from qemu"));
|
2009-10-02 15:14:27 +00:00
|
|
|
goto cancel;
|
2009-09-30 10:51:54 +00:00
|
|
|
}
|
|
|
|
|
2009-10-02 15:02:25 +00:00
|
|
|
retval = doTunnelSendAll(dom, st, client_sock);
|
2009-10-02 14:31:06 +00:00
|
|
|
|
2009-10-02 15:14:27 +00:00
|
|
|
cancel:
|
2009-10-13 14:27:58 +00:00
|
|
|
if (retval != 0) {
|
2009-11-03 18:26:32 +00:00
|
|
|
qemuDomainObjEnterMonitorWithDriver(driver, vm);
|
2009-10-09 20:13:06 +00:00
|
|
|
qemuMonitorMigrateCancel(priv->mon);
|
2009-11-03 18:26:32 +00:00
|
|
|
qemuDomainObjExitMonitorWithDriver(driver, vm);
|
2009-10-13 14:27:58 +00:00
|
|
|
}
|
2009-09-30 10:51:54 +00:00
|
|
|
|
2009-10-02 15:14:27 +00:00
|
|
|
finish:
|
2009-09-30 10:51:54 +00:00
|
|
|
dname = dname ? dname : dom->name;
|
|
|
|
ddomain = dconn->driver->domainMigrateFinish2
|
|
|
|
(dconn, dname, NULL, 0, uri, flags, retval);
|
2009-10-02 15:14:27 +00:00
|
|
|
|
|
|
|
cleanup:
|
|
|
|
if (client_sock != -1)
|
|
|
|
close(client_sock);
|
|
|
|
if (qemu_sock != -1)
|
|
|
|
close(qemu_sock);
|
|
|
|
|
2009-09-30 10:51:54 +00:00
|
|
|
if (ddomain)
|
|
|
|
virUnrefDomain(ddomain);
|
|
|
|
|
2009-10-02 15:14:27 +00:00
|
|
|
if (unixfile) {
|
|
|
|
unlink(unixfile);
|
|
|
|
VIR_FREE(unixfile);
|
|
|
|
}
|
2009-09-30 10:51:54 +00:00
|
|
|
|
2009-10-02 15:14:27 +00:00
|
|
|
if (st)
|
|
|
|
/* don't call virStreamFree(), because that resets any pending errors */
|
|
|
|
virUnrefStream(st);
|
2009-10-02 14:56:36 +00:00
|
|
|
return retval;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
2009-09-17 17:10:04 +00:00
|
|
|
/* This is essentially a simplified re-impl of
|
|
|
|
* virDomainMigrateVersion2 from libvirt.c, but running in source
|
|
|
|
* libvirtd context, instead of client app context */
|
|
|
|
static int doNonTunnelMigrate(virDomainPtr dom,
|
2009-11-03 18:26:32 +00:00
|
|
|
struct qemud_driver *driver,
|
2009-09-17 17:10:04 +00:00
|
|
|
virConnectPtr dconn,
|
|
|
|
virDomainObjPtr vm,
|
|
|
|
const char *dom_xml,
|
|
|
|
const char *uri ATTRIBUTE_UNUSED,
|
|
|
|
unsigned long flags,
|
|
|
|
const char *dname,
|
|
|
|
unsigned long resource)
|
|
|
|
{
|
|
|
|
virDomainPtr ddomain = NULL;
|
|
|
|
int retval = -1;
|
|
|
|
char *uri_out = NULL;
|
|
|
|
|
|
|
|
/* NB we don't pass 'uri' into this, since that's the libvirtd
|
|
|
|
* URI in this context - so we let dest pick it */
|
|
|
|
if (dconn->driver->domainMigratePrepare2(dconn,
|
|
|
|
NULL, /* cookie */
|
|
|
|
0, /* cookielen */
|
|
|
|
NULL, /* uri */
|
|
|
|
&uri_out,
|
|
|
|
flags, dname,
|
|
|
|
resource, dom_xml) < 0)
|
|
|
|
/* domainMigratePrepare2 sets the error for us */
|
|
|
|
goto cleanup;
|
|
|
|
|
|
|
|
if (uri_out == NULL) {
|
2009-11-03 12:30:47 +00:00
|
|
|
qemudReportError(NULL, NULL, NULL, VIR_ERR_INTERNAL_ERROR, "%s",
|
2009-09-17 17:10:04 +00:00
|
|
|
_("domainMigratePrepare2 did not set uri"));
|
2009-12-14 16:02:56 +00:00
|
|
|
goto cleanup;
|
2009-09-17 17:10:04 +00:00
|
|
|
}
|
|
|
|
|
2009-11-03 18:26:32 +00:00
|
|
|
if (doNativeMigrate(dom, driver, vm, uri_out, flags, dname, resource) < 0)
|
2009-09-17 17:10:04 +00:00
|
|
|
goto finish;
|
|
|
|
|
|
|
|
retval = 0;
|
|
|
|
|
|
|
|
finish:
|
|
|
|
dname = dname ? dname : dom->name;
|
|
|
|
ddomain = dconn->driver->domainMigrateFinish2
|
|
|
|
(dconn, dname, NULL, 0, uri_out, flags, retval);
|
|
|
|
|
|
|
|
if (ddomain)
|
|
|
|
virUnrefDomain(ddomain);
|
|
|
|
|
|
|
|
cleanup:
|
|
|
|
return retval;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
2009-10-02 14:56:36 +00:00
|
|
|
static int doPeer2PeerMigrate(virDomainPtr dom,
|
2009-11-03 18:26:32 +00:00
|
|
|
struct qemud_driver *driver,
|
2009-10-02 14:56:36 +00:00
|
|
|
virDomainObjPtr vm,
|
|
|
|
const char *uri,
|
|
|
|
unsigned long flags,
|
|
|
|
const char *dname,
|
|
|
|
unsigned long resource)
|
|
|
|
{
|
|
|
|
int ret = -1;
|
|
|
|
virConnectPtr dconn = NULL;
|
|
|
|
char *dom_xml;
|
|
|
|
|
|
|
|
/* the order of operations is important here; we make sure the
|
|
|
|
* destination side is completely setup before we touch the source
|
|
|
|
*/
|
|
|
|
|
|
|
|
dconn = virConnectOpen(uri);
|
|
|
|
if (dconn == NULL) {
|
|
|
|
qemudReportError(dom->conn, dom, NULL, VIR_ERR_OPERATION_FAILED,
|
|
|
|
_("Failed to connect to remote libvirt URI %s"), uri);
|
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
if (!VIR_DRV_SUPPORTS_FEATURE(dconn->driver, dconn,
|
2009-09-17 17:10:04 +00:00
|
|
|
VIR_DRV_FEATURE_MIGRATION_P2P)) {
|
2009-10-02 14:56:36 +00:00
|
|
|
qemudReportError(dom->conn, dom, NULL, VIR_ERR_OPERATION_FAILED, "%s",
|
2009-09-17 17:10:04 +00:00
|
|
|
_("Destination libvirt does not support peer-to-peer migration protocol"));
|
2009-10-02 14:56:36 +00:00
|
|
|
goto cleanup;
|
|
|
|
}
|
|
|
|
|
|
|
|
dom_xml = virDomainDefFormat(dom->conn, vm->def, VIR_DOMAIN_XML_SECURE);
|
|
|
|
if (!dom_xml) {
|
|
|
|
qemudReportError(dom->conn, dom, NULL, VIR_ERR_OPERATION_FAILED,
|
|
|
|
"%s", _("failed to get domain xml"));
|
|
|
|
goto cleanup;
|
|
|
|
}
|
|
|
|
|
2009-09-17 17:10:04 +00:00
|
|
|
if (flags & VIR_MIGRATE_TUNNELLED)
|
2009-11-03 18:26:32 +00:00
|
|
|
ret = doTunnelMigrate(dom, driver, dconn, vm, dom_xml, uri, flags, dname, resource);
|
2009-09-17 17:10:04 +00:00
|
|
|
else
|
2009-11-03 18:26:32 +00:00
|
|
|
ret = doNonTunnelMigrate(dom, driver, dconn, vm, dom_xml, uri, flags, dname, resource);
|
2009-10-02 14:56:36 +00:00
|
|
|
|
|
|
|
cleanup:
|
|
|
|
VIR_FREE(dom_xml);
|
2009-09-30 10:51:54 +00:00
|
|
|
/* don't call virConnectClose(), because that resets any pending errors */
|
|
|
|
virUnrefConnect(dconn);
|
|
|
|
|
2009-10-02 14:56:36 +00:00
|
|
|
return ret;
|
2008-11-14 08:42:47 +00:00
|
|
|
}
|
|
|
|
|
2009-10-02 14:56:36 +00:00
|
|
|
|
2008-11-14 08:42:47 +00:00
|
|
|
/* Perform is the second step, and it runs on the source host. */
|
|
|
|
static int
|
|
|
|
qemudDomainMigratePerform (virDomainPtr dom,
|
|
|
|
const char *cookie ATTRIBUTE_UNUSED,
|
|
|
|
int cookielen ATTRIBUTE_UNUSED,
|
|
|
|
const char *uri,
|
2009-07-31 07:29:09 +00:00
|
|
|
unsigned long flags,
|
2009-10-02 14:31:06 +00:00
|
|
|
const char *dname,
|
2008-11-14 08:42:47 +00:00
|
|
|
unsigned long resource)
|
|
|
|
{
|
2008-12-04 21:04:30 +00:00
|
|
|
struct qemud_driver *driver = dom->conn->privateData;
|
|
|
|
virDomainObjPtr vm;
|
2008-12-04 21:09:20 +00:00
|
|
|
virDomainEventPtr event = NULL;
|
2008-12-04 21:04:30 +00:00
|
|
|
int ret = -1;
|
2009-02-27 16:18:50 +00:00
|
|
|
int paused = 0;
|
2008-11-14 08:42:47 +00:00
|
|
|
|
2008-12-04 21:06:41 +00:00
|
|
|
qemuDriverLock(driver);
|
2009-04-19 15:30:50 +00:00
|
|
|
vm = virDomainFindByUUID(&driver->domains, dom->uuid);
|
2008-11-14 08:42:47 +00:00
|
|
|
if (!vm) {
|
2009-04-19 15:30:50 +00:00
|
|
|
char uuidstr[VIR_UUID_STRING_BUFLEN];
|
|
|
|
virUUIDFormat(dom->uuid, uuidstr);
|
|
|
|
qemudReportError(dom->conn, dom, NULL, VIR_ERR_NO_DOMAIN,
|
|
|
|
_("no domain with matching uuid '%s'"), uuidstr);
|
2008-12-04 21:04:30 +00:00
|
|
|
goto cleanup;
|
2008-11-14 08:42:47 +00:00
|
|
|
}
|
|
|
|
|
2009-11-03 18:26:32 +00:00
|
|
|
if (qemuDomainObjBeginJobWithDriver(driver, vm) < 0)
|
|
|
|
goto cleanup;
|
|
|
|
|
Rename internal APis
Rename virDomainIsActive to virDomainObjIsActive, and
virInterfaceIsActive to virInterfaceObjIsActive and finally
virNetworkIsActive to virNetworkObjIsActive.
* src/conf/domain_conf.c, src/conf/domain_conf.h,
src/conf/interface_conf.h, src/conf/network_conf.c,
src/conf/network_conf.h, src/lxc/lxc_driver.c,
src/network/bridge_driver.c, src/opennebula/one_driver.c,
src/openvz/openvz_driver.c, src/qemu/qemu_driver.c,
src/test/test_driver.c, src/uml/uml_driver.c: Update for
renamed APIs.
2009-10-20 14:51:03 +00:00
|
|
|
if (!virDomainObjIsActive(vm)) {
|
2009-05-08 09:58:46 +00:00
|
|
|
qemudReportError (dom->conn, dom, NULL, VIR_ERR_OPERATION_INVALID,
|
2008-11-14 08:42:47 +00:00
|
|
|
"%s", _("domain is not running"));
|
2009-11-03 18:26:32 +00:00
|
|
|
goto endjob;
|
2008-11-14 08:42:47 +00:00
|
|
|
}
|
|
|
|
|
2009-12-11 08:42:19 +00:00
|
|
|
if (!(flags & VIR_MIGRATE_LIVE) && vm->state == VIR_DOMAIN_RUNNING) {
|
2009-10-09 20:13:06 +00:00
|
|
|
qemuDomainObjPrivatePtr priv = vm->privateData;
|
2008-11-17 16:43:00 +00:00
|
|
|
/* Pause domain for non-live migration */
|
2009-11-03 18:26:32 +00:00
|
|
|
qemuDomainObjEnterMonitorWithDriver(driver, vm);
|
2009-10-13 14:27:58 +00:00
|
|
|
if (qemuMonitorStopCPUs(priv->mon) < 0) {
|
2009-11-03 18:26:32 +00:00
|
|
|
qemuDomainObjExitMonitorWithDriver(driver, vm);
|
|
|
|
goto endjob;
|
2009-10-13 14:27:58 +00:00
|
|
|
}
|
2009-11-03 18:26:32 +00:00
|
|
|
qemuDomainObjExitMonitorWithDriver(driver, vm);
|
2009-02-27 16:18:50 +00:00
|
|
|
paused = 1;
|
2008-11-17 16:43:00 +00:00
|
|
|
|
2009-12-11 08:42:19 +00:00
|
|
|
vm->state = VIR_DOMAIN_PAUSED;
|
2008-12-04 21:09:20 +00:00
|
|
|
event = virDomainEventNewFromObj(vm,
|
|
|
|
VIR_DOMAIN_EVENT_SUSPENDED,
|
|
|
|
VIR_DOMAIN_EVENT_SUSPENDED_MIGRATED);
|
|
|
|
if (event)
|
|
|
|
qemuDomainEventQueue(driver, event);
|
|
|
|
event = NULL;
|
2008-11-17 16:43:00 +00:00
|
|
|
}
|
|
|
|
|
2009-11-05 17:06:31 +00:00
|
|
|
if ((flags & (VIR_MIGRATE_TUNNELLED | VIR_MIGRATE_PEER2PEER))) {
|
2009-11-03 18:26:32 +00:00
|
|
|
if (doPeer2PeerMigrate(dom, driver, vm, uri, flags, dname, resource) < 0)
|
2009-11-05 17:06:31 +00:00
|
|
|
/* doPeer2PeerMigrate already set the error, so just get out */
|
2009-11-03 18:26:32 +00:00
|
|
|
goto endjob;
|
2009-10-02 14:31:06 +00:00
|
|
|
} else {
|
2009-11-03 18:26:32 +00:00
|
|
|
if (doNativeMigrate(dom, driver, vm, uri, flags, dname, resource) < 0)
|
|
|
|
goto endjob;
|
2009-08-25 15:23:12 +00:00
|
|
|
}
|
|
|
|
|
2008-11-14 08:42:47 +00:00
|
|
|
/* Clean up the source domain. */
|
|
|
|
qemudShutdownVMDaemon (dom->conn, driver, vm);
|
2009-02-27 16:18:50 +00:00
|
|
|
paused = 0;
|
2008-12-04 21:09:20 +00:00
|
|
|
|
|
|
|
event = virDomainEventNewFromObj(vm,
|
|
|
|
VIR_DOMAIN_EVENT_STOPPED,
|
|
|
|
VIR_DOMAIN_EVENT_STOPPED_MIGRATED);
|
2009-07-31 10:10:22 +00:00
|
|
|
if (!vm->persistent || (flags & VIR_MIGRATE_UNDEFINE_SOURCE)) {
|
|
|
|
virDomainDeleteConfig(dom->conn, driver->configDir, driver->autostartDir, vm);
|
2009-12-08 14:42:43 +00:00
|
|
|
if (qemuDomainObjEndJob(vm) > 0)
|
|
|
|
virDomainRemoveInactive(&driver->domains, vm);
|
2008-12-04 21:06:41 +00:00
|
|
|
vm = NULL;
|
|
|
|
}
|
2008-12-04 21:04:30 +00:00
|
|
|
ret = 0;
|
2008-11-14 08:42:47 +00:00
|
|
|
|
2009-11-03 18:26:32 +00:00
|
|
|
endjob:
|
2009-02-27 16:18:50 +00:00
|
|
|
if (paused) {
|
2009-10-09 20:13:06 +00:00
|
|
|
qemuDomainObjPrivatePtr priv = vm->privateData;
|
2009-02-27 16:18:50 +00:00
|
|
|
/* we got here through some sort of failure; start the domain again */
|
2009-11-03 18:26:32 +00:00
|
|
|
qemuDomainObjEnterMonitorWithDriver(driver, vm);
|
2009-10-09 20:13:06 +00:00
|
|
|
if (qemuMonitorStartCPUs(priv->mon, dom->conn) < 0) {
|
2009-02-27 16:18:50 +00:00
|
|
|
/* Hm, we already know we are in error here. We don't want to
|
|
|
|
* overwrite the previous error, though, so we just throw something
|
|
|
|
* to the logs and hope for the best
|
|
|
|
*/
|
2010-01-19 13:17:20 +00:00
|
|
|
VIR_ERROR(_("Failed to resume guest %s after failure"),
|
2009-03-03 11:40:08 +00:00
|
|
|
vm->def->name);
|
2009-02-27 16:18:50 +00:00
|
|
|
}
|
2009-11-03 18:26:32 +00:00
|
|
|
qemuDomainObjExitMonitorWithDriver(driver, vm);
|
2009-02-27 16:18:50 +00:00
|
|
|
|
2009-12-11 08:42:19 +00:00
|
|
|
vm->state = VIR_DOMAIN_RUNNING;
|
2009-02-27 16:18:50 +00:00
|
|
|
event = virDomainEventNewFromObj(vm,
|
|
|
|
VIR_DOMAIN_EVENT_RESUMED,
|
|
|
|
VIR_DOMAIN_EVENT_RESUMED_MIGRATED);
|
|
|
|
}
|
2009-12-08 14:42:43 +00:00
|
|
|
if (vm &&
|
|
|
|
qemuDomainObjEndJob(vm) == 0)
|
|
|
|
vm = NULL;
|
2009-02-27 16:18:50 +00:00
|
|
|
|
2009-11-03 18:26:32 +00:00
|
|
|
cleanup:
|
2008-12-04 21:06:41 +00:00
|
|
|
if (vm)
|
|
|
|
virDomainObjUnlock(vm);
|
2008-12-04 21:09:20 +00:00
|
|
|
if (event)
|
|
|
|
qemuDomainEventQueue(driver, event);
|
2008-12-04 21:06:41 +00:00
|
|
|
qemuDriverUnlock(driver);
|
2008-12-04 21:04:30 +00:00
|
|
|
return ret;
|
2008-11-14 08:42:47 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
/* Finish is the third and final step, and it runs on the destination host. */
|
|
|
|
static virDomainPtr
|
|
|
|
qemudDomainMigrateFinish2 (virConnectPtr dconn,
|
|
|
|
const char *dname,
|
|
|
|
const char *cookie ATTRIBUTE_UNUSED,
|
|
|
|
int cookielen ATTRIBUTE_UNUSED,
|
|
|
|
const char *uri ATTRIBUTE_UNUSED,
|
2009-07-31 10:10:22 +00:00
|
|
|
unsigned long flags,
|
2008-11-14 08:42:47 +00:00
|
|
|
int retcode)
|
|
|
|
{
|
2008-12-04 21:04:30 +00:00
|
|
|
struct qemud_driver *driver = dconn->privateData;
|
|
|
|
virDomainObjPtr vm;
|
|
|
|
virDomainPtr dom = NULL;
|
2008-12-04 21:09:20 +00:00
|
|
|
virDomainEventPtr event = NULL;
|
2010-01-09 01:55:14 +00:00
|
|
|
virErrorPtr orig_err;
|
2009-07-31 10:10:22 +00:00
|
|
|
int newVM = 1;
|
2008-11-14 08:42:47 +00:00
|
|
|
|
2010-01-09 01:55:14 +00:00
|
|
|
/* Migration failed. Save the current error so nothing squashes it */
|
|
|
|
orig_err = virSaveLastError();
|
|
|
|
|
2008-12-04 21:06:41 +00:00
|
|
|
qemuDriverLock(driver);
|
2008-12-04 21:04:30 +00:00
|
|
|
vm = virDomainFindByName(&driver->domains, dname);
|
2008-11-14 08:42:47 +00:00
|
|
|
if (!vm) {
|
2009-04-19 15:30:50 +00:00
|
|
|
qemudReportError (dconn, NULL, NULL, VIR_ERR_NO_DOMAIN,
|
|
|
|
_("no domain with matching name '%s'"), dname);
|
2008-12-04 21:04:30 +00:00
|
|
|
goto cleanup;
|
2008-11-14 08:42:47 +00:00
|
|
|
}
|
|
|
|
|
2009-11-03 18:26:32 +00:00
|
|
|
if (qemuDomainObjBeginJobWithDriver(driver, vm) < 0)
|
|
|
|
goto cleanup;
|
|
|
|
|
2008-11-14 08:42:47 +00:00
|
|
|
/* Did the migration go as planned? If yes, return the domain
|
|
|
|
* object, but if no, clean up the empty qemu process.
|
|
|
|
*/
|
|
|
|
if (retcode == 0) {
|
2009-07-31 10:10:22 +00:00
|
|
|
if (flags & VIR_MIGRATE_PERSIST_DEST) {
|
|
|
|
if (vm->persistent)
|
|
|
|
newVM = 0;
|
|
|
|
vm->persistent = 1;
|
|
|
|
|
|
|
|
if (virDomainSaveConfig(dconn, driver->configDir, vm->def) < 0) {
|
|
|
|
/* Hmpf. Migration was successful, but making it persistent
|
|
|
|
* was not. If we report successful, then when this domain
|
|
|
|
* shuts down, management tools are in for a surprise. On the
|
|
|
|
* other hand, if we report failure, then the management tools
|
|
|
|
* might try to restart the domain on the source side, even
|
|
|
|
* though the domain is actually running on the destination.
|
|
|
|
* Return a NULL dom pointer, and hope that this is a rare
|
|
|
|
* situation and management tools are smart.
|
|
|
|
*/
|
|
|
|
vm = NULL;
|
2009-11-03 18:26:32 +00:00
|
|
|
goto endjob;
|
2009-07-31 10:10:22 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
event = virDomainEventNewFromObj(vm,
|
|
|
|
VIR_DOMAIN_EVENT_DEFINED,
|
|
|
|
newVM ?
|
|
|
|
VIR_DOMAIN_EVENT_DEFINED_ADDED :
|
|
|
|
VIR_DOMAIN_EVENT_DEFINED_UPDATED);
|
|
|
|
if (event)
|
|
|
|
qemuDomainEventQueue(driver, event);
|
2009-12-14 14:55:19 +00:00
|
|
|
event = NULL;
|
2009-07-31 10:10:22 +00:00
|
|
|
|
|
|
|
}
|
2009-10-09 20:13:06 +00:00
|
|
|
qemuDomainObjPrivatePtr priv = vm->privateData;
|
2008-11-14 08:42:47 +00:00
|
|
|
dom = virGetDomain (dconn, vm->def->name, vm->def->uuid);
|
2009-08-05 11:42:07 +00:00
|
|
|
|
2009-12-11 09:00:44 +00:00
|
|
|
if (!(flags & VIR_MIGRATE_PAUSED)) {
|
|
|
|
/* run 'cont' on the destination, which allows migration on qemu
|
|
|
|
* >= 0.10.6 to work properly. This isn't strictly necessary on
|
|
|
|
* older qemu's, but it also doesn't hurt anything there
|
|
|
|
*/
|
|
|
|
qemuDomainObjEnterMonitorWithDriver(driver, vm);
|
|
|
|
if (qemuMonitorStartCPUs(priv->mon, dconn) < 0) {
|
|
|
|
if (virGetLastError() == NULL)
|
|
|
|
qemudReportError(dconn, NULL, NULL, VIR_ERR_INTERNAL_ERROR,
|
|
|
|
"%s", _("resume operation failed"));
|
|
|
|
qemuDomainObjExitMonitorWithDriver(driver, vm);
|
|
|
|
goto endjob;
|
|
|
|
}
|
2009-11-03 18:26:32 +00:00
|
|
|
qemuDomainObjExitMonitorWithDriver(driver, vm);
|
2009-12-11 09:00:44 +00:00
|
|
|
|
|
|
|
vm->state = VIR_DOMAIN_RUNNING;
|
2009-08-05 11:42:07 +00:00
|
|
|
}
|
|
|
|
|
2008-12-04 21:09:20 +00:00
|
|
|
event = virDomainEventNewFromObj(vm,
|
|
|
|
VIR_DOMAIN_EVENT_RESUMED,
|
|
|
|
VIR_DOMAIN_EVENT_RESUMED_MIGRATED);
|
2009-12-11 09:00:44 +00:00
|
|
|
if (vm->state == VIR_DOMAIN_PAUSED) {
|
|
|
|
qemuDomainEventQueue(driver, event);
|
|
|
|
event = virDomainEventNewFromObj(vm,
|
|
|
|
VIR_DOMAIN_EVENT_SUSPENDED,
|
|
|
|
VIR_DOMAIN_EVENT_SUSPENDED_PAUSED);
|
|
|
|
}
|
2009-11-26 17:57:00 +00:00
|
|
|
virDomainSaveStatus(dconn, driver->caps, driver->stateDir, vm);
|
2008-11-14 08:42:47 +00:00
|
|
|
} else {
|
|
|
|
qemudShutdownVMDaemon (dconn, driver, vm);
|
2008-12-04 21:09:20 +00:00
|
|
|
event = virDomainEventNewFromObj(vm,
|
|
|
|
VIR_DOMAIN_EVENT_STOPPED,
|
|
|
|
VIR_DOMAIN_EVENT_STOPPED_FAILED);
|
2008-12-04 21:06:41 +00:00
|
|
|
if (!vm->persistent) {
|
2009-12-08 14:42:43 +00:00
|
|
|
if (qemuDomainObjEndJob(vm) > 0)
|
|
|
|
virDomainRemoveInactive(&driver->domains, vm);
|
2008-12-04 21:06:41 +00:00
|
|
|
vm = NULL;
|
|
|
|
}
|
2008-11-14 08:42:47 +00:00
|
|
|
}
|
2008-12-04 21:04:30 +00:00
|
|
|
|
2009-11-03 18:26:32 +00:00
|
|
|
endjob:
|
2009-12-08 14:42:43 +00:00
|
|
|
if (vm &&
|
|
|
|
qemuDomainObjEndJob(vm) == 0)
|
|
|
|
vm = NULL;
|
2009-11-03 18:26:32 +00:00
|
|
|
|
2008-12-04 21:04:30 +00:00
|
|
|
cleanup:
|
2010-01-09 01:55:14 +00:00
|
|
|
if (orig_err) {
|
|
|
|
virSetError(orig_err);
|
|
|
|
virFreeError(orig_err);
|
|
|
|
}
|
2008-12-04 21:06:41 +00:00
|
|
|
if (vm)
|
|
|
|
virDomainObjUnlock(vm);
|
2008-12-04 21:09:20 +00:00
|
|
|
if (event)
|
|
|
|
qemuDomainEventQueue(driver, event);
|
2008-12-04 21:06:41 +00:00
|
|
|
qemuDriverUnlock(driver);
|
2008-12-04 21:04:30 +00:00
|
|
|
return dom;
|
2008-11-14 08:42:47 +00:00
|
|
|
}
|
|
|
|
|
2009-03-02 16:32:52 +00:00
|
|
|
static int
|
|
|
|
qemudNodeDeviceGetPciInfo (virNodeDevicePtr dev,
|
|
|
|
unsigned *domain,
|
|
|
|
unsigned *bus,
|
|
|
|
unsigned *slot,
|
|
|
|
unsigned *function)
|
|
|
|
{
|
|
|
|
virNodeDeviceDefPtr def = NULL;
|
|
|
|
virNodeDevCapsDefPtr cap;
|
|
|
|
char *xml = NULL;
|
|
|
|
int ret = -1;
|
|
|
|
|
|
|
|
xml = virNodeDeviceGetXMLDesc(dev, 0);
|
|
|
|
if (!xml)
|
|
|
|
goto out;
|
|
|
|
|
2009-06-02 15:12:53 +00:00
|
|
|
def = virNodeDeviceDefParseString(dev->conn, xml, EXISTING_DEVICE);
|
2009-03-02 16:32:52 +00:00
|
|
|
if (!def)
|
|
|
|
goto out;
|
|
|
|
|
|
|
|
cap = def->caps;
|
|
|
|
while (cap) {
|
|
|
|
if (cap->type == VIR_NODE_DEV_CAP_PCI_DEV) {
|
|
|
|
*domain = cap->data.pci_dev.domain;
|
|
|
|
*bus = cap->data.pci_dev.bus;
|
|
|
|
*slot = cap->data.pci_dev.slot;
|
|
|
|
*function = cap->data.pci_dev.function;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
|
|
|
cap = cap->next;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (!cap) {
|
|
|
|
qemudReportError(dev->conn, NULL, NULL, VIR_ERR_INVALID_ARG,
|
|
|
|
_("device %s is not a PCI device"), dev->name);
|
|
|
|
goto out;
|
|
|
|
}
|
|
|
|
|
|
|
|
ret = 0;
|
|
|
|
out:
|
|
|
|
virNodeDeviceDefFree(def);
|
|
|
|
VIR_FREE(xml);
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
|
|
|
static int
|
|
|
|
qemudNodeDeviceDettach (virNodeDevicePtr dev)
|
|
|
|
{
|
|
|
|
pciDevice *pci;
|
|
|
|
unsigned domain, bus, slot, function;
|
|
|
|
int ret = -1;
|
|
|
|
|
|
|
|
if (qemudNodeDeviceGetPciInfo(dev, &domain, &bus, &slot, &function) < 0)
|
|
|
|
return -1;
|
|
|
|
|
|
|
|
pci = pciGetDevice(dev->conn, domain, bus, slot, function);
|
|
|
|
if (!pci)
|
|
|
|
return -1;
|
|
|
|
|
|
|
|
if (pciDettachDevice(dev->conn, pci) < 0)
|
|
|
|
goto out;
|
|
|
|
|
|
|
|
ret = 0;
|
|
|
|
out:
|
|
|
|
pciFreeDevice(dev->conn, pci);
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
|
|
|
static int
|
|
|
|
qemudNodeDeviceReAttach (virNodeDevicePtr dev)
|
|
|
|
{
|
|
|
|
pciDevice *pci;
|
|
|
|
unsigned domain, bus, slot, function;
|
|
|
|
int ret = -1;
|
|
|
|
|
|
|
|
if (qemudNodeDeviceGetPciInfo(dev, &domain, &bus, &slot, &function) < 0)
|
|
|
|
return -1;
|
|
|
|
|
|
|
|
pci = pciGetDevice(dev->conn, domain, bus, slot, function);
|
|
|
|
if (!pci)
|
|
|
|
return -1;
|
|
|
|
|
|
|
|
if (pciReAttachDevice(dev->conn, pci) < 0)
|
|
|
|
goto out;
|
|
|
|
|
|
|
|
ret = 0;
|
|
|
|
out:
|
|
|
|
pciFreeDevice(dev->conn, pci);
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
|
|
|
static int
|
|
|
|
qemudNodeDeviceReset (virNodeDevicePtr dev)
|
|
|
|
{
|
2009-08-17 14:05:23 +00:00
|
|
|
struct qemud_driver *driver = dev->conn->privateData;
|
2009-03-02 16:32:52 +00:00
|
|
|
pciDevice *pci;
|
|
|
|
unsigned domain, bus, slot, function;
|
|
|
|
int ret = -1;
|
|
|
|
|
|
|
|
if (qemudNodeDeviceGetPciInfo(dev, &domain, &bus, &slot, &function) < 0)
|
|
|
|
return -1;
|
|
|
|
|
|
|
|
pci = pciGetDevice(dev->conn, domain, bus, slot, function);
|
|
|
|
if (!pci)
|
|
|
|
return -1;
|
|
|
|
|
2009-08-17 14:05:23 +00:00
|
|
|
qemuDriverLock(driver);
|
|
|
|
|
|
|
|
if (pciResetDevice(dev->conn, pci, driver->activePciHostdevs) < 0)
|
2009-03-02 16:32:52 +00:00
|
|
|
goto out;
|
|
|
|
|
|
|
|
ret = 0;
|
|
|
|
out:
|
2009-08-17 14:05:23 +00:00
|
|
|
qemuDriverUnlock(driver);
|
2009-03-02 16:32:52 +00:00
|
|
|
pciFreeDevice(dev->conn, pci);
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
2009-12-18 15:24:14 +00:00
|
|
|
static int
|
|
|
|
qemuCPUCompare(virConnectPtr conn,
|
|
|
|
const char *xmlDesc,
|
|
|
|
unsigned int flags ATTRIBUTE_UNUSED)
|
|
|
|
{
|
|
|
|
struct qemud_driver *driver = conn->privateData;
|
|
|
|
int ret = VIR_CPU_COMPARE_ERROR;
|
|
|
|
|
|
|
|
qemuDriverLock(driver);
|
|
|
|
|
|
|
|
if (!driver->caps || !driver->caps->host.cpu) {
|
|
|
|
qemudReportError(conn, NULL, NULL, VIR_ERR_NO_SUPPORT,
|
|
|
|
"%s", _("cannot get host CPU capabilities"));
|
|
|
|
}
|
|
|
|
else
|
|
|
|
ret = cpuCompareXML(conn, driver->caps->host.cpu, xmlDesc);
|
|
|
|
|
|
|
|
qemuDriverUnlock(driver);
|
|
|
|
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
2007-06-26 22:39:53 +00:00
|
|
|
static virDriver qemuDriver = {
|
|
|
|
VIR_DRV_QEMU,
|
|
|
|
"QEMU",
|
|
|
|
qemudOpen, /* open */
|
|
|
|
qemudClose, /* close */
|
2008-11-14 08:42:47 +00:00
|
|
|
qemudSupportsFeature, /* supports_feature */
|
2007-06-26 22:39:53 +00:00
|
|
|
qemudGetType, /* type */
|
|
|
|
qemudGetVersion, /* version */
|
2009-11-12 15:53:26 +00:00
|
|
|
NULL, /* libvirtVersion (impl. in libvirt.c) */
|
2009-10-23 17:01:22 +00:00
|
|
|
virGetHostname, /* getHostname */
|
2007-06-26 22:39:53 +00:00
|
|
|
qemudGetMaxVCPUs, /* getMaxVcpus */
|
2009-06-03 13:28:02 +00:00
|
|
|
nodeGetInfo, /* nodeGetInfo */
|
2007-06-26 22:39:53 +00:00
|
|
|
qemudGetCapabilities, /* getCapabilities */
|
|
|
|
qemudListDomains, /* listDomains */
|
|
|
|
qemudNumDomains, /* numOfDomains */
|
2008-10-10 09:32:27 +00:00
|
|
|
qemudDomainCreate, /* domainCreateXML */
|
2007-06-26 22:39:53 +00:00
|
|
|
qemudDomainLookupByID, /* domainLookupByID */
|
|
|
|
qemudDomainLookupByUUID, /* domainLookupByUUID */
|
|
|
|
qemudDomainLookupByName, /* domainLookupByName */
|
|
|
|
qemudDomainSuspend, /* domainSuspend */
|
|
|
|
qemudDomainResume, /* domainResume */
|
2008-01-09 16:05:21 +00:00
|
|
|
qemudDomainShutdown, /* domainShutdown */
|
2007-06-26 22:39:53 +00:00
|
|
|
NULL, /* domainReboot */
|
|
|
|
qemudDomainDestroy, /* domainDestroy */
|
|
|
|
qemudDomainGetOSType, /* domainGetOSType */
|
2008-03-19 14:32:50 +00:00
|
|
|
qemudDomainGetMaxMemory, /* domainGetMaxMemory */
|
|
|
|
qemudDomainSetMaxMemory, /* domainSetMaxMemory */
|
|
|
|
qemudDomainSetMemory, /* domainSetMemory */
|
2007-06-26 22:39:53 +00:00
|
|
|
qemudDomainGetInfo, /* domainGetInfo */
|
|
|
|
qemudDomainSave, /* domainSave */
|
|
|
|
qemudDomainRestore, /* domainRestore */
|
2009-07-16 14:50:23 +00:00
|
|
|
qemudDomainCoreDump, /* domainCoreDump */
|
2008-05-07 16:16:44 +00:00
|
|
|
qemudDomainSetVcpus, /* domainSetVcpus */
|
2008-05-22 16:20:31 +00:00
|
|
|
qemudDomainPinVcpu, /* domainPinVcpu */
|
|
|
|
qemudDomainGetVcpus, /* domainGetVcpus */
|
2008-05-07 16:16:44 +00:00
|
|
|
qemudDomainGetMaxVcpus, /* domainGetMaxVcpus */
|
2009-03-03 12:03:44 +00:00
|
|
|
qemudDomainGetSecurityLabel, /* domainGetSecurityLabel */
|
|
|
|
qemudNodeGetSecurityModel, /* nodeGetSecurityModel */
|
2007-06-26 22:39:53 +00:00
|
|
|
qemudDomainDumpXML, /* domainDumpXML */
|
2009-05-21 14:16:55 +00:00
|
|
|
qemuDomainXMLFromNative, /* domainXmlFromNative */
|
2009-05-21 14:14:01 +00:00
|
|
|
qemuDomainXMLToNative, /* domainXMLToNative */
|
2009-03-31 15:47:16 +00:00
|
|
|
qemudListDefinedDomains, /* listDefinedDomains */
|
|
|
|
qemudNumDefinedDomains, /* numOfDefinedDomains */
|
2007-06-26 22:39:53 +00:00
|
|
|
qemudDomainStart, /* domainCreate */
|
|
|
|
qemudDomainDefine, /* domainDefineXML */
|
|
|
|
qemudDomainUndefine, /* domainUndefine */
|
2007-10-27 01:21:09 +00:00
|
|
|
qemudDomainAttachDevice, /* domainAttachDevice */
|
2008-10-29 14:32:40 +00:00
|
|
|
qemudDomainDetachDevice, /* domainDetachDevice */
|
2007-06-26 22:39:53 +00:00
|
|
|
qemudDomainGetAutostart, /* domainGetAutostart */
|
|
|
|
qemudDomainSetAutostart, /* domainSetAutostart */
|
2009-07-09 13:11:21 +00:00
|
|
|
qemuGetSchedulerType, /* domainGetSchedulerType */
|
|
|
|
qemuGetSchedulerParameters, /* domainGetSchedulerParameters */
|
|
|
|
qemuSetSchedulerParameters, /* domainSetSchedulerParameters */
|
2008-11-14 08:42:47 +00:00
|
|
|
NULL, /* domainMigratePrepare (v1) */
|
|
|
|
qemudDomainMigratePerform, /* domainMigratePerform */
|
2007-08-21 09:31:12 +00:00
|
|
|
NULL, /* domainMigrateFinish */
|
2008-02-26 18:41:43 +00:00
|
|
|
qemudDomainBlockStats, /* domainBlockStats */
|
2007-11-15 17:45:44 +00:00
|
|
|
qemudDomainInterfaceStats, /* domainInterfaceStats */
|
2009-12-20 12:36:28 +00:00
|
|
|
qemudDomainMemoryStats, /* domainMemoryStats */
|
2008-06-05 21:12:26 +00:00
|
|
|
qemudDomainBlockPeek, /* domainBlockPeek */
|
2008-06-10 10:43:28 +00:00
|
|
|
qemudDomainMemoryPeek, /* domainMemoryPeek */
|
2009-06-03 13:28:02 +00:00
|
|
|
nodeGetCellsFreeMemory, /* nodeGetCellsFreeMemory */
|
|
|
|
nodeGetFreeMemory, /* getFreeMemory */
|
2008-10-23 13:18:18 +00:00
|
|
|
qemudDomainEventRegister, /* domainEventRegister */
|
|
|
|
qemudDomainEventDeregister, /* domainEventDeregister */
|
2008-11-14 08:42:47 +00:00
|
|
|
qemudDomainMigratePrepare2, /* domainMigratePrepare2 */
|
|
|
|
qemudDomainMigrateFinish2, /* domainMigrateFinish2 */
|
2009-03-02 16:32:52 +00:00
|
|
|
qemudNodeDeviceDettach, /* nodeDeviceDettach */
|
|
|
|
qemudNodeDeviceReAttach, /* nodeDeviceReAttach */
|
|
|
|
qemudNodeDeviceReset, /* nodeDeviceReset */
|
2009-09-30 10:51:54 +00:00
|
|
|
qemudDomainMigratePrepareTunnel, /* domainMigratePrepareTunnel */
|
Implmentation of new APIs to checking state/persistence of objects
This implements the virConnectIsSecure, virConnectIsEncrypted,
virDomainIsPersistent, virDomainIsActive, virNetworkIsActive,
virNetworkIsPersistent, virStoragePoolIsActive,
virStoragePoolIsPersistent, virInterfaceIsActive APIs in
(nearly) all drivers. Exceptions are:
phyp: missing domainIsActive/Persistent
esx: missing domainIsPersistent
opennebula: missing domainIsActive/Persistent
* src/remote/remote_protocol.x: Define remote wire ABI for newly
added APIs.
* daemon/remote_dispatch*.h: Re-generated from remote_protocol.x
* src/esx/esx_driver.c, src/lxc/lxc_driver.c, src/network/bridge_driver.c,
src/opennebula/one_driver.c, src/openvz/openvz_conf.c,
src/openvz/openvz_driver.c, src/phyp/phyp_driver.c,
src/remote/remote_driver.c, src/storage/storage_driver.c,
src/test/test_driver.c, src/uml/uml_driver.c, src/vbox/vbox_tmpl.c,
src/xen/xen_driver.c, src/xen/xen_driver.h, src/xen/xen_inotify.c,
src/xen/xen_inotify.h: Implement all the new APIs where possible
2009-10-20 14:12:03 +00:00
|
|
|
qemuIsEncrypted,
|
|
|
|
qemuIsSecure,
|
|
|
|
qemuDomainIsActive,
|
|
|
|
qemuDomainIsPersistent,
|
2009-12-18 15:24:14 +00:00
|
|
|
qemuCPUCompare, /* cpuCompare */
|
2007-06-26 22:39:53 +00:00
|
|
|
};
|
|
|
|
|
|
|
|
|
2007-06-26 22:56:14 +00:00
|
|
|
static virStateDriver qemuStateDriver = {
|
Fix return value in virStateInitialize impl for LXC
The LXC driver was mistakenly returning -1 for lxcStartup()
in scenarios that are not an error. This caused the libvirtd
to quit for unprivileged users. This fixes the return code
of LXC driver, and also adds a "name" field to the virStateDriver
struct and logging to make it easier to find these problems
in the future
* src/driver.h: Add a 'name' field to state driver to allow
easy identification during failures
* src/libvirt.c: Log name of failed driver for virStateInit
failures
* src/lxc/lxc_driver.c: Don't return a failure code for
lxcStartup() if LXC is not available on this host, simply
disable the driver.
* src/network/bridge_driver.c, src/node_device/node_device_devkit.c,
src/node_device/node_device_hal.c, src/opennebula/one_driver.c,
src/qemu/qemu_driver.c, src/remote/remote_driver.c,
src/secret/secret_driver.c, src/storage/storage_driver.c,
src/uml/uml_driver.c, src/xen/xen_driver.c: Fill in name
field in virStateDriver struct
2009-11-02 23:18:19 +00:00
|
|
|
.name = "QEMU",
|
2008-10-06 15:40:37 +00:00
|
|
|
.initialize = qemudStartup,
|
|
|
|
.cleanup = qemudShutdown,
|
|
|
|
.reload = qemudReload,
|
|
|
|
.active = qemudActive,
|
2007-06-26 22:56:14 +00:00
|
|
|
};
|
2007-06-26 22:39:53 +00:00
|
|
|
|
2008-11-21 12:16:08 +00:00
|
|
|
int qemuRegister(void) {
|
2007-06-26 23:48:46 +00:00
|
|
|
virRegisterDriver(&qemuDriver);
|
|
|
|
virRegisterStateDriver(&qemuStateDriver);
|
|
|
|
return 0;
|
|
|
|
}
|