2005-12-07 18:10:51 +00:00
|
|
|
/*
|
|
|
|
* xen_internal.c: direct access to Xen hypervisor level
|
|
|
|
*
|
2006-08-29 22:27:07 +00:00
|
|
|
* Copyright (C) 2005, 2006 Red Hat, Inc.
|
2005-12-07 18:10:51 +00:00
|
|
|
*
|
|
|
|
* See COPYING.LIB for the License of this software
|
|
|
|
*
|
|
|
|
* Daniel Veillard <veillard@redhat.com>
|
|
|
|
*/
|
|
|
|
|
2007-03-15 07:43:16 +00:00
|
|
|
#ifdef WITH_XEN
|
|
|
|
|
2005-12-07 18:10:51 +00:00
|
|
|
#include <stdio.h>
|
|
|
|
#include <string.h>
|
2006-03-23 15:42:10 +00:00
|
|
|
/* required for uint8_t, uint32_t, etc ... */
|
2005-12-07 18:10:51 +00:00
|
|
|
#include <stdint.h>
|
|
|
|
#include <sys/types.h>
|
|
|
|
#include <sys/stat.h>
|
|
|
|
#include <unistd.h>
|
|
|
|
#include <fcntl.h>
|
|
|
|
#include <sys/mman.h>
|
|
|
|
#include <sys/ioctl.h>
|
2006-08-04 10:41:05 +00:00
|
|
|
#include <limits.h>
|
2006-03-23 15:42:10 +00:00
|
|
|
#include <stdint.h>
|
2007-03-15 17:24:56 +00:00
|
|
|
#include <regex.h>
|
|
|
|
#include <errno.h>
|
|
|
|
#include <sys/utsname.h>
|
2006-03-23 15:42:10 +00:00
|
|
|
|
|
|
|
/* required for dom0_getdomaininfo_t */
|
2005-12-07 18:10:51 +00:00
|
|
|
#include <xen/dom0_ops.h>
|
2005-12-08 13:26:52 +00:00
|
|
|
#include <xen/version.h>
|
2005-12-07 18:10:51 +00:00
|
|
|
#include <xen/xen.h>
|
2006-06-20 16:07:41 +00:00
|
|
|
#include <xen/linux/privcmd.h>
|
2005-12-07 18:10:51 +00:00
|
|
|
|
2006-10-11 16:11:59 +00:00
|
|
|
/* required for shutdown flags */
|
|
|
|
#include <xen/sched.h>
|
|
|
|
|
2007-03-15 17:24:56 +00:00
|
|
|
#include "xml.h"
|
|
|
|
|
2006-09-02 21:23:14 +00:00
|
|
|
/* #define DEBUG */
|
|
|
|
/*
|
2006-09-28 23:29:25 +00:00
|
|
|
* so far there is 2 versions of the structures usable for doing
|
2006-09-02 21:23:14 +00:00
|
|
|
* hypervisor calls.
|
|
|
|
*/
|
|
|
|
/* the old one */
|
|
|
|
typedef struct v0_hypercall_struct {
|
2006-06-21 12:15:18 +00:00
|
|
|
unsigned long op;
|
|
|
|
unsigned long arg[5];
|
2006-09-02 21:23:14 +00:00
|
|
|
} v0_hypercall_t;
|
|
|
|
#define XEN_V0_IOCTL_HYPERCALL_CMD \
|
|
|
|
_IOC(_IOC_NONE, 'P', 0, sizeof(v0_hypercall_t))
|
|
|
|
|
|
|
|
/* the new one */
|
|
|
|
typedef struct v1_hypercall_struct
|
|
|
|
{
|
|
|
|
uint64_t op;
|
|
|
|
uint64_t arg[5];
|
|
|
|
} v1_hypercall_t;
|
2006-09-28 23:29:25 +00:00
|
|
|
#define XEN_V1_IOCTL_HYPERCALL_CMD \
|
|
|
|
_IOC(_IOC_NONE, 'P', 0, sizeof(v1_hypercall_t))
|
2006-06-21 12:15:18 +00:00
|
|
|
|
2006-09-02 21:23:14 +00:00
|
|
|
typedef v1_hypercall_t hypercall_t;
|
|
|
|
|
|
|
|
#ifndef __HYPERVISOR_sysctl
|
|
|
|
#define __HYPERVISOR_sysctl 35
|
|
|
|
#endif
|
|
|
|
#ifndef __HYPERVISOR_domctl
|
|
|
|
#define __HYPERVISOR_domctl 36
|
|
|
|
#endif
|
2005-12-07 18:10:51 +00:00
|
|
|
|
2006-06-21 12:15:18 +00:00
|
|
|
static int xen_ioctl_hypercall_cmd = 0;
|
|
|
|
static int initialized = 0;
|
2006-09-02 21:23:14 +00:00
|
|
|
static int in_init = 0;
|
2006-06-21 12:15:18 +00:00
|
|
|
static int hv_version = 0;
|
2006-09-02 21:23:14 +00:00
|
|
|
static int hypervisor_version = 2;
|
|
|
|
static int sys_interface_version = -1;
|
|
|
|
static int dom_interface_version = -1;
|
2006-10-16 16:04:55 +00:00
|
|
|
static int kb_per_pages = 0;
|
2006-09-02 21:23:14 +00:00
|
|
|
|
2007-03-15 17:24:56 +00:00
|
|
|
/* Regular expressions used by xenHypervisorGetCapabilities, and
|
|
|
|
* compiled once by xenHypervisorInit. Note that these are POSIX.2
|
|
|
|
* extended regular expressions (regex(7)).
|
|
|
|
*/
|
|
|
|
static const char *flags_hvm_re = "^flags[[:blank:]]+:.* (vmx|svm)[[:space:]]";
|
|
|
|
static regex_t flags_hvm_rec;
|
|
|
|
static const char *flags_pae_re = "^flags[[:blank:]]+:.* pae[[:space:]]";
|
|
|
|
static regex_t flags_pae_rec;
|
2007-03-27 14:45:17 +00:00
|
|
|
static const char *xen_cap_re = "(xen|hvm)-[[:digit:]]+\\.[[:digit:]]+-(x86_32|x86_64|ia64|powerpc64)(p|be)?";
|
2007-03-15 17:24:56 +00:00
|
|
|
static regex_t xen_cap_rec;
|
|
|
|
|
2006-09-02 21:23:14 +00:00
|
|
|
/*
|
|
|
|
* The content of the structures for a getdomaininfolist system hypercall
|
|
|
|
*/
|
|
|
|
#ifndef DOMFLAGS_DYING
|
|
|
|
#define DOMFLAGS_DYING (1<<0) /* Domain is scheduled to die. */
|
|
|
|
#define DOMFLAGS_SHUTDOWN (1<<2) /* The guest OS has shut down. */
|
|
|
|
#define DOMFLAGS_PAUSED (1<<3) /* Currently paused by control software. */
|
|
|
|
#define DOMFLAGS_BLOCKED (1<<4) /* Currently blocked pending an event. */
|
|
|
|
#define DOMFLAGS_RUNNING (1<<5) /* Domain is currently running. */
|
|
|
|
#define DOMFLAGS_CPUMASK 255 /* CPU to which this domain is bound. */
|
|
|
|
#define DOMFLAGS_CPUSHIFT 8
|
|
|
|
#define DOMFLAGS_SHUTDOWNMASK 255 /* DOMFLAGS_SHUTDOWN guest-supplied code. */
|
|
|
|
#define DOMFLAGS_SHUTDOWNSHIFT 16
|
|
|
|
#endif
|
|
|
|
|
2006-10-11 16:11:59 +00:00
|
|
|
/*
|
|
|
|
* These flags explain why a system is in the state of "shutdown". Normally,
|
|
|
|
* They are defined in xen/sched.h
|
|
|
|
*/
|
|
|
|
#ifndef SHUTDOWN_poweroff
|
|
|
|
#define SHUTDOWN_poweroff 0 /* Domain exited normally. Clean up and kill. */
|
|
|
|
#define SHUTDOWN_reboot 1 /* Clean up, kill, and then restart. */
|
|
|
|
#define SHUTDOWN_suspend 2 /* Clean up, save suspend info, kill. */
|
|
|
|
#define SHUTDOWN_crash 3 /* Tell controller we've crashed. */
|
|
|
|
#endif
|
|
|
|
|
2006-09-02 21:23:14 +00:00
|
|
|
#define XEN_V0_OP_GETDOMAININFOLIST 38
|
|
|
|
#define XEN_V1_OP_GETDOMAININFOLIST 38
|
|
|
|
#define XEN_V2_OP_GETDOMAININFOLIST 6
|
|
|
|
|
|
|
|
struct xen_v0_getdomaininfo {
|
|
|
|
domid_t domain; /* the domain number */
|
|
|
|
uint32_t flags; /* falgs, see before */
|
|
|
|
uint64_t tot_pages; /* total number of pages used */
|
|
|
|
uint64_t max_pages; /* maximum number of pages allowed */
|
2006-09-19 15:55:57 +00:00
|
|
|
unsigned long shared_info_frame; /* MFN of shared_info struct */
|
2006-09-02 21:23:14 +00:00
|
|
|
uint64_t cpu_time; /* CPU time used */
|
|
|
|
uint32_t nr_online_vcpus; /* Number of VCPUs currently online. */
|
|
|
|
uint32_t max_vcpu_id; /* Maximum VCPUID in use by this domain. */
|
|
|
|
uint32_t ssidref;
|
|
|
|
xen_domain_handle_t handle;
|
|
|
|
};
|
|
|
|
typedef struct xen_v0_getdomaininfo xen_v0_getdomaininfo;
|
|
|
|
|
2006-09-28 23:29:25 +00:00
|
|
|
struct xen_v2_getdomaininfo {
|
|
|
|
domid_t domain; /* the domain number */
|
|
|
|
uint32_t flags; /* falgs, see before */
|
|
|
|
uint64_t tot_pages; /* total number of pages used */
|
|
|
|
uint64_t max_pages; /* maximum number of pages allowed */
|
|
|
|
uint64_t shared_info_frame; /* MFN of shared_info struct */
|
|
|
|
uint64_t cpu_time; /* CPU time used */
|
|
|
|
uint32_t nr_online_vcpus; /* Number of VCPUs currently online. */
|
|
|
|
uint32_t max_vcpu_id; /* Maximum VCPUID in use by this domain. */
|
|
|
|
uint32_t ssidref;
|
|
|
|
xen_domain_handle_t handle;
|
|
|
|
};
|
|
|
|
typedef struct xen_v2_getdomaininfo xen_v2_getdomaininfo;
|
|
|
|
|
|
|
|
union xen_getdomaininfo {
|
|
|
|
struct xen_v0_getdomaininfo v0;
|
|
|
|
struct xen_v2_getdomaininfo v2;
|
|
|
|
};
|
|
|
|
typedef union xen_getdomaininfo xen_getdomaininfo;
|
|
|
|
|
|
|
|
union xen_getdomaininfolist {
|
|
|
|
struct xen_v0_getdomaininfo *v0;
|
|
|
|
struct xen_v2_getdomaininfo *v2;
|
|
|
|
};
|
|
|
|
typedef union xen_getdomaininfolist xen_getdomaininfolist;
|
|
|
|
|
|
|
|
#define XEN_GETDOMAININFOLIST_ALLOC(domlist, size) \
|
|
|
|
(hypervisor_version < 2 ? \
|
|
|
|
((domlist.v0 = malloc(sizeof(xen_v0_getdomaininfo)*(size))) != NULL) : \
|
|
|
|
((domlist.v2 = malloc(sizeof(xen_v2_getdomaininfo)*(size))) != NULL))
|
|
|
|
|
|
|
|
#define XEN_GETDOMAININFOLIST_FREE(domlist) \
|
|
|
|
(hypervisor_version < 2 ? \
|
|
|
|
free(domlist.v0) : \
|
|
|
|
free(domlist.v2))
|
|
|
|
|
|
|
|
#define XEN_GETDOMAININFOLIST_CLEAR(domlist, size) \
|
|
|
|
(hypervisor_version < 2 ? \
|
|
|
|
memset(domlist.v0, 0, sizeof(xen_v0_getdomaininfo) * size) : \
|
|
|
|
memset(domlist.v2, 0, sizeof(xen_v2_getdomaininfo) * size))
|
|
|
|
|
|
|
|
#define XEN_GETDOMAININFOLIST_DOMAIN(domlist, n) \
|
|
|
|
(hypervisor_version < 2 ? \
|
|
|
|
domlist.v0[n].domain : \
|
|
|
|
domlist.v2[n].domain)
|
|
|
|
|
2006-10-02 19:26:39 +00:00
|
|
|
#define XEN_GETDOMAININFOLIST_DATA(domlist) \
|
|
|
|
(hypervisor_version < 2 ? \
|
|
|
|
(void*)(domlist->v0) : \
|
|
|
|
(void*)(domlist->v2))
|
2006-09-28 23:29:25 +00:00
|
|
|
|
2006-10-02 19:26:39 +00:00
|
|
|
#define XEN_GETDOMAININFO_SIZE \
|
|
|
|
(hypervisor_version < 2 ? \
|
|
|
|
sizeof(xen_v0_getdomaininfo) : \
|
|
|
|
sizeof(xen_v2_getdomaininfo))
|
2006-09-28 23:29:25 +00:00
|
|
|
|
|
|
|
#define XEN_GETDOMAININFO_CLEAR(dominfo) \
|
|
|
|
(hypervisor_version < 2 ? \
|
|
|
|
memset(&(dominfo.v0), 0, sizeof(xen_v0_getdomaininfo)) : \
|
|
|
|
memset(&(dominfo.v2), 0, sizeof(xen_v2_getdomaininfo)))
|
|
|
|
|
|
|
|
#define XEN_GETDOMAININFO_DOMAIN(dominfo) \
|
|
|
|
(hypervisor_version < 2 ? \
|
|
|
|
dominfo.v0.domain : \
|
|
|
|
dominfo.v2.domain)
|
|
|
|
|
|
|
|
#define XEN_GETDOMAININFO_CPUTIME(dominfo) \
|
|
|
|
(hypervisor_version < 2 ? \
|
|
|
|
dominfo.v0.cpu_time : \
|
|
|
|
dominfo.v2.cpu_time)
|
|
|
|
|
|
|
|
#define XEN_GETDOMAININFO_CPUCOUNT(dominfo) \
|
|
|
|
(hypervisor_version < 2 ? \
|
|
|
|
dominfo.v0.nr_online_vcpus : \
|
|
|
|
dominfo.v2.nr_online_vcpus)
|
|
|
|
|
2007-03-08 08:31:07 +00:00
|
|
|
#define XEN_GETDOMAININFO_MAXCPUID(dominfo) \
|
|
|
|
(hypervisor_version < 2 ? \
|
|
|
|
dominfo.v0.max_vcpu_id : \
|
|
|
|
dominfo.v2.max_vcpu_id)
|
|
|
|
|
2006-09-28 23:29:25 +00:00
|
|
|
#define XEN_GETDOMAININFO_FLAGS(dominfo) \
|
|
|
|
(hypervisor_version < 2 ? \
|
|
|
|
dominfo.v0.flags : \
|
|
|
|
dominfo.v2.flags)
|
|
|
|
|
|
|
|
#define XEN_GETDOMAININFO_TOT_PAGES(dominfo) \
|
|
|
|
(hypervisor_version < 2 ? \
|
|
|
|
dominfo.v0.tot_pages : \
|
|
|
|
dominfo.v2.tot_pages)
|
|
|
|
|
|
|
|
#define XEN_GETDOMAININFO_MAX_PAGES(dominfo) \
|
|
|
|
(hypervisor_version < 2 ? \
|
|
|
|
dominfo.v0.max_pages : \
|
|
|
|
dominfo.v2.max_pages)
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
struct xen_v0_getdomaininfolistop {
|
2006-09-02 21:23:14 +00:00
|
|
|
domid_t first_domain;
|
|
|
|
uint32_t max_domains;
|
|
|
|
struct xen_v0_getdomaininfo *buffer;
|
|
|
|
uint32_t num_domains;
|
|
|
|
};
|
2006-09-28 23:29:25 +00:00
|
|
|
typedef struct xen_v0_getdomaininfolistop xen_v0_getdomaininfolistop;
|
|
|
|
|
|
|
|
|
|
|
|
struct xen_v2_getdomaininfolistop {
|
|
|
|
domid_t first_domain;
|
|
|
|
uint32_t max_domains;
|
|
|
|
struct xen_v2_getdomaininfo *buffer;
|
|
|
|
uint32_t num_domains;
|
|
|
|
};
|
|
|
|
typedef struct xen_v2_getdomaininfolistop xen_v2_getdomaininfolistop;
|
|
|
|
|
|
|
|
|
2006-09-02 21:23:14 +00:00
|
|
|
|
|
|
|
struct xen_v0_domainop {
|
|
|
|
domid_t domain;
|
|
|
|
};
|
|
|
|
typedef struct xen_v0_domainop xen_v0_domainop;
|
|
|
|
|
|
|
|
/*
|
|
|
|
* The informations for a destroydomain system hypercall
|
|
|
|
*/
|
|
|
|
#define XEN_V0_OP_DESTROYDOMAIN 9
|
|
|
|
#define XEN_V1_OP_DESTROYDOMAIN 9
|
|
|
|
#define XEN_V2_OP_DESTROYDOMAIN 2
|
|
|
|
|
|
|
|
/*
|
|
|
|
* The informations for a pausedomain system hypercall
|
|
|
|
*/
|
|
|
|
#define XEN_V0_OP_PAUSEDOMAIN 10
|
|
|
|
#define XEN_V1_OP_PAUSEDOMAIN 10
|
|
|
|
#define XEN_V2_OP_PAUSEDOMAIN 3
|
|
|
|
|
|
|
|
/*
|
|
|
|
* The informations for an unpausedomain system hypercall
|
|
|
|
*/
|
|
|
|
#define XEN_V0_OP_UNPAUSEDOMAIN 11
|
|
|
|
#define XEN_V1_OP_UNPAUSEDOMAIN 11
|
|
|
|
#define XEN_V2_OP_UNPAUSEDOMAIN 4
|
|
|
|
|
|
|
|
/*
|
|
|
|
* The informations for an setmaxmem system hypercall
|
|
|
|
*/
|
|
|
|
#define XEN_V0_OP_SETMAXMEM 28
|
|
|
|
#define XEN_V1_OP_SETMAXMEM 28
|
2007-03-28 08:48:52 +00:00
|
|
|
#define XEN_V2_OP_SETMAXMEM 11
|
2006-09-02 21:23:14 +00:00
|
|
|
|
|
|
|
struct xen_v0_setmaxmem {
|
|
|
|
domid_t domain;
|
|
|
|
uint64_t maxmem;
|
|
|
|
};
|
|
|
|
typedef struct xen_v0_setmaxmem xen_v0_setmaxmem;
|
|
|
|
typedef struct xen_v0_setmaxmem xen_v1_setmaxmem;
|
|
|
|
|
|
|
|
struct xen_v2_setmaxmem {
|
|
|
|
uint64_t maxmem;
|
|
|
|
};
|
|
|
|
typedef struct xen_v2_setmaxmem xen_v2_setmaxmem;
|
|
|
|
|
|
|
|
/*
|
|
|
|
* The informations for an setmaxvcpu system hypercall
|
|
|
|
*/
|
|
|
|
#define XEN_V0_OP_SETMAXVCPU 41
|
|
|
|
#define XEN_V1_OP_SETMAXVCPU 41
|
|
|
|
#define XEN_V2_OP_SETMAXVCPU 15
|
|
|
|
|
|
|
|
struct xen_v0_setmaxvcpu {
|
|
|
|
domid_t domain;
|
|
|
|
uint32_t maxvcpu;
|
|
|
|
};
|
|
|
|
typedef struct xen_v0_setmaxvcpu xen_v0_setmaxvcpu;
|
|
|
|
typedef struct xen_v0_setmaxvcpu xen_v1_setmaxvcpu;
|
|
|
|
|
|
|
|
struct xen_v2_setmaxvcpu {
|
|
|
|
uint32_t maxvcpu;
|
|
|
|
};
|
|
|
|
typedef struct xen_v2_setmaxvcpu xen_v2_setmaxvcpu;
|
|
|
|
|
|
|
|
/*
|
|
|
|
* The informations for an setvcpumap system hypercall
|
|
|
|
* Note that between 1 and 2 the limitation to 64 physical CPU was lifted
|
|
|
|
* hence the difference in structures
|
|
|
|
*/
|
|
|
|
#define XEN_V0_OP_SETVCPUMAP 20
|
|
|
|
#define XEN_V1_OP_SETVCPUMAP 20
|
|
|
|
#define XEN_V2_OP_SETVCPUMAP 9
|
|
|
|
|
|
|
|
struct xen_v0_setvcpumap {
|
|
|
|
domid_t domain;
|
|
|
|
uint32_t vcpu;
|
|
|
|
cpumap_t cpumap;
|
|
|
|
};
|
|
|
|
typedef struct xen_v0_setvcpumap xen_v0_setvcpumap;
|
|
|
|
typedef struct xen_v0_setvcpumap xen_v1_setvcpumap;
|
|
|
|
|
|
|
|
struct xen_v2_cpumap {
|
|
|
|
uint8_t *bitmap;
|
|
|
|
uint32_t nr_cpus;
|
|
|
|
};
|
|
|
|
struct xen_v2_setvcpumap {
|
|
|
|
uint32_t vcpu;
|
|
|
|
struct xen_v2_cpumap cpumap;
|
|
|
|
};
|
|
|
|
typedef struct xen_v2_setvcpumap xen_v2_setvcpumap;
|
|
|
|
|
2006-09-05 06:19:28 +00:00
|
|
|
/*
|
|
|
|
* The informations for an vcpuinfo system hypercall
|
|
|
|
*/
|
|
|
|
#define XEN_V0_OP_GETVCPUINFO 43
|
|
|
|
#define XEN_V1_OP_GETVCPUINFO 43
|
|
|
|
#define XEN_V2_OP_GETVCPUINFO 14
|
|
|
|
|
|
|
|
struct xen_v0_vcpuinfo {
|
|
|
|
domid_t domain; /* owner's domain */
|
|
|
|
uint32_t vcpu; /* the vcpu number */
|
|
|
|
uint8_t online; /* seen as on line */
|
|
|
|
uint8_t blocked; /* blocked on event */
|
|
|
|
uint8_t running; /* scheduled on CPU */
|
|
|
|
uint64_t cpu_time; /* nanosecond of CPU used */
|
|
|
|
uint32_t cpu; /* current mapping */
|
|
|
|
cpumap_t cpumap; /* deprecated in V2 */
|
|
|
|
};
|
|
|
|
typedef struct xen_v0_vcpuinfo xen_v0_vcpuinfo;
|
|
|
|
typedef struct xen_v0_vcpuinfo xen_v1_vcpuinfo;
|
|
|
|
|
|
|
|
struct xen_v2_vcpuinfo {
|
|
|
|
uint32_t vcpu; /* the vcpu number */
|
|
|
|
uint8_t online; /* seen as on line */
|
|
|
|
uint8_t blocked; /* blocked on event */
|
|
|
|
uint8_t running; /* scheduled on CPU */
|
|
|
|
uint64_t cpu_time; /* nanosecond of CPU used */
|
|
|
|
uint32_t cpu; /* current mapping */
|
|
|
|
};
|
|
|
|
typedef struct xen_v2_vcpuinfo xen_v2_vcpuinfo;
|
|
|
|
|
|
|
|
/*
|
|
|
|
* from V2 the pinning of a vcpu is read with a separate call
|
|
|
|
*/
|
|
|
|
#define XEN_V2_OP_GETVCPUMAP 25
|
|
|
|
typedef struct xen_v2_setvcpumap xen_v2_getvcpumap;
|
|
|
|
|
2006-09-02 21:23:14 +00:00
|
|
|
/*
|
|
|
|
* The hypercall operation structures also have changed on
|
|
|
|
* changeset 86d26e6ec89b
|
|
|
|
*/
|
|
|
|
/* the old structure */
|
|
|
|
struct xen_op_v0 {
|
|
|
|
uint32_t cmd;
|
|
|
|
uint32_t interface_version;
|
|
|
|
union {
|
2006-09-28 23:29:25 +00:00
|
|
|
xen_v0_getdomaininfolistop getdomaininfolist;
|
|
|
|
xen_v0_domainop domain;
|
|
|
|
xen_v0_setmaxmem setmaxmem;
|
|
|
|
xen_v0_setmaxvcpu setmaxvcpu;
|
|
|
|
xen_v0_setvcpumap setvcpumap;
|
|
|
|
xen_v0_vcpuinfo getvcpuinfo;
|
|
|
|
uint8_t padding[128];
|
2006-09-02 21:23:14 +00:00
|
|
|
} u;
|
|
|
|
};
|
|
|
|
typedef struct xen_op_v0 xen_op_v0;
|
|
|
|
typedef struct xen_op_v0 xen_op_v1;
|
|
|
|
|
|
|
|
/* the new structure for systems operations */
|
|
|
|
struct xen_op_v2_sys {
|
|
|
|
uint32_t cmd;
|
|
|
|
uint32_t interface_version;
|
|
|
|
union {
|
2006-09-28 23:29:25 +00:00
|
|
|
xen_v2_getdomaininfolistop getdomaininfolist;
|
|
|
|
uint8_t padding[128];
|
2006-09-02 21:23:14 +00:00
|
|
|
} u;
|
|
|
|
};
|
|
|
|
typedef struct xen_op_v2_sys xen_op_v2_sys;
|
|
|
|
|
|
|
|
/* the new structure for domains operation */
|
|
|
|
struct xen_op_v2_dom {
|
|
|
|
uint32_t cmd;
|
|
|
|
uint32_t interface_version;
|
|
|
|
domid_t domain;
|
|
|
|
union {
|
2006-09-28 23:29:25 +00:00
|
|
|
xen_v2_setmaxmem setmaxmem;
|
|
|
|
xen_v2_setmaxvcpu setmaxvcpu;
|
|
|
|
xen_v2_setvcpumap setvcpumap;
|
|
|
|
xen_v2_vcpuinfo getvcpuinfo;
|
|
|
|
xen_v2_getvcpumap getvcpumap;
|
|
|
|
uint8_t padding[128];
|
2006-09-02 21:23:14 +00:00
|
|
|
} u;
|
|
|
|
};
|
|
|
|
typedef struct xen_op_v2_dom xen_op_v2_dom;
|
2005-12-07 18:10:51 +00:00
|
|
|
|
|
|
|
#include "internal.h"
|
2006-03-20 17:49:28 +00:00
|
|
|
#include "driver.h"
|
2005-12-07 18:10:51 +00:00
|
|
|
#include "xen_internal.h"
|
|
|
|
|
|
|
|
#define XEN_HYPERVISOR_SOCKET "/proc/xen/privcmd"
|
|
|
|
|
2006-07-20 13:59:23 +00:00
|
|
|
#ifndef PROXY
|
2006-06-13 18:29:42 +00:00
|
|
|
static const char * xenHypervisorGetType(virConnectPtr conn);
|
2006-06-16 12:36:40 +00:00
|
|
|
static unsigned long xenHypervisorGetMaxMemory(virDomainPtr domain);
|
2006-07-20 13:59:23 +00:00
|
|
|
#endif
|
2006-06-13 18:29:42 +00:00
|
|
|
|
2006-07-20 13:59:23 +00:00
|
|
|
#ifndef PROXY
|
2006-03-20 23:42:12 +00:00
|
|
|
static virDriver xenHypervisorDriver = {
|
2006-06-21 12:56:19 +00:00
|
|
|
VIR_DRV_XEN_HYPERVISOR,
|
2006-03-20 23:42:12 +00:00
|
|
|
"Xen",
|
2006-06-13 16:31:44 +00:00
|
|
|
(DOM0_INTERFACE_VERSION >> 24) * 1000000 +
|
|
|
|
((DOM0_INTERFACE_VERSION >> 16) & 0xFF) * 1000 +
|
|
|
|
(DOM0_INTERFACE_VERSION & 0xFFFF),
|
2006-03-20 23:42:12 +00:00
|
|
|
xenHypervisorOpen, /* open */
|
|
|
|
xenHypervisorClose, /* close */
|
2006-06-13 18:29:42 +00:00
|
|
|
xenHypervisorGetType, /* type */
|
2006-03-20 23:42:12 +00:00
|
|
|
xenHypervisorGetVersion, /* version */
|
2007-03-08 08:31:07 +00:00
|
|
|
xenHypervisorNumOfMaxVcpus, /* getMaxVcpus */
|
2006-03-29 12:46:03 +00:00
|
|
|
NULL, /* nodeGetInfo */
|
2007-03-15 17:24:56 +00:00
|
|
|
xenHypervisorGetCapabilities, /* getCapabilities */
|
2006-04-24 18:21:29 +00:00
|
|
|
xenHypervisorListDomains, /* listDomains */
|
|
|
|
xenHypervisorNumOfDomains, /* numOfDomains */
|
2006-03-20 23:42:12 +00:00
|
|
|
NULL, /* domainCreateLinux */
|
|
|
|
NULL, /* domainLookupByID */
|
|
|
|
NULL, /* domainLookupByUUID */
|
|
|
|
NULL, /* domainLookupByName */
|
|
|
|
xenHypervisorPauseDomain, /* domainSuspend */
|
|
|
|
xenHypervisorResumeDomain, /* domainResume */
|
|
|
|
NULL, /* domainShutdown */
|
2006-04-03 13:46:43 +00:00
|
|
|
NULL, /* domainReboot */
|
2006-03-20 23:42:12 +00:00
|
|
|
xenHypervisorDestroyDomain, /* domainDestroy */
|
|
|
|
NULL, /* domainGetOSType */
|
2006-06-16 12:36:40 +00:00
|
|
|
xenHypervisorGetMaxMemory, /* domainGetMaxMemory */
|
2006-03-20 23:42:12 +00:00
|
|
|
xenHypervisorSetMaxMemory, /* domainSetMaxMemory */
|
2006-04-13 17:18:49 +00:00
|
|
|
NULL, /* domainSetMemory */
|
2006-03-20 23:42:12 +00:00
|
|
|
xenHypervisorGetDomainInfo, /* domainGetInfo */
|
|
|
|
NULL, /* domainSave */
|
2006-08-08 22:22:55 +00:00
|
|
|
NULL, /* domainRestore */
|
2006-11-22 17:48:29 +00:00
|
|
|
NULL, /* domainCoreDump */
|
2006-08-08 22:22:55 +00:00
|
|
|
xenHypervisorSetVcpus, /* domainSetVcpus */
|
|
|
|
xenHypervisorPinVcpu, /* domainPinVcpu */
|
2006-08-09 15:21:16 +00:00
|
|
|
xenHypervisorGetVcpus, /* domainGetVcpus */
|
2007-03-08 08:31:07 +00:00
|
|
|
xenHypervisorGetVcpuMax, /* domainGetMaxVcpus */
|
2006-08-09 15:21:16 +00:00
|
|
|
NULL, /* domainDumpXML */
|
2006-08-30 14:21:03 +00:00
|
|
|
NULL, /* listDefinedDomains */
|
|
|
|
NULL, /* numOfDefinedDomains */
|
|
|
|
NULL, /* domainCreate */
|
|
|
|
NULL, /* domainDefineXML */
|
|
|
|
NULL, /* domainUndefine */
|
2006-11-16 18:11:28 +00:00
|
|
|
NULL, /* domainAttachDevice */
|
|
|
|
NULL, /* domainDetachDevice */
|
2007-02-23 08:51:30 +00:00
|
|
|
NULL, /* domainGetAutostart */
|
|
|
|
NULL, /* domainSetAutostart */
|
2006-03-20 23:42:12 +00:00
|
|
|
};
|
2006-07-20 13:59:23 +00:00
|
|
|
#endif /* !PROXY */
|
2006-03-20 23:42:12 +00:00
|
|
|
|
2006-02-27 21:34:28 +00:00
|
|
|
/**
|
|
|
|
* virXenError:
|
|
|
|
* @error: the error number
|
|
|
|
* @info: extra information string
|
2007-03-15 17:24:56 +00:00
|
|
|
* @value: extra information number
|
2006-02-27 21:34:28 +00:00
|
|
|
*
|
|
|
|
* Handle an error at the xend daemon interface
|
|
|
|
*/
|
|
|
|
static void
|
2006-03-15 12:13:25 +00:00
|
|
|
virXenError(virErrorNumber error, const char *info, int value)
|
|
|
|
{
|
2006-02-27 21:34:28 +00:00
|
|
|
const char *errmsg;
|
2006-03-15 12:13:25 +00:00
|
|
|
|
2006-09-02 21:23:14 +00:00
|
|
|
if ((error == VIR_ERR_OK) || (in_init != 0))
|
2006-02-27 21:34:28 +00:00
|
|
|
return;
|
|
|
|
|
|
|
|
errmsg = __virErrorMsg(error, info);
|
Tue Feb 14 15:37:17 EST 2007 Mark McLoughlin <markmc@redhat.com>
Note: potential ABI break here, but people should
only really be using virError structs returned from
libvirt itself.
* include/libvirt/virterror.h: add virNetwork
to virError
* src/internal.h, src/virterror.c: add network param
to __virRaiseError()
* src/conf.c, src/hash.c, src/libvirt.c, src/proxy_internal.c,
src/qemu_internal.c, src/sexpr.c, src/test.c, src/xen_internal.c,
src/xend_internal.c, src/xm_internal.c, src/xml.c, src/xmlrpc.c,
src/xs_internal.c: update.
2007-02-14 15:40:53 +00:00
|
|
|
__virRaiseError(NULL, NULL, NULL, VIR_FROM_XEN, error, VIR_ERR_ERROR,
|
2007-03-15 17:24:56 +00:00
|
|
|
errmsg, info, NULL, value, 0, errmsg, info);
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* virXenPerror:
|
|
|
|
* @conn: the connection (if available)
|
|
|
|
* @msg: name of system call or file (as in perror(3))
|
|
|
|
*
|
|
|
|
* Raise error from a failed system call, using errno as the source.
|
|
|
|
*/
|
|
|
|
static void
|
|
|
|
virXenPerror (virConnectPtr conn, const char *msg)
|
|
|
|
{
|
|
|
|
char *msg_s;
|
|
|
|
|
|
|
|
msg_s = malloc (strlen (msg) + 10);
|
|
|
|
if (msg_s) {
|
|
|
|
strcpy (msg_s, msg);
|
|
|
|
strcat (msg_s, ": %s");
|
|
|
|
}
|
|
|
|
|
|
|
|
__virRaiseError (conn, NULL, NULL,
|
|
|
|
VIR_FROM_XEN, VIR_ERR_SYSTEM_ERROR, VIR_ERR_ERROR,
|
|
|
|
msg, NULL, NULL, errno, 0,
|
|
|
|
msg_s ? msg_s : msg, strerror (errno));
|
2006-02-27 21:34:28 +00:00
|
|
|
}
|
|
|
|
|
2006-09-02 21:23:14 +00:00
|
|
|
/**
|
|
|
|
* xenHypervisorDoV0Op:
|
|
|
|
* @handle: the handle to the Xen hypervisor
|
|
|
|
* @op: pointer to the hyperviros operation structure
|
|
|
|
*
|
|
|
|
* Do an hypervisor operation though the old interface,
|
|
|
|
* this leads to an hypervisor call through ioctl.
|
|
|
|
*
|
|
|
|
* Returns 0 in case of success and -1 in case of error.
|
|
|
|
*/
|
|
|
|
static int
|
|
|
|
xenHypervisorDoV0Op(int handle, xen_op_v0 * op)
|
|
|
|
{
|
|
|
|
int ret;
|
|
|
|
v0_hypercall_t hc;
|
|
|
|
|
|
|
|
memset(&hc, 0, sizeof(hc));
|
|
|
|
op->interface_version = hv_version << 8;
|
|
|
|
hc.op = __HYPERVISOR_dom0_op;
|
|
|
|
hc.arg[0] = (unsigned long) op;
|
|
|
|
|
|
|
|
if (mlock(op, sizeof(dom0_op_t)) < 0) {
|
|
|
|
virXenError(VIR_ERR_XEN_CALL, " locking", sizeof(*op));
|
|
|
|
return (-1);
|
|
|
|
}
|
|
|
|
|
|
|
|
ret = ioctl(handle, xen_ioctl_hypercall_cmd, (unsigned long) &hc);
|
|
|
|
if (ret < 0) {
|
|
|
|
virXenError(VIR_ERR_XEN_CALL, " ioctl ", xen_ioctl_hypercall_cmd);
|
|
|
|
}
|
|
|
|
|
|
|
|
if (munlock(op, sizeof(dom0_op_t)) < 0) {
|
|
|
|
virXenError(VIR_ERR_XEN_CALL, " releasing", sizeof(*op));
|
|
|
|
ret = -1;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (ret < 0)
|
|
|
|
return (-1);
|
|
|
|
|
|
|
|
return (0);
|
|
|
|
}
|
|
|
|
/**
|
|
|
|
* xenHypervisorDoV1Op:
|
|
|
|
* @handle: the handle to the Xen hypervisor
|
|
|
|
* @op: pointer to the hyperviros operation structure
|
|
|
|
*
|
|
|
|
* Do an hypervisor v1 operation, this leads to an hypervisor call through
|
|
|
|
* ioctl.
|
|
|
|
*
|
|
|
|
* Returns 0 in case of success and -1 in case of error.
|
|
|
|
*/
|
|
|
|
static int
|
|
|
|
xenHypervisorDoV1Op(int handle, xen_op_v1* op)
|
|
|
|
{
|
|
|
|
int ret;
|
|
|
|
hypercall_t hc;
|
|
|
|
|
|
|
|
memset(&hc, 0, sizeof(hc));
|
|
|
|
op->interface_version = DOM0_INTERFACE_VERSION;
|
|
|
|
hc.op = __HYPERVISOR_dom0_op;
|
|
|
|
hc.arg[0] = (unsigned long) op;
|
|
|
|
|
|
|
|
if (mlock(op, sizeof(dom0_op_t)) < 0) {
|
|
|
|
virXenError(VIR_ERR_XEN_CALL, " locking", sizeof(*op));
|
|
|
|
return (-1);
|
|
|
|
}
|
|
|
|
|
|
|
|
ret = ioctl(handle, xen_ioctl_hypercall_cmd, (unsigned long) &hc);
|
|
|
|
if (ret < 0) {
|
|
|
|
virXenError(VIR_ERR_XEN_CALL, " ioctl ", xen_ioctl_hypercall_cmd);
|
|
|
|
}
|
|
|
|
|
|
|
|
if (munlock(op, sizeof(dom0_op_t)) < 0) {
|
|
|
|
virXenError(VIR_ERR_XEN_CALL, " releasing", sizeof(*op));
|
|
|
|
ret = -1;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (ret < 0)
|
|
|
|
return (-1);
|
|
|
|
|
|
|
|
return (0);
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* xenHypervisorDoV2Sys:
|
|
|
|
* @handle: the handle to the Xen hypervisor
|
|
|
|
* @op: pointer to the hypervisor operation structure
|
|
|
|
*
|
|
|
|
* Do an hypervisor v2 stsyem operation, this leads to an hypervisor
|
|
|
|
* call through ioctl.
|
|
|
|
*
|
|
|
|
* Returns 0 in case of success and -1 in case of error.
|
|
|
|
*/
|
|
|
|
static int
|
|
|
|
xenHypervisorDoV2Sys(int handle, xen_op_v2_sys* op)
|
|
|
|
{
|
|
|
|
int ret;
|
|
|
|
hypercall_t hc;
|
|
|
|
|
|
|
|
memset(&hc, 0, sizeof(hc));
|
|
|
|
op->interface_version = sys_interface_version;
|
|
|
|
hc.op = __HYPERVISOR_sysctl;
|
|
|
|
hc.arg[0] = (unsigned long) op;
|
|
|
|
|
|
|
|
if (mlock(op, sizeof(dom0_op_t)) < 0) {
|
|
|
|
virXenError(VIR_ERR_XEN_CALL, " locking", sizeof(*op));
|
|
|
|
return (-1);
|
|
|
|
}
|
|
|
|
|
|
|
|
ret = ioctl(handle, xen_ioctl_hypercall_cmd, (unsigned long) &hc);
|
|
|
|
if (ret < 0) {
|
|
|
|
virXenError(VIR_ERR_XEN_CALL, " ioctl ", xen_ioctl_hypercall_cmd);
|
|
|
|
}
|
|
|
|
|
|
|
|
if (munlock(op, sizeof(dom0_op_t)) < 0) {
|
|
|
|
virXenError(VIR_ERR_XEN_CALL, " releasing", sizeof(*op));
|
|
|
|
ret = -1;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (ret < 0)
|
|
|
|
return (-1);
|
|
|
|
|
|
|
|
return (0);
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* xenHypervisorDoV2Dom:
|
|
|
|
* @handle: the handle to the Xen hypervisor
|
|
|
|
* @op: pointer to the hypervisor domain operation structure
|
|
|
|
*
|
|
|
|
* Do an hypervisor v2 domain operation, this leads to an hypervisor
|
|
|
|
* call through ioctl.
|
|
|
|
*
|
|
|
|
* Returns 0 in case of success and -1 in case of error.
|
|
|
|
*/
|
|
|
|
static int
|
|
|
|
xenHypervisorDoV2Dom(int handle, xen_op_v2_dom* op)
|
|
|
|
{
|
|
|
|
int ret;
|
|
|
|
hypercall_t hc;
|
|
|
|
|
|
|
|
memset(&hc, 0, sizeof(hc));
|
|
|
|
op->interface_version = dom_interface_version;
|
|
|
|
hc.op = __HYPERVISOR_domctl;
|
|
|
|
hc.arg[0] = (unsigned long) op;
|
|
|
|
|
|
|
|
if (mlock(op, sizeof(dom0_op_t)) < 0) {
|
|
|
|
virXenError(VIR_ERR_XEN_CALL, " locking", sizeof(*op));
|
|
|
|
return (-1);
|
|
|
|
}
|
|
|
|
|
|
|
|
ret = ioctl(handle, xen_ioctl_hypercall_cmd, (unsigned long) &hc);
|
|
|
|
if (ret < 0) {
|
|
|
|
virXenError(VIR_ERR_XEN_CALL, " ioctl ", xen_ioctl_hypercall_cmd);
|
|
|
|
}
|
|
|
|
|
|
|
|
if (munlock(op, sizeof(dom0_op_t)) < 0) {
|
|
|
|
virXenError(VIR_ERR_XEN_CALL, " releasing", sizeof(*op));
|
|
|
|
ret = -1;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (ret < 0)
|
|
|
|
return (-1);
|
|
|
|
|
|
|
|
return (0);
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* virXen_getdomaininfolist:
|
|
|
|
* @handle: the hypervisor handle
|
|
|
|
* @first_domain: first domain in the range
|
|
|
|
* @maxids: maximum number of domains to list
|
|
|
|
* @dominfos: output structures
|
|
|
|
*
|
|
|
|
* Do a low level hypercall to list existing domains informations
|
|
|
|
*
|
|
|
|
* Returns the number of domains or -1 in case of failure
|
|
|
|
*/
|
|
|
|
static int
|
|
|
|
virXen_getdomaininfolist(int handle, int first_domain, int maxids,
|
2006-09-28 23:29:25 +00:00
|
|
|
xen_getdomaininfolist *dominfos)
|
2006-09-02 21:23:14 +00:00
|
|
|
{
|
|
|
|
int ret = -1;
|
|
|
|
|
2006-10-02 19:26:39 +00:00
|
|
|
if (mlock(XEN_GETDOMAININFOLIST_DATA(dominfos),
|
|
|
|
XEN_GETDOMAININFO_SIZE * maxids) < 0) {
|
2006-09-02 21:23:14 +00:00
|
|
|
virXenError(VIR_ERR_XEN_CALL, " locking",
|
2006-10-02 22:13:12 +00:00
|
|
|
XEN_GETDOMAININFO_SIZE * maxids);
|
2006-09-02 21:23:14 +00:00
|
|
|
return (-1);
|
|
|
|
}
|
|
|
|
if (hypervisor_version > 1) {
|
|
|
|
xen_op_v2_sys op;
|
|
|
|
|
|
|
|
memset(&op, 0, sizeof(op));
|
2006-09-28 23:29:25 +00:00
|
|
|
op.cmd = XEN_V2_OP_GETDOMAININFOLIST;
|
|
|
|
op.u.getdomaininfolist.first_domain = (domid_t) first_domain;
|
|
|
|
op.u.getdomaininfolist.max_domains = maxids;
|
|
|
|
op.u.getdomaininfolist.buffer = dominfos->v2;
|
|
|
|
op.u.getdomaininfolist.num_domains = maxids;
|
|
|
|
ret = xenHypervisorDoV2Sys(handle, &op);
|
|
|
|
if (ret == 0)
|
|
|
|
ret = op.u.getdomaininfolist.num_domains;
|
2006-09-02 21:23:14 +00:00
|
|
|
} else if (hypervisor_version == 1) {
|
|
|
|
xen_op_v1 op;
|
|
|
|
|
|
|
|
memset(&op, 0, sizeof(op));
|
2006-09-28 23:29:25 +00:00
|
|
|
op.cmd = XEN_V1_OP_GETDOMAININFOLIST;
|
|
|
|
op.u.getdomaininfolist.first_domain = (domid_t) first_domain;
|
|
|
|
op.u.getdomaininfolist.max_domains = maxids;
|
|
|
|
op.u.getdomaininfolist.buffer = dominfos->v0;
|
|
|
|
op.u.getdomaininfolist.num_domains = maxids;
|
|
|
|
ret = xenHypervisorDoV1Op(handle, &op);
|
|
|
|
if (ret == 0)
|
|
|
|
ret = op.u.getdomaininfolist.num_domains;
|
2006-09-02 21:23:14 +00:00
|
|
|
} else if (hypervisor_version == 0) {
|
|
|
|
xen_op_v0 op;
|
|
|
|
|
|
|
|
memset(&op, 0, sizeof(op));
|
2006-09-28 23:29:25 +00:00
|
|
|
op.cmd = XEN_V0_OP_GETDOMAININFOLIST;
|
|
|
|
op.u.getdomaininfolist.first_domain = (domid_t) first_domain;
|
|
|
|
op.u.getdomaininfolist.max_domains = maxids;
|
|
|
|
op.u.getdomaininfolist.buffer = dominfos->v0;
|
|
|
|
op.u.getdomaininfolist.num_domains = maxids;
|
|
|
|
ret = xenHypervisorDoV0Op(handle, &op);
|
|
|
|
if (ret == 0)
|
|
|
|
ret = op.u.getdomaininfolist.num_domains;
|
2006-09-02 21:23:14 +00:00
|
|
|
}
|
2006-10-02 22:13:12 +00:00
|
|
|
if (munlock(XEN_GETDOMAININFOLIST_DATA(dominfos),
|
|
|
|
XEN_GETDOMAININFO_SIZE * maxids) < 0) {
|
2006-09-02 21:23:14 +00:00
|
|
|
virXenError(VIR_ERR_XEN_CALL, " release",
|
2006-10-02 22:13:12 +00:00
|
|
|
XEN_GETDOMAININFO_SIZE * maxids);
|
2006-09-02 21:23:14 +00:00
|
|
|
ret = -1;
|
|
|
|
}
|
|
|
|
return(ret);
|
|
|
|
}
|
|
|
|
|
2006-09-28 23:29:25 +00:00
|
|
|
static int
|
|
|
|
virXen_getdomaininfo(int handle, int first_domain,
|
|
|
|
xen_getdomaininfo *dominfo) {
|
|
|
|
xen_getdomaininfolist dominfos;
|
|
|
|
|
|
|
|
if (hypervisor_version < 2) {
|
|
|
|
dominfos.v0 = &(dominfo->v0);
|
|
|
|
} else {
|
|
|
|
dominfos.v2 = &(dominfo->v2);
|
|
|
|
}
|
|
|
|
|
|
|
|
return virXen_getdomaininfolist(handle, first_domain, 1, &dominfos);
|
|
|
|
}
|
|
|
|
|
|
|
|
|
2006-09-04 19:15:10 +00:00
|
|
|
#ifndef PROXY
|
2006-09-02 21:23:14 +00:00
|
|
|
/**
|
|
|
|
* virXen_pausedomain:
|
|
|
|
* @handle: the hypervisor handle
|
|
|
|
* @id: the domain id
|
|
|
|
*
|
|
|
|
* Do a low level hypercall to pause the domain
|
|
|
|
*
|
|
|
|
* Returns 0 or -1 in case of failure
|
|
|
|
*/
|
|
|
|
static int
|
2006-09-28 23:29:25 +00:00
|
|
|
virXen_pausedomain(int handle, int id)
|
2006-09-02 21:23:14 +00:00
|
|
|
{
|
|
|
|
int ret = -1;
|
|
|
|
|
|
|
|
if (hypervisor_version > 1) {
|
|
|
|
xen_op_v2_dom op;
|
|
|
|
|
|
|
|
memset(&op, 0, sizeof(op));
|
2006-09-28 23:29:25 +00:00
|
|
|
op.cmd = XEN_V2_OP_PAUSEDOMAIN;
|
|
|
|
op.domain = (domid_t) id;
|
|
|
|
ret = xenHypervisorDoV2Dom(handle, &op);
|
2006-09-02 21:23:14 +00:00
|
|
|
} else if (hypervisor_version == 1) {
|
|
|
|
xen_op_v1 op;
|
|
|
|
|
|
|
|
memset(&op, 0, sizeof(op));
|
2006-09-28 23:29:25 +00:00
|
|
|
op.cmd = XEN_V1_OP_PAUSEDOMAIN;
|
|
|
|
op.u.domain.domain = (domid_t) id;
|
|
|
|
ret = xenHypervisorDoV1Op(handle, &op);
|
2006-09-02 21:23:14 +00:00
|
|
|
} else if (hypervisor_version == 0) {
|
|
|
|
xen_op_v0 op;
|
|
|
|
|
|
|
|
memset(&op, 0, sizeof(op));
|
2006-09-28 23:29:25 +00:00
|
|
|
op.cmd = XEN_V0_OP_PAUSEDOMAIN;
|
|
|
|
op.u.domain.domain = (domid_t) id;
|
|
|
|
ret = xenHypervisorDoV0Op(handle, &op);
|
2006-09-02 21:23:14 +00:00
|
|
|
}
|
|
|
|
return(ret);
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* virXen_unpausedomain:
|
|
|
|
* @handle: the hypervisor handle
|
|
|
|
* @id: the domain id
|
|
|
|
*
|
|
|
|
* Do a low level hypercall to unpause the domain
|
|
|
|
*
|
|
|
|
* Returns 0 or -1 in case of failure
|
|
|
|
*/
|
|
|
|
static int
|
2006-09-28 23:29:25 +00:00
|
|
|
virXen_unpausedomain(int handle, int id)
|
2006-09-02 21:23:14 +00:00
|
|
|
{
|
|
|
|
int ret = -1;
|
|
|
|
|
|
|
|
if (hypervisor_version > 1) {
|
|
|
|
xen_op_v2_dom op;
|
|
|
|
|
|
|
|
memset(&op, 0, sizeof(op));
|
2006-09-28 23:29:25 +00:00
|
|
|
op.cmd = XEN_V2_OP_UNPAUSEDOMAIN;
|
|
|
|
op.domain = (domid_t) id;
|
|
|
|
ret = xenHypervisorDoV2Dom(handle, &op);
|
2006-09-02 21:23:14 +00:00
|
|
|
} else if (hypervisor_version == 1) {
|
|
|
|
xen_op_v1 op;
|
|
|
|
|
|
|
|
memset(&op, 0, sizeof(op));
|
2006-09-28 23:29:25 +00:00
|
|
|
op.cmd = XEN_V1_OP_UNPAUSEDOMAIN;
|
|
|
|
op.u.domain.domain = (domid_t) id;
|
|
|
|
ret = xenHypervisorDoV1Op(handle, &op);
|
2006-09-02 21:23:14 +00:00
|
|
|
} else if (hypervisor_version == 0) {
|
|
|
|
xen_op_v0 op;
|
|
|
|
|
|
|
|
memset(&op, 0, sizeof(op));
|
2006-09-28 23:29:25 +00:00
|
|
|
op.cmd = XEN_V0_OP_UNPAUSEDOMAIN;
|
|
|
|
op.u.domain.domain = (domid_t) id;
|
|
|
|
ret = xenHypervisorDoV0Op(handle, &op);
|
2006-09-02 21:23:14 +00:00
|
|
|
}
|
|
|
|
return(ret);
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* virXen_destroydomain:
|
|
|
|
* @handle: the hypervisor handle
|
|
|
|
* @id: the domain id
|
|
|
|
*
|
|
|
|
* Do a low level hypercall to destroy the domain
|
|
|
|
*
|
|
|
|
* Returns 0 or -1 in case of failure
|
|
|
|
*/
|
|
|
|
static int
|
2006-09-28 23:29:25 +00:00
|
|
|
virXen_destroydomain(int handle, int id)
|
2006-09-02 21:23:14 +00:00
|
|
|
{
|
|
|
|
int ret = -1;
|
|
|
|
|
|
|
|
if (hypervisor_version > 1) {
|
|
|
|
xen_op_v2_dom op;
|
|
|
|
|
|
|
|
memset(&op, 0, sizeof(op));
|
2006-09-28 23:29:25 +00:00
|
|
|
op.cmd = XEN_V2_OP_DESTROYDOMAIN;
|
|
|
|
op.domain = (domid_t) id;
|
|
|
|
ret = xenHypervisorDoV2Dom(handle, &op);
|
2006-09-02 21:23:14 +00:00
|
|
|
} else if (hypervisor_version == 1) {
|
|
|
|
xen_op_v1 op;
|
|
|
|
|
|
|
|
memset(&op, 0, sizeof(op));
|
2006-09-28 23:29:25 +00:00
|
|
|
op.cmd = XEN_V1_OP_DESTROYDOMAIN;
|
|
|
|
op.u.domain.domain = (domid_t) id;
|
|
|
|
ret = xenHypervisorDoV1Op(handle, &op);
|
2006-09-02 21:23:14 +00:00
|
|
|
} else if (hypervisor_version == 0) {
|
|
|
|
xen_op_v0 op;
|
|
|
|
|
|
|
|
memset(&op, 0, sizeof(op));
|
2006-09-28 23:29:25 +00:00
|
|
|
op.cmd = XEN_V0_OP_DESTROYDOMAIN;
|
|
|
|
op.u.domain.domain = (domid_t) id;
|
|
|
|
ret = xenHypervisorDoV0Op(handle, &op);
|
2006-09-02 21:23:14 +00:00
|
|
|
}
|
|
|
|
return(ret);
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* virXen_setmaxmem:
|
|
|
|
* @handle: the hypervisor handle
|
|
|
|
* @id: the domain id
|
|
|
|
* @memory: the amount of memory in kilobytes
|
|
|
|
*
|
|
|
|
* Do a low level hypercall to change the max memory amount
|
|
|
|
*
|
|
|
|
* Returns 0 or -1 in case of failure
|
|
|
|
*/
|
|
|
|
static int
|
2006-09-28 23:29:25 +00:00
|
|
|
virXen_setmaxmem(int handle, int id, unsigned long memory)
|
2006-09-02 21:23:14 +00:00
|
|
|
{
|
|
|
|
int ret = -1;
|
|
|
|
|
|
|
|
if (hypervisor_version > 1) {
|
|
|
|
xen_op_v2_dom op;
|
|
|
|
|
|
|
|
memset(&op, 0, sizeof(op));
|
2006-09-28 23:29:25 +00:00
|
|
|
op.cmd = XEN_V2_OP_SETMAXMEM;
|
|
|
|
op.domain = (domid_t) id;
|
|
|
|
op.u.setmaxmem.maxmem = memory;
|
|
|
|
ret = xenHypervisorDoV2Dom(handle, &op);
|
2006-09-02 21:23:14 +00:00
|
|
|
} else if (hypervisor_version == 1) {
|
|
|
|
xen_op_v1 op;
|
|
|
|
|
|
|
|
memset(&op, 0, sizeof(op));
|
2006-09-28 23:29:25 +00:00
|
|
|
op.cmd = XEN_V1_OP_SETMAXMEM;
|
|
|
|
op.u.setmaxmem.domain = (domid_t) id;
|
|
|
|
op.u.setmaxmem.maxmem = memory;
|
|
|
|
ret = xenHypervisorDoV1Op(handle, &op);
|
2006-09-02 21:23:14 +00:00
|
|
|
} else if (hypervisor_version == 0) {
|
2006-09-05 06:19:28 +00:00
|
|
|
xen_op_v0 op;
|
2006-09-02 21:23:14 +00:00
|
|
|
|
|
|
|
memset(&op, 0, sizeof(op));
|
2006-09-28 23:29:25 +00:00
|
|
|
op.cmd = XEN_V0_OP_SETMAXMEM;
|
|
|
|
op.u.setmaxmem.domain = (domid_t) id;
|
|
|
|
op.u.setmaxmem.maxmem = memory;
|
|
|
|
ret = xenHypervisorDoV0Op(handle, &op);
|
2006-09-02 21:23:14 +00:00
|
|
|
}
|
|
|
|
return(ret);
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* virXen_setmaxvcpus:
|
|
|
|
* @handle: the hypervisor handle
|
|
|
|
* @id: the domain id
|
|
|
|
* @vcpus: the numbers of vcpus
|
|
|
|
*
|
|
|
|
* Do a low level hypercall to change the max vcpus amount
|
|
|
|
*
|
|
|
|
* Returns 0 or -1 in case of failure
|
|
|
|
*/
|
|
|
|
static int
|
2006-09-28 23:29:25 +00:00
|
|
|
virXen_setmaxvcpus(int handle, int id, unsigned int vcpus)
|
2006-09-02 21:23:14 +00:00
|
|
|
{
|
|
|
|
int ret = -1;
|
|
|
|
|
|
|
|
if (hypervisor_version > 1) {
|
|
|
|
xen_op_v2_dom op;
|
|
|
|
|
|
|
|
memset(&op, 0, sizeof(op));
|
2006-09-28 23:29:25 +00:00
|
|
|
op.cmd = XEN_V2_OP_SETMAXVCPU;
|
|
|
|
op.domain = (domid_t) id;
|
|
|
|
op.u.setmaxvcpu.maxvcpu = vcpus;
|
|
|
|
ret = xenHypervisorDoV2Dom(handle, &op);
|
2006-09-02 21:23:14 +00:00
|
|
|
} else if (hypervisor_version == 1) {
|
|
|
|
xen_op_v1 op;
|
|
|
|
|
|
|
|
memset(&op, 0, sizeof(op));
|
2006-09-28 23:29:25 +00:00
|
|
|
op.cmd = XEN_V1_OP_SETMAXVCPU;
|
|
|
|
op.u.setmaxvcpu.domain = (domid_t) id;
|
|
|
|
op.u.setmaxvcpu.maxvcpu = vcpus;
|
|
|
|
ret = xenHypervisorDoV1Op(handle, &op);
|
2006-09-02 21:23:14 +00:00
|
|
|
} else if (hypervisor_version == 0) {
|
2006-09-05 06:19:28 +00:00
|
|
|
xen_op_v0 op;
|
2006-09-02 21:23:14 +00:00
|
|
|
|
|
|
|
memset(&op, 0, sizeof(op));
|
2006-09-28 23:29:25 +00:00
|
|
|
op.cmd = XEN_V0_OP_SETMAXVCPU;
|
|
|
|
op.u.setmaxvcpu.domain = (domid_t) id;
|
|
|
|
op.u.setmaxvcpu.maxvcpu = vcpus;
|
|
|
|
ret = xenHypervisorDoV0Op(handle, &op);
|
2006-09-02 21:23:14 +00:00
|
|
|
}
|
|
|
|
return(ret);
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* virXen_setvcpumap:
|
|
|
|
* @handle: the hypervisor handle
|
|
|
|
* @id: the domain id
|
|
|
|
* @vcpu: the vcpu to map
|
|
|
|
* @cpumap: the bitmap for this vcpu
|
2006-09-05 06:19:28 +00:00
|
|
|
* @maplen: the size of the bitmap in bytes
|
2006-09-02 21:23:14 +00:00
|
|
|
*
|
|
|
|
* Do a low level hypercall to change the pinning for vcpu
|
|
|
|
*
|
|
|
|
* Returns 0 or -1 in case of failure
|
|
|
|
*/
|
|
|
|
static int
|
|
|
|
virXen_setvcpumap(int handle, int id, unsigned int vcpu,
|
|
|
|
unsigned char * cpumap, int maplen)
|
|
|
|
{
|
|
|
|
int ret = -1;
|
|
|
|
|
|
|
|
if (hypervisor_version > 1) {
|
|
|
|
xen_op_v2_dom op;
|
|
|
|
|
2006-09-28 23:29:25 +00:00
|
|
|
if (mlock(cpumap, maplen) < 0) {
|
|
|
|
virXenError(VIR_ERR_XEN_CALL, " locking", maplen);
|
|
|
|
return (-1);
|
|
|
|
}
|
2006-09-02 21:23:14 +00:00
|
|
|
memset(&op, 0, sizeof(op));
|
2006-09-28 23:29:25 +00:00
|
|
|
op.cmd = XEN_V2_OP_SETVCPUMAP;
|
|
|
|
op.domain = (domid_t) id;
|
|
|
|
op.u.setvcpumap.vcpu = vcpu;
|
|
|
|
op.u.setvcpumap.cpumap.bitmap = cpumap;
|
|
|
|
op.u.setvcpumap.cpumap.nr_cpus = maplen * 8;
|
|
|
|
ret = xenHypervisorDoV2Dom(handle, &op);
|
|
|
|
if (munlock(cpumap, maplen) < 0) {
|
|
|
|
virXenError(VIR_ERR_XEN_CALL, " release", maplen);
|
|
|
|
ret = -1;
|
|
|
|
}
|
2006-09-02 21:23:14 +00:00
|
|
|
} else {
|
2006-09-28 23:29:25 +00:00
|
|
|
cpumap_t xen_cpumap; /* limited to 64 CPUs in old hypervisors */
|
|
|
|
uint64_t *pm = &xen_cpumap;
|
|
|
|
int j;
|
2006-09-02 21:23:14 +00:00
|
|
|
|
2006-09-28 23:29:25 +00:00
|
|
|
if ((maplen > (int)sizeof(cpumap_t)) || (sizeof(cpumap_t) & 7))
|
|
|
|
return (-1);
|
2006-09-02 21:23:14 +00:00
|
|
|
|
2006-09-28 23:29:25 +00:00
|
|
|
memset(pm, 0, sizeof(cpumap_t));
|
|
|
|
for (j = 0; j < maplen; j++)
|
|
|
|
*(pm + (j / 8)) |= cpumap[j] << (8 * (j & 7));
|
2006-09-02 21:23:14 +00:00
|
|
|
|
|
|
|
if (hypervisor_version == 1) {
|
2006-09-28 23:29:25 +00:00
|
|
|
xen_op_v1 op;
|
|
|
|
|
|
|
|
memset(&op, 0, sizeof(op));
|
|
|
|
op.cmd = XEN_V1_OP_SETVCPUMAP;
|
|
|
|
op.u.setvcpumap.domain = (domid_t) id;
|
|
|
|
op.u.setvcpumap.vcpu = vcpu;
|
|
|
|
op.u.setvcpumap.cpumap = xen_cpumap;
|
|
|
|
ret = xenHypervisorDoV1Op(handle, &op);
|
|
|
|
} else if (hypervisor_version == 0) {
|
|
|
|
xen_op_v0 op;
|
|
|
|
|
|
|
|
memset(&op, 0, sizeof(op));
|
|
|
|
op.cmd = XEN_V0_OP_SETVCPUMAP;
|
|
|
|
op.u.setvcpumap.domain = (domid_t) id;
|
|
|
|
op.u.setvcpumap.vcpu = vcpu;
|
|
|
|
op.u.setvcpumap.cpumap = xen_cpumap;
|
|
|
|
ret = xenHypervisorDoV0Op(handle, &op);
|
|
|
|
}
|
2006-09-02 21:23:14 +00:00
|
|
|
}
|
|
|
|
return(ret);
|
|
|
|
}
|
2007-03-20 15:22:39 +00:00
|
|
|
#endif /* !PROXY*/
|
|
|
|
|
2006-09-05 06:19:28 +00:00
|
|
|
/**
|
|
|
|
* virXen_getvcpusinfo:
|
|
|
|
* @handle: the hypervisor handle
|
|
|
|
* @id: the domain id
|
|
|
|
* @vcpu: the vcpu to map
|
|
|
|
* @cpumap: the bitmap for this vcpu
|
|
|
|
* @maplen: the size of the bitmap in bytes
|
|
|
|
*
|
|
|
|
* Do a low level hypercall to change the pinning for vcpu
|
|
|
|
*
|
|
|
|
* Returns 0 or -1 in case of failure
|
|
|
|
*/
|
|
|
|
static int
|
|
|
|
virXen_getvcpusinfo(int handle, int id, unsigned int vcpu, virVcpuInfoPtr ipt,
|
2006-09-28 23:29:25 +00:00
|
|
|
unsigned char *cpumap, int maplen)
|
2006-09-05 06:19:28 +00:00
|
|
|
{
|
|
|
|
int ret = -1;
|
|
|
|
|
|
|
|
if (hypervisor_version > 1) {
|
|
|
|
xen_op_v2_dom op;
|
|
|
|
|
|
|
|
memset(&op, 0, sizeof(op));
|
2006-09-28 23:29:25 +00:00
|
|
|
op.cmd = XEN_V2_OP_GETVCPUINFO;
|
|
|
|
op.domain = (domid_t) id;
|
2006-12-06 15:02:03 +00:00
|
|
|
op.u.getvcpuinfo.vcpu = (uint16_t) vcpu;
|
2006-09-28 23:29:25 +00:00
|
|
|
ret = xenHypervisorDoV2Dom(handle, &op);
|
|
|
|
if (ret < 0)
|
|
|
|
return(-1);
|
2006-10-12 12:31:51 +00:00
|
|
|
ipt->number = vcpu;
|
2006-09-28 23:29:25 +00:00
|
|
|
if (op.u.getvcpuinfo.online) {
|
|
|
|
if (op.u.getvcpuinfo.running) ipt->state = VIR_VCPU_RUNNING;
|
|
|
|
if (op.u.getvcpuinfo.blocked) ipt->state = VIR_VCPU_BLOCKED;
|
|
|
|
}
|
|
|
|
else ipt->state = VIR_VCPU_OFFLINE;
|
|
|
|
ipt->cpuTime = op.u.getvcpuinfo.cpu_time;
|
|
|
|
ipt->cpu = op.u.getvcpuinfo.online ? (int)op.u.getvcpuinfo.cpu : -1;
|
|
|
|
if ((cpumap != NULL) && (maplen > 0)) {
|
|
|
|
if (mlock(cpumap, maplen) < 0) {
|
|
|
|
virXenError(VIR_ERR_XEN_CALL, " locking", maplen);
|
|
|
|
return (-1);
|
|
|
|
}
|
|
|
|
memset(&op, 0, sizeof(op));
|
|
|
|
op.cmd = XEN_V2_OP_GETVCPUMAP;
|
|
|
|
op.domain = (domid_t) id;
|
|
|
|
op.u.setvcpumap.vcpu = vcpu;
|
|
|
|
op.u.setvcpumap.cpumap.bitmap = cpumap;
|
|
|
|
op.u.setvcpumap.cpumap.nr_cpus = maplen * 8;
|
|
|
|
ret = xenHypervisorDoV2Dom(handle, &op);
|
|
|
|
if (munlock(cpumap, maplen) < 0) {
|
|
|
|
virXenError(VIR_ERR_XEN_CALL, " release", maplen);
|
|
|
|
ret = -1;
|
|
|
|
}
|
|
|
|
}
|
2006-09-05 06:19:28 +00:00
|
|
|
} else {
|
2006-09-28 23:29:25 +00:00
|
|
|
int mapl = maplen;
|
|
|
|
int cpu;
|
|
|
|
|
|
|
|
if (maplen > (int)sizeof(cpumap_t))
|
|
|
|
mapl = (int)sizeof(cpumap_t);
|
2006-09-05 06:19:28 +00:00
|
|
|
|
|
|
|
if (hypervisor_version == 1) {
|
2006-09-28 23:29:25 +00:00
|
|
|
xen_op_v1 op;
|
|
|
|
|
|
|
|
memset(&op, 0, sizeof(op));
|
|
|
|
op.cmd = XEN_V1_OP_GETVCPUINFO;
|
|
|
|
op.u.getvcpuinfo.domain = (domid_t) id;
|
|
|
|
op.u.getvcpuinfo.vcpu = vcpu;
|
|
|
|
ret = xenHypervisorDoV1Op(handle, &op);
|
|
|
|
if (ret < 0)
|
|
|
|
return(-1);
|
2006-10-12 12:31:51 +00:00
|
|
|
ipt->number = vcpu;
|
2006-09-28 23:29:25 +00:00
|
|
|
if (op.u.getvcpuinfo.online) {
|
|
|
|
if (op.u.getvcpuinfo.running) ipt->state = VIR_VCPU_RUNNING;
|
|
|
|
if (op.u.getvcpuinfo.blocked) ipt->state = VIR_VCPU_BLOCKED;
|
|
|
|
}
|
|
|
|
else ipt->state = VIR_VCPU_OFFLINE;
|
|
|
|
ipt->cpuTime = op.u.getvcpuinfo.cpu_time;
|
|
|
|
ipt->cpu = op.u.getvcpuinfo.online ? (int)op.u.getvcpuinfo.cpu : -1;
|
|
|
|
if ((cpumap != NULL) && (maplen > 0)) {
|
|
|
|
for (cpu = 0; cpu < (mapl * 8); cpu++) {
|
|
|
|
if (op.u.getvcpuinfo.cpumap & ((uint64_t)1<<cpu))
|
|
|
|
VIR_USE_CPU(cpumap, cpu);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
} else if (hypervisor_version == 0) {
|
|
|
|
xen_op_v1 op;
|
|
|
|
|
|
|
|
memset(&op, 0, sizeof(op));
|
|
|
|
op.cmd = XEN_V0_OP_GETVCPUINFO;
|
|
|
|
op.u.getvcpuinfo.domain = (domid_t) id;
|
|
|
|
op.u.getvcpuinfo.vcpu = vcpu;
|
|
|
|
ret = xenHypervisorDoV0Op(handle, &op);
|
|
|
|
if (ret < 0)
|
|
|
|
return(-1);
|
2006-10-12 12:31:51 +00:00
|
|
|
ipt->number = vcpu;
|
2006-09-28 23:29:25 +00:00
|
|
|
if (op.u.getvcpuinfo.online) {
|
|
|
|
if (op.u.getvcpuinfo.running) ipt->state = VIR_VCPU_RUNNING;
|
|
|
|
if (op.u.getvcpuinfo.blocked) ipt->state = VIR_VCPU_BLOCKED;
|
|
|
|
}
|
|
|
|
else ipt->state = VIR_VCPU_OFFLINE;
|
|
|
|
ipt->cpuTime = op.u.getvcpuinfo.cpu_time;
|
|
|
|
ipt->cpu = op.u.getvcpuinfo.online ? (int)op.u.getvcpuinfo.cpu : -1;
|
|
|
|
if ((cpumap != NULL) && (maplen > 0)) {
|
|
|
|
for (cpu = 0; cpu < (mapl * 8); cpu++) {
|
|
|
|
if (op.u.getvcpuinfo.cpumap & ((uint64_t)1<<cpu))
|
|
|
|
VIR_USE_CPU(cpumap, cpu);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
2006-09-05 06:19:28 +00:00
|
|
|
}
|
|
|
|
return(ret);
|
|
|
|
}
|
2006-09-02 21:23:14 +00:00
|
|
|
|
2006-06-21 12:15:18 +00:00
|
|
|
/**
|
|
|
|
* xenHypervisorInit:
|
|
|
|
*
|
|
|
|
* Initialize the hypervisor layer. Try to detect the kind of interface
|
|
|
|
* used i.e. pre or post changeset 10277
|
|
|
|
*/
|
2007-03-06 21:55:44 +00:00
|
|
|
static int
|
2007-02-16 16:04:54 +00:00
|
|
|
xenHypervisorInit(void)
|
2006-06-21 12:15:18 +00:00
|
|
|
{
|
2007-03-15 17:24:56 +00:00
|
|
|
int fd, ret, cmd, errcode;
|
2006-06-21 12:15:18 +00:00
|
|
|
hypercall_t hc;
|
2006-09-02 21:23:14 +00:00
|
|
|
v0_hypercall_t v0_hc;
|
2006-09-28 23:29:25 +00:00
|
|
|
xen_getdomaininfo info;
|
2007-03-20 15:22:39 +00:00
|
|
|
virVcpuInfoPtr ipt;
|
2006-06-21 12:15:18 +00:00
|
|
|
|
|
|
|
if (initialized) {
|
2006-09-02 21:23:14 +00:00
|
|
|
if (hypervisor_version == -1)
|
2006-09-28 23:29:25 +00:00
|
|
|
return(-1);
|
|
|
|
return(0);
|
2006-06-21 12:15:18 +00:00
|
|
|
}
|
|
|
|
initialized = 1;
|
2006-09-02 21:23:14 +00:00
|
|
|
in_init = 1;
|
2006-06-21 12:15:18 +00:00
|
|
|
|
2007-03-15 17:24:56 +00:00
|
|
|
/* Compile regular expressions used by xenHypervisorGetCapabilities.
|
|
|
|
* Note that errors here are really internal errors since these
|
|
|
|
* regexps should never fail to compile.
|
|
|
|
*/
|
|
|
|
errcode = regcomp (&flags_hvm_rec, flags_hvm_re, REG_EXTENDED);
|
|
|
|
if (errcode != 0) {
|
|
|
|
char error[100];
|
|
|
|
regerror (errcode, &flags_hvm_rec, error, sizeof error);
|
|
|
|
regfree (&flags_hvm_rec);
|
|
|
|
virXenError (VIR_ERR_INTERNAL_ERROR, error, 0);
|
|
|
|
in_init = 0;
|
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
errcode = regcomp (&flags_pae_rec, flags_pae_re, REG_EXTENDED);
|
|
|
|
if (errcode != 0) {
|
|
|
|
char error[100];
|
|
|
|
regerror (errcode, &flags_pae_rec, error, sizeof error);
|
|
|
|
regfree (&flags_pae_rec);
|
|
|
|
regfree (&flags_hvm_rec);
|
|
|
|
virXenError (VIR_ERR_INTERNAL_ERROR, error, 0);
|
|
|
|
in_init = 0;
|
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
errcode = regcomp (&xen_cap_rec, xen_cap_re, REG_EXTENDED);
|
|
|
|
if (errcode != 0) {
|
|
|
|
char error[100];
|
|
|
|
regerror (errcode, &xen_cap_rec, error, sizeof error);
|
|
|
|
regfree (&xen_cap_rec);
|
|
|
|
regfree (&flags_pae_rec);
|
|
|
|
regfree (&flags_hvm_rec);
|
|
|
|
virXenError (VIR_ERR_INTERNAL_ERROR, error, 0);
|
|
|
|
in_init = 0;
|
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Xen hypervisor version detection begins. */
|
2006-06-21 12:15:18 +00:00
|
|
|
ret = open(XEN_HYPERVISOR_SOCKET, O_RDWR);
|
|
|
|
if (ret < 0) {
|
2006-09-28 23:29:25 +00:00
|
|
|
hypervisor_version = -1;
|
2006-06-21 12:15:18 +00:00
|
|
|
return (-1);
|
|
|
|
}
|
|
|
|
fd = ret;
|
|
|
|
|
2006-09-02 21:23:14 +00:00
|
|
|
/*
|
|
|
|
* The size of the hypervisor call block changed July 2006
|
|
|
|
* this detect if we are using the new or old hypercall_t structure
|
|
|
|
*/
|
2006-06-21 12:15:18 +00:00
|
|
|
hc.op = __HYPERVISOR_xen_version;
|
|
|
|
hc.arg[0] = (unsigned long) XENVER_version;
|
|
|
|
hc.arg[1] = 0;
|
|
|
|
|
|
|
|
cmd = IOCTL_PRIVCMD_HYPERCALL;
|
|
|
|
ret = ioctl(fd, cmd, (unsigned long) &hc);
|
|
|
|
|
|
|
|
if ((ret != -1) && (ret != 0)) {
|
2006-09-02 21:27:09 +00:00
|
|
|
#ifdef DEBUG
|
2006-09-02 21:23:14 +00:00
|
|
|
fprintf(stderr, "Using new hypervisor call: %X\n", ret);
|
2006-09-02 21:27:09 +00:00
|
|
|
#endif
|
2006-09-28 23:29:25 +00:00
|
|
|
hv_version = ret;
|
|
|
|
xen_ioctl_hypercall_cmd = cmd;
|
|
|
|
goto detect_v2;
|
2006-06-21 12:15:18 +00:00
|
|
|
}
|
2006-09-28 23:29:25 +00:00
|
|
|
|
2006-09-02 21:23:14 +00:00
|
|
|
/*
|
|
|
|
* check if the old hypercall are actually working
|
|
|
|
*/
|
|
|
|
v0_hc.op = __HYPERVISOR_xen_version;
|
|
|
|
v0_hc.arg[0] = (unsigned long) XENVER_version;
|
|
|
|
v0_hc.arg[1] = 0;
|
|
|
|
cmd = _IOC(_IOC_NONE, 'P', 0, sizeof(v0_hypercall_t));
|
|
|
|
ret = ioctl(fd, cmd, (unsigned long) &v0_hc);
|
2006-06-21 12:15:18 +00:00
|
|
|
if ((ret != -1) && (ret != 0)) {
|
2006-09-02 21:27:09 +00:00
|
|
|
#ifdef DEBUG
|
2006-09-02 21:23:14 +00:00
|
|
|
fprintf(stderr, "Using old hypervisor call: %X\n", ret);
|
2006-09-02 21:27:09 +00:00
|
|
|
#endif
|
2006-09-28 23:29:25 +00:00
|
|
|
hv_version = ret;
|
|
|
|
xen_ioctl_hypercall_cmd = cmd;
|
2006-09-02 21:23:14 +00:00
|
|
|
hypervisor_version = 0;
|
2006-09-28 23:29:25 +00:00
|
|
|
goto done;
|
2006-06-21 12:15:18 +00:00
|
|
|
}
|
|
|
|
|
2006-09-02 21:23:14 +00:00
|
|
|
/*
|
|
|
|
* we faild to make any hypercall
|
|
|
|
*/
|
|
|
|
|
|
|
|
hypervisor_version = -1;
|
2006-06-21 12:15:18 +00:00
|
|
|
virXenError(VIR_ERR_XEN_CALL, " ioctl ", IOCTL_PRIVCMD_HYPERCALL);
|
|
|
|
close(fd);
|
2006-09-02 21:23:14 +00:00
|
|
|
in_init = 0;
|
|
|
|
return(-1);
|
|
|
|
|
2006-09-28 23:29:25 +00:00
|
|
|
detect_v2:
|
2006-09-02 21:23:14 +00:00
|
|
|
/*
|
|
|
|
* The hypercalls were refactored into 3 different section in August 2006
|
|
|
|
* Try to detect if we are running a version post 3.0.2 with the new ones
|
|
|
|
* or the old ones
|
|
|
|
*/
|
|
|
|
hypervisor_version = 2;
|
2007-03-20 15:22:39 +00:00
|
|
|
|
|
|
|
ipt = malloc(sizeof(virVcpuInfo));
|
|
|
|
if (ipt == NULL){
|
|
|
|
#ifdef DEBUG
|
|
|
|
fprintf(stderr, "Memory allocation failed at xenHypervisorIniti()\n");
|
|
|
|
#endif
|
|
|
|
return(-1);
|
|
|
|
}
|
|
|
|
/* Currently consider RHEL5.0 Fedora7 and xen-unstable */
|
2006-09-02 21:23:14 +00:00
|
|
|
sys_interface_version = 2; /* XEN_SYSCTL_INTERFACE_VERSION */
|
2006-09-28 23:29:25 +00:00
|
|
|
if (virXen_getdomaininfo(fd, 0, &info) == 1) {
|
2007-03-20 15:22:39 +00:00
|
|
|
/* RHEL 5.0 */
|
|
|
|
dom_interface_version = 3; /* XEN_DOMCTL_INTERFACE_VERSION */
|
|
|
|
if (virXen_getvcpusinfo(fd, 0, 0, ipt, NULL, 0) == 0){
|
2006-09-02 21:27:09 +00:00
|
|
|
#ifdef DEBUG
|
2007-03-20 15:22:39 +00:00
|
|
|
fprintf(stderr, "Using hypervisor call v2, sys ver2 dom ver3\n");
|
2006-09-02 21:27:09 +00:00
|
|
|
#endif
|
2007-03-20 15:22:39 +00:00
|
|
|
goto done;
|
|
|
|
}
|
|
|
|
/* Fedora 7 */
|
|
|
|
dom_interface_version = 4; /* XEN_DOMCTL_INTERFACE_VERSION */
|
|
|
|
if (virXen_getvcpusinfo(fd, 0, 0, ipt, NULL, 0) == 0){
|
|
|
|
#ifdef DEBUG
|
|
|
|
fprintf(stderr, "Using hypervisor call v2, sys ver2 dom ver4\n");
|
|
|
|
#endif
|
|
|
|
goto done;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
sys_interface_version = 3; /* XEN_SYSCTL_INTERFACE_VERSION */
|
|
|
|
if (virXen_getdomaininfo(fd, 0, &info) == 1) {
|
|
|
|
/* xen-unstable */
|
|
|
|
dom_interface_version = 5; /* XEN_DOMCTL_INTERFACE_VERSION */
|
|
|
|
if (virXen_getvcpusinfo(fd, 0, 0, ipt, NULL, 0) == 0){
|
|
|
|
#ifdef DEBUG
|
|
|
|
fprintf(stderr, "Using hypervisor call v2, sys ver3 dom ver5\n");
|
|
|
|
#endif
|
|
|
|
goto done;
|
|
|
|
}
|
2006-09-02 21:23:14 +00:00
|
|
|
}
|
2007-03-20 15:22:39 +00:00
|
|
|
|
2006-09-02 21:23:14 +00:00
|
|
|
hypervisor_version = 1;
|
|
|
|
sys_interface_version = -1;
|
2006-09-28 23:29:25 +00:00
|
|
|
if (virXen_getdomaininfo(fd, 0, &info) == 1) {
|
2006-09-02 21:27:09 +00:00
|
|
|
#ifdef DEBUG
|
2006-09-02 21:23:14 +00:00
|
|
|
fprintf(stderr, "Using hypervisor call v1\n");
|
2006-09-02 21:27:09 +00:00
|
|
|
#endif
|
2006-09-28 23:29:25 +00:00
|
|
|
goto done;
|
2006-09-02 21:23:14 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* we faild to make the getdomaininfolist hypercall
|
|
|
|
*/
|
|
|
|
|
|
|
|
hypervisor_version = -1;
|
|
|
|
virXenError(VIR_ERR_XEN_CALL, " ioctl ", IOCTL_PRIVCMD_HYPERCALL);
|
|
|
|
close(fd);
|
|
|
|
in_init = 0;
|
2006-06-21 12:15:18 +00:00
|
|
|
return(-1);
|
|
|
|
|
2006-09-28 23:29:25 +00:00
|
|
|
done:
|
2006-06-21 12:15:18 +00:00
|
|
|
close(fd);
|
2006-09-02 21:23:14 +00:00
|
|
|
in_init = 0;
|
2006-06-21 12:15:18 +00:00
|
|
|
return(0);
|
|
|
|
}
|
|
|
|
|
2006-07-20 13:59:23 +00:00
|
|
|
#ifndef PROXY
|
2006-06-21 12:15:18 +00:00
|
|
|
/**
|
|
|
|
* xenHypervisorRegister:
|
|
|
|
*
|
|
|
|
* Registers the xenHypervisor driver
|
|
|
|
*/
|
|
|
|
void xenHypervisorRegister(void)
|
|
|
|
{
|
|
|
|
if (initialized == 0)
|
|
|
|
xenHypervisorInit();
|
|
|
|
|
|
|
|
virRegisterDriver(&xenHypervisorDriver);
|
|
|
|
}
|
2006-07-20 13:59:23 +00:00
|
|
|
#endif /* !PROXY */
|
2006-06-21 12:15:18 +00:00
|
|
|
|
2005-12-07 18:10:51 +00:00
|
|
|
/**
|
|
|
|
* xenHypervisorOpen:
|
2006-03-20 17:49:28 +00:00
|
|
|
* @conn: pointer to the connection block
|
|
|
|
* @name: URL for the target, NULL for local
|
|
|
|
* @flags: combination of virDrvOpenFlag(s)
|
2005-12-07 18:10:51 +00:00
|
|
|
*
|
|
|
|
* Connects to the Xen hypervisor.
|
|
|
|
*
|
2006-03-20 17:49:28 +00:00
|
|
|
* Returns 0 or -1 in case of error.
|
2005-12-07 18:10:51 +00:00
|
|
|
*/
|
2006-03-15 12:13:25 +00:00
|
|
|
int
|
2006-03-20 17:49:28 +00:00
|
|
|
xenHypervisorOpen(virConnectPtr conn, const char *name, int flags)
|
2006-03-15 12:13:25 +00:00
|
|
|
{
|
2005-12-07 18:10:51 +00:00
|
|
|
int ret;
|
|
|
|
|
2006-06-21 12:15:18 +00:00
|
|
|
if (initialized == 0)
|
|
|
|
xenHypervisorInit();
|
|
|
|
|
2006-06-13 18:29:42 +00:00
|
|
|
if ((name != NULL) && (strcasecmp(name, "xen")))
|
2006-03-20 17:49:28 +00:00
|
|
|
return(-1);
|
|
|
|
|
|
|
|
conn->handle = -1;
|
|
|
|
|
2005-12-07 18:10:51 +00:00
|
|
|
ret = open(XEN_HYPERVISOR_SOCKET, O_RDWR);
|
2006-02-27 21:34:28 +00:00
|
|
|
if (ret < 0) {
|
2006-03-20 17:49:28 +00:00
|
|
|
if (!(flags & VIR_DRV_OPEN_QUIET))
|
2006-03-15 12:13:25 +00:00
|
|
|
virXenError(VIR_ERR_NO_XEN, XEN_HYPERVISOR_SOCKET, 0);
|
|
|
|
return (-1);
|
2006-02-27 21:34:28 +00:00
|
|
|
}
|
2006-03-20 17:49:28 +00:00
|
|
|
conn->handle = ret;
|
2005-12-07 18:10:51 +00:00
|
|
|
|
2006-04-24 18:21:29 +00:00
|
|
|
return(0);
|
2005-12-07 18:10:51 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* xenHypervisorClose:
|
2006-03-20 17:49:28 +00:00
|
|
|
* @conn: pointer to the connection block
|
2005-12-07 18:10:51 +00:00
|
|
|
*
|
|
|
|
* Close the connection to the Xen hypervisor.
|
|
|
|
*
|
|
|
|
* Returns 0 in case of success or -1 in case of error.
|
|
|
|
*/
|
2006-03-15 12:13:25 +00:00
|
|
|
int
|
2006-03-20 17:49:28 +00:00
|
|
|
xenHypervisorClose(virConnectPtr conn)
|
2006-03-15 12:13:25 +00:00
|
|
|
{
|
2005-12-07 18:10:51 +00:00
|
|
|
int ret;
|
|
|
|
|
2006-03-20 17:49:28 +00:00
|
|
|
if ((conn == NULL) || (conn->handle < 0))
|
2006-03-15 12:13:25 +00:00
|
|
|
return (-1);
|
2005-12-07 18:10:51 +00:00
|
|
|
|
2006-03-20 17:49:28 +00:00
|
|
|
ret = close(conn->handle);
|
2005-12-07 18:10:51 +00:00
|
|
|
if (ret < 0)
|
2006-03-15 12:13:25 +00:00
|
|
|
return (-1);
|
|
|
|
return (0);
|
2005-12-07 18:10:51 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
|
2006-07-20 13:59:23 +00:00
|
|
|
#ifndef PROXY
|
2006-06-13 18:29:42 +00:00
|
|
|
/**
|
|
|
|
* xenHypervisorGetType:
|
|
|
|
* @conn: pointer to the Xen Hypervisor block
|
|
|
|
*
|
|
|
|
* Get the version level of the Hypervisor running.
|
|
|
|
*
|
|
|
|
* Returns -1 in case of error, 0 otherwise. if the version can't be
|
|
|
|
* extracted by lack of capacities returns 0 and @hvVer is 0, otherwise
|
|
|
|
* @hvVer value is major * 1,000,000 + minor * 1,000 + release
|
|
|
|
*/
|
|
|
|
static const char *
|
|
|
|
xenHypervisorGetType(virConnectPtr conn)
|
|
|
|
{
|
|
|
|
if (!VIR_IS_CONNECT(conn)) {
|
|
|
|
virXenError(VIR_ERR_INVALID_CONN, __FUNCTION__, 0);
|
|
|
|
return (NULL);
|
|
|
|
}
|
|
|
|
return("Xen");
|
|
|
|
}
|
2006-07-20 13:59:23 +00:00
|
|
|
#endif
|
2006-06-13 18:29:42 +00:00
|
|
|
|
2005-12-08 13:26:52 +00:00
|
|
|
/**
|
|
|
|
* xenHypervisorGetVersion:
|
2006-03-20 17:49:28 +00:00
|
|
|
* @conn: pointer to the connection block
|
|
|
|
* @hvVer: where to store the version
|
2005-12-08 13:26:52 +00:00
|
|
|
*
|
|
|
|
* Call the hypervisor to extracts his own internal API version
|
|
|
|
*
|
2006-03-20 17:49:28 +00:00
|
|
|
* Returns 0 in case of success, -1 in case of error
|
2005-12-08 13:26:52 +00:00
|
|
|
*/
|
2006-03-20 17:49:28 +00:00
|
|
|
int
|
|
|
|
xenHypervisorGetVersion(virConnectPtr conn, unsigned long *hvVer)
|
2006-03-15 12:13:25 +00:00
|
|
|
{
|
2006-03-20 17:49:28 +00:00
|
|
|
if ((conn == NULL) || (conn->handle < 0) || (hvVer == NULL))
|
|
|
|
return (-1);
|
2006-06-21 12:15:18 +00:00
|
|
|
*hvVer = (hv_version >> 16) * 1000000 + (hv_version & 0xFFFF) * 1000;
|
2006-03-20 17:49:28 +00:00
|
|
|
return(0);
|
2005-12-08 13:26:52 +00:00
|
|
|
}
|
|
|
|
|
2007-03-15 17:24:56 +00:00
|
|
|
/**
|
|
|
|
* xenHypervisorGetCapabilities:
|
|
|
|
* @conn: pointer to the connection block
|
2007-03-27 14:45:17 +00:00
|
|
|
* @cpuinfo: file handle containing /proc/cpuinfo data, or NULL
|
|
|
|
* @capabilities: file handle containing /sys/hypervisor/properties/capabilities data, or NULL
|
2007-03-15 17:24:56 +00:00
|
|
|
*
|
|
|
|
* Return the capabilities of this hypervisor.
|
|
|
|
*/
|
|
|
|
char *
|
2007-03-27 14:45:17 +00:00
|
|
|
xenHypervisorMakeCapabilitiesXML(virConnectPtr conn ATTRIBUTE_UNUSED,
|
|
|
|
const char *hostmachine,
|
|
|
|
FILE *cpuinfo, FILE *capabilities)
|
2007-03-15 17:24:56 +00:00
|
|
|
{
|
|
|
|
char line[1024], *str, *token;
|
2007-03-15 18:59:47 +00:00
|
|
|
regmatch_t subs[4];
|
2007-03-15 18:15:14 +00:00
|
|
|
char *saveptr = NULL;
|
2007-03-15 17:24:56 +00:00
|
|
|
int i, r;
|
|
|
|
|
|
|
|
char hvm_type[4] = ""; /* "vmx" or "svm" (or "" if not in CPU). */
|
|
|
|
int host_pae = 0;
|
2007-03-15 18:59:47 +00:00
|
|
|
struct guest_arch {
|
2007-03-15 17:24:56 +00:00
|
|
|
const char *model;
|
|
|
|
int bits;
|
|
|
|
int hvm;
|
|
|
|
int pae;
|
2007-03-27 14:45:17 +00:00
|
|
|
int nonpae;
|
2007-03-15 17:24:56 +00:00
|
|
|
int ia64_be;
|
2007-03-15 18:59:47 +00:00
|
|
|
} guest_archs[32];
|
2007-03-15 17:24:56 +00:00
|
|
|
int nr_guest_archs = 0;
|
|
|
|
|
|
|
|
virBufferPtr xml;
|
|
|
|
char *xml_str;
|
|
|
|
|
2007-03-15 18:59:47 +00:00
|
|
|
memset(guest_archs, 0, sizeof(guest_archs));
|
|
|
|
|
2007-03-15 17:24:56 +00:00
|
|
|
/* /proc/cpuinfo: flags: Intel calls HVM "vmx", AMD calls it "svm".
|
|
|
|
* It's not clear if this will work on IA64, let alone other
|
|
|
|
* architectures and non-Linux. (XXX)
|
|
|
|
*/
|
2007-03-27 14:45:17 +00:00
|
|
|
if (cpuinfo) {
|
|
|
|
while (fgets (line, sizeof line, cpuinfo)) {
|
|
|
|
if (regexec (&flags_hvm_rec, line, sizeof(subs)/sizeof(regmatch_t), subs, 0) == 0
|
|
|
|
&& subs[0].rm_so != -1) {
|
|
|
|
strncpy (hvm_type,
|
|
|
|
&line[subs[1].rm_so], subs[1].rm_eo-subs[1].rm_so+1);
|
|
|
|
hvm_type[subs[1].rm_eo-subs[1].rm_so] = '\0';
|
|
|
|
} else if (regexec (&flags_pae_rec, line, 0, NULL, 0) == 0)
|
|
|
|
host_pae = 1;
|
|
|
|
}
|
2007-03-15 17:24:56 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
/* Most of the useful info is in /sys/hypervisor/properties/capabilities
|
|
|
|
* which is documented in the code in xen-unstable.hg/xen/arch/.../setup.c.
|
|
|
|
*
|
|
|
|
* It is a space-separated list of supported guest architectures.
|
|
|
|
*
|
|
|
|
* For x86:
|
|
|
|
* TYP-VER-ARCH[p]
|
|
|
|
* ^ ^ ^ ^
|
|
|
|
* | | | +-- PAE supported
|
|
|
|
* | | +------- x86_32 or x86_64
|
|
|
|
* | +----------- the version of Xen, eg. "3.0"
|
|
|
|
* +--------------- "xen" or "hvm" for para or full virt respectively
|
|
|
|
*
|
|
|
|
* For PPC this file appears to be always empty (?)
|
|
|
|
*
|
|
|
|
* For IA64:
|
|
|
|
* TYP-VER-ARCH[be]
|
|
|
|
* ^ ^ ^ ^
|
|
|
|
* | | | +-- Big-endian supported
|
|
|
|
* | | +------- always "ia64"
|
|
|
|
* | +----------- the version of Xen, eg. "3.0"
|
|
|
|
* +--------------- "xen" or "hvm" for para or full virt respectively
|
|
|
|
*/
|
|
|
|
|
|
|
|
/* Expecting one line in this file - ignore any more. */
|
2007-03-27 14:45:17 +00:00
|
|
|
if (fgets (line, sizeof line, capabilities)) {
|
|
|
|
/* Split the line into tokens. strtok_r is OK here because we "own"
|
|
|
|
* this buffer. Parse out the features from each token.
|
|
|
|
*/
|
|
|
|
for (str = line, nr_guest_archs = 0;
|
|
|
|
nr_guest_archs < sizeof guest_archs / sizeof guest_archs[0]
|
|
|
|
&& (token = strtok_r (str, " ", &saveptr)) != NULL;
|
|
|
|
str = NULL) {
|
|
|
|
|
|
|
|
if (regexec (&xen_cap_rec, token, sizeof subs / sizeof subs[0],
|
|
|
|
subs, 0) == 0) {
|
|
|
|
int hvm = strncmp (&token[subs[1].rm_so], "hvm", 3) == 0;
|
|
|
|
const char *model;
|
|
|
|
int bits, pae = 0, nonpae = 0, ia64_be = 0;
|
|
|
|
if (strncmp (&token[subs[2].rm_so], "x86_32", 6) == 0) {
|
|
|
|
model = "i686";
|
|
|
|
bits = 32;
|
|
|
|
if (strncmp (&token[subs[3].rm_so], "p", 1) == 0)
|
|
|
|
pae = 1;
|
|
|
|
else
|
|
|
|
nonpae = 1;
|
|
|
|
}
|
|
|
|
else if (strncmp (&token[subs[2].rm_so], "x86_64", 6) == 0) {
|
|
|
|
model = "x86_64";
|
|
|
|
bits = 64;
|
|
|
|
}
|
|
|
|
else if (strncmp (&token[subs[2].rm_so], "ia64", 4) == 0) {
|
|
|
|
model = "ia64";
|
|
|
|
bits = 64;
|
|
|
|
if (strncmp (&token[subs[3].rm_so], "be", 2) == 0)
|
|
|
|
ia64_be = 1;
|
|
|
|
}
|
|
|
|
else if (strncmp (&token[subs[2].rm_so], "powerpc64", 4) == 0) {
|
|
|
|
model = "ppc64";
|
|
|
|
bits = 64;
|
|
|
|
} else {
|
|
|
|
/* XXX surely no other Xen archs exist */
|
|
|
|
continue;
|
|
|
|
}
|
2007-03-15 17:24:56 +00:00
|
|
|
|
2007-03-27 14:45:17 +00:00
|
|
|
/* Search for existing matching (model,hvm) tuple */
|
|
|
|
for (i = 0 ; i < nr_guest_archs ; i++) {
|
|
|
|
if (!strcmp(guest_archs[i].model, model) &&
|
|
|
|
guest_archs[i].hvm == hvm) {
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
2007-03-15 17:24:56 +00:00
|
|
|
|
2007-03-27 14:45:17 +00:00
|
|
|
/* Too many arch flavours - highly unlikely ! */
|
|
|
|
if (i >= sizeof(guest_archs)/sizeof(guest_archs[0]))
|
|
|
|
continue;
|
|
|
|
/* Didn't find a match, so create a new one */
|
|
|
|
if (i == nr_guest_archs)
|
|
|
|
nr_guest_archs++;
|
|
|
|
|
|
|
|
guest_archs[i].model = model;
|
|
|
|
guest_archs[i].bits = bits;
|
|
|
|
guest_archs[i].hvm = hvm;
|
|
|
|
|
|
|
|
/* Careful not to overwrite a previous positive
|
|
|
|
setting with a negative one here - some archs
|
|
|
|
can do both pae & non-pae, but Xen reports
|
|
|
|
separately capabilities so we're merging archs */
|
|
|
|
if (pae)
|
|
|
|
guest_archs[i].pae = pae;
|
|
|
|
if (nonpae)
|
|
|
|
guest_archs[i].nonpae = nonpae;
|
|
|
|
if (ia64_be)
|
|
|
|
guest_archs[i].ia64_be = ia64_be;
|
2007-03-15 17:24:56 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Construct the final XML. */
|
|
|
|
xml = virBufferNew (1024);
|
|
|
|
if (!xml) return NULL;
|
|
|
|
r = virBufferVSprintf (xml,
|
|
|
|
"\
|
|
|
|
<capabilities>\n\
|
|
|
|
<host>\n\
|
|
|
|
<cpu>\n\
|
|
|
|
<arch>%s</arch>\n\
|
|
|
|
<features>\n",
|
2007-03-27 14:45:17 +00:00
|
|
|
hostmachine);
|
|
|
|
if (r == -1) goto vir_buffer_failed;
|
2007-03-15 17:24:56 +00:00
|
|
|
|
|
|
|
if (strcmp (hvm_type, "") != 0) {
|
|
|
|
r = virBufferVSprintf (xml,
|
|
|
|
"\
|
|
|
|
<%s/>\n",
|
|
|
|
hvm_type);
|
2007-03-27 14:45:17 +00:00
|
|
|
if (r == -1) goto vir_buffer_failed;
|
2007-03-15 17:24:56 +00:00
|
|
|
}
|
|
|
|
if (host_pae) {
|
|
|
|
r = virBufferAdd (xml, "\
|
|
|
|
<pae/>\n", -1);
|
|
|
|
if (r == -1) goto vir_buffer_failed;
|
|
|
|
}
|
|
|
|
r = virBufferAdd (xml,
|
|
|
|
"\
|
|
|
|
</features>\n\
|
|
|
|
</cpu>\n\
|
|
|
|
</host>\n", -1);
|
|
|
|
if (r == -1) goto vir_buffer_failed;
|
|
|
|
|
|
|
|
for (i = 0; i < nr_guest_archs; ++i) {
|
|
|
|
r = virBufferVSprintf (xml,
|
|
|
|
"\
|
|
|
|
\n\
|
|
|
|
<guest>\n\
|
|
|
|
<os_type>%s</os_type>\n\
|
|
|
|
<arch name=\"%s\">\n\
|
|
|
|
<wordsize>%d</wordsize>\n\
|
2007-03-27 14:45:17 +00:00
|
|
|
<domain type=\"xen\"></domain>\n",
|
2007-03-15 17:24:56 +00:00
|
|
|
guest_archs[i].hvm ? "hvm" : "xen",
|
|
|
|
guest_archs[i].model,
|
2007-03-27 14:45:17 +00:00
|
|
|
guest_archs[i].bits);
|
2007-03-15 17:24:56 +00:00
|
|
|
if (r == -1) goto vir_buffer_failed;
|
|
|
|
if (guest_archs[i].hvm) {
|
2007-03-27 14:45:17 +00:00
|
|
|
r = virBufferVSprintf (xml,
|
2007-03-15 17:24:56 +00:00
|
|
|
"\
|
2007-03-27 14:45:17 +00:00
|
|
|
<emulator>/usr/lib%s/xen/bin/qemu-dm</emulator>\n\
|
2007-03-15 17:24:56 +00:00
|
|
|
<machine>pc</machine>\n\
|
|
|
|
<machine>isapc</machine>\n\
|
2007-03-27 14:45:17 +00:00
|
|
|
<loader>/usr/lib/xen/boot/hvmloader</loader>\n",
|
|
|
|
guest_archs[i].bits == 64 ? "64" : "");
|
2007-03-15 17:24:56 +00:00
|
|
|
if (r == -1) goto vir_buffer_failed;
|
|
|
|
}
|
|
|
|
r = virBufferAdd (xml,
|
|
|
|
"\
|
|
|
|
</arch>\n\
|
2007-03-15 18:59:47 +00:00
|
|
|
<features>\n", -1);
|
2007-03-15 17:24:56 +00:00
|
|
|
if (r == -1) goto vir_buffer_failed;
|
|
|
|
if (guest_archs[i].pae) {
|
|
|
|
r = virBufferAdd (xml,
|
|
|
|
"\
|
2007-03-27 14:45:17 +00:00
|
|
|
<pae/>\n", -1);
|
|
|
|
if (r == -1) goto vir_buffer_failed;
|
|
|
|
}
|
|
|
|
if (guest_archs[i].nonpae) {
|
|
|
|
r = virBufferAdd (xml,
|
|
|
|
"\
|
2007-03-15 18:59:47 +00:00
|
|
|
<nonpae/>\n", -1);
|
2007-03-15 17:24:56 +00:00
|
|
|
if (r == -1) goto vir_buffer_failed;
|
|
|
|
}
|
|
|
|
if (guest_archs[i].ia64_be) {
|
|
|
|
r = virBufferAdd (xml,
|
|
|
|
"\
|
2007-03-15 18:59:47 +00:00
|
|
|
<ia64_be/>\n", -1);
|
2007-03-15 17:24:56 +00:00
|
|
|
if (r == -1) goto vir_buffer_failed;
|
|
|
|
}
|
|
|
|
r = virBufferAdd (xml,
|
|
|
|
"\
|
|
|
|
</features>\n\
|
|
|
|
</guest>\n", -1);
|
|
|
|
if (r == -1) goto vir_buffer_failed;
|
|
|
|
}
|
|
|
|
r = virBufferAdd (xml,
|
|
|
|
"\
|
|
|
|
</capabilities>\n", -1);
|
|
|
|
if (r == -1) goto vir_buffer_failed;
|
|
|
|
xml_str = strdup (xml->content);
|
|
|
|
if (!xml_str) {
|
|
|
|
virXenError(VIR_ERR_NO_MEMORY, "strdup", 0);
|
|
|
|
goto vir_buffer_failed;
|
|
|
|
}
|
|
|
|
virBufferFree (xml);
|
|
|
|
|
|
|
|
return xml_str;
|
2007-03-27 14:45:17 +00:00
|
|
|
|
|
|
|
vir_buffer_failed:
|
|
|
|
virBufferFree (xml);
|
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* xenHypervisorGetCapabilities:
|
|
|
|
* @conn: pointer to the connection block
|
|
|
|
*
|
|
|
|
* Return the capabilities of this hypervisor.
|
|
|
|
*/
|
|
|
|
char *
|
|
|
|
xenHypervisorGetCapabilities (virConnectPtr conn)
|
|
|
|
{
|
|
|
|
char *xml;
|
|
|
|
FILE *cpuinfo, *capabilities;
|
|
|
|
struct utsname utsname;
|
|
|
|
|
|
|
|
/* Really, this never fails - look at the man-page. */
|
|
|
|
uname (&utsname);
|
|
|
|
|
|
|
|
cpuinfo = fopen ("/proc/cpuinfo", "r");
|
|
|
|
if (cpuinfo == NULL) {
|
|
|
|
if (errno != ENOENT) {
|
|
|
|
virXenPerror (conn, "/proc/cpuinfo");
|
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
capabilities = fopen ("/sys/hypervisor/properties/capabilities", "r");
|
|
|
|
if (capabilities == NULL) {
|
|
|
|
if (errno != ENOENT) {
|
|
|
|
fclose(cpuinfo);
|
|
|
|
virXenPerror (conn, "/sys/hypervisor/properties/capabilities");
|
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
xml = xenHypervisorMakeCapabilitiesXML(conn, utsname.machine, cpuinfo, capabilities);
|
|
|
|
|
|
|
|
if (cpuinfo)
|
|
|
|
fclose(cpuinfo);
|
|
|
|
if (capabilities)
|
|
|
|
fclose(capabilities);
|
|
|
|
|
|
|
|
return xml;
|
2007-03-15 17:24:56 +00:00
|
|
|
}
|
|
|
|
|
2006-04-24 18:21:29 +00:00
|
|
|
/**
|
|
|
|
* xenHypervisorNumOfDomains:
|
|
|
|
* @conn: pointer to the connection block
|
|
|
|
*
|
|
|
|
* Provides the number of active domains.
|
|
|
|
*
|
|
|
|
* Returns the number of domain found or -1 in case of error
|
|
|
|
*/
|
|
|
|
int
|
|
|
|
xenHypervisorNumOfDomains(virConnectPtr conn)
|
|
|
|
{
|
2006-09-28 23:29:25 +00:00
|
|
|
xen_getdomaininfolist dominfos;
|
2006-04-24 18:21:29 +00:00
|
|
|
int ret, nbids;
|
|
|
|
static int last_maxids = 2;
|
|
|
|
int maxids = last_maxids;
|
|
|
|
|
|
|
|
if ((conn == NULL) || (conn->handle < 0))
|
|
|
|
return (-1);
|
|
|
|
|
2006-09-28 23:29:25 +00:00
|
|
|
retry:
|
|
|
|
if (!(XEN_GETDOMAININFOLIST_ALLOC(dominfos, maxids))) {
|
2006-09-21 15:24:37 +00:00
|
|
|
virXenError(VIR_ERR_NO_MEMORY, _("allocating %d domain info"),
|
2006-09-28 23:29:25 +00:00
|
|
|
maxids);
|
|
|
|
return(-1);
|
2006-04-24 18:21:29 +00:00
|
|
|
}
|
|
|
|
|
2006-09-28 23:29:25 +00:00
|
|
|
XEN_GETDOMAININFOLIST_CLEAR(dominfos, maxids);
|
|
|
|
|
|
|
|
ret = virXen_getdomaininfolist(conn->handle, 0, maxids, &dominfos);
|
2006-04-24 18:21:29 +00:00
|
|
|
|
2006-09-28 23:29:25 +00:00
|
|
|
XEN_GETDOMAININFOLIST_FREE(dominfos);
|
2006-04-24 18:21:29 +00:00
|
|
|
|
|
|
|
if (ret < 0)
|
|
|
|
return (-1);
|
|
|
|
|
2006-09-02 21:23:14 +00:00
|
|
|
nbids = ret;
|
2006-04-24 18:21:29 +00:00
|
|
|
if (nbids == maxids) {
|
|
|
|
last_maxids *= 2;
|
|
|
|
maxids *= 2;
|
2006-09-28 23:29:25 +00:00
|
|
|
goto retry;
|
2006-04-24 18:21:29 +00:00
|
|
|
}
|
|
|
|
if ((nbids < 0) || (nbids > maxids))
|
|
|
|
return(-1);
|
|
|
|
return(nbids);
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* xenHypervisorListDomains:
|
|
|
|
* @conn: pointer to the connection block
|
|
|
|
* @ids: array to collect the list of IDs of active domains
|
|
|
|
* @maxids: size of @ids
|
|
|
|
*
|
|
|
|
* Collect the list of active domains, and store their ID in @maxids
|
|
|
|
*
|
|
|
|
* Returns the number of domain found or -1 in case of error
|
|
|
|
*/
|
|
|
|
int
|
|
|
|
xenHypervisorListDomains(virConnectPtr conn, int *ids, int maxids)
|
|
|
|
{
|
2006-09-28 23:29:25 +00:00
|
|
|
xen_getdomaininfolist dominfos;
|
2006-04-24 18:21:29 +00:00
|
|
|
int ret, nbids, i;
|
|
|
|
|
|
|
|
if ((conn == NULL) || (conn->handle < 0) ||
|
|
|
|
(ids == NULL) || (maxids < 1))
|
|
|
|
return (-1);
|
|
|
|
|
2006-09-28 23:29:25 +00:00
|
|
|
if (!(XEN_GETDOMAININFOLIST_ALLOC(dominfos, maxids))) {
|
2006-09-21 15:24:37 +00:00
|
|
|
virXenError(VIR_ERR_NO_MEMORY, "allocating %d domain info",
|
2006-09-28 23:29:25 +00:00
|
|
|
maxids);
|
|
|
|
return(-1);
|
2006-04-24 18:21:29 +00:00
|
|
|
}
|
2006-09-28 23:29:25 +00:00
|
|
|
|
|
|
|
XEN_GETDOMAININFOLIST_CLEAR(dominfos, maxids);
|
2006-04-24 18:21:29 +00:00
|
|
|
memset(ids, 0, maxids * sizeof(int));
|
|
|
|
|
2006-09-28 23:29:25 +00:00
|
|
|
ret = virXen_getdomaininfolist(conn->handle, 0, maxids, &dominfos);
|
2006-04-24 18:21:29 +00:00
|
|
|
|
|
|
|
if (ret < 0) {
|
2006-09-28 23:29:25 +00:00
|
|
|
XEN_GETDOMAININFOLIST_FREE(dominfos);
|
2006-04-24 18:21:29 +00:00
|
|
|
return (-1);
|
|
|
|
}
|
|
|
|
|
2006-09-02 21:23:14 +00:00
|
|
|
nbids = ret;
|
2006-04-24 18:21:29 +00:00
|
|
|
if ((nbids < 0) || (nbids > maxids)) {
|
2006-09-28 23:29:25 +00:00
|
|
|
XEN_GETDOMAININFOLIST_FREE(dominfos);
|
2006-04-24 18:21:29 +00:00
|
|
|
return(-1);
|
|
|
|
}
|
|
|
|
|
|
|
|
for (i = 0;i < nbids;i++) {
|
2006-09-28 23:29:25 +00:00
|
|
|
ids[i] = XEN_GETDOMAININFOLIST_DOMAIN(dominfos, i);
|
2006-04-24 18:21:29 +00:00
|
|
|
}
|
|
|
|
|
2006-09-28 23:29:25 +00:00
|
|
|
XEN_GETDOMAININFOLIST_FREE(dominfos);
|
2006-04-24 18:21:29 +00:00
|
|
|
return (nbids);
|
|
|
|
}
|
|
|
|
|
2007-03-08 08:31:07 +00:00
|
|
|
/**
|
|
|
|
* xenHypervisorNumOfMaxVcpus:
|
|
|
|
*
|
|
|
|
* Returns the maximum of CPU defined by Xen.
|
|
|
|
*/
|
|
|
|
int
|
|
|
|
xenHypervisorNumOfMaxVcpus(virConnectPtr conn)
|
|
|
|
{
|
|
|
|
if ((conn == NULL) || (conn->handle < 0))
|
|
|
|
return (-1);
|
|
|
|
|
|
|
|
return MAX_VIRT_CPUS;
|
|
|
|
}
|
|
|
|
|
2006-06-16 12:36:40 +00:00
|
|
|
/**
|
2006-06-29 22:12:47 +00:00
|
|
|
* xenHypervisorGetDomMaxMemory:
|
|
|
|
* @conn: connection data
|
|
|
|
* @id: domain id
|
2006-09-28 23:29:25 +00:00
|
|
|
*
|
2006-06-16 12:36:40 +00:00
|
|
|
* Retrieve the maximum amount of physical memory allocated to a
|
2006-06-29 22:12:47 +00:00
|
|
|
* domain.
|
2006-06-16 12:36:40 +00:00
|
|
|
*
|
|
|
|
* Returns the memory size in kilobytes or 0 in case of error.
|
|
|
|
*/
|
2006-06-29 22:12:47 +00:00
|
|
|
unsigned long
|
|
|
|
xenHypervisorGetDomMaxMemory(virConnectPtr conn, int id)
|
2006-06-16 12:36:40 +00:00
|
|
|
{
|
2006-09-28 23:29:25 +00:00
|
|
|
xen_getdomaininfo dominfo;
|
2006-06-16 12:36:40 +00:00
|
|
|
int ret;
|
|
|
|
|
2006-06-29 22:12:47 +00:00
|
|
|
if ((conn == NULL) || (conn->handle < 0))
|
2006-06-16 12:36:40 +00:00
|
|
|
return (0);
|
|
|
|
|
2006-10-12 16:25:51 +00:00
|
|
|
if (kb_per_pages == 0) {
|
|
|
|
kb_per_pages = sysconf(_SC_PAGESIZE) / 1024;
|
|
|
|
if (kb_per_pages <= 0)
|
|
|
|
kb_per_pages = 4;
|
|
|
|
}
|
|
|
|
|
2006-09-28 23:29:25 +00:00
|
|
|
XEN_GETDOMAININFO_CLEAR(dominfo);
|
2006-06-16 12:36:40 +00:00
|
|
|
|
2006-09-28 23:29:25 +00:00
|
|
|
ret = virXen_getdomaininfo(conn->handle, id, &dominfo);
|
2006-06-16 12:36:40 +00:00
|
|
|
|
2006-09-28 23:29:25 +00:00
|
|
|
if ((ret < 0) || (XEN_GETDOMAININFO_DOMAIN(dominfo) != id))
|
2006-06-16 12:36:40 +00:00
|
|
|
return (0);
|
|
|
|
|
2006-10-12 16:25:51 +00:00
|
|
|
return((unsigned long) XEN_GETDOMAININFO_MAX_PAGES(dominfo) * kb_per_pages);
|
2006-06-16 12:36:40 +00:00
|
|
|
}
|
|
|
|
|
2006-07-20 13:59:23 +00:00
|
|
|
#ifndef PROXY
|
2006-06-29 22:12:47 +00:00
|
|
|
/**
|
|
|
|
* xenHypervisorGetMaxMemory:
|
|
|
|
* @domain: a domain object or NULL
|
2006-09-28 23:29:25 +00:00
|
|
|
*
|
2006-06-29 22:12:47 +00:00
|
|
|
* Retrieve the maximum amount of physical memory allocated to a
|
|
|
|
* domain. If domain is NULL, then this get the amount of memory reserved
|
|
|
|
* to Domain0 i.e. the domain where the application runs.
|
|
|
|
*
|
|
|
|
* Returns the memory size in kilobytes or 0 in case of error.
|
|
|
|
*/
|
|
|
|
static unsigned long
|
|
|
|
xenHypervisorGetMaxMemory(virDomainPtr domain)
|
|
|
|
{
|
|
|
|
if ((domain == NULL) || (domain->conn == NULL) ||
|
2007-01-22 16:25:27 +00:00
|
|
|
(domain->conn->handle < 0) || (domain->id < 0))
|
2006-06-29 22:12:47 +00:00
|
|
|
return (0);
|
|
|
|
|
2007-01-22 16:25:27 +00:00
|
|
|
return(xenHypervisorGetDomMaxMemory(domain->conn, domain->id));
|
2006-06-29 22:12:47 +00:00
|
|
|
}
|
2006-07-20 13:59:23 +00:00
|
|
|
#endif
|
2006-06-29 22:12:47 +00:00
|
|
|
|
2005-12-07 18:10:51 +00:00
|
|
|
/**
|
2006-06-29 23:53:31 +00:00
|
|
|
* xenHypervisorGetDomInfo:
|
|
|
|
* @conn: connection data
|
|
|
|
* @id: the domain ID
|
2006-07-19 22:24:37 +00:00
|
|
|
* @info: the place where information should be stored
|
2005-12-07 18:10:51 +00:00
|
|
|
*
|
2006-07-19 22:24:37 +00:00
|
|
|
* Do an hypervisor call to get the related set of domain information.
|
2005-12-07 18:10:51 +00:00
|
|
|
*
|
|
|
|
* Returns 0 in case of success, -1 in case of error.
|
|
|
|
*/
|
|
|
|
int
|
2006-06-29 23:53:31 +00:00
|
|
|
xenHypervisorGetDomInfo(virConnectPtr conn, int id, virDomainInfoPtr info)
|
2006-03-15 12:13:25 +00:00
|
|
|
{
|
2006-09-28 23:29:25 +00:00
|
|
|
xen_getdomaininfo dominfo;
|
2005-12-07 18:10:51 +00:00
|
|
|
int ret;
|
2006-10-11 16:11:59 +00:00
|
|
|
uint32_t domain_flags, domain_state, domain_shutdown_cause;
|
2006-09-29 16:12:08 +00:00
|
|
|
|
|
|
|
if (kb_per_pages == 0) {
|
|
|
|
kb_per_pages = sysconf(_SC_PAGESIZE) / 1024;
|
|
|
|
if (kb_per_pages <= 0)
|
|
|
|
kb_per_pages = 4;
|
|
|
|
}
|
2005-12-07 18:10:51 +00:00
|
|
|
|
2006-06-29 23:53:31 +00:00
|
|
|
if ((conn == NULL) || (conn->handle < 0) || (info == NULL))
|
2006-03-15 12:13:25 +00:00
|
|
|
return (-1);
|
2005-12-07 18:10:51 +00:00
|
|
|
|
2006-03-20 17:49:28 +00:00
|
|
|
memset(info, 0, sizeof(virDomainInfo));
|
2006-09-28 23:29:25 +00:00
|
|
|
XEN_GETDOMAININFO_CLEAR(dominfo);
|
2005-12-07 18:10:51 +00:00
|
|
|
|
2006-09-28 23:29:25 +00:00
|
|
|
ret = virXen_getdomaininfo(conn->handle, id, &dominfo);
|
2005-12-07 18:10:51 +00:00
|
|
|
|
2006-09-28 23:29:25 +00:00
|
|
|
if ((ret < 0) || (XEN_GETDOMAININFO_DOMAIN(dominfo) != id))
|
2006-03-15 12:13:25 +00:00
|
|
|
return (-1);
|
2006-03-20 17:49:28 +00:00
|
|
|
|
2006-10-11 16:11:59 +00:00
|
|
|
domain_flags = XEN_GETDOMAININFO_FLAGS(dominfo);
|
|
|
|
domain_state = domain_flags & 0xFF;
|
|
|
|
switch (domain_state) {
|
2006-03-20 17:49:28 +00:00
|
|
|
case DOMFLAGS_DYING:
|
|
|
|
info->state = VIR_DOMAIN_SHUTDOWN;
|
|
|
|
break;
|
|
|
|
case DOMFLAGS_SHUTDOWN:
|
2006-10-11 16:11:59 +00:00
|
|
|
/* The domain is shutdown. Determine the cause. */
|
|
|
|
domain_shutdown_cause = domain_flags >> DOMFLAGS_SHUTDOWNSHIFT;
|
|
|
|
switch (domain_shutdown_cause) {
|
|
|
|
case SHUTDOWN_crash:
|
|
|
|
info->state = VIR_DOMAIN_CRASHED;
|
|
|
|
break;
|
|
|
|
default:
|
|
|
|
info->state = VIR_DOMAIN_SHUTOFF;
|
|
|
|
}
|
2006-03-20 17:49:28 +00:00
|
|
|
break;
|
|
|
|
case DOMFLAGS_PAUSED:
|
|
|
|
info->state = VIR_DOMAIN_PAUSED;
|
|
|
|
break;
|
|
|
|
case DOMFLAGS_BLOCKED:
|
|
|
|
info->state = VIR_DOMAIN_BLOCKED;
|
|
|
|
break;
|
|
|
|
case DOMFLAGS_RUNNING:
|
|
|
|
info->state = VIR_DOMAIN_RUNNING;
|
|
|
|
break;
|
|
|
|
default:
|
|
|
|
info->state = VIR_DOMAIN_NONE;
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* the API brings back the cpu time in nanoseconds,
|
|
|
|
* convert to microseconds, same thing convert to
|
|
|
|
* kilobytes from page counts
|
|
|
|
*/
|
2006-09-28 23:29:25 +00:00
|
|
|
info->cpuTime = XEN_GETDOMAININFO_CPUTIME(dominfo);
|
2006-09-29 16:12:08 +00:00
|
|
|
info->memory = XEN_GETDOMAININFO_TOT_PAGES(dominfo) * kb_per_pages;
|
2007-03-15 14:27:09 +00:00
|
|
|
info->maxMem = XEN_GETDOMAININFO_MAX_PAGES(dominfo);
|
|
|
|
if(info->maxMem != UINT_MAX)
|
|
|
|
info->maxMem *= kb_per_pages;
|
2006-09-28 23:29:25 +00:00
|
|
|
info->nrVirtCpu = XEN_GETDOMAININFO_CPUCOUNT(dominfo);
|
2006-03-15 12:13:25 +00:00
|
|
|
return (0);
|
2005-12-07 18:10:51 +00:00
|
|
|
}
|
|
|
|
|
2006-06-29 23:53:31 +00:00
|
|
|
/**
|
|
|
|
* xenHypervisorGetDomainInfo:
|
|
|
|
* @domain: pointer to the domain block
|
2006-07-19 22:24:37 +00:00
|
|
|
* @info: the place where information should be stored
|
2006-06-29 23:53:31 +00:00
|
|
|
*
|
2006-07-19 22:24:37 +00:00
|
|
|
* Do an hypervisor call to get the related set of domain information.
|
2006-06-29 23:53:31 +00:00
|
|
|
*
|
|
|
|
* Returns 0 in case of success, -1 in case of error.
|
|
|
|
*/
|
|
|
|
int
|
|
|
|
xenHypervisorGetDomainInfo(virDomainPtr domain, virDomainInfoPtr info)
|
|
|
|
{
|
|
|
|
if ((domain == NULL) || (domain->conn == NULL) ||
|
|
|
|
(domain->conn->handle < 0) || (info == NULL) ||
|
2007-01-22 16:25:27 +00:00
|
|
|
(domain->id < 0))
|
2006-06-29 23:53:31 +00:00
|
|
|
return (-1);
|
2006-11-15 21:03:34 +00:00
|
|
|
|
2007-01-22 16:25:27 +00:00
|
|
|
return(xenHypervisorGetDomInfo(domain->conn, domain->id, info));
|
2006-06-29 23:53:31 +00:00
|
|
|
|
|
|
|
}
|
|
|
|
|
2006-08-09 15:21:16 +00:00
|
|
|
#ifndef PROXY
|
2005-12-08 17:16:24 +00:00
|
|
|
/**
|
|
|
|
* xenHypervisorPauseDomain:
|
2006-03-20 17:49:28 +00:00
|
|
|
* @domain: pointer to the domain block
|
2005-12-08 17:16:24 +00:00
|
|
|
*
|
|
|
|
* Do an hypervisor call to pause the given domain
|
|
|
|
*
|
|
|
|
* Returns 0 in case of success, -1 in case of error.
|
|
|
|
*/
|
|
|
|
int
|
2006-03-20 17:49:28 +00:00
|
|
|
xenHypervisorPauseDomain(virDomainPtr domain)
|
2006-03-15 12:13:25 +00:00
|
|
|
{
|
2005-12-08 17:16:24 +00:00
|
|
|
int ret;
|
|
|
|
|
2006-03-20 17:49:28 +00:00
|
|
|
if ((domain == NULL) || (domain->conn == NULL) ||
|
2007-01-22 16:25:27 +00:00
|
|
|
(domain->conn->handle < 0) || (domain->id < 0))
|
2006-03-20 17:49:28 +00:00
|
|
|
return (-1);
|
|
|
|
|
2007-01-22 16:25:27 +00:00
|
|
|
ret = virXen_pausedomain(domain->conn->handle, domain->id);
|
2005-12-08 17:16:24 +00:00
|
|
|
if (ret < 0)
|
2006-03-15 12:13:25 +00:00
|
|
|
return (-1);
|
|
|
|
return (0);
|
2005-12-08 17:16:24 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* xenHypervisorResumeDomain:
|
2006-03-20 17:49:28 +00:00
|
|
|
* @domain: pointer to the domain block
|
2005-12-08 17:16:24 +00:00
|
|
|
*
|
|
|
|
* Do an hypervisor call to resume the given domain
|
|
|
|
*
|
|
|
|
* Returns 0 in case of success, -1 in case of error.
|
|
|
|
*/
|
|
|
|
int
|
2006-03-20 17:49:28 +00:00
|
|
|
xenHypervisorResumeDomain(virDomainPtr domain)
|
2006-03-15 12:13:25 +00:00
|
|
|
{
|
2005-12-08 17:16:24 +00:00
|
|
|
int ret;
|
|
|
|
|
2006-03-20 17:49:28 +00:00
|
|
|
if ((domain == NULL) || (domain->conn == NULL) ||
|
2007-01-22 16:25:27 +00:00
|
|
|
(domain->conn->handle < 0) || (domain->id < 0))
|
2006-03-20 17:49:28 +00:00
|
|
|
return (-1);
|
|
|
|
|
2007-01-22 16:25:27 +00:00
|
|
|
ret = virXen_unpausedomain(domain->conn->handle, domain->id);
|
2005-12-08 17:16:24 +00:00
|
|
|
if (ret < 0)
|
2006-03-15 12:13:25 +00:00
|
|
|
return (-1);
|
|
|
|
return (0);
|
2005-12-08 17:16:24 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* xenHypervisorDestroyDomain:
|
2006-03-20 17:49:28 +00:00
|
|
|
* @domain: pointer to the domain block
|
2005-12-08 17:16:24 +00:00
|
|
|
*
|
|
|
|
* Do an hypervisor call to destroy the given domain
|
|
|
|
*
|
|
|
|
* Returns 0 in case of success, -1 in case of error.
|
|
|
|
*/
|
|
|
|
int
|
2006-03-20 17:49:28 +00:00
|
|
|
xenHypervisorDestroyDomain(virDomainPtr domain)
|
2006-03-15 12:13:25 +00:00
|
|
|
{
|
2005-12-08 17:16:24 +00:00
|
|
|
int ret;
|
|
|
|
|
2006-03-20 17:49:28 +00:00
|
|
|
if ((domain == NULL) || (domain->conn == NULL) ||
|
2007-01-22 16:25:27 +00:00
|
|
|
(domain->conn->handle < 0) || (domain->id < 0))
|
2006-03-20 17:49:28 +00:00
|
|
|
return (-1);
|
|
|
|
|
2007-01-22 16:25:27 +00:00
|
|
|
ret = virXen_destroydomain(domain->conn->handle, domain->id);
|
2005-12-08 17:16:24 +00:00
|
|
|
if (ret < 0)
|
2006-03-15 12:13:25 +00:00
|
|
|
return (-1);
|
|
|
|
return (0);
|
2005-12-08 17:16:24 +00:00
|
|
|
}
|
|
|
|
|
2005-12-12 13:22:20 +00:00
|
|
|
/**
|
|
|
|
* xenHypervisorSetMaxMemory:
|
2006-03-20 17:49:28 +00:00
|
|
|
* @domain: pointer to the domain block
|
2005-12-12 13:22:20 +00:00
|
|
|
* @memory: the max memory size in kilobytes.
|
|
|
|
*
|
|
|
|
* Do an hypervisor call to change the maximum amount of memory used
|
|
|
|
*
|
|
|
|
* Returns 0 in case of success, -1 in case of error.
|
|
|
|
*/
|
|
|
|
int
|
2006-03-20 17:49:28 +00:00
|
|
|
xenHypervisorSetMaxMemory(virDomainPtr domain, unsigned long memory)
|
2006-03-15 12:13:25 +00:00
|
|
|
{
|
2005-12-12 13:22:20 +00:00
|
|
|
int ret;
|
|
|
|
|
2006-03-20 17:49:28 +00:00
|
|
|
if ((domain == NULL) || (domain->conn == NULL) ||
|
2007-01-22 16:25:27 +00:00
|
|
|
(domain->conn->handle < 0) || (domain->id < 0))
|
2006-03-20 17:49:28 +00:00
|
|
|
return (-1);
|
|
|
|
|
2007-01-22 16:25:27 +00:00
|
|
|
ret = virXen_setmaxmem(domain->conn->handle, domain->id, memory);
|
2005-12-12 13:22:20 +00:00
|
|
|
if (ret < 0)
|
2006-03-15 12:13:25 +00:00
|
|
|
return (-1);
|
|
|
|
return (0);
|
2005-12-12 13:22:20 +00:00
|
|
|
}
|
2006-08-09 15:21:16 +00:00
|
|
|
#endif /* PROXY */
|
2006-06-16 15:28:26 +00:00
|
|
|
|
2006-08-09 15:21:16 +00:00
|
|
|
#ifndef PROXY
|
2006-08-04 10:41:05 +00:00
|
|
|
/**
|
|
|
|
* xenHypervisorSetVcpus:
|
|
|
|
* @domain: pointer to domain object
|
|
|
|
* @nvcpus: the new number of virtual CPUs for this domain
|
|
|
|
*
|
|
|
|
* Dynamically change the number of virtual CPUs used by the domain.
|
|
|
|
*
|
|
|
|
* Returns 0 in case of success, -1 in case of failure.
|
|
|
|
*/
|
|
|
|
|
|
|
|
int
|
|
|
|
xenHypervisorSetVcpus(virDomainPtr domain, unsigned int nvcpus)
|
|
|
|
{
|
2006-09-02 21:23:14 +00:00
|
|
|
int ret;
|
2006-08-04 10:41:05 +00:00
|
|
|
|
2006-09-02 21:23:14 +00:00
|
|
|
if ((domain == NULL) || (domain->conn == NULL) ||
|
2007-01-22 16:25:27 +00:00
|
|
|
(domain->conn->handle < 0) || (domain->id < 0) ||
|
2006-11-15 21:03:34 +00:00
|
|
|
(nvcpus < 1))
|
2006-08-04 10:41:05 +00:00
|
|
|
return (-1);
|
2006-09-02 21:23:14 +00:00
|
|
|
|
2007-01-22 16:25:27 +00:00
|
|
|
ret = virXen_setmaxvcpus(domain->conn->handle, domain->id, nvcpus);
|
2006-09-02 21:23:14 +00:00
|
|
|
if (ret < 0)
|
2006-08-04 10:41:05 +00:00
|
|
|
return (-1);
|
2006-09-02 21:23:14 +00:00
|
|
|
return (0);
|
2006-08-04 10:41:05 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* xenHypervisorPinVcpu:
|
|
|
|
* @domain: pointer to domain object
|
|
|
|
* @vcpu: virtual CPU number
|
|
|
|
* @cpumap: pointer to a bit map of real CPUs (in 8-bit bytes)
|
|
|
|
* @maplen: length of cpumap in bytes
|
2006-09-28 23:29:25 +00:00
|
|
|
*
|
2006-08-04 10:41:05 +00:00
|
|
|
* Dynamically change the real CPUs which can be allocated to a virtual CPU.
|
|
|
|
*
|
|
|
|
* Returns 0 in case of success, -1 in case of failure.
|
|
|
|
*/
|
|
|
|
|
|
|
|
int
|
|
|
|
xenHypervisorPinVcpu(virDomainPtr domain, unsigned int vcpu,
|
|
|
|
unsigned char *cpumap, int maplen)
|
|
|
|
{
|
2006-09-02 21:23:14 +00:00
|
|
|
int ret;
|
2006-08-04 10:41:05 +00:00
|
|
|
|
2006-09-02 21:23:14 +00:00
|
|
|
if ((domain == NULL) || (domain->conn == NULL) ||
|
2007-01-22 16:25:27 +00:00
|
|
|
(domain->conn->handle < 0) || (domain->id < 0) ||
|
2006-11-15 21:03:34 +00:00
|
|
|
(cpumap == NULL) || (maplen < 1))
|
2006-09-04 19:15:10 +00:00
|
|
|
return (-1);
|
|
|
|
|
2007-01-22 16:25:27 +00:00
|
|
|
ret = virXen_setvcpumap(domain->conn->handle, domain->id, vcpu,
|
2006-09-02 21:23:14 +00:00
|
|
|
cpumap, maplen);
|
|
|
|
if (ret < 0)
|
2006-08-04 10:41:05 +00:00
|
|
|
return (-1);
|
2006-09-02 21:23:14 +00:00
|
|
|
return (0);
|
2006-08-04 10:41:05 +00:00
|
|
|
}
|
2006-08-09 15:21:16 +00:00
|
|
|
#endif
|
2006-08-04 10:41:05 +00:00
|
|
|
|
|
|
|
/**
|
|
|
|
* virDomainGetVcpus:
|
|
|
|
* @domain: pointer to domain object, or NULL for Domain0
|
|
|
|
* @info: pointer to an array of virVcpuInfo structures (OUT)
|
|
|
|
* @maxinfo: number of structures in info array
|
|
|
|
* @cpumaps: pointer to an bit map of real CPUs for all vcpus of this domain (in 8-bit bytes) (OUT)
|
|
|
|
* If cpumaps is NULL, then no cupmap information is returned by the API.
|
|
|
|
* It's assumed there is <maxinfo> cpumap in cpumaps array.
|
|
|
|
* The memory allocated to cpumaps must be (maxinfo * maplen) bytes
|
|
|
|
* (ie: calloc(maxinfo, maplen)).
|
|
|
|
* One cpumap inside cpumaps has the format described in virDomainPinVcpu() API.
|
|
|
|
* @maplen: number of bytes in one cpumap, from 1 up to size of CPU map in
|
|
|
|
* underlying virtualization system (Xen...).
|
2006-09-28 23:29:25 +00:00
|
|
|
*
|
2006-08-04 10:41:05 +00:00
|
|
|
* Extract information about virtual CPUs of domain, store it in info array
|
|
|
|
* and also in cpumaps if this pointer is'nt NULL.
|
|
|
|
*
|
|
|
|
* Returns the number of info filled in case of success, -1 in case of failure.
|
|
|
|
*/
|
2006-09-28 23:29:25 +00:00
|
|
|
#ifndef PROXY
|
2006-08-04 10:41:05 +00:00
|
|
|
int
|
|
|
|
xenHypervisorGetVcpus(virDomainPtr domain, virVcpuInfoPtr info, int maxinfo,
|
2006-09-28 23:29:25 +00:00
|
|
|
unsigned char *cpumaps, int maplen)
|
2006-08-04 10:41:05 +00:00
|
|
|
{
|
2006-09-28 23:29:25 +00:00
|
|
|
xen_getdomaininfo dominfo;
|
2006-09-05 06:19:28 +00:00
|
|
|
int ret;
|
|
|
|
|
2006-08-04 10:41:05 +00:00
|
|
|
virVcpuInfoPtr ipt;
|
2006-09-05 06:19:28 +00:00
|
|
|
int nbinfo, i;
|
2006-08-04 10:41:05 +00:00
|
|
|
|
2006-11-15 21:03:34 +00:00
|
|
|
if ((domain == NULL) || (domain->conn == NULL) ||
|
2007-01-22 16:25:27 +00:00
|
|
|
(domain->conn->handle < 0) || (domain->id < 0) ||
|
2006-11-15 21:03:34 +00:00
|
|
|
(info == NULL) || (maxinfo < 1) ||
|
|
|
|
(sizeof(cpumap_t) & 7))
|
2006-08-04 10:41:05 +00:00
|
|
|
return (-1);
|
2006-09-05 06:19:28 +00:00
|
|
|
if ((cpumaps != NULL) && (maplen < 1))
|
2006-09-28 23:29:25 +00:00
|
|
|
return -1;
|
2006-08-04 10:41:05 +00:00
|
|
|
|
|
|
|
/* first get the number of virtual CPUs in this domain */
|
2006-09-28 23:29:25 +00:00
|
|
|
XEN_GETDOMAININFO_CLEAR(dominfo);
|
2007-01-22 16:25:27 +00:00
|
|
|
ret = virXen_getdomaininfo(domain->conn->handle, domain->id,
|
2006-09-28 23:29:25 +00:00
|
|
|
&dominfo);
|
2006-09-05 06:19:28 +00:00
|
|
|
|
2007-01-22 16:25:27 +00:00
|
|
|
if ((ret < 0) || (XEN_GETDOMAININFO_DOMAIN(dominfo) != domain->id))
|
2006-08-04 10:41:05 +00:00
|
|
|
return (-1);
|
2006-09-28 23:29:25 +00:00
|
|
|
nbinfo = XEN_GETDOMAININFO_CPUCOUNT(dominfo) + 1;
|
2006-08-04 10:41:05 +00:00
|
|
|
if (nbinfo > maxinfo) nbinfo = maxinfo;
|
|
|
|
|
|
|
|
if (cpumaps != NULL)
|
2006-09-28 23:29:25 +00:00
|
|
|
memset(cpumaps, 0, maxinfo * maplen);
|
2006-08-04 10:41:05 +00:00
|
|
|
|
2006-09-05 06:19:28 +00:00
|
|
|
for (i = 0, ipt = info; i < nbinfo; i++, ipt++) {
|
|
|
|
if ((cpumaps != NULL) && (i < maxinfo)) {
|
2007-01-22 16:25:27 +00:00
|
|
|
ret = virXen_getvcpusinfo(domain->conn->handle, domain->id, i,
|
2006-09-28 23:29:25 +00:00
|
|
|
ipt,
|
|
|
|
(unsigned char *)VIR_GET_CPUMAP(cpumaps, maplen, i),
|
|
|
|
maplen);
|
|
|
|
if (ret < 0)
|
|
|
|
return(-1);
|
|
|
|
} else {
|
2007-01-22 16:25:27 +00:00
|
|
|
ret = virXen_getvcpusinfo(domain->conn->handle, domain->id, i,
|
2006-09-28 23:29:25 +00:00
|
|
|
ipt, NULL, 0);
|
|
|
|
if (ret < 0)
|
|
|
|
return(-1);
|
|
|
|
}
|
2006-08-04 10:41:05 +00:00
|
|
|
}
|
|
|
|
return nbinfo;
|
|
|
|
}
|
2006-09-28 23:29:25 +00:00
|
|
|
#endif
|
|
|
|
|
2007-03-08 08:31:07 +00:00
|
|
|
/**
|
|
|
|
* xenHypervisorGetVcpuMax:
|
|
|
|
*
|
|
|
|
* Returns the maximum number of virtual CPUs supported for
|
|
|
|
* the guest VM. If the guest is inactive, this is the maximum
|
|
|
|
* of CPU defined by Xen. If the guest is running this reflect
|
|
|
|
* the maximum number of virtual CPUs the guest was booted with.
|
|
|
|
*/
|
|
|
|
int
|
|
|
|
xenHypervisorGetVcpuMax(virDomainPtr domain)
|
|
|
|
{
|
|
|
|
xen_getdomaininfo dominfo;
|
|
|
|
int ret;
|
|
|
|
int maxcpu;
|
|
|
|
|
|
|
|
if ((domain == NULL) || (domain->conn == NULL) ||
|
|
|
|
(domain->conn->handle < 0))
|
|
|
|
return (-1);
|
|
|
|
|
|
|
|
/* inactive domain */
|
|
|
|
if (domain->id < 0) {
|
|
|
|
maxcpu = MAX_VIRT_CPUS;
|
|
|
|
} else {
|
|
|
|
XEN_GETDOMAININFO_CLEAR(dominfo);
|
|
|
|
ret = virXen_getdomaininfo(domain->conn->handle, domain->id,
|
|
|
|
&dominfo);
|
|
|
|
|
|
|
|
if ((ret < 0) || (XEN_GETDOMAININFO_DOMAIN(dominfo) != domain->id))
|
|
|
|
return (-1);
|
|
|
|
maxcpu = XEN_GETDOMAININFO_MAXCPUID(dominfo) + 1;
|
|
|
|
}
|
|
|
|
|
|
|
|
return maxcpu;
|
|
|
|
}
|
|
|
|
|
2007-03-15 07:43:16 +00:00
|
|
|
#endif /* WITH_XEN */
|
2007-03-15 17:24:56 +00:00
|
|
|
/*
|
|
|
|
* vim: set tabstop=4:
|
|
|
|
* vim: set shiftwidth=4:
|
|
|
|
* vim: set expandtab:
|
|
|
|
*/
|
2006-09-28 23:29:25 +00:00
|
|
|
/*
|
|
|
|
* Local variables:
|
|
|
|
* indent-tabs-mode: nil
|
|
|
|
* c-indent-level: 4
|
|
|
|
* c-basic-offset: 4
|
|
|
|
* tab-width: 4
|
|
|
|
* End:
|
|
|
|
*/
|