* 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.
+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()
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])
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.
</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>
<td> ≥ 0.2.0 </td>
<td> ≥ 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>
<td> x </td>
<td> ≥ 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>
</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>
<td> ≥ 0.2.0 </td>
<td> ≥ 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>
<td> x </td>
<td> ≥ 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>
* 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;
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 */
};
/**
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 */
};
* 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;
/**
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 */
};
/*
* 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);
#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);
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
VIR_DOMAIN_XML_INACTIVE = 2/* dump inactive domain information */
} virDomainXMLFlags;
-char * virDomainGetXMLDesc (virDomainPtr domain,
+char * virDomainGetXMLDesc (virDomainPtr domain,
int flags);
int virDomainBlockStats (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);
/**
*/
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);
* 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:
* 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:
#define VIR_CPU_MAPLEN(cpu) (((cpu)+7)/8)
-int virDomainGetVcpus (virDomainPtr domain,
+int virDomainGetVcpus (virDomainPtr domain,
virVcpuInfoPtr info,
int maxinfo,
unsigned char *cpumaps,
* @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
* 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);
* NUMA support
*/
-int virNodeGetCellsFreeMemory(virConnectPtr conn,
+int virNodeGetCellsFreeMemory(virConnectPtr conn,
unsigned long long *freeMems,
int startCell,
int maxCells);
/*
* 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);
/*
* 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
}
* 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;
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 */
};
/**
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 */
};
* 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;
/**
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 */
};
/*
* 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);
#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);
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
VIR_DOMAIN_XML_INACTIVE = 2/* dump inactive domain information */
} virDomainXMLFlags;
-char * virDomainGetXMLDesc (virDomainPtr domain,
+char * virDomainGetXMLDesc (virDomainPtr domain,
int flags);
int virDomainBlockStats (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);
/**
*/
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);
* 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:
* 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:
#define VIR_CPU_MAPLEN(cpu) (((cpu)+7)/8)
-int virDomainGetVcpus (virDomainPtr domain,
+int virDomainGetVcpus (virDomainPtr domain,
virVcpuInfoPtr info,
int maxinfo,
unsigned char *cpumaps,
* @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
* 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);
* NUMA support
*/
-int virNodeGetCellsFreeMemory(virConnectPtr conn,
+int virNodeGetCellsFreeMemory(virConnectPtr conn,
unsigned long long *freeMems,
int startCell,
int maxCells);
/*
* 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);
/*
* 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
}
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,
virDrvDomainMigrateFinish domainMigrateFinish;
virDrvDomainBlockStats domainBlockStats;
virDrvDomainInterfaceStats domainInterfaceStats;
+ virDrvDomainBlockPeek domainBlockPeek;
virDrvNodeGetCellsFreeMemory nodeGetCellsFreeMemory;
virDrvNodeGetFreeMemory getFreeMemory;
};
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;
+}
/************************************************************************
virDomainSetSchedulerParameters;
virDomainBlockStats;
virDomainInterfaceStats;
+ virDomainBlockPeek;
virDomainAttachDevice;
virDomainDetachDevice;
NULL, /* domainMigrateFinish */
qemudDomainBlockStats, /* domainBlockStats */
qemudDomainInterfaceStats, /* domainInterfaceStats */
+ NULL, /* domainBlockPeek */
#if HAVE_NUMACTL
qemudNodeGetCellsFreeMemory, /* nodeGetCellsFreeMemory */
qemudNodeGetFreeMemory, /* getFreeMemory */
NULL, /* domainMigrateFinish */
NULL, /* domainBlockStats */
NULL, /* domainInterfaceStats */
+ NULL, /* domainBlockPeek */
testNodeGetCellsFreeMemory, /* nodeGetCellsFreeMemory */
NULL, /* getFreeMemory */
};
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)
.domainMigrateFinish = xenUnifiedDomainMigrateFinish,
.domainBlockStats = xenUnifiedDomainBlockStats,
.domainInterfaceStats = xenUnifiedDomainInterfaceStats,
+ .domainBlockPeek = xenUnifiedDomainBlockPeek,
.nodeGetCellsFreeMemory = xenUnifiedNodeGetCellsFreeMemory,
.getFreeMemory = xenUnifiedNodeGetFreeMemory,
};
#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>
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
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");
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 */
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
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 */
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
}
<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'>
<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'/>
<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'>
projects / thirdparty / libvirt.git / commitdiff
