shaba/libvirt
1
0
Fork 0
mirror of https://gitlab.com/libvirt/libvirt.git synced 2025-02-02 13:47:13 +03:00
Code Releases Activity

virDomainBlockPeek call

Browse Source 
* configure.in: Document AC_SYS_LARGEFILE.
	* docs/hvsupport.html.in: Document HV support for virDomainBlockPeek.
	* include/libvirt/libvirt.h.in, src/driver.h, src/libvirt.c,
	src/libvirt_sym.version: Add virDomainBlockPeek infrastructure.
	* src/qemu_driver.c, src/test.c: Null versions of this call.
	* src/xen_unified.c, src/xend_internal.c, src/xend_internal.h,
	src/xm_internal.c, src/xm_internal.h: Xen implementation.
	* tests/sexpr2xmldata/sexpr2xml-curmem.xml,
	tests/sexpr2xmldata/sexpr2xml-no-source-cdrom.xml: XML output
	has been reordered slightly in the Xen driver, but should be
	functionally the same.
This commit is contained in:
Richard W.M. Jones 2008-06-05 13:17:45 +00:00
parent 0bd57cdbe1
commit 8354895e68
18 changed files with 826 additions and 470 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

15
ChangeLog
View File

@ -1,3 +1,18 @@
Thu Jun 5 14:10:00 BST 2008 Richard W.M. Jones <rjones@redhat.com>
virDomainBlockPeek call
* configure.in: Document AC_SYS_LARGEFILE.
* docs/hvsupport.html.in: Document HV support for virDomainBlockPeek.
* include/libvirt/libvirt.h.in, src/driver.h, src/libvirt.c,
src/libvirt_sym.version: Add virDomainBlockPeek infrastructure.
* src/qemu_driver.c, src/test.c: Null versions of this call.
* src/xen_unified.c, src/xend_internal.c, src/xend_internal.h,
src/xm_internal.c, src/xm_internal.h: Xen implementation.
* tests/sexpr2xmldata/sexpr2xml-curmem.xml,
tests/sexpr2xmldata/sexpr2xml-no-source-cdrom.xml: XML output
has been reordered slightly in the Xen driver, but should be
functionally the same.
Wed Jun 4 23:02:21 PST 2008 David L. Leskovec <dlesko@linux.vnet.ibm.com>
* src/lxc_driver.c: Add sanity of tty pid before kill()

6
configure.in
View File

@ -60,6 +60,10 @@ AM_PROG_CC_C_O
LIBVIRT_COMPILE_WARNINGS([maximum])
dnl Support large files / 64 bit seek offsets.
dnl Use --disable-largefile if you don't want this.
AC_SYS_LARGEFILE
dnl Availability of various common functions (non-fatal if missing).
AC_CHECK_FUNCS([cfmakeraw regexec uname sched_getaffinity])
@ -982,8 +986,6 @@ AC_SUBST([CYGWIN_EXTRA_LIBADD])
AC_SUBST([CYGWIN_EXTRA_PYTHON_LIBADD])
AC_SUBST([MINGW_EXTRA_LDFLAGS])
AC_SYS_LARGEFILE
# Set LV_LIBTOOL_OBJDIR to "." or $lt_cv_objdir, depending on whether
# we're building shared libraries. This is the name of the directory
# in which .o files will be created.

18
docs/hvsupport.html
View File

@ -137,7 +137,7 @@ in.
</p>
<p>
This information changes frequently. This page was last checked or
updated on <i>2007-08-20</i>.
updated on <i>2008-06-05</i>.
</p>
<h3>Domain functions</h3>
<p> x = not supported; empty cell means no information </p>
@ -254,6 +254,14 @@ updated on <i>2007-08-20</i>.
<td> &#8805; 0.2.0 </td>
<td> &#8805; 0.3.0 </td>
</tr>
<tr>
<td> virConnectOpenAuth </td>
<td> </td>
<td> </td>
<td> </td>
<td> </td>
<td> </td>
</tr>
<tr>
<td> virConnectOpenReadOnly </td>
<td> All </td>
@ -270,6 +278,14 @@ updated on <i>2007-08-20</i>.
<td> x </td>
<td> &#8805; 0.3.0 </td>
</tr>
<tr>
<td> virDomainBlockPeek </td>
<td> 0.4.3 </td>
<td> x </td>
<td> x </td>
<td> x </td>
<td> x </td>
</tr>
<tr>
<td> virDomainBlockStats </td>
<td> 0.3.2 </td>

18
docs/hvsupport.html.in
View File

@ -9,7 +9,7 @@ in.
</p>
<p>
This information changes frequently. This page was last checked or
updated on <i>2007-08-20</i>.
updated on <i>2008-06-05</i>.
</p>
<h3>Domain functions</h3>
<p> x = not supported; empty cell means no information </p>
@ -118,6 +118,14 @@ updated on <i>2007-08-20</i>.
<td> &#x2265; 0.2.0 </td>
<td> &#x2265; 0.3.0 </td>
</tr>
<tr>
<td> virConnectOpenAuth </td>
<td> </td>
<td> </td>
<td> </td>
<td> </td>
<td> </td>
</tr>
<tr>
<td> virConnectOpenReadOnly </td>
<td> All </td>
@ -134,6 +142,14 @@ updated on <i>2007-08-20</i>.
<td> x </td>
<td> &#x2265; 0.3.0 </td>
</tr>
<tr>
<td> virDomainBlockPeek </td>
<td> 0.4.3 </td>
<td> x </td>
<td> x </td>
<td> x </td>
<td> x </td>
</tr>
<tr>
<td> virDomainBlockStats </td>
<td> 0.3.2 </td>

305
include/libvirt/libvirt.h
View File

