shaba/libvirt
1
0
Fork 0
mirror of https://gitlab.com/libvirt/libvirt.git synced 2025-03-27 06:50:23 +03:00
Code Releases Activity

Switch QEMU driver over to generic domain APIs

Browse Source
This commit is contained in:
Daniel P. Berrange 2008-07-11 19:34:11 +00:00
parent 774354e3ef
commit 6385fe3ede
12 changed files with 527 additions and 3280 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

20
ChangeLog
View File

@ -1,3 +1,14 @@
Fri Jul 11 20:32:59 BST 2008 Daniel P. Berrange <berrange@redhat.com>
* src/qemu_conf.c, src/qemu_conf.h, src/qemu_driver.c: Switch
over to generic domain APIs
* src/bridge.c, src/bridge.h: Allocate tap device string on
demand.
* tests/qemuxml2argvtest.c, tests/qemuxml2xmltest.c: Update
to new APIs
* tests/qemuxml2argvdata/: Update data files to match new
XML generation format
Fri Jul 11 20:28:59 BST 2008 Daniel P. Berrange <berrange@redhat.com>
* src/domain_conf.c: Set state to SHUTOFF when loading domain
@ -8,15 +19,6 @@ Fri Jul 11 18:58:59 BST 2008 Daniel P. Berrange <berrange@redhat.com>
* src/network_conf.c, src/domain_conf.c: Use full path when
opening XML files
Fri Jul 11 18:34:59 BST 2008 Daniel P. Berrange <berrange@redhat.com>
* src/qemu_conf.c, src/qemu_conf.h, src/qemu_driver.c: Switch
over to generic domain APIs
* tests/qemuxml2argvtest.c, tests/qemuxml2xmltest.c: Update
to new APIs
* tests/qemuxml2argvdata/: Update data files to match new
XML generation format
Fri Jul 11 18:32:59 BST 2008 Daniel P. Berrange <berrange@redhat.com>
* src/bridge.c, src/bridge.h, src/qemu_conf.c, src/qemu_conf.h,

23
src/bridge.c
View File

