2007-02-14 01:40:09 +00:00
|
|
|
/*
|
|
|
|
* driver.c: core driver methods for managing qemu guests
|
|
|
|
*
|
Eliminate all uses of virBufferAdd with string literals.
* Makefile.maint (sc_prohibit_virBufferAdd_with_string_literal):
New rule.
* src/buf.h (virBufferAddLit): Define.
* src/conf.c (virConfSaveValue): Use virBufferAddLit, in place
of virBufferAdd everywhere possible.
(virConfSaveEntry): Likewise.
* src/qemu_conf.c (qemudGenerateXML, qemudGenerateNetworkXML): Likewise.
* src/qemu_driver.c (qemudGetFeatures, qemudGetCapabilities): Likewise.
* src/test.c (testDomainDumpXML, testNetworkDumpXML): Likewise.
* src/xen_internal.c (xenHypervisorMakeCapabilitiesXML): Likewise.
* src/xend_internal.c (xend_parse_sexp_desc_os): Likewise.
(xend_parse_sexp_desc, sexpr_to_xend_topology_xml): Likewise.
* src/xm_internal.c (xenXMDomainFormatXML, xenXMDomainPinVcpu): Likewise.
* src/xml.c (virSaveCpuSet, virParseXenCpuTopology): Likewise.
(virDomainParseXMLGraphicsDescImage): Likewise.
(virDomainParseXMLGraphicsDescVFB, virDomainParseXMLOSDescHVM): Likewise.
(virDomainParseXMLOSDescPV, virDomainParseXMLDiskDesc): Likewise.
(virDomainParseXMLIfDesc, virDomainParseXMLDesc): Likewise.
2008-02-05 14:22:28 +00:00
|
|
|
* Copyright (C) 2006, 2007, 2008 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
|
|
|
|
|
|
|
#ifdef WITH_QEMU
|
2007-02-14 15:42:55 +00:00
|
|
|
|
2007-02-14 01:40:09 +00:00
|
|
|
#include <sys/types.h>
|
|
|
|
#include <sys/poll.h>
|
|
|
|
#include <dirent.h>
|
|
|
|
#include <limits.h>
|
|
|
|
#include <string.h>
|
|
|
|
#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>
|
2007-02-14 01:40:09 +00:00
|
|
|
|
2008-05-22 15:29:50 +00:00
|
|
|
#if HAVE_NUMACTL
|
|
|
|
#include <numa.h>
|
|
|
|
#endif
|
|
|
|
|
2008-05-22 16:20:31 +00:00
|
|
|
#if HAVE_SCHED_H
|
|
|
|
#include <sched.h>
|
|
|
|
#endif
|
|
|
|
|
2008-07-11 19:34:11 +00:00
|
|
|
#include "qemu_driver.h"
|
|
|
|
#include "qemu_conf.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"
|
2007-06-26 20:41:25 +00:00
|
|
|
|
2008-06-10 10:43:28 +00:00
|
|
|
/* For storing short-lived temporary files. */
|
|
|
|
#define TEMPDIR LOCAL_STATE_DIR "/cache/libvirt"
|
|
|
|
|
2008-06-26 09:37:51 +00:00
|
|
|
#ifdef WITH_LIBVIRTD
|
2007-06-29 13:23:13 +00:00
|
|
|
static int qemudShutdown(void);
|
2008-06-26 09:37:51 +00:00
|
|
|
#endif
|
2007-06-29 13:23:13 +00:00
|
|
|
|
2008-02-26 18:41:43 +00:00
|
|
|
/* qemudDebug statements should be changed to use this macro instead. */
|
|
|
|
#define DEBUG(fmt,...) VIR_DEBUG(__FILE__, fmt, __VA_ARGS__)
|
|
|
|
#define DEBUG0(msg) VIR_DEBUG(__FILE__, "%s", msg)
|
2007-06-29 13:23:13 +00:00
|
|
|
|
2007-06-26 23:48:46 +00:00
|
|
|
#define qemudLog(level, msg...) fprintf(stderr, msg)
|
|
|
|
|
2007-06-26 20:41:25 +00:00
|
|
|
static int qemudSetCloseExec(int fd) {
|
|
|
|
int flags;
|
|
|
|
if ((flags = fcntl(fd, F_GETFD)) < 0)
|
|
|
|
goto error;
|
|
|
|
flags |= FD_CLOEXEC;
|
|
|
|
if ((fcntl(fd, F_SETFD, flags)) < 0)
|
|
|
|
goto error;
|
|
|
|
return 0;
|
|
|
|
error:
|
2008-02-22 16:26:13 +00:00
|
|
|
qemudLog(QEMUD_ERR,
|
2008-08-01 11:24:04 +00:00
|
|
|
"%s", _("Failed to set close-on-exec file descriptor flag\n"));
|
2007-06-26 20:41:25 +00:00
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
static int qemudSetNonBlock(int fd) {
|
|
|
|
int flags;
|
|
|
|
if ((flags = fcntl(fd, F_GETFL)) < 0)
|
|
|
|
goto error;
|
|
|
|
flags |= O_NONBLOCK;
|
|
|
|
if ((fcntl(fd, F_SETFL, flags)) < 0)
|
|
|
|
goto error;
|
|
|
|
return 0;
|
|
|
|
error:
|
2008-02-22 16:26:13 +00:00
|
|
|
qemudLog(QEMUD_ERR,
|
2008-08-01 11:24:04 +00:00
|
|
|
"%s", _("Failed to set non-blocking file descriptor flag\n"));
|
2007-06-26 20:41:25 +00:00
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
2007-06-26 22:13:21 +00:00
|
|
|
static void qemudDispatchVMEvent(int fd, int events, void *opaque);
|
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,
|
|
|
|
const char *migrateFrom);
|
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
|
|
|
|
2007-07-12 15:09:01 +00:00
|
|
|
static int qemudStartNetworkDaemon(virConnectPtr conn,
|
|
|
|
struct qemud_driver *driver,
|
2008-07-11 17:33:45 +00:00
|
|
|
virNetworkObjPtr network);
|
2007-06-26 22:42:47 +00:00
|
|
|
|
2007-07-12 15:09:01 +00:00
|
|
|
static int qemudShutdownNetworkDaemon(virConnectPtr conn,
|
|
|
|
struct qemud_driver *driver,
|
2008-07-11 17:33:45 +00:00
|
|
|
virNetworkObjPtr network);
|
2007-06-26 22:42:47 +00:00
|
|
|
|
2008-05-07 16:16:44 +00:00
|
|
|
static int qemudDomainGetMaxVcpus(virDomainPtr dom);
|
2008-05-22 16:20:31 +00:00
|
|
|
static int qemudMonitorCommand (const struct qemud_driver *driver,
|
2008-07-11 19:34:11 +00:00
|
|
|
const virDomainObjPtr vm,
|
2008-05-22 16:20:31 +00:00
|
|
|
const char *cmd,
|
|
|
|
char **reply);
|
2008-05-07 16:16:44 +00:00
|
|
|
|
2008-01-14 14:05:25 +00:00
|
|
|
static struct qemud_driver *qemu_driver = NULL;
|
2007-06-26 22:13:21 +00:00
|
|
|
|
|
|
|
|
|
|
|
static
|
|
|
|
void qemudAutostartConfigs(struct qemud_driver *driver) {
|
2008-07-11 17:33:45 +00:00
|
|
|
virNetworkObjPtr network;
|
2008-07-11 19:34:11 +00:00
|
|
|
virDomainObjPtr vm;
|
2007-06-26 22:13:21 +00:00
|
|
|
|
|
|
|
network = driver->networks;
|
|
|
|
while (network != NULL) {
|
2008-07-11 17:33:45 +00:00
|
|
|
virNetworkObjPtr next = network->next;
|
2007-06-26 22:13:21 +00:00
|
|
|
|
|
|
|
if (network->autostart &&
|
2008-07-11 17:33:45 +00:00
|
|
|
!virNetworkIsActive(network) &&
|
2007-07-12 15:09:01 +00:00
|
|
|
qemudStartNetworkDaemon(NULL, driver, network) < 0) {
|
2007-06-26 22:13:21 +00:00
|
|
|
virErrorPtr err = virGetLastError();
|
2008-08-01 11:24:04 +00:00
|
|
|
qemudLog(QEMUD_ERR, _("Failed to autostart network '%s': %s\n"),
|
2007-06-26 22:13:21 +00:00
|
|
|
network->def->name, err->message);
|
|
|
|
}
|
|
|
|
|
|
|
|
network = next;
|
|
|
|
}
|
|
|
|
|
2008-07-11 19:34:11 +00:00
|
|
|
vm = driver->domains;
|
2007-06-26 22:13:21 +00:00
|
|
|
while (vm != NULL) {
|
2008-07-11 19:34:11 +00:00
|
|
|
virDomainObjPtr next = vm->next;
|
2007-06-26 22:13:21 +00:00
|
|
|
|
|
|
|
if (vm->autostart &&
|
2008-07-11 19:34:11 +00:00
|
|
|
!virDomainIsActive(vm) &&
|
|
|
|
qemudStartVMDaemon(NULL, driver, vm, NULL) < 0) {
|
2007-06-26 22:13:21 +00:00
|
|
|
virErrorPtr err = virGetLastError();
|
2008-08-01 11:24:04 +00:00
|
|
|
qemudLog(QEMUD_ERR, _("Failed to autostart VM '%s': %s\n"),
|
2007-06-26 22:13:21 +00:00
|
|
|
vm->def->name, err->message);
|
|
|
|
}
|
|
|
|
|
|
|
|
vm = next;
|
|
|
|
}
|
2007-06-26 20:45:21 +00:00
|
|
|
}
|
|
|
|
|
2008-06-26 09:37:51 +00:00
|
|
|
#ifdef WITH_LIBVIRTD
|
2007-06-29 13:23:13 +00:00
|
|
|
/**
|
|
|
|
* qemudStartup:
|
|
|
|
*
|
|
|
|
* Initialization function for the QEmu daemon
|
|
|
|
*/
|
|
|
|
static int
|
|
|
|
qemudStartup(void) {
|
2007-06-26 22:13:21 +00:00
|
|
|
uid_t uid = geteuid();
|
|
|
|
struct passwd *pw;
|
|
|
|
char *base = NULL;
|
2007-10-12 16:05:44 +00:00
|
|
|
char driverConf[PATH_MAX];
|
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;
|
|
|
|
|
|
|
|
/* Don't have a dom0 so start from 1 */
|
|
|
|
qemu_driver->nextvmid = 1;
|
|
|
|
|
|
|
|
if (!uid) {
|
2008-07-11 19:34:11 +00:00
|
|
|
if (asprintf(&qemu_driver->logDir,
|
|
|
|
"%s/log/libvirt/qemu", LOCAL_STATE_DIR) == -1)
|
|
|
|
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;
|
|
|
|
} else {
|
|
|
|
if (!(pw = getpwuid(uid))) {
|
2008-08-01 11:24:04 +00:00
|
|
|
qemudLog(QEMUD_ERR, _("Failed to find user record for uid '%d': %s\n"),
|
2007-06-26 22:13:21 +00:00
|
|
|
uid, strerror(errno));
|
|
|
|
goto out_of_memory;
|
|
|
|
}
|
|
|
|
|
2008-07-11 19:34:11 +00:00
|
|
|
if (asprintf(&qemu_driver->logDir,
|
|
|
|
"%s/.libvirt/qemu/log", pw->pw_dir) == -1)
|
|
|
|
goto out_of_memory;
|
2007-06-26 22:13:21 +00:00
|
|
|
|
2007-10-12 16:05:44 +00:00
|
|
|
if (asprintf (&base, "%s/.libvirt", pw->pw_dir) == -1) {
|
2008-02-22 16:26:13 +00:00
|
|
|
qemudLog (QEMUD_ERR,
|
2008-08-01 11:24:04 +00:00
|
|
|
"%s", _("out of memory in asprintf\n"));
|
2007-06-26 22:13:21 +00:00
|
|
|
goto out_of_memory;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
/* 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
|
|
|
|
2007-10-12 16:05:44 +00:00
|
|
|
if (asprintf (&qemu_driver->configDir, "%s/qemu", base) == -1)
|
2007-06-26 22:13:21 +00:00
|
|
|
goto out_of_memory;
|
|
|
|
|
2007-10-12 16:05:44 +00:00
|
|
|
if (asprintf (&qemu_driver->autostartDir, "%s/qemu/autostart", base) == -1)
|
2007-06-26 22:13:21 +00:00
|
|
|
goto out_of_memory;
|
|
|
|
|
2007-10-12 16:05:44 +00:00
|
|
|
if (asprintf (&qemu_driver->networkConfigDir, "%s/qemu/networks", base) == -1)
|
|
|
|
goto out_of_memory;
|
|
|
|
|
|
|
|
if (asprintf (&qemu_driver->networkAutostartDir, "%s/qemu/networks/autostart",
|
2007-06-26 22:13:21 +00:00
|
|
|
base) == -1)
|
|
|
|
goto out_of_memory;
|
|
|
|
|
2008-05-29 19:20:22 +00:00
|
|
|
VIR_FREE(base);
|
2008-02-27 04:35:08 +00:00
|
|
|
|
|
|
|
if ((qemu_driver->caps = qemudCapsInit()) == NULL)
|
|
|
|
goto out_of_memory;
|
2007-10-12 16:05:44 +00:00
|
|
|
|
|
|
|
if (qemudLoadDriverConfig(qemu_driver, driverConf) < 0) {
|
2007-06-26 22:13:21 +00:00
|
|
|
qemudShutdown();
|
2007-10-12 16:05:44 +00:00
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
|
2008-07-11 19:34:11 +00:00
|
|
|
if (virDomainLoadAllConfigs(NULL,
|
|
|
|
qemu_driver->caps,
|
|
|
|
&qemu_driver->domains,
|
|
|
|
qemu_driver->configDir,
|
|
|
|
qemu_driver->autostartDir) < 0) {
|
2007-10-12 16:05:44 +00:00
|
|
|
qemudShutdown();
|
|
|
|
return -1;
|
|
|
|
}
|
2008-07-11 17:33:45 +00:00
|
|
|
if (virNetworkLoadAllConfigs(NULL,
|
|
|
|
&qemu_driver->networks,
|
|
|
|
qemu_driver->networkConfigDir,
|
|
|
|
qemu_driver->networkAutostartDir) < 0) {
|
|
|
|
qemudShutdown();
|
|
|
|
return -1;
|
|
|
|
}
|
2007-06-26 22:13:21 +00:00
|
|
|
qemudAutostartConfigs(qemu_driver);
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
|
|
|
|
out_of_memory:
|
2008-02-22 16:26:13 +00:00
|
|
|
qemudLog (QEMUD_ERR,
|
2008-08-01 11:24:04 +00:00
|
|
|
"%s", _("qemudStartup: out of memory\n"));
|
2008-05-29 19:20:22 +00:00
|
|
|
VIR_FREE(base);
|
|
|
|
VIR_FREE(qemu_driver);
|
2007-06-26 22:13:21 +00:00
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
|
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-07-11 19:34:11 +00:00
|
|
|
virDomainLoadAllConfigs(NULL,
|
|
|
|
qemu_driver->caps,
|
|
|
|
&qemu_driver->domains,
|
|
|
|
qemu_driver->configDir,
|
|
|
|
qemu_driver->autostartDir);
|
|
|
|
|
2008-07-11 17:33:45 +00:00
|
|
|
virNetworkLoadAllConfigs(NULL,
|
|
|
|
&qemu_driver->networks,
|
|
|
|
qemu_driver->networkConfigDir,
|
|
|
|
qemu_driver->networkAutostartDir);
|
2007-06-26 22:13:21 +00:00
|
|
|
|
|
|
|
if (qemu_driver->iptables) {
|
2008-02-22 16:26:13 +00:00
|
|
|
qemudLog(QEMUD_INFO,
|
2008-08-01 11:24:04 +00:00
|
|
|
"%s", _("Reloading iptables rules\n"));
|
2007-06-26 22:13:21 +00:00
|
|
|
iptablesReloadRules(qemu_driver->iptables);
|
2007-06-26 20:45:21 +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-07-11 19:34:11 +00:00
|
|
|
virDomainObjPtr dom = qemu_driver->domains;
|
2008-07-11 17:33:45 +00:00
|
|
|
virNetworkObjPtr net = qemu_driver->networks;
|
2008-07-11 19:34:11 +00:00
|
|
|
while (dom) {
|
|
|
|
if (virDomainIsActive(dom))
|
|
|
|
return 1;
|
|
|
|
dom = dom->next;
|
|
|
|
}
|
|
|
|
|
2008-07-11 17:33:45 +00:00
|
|
|
while (net) {
|
2008-07-11 19:34:11 +00:00
|
|
|
if (virNetworkIsActive(net))
|
2008-07-11 17:33:45 +00:00
|
|
|
return 1;
|
|
|
|
net = net->next;
|
|
|
|
}
|
|
|
|
|
2007-06-26 22:56:14 +00:00
|
|
|
/* Otherwise we're happy to deal with a shutdown */
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
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) {
|
2008-07-11 19:34:11 +00:00
|
|
|
virDomainObjPtr vm;
|
2008-07-11 17:33:45 +00:00
|
|
|
virNetworkObjPtr network;
|
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-02-27 04:35:08 +00:00
|
|
|
virCapabilitiesFree(qemu_driver->caps);
|
|
|
|
|
2007-06-26 20:41:25 +00:00
|
|
|
/* shutdown active VMs */
|
2008-07-11 19:34:11 +00:00
|
|
|
vm = qemu_driver->domains;
|
2007-06-26 20:41:25 +00:00
|
|
|
while (vm) {
|
2008-07-11 19:34:11 +00:00
|
|
|
virDomainObjPtr next = vm->next;
|
|
|
|
if (virDomainIsActive(vm))
|
2007-07-12 15:09:01 +00:00
|
|
|
qemudShutdownVMDaemon(NULL, qemu_driver, vm);
|
2008-08-20 19:42:36 +00:00
|
|
|
if (!vm->persistent)
|
2008-07-11 19:34:11 +00:00
|
|
|
virDomainRemoveInactive(&qemu_driver->domains,
|
|
|
|
vm);
|
2007-06-26 20:41:25 +00:00
|
|
|
vm = next;
|
|
|
|
}
|
2008-02-05 19:27:37 +00:00
|
|
|
|
2007-06-26 20:41:25 +00:00
|
|
|
/* free inactive VMs */
|
2008-07-11 19:34:11 +00:00
|
|
|
vm = qemu_driver->domains;
|
2007-06-26 20:41:25 +00:00
|
|
|
while (vm) {
|
2008-07-11 19:34:11 +00:00
|
|
|
virDomainObjPtr next = vm->next;
|
|
|
|
virDomainObjFree(vm);
|
2007-06-26 20:41:25 +00:00
|
|
|
vm = next;
|
|
|
|
}
|
2008-07-11 19:34:11 +00:00
|
|
|
qemu_driver->domains = NULL;
|
2007-06-26 20:41:25 +00:00
|
|
|
|
|
|
|
/* shutdown active networks */
|
2007-06-26 22:13:21 +00:00
|
|
|
network = qemu_driver->networks;
|
2007-06-26 20:41:25 +00:00
|
|
|
while (network) {
|
2008-07-11 17:33:45 +00:00
|
|
|
virNetworkObjPtr next = network->next;
|
|
|
|
if (virNetworkIsActive(network))
|
2007-07-12 15:09:01 +00:00
|
|
|
qemudShutdownNetworkDaemon(NULL, qemu_driver, network);
|
2007-06-26 20:41:25 +00:00
|
|
|
network = next;
|
|
|
|
}
|
2008-02-05 19:27:37 +00:00
|
|
|
|
2007-06-26 20:41:25 +00:00
|
|
|
/* free inactive networks */
|
2007-06-26 22:13:21 +00:00
|
|
|
network = qemu_driver->networks;
|
2007-06-26 20:41:25 +00:00
|
|
|
while (network) {
|
2008-07-11 17:33:45 +00:00
|
|
|
virNetworkObjPtr next = network->next;
|
|
|
|
virNetworkObjFree(network);
|
2007-06-26 20:41:25 +00:00
|
|
|
network = next;
|
|
|
|
}
|
2007-06-26 22:13:21 +00:00
|
|
|
qemu_driver->networks = NULL;
|
|
|
|
|
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);
|
|
|
|
VIR_FREE(qemu_driver->networkConfigDir);
|
|
|
|
VIR_FREE(qemu_driver->networkAutostartDir);
|
|
|
|
VIR_FREE(qemu_driver->vncTLSx509certdir);
|
2007-12-01 15:45:25 +00:00
|
|
|
|
2007-06-26 22:13:21 +00:00
|
|
|
if (qemu_driver->brctl)
|
|
|
|
brShutdown(qemu_driver->brctl);
|
|
|
|
if (qemu_driver->iptables)
|
|
|
|
iptablesContextFree(qemu_driver->iptables);
|
|
|
|
|
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
|
|
|
}
|
2008-06-26 09:37:51 +00:00
|
|
|
#endif
|
2007-06-26 20:41:25 +00:00
|
|
|
|
|
|
|
/* Return -1 for error, 1 to continue reading and 0 for success */
|
2007-07-12 15:09:01 +00:00
|
|
|
typedef int qemudHandlerMonitorOutput(virConnectPtr conn,
|
|
|
|
struct qemud_driver *driver,
|
2008-07-11 19:34:11 +00:00
|
|
|
virDomainObjPtr vm,
|
2007-06-26 20:41:25 +00:00
|
|
|
const char *output,
|
|
|
|
int fd);
|
|
|
|
|
|
|
|
static int
|
2007-07-12 15:09:01 +00:00
|
|
|
qemudReadMonitorOutput(virConnectPtr conn,
|
|
|
|
struct qemud_driver *driver,
|
2008-07-11 19:34:11 +00:00
|
|
|
virDomainObjPtr vm,
|
2007-06-26 20:41:25 +00:00
|
|
|
int fd,
|
|
|
|
char *buf,
|
|
|
|
int buflen,
|
|
|
|
qemudHandlerMonitorOutput func,
|
|
|
|
const char *what)
|
|
|
|
{
|
|
|
|
#define MONITOR_TIMEOUT 3000
|
|
|
|
int got = 0;
|
|
|
|
buf[0] = '\0';
|
|
|
|
|
|
|
|
/* Consume & discard the initial greeting */
|
|
|
|
while (got < (buflen-1)) {
|
|
|
|
int ret;
|
|
|
|
|
|
|
|
ret = read(fd, buf+got, buflen-got-1);
|
|
|
|
if (ret == 0) {
|
2007-07-12 15:09:01 +00:00
|
|
|
qemudReportError(conn, NULL, NULL, VIR_ERR_INTERNAL_ERROR,
|
2008-03-24 10:51:47 +00:00
|
|
|
_("QEMU quit during %s startup\n%s"), what, buf);
|
2007-06-26 20:41:25 +00:00
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
if (ret < 0) {
|
|
|
|
struct pollfd pfd = { .fd = fd, .events = POLLIN };
|
|
|
|
if (errno == EINTR)
|
|
|
|
continue;
|
|
|
|
|
|
|
|
if (errno != EAGAIN) {
|
2007-07-12 15:09:01 +00:00
|
|
|
qemudReportError(conn, NULL, NULL, VIR_ERR_INTERNAL_ERROR,
|
2008-03-24 10:51:47 +00:00
|
|
|
_("Failure while reading %s startup output: %s"),
|
2007-06-26 20:41:25 +00:00
|
|
|
what, strerror(errno));
|
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
|
|
|
|
ret = poll(&pfd, 1, MONITOR_TIMEOUT);
|
|
|
|
if (ret == 0) {
|
2007-07-12 15:09:01 +00:00
|
|
|
qemudReportError(conn, NULL, NULL, VIR_ERR_INTERNAL_ERROR,
|
2008-03-24 10:51:47 +00:00
|
|
|
_("Timed out while reading %s startup output"), what);
|
2007-06-26 20:41:25 +00:00
|
|
|
return -1;
|
|
|
|
} else if (ret == -1) {
|
|
|
|
if (errno != EINTR) {
|
2007-07-12 15:09:01 +00:00
|
|
|
qemudReportError(conn, NULL, NULL, VIR_ERR_INTERNAL_ERROR,
|
2008-03-24 10:51:47 +00:00
|
|
|
_("Failure while reading %s startup output: %s"),
|
2007-06-26 20:41:25 +00:00
|
|
|
what, strerror(errno));
|
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
} else {
|
|
|
|
/* Make sure we continue loop & read any further data
|
|
|
|
available before dealing with EOF */
|
|
|
|
if (pfd.revents & (POLLIN | POLLHUP))
|
|
|
|
continue;
|
|
|
|
|
2007-07-12 15:09:01 +00:00
|
|
|
qemudReportError(conn, NULL, NULL, VIR_ERR_INTERNAL_ERROR,
|
2008-03-24 10:51:47 +00:00
|
|
|
_("Failure while reading %s startup output"), what);
|
2007-06-26 20:41:25 +00:00
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
} else {
|
|
|
|
got += ret;
|
|
|
|
buf[got] = '\0';
|
2007-07-12 15:09:01 +00:00
|
|
|
if ((ret = func(conn, driver, vm, buf, fd)) != 1)
|
2007-06-26 20:41:25 +00:00
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2007-07-12 15:09:01 +00:00
|
|
|
qemudReportError(conn, NULL, NULL, VIR_ERR_INTERNAL_ERROR,
|
2008-03-24 10:51:47 +00:00
|
|
|
_("Out of space while reading %s startup output"), what);
|
2007-06-26 20:41:25 +00:00
|
|
|
return -1;
|
|
|
|
|
|
|
|
#undef MONITOR_TIMEOUT
|
|
|
|
}
|
|
|
|
|
|
|
|
static int
|
2007-07-12 15:09:01 +00:00
|
|
|
qemudCheckMonitorPrompt(virConnectPtr conn ATTRIBUTE_UNUSED,
|
|
|
|
struct qemud_driver *driver ATTRIBUTE_UNUSED,
|
2008-07-11 19:34:11 +00:00
|
|
|
virDomainObjPtr vm,
|
2007-06-26 20:41:25 +00:00
|
|
|
const char *output,
|
|
|
|
int fd)
|
|
|
|
{
|
|
|
|
if (strstr(output, "(qemu) ") == NULL)
|
|
|
|
return 1; /* keep reading */
|
|
|
|
|
|
|
|
vm->monitor = fd;
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2007-07-12 15:09:01 +00:00
|
|
|
static int qemudOpenMonitor(virConnectPtr conn,
|
|
|
|
struct qemud_driver *driver,
|
2008-07-11 19:34:11 +00:00
|
|
|
virDomainObjPtr vm,
|
2007-07-12 15:09:01 +00:00
|
|
|
const char *monitor) {
|
2007-06-26 20:41:25 +00:00
|
|
|
int monfd;
|
|
|
|
char buf[1024];
|
|
|
|
int ret = -1;
|
|
|
|
|
2008-07-25 08:42:05 +00:00
|
|
|
if ((monfd = open(monitor, O_RDWR)) < 0) {
|
2007-07-12 15:09:01 +00:00
|
|
|
qemudReportError(conn, NULL, NULL, VIR_ERR_INTERNAL_ERROR,
|
2008-03-24 10:51:47 +00:00
|
|
|
_("Unable to open monitor path %s"), monitor);
|
2007-06-26 20:41:25 +00:00
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
if (qemudSetCloseExec(monfd) < 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 set monitor close-on-exec flag"));
|
2007-06-26 20:41:25 +00:00
|
|
|
goto error;
|
|
|
|
}
|
|
|
|
if (qemudSetNonBlock(monfd) < 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 put monitor into non-blocking mode"));
|
2007-06-26 20:41:25 +00:00
|
|
|
goto error;
|
|
|
|
}
|
|
|
|
|
2007-07-12 15:09:01 +00:00
|
|
|
ret = qemudReadMonitorOutput(conn,
|
|
|
|
driver, vm, monfd,
|
2007-06-26 20:41:25 +00:00
|
|
|
buf, sizeof(buf),
|
|
|
|
qemudCheckMonitorPrompt,
|
|
|
|
"monitor");
|
2007-07-23 18:00:33 +00:00
|
|
|
|
|
|
|
/* Keep monitor open upon success */
|
|
|
|
if (ret == 0)
|
|
|
|
return ret;
|
|
|
|
|
2007-06-26 20:41:25 +00:00
|
|
|
error:
|
|
|
|
close(monfd);
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
2008-07-11 19:34:11 +00:00
|
|
|
static int qemudExtractMonitorPath(virConnectPtr conn,
|
|
|
|
const char *haystack,
|
2008-04-25 20:46:13 +00:00
|
|
|
size_t *offset,
|
2008-07-11 19:34:11 +00:00
|
|
|
char **path) {
|
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)) {
|
2008-07-11 19:34:11 +00:00
|
|
|
if (VIR_ALLOC_N(*path, (tmp-dev)+1) < 0) {
|
|
|
|
qemudReportError(conn, NULL, NULL,
|
|
|
|
VIR_ERR_NO_MEMORY, NULL);
|
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
strncpy(*path, dev, (tmp-dev));
|
|
|
|
(*path)[(tmp-dev)] = '\0';
|
2008-07-11 09:48:51 +00:00
|
|
|
/* ... now further update offset till we get EOL */
|
2008-07-11 19:34:11 +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
|
|
|
}
|
|
|
|
|
|
|
|
static int
|
2008-04-25 20:46:13 +00:00
|
|
|
qemudFindCharDevicePTYs(virConnectPtr conn,
|
|
|
|
struct qemud_driver *driver,
|
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-07-11 19:34:11 +00:00
|
|
|
char *monitor = NULL;
|
2008-04-25 20:46:13 +00:00
|
|
|
size_t offset = 0;
|
2008-07-11 19:34:11 +00:00
|
|
|
virDomainChrDefPtr chr;
|
|
|
|
int ret;
|
2008-04-25 20:46:13 +00:00
|
|
|
|
|
|
|
/* The order in which QEMU prints out the PTY paths is
|
|
|
|
the order in which it procsses its monitor, serial
|
|
|
|
and parallel device args. This code must match that
|
|
|
|
ordering.... */
|
2007-06-26 20:41:25 +00:00
|
|
|
|
2008-04-25 20:46:13 +00:00
|
|
|
/* So first comes the monitor device */
|
2008-07-11 19:34:11 +00:00
|
|
|
if ((ret = qemudExtractMonitorPath(conn, output, &offset, &monitor)) != 0)
|
|
|
|
goto cleanup;
|
2007-06-26 20:41:25 +00:00
|
|
|
|
2008-04-25 20:46:13 +00:00
|
|
|
/* then the serial devices */
|
|
|
|
chr = vm->def->serials;
|
|
|
|
while (chr) {
|
2008-07-11 19:34:11 +00:00
|
|
|
if (chr->type == VIR_DOMAIN_CHR_TYPE_PTY) {
|
|
|
|
if ((ret = qemudExtractMonitorPath(conn, output, &offset,
|
|
|
|
&chr->data.file.path)) != 0)
|
|
|
|
goto cleanup;
|
2008-04-25 20:46:13 +00:00
|
|
|
}
|
|
|
|
chr = chr->next;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* and finally the parallel devices */
|
|
|
|
chr = vm->def->parallels;
|
|
|
|
while (chr) {
|
2008-07-11 19:34:11 +00:00
|
|
|
if (chr->type == VIR_DOMAIN_CHR_TYPE_PTY) {
|
|
|
|
if ((ret = qemudExtractMonitorPath(conn, output, &offset,
|
|
|
|
&chr->data.file.path)) != 0)
|
|
|
|
goto cleanup;
|
2008-04-25 20:46:13 +00:00
|
|
|
}
|
|
|
|
chr = chr->next;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Got them all, so now open the monitor console */
|
2008-07-11 19:34:11 +00:00
|
|
|
ret = qemudOpenMonitor(conn, driver, vm, monitor);
|
|
|
|
|
|
|
|
cleanup:
|
|
|
|
VIR_FREE(monitor);
|
|
|
|
return ret;
|
2007-06-26 20:41:25 +00:00
|
|
|
}
|
|
|
|
|
2007-07-12 15:09:01 +00:00
|
|
|
static int qemudWaitForMonitor(virConnectPtr conn,
|
|
|
|
struct qemud_driver *driver,
|
2008-07-11 19:34:11 +00:00
|
|
|
virDomainObjPtr vm) {
|
2007-06-26 20:41:25 +00:00
|
|
|
char buf[1024]; /* Plenty of space to get startup greeting */
|
2007-07-12 15:09:01 +00:00
|
|
|
int ret = qemudReadMonitorOutput(conn,
|
2008-08-12 08:38:22 +00:00
|
|
|
driver, vm, vm->stderr_fd,
|
2007-06-26 20:41:25 +00:00
|
|
|
buf, sizeof(buf),
|
2008-04-25 20:46:13 +00:00
|
|
|
qemudFindCharDevicePTYs,
|
2007-06-26 20:41:25 +00:00
|
|
|
"console");
|
|
|
|
|
|
|
|
buf[sizeof(buf)-1] = '\0';
|
Use safewrite in place of write, in many cases.
Also add "make syntax-check" rules to ensure no new uses sneak in.
There are many uses of write like this:
if (write (fd, xml, towrite) != towrite)
return -1;
The problem is that the syscall can succeed, yet write less than
the requested number of bytes, so the caller should retry
rather than simply failing.
This patch changes most of them to use util.c's safewrite wrapper,
which encapsulates the process. Also, there were a few cases in
which the retry loop was open-coded, and I replaced those, too.
* Makefile.maint (sc_avoid_write): New rule, to avoid recurrence.
* .x-sc_avoid_write: New file. Record two legitimate exemptions.
* qemud/qemud.c (sig_handler, qemudClientWriteBuf): Use safewrite, not write.
* src/conf.c (__virConfWriteFile): Likewise.
* src/qemu_conf.c (qemudSaveConfig, qemudSaveNetworkConfig): Likewise.
* src/qemu_driver.c (qemudWaitForMonitor, qemudStartVMDaemon)
(qemudVMData, PROC_IP_FORWARD): Likewise.
* proxy/libvirt_proxy.c: Include "util.h".
(proxyWriteClientSocket): Use safewrite.
* src/test.c (testDomainSave, testDomainCoreDump): Likewise.
* src/proxy_internal.c (virProxyWriteClientSocket): Likewise.
* src/virsh.c: Include "util-lib.h".
(vshOutputLogFile): Use safewrite.
* src/console.c: Include "util-lib.h".
(vshRunConsole): Use safewrite.
2008-02-22 15:55:04 +00:00
|
|
|
|
|
|
|
if (safewrite(vm->logfile, buf, strlen(buf)) < 0) {
|
2007-06-26 20:41:25 +00:00
|
|
|
/* Log, but ignore failures to write logfile for VM */
|
2008-08-01 11:24:04 +00:00
|
|
|
qemudLog(QEMUD_WARN, _("Unable to log VM console data: %s\n"),
|
2007-06-26 20:41:25 +00:00
|
|
|
strerror(errno));
|
|
|
|
}
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
2008-05-22 16:20:31 +00:00
|
|
|
static int
|
|
|
|
qemudDetectVcpuPIDs(virConnectPtr conn,
|
|
|
|
struct qemud_driver *driver,
|
2008-07-11 19:34:11 +00:00
|
|
|
virDomainObjPtr vm) {
|
2008-05-22 16:20:31 +00:00
|
|
|
char *qemucpus = NULL;
|
|
|
|
char *line;
|
|
|
|
int lastVcpu = -1;
|
|
|
|
|
|
|
|
/* Only KVM has seperate threads for CPUs,
|
|
|
|
others just use main QEMU process for CPU */
|
2008-07-11 19:34:11 +00:00
|
|
|
if (vm->def->virtType != VIR_DOMAIN_VIRT_KVM)
|
2008-05-22 16:20:31 +00:00
|
|
|
vm->nvcpupids = 1;
|
|
|
|
else
|
|
|
|
vm->nvcpupids = vm->def->vcpus;
|
|
|
|
|
|
|
|
if (VIR_ALLOC_N(vm->vcpupids, vm->nvcpupids) < 0) {
|
|
|
|
qemudReportError(conn, NULL, NULL, VIR_ERR_NO_MEMORY,
|
|
|
|
"%s", _("allocate cpumap"));
|
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
|
2008-07-11 19:34:11 +00:00
|
|
|
if (vm->def->virtType != VIR_DOMAIN_VIRT_KVM) {
|
2008-05-22 16:20:31 +00:00
|
|
|
vm->vcpupids[0] = vm->pid;
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (qemudMonitorCommand(driver, vm, "info cpus", &qemucpus) < 0) {
|
|
|
|
qemudReportError(conn, NULL, NULL, VIR_ERR_INTERNAL_ERROR,
|
|
|
|
"%s", _("cannot run monitor command to fetch CPU thread info"));
|
|
|
|
VIR_FREE(vm->vcpupids);
|
|
|
|
vm->nvcpupids = 0;
|
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* This is the gross format we're about to parse :-{
|
|
|
|
*
|
|
|
|
* (qemu) info cpus
|
|
|
|
* * CPU #0: pc=0x00000000000f0c4a thread_id=30019
|
|
|
|
* CPU #1: pc=0x00000000fffffff0 thread_id=30020
|
|
|
|
* CPU #2: pc=0x00000000fffffff0 thread_id=30021
|
|
|
|
*
|
|
|
|
*/
|
|
|
|
line = qemucpus;
|
|
|
|
do {
|
|
|
|
char *offset = strchr(line, '#');
|
|
|
|
char *end = NULL;
|
|
|
|
int vcpu = 0, tid = 0;
|
|
|
|
|
|
|
|
/* See if we're all done */
|
|
|
|
if (offset == NULL)
|
|
|
|
break;
|
|
|
|
|
|
|
|
/* Extract VCPU number */
|
|
|
|
if (virStrToLong_i(offset + 1, &end, 10, &vcpu) < 0)
|
|
|
|
goto error;
|
|
|
|
if (end == NULL || *end != ':')
|
|
|
|
goto error;
|
|
|
|
|
|
|
|
/* Extract host Thread ID */
|
|
|
|
if ((offset = strstr(line, "thread_id=")) == NULL)
|
|
|
|
goto error;
|
|
|
|
if (virStrToLong_i(offset + strlen("thread_id="), &end, 10, &tid) < 0)
|
|
|
|
goto error;
|
|
|
|
if (end == NULL || !c_isspace(*end))
|
|
|
|
goto error;
|
|
|
|
|
|
|
|
/* Validate the VCPU is in expected range & order */
|
|
|
|
if (vcpu > vm->nvcpupids ||
|
|
|
|
vcpu != (lastVcpu + 1))
|
|
|
|
goto error;
|
|
|
|
|
|
|
|
lastVcpu = vcpu;
|
|
|
|
vm->vcpupids[vcpu] = tid;
|
|
|
|
|
|
|
|
/* Skip to next data line */
|
|
|
|
line = strchr(offset, '\r');
|
|
|
|
if (line == NULL)
|
|
|
|
line = strchr(offset, '\n');
|
|
|
|
} while (line != NULL);
|
|
|
|
|
|
|
|
/* Validate we got data for all VCPUs we expected */
|
|
|
|
if (lastVcpu != (vm->def->vcpus - 1))
|
|
|
|
goto error;
|
|
|
|
|
2008-05-29 19:20:22 +00:00
|
|
|
VIR_FREE(qemucpus);
|
2008-05-22 16:20:31 +00:00
|
|
|
return 0;
|
|
|
|
|
|
|
|
error:
|
|
|
|
VIR_FREE(vm->vcpupids);
|
2008-05-29 19:20:22 +00:00
|
|
|
vm->nvcpupids = 0;
|
|
|
|
VIR_FREE(qemucpus);
|
2008-05-22 16:20:31 +00:00
|
|
|
|
|
|
|
/* Explicitly return success, not error. Older KVM does
|
|
|
|
not have vCPU -> Thread mapping info and we don't
|
|
|
|
want to break its use. This merely disables ability
|
|
|
|
to pin vCPUS with libvirt */
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2008-05-22 16:27:20 +00:00
|
|
|
static int
|
|
|
|
qemudInitCpus(virConnectPtr conn,
|
|
|
|
struct qemud_driver *driver,
|
2008-07-11 19:34:11 +00:00
|
|
|
virDomainObjPtr vm) {
|
2008-05-22 16:27:20 +00:00
|
|
|
char *info = NULL;
|
|
|
|
#if HAVE_SCHED_GETAFFINITY
|
|
|
|
cpu_set_t mask;
|
|
|
|
int i, maxcpu = QEMUD_CPUMASK_LEN;
|
|
|
|
virNodeInfo nodeinfo;
|
|
|
|
|
|
|
|
if (virNodeInfoPopulate(conn, &nodeinfo) < 0)
|
|
|
|
return -1;
|
|
|
|
|
|
|
|
/* setaffinity fails if you set bits for CPUs which
|
|
|
|
* aren't present, so we have to limit ourselves */
|
|
|
|
if (maxcpu > nodeinfo.cpus)
|
|
|
|
maxcpu = nodeinfo.cpus;
|
|
|
|
|
|
|
|
CPU_ZERO(&mask);
|
2008-07-25 09:31:24 +00:00
|
|
|
if (vm->def->cpumask) {
|
|
|
|
for (i = 0 ; i < maxcpu ; i++)
|
|
|
|
if (vm->def->cpumask[i])
|
|
|
|
CPU_SET(i, &mask);
|
|
|
|
} else {
|
|
|
|
for (i = 0 ; i < maxcpu ; i++)
|
2008-05-22 16:27:20 +00:00
|
|
|
CPU_SET(i, &mask);
|
2008-07-25 09:31:24 +00:00
|
|
|
}
|
2008-05-22 16:27:20 +00:00
|
|
|
|
|
|
|
for (i = 0 ; i < vm->nvcpupids ; i++) {
|
|
|
|
if (sched_setaffinity(vm->vcpupids[i],
|
|
|
|
sizeof(mask), &mask) < 0) {
|
|
|
|
qemudReportError(conn, NULL, NULL, VIR_ERR_INTERNAL_ERROR,
|
|
|
|
_("failed to set CPU affinity %s"),
|
|
|
|
strerror(errno));
|
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
#endif /* HAVE_SCHED_GETAFFINITY */
|
|
|
|
|
|
|
|
/* Allow the CPUS to start executing */
|
|
|
|
if (qemudMonitorCommand(driver, vm, "cont", &info) < 0) {
|
|
|
|
qemudReportError(conn, NULL, NULL, VIR_ERR_INTERNAL_ERROR,
|
|
|
|
"%s", _("resume operation failed"));
|
|
|
|
return -1;
|
|
|
|
}
|
2008-05-29 19:20:22 +00:00
|
|
|
VIR_FREE(info);
|
2008-05-22 16:27:20 +00:00
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
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;
|
|
|
|
}
|
|
|
|
|
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,
|
|
|
|
const char *migrateFrom) {
|
2008-08-08 15:43:38 +00:00
|
|
|
const char **argv = NULL, **tmp;
|
2008-04-08 12:27:53 +00:00
|
|
|
int i, ret;
|
2007-06-26 20:41:25 +00:00
|
|
|
char logfile[PATH_MAX];
|
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;
|
|
|
|
int qemuCmdFlags;
|
2007-06-26 20:41:25 +00:00
|
|
|
|
2008-07-11 19:34:11 +00:00
|
|
|
if (virDomainIsActive(vm)) {
|
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", _("VM is already active"));
|
2007-06-26 20:41:25 +00:00
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
|
2008-07-11 19:34:11 +00:00
|
|
|
if (vm->def->graphics &&
|
|
|
|
vm->def->graphics->type == VIR_DOMAIN_GRAPHICS_TYPE_VNC &&
|
|
|
|
vm->def->graphics->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"));
|
2007-06-26 20:41:25 +00:00
|
|
|
return -1;
|
|
|
|
}
|
2008-07-11 19:34:11 +00:00
|
|
|
vm->def->graphics->data.vnc.port = port;
|
|
|
|
}
|
2007-06-26 20:41:25 +00:00
|
|
|
|
2007-06-26 22:13:21 +00:00
|
|
|
if ((strlen(driver->logDir) + /* path */
|
2007-06-26 20:41:25 +00:00
|
|
|
1 + /* Separator */
|
|
|
|
strlen(vm->def->name) + /* basename */
|
|
|
|
4 + /* suffix .log */
|
|
|
|
1 /* NULL */) > PATH_MAX) {
|
2007-07-12 15:09:01 +00:00
|
|
|
qemudReportError(conn, NULL, NULL, VIR_ERR_INTERNAL_ERROR,
|
2008-03-24 10:51:47 +00:00
|
|
|
_("config file path too long: %s/%s.log"),
|
2007-06-26 22:13:21 +00:00
|
|
|
driver->logDir, vm->def->name);
|
2007-06-26 20:41:25 +00:00
|
|
|
return -1;
|
|
|
|
}
|
2007-06-26 22:13:21 +00:00
|
|
|
strcpy(logfile, driver->logDir);
|
2007-06-26 20:41:25 +00:00
|
|
|
strcat(logfile, "/");
|
|
|
|
strcat(logfile, vm->def->name);
|
|
|
|
strcat(logfile, ".log");
|
|
|
|
|
2007-12-03 14:30:46 +00:00
|
|
|
if (virFileMakePath(driver->logDir) < 0) {
|
2007-07-12 15:09:01 +00:00
|
|
|
qemudReportError(conn, NULL, NULL, VIR_ERR_INTERNAL_ERROR,
|
2008-03-24 10:51:47 +00:00
|
|
|
_("cannot create log directory %s: %s"),
|
2007-06-26 22:13:21 +00:00
|
|
|
driver->logDir, strerror(errno));
|
2007-06-26 20:41:25 +00:00
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
|
|
|
|
if ((vm->logfile = open(logfile, O_CREAT | O_TRUNC | O_WRONLY,
|
|
|
|
S_IRUSR | S_IWUSR)) < 0) {
|
2007-07-12 15:09:01 +00:00
|
|
|
qemudReportError(conn, NULL, NULL, VIR_ERR_INTERNAL_ERROR,
|
2008-03-24 10:51:47 +00:00
|
|
|
_("failed to create logfile %s: %s"),
|
2007-06-26 20:41:25 +00:00
|
|
|
logfile, strerror(errno));
|
|
|
|
return -1;
|
|
|
|
}
|
2007-07-23 18:00:33 +00:00
|
|
|
if (qemudSetCloseExec(vm->logfile) < 0) {
|
|
|
|
qemudReportError(conn, NULL, NULL, VIR_ERR_INTERNAL_ERROR,
|
2008-03-24 10:51:47 +00:00
|
|
|
_("Unable to set VM logfile close-on-exec flag %s"),
|
2007-07-23 18:00:33 +00:00
|
|
|
strerror(errno));
|
|
|
|
close(vm->logfile);
|
|
|
|
vm->logfile = -1;
|
|
|
|
return -1;
|
|
|
|
}
|
2007-06-26 20:41:25 +00:00
|
|
|
|
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-07-11 19:34:11 +00:00
|
|
|
if (stat(vm->def->emulator, &sb) < 0) {
|
2008-05-16 16:51:30 +00:00
|
|
|
qemudReportError(conn, NULL, NULL, VIR_ERR_INTERNAL_ERROR,
|
|
|
|
_("Cannot find QEMU binary %s: %s"),
|
2008-07-11 19:34:11 +00:00
|
|
|
vm->def->emulator,
|
2008-05-16 16:51:30 +00:00
|
|
|
strerror(errno));
|
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
|
2008-07-11 19:34:11 +00:00
|
|
|
if (qemudExtractVersionInfo(vm->def->emulator,
|
|
|
|
NULL,
|
|
|
|
&qemuCmdFlags) < 0) {
|
|
|
|
qemudReportError(conn, NULL, NULL, VIR_ERR_INTERNAL_ERROR,
|
|
|
|
_("Cannot determine QEMU argv syntax %s"),
|
|
|
|
vm->def->emulator);
|
|
|
|
return -1;
|
|
|
|
}
|
2008-05-16 16:51:30 +00:00
|
|
|
|
2008-07-11 19:34:11 +00:00
|
|
|
if (qemudBuildCommandLine(conn, driver, vm,
|
|
|
|
qemuCmdFlags, &argv,
|
|
|
|
&tapfds, &ntapfds, migrateFrom) < 0) {
|
2007-06-26 20:41:25 +00:00
|
|
|
close(vm->logfile);
|
|
|
|
vm->logfile = -1;
|
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
|
|
|
|
tmp = argv;
|
|
|
|
while (*tmp) {
|
Use safewrite in place of write, in many cases.
Also add "make syntax-check" rules to ensure no new uses sneak in.
There are many uses of write like this:
if (write (fd, xml, towrite) != towrite)
return -1;
The problem is that the syscall can succeed, yet write less than
the requested number of bytes, so the caller should retry
rather than simply failing.
This patch changes most of them to use util.c's safewrite wrapper,
which encapsulates the process. Also, there were a few cases in
which the retry loop was open-coded, and I replaced those, too.
* Makefile.maint (sc_avoid_write): New rule, to avoid recurrence.
* .x-sc_avoid_write: New file. Record two legitimate exemptions.
* qemud/qemud.c (sig_handler, qemudClientWriteBuf): Use safewrite, not write.
* src/conf.c (__virConfWriteFile): Likewise.
* src/qemu_conf.c (qemudSaveConfig, qemudSaveNetworkConfig): Likewise.
* src/qemu_driver.c (qemudWaitForMonitor, qemudStartVMDaemon)
(qemudVMData, PROC_IP_FORWARD): Likewise.
* proxy/libvirt_proxy.c: Include "util.h".
(proxyWriteClientSocket): Use safewrite.
* src/test.c (testDomainSave, testDomainCoreDump): Likewise.
* src/proxy_internal.c (virProxyWriteClientSocket): Likewise.
* src/virsh.c: Include "util-lib.h".
(vshOutputLogFile): Use safewrite.
* src/console.c: Include "util-lib.h".
(vshRunConsole): Use safewrite.
2008-02-22 15:55:04 +00:00
|
|
|
if (safewrite(vm->logfile, *tmp, strlen(*tmp)) < 0)
|
2008-08-01 11:24:04 +00:00
|
|
|
qemudLog(QEMUD_WARN, _("Unable to write argv to logfile %d: %s\n"),
|
2007-06-26 20:41:25 +00:00
|
|
|
errno, strerror(errno));
|
Use safewrite in place of write, in many cases.
Also add "make syntax-check" rules to ensure no new uses sneak in.
There are many uses of write like this:
if (write (fd, xml, towrite) != towrite)
return -1;
The problem is that the syscall can succeed, yet write less than
the requested number of bytes, so the caller should retry
rather than simply failing.
This patch changes most of them to use util.c's safewrite wrapper,
which encapsulates the process. Also, there were a few cases in
which the retry loop was open-coded, and I replaced those, too.
* Makefile.maint (sc_avoid_write): New rule, to avoid recurrence.
* .x-sc_avoid_write: New file. Record two legitimate exemptions.
* qemud/qemud.c (sig_handler, qemudClientWriteBuf): Use safewrite, not write.
* src/conf.c (__virConfWriteFile): Likewise.
* src/qemu_conf.c (qemudSaveConfig, qemudSaveNetworkConfig): Likewise.
* src/qemu_driver.c (qemudWaitForMonitor, qemudStartVMDaemon)
(qemudVMData, PROC_IP_FORWARD): Likewise.
* proxy/libvirt_proxy.c: Include "util.h".
(proxyWriteClientSocket): Use safewrite.
* src/test.c (testDomainSave, testDomainCoreDump): Likewise.
* src/proxy_internal.c (virProxyWriteClientSocket): Likewise.
* src/virsh.c: Include "util-lib.h".
(vshOutputLogFile): Use safewrite.
* src/console.c: Include "util-lib.h".
(vshRunConsole): Use safewrite.
2008-02-22 15:55:04 +00:00
|
|
|
if (safewrite(vm->logfile, " ", 1) < 0)
|
2008-08-01 11:24:04 +00:00
|
|
|
qemudLog(QEMUD_WARN, _("Unable to write argv to logfile %d: %s\n"),
|
2007-06-26 20:41:25 +00:00
|
|
|
errno, strerror(errno));
|
|
|
|
tmp++;
|
|
|
|
}
|
Use safewrite in place of write, in many cases.
Also add "make syntax-check" rules to ensure no new uses sneak in.
There are many uses of write like this:
if (write (fd, xml, towrite) != towrite)
return -1;
The problem is that the syscall can succeed, yet write less than
the requested number of bytes, so the caller should retry
rather than simply failing.
This patch changes most of them to use util.c's safewrite wrapper,
which encapsulates the process. Also, there were a few cases in
which the retry loop was open-coded, and I replaced those, too.
* Makefile.maint (sc_avoid_write): New rule, to avoid recurrence.
* .x-sc_avoid_write: New file. Record two legitimate exemptions.
* qemud/qemud.c (sig_handler, qemudClientWriteBuf): Use safewrite, not write.
* src/conf.c (__virConfWriteFile): Likewise.
* src/qemu_conf.c (qemudSaveConfig, qemudSaveNetworkConfig): Likewise.
* src/qemu_driver.c (qemudWaitForMonitor, qemudStartVMDaemon)
(qemudVMData, PROC_IP_FORWARD): Likewise.
* proxy/libvirt_proxy.c: Include "util.h".
(proxyWriteClientSocket): Use safewrite.
* src/test.c (testDomainSave, testDomainCoreDump): Likewise.
* src/proxy_internal.c (virProxyWriteClientSocket): Likewise.
* src/virsh.c: Include "util-lib.h".
(vshOutputLogFile): Use safewrite.
* src/console.c: Include "util-lib.h".
(vshRunConsole): Use safewrite.
2008-02-22 15:55:04 +00:00
|
|
|
if (safewrite(vm->logfile, "\n", 1) < 0)
|
2008-08-01 11:24:04 +00:00
|
|
|
qemudLog(QEMUD_WARN, _("Unable to write argv to logfile %d: %s\n"),
|
2007-06-26 20:41:25 +00:00
|
|
|
errno, strerror(errno));
|
|
|
|
|
2008-08-20 09:08:17 +00:00
|
|
|
vm->stdout_fd = -1;
|
|
|
|
vm->stderr_fd = -1;
|
|
|
|
|
2008-08-20 09:24:14 +00:00
|
|
|
ret = virExec(conn, argv, NULL, &vm->pid,
|
|
|
|
vm->stdin_fd, &vm->stdout_fd, &vm->stderr_fd,
|
|
|
|
VIR_EXEC_NONBLOCK);
|
2008-04-08 12:27:53 +00:00
|
|
|
if (ret == 0) {
|
2008-07-11 19:34:11 +00:00
|
|
|
vm->def->id = driver->nextvmid++;
|
|
|
|
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-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
|
|
|
}
|
|
|
|
|
2008-04-08 12:27:53 +00:00
|
|
|
if (ret == 0) {
|
2008-08-12 08:38:22 +00:00
|
|
|
if ((virEventAddHandle(vm->stdout_fd,
|
2008-05-22 16:27:20 +00:00
|
|
|
POLLIN | POLLERR | POLLHUP,
|
|
|
|
qemudDispatchVMEvent,
|
|
|
|
driver) < 0) ||
|
2008-08-12 08:38:22 +00:00
|
|
|
(virEventAddHandle(vm->stderr_fd,
|
2008-05-22 16:27:20 +00:00
|
|
|
POLLIN | POLLERR | POLLHUP,
|
|
|
|
qemudDispatchVMEvent,
|
|
|
|
driver) < 0) ||
|
|
|
|
(qemudWaitForMonitor(conn, driver, vm) < 0) ||
|
|
|
|
(qemudDetectVcpuPIDs(conn, driver, vm) < 0) ||
|
|
|
|
(qemudInitCpus(conn, driver, vm) < 0)) {
|
2008-05-22 16:20:31 +00:00
|
|
|
qemudShutdownVMDaemon(conn, driver, vm);
|
|
|
|
return -1;
|
|
|
|
}
|
2007-06-26 20:45:21 +00:00
|
|
|
}
|
|
|
|
|
2008-04-08 12:27:53 +00:00
|
|
|
return ret;
|
2007-06-26 20:41:25 +00:00
|
|
|
}
|
|
|
|
|
2007-06-26 22:13:21 +00:00
|
|
|
static int qemudVMData(struct qemud_driver *driver ATTRIBUTE_UNUSED,
|
2008-07-11 19:34:11 +00:00
|
|
|
virDomainObjPtr vm, int fd) {
|
2007-06-26 20:41:25 +00:00
|
|
|
char buf[4096];
|
|
|
|
if (vm->pid < 0)
|
|
|
|
return 0;
|
|
|
|
|
|
|
|
for (;;) {
|
|
|
|
int ret = read(fd, buf, sizeof(buf)-1);
|
|
|
|
if (ret < 0) {
|
|
|
|
if (errno == EAGAIN)
|
|
|
|
return 0;
|
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
if (ret == 0) {
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
buf[ret] = '\0';
|
|
|
|
|
Use safewrite in place of write, in many cases.
Also add "make syntax-check" rules to ensure no new uses sneak in.
There are many uses of write like this:
if (write (fd, xml, towrite) != towrite)
return -1;
The problem is that the syscall can succeed, yet write less than
the requested number of bytes, so the caller should retry
rather than simply failing.
This patch changes most of them to use util.c's safewrite wrapper,
which encapsulates the process. Also, there were a few cases in
which the retry loop was open-coded, and I replaced those, too.
* Makefile.maint (sc_avoid_write): New rule, to avoid recurrence.
* .x-sc_avoid_write: New file. Record two legitimate exemptions.
* qemud/qemud.c (sig_handler, qemudClientWriteBuf): Use safewrite, not write.
* src/conf.c (__virConfWriteFile): Likewise.
* src/qemu_conf.c (qemudSaveConfig, qemudSaveNetworkConfig): Likewise.
* src/qemu_driver.c (qemudWaitForMonitor, qemudStartVMDaemon)
(qemudVMData, PROC_IP_FORWARD): Likewise.
* proxy/libvirt_proxy.c: Include "util.h".
(proxyWriteClientSocket): Use safewrite.
* src/test.c (testDomainSave, testDomainCoreDump): Likewise.
* src/proxy_internal.c (virProxyWriteClientSocket): Likewise.
* src/virsh.c: Include "util-lib.h".
(vshOutputLogFile): Use safewrite.
* src/console.c: Include "util-lib.h".
(vshRunConsole): Use safewrite.
2008-02-22 15:55:04 +00:00
|
|
|
if (safewrite(vm->logfile, buf, ret) < 0) {
|
2007-06-26 20:41:25 +00:00
|
|
|
/* Log, but ignore failures to write logfile for VM */
|
2008-08-01 11:24:04 +00:00
|
|
|
qemudLog(QEMUD_WARN, _("Unable to log VM console data: %s\n"),
|
2007-06-26 20:41:25 +00:00
|
|
|
strerror(errno));
|
|
|
|
}
|
|
|
|
}
|
2007-06-26 22:42:47 +00:00
|
|
|
|
|
|
|
qemudAutostartConfigs(qemu_driver);
|
2007-06-26 20:41:25 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
|
2007-07-24 14:24:52 +00:00
|
|
|
static void qemudShutdownVMDaemon(virConnectPtr conn ATTRIBUTE_UNUSED,
|
2008-07-11 19:34:11 +00:00
|
|
|
struct qemud_driver *driver, virDomainObjPtr vm) {
|
|
|
|
if (!virDomainIsActive(vm))
|
2007-07-24 14:24:52 +00:00
|
|
|
return;
|
2007-06-26 20:41:25 +00:00
|
|
|
|
2008-08-01 11:24:04 +00:00
|
|
|
qemudLog(QEMUD_INFO, _("Shutting down VM '%s'\n"), vm->def->name);
|
2007-06-26 20:41:25 +00:00
|
|
|
|
|
|
|
kill(vm->pid, SIGTERM);
|
|
|
|
|
2008-08-12 08:38:22 +00:00
|
|
|
qemudVMData(driver, vm, vm->stdout_fd);
|
|
|
|
qemudVMData(driver, vm, vm->stderr_fd);
|
2007-06-26 20:41:25 +00:00
|
|
|
|
2008-08-12 08:38:22 +00:00
|
|
|
virEventRemoveHandle(vm->stdout_fd);
|
|
|
|
virEventRemoveHandle(vm->stderr_fd);
|
2007-06-26 20:41:25 +00:00
|
|
|
|
|
|
|
if (close(vm->logfile) < 0)
|
2008-08-01 11:24:04 +00:00
|
|
|
qemudLog(QEMUD_WARN, _("Unable to close logfile %d: %s\n"),
|
Mark all qemudLog diagnostics for translation.
* po/POTFILES.in: Add names of many new files.
* Makefile.maint (err_func_re): Add qemudLog.
Mark diagnostics with _(...). Split some long lines.
* qemud/qemud.c (remoteCheckCertFile, remoteInitializeGnuTLS):
(qemudDispatchSignalEvent, qemudSetCloseExec, qemudSetNonBlock):
(qemudWritePidFile, qemudListenUnix, remoteMakeSockets):
(remoteListenTCP, qemudInitPaths, qemudInitialize):
(qemudNetworkInit, remoteInitializeTLSSession, remoteCheckDN):
(remoteCheckCertificate, remoteCheckAccess, qemudDispatchServer):
(qemudClientReadBuf, qemudDispatchClientRead):
(qemudClientWriteBuf, qemudDispatchClientWrite, qemudOneLoop):
(remoteConfigGetStringList, checkType, GET_CONF_STR):
(remoteConfigGetAuth, remoteReadConfigFile, main):
* qemud/remote.c (remoteDispatchAuthSaslInit, remoteSASLCheckSSF):
(remoteSASLCheckAccess, remoteDispatchAuthSaslStart):
(remoteDispatchAuthSaslStep, remoteDispatchAuthSaslInit):
(remoteDispatchAuthSaslStart, remoteDispatchAuthSaslStep):
(qemudGetSocketIdentity, remoteDispatchAuthPolkit):
* src/iptables.c (notifyRulesUpdated, MAX_FILE_LEN, iptRulesSave):
(iptRulesReload):
* src/qemu_conf.c (qemudExtractVersionInfo, qemudLoadConfig):
(qemudLoadNetworkConfig, qemudScanConfigDir):
* src/qemu_driver.c (qemudSetCloseExec, qemudSetNonBlock):
(qemudAutostartConfigs, qemudStartup, qemudReload):
(qemudWaitForMonitor, qemudStartVMDaemon, qemudVMData):
(qemudShutdownVMDaemon, qemudStartNetworkDaemon):
(qemudShutdownNetworkDaemon, qemudMonitorCommand):
(qemudDomainUndefine, qemudNetworkUndefine):
* src/uuid.c (virUUIDGenerate):
* src/xm_internal.c (xenXMAttachInterface):
2008-02-07 16:50:17 +00:00
|
|
|
errno, strerror(errno));
|
2008-08-12 08:38:22 +00:00
|
|
|
close(vm->stdout_fd);
|
|
|
|
close(vm->stderr_fd);
|
2007-06-26 20:41:25 +00:00
|
|
|
if (vm->monitor != -1)
|
|
|
|
close(vm->monitor);
|
|
|
|
vm->logfile = -1;
|
2008-08-12 08:38:22 +00:00
|
|
|
vm->stdout_fd = -1;
|
|
|
|
vm->stderr_fd = -1;
|
2007-06-26 20:41:25 +00:00
|
|
|
vm->monitor = -1;
|
|
|
|
|
|
|
|
if (waitpid(vm->pid, NULL, WNOHANG) != vm->pid) {
|
|
|
|
kill(vm->pid, SIGKILL);
|
|
|
|
if (waitpid(vm->pid, NULL, 0) != vm->pid) {
|
2008-02-22 16:26:13 +00:00
|
|
|
qemudLog(QEMUD_WARN,
|
2008-08-01 11:24:04 +00:00
|
|
|
"%s", _("Got unexpected pid, damn\n"));
|
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;
|
2008-05-29 19:20:22 +00:00
|
|
|
VIR_FREE(vm->vcpupids);
|
2008-05-22 16:20:31 +00:00
|
|
|
vm->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;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2008-07-11 19:34:11 +00:00
|
|
|
static int qemudDispatchVMLog(struct qemud_driver *driver, virDomainObjPtr vm, int fd) {
|
2007-07-24 14:24:52 +00:00
|
|
|
if (qemudVMData(driver, vm, fd) < 0) {
|
|
|
|
qemudShutdownVMDaemon(NULL, driver, vm);
|
2008-08-20 19:42:36 +00:00
|
|
|
if (!vm->persistent)
|
2008-07-11 19:34:11 +00:00
|
|
|
virDomainRemoveInactive(&driver->domains,
|
|
|
|
vm);
|
2007-07-24 14:24:52 +00:00
|
|
|
}
|
2007-06-26 20:41:25 +00:00
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2008-07-11 19:34:11 +00:00
|
|
|
static int qemudDispatchVMFailure(struct qemud_driver *driver, virDomainObjPtr vm,
|
2007-06-26 20:41:25 +00:00
|
|
|
int fd ATTRIBUTE_UNUSED) {
|
2007-07-24 14:24:52 +00:00
|
|
|
qemudShutdownVMDaemon(NULL, driver, vm);
|
2008-08-20 19:42:36 +00:00
|
|
|
if (!vm->persistent)
|
2008-07-11 19:34:11 +00:00
|
|
|
virDomainRemoveInactive(&driver->domains,
|
|
|
|
vm);
|
2007-06-26 20:41:25 +00:00
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
static int
|
2007-07-12 15:09:01 +00:00
|
|
|
qemudBuildDnsmasqArgv(virConnectPtr conn,
|
2008-07-11 17:33:45 +00:00
|
|
|
virNetworkObjPtr network,
|
2008-08-08 15:43:38 +00:00
|
|
|
const char ***argv) {
|
2008-07-11 17:33:45 +00:00
|
|
|
int i, len, r;
|
2007-06-26 20:41:25 +00:00
|
|
|
char buf[PATH_MAX];
|
|
|
|
|
|
|
|
len =
|
|
|
|
1 + /* dnsmasq */
|
|
|
|
1 + /* --keep-in-foreground */
|
|
|
|
1 + /* --strict-order */
|
|
|
|
1 + /* --bind-interfaces */
|
|
|
|
2 + /* --pid-file "" */
|
|
|
|
2 + /* --conf-file "" */
|
|
|
|
/*2 + *//* --interface virbr0 */
|
|
|
|
2 + /* --except-interface lo */
|
|
|
|
2 + /* --listen-address 10.0.0.1 */
|
|
|
|
1 + /* --dhcp-leasefile=path */
|
|
|
|
(2 * network->def->nranges) + /* --dhcp-range 10.0.0.2,10.0.0.254 */
|
2008-08-20 12:50:29 +00:00
|
|
|
/* --dhcp-host 01:23:45:67:89:0a,hostname,10.0.0.3 */
|
|
|
|
(2 * network->def->nhosts) +
|
2007-06-26 20:41:25 +00:00
|
|
|
1; /* NULL */
|
|
|
|
|
2008-05-29 19:20:22 +00:00
|
|
|
if (VIR_ALLOC_N(*argv, len) < 0)
|
2007-06-26 20:41:25 +00:00
|
|
|
goto no_memory;
|
|
|
|
|
|
|
|
#define APPEND_ARG(v, n, s) do { \
|
|
|
|
if (!((v)[(n)] = strdup(s))) \
|
|
|
|
goto no_memory; \
|
|
|
|
} while (0)
|
|
|
|
|
|
|
|
i = 0;
|
|
|
|
|
2007-09-20 18:40:36 +00:00
|
|
|
APPEND_ARG(*argv, i++, DNSMASQ);
|
2007-06-26 20:41:25 +00:00
|
|
|
|
|
|
|
APPEND_ARG(*argv, i++, "--keep-in-foreground");
|
|
|
|
/*
|
|
|
|
* Needed to ensure dnsmasq uses same algorithm for processing
|
2007-06-26 22:13:21 +00:00
|
|
|
* multiple namedriver entries in /etc/resolv.conf as GLibC.
|
2007-06-26 20:41:25 +00:00
|
|
|
*/
|
|
|
|
APPEND_ARG(*argv, i++, "--strict-order");
|
|
|
|
APPEND_ARG(*argv, i++, "--bind-interfaces");
|
|
|
|
|
|
|
|
APPEND_ARG(*argv, i++, "--pid-file");
|
|
|
|
APPEND_ARG(*argv, i++, "");
|
|
|
|
|
|
|
|
APPEND_ARG(*argv, i++, "--conf-file");
|
|
|
|
APPEND_ARG(*argv, i++, "");
|
|
|
|
|
|
|
|
/*
|
|
|
|
* XXX does not actually work, due to some kind of
|
|
|
|
* race condition setting up ipv6 addresses on the
|
|
|
|
* interface. A sleep(10) makes it work, but that's
|
|
|
|
* clearly not practical
|
|
|
|
*
|
|
|
|
* APPEND_ARG(*argv, i++, "--interface");
|
|
|
|
* APPEND_ARG(*argv, i++, network->def->bridge);
|
|
|
|
*/
|
|
|
|
APPEND_ARG(*argv, i++, "--listen-address");
|
|
|
|
APPEND_ARG(*argv, i++, network->def->ipAddress);
|
|
|
|
|
|
|
|
APPEND_ARG(*argv, i++, "--except-interface");
|
|
|
|
APPEND_ARG(*argv, i++, "lo");
|
|
|
|
|
|
|
|
/*
|
|
|
|
* NB, dnsmasq command line arg bug means we need to
|
|
|
|
* use a single arg '--dhcp-leasefile=path' rather than
|
|
|
|
* two separate args in '--dhcp-leasefile path' style
|
|
|
|
*/
|
|
|
|
snprintf(buf, sizeof(buf), "--dhcp-leasefile=%s/lib/libvirt/dhcp-%s.leases",
|
|
|
|
LOCAL_STATE_DIR, network->def->name);
|
|
|
|
APPEND_ARG(*argv, i++, buf);
|
|
|
|
|
2008-07-11 17:33:45 +00:00
|
|
|
for (r = 0 ; r < network->def->nranges ; r++) {
|
2007-06-26 20:41:25 +00:00
|
|
|
snprintf(buf, sizeof(buf), "%s,%s",
|
2008-07-11 17:33:45 +00:00
|
|
|
network->def->ranges[r].start,
|
|
|
|
network->def->ranges[r].end);
|
2007-06-26 20:41:25 +00:00
|
|
|
|
|
|
|
APPEND_ARG(*argv, i++, "--dhcp-range");
|
|
|
|
APPEND_ARG(*argv, i++, buf);
|
|
|
|
}
|
|
|
|
|
2008-08-20 12:50:29 +00:00
|
|
|
for (r = 0 ; r < network->def->nhosts ; r++) {
|
|
|
|
virNetworkDHCPHostDefPtr host = &(network->def->hosts[r]);
|
|
|
|
if ((host->mac) && (host->name)) {
|
|
|
|
snprintf(buf, sizeof(buf), "%s,%s,%s",
|
|
|
|
host->mac, host->name, host->ip);
|
|
|
|
} else if (host->mac) {
|
|
|
|
snprintf(buf, sizeof(buf), "%s,%s",
|
|
|
|
host->mac, host->ip);
|
|
|
|
} else if (host->name) {
|
|
|
|
snprintf(buf, sizeof(buf), "%s,%s",
|
|
|
|
host->name, host->ip);
|
|
|
|
} else
|
|
|
|
continue;
|
|
|
|
|
|
|
|
APPEND_ARG(*argv, i++, "--dhcp-host");
|
|
|
|
APPEND_ARG(*argv, i++, buf);
|
|
|
|
}
|
|
|
|
|
2007-06-26 20:41:25 +00:00
|
|
|
#undef APPEND_ARG
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
|
|
|
|
no_memory:
|
|
|
|
if (argv) {
|
|
|
|
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:41:25 +00:00
|
|
|
}
|
qemudReportError: mark for translation string args to this function
* Makefile.maint (msg_gen_function): Add qemudReportError.
* src/qemu_conf.c (qemudLoadDriverConfig)
(qemudExtractVersion, qemudParseDiskXML, qemudParseInterfaceXML)
(qemudParseInputXML, qemudParseXML, qemudNetworkIfaceConnect)
(qemudBuildCommandLine, qemudSaveConfig, qemudParseVMDeviceDef)
(qemudAssignVMDef, qemudSaveVMDef, qemudSaveNetworkConfig)
(qemudParseDhcpRangesXML, qemudParseNetworkXML)
(qemudAssignNetworkDef, qemudSaveNetworkDef, qemudGenerateXML)
(qemudGenerateNetworkXML, qemudDeleteConfig): Mark strings.
* src/qemu_driver.c (qemudBuildDnsmasqArgv, qemudAddIptablesRules)
(qemudGetCapabilities, qemudDomainGetOSType)
(qemudListDefinedDomains, qemudListNetworks)
(qemudListDefinedNetworks, qemudNetworkGetBridgeName): Mark strings.
2008-03-27 13:53:14 +00:00
|
|
|
qemudReportError(conn, NULL, NULL, VIR_ERR_NO_MEMORY,
|
|
|
|
"%s", _("failed to allocate space for dnsmasq argv"));
|
2007-06-26 20:41:25 +00:00
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
static int
|
2007-07-12 15:09:01 +00:00
|
|
|
dhcpStartDhcpDaemon(virConnectPtr conn,
|
2008-07-11 17:33:45 +00:00
|
|
|
virNetworkObjPtr network)
|
2007-06-26 20:41:25 +00:00
|
|
|
{
|
2008-08-08 15:43:38 +00:00
|
|
|
const char **argv;
|
2007-06-26 20:41:25 +00:00
|
|
|
int ret, i;
|
|
|
|
|
2008-07-11 17:33:45 +00:00
|
|
|
if (network->def->ipAddress == NULL) {
|
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", _("cannot start dhcp daemon without IP address for server"));
|
2007-06-26 20:41:25 +00:00
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
|
|
|
|
argv = NULL;
|
2007-07-12 15:09:01 +00:00
|
|
|
if (qemudBuildDnsmasqArgv(conn, network, &argv) < 0)
|
2007-06-26 20:41:25 +00:00
|
|
|
return -1;
|
|
|
|
|
2008-08-20 09:24:14 +00:00
|
|
|
ret = virExec(conn, argv, NULL, &network->dnsmasqPid, -1, NULL, NULL, VIR_EXEC_NONBLOCK);
|
2007-06-26 20:41:25 +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:41:25 +00:00
|
|
|
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
2008-03-28 20:38:21 +00:00
|
|
|
static int
|
|
|
|
qemudAddMasqueradingIptablesRules(virConnectPtr conn,
|
|
|
|
struct qemud_driver *driver,
|
2008-07-11 17:33:45 +00:00
|
|
|
virNetworkObjPtr network) {
|
2008-03-28 20:38:21 +00:00
|
|
|
int err;
|
|
|
|
/* allow forwarding packets from the bridge interface */
|
|
|
|
if ((err = iptablesAddForwardAllowOut(driver->iptables,
|
|
|
|
network->def->network,
|
2008-07-11 17:33:45 +00:00
|
|
|
network->def->bridge,
|
2008-03-28 20:38:21 +00:00
|
|
|
network->def->forwardDev))) {
|
|
|
|
qemudReportError(conn, NULL, NULL, VIR_ERR_INTERNAL_ERROR,
|
|
|
|
_("failed to add iptables rule to allow forwarding from '%s' : %s\n"),
|
2008-07-11 17:33:45 +00:00
|
|
|
network->def->bridge, strerror(err));
|
2008-03-28 20:38:21 +00:00
|
|
|
goto masqerr1;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* allow forwarding packets to the bridge interface if they are part of an existing connection */
|
|
|
|
if ((err = iptablesAddForwardAllowRelatedIn(driver->iptables,
|
|
|
|
network->def->network,
|
2008-07-11 17:33:45 +00:00
|
|
|
network->def->bridge,
|
2008-03-28 20:38:21 +00:00
|
|
|
network->def->forwardDev))) {
|
|
|
|
qemudReportError(conn, NULL, NULL, VIR_ERR_INTERNAL_ERROR,
|
|
|
|
_("failed to add iptables rule to allow forwarding to '%s' : %s\n"),
|
2008-07-11 17:33:45 +00:00
|
|
|
network->def->bridge, strerror(err));
|
2008-03-28 20:38:21 +00:00
|
|
|
goto masqerr2;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* enable masquerading */
|
|
|
|
if ((err = iptablesAddForwardMasquerade(driver->iptables,
|
|
|
|
network->def->network,
|
|
|
|
network->def->forwardDev))) {
|
|
|
|
qemudReportError(conn, NULL, NULL, VIR_ERR_INTERNAL_ERROR,
|
|
|
|
_("failed to add iptables rule to enable masquerading : %s\n"),
|
|
|
|
strerror(err));
|
|
|
|
goto masqerr3;
|
|
|
|
}
|
|
|
|
|
|
|
|
return 1;
|
|
|
|
|
|
|
|
masqerr3:
|
|
|
|
iptablesRemoveForwardAllowRelatedIn(driver->iptables,
|
|
|
|
network->def->network,
|
2008-07-11 17:33:45 +00:00
|
|
|
network->def->bridge,
|
2008-03-28 20:38:21 +00:00
|
|
|
network->def->forwardDev);
|
|
|
|
masqerr2:
|
|
|
|
iptablesRemoveForwardAllowOut(driver->iptables,
|
|
|
|
network->def->network,
|
2008-07-11 17:33:45 +00:00
|
|
|
network->def->bridge,
|
2008-03-28 20:38:21 +00:00
|
|
|
network->def->forwardDev);
|
|
|
|
masqerr1:
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
static int
|
|
|
|
qemudAddRoutingIptablesRules(virConnectPtr conn,
|
|
|
|
struct qemud_driver *driver,
|
2008-07-11 17:33:45 +00:00
|
|
|
virNetworkObjPtr network) {
|
2008-03-28 20:38:21 +00:00
|
|
|
int err;
|
|
|
|
/* allow routing packets from the bridge interface */
|
|
|
|
if ((err = iptablesAddForwardAllowOut(driver->iptables,
|
|
|
|
network->def->network,
|
2008-07-11 17:33:45 +00:00
|
|
|
network->def->bridge,
|
2008-03-28 20:38:21 +00:00
|
|
|
network->def->forwardDev))) {
|
|
|
|
qemudReportError(conn, NULL, NULL, VIR_ERR_INTERNAL_ERROR,
|
|
|
|
_("failed to add iptables rule to allow routing from '%s' : %s\n"),
|
2008-07-11 17:33:45 +00:00
|
|
|
network->def->bridge, strerror(err));
|
2008-03-28 20:38:21 +00:00
|
|
|
goto routeerr1;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* allow routing packets to the bridge interface */
|
|
|
|
if ((err = iptablesAddForwardAllowIn(driver->iptables,
|
|
|
|
network->def->network,
|
2008-07-11 17:33:45 +00:00
|
|
|
network->def->bridge,
|
2008-03-28 20:38:21 +00:00
|
|
|
network->def->forwardDev))) {
|
|
|
|
qemudReportError(conn, NULL, NULL, VIR_ERR_INTERNAL_ERROR,
|
|
|
|
_("failed to add iptables rule to allow routing to '%s' : %s\n"),
|
2008-07-11 17:33:45 +00:00
|
|
|
network->def->bridge, strerror(err));
|
2008-03-28 20:38:21 +00:00
|
|
|
goto routeerr2;
|
|
|
|
}
|
|
|
|
|
|
|
|
return 1;
|
|
|
|
|
|
|
|
|
|
|
|
routeerr2:
|
|
|
|
iptablesRemoveForwardAllowOut(driver->iptables,
|
|
|
|
network->def->network,
|
2008-07-11 17:33:45 +00:00
|
|
|
network->def->bridge,
|
2008-03-28 20:38:21 +00:00
|
|
|
network->def->forwardDev);
|
|
|
|
routeerr1:
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2007-06-26 20:41:25 +00:00
|
|
|
static int
|
2007-07-12 15:09:01 +00:00
|
|
|
qemudAddIptablesRules(virConnectPtr conn,
|
|
|
|
struct qemud_driver *driver,
|
2008-07-11 17:33:45 +00:00
|
|
|
virNetworkObjPtr network) {
|
2007-06-26 20:41:25 +00:00
|
|
|
int err;
|
|
|
|
|
2007-06-26 22:13:21 +00:00
|
|
|
if (!driver->iptables && !(driver->iptables = iptablesContextNew())) {
|
qemudReportError: mark for translation string args to this function
* Makefile.maint (msg_gen_function): Add qemudReportError.
* src/qemu_conf.c (qemudLoadDriverConfig)
(qemudExtractVersion, qemudParseDiskXML, qemudParseInterfaceXML)
(qemudParseInputXML, qemudParseXML, qemudNetworkIfaceConnect)
(qemudBuildCommandLine, qemudSaveConfig, qemudParseVMDeviceDef)
(qemudAssignVMDef, qemudSaveVMDef, qemudSaveNetworkConfig)
(qemudParseDhcpRangesXML, qemudParseNetworkXML)
(qemudAssignNetworkDef, qemudSaveNetworkDef, qemudGenerateXML)
(qemudGenerateNetworkXML, qemudDeleteConfig): Mark strings.
* src/qemu_driver.c (qemudBuildDnsmasqArgv, qemudAddIptablesRules)
(qemudGetCapabilities, qemudDomainGetOSType)
(qemudListDefinedDomains, qemudListNetworks)
(qemudListDefinedNetworks, qemudNetworkGetBridgeName): Mark strings.
2008-03-27 13:53:14 +00:00
|
|
|
qemudReportError(conn, NULL, NULL, VIR_ERR_NO_MEMORY,
|
|
|
|
"%s", _("failed to allocate space for IP tables support"));
|
2008-06-12 13:47:38 +00:00
|
|
|
return 0;
|
2007-06-26 20:41:25 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
/* allow DHCP requests through to dnsmasq */
|
2008-07-11 17:33:45 +00:00
|
|
|
if ((err = iptablesAddTcpInput(driver->iptables, network->def->bridge, 67))) {
|
2007-07-12 15:09:01 +00:00
|
|
|
qemudReportError(conn, NULL, NULL, VIR_ERR_INTERNAL_ERROR,
|
2008-03-24 10:58:21 +00:00
|
|
|
_("failed to add iptables rule to allow DHCP requests from '%s' : %s"),
|
2008-07-11 17:33:45 +00:00
|
|
|
network->def->bridge, strerror(err));
|
2007-06-26 20:41:25 +00:00
|
|
|
goto err1;
|
|
|
|
}
|
|
|
|
|
2008-07-11 17:33:45 +00:00
|
|
|
if ((err = iptablesAddUdpInput(driver->iptables, network->def->bridge, 67))) {
|
2007-07-12 15:09:01 +00:00
|
|
|
qemudReportError(conn, NULL, NULL, VIR_ERR_INTERNAL_ERROR,
|
2008-03-24 10:58:21 +00:00
|
|
|
_("failed to add iptables rule to allow DHCP requests from '%s' : %s"),
|
2008-07-11 17:33:45 +00:00
|
|
|
network->def->bridge, strerror(err));
|
2007-06-26 20:41:25 +00:00
|
|
|
goto err2;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* allow DNS requests through to dnsmasq */
|
2008-07-11 17:33:45 +00:00
|
|
|
if ((err = iptablesAddTcpInput(driver->iptables, network->def->bridge, 53))) {
|
2007-07-12 15:09:01 +00:00
|
|
|
qemudReportError(conn, NULL, NULL, VIR_ERR_INTERNAL_ERROR,
|
2008-03-24 10:58:21 +00:00
|
|
|
_("failed to add iptables rule to allow DNS requests from '%s' : %s"),
|
2008-07-11 17:33:45 +00:00
|
|
|
network->def->bridge, strerror(err));
|
2007-06-26 20:41:25 +00:00
|
|
|
goto err3;
|
|
|
|
}
|
|
|
|
|
2008-07-11 17:33:45 +00:00
|
|
|
if ((err = iptablesAddUdpInput(driver->iptables, network->def->bridge, 53))) {
|
2007-07-12 15:09:01 +00:00
|
|
|
qemudReportError(conn, NULL, NULL, VIR_ERR_INTERNAL_ERROR,
|
2008-03-24 10:58:21 +00:00
|
|
|
_("failed to add iptables rule to allow DNS requests from '%s' : %s"),
|
2008-07-11 17:33:45 +00:00
|
|
|
network->def->bridge, strerror(err));
|
2007-06-26 20:41:25 +00:00
|
|
|
goto err4;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
/* Catch all rules to block forwarding to/from bridges */
|
|
|
|
|
2008-07-11 17:33:45 +00:00
|
|
|
if ((err = iptablesAddForwardRejectOut(driver->iptables, network->def->bridge))) {
|
2007-07-12 15:09:01 +00:00
|
|
|
qemudReportError(conn, NULL, NULL, VIR_ERR_INTERNAL_ERROR,
|
2008-03-24 10:58:21 +00:00
|
|
|
_("failed to add iptables rule to block outbound traffic from '%s' : %s"),
|
2008-07-11 17:33:45 +00:00
|
|
|
network->def->bridge, strerror(err));
|
2007-06-26 20:41:25 +00:00
|
|
|
goto err5;
|
|
|
|
}
|
|
|
|
|
2008-07-11 17:33:45 +00:00
|
|
|
if ((err = iptablesAddForwardRejectIn(driver->iptables, network->def->bridge))) {
|
2007-07-12 15:09:01 +00:00
|
|
|
qemudReportError(conn, NULL, NULL, VIR_ERR_INTERNAL_ERROR,
|
2008-03-24 10:58:21 +00:00
|
|
|
_("failed to add iptables rule to block inbound traffic to '%s' : %s"),
|
2008-07-11 17:33:45 +00:00
|
|
|
network->def->bridge, strerror(err));
|
2007-06-26 20:41:25 +00:00
|
|
|
goto err6;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Allow traffic between guests on the same bridge */
|
2008-07-11 17:33:45 +00:00
|
|
|
if ((err = iptablesAddForwardAllowCross(driver->iptables, network->def->bridge))) {
|
2007-07-12 15:09:01 +00:00
|
|
|
qemudReportError(conn, NULL, NULL, VIR_ERR_INTERNAL_ERROR,
|
2008-03-24 10:58:21 +00:00
|
|
|
_("failed to add iptables rule to allow cross bridge traffic on '%s' : %s"),
|
2008-07-11 17:33:45 +00:00
|
|
|
network->def->bridge, strerror(err));
|
2007-06-26 20:41:25 +00:00
|
|
|
goto err7;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
2008-07-11 17:33:45 +00:00
|
|
|
/* If masquerading is enabled, set up the rules*/
|
|
|
|
if (network->def->forwardType == VIR_NETWORK_FORWARD_NAT &&
|
|
|
|
!qemudAddMasqueradingIptablesRules(conn, driver, network))
|
|
|
|
goto err8;
|
|
|
|
/* else if routing is enabled, set up the rules*/
|
|
|
|
else if (network->def->forwardType == VIR_NETWORK_FORWARD_ROUTE &&
|
|
|
|
!qemudAddRoutingIptablesRules(conn, driver, network))
|
|
|
|
goto err8;
|
2007-06-26 20:41:25 +00:00
|
|
|
|
2008-06-12 13:47:38 +00:00
|
|
|
iptablesSaveRules(driver->iptables);
|
|
|
|
|
|
|
|
return 1;
|
2007-06-26 20:41:25 +00:00
|
|
|
|
2008-06-12 13:47:38 +00:00
|
|
|
err8:
|
2007-06-26 22:13:21 +00:00
|
|
|
iptablesRemoveForwardAllowCross(driver->iptables,
|
2008-07-11 17:33:45 +00:00
|
|
|
network->def->bridge);
|
2007-06-26 20:41:25 +00:00
|
|
|
err7:
|
2007-06-26 22:13:21 +00:00
|
|
|
iptablesRemoveForwardRejectIn(driver->iptables,
|
2008-07-11 17:33:45 +00:00
|
|
|
network->def->bridge);
|
2007-06-26 20:41:25 +00:00
|
|
|
err6:
|
2007-06-26 22:13:21 +00:00
|
|
|
iptablesRemoveForwardRejectOut(driver->iptables,
|
2008-07-11 17:33:45 +00:00
|
|
|
network->def->bridge);
|
2007-06-26 20:41:25 +00:00
|
|
|
err5:
|
2008-07-11 17:33:45 +00:00
|
|
|
iptablesRemoveUdpInput(driver->iptables, network->def->bridge, 53);
|
2007-06-26 20:41:25 +00:00
|
|
|
err4:
|
2008-07-11 17:33:45 +00:00
|
|
|
iptablesRemoveTcpInput(driver->iptables, network->def->bridge, 53);
|
2007-06-26 20:41:25 +00:00
|
|
|
err3:
|
2008-07-11 17:33:45 +00:00
|
|
|
iptablesRemoveUdpInput(driver->iptables, network->def->bridge, 67);
|
2007-06-26 20:41:25 +00:00
|
|
|
err2:
|
2008-07-11 17:33:45 +00:00
|
|
|
iptablesRemoveTcpInput(driver->iptables, network->def->bridge, 67);
|
2007-06-26 20:41:25 +00:00
|
|
|
err1:
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
static void
|
2007-06-26 22:13:21 +00:00
|
|
|
qemudRemoveIptablesRules(struct qemud_driver *driver,
|
2008-07-11 17:33:45 +00:00
|
|
|
virNetworkObjPtr network) {
|
|
|
|
if (network->def->forwardType != VIR_NETWORK_FORWARD_NONE) {
|
2007-06-26 22:13:21 +00:00
|
|
|
iptablesRemoveForwardMasquerade(driver->iptables,
|
2008-05-22 15:49:50 +00:00
|
|
|
network->def->network,
|
|
|
|
network->def->forwardDev);
|
|
|
|
|
2008-07-11 17:33:45 +00:00
|
|
|
if (network->def->forwardType == VIR_NETWORK_FORWARD_NAT)
|
2008-05-22 15:49:50 +00:00
|
|
|
iptablesRemoveForwardAllowRelatedIn(driver->iptables,
|
|
|
|
network->def->network,
|
2008-07-11 17:33:45 +00:00
|
|
|
network->def->bridge,
|
2008-05-22 15:49:50 +00:00
|
|
|
network->def->forwardDev);
|
2008-07-11 17:33:45 +00:00
|
|
|
else if (network->def->forwardType == VIR_NETWORK_FORWARD_ROUTE)
|
2008-05-22 15:49:50 +00:00
|
|
|
iptablesRemoveForwardAllowIn(driver->iptables,
|
|
|
|
network->def->network,
|
2008-07-11 17:33:45 +00:00
|
|
|
network->def->bridge,
|
2008-05-22 15:49:50 +00:00
|
|
|
network->def->forwardDev);
|
|
|
|
|
2007-06-26 22:13:21 +00:00
|
|
|
iptablesRemoveForwardAllowOut(driver->iptables,
|
2007-06-26 20:41:25 +00:00
|
|
|
network->def->network,
|
2008-07-11 17:33:45 +00:00
|
|
|
network->def->bridge,
|
2007-06-26 20:41:25 +00:00
|
|
|
network->def->forwardDev);
|
|
|
|
}
|
2008-07-11 17:33:45 +00:00
|
|
|
iptablesRemoveForwardAllowCross(driver->iptables, network->def->bridge);
|
|
|
|
iptablesRemoveForwardRejectIn(driver->iptables, network->def->bridge);
|
|
|
|
iptablesRemoveForwardRejectOut(driver->iptables, network->def->bridge);
|
|
|
|
iptablesRemoveUdpInput(driver->iptables, network->def->bridge, 53);
|
|
|
|
iptablesRemoveTcpInput(driver->iptables, network->def->bridge, 53);
|
|
|
|
iptablesRemoveUdpInput(driver->iptables, network->def->bridge, 67);
|
|
|
|
iptablesRemoveTcpInput(driver->iptables, network->def->bridge, 67);
|
2008-01-10 14:01:00 +00:00
|
|
|
iptablesSaveRules(driver->iptables);
|
2007-06-26 20:41:25 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
static int
|
|
|
|
qemudEnableIpForwarding(void)
|
|
|
|
{
|
|
|
|
#define PROC_IP_FORWARD "/proc/sys/net/ipv4/ip_forward"
|
|
|
|
|
|
|
|
int fd, ret;
|
|
|
|
|
|
|
|
if ((fd = open(PROC_IP_FORWARD, O_WRONLY|O_TRUNC)) == -1)
|
|
|
|
return 0;
|
|
|
|
|
Use safewrite in place of write, in many cases.
Also add "make syntax-check" rules to ensure no new uses sneak in.
There are many uses of write like this:
if (write (fd, xml, towrite) != towrite)
return -1;
The problem is that the syscall can succeed, yet write less than
the requested number of bytes, so the caller should retry
rather than simply failing.
This patch changes most of them to use util.c's safewrite wrapper,
which encapsulates the process. Also, there were a few cases in
which the retry loop was open-coded, and I replaced those, too.
* Makefile.maint (sc_avoid_write): New rule, to avoid recurrence.
* .x-sc_avoid_write: New file. Record two legitimate exemptions.
* qemud/qemud.c (sig_handler, qemudClientWriteBuf): Use safewrite, not write.
* src/conf.c (__virConfWriteFile): Likewise.
* src/qemu_conf.c (qemudSaveConfig, qemudSaveNetworkConfig): Likewise.
* src/qemu_driver.c (qemudWaitForMonitor, qemudStartVMDaemon)
(qemudVMData, PROC_IP_FORWARD): Likewise.
* proxy/libvirt_proxy.c: Include "util.h".
(proxyWriteClientSocket): Use safewrite.
* src/test.c (testDomainSave, testDomainCoreDump): Likewise.
* src/proxy_internal.c (virProxyWriteClientSocket): Likewise.
* src/virsh.c: Include "util-lib.h".
(vshOutputLogFile): Use safewrite.
* src/console.c: Include "util-lib.h".
(vshRunConsole): Use safewrite.
2008-02-22 15:55:04 +00:00
|
|
|
if (safewrite(fd, "1\n", 2) < 0)
|
2007-06-26 20:41:25 +00:00
|
|
|
ret = 0;
|
|
|
|
|
|
|
|
close (fd);
|
|
|
|
|
|
|
|
return 1;
|
|
|
|
|
|
|
|
#undef PROC_IP_FORWARD
|
|
|
|
}
|
|
|
|
|
2007-07-12 15:09:01 +00:00
|
|
|
static int qemudStartNetworkDaemon(virConnectPtr conn,
|
|
|
|
struct qemud_driver *driver,
|
2008-07-11 17:33:45 +00:00
|
|
|
virNetworkObjPtr network) {
|
2007-06-26 20:41:25 +00:00
|
|
|
int err;
|
|
|
|
|
2008-07-11 17:33:45 +00:00
|
|
|
if (virNetworkIsActive(network)) {
|
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", _("network is already active"));
|
2007-06-26 20:41:25 +00:00
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
|
2007-06-26 22:13:21 +00:00
|
|
|
if (!driver->brctl && (err = brInit(&driver->brctl))) {
|
2007-07-12 15:09:01 +00:00
|
|
|
qemudReportError(conn, NULL, NULL, VIR_ERR_INTERNAL_ERROR,
|
2008-03-24 10:51:47 +00:00
|
|
|
_("cannot initialize bridge support: %s"), strerror(err));
|
2007-06-26 20:41:25 +00:00
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
|
2008-07-11 17:33:45 +00:00
|
|
|
if ((err = brAddBridge(driver->brctl, &network->def->bridge))) {
|
2007-07-12 15:09:01 +00:00
|
|
|
qemudReportError(conn, NULL, NULL, VIR_ERR_INTERNAL_ERROR,
|
2008-07-11 17:33:45 +00:00
|
|
|
_("cannot create bridge '%s' : %s"),
|
|
|
|
network->def->bridge, strerror(err));
|
2007-06-26 20:41:25 +00:00
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
|
2007-06-26 23:01:54 +00:00
|
|
|
|
2008-08-01 12:56:52 +00:00
|
|
|
if ((err = brSetForwardDelay(driver->brctl, network->def->bridge, network->def->delay))) {
|
2007-07-12 15:09:01 +00:00
|
|
|
qemudReportError(conn, NULL, NULL, VIR_ERR_INTERNAL_ERROR,
|
2008-07-11 17:33:45 +00:00
|
|
|
_("failed to set bridge forward delay to %ld"),
|
|
|
|
network->def->delay);
|
2007-06-26 23:01:54 +00:00
|
|
|
goto err_delbr;
|
|
|
|
}
|
|
|
|
|
2008-07-11 17:33:45 +00:00
|
|
|
if ((err = brSetEnableSTP(driver->brctl, network->def->bridge, network->def->stp ? 1 : 0))) {
|
2007-07-12 15:09:01 +00:00
|
|
|
qemudReportError(conn, NULL, NULL, VIR_ERR_INTERNAL_ERROR,
|
2008-03-24 10:58:21 +00:00
|
|
|
_("failed to set bridge STP to %s"),
|
2008-07-11 17:33:45 +00:00
|
|
|
network->def->stp ? "on" : "off");
|
2007-06-26 23:01:54 +00:00
|
|
|
goto err_delbr;
|
|
|
|
}
|
|
|
|
|
2008-07-11 17:33:45 +00:00
|
|
|
if (network->def->ipAddress &&
|
|
|
|
(err = brSetInetAddress(driver->brctl, network->def->bridge, network->def->ipAddress))) {
|
2007-07-12 15:09:01 +00:00
|
|
|
qemudReportError(conn, NULL, NULL, VIR_ERR_INTERNAL_ERROR,
|
2008-03-24 10:58:21 +00:00
|
|
|
_("cannot set IP address on bridge '%s' to '%s' : %s"),
|
2008-07-11 17:33:45 +00:00
|
|
|
network->def->bridge, network->def->ipAddress, strerror(err));
|
2007-06-26 20:41:25 +00:00
|
|
|
goto err_delbr;
|
|
|
|
}
|
|
|
|
|
2008-07-11 17:33:45 +00:00
|
|
|
if (network->def->netmask &&
|
|
|
|
(err = brSetInetNetmask(driver->brctl, network->def->bridge, network->def->netmask))) {
|
2007-07-12 15:09:01 +00:00
|
|
|
qemudReportError(conn, NULL, NULL, VIR_ERR_INTERNAL_ERROR,
|
2008-03-24 10:58:21 +00:00
|
|
|
_("cannot set netmask on bridge '%s' to '%s' : %s"),
|
2008-07-11 17:33:45 +00:00
|
|
|
network->def->bridge, network->def->netmask, strerror(err));
|
2007-06-26 20:41:25 +00:00
|
|
|
goto err_delbr;
|
|
|
|
}
|
|
|
|
|
2008-07-11 17:33:45 +00:00
|
|
|
if (network->def->ipAddress &&
|
|
|
|
(err = brSetInterfaceUp(driver->brctl, network->def->bridge, 1))) {
|
2007-07-12 15:09:01 +00:00
|
|
|
qemudReportError(conn, NULL, NULL, VIR_ERR_INTERNAL_ERROR,
|
2008-03-24 10:58:21 +00:00
|
|
|
_("failed to bring the bridge '%s' up : %s"),
|
2008-07-11 17:33:45 +00:00
|
|
|
network->def->bridge, strerror(err));
|
2007-06-26 20:41:25 +00:00
|
|
|
goto err_delbr;
|
|
|
|
}
|
|
|
|
|
2007-07-12 15:09:01 +00:00
|
|
|
if (!qemudAddIptablesRules(conn, driver, network))
|
2007-06-26 20:41:25 +00:00
|
|
|
goto err_delbr1;
|
|
|
|
|
2008-07-11 17:33:45 +00:00
|
|
|
if (network->def->forwardType != VIR_NETWORK_FORWARD_NONE &&
|
2007-06-26 20:41:25 +00:00
|
|
|
!qemudEnableIpForwarding()) {
|
2007-07-12 15:09:01 +00:00
|
|
|
qemudReportError(conn, NULL, NULL, VIR_ERR_INTERNAL_ERROR,
|
2008-03-24 10:58:21 +00:00
|
|
|
_("failed to enable IP forwarding : %s"), strerror(err));
|
2007-06-26 20:41:25 +00:00
|
|
|
goto err_delbr2;
|
|
|
|
}
|
|
|
|
|
2008-07-11 17:33:45 +00:00
|
|
|
if (network->def->nranges &&
|
2007-07-12 15:09:01 +00:00
|
|
|
dhcpStartDhcpDaemon(conn, network) < 0)
|
2007-06-26 20:41:25 +00:00
|
|
|
goto err_delbr2;
|
|
|
|
|
|
|
|
network->active = 1;
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
|
|
|
|
err_delbr2:
|
2007-06-26 22:13:21 +00:00
|
|
|
qemudRemoveIptablesRules(driver, network);
|
2007-06-26 20:41:25 +00:00
|
|
|
|
|
|
|
err_delbr1:
|
2008-07-11 17:33:45 +00:00
|
|
|
if (network->def->ipAddress &&
|
|
|
|
(err = brSetInterfaceUp(driver->brctl, network->def->bridge, 0))) {
|
2008-08-01 11:24:04 +00:00
|
|
|
qemudLog(QEMUD_WARN, _("Failed to bring down bridge '%s' : %s\n"),
|
2008-07-11 17:33:45 +00:00
|
|
|
network->def->bridge, strerror(err));
|
2007-06-26 20:41:25 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
err_delbr:
|
2008-07-11 17:33:45 +00:00
|
|
|
if ((err = brDeleteBridge(driver->brctl, network->def->bridge))) {
|
2008-08-01 11:24:04 +00:00
|
|
|
qemudLog(QEMUD_WARN, _("Failed to delete bridge '%s' : %s\n"),
|
2008-07-11 17:33:45 +00:00
|
|
|
network->def->bridge, strerror(err));
|
2007-06-26 20:41:25 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
2007-07-12 15:09:01 +00:00
|
|
|
static int qemudShutdownNetworkDaemon(virConnectPtr conn ATTRIBUTE_UNUSED,
|
|
|
|
struct qemud_driver *driver,
|
2008-07-11 17:33:45 +00:00
|
|
|
virNetworkObjPtr network) {
|
2007-06-26 20:41:25 +00:00
|
|
|
int err;
|
|
|
|
|
2008-08-01 11:24:04 +00:00
|
|
|
qemudLog(QEMUD_INFO, _("Shutting down network '%s'\n"), network->def->name);
|
2007-06-26 20:41:25 +00:00
|
|
|
|
2008-07-11 17:33:45 +00:00
|
|
|
if (!virNetworkIsActive(network))
|
2007-06-26 20:41:25 +00:00
|
|
|
return 0;
|
|
|
|
|
|
|
|
if (network->dnsmasqPid > 0)
|
|
|
|
kill(network->dnsmasqPid, SIGTERM);
|
|
|
|
|
2007-06-26 22:13:21 +00:00
|
|
|
qemudRemoveIptablesRules(driver, network);
|
2007-06-26 20:41:25 +00:00
|
|
|
|
2008-07-11 17:33:45 +00:00
|
|
|
if (network->def->ipAddress &&
|
|
|
|
(err = brSetInterfaceUp(driver->brctl, network->def->bridge, 0))) {
|
2008-08-01 11:24:04 +00:00
|
|
|
qemudLog(QEMUD_WARN, _("Failed to bring down bridge '%s' : %s\n"),
|
2008-07-11 17:33:45 +00:00
|
|
|
network->def->bridge, strerror(err));
|
2007-06-26 20:41:25 +00:00
|
|
|
}
|
|
|
|
|
2008-07-11 17:33:45 +00:00
|
|
|
if ((err = brDeleteBridge(driver->brctl, network->def->bridge))) {
|
2008-08-01 11:24:04 +00:00
|
|
|
qemudLog(QEMUD_WARN, _("Failed to delete bridge '%s' : %s\n"),
|
2008-07-11 17:33:45 +00:00
|
|
|
network->def->bridge, strerror(err));
|
2007-06-26 20:41:25 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
if (network->dnsmasqPid > 0 &&
|
|
|
|
waitpid(network->dnsmasqPid, NULL, WNOHANG) != network->dnsmasqPid) {
|
|
|
|
kill(network->dnsmasqPid, SIGKILL);
|
|
|
|
if (waitpid(network->dnsmasqPid, NULL, 0) != network->dnsmasqPid)
|
2008-02-22 16:26:13 +00:00
|
|
|
qemudLog(QEMUD_WARN,
|
2008-08-01 11:24:04 +00:00
|
|
|
"%s", _("Got unexpected pid for dnsmasq\n"));
|
2007-06-26 20:41:25 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
network->dnsmasqPid = -1;
|
|
|
|
network->active = 0;
|
|
|
|
|
|
|
|
if (network->newDef) {
|
2008-07-11 17:33:45 +00:00
|
|
|
virNetworkDefFree(network->def);
|
2007-06-26 20:41:25 +00:00
|
|
|
network->def = network->newDef;
|
|
|
|
network->newDef = NULL;
|
|
|
|
}
|
|
|
|
|
2008-07-11 17:33:45 +00:00
|
|
|
if (!network->configFile)
|
|
|
|
virNetworkRemoveInactive(&driver->networks,
|
|
|
|
network);
|
2007-06-26 20:45:21 +00:00
|
|
|
|
2007-06-26 20:41:25 +00:00
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
static void qemudDispatchVMEvent(int fd, int events, void *opaque) {
|
2007-06-26 22:13:21 +00:00
|
|
|
struct qemud_driver *driver = (struct qemud_driver *)opaque;
|
2008-07-11 19:34:11 +00:00
|
|
|
virDomainObjPtr vm = driver->domains;
|
2007-06-26 20:41:25 +00:00
|
|
|
|
|
|
|
while (vm) {
|
2008-07-11 19:34:11 +00:00
|
|
|
if (virDomainIsActive(vm) &&
|
2008-08-12 08:38:22 +00:00
|
|
|
(vm->stdout_fd == fd ||
|
|
|
|
vm->stderr_fd == fd))
|
2007-06-26 20:41:25 +00:00
|
|
|
break;
|
|
|
|
|
|
|
|
vm = vm->next;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (!vm)
|
|
|
|
return;
|
|
|
|
|
2007-06-26 20:45:21 +00:00
|
|
|
if (events == POLLIN)
|
2007-06-26 22:13:21 +00:00
|
|
|
qemudDispatchVMLog(driver, vm, fd);
|
2007-06-26 20:45:21 +00:00
|
|
|
else
|
2007-06-26 22:13:21 +00:00
|
|
|
qemudDispatchVMFailure(driver, vm, fd);
|
2007-06-26 20:41:25 +00:00
|
|
|
}
|
|
|
|
|
2008-02-26 18:41:43 +00:00
|
|
|
static int
|
|
|
|
qemudMonitorCommand (const struct qemud_driver *driver ATTRIBUTE_UNUSED,
|
2008-07-11 19:34:11 +00:00
|
|
|
const virDomainObjPtr vm,
|
2008-02-26 18:41:43 +00:00
|
|
|
const char *cmd,
|
|
|
|
char **reply) {
|
2007-02-14 01:40:09 +00:00
|
|
|
int size = 0;
|
|
|
|
char *buf = NULL;
|
2007-10-27 01:16:53 +00:00
|
|
|
size_t cmdlen = strlen(cmd);
|
2007-03-05 17:15:20 +00:00
|
|
|
|
2007-10-27 01:16:53 +00:00
|
|
|
if (safewrite(vm->monitor, cmd, cmdlen) != cmdlen)
|
|
|
|
return -1;
|
|
|
|
if (safewrite(vm->monitor, "\r", 1) != 1)
|
2007-02-14 01:40:09 +00:00
|
|
|
return -1;
|
|
|
|
|
|
|
|
*reply = NULL;
|
|
|
|
|
|
|
|
for (;;) {
|
|
|
|
struct pollfd fd = { vm->monitor, POLLIN | POLLERR | POLLHUP, 0 };
|
|
|
|
char *tmp;
|
|
|
|
|
|
|
|
/* Read all the data QEMU has sent thus far */
|
|
|
|
for (;;) {
|
|
|
|
char data[1024];
|
|
|
|
int got = read(vm->monitor, data, sizeof(data));
|
2007-03-05 17:15:20 +00:00
|
|
|
|
2007-10-27 01:16:53 +00:00
|
|
|
if (got == 0)
|
|
|
|
goto error;
|
2007-02-14 01:40:09 +00:00
|
|
|
if (got < 0) {
|
|
|
|
if (errno == EINTR)
|
|
|
|
continue;
|
|
|
|
if (errno == EAGAIN)
|
|
|
|
break;
|
2007-10-27 01:16:53 +00:00
|
|
|
goto error;
|
2007-06-22 10:14:48 +00:00
|
|
|
}
|
2008-05-29 19:20:22 +00:00
|
|
|
if (VIR_REALLOC_N(buf, size+got+1) < 0)
|
2007-10-27 01:16:53 +00:00
|
|
|
goto error;
|
|
|
|
|
2007-02-14 01:40:09 +00:00
|
|
|
memmove(buf+size, data, got);
|
|
|
|
buf[size+got] = '\0';
|
|
|
|
size += got;
|
|
|
|
}
|
2007-10-27 01:16:53 +00:00
|
|
|
|
2007-02-14 01:40:09 +00:00
|
|
|
/* Look for QEMU prompt to indicate completion */
|
2007-03-05 17:15:20 +00:00
|
|
|
if (buf && ((tmp = strstr(buf, "\n(qemu) ")) != NULL)) {
|
2007-02-14 01:40:09 +00:00
|
|
|
tmp[0] = '\0';
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
pollagain:
|
|
|
|
/* Need to wait for more data */
|
|
|
|
if (poll(&fd, 1, -1) < 0) {
|
|
|
|
if (errno == EINTR)
|
|
|
|
goto pollagain;
|
2007-10-27 01:16:53 +00:00
|
|
|
goto error;
|
2007-02-14 01:40:09 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2007-10-27 01:16:53 +00:00
|
|
|
/* Log, but ignore failures to write logfile for VM */
|
|
|
|
if (safewrite(vm->logfile, buf, strlen(buf)) < 0)
|
2008-08-01 11:24:04 +00:00
|
|
|
qemudLog(QEMUD_WARN, _("Unable to log VM console data: %s\n"),
|
2007-10-27 01:16:53 +00:00
|
|
|
strerror(errno));
|
|
|
|
|
2007-02-14 01:40:09 +00:00
|
|
|
*reply = buf;
|
|
|
|
return 0;
|
2007-10-27 01:16:53 +00:00
|
|
|
|
|
|
|
error:
|
|
|
|
if (buf) {
|
|
|
|
/* Log, but ignore failures to write logfile for VM */
|
|
|
|
if (safewrite(vm->logfile, buf, strlen(buf)) < 0)
|
2008-08-01 11:24:04 +00:00
|
|
|
qemudLog(QEMUD_WARN, _("Unable to log VM console data: %s\n"),
|
2007-10-27 01:16:53 +00:00
|
|
|
strerror(errno));
|
2008-05-29 19:20:22 +00:00
|
|
|
VIR_FREE(buf);
|
2007-10-27 01:16:53 +00:00
|
|
|
}
|
|
|
|
return -1;
|
2007-02-14 01:40:09 +00:00
|
|
|
}
|
|
|
|
|
2008-02-26 07:05:18 +00:00
|
|
|
/**
|
|
|
|
* qemudProbe:
|
|
|
|
*
|
|
|
|
* Probe for the availability of the qemu driver, assume the
|
|
|
|
* presence of QEmu emulation if the binaries are installed
|
|
|
|
*/
|
|
|
|
static const char *qemudProbe(void)
|
|
|
|
{
|
|
|
|
if ((virFileExists("/usr/bin/qemu")) ||
|
|
|
|
(virFileExists("/usr/bin/qemu-kvm")) ||
|
2008-04-10 16:54:54 +00:00
|
|
|
(virFileExists("/usr/bin/xenner"))) {
|
2008-02-26 07:05:18 +00:00
|
|
|
if (getuid() == 0) {
|
2008-04-10 16:54:54 +00:00
|
|
|
return("qemu:///system");
|
|
|
|
} else {
|
|
|
|
return("qemu:///session");
|
|
|
|
}
|
2008-02-26 07:05:18 +00:00
|
|
|
}
|
|
|
|
return(NULL);
|
|
|
|
}
|
2007-06-26 19:49:50 +00:00
|
|
|
|
2007-06-29 13:23:13 +00:00
|
|
|
static virDrvOpenStatus qemudOpen(virConnectPtr conn,
|
2007-11-14 11:40:57 +00:00
|
|
|
xmlURIPtr uri,
|
2007-12-05 18:28:05 +00:00
|
|
|
virConnectAuthPtr auth ATTRIBUTE_UNUSED,
|
2007-09-21 19:32:02 +00:00
|
|
|
int flags ATTRIBUTE_UNUSED) {
|
2007-06-26 22:39:53 +00:00
|
|
|
uid_t uid = getuid();
|
|
|
|
|
|
|
|
if (qemu_driver == NULL)
|
2007-11-14 11:40:57 +00:00
|
|
|
goto decline;
|
2007-06-26 22:39:53 +00:00
|
|
|
|
2007-09-21 19:32:02 +00:00
|
|
|
if (uri == NULL || uri->scheme == NULL || uri->path == NULL)
|
|
|
|
goto decline;
|
|
|
|
|
|
|
|
if (STRNEQ (uri->scheme, "qemu"))
|
|
|
|
goto decline;
|
|
|
|
|
2007-09-20 17:13:39 +00:00
|
|
|
if (uid != 0) {
|
2007-09-21 19:32:02 +00:00
|
|
|
if (STRNEQ (uri->path, "/session"))
|
|
|
|
goto decline;
|
2007-09-20 17:13:39 +00:00
|
|
|
} else { /* root */
|
2007-09-21 19:32:02 +00:00
|
|
|
if (STRNEQ (uri->path, "/system") &&
|
|
|
|
STRNEQ (uri->path, "/session"))
|
2008-02-05 19:27:37 +00:00
|
|
|
goto decline;
|
2007-06-26 22:39:53 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
conn->privateData = qemu_driver;
|
|
|
|
|
|
|
|
return VIR_DRV_OPEN_SUCCESS;
|
2007-09-21 19:32:02 +00:00
|
|
|
|
|
|
|
decline:
|
2008-02-05 19:27:37 +00:00
|
|
|
return VIR_DRV_OPEN_DECLINED;
|
2007-06-26 22:39:53 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
static int qemudClose(virConnectPtr conn) {
|
|
|
|
/*struct qemud_driver *driver = (struct qemud_driver *)conn->privateData;*/
|
|
|
|
|
|
|
|
conn->privateData = NULL;
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
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-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;
|
|
|
|
|
|
|
|
/* XXX future KVM will support SMP. Need to probe
|
|
|
|
kernel to figure out KVM module version i guess */
|
2008-05-07 16:16:44 +00:00
|
|
|
if (STRCASEEQ(type, "kvm"))
|
2007-06-26 22:39:53 +00:00
|
|
|
return 1;
|
|
|
|
|
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-07-25 23:16:30 +00:00
|
|
|
static int qemudGetNodeInfo(virConnectPtr conn,
|
|
|
|
virNodeInfoPtr nodeinfo) {
|
|
|
|
return virNodeInfoPopulate(conn, nodeinfo);
|
2007-06-26 19:49:50 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
|
2008-02-27 04:35:08 +00:00
|
|
|
static char *qemudGetCapabilities(virConnectPtr conn) {
|
|
|
|
struct qemud_driver *driver = (struct qemud_driver *)conn->privateData;
|
|
|
|
char *xml;
|
2007-06-26 19:49:50 +00:00
|
|
|
|
2008-02-27 04:35:08 +00:00
|
|
|
if ((xml = virCapabilitiesFormatXML(driver->caps)) == NULL) {
|
qemudReportError: mark for translation string args to this function
* Makefile.maint (msg_gen_function): Add qemudReportError.
* src/qemu_conf.c (qemudLoadDriverConfig)
(qemudExtractVersion, qemudParseDiskXML, qemudParseInterfaceXML)
(qemudParseInputXML, qemudParseXML, qemudNetworkIfaceConnect)
(qemudBuildCommandLine, qemudSaveConfig, qemudParseVMDeviceDef)
(qemudAssignVMDef, qemudSaveVMDef, qemudSaveNetworkConfig)
(qemudParseDhcpRangesXML, qemudParseNetworkXML)
(qemudAssignNetworkDef, qemudSaveNetworkDef, qemudGenerateXML)
(qemudGenerateNetworkXML, qemudDeleteConfig): Mark strings.
* src/qemu_driver.c (qemudBuildDnsmasqArgv, qemudAddIptablesRules)
(qemudGetCapabilities, qemudDomainGetOSType)
(qemudListDefinedDomains, qemudListNetworks)
(qemudListDefinedNetworks, qemudNetworkGetBridgeName): Mark strings.
2008-03-27 13:53:14 +00:00
|
|
|
qemudReportError(conn, NULL, NULL, VIR_ERR_NO_MEMORY,
|
|
|
|
"%s", _("failed to allocate space for capabilities support"));
|
2007-06-26 19:49:50 +00:00
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
|
2008-02-27 04:35:08 +00:00
|
|
|
return xml;
|
2007-06-26 19:49:50 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
|
2008-05-22 15:29:50 +00:00
|
|
|
#if HAVE_NUMACTL
|
|
|
|
static int
|
|
|
|
qemudNodeGetCellsFreeMemory(virConnectPtr conn,
|
|
|
|
unsigned long long *freeMems,
|
|
|
|
int startCell,
|
|
|
|
int maxCells)
|
|
|
|
{
|
|
|
|
int n, lastCell, numCells;
|
|
|
|
|
|
|
|
if (numa_available() < 0) {
|
|
|
|
qemudReportError(conn, NULL, NULL, VIR_ERR_NO_SUPPORT,
|
|
|
|
"%s", _("NUMA not supported on this host"));
|
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
lastCell = startCell + maxCells - 1;
|
|
|
|
if (lastCell > numa_max_node())
|
|
|
|
lastCell = numa_max_node();
|
|
|
|
|
|
|
|
for (numCells = 0, n = startCell ; n <= lastCell ; n++) {
|
|
|
|
long long mem;
|
|
|
|
if (numa_node_size64(n, &mem) < 0) {
|
|
|
|
qemudReportError(conn, NULL, NULL, VIR_ERR_INTERNAL_ERROR,
|
|
|
|
"%s", _("Failed to query NUMA free memory"));
|
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
freeMems[numCells++] = mem;
|
|
|
|
}
|
|
|
|
return numCells;
|
|
|
|
}
|
|
|
|
|
|
|
|
static unsigned long long
|
|
|
|
qemudNodeGetFreeMemory (virConnectPtr conn)
|
|
|
|
{
|
|
|
|
unsigned long long freeMem = 0;
|
|
|
|
int n;
|
|
|
|
if (numa_available() < 0) {
|
|
|
|
qemudReportError(conn, NULL, NULL, VIR_ERR_NO_SUPPORT,
|
|
|
|
"%s", _("NUMA not supported on this host"));
|
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
|
|
|
|
for (n = 0 ; n <= numa_max_node() ; n++) {
|
|
|
|
long long mem;
|
|
|
|
if (numa_node_size64(n, &mem) < 0) {
|
|
|
|
qemudReportError(conn, NULL, NULL, VIR_ERR_INTERNAL_ERROR,
|
|
|
|
"%s", _("Failed to query NUMA free memory"));
|
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
freeMem += mem;
|
|
|
|
}
|
|
|
|
|
|
|
|
return freeMem;
|
|
|
|
}
|
|
|
|
|
|
|
|
#endif
|
2007-06-26 19:49:50 +00:00
|
|
|
|
2007-02-14 01:40:09 +00:00
|
|
|
static int qemudGetProcessInfo(unsigned long long *cpuTime, int pid) {
|
|
|
|
char proc[PATH_MAX];
|
|
|
|
FILE *pidinfo;
|
2007-04-15 19:58:44 +00:00
|
|
|
unsigned long long usertime, systime;
|
2007-02-14 01:40:09 +00:00
|
|
|
|
|
|
|
if (snprintf(proc, sizeof(proc), "/proc/%d/stat", pid) >= (int)sizeof(proc)) {
|
|
|
|
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 */
|
|
|
|
*cpuTime = 0;
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2007-04-15 19:58:44 +00:00
|
|
|
if (fscanf(pidinfo, "%*d %*s %*c %*d %*d %*d %*d %*d %*u %*u %*u %*u %*u %llu %llu", &usertime, &systime) != 2) {
|
2007-02-16 18:30:55 +00:00
|
|
|
qemudDebug("not enough arg");
|
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....
|
|
|
|
*/
|
2007-04-15 19:58:44 +00:00
|
|
|
*cpuTime = 1000ull * 1000ull * 1000ull * (usertime + systime) / (unsigned long long)sysconf(_SC_CLK_TCK);
|
2007-02-14 01:40:09 +00:00
|
|
|
|
2007-04-15 19:58:44 +00:00
|
|
|
qemudDebug("Got %llu %llu %llu", usertime, systime, *cpuTime);
|
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) {
|
2007-06-26 22:39:53 +00:00
|
|
|
struct qemud_driver *driver = (struct qemud_driver *)conn->privateData;
|
2008-07-11 19:34:11 +00:00
|
|
|
virDomainObjPtr vm = virDomainFindByID(driver->domains, id);
|
2007-06-26 22:39:53 +00:00
|
|
|
virDomainPtr dom;
|
|
|
|
|
|
|
|
if (!vm) {
|
2007-07-06 14:56:15 +00:00
|
|
|
qemudReportError(conn, NULL, NULL, VIR_ERR_NO_DOMAIN, NULL);
|
2007-06-26 22:39:53 +00:00
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
|
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;
|
2007-06-26 22:39:53 +00:00
|
|
|
return dom;
|
|
|
|
}
|
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) {
|
2007-06-26 22:39:53 +00:00
|
|
|
struct qemud_driver *driver = (struct qemud_driver *)conn->privateData;
|
2008-07-11 19:34:11 +00:00
|
|
|
virDomainObjPtr vm = virDomainFindByUUID(driver->domains, uuid);
|
2007-06-26 22:39:53 +00:00
|
|
|
virDomainPtr dom;
|
|
|
|
|
|
|
|
if (!vm) {
|
2007-07-06 14:56:15 +00:00
|
|
|
qemudReportError(conn, NULL, NULL, VIR_ERR_NO_DOMAIN, NULL);
|
2007-06-26 22:39:53 +00:00
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
|
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;
|
2007-06-26 22:39:53 +00:00
|
|
|
return dom;
|
|
|
|
}
|
2007-06-29 13:23:13 +00:00
|
|
|
static virDomainPtr qemudDomainLookupByName(virConnectPtr conn,
|
2008-07-11 19:34:11 +00:00
|
|
|
const char *name) {
|
2007-06-26 22:39:53 +00:00
|
|
|
struct qemud_driver *driver = (struct qemud_driver *)conn->privateData;
|
2008-07-11 19:34:11 +00:00
|
|
|
virDomainObjPtr vm = virDomainFindByName(driver->domains, name);
|
2007-06-26 22:39:53 +00:00
|
|
|
virDomainPtr dom;
|
|
|
|
|
|
|
|
if (!vm) {
|
2007-07-06 14:56:15 +00:00
|
|
|
qemudReportError(conn, NULL, NULL, VIR_ERR_NO_DOMAIN, NULL);
|
2007-06-26 22:39:53 +00:00
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
|
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;
|
2007-06-26 22:39:53 +00:00
|
|
|
return dom;
|
|
|
|
}
|
|
|
|
|
2007-06-29 13:23:13 +00:00
|
|
|
static int qemudGetVersion(virConnectPtr conn, unsigned long *version) {
|
2007-06-26 22:39:53 +00:00
|
|
|
struct qemud_driver *driver = (struct qemud_driver *)conn->privateData;
|
2007-07-12 15:09:01 +00:00
|
|
|
if (qemudExtractVersion(conn, driver) < 0)
|
2007-02-23 17:15:18 +00:00
|
|
|
return -1;
|
|
|
|
|
2007-06-26 22:39:53 +00:00
|
|
|
*version = qemu_driver->qemuVersion;
|
|
|
|
return 0;
|
2007-02-14 01:40:09 +00:00
|
|
|
}
|
|
|
|
|
2007-09-20 17:13:39 +00:00
|
|
|
static char *
|
|
|
|
qemudGetHostname (virConnectPtr conn)
|
|
|
|
{
|
|
|
|
int r;
|
|
|
|
char hostname[HOST_NAME_MAX+1], *str;
|
|
|
|
|
|
|
|
r = gethostname (hostname, HOST_NAME_MAX+1);
|
|
|
|
if (r == -1) {
|
|
|
|
qemudReportError (conn, NULL, NULL, VIR_ERR_SYSTEM_ERROR,
|
|
|
|
"%s", strerror (errno));
|
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
/* Caller frees this string. */
|
|
|
|
str = strdup (hostname);
|
|
|
|
if (str == NULL) {
|
|
|
|
qemudReportError (conn, NULL, NULL, VIR_ERR_SYSTEM_ERROR,
|
|
|
|
"%s", strerror (errno));
|
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
return str;
|
|
|
|
}
|
|
|
|
|
2007-06-29 13:23:13 +00:00
|
|
|
static int qemudListDomains(virConnectPtr conn, int *ids, int nids) {
|
2007-06-26 22:39:53 +00:00
|
|
|
struct qemud_driver *driver = (struct qemud_driver *)conn->privateData;
|
2008-07-11 19:34:11 +00:00
|
|
|
virDomainObjPtr vm = driver->domains;
|
2007-02-14 01:40:09 +00:00
|
|
|
int got = 0;
|
|
|
|
while (vm && got < nids) {
|
2008-07-11 19:34:11 +00:00
|
|
|
if (virDomainIsActive(vm)) {
|
|
|
|
ids[got] = vm->def->id;
|
2007-02-23 08:39:49 +00:00
|
|
|
got++;
|
|
|
|
}
|
2007-02-14 01:40:09 +00:00
|
|
|
vm = vm->next;
|
|
|
|
}
|
|
|
|
return got;
|
|
|
|
}
|
2007-06-29 13:23:13 +00:00
|
|
|
static int qemudNumDomains(virConnectPtr conn) {
|
2007-06-26 22:39:53 +00:00
|
|
|
struct qemud_driver *driver = (struct qemud_driver *)conn->privateData;
|
2008-07-11 19:34:11 +00:00
|
|
|
int n = 0;
|
|
|
|
virDomainObjPtr dom = driver->domains;
|
|
|
|
while (dom) {
|
|
|
|
if (virDomainIsActive(dom))
|
|
|
|
n++;
|
|
|
|
dom = dom->next;
|
|
|
|
}
|
|
|
|
return n;
|
2007-02-14 01:40:09 +00:00
|
|
|
}
|
2007-06-29 13:23:13 +00:00
|
|
|
static virDomainPtr qemudDomainCreate(virConnectPtr conn, const char *xml,
|
2007-07-12 15:09:01 +00:00
|
|
|
unsigned int flags ATTRIBUTE_UNUSED) {
|
2008-07-11 19:34:11 +00:00
|
|
|
virDomainDefPtr def;
|
|
|
|
virDomainObjPtr vm;
|
2007-06-26 22:39:53 +00:00
|
|
|
virDomainPtr dom;
|
|
|
|
struct qemud_driver *driver = (struct qemud_driver *)conn->privateData;
|
2007-02-14 01:40:09 +00:00
|
|
|
|
2008-07-11 19:34:11 +00:00
|
|
|
if (!(def = virDomainDefParseString(conn, driver->caps, xml)))
|
2007-02-23 08:48:02 +00:00
|
|
|
return NULL;
|
|
|
|
|
2008-07-24 07:29:50 +00:00
|
|
|
vm = virDomainFindByName(driver->domains, def->name);
|
2008-07-28 12:52:37 +00:00
|
|
|
if (vm) {
|
2008-07-24 07:29:50 +00:00
|
|
|
qemudReportError(conn, NULL, NULL, VIR_ERR_OPERATION_FAILED,
|
2008-08-01 06:23:31 +00:00
|
|
|
_("domain '%s' is already defined"),
|
2008-07-24 07:29:50 +00:00
|
|
|
def->name);
|
|
|
|
virDomainDefFree(def);
|
|
|
|
return NULL;
|
|
|
|
}
|
2008-07-28 12:52:37 +00:00
|
|
|
vm = virDomainFindByUUID(driver->domains, def->uuid);
|
|
|
|
if (vm) {
|
|
|
|
char uuidstr[VIR_UUID_STRING_BUFLEN];
|
|
|
|
|
|
|
|
virUUIDFormat(def->uuid, uuidstr);
|
|
|
|
qemudReportError(conn, NULL, NULL, VIR_ERR_OPERATION_FAILED,
|
2008-08-01 06:23:31 +00:00
|
|
|
_("domain with uuid '%s' is already defined"),
|
2008-07-28 12:52:37 +00:00
|
|
|
uuidstr);
|
|
|
|
virDomainDefFree(def);
|
|
|
|
return NULL;
|
|
|
|
}
|
2008-07-24 07:29:50 +00:00
|
|
|
|
2008-07-11 19:34:11 +00:00
|
|
|
if (!(vm = virDomainAssignDef(conn,
|
|
|
|
&driver->domains,
|
|
|
|
def))) {
|
|
|
|
virDomainDefFree(def);
|
2007-02-14 01:40:09 +00:00
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
|
2008-07-11 19:34:11 +00:00
|
|
|
if (qemudStartVMDaemon(conn, driver, vm, NULL) < 0) {
|
|
|
|
virDomainRemoveInactive(&driver->domains,
|
|
|
|
vm);
|
2007-02-14 01:40:09 +00:00
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
|
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;
|
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) {
|
2007-06-26 22:39:53 +00:00
|
|
|
struct qemud_driver *driver = (struct qemud_driver *)dom->conn->privateData;
|
2007-02-14 01:40:09 +00:00
|
|
|
char *info;
|
2008-07-11 19:34:11 +00:00
|
|
|
virDomainObjPtr vm = virDomainFindByID(driver->domains, dom->id);
|
2007-02-14 01:40:09 +00:00
|
|
|
if (!vm) {
|
2008-03-24 10:51:47 +00:00
|
|
|
qemudReportError(dom->conn, dom, NULL, VIR_ERR_INVALID_DOMAIN, _("no domain with matching id %d"), dom->id);
|
2007-02-14 01:40:09 +00:00
|
|
|
return -1;
|
|
|
|
}
|
2008-07-11 19:34:11 +00:00
|
|
|
if (!virDomainIsActive(vm)) {
|
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
|
|
|
qemudReportError(dom->conn, dom, NULL, VIR_ERR_OPERATION_FAILED,
|
|
|
|
"%s", _("domain is not running"));
|
2007-02-14 01:40:09 +00:00
|
|
|
return -1;
|
|
|
|
}
|
2007-06-26 22:39:53 +00:00
|
|
|
if (vm->state == VIR_DOMAIN_PAUSED)
|
2007-03-05 17:15:20 +00:00
|
|
|
return 0;
|
2007-02-14 01:40:09 +00:00
|
|
|
|
2007-10-27 01:16:53 +00:00
|
|
|
if (qemudMonitorCommand(driver, vm, "stop", &info) < 0) {
|
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
|
|
|
qemudReportError(dom->conn, dom, NULL, VIR_ERR_OPERATION_FAILED,
|
|
|
|
"%s", _("suspend operation failed"));
|
2007-02-14 01:40:09 +00:00
|
|
|
return -1;
|
|
|
|
}
|
2007-06-26 22:39:53 +00:00
|
|
|
vm->state = VIR_DOMAIN_PAUSED;
|
2007-02-16 18:30:55 +00:00
|
|
|
qemudDebug("Reply %s", info);
|
2008-05-29 19:20:22 +00:00
|
|
|
VIR_FREE(info);
|
2007-02-14 01:40:09 +00:00
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
2007-06-29 13:23:13 +00:00
|
|
|
static int qemudDomainResume(virDomainPtr dom) {
|
2007-06-26 22:39:53 +00:00
|
|
|
struct qemud_driver *driver = (struct qemud_driver *)dom->conn->privateData;
|
2007-02-14 01:40:09 +00:00
|
|
|
char *info;
|
2008-07-11 19:34:11 +00:00
|
|
|
virDomainObjPtr vm = virDomainFindByID(driver->domains, dom->id);
|
2007-02-14 01:40:09 +00:00
|
|
|
if (!vm) {
|
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
|
|
|
qemudReportError(dom->conn, dom, NULL, VIR_ERR_INVALID_DOMAIN,
|
|
|
|
_("no domain with matching id %d"), dom->id);
|
2007-02-14 01:40:09 +00:00
|
|
|
return -1;
|
|
|
|
}
|
2008-07-11 19:34:11 +00:00
|
|
|
if (!virDomainIsActive(vm)) {
|
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
|
|
|
qemudReportError(dom->conn, dom, NULL, VIR_ERR_OPERATION_FAILED,
|
|
|
|
"%s", _("domain is not running"));
|
2007-02-14 01:40:09 +00:00
|
|
|
return -1;
|
|
|
|
}
|
2007-06-26 22:39:53 +00:00
|
|
|
if (vm->state == VIR_DOMAIN_RUNNING)
|
2007-03-05 17:15:20 +00:00
|
|
|
return 0;
|
2007-10-27 01:16:53 +00:00
|
|
|
if (qemudMonitorCommand(driver, vm, "cont", &info) < 0) {
|
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
|
|
|
qemudReportError(dom->conn, dom, NULL, VIR_ERR_OPERATION_FAILED,
|
|
|
|
"%s", _("resume operation failed"));
|
2007-02-14 01:40:09 +00:00
|
|
|
return -1;
|
|
|
|
}
|
2007-06-26 22:39:53 +00:00
|
|
|
vm->state = VIR_DOMAIN_RUNNING;
|
2007-02-16 18:30:55 +00:00
|
|
|
qemudDebug("Reply %s", info);
|
2008-05-29 19:20:22 +00:00
|
|
|
VIR_FREE(info);
|
2007-03-05 17:15:20 +00:00
|
|
|
return 0;
|
2007-02-14 01:40:09 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
|
2008-01-09 16:05:21 +00:00
|
|
|
static int qemudDomainShutdown(virDomainPtr dom) {
|
|
|
|
struct qemud_driver *driver = (struct qemud_driver *)dom->conn->privateData;
|
2008-07-11 19:34:11 +00:00
|
|
|
virDomainObjPtr vm = virDomainFindByID(driver->domains, dom->id);
|
2008-01-09 16:05:21 +00:00
|
|
|
char* info;
|
|
|
|
|
|
|
|
if (!vm) {
|
|
|
|
qemudReportError(dom->conn, dom, NULL, VIR_ERR_INVALID_DOMAIN,
|
2008-03-24 10:51:47 +00:00
|
|
|
_("no domain with matching id %d"), dom->id);
|
2008-01-09 16:05:21 +00:00
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (qemudMonitorCommand(driver, vm, "system_powerdown", &info) < 0) {
|
|
|
|
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", _("shutdown operation failed"));
|
2008-01-09 16:05:21 +00:00
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
return 0;
|
|
|
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
2007-06-29 13:23:13 +00:00
|
|
|
static int qemudDomainDestroy(virDomainPtr dom) {
|
2007-06-26 22:39:53 +00:00
|
|
|
struct qemud_driver *driver = (struct qemud_driver *)dom->conn->privateData;
|
2008-07-11 19:34:11 +00:00
|
|
|
virDomainObjPtr vm = virDomainFindByID(driver->domains, dom->id);
|
2007-02-23 08:41:23 +00:00
|
|
|
|
2007-02-14 01:40:09 +00:00
|
|
|
if (!vm) {
|
2007-06-26 22:39:53 +00:00
|
|
|
qemudReportError(dom->conn, dom, NULL, VIR_ERR_INVALID_DOMAIN,
|
2008-03-24 10:51:47 +00:00
|
|
|
_("no domain with matching id %d"), dom->id);
|
2007-02-14 01:40:09 +00:00
|
|
|
return -1;
|
|
|
|
}
|
2007-02-23 08:41:23 +00:00
|
|
|
|
2007-07-24 14:24:52 +00:00
|
|
|
qemudShutdownVMDaemon(dom->conn, driver, vm);
|
2008-08-20 19:42:36 +00:00
|
|
|
if (!vm->persistent)
|
2008-07-11 19:34:11 +00:00
|
|
|
virDomainRemoveInactive(&driver->domains,
|
|
|
|
vm);
|
2008-01-21 16:29:10 +00:00
|
|
|
|
2007-07-24 14:24:52 +00:00
|
|
|
return 0;
|
2007-02-14 01:40:09 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
|
2007-06-26 22:39:53 +00:00
|
|
|
static char *qemudDomainGetOSType(virDomainPtr dom) {
|
|
|
|
struct qemud_driver *driver = (struct qemud_driver *)dom->conn->privateData;
|
2008-07-11 19:34:11 +00:00
|
|
|
virDomainObjPtr vm = virDomainFindByUUID(driver->domains, dom->uuid);
|
2007-06-26 22:39:53 +00:00
|
|
|
char *type;
|
|
|
|
|
|
|
|
if (!vm) {
|
|
|
|
qemudReportError(dom->conn, dom, NULL, VIR_ERR_INVALID_DOMAIN,
|
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", _("no domain with matching uuid"));
|
2007-06-26 22:39:53 +00:00
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (!(type = strdup(vm->def->os.type))) {
|
qemudReportError: mark for translation string args to this function
* Makefile.maint (msg_gen_function): Add qemudReportError.
* src/qemu_conf.c (qemudLoadDriverConfig)
(qemudExtractVersion, qemudParseDiskXML, qemudParseInterfaceXML)
(qemudParseInputXML, qemudParseXML, qemudNetworkIfaceConnect)
(qemudBuildCommandLine, qemudSaveConfig, qemudParseVMDeviceDef)
(qemudAssignVMDef, qemudSaveVMDef, qemudSaveNetworkConfig)
(qemudParseDhcpRangesXML, qemudParseNetworkXML)
(qemudAssignNetworkDef, qemudSaveNetworkDef, qemudGenerateXML)
(qemudGenerateNetworkXML, qemudDeleteConfig): Mark strings.
* src/qemu_driver.c (qemudBuildDnsmasqArgv, qemudAddIptablesRules)
(qemudGetCapabilities, qemudDomainGetOSType)
(qemudListDefinedDomains, qemudListNetworks)
(qemudListDefinedNetworks, qemudNetworkGetBridgeName): Mark strings.
2008-03-27 13:53:14 +00:00
|
|
|
qemudReportError(dom->conn, dom, NULL, VIR_ERR_NO_MEMORY,
|
|
|
|
"%s", _("failed to allocate space for ostype"));
|
2007-06-26 22:39:53 +00:00
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
return type;
|
|
|
|
}
|
|
|
|
|
2008-03-19 14:32:50 +00:00
|
|
|
/* Returns max memory in kb, 0 if error */
|
|
|
|
static unsigned long qemudDomainGetMaxMemory(virDomainPtr dom) {
|
|
|
|
struct qemud_driver *driver = (struct qemud_driver *)dom->conn->privateData;
|
2008-07-11 19:34:11 +00:00
|
|
|
virDomainObjPtr vm = virDomainFindByUUID(driver->domains, dom->uuid);
|
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);
|
2008-03-19 14:32:50 +00:00
|
|
|
qemudReportError(dom->conn, dom, NULL, VIR_ERR_INVALID_DOMAIN,
|
2008-07-25 09:01:25 +00:00
|
|
|
_("no domain with matching uuid '%s'"), uuidstr);
|
2008-03-19 14:32:50 +00:00
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
return vm->def->maxmem;
|
|
|
|
}
|
|
|
|
|
|
|
|
static int qemudDomainSetMaxMemory(virDomainPtr dom, unsigned long newmax) {
|
|
|
|
struct qemud_driver *driver = (struct qemud_driver *)dom->conn->privateData;
|
2008-07-11 19:34:11 +00:00
|
|
|
virDomainObjPtr vm = virDomainFindByUUID(driver->domains, dom->uuid);
|
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);
|
2008-03-19 14:32:50 +00:00
|
|
|
qemudReportError(dom->conn, dom, NULL, VIR_ERR_INVALID_DOMAIN,
|
2008-07-25 09:01:25 +00:00
|
|
|
_("no domain with matching uuid '%s'"), uuidstr);
|
2008-03-19 14:32:50 +00:00
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
|
|
|
|
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-03-19 14:32:50 +00:00
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
|
|
|
|
vm->def->maxmem = newmax;
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
static int qemudDomainSetMemory(virDomainPtr dom, unsigned long newmem) {
|
|
|
|
struct qemud_driver *driver = (struct qemud_driver *)dom->conn->privateData;
|
2008-07-11 19:34:11 +00:00
|
|
|
virDomainObjPtr vm = virDomainFindByUUID(driver->domains, dom->uuid);
|
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);
|
2008-03-19 14:32:50 +00:00
|
|
|
qemudReportError(dom->conn, dom, NULL, VIR_ERR_INVALID_DOMAIN,
|
2008-07-25 09:01:25 +00:00
|
|
|
_("no domain with matching uuid '%s'"), uuidstr);
|
2008-03-19 14:32:50 +00:00
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
|
2008-07-11 19:34:11 +00:00
|
|
|
if (virDomainIsActive(vm)) {
|
2008-06-12 08:55:13 +00:00
|
|
|
qemudReportError(dom->conn, dom, NULL, VIR_ERR_NO_SUPPORT,
|
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 of an active domain"));
|
2008-03-19 14:32:50 +00:00
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
|
|
|
|
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-03-19 14:32:50 +00:00
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
|
|
|
|
vm->def->memory = newmem;
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2007-06-29 13:23:13 +00:00
|
|
|
static int qemudDomainGetInfo(virDomainPtr dom,
|
2008-07-11 19:34:11 +00:00
|
|
|
virDomainInfoPtr info) {
|
2007-06-26 22:39:53 +00:00
|
|
|
struct qemud_driver *driver = (struct qemud_driver *)dom->conn->privateData;
|
2008-07-11 19:34:11 +00:00
|
|
|
virDomainObjPtr vm = virDomainFindByUUID(driver->domains, dom->uuid);
|
2007-02-14 01:40:09 +00:00
|
|
|
if (!vm) {
|
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
|
|
|
qemudReportError(dom->conn, dom, NULL, VIR_ERR_INVALID_DOMAIN,
|
|
|
|
"%s", _("no domain with matching uuid"));
|
2007-02-14 01:40:09 +00:00
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
|
2007-06-26 22:39:53 +00:00
|
|
|
info->state = vm->state;
|
2007-02-14 01:40:09 +00:00
|
|
|
|
2008-07-11 19:34:11 +00:00
|
|
|
if (!virDomainIsActive(vm)) {
|
2007-06-26 22:39:53 +00:00
|
|
|
info->cpuTime = 0;
|
2007-02-14 01:40:09 +00:00
|
|
|
} else {
|
2007-06-26 22:39:53 +00:00
|
|
|
if (qemudGetProcessInfo(&(info->cpuTime), vm->pid) < 0) {
|
2008-03-24 10:51:47 +00:00
|
|
|
qemudReportError(dom->conn, dom, NULL, VIR_ERR_OPERATION_FAILED, ("cannot read cputime for domain"));
|
2007-02-14 01:40:09 +00:00
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2007-06-26 22:39:53 +00:00
|
|
|
info->maxMem = vm->def->maxmem;
|
|
|
|
info->memory = vm->def->memory;
|
|
|
|
info->nrVirtCpu = vm->def->vcpus;
|
2007-02-14 01:40:09 +00:00
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
2007-10-27 01:19:51 +00:00
|
|
|
static char *qemudEscape(const char *in, int shell)
|
2007-08-14 01:33:38 +00:00
|
|
|
{
|
|
|
|
int len = 0;
|
|
|
|
int i, j;
|
|
|
|
char *out;
|
|
|
|
|
|
|
|
/* To pass through the QEMU monitor, we need to use escape
|
|
|
|
sequences: \r, \n, \", \\
|
|
|
|
|
|
|
|
To pass through both QEMU + the shell, we need to escape
|
|
|
|
the single character ' as the five characters '\\''
|
|
|
|
*/
|
|
|
|
|
|
|
|
for (i = 0; in[i] != '\0'; i++) {
|
|
|
|
switch(in[i]) {
|
|
|
|
case '\r':
|
|
|
|
case '\n':
|
|
|
|
case '"':
|
|
|
|
case '\\':
|
|
|
|
len += 2;
|
|
|
|
break;
|
|
|
|
case '\'':
|
2007-10-27 01:19:51 +00:00
|
|
|
if (shell)
|
|
|
|
len += 5;
|
|
|
|
else
|
|
|
|
len += 1;
|
2007-08-14 01:33:38 +00:00
|
|
|
break;
|
|
|
|
default:
|
|
|
|
len += 1;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2008-05-29 19:20:22 +00:00
|
|
|
if (VIR_ALLOC_N(out, len + 1) < 0)
|
2007-08-14 01:33:38 +00:00
|
|
|
return NULL;
|
|
|
|
|
|
|
|
for (i = j = 0; in[i] != '\0'; i++) {
|
|
|
|
switch(in[i]) {
|
|
|
|
case '\r':
|
|
|
|
out[j++] = '\\';
|
|
|
|
out[j++] = 'r';
|
|
|
|
break;
|
|
|
|
case '\n':
|
|
|
|
out[j++] = '\\';
|
|
|
|
out[j++] = 'n';
|
|
|
|
break;
|
|
|
|
case '"':
|
|
|
|
case '\\':
|
|
|
|
out[j++] = '\\';
|
|
|
|
out[j++] = in[i];
|
|
|
|
break;
|
|
|
|
case '\'':
|
2007-10-27 01:19:51 +00:00
|
|
|
if (shell) {
|
|
|
|
out[j++] = '\'';
|
|
|
|
out[j++] = '\\';
|
|
|
|
out[j++] = '\\';
|
|
|
|
out[j++] = '\'';
|
|
|
|
out[j++] = '\'';
|
|
|
|
} else {
|
|
|
|
out[j++] = in[i];
|
|
|
|
}
|
2007-08-14 01:33:38 +00:00
|
|
|
break;
|
|
|
|
default:
|
|
|
|
out[j++] = in[i];
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
out[j] = '\0';
|
|
|
|
|
|
|
|
return out;
|
|
|
|
}
|
|
|
|
|
2007-10-27 01:21:09 +00:00
|
|
|
static char *qemudEscapeMonitorArg(const char *in)
|
|
|
|
{
|
|
|
|
return qemudEscape(in, 0);
|
|
|
|
}
|
|
|
|
|
2007-10-27 01:19:51 +00:00
|
|
|
static char *qemudEscapeShellArg(const char *in)
|
|
|
|
{
|
|
|
|
return qemudEscape(in, 1);
|
|
|
|
}
|
2007-08-14 01:33:38 +00:00
|
|
|
|
2007-08-14 01:47:24 +00:00
|
|
|
#define QEMUD_SAVE_MAGIC "LibvirtQemudSave"
|
|
|
|
#define QEMUD_SAVE_VERSION 1
|
|
|
|
|
|
|
|
struct qemud_save_header {
|
|
|
|
char magic[sizeof(QEMUD_SAVE_MAGIC)-1];
|
|
|
|
int version;
|
|
|
|
int xml_len;
|
|
|
|
int was_running;
|
|
|
|
int unused[16];
|
|
|
|
};
|
|
|
|
|
2007-06-29 13:23:13 +00:00
|
|
|
static int qemudDomainSave(virDomainPtr dom,
|
2007-08-14 01:47:24 +00:00
|
|
|
const char *path) {
|
2007-06-26 22:39:53 +00:00
|
|
|
struct qemud_driver *driver = (struct qemud_driver *)dom->conn->privateData;
|
2008-07-11 19:34:11 +00:00
|
|
|
virDomainObjPtr vm = virDomainFindByID(driver->domains, dom->id);
|
2007-08-14 01:47:24 +00:00
|
|
|
char *command, *info;
|
|
|
|
int fd;
|
|
|
|
char *safe_path;
|
|
|
|
char *xml;
|
|
|
|
struct qemud_save_header header;
|
|
|
|
|
|
|
|
memset(&header, 0, sizeof(header));
|
|
|
|
memcpy(header.magic, QEMUD_SAVE_MAGIC, sizeof(header.magic));
|
|
|
|
header.version = QEMUD_SAVE_VERSION;
|
|
|
|
|
2007-02-14 01:40:09 +00:00
|
|
|
if (!vm) {
|
2007-08-14 01:47:24 +00:00
|
|
|
qemudReportError(dom->conn, dom, NULL, VIR_ERR_INVALID_DOMAIN,
|
2008-03-24 10:51:47 +00:00
|
|
|
_("no domain with matching id %d"), dom->id);
|
2007-02-14 01:40:09 +00:00
|
|
|
return -1;
|
|
|
|
}
|
2007-08-14 01:47:24 +00:00
|
|
|
|
2008-07-11 19:34:11 +00:00
|
|
|
if (!virDomainIsActive(vm)) {
|
2007-08-14 01:47:24 +00:00
|
|
|
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", _("domain is not running"));
|
2007-02-14 01:40:09 +00:00
|
|
|
return -1;
|
|
|
|
}
|
2007-08-14 01:47:24 +00:00
|
|
|
|
|
|
|
/* Pause */
|
|
|
|
if (vm->state == VIR_DOMAIN_RUNNING) {
|
|
|
|
header.was_running = 1;
|
|
|
|
if (qemudDomainSuspend(dom) != 0) {
|
|
|
|
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 pause domain"));
|
2007-08-14 01:47:24 +00:00
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
/* 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"));
|
2007-08-14 01:47:24 +00:00
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
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);
|
2008-05-29 19:20:22 +00:00
|
|
|
VIR_FREE(xml);
|
2007-08-14 01:47:24 +00:00
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
|
|
|
|
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"));
|
2007-08-14 01:47:24 +00:00
|
|
|
close(fd);
|
2008-05-29 19:20:22 +00:00
|
|
|
VIR_FREE(xml);
|
2007-08-14 01:47:24 +00:00
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
|
|
|
|
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"));
|
2007-08-14 01:47:24 +00:00
|
|
|
close(fd);
|
2008-05-29 19:20:22 +00:00
|
|
|
VIR_FREE(xml);
|
2007-08-14 01:47:24 +00:00
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
|
|
|
|
close(fd);
|
2008-05-29 19:20:22 +00:00
|
|
|
VIR_FREE(xml);
|
2007-08-14 01:47:24 +00:00
|
|
|
|
|
|
|
/* Migrate to file */
|
|
|
|
safe_path = qemudEscapeShellArg(path);
|
|
|
|
if (!safe_path) {
|
|
|
|
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", _("out of memory"));
|
2007-08-14 01:47:24 +00:00
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
if (asprintf (&command, "migrate \"exec:"
|
|
|
|
"dd of='%s' oflag=append conv=notrunc 2>/dev/null"
|
2007-10-27 01:16:53 +00:00
|
|
|
"\"", safe_path) == -1) {
|
2007-08-14 01:47:24 +00:00
|
|
|
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", _("out of memory"));
|
2008-05-29 19:20:22 +00:00
|
|
|
VIR_FREE(safe_path);
|
2007-08-14 01:47:24 +00:00
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
free(safe_path);
|
|
|
|
|
|
|
|
if (qemudMonitorCommand(driver, vm, command, &info) < 0) {
|
|
|
|
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", _("migrate operation failed"));
|
2008-05-29 19:20:22 +00:00
|
|
|
VIR_FREE(command);
|
2007-08-14 01:47:24 +00:00
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
|
2008-07-24 07:09:45 +00:00
|
|
|
DEBUG ("migrate reply: %s", info);
|
|
|
|
|
|
|
|
/* If the command isn't supported then qemu prints:
|
|
|
|
* unknown command: migrate" */
|
|
|
|
if (strstr(info, "unknown command:")) {
|
|
|
|
qemudReportError (dom->conn, dom, NULL, VIR_ERR_NO_SUPPORT,
|
|
|
|
"%s",
|
|
|
|
_("'migrate' not supported by this qemu"));
|
|
|
|
VIR_FREE(info);
|
|
|
|
VIR_FREE(command);
|
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
|
2008-05-29 19:20:22 +00:00
|
|
|
VIR_FREE(info);
|
|
|
|
VIR_FREE(command);
|
2007-08-14 01:47:24 +00:00
|
|
|
|
|
|
|
/* Shut it down */
|
|
|
|
qemudShutdownVMDaemon(dom->conn, driver, vm);
|
2008-08-20 19:42:36 +00:00
|
|
|
if (!vm->persistent)
|
2008-07-11 19:34:11 +00:00
|
|
|
virDomainRemoveInactive(&driver->domains,
|
|
|
|
vm);
|
2007-08-14 01:47:24 +00:00
|
|
|
|
|
|
|
return 0;
|
2007-02-14 01:40:09 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
|
2008-05-07 16:16:44 +00:00
|
|
|
static int qemudDomainSetVcpus(virDomainPtr dom, unsigned int nvcpus) {
|
|
|
|
const struct qemud_driver *driver = (struct qemud_driver *)dom->conn->privateData;
|
2008-07-11 19:34:11 +00:00
|
|
|
virDomainObjPtr vm = virDomainFindByUUID(driver->domains, dom->uuid);
|
2008-05-07 16:16:44 +00:00
|
|
|
int max;
|
|
|
|
|
|
|
|
if (!vm) {
|
2008-07-25 09:01:25 +00:00
|
|
|
char uuidstr[VIR_UUID_STRING_BUFLEN];
|
|
|
|
|
|
|
|
virUUIDFormat(dom->uuid, uuidstr);
|
2008-05-07 16:16:44 +00:00
|
|
|
qemudReportError(dom->conn, dom, NULL, VIR_ERR_INVALID_DOMAIN,
|
2008-07-25 09:01:25 +00:00
|
|
|
_("no domain with matching uuid '%s'"), uuidstr);
|
2008-05-07 16:16:44 +00:00
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
|
2008-07-11 19:34:11 +00:00
|
|
|
if (virDomainIsActive(vm)) {
|
2008-06-12 08:55:13 +00:00
|
|
|
qemudReportError(dom->conn, dom, NULL, VIR_ERR_NO_SUPPORT, "%s",
|
2008-05-07 16:16:44 +00:00
|
|
|
_("cannot change vcpu count of an active domain"));
|
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
|
|
|
|
if ((max = qemudDomainGetMaxVcpus(dom)) < 0) {
|
|
|
|
qemudReportError(dom->conn, dom, NULL, VIR_ERR_INTERNAL_ERROR, "%s",
|
|
|
|
_("could not determine max vcpus for the domain"));
|
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
|
|
|
|
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);
|
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
|
|
|
|
vm->def->vcpus = nvcpus;
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2008-05-22 16:20:31 +00:00
|
|
|
|
|
|
|
#if HAVE_SCHED_GETAFFINITY
|
|
|
|
static int
|
|
|
|
qemudDomainPinVcpu(virDomainPtr dom,
|
|
|
|
unsigned int vcpu,
|
|
|
|
unsigned char *cpumap,
|
|
|
|
int maplen) {
|
|
|
|
struct qemud_driver *driver = (struct qemud_driver *)dom->conn->privateData;
|
2008-07-11 19:34:11 +00:00
|
|
|
virDomainObjPtr vm = virDomainFindByUUID(driver->domains, dom->uuid);
|
2008-05-22 16:20:31 +00:00
|
|
|
cpu_set_t mask;
|
|
|
|
int i, maxcpu;
|
|
|
|
virNodeInfo nodeinfo;
|
|
|
|
|
2008-07-11 19:34:11 +00:00
|
|
|
if (!virDomainIsActive(vm)) {
|
2008-05-22 16:20:31 +00:00
|
|
|
qemudReportError(dom->conn, dom, NULL, VIR_ERR_INVALID_ARG,
|
|
|
|
"%s",_("cannot pin vcpus on an inactive domain"));
|
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (vcpu > (vm->nvcpupids-1)) {
|
|
|
|
qemudReportError(dom->conn, dom, NULL, VIR_ERR_INVALID_ARG,
|
|
|
|
_("vcpu number out of range %d > %d"),
|
|
|
|
vcpu, vm->nvcpupids);
|
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (virNodeInfoPopulate(dom->conn, &nodeinfo) < 0)
|
|
|
|
return -1;
|
|
|
|
|
|
|
|
maxcpu = maplen * 8;
|
|
|
|
if (maxcpu > nodeinfo.cpus)
|
|
|
|
maxcpu = nodeinfo.cpus;
|
|
|
|
|
|
|
|
CPU_ZERO(&mask);
|
|
|
|
for (i = 0 ; i < maxcpu ; i++) {
|
|
|
|
if ((cpumap[i/8] >> (i % 8)) & 1)
|
|
|
|
CPU_SET(i, &mask);
|
|
|
|
}
|
|
|
|
|
|
|
|
if (vm->vcpupids != NULL) {
|
|
|
|
if (sched_setaffinity(vm->vcpupids[vcpu], sizeof(mask), &mask) < 0) {
|
|
|
|
qemudReportError(dom->conn, dom, NULL, VIR_ERR_INVALID_ARG,
|
|
|
|
_("cannot set affinity: %s"), strerror(errno));
|
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
} else {
|
|
|
|
qemudReportError(dom->conn, dom, NULL, VIR_ERR_NO_SUPPORT,
|
|
|
|
"%s", _("cpu affinity is not supported"));
|
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
static int
|
|
|
|
qemudDomainGetVcpus(virDomainPtr dom,
|
|
|
|
virVcpuInfoPtr info,
|
|
|
|
int maxinfo,
|
|
|
|
unsigned char *cpumaps,
|
|
|
|
int maplen) {
|
|
|
|
struct qemud_driver *driver = (struct qemud_driver *)dom->conn->privateData;
|
2008-07-11 19:34:11 +00:00
|
|
|
virDomainObjPtr vm = virDomainFindByUUID(driver->domains, dom->uuid);
|
2008-05-22 16:20:31 +00:00
|
|
|
virNodeInfo nodeinfo;
|
|
|
|
int i, v, maxcpu;
|
|
|
|
|
2008-07-11 19:34:11 +00:00
|
|
|
if (!virDomainIsActive(vm)) {
|
2008-05-22 16:20:31 +00:00
|
|
|
qemudReportError(dom->conn, dom, NULL, VIR_ERR_INVALID_ARG,
|
|
|
|
"%s",_("cannot pin vcpus on an inactive domain"));
|
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (virNodeInfoPopulate(dom->conn, &nodeinfo) < 0)
|
|
|
|
return -1;
|
|
|
|
|
|
|
|
maxcpu = maplen * 8;
|
|
|
|
if (maxcpu > nodeinfo.cpus)
|
|
|
|
maxcpu = nodeinfo.cpus;
|
|
|
|
|
|
|
|
/* Clamp to actual number of vcpus */
|
|
|
|
if (maxinfo > vm->nvcpupids)
|
|
|
|
maxinfo = vm->nvcpupids;
|
|
|
|
|
|
|
|
if (maxinfo < 1)
|
|
|
|
return 0;
|
|
|
|
|
|
|
|
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;
|
|
|
|
/* XXX cpu time, current pCPU mapping */
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
if (cpumaps != NULL) {
|
|
|
|
memset(cpumaps, 0, maplen * maxinfo);
|
|
|
|
if (vm->vcpupids != NULL) {
|
|
|
|
for (v = 0 ; v < maxinfo ; v++) {
|
|
|
|
cpu_set_t mask;
|
|
|
|
unsigned char *cpumap = VIR_GET_CPUMAP(cpumaps, maplen, v);
|
|
|
|
CPU_ZERO(&mask);
|
|
|
|
|
|
|
|
if (sched_getaffinity(vm->vcpupids[v], sizeof(mask), &mask) < 0) {
|
|
|
|
qemudReportError(dom->conn, dom, NULL, VIR_ERR_INVALID_ARG,
|
|
|
|
_("cannot get affinity: %s"), strerror(errno));
|
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
|
|
|
|
for (i = 0 ; i < maxcpu ; i++)
|
|
|
|
if (CPU_ISSET(i, &mask))
|
|
|
|
VIR_USE_CPU(cpumap, i);
|
|
|
|
}
|
|
|
|
} else {
|
|
|
|
qemudReportError(dom->conn, dom, NULL, VIR_ERR_NO_SUPPORT,
|
|
|
|
"%s", _("cpu affinity is not available"));
|
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
return maxinfo;
|
|
|
|
}
|
|
|
|
#endif /* HAVE_SCHED_GETAFFINITY */
|
|
|
|
|
|
|
|
|
2008-05-07 16:16:44 +00:00
|
|
|
static int qemudDomainGetMaxVcpus(virDomainPtr dom) {
|
|
|
|
struct qemud_driver *driver = (struct qemud_driver *)dom->conn->privateData;
|
2008-07-11 19:34:11 +00:00
|
|
|
virDomainObjPtr vm = virDomainFindByUUID(driver->domains, dom->uuid);
|
2008-05-07 16:16:44 +00:00
|
|
|
const char *type;
|
|
|
|
int ret;
|
|
|
|
|
|
|
|
if (!vm) {
|
2008-07-25 09:01:25 +00:00
|
|
|
char uuidstr[VIR_UUID_STRING_BUFLEN];
|
|
|
|
|
|
|
|
virUUIDFormat(dom->uuid, uuidstr);
|
2008-05-07 16:16:44 +00:00
|
|
|
qemudReportError(dom->conn, dom, NULL, VIR_ERR_INVALID_DOMAIN,
|
2008-07-25 09:01:25 +00:00
|
|
|
_("no domain with matching uuid '%s'"), uuidstr);
|
2008-05-07 16:16:44 +00:00
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
|
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);
|
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
|
|
|
|
if ((ret = qemudGetMaxVCPUs(dom->conn, type)) < 0) {
|
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
2007-06-29 13:23:13 +00:00
|
|
|
static int qemudDomainRestore(virConnectPtr conn,
|
2007-08-14 01:47:24 +00:00
|
|
|
const char *path) {
|
|
|
|
struct qemud_driver *driver = (struct qemud_driver *)conn->privateData;
|
2008-07-11 19:34:11 +00:00
|
|
|
virDomainDefPtr def;
|
|
|
|
virDomainObjPtr vm;
|
2007-08-14 01:47:24 +00:00
|
|
|
int fd;
|
2007-10-10 19:46:17 +00:00
|
|
|
int ret;
|
2007-08-14 01:47:24 +00:00
|
|
|
char *xml;
|
|
|
|
struct qemud_save_header header;
|
|
|
|
|
|
|
|
/* 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"));
|
2007-08-14 01:47:24 +00:00
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
|
|
|
|
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"));
|
2007-08-14 01:47:24 +00:00
|
|
|
close(fd);
|
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
|
|
|
|
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"));
|
2007-08-14 01:47:24 +00:00
|
|
|
close(fd);
|
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
|
|
|
|
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);
|
|
|
|
close(fd);
|
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
|
2008-05-29 19:20:22 +00:00
|
|
|
if (VIR_ALLOC_N(xml, header.xml_len) < 0) {
|
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", _("out of memory"));
|
2007-08-14 01:47:24 +00:00
|
|
|
close(fd);
|
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
|
|
|
|
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"));
|
2007-08-14 01:47:24 +00:00
|
|
|
close(fd);
|
2008-05-29 19:20:22 +00:00
|
|
|
VIR_FREE(xml);
|
2007-08-14 01:47:24 +00:00
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Create a domain from this XML */
|
2008-07-11 19:34:11 +00:00
|
|
|
if (!(def = virDomainDefParseString(conn, driver->caps, xml))) {
|
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"));
|
2007-08-14 01:47:24 +00:00
|
|
|
close(fd);
|
2008-05-29 19:20:22 +00:00
|
|
|
VIR_FREE(xml);
|
2007-08-14 01:47:24 +00:00
|
|
|
return -1;
|
|
|
|
}
|
2008-05-29 19:20:22 +00:00
|
|
|
VIR_FREE(xml);
|
2007-08-14 01:47:24 +00:00
|
|
|
|
|
|
|
/* Ensure the name and UUID don't already exist in an active VM */
|
2008-07-11 19:34:11 +00:00
|
|
|
vm = virDomainFindByUUID(driver->domains, def->uuid);
|
|
|
|
if (!vm)
|
|
|
|
vm = virDomainFindByName(driver->domains, def->name);
|
|
|
|
if (vm && virDomainIsActive(vm)) {
|
2007-08-14 01:47:24 +00:00
|
|
|
qemudReportError(conn, NULL, NULL, VIR_ERR_OPERATION_FAILED,
|
2008-03-24 10:51:47 +00:00
|
|
|
_("domain is already active as '%s'"), vm->def->name);
|
2007-08-14 01:47:24 +00:00
|
|
|
close(fd);
|
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
|
2008-07-11 19:34:11 +00:00
|
|
|
if (!(vm = virDomainAssignDef(conn,
|
|
|
|
&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-07-11 19:34:11 +00:00
|
|
|
virDomainDefFree(def);
|
2007-08-14 01:47:24 +00:00
|
|
|
close(fd);
|
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Set the migration source and start it up. */
|
2008-08-12 08:38:22 +00:00
|
|
|
vm->stdin_fd = fd;
|
2008-07-11 19:34:11 +00:00
|
|
|
ret = qemudStartVMDaemon(conn, driver, vm, "stdio");
|
2007-10-10 19:46:17 +00:00
|
|
|
close(fd);
|
2008-08-12 08:38:22 +00:00
|
|
|
vm->stdin_fd = -1;
|
2007-10-10 19:46:17 +00:00
|
|
|
if (ret < 0) {
|
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 start VM"));
|
2008-08-20 19:42:36 +00:00
|
|
|
if (!vm->persistent)
|
2008-07-11 19:34:11 +00:00
|
|
|
virDomainRemoveInactive(&driver->domains,
|
|
|
|
vm);
|
2007-08-14 01:47:24 +00:00
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* If it was running before, resume it now. */
|
|
|
|
if (header.was_running) {
|
|
|
|
char *info;
|
2007-10-27 01:16:53 +00:00
|
|
|
if (qemudMonitorCommand(driver, vm, "cont", &info) < 0) {
|
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 resume domain"));
|
2007-08-14 01:47:24 +00:00
|
|
|
return -1;
|
|
|
|
}
|
2008-05-29 19:20:22 +00:00
|
|
|
VIR_FREE(info);
|
2007-08-14 01:47:24 +00:00
|
|
|
vm->state = VIR_DOMAIN_RUNNING;
|
|
|
|
}
|
|
|
|
|
|
|
|
return 0;
|
2007-02-14 01:40:09 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
|
2007-06-29 13:23:13 +00:00
|
|
|
static char *qemudDomainDumpXML(virDomainPtr dom,
|
2008-07-11 19:34:11 +00:00
|
|
|
int flags ATTRIBUTE_UNUSED) {
|
2007-06-26 22:39:53 +00:00
|
|
|
struct qemud_driver *driver = (struct qemud_driver *)dom->conn->privateData;
|
2008-07-11 19:34:11 +00:00
|
|
|
virDomainObjPtr vm = virDomainFindByUUID(driver->domains, dom->uuid);
|
2007-02-14 01:40:09 +00:00
|
|
|
if (!vm) {
|
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
|
|
|
qemudReportError(dom->conn, dom, NULL, VIR_ERR_INVALID_DOMAIN,
|
|
|
|
"%s", _("no domain with matching uuid"));
|
2007-06-26 22:39:53 +00:00
|
|
|
return NULL;
|
2007-02-14 01:40:09 +00:00
|
|
|
}
|
|
|
|
|
2008-07-11 19:34:11 +00:00
|
|
|
return virDomainDefFormat(dom->conn,
|
|
|
|
(flags & VIR_DOMAIN_XML_INACTIVE) && vm->newDef ?
|
|
|
|
vm->newDef : vm->def,
|
|
|
|
flags);
|
2007-02-14 01:40:09 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
|
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) {
|
|
|
|
struct qemud_driver *driver = (struct qemud_driver *)conn->privateData;
|
2008-07-11 19:34:11 +00:00
|
|
|
virDomainObjPtr vm = driver->domains;
|
2007-06-26 22:39:53 +00:00
|
|
|
int got = 0, i;
|
2007-02-14 01:40:09 +00:00
|
|
|
while (vm && got < nnames) {
|
2008-07-11 19:34:11 +00:00
|
|
|
if (!virDomainIsActive(vm)) {
|
2007-06-26 22:39:53 +00:00
|
|
|
if (!(names[got] = strdup(vm->def->name))) {
|
qemudReportError: mark for translation string args to this function
* Makefile.maint (msg_gen_function): Add qemudReportError.
* src/qemu_conf.c (qemudLoadDriverConfig)
(qemudExtractVersion, qemudParseDiskXML, qemudParseInterfaceXML)
(qemudParseInputXML, qemudParseXML, qemudNetworkIfaceConnect)
(qemudBuildCommandLine, qemudSaveConfig, qemudParseVMDeviceDef)
(qemudAssignVMDef, qemudSaveVMDef, qemudSaveNetworkConfig)
(qemudParseDhcpRangesXML, qemudParseNetworkXML)
(qemudAssignNetworkDef, qemudSaveNetworkDef, qemudGenerateXML)
(qemudGenerateNetworkXML, qemudDeleteConfig): Mark strings.
* src/qemu_driver.c (qemudBuildDnsmasqArgv, qemudAddIptablesRules)
(qemudGetCapabilities, qemudDomainGetOSType)
(qemudListDefinedDomains, qemudListNetworks)
(qemudListDefinedNetworks, qemudNetworkGetBridgeName): Mark strings.
2008-03-27 13:53:14 +00:00
|
|
|
qemudReportError(conn, NULL, NULL, VIR_ERR_NO_MEMORY,
|
|
|
|
"%s", _("failed to allocate space for VM name string"));
|
2007-06-26 22:39:53 +00:00
|
|
|
goto cleanup;
|
|
|
|
}
|
2007-02-23 08:39:49 +00:00
|
|
|
got++;
|
|
|
|
}
|
2007-02-14 01:40:09 +00:00
|
|
|
vm = vm->next;
|
|
|
|
}
|
|
|
|
return got;
|
2007-06-26 22:39:53 +00:00
|
|
|
|
|
|
|
cleanup:
|
|
|
|
for (i = 0 ; i < got ; i++)
|
2008-05-29 19:20:22 +00:00
|
|
|
VIR_FREE(names[i]);
|
2007-06-26 22:39:53 +00:00
|
|
|
return -1;
|
2007-02-14 01:40:09 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
|
2007-06-29 13:23:13 +00:00
|
|
|
static int qemudNumDefinedDomains(virConnectPtr conn) {
|
2007-06-26 22:39:53 +00:00
|
|
|
struct qemud_driver *driver = (struct qemud_driver *)conn->privateData;
|
2008-07-11 19:34:11 +00:00
|
|
|
int n = 0;
|
|
|
|
virDomainObjPtr dom = driver->domains;
|
|
|
|
while (dom) {
|
|
|
|
if (!virDomainIsActive(dom))
|
|
|
|
n++;
|
|
|
|
dom = dom->next;
|
|
|
|
}
|
|
|
|
return n;
|
2007-02-14 01:40:09 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
|
2007-06-29 13:23:13 +00:00
|
|
|
static int qemudDomainStart(virDomainPtr dom) {
|
2007-06-26 22:39:53 +00:00
|
|
|
struct qemud_driver *driver = (struct qemud_driver *)dom->conn->privateData;
|
2008-07-11 19:34:11 +00:00
|
|
|
virDomainObjPtr vm = virDomainFindByUUID(driver->domains, dom->uuid);
|
2007-02-23 08:41:23 +00:00
|
|
|
|
|
|
|
if (!vm) {
|
2007-06-26 22:39:53 +00:00
|
|
|
qemudReportError(dom->conn, dom, NULL, VIR_ERR_INVALID_DOMAIN,
|
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", _("no domain with matching uuid"));
|
2007-06-26 22:39:53 +00:00
|
|
|
return -1;
|
2007-02-23 08:41:23 +00:00
|
|
|
}
|
|
|
|
|
2008-07-11 19:34:11 +00:00
|
|
|
return qemudStartVMDaemon(dom->conn, driver, vm, NULL);
|
2007-02-14 01:40:09 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
|
2007-06-29 13:23:13 +00:00
|
|
|
static virDomainPtr qemudDomainDefine(virConnectPtr conn, const char *xml) {
|
2007-06-26 22:39:53 +00:00
|
|
|
struct qemud_driver *driver = (struct qemud_driver *)conn->privateData;
|
2008-07-11 19:34:11 +00:00
|
|
|
virDomainDefPtr def;
|
|
|
|
virDomainObjPtr vm;
|
2007-06-26 22:39:53 +00:00
|
|
|
virDomainPtr dom;
|
2007-02-23 08:48:02 +00:00
|
|
|
|
2008-07-11 19:34:11 +00:00
|
|
|
if (!(def = virDomainDefParseString(conn, driver->caps, xml)))
|
2007-02-23 08:48:02 +00:00
|
|
|
return NULL;
|
|
|
|
|
2008-07-11 19:34:11 +00:00
|
|
|
if (!(vm = virDomainAssignDef(conn,
|
|
|
|
&driver->domains,
|
|
|
|
def))) {
|
|
|
|
virDomainDefFree(def);
|
2007-02-23 08:48:02 +00:00
|
|
|
return 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);
|
2007-02-23 08:48:02 +00:00
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
|
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;
|
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) {
|
2007-06-26 22:39:53 +00:00
|
|
|
struct qemud_driver *driver = (struct qemud_driver *)dom->conn->privateData;
|
2008-07-11 19:34:11 +00:00
|
|
|
virDomainObjPtr vm = virDomainFindByUUID(driver->domains, dom->uuid);
|
2007-02-14 01:40:09 +00:00
|
|
|
|
|
|
|
if (!vm) {
|
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
|
|
|
qemudReportError(dom->conn, dom, NULL, VIR_ERR_INVALID_DOMAIN,
|
|
|
|
"%s", _("no domain with matching uuid"));
|
2007-02-14 01:40:09 +00:00
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
|
2008-07-11 19:34:11 +00:00
|
|
|
if (virDomainIsActive(vm)) {
|
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
|
|
|
qemudReportError(dom->conn, dom, NULL, VIR_ERR_INTERNAL_ERROR,
|
|
|
|
"%s", _("cannot delete active domain"));
|
2007-02-14 01:40:09 +00:00
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
|
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"));
|
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (virDomainDeleteConfig(dom->conn, driver->configDir, driver->autostartDir, vm) < 0)
|
2007-02-14 01:40:09 +00:00
|
|
|
return -1;
|
|
|
|
|
2008-07-11 19:34:11 +00:00
|
|
|
virDomainRemoveInactive(&driver->domains,
|
|
|
|
vm);
|
2007-02-14 01:40:09 +00:00
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2007-10-27 01:21:09 +00:00
|
|
|
static int qemudDomainChangeCDROM(virDomainPtr dom,
|
2008-07-11 19:34:11 +00:00
|
|
|
virDomainObjPtr vm,
|
|
|
|
virDomainDiskDefPtr olddisk,
|
|
|
|
virDomainDiskDefPtr newdisk) {
|
2007-10-27 01:21:09 +00:00
|
|
|
struct qemud_driver *driver = (struct qemud_driver *)dom->conn->privateData;
|
|
|
|
char *cmd, *reply, *safe_path;
|
|
|
|
|
2008-07-11 19:34:11 +00:00
|
|
|
if (newdisk->src) {
|
2008-03-13 09:17:45 +00:00
|
|
|
safe_path = qemudEscapeMonitorArg(newdisk->src);
|
|
|
|
if (!safe_path) {
|
|
|
|
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", _("out of memory"));
|
2008-03-13 09:17:45 +00:00
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
if (asprintf (&cmd, "change %s \"%s\"",
|
|
|
|
/* XXX qemu may support multiple CDROM in future */
|
|
|
|
/* olddisk->dst */ "cdrom",
|
|
|
|
safe_path) == -1) {
|
|
|
|
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", _("out of memory"));
|
2008-05-29 19:20:22 +00:00
|
|
|
VIR_FREE(safe_path);
|
2008-03-13 09:17:45 +00:00
|
|
|
return -1;
|
|
|
|
}
|
2008-05-29 19:20:22 +00:00
|
|
|
VIR_FREE(safe_path);
|
2008-03-13 09:17:45 +00:00
|
|
|
|
|
|
|
} else if (asprintf(&cmd, "eject cdrom") == -1) {
|
2007-10-27 01:21:09 +00:00
|
|
|
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", _("out of memory"));
|
2007-10-27 01:21:09 +00:00
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (qemudMonitorCommand(driver, vm, cmd, &reply) < 0) {
|
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
|
|
|
qemudReportError(dom->conn, dom, NULL, VIR_ERR_OPERATION_FAILED,
|
|
|
|
"%s", _("cannot change cdrom media"));
|
2008-05-29 19:20:22 +00:00
|
|
|
VIR_FREE(cmd);
|
2007-10-27 01:21:09 +00:00
|
|
|
return -1;
|
|
|
|
}
|
2008-05-29 19:20:22 +00:00
|
|
|
VIR_FREE(reply);
|
|
|
|
VIR_FREE(cmd);
|
2008-03-13 09:17:45 +00:00
|
|
|
strcpy(olddisk->src, newdisk->src);
|
2007-10-27 01:21:09 +00:00
|
|
|
olddisk->type = newdisk->type;
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2008-08-08 14:27:05 +00:00
|
|
|
static int qemudDomainAttachCdromDevice(virDomainPtr dom,
|
|
|
|
virDomainDeviceDefPtr dev)
|
|
|
|
{
|
2007-10-27 01:21:09 +00:00
|
|
|
struct qemud_driver *driver = (struct qemud_driver *)dom->conn->privateData;
|
2008-07-11 19:34:11 +00:00
|
|
|
virDomainObjPtr vm = virDomainFindByUUID(driver->domains, dom->uuid);
|
|
|
|
virDomainDiskDefPtr disk;
|
2007-10-27 01:21:09 +00:00
|
|
|
|
|
|
|
if (!vm) {
|
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
|
|
|
qemudReportError(dom->conn, dom, NULL, VIR_ERR_INVALID_DOMAIN,
|
|
|
|
"%s", _("no domain with matching uuid"));
|
2007-10-27 01:21:09 +00:00
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
|
|
|
|
disk = vm->def->disks;
|
|
|
|
while (disk) {
|
2008-07-11 19:34:11 +00:00
|
|
|
if (disk->device == VIR_DOMAIN_DISK_DEVICE_CDROM &&
|
|
|
|
STREQ(disk->dst, dev->data.disk->dst))
|
2007-10-27 01:21:09 +00:00
|
|
|
break;
|
|
|
|
disk = disk->next;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (!disk) {
|
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
|
|
|
qemudReportError(dom->conn, dom, NULL, VIR_ERR_NO_SUPPORT,
|
|
|
|
"%s", _("CDROM not attached, cannot change media"));
|
2007-10-27 01:21:09 +00:00
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
|
2008-07-11 19:34:11 +00:00
|
|
|
if (qemudDomainChangeCDROM(dom, vm, disk, dev->data.disk) < 0) {
|
2007-10-27 01:21:09 +00:00
|
|
|
return -1;
|
|
|
|
}
|
2008-08-08 14:27:05 +00:00
|
|
|
return 0;
|
|
|
|
}
|
2007-10-27 01:21:09 +00:00
|
|
|
|
2008-08-08 15:03:00 +00:00
|
|
|
static int qemudDomainAttachUsbMassstorageDevice(virDomainPtr dom, virDomainDeviceDefPtr dev)
|
|
|
|
{
|
|
|
|
struct qemud_driver *driver = (struct qemud_driver *)dom->conn->privateData;
|
|
|
|
virDomainObjPtr vm = virDomainFindByUUID(driver->domains, dom->uuid);
|
|
|
|
int ret;
|
|
|
|
char *cmd, *reply;
|
|
|
|
|
|
|
|
if (!vm) {
|
|
|
|
qemudReportError(dom->conn, dom, NULL, VIR_ERR_INVALID_DOMAIN,
|
|
|
|
"%s", _("no domain with matching uuid"));
|
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
|
|
|
|
ret = asprintf(&cmd, "usb_add disk:%s", dev->data.disk->src);
|
|
|
|
if (ret == -1) {
|
|
|
|
qemudReportError(dom->conn, NULL, NULL, VIR_ERR_NO_MEMORY, NULL);
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (qemudMonitorCommand(driver, vm, cmd, &reply) < 0) {
|
|
|
|
qemudReportError(dom->conn, dom, NULL, VIR_ERR_OPERATION_FAILED,
|
|
|
|
"%s", _("cannot attach usb device"));
|
|
|
|
VIR_FREE(cmd);
|
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
|
|
|
|
DEBUG ("attach_usb reply: %s", reply);
|
|
|
|
/* If the command failed qemu prints:
|
|
|
|
* Could not add ... */
|
|
|
|
if (strstr(reply, "Could not add ")) {
|
|
|
|
qemudReportError (dom->conn, dom, NULL, VIR_ERR_OPERATION_FAILED,
|
|
|
|
"%s",
|
|
|
|
_("adding usb device failed"));
|
|
|
|
VIR_FREE(reply);
|
|
|
|
VIR_FREE(cmd);
|
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
VIR_FREE(reply);
|
|
|
|
VIR_FREE(cmd);
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2008-08-08 14:27:05 +00:00
|
|
|
static int qemudDomainAttachHostDevice(virDomainPtr dom, virDomainDeviceDefPtr dev)
|
|
|
|
{
|
|
|
|
struct qemud_driver *driver = (struct qemud_driver *)dom->conn->privateData;
|
|
|
|
virDomainObjPtr vm = virDomainFindByUUID(driver->domains, dom->uuid);
|
|
|
|
int ret;
|
|
|
|
char *cmd, *reply;
|
|
|
|
|
|
|
|
if (!vm) {
|
|
|
|
qemudReportError(dom->conn, dom, NULL, VIR_ERR_INVALID_DOMAIN,
|
|
|
|
"%s", _("no domain with matching uuid"));
|
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (dev->data.hostdev->source.subsys.usb.vendor) {
|
|
|
|
ret = asprintf(&cmd, "usb_add host:%.4x:%.4x",
|
|
|
|
dev->data.hostdev->source.subsys.usb.vendor,
|
|
|
|
dev->data.hostdev->source.subsys.usb.product);
|
|
|
|
} else {
|
|
|
|
ret = asprintf(&cmd, "usb_add host:%.3d.%.3d",
|
|
|
|
dev->data.hostdev->source.subsys.usb.bus,
|
|
|
|
dev->data.hostdev->source.subsys.usb.device);
|
|
|
|
}
|
|
|
|
if (ret == -1) {
|
|
|
|
qemudReportError(dom->conn, NULL, NULL, VIR_ERR_NO_MEMORY, NULL);
|
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (qemudMonitorCommand(driver, vm, cmd, &reply) < 0) {
|
|
|
|
qemudReportError(dom->conn, dom, NULL, VIR_ERR_OPERATION_FAILED,
|
|
|
|
"%s", _("cannot attach usb device"));
|
|
|
|
VIR_FREE(cmd);
|
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
|
|
|
|
DEBUG ("attach_usb reply: %s", reply);
|
|
|
|
/* If the command failed qemu prints:
|
|
|
|
* Could not add ... */
|
|
|
|
if (strstr(reply, "Could not add ")) {
|
|
|
|
qemudReportError (dom->conn, dom, NULL, VIR_ERR_OPERATION_FAILED,
|
|
|
|
"%s",
|
|
|
|
_("adding usb device failed"));
|
|
|
|
VIR_FREE(reply);
|
|
|
|
VIR_FREE(cmd);
|
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
VIR_FREE(reply);
|
|
|
|
VIR_FREE(cmd);
|
2007-10-27 01:21:09 +00:00
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2008-08-08 14:27:05 +00:00
|
|
|
static int qemudDomainAttachDevice(virDomainPtr dom,
|
|
|
|
const char *xml) {
|
|
|
|
struct qemud_driver *driver = (struct qemud_driver *)dom->conn->privateData;
|
|
|
|
virDomainObjPtr vm = virDomainFindByUUID(driver->domains, dom->uuid);
|
|
|
|
virDomainDeviceDefPtr dev;
|
|
|
|
int ret = 0;
|
|
|
|
|
|
|
|
if (!vm) {
|
|
|
|
qemudReportError(dom->conn, dom, NULL, VIR_ERR_INVALID_DOMAIN,
|
|
|
|
"%s", _("no domain with matching uuid"));
|
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (!virDomainIsActive(vm)) {
|
|
|
|
qemudReportError(dom->conn, dom, NULL, VIR_ERR_INTERNAL_ERROR,
|
|
|
|
"%s", _("cannot attach device on inactive domain"));
|
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
|
|
|
|
dev = virDomainDeviceDefParse(dom->conn, vm->def, xml);
|
|
|
|
if (dev == NULL) {
|
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (dev->type == VIR_DOMAIN_DEVICE_DISK &&
|
|
|
|
dev->data.disk->device == VIR_DOMAIN_DISK_DEVICE_CDROM) {
|
|
|
|
ret = qemudDomainAttachCdromDevice(dom, dev);
|
2008-08-08 15:03:00 +00:00
|
|
|
} else if (dev->type == VIR_DOMAIN_DEVICE_DISK &&
|
|
|
|
dev->data.disk->device == VIR_DOMAIN_DEVICE_DISK &&
|
|
|
|
dev->data.disk->bus == VIR_DOMAIN_DISK_BUS_USB) {
|
|
|
|
ret = qemudDomainAttachUsbMassstorageDevice(dom, dev);
|
2008-08-08 14:27:05 +00:00
|
|
|
} else if (dev->type == VIR_DOMAIN_DEVICE_HOSTDEV &&
|
|
|
|
dev->data.hostdev->mode == VIR_DOMAIN_HOSTDEV_MODE_SUBSYS &&
|
|
|
|
dev->data.hostdev->source.subsys.type == VIR_DOMAIN_HOSTDEV_SUBSYS_TYPE_USB) {
|
|
|
|
ret = qemudDomainAttachHostDevice(dom, dev);
|
|
|
|
} else {
|
|
|
|
qemudReportError(dom->conn, dom, NULL, VIR_ERR_NO_SUPPORT,
|
2008-08-15 01:41:49 +00:00
|
|
|
"%s", _("this devicetype cannot be attached"));
|
2008-08-08 14:27:05 +00:00
|
|
|
ret = -1;
|
|
|
|
}
|
|
|
|
|
|
|
|
VIR_FREE(dev);
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
2007-06-29 13:23:13 +00:00
|
|
|
static int qemudDomainGetAutostart(virDomainPtr dom,
|
2007-06-26 22:39:53 +00:00
|
|
|
int *autostart) {
|
|
|
|
struct qemud_driver *driver = (struct qemud_driver *)dom->conn->privateData;
|
2008-07-11 19:34:11 +00:00
|
|
|
virDomainObjPtr vm = virDomainFindByUUID(driver->domains, dom->uuid);
|
2007-02-23 09:03:25 +00:00
|
|
|
|
|
|
|
if (!vm) {
|
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
|
|
|
qemudReportError(dom->conn, dom, NULL, VIR_ERR_INVALID_DOMAIN,
|
|
|
|
"%s", _("no domain with matching uuid"));
|
2007-02-23 09:03:25 +00:00
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
|
|
|
|
*autostart = vm->autostart;
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2007-06-29 13:23:13 +00:00
|
|
|
static int qemudDomainSetAutostart(virDomainPtr dom,
|
2008-08-20 19:42:36 +00:00
|
|
|
int autostart) {
|
2007-06-26 22:39:53 +00:00
|
|
|
struct qemud_driver *driver = (struct qemud_driver *)dom->conn->privateData;
|
2008-07-11 19:34:11 +00:00
|
|
|
virDomainObjPtr vm = virDomainFindByUUID(driver->domains, dom->uuid);
|
2008-08-20 19:42:36 +00:00
|
|
|
char *configFile = NULL, *autostartLink = NULL;
|
|
|
|
int ret = -1;
|
2007-02-23 09:03:25 +00:00
|
|
|
|
|
|
|
if (!vm) {
|
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
|
|
|
qemudReportError(dom->conn, dom, NULL, VIR_ERR_INVALID_DOMAIN,
|
|
|
|
"%s", _("no domain with matching uuid"));
|
2007-02-23 09:03:25 +00:00
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
|
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"));
|
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
|
2007-02-23 09:03:25 +00:00
|
|
|
autostart = (autostart != 0);
|
|
|
|
|
|
|
|
if (vm->autostart == autostart)
|
|
|
|
return 0;
|
|
|
|
|
2008-08-20 19:42:36 +00:00
|
|
|
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:07:41 +00:00
|
|
|
if (autostart) {
|
|
|
|
int err;
|
|
|
|
|
2007-12-03 14:30:46 +00:00
|
|
|
if ((err = virFileMakePath(driver->autostartDir))) {
|
2007-06-26 22:39:53 +00:00
|
|
|
qemudReportError(dom->conn, dom, NULL, VIR_ERR_INTERNAL_ERROR,
|
2008-03-24 10:51:47 +00:00
|
|
|
_("cannot create autostart directory %s: %s"),
|
2007-06-26 22:13:21 +00:00
|
|
|
driver->autostartDir, strerror(err));
|
2008-08-20 19:42:36 +00:00
|
|
|
goto cleanup;
|
2007-02-23 09:07:41 +00:00
|
|
|
}
|
|
|
|
|
2008-08-20 19:42:36 +00:00
|
|
|
if (symlink(configFile, autostartLink) < 0) {
|
2007-06-26 22:39:53 +00:00
|
|
|
qemudReportError(dom->conn, dom, NULL, VIR_ERR_INTERNAL_ERROR,
|
2008-08-20 19:42:36 +00:00
|
|
|
_("Failed to create symlink '%s to '%s': %s"),
|
|
|
|
autostartLink, configFile, strerror(errno));
|
|
|
|
goto cleanup;
|
2007-02-23 09:07:41 +00:00
|
|
|
}
|
|
|
|
} else {
|
2008-08-20 19:42:36 +00:00
|
|
|
if (unlink(autostartLink) < 0 && errno != ENOENT && errno != ENOTDIR) {
|
2007-06-26 22:39:53 +00:00
|
|
|
qemudReportError(dom->conn, dom, NULL, VIR_ERR_INTERNAL_ERROR,
|
2008-03-24 10:51:47 +00:00
|
|
|
_("Failed to delete symlink '%s': %s"),
|
2008-08-20 19:42:36 +00:00
|
|
|
autostartLink, strerror(errno));
|
|
|
|
goto cleanup;
|
2007-02-23 09:07:41 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2007-02-23 09:03:25 +00:00
|
|
|
vm->autostart = autostart;
|
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);
|
|
|
|
|
|
|
|
return ret;
|
2007-02-23 09:03:25 +00:00
|
|
|
}
|
|
|
|
|
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)
|
|
|
|
{
|
|
|
|
const struct qemud_driver *driver =
|
|
|
|
(struct qemud_driver *)dom->conn->privateData;
|
|
|
|
char *dummy, *info;
|
|
|
|
const char *p, *eol;
|
|
|
|
char qemu_dev_name[32];
|
|
|
|
size_t len;
|
2008-07-11 19:34:11 +00:00
|
|
|
const virDomainObjPtr vm = virDomainFindByID(driver->domains, dom->id);
|
2008-02-26 18:41:43 +00:00
|
|
|
|
|
|
|
if (!vm) {
|
|
|
|
qemudReportError (dom->conn, dom, NULL, VIR_ERR_INVALID_DOMAIN,
|
|
|
|
_("no domain with matching id %d"), dom->id);
|
|
|
|
return -1;
|
|
|
|
}
|
2008-07-11 19:34:11 +00:00
|
|
|
if (!virDomainIsActive (vm)) {
|
2008-02-26 18:41:43 +00:00
|
|
|
qemudReportError (dom->conn, dom, NULL, VIR_ERR_OPERATION_FAILED,
|
|
|
|
"%s", _("domain is not running"));
|
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* QEMU internal block device names are different from the device
|
|
|
|
* names we use in libvirt, so we need to map between them:
|
|
|
|
*
|
|
|
|
* hd[a-] to ide0-hd[0-]
|
|
|
|
* cdrom to ide1-cd0
|
|
|
|
* fd[a-] to floppy[0-]
|
|
|
|
*/
|
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
|
|
|
if (STRPREFIX (path, "hd") && c_islower(path[2]))
|
2008-02-26 18:41:43 +00:00
|
|
|
snprintf (qemu_dev_name, sizeof (qemu_dev_name),
|
|
|
|
"ide0-hd%d", path[2] - 'a');
|
|
|
|
else if (STREQ (path, "cdrom"))
|
|
|
|
strcpy (qemu_dev_name, "ide1-cd0");
|
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
|
|
|
else if (STRPREFIX (path, "fd") && c_islower(path[2]))
|
2008-02-26 18:41:43 +00:00
|
|
|
snprintf (qemu_dev_name, sizeof (qemu_dev_name),
|
|
|
|
"floppy%d", path[2] - 'a');
|
|
|
|
else {
|
|
|
|
qemudReportError (dom->conn, dom, NULL, VIR_ERR_INVALID_ARG,
|
|
|
|
_("invalid path: %s"), path);
|
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
|
|
|
|
len = strlen (qemu_dev_name);
|
|
|
|
|
|
|
|
if (qemudMonitorCommand (driver, vm, "info blockstats", &info) < 0) {
|
|
|
|
qemudReportError (dom->conn, dom, NULL, VIR_ERR_OPERATION_FAILED,
|
|
|
|
"%s", _("'info blockstats' command failed"));
|
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
|
|
|
|
DEBUG ("info blockstats reply: %s", info);
|
|
|
|
|
|
|
|
/* If the command isn't supported then qemu prints the supported
|
|
|
|
* info commands, so the output starts "info ". Since this is
|
|
|
|
* unlikely to be the name of a block device, we can use this
|
|
|
|
* to detect if qemu supports the command.
|
|
|
|
*/
|
2008-05-15 14:21:34 +00:00
|
|
|
if (STRPREFIX (info, "info ")) {
|
2008-02-26 18:41:43 +00:00
|
|
|
free (info);
|
|
|
|
qemudReportError (dom->conn, dom, NULL, VIR_ERR_NO_SUPPORT,
|
|
|
|
"%s",
|
|
|
|
_("'info blockstats' not supported by this qemu"));
|
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
|
|
|
|
stats->rd_req = -1;
|
|
|
|
stats->rd_bytes = -1;
|
|
|
|
stats->wr_req = -1;
|
|
|
|
stats->wr_bytes = -1;
|
|
|
|
stats->errs = -1;
|
|
|
|
|
|
|
|
/* The output format for both qemu & KVM is:
|
|
|
|
* blockdevice: rd_bytes=% wr_bytes=% rd_operations=% wr_operations=%
|
|
|
|
* (repeated for each block device)
|
|
|
|
* where '%' is a 64 bit number.
|
|
|
|
*/
|
|
|
|
p = info;
|
|
|
|
|
|
|
|
while (*p) {
|
|
|
|
if (STREQLEN (p, qemu_dev_name, len)
|
|
|
|
&& p[len] == ':' && p[len+1] == ' ') {
|
|
|
|
|
|
|
|
eol = strchr (p, '\n');
|
|
|
|
if (!eol)
|
|
|
|
eol = p + strlen (p);
|
|
|
|
|
|
|
|
p += len+2; /* Skip to first label. */
|
|
|
|
|
|
|
|
while (*p) {
|
2008-05-15 14:21:34 +00:00
|
|
|
if (STRPREFIX (p, "rd_bytes=")) {
|
2008-02-26 18:41:43 +00:00
|
|
|
p += 9;
|
|
|
|
if (virStrToLong_ll (p, &dummy, 10, &stats->rd_bytes) == -1)
|
|
|
|
DEBUG ("error reading rd_bytes: %s", p);
|
2008-05-15 14:21:34 +00:00
|
|
|
} else if (STRPREFIX (p, "wr_bytes=")) {
|
2008-02-26 18:41:43 +00:00
|
|
|
p += 9;
|
|
|
|
if (virStrToLong_ll (p, &dummy, 10, &stats->wr_bytes) == -1)
|
|
|
|
DEBUG ("error reading wr_bytes: %s", p);
|
2008-05-15 14:21:34 +00:00
|
|
|
} else if (STRPREFIX (p, "rd_operations=")) {
|
2008-02-26 18:41:43 +00:00
|
|
|
p += 14;
|
|
|
|
if (virStrToLong_ll (p, &dummy, 10, &stats->rd_req) == -1)
|
|
|
|
DEBUG ("error reading rd_req: %s", p);
|
2008-05-15 14:21:34 +00:00
|
|
|
} else if (STRPREFIX (p, "wr_operations=")) {
|
2008-02-26 18:41:43 +00:00
|
|
|
p += 14;
|
|
|
|
if (virStrToLong_ll (p, &dummy, 10, &stats->wr_req) == -1)
|
|
|
|
DEBUG ("error reading wr_req: %s", p);
|
|
|
|
} else
|
|
|
|
DEBUG ("unknown block stat near %s", p);
|
|
|
|
|
|
|
|
/* Skip to next label. */
|
|
|
|
p = strchr (p, ' ');
|
|
|
|
if (!p || p >= eol) break;
|
|
|
|
p++;
|
|
|
|
}
|
|
|
|
|
|
|
|
goto done;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Skip to next line. */
|
|
|
|
p = strchr (p, '\n');
|
|
|
|
if (!p) break;
|
|
|
|
p++;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* If we reach here then the device was not found. */
|
|
|
|
free (info);
|
|
|
|
qemudReportError (dom->conn, dom, NULL, VIR_ERR_INVALID_ARG,
|
|
|
|
_("device not found: %s (%s)"), path, qemu_dev_name);
|
|
|
|
return -1;
|
|
|
|
|
|
|
|
done:
|
|
|
|
free (info);
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2007-11-15 17:45:44 +00:00
|
|
|
static int
|
|
|
|
qemudDomainInterfaceStats (virDomainPtr dom,
|
|
|
|
const char *path,
|
|
|
|
struct _virDomainInterfaceStats *stats)
|
|
|
|
{
|
|
|
|
#ifdef __linux__
|
|
|
|
struct qemud_driver *driver = (struct qemud_driver *)dom->conn->privateData;
|
2008-07-11 19:34:11 +00:00
|
|
|
virDomainObjPtr vm = virDomainFindByID(driver->domains, dom->id);
|
|
|
|
virDomainNetDefPtr net;
|
2007-11-15 17:45:44 +00:00
|
|
|
|
|
|
|
if (!vm) {
|
|
|
|
qemudReportError (dom->conn, dom, NULL, VIR_ERR_INVALID_DOMAIN,
|
2008-03-24 10:51:47 +00:00
|
|
|
_("no domain with matching id %d"), dom->id);
|
2007-11-15 17:45:44 +00:00
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
|
2008-07-11 19:34:11 +00:00
|
|
|
if (!virDomainIsActive(vm)) {
|
2007-11-15 17:45:44 +00:00
|
|
|
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", _("domain is not running"));
|
2007-11-15 17:45:44 +00:00
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (!path || path[0] == '\0') {
|
|
|
|
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", _("NULL or empty path"));
|
2007-11-15 17:45:44 +00:00
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Check the path is one of the domain's network interfaces. */
|
|
|
|
for (net = vm->def->nets; net; net = net->next) {
|
2008-07-30 09:20:19 +00:00
|
|
|
if (net->ifname && STREQ (net->ifname, path))
|
2008-07-11 19:34:11 +00:00
|
|
|
goto ok;
|
2007-11-15 17:45:44 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
qemudReportError (dom->conn, dom, NULL, VIR_ERR_INVALID_ARG,
|
2008-03-24 10:51:47 +00:00
|
|
|
_("invalid path, '%s' is not a known interface"), path);
|
2007-11-15 17:45:44 +00:00
|
|
|
return -1;
|
|
|
|
ok:
|
|
|
|
|
|
|
|
return linuxDomainInterfaceStats (dom->conn, path, stats);
|
|
|
|
#else
|
|
|
|
qemudReportError (dom->conn, dom, NULL, VIR_ERR_NO_SUPPORT,
|
|
|
|
"%s", __FUNCTION__);
|
|
|
|
return -1;
|
|
|
|
#endif
|
|
|
|
}
|
|
|
|
|
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)
|
|
|
|
{
|
|
|
|
struct qemud_driver *driver = (struct qemud_driver *)dom->conn->privateData;
|
2008-07-11 19:34:11 +00:00
|
|
|
virDomainObjPtr vm = virDomainFindByUUID(driver->domains, dom->uuid);
|
|
|
|
virDomainDiskDefPtr disk;
|
2008-06-05 21:12:26 +00:00
|
|
|
int fd, ret = -1;
|
|
|
|
|
|
|
|
if (!vm) {
|
|
|
|
qemudReportError (dom->conn, dom, NULL, VIR_ERR_INVALID_DOMAIN,
|
|
|
|
_("no domain with matching uuid"));
|
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (!path || path[0] == '\0') {
|
|
|
|
qemudReportError(dom->conn, dom, NULL, VIR_ERR_INVALID_ARG,
|
|
|
|
_("NULL or empty path"));
|
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Check the path belongs to this domain. */
|
2008-07-11 19:34:11 +00:00
|
|
|
for (disk = vm->def->disks ; disk != NULL ; disk = disk->next) {
|
|
|
|
if (disk->src != NULL &&
|
|
|
|
STREQ (disk->src, path)) goto found;
|
2008-06-05 21:12:26 +00:00
|
|
|
}
|
|
|
|
qemudReportError (dom->conn, dom, NULL, VIR_ERR_INVALID_ARG,
|
|
|
|
_("invalid path"));
|
|
|
|
return -1;
|
|
|
|
|
|
|
|
found:
|
|
|
|
/* The path is correct, now try to open it and get its size. */
|
|
|
|
fd = open (path, O_RDONLY);
|
|
|
|
if (fd == -1) {
|
|
|
|
qemudReportError (dom->conn, dom, NULL, VIR_ERR_SYSTEM_ERROR,
|
|
|
|
"%s", strerror (errno));
|
|
|
|
goto done;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* 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) {
|
|
|
|
qemudReportError (dom->conn, dom, NULL, VIR_ERR_SYSTEM_ERROR,
|
|
|
|
"%s", strerror (errno));
|
|
|
|
goto done;
|
|
|
|
}
|
|
|
|
|
|
|
|
ret = 0;
|
|
|
|
done:
|
|
|
|
if (fd >= 0) close (fd);
|
|
|
|
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)
|
|
|
|
{
|
|
|
|
struct qemud_driver *driver = (struct qemud_driver *)dom->conn->privateData;
|
2008-07-11 19:34:11 +00:00
|
|
|
virDomainObjPtr vm = virDomainFindByID(driver->domains, dom->id);
|
2008-06-10 10:43:28 +00:00
|
|
|
char cmd[256], *info;
|
|
|
|
char tmp[] = TEMPDIR "/qemu.mem.XXXXXX";
|
|
|
|
int fd = -1, ret = -1;
|
|
|
|
|
|
|
|
if (flags != VIR_MEMORY_VIRTUAL) {
|
|
|
|
qemudReportError (dom->conn, dom, NULL, VIR_ERR_INVALID_ARG,
|
|
|
|
_("QEMU driver only supports virtual memory addrs"));
|
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (!vm) {
|
|
|
|
qemudReportError (dom->conn, dom, NULL, VIR_ERR_INVALID_DOMAIN,
|
|
|
|
_("no domain with matching id %d"), dom->id);
|
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
|
2008-07-11 19:34:11 +00:00
|
|
|
if (!virDomainIsActive(vm)) {
|
2008-06-10 10:43:28 +00:00
|
|
|
qemudReportError(dom->conn, dom, NULL, VIR_ERR_OPERATION_FAILED,
|
|
|
|
"%s", _("domain is not running"));
|
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Create a temporary filename. */
|
|
|
|
if ((fd = mkstemp (tmp)) == -1) {
|
|
|
|
qemudReportError (dom->conn, dom, NULL, VIR_ERR_SYSTEM_ERROR,
|
|
|
|
"%s", strerror (errno));
|
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Issue the memsave command. */
|
|
|
|
snprintf (cmd, sizeof cmd, "memsave %llu %zi \"%s\"", offset, size, tmp);
|
|
|
|
if (qemudMonitorCommand (driver, vm, cmd, &info) < 0) {
|
|
|
|
qemudReportError (dom->conn, dom, NULL, VIR_ERR_OPERATION_FAILED,
|
|
|
|
"%s", _("'info blockstats' command failed"));
|
|
|
|
goto done;
|
|
|
|
}
|
|
|
|
|
|
|
|
DEBUG ("memsave reply: %s", info);
|
|
|
|
free (info);
|
|
|
|
|
|
|
|
/* Read the memory file into buffer. */
|
|
|
|
if (saferead (fd, buffer, size) == (ssize_t) -1) {
|
|
|
|
qemudReportError (dom->conn, dom, NULL, VIR_ERR_SYSTEM_ERROR,
|
|
|
|
"%s", strerror (errno));
|
|
|
|
goto done;
|
|
|
|
}
|
|
|
|
|
|
|
|
ret = 0;
|
|
|
|
done:
|
|
|
|
if (fd >= 0) close (fd);
|
|
|
|
unlink (tmp);
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
2007-06-29 13:23:13 +00:00
|
|
|
static virNetworkPtr qemudNetworkLookupByUUID(virConnectPtr conn ATTRIBUTE_UNUSED,
|
2008-07-11 17:33:45 +00:00
|
|
|
const unsigned char *uuid) {
|
2007-07-04 03:59:13 +00:00
|
|
|
struct qemud_driver *driver = (struct qemud_driver *)conn->networkPrivateData;
|
2008-07-11 17:33:45 +00:00
|
|
|
virNetworkObjPtr network = virNetworkFindByUUID(driver->networks, uuid);
|
2007-06-26 22:39:53 +00:00
|
|
|
virNetworkPtr net;
|
|
|
|
|
|
|
|
if (!network) {
|
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
|
|
|
qemudReportError(conn, NULL, NULL, VIR_ERR_NO_NETWORK,
|
|
|
|
"%s", _("no network with matching uuid"));
|
2007-06-26 22:39:53 +00:00
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
|
2007-06-26 23:48:46 +00:00
|
|
|
net = virGetNetwork(conn, network->def->name, network->def->uuid);
|
2007-06-26 22:39:53 +00:00
|
|
|
return net;
|
|
|
|
}
|
2007-06-29 13:23:13 +00:00
|
|
|
static virNetworkPtr qemudNetworkLookupByName(virConnectPtr conn ATTRIBUTE_UNUSED,
|
2008-07-11 17:33:45 +00:00
|
|
|
const char *name) {
|
2007-07-04 03:59:13 +00:00
|
|
|
struct qemud_driver *driver = (struct qemud_driver *)conn->networkPrivateData;
|
2008-07-11 17:33:45 +00:00
|
|
|
virNetworkObjPtr network = virNetworkFindByName(driver->networks, name);
|
2007-06-26 22:39:53 +00:00
|
|
|
virNetworkPtr net;
|
|
|
|
|
|
|
|
if (!network) {
|
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
|
|
|
qemudReportError(conn, NULL, NULL, VIR_ERR_NO_NETWORK,
|
|
|
|
"%s", _("no network with matching name"));
|
2007-06-26 22:39:53 +00:00
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
|
2007-06-26 23:48:46 +00:00
|
|
|
net = virGetNetwork(conn, network->def->name, network->def->uuid);
|
2007-06-26 22:39:53 +00:00
|
|
|
return net;
|
|
|
|
}
|
|
|
|
|
|
|
|
static virDrvOpenStatus qemudOpenNetwork(virConnectPtr conn,
|
2007-11-14 11:40:57 +00:00
|
|
|
xmlURIPtr uri ATTRIBUTE_UNUSED,
|
2007-12-05 18:28:05 +00:00
|
|
|
virConnectAuthPtr auth ATTRIBUTE_UNUSED,
|
2007-06-26 22:39:53 +00:00
|
|
|
int flags ATTRIBUTE_UNUSED) {
|
|
|
|
if (!qemu_driver)
|
|
|
|
return VIR_DRV_OPEN_DECLINED;
|
|
|
|
|
|
|
|
conn->networkPrivateData = qemu_driver;
|
|
|
|
return VIR_DRV_OPEN_SUCCESS;
|
|
|
|
}
|
|
|
|
|
|
|
|
static int qemudCloseNetwork(virConnectPtr conn) {
|
|
|
|
conn->networkPrivateData = NULL;
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2007-06-29 13:23:13 +00:00
|
|
|
static int qemudNumNetworks(virConnectPtr conn) {
|
2008-07-11 17:33:45 +00:00
|
|
|
int nactive = 0;
|
2007-06-26 22:39:53 +00:00
|
|
|
struct qemud_driver *driver = (struct qemud_driver *)conn->networkPrivateData;
|
2008-07-11 17:33:45 +00:00
|
|
|
virNetworkObjPtr net = driver->networks;
|
|
|
|
while (net) {
|
|
|
|
if (virNetworkIsActive(net))
|
|
|
|
nactive++;
|
|
|
|
net = net->next;
|
|
|
|
}
|
|
|
|
return nactive;
|
2007-02-14 15:54:10 +00:00
|
|
|
}
|
|
|
|
|
2007-06-29 13:23:13 +00:00
|
|
|
static int qemudListNetworks(virConnectPtr conn, char **const names, int nnames) {
|
2007-06-26 22:39:53 +00:00
|
|
|
struct qemud_driver *driver = (struct qemud_driver *)conn->networkPrivateData;
|
2008-07-11 17:33:45 +00:00
|
|
|
virNetworkObjPtr network = driver->networks;
|
2007-06-26 22:39:53 +00:00
|
|
|
int got = 0, i;
|
2007-02-14 15:58:06 +00:00
|
|
|
while (network && got < nnames) {
|
2008-07-11 17:33:45 +00:00
|
|
|
if (virNetworkIsActive(network)) {
|
2007-06-26 22:39:53 +00:00
|
|
|
if (!(names[got] = strdup(network->def->name))) {
|
qemudReportError: mark for translation string args to this function
* Makefile.maint (msg_gen_function): Add qemudReportError.
* src/qemu_conf.c (qemudLoadDriverConfig)
(qemudExtractVersion, qemudParseDiskXML, qemudParseInterfaceXML)
(qemudParseInputXML, qemudParseXML, qemudNetworkIfaceConnect)
(qemudBuildCommandLine, qemudSaveConfig, qemudParseVMDeviceDef)
(qemudAssignVMDef, qemudSaveVMDef, qemudSaveNetworkConfig)
(qemudParseDhcpRangesXML, qemudParseNetworkXML)
(qemudAssignNetworkDef, qemudSaveNetworkDef, qemudGenerateXML)
(qemudGenerateNetworkXML, qemudDeleteConfig): Mark strings.
* src/qemu_driver.c (qemudBuildDnsmasqArgv, qemudAddIptablesRules)
(qemudGetCapabilities, qemudDomainGetOSType)
(qemudListDefinedDomains, qemudListNetworks)
(qemudListDefinedNetworks, qemudNetworkGetBridgeName): Mark strings.
2008-03-27 13:53:14 +00:00
|
|
|
qemudReportError(conn, NULL, NULL, VIR_ERR_NO_MEMORY,
|
|
|
|
"%s", _("failed to allocate space for VM name string"));
|
2007-06-26 22:39:53 +00:00
|
|
|
goto cleanup;
|
|
|
|
}
|
2007-02-23 08:39:49 +00:00
|
|
|
got++;
|
|
|
|
}
|
2007-02-14 15:58:06 +00:00
|
|
|
network = network->next;
|
|
|
|
}
|
|
|
|
return got;
|
2007-06-26 22:39:53 +00:00
|
|
|
|
|
|
|
cleanup:
|
|
|
|
for (i = 0 ; i < got ; i++)
|
2008-05-29 19:20:22 +00:00
|
|
|
VIR_FREE(names[i]);
|
2007-06-26 22:39:53 +00:00
|
|
|
return -1;
|
2007-02-14 15:54:10 +00:00
|
|
|
}
|
|
|
|
|
2007-06-29 13:23:13 +00:00
|
|
|
static int qemudNumDefinedNetworks(virConnectPtr conn) {
|
2008-07-11 17:33:45 +00:00
|
|
|
int ninactive = 0;
|
2007-06-26 22:39:53 +00:00
|
|
|
struct qemud_driver *driver = (struct qemud_driver *)conn->networkPrivateData;
|
2008-07-11 17:33:45 +00:00
|
|
|
virNetworkObjPtr net = driver->networks;
|
|
|
|
while (net) {
|
|
|
|
if (!virNetworkIsActive(net))
|
|
|
|
ninactive++;
|
|
|
|
net = net->next;
|
|
|
|
}
|
|
|
|
return ninactive;
|
2007-02-14 15:54:10 +00:00
|
|
|
}
|
|
|
|
|
2007-06-29 13:23:13 +00:00
|
|
|
static int qemudListDefinedNetworks(virConnectPtr conn, char **const names, int nnames) {
|
2007-06-26 22:39:53 +00:00
|
|
|
struct qemud_driver *driver = (struct qemud_driver *)conn->networkPrivateData;
|
2008-07-11 17:33:45 +00:00
|
|
|
virNetworkObjPtr network = driver->networks;
|
2007-06-26 22:39:53 +00:00
|
|
|
int got = 0, i;
|
2007-02-14 15:58:06 +00:00
|
|
|
while (network && got < nnames) {
|
2008-07-11 17:33:45 +00:00
|
|
|
if (!virNetworkIsActive(network)) {
|
2007-06-26 22:39:53 +00:00
|
|
|
if (!(names[got] = strdup(network->def->name))) {
|
qemudReportError: mark for translation string args to this function
* Makefile.maint (msg_gen_function): Add qemudReportError.
* src/qemu_conf.c (qemudLoadDriverConfig)
(qemudExtractVersion, qemudParseDiskXML, qemudParseInterfaceXML)
(qemudParseInputXML, qemudParseXML, qemudNetworkIfaceConnect)
(qemudBuildCommandLine, qemudSaveConfig, qemudParseVMDeviceDef)
(qemudAssignVMDef, qemudSaveVMDef, qemudSaveNetworkConfig)
(qemudParseDhcpRangesXML, qemudParseNetworkXML)
(qemudAssignNetworkDef, qemudSaveNetworkDef, qemudGenerateXML)
(qemudGenerateNetworkXML, qemudDeleteConfig): Mark strings.
* src/qemu_driver.c (qemudBuildDnsmasqArgv, qemudAddIptablesRules)
(qemudGetCapabilities, qemudDomainGetOSType)
(qemudListDefinedDomains, qemudListNetworks)
(qemudListDefinedNetworks, qemudNetworkGetBridgeName): Mark strings.
2008-03-27 13:53:14 +00:00
|
|
|
qemudReportError(conn, NULL, NULL, VIR_ERR_NO_MEMORY,
|
|
|
|
"%s", _("failed to allocate space for VM name string"));
|
2007-06-26 22:39:53 +00:00
|
|
|
goto cleanup;
|
|
|
|
}
|
2007-02-23 08:39:49 +00:00
|
|
|
got++;
|
|
|
|
}
|
2007-02-14 15:58:06 +00:00
|
|
|
network = network->next;
|
|
|
|
}
|
|
|
|
return got;
|
2007-06-26 22:39:53 +00:00
|
|
|
|
|
|
|
cleanup:
|
|
|
|
for (i = 0 ; i < got ; i++)
|
2008-05-29 19:20:22 +00:00
|
|
|
VIR_FREE(names[i]);
|
2007-06-26 22:39:53 +00:00
|
|
|
return -1;
|
2007-02-14 15:54:10 +00:00
|
|
|
}
|
|
|
|
|
2007-06-29 13:23:13 +00:00
|
|
|
static virNetworkPtr qemudNetworkCreate(virConnectPtr conn, const char *xml) {
|
2008-07-11 19:34:11 +00:00
|
|
|
struct qemud_driver *driver = (struct qemud_driver *)conn->networkPrivateData;
|
2008-07-11 17:33:45 +00:00
|
|
|
virNetworkDefPtr def;
|
|
|
|
virNetworkObjPtr network;
|
2007-06-26 22:39:53 +00:00
|
|
|
virNetworkPtr net;
|
2007-02-14 15:58:06 +00:00
|
|
|
|
2008-07-11 17:33:45 +00:00
|
|
|
if (!(def = virNetworkDefParseString(conn, xml)))
|
2007-02-23 08:48:02 +00:00
|
|
|
return NULL;
|
|
|
|
|
2008-07-11 17:33:45 +00:00
|
|
|
if (!(network = virNetworkAssignDef(conn,
|
|
|
|
&driver->networks,
|
|
|
|
def))) {
|
|
|
|
virNetworkDefFree(def);
|
2007-02-14 15:58:06 +00:00
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
|
2007-07-12 15:09:01 +00:00
|
|
|
if (qemudStartNetworkDaemon(conn, driver, network) < 0) {
|
2008-07-11 17:33:45 +00:00
|
|
|
virNetworkRemoveInactive(&driver->networks,
|
|
|
|
network);
|
2007-02-14 15:58:06 +00:00
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
|
2007-06-26 23:48:46 +00:00
|
|
|
net = virGetNetwork(conn, network->def->name, network->def->uuid);
|
2007-06-26 22:39:53 +00:00
|
|
|
return net;
|
2007-02-14 15:54:10 +00:00
|
|
|
}
|
|
|
|
|
2007-06-29 13:23:13 +00:00
|
|
|
static virNetworkPtr qemudNetworkDefine(virConnectPtr conn, const char *xml) {
|
2007-06-26 22:39:53 +00:00
|
|
|
struct qemud_driver *driver = (struct qemud_driver *)conn->networkPrivateData;
|
2008-07-11 17:33:45 +00:00
|
|
|
virNetworkDefPtr def;
|
|
|
|
virNetworkObjPtr network;
|
2007-02-23 08:48:02 +00:00
|
|
|
|
2008-07-11 17:33:45 +00:00
|
|
|
if (!(def = virNetworkDefParseString(conn, xml)))
|
2007-02-23 08:48:02 +00:00
|
|
|
return NULL;
|
|
|
|
|
2008-07-11 17:33:45 +00:00
|
|
|
if (!(network = virNetworkAssignDef(conn,
|
|
|
|
&driver->networks,
|
|
|
|
def))) {
|
|
|
|
virNetworkDefFree(def);
|
2007-02-23 08:48:02 +00:00
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
|
2008-07-11 17:33:45 +00:00
|
|
|
if (virNetworkSaveConfig(conn,
|
|
|
|
driver->networkConfigDir,
|
|
|
|
driver->networkAutostartDir,
|
|
|
|
network) < 0) {
|
|
|
|
virNetworkRemoveInactive(&driver->networks,
|
|
|
|
network);
|
2007-02-23 08:48:02 +00:00
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
|
2008-07-11 17:33:45 +00:00
|
|
|
return virGetNetwork(conn, network->def->name, network->def->uuid);
|
2007-02-14 15:54:10 +00:00
|
|
|
}
|
|
|
|
|
2007-06-29 13:23:13 +00:00
|
|
|
static int qemudNetworkUndefine(virNetworkPtr net) {
|
2007-06-26 22:39:53 +00:00
|
|
|
struct qemud_driver *driver = (struct qemud_driver *)net->conn->networkPrivateData;
|
2008-07-11 17:33:45 +00:00
|
|
|
virNetworkObjPtr network = virNetworkFindByUUID(driver->networks, net->uuid);
|
2007-02-14 15:58:06 +00:00
|
|
|
|
|
|
|
if (!network) {
|
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
|
|
|
qemudReportError(net->conn, NULL, net, VIR_ERR_INVALID_DOMAIN,
|
|
|
|
"%s", _("no network with matching uuid"));
|
2007-02-14 15:58:06 +00:00
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
|
2008-07-11 17:33:45 +00:00
|
|
|
if (virNetworkIsActive(network)) {
|
|
|
|
qemudReportError(net->conn, NULL, net, VIR_ERR_INTERNAL_ERROR,
|
|
|
|
"%s", _("network is still active"));
|
2007-02-14 15:58:06 +00:00
|
|
|
return -1;
|
2008-07-11 17:33:45 +00:00
|
|
|
}
|
2007-02-14 15:58:06 +00:00
|
|
|
|
2008-07-11 17:33:45 +00:00
|
|
|
if (virNetworkDeleteConfig(net->conn, network) < 0)
|
|
|
|
return -1;
|
2007-02-14 15:58:06 +00:00
|
|
|
|
2008-07-11 17:33:45 +00:00
|
|
|
virNetworkRemoveInactive(&driver->networks,
|
|
|
|
network);
|
2007-02-14 15:58:06 +00:00
|
|
|
|
|
|
|
return 0;
|
2007-02-14 15:54:10 +00:00
|
|
|
}
|
|
|
|
|
2007-06-29 13:23:13 +00:00
|
|
|
static int qemudNetworkStart(virNetworkPtr net) {
|
2007-06-26 22:39:53 +00:00
|
|
|
struct qemud_driver *driver = (struct qemud_driver *)net->conn->networkPrivateData;
|
2008-07-11 17:33:45 +00:00
|
|
|
virNetworkObjPtr network = virNetworkFindByUUID(driver->networks, net->uuid);
|
2007-02-23 08:41:23 +00:00
|
|
|
|
|
|
|
if (!network) {
|
2007-06-26 22:39:53 +00:00
|
|
|
qemudReportError(net->conn, NULL, net, VIR_ERR_INVALID_NETWORK,
|
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", _("no network with matching uuid"));
|
2007-06-26 22:39:53 +00:00
|
|
|
return -1;
|
2007-02-23 08:41:23 +00:00
|
|
|
}
|
|
|
|
|
2007-07-12 15:09:01 +00:00
|
|
|
return qemudStartNetworkDaemon(net->conn, driver, network);
|
2007-02-14 15:54:10 +00:00
|
|
|
}
|
|
|
|
|
2007-06-29 13:23:13 +00:00
|
|
|
static int qemudNetworkDestroy(virNetworkPtr net) {
|
2007-06-26 22:39:53 +00:00
|
|
|
struct qemud_driver *driver = (struct qemud_driver *)net->conn->networkPrivateData;
|
2008-07-11 17:33:45 +00:00
|
|
|
virNetworkObjPtr network = virNetworkFindByUUID(driver->networks, net->uuid);
|
2007-07-06 21:52:42 +00:00
|
|
|
int ret;
|
2007-02-23 08:41:23 +00:00
|
|
|
|
2007-02-14 15:58:06 +00:00
|
|
|
if (!network) {
|
2007-06-26 22:39:53 +00:00
|
|
|
qemudReportError(net->conn, NULL, net, VIR_ERR_INVALID_NETWORK,
|
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", _("no network with matching uuid"));
|
2007-02-14 15:58:06 +00:00
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
|
2007-07-12 15:09:01 +00:00
|
|
|
ret = qemudShutdownNetworkDaemon(net->conn, driver, network);
|
2007-07-06 21:52:42 +00:00
|
|
|
|
|
|
|
return ret;
|
2007-02-14 15:54:10 +00:00
|
|
|
}
|
|
|
|
|
2007-06-29 13:23:13 +00:00
|
|
|
static char *qemudNetworkDumpXML(virNetworkPtr net, int flags ATTRIBUTE_UNUSED) {
|
2007-06-26 22:39:53 +00:00
|
|
|
struct qemud_driver *driver = (struct qemud_driver *)net->conn->networkPrivateData;
|
2008-07-11 17:33:45 +00:00
|
|
|
virNetworkObjPtr network = virNetworkFindByUUID(driver->networks, net->uuid);
|
2007-06-26 22:39:53 +00:00
|
|
|
|
2007-02-14 15:58:06 +00:00
|
|
|
if (!network) {
|
2007-06-26 22:39:53 +00:00
|
|
|
qemudReportError(net->conn, NULL, net, VIR_ERR_INVALID_NETWORK,
|
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", _("no network with matching uuid"));
|
2007-06-26 22:39:53 +00:00
|
|
|
return NULL;
|
2007-02-14 15:58:06 +00:00
|
|
|
}
|
|
|
|
|
2008-07-11 17:33:45 +00:00
|
|
|
return virNetworkDefFormat(net->conn, network->def);
|
2007-02-14 15:54:10 +00:00
|
|
|
}
|
2007-02-14 01:40:09 +00:00
|
|
|
|
2007-06-29 13:23:13 +00:00
|
|
|
static char *qemudNetworkGetBridgeName(virNetworkPtr net) {
|
2007-06-26 22:39:53 +00:00
|
|
|
struct qemud_driver *driver = (struct qemud_driver *)net->conn->networkPrivateData;
|
2008-07-11 17:33:45 +00:00
|
|
|
virNetworkObjPtr network = virNetworkFindByUUID(driver->networks, net->uuid);
|
2007-06-26 22:39:53 +00:00
|
|
|
char *bridge;
|
2007-02-14 16:20:38 +00:00
|
|
|
if (!network) {
|
qemudReportError: mark for translation string args to this function
* Makefile.maint (msg_gen_function): Add qemudReportError.
* src/qemu_conf.c (qemudLoadDriverConfig)
(qemudExtractVersion, qemudParseDiskXML, qemudParseInterfaceXML)
(qemudParseInputXML, qemudParseXML, qemudNetworkIfaceConnect)
(qemudBuildCommandLine, qemudSaveConfig, qemudParseVMDeviceDef)
(qemudAssignVMDef, qemudSaveVMDef, qemudSaveNetworkConfig)
(qemudParseDhcpRangesXML, qemudParseNetworkXML)
(qemudAssignNetworkDef, qemudSaveNetworkDef, qemudGenerateXML)
(qemudGenerateNetworkXML, qemudDeleteConfig): Mark strings.
* src/qemu_driver.c (qemudBuildDnsmasqArgv, qemudAddIptablesRules)
(qemudGetCapabilities, qemudDomainGetOSType)
(qemudListDefinedDomains, qemudListNetworks)
(qemudListDefinedNetworks, qemudNetworkGetBridgeName): Mark strings.
2008-03-27 13:53:14 +00:00
|
|
|
qemudReportError(net->conn, NULL, net, VIR_ERR_INVALID_NETWORK,
|
|
|
|
"%s", _("no network with matching id"));
|
2007-06-26 22:39:53 +00:00
|
|
|
return NULL;
|
2007-02-14 16:20:38 +00:00
|
|
|
}
|
|
|
|
|
2008-07-11 17:33:45 +00:00
|
|
|
bridge = strdup(network->def->bridge);
|
2007-06-26 22:39:53 +00:00
|
|
|
if (!bridge) {
|
qemudReportError: mark for translation string args to this function
* Makefile.maint (msg_gen_function): Add qemudReportError.
* src/qemu_conf.c (qemudLoadDriverConfig)
(qemudExtractVersion, qemudParseDiskXML, qemudParseInterfaceXML)
(qemudParseInputXML, qemudParseXML, qemudNetworkIfaceConnect)
(qemudBuildCommandLine, qemudSaveConfig, qemudParseVMDeviceDef)
(qemudAssignVMDef, qemudSaveVMDef, qemudSaveNetworkConfig)
(qemudParseDhcpRangesXML, qemudParseNetworkXML)
(qemudAssignNetworkDef, qemudSaveNetworkDef, qemudGenerateXML)
(qemudGenerateNetworkXML, qemudDeleteConfig): Mark strings.
* src/qemu_driver.c (qemudBuildDnsmasqArgv, qemudAddIptablesRules)
(qemudGetCapabilities, qemudDomainGetOSType)
(qemudListDefinedDomains, qemudListNetworks)
(qemudListDefinedNetworks, qemudNetworkGetBridgeName): Mark strings.
2008-03-27 13:53:14 +00:00
|
|
|
qemudReportError(net->conn, NULL, net, VIR_ERR_NO_MEMORY,
|
|
|
|
"%s", _("failed to allocate space for network bridge string"));
|
2007-06-26 22:39:53 +00:00
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
return bridge;
|
2007-02-14 16:20:38 +00:00
|
|
|
}
|
|
|
|
|
2007-06-29 13:23:13 +00:00
|
|
|
static int qemudNetworkGetAutostart(virNetworkPtr net,
|
2007-02-23 09:03:25 +00:00
|
|
|
int *autostart) {
|
2007-06-26 22:39:53 +00:00
|
|
|
struct qemud_driver *driver = (struct qemud_driver *)net->conn->networkPrivateData;
|
2008-07-11 17:33:45 +00:00
|
|
|
virNetworkObjPtr network = virNetworkFindByUUID(driver->networks, net->uuid);
|
2007-02-23 09:03:25 +00:00
|
|
|
|
|
|
|
if (!network) {
|
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
|
|
|
qemudReportError(net->conn, NULL, net, VIR_ERR_INVALID_NETWORK,
|
|
|
|
"%s", _("no network with matching uuid"));
|
2007-02-23 09:03:25 +00:00
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
|
|
|
|
*autostart = network->autostart;
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2007-06-29 13:23:13 +00:00
|
|
|
static int qemudNetworkSetAutostart(virNetworkPtr net,
|
2007-02-23 09:03:25 +00:00
|
|
|
int autostart) {
|
2007-06-26 22:39:53 +00:00
|
|
|
struct qemud_driver *driver = (struct qemud_driver *)net->conn->networkPrivateData;
|
2008-07-11 17:33:45 +00:00
|
|
|
virNetworkObjPtr network = virNetworkFindByUUID(driver->networks, net->uuid);
|
2007-02-23 09:03:25 +00:00
|
|
|
|
|
|
|
if (!network) {
|
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
|
|
|
qemudReportError(net->conn, NULL, net, VIR_ERR_INVALID_NETWORK,
|
|
|
|
"%s", _("no network with matching uuid"));
|
2007-02-23 09:03:25 +00:00
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
|
|
|
|
autostart = (autostart != 0);
|
|
|
|
|
|
|
|
if (network->autostart == autostart)
|
|
|
|
return 0;
|
|
|
|
|
2007-02-23 09:07:41 +00:00
|
|
|
if (autostart) {
|
|
|
|
int err;
|
|
|
|
|
2007-12-03 14:30:46 +00:00
|
|
|
if ((err = virFileMakePath(driver->networkAutostartDir))) {
|
2007-06-26 22:39:53 +00:00
|
|
|
qemudReportError(net->conn, NULL, net, VIR_ERR_INTERNAL_ERROR,
|
2008-03-24 10:51:47 +00:00
|
|
|
_("cannot create autostart directory %s: %s"),
|
2007-06-26 22:13:21 +00:00
|
|
|
driver->networkAutostartDir, strerror(err));
|
2007-02-23 09:07:41 +00:00
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (symlink(network->configFile, network->autostartLink) < 0) {
|
2007-06-26 22:39:53 +00:00
|
|
|
qemudReportError(net->conn, NULL, net, VIR_ERR_INTERNAL_ERROR,
|
2008-03-24 10:51:47 +00:00
|
|
|
_("Failed to create symlink '%s' to '%s': %s"),
|
2007-02-23 09:07:41 +00:00
|
|
|
network->autostartLink, network->configFile, strerror(errno));
|
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
} else {
|
|
|
|
if (unlink(network->autostartLink) < 0 && errno != ENOENT && errno != ENOTDIR) {
|
2007-06-26 22:39:53 +00:00
|
|
|
qemudReportError(net->conn, NULL, net, VIR_ERR_INTERNAL_ERROR,
|
2008-03-24 10:51:47 +00:00
|
|
|
_("Failed to delete symlink '%s': %s"),
|
2007-02-23 09:07:41 +00:00
|
|
|
network->autostartLink, strerror(errno));
|
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2007-02-23 09:03:25 +00:00
|
|
|
network->autostart = autostart;
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2007-06-26 22:39:53 +00:00
|
|
|
static virDriver qemuDriver = {
|
|
|
|
VIR_DRV_QEMU,
|
|
|
|
"QEMU",
|
|
|
|
LIBVIR_VERSION_NUMBER,
|
2008-02-26 07:05:18 +00:00
|
|
|
qemudProbe, /* probe */
|
2007-06-26 22:39:53 +00:00
|
|
|
qemudOpen, /* open */
|
|
|
|
qemudClose, /* close */
|
2007-08-21 09:03:55 +00:00
|
|
|
NULL, /* supports_feature */
|
2007-06-26 22:39:53 +00:00
|
|
|
qemudGetType, /* type */
|
|
|
|
qemudGetVersion, /* version */
|
2007-09-20 17:13:39 +00:00
|
|
|
qemudGetHostname, /* hostname */
|
2007-11-14 11:40:57 +00:00
|
|
|
NULL, /* URI */
|
2007-06-26 22:39:53 +00:00
|
|
|
qemudGetMaxVCPUs, /* getMaxVcpus */
|
|
|
|
qemudGetNodeInfo, /* nodeGetInfo */
|
|
|
|
qemudGetCapabilities, /* getCapabilities */
|
|
|
|
qemudListDomains, /* listDomains */
|
|
|
|
qemudNumDomains, /* numOfDomains */
|
|
|
|
qemudDomainCreate, /* domainCreateLinux */
|
|
|
|
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 */
|
|
|
|
NULL, /* domainCoreDump */
|
2008-05-07 16:16:44 +00:00
|
|
|
qemudDomainSetVcpus, /* domainSetVcpus */
|
2008-05-22 16:20:31 +00:00
|
|
|
#if HAVE_SCHED_GETAFFINITY
|
|
|
|
qemudDomainPinVcpu, /* domainPinVcpu */
|
|
|
|
qemudDomainGetVcpus, /* domainGetVcpus */
|
|
|
|
#else
|
2007-06-26 22:39:53 +00:00
|
|
|
NULL, /* domainPinVcpu */
|
|
|
|
NULL, /* domainGetVcpus */
|
2008-05-22 16:20:31 +00:00
|
|
|
#endif
|
2008-05-07 16:16:44 +00:00
|
|
|
qemudDomainGetMaxVcpus, /* domainGetMaxVcpus */
|
2007-06-26 22:39:53 +00:00
|
|
|
qemudDomainDumpXML, /* domainDumpXML */
|
|
|
|
qemudListDefinedDomains, /* listDomains */
|
|
|
|
qemudNumDefinedDomains, /* numOfDomains */
|
|
|
|
qemudDomainStart, /* domainCreate */
|
|
|
|
qemudDomainDefine, /* domainDefineXML */
|
|
|
|
qemudDomainUndefine, /* domainUndefine */
|
2007-10-27 01:21:09 +00:00
|
|
|
qemudDomainAttachDevice, /* domainAttachDevice */
|
2007-06-26 22:39:53 +00:00
|
|
|
NULL, /* domainDetachDevice */
|
|
|
|
qemudDomainGetAutostart, /* domainGetAutostart */
|
|
|
|
qemudDomainSetAutostart, /* domainSetAutostart */
|
|
|
|
NULL, /* domainGetSchedulerType */
|
|
|
|
NULL, /* domainGetSchedulerParameters */
|
|
|
|
NULL, /* domainSetSchedulerParameters */
|
2007-08-21 09:31:12 +00:00
|
|
|
NULL, /* domainMigratePrepare */
|
|
|
|
NULL, /* domainMigratePerform */
|
|
|
|
NULL, /* domainMigrateFinish */
|
2008-02-26 18:41:43 +00:00
|
|
|
qemudDomainBlockStats, /* domainBlockStats */
|
2007-11-15 17:45:44 +00:00
|
|
|
qemudDomainInterfaceStats, /* domainInterfaceStats */
|
2008-06-05 21:12:26 +00:00
|
|
|
qemudDomainBlockPeek, /* domainBlockPeek */
|
2008-06-10 10:43:28 +00:00
|
|
|
qemudDomainMemoryPeek, /* domainMemoryPeek */
|
2008-05-22 15:29:50 +00:00
|
|
|
#if HAVE_NUMACTL
|
|
|
|
qemudNodeGetCellsFreeMemory, /* nodeGetCellsFreeMemory */
|
|
|
|
qemudNodeGetFreeMemory, /* getFreeMemory */
|
|
|
|
#else
|
2007-09-28 14:28:12 +00:00
|
|
|
NULL, /* nodeGetCellsFreeMemory */
|
2007-09-30 13:09:07 +00:00
|
|
|
NULL, /* getFreeMemory */
|
2008-05-22 15:29:50 +00:00
|
|
|
#endif
|
2007-06-26 22:39:53 +00:00
|
|
|
};
|
|
|
|
|
|
|
|
static virNetworkDriver qemuNetworkDriver = {
|
2007-07-27 23:23:00 +00:00
|
|
|
"QEMU",
|
2007-06-26 22:39:53 +00:00
|
|
|
qemudOpenNetwork, /* open */
|
|
|
|
qemudCloseNetwork, /* close */
|
|
|
|
qemudNumNetworks, /* numOfNetworks */
|
|
|
|
qemudListNetworks, /* listNetworks */
|
|
|
|
qemudNumDefinedNetworks, /* numOfDefinedNetworks */
|
|
|
|
qemudListDefinedNetworks, /* listDefinedNetworks */
|
|
|
|
qemudNetworkLookupByUUID, /* networkLookupByUUID */
|
|
|
|
qemudNetworkLookupByName, /* networkLookupByName */
|
|
|
|
qemudNetworkCreate, /* networkCreateXML */
|
|
|
|
qemudNetworkDefine, /* networkDefineXML */
|
|
|
|
qemudNetworkUndefine, /* networkUndefine */
|
|
|
|
qemudNetworkStart, /* networkCreate */
|
|
|
|
qemudNetworkDestroy, /* networkDestroy */
|
|
|
|
qemudNetworkDumpXML, /* networkDumpXML */
|
|
|
|
qemudNetworkGetBridgeName, /* networkGetBridgeName */
|
|
|
|
qemudNetworkGetAutostart, /* networkGetAutostart */
|
|
|
|
qemudNetworkSetAutostart, /* networkSetAutostart */
|
|
|
|
};
|
|
|
|
|
2008-06-26 09:37:51 +00:00
|
|
|
#ifdef WITH_LIBVIRTD
|
2007-06-26 22:56:14 +00:00
|
|
|
static virStateDriver qemuStateDriver = {
|
|
|
|
qemudStartup,
|
|
|
|
qemudShutdown,
|
|
|
|
qemudReload,
|
|
|
|
qemudActive,
|
2008-05-13 06:30:58 +00:00
|
|
|
NULL
|
2007-06-26 22:56:14 +00:00
|
|
|
};
|
2008-06-26 09:37:51 +00:00
|
|
|
#endif
|
2007-06-26 22:39:53 +00:00
|
|
|
|
2007-06-26 23:48:46 +00:00
|
|
|
int qemudRegister(void) {
|
|
|
|
virRegisterDriver(&qemuDriver);
|
|
|
|
virRegisterNetworkDriver(&qemuNetworkDriver);
|
2008-06-26 09:37:51 +00:00
|
|
|
#ifdef WITH_LIBVIRTD
|
2007-06-26 23:48:46 +00:00
|
|
|
virRegisterStateDriver(&qemuStateDriver);
|
2008-06-26 09:37:51 +00:00
|
|
|
#endif
|
2007-06-26 23:48:46 +00:00
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2007-11-26 11:50:16 +00:00
|
|
|
#endif /* WITH_QEMU */
|