@ -66,12 +66,12 @@ typedef virDomain *virDomainPtr;
* A domain may be in different states at a given point in time
*/
typedef enum {
VIR_DOMAIN_NOSTATE = 0, /* no state */
VIR_DOMAIN_RUNNING = 1, /* the domain is running */
VIR_DOMAIN_BLOCKED = 2, /* the domain is blocked on resource */
VIR_DOMAIN_PAUSED = 3, /* the domain is paused by user */
VIR_DOMAIN_NOSTATE = 0, /* no state */
VIR_DOMAIN_RUNNING = 1, /* the domain is running */
VIR_DOMAIN_BLOCKED = 2, /* the domain is blocked on resource */
VIR_DOMAIN_PAUSED = 3, /* the domain is paused by user */
VIR_DOMAIN_SHUTDOWN= 4, /* the domain is being shut down */
VIR_DOMAIN_SHUTOFF = 5, /* the domain is shut off */
VIR_DOMAIN_SHUTOFF = 5, /* the domain is shut off */
VIR_DOMAIN_CRASHED = 6 /* the domain is crashed */
} virDomainState;
@ -85,11 +85,11 @@ typedef enum {
typedef struct _virDomainInfo virDomainInfo;
struct _virDomainInfo {
unsigned char state; /* the running state, one of virDomainFlags */
unsigned long maxMem; /* the maximum memory in KBytes allowed */
unsigned long memory; /* the memory in KBytes used by the domain */
unsigned short nrVirtCpu; /* the number of virtual CPUs for the domain */
unsigned long long cpuTime; /* the CPU time used in nanoseconds */
unsigned char state; /* the running state, one of virDomainFlags */
unsigned long maxMem; /* the maximum memory in KBytes allowed */
unsigned long memory; /* the memory in KBytes used by the domain */
unsigned short nrVirtCpu; /* the number of virtual CPUs for the domain */
unsigned long long cpuTime; /* the CPU time used in nanoseconds */
};
/**
@ -120,13 +120,13 @@ typedef enum {
typedef struct _virNodeInfo virNodeInfo;
struct _virNodeInfo {
char model[32]; /* string indicating the CPU model */
char model[32]; /* string indicating the CPU model */
unsigned long memory;/* memory size in kilobytes */
unsigned int cpus; /* the number of active CPUs */
unsigned int mhz; /* expected CPU frequency */
unsigned int nodes; /* the number of NUMA cell, 1 for uniform mem access */
unsigned int cpus; /* the number of active CPUs */
unsigned int mhz; /* expected CPU frequency */
unsigned int nodes; /* the number of NUMA cell, 1 for uniform mem access */
unsigned int sockets;/* number of CPU socket per node */
unsigned int cores; /* number of core per socket */
unsigned int cores; /* number of core per socket */
unsigned int threads;/* number of threads per core */
};
@ -137,12 +137,12 @@ struct _virNodeInfo {
* A scheduler parameter field type
*/
typedef enum {
VIR_DOMAIN_SCHED_FIELD_INT = 1, /* integer case */
VIR_DOMAIN_SCHED_FIELD_UINT = 2, /* unsigned integer case */
VIR_DOMAIN_SCHED_FIELD_LLONG = 3, /* long long case */
VIR_DOMAIN_SCHED_FIELD_ULLONG = 4, /* unsigned long long case */
VIR_DOMAIN_SCHED_FIELD_DOUBLE = 5, /* double case */
VIR_DOMAIN_SCHED_FIELD_BOOLEAN = 6 /* boolean(character) case */
VIR_DOMAIN_SCHED_FIELD_INT = 1, /* integer case */
VIR_DOMAIN_SCHED_FIELD_UINT = 2, /* unsigned integer case */
VIR_DOMAIN_SCHED_FIELD_LLONG = 3, /* long long case */
VIR_DOMAIN_SCHED_FIELD_ULLONG = 4, /* unsigned long long case */
VIR_DOMAIN_SCHED_FIELD_DOUBLE = 5, /* double case */
VIR_DOMAIN_SCHED_FIELD_BOOLEAN = 6 /* boolean(character) case */
} virSchedParameterType;
/**
@ -162,15 +162,15 @@ typedef enum {
typedef struct _virSchedParameter virSchedParameter;
struct _virSchedParameter {
char field[VIR_DOMAIN_SCHED_FIELD_LENGTH]; /* parameter name */
int type; /* parameter type */
char field[VIR_DOMAIN_SCHED_FIELD_LENGTH]; /* parameter name */
int type; /* parameter type */
union {
int i; /* data for integer case */
unsigned int ui; /* data for unsigned integer case */
long long int l; /* data for long long integer case */
unsigned long long int ul; /* data for unsigned long long integer case */
double d; /* data for double case */
char b; /* data for char case */
int i; /* data for integer case */
unsigned int ui; /* data for unsigned integer case */
long long int l; /* data for long long integer case */
unsigned long long int ul; /* data for unsigned long long integer case */
double d; /* data for double case */
char b; /* data for char case */
} value; /* parameter value */
};
@ -185,14 +185,14 @@ typedef virSchedParameter *virSchedParameterPtr;
/*
* Fetch scheduler parameters, caller allocates 'params' field of size 'nparams'
*/
int virDomainGetSchedulerParameters (virDomainPtr domain,
int virDomainGetSchedulerParameters (virDomainPtr domain,
virSchedParameterPtr params,
int *nparams);
/*
* Change scheduler parameters
*/
int virDomainSetSchedulerParameters (virDomainPtr domain,
int virDomainSetSchedulerParameters (virDomainPtr domain,
virSchedParameterPtr params,
int nparams);
@ -382,23 +382,23 @@ extern virConnectAuthPtr virConnectAuthPtrDefault;
#define LIBVIR_VERSION_NUMBER 4002
int virGetVersion (unsigned long *libVer,
int virGetVersion (unsigned long *libVer,
const char *type,
unsigned long *typeVer);
/*
* Connection and disconnections to the Hypervisor
*/
int virInitialize (void);
int virInitialize (void);
virConnectPtr virConnectOpen (const char *name);
virConnectPtr virConnectOpenReadOnly (const char *name);
virConnectPtr virConnectOpen (const char *name);
virConnectPtr virConnectOpenReadOnly (const char *name);
virConnectPtr virConnectOpenAuth (const char *name,
virConnectAuthPtr auth,
int flags);
int virConnectClose (virConnectPtr conn);
const char * virConnectGetType (virConnectPtr conn);
int virConnectGetVersion (virConnectPtr conn,
int virConnectClose (virConnectPtr conn);
const char * virConnectGetType (virConnectPtr conn);
int virConnectGetVersion (virConnectPtr conn,
unsigned long *hvVer);
char * virConnectGetHostname (virConnectPtr conn);
char * virConnectGetURI (virConnectPtr conn);
@ -410,100 +410,100 @@ char * virConnectGetURI (virConnectPtr conn);
int virConnectGetMaxVcpus (virConnectPtr conn,
const char *type);
int virNodeGetInfo (virConnectPtr conn,
int virNodeGetInfo (virConnectPtr conn,
virNodeInfoPtr info);
char * virConnectGetCapabilities (virConnectPtr conn);
unsigned long long virNodeGetFreeMemory (virConnectPtr conn);
unsigned long long virNodeGetFreeMemory (virConnectPtr conn);
/*
* Gather list of running domains
*/
int virConnectListDomains (virConnectPtr conn,
int virConnectListDomains (virConnectPtr conn,
int *ids,
int maxids);
/*
* Number of domains
*/
int virConnectNumOfDomains (virConnectPtr conn);
int virConnectNumOfDomains (virConnectPtr conn);
/*
* Get connection from domain.
*/
virConnectPtr virDomainGetConnect (virDomainPtr domain);
virConnectPtr virDomainGetConnect (virDomainPtr domain);
/*
* Domain creation and destruction
*/
virDomainPtr virDomainCreateLinux (virConnectPtr conn,
virDomainPtr virDomainCreateLinux (virConnectPtr conn,
const char *xmlDesc,
unsigned int flags);
virDomainPtr virDomainLookupByName (virConnectPtr conn,
virDomainPtr virDomainLookupByName (virConnectPtr conn,
const char *name);
virDomainPtr virDomainLookupByID (virConnectPtr conn,
virDomainPtr virDomainLookupByID (virConnectPtr conn,
int id);
virDomainPtr virDomainLookupByUUID (virConnectPtr conn,
virDomainPtr virDomainLookupByUUID (virConnectPtr conn,
const unsigned char *uuid);
virDomainPtr virDomainLookupByUUIDString (virConnectPtr conn,
virDomainPtr virDomainLookupByUUIDString (virConnectPtr conn,
const char *uuid);
int virDomainShutdown (virDomainPtr domain);
int virDomainReboot (virDomainPtr domain,
int virDomainShutdown (virDomainPtr domain);
int virDomainReboot (virDomainPtr domain,
unsigned int flags);
int virDomainDestroy (virDomainPtr domain);
int virDomainFree (virDomainPtr domain);
int virDomainDestroy (virDomainPtr domain);
int virDomainFree (virDomainPtr domain);
/*
* Domain suspend/resume
*/
int virDomainSuspend (virDomainPtr domain);
int virDomainResume (virDomainPtr domain);
int virDomainSuspend (virDomainPtr domain);
int virDomainResume (virDomainPtr domain);
/*
* Domain save/restore
*/
int virDomainSave (virDomainPtr domain,
int virDomainSave (virDomainPtr domain,
const char *to);
int virDomainRestore (virConnectPtr conn,
int virDomainRestore (virConnectPtr conn,
const char *from);
/*
* Domain core dump
*/
int virDomainCoreDump (virDomainPtr domain,
int virDomainCoreDump (virDomainPtr domain,
const char *to,
int flags);
/*
* Domain runtime information
*/
int virDomainGetInfo (virDomainPtr domain,
int virDomainGetInfo (virDomainPtr domain,
virDomainInfoPtr info);
/*
* Return scheduler type in effect 'sedf', 'credit', 'linux'
*/
char * virDomainGetSchedulerType(virDomainPtr domain,
char * virDomainGetSchedulerType(virDomainPtr domain,
int *nparams);
/*
* Dynamic control of domains
*/
const char * virDomainGetName (virDomainPtr domain);
unsigned int virDomainGetID (virDomainPtr domain);
int virDomainGetUUID (virDomainPtr domain,
const char * virDomainGetName (virDomainPtr domain);
unsigned int virDomainGetID (virDomainPtr domain);
int virDomainGetUUID (virDomainPtr domain,
unsigned char *uuid);
int virDomainGetUUIDString (virDomainPtr domain,
int virDomainGetUUIDString (virDomainPtr domain,
char *buf);
char * virDomainGetOSType (virDomainPtr domain);
unsigned long virDomainGetMaxMemory (virDomainPtr domain);
int virDomainSetMaxMemory (virDomainPtr domain,
char * virDomainGetOSType (virDomainPtr domain);
unsigned long virDomainGetMaxMemory (virDomainPtr domain);
int virDomainSetMaxMemory (virDomainPtr domain,
unsigned long memory);
int virDomainSetMemory (virDomainPtr domain,
int virDomainSetMemory (virDomainPtr domain,
unsigned long memory);
int virDomainGetMaxVcpus (virDomainPtr domain);
int virDomainGetMaxVcpus (virDomainPtr domain);
/*
* XML domain description
@ -519,7 +519,7 @@ typedef enum {
VIR_DOMAIN_XML_INACTIVE = 2/* dump inactive domain information */
} virDomainXMLFlags;
char * virDomainGetXMLDesc (virDomainPtr domain,
char * virDomainGetXMLDesc (virDomainPtr domain,
int flags);
int virDomainBlockStats (virDomainPtr dom,
@ -530,23 +530,28 @@ int virDomainInterfaceStats (virDomainPtr dom,
const char *path,
virDomainInterfaceStatsPtr stats,
size_t size);
int virDomainBlockPeek (virDomainPtr dom,
const char *path,
unsigned long long offset,
size_t size,
void *buffer,
unsigned int flags);
/*
* defined but not running domains
*/
virDomainPtr virDomainDefineXML (virConnectPtr conn,
virDomainPtr virDomainDefineXML (virConnectPtr conn,
const char *xml);
int virDomainUndefine (virDomainPtr domain);
int virDomainUndefine (virDomainPtr domain);
int virConnectNumOfDefinedDomains (virConnectPtr conn);
int virConnectListDefinedDomains (virConnectPtr conn,
int virConnectListDefinedDomains (virConnectPtr conn,
char **const names,
int maxnames);
int virDomainCreate (virDomainPtr domain);
int virDomainCreate (virDomainPtr domain);
int virDomainGetAutostart (virDomainPtr domain,
int virDomainGetAutostart (virDomainPtr domain,
int *autostart);
int virDomainSetAutostart (virDomainPtr domain,
int virDomainSetAutostart (virDomainPtr domain,
int autostart);
/**
@ -554,24 +559,24 @@ int virDomainSetAutostart (virDomainPtr domain,
*/
typedef enum {
VIR_VCPU_OFFLINE = 0, /* the virtual CPU is offline */
VIR_VCPU_RUNNING = 1, /* the virtual CPU is running */
VIR_VCPU_BLOCKED = 2, /* the virtual CPU is blocked on resource */
VIR_VCPU_OFFLINE = 0, /* the virtual CPU is offline */
VIR_VCPU_RUNNING = 1, /* the virtual CPU is running */
VIR_VCPU_BLOCKED = 2, /* the virtual CPU is blocked on resource */
} virVcpuState;
typedef struct _virVcpuInfo virVcpuInfo;
struct _virVcpuInfo {
unsigned int number; /* virtual CPU number */
int state; /* value from virVcpuState */
unsigned int number; /* virtual CPU number */
int state; /* value from virVcpuState */
unsigned long long cpuTime; /* CPU time used, in nanoseconds */
int cpu; /* real CPU number, or -1 if offline */
int cpu; /* real CPU number, or -1 if offline */
};
typedef virVcpuInfo *virVcpuInfoPtr;
int virDomainSetVcpus (virDomainPtr domain,
int virDomainSetVcpus (virDomainPtr domain,
unsigned int nvcpus);
int virDomainPinVcpu (virDomainPtr domain,
int virDomainPinVcpu (virDomainPtr domain,
unsigned int vcpu,
unsigned char *cpumap,
int maplen);
@ -585,7 +590,7 @@ int virDomainPinVcpu (virDomainPtr domain,
* USE_CPU macro set the bit (CPU usable) of the related cpu in cpumap.
*/
#define VIR_USE_CPU(cpumap,cpu) (cpumap[(cpu)/8] |= (1<<((cpu)%8)))
#define VIR_USE_CPU(cpumap,cpu) (cpumap[(cpu)/8] |= (1<<((cpu)%8)))
/**
* VIR_UNUSE_CPU:
@ -596,7 +601,7 @@ int virDomainPinVcpu (virDomainPtr domain,
* USE_CPU macro reset the bit (CPU not usable) of the related cpu in cpumap.
*/
#define VIR_UNUSE_CPU(cpumap,cpu) (cpumap[(cpu)/8] &= ~(1<<((cpu)%8)))
#define VIR_UNUSE_CPU(cpumap,cpu) (cpumap[(cpu)/8] &= ~(1<<((cpu)%8)))
/**
* VIR_CPU_MAPLEN:
@ -610,7 +615,7 @@ int virDomainPinVcpu (virDomainPtr domain,
#define VIR_CPU_MAPLEN(cpu) (((cpu)+7)/8)
int virDomainGetVcpus (virDomainPtr domain,
int virDomainGetVcpus (virDomainPtr domain,
virVcpuInfoPtr info,
int maxinfo,
unsigned char *cpumaps,
@ -637,7 +642,7 @@ int virDomainGetVcpus (virDomainPtr domain,
* @maplen: the length (in bytes) of one cpumap
* @vcpu: the virtual CPU number
* @cpumap: pointer to a cpumap (in 8-bit bytes) (OUT)
* This cpumap must be previously allocated by the caller
* This cpumap must be previously allocated by the caller
* (ie: malloc(maplen))
*
* This macro is to be used in conjunction with virDomainGetVcpus() and
@ -659,7 +664,7 @@ int virDomainGetVcpus (virDomainPtr domain,
* virDomainPinVcpu() APIs. VIR_GET_CPUMAP macro returns a pointer to the
* cpumap of the specified vcpu from cpumaps array.
*/
#define VIR_GET_CPUMAP(cpumaps,maplen,vcpu) &(cpumaps[(vcpu)*(maplen)])
#define VIR_GET_CPUMAP(cpumaps,maplen,vcpu) &(cpumaps[(vcpu)*(maplen)])
int virDomainAttachDevice(virDomainPtr domain, const char *xml);
int virDomainDetachDevice(virDomainPtr domain, const char *xml);
@ -668,7 +673,7 @@ int virDomainDetachDevice(virDomainPtr domain, const char *xml);
* NUMA support
*/
int virNodeGetCellsFreeMemory(virConnectPtr conn,
int virNodeGetCellsFreeMemory(virConnectPtr conn,
unsigned long long *freeMems,
int startCell,
int maxCells);
@ -695,77 +700,77 @@ typedef virNetwork *virNetworkPtr;
/*
* Get connection from network.
*/
virConnectPtr virNetworkGetConnect (virNetworkPtr network);
virConnectPtr virNetworkGetConnect (virNetworkPtr network);
/*
* List active networks
*/
int virConnectNumOfNetworks (virConnectPtr conn);
int virConnectListNetworks (virConnectPtr conn,
int virConnectNumOfNetworks (virConnectPtr conn);
int virConnectListNetworks (virConnectPtr conn,
char **const names,
int maxnames);
/*
* List inactive networks
*/
int virConnectNumOfDefinedNetworks (virConnectPtr conn);
int virConnectListDefinedNetworks (virConnectPtr conn,
int virConnectNumOfDefinedNetworks (virConnectPtr conn);
int virConnectListDefinedNetworks (virConnectPtr conn,
char **const names,
int maxnames);
/*
* Lookup network by name or uuid
*/
virNetworkPtr virNetworkLookupByName (virConnectPtr conn,
virNetworkPtr virNetworkLookupByName (virConnectPtr conn,
const char *name);
virNetworkPtr virNetworkLookupByUUID (virConnectPtr conn,
virNetworkPtr virNetworkLookupByUUID (virConnectPtr conn,
const unsigned char *uuid);
virNetworkPtr virNetworkLookupByUUIDString (virConnectPtr conn,
virNetworkPtr virNetworkLookupByUUIDString (virConnectPtr conn,
const char *uuid);
/*
* Create active transient network
*/
virNetworkPtr virNetworkCreateXML (virConnectPtr conn,
virNetworkPtr virNetworkCreateXML (virConnectPtr conn,
const char *xmlDesc);
/*
* Define inactive persistent network
*/
virNetworkPtr virNetworkDefineXML (virConnectPtr conn,
virNetworkPtr virNetworkDefineXML (virConnectPtr conn,
const char *xmlDesc);
/*
* Delete persistent network
*/
int virNetworkUndefine (virNetworkPtr network);
int virNetworkUndefine (virNetworkPtr network);
/*
* Activate persistent network
*/
int virNetworkCreate (virNetworkPtr network);
int virNetworkCreate (virNetworkPtr network);
/*
* Network destroy/free
*/
int virNetworkDestroy (virNetworkPtr network);
int virNetworkFree (virNetworkPtr network);
int virNetworkDestroy (virNetworkPtr network);
int virNetworkFree (virNetworkPtr network);
/*
* Network information
*/
const char* virNetworkGetName (virNetworkPtr network);
int virNetworkGetUUID (virNetworkPtr network,
const char* virNetworkGetName (virNetworkPtr network);
int virNetworkGetUUID (virNetworkPtr network,
unsigned char *uuid);
int virNetworkGetUUIDString (virNetworkPtr network,
int virNetworkGetUUIDString (virNetworkPtr network,
char *buf);
char * virNetworkGetXMLDesc (virNetworkPtr network,
char * virNetworkGetXMLDesc (virNetworkPtr network,
int flags);
char * virNetworkGetBridgeName (virNetworkPtr network);
char * virNetworkGetBridgeName (virNetworkPtr network);
int virNetworkGetAutostart (virNetworkPtr network,
int virNetworkGetAutostart (virNetworkPtr network,
int *autostart);
int virNetworkSetAutostart (virNetworkPtr network,
int virNetworkSetAutostart (virNetworkPtr network,
int autostart);
@ -855,113 +860,113 @@ typedef virStorageVolInfo *virStorageVolInfoPtr;
/*
* Get connection from pool.
*/
virConnectPtr virStoragePoolGetConnect (virStoragePoolPtr pool);
virConnectPtr virStoragePoolGetConnect (virStoragePoolPtr pool);
/*
* List active storage pools
*/
int virConnectNumOfStoragePools (virConnectPtr conn);
int virConnectListStoragePools (virConnectPtr conn,
int virConnectNumOfStoragePools (virConnectPtr conn);
int virConnectListStoragePools (virConnectPtr conn,
char **const names,
int maxnames);
/*
* List inactive storage pools
*/
int virConnectNumOfDefinedStoragePools(virConnectPtr conn);
int virConnectListDefinedStoragePools(virConnectPtr conn,
int virConnectNumOfDefinedStoragePools(virConnectPtr conn);
int virConnectListDefinedStoragePools(virConnectPtr conn,
char **const names,
int maxnames);
/*
* Lookup pool by name or uuid
*/
virStoragePoolPtr virStoragePoolLookupByName (virConnectPtr conn,
virStoragePoolPtr virStoragePoolLookupByName (virConnectPtr conn,
const char *name);
virStoragePoolPtr virStoragePoolLookupByUUID (virConnectPtr conn,
virStoragePoolPtr virStoragePoolLookupByUUID (virConnectPtr conn,
const unsigned char *uuid);
virStoragePoolPtr virStoragePoolLookupByUUIDString(virConnectPtr conn,
virStoragePoolPtr virStoragePoolLookupByUUIDString(virConnectPtr conn,
const char *uuid);
virStoragePoolPtr virStoragePoolLookupByVolume (virStorageVolPtr vol);
virStoragePoolPtr virStoragePoolLookupByVolume (virStorageVolPtr vol);
/*
* Creating/destroying pools
*/
virStoragePoolPtr virStoragePoolCreateXML (virConnectPtr conn,
virStoragePoolPtr virStoragePoolCreateXML (virConnectPtr conn,
const char *xmlDesc,
unsigned int flags);
virStoragePoolPtr virStoragePoolDefineXML (virConnectPtr conn,
virStoragePoolPtr virStoragePoolDefineXML (virConnectPtr conn,
const char *xmlDesc,
unsigned int flags);
int virStoragePoolBuild (virStoragePoolPtr pool,
int virStoragePoolBuild (virStoragePoolPtr pool,
unsigned int flags);
int virStoragePoolUndefine (virStoragePoolPtr pool);
int virStoragePoolCreate (virStoragePoolPtr pool,
int virStoragePoolUndefine (virStoragePoolPtr pool);
int virStoragePoolCreate (virStoragePoolPtr pool,
unsigned int flags);
int virStoragePoolDestroy (virStoragePoolPtr pool);
int virStoragePoolDelete (virStoragePoolPtr pool,
int virStoragePoolDestroy (virStoragePoolPtr pool);
int virStoragePoolDelete (virStoragePoolPtr pool,
unsigned int flags);
int virStoragePoolFree (virStoragePoolPtr pool);
int virStoragePoolRefresh (virStoragePoolPtr pool,
int virStoragePoolFree (virStoragePoolPtr pool);
int virStoragePoolRefresh (virStoragePoolPtr pool,
unsigned int flags);
/*
* StoragePool information
*/
const char* virStoragePoolGetName (virStoragePoolPtr pool);
int virStoragePoolGetUUID (virStoragePoolPtr pool,
const char* virStoragePoolGetName (virStoragePoolPtr pool);
int virStoragePoolGetUUID (virStoragePoolPtr pool,
unsigned char *uuid);
int virStoragePoolGetUUIDString (virStoragePoolPtr pool,
int virStoragePoolGetUUIDString (virStoragePoolPtr pool,
char *buf);
int virStoragePoolGetInfo (virStoragePoolPtr vol,
int virStoragePoolGetInfo (virStoragePoolPtr vol,
virStoragePoolInfoPtr info);
char * virStoragePoolGetXMLDesc (virStoragePoolPtr pool,
char * virStoragePoolGetXMLDesc (virStoragePoolPtr pool,
unsigned int flags);
int virStoragePoolGetAutostart (virStoragePoolPtr pool,
int virStoragePoolGetAutostart (virStoragePoolPtr pool,
int *autostart);
int virStoragePoolSetAutostart (virStoragePoolPtr pool,
int virStoragePoolSetAutostart (virStoragePoolPtr pool,
int autostart);
/*
* List/lookup storage volumes within a pool
*/
int virStoragePoolNumOfVolumes (virStoragePoolPtr pool);
int virStoragePoolListVolumes (virStoragePoolPtr pool,
int virStoragePoolNumOfVolumes (virStoragePoolPtr pool);
int virStoragePoolListVolumes (virStoragePoolPtr pool,
char **const names,
int maxnames);
virConnectPtr virStorageVolGetConnect (virStorageVolPtr vol);
virConnectPtr virStorageVolGetConnect (virStorageVolPtr vol);
/*
* Lookup volumes based on various attributes
*/
virStorageVolPtr virStorageVolLookupByName (virStoragePoolPtr pool,
virStorageVolPtr virStorageVolLookupByName (virStoragePoolPtr pool,
const char *name);
virStorageVolPtr virStorageVolLookupByKey (virConnectPtr conn,
virStorageVolPtr virStorageVolLookupByKey (virConnectPtr conn,
const char *key);
virStorageVolPtr virStorageVolLookupByPath (virConnectPtr conn,
virStorageVolPtr virStorageVolLookupByPath (virConnectPtr conn,
const char *path);
const char* virStorageVolGetName (virStorageVolPtr vol);
const char* virStorageVolGetKey (virStorageVolPtr vol);
const char* virStorageVolGetName (virStorageVolPtr vol);
const char* virStorageVolGetKey (virStorageVolPtr vol);
virStorageVolPtr virStorageVolCreateXML (virStoragePoolPtr pool,
virStorageVolPtr virStorageVolCreateXML (virStoragePoolPtr pool,
const char *xmldesc,
unsigned int flags);
int virStorageVolDelete (virStorageVolPtr vol,
int virStorageVolDelete (virStorageVolPtr vol,
unsigned int flags);
int virStorageVolFree (virStorageVolPtr vol);
int virStorageVolFree (virStorageVolPtr vol);
int virStorageVolGetInfo (virStorageVolPtr vol,
int virStorageVolGetInfo (virStorageVolPtr vol,
virStorageVolInfoPtr info);
char * virStorageVolGetXMLDesc (virStorageVolPtr pool,
char * virStorageVolGetXMLDesc (virStorageVolPtr pool,
unsigned int flags);
char * virStorageVolGetPath (virStorageVolPtr vol);
char * virStorageVolGetPath (virStorageVolPtr vol);
#ifdef __cplusplus
}

305
include/libvirt/libvirt.h.in
View File

@ -66,12 +66,12 @@ typedef virDomain *virDomainPtr;
* A domain may be in different states at a given point in time
*/
typedef enum {
VIR_DOMAIN_NOSTATE = 0, /* no state */
VIR_DOMAIN_RUNNING = 1, /* the domain is running */
VIR_DOMAIN_BLOCKED = 2, /* the domain is blocked on resource */
VIR_DOMAIN_PAUSED = 3, /* the domain is paused by user */
VIR_DOMAIN_NOSTATE = 0, /* no state */
VIR_DOMAIN_RUNNING = 1, /* the domain is running */
VIR_DOMAIN_BLOCKED = 2, /* the domain is blocked on resource */
VIR_DOMAIN_PAUSED = 3, /* the domain is paused by user */
VIR_DOMAIN_SHUTDOWN= 4, /* the domain is being shut down */
VIR_DOMAIN_SHUTOFF = 5, /* the domain is shut off */
VIR_DOMAIN_SHUTOFF = 5, /* the domain is shut off */
VIR_DOMAIN_CRASHED = 6 /* the domain is crashed */
} virDomainState;
@ -85,11 +85,11 @@ typedef enum {
typedef struct _virDomainInfo virDomainInfo;
struct _virDomainInfo {
unsigned char state; /* the running state, one of virDomainFlags */
unsigned long maxMem; /* the maximum memory in KBytes allowed */
unsigned long memory; /* the memory in KBytes used by the domain */
unsigned short nrVirtCpu; /* the number of virtual CPUs for the domain */
unsigned long long cpuTime; /* the CPU time used in nanoseconds */
unsigned char state; /* the running state, one of virDomainFlags */
unsigned long maxMem; /* the maximum memory in KBytes allowed */
unsigned long memory; /* the memory in KBytes used by the domain */
unsigned short nrVirtCpu; /* the number of virtual CPUs for the domain */
unsigned long long cpuTime; /* the CPU time used in nanoseconds */
};
/**
@ -120,13 +120,13 @@ typedef enum {
typedef struct _virNodeInfo virNodeInfo;
struct _virNodeInfo {
char model[32]; /* string indicating the CPU model */
char model[32]; /* string indicating the CPU model */
unsigned long memory;/* memory size in kilobytes */
unsigned int cpus; /* the number of active CPUs */
unsigned int mhz; /* expected CPU frequency */
unsigned int nodes; /* the number of NUMA cell, 1 for uniform mem access */
unsigned int cpus; /* the number of active CPUs */
unsigned int mhz; /* expected CPU frequency */
unsigned int nodes; /* the number of NUMA cell, 1 for uniform mem access */
unsigned int sockets;/* number of CPU socket per node */
unsigned int cores; /* number of core per socket */
unsigned int cores; /* number of core per socket */
unsigned int threads;/* number of threads per core */
};
@ -137,12 +137,12 @@ struct _virNodeInfo {
* A scheduler parameter field type
*/
typedef enum {
VIR_DOMAIN_SCHED_FIELD_INT = 1, /* integer case */
VIR_DOMAIN_SCHED_FIELD_UINT = 2, /* unsigned integer case */
VIR_DOMAIN_SCHED_FIELD_LLONG = 3, /* long long case */
VIR_DOMAIN_SCHED_FIELD_ULLONG = 4, /* unsigned long long case */
VIR_DOMAIN_SCHED_FIELD_DOUBLE = 5, /* double case */
VIR_DOMAIN_SCHED_FIELD_BOOLEAN = 6 /* boolean(character) case */
VIR_DOMAIN_SCHED_FIELD_INT = 1, /* integer case */
VIR_DOMAIN_SCHED_FIELD_UINT = 2, /* unsigned integer case */
VIR_DOMAIN_SCHED_FIELD_LLONG = 3, /* long long case */
VIR_DOMAIN_SCHED_FIELD_ULLONG = 4, /* unsigned long long case */
VIR_DOMAIN_SCHED_FIELD_DOUBLE = 5, /* double case */
VIR_DOMAIN_SCHED_FIELD_BOOLEAN = 6 /* boolean(character) case */
} virSchedParameterType;
/**
@ -162,15 +162,15 @@ typedef enum {
typedef struct _virSchedParameter virSchedParameter;
struct _virSchedParameter {
char field[VIR_DOMAIN_SCHED_FIELD_LENGTH]; /* parameter name */
int type; /* parameter type */
char field[VIR_DOMAIN_SCHED_FIELD_LENGTH]; /* parameter name */
int type; /* parameter type */
union {
int i; /* data for integer case */
unsigned int ui; /* data for unsigned integer case */
long long int l; /* data for long long integer case */
unsigned long long int ul; /* data for unsigned long long integer case */
double d; /* data for double case */
char b; /* data for char case */
int i; /* data for integer case */
unsigned int ui; /* data for unsigned integer case */
long long int l; /* data for long long integer case */
unsigned long long int ul; /* data for unsigned long long integer case */
double d; /* data for double case */
char b; /* data for char case */
} value; /* parameter value */
};
@ -185,14 +185,14 @@ typedef virSchedParameter *virSchedParameterPtr;
/*
* Fetch scheduler parameters, caller allocates 'params' field of size 'nparams'
*/
int virDomainGetSchedulerParameters (virDomainPtr domain,
int virDomainGetSchedulerParameters (virDomainPtr domain,
virSchedParameterPtr params,
int *nparams);
/*
* Change scheduler parameters
*/
int virDomainSetSchedulerParameters (virDomainPtr domain,
int virDomainSetSchedulerParameters (virDomainPtr domain,
virSchedParameterPtr params,
int nparams);
@ -382,23 +382,23 @@ extern virConnectAuthPtr virConnectAuthPtrDefault;
#define LIBVIR_VERSION_NUMBER @LIBVIRT_VERSION_NUMBER@
int virGetVersion (unsigned long *libVer,
int virGetVersion (unsigned long *libVer,
const char *type,
unsigned long *typeVer);
/*
* Connection and disconnections to the Hypervisor
*/
int virInitialize (void);
int virInitialize (void);
virConnectPtr virConnectOpen (const char *name);
virConnectPtr virConnectOpenReadOnly (const char *name);
virConnectPtr virConnectOpen (const char *name);
virConnectPtr virConnectOpenReadOnly (const char *name);
virConnectPtr virConnectOpenAuth (const char *name,
virConnectAuthPtr auth,
int flags);
int virConnectClose (virConnectPtr conn);
const char * virConnectGetType (virConnectPtr conn);
int virConnectGetVersion (virConnectPtr conn,
int virConnectClose (virConnectPtr conn);
const char * virConnectGetType (virConnectPtr conn);
int virConnectGetVersion (virConnectPtr conn,
unsigned long *hvVer);
char * virConnectGetHostname (virConnectPtr conn);
char * virConnectGetURI (virConnectPtr conn);
@ -410,100 +410,100 @@ char * virConnectGetURI (virConnectPtr conn);
int virConnectGetMaxVcpus (virConnectPtr conn,
const char *type);
int virNodeGetInfo (virConnectPtr conn,
int virNodeGetInfo (virConnectPtr conn,
virNodeInfoPtr info);
char * virConnectGetCapabilities (virConnectPtr conn);
unsigned long long virNodeGetFreeMemory (virConnectPtr conn);
unsigned long long virNodeGetFreeMemory (virConnectPtr conn);
/*
* Gather list of running domains
*/
int virConnectListDomains (virConnectPtr conn,
int virConnectListDomains (virConnectPtr conn,
int *ids,
int maxids);
/*
* Number of domains
*/
int virConnectNumOfDomains (virConnectPtr conn);
int virConnectNumOfDomains (virConnectPtr conn);
/*
* Get connection from domain.
*/
virConnectPtr virDomainGetConnect (virDomainPtr domain);
virConnectPtr virDomainGetConnect (virDomainPtr domain);
/*
* Domain creation and destruction
*/
virDomainPtr virDomainCreateLinux (virConnectPtr conn,
virDomainPtr virDomainCreateLinux (virConnectPtr conn,
const char *xmlDesc,
unsigned int flags);
virDomainPtr virDomainLookupByName (virConnectPtr conn,
virDomainPtr virDomainLookupByName (virConnectPtr conn,
const char *name);
virDomainPtr virDomainLookupByID (virConnectPtr conn,
virDomainPtr virDomainLookupByID (virConnectPtr conn,
int id);
virDomainPtr virDomainLookupByUUID (virConnectPtr conn,
virDomainPtr virDomainLookupByUUID (virConnectPtr conn,
const unsigned char *uuid);
virDomainPtr virDomainLookupByUUIDString (virConnectPtr conn,
virDomainPtr virDomainLookupByUUIDString (virConnectPtr conn,
const char *uuid);
int virDomainShutdown (virDomainPtr domain);
int virDomainReboot (virDomainPtr domain,
int virDomainShutdown (virDomainPtr domain);
int virDomainReboot (virDomainPtr domain,
unsigned int flags);
int virDomainDestroy (virDomainPtr domain);
int virDomainFree (virDomainPtr domain);
int virDomainDestroy (virDomainPtr domain);
int virDomainFree (virDomainPtr domain);
/*
* Domain suspend/resume
*/
int virDomainSuspend (virDomainPtr domain);
int virDomainResume (virDomainPtr domain);
int virDomainSuspend (virDomainPtr domain);
int virDomainResume (virDomainPtr domain);
/*
* Domain save/restore
*/
int virDomainSave (virDomainPtr domain,
int virDomainSave (virDomainPtr domain,
const char *to);
int virDomainRestore (virConnectPtr conn,
int virDomainRestore (virConnectPtr conn,
const char *from);
/*
* Domain core dump
*/
int virDomainCoreDump (virDomainPtr domain,
int virDomainCoreDump (virDomainPtr domain,
const char *to,
int flags);
/*
* Domain runtime information
*/
int virDomainGetInfo (virDomainPtr domain,
int virDomainGetInfo (virDomainPtr domain,
virDomainInfoPtr info);
/*
* Return scheduler type in effect 'sedf', 'credit', 'linux'
*/
char * virDomainGetSchedulerType(virDomainPtr domain,
char * virDomainGetSchedulerType(virDomainPtr domain,
int *nparams);
/*
* Dynamic control of domains
*/
const char * virDomainGetName (virDomainPtr domain);
unsigned int virDomainGetID (virDomainPtr domain);
int virDomainGetUUID (virDomainPtr domain,
const char * virDomainGetName (virDomainPtr domain);
unsigned int virDomainGetID (virDomainPtr domain);
int virDomainGetUUID (virDomainPtr domain,
unsigned char *uuid);
int virDomainGetUUIDString (virDomainPtr domain,
int virDomainGetUUIDString (virDomainPtr domain,
char *buf);
char * virDomainGetOSType (virDomainPtr domain);
unsigned long virDomainGetMaxMemory (virDomainPtr domain);
int virDomainSetMaxMemory (virDomainPtr domain,
char * virDomainGetOSType (virDomainPtr domain);
unsigned long virDomainGetMaxMemory (virDomainPtr domain);
int virDomainSetMaxMemory (virDomainPtr domain,
unsigned long memory);
int virDomainSetMemory (virDomainPtr domain,
int virDomainSetMemory (virDomainPtr domain,
unsigned long memory);
int virDomainGetMaxVcpus (virDomainPtr domain);
int virDomainGetMaxVcpus (virDomainPtr domain);
/*
* XML domain description
@ -519,7 +519,7 @@ typedef enum {
VIR_DOMAIN_XML_INACTIVE = 2/* dump inactive domain information */
} virDomainXMLFlags;
char * virDomainGetXMLDesc (virDomainPtr domain,
char * virDomainGetXMLDesc (virDomainPtr domain,
int flags);
int virDomainBlockStats (virDomainPtr dom,
@ -530,23 +530,28 @@ int virDomainInterfaceStats (virDomainPtr dom,
const char *path,
virDomainInterfaceStatsPtr stats,
size_t size);
int virDomainBlockPeek (virDomainPtr dom,
const char *path,
unsigned long long offset,
size_t size,
void *buffer,
unsigned int flags);
/*
* defined but not running domains
*/
virDomainPtr virDomainDefineXML (virConnectPtr conn,
virDomainPtr virDomainDefineXML (virConnectPtr conn,
const char *xml);
int virDomainUndefine (virDomainPtr domain);
int virDomainUndefine (virDomainPtr domain);
int virConnectNumOfDefinedDomains (virConnectPtr conn);
int virConnectListDefinedDomains (virConnectPtr conn,
int virConnectListDefinedDomains (virConnectPtr conn,
char **const names,
int maxnames);
int virDomainCreate (virDomainPtr domain);
int virDomainCreate (virDomainPtr domain);
int virDomainGetAutostart (virDomainPtr domain,
int virDomainGetAutostart (virDomainPtr domain,
int *autostart);
int virDomainSetAutostart (virDomainPtr domain,
int virDomainSetAutostart (virDomainPtr domain,
int autostart);
/**
@ -554,24 +559,24 @@ int virDomainSetAutostart (virDomainPtr domain,
*/
typedef enum {
VIR_VCPU_OFFLINE = 0, /* the virtual CPU is offline */
VIR_VCPU_RUNNING = 1, /* the virtual CPU is running */
VIR_VCPU_BLOCKED = 2, /* the virtual CPU is blocked on resource */
VIR_VCPU_OFFLINE = 0, /* the virtual CPU is offline */
VIR_VCPU_RUNNING = 1, /* the virtual CPU is running */
VIR_VCPU_BLOCKED = 2, /* the virtual CPU is blocked on resource */
} virVcpuState;
typedef struct _virVcpuInfo virVcpuInfo;
struct _virVcpuInfo {
unsigned int number; /* virtual CPU number */
int state; /* value from virVcpuState */
unsigned int number; /* virtual CPU number */
int state; /* value from virVcpuState */
unsigned long long cpuTime; /* CPU time used, in nanoseconds */
int cpu; /* real CPU number, or -1 if offline */
int cpu; /* real CPU number, or -1 if offline */
};
typedef virVcpuInfo *virVcpuInfoPtr;
int virDomainSetVcpus (virDomainPtr domain,
int virDomainSetVcpus (virDomainPtr domain,
unsigned int nvcpus);
int virDomainPinVcpu (virDomainPtr domain,
int virDomainPinVcpu (virDomainPtr domain,
unsigned int vcpu,
unsigned char *cpumap,
int maplen);
@ -585,7 +590,7 @@ int virDomainPinVcpu (virDomainPtr domain,
* USE_CPU macro set the bit (CPU usable) of the related cpu in cpumap.
*/
#define VIR_USE_CPU(cpumap,cpu) (cpumap[(cpu)/8] |= (1<<((cpu)%8)))
#define VIR_USE_CPU(cpumap,cpu) (cpumap[(cpu)/8] |= (1<<((cpu)%8)))
/**
* VIR_UNUSE_CPU:
@ -596,7 +601,7 @@ int virDomainPinVcpu (virDomainPtr domain,
* USE_CPU macro reset the bit (CPU not usable) of the related cpu in cpumap.
*/
#define VIR_UNUSE_CPU(cpumap,cpu) (cpumap[(cpu)/8] &= ~(1<<((cpu)%8)))
#define VIR_UNUSE_CPU(cpumap,cpu) (cpumap[(cpu)/8] &= ~(1<<((cpu)%8)))
/**
* VIR_CPU_MAPLEN:
@ -610,7 +615,7 @@ int virDomainPinVcpu (virDomainPtr domain,
#define VIR_CPU_MAPLEN(cpu) (((cpu)+7)/8)
int virDomainGetVcpus (virDomainPtr domain,
int virDomainGetVcpus (virDomainPtr domain,
virVcpuInfoPtr info,
int maxinfo,
unsigned char *cpumaps,
@ -637,7 +642,7 @@ int virDomainGetVcpus (virDomainPtr domain,
* @maplen: the length (in bytes) of one cpumap
* @vcpu: the virtual CPU number
* @cpumap: pointer to a cpumap (in 8-bit bytes) (OUT)
* This cpumap must be previously allocated by the caller
* This cpumap must be previously allocated by the caller
* (ie: malloc(maplen))
*
* This macro is to be used in conjunction with virDomainGetVcpus() and
@ -659,7 +664,7 @@ int virDomainGetVcpus (virDomainPtr domain,
* virDomainPinVcpu() APIs. VIR_GET_CPUMAP macro returns a pointer to the
* cpumap of the specified vcpu from cpumaps array.
*/
#define VIR_GET_CPUMAP(cpumaps,maplen,vcpu) &(cpumaps[(vcpu)*(maplen)])
#define VIR_GET_CPUMAP(cpumaps,maplen,vcpu) &(cpumaps[(vcpu)*(maplen)])
int virDomainAttachDevice(virDomainPtr domain, const char *xml);
int virDomainDetachDevice(virDomainPtr domain, const char *xml);
@ -668,7 +673,7 @@ int virDomainDetachDevice(virDomainPtr domain, const char *xml);
* NUMA support
*/
int virNodeGetCellsFreeMemory(virConnectPtr conn,
int virNodeGetCellsFreeMemory(virConnectPtr conn,
unsigned long long *freeMems,
int startCell,
int maxCells);
@ -695,77 +700,77 @@ typedef virNetwork *virNetworkPtr;
/*
* Get connection from network.
*/
virConnectPtr virNetworkGetConnect (virNetworkPtr network);
virConnectPtr virNetworkGetConnect (virNetworkPtr network);
/*
* List active networks
*/
int virConnectNumOfNetworks (virConnectPtr conn);
int virConnectListNetworks (virConnectPtr conn,
int virConnectNumOfNetworks (virConnectPtr conn);
int virConnectListNetworks (virConnectPtr conn,
char **const names,
int maxnames);
/*
* List inactive networks
*/
int virConnectNumOfDefinedNetworks (virConnectPtr conn);
int virConnectListDefinedNetworks (virConnectPtr conn,
int virConnectNumOfDefinedNetworks (virConnectPtr conn);
int virConnectListDefinedNetworks (virConnectPtr conn,
char **const names,
int maxnames);
/*
* Lookup network by name or uuid
*/
virNetworkPtr virNetworkLookupByName (virConnectPtr conn,
virNetworkPtr virNetworkLookupByName (virConnectPtr conn,
const char *name);
virNetworkPtr virNetworkLookupByUUID (virConnectPtr conn,
virNetworkPtr virNetworkLookupByUUID (virConnectPtr conn,
const unsigned char *uuid);
virNetworkPtr virNetworkLookupByUUIDString (virConnectPtr conn,
virNetworkPtr virNetworkLookupByUUIDString (virConnectPtr conn,
const char *uuid);
/*
* Create active transient network
*/
virNetworkPtr virNetworkCreateXML (virConnectPtr conn,
virNetworkPtr virNetworkCreateXML (virConnectPtr conn,
const char *xmlDesc);
/*
* Define inactive persistent network
*/
virNetworkPtr virNetworkDefineXML (virConnectPtr conn,
virNetworkPtr virNetworkDefineXML (virConnectPtr conn,
const char *xmlDesc);
/*
* Delete persistent network
*/
int virNetworkUndefine (virNetworkPtr network);
int virNetworkUndefine (virNetworkPtr network);
/*
* Activate persistent network
*/
int virNetworkCreate (virNetworkPtr network);
int virNetworkCreate (virNetworkPtr network);
/*
* Network destroy/free
*/
int virNetworkDestroy (virNetworkPtr network);
int virNetworkFree (virNetworkPtr network);
int virNetworkDestroy (virNetworkPtr network);
int virNetworkFree (virNetworkPtr network);
/*
* Network information
*/
const char* virNetworkGetName (virNetworkPtr network);
int virNetworkGetUUID (virNetworkPtr network,
const char* virNetworkGetName (virNetworkPtr network);
int virNetworkGetUUID (virNetworkPtr network,
unsigned char *uuid);
int virNetworkGetUUIDString (virNetworkPtr network,
int virNetworkGetUUIDString (virNetworkPtr network,
char *buf);
char * virNetworkGetXMLDesc (virNetworkPtr network,
char * virNetworkGetXMLDesc (virNetworkPtr network,
int flags);
char * virNetworkGetBridgeName (virNetworkPtr network);
char * virNetworkGetBridgeName (virNetworkPtr network);
int virNetworkGetAutostart (virNetworkPtr network,
int virNetworkGetAutostart (virNetworkPtr network,
int *autostart);
int virNetworkSetAutostart (virNetworkPtr network,
int virNetworkSetAutostart (virNetworkPtr network,
int autostart);
@ -855,113 +860,113 @@ typedef virStorageVolInfo *virStorageVolInfoPtr;
/*
* Get connection from pool.
*/
virConnectPtr virStoragePoolGetConnect (virStoragePoolPtr pool);
virConnectPtr virStoragePoolGetConnect (virStoragePoolPtr pool);
/*
* List active storage pools
*/
int virConnectNumOfStoragePools (virConnectPtr conn);
int virConnectListStoragePools (virConnectPtr conn,
int virConnectNumOfStoragePools (virConnectPtr conn);
int virConnectListStoragePools (virConnectPtr conn,
char **const names,
int maxnames);
/*
* List inactive storage pools
*/
int virConnectNumOfDefinedStoragePools(virConnectPtr conn);
int virConnectListDefinedStoragePools(virConnectPtr conn,
int virConnectNumOfDefinedStoragePools(virConnectPtr conn);
int virConnectListDefinedStoragePools(virConnectPtr conn,
char **const names,
int maxnames);
/*
* Lookup pool by name or uuid
*/
virStoragePoolPtr virStoragePoolLookupByName (virConnectPtr conn,
virStoragePoolPtr virStoragePoolLookupByName (virConnectPtr conn,
const char *name);
virStoragePoolPtr virStoragePoolLookupByUUID (virConnectPtr conn,
virStoragePoolPtr virStoragePoolLookupByUUID (virConnectPtr conn,
const unsigned char *uuid);
virStoragePoolPtr virStoragePoolLookupByUUIDString(virConnectPtr conn,
virStoragePoolPtr virStoragePoolLookupByUUIDString(virConnectPtr conn,
const char *uuid);
virStoragePoolPtr virStoragePoolLookupByVolume (virStorageVolPtr vol);
virStoragePoolPtr virStoragePoolLookupByVolume (virStorageVolPtr vol);
/*
* Creating/destroying pools
*/
virStoragePoolPtr virStoragePoolCreateXML (virConnectPtr conn,
virStoragePoolPtr virStoragePoolCreateXML (virConnectPtr conn,
const char *xmlDesc,
unsigned int flags);
virStoragePoolPtr virStoragePoolDefineXML (virConnectPtr conn,
virStoragePoolPtr virStoragePoolDefineXML (virConnectPtr conn,
const char *xmlDesc,
unsigned int flags);
int virStoragePoolBuild (virStoragePoolPtr pool,
int virStoragePoolBuild (virStoragePoolPtr pool,
unsigned int flags);
int virStoragePoolUndefine (virStoragePoolPtr pool);
int virStoragePoolCreate (virStoragePoolPtr pool,
int virStoragePoolUndefine (virStoragePoolPtr pool);
int virStoragePoolCreate (virStoragePoolPtr pool,
unsigned int flags);
int virStoragePoolDestroy (virStoragePoolPtr pool);
int virStoragePoolDelete (virStoragePoolPtr pool,
int virStoragePoolDestroy (virStoragePoolPtr pool);
int virStoragePoolDelete (virStoragePoolPtr pool,
unsigned int flags);
int virStoragePoolFree (virStoragePoolPtr pool);
int virStoragePoolRefresh (virStoragePoolPtr pool,
int virStoragePoolFree (virStoragePoolPtr pool);
int virStoragePoolRefresh (virStoragePoolPtr pool,
unsigned int flags);
/*
* StoragePool information
*/
const char* virStoragePoolGetName (virStoragePoolPtr pool);
int virStoragePoolGetUUID (virStoragePoolPtr pool,
const char* virStoragePoolGetName (virStoragePoolPtr pool);
int virStoragePoolGetUUID (virStoragePoolPtr pool,
unsigned char *uuid);
int virStoragePoolGetUUIDString (virStoragePoolPtr pool,
int virStoragePoolGetUUIDString (virStoragePoolPtr pool,
char *buf);
int virStoragePoolGetInfo (virStoragePoolPtr vol,
int virStoragePoolGetInfo (virStoragePoolPtr vol,
virStoragePoolInfoPtr info);
char * virStoragePoolGetXMLDesc (virStoragePoolPtr pool,
char * virStoragePoolGetXMLDesc (virStoragePoolPtr pool,
unsigned int flags);
int virStoragePoolGetAutostart (virStoragePoolPtr pool,
int virStoragePoolGetAutostart (virStoragePoolPtr pool,
int *autostart);
int virStoragePoolSetAutostart (virStoragePoolPtr pool,
int virStoragePoolSetAutostart (virStoragePoolPtr pool,
int autostart);
/*
* List/lookup storage volumes within a pool
*/
int virStoragePoolNumOfVolumes (virStoragePoolPtr pool);
int virStoragePoolListVolumes (virStoragePoolPtr pool,
int virStoragePoolNumOfVolumes (virStoragePoolPtr pool);
int virStoragePoolListVolumes (virStoragePoolPtr pool,
char **const names,
int maxnames);
virConnectPtr virStorageVolGetConnect (virStorageVolPtr vol);
virConnectPtr virStorageVolGetConnect (virStorageVolPtr vol);
/*
* Lookup volumes based on various attributes
*/
virStorageVolPtr virStorageVolLookupByName (virStoragePoolPtr pool,
virStorageVolPtr virStorageVolLookupByName (virStoragePoolPtr pool,
const char *name);
virStorageVolPtr virStorageVolLookupByKey (virConnectPtr conn,
virStorageVolPtr virStorageVolLookupByKey (virConnectPtr conn,
const char *key);
virStorageVolPtr virStorageVolLookupByPath (virConnectPtr conn,
virStorageVolPtr virStorageVolLookupByPath (virConnectPtr conn,
const char *path);
const char* virStorageVolGetName (virStorageVolPtr vol);
const char* virStorageVolGetKey (virStorageVolPtr vol);
const char* virStorageVolGetName (virStorageVolPtr vol);
const char* virStorageVolGetKey (virStorageVolPtr vol);
virStorageVolPtr virStorageVolCreateXML (virStoragePoolPtr pool,
virStorageVolPtr virStorageVolCreateXML (virStoragePoolPtr pool,
const char *xmldesc,
unsigned int flags);
int virStorageVolDelete (virStorageVolPtr vol,
int virStorageVolDelete (virStorageVolPtr vol,
unsigned int flags);
int virStorageVolFree (virStorageVolPtr vol);
int virStorageVolFree (virStorageVolPtr vol);
int virStorageVolGetInfo (virStorageVolPtr vol,
int virStorageVolGetInfo (virStorageVolPtr vol,
virStorageVolInfoPtr info);
char * virStorageVolGetXMLDesc (virStorageVolPtr pool,
char * virStorageVolGetXMLDesc (virStorageVolPtr pool,
unsigned int flags);
char * virStorageVolGetPath (virStorageVolPtr vol);
char * virStorageVolGetPath (virStorageVolPtr vol);
#ifdef __cplusplus
}

8
src/driver.h
View File

@ -225,6 +225,13 @@ typedef int
const char *path,
struct _virDomainInterfaceStats *stats);
typedef int
(*virDrvDomainBlockPeek)
(virDomainPtr domain,
const char *path,
unsigned long long offset, size_t size,
void *buffer);
typedef int
(*virDrvDomainMigratePrepare)
(virConnectPtr dconn,
@ -337,6 +344,7 @@ struct _virDriver {
virDrvDomainMigrateFinish domainMigrateFinish;
virDrvDomainBlockStats domainBlockStats;
virDrvDomainInterfaceStats domainInterfaceStats;
virDrvDomainBlockPeek domainBlockPeek;
virDrvNodeGetCellsFreeMemory nodeGetCellsFreeMemory;
virDrvNodeGetFreeMemory getFreeMemory;
};

77
src/libvirt.c
View File

@ -2586,7 +2586,84 @@ virDomainInterfaceStats (virDomainPtr dom, const char *path,
return -1;
}
/**
* virDomainBlockPeek:
* @dom: pointer to the domain object
* @path: path to the block device
* @offset: offset within block device
* @size: size to read
* @buffer: return buffer (must be at least size bytes)
* @flags: unused, always pass 0
*
* This function allows you to read the contents of a domain's
* disk device.
*
* Typical uses for this are to determine if the domain has
* written a Master Boot Record (indicating that the domain
* has completed installation), or to try to work out the state
* of the domain's filesystems.
*
* (Note that in the local case you might try to open the
* block device or file directly, but that won't work in the
* remote case, nor if you don't have sufficient permission.
* Hence the need for this call).
*
* 'path' must be a device or file corresponding to the domain.
* In other words it must be the precise string returned in
* a <disk><source dev='...'/></disk> from
* virDomainGetXMLDesc.
*
* 'offset' and 'size' represent an area which must lie entirely
* within the device or file. 'size' may be 0 to test if the
* call would succeed.
*
* 'buffer' is the return buffer and must be at least 'size' bytes.
*
* Returns: 0 in case of success or -1 in case of failure.
*/
int
virDomainBlockPeek (virDomainPtr dom,
const char *path,
unsigned long long offset /* really 64 bits */,
size_t size,
void *buffer,
unsigned int flags)
{
virConnectPtr conn;
DEBUG("domain=%p, path=%s, offset=%lld, size=%zi, buffer=%p",
dom, path, offset, size, buffer);
if (!VIR_IS_CONNECTED_DOMAIN (dom)) {
virLibDomainError (NULL, VIR_ERR_INVALID_DOMAIN, __FUNCTION__);
return -1;
}
conn = dom->conn;
if (!path) {
virLibDomainError (dom, VIR_ERR_INVALID_ARG,
_("path is NULL"));
return -1;
}
if (flags != 0) {
virLibDomainError (dom, VIR_ERR_INVALID_ARG,
_("flags must be zero"));
return -1;
}
/* Allow size == 0 as an access test. */
if (size > 0 && !buffer) {
virLibDomainError (dom, VIR_ERR_INVALID_ARG,
_("buffer is NULL"));
return -1;
}
if (conn->driver->domainBlockPeek)
return conn->driver->domainBlockPeek (dom, path, offset, size, buffer);
virLibDomainError (dom, VIR_ERR_NO_SUPPORT, __FUNCTION__);
return -1;
}
/************************************************************************

1
src/libvirt_sym.version
View File

@ -73,6 +73,7 @@
virDomainSetSchedulerParameters;
virDomainBlockStats;
virDomainInterfaceStats;
virDomainBlockPeek;
virDomainAttachDevice;
virDomainDetachDevice;

1
src/qemu_driver.c
View File

@ -3521,6 +3521,7 @@ static virDriver qemuDriver = {
NULL, /* domainMigrateFinish */
qemudDomainBlockStats, /* domainBlockStats */
qemudDomainInterfaceStats, /* domainInterfaceStats */
NULL, /* domainBlockPeek */
#if HAVE_NUMACTL
qemudNodeGetCellsFreeMemory, /* nodeGetCellsFreeMemory */
qemudNodeGetFreeMemory, /* getFreeMemory */

1
src/test.c
View File

@ -2060,6 +2060,7 @@ static virDriver testDriver = {
NULL, /* domainMigrateFinish */
NULL, /* domainBlockStats */
NULL, /* domainInterfaceStats */
NULL, /* domainBlockPeek */
testNodeGetCellsFreeMemory, /* nodeGetCellsFreeMemory */
NULL, /* getFreeMemory */
};

24
src/xen_unified.c
View File

@ -1234,6 +1234,29 @@ xenUnifiedDomainInterfaceStats (virDomainPtr dom, const char *path,
return -1;
}
static int
xenUnifiedDomainBlockPeek (virDomainPtr dom, const char *path,
unsigned long long offset, size_t size,
void *buffer)
{
int r;
GET_PRIVATE (dom->conn);
if (priv->opened[XEN_UNIFIED_XEND_OFFSET]) {
r = xenDaemonDomainBlockPeek (dom, path, offset, size, buffer);
if (r != -2) return r;
/* r == -2 means declined, so fall through to XM driver ... */
}
if (priv->opened[XEN_UNIFIED_XM_OFFSET]) {
if (xenXMDomainBlockPeek (dom, path, offset, size, buffer) == 0)
return 0;
}
xenUnifiedError (dom->conn, VIR_ERR_NO_SUPPORT, __FUNCTION__);
return -1;
}
static int
xenUnifiedNodeGetCellsFreeMemory (virConnectPtr conn, unsigned long long *freeMems,
int startCell, int maxCells)
@ -1329,6 +1352,7 @@ static virDriver xenUnifiedDriver = {
.domainMigrateFinish = xenUnifiedDomainMigrateFinish,
.domainBlockStats = xenUnifiedDomainBlockStats,
.domainInterfaceStats = xenUnifiedDomainInterfaceStats,
.domainBlockPeek = xenUnifiedDomainBlockPeek,
.nodeGetCellsFreeMemory = xenUnifiedNodeGetCellsFreeMemory,
.getFreeMemory = xenUnifiedNodeGetFreeMemory,
};

483
src/xend_internal.c
View File

@ -18,6 +18,8 @@
#include <sys/socket.h>
#include <sys/un.h>
#include <sys/errno.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <unistd.h>
#include <string.h>
#include <stdlib.h>
@ -1705,6 +1707,219 @@ error:
return ret;
}
typedef int
(*sexp_blockdevs_cb)
(virConnectPtr conn, void *data,
int isBlock, int cdrom, int isNoSrcCdrom, int hvm,
const char *drvName, const char *drvType,
const char *src, const char *dst,
const char *mode);
/**
* xend_parse_sexp_blockdevs:
* @conn: connection
* @root: root sexpr
* @xendConfigVersion: version of xend
* @fn: callback function
* @data: optional data for callback function
*
* This parses out block devices from the domain sexpr and calls
* fn (conn, data, ...) for each block device found.
*
* Returns 0 if successful or -1 if failed.
*/
static int
xend_parse_sexp_blockdevs (virConnectPtr conn, struct sexpr *root,
int xendConfigVersion,
sexp_blockdevs_cb fn, void *data)
{
struct sexpr *cur, *node;
int hvm;
hvm = sexpr_lookup(root, "domain/image/hvm") ? 1 : 0;
for (cur = root; cur->kind == SEXPR_CONS; cur = cur->u.s.cdr) {
node = cur->u.s.car;
/* Normally disks are in a (device (vbd ...)) block
but blktap disks ended up in a differently named
(device (tap ....)) block.... */
if (sexpr_lookup(node, "device/vbd") ||
sexpr_lookup(node, "device/tap")) {
char *offset;
int ret = -1;
int isBlock = 0;
int cdrom = 0;
int isNoSrcCdrom = 0;
char *drvName = NULL;
char *drvType = NULL;
const char *src = NULL;
const char *dst = NULL;
const char *mode = NULL;
/* Again dealing with (vbd...) vs (tap ...) differences */
if (sexpr_lookup(node, "device/vbd")) {
src = sexpr_node(node, "device/vbd/uname");
dst = sexpr_node(node, "device/vbd/dev");
mode = sexpr_node(node, "device/vbd/mode");
} else {
src = sexpr_node(node, "device/tap/uname");
dst = sexpr_node(node, "device/tap/dev");
mode = sexpr_node(node, "device/tap/mode");
}
if (dst == NULL) {
virXendError(conn, VIR_ERR_INTERNAL_ERROR,
_("domain information incomplete, vbd has no dev"));
goto bad_parse;
}
if (src == NULL) {
/* There is a case without the uname to the CD-ROM device */
offset = strchr(dst, ':');
if (offset) {
if (hvm && STREQ(offset, ":cdrom")) {
isNoSrcCdrom = 1;
}
offset[0] = '\0';
}
if (!isNoSrcCdrom) {
virXendError(conn, VIR_ERR_INTERNAL_ERROR,
_("domain information incomplete, vbd has no src"));
goto bad_parse;
}
}
if (!isNoSrcCdrom) {
offset = strchr(src, ':');
if (!offset) {
virXendError(conn, VIR_ERR_INTERNAL_ERROR,
_("cannot parse vbd filename, missing driver name"));
goto bad_parse;
}
if (VIR_ALLOC_N(drvName, (offset-src)+1) < 0) {
virXendError(conn, VIR_ERR_NO_MEMORY,
_("allocate new buffer"));
goto bad_parse;
}
strncpy(drvName, src, (offset-src));
drvName[offset-src] = '\0';
src = offset + 1;
if (STREQ (drvName, "tap")) {
offset = strchr(src, ':');
if (!offset) {
virXendError(conn, VIR_ERR_INTERNAL_ERROR,
_("cannot parse vbd filename, missing driver type"));
goto bad_parse;
}
if (VIR_ALLOC_N(drvType, (offset-src)+1)< 0) {
virXendError(conn, VIR_ERR_NO_MEMORY,
_("allocate new buffer"));
goto bad_parse;
}
strncpy(drvType, src, (offset-src));
drvType[offset-src] = '\0';
src = offset + 1;
/* Its possible to use blktap driver for block devs
too, but kinda pointless because blkback is better,
so we assume common case here. If blktap becomes
omnipotent, we can revisit this, perhaps stat()'ing
the src file in question */
isBlock = 0;
} else if (STREQ(drvName, "phy")) {
isBlock = 1;
} else if (STREQ(drvName, "file")) {
isBlock = 0;
}
}
if (STREQLEN (dst, "ioemu:", 6))
dst += 6;
/* New style disk config from Xen >= 3.0.3 */
if (xendConfigVersion > 1) {
offset = strrchr(dst, ':');
if (offset) {
if (STREQ (offset, ":cdrom")) {
cdrom = 1;
} else if (STREQ (offset, ":disk")) {
/* The default anyway */
} else {
/* Unknown, lets pretend its a disk too */
}
offset[0] = '\0';
}
}
/* Call the callback function. */
ret = fn (conn, data, isBlock, cdrom, isNoSrcCdrom, hvm,
drvName, drvType, src, dst, mode);
bad_parse:
VIR_FREE(drvName);
VIR_FREE(drvType);
if (ret == -1) return -1;
}
}
return 0;
}
static int
xend_parse_sexp_desc_blockdev (virConnectPtr conn ATTRIBUTE_UNUSED,
void *data,
int isBlock, int cdrom, int isNoSrcCdrom,
int hvm,
const char *drvName, const char *drvType,
const char *src, const char *dst,
const char *mode)
{
virBuffer *buf = (virBuffer *) data;
const char *bus = NULL;
if (!isNoSrcCdrom) {
virBufferVSprintf(buf, " <disk type='%s' device='%s'>\n",
isBlock ? "block" : "file",
cdrom ? "cdrom" : "disk");
if (drvType) {
virBufferVSprintf(buf, " <driver name='%s' type='%s'/>\n", drvName, drvType);
} else {
virBufferVSprintf(buf, " <driver name='%s'/>\n", drvName);
}
if (isBlock) {
virBufferVSprintf(buf, " <source dev='%s'/>\n", src);
} else {
virBufferVSprintf(buf, " <source file='%s'/>\n", src);
}
} else {
/* This case is the cdrom device only */
virBufferAddLit(buf, " <disk device='cdrom'>\n");
}
if (STRPREFIX(dst, "xvd") || !hvm) {
bus = "xen";
} else if (STRPREFIX(dst, "sd")) {
bus = "scsi";
} else {
bus = "ide";
}
virBufferVSprintf(buf, " <target dev='%s' bus='%s'/>\n",
dst, bus);
/* XXX should we force mode == r, if cdrom==1, or assume
xend has already done this ? */
if ((mode != NULL) && (STREQ (mode, "r")))
virBufferAddLit(buf, " <readonly/>\n");
else if ((mode != NULL) && (STREQ (mode, "w!")))
virBufferAddLit(buf, " <shareable/>\n");
virBufferAddLit(buf, " </disk>\n");
return 0;
}
/**
* xend_parse_sexp_desc:
* @conn: the connection associated with the XML
@ -1849,164 +2064,15 @@ xend_parse_sexp_desc(virConnectPtr conn, struct sexpr *root,
if ((tmp != NULL) && (tmp[0] != 0))
virBufferVSprintf(&buf, " <emulator>%s</emulator>\n", tmp);
/* append block devices */
if (xend_parse_sexp_blockdevs (conn, root, xendConfigVersion,
xend_parse_sexp_desc_blockdev, &buf) == -1)
goto error;
/* append network devices and framebuffer */
for (cur = root; cur->kind == SEXPR_CONS; cur = cur->u.s.cdr) {
node = cur->u.s.car;
/* Normally disks are in a (device (vbd ...)) block
but blktap disks ended up in a differently named
(device (tap ....)) block.... */
if (sexpr_lookup(node, "device/vbd") ||
sexpr_lookup(node, "device/tap")) {
char *offset;
int isBlock = 0;
int cdrom = 0;
int isNoSrcCdrom = 0;
char *drvName = NULL;
char *drvType = NULL;
const char *src = NULL;
const char *dst = NULL;
const char *mode = NULL;
const char *bus = NULL;
/* Again dealing with (vbd...) vs (tap ...) differences */
if (sexpr_lookup(node, "device/vbd")) {
src = sexpr_node(node, "device/vbd/uname");
dst = sexpr_node(node, "device/vbd/dev");
mode = sexpr_node(node, "device/vbd/mode");
} else {
src = sexpr_node(node, "device/tap/uname");
dst = sexpr_node(node, "device/tap/dev");
mode = sexpr_node(node, "device/tap/mode");
}
if (dst == NULL) {
virXendError(conn, VIR_ERR_INTERNAL_ERROR,
_("domain information incomplete, vbd has no dev"));
goto bad_parse;
}
if (src == NULL) {
/* There is a case without the uname to the CD-ROM device */
offset = strchr(dst, ':');
if (offset) {
if (hvm && STREQ( offset , ":cdrom")) {
isNoSrcCdrom = 1;
}
offset[0] = '\0';
}
if (!isNoSrcCdrom) {
virXendError(conn, VIR_ERR_INTERNAL_ERROR,
_("domain information incomplete, vbd has no src"));
goto bad_parse;
}
}
if (!isNoSrcCdrom) {
offset = strchr(src, ':');
if (!offset) {
virXendError(conn, VIR_ERR_INTERNAL_ERROR,
_("cannot parse vbd filename, missing driver name"));
goto bad_parse;
}
if (VIR_ALLOC_N(drvName, (offset-src)+1) < 0) {
virXendError(conn, VIR_ERR_NO_MEMORY,
_("allocate new buffer"));
goto bad_parse;
}
strncpy(drvName, src, (offset-src));
drvName[offset-src] = '\0';
src = offset + 1;
if (STREQ(drvName, "tap")) {
offset = strchr(src, ':');
if (!offset) {
virXendError(conn, VIR_ERR_INTERNAL_ERROR,
_("cannot parse vbd filename, missing driver type"));
goto bad_parse;
}
if (VIR_ALLOC_N(drvType, (offset-src)+1)< 0) {
virXendError(conn, VIR_ERR_NO_MEMORY,
_("allocate new buffer"));
goto bad_parse;
}
strncpy(drvType, src, (offset-src));
drvType[offset-src] = '\0';
src = offset + 1;
/* Its possible to use blktap driver for block devs
too, but kinda pointless because blkback is better,
so we assume common case here. If blktap becomes
omnipotent, we can revisit this, perhaps stat()'ing
the src file in question */
isBlock = 0;
} else if (STREQ(drvName, "phy")) {
isBlock = 1;
} else if (STREQ(drvName, "file")) {
isBlock = 0;
}
}
if (STRPREFIX(dst, "ioemu:"))
dst += 6;
/* New style disk config from Xen >= 3.0.3 */
if (xendConfigVersion > 1) {
offset = strrchr(dst, ':');
if (offset) {
if (STREQ(offset, ":cdrom")) {
cdrom = 1;
} else if (STREQ(offset, ":disk")) {
/* The default anyway */
} else {
/* Unknown, lets pretend its a disk too */
}
offset[0] = '\0';
}
}
if (!isNoSrcCdrom) {
virBufferVSprintf(&buf, " <disk type='%s' device='%s'>\n",
isBlock ? "block" : "file",
cdrom ? "cdrom" : "disk");
if (drvType) {
virBufferVSprintf(&buf, " <driver name='%s' type='%s'/>\n", drvName, drvType);
} else {
virBufferVSprintf(&buf, " <driver name='%s'/>\n", drvName);
}
if (isBlock) {
virBufferVSprintf(&buf, " <source dev='%s'/>\n", src);
} else {
virBufferVSprintf(&buf, " <source file='%s'/>\n", src);
}
} else {
/* This case is the cdrom device only */
virBufferAddLit(&buf, " <disk device='cdrom'>\n");
}
if (STRPREFIX(dst, "xvd") || !hvm) {
bus = "xen";
} else if (STRPREFIX(dst, "sd")) {
bus = "scsi";
} else {
bus = "ide";
}
virBufferVSprintf(&buf, " <target dev='%s' bus='%s'/>\n",
dst, bus);
/* XXX should we force mode == r, if cdrom==1, or assume
xend has already done this ? */
if ((mode != NULL) && (STREQ(mode, "r")))
virBufferAddLit(&buf, " <readonly/>\n");
else if ((mode != NULL) && (STREQ(mode, "w!")))
virBufferAddLit(&buf, " <shareable/>\n");
virBufferAddLit(&buf, " </disk>\n");
bad_parse:
VIR_FREE(drvName);
VIR_FREE(drvType);
} else if (sexpr_lookup(node, "device/vif")) {
if (sexpr_lookup(node, "device/vif")) {
const char *tmp2, *model;
tmp2 = sexpr_node(node, "device/vif/script");
tmp = sexpr_node(node, "device/vif/bridge");
@ -4433,5 +4499,110 @@ error:
return (ret);
}
struct check_path_data {
const char *path;
int ok;
};
static int
check_path (virConnectPtr conn ATTRIBUTE_UNUSED, void *vp,
int isBlock ATTRIBUTE_UNUSED,
int cdrom, int isNoSrcCdrom,
int hvm ATTRIBUTE_UNUSED,
const char *drvName ATTRIBUTE_UNUSED,
const char *drvType ATTRIBUTE_UNUSED,
const char *src, const char *dst ATTRIBUTE_UNUSED,
const char *mode ATTRIBUTE_UNUSED)
{
struct check_path_data *data = (struct check_path_data *) vp;
if (!isNoSrcCdrom && !cdrom && src && STREQ (src, data->path))
data->ok = 1;
return 0;
}
/**
* xenDaemonDomainBlockPeek:
* @dom: domain object
* @path: path to the file or device
* @offset: offset
* @size: size
* @buffer: return buffer
*
* Returns 0 if successful, -1 if error, -2 if declined.
*/
int
xenDaemonDomainBlockPeek (virDomainPtr domain, const char *path,
unsigned long long offset, size_t size,
void *buffer)
{
xenUnifiedPrivatePtr priv;
struct sexpr *root;
struct check_path_data data;
int fd, ret = -1;
struct stat statbuf;
priv = (xenUnifiedPrivatePtr) domain->conn->privateData;
if (domain->id < 0 && priv->xendConfigVersion < 3)
return -2; /* Decline, allow XM to handle it. */
/* Security check: The path must correspond to a block device. */
if (domain->id > 0)
root = sexpr_get (domain->conn, "/xend/domain/%d?detail=1",
domain->id);
else if (domain->id < 0)
root = sexpr_get (domain->conn, "/xend/domain/%s?detail=1",
domain->name);
else {
/* This call always fails for dom0. */
virXendError (domain->conn, VIR_ERR_NO_SUPPORT,
_("domainBlockPeek is not supported for dom0"));
return -1;
}
if (!root) {
virXendError (domain->conn, VIR_ERR_XEN_CALL, __FUNCTION__);
return -1;
}
data.path = path;
data.ok = 0;
if (xend_parse_sexp_blockdevs (domain->conn, root,
priv->xendConfigVersion,
check_path, &data) == -1)
return -1;
if (!data.ok) {
virXendError (domain->conn, VIR_ERR_INVALID_ARG,
_("invalid path"));
return -1;
}
/* The path is correct, now try to open it and get its size. */
fd = open (path, O_RDONLY);
if (fd == -1 || fstat (fd, &statbuf) == -1) {
virXendError (domain->conn, VIR_ERR_SYSTEM_ERROR, strerror (errno));
goto done;
}
/* Seek and read. */
/* NB. Because we configure with AC_SYS_LARGEFILE, off_t should
* be 64 bits on all platforms.
*/
if (lseek (fd, offset, SEEK_SET) == (off_t) -1 ||
saferead (fd, buffer, size) == (ssize_t) -1) {
virXendError (domain->conn, VIR_ERR_SYSTEM_ERROR, strerror (errno));
goto done;
}
ret = 0;
done:
if (fd >= 0) close (fd);
return ret;
}
#endif /* ! PROXY */
#endif /* WITH_XEN */

2
src/xend_internal.h
View File

@ -244,6 +244,8 @@ virDomainPtr xenDaemonLookupByName(virConnectPtr conn, const char *domname);
int xenDaemonDomainMigratePrepare (virConnectPtr dconn, char **cookie, int *cookielen, const char *uri_in, char **uri_out, unsigned long flags, const char *dname, unsigned long resource);
int xenDaemonDomainMigratePerform (virDomainPtr domain, const char *cookie, int cookielen, const char *uri, unsigned long flags, const char *dname, unsigned long resource);
int xenDaemonDomainBlockPeek (virDomainPtr domain, const char *path, unsigned long long offset, size_t size, void *buffer);
#ifdef __cplusplus
}
#endif

11
src/xm_internal.c
View File

@ -3241,4 +3241,15 @@ xenXMDomainDetachDevice(virDomainPtr domain, const char *xml) {
return (ret);
}
int
xenXMDomainBlockPeek (virDomainPtr dom,
const char *path ATTRIBUTE_UNUSED,
unsigned long long offset ATTRIBUTE_UNUSED,
size_t size ATTRIBUTE_UNUSED,
void *buffer ATTRIBUTE_UNUSED)
{
xenXMError (dom->conn, VIR_ERR_NO_SUPPORT, __FUNCTION__);
return -1;
}
#endif /* WITH_XEN */

1
src/xm_internal.h
View File

@ -60,6 +60,7 @@ int xenXMDomainUndefine(virDomainPtr domain);
virConfPtr xenXMParseXMLToConfig(virConnectPtr conn, const char *xml);
char *xenXMDomainFormatXML(virConnectPtr conn, virConfPtr conf);
int xenXMDomainBlockPeek (virDomainPtr dom, const char *path, unsigned long long offset, size_t size, void *buffer);
#ifdef __cplusplus
}

10
tests/sexpr2xmldata/sexpr2xml-curmem.xml
View File

@ -15,17 +15,17 @@
<on_reboot>restart</on_reboot>
<on_crash>restart</on_crash>
<devices>
<disk type='file' device='disk'>
<driver name='tap' type='aio'/>
<source file='/xen/rhel5.img'/>
<target dev='xvda' bus='xen'/>
</disk>
<interface type='bridge'>
<source bridge='xenbr0'/>
<target dev='vif5.0'/>
<mac address='00:16:3e:1d:06:15'/>
<script path='vif-bridge'/>
</interface>
<disk type='file' device='disk'>
<driver name='tap' type='aio'/>
<source file='/xen/rhel5.img'/>
<target dev='xvda' bus='xen'/>
</disk>
<input type='mouse' bus='xen'/>
<graphics type='vnc' port='-1'/>
<console type='pty'>

10
tests/sexpr2xmldata/sexpr2xml-no-source-cdrom.xml
View File

@ -20,11 +20,6 @@
<clock offset='utc'/>
<devices>
<emulator>/usr/lib/xen/bin/qemu-dm</emulator>
<interface type='bridge'>
<source bridge='xenbr0'/>
<target dev='vif6.0'/>
<mac address='00:16:3e:0a:7b:39'/>
</interface>
<disk type='block' device='disk'>
<driver name='phy'/>
<source dev='/dev/sda8'/>
@ -34,6 +29,11 @@
<target dev='hdc' bus='ide'/>
<readonly/>
</disk>
<interface type='bridge'>
<source bridge='xenbr0'/>
<target dev='vif6.0'/>
<mac address='00:16:3e:0a:7b:39'/>
</interface>
<input type='mouse' bus='ps2'/>
<graphics type='vnc' port='-1'/>
<serial type='pty'>