@ -281,7 +281,6 @@ brDeleteInterface(brControl *ctl ATTRIBUTE_UNUSED,
* @ctl: bridge control pointer
* @bridge: the bridge name
* @ifname: the interface name (or name template)
* @maxlen: size of @ifname array
* @tapfd: file descriptor return value for the new tap device
*
* This function creates a new tap device on a bridge. @ifname can be either
@ -294,8 +293,7 @@ brDeleteInterface(brControl *ctl ATTRIBUTE_UNUSED,
int
brAddTap(brControl *ctl,
const char *bridge,
char *ifname,
int maxlen,
char **ifname,
int *tapfd)
{
int id, subst, fd;
@ -305,7 +303,7 @@ brAddTap(brControl *ctl,
subst = id = 0;
if (strstr(ifname, "%d"))
if (strstr(*ifname, "%d"))
subst = 1;
if ((fd = open("/dev/net/tun", O_RDWR)) < 0)
@ -320,19 +318,19 @@ brAddTap(brControl *ctl,
try.ifr_flags = IFF_TAP|IFF_NO_PI;
if (subst) {
len = snprintf(try.ifr_name, maxlen, ifname, id);
if (len >= maxlen) {
len = snprintf(try.ifr_name, BR_IFNAME_MAXLEN, *ifname, id);
if (len >= BR_IFNAME_MAXLEN) {
errno = EADDRINUSE;
goto error;
}
} else {
len = strlen(ifname);
if (len >= maxlen - 1) {
len = strlen(*ifname);
if (len >= BR_IFNAME_MAXLEN - 1) {
errno = EINVAL;
goto error;
}
strncpy(try.ifr_name, ifname, len);
strncpy(try.ifr_name, *ifname, len);
try.ifr_name[len] = '\0';
}
@ -341,8 +339,11 @@ brAddTap(brControl *ctl,
goto error;
if ((errno = brSetInterfaceUp(ctl, try.ifr_name, 1)))
goto error;
if (ifname)
strncpy(ifname, try.ifr_name, maxlen);
VIR_FREE(*ifname);
if (!(*ifname = strdup(try.ifr_name))) {
errno = ENOMEM;
goto error;
}
*tapfd = fd;
return 0;
}

3
src/bridge.h
View File

@ -60,8 +60,7 @@ int brDeleteInterface (brControl *ctl,
int brAddTap (brControl *ctl,
const char *bridge,
char *ifname,
int maxlen,
char **ifname,
int *tapfd);
int brSetInterfaceUp (brControl *ctl,

2792
src/qemu_conf.c
View File

File diff suppressed because it is too large Load Diff

368
src/qemu_conf.h
View File

@ -29,218 +29,16 @@
#ifdef WITH_QEMU
#include "internal.h"
#include "bridge.h"
#include "iptables.h"
#include "bridge.h"
#include "capabilities.h"
#include "network_conf.h"
#include <netinet/in.h>
#include <sched.h>
#include "domain_conf.h"
#define qemudDebug(fmt, ...) do {} while(0)
/* Different types of QEMU acceleration possible */
enum qemud_vm_virt_type {
QEMUD_VIRT_QEMU,
QEMUD_VIRT_KQEMU,
QEMUD_VIRT_KVM,
};
/* Two types of disk backends */
enum qemud_vm_disk_type {
QEMUD_DISK_BLOCK,
QEMUD_DISK_FILE
};
/* Three types of disk frontend */
enum qemud_vm_disk_device {
QEMUD_DISK_DISK,
QEMUD_DISK_CDROM,
QEMUD_DISK_FLOPPY,
};
enum qemud_vm_disk_bus {
QEMUD_DISK_BUS_IDE,
QEMUD_DISK_BUS_FDC,
QEMUD_DISK_BUS_SCSI,
QEMUD_DISK_BUS_VIRTIO,
QEMUD_DISK_BUS_XEN,
QEMUD_DISK_BUS_LAST
};
/* Stores the virtual disk configuration */
struct qemud_vm_disk_def {
int type;
int device;
int bus;
char src[PATH_MAX];
char dst[NAME_MAX];
int readonly;
struct qemud_vm_disk_def *next;
};
#define QEMUD_MAC_ADDRESS_LEN 6
#define QEMUD_MODEL_MAX_LEN 10
#define QEMUD_OS_TYPE_MAX_LEN 10
#define QEMUD_OS_ARCH_MAX_LEN 10
#define QEMUD_OS_MACHINE_MAX_LEN 10
/* 5 different types of networking config */
enum qemud_vm_net_type {
QEMUD_NET_USER,
QEMUD_NET_ETHERNET,
QEMUD_NET_SERVER,
QEMUD_NET_CLIENT,
QEMUD_NET_MCAST,
QEMUD_NET_NETWORK,
QEMUD_NET_BRIDGE,
};
#define QEMUD_MAX_NAME_LEN 50
#define QEMUD_MAX_XML_LEN 4096
#define QEMUD_MAX_ERROR_LEN 1024
#define QEMUD_CPUMASK_LEN CPU_SETSIZE
/* Stores the virtual network interface configuration */
struct qemud_vm_net_def {
int type;
unsigned char mac[QEMUD_MAC_ADDRESS_LEN];
char model[QEMUD_MODEL_MAX_LEN];
union {
struct {
char ifname[BR_IFNAME_MAXLEN];
char script[PATH_MAX];
} ethernet;
struct {
char address[BR_INET_ADDR_MAXLEN];
int port;
} socket; /* any of NET_CLIENT or NET_SERVER or NET_MCAST */
struct {
char name[QEMUD_MAX_NAME_LEN];
char ifname[BR_IFNAME_MAXLEN];
} network;
struct {
char brname[BR_IFNAME_MAXLEN];
char ifname[BR_IFNAME_MAXLEN];
} bridge;
} dst;
struct qemud_vm_net_def *next;
};
enum qemu_vm_chr_dst_type {
QEMUD_CHR_SRC_TYPE_NULL,
QEMUD_CHR_SRC_TYPE_VC,
QEMUD_CHR_SRC_TYPE_PTY,
QEMUD_CHR_SRC_TYPE_DEV,
QEMUD_CHR_SRC_TYPE_FILE,
QEMUD_CHR_SRC_TYPE_PIPE,
QEMUD_CHR_SRC_TYPE_STDIO,
QEMUD_CHR_SRC_TYPE_UDP,
QEMUD_CHR_SRC_TYPE_TCP,
QEMUD_CHR_SRC_TYPE_UNIX,
QEMUD_CHR_SRC_TYPE_LAST,
};
enum {
QEMUD_CHR_SRC_TCP_PROTOCOL_RAW,
QEMUD_CHR_SRC_TCP_PROTOCOL_TELNET,
};
struct qemud_vm_chr_def {
int dstPort;
int srcType;
union {
struct {
char path[PATH_MAX];
} file; /* pty, file, pipe, or device */
struct {
char host[BR_INET_ADDR_MAXLEN];
char service[BR_INET_ADDR_MAXLEN];
int listen;
int protocol;
} tcp;
struct {
char bindHost[BR_INET_ADDR_MAXLEN];
char bindService[BR_INET_ADDR_MAXLEN];
char connectHost[BR_INET_ADDR_MAXLEN];
char connectService[BR_INET_ADDR_MAXLEN];
} udp;
struct {
char path[PATH_MAX];
int listen;
} nix;
} srcData;
struct qemud_vm_chr_def *next;
};
enum qemu_vm_input_type {
QEMU_INPUT_TYPE_MOUSE,
QEMU_INPUT_TYPE_TABLET,
};
enum qemu_vm_input_bus {
QEMU_INPUT_BUS_PS2,
QEMU_INPUT_BUS_USB,
QEMU_INPUT_BUS_XEN,
};
struct qemud_vm_input_def {
int type;
int bus;
struct qemud_vm_input_def *next;
};
enum qemu_vm_sound_model {
QEMU_SOUND_NONE = 0,
QEMU_SOUND_SB16,
QEMU_SOUND_ES1370,
QEMU_SOUND_PCSPK,
};
struct qemud_vm_sound_def {
int model;
struct qemud_vm_sound_def *next;
};
/* Flags for the 'type' field in next struct */
enum qemud_vm_device_type {
QEMUD_DEVICE_DISK,
QEMUD_DEVICE_NET,
QEMUD_DEVICE_INPUT,
QEMUD_DEVICE_SOUND,
};
struct qemud_vm_device_def {
int type;
union {
struct qemud_vm_disk_def disk;
struct qemud_vm_net_def net;
struct qemud_vm_input_def input;
struct qemud_vm_sound_def sound;
} data;
};
#define QEMUD_MAX_BOOT_DEVS 4
/* 3 possible boot devices */
enum qemud_vm_boot_order {
QEMUD_BOOT_FLOPPY,
QEMUD_BOOT_CDROM,
QEMUD_BOOT_DISK,
QEMUD_BOOT_NET,
};
/* 3 possible graphics console modes */
enum qemud_vm_graphics_type {
QEMUD_GRAPHICS_NONE,
QEMUD_GRAPHICS_SDL,
QEMUD_GRAPHICS_VNC,
};
/* Internal flags to keep track of qemu command line capabilities */
enum qemud_cmd_flags {
QEMUD_CMD_FLAG_KQEMU = (1 << 0),
@ -251,107 +49,12 @@ enum qemud_cmd_flags {
QEMUD_CMD_FLAG_NAME = (1 << 5),
};
enum qemud_vm_features {
QEMUD_FEATURE_ACPI = 1,
};
/* Operating system configuration data & machine / arch */
struct qemud_vm_os_def {
char type[QEMUD_OS_TYPE_MAX_LEN];
char arch[QEMUD_OS_ARCH_MAX_LEN];
char machine[QEMUD_OS_MACHINE_MAX_LEN];
int nBootDevs;
int bootDevs[QEMUD_MAX_BOOT_DEVS];
char kernel[PATH_MAX];
char initrd[PATH_MAX];
char cmdline[PATH_MAX];
char binary[PATH_MAX];
char bootloader[PATH_MAX];
};
/* Guest VM main configuration */
struct qemud_vm_def {
int virtType;
unsigned char uuid[VIR_UUID_BUFLEN];
char name[QEMUD_MAX_NAME_LEN];
unsigned long memory;
unsigned long maxmem;
int vcpus;
char cpumask[QEMUD_CPUMASK_LEN];
int noReboot;
struct qemud_vm_os_def os;
int localtime;
int features;
int graphicsType;
int vncPort;
int vncActivePort;
char vncListen[BR_INET_ADDR_MAXLEN];
char *keymap;
unsigned int ndisks;
struct qemud_vm_disk_def *disks;
unsigned int nnets;
struct qemud_vm_net_def *nets;
unsigned int ninputs;
struct qemud_vm_input_def *inputs;
unsigned int nsounds;
struct qemud_vm_sound_def *sounds;
unsigned int nserials;
struct qemud_vm_chr_def *serials;
unsigned int nparallels;
struct qemud_vm_chr_def *parallels;
};
/* Guest VM runtime state */
struct qemud_vm {
int stdin;
int stdout;
int stderr;
int monitor;
int logfile;
int pid;
int id;
int state;
int *tapfds;
int ntapfds;
int nvcpupids;
int *vcpupids;
int qemuVersion;
int qemuCmdFlags; /* values from enum qemud_cmd_flags */
char configFile[PATH_MAX];
char autostartLink[PATH_MAX];
char migrateFrom[PATH_MAX];
struct qemud_vm_def *def; /* The current definition */
struct qemud_vm_def *newDef; /* New definition to activate at shutdown */
unsigned int autostart : 1;
struct qemud_vm *next;
};
/* Main driver state */
struct qemud_driver {
int qemuVersion;
int nactivevms;
int ninactivevms;
struct qemud_vm *vms;
int nextvmid;
virDomainObjPtr domains;
virNetworkObjPtr networks;
brControl *brctl;
@ -360,22 +63,16 @@ struct qemud_driver {
char *autostartDir;
char *networkConfigDir;
char *networkAutostartDir;
char logDir[PATH_MAX];
char *logDir;
unsigned int vncTLS : 1;
unsigned int vncTLSx509verify : 1;
char *vncTLSx509certdir;
char vncListen[BR_INET_ADDR_MAXLEN];
char *vncListen;
virCapsPtr caps;
};
static inline int
qemudIsActiveVM(const struct qemud_vm *vm)
{
return vm->id != -1;
}
void qemudReportError(virConnectPtr conn,
virDomainPtr dom,
virNetworkPtr net,
@ -386,57 +83,22 @@ void qemudReportError(virConnectPtr conn,
int qemudLoadDriverConfig(struct qemud_driver *driver,
const char *filename);
struct qemud_vm *qemudFindVMByID(const struct qemud_driver *driver,
int id);
struct qemud_vm *qemudFindVMByUUID(const struct qemud_driver *driver,
const unsigned char *uuid);
struct qemud_vm *qemudFindVMByName(const struct qemud_driver *driver,
const char *name);
virCapsPtr qemudCapsInit (void);
int qemudExtractVersion (virConnectPtr conn,
struct qemud_driver *driver);
int qemudExtractVersionInfo (const char *qemu,
int *version,
int *flags);
int qemudBuildCommandLine (virConnectPtr conn,
struct qemud_driver *driver,
struct qemud_vm *vm,
char ***argv);
int qemudScanConfigs (struct qemud_driver *driver);
int qemudDeleteConfig (virConnectPtr conn,
struct qemud_driver *driver,
const char *configFile,
const char *name);
void qemudFreeVMDef (struct qemud_vm_def *vm);
void qemudFreeVM (struct qemud_vm *vm);
struct qemud_vm *
qemudAssignVMDef (virConnectPtr conn,
struct qemud_driver *driver,
struct qemud_vm_def *def);
void qemudRemoveInactiveVM (struct qemud_driver *driver,
struct qemud_vm *vm);
struct qemud_vm_device_def *
qemudParseVMDeviceDef (virConnectPtr conn,
const struct qemud_vm_def *def,
const char *xmlStr);
struct qemud_vm_def *
qemudParseVMDef (virConnectPtr conn,
struct qemud_driver *driver,
const char *xmlStr,
const char *displayName);
int qemudSaveVMDef (virConnectPtr conn,
struct qemud_driver *driver,
struct qemud_vm *vm,
struct qemud_vm_def *def);
char * qemudGenerateXML (virConnectPtr conn,
struct qemud_driver *driver,
struct qemud_vm *vm,
struct qemud_vm_def *def,
int live);
virDomainObjPtr dom,
int qemuCmdFlags,
char ***argv,
int **tapfds,
int *ntapfds,
const char *migrateFrom);
const char *qemudVirtTypeToString (int type);

535
src/qemu_driver.c
View File

File diff suppressed because it is too large Load Diff

2
tests/qemuxml2argvdata/qemuxml2argv-bootloader.xml
View File

@ -6,7 +6,7 @@
<vcpu>1</vcpu>
<bootloader>/usr/bin/pygrub</bootloader>
<os>
<type>xen</type>
<type arch='x86_64' machine='xenner'>xen</type>
</os>
<clock offset='utc'/>
<on_poweroff>destroy</on_poweroff>

2
tests/qemuxml2argvdata/qemuxml2argv-graphics-vnc.xml
View File

@ -19,6 +19,6 @@
<target dev='hda' bus='ide'/>
</disk>
<input type='mouse' bus='ps2'/>
<graphics type='vnc' port='5903' listen='127.0.0.1'/>
<graphics type='vnc' port='5903' autoport='no' listen='127.0.0.1'/>
</devices>
</domain>

4
tests/qemuxml2argvdata/qemuxml2argv-input-xen.xml
View File

@ -6,7 +6,7 @@
<vcpu>1</vcpu>
<bootloader>/foo</bootloader>
<os>
<type>xen</type>
<type arch='x86_64' machine='xenner'>xen</type>
</os>
<clock offset='utc'/>
<on_poweroff>destroy</on_poweroff>
@ -19,6 +19,6 @@
<target dev='hda' bus='ide'/>
</disk>
<input type='mouse' bus='xen'/>
<graphics type='vnc' port='-1'/>
<graphics type='vnc' port='5903' autoport='no' listen='127.0.0.1'/>
</devices>
</domain>

7
tests/qemuxml2argvdata/qemuxml2argv-sound.xml
View File

@ -16,15 +16,10 @@
<emulator>/usr/bin/qemu</emulator>
<disk type='block' device='disk'>
<source dev='/dev/HostVG/QEMUGuest1'/>
<target dev='hda'/>
<target dev='hda' bus='ide'/>
</disk>
<sound model='pcspk'/>
<sound model='pcspk'/>
<sound model='es1370'/>
<sound model='pcspk'/>
<sound model='sb16'/>
<sound model='es1370'/>
<sound model='pcspk'/>
<sound model='sb16'/>
</devices>
</domain>

31
tests/qemuxml2argvtest.c
View File

@ -23,39 +23,33 @@ static struct qemud_driver driver;
#define MAX_FILE 4096
static int testCompareXMLToArgvFiles(const char *xml, const char *cmd, int extraFlags) {
char xmlData[MAX_FILE];
char argvData[MAX_FILE];
char *xmlPtr = &(xmlData[0]);
char *expectargv = &(argvData[0]);
char *actualargv = NULL;
char **argv = NULL;
char **tmp = NULL;
int ret = -1, len;
struct qemud_vm_def *vmdef = NULL;
struct qemud_vm vm;
if (virtTestLoadFile(xml, &xmlPtr, MAX_FILE) < 0)
goto fail;
int ret = -1, len, flags;
virDomainDefPtr vmdef = NULL;
virDomainObj vm;
if (virtTestLoadFile(cmd, &expectargv, MAX_FILE) < 0)
goto fail;
if (!(vmdef = qemudParseVMDef(NULL, &driver, xmlData, "test")))
if (!(vmdef = virDomainDefParseFile(NULL, driver.caps, xml)))
goto fail;
memset(&vm, 0, sizeof vm);
vm.def = vmdef;
vm.def->id = -1;
vm.pid = -1;
vm.id = -1;
vm.qemuVersion = 0 * 1000 * 100 + (8 * 1000) + 1;
vm.qemuCmdFlags = QEMUD_CMD_FLAG_VNC_COLON |
QEMUD_CMD_FLAG_NO_REBOOT;
vm.qemuCmdFlags |= extraFlags;
vm.migrateFrom[0] = '\0';
vmdef->vncActivePort = vmdef->vncPort;
flags = QEMUD_CMD_FLAG_VNC_COLON |
QEMUD_CMD_FLAG_NO_REBOOT |
extraFlags;
if (qemudBuildCommandLine(NULL, &driver, &vm, &argv) < 0)
if (qemudBuildCommandLine(NULL, &driver,
&vm, flags, &argv,
NULL, NULL, NULL) < 0)
goto fail;
tmp = argv;
@ -92,8 +86,7 @@ static int testCompareXMLToArgvFiles(const char *xml, const char *cmd, int extra
}
free(argv);
}
if (vmdef)
qemudFreeVMDef(vmdef);
virDomainDefFree(vmdef);
return ret;
}

20
tests/qemuxml2xmltest.c
View File

@ -27,25 +27,15 @@ static int testCompareXMLToXMLFiles(const char *xml) {
char *xmlPtr = &(xmlData[0]);
char *actual = NULL;
int ret = -1;
struct qemud_vm_def *vmdef = NULL;
struct qemud_vm vm;
virDomainDefPtr vmdef = NULL;
if (virtTestLoadFile(xml, &xmlPtr, MAX_FILE) < 0)
goto fail;
if (!(vmdef = qemudParseVMDef(NULL, &driver, xmlData, "test")))
if (!(vmdef = virDomainDefParseString(NULL, driver.caps, xmlData)))
goto fail;
vm.def = vmdef;
vm.pid = -1;
vm.id = -1;
vm.qemuVersion = 0 * 1000 * 100 + (8 * 1000) + 1;
vm.qemuCmdFlags = QEMUD_CMD_FLAG_VNC_COLON |
QEMUD_CMD_FLAG_NO_REBOOT;
vmdef->vncActivePort = vmdef->vncPort;
if (!(actual = qemudGenerateXML(NULL, &driver, &vm, vmdef, 0)))
if (!(actual = virDomainDefFormat(NULL, vmdef, 0)))
goto fail;
if (STRNEQ(xmlData, actual)) {
@ -57,8 +47,7 @@ static int testCompareXMLToXMLFiles(const char *xml) {
fail:
free(actual);
if (vmdef)
qemudFreeVMDef(vmdef);
virDomainDefFree(vmdef);
return ret;
}
@ -115,6 +104,7 @@ mymain(int argc, char **argv)
DO_TEST("misc-no-reboot");
DO_TEST("net-user");
DO_TEST("net-virtio");
DO_TEST("sound");
DO_TEST("serial-vc");
DO_TEST("serial-pty");