#define VIR_FROM_THIS VIR_FROM_QEMU
int
-networkAddEbtablesRules(struct qemud_driver *driver) {
+networkAddEbtablesRules(virQEMUDriverPtr driver) {
int err;
/* Set forward policy to DROP */
int
-networkDisableAllFrames(struct qemud_driver *driver) {
+networkDisableAllFrames(virQEMUDriverPtr driver) {
int err;
/* add default rules */
}
int
-networkAllowMacOnPort(struct qemud_driver *driver,
+networkAllowMacOnPort(virQEMUDriverPtr driver,
const char * ifname,
const virMacAddrPtr mac) {
int
-networkDisallowMacOnPort(struct qemud_driver *driver,
+networkDisallowMacOnPort(virQEMUDriverPtr driver,
const char * ifname,
const virMacAddrPtr mac) {
# define __QEMUD_BRIDGE_FILTER_H__
-int networkAllowMacOnPort(struct qemud_driver *driver,
+int networkAllowMacOnPort(virQEMUDriverPtr driver,
const char * ifname,
const virMacAddrPtr mac);
-int networkDisallowMacOnPort(struct qemud_driver *driver,
+int networkDisallowMacOnPort(virQEMUDriverPtr driver,
const char * ifname,
const virMacAddrPtr mac);
-int networkDisableAllFrames(struct qemud_driver *driver);
-int networkAddEbtablesRules(struct qemud_driver *driver);
+int networkDisableAllFrames(virQEMUDriverPtr driver);
+int networkAddEbtablesRules(virQEMUDriverPtr driver);
#endif /* __QEMUD_BRIDGE_FILTER_H__ */
#define DEVICE_PTY_MAJOR 136
#define DEVICE_SND_MAJOR 116
-bool qemuCgroupControllerActive(struct qemud_driver *driver,
+bool qemuCgroupControllerActive(virQEMUDriverPtr driver,
int controller)
{
if (driver->cgroup == NULL)
return 0;
}
-int qemuSetupCgroup(struct qemud_driver *driver,
+int qemuSetupCgroup(virQEMUDriverPtr driver,
virDomainObjPtr vm,
virBitmapPtr nodemask)
{
return rc;
}
-int qemuSetupCgroupForVcpu(struct qemud_driver *driver, virDomainObjPtr vm)
+int qemuSetupCgroupForVcpu(virQEMUDriverPtr driver, virDomainObjPtr vm)
{
virCgroupPtr cgroup = NULL;
virCgroupPtr cgroup_vcpu = NULL;
return -1;
}
-int qemuSetupCgroupForEmulator(struct qemud_driver *driver,
+int qemuSetupCgroupForEmulator(virQEMUDriverPtr driver,
virDomainObjPtr vm,
virBitmapPtr nodemask)
{
return rc;
}
-int qemuRemoveCgroup(struct qemud_driver *driver,
+int qemuRemoveCgroup(virQEMUDriverPtr driver,
virDomainObjPtr vm,
int quiet)
{
return rc;
}
-int qemuAddToCgroup(struct qemud_driver *driver,
+int qemuAddToCgroup(virQEMUDriverPtr driver,
virDomainDefPtr def)
{
virCgroupPtr cgroup = NULL;
};
typedef struct _qemuCgroupData qemuCgroupData;
-bool qemuCgroupControllerActive(struct qemud_driver *driver,
+bool qemuCgroupControllerActive(virQEMUDriverPtr driver,
int controller);
int qemuSetupDiskCgroup(virDomainObjPtr vm,
virCgroupPtr cgroup,
int qemuSetupHostUsbDeviceCgroup(usbDevice *dev,
const char *path,
void *opaque);
-int qemuSetupCgroup(struct qemud_driver *driver,
+int qemuSetupCgroup(virQEMUDriverPtr driver,
virDomainObjPtr vm,
virBitmapPtr nodemask);
int qemuSetupCgroupVcpuBW(virCgroupPtr cgroup,
int nvcpupin,
int vcpuid);
int qemuSetupCgroupEmulatorPin(virCgroupPtr cgroup, virBitmapPtr cpumask);
-int qemuSetupCgroupForVcpu(struct qemud_driver *driver, virDomainObjPtr vm);
-int qemuSetupCgroupForEmulator(struct qemud_driver *driver,
+int qemuSetupCgroupForVcpu(virQEMUDriverPtr driver, virDomainObjPtr vm);
+int qemuSetupCgroupForEmulator(virQEMUDriverPtr driver,
virDomainObjPtr vm,
virBitmapPtr nodemask);
-int qemuRemoveCgroup(struct qemud_driver *driver,
+int qemuRemoveCgroup(virQEMUDriverPtr driver,
virDomainObjPtr vm,
int quiet);
-int qemuAddToCgroup(struct qemud_driver *driver,
+int qemuAddToCgroup(virQEMUDriverPtr driver,
virDomainDefPtr def);
#endif /* __QEMU_CGROUP_H__ */
/**
* qemuPhysIfaceConnect:
* @def: the definition of the VM (needed by 802.1Qbh and audit)
- * @driver: pointer to the qemud_driver
+ * @driver: pointer to the driver instance
* @net: pointer to he VM's interface description with direct device type
* @qemuCaps: flags for qemu
* @vmop: VM operation type
*/
int
qemuPhysIfaceConnect(virDomainDefPtr def,
- struct qemud_driver *driver,
+ virQEMUDriverPtr driver,
virDomainNetDefPtr net,
qemuCapsPtr caps,
enum virNetDevVPortProfileOp vmop)
int
qemuNetworkIfaceConnect(virDomainDefPtr def,
virConnectPtr conn,
- struct qemud_driver *driver,
+ virQEMUDriverPtr driver,
virDomainNetDefPtr net,
qemuCapsPtr caps)
{
char *
qemuBuildHostNetStr(virDomainNetDefPtr net,
- struct qemud_driver *driver,
+ virQEMUDriverPtr driver,
qemuCapsPtr caps,
char type_sep,
int vlan,
static int
-qemuBuildCpuArgStr(const struct qemud_driver *driver,
+qemuBuildCpuArgStr(const virQEMUDriverPtr driver,
const virDomainDefPtr def,
const char *emulator,
qemuCapsPtr caps,
}
static int
-qemuBuildGraphicsCommandLine(struct qemud_driver *driver,
+qemuBuildGraphicsCommandLine(virQEMUDriverPtr driver,
virCommandPtr cmd,
virDomainDefPtr def,
qemuCapsPtr caps,
*/
virCommandPtr
qemuBuildCommandLine(virConnectPtr conn,
- struct qemud_driver *driver,
+ virQEMUDriverPtr driver,
virDomainDefPtr def,
virDomainChrSourceDefPtr monitor_chr,
bool monitor_json,
virCommandPtr qemuBuildCommandLine(virConnectPtr conn,
- struct qemud_driver *driver,
+ virQEMUDriverPtr driver,
virDomainDefPtr def,
virDomainChrSourceDefPtr monitor_chr,
bool monitor_json,
/* With vlan == -1, use netdev syntax, else old hostnet */
char * qemuBuildHostNetStr(virDomainNetDefPtr net,
- struct qemud_driver *driver,
+ virQEMUDriverPtr driver,
qemuCapsPtr caps,
char type_sep,
int vlan,
int qemuNetworkIfaceConnect(virDomainDefPtr def,
virConnectPtr conn,
- struct qemud_driver *driver,
+ virQEMUDriverPtr driver,
virDomainNetDefPtr net,
qemuCapsPtr caps)
ATTRIBUTE_NONNULL(2);
int qemuPhysIfaceConnect(virDomainDefPtr def,
- struct qemud_driver *driver,
+ virQEMUDriverPtr driver,
virDomainNetDefPtr net,
qemuCapsPtr caps,
enum virNetDevVPortProfileOp vmop);
qemuDriverCloseCallback cb;
};
-void qemuDriverLock(struct qemud_driver *driver)
+void qemuDriverLock(virQEMUDriverPtr driver)
{
virMutexLock(&driver->lock);
}
-void qemuDriverUnlock(struct qemud_driver *driver)
+void qemuDriverUnlock(virQEMUDriverPtr driver)
{
virMutexUnlock(&driver->lock);
}
-int qemuLoadDriverConfig(struct qemud_driver *driver,
+int qemuLoadDriverConfig(virQEMUDriverPtr driver,
const char *filename) {
virConfPtr conf;
virConfValuePtr p;
}
int
-qemuDriverCloseCallbackInit(struct qemud_driver *driver)
+qemuDriverCloseCallbackInit(virQEMUDriverPtr driver)
{
driver->closeCallbacks = virHashCreate(5, qemuDriverCloseCallbackFree);
if (!driver->closeCallbacks)
}
void
-qemuDriverCloseCallbackShutdown(struct qemud_driver *driver)
+qemuDriverCloseCallbackShutdown(virQEMUDriverPtr driver)
{
virHashFree(driver->closeCallbacks);
}
int
-qemuDriverCloseCallbackSet(struct qemud_driver *driver,
+qemuDriverCloseCallbackSet(virQEMUDriverPtr driver,
virDomainObjPtr vm,
virConnectPtr conn,
qemuDriverCloseCallback cb)
}
int
-qemuDriverCloseCallbackUnset(struct qemud_driver *driver,
+qemuDriverCloseCallbackUnset(virQEMUDriverPtr driver,
virDomainObjPtr vm,
qemuDriverCloseCallback cb)
{
}
qemuDriverCloseCallback
-qemuDriverCloseCallbackGet(struct qemud_driver *driver,
+qemuDriverCloseCallbackGet(virQEMUDriverPtr driver,
virDomainObjPtr vm,
virConnectPtr conn)
{
}
struct qemuDriverCloseCallbackData {
- struct qemud_driver *driver;
+ virQEMUDriverPtr driver;
virConnectPtr conn;
};
}
void
-qemuDriverCloseCallbackRunAll(struct qemud_driver *driver,
+qemuDriverCloseCallbackRunAll(virQEMUDriverPtr driver,
virConnectPtr conn)
{
struct qemuDriverCloseCallbackData data = {
typedef struct _qemuDriverCloseDef qemuDriverCloseDef;
typedef qemuDriverCloseDef *qemuDriverCloseDefPtr;
+typedef struct _virQEMUDriver virQEMUDriver;
+typedef virQEMUDriver *virQEMUDriverPtr;
+
/* Main driver state */
-struct qemud_driver {
+struct _virQEMUDriver {
virMutex lock;
virThreadPoolPtr workerPool;
# define QEMUD_MIGRATION_NUM_PORTS 64
-void qemuDriverLock(struct qemud_driver *driver);
-void qemuDriverUnlock(struct qemud_driver *driver);
-int qemuLoadDriverConfig(struct qemud_driver *driver,
+void qemuDriverLock(virQEMUDriverPtr driver);
+void qemuDriverUnlock(virQEMUDriverPtr driver);
+int qemuLoadDriverConfig(virQEMUDriverPtr driver,
const char *filename);
struct qemuDomainDiskInfo {
int io_status;
};
-typedef virDomainObjPtr (*qemuDriverCloseCallback)(struct qemud_driver *driver,
+typedef virDomainObjPtr (*qemuDriverCloseCallback)(virQEMUDriverPtr driver,
virDomainObjPtr vm,
virConnectPtr conn);
-int qemuDriverCloseCallbackInit(struct qemud_driver *driver);
-void qemuDriverCloseCallbackShutdown(struct qemud_driver *driver);
-int qemuDriverCloseCallbackSet(struct qemud_driver *driver,
+int qemuDriverCloseCallbackInit(virQEMUDriverPtr driver);
+void qemuDriverCloseCallbackShutdown(virQEMUDriverPtr driver);
+int qemuDriverCloseCallbackSet(virQEMUDriverPtr driver,
virDomainObjPtr vm,
virConnectPtr conn,
qemuDriverCloseCallback cb);
-int qemuDriverCloseCallbackUnset(struct qemud_driver *driver,
+int qemuDriverCloseCallbackUnset(virQEMUDriverPtr driver,
virDomainObjPtr vm,
qemuDriverCloseCallback cb);
-qemuDriverCloseCallback qemuDriverCloseCallbackGet(struct qemud_driver *driver,
+qemuDriverCloseCallback qemuDriverCloseCallbackGet(virQEMUDriverPtr driver,
virDomainObjPtr vm,
virConnectPtr conn);
-void qemuDriverCloseCallbackRunAll(struct qemud_driver *driver,
+void qemuDriverCloseCallbackRunAll(virQEMUDriverPtr driver,
virConnectPtr conn);
#endif /* __QEMUD_CONF_H */
/* driver must be locked before calling */
-void qemuDomainEventQueue(struct qemud_driver *driver,
+void qemuDomainEventQueue(virQEMUDriverPtr driver,
virDomainEventPtr event)
{
virDomainEventStateQueue(driver->domainEventState, event);
}
static void
-qemuDomainObjSaveJob(struct qemud_driver *driver, virDomainObjPtr obj)
+qemuDomainObjSaveJob(virQEMUDriverPtr driver, virDomainObjPtr obj)
{
if (!virDomainObjIsActive(obj)) {
/* don't write the state file yet, it will be written once the domain
}
void
-qemuDomainObjSetJobPhase(struct qemud_driver *driver,
+qemuDomainObjSetJobPhase(virQEMUDriverPtr driver,
virDomainObjPtr obj,
int phase)
{
}
void
-qemuDomainObjDiscardAsyncJob(struct qemud_driver *driver, virDomainObjPtr obj)
+qemuDomainObjDiscardAsyncJob(virQEMUDriverPtr driver, virDomainObjPtr obj)
{
qemuDomainObjPrivatePtr priv = obj->privateData;
* locked or not.
*/
static int ATTRIBUTE_NONNULL(1)
-qemuDomainObjBeginJobInternal(struct qemud_driver *driver,
+qemuDomainObjBeginJobInternal(virQEMUDriverPtr driver,
bool driver_locked,
virDomainObjPtr obj,
enum qemuDomainJob job,
}
/*
- * obj must be locked before calling, qemud_driver must NOT be locked
+ * obj must be locked before calling, driver must NOT be locked
*
* This must be called by anything that will change the VM state
* in any way, or anything that will use the QEMU monitor.
* Upon successful return, the object will have its ref count increased,
* successful calls must be followed by EndJob eventually
*/
-int qemuDomainObjBeginJob(struct qemud_driver *driver,
+int qemuDomainObjBeginJob(virQEMUDriverPtr driver,
virDomainObjPtr obj,
enum qemuDomainJob job)
{
QEMU_ASYNC_JOB_NONE);
}
-int qemuDomainObjBeginAsyncJob(struct qemud_driver *driver,
+int qemuDomainObjBeginAsyncJob(virQEMUDriverPtr driver,
virDomainObjPtr obj,
enum qemuDomainAsyncJob asyncJob)
{
}
/*
- * obj and qemud_driver must be locked before calling.
+ * obj and driver must be locked before calling.
*
* This must be called by anything that will change the VM state
* in any way, or anything that will use the QEMU monitor.
* Upon successful return, the object will have its ref count increased,
* successful calls must be followed by EndJob eventually
*/
-int qemuDomainObjBeginJobWithDriver(struct qemud_driver *driver,
+int qemuDomainObjBeginJobWithDriver(virQEMUDriverPtr driver,
virDomainObjPtr obj,
enum qemuDomainJob job)
{
QEMU_ASYNC_JOB_NONE);
}
-int qemuDomainObjBeginAsyncJobWithDriver(struct qemud_driver *driver,
+int qemuDomainObjBeginAsyncJobWithDriver(virQEMUDriverPtr driver,
virDomainObjPtr obj,
enum qemuDomainAsyncJob asyncJob)
{
}
/*
- * obj must be locked before calling, qemud_driver does not matter
+ * obj must be locked before calling, driver does not matter
*
* To be called after completing the work associated with the
* earlier qemuDomainBeginJob() call
* Returns true if @obj was still referenced, false if it was
* disposed of.
*/
-bool qemuDomainObjEndJob(struct qemud_driver *driver, virDomainObjPtr obj)
+bool qemuDomainObjEndJob(virQEMUDriverPtr driver, virDomainObjPtr obj)
{
qemuDomainObjPrivatePtr priv = obj->privateData;
enum qemuDomainJob job = priv->job.active;
}
bool
-qemuDomainObjEndAsyncJob(struct qemud_driver *driver, virDomainObjPtr obj)
+qemuDomainObjEndAsyncJob(virQEMUDriverPtr driver, virDomainObjPtr obj)
{
qemuDomainObjPrivatePtr priv = obj->privateData;
}
static int
-qemuDomainObjEnterMonitorInternal(struct qemud_driver *driver,
+qemuDomainObjEnterMonitorInternal(virQEMUDriverPtr driver,
bool driver_locked,
virDomainObjPtr obj,
enum qemuDomainAsyncJob asyncJob)
}
static void ATTRIBUTE_NONNULL(1)
-qemuDomainObjExitMonitorInternal(struct qemud_driver *driver,
+qemuDomainObjExitMonitorInternal(virQEMUDriverPtr driver,
bool driver_locked,
virDomainObjPtr obj)
{
}
/*
- * obj must be locked before calling, qemud_driver must be unlocked
+ * obj must be locked before calling, driver must be unlocked
*
* To be called immediately before any QEMU monitor API call
* Must have already either called qemuDomainObjBeginJob() and checked
*
* To be followed with qemuDomainObjExitMonitor() once complete
*/
-void qemuDomainObjEnterMonitor(struct qemud_driver *driver,
+void qemuDomainObjEnterMonitor(virQEMUDriverPtr driver,
virDomainObjPtr obj)
{
ignore_value(qemuDomainObjEnterMonitorInternal(driver, false, obj,
QEMU_ASYNC_JOB_NONE));
}
-/* obj must NOT be locked before calling, qemud_driver must be unlocked
+/* obj must NOT be locked before calling, driver must be unlocked
*
* Should be paired with an earlier qemuDomainObjEnterMonitor() call
*/
-void qemuDomainObjExitMonitor(struct qemud_driver *driver,
+void qemuDomainObjExitMonitor(virQEMUDriverPtr driver,
virDomainObjPtr obj)
{
qemuDomainObjExitMonitorInternal(driver, false, obj);
}
/*
- * obj must be locked before calling, qemud_driver must be locked
+ * obj must be locked before calling, driver must be locked
*
* To be called immediately before any QEMU monitor API call
* Must have already either called qemuDomainObjBeginJobWithDriver() and
*
* To be followed with qemuDomainObjExitMonitorWithDriver() once complete
*/
-void qemuDomainObjEnterMonitorWithDriver(struct qemud_driver *driver,
+void qemuDomainObjEnterMonitorWithDriver(virQEMUDriverPtr driver,
virDomainObjPtr obj)
{
ignore_value(qemuDomainObjEnterMonitorInternal(driver, true, obj,
}
/*
- * obj and qemud_driver must be locked before calling
+ * obj and driver must be locked before calling
*
* To be called immediately before any QEMU monitor API call.
* Must have already either called qemuDomainObjBeginJobWithDriver()
* started (probably because the vm exited in the meantime).
*/
int
-qemuDomainObjEnterMonitorAsync(struct qemud_driver *driver,
+qemuDomainObjEnterMonitorAsync(virQEMUDriverPtr driver,
virDomainObjPtr obj,
enum qemuDomainAsyncJob asyncJob)
{
return qemuDomainObjEnterMonitorInternal(driver, true, obj, asyncJob);
}
-/* obj must NOT be locked before calling, qemud_driver must be unlocked,
+/* obj must NOT be locked before calling, driver must be unlocked,
* and will be locked after returning
*
* Should be paired with an earlier qemuDomainObjEnterMonitorWithDriver() call
*/
-void qemuDomainObjExitMonitorWithDriver(struct qemud_driver *driver,
+void qemuDomainObjExitMonitorWithDriver(virQEMUDriverPtr driver,
virDomainObjPtr obj)
{
qemuDomainObjExitMonitorInternal(driver, true, obj);
static int
-qemuDomainObjEnterAgentInternal(struct qemud_driver *driver,
+qemuDomainObjEnterAgentInternal(virQEMUDriverPtr driver,
bool driver_locked,
virDomainObjPtr obj)
{
}
static void ATTRIBUTE_NONNULL(1)
-qemuDomainObjExitAgentInternal(struct qemud_driver *driver,
+qemuDomainObjExitAgentInternal(virQEMUDriverPtr driver,
bool driver_locked,
virDomainObjPtr obj)
{
}
/*
- * obj must be locked before calling, qemud_driver must be unlocked
+ * obj must be locked before calling, driver must be unlocked
*
* To be called immediately before any QEMU agent API call.
* Must have already called qemuDomainObjBeginJob() and checked
*
* To be followed with qemuDomainObjExitAgent() once complete
*/
-void qemuDomainObjEnterAgent(struct qemud_driver *driver,
+void qemuDomainObjEnterAgent(virQEMUDriverPtr driver,
virDomainObjPtr obj)
{
ignore_value(qemuDomainObjEnterAgentInternal(driver, false, obj));
}
-/* obj must NOT be locked before calling, qemud_driver must be unlocked
+/* obj must NOT be locked before calling, driver must be unlocked
*
* Should be paired with an earlier qemuDomainObjEnterAgent() call
*/
-void qemuDomainObjExitAgent(struct qemud_driver *driver,
+void qemuDomainObjExitAgent(virQEMUDriverPtr driver,
virDomainObjPtr obj)
{
qemuDomainObjExitAgentInternal(driver, false, obj);
}
/*
- * obj must be locked before calling, qemud_driver must be locked
+ * obj must be locked before calling, driver must be locked
*
* To be called immediately before any QEMU agent API call.
* Must have already called qemuDomainObjBeginJobWithDriver() and
*
* To be followed with qemuDomainObjExitAgentWithDriver() once complete
*/
-void qemuDomainObjEnterAgentWithDriver(struct qemud_driver *driver,
+void qemuDomainObjEnterAgentWithDriver(virQEMUDriverPtr driver,
virDomainObjPtr obj)
{
ignore_value(qemuDomainObjEnterAgentInternal(driver, true, obj));
}
-/* obj must NOT be locked before calling, qemud_driver must be unlocked,
+/* obj must NOT be locked before calling, driver must be unlocked,
* and will be locked after returning
*
* Should be paired with an earlier qemuDomainObjEnterAgentWithDriver() call
*/
-void qemuDomainObjExitAgentWithDriver(struct qemud_driver *driver,
+void qemuDomainObjExitAgentWithDriver(virQEMUDriverPtr driver,
virDomainObjPtr obj)
{
qemuDomainObjExitAgentInternal(driver, true, obj);
}
-void qemuDomainObjEnterRemoteWithDriver(struct qemud_driver *driver,
+void qemuDomainObjEnterRemoteWithDriver(virQEMUDriverPtr driver,
virDomainObjPtr obj)
{
virObjectRef(obj);
qemuDriverUnlock(driver);
}
-void qemuDomainObjExitRemoteWithDriver(struct qemud_driver *driver,
+void qemuDomainObjExitRemoteWithDriver(virQEMUDriverPtr driver,
virDomainObjPtr obj)
{
qemuDriverLock(driver);
int
-qemuDomainDefFormatBuf(struct qemud_driver *driver,
+qemuDomainDefFormatBuf(virQEMUDriverPtr driver,
virDomainDefPtr def,
unsigned int flags,
virBuffer *buf)
return ret;
}
-char *qemuDomainDefFormatXML(struct qemud_driver *driver,
+char *qemuDomainDefFormatXML(virQEMUDriverPtr driver,
virDomainDefPtr def,
unsigned int flags)
{
return virBufferContentAndReset(&buf);
}
-char *qemuDomainFormatXML(struct qemud_driver *driver,
+char *qemuDomainFormatXML(virQEMUDriverPtr driver,
virDomainObjPtr vm,
unsigned int flags)
{
}
char *
-qemuDomainDefFormatLive(struct qemud_driver *driver,
+qemuDomainDefFormatLive(virQEMUDriverPtr driver,
virDomainDefPtr def,
bool inactive,
bool compatible)
}
-void qemuDomainObjTaint(struct qemud_driver *driver,
+void qemuDomainObjTaint(virQEMUDriverPtr driver,
virDomainObjPtr obj,
enum virDomainTaintFlags taint,
int logFD)
}
-void qemuDomainObjCheckTaint(struct qemud_driver *driver,
+void qemuDomainObjCheckTaint(virQEMUDriverPtr driver,
virDomainObjPtr obj,
int logFD)
{
}
-void qemuDomainObjCheckDiskTaint(struct qemud_driver *driver,
+void qemuDomainObjCheckDiskTaint(virQEMUDriverPtr driver,
virDomainObjPtr obj,
virDomainDiskDefPtr disk,
int logFD)
}
-void qemuDomainObjCheckNetTaint(struct qemud_driver *driver,
+void qemuDomainObjCheckNetTaint(virQEMUDriverPtr driver,
virDomainObjPtr obj,
virDomainNetDefPtr net,
int logFD)
static int
-qemuDomainOpenLogHelper(struct qemud_driver *driver,
+qemuDomainOpenLogHelper(virQEMUDriverPtr driver,
virDomainObjPtr vm,
int oflags,
mode_t mode)
int
-qemuDomainCreateLog(struct qemud_driver *driver, virDomainObjPtr vm,
+qemuDomainCreateLog(virQEMUDriverPtr driver, virDomainObjPtr vm,
bool append)
{
int oflags;
int
-qemuDomainOpenLog(struct qemud_driver *driver, virDomainObjPtr vm, off_t pos)
+qemuDomainOpenLog(virQEMUDriverPtr driver, virDomainObjPtr vm, off_t pos)
{
int fd;
off_t off;
}
-int qemuDomainAppendLog(struct qemud_driver *driver,
+int qemuDomainAppendLog(virQEMUDriverPtr driver,
virDomainObjPtr obj,
int logFD,
const char *fmt, ...)
/* Locate an appropriate 'qemu-img' binary. */
const char *
-qemuFindQemuImgBinary(struct qemud_driver *driver)
+qemuFindQemuImgBinary(virQEMUDriverPtr driver)
{
if (!driver->qemuImgBinary) {
driver->qemuImgBinary = virFindFileInPath("kvm-img");
/* The domain is expected to be locked and inactive. Return -1 on normal
* failure, 1 if we skipped a disk due to try_all. */
static int
-qemuDomainSnapshotForEachQcow2Raw(struct qemud_driver *driver,
+qemuDomainSnapshotForEachQcow2Raw(virQEMUDriverPtr driver,
virDomainDefPtr def,
const char *name,
const char *op,
/* The domain is expected to be locked and inactive. Return -1 on normal
* failure, 1 if we skipped a disk due to try_all. */
int
-qemuDomainSnapshotForEachQcow2(struct qemud_driver *driver,
+qemuDomainSnapshotForEachQcow2(virQEMUDriverPtr driver,
virDomainObjPtr vm,
virDomainSnapshotObjPtr snap,
const char *op,
/* Discard one snapshot (or its metadata), without reparenting any children. */
int
-qemuDomainSnapshotDiscard(struct qemud_driver *driver,
+qemuDomainSnapshotDiscard(virQEMUDriverPtr driver,
virDomainObjPtr vm,
virDomainSnapshotObjPtr snap,
bool update_current,
}
int
-qemuDomainSnapshotDiscardAllMetadata(struct qemud_driver *driver,
+qemuDomainSnapshotDiscardAllMetadata(virQEMUDriverPtr driver,
virDomainObjPtr vm)
{
struct qemu_snap_remove rem;
* be no remaining references to vm.
*/
void
-qemuDomainRemoveInactive(struct qemud_driver *driver,
+qemuDomainRemoveInactive(virQEMUDriverPtr driver,
virDomainObjPtr vm)
{
char *snapDir;
}
void
-qemuDomainSetFakeReboot(struct qemud_driver *driver,
+qemuDomainSetFakeReboot(virQEMUDriverPtr driver,
virDomainObjPtr vm,
bool value)
{
}
int
-qemuDomainCheckDiskPresence(struct qemud_driver *driver,
+qemuDomainCheckDiskPresence(virQEMUDriverPtr driver,
virDomainObjPtr vm,
bool cold_boot)
{
}
void
-qemuDomainCleanupRun(struct qemud_driver *driver,
+qemuDomainCleanupRun(virQEMUDriverPtr driver,
virDomainObjPtr vm)
{
qemuDomainObjPrivatePtr priv = vm->privateData;
}
int
-qemuDomainDetermineDiskChain(struct qemud_driver *driver,
+qemuDomainDetermineDiskChain(virQEMUDriverPtr driver,
virDomainDiskDefPtr disk,
bool force)
{
typedef struct _qemuDomainPCIAddressSet qemuDomainPCIAddressSet;
typedef qemuDomainPCIAddressSet *qemuDomainPCIAddressSetPtr;
-typedef void (*qemuDomainCleanupCallback)(struct qemud_driver *driver,
+typedef void (*qemuDomainCleanupCallback)(virQEMUDriverPtr driver,
virDomainObjPtr vm);
typedef struct _qemuDomainObjPrivate qemuDomainObjPrivate;
void qemuDomainEventFlush(int timer, void *opaque);
/* driver must be locked before calling */
-void qemuDomainEventQueue(struct qemud_driver *driver,
+void qemuDomainEventQueue(virQEMUDriverPtr driver,
virDomainEventPtr event);
void qemuDomainSetPrivateDataHooks(virCapsPtr caps);
void qemuDomainSetNamespaceHooks(virCapsPtr caps);
-int qemuDomainObjBeginJob(struct qemud_driver *driver,
+int qemuDomainObjBeginJob(virQEMUDriverPtr driver,
virDomainObjPtr obj,
enum qemuDomainJob job)
ATTRIBUTE_RETURN_CHECK;
-int qemuDomainObjBeginAsyncJob(struct qemud_driver *driver,
+int qemuDomainObjBeginAsyncJob(virQEMUDriverPtr driver,
virDomainObjPtr obj,
enum qemuDomainAsyncJob asyncJob)
ATTRIBUTE_RETURN_CHECK;
-int qemuDomainObjBeginJobWithDriver(struct qemud_driver *driver,
+int qemuDomainObjBeginJobWithDriver(virQEMUDriverPtr driver,
virDomainObjPtr obj,
enum qemuDomainJob job)
ATTRIBUTE_RETURN_CHECK;
-int qemuDomainObjBeginAsyncJobWithDriver(struct qemud_driver *driver,
+int qemuDomainObjBeginAsyncJobWithDriver(virQEMUDriverPtr driver,
virDomainObjPtr obj,
enum qemuDomainAsyncJob asyncJob)
ATTRIBUTE_RETURN_CHECK;
-bool qemuDomainObjEndJob(struct qemud_driver *driver,
+bool qemuDomainObjEndJob(virQEMUDriverPtr driver,
virDomainObjPtr obj)
ATTRIBUTE_RETURN_CHECK;
-bool qemuDomainObjEndAsyncJob(struct qemud_driver *driver,
+bool qemuDomainObjEndAsyncJob(virQEMUDriverPtr driver,
virDomainObjPtr obj)
ATTRIBUTE_RETURN_CHECK;
void qemuDomainObjAbortAsyncJob(virDomainObjPtr obj);
-void qemuDomainObjSetJobPhase(struct qemud_driver *driver,
+void qemuDomainObjSetJobPhase(virQEMUDriverPtr driver,
virDomainObjPtr obj,
int phase);
void qemuDomainObjSetAsyncJobMask(virDomainObjPtr obj,
void qemuDomainObjRestoreJob(virDomainObjPtr obj,
struct qemuDomainJobObj *job);
void qemuDomainObjTransferJob(virDomainObjPtr obj);
-void qemuDomainObjDiscardAsyncJob(struct qemud_driver *driver,
+void qemuDomainObjDiscardAsyncJob(virQEMUDriverPtr driver,
virDomainObjPtr obj);
void qemuDomainObjReleaseAsyncJob(virDomainObjPtr obj);
-void qemuDomainObjEnterMonitor(struct qemud_driver *driver,
+void qemuDomainObjEnterMonitor(virQEMUDriverPtr driver,
virDomainObjPtr obj)
ATTRIBUTE_NONNULL(1) ATTRIBUTE_NONNULL(2);
-void qemuDomainObjExitMonitor(struct qemud_driver *driver,
+void qemuDomainObjExitMonitor(virQEMUDriverPtr driver,
virDomainObjPtr obj)
ATTRIBUTE_NONNULL(1) ATTRIBUTE_NONNULL(2);
-void qemuDomainObjEnterMonitorWithDriver(struct qemud_driver *driver,
+void qemuDomainObjEnterMonitorWithDriver(virQEMUDriverPtr driver,
virDomainObjPtr obj)
ATTRIBUTE_NONNULL(1) ATTRIBUTE_NONNULL(2);
-int qemuDomainObjEnterMonitorAsync(struct qemud_driver *driver,
+int qemuDomainObjEnterMonitorAsync(virQEMUDriverPtr driver,
virDomainObjPtr obj,
enum qemuDomainAsyncJob asyncJob)
ATTRIBUTE_NONNULL(1) ATTRIBUTE_NONNULL(2) ATTRIBUTE_RETURN_CHECK;
-void qemuDomainObjExitMonitorWithDriver(struct qemud_driver *driver,
+void qemuDomainObjExitMonitorWithDriver(virQEMUDriverPtr driver,
virDomainObjPtr obj)
ATTRIBUTE_NONNULL(1) ATTRIBUTE_NONNULL(2);
-void qemuDomainObjEnterAgent(struct qemud_driver *driver,
+void qemuDomainObjEnterAgent(virQEMUDriverPtr driver,
virDomainObjPtr obj)
ATTRIBUTE_NONNULL(1) ATTRIBUTE_NONNULL(2);
-void qemuDomainObjExitAgent(struct qemud_driver *driver,
+void qemuDomainObjExitAgent(virQEMUDriverPtr driver,
virDomainObjPtr obj)
ATTRIBUTE_NONNULL(1) ATTRIBUTE_NONNULL(2);
-void qemuDomainObjEnterAgentWithDriver(struct qemud_driver *driver,
+void qemuDomainObjEnterAgentWithDriver(virQEMUDriverPtr driver,
virDomainObjPtr obj)
ATTRIBUTE_NONNULL(1) ATTRIBUTE_NONNULL(2);
-void qemuDomainObjExitAgentWithDriver(struct qemud_driver *driver,
+void qemuDomainObjExitAgentWithDriver(virQEMUDriverPtr driver,
virDomainObjPtr obj)
ATTRIBUTE_NONNULL(1) ATTRIBUTE_NONNULL(2);
-void qemuDomainObjEnterRemoteWithDriver(struct qemud_driver *driver,
+void qemuDomainObjEnterRemoteWithDriver(virQEMUDriverPtr driver,
virDomainObjPtr obj)
ATTRIBUTE_NONNULL(1) ATTRIBUTE_NONNULL(2);
-void qemuDomainObjExitRemoteWithDriver(struct qemud_driver *driver,
+void qemuDomainObjExitRemoteWithDriver(virQEMUDriverPtr driver,
virDomainObjPtr obj)
ATTRIBUTE_NONNULL(1) ATTRIBUTE_NONNULL(2);
-int qemuDomainDefFormatBuf(struct qemud_driver *driver,
+int qemuDomainDefFormatBuf(virQEMUDriverPtr driver,
virDomainDefPtr vm,
unsigned int flags,
virBuffer *buf);
-char *qemuDomainDefFormatXML(struct qemud_driver *driver,
+char *qemuDomainDefFormatXML(virQEMUDriverPtr driver,
virDomainDefPtr vm,
unsigned int flags);
-char *qemuDomainFormatXML(struct qemud_driver *driver,
+char *qemuDomainFormatXML(virQEMUDriverPtr driver,
virDomainObjPtr vm,
unsigned int flags);
-char *qemuDomainDefFormatLive(struct qemud_driver *driver,
+char *qemuDomainDefFormatLive(virQEMUDriverPtr driver,
virDomainDefPtr def,
bool inactive,
bool compatible);
-void qemuDomainObjTaint(struct qemud_driver *driver,
+void qemuDomainObjTaint(virQEMUDriverPtr driver,
virDomainObjPtr obj,
enum virDomainTaintFlags taint,
int logFD);
-void qemuDomainObjCheckTaint(struct qemud_driver *driver,
+void qemuDomainObjCheckTaint(virQEMUDriverPtr driver,
virDomainObjPtr obj,
int logFD);
-void qemuDomainObjCheckDiskTaint(struct qemud_driver *driver,
+void qemuDomainObjCheckDiskTaint(virQEMUDriverPtr driver,
virDomainObjPtr obj,
virDomainDiskDefPtr disk,
int logFD);
-void qemuDomainObjCheckNetTaint(struct qemud_driver *driver,
+void qemuDomainObjCheckNetTaint(virQEMUDriverPtr driver,
virDomainObjPtr obj,
virDomainNetDefPtr net,
int logFD);
-int qemuDomainCreateLog(struct qemud_driver *driver, virDomainObjPtr vm, bool append);
-int qemuDomainOpenLog(struct qemud_driver *driver, virDomainObjPtr vm, off_t pos);
-int qemuDomainAppendLog(struct qemud_driver *driver,
+int qemuDomainCreateLog(virQEMUDriverPtr driver, virDomainObjPtr vm, bool append);
+int qemuDomainOpenLog(virQEMUDriverPtr driver, virDomainObjPtr vm, off_t pos);
+int qemuDomainAppendLog(virQEMUDriverPtr driver,
virDomainObjPtr vm,
int logFD,
const char *fmt, ...) ATTRIBUTE_FMT_PRINTF(4, 5);
-const char *qemuFindQemuImgBinary(struct qemud_driver *driver);
+const char *qemuFindQemuImgBinary(virQEMUDriverPtr driver);
int qemuDomainSnapshotWriteMetadata(virDomainObjPtr vm,
virDomainSnapshotObjPtr snapshot,
char *snapshotDir);
-int qemuDomainSnapshotForEachQcow2(struct qemud_driver *driver,
+int qemuDomainSnapshotForEachQcow2(virQEMUDriverPtr driver,
virDomainObjPtr vm,
virDomainSnapshotObjPtr snap,
const char *op,
bool try_all);
-int qemuDomainSnapshotDiscard(struct qemud_driver *driver,
+int qemuDomainSnapshotDiscard(virQEMUDriverPtr driver,
virDomainObjPtr vm,
virDomainSnapshotObjPtr snap,
bool update_current,
bool metadata_only);
struct qemu_snap_remove {
- struct qemud_driver *driver;
+ virQEMUDriverPtr driver;
virDomainObjPtr vm;
int err;
bool metadata_only;
const void *name,
void *data);
-int qemuDomainSnapshotDiscardAllMetadata(struct qemud_driver *driver,
+int qemuDomainSnapshotDiscardAllMetadata(virQEMUDriverPtr driver,
virDomainObjPtr vm);
-void qemuDomainRemoveInactive(struct qemud_driver *driver,
+void qemuDomainRemoveInactive(virQEMUDriverPtr driver,
virDomainObjPtr vm);
-void qemuDomainSetFakeReboot(struct qemud_driver *driver,
+void qemuDomainSetFakeReboot(virQEMUDriverPtr driver,
virDomainObjPtr vm,
bool value);
bool qemuDomainJobAllowed(qemuDomainObjPrivatePtr priv,
enum qemuDomainJob job);
-int qemuDomainCheckDiskPresence(struct qemud_driver *driver,
+int qemuDomainCheckDiskPresence(virQEMUDriverPtr driver,
virDomainObjPtr vm,
bool start_with_state);
-int qemuDomainDetermineDiskChain(struct qemud_driver *driver,
+int qemuDomainDetermineDiskChain(virQEMUDriverPtr driver,
virDomainDiskDefPtr disk,
bool force);
qemuDomainCleanupCallback cb);
void qemuDomainCleanupRemove(virDomainObjPtr vm,
qemuDomainCleanupCallback cb);
-void qemuDomainCleanupRun(struct qemud_driver *driver,
+void qemuDomainCleanupRun(virQEMUDriverPtr driver,
virDomainObjPtr vm);
#endif /* __QEMU_DOMAIN_H__ */
static int qemuShutdown(void);
static int qemuDomainObjStart(virConnectPtr conn,
- struct qemud_driver *driver,
+ virQEMUDriverPtr driver,
virDomainObjPtr vm,
unsigned int flags);
void *opaque);
-struct qemud_driver *qemu_driver = NULL;
+virQEMUDriverPtr qemu_driver = NULL;
static void
struct qemuAutostartData {
- struct qemud_driver *driver;
+ virQEMUDriverPtr driver;
virConnectPtr conn;
};
static virDomainObjPtr
qemuDomObjFromDomain(virDomainPtr domain)
{
- struct qemud_driver *driver = domain->conn->privateData;
+ virQEMUDriverPtr driver = domain->conn->privateData;
virDomainObjPtr vm;
char uuidstr[VIR_UUID_STRING_BUFLEN];
static void
-qemuAutostartDomains(struct qemud_driver *driver)
+qemuAutostartDomains(virQEMUDriverPtr driver)
{
/* XXX: Figure out a better way todo this. The domain
* startup code needs a connection handle in order
}
static int
-qemuSecurityInit(struct qemud_driver *driver)
+qemuSecurityInit(virQEMUDriverPtr driver)
{
char **names;
virSecurityManagerPtr mgr = NULL;
static virCapsPtr
-qemuCreateCapabilities(struct qemud_driver *driver)
+qemuCreateCapabilities(virQEMUDriverPtr driver)
{
size_t i;
virCapsPtr caps;
static void qemuNotifyLoadDomain(virDomainObjPtr vm, int newVM, void *opaque)
{
- struct qemud_driver *driver = opaque;
+ virQEMUDriverPtr driver = opaque;
if (newVM) {
virDomainEventPtr event =
}
static int qemuClose(virConnectPtr conn) {
- struct qemud_driver *driver = conn->privateData;
+ virQEMUDriverPtr driver = conn->privateData;
/* Get rid of callbacks registered for this conn */
qemuDriverLock(driver);
static char *
qemuGetSysinfo(virConnectPtr conn, unsigned int flags)
{
- struct qemud_driver *driver = conn->privateData;
+ virQEMUDriverPtr driver = conn->privateData;
virBuffer buf = VIR_BUFFER_INITIALIZER;
virCheckFlags(0, NULL);
static char *qemuGetCapabilities(virConnectPtr conn) {
- struct qemud_driver *driver = conn->privateData;
+ virQEMUDriverPtr driver = conn->privateData;
virCapsPtr caps = NULL;
char *xml = NULL;
static virDomainPtr qemuDomainLookupByID(virConnectPtr conn,
int id) {
- struct qemud_driver *driver = conn->privateData;
+ virQEMUDriverPtr driver = conn->privateData;
virDomainObjPtr vm;
virDomainPtr dom = NULL;
static virDomainPtr qemuDomainLookupByUUID(virConnectPtr conn,
const unsigned char *uuid) {
- struct qemud_driver *driver = conn->privateData;
+ virQEMUDriverPtr driver = conn->privateData;
virDomainObjPtr vm;
virDomainPtr dom = NULL;
static virDomainPtr qemuDomainLookupByName(virConnectPtr conn,
const char *name) {
- struct qemud_driver *driver = conn->privateData;
+ virQEMUDriverPtr driver = conn->privateData;
virDomainObjPtr vm;
virDomainPtr dom = NULL;
static int qemuDomainIsActive(virDomainPtr dom)
{
- struct qemud_driver *driver = dom->conn->privateData;
+ virQEMUDriverPtr driver = dom->conn->privateData;
virDomainObjPtr obj;
int ret = -1;
static int qemuDomainIsPersistent(virDomainPtr dom)
{
- struct qemud_driver *driver = dom->conn->privateData;
+ virQEMUDriverPtr driver = dom->conn->privateData;
virDomainObjPtr obj;
int ret = -1;
static int qemuDomainIsUpdated(virDomainPtr dom)
{
- struct qemud_driver *driver = dom->conn->privateData;
+ virQEMUDriverPtr driver = dom->conn->privateData;
virDomainObjPtr obj;
int ret = -1;
}
static int qemuGetVersion(virConnectPtr conn, unsigned long *version) {
- struct qemud_driver *driver = conn->privateData;
+ virQEMUDriverPtr driver = conn->privateData;
int ret = -1;
qemuDriverLock(driver);
}
static int qemuListDomains(virConnectPtr conn, int *ids, int nids) {
- struct qemud_driver *driver = conn->privateData;
+ virQEMUDriverPtr driver = conn->privateData;
int n;
qemuDriverLock(driver);
}
static int qemuNumDomains(virConnectPtr conn) {
- struct qemud_driver *driver = conn->privateData;
+ virQEMUDriverPtr driver = conn->privateData;
int n;
qemuDriverLock(driver);
static virDomainPtr qemuDomainCreate(virConnectPtr conn, const char *xml,
unsigned int flags) {
- struct qemud_driver *driver = conn->privateData;
+ virQEMUDriverPtr driver = conn->privateData;
virDomainDefPtr def;
virDomainObjPtr vm = NULL;
virDomainPtr dom = NULL;
static int qemuDomainSuspend(virDomainPtr dom) {
- struct qemud_driver *driver = dom->conn->privateData;
+ virQEMUDriverPtr driver = dom->conn->privateData;
virDomainObjPtr vm;
int ret = -1;
virDomainEventPtr event = NULL;
static int qemuDomainResume(virDomainPtr dom) {
- struct qemud_driver *driver = dom->conn->privateData;
+ virQEMUDriverPtr driver = dom->conn->privateData;
virDomainObjPtr vm;
int ret = -1;
virDomainEventPtr event = NULL;
}
static int qemuDomainShutdownFlags(virDomainPtr dom, unsigned int flags) {
- struct qemud_driver *driver = dom->conn->privateData;
+ virQEMUDriverPtr driver = dom->conn->privateData;
virDomainObjPtr vm;
int ret = -1;
qemuDomainObjPrivatePtr priv;
static int
qemuDomainReboot(virDomainPtr dom, unsigned int flags)
{
- struct qemud_driver *driver = dom->conn->privateData;
+ virQEMUDriverPtr driver = dom->conn->privateData;
virDomainObjPtr vm;
int ret = -1;
qemuDomainObjPrivatePtr priv;
static int
qemuDomainReset(virDomainPtr dom, unsigned int flags)
{
- struct qemud_driver *driver = dom->conn->privateData;
+ virQEMUDriverPtr driver = dom->conn->privateData;
virDomainObjPtr vm;
int ret = -1;
qemuDomainObjPrivatePtr priv;
qemuDomainDestroyFlags(virDomainPtr dom,
unsigned int flags)
{
- struct qemud_driver *driver = dom->conn->privateData;
+ virQEMUDriverPtr driver = dom->conn->privateData;
virDomainObjPtr vm;
int ret = -1;
virDomainEventPtr event = NULL;
}
static char *qemuDomainGetOSType(virDomainPtr dom) {
- struct qemud_driver *driver = dom->conn->privateData;
+ virQEMUDriverPtr driver = dom->conn->privateData;
virDomainObjPtr vm;
char *type = NULL;
static unsigned long long
qemuDomainGetMaxMemory(virDomainPtr dom)
{
- struct qemud_driver *driver = dom->conn->privateData;
+ virQEMUDriverPtr driver = dom->conn->privateData;
virDomainObjPtr vm;
unsigned long long ret = 0;
static int qemuDomainSetMemoryFlags(virDomainPtr dom, unsigned long newmem,
unsigned int flags) {
- struct qemud_driver *driver = dom->conn->privateData;
+ virQEMUDriverPtr driver = dom->conn->privateData;
qemuDomainObjPrivatePtr priv;
virDomainObjPtr vm;
virDomainDefPtr persistentDef = NULL;
static int qemuDomainInjectNMI(virDomainPtr domain, unsigned int flags)
{
- struct qemud_driver *driver = domain->conn->privateData;
+ virQEMUDriverPtr driver = domain->conn->privateData;
virDomainObjPtr vm = NULL;
int ret = -1;
qemuDomainObjPrivatePtr priv;
int nkeycodes,
unsigned int flags)
{
- struct qemud_driver *driver = domain->conn->privateData;
+ virQEMUDriverPtr driver = domain->conn->privateData;
virDomainObjPtr vm = NULL;
int ret = -1;
qemuDomainObjPrivatePtr priv;
static int qemuDomainGetInfo(virDomainPtr dom,
virDomainInfoPtr info)
{
- struct qemud_driver *driver = dom->conn->privateData;
+ virQEMUDriverPtr driver = dom->conn->privateData;
virDomainObjPtr vm;
int ret = -1;
int err;
int *reason,
unsigned int flags)
{
- struct qemud_driver *driver = dom->conn->privateData;
+ virQEMUDriverPtr driver = dom->conn->privateData;
virDomainObjPtr vm;
int ret = -1;
virDomainControlInfoPtr info,
unsigned int flags)
{
- struct qemud_driver *driver = dom->conn->privateData;
+ virQEMUDriverPtr driver = dom->conn->privateData;
virDomainObjPtr vm;
qemuDomainObjPrivatePtr priv;
int ret = -1;
/* Internal function to properly create or open existing files, with
* ownership affected by qemu driver setup. */
static int
-qemuOpenFile(struct qemud_driver *driver, const char *path, int oflags,
+qemuOpenFile(virQEMUDriverPtr driver, const char *path, int oflags,
bool *needUnlink, bool *bypassSecurityDriver)
{
struct stat sb;
* the caller needs to make sure that the processors are stopped and do all other
* actions besides saving memory */
static int
-qemuDomainSaveMemory(struct qemud_driver *driver,
+qemuDomainSaveMemory(virQEMUDriverPtr driver,
virDomainObjPtr vm,
const char *path,
const char *domXML,
* this returns (whether returning success or failure).
*/
static int
-qemuDomainSaveInternal(struct qemud_driver *driver, virDomainPtr dom,
+qemuDomainSaveInternal(virQEMUDriverPtr driver, virDomainPtr dom,
virDomainObjPtr vm, const char *path,
int compressed, const char *xmlin, unsigned int flags)
{
qemuDomainSaveFlags(virDomainPtr dom, const char *path, const char *dxml,
unsigned int flags)
{
- struct qemud_driver *driver = dom->conn->privateData;
+ virQEMUDriverPtr driver = dom->conn->privateData;
int compressed;
int ret = -1;
virDomainObjPtr vm = NULL;
}
static char *
-qemuDomainManagedSavePath(struct qemud_driver *driver, virDomainObjPtr vm) {
+qemuDomainManagedSavePath(virQEMUDriverPtr driver, virDomainObjPtr vm) {
char *ret;
if (virAsprintf(&ret, "%s/%s.save", driver->saveDir, vm->def->name) < 0) {
static int
qemuDomainManagedSave(virDomainPtr dom, unsigned int flags)
{
- struct qemud_driver *driver = dom->conn->privateData;
+ virQEMUDriverPtr driver = dom->conn->privateData;
virDomainObjPtr vm = NULL;
char *name = NULL;
int ret = -1;
void *opaque)
{
virDomainObjPtr vm = payload;
- struct qemud_driver *driver = opaque;
+ virQEMUDriverPtr driver = opaque;
char *name;
virDomainObjLock(vm);
static int
qemuDomainHasManagedSaveImage(virDomainPtr dom, unsigned int flags)
{
- struct qemud_driver *driver = dom->conn->privateData;
+ virQEMUDriverPtr driver = dom->conn->privateData;
virDomainObjPtr vm = NULL;
int ret = -1;
static int
qemuDomainManagedSaveRemove(virDomainPtr dom, unsigned int flags)
{
- struct qemud_driver *driver = dom->conn->privateData;
+ virQEMUDriverPtr driver = dom->conn->privateData;
virDomainObjPtr vm = NULL;
int ret = -1;
char *name = NULL;
return ret;
}
-static int qemuDumpToFd(struct qemud_driver *driver, virDomainObjPtr vm,
+static int qemuDumpToFd(virQEMUDriverPtr driver, virDomainObjPtr vm,
int fd, enum qemuDomainAsyncJob asyncJob)
{
qemuDomainObjPrivatePtr priv = vm->privateData;
}
static int
-doCoreDump(struct qemud_driver *driver,
+doCoreDump(virQEMUDriverPtr driver,
virDomainObjPtr vm,
const char *path,
enum qemu_save_formats compress,
}
static enum qemu_save_formats
-getCompressionType(struct qemud_driver *driver)
+getCompressionType(virQEMUDriverPtr driver)
{
int compress = QEMU_SAVE_FORMAT_RAW;
const char *path,
unsigned int flags)
{
- struct qemud_driver *driver = dom->conn->privateData;
+ virQEMUDriverPtr driver = dom->conn->privateData;
virDomainObjPtr vm;
qemuDomainObjPrivatePtr priv;
int resume = 0, paused = 0;
unsigned int screen,
unsigned int flags)
{
- struct qemud_driver *driver = dom->conn->privateData;
+ virQEMUDriverPtr driver = dom->conn->privateData;
virDomainObjPtr vm;
qemuDomainObjPrivatePtr priv;
char *tmp = NULL;
{
int ret;
struct qemuDomainWatchdogEvent *wdEvent = data;
- struct qemud_driver *driver = opaque;
+ virQEMUDriverPtr driver = opaque;
qemuDriverLock(driver);
virDomainObjLock(wdEvent->vm);
VIR_FREE(wdEvent);
}
-static int qemuDomainHotplugVcpus(struct qemud_driver *driver,
+static int qemuDomainHotplugVcpus(virQEMUDriverPtr driver,
virDomainObjPtr vm,
unsigned int nvcpus)
{
qemuDomainSetVcpusFlags(virDomainPtr dom, unsigned int nvcpus,
unsigned int flags)
{
- struct qemud_driver *driver = dom->conn->privateData;
+ virQEMUDriverPtr driver = dom->conn->privateData;
virDomainObjPtr vm;
virDomainDefPtr persistentDef;
const char * type;
int maplen,
unsigned int flags) {
- struct qemud_driver *driver = dom->conn->privateData;
+ virQEMUDriverPtr driver = dom->conn->privateData;
virDomainObjPtr vm;
virDomainDefPtr persistentDef = NULL;
virCgroupPtr cgroup_dom = NULL;
int maplen,
unsigned int flags) {
- struct qemud_driver *driver = dom->conn->privateData;
+ virQEMUDriverPtr driver = dom->conn->privateData;
virDomainObjPtr vm = NULL;
virDomainDefPtr targetDef = NULL;
int ret = -1;
int maplen,
unsigned int flags)
{
- struct qemud_driver *driver = dom->conn->privateData;
+ virQEMUDriverPtr driver = dom->conn->privateData;
virDomainObjPtr vm;
virCgroupPtr cgroup_dom = NULL;
virCgroupPtr cgroup_emulator = NULL;
int maplen,
unsigned int flags)
{
- struct qemud_driver *driver = dom->conn->privateData;
+ virQEMUDriverPtr driver = dom->conn->privateData;
virDomainObjPtr vm = NULL;
virDomainDefPtr targetDef = NULL;
int ret = -1;
int maxinfo,
unsigned char *cpumaps,
int maplen) {
- struct qemud_driver *driver = dom->conn->privateData;
+ virQEMUDriverPtr driver = dom->conn->privateData;
virDomainObjPtr vm;
int i, v, maxcpu, hostcpus;
int ret = -1;
static int
qemuDomainGetVcpusFlags(virDomainPtr dom, unsigned int flags)
{
- struct qemud_driver *driver = dom->conn->privateData;
+ virQEMUDriverPtr driver = dom->conn->privateData;
virDomainObjPtr vm;
virDomainDefPtr def;
int ret = -1;
static int qemuDomainGetSecurityLabel(virDomainPtr dom, virSecurityLabelPtr seclabel)
{
- struct qemud_driver *driver = (struct qemud_driver *)dom->conn->privateData;
+ virQEMUDriverPtr driver = dom->conn->privateData;
virDomainObjPtr vm;
int ret = -1;
static int qemuDomainGetSecurityLabelList(virDomainPtr dom,
virSecurityLabelPtr* seclabels)
{
- struct qemud_driver *driver = dom->conn->privateData;
+ virQEMUDriverPtr driver = dom->conn->privateData;
virDomainObjPtr vm;
int i, ret = -1;
static int qemuNodeGetSecurityModel(virConnectPtr conn,
virSecurityModelPtr secmodel)
{
- struct qemud_driver *driver = (struct qemud_driver *)conn->privateData;
+ virQEMUDriverPtr driver = conn->privateData;
char *p;
int ret = 0;
* not represent any changes (no error raised), -3 if corrupt image was
* unlinked (no error raised), and opened fd on success. */
static int ATTRIBUTE_NONNULL(3) ATTRIBUTE_NONNULL(4)
-qemuDomainSaveImageOpen(struct qemud_driver *driver,
+qemuDomainSaveImageOpen(virQEMUDriverPtr driver,
const char *path,
virDomainDefPtr *ret_def,
struct qemu_save_header *ret_header,
static int ATTRIBUTE_NONNULL(4) ATTRIBUTE_NONNULL(5) ATTRIBUTE_NONNULL(6)
qemuDomainSaveImageStartVM(virConnectPtr conn,
- struct qemud_driver *driver,
+ virQEMUDriverPtr driver,
virDomainObjPtr vm,
int *fd,
const struct qemu_save_header *header,
const char *dxml,
unsigned int flags)
{
- struct qemud_driver *driver = conn->privateData;
+ virQEMUDriverPtr driver = conn->privateData;
virDomainDefPtr def = NULL;
virDomainObjPtr vm = NULL;
int fd = -1;
qemuDomainSaveImageGetXMLDesc(virConnectPtr conn, const char *path,
unsigned int flags)
{
- struct qemud_driver *driver = conn->privateData;
+ virQEMUDriverPtr driver = conn->privateData;
char *ret = NULL;
virDomainDefPtr def = NULL;
int fd = -1;
qemuDomainSaveImageDefineXML(virConnectPtr conn, const char *path,
const char *dxml, unsigned int flags)
{
- struct qemud_driver *driver = conn->privateData;
+ virQEMUDriverPtr driver = conn->privateData;
int ret = -1;
virDomainDefPtr def = NULL;
int fd = -1;
* and -1 on failure with error raised. */
static int
qemuDomainObjRestore(virConnectPtr conn,
- struct qemud_driver *driver,
+ virQEMUDriverPtr driver,
virDomainObjPtr vm,
const char *path,
bool start_paused,
static char *qemuDomainGetXMLDesc(virDomainPtr dom,
unsigned int flags)
{
- struct qemud_driver *driver = dom->conn->privateData;
+ virQEMUDriverPtr driver = dom->conn->privateData;
virDomainObjPtr vm;
char *ret = NULL;
unsigned long long balloon;
const char *config,
unsigned int flags)
{
- struct qemud_driver *driver = conn->privateData;
+ virQEMUDriverPtr driver = conn->privateData;
virDomainDefPtr def = NULL;
char *xml = NULL;
const char *xmlData,
unsigned int flags)
{
- struct qemud_driver *driver = conn->privateData;
+ virQEMUDriverPtr driver = conn->privateData;
virDomainDefPtr def = NULL;
virDomainChrSourceDef monConfig;
qemuCapsPtr caps = NULL;
static int qemuListDefinedDomains(virConnectPtr conn,
char **const names, int nnames) {
- struct qemud_driver *driver = conn->privateData;
+ virQEMUDriverPtr driver = conn->privateData;
int n;
qemuDriverLock(driver);
}
static int qemuNumDefinedDomains(virConnectPtr conn) {
- struct qemud_driver *driver = conn->privateData;
+ virQEMUDriverPtr driver = conn->privateData;
int n;
qemuDriverLock(driver);
static int
qemuDomainObjStart(virConnectPtr conn,
- struct qemud_driver *driver,
+ virQEMUDriverPtr driver,
virDomainObjPtr vm,
unsigned int flags)
{
static int
qemuDomainStartWithFlags(virDomainPtr dom, unsigned int flags)
{
- struct qemud_driver *driver = dom->conn->privateData;
+ virQEMUDriverPtr driver = dom->conn->privateData;
virDomainObjPtr vm;
int ret = -1;
}
static virDomainPtr qemuDomainDefine(virConnectPtr conn, const char *xml) {
- struct qemud_driver *driver = conn->privateData;
+ virQEMUDriverPtr driver = conn->privateData;
virDomainDefPtr def;
virDomainDefPtr def_backup = NULL;
virDomainObjPtr vm = NULL;
qemuDomainUndefineFlags(virDomainPtr dom,
unsigned int flags)
{
- struct qemud_driver *driver = dom->conn->privateData;
+ virQEMUDriverPtr driver = dom->conn->privateData;
virDomainObjPtr vm;
virDomainEventPtr event = NULL;
char *name = NULL;
static int
qemuDomainAttachDeviceDiskLive(virConnectPtr conn,
- struct qemud_driver *driver,
+ virQEMUDriverPtr driver,
virDomainObjPtr vm,
virDomainDeviceDefPtr dev)
{
}
static int
-qemuDomainAttachDeviceControllerLive(struct qemud_driver *driver,
+qemuDomainAttachDeviceControllerLive(virQEMUDriverPtr driver,
virDomainObjPtr vm,
virDomainDeviceDefPtr dev)
{
virDomainDeviceDefPtr dev,
virDomainPtr dom)
{
- struct qemud_driver *driver = dom->conn->privateData;
+ virQEMUDriverPtr driver = dom->conn->privateData;
int ret = -1;
switch (dev->type) {
}
static int
-qemuDomainDetachDeviceDiskLive(struct qemud_driver *driver,
+qemuDomainDetachDeviceDiskLive(virQEMUDriverPtr driver,
virDomainObjPtr vm,
virDomainDeviceDefPtr dev)
{
}
static int
-qemuDomainDetachDeviceControllerLive(struct qemud_driver *driver,
+qemuDomainDetachDeviceControllerLive(virQEMUDriverPtr driver,
virDomainObjPtr vm,
virDomainDeviceDefPtr dev)
{
virDomainDeviceDefPtr dev,
virDomainPtr dom)
{
- struct qemud_driver *driver = dom->conn->privateData;
+ virQEMUDriverPtr driver = dom->conn->privateData;
int ret = -1;
switch (dev->type) {
static int
qemuDomainChangeDiskMediaLive(virDomainObjPtr vm,
virDomainDeviceDefPtr dev,
- struct qemud_driver *driver,
+ virQEMUDriverPtr driver,
bool force)
{
virDomainDiskDefPtr disk = dev->data.disk;
virDomainPtr dom,
bool force)
{
- struct qemud_driver *driver = dom->conn->privateData;
+ virQEMUDriverPtr driver = dom->conn->privateData;
int ret = -1;
switch (dev->type) {
qemuDomainModifyDeviceFlags(virDomainPtr dom, const char *xml,
unsigned int flags, int action)
{
- struct qemud_driver *driver = dom->conn->privateData;
+ virQEMUDriverPtr driver = dom->conn->privateData;
virDomainObjPtr vm = NULL;
virDomainDefPtr vmdef = NULL;
virDomainDeviceDefPtr dev = NULL, dev_copy = NULL;
static int qemuDomainGetAutostart(virDomainPtr dom,
int *autostart) {
- struct qemud_driver *driver = dom->conn->privateData;
+ virQEMUDriverPtr driver = dom->conn->privateData;
virDomainObjPtr vm;
int ret = -1;
static int qemuDomainSetAutostart(virDomainPtr dom,
int autostart) {
- struct qemud_driver *driver = dom->conn->privateData;
+ virQEMUDriverPtr driver = dom->conn->privateData;
virDomainObjPtr vm;
char *configFile = NULL, *autostartLink = NULL;
int ret = -1;
static char *qemuGetSchedulerType(virDomainPtr dom,
int *nparams)
{
- struct qemud_driver *driver = dom->conn->privateData;
+ virQEMUDriverPtr driver = dom->conn->privateData;
char *ret = NULL;
int rc;
int nparams,
unsigned int flags)
{
- struct qemud_driver *driver = dom->conn->privateData;
+ virQEMUDriverPtr driver = dom->conn->privateData;
int i;
virCgroupPtr group = NULL;
virDomainObjPtr vm = NULL;
int *nparams,
unsigned int flags)
{
- struct qemud_driver *driver = dom->conn->privateData;
+ virQEMUDriverPtr driver = dom->conn->privateData;
int i, j;
virCgroupPtr group = NULL;
virDomainObjPtr vm = NULL;
int nparams,
unsigned int flags)
{
- struct qemud_driver *driver = dom->conn->privateData;
+ virQEMUDriverPtr driver = dom->conn->privateData;
int i;
virDomainDefPtr persistentDef = NULL;
virCgroupPtr group = NULL;
int *nparams,
unsigned int flags)
{
- struct qemud_driver *driver = dom->conn->privateData;
+ virQEMUDriverPtr driver = dom->conn->privateData;
int i;
virCgroupPtr group = NULL;
virDomainObjPtr vm = NULL;
int nparams,
unsigned int flags)
{
- struct qemud_driver *driver = dom->conn->privateData;
+ virQEMUDriverPtr driver = dom->conn->privateData;
int i;
virDomainDefPtr persistentDef = NULL;
virCgroupPtr group = NULL;
int *nparams,
unsigned int flags)
{
- struct qemud_driver *driver = dom->conn->privateData;
+ virQEMUDriverPtr driver = dom->conn->privateData;
int i;
virCgroupPtr group = NULL;
virDomainObjPtr vm = NULL;
int nparams,
unsigned int flags)
{
- struct qemud_driver *driver = dom->conn->privateData;
+ virQEMUDriverPtr driver = dom->conn->privateData;
int i;
virCgroupPtr group = NULL;
virDomainObjPtr vm = NULL;
int *nparams,
unsigned int flags)
{
- struct qemud_driver *driver = dom->conn->privateData;
+ virQEMUDriverPtr driver = dom->conn->privateData;
virCgroupPtr group = NULL;
virDomainObjPtr vm = NULL;
unsigned long long shares;
unsigned long long size,
unsigned int flags)
{
- struct qemud_driver *driver = dom->conn->privateData;
+ virQEMUDriverPtr driver = dom->conn->privateData;
virDomainObjPtr vm;
qemuDomainObjPrivatePtr priv;
int ret = -1, i;
const char *path,
struct _virDomainBlockStats *stats)
{
- struct qemud_driver *driver = dom->conn->privateData;
+ virQEMUDriverPtr driver = dom->conn->privateData;
int i, ret = -1;
virDomainObjPtr vm;
virDomainDiskDefPtr disk = NULL;
int *nparams,
unsigned int flags)
{
- struct qemud_driver *driver = dom->conn->privateData;
+ virQEMUDriverPtr driver = dom->conn->privateData;
int i, tmp, ret = -1;
virDomainObjPtr vm;
virDomainDiskDefPtr disk = NULL;
const char *path,
struct _virDomainInterfaceStats *stats)
{
- struct qemud_driver *driver = dom->conn->privateData;
+ virQEMUDriverPtr driver = dom->conn->privateData;
virDomainObjPtr vm;
int i;
int ret = -1;
int nparams,
unsigned int flags)
{
- struct qemud_driver *driver = dom->conn->privateData;
+ virQEMUDriverPtr driver = dom->conn->privateData;
int i;
virCgroupPtr group = NULL;
virDomainObjPtr vm = NULL;
int *nparams,
unsigned int flags)
{
- struct qemud_driver *driver = dom->conn->privateData;
+ virQEMUDriverPtr driver = dom->conn->privateData;
int i;
virCgroupPtr group = NULL;
virDomainObjPtr vm = NULL;
unsigned int nr_stats,
unsigned int flags)
{
- struct qemud_driver *driver = dom->conn->privateData;
+ virQEMUDriverPtr driver = dom->conn->privateData;
virDomainObjPtr vm;
int ret = -1;
void *buffer,
unsigned int flags)
{
- struct qemud_driver *driver = dom->conn->privateData;
+ virQEMUDriverPtr driver = dom->conn->privateData;
virDomainObjPtr vm;
int fd = -1, ret = -1;
const char *actual;
void *buffer,
unsigned int flags)
{
- struct qemud_driver *driver = dom->conn->privateData;
+ virQEMUDriverPtr driver = dom->conn->privateData;
virDomainObjPtr vm;
char *tmp = NULL;
int fd = -1, ret = -1;
const char *path,
virDomainBlockInfoPtr info,
unsigned int flags) {
- struct qemud_driver *driver = dom->conn->privateData;
+ virQEMUDriverPtr driver = dom->conn->privateData;
virDomainObjPtr vm;
int ret = -1;
int fd = -1;
void *opaque,
virFreeCallback freecb)
{
- struct qemud_driver *driver = conn->privateData;
+ virQEMUDriverPtr driver = conn->privateData;
int ret;
qemuDriverLock(driver);
qemuDomainEventDeregister(virConnectPtr conn,
virConnectDomainEventCallback callback)
{
- struct qemud_driver *driver = conn->privateData;
+ virQEMUDriverPtr driver = conn->privateData;
int ret;
qemuDriverLock(driver);
void *opaque,
virFreeCallback freecb)
{
- struct qemud_driver *driver = conn->privateData;
+ virQEMUDriverPtr driver = conn->privateData;
int ret;
qemuDriverLock(driver);
qemuDomainEventDeregisterAny(virConnectPtr conn,
int callbackID)
{
- struct qemud_driver *driver = conn->privateData;
+ virQEMUDriverPtr driver = conn->privateData;
int ret;
qemuDriverLock(driver);
unsigned long resource ATTRIBUTE_UNUSED,
const char *dom_xml)
{
- struct qemud_driver *driver = dconn->privateData;
+ virQEMUDriverPtr driver = dconn->privateData;
int ret = -1;
virCheckFlags(QEMU_MIGRATION_FLAGS, -1);
unsigned long resource ATTRIBUTE_UNUSED,
const char *dom_xml)
{
- struct qemud_driver *driver = dconn->privateData;
+ virQEMUDriverPtr driver = dconn->privateData;
int ret = -1;
virCheckFlags(QEMU_MIGRATION_FLAGS, -1);
const char *dname,
unsigned long resource)
{
- struct qemud_driver *driver = dom->conn->privateData;
+ virQEMUDriverPtr driver = dom->conn->privateData;
virDomainObjPtr vm;
int ret = -1;
const char *dconnuri = NULL;
unsigned long flags,
int retcode)
{
- struct qemud_driver *driver = dconn->privateData;
+ virQEMUDriverPtr driver = dconn->privateData;
virDomainObjPtr vm;
virDomainPtr dom = NULL;
const char *dname,
unsigned long resource ATTRIBUTE_UNUSED)
{
- struct qemud_driver *driver = domain->conn->privateData;
+ virQEMUDriverPtr driver = domain->conn->privateData;
virDomainObjPtr vm;
char *xml = NULL;
enum qemuDomainAsyncJob asyncJob;
unsigned long resource ATTRIBUTE_UNUSED,
const char *dom_xml)
{
- struct qemud_driver *driver = dconn->privateData;
+ virQEMUDriverPtr driver = dconn->privateData;
int ret = -1;
virCheckFlags(QEMU_MIGRATION_FLAGS, -1);
unsigned long resource ATTRIBUTE_UNUSED,
const char *dom_xml)
{
- struct qemud_driver *driver = dconn->privateData;
+ virQEMUDriverPtr driver = dconn->privateData;
int ret = -1;
virCheckFlags(QEMU_MIGRATION_FLAGS, -1);
const char *dname,
unsigned long resource)
{
- struct qemud_driver *driver = dom->conn->privateData;
+ virQEMUDriverPtr driver = dom->conn->privateData;
virDomainObjPtr vm;
int ret = -1;
unsigned long flags,
int cancelled)
{
- struct qemud_driver *driver = dconn->privateData;
+ virQEMUDriverPtr driver = dconn->privateData;
virDomainObjPtr vm;
virDomainPtr dom = NULL;
unsigned long flags,
int cancelled)
{
- struct qemud_driver *driver = domain->conn->privateData;
+ virQEMUDriverPtr driver = domain->conn->privateData;
virDomainObjPtr vm;
int ret = -1;
enum qemuMigrationJobPhase phase;
static int
qemuNodeDeviceDettach(virNodeDevicePtr dev)
{
- struct qemud_driver *driver = dev->conn->privateData;
+ virQEMUDriverPtr driver = dev->conn->privateData;
pciDevice *pci;
unsigned domain, bus, slot, function;
int ret = -1;
static int
qemuNodeDeviceReAttach(virNodeDevicePtr dev)
{
- struct qemud_driver *driver = dev->conn->privateData;
+ virQEMUDriverPtr driver = dev->conn->privateData;
pciDevice *pci;
pciDevice *other;
unsigned domain, bus, slot, function;
static int
qemuNodeDeviceReset(virNodeDevicePtr dev)
{
- struct qemud_driver *driver = dev->conn->privateData;
+ virQEMUDriverPtr driver = dev->conn->privateData;
pciDevice *pci;
unsigned domain, bus, slot, function;
int ret = -1;
const char *xmlDesc,
unsigned int flags)
{
- struct qemud_driver *driver = conn->privateData;
+ virQEMUDriverPtr driver = conn->privateData;
int ret = VIR_CPU_COMPARE_ERROR;
virCheckFlags(0, VIR_CPU_COMPARE_ERROR);
static int qemuDomainGetJobInfo(virDomainPtr dom,
virDomainJobInfoPtr info) {
- struct qemud_driver *driver = dom->conn->privateData;
+ virQEMUDriverPtr driver = dom->conn->privateData;
virDomainObjPtr vm;
int ret = -1;
qemuDomainObjPrivatePtr priv;
static int qemuDomainAbortJob(virDomainPtr dom) {
- struct qemud_driver *driver = dom->conn->privateData;
+ virQEMUDriverPtr driver = dom->conn->privateData;
virDomainObjPtr vm;
int ret = -1;
qemuDomainObjPrivatePtr priv;
unsigned long long downtime,
unsigned int flags)
{
- struct qemud_driver *driver = dom->conn->privateData;
+ virQEMUDriverPtr driver = dom->conn->privateData;
virDomainObjPtr vm;
qemuDomainObjPrivatePtr priv;
int ret = -1;
unsigned long bandwidth,
unsigned int flags)
{
- struct qemud_driver *driver = dom->conn->privateData;
+ virQEMUDriverPtr driver = dom->conn->privateData;
virDomainObjPtr vm;
qemuDomainObjPrivatePtr priv;
int ret = -1;
unsigned long *bandwidth,
unsigned int flags)
{
- struct qemud_driver *driver = dom->conn->privateData;
+ virQEMUDriverPtr driver = dom->conn->privateData;
virDomainObjPtr vm;
qemuDomainObjPrivatePtr priv;
int ret = -1;
* are all aware of each new file before it is added to a chain, and
* can revoke access to a file no longer needed in a chain. */
static int
-qemuDomainPrepareDiskChainElement(struct qemud_driver *driver,
+qemuDomainPrepareDiskChainElement(virQEMUDriverPtr driver,
virDomainObjPtr vm,
virCgroupPtr cgroup,
virDomainDiskDefPtr disk,
/* this function expects the driver lock to be held by the caller */
static int
-qemuDomainSnapshotFSFreeze(struct qemud_driver *driver,
+qemuDomainSnapshotFSFreeze(virQEMUDriverPtr driver,
virDomainObjPtr vm) {
qemuDomainObjPrivatePtr priv = vm->privateData;
int freezed;
}
static int
-qemuDomainSnapshotFSThaw(struct qemud_driver *driver,
+qemuDomainSnapshotFSThaw(virQEMUDriverPtr driver,
virDomainObjPtr vm, bool report)
{
qemuDomainObjPrivatePtr priv = vm->privateData;
/* The domain is expected to be locked and inactive. */
static int
-qemuDomainSnapshotCreateInactiveInternal(struct qemud_driver *driver,
+qemuDomainSnapshotCreateInactiveInternal(virQEMUDriverPtr driver,
virDomainObjPtr vm,
virDomainSnapshotObjPtr snap)
{
/* The domain is expected to be locked and inactive. */
static int
-qemuDomainSnapshotCreateInactiveExternal(struct qemud_driver *driver,
+qemuDomainSnapshotCreateInactiveExternal(virQEMUDriverPtr driver,
virDomainObjPtr vm,
virDomainSnapshotObjPtr snap,
bool reuse)
/* The domain is expected to be locked and active. */
static int
qemuDomainSnapshotCreateActiveInternal(virConnectPtr conn,
- struct qemud_driver *driver,
+ virQEMUDriverPtr driver,
virDomainObjPtr *vmptr,
virDomainSnapshotObjPtr snap,
unsigned int flags)
/* The domain is expected to hold monitor lock. */
static int
-qemuDomainSnapshotCreateSingleDiskActive(struct qemud_driver *driver,
+qemuDomainSnapshotCreateSingleDiskActive(virQEMUDriverPtr driver,
virDomainObjPtr vm,
virCgroupPtr cgroup,
virDomainSnapshotDiskDefPtr snap,
* counterpart to qemuDomainSnapshotCreateSingleDiskActive, called
* only on a failed transaction. */
static void
-qemuDomainSnapshotUndoSingleDiskActive(struct qemud_driver *driver,
+qemuDomainSnapshotUndoSingleDiskActive(virQEMUDriverPtr driver,
virDomainObjPtr vm,
virCgroupPtr cgroup,
virDomainDiskDefPtr origdisk,
/* The domain is expected to be locked and active. */
static int
-qemuDomainSnapshotCreateDiskActive(struct qemud_driver *driver,
+qemuDomainSnapshotCreateDiskActive(virQEMUDriverPtr driver,
virDomainObjPtr vm,
virDomainSnapshotObjPtr snap,
unsigned int flags,
static int
qemuDomainSnapshotCreateActiveExternal(virConnectPtr conn,
- struct qemud_driver *driver,
+ virQEMUDriverPtr driver,
virDomainObjPtr *vmptr,
virDomainSnapshotObjPtr snap,
unsigned int flags)
const char *xmlDesc,
unsigned int flags)
{
- struct qemud_driver *driver = domain->conn->privateData;
+ virQEMUDriverPtr driver = domain->conn->privateData;
virDomainObjPtr vm = NULL;
char *xml = NULL;
virDomainSnapshotObjPtr snap = NULL;
/* The domain is expected to be locked and inactive. */
static int
-qemuDomainSnapshotRevertInactive(struct qemud_driver *driver,
+qemuDomainSnapshotRevertInactive(virQEMUDriverPtr driver,
virDomainObjPtr vm,
virDomainSnapshotObjPtr snap)
{
static int qemuDomainRevertToSnapshot(virDomainSnapshotPtr snapshot,
unsigned int flags)
{
- struct qemud_driver *driver = snapshot->domain->conn->privateData;
+ virQEMUDriverPtr driver = snapshot->domain->conn->privateData;
virDomainObjPtr vm = NULL;
int ret = -1;
virDomainSnapshotObjPtr snap = NULL;
}
struct snap_reparent {
- struct qemud_driver *driver;
+ virQEMUDriverPtr driver;
virDomainSnapshotObjPtr parent;
virDomainObjPtr vm;
int err;
static int qemuDomainSnapshotDelete(virDomainSnapshotPtr snapshot,
unsigned int flags)
{
- struct qemud_driver *driver = snapshot->domain->conn->privateData;
+ virQEMUDriverPtr driver = snapshot->domain->conn->privateData;
virDomainObjPtr vm = NULL;
int ret = -1;
virDomainSnapshotObjPtr snap = NULL;
static int qemuDomainMonitorCommand(virDomainPtr domain, const char *cmd,
char **result, unsigned int flags)
{
- struct qemud_driver *driver = domain->conn->privateData;
+ virQEMUDriverPtr driver = domain->conn->privateData;
virDomainObjPtr vm = NULL;
int ret = -1;
qemuDomainObjPrivatePtr priv;
unsigned int pid_value,
unsigned int flags)
{
- struct qemud_driver *driver = conn->privateData;
+ virQEMUDriverPtr driver = conn->privateData;
virDomainObjPtr vm = NULL;
virDomainDefPtr def = NULL;
virDomainPtr dom = NULL;
* either success or failure. */
static int
qemuDomainBlockPivot(virConnectPtr conn,
- struct qemud_driver *driver, virDomainObjPtr vm,
+ virQEMUDriverPtr driver, virDomainObjPtr vm,
const char *device, virDomainDiskDefPtr disk)
{
int ret = -1;
unsigned long bandwidth, virDomainBlockJobInfoPtr info,
int mode, unsigned int flags)
{
- struct qemud_driver *driver = dom->conn->privateData;
+ virQEMUDriverPtr driver = dom->conn->privateData;
virDomainObjPtr vm = NULL;
qemuDomainObjPrivatePtr priv;
char uuidstr[VIR_UUID_STRING_BUFLEN];
const char *dest, const char *format,
unsigned long bandwidth, unsigned int flags)
{
- struct qemud_driver *driver = dom->conn->privateData;
+ virQEMUDriverPtr driver = dom->conn->privateData;
virDomainObjPtr vm;
qemuDomainObjPrivatePtr priv;
char *device = NULL;
const char *top, unsigned long bandwidth,
unsigned int flags)
{
- struct qemud_driver *driver = dom->conn->privateData;
+ virQEMUDriverPtr driver = dom->conn->privateData;
qemuDomainObjPrivatePtr priv;
virDomainObjPtr vm = NULL;
char *device = NULL;
int fd,
unsigned int flags)
{
- struct qemud_driver *driver = dom->conn->privateData;
+ virQEMUDriverPtr driver = dom->conn->privateData;
virDomainObjPtr vm = NULL;
char uuidstr[VIR_UUID_STRING_BUFLEN];
int ret = -1;
int nparams,
unsigned int flags)
{
- struct qemud_driver *driver = dom->conn->privateData;
+ virQEMUDriverPtr driver = dom->conn->privateData;
virDomainObjPtr vm = NULL;
qemuDomainObjPrivatePtr priv;
virDomainDefPtr persistentDef = NULL;
int *nparams,
unsigned int flags)
{
- struct qemud_driver *driver = dom->conn->privateData;
+ virQEMUDriverPtr driver = dom->conn->privateData;
virDomainObjPtr vm = NULL;
qemuDomainObjPrivatePtr priv;
virDomainDefPtr persistentDef = NULL;
unsigned int nerrors,
unsigned int flags)
{
- struct qemud_driver *driver = dom->conn->privateData;
+ virQEMUDriverPtr driver = dom->conn->privateData;
virDomainObjPtr vm = NULL;
qemuDomainObjPrivatePtr priv;
char uuidstr[VIR_UUID_STRING_BUFLEN];
const char *uri ATTRIBUTE_UNUSED,
unsigned int flags)
{
- struct qemud_driver *driver = dom->conn->privateData;
+ virQEMUDriverPtr driver = dom->conn->privateData;
virDomainObjPtr vm;
virDomainDefPtr persistentDef;
int ret = -1;
const char *uri ATTRIBUTE_UNUSED,
unsigned int flags)
{
- struct qemud_driver *driver = dom->conn->privateData;
+ virQEMUDriverPtr driver = dom->conn->privateData;
virDomainObjPtr vm;
virDomainDefPtr def;
char *ret = NULL;
unsigned int ncpus,
unsigned int flags)
{
- struct qemud_driver *driver = domain->conn->privateData;
+ virQEMUDriverPtr driver = domain->conn->privateData;
virCgroupPtr group = NULL;
virDomainObjPtr vm = NULL;
int ret = -1;
unsigned long long duration,
unsigned int flags)
{
- struct qemud_driver *driver = dom->conn->privateData;
+ virQEMUDriverPtr driver = dom->conn->privateData;
qemuDomainObjPrivatePtr priv;
virDomainObjPtr vm;
int ret = -1;
qemuDomainPMWakeup(virDomainPtr dom,
unsigned int flags)
{
- struct qemud_driver *driver = dom->conn->privateData;
+ virQEMUDriverPtr driver = dom->conn->privateData;
virDomainObjPtr vm;
int ret = -1;
qemuDomainObjPrivatePtr priv;
virDomainPtr **domains,
unsigned int flags)
{
- struct qemud_driver *driver = conn->privateData;
+ virQEMUDriverPtr driver = conn->privateData;
int ret = -1;
virCheckFlags(VIR_CONNECT_LIST_DOMAINS_FILTERS_ALL, -1);
int timeout,
unsigned int flags)
{
- struct qemud_driver *driver = domain->conn->privateData;
+ virQEMUDriverPtr driver = domain->conn->privateData;
virDomainObjPtr vm;
int ret = -1;
char *result = NULL;
unsigned long long minimum,
unsigned int flags)
{
- struct qemud_driver *driver = dom->conn->privateData;
+ virQEMUDriverPtr driver = dom->conn->privateData;
virDomainObjPtr vm;
int ret = -1;
qemuDomainObjPrivatePtr priv;
}
static pciDeviceList *
-qemuGetActivePciHostDeviceList(struct qemud_driver *driver,
+qemuGetActivePciHostDeviceList(virQEMUDriverPtr driver,
virDomainHostdevDefPtr *hostdevs,
int nhostdevs)
{
return list;
}
-int qemuUpdateActivePciHostdevs(struct qemud_driver *driver,
+int qemuUpdateActivePciHostdevs(virQEMUDriverPtr driver,
virDomainDefPtr def)
{
virDomainHostdevDefPtr hostdev = NULL;
}
int
-qemuUpdateActiveUsbHostdevs(struct qemud_driver *driver,
+qemuUpdateActiveUsbHostdevs(virQEMUDriverPtr driver,
virDomainDefPtr def)
{
virDomainHostdevDefPtr hostdev = NULL;
return ret;
}
-int qemuPrepareHostdevPCIDevices(struct qemud_driver *driver,
+int qemuPrepareHostdevPCIDevices(virQEMUDriverPtr driver,
const char *name,
const unsigned char *uuid,
virDomainHostdevDefPtr *hostdevs,
}
static int
-qemuPrepareHostPCIDevices(struct qemud_driver *driver,
+qemuPrepareHostPCIDevices(virQEMUDriverPtr driver,
virDomainDefPtr def)
{
return qemuPrepareHostdevPCIDevices(driver, def->name, def->uuid,
}
int
-qemuPrepareHostdevUSBDevices(struct qemud_driver *driver,
+qemuPrepareHostdevUSBDevices(virQEMUDriverPtr driver,
const char *name,
usbDeviceList *list)
{
}
static int
-qemuPrepareHostUSBDevices(struct qemud_driver *driver,
+qemuPrepareHostUSBDevices(virQEMUDriverPtr driver,
virDomainDefPtr def,
bool coldBoot)
{
return ret;
}
-int qemuPrepareHostDevices(struct qemud_driver *driver,
+int qemuPrepareHostDevices(virQEMUDriverPtr driver,
virDomainDefPtr def,
bool coldBoot)
{
}
-void qemuReattachPciDevice(pciDevice *dev, struct qemud_driver *driver)
+void qemuReattachPciDevice(pciDevice *dev, virQEMUDriverPtr driver)
{
int retries = 100;
}
-void qemuDomainReAttachHostdevDevices(struct qemud_driver *driver,
+void qemuDomainReAttachHostdevDevices(virQEMUDriverPtr driver,
const char *name,
virDomainHostdevDefPtr *hostdevs,
int nhostdevs)
}
static void
-qemuDomainReAttachHostUsbDevices(struct qemud_driver *driver,
+qemuDomainReAttachHostUsbDevices(virQEMUDriverPtr driver,
const char *name,
virDomainHostdevDefPtr *hostdevs,
int nhostdevs)
}
}
-void qemuDomainReAttachHostDevices(struct qemud_driver *driver,
+void qemuDomainReAttachHostDevices(virQEMUDriverPtr driver,
virDomainDefPtr def)
{
if (!def->nhostdevs)
# include "qemu_conf.h"
# include "domain_conf.h"
-int qemuUpdateActivePciHostdevs(struct qemud_driver *driver,
+int qemuUpdateActivePciHostdevs(virQEMUDriverPtr driver,
virDomainDefPtr def);
-int qemuUpdateActiveUsbHostdevs(struct qemud_driver *driver,
+int qemuUpdateActiveUsbHostdevs(virQEMUDriverPtr driver,
virDomainDefPtr def);
-int qemuPrepareHostdevPCIDevices(struct qemud_driver *driver,
+int qemuPrepareHostdevPCIDevices(virQEMUDriverPtr driver,
const char *name,
const unsigned char *uuid,
virDomainHostdevDefPtr *hostdevs,
int qemuFindHostdevUSBDevice(virDomainHostdevDefPtr hostdev,
bool mandatory,
usbDevice **usb);
-int qemuPrepareHostdevUSBDevices(struct qemud_driver *driver,
+int qemuPrepareHostdevUSBDevices(virQEMUDriverPtr driver,
const char *name,
usbDeviceList *list);
-int qemuPrepareHostDevices(struct qemud_driver *driver,
+int qemuPrepareHostDevices(virQEMUDriverPtr driver,
virDomainDefPtr def,
bool coldBoot);
-void qemuReattachPciDevice(pciDevice *dev, struct qemud_driver *driver);
-void qemuDomainReAttachHostdevDevices(struct qemud_driver *driver,
+void qemuReattachPciDevice(pciDevice *dev, virQEMUDriverPtr driver);
+void qemuDomainReAttachHostdevDevices(virQEMUDriverPtr driver,
const char *name,
virDomainHostdevDefPtr *hostdevs,
int nhostdevs);
-void qemuDomainReAttachHostDevices(struct qemud_driver *driver,
+void qemuDomainReAttachHostDevices(virQEMUDriverPtr driver,
virDomainDefPtr def);
int qemuDomainHostdevIsVirtualFunction(virDomainHostdevDefPtr hostdev);
int qemuDomainHostdevNetConfigReplace(virDomainHostdevDefPtr hostdev,
#define VIR_FROM_THIS VIR_FROM_QEMU
-int qemuDomainChangeEjectableMedia(struct qemud_driver *driver,
+int qemuDomainChangeEjectableMedia(virQEMUDriverPtr driver,
virDomainObjPtr vm,
virDomainDiskDefPtr disk,
bool force)
}
int
-qemuDomainCheckEjectableMedia(struct qemud_driver *driver,
+qemuDomainCheckEjectableMedia(virQEMUDriverPtr driver,
virDomainObjPtr vm,
enum qemuDomainAsyncJob asyncJob)
{
int qemuDomainAttachPciDiskDevice(virConnectPtr conn,
- struct qemud_driver *driver,
+ virQEMUDriverPtr driver,
virDomainObjPtr vm,
virDomainDiskDefPtr disk)
{
}
-int qemuDomainAttachPciControllerDevice(struct qemud_driver *driver,
+int qemuDomainAttachPciControllerDevice(virQEMUDriverPtr driver,
virDomainObjPtr vm,
virDomainControllerDefPtr controller)
{
static virDomainControllerDefPtr
-qemuDomainFindOrCreateSCSIDiskController(struct qemud_driver *driver,
+qemuDomainFindOrCreateSCSIDiskController(virQEMUDriverPtr driver,
virDomainObjPtr vm,
int controller)
{
int qemuDomainAttachSCSIDisk(virConnectPtr conn,
- struct qemud_driver *driver,
+ virQEMUDriverPtr driver,
virDomainObjPtr vm,
virDomainDiskDefPtr disk)
{
int qemuDomainAttachUsbMassstorageDevice(virConnectPtr conn,
- struct qemud_driver *driver,
+ virQEMUDriverPtr driver,
virDomainObjPtr vm,
virDomainDiskDefPtr disk)
{
/* XXX conn required for network -> bridge resolution */
int qemuDomainAttachNetDevice(virConnectPtr conn,
- struct qemud_driver *driver,
+ virQEMUDriverPtr driver,
virDomainObjPtr vm,
virDomainNetDefPtr net)
{
}
-int qemuDomainAttachHostPciDevice(struct qemud_driver *driver,
+int qemuDomainAttachHostPciDevice(virQEMUDriverPtr driver,
virDomainObjPtr vm,
virDomainHostdevDefPtr hostdev)
{
}
-int qemuDomainAttachRedirdevDevice(struct qemud_driver *driver,
+int qemuDomainAttachRedirdevDevice(virQEMUDriverPtr driver,
virDomainObjPtr vm,
virDomainRedirdevDefPtr redirdev)
{
}
-int qemuDomainAttachHostUsbDevice(struct qemud_driver *driver,
+int qemuDomainAttachHostUsbDevice(virQEMUDriverPtr driver,
virDomainObjPtr vm,
virDomainHostdevDefPtr hostdev)
{
return -1;
}
-int qemuDomainAttachHostDevice(struct qemud_driver *driver,
+int qemuDomainAttachHostDevice(virQEMUDriverPtr driver,
virDomainObjPtr vm,
virDomainHostdevDefPtr hostdev)
{
return ret;
}
-int qemuDomainChangeNetLinkState(struct qemud_driver *driver,
+int qemuDomainChangeNetLinkState(virQEMUDriverPtr driver,
virDomainObjPtr vm,
virDomainNetDefPtr dev,
int linkstate)
}
int
-qemuDomainChangeNet(struct qemud_driver *driver,
+qemuDomainChangeNet(virQEMUDriverPtr driver,
virDomainObjPtr vm,
virDomainPtr dom,
virDomainDeviceDefPtr dev)
int
-qemuDomainChangeGraphics(struct qemud_driver *driver,
+qemuDomainChangeGraphics(virQEMUDriverPtr driver,
virDomainObjPtr vm,
virDomainGraphicsDefPtr dev)
{
}
-int qemuDomainDetachPciDiskDevice(struct qemud_driver *driver,
+int qemuDomainDetachPciDiskDevice(virQEMUDriverPtr driver,
virDomainObjPtr vm,
virDomainDeviceDefPtr dev)
{
return ret;
}
-int qemuDomainDetachDiskDevice(struct qemud_driver *driver,
+int qemuDomainDetachDiskDevice(virQEMUDriverPtr driver,
virDomainObjPtr vm,
virDomainDeviceDefPtr dev)
{
}
}
-int qemuDomainDetachPciControllerDevice(struct qemud_driver *driver,
+int qemuDomainDetachPciControllerDevice(virQEMUDriverPtr driver,
virDomainObjPtr vm,
virDomainDeviceDefPtr dev)
{
}
static int
-qemuDomainDetachHostPciDevice(struct qemud_driver *driver,
+qemuDomainDetachHostPciDevice(virQEMUDriverPtr driver,
virDomainObjPtr vm,
virDomainHostdevDefPtr detach)
{
}
static int
-qemuDomainDetachHostUsbDevice(struct qemud_driver *driver,
+qemuDomainDetachHostUsbDevice(virQEMUDriverPtr driver,
virDomainObjPtr vm,
virDomainHostdevDefPtr detach)
{
}
static
-int qemuDomainDetachThisHostDevice(struct qemud_driver *driver,
+int qemuDomainDetachThisHostDevice(virQEMUDriverPtr driver,
virDomainObjPtr vm,
virDomainHostdevDefPtr detach,
int idx)
}
/* search for a hostdev matching dev and detach it */
-int qemuDomainDetachHostDevice(struct qemud_driver *driver,
+int qemuDomainDetachHostDevice(virQEMUDriverPtr driver,
virDomainObjPtr vm,
virDomainDeviceDefPtr dev)
{
}
int
-qemuDomainDetachNetDevice(struct qemud_driver *driver,
+qemuDomainDetachNetDevice(virQEMUDriverPtr driver,
virDomainObjPtr vm,
virDomainDeviceDefPtr dev)
{
}
int
-qemuDomainChangeGraphicsPasswords(struct qemud_driver *driver,
+qemuDomainChangeGraphicsPasswords(virQEMUDriverPtr driver,
virDomainObjPtr vm,
int type,
virDomainGraphicsAuthDefPtr auth,
return ret;
}
-int qemuDomainAttachLease(struct qemud_driver *driver,
+int qemuDomainAttachLease(virQEMUDriverPtr driver,
virDomainObjPtr vm,
virDomainLeaseDefPtr lease)
{
return 0;
}
-int qemuDomainDetachLease(struct qemud_driver *driver,
+int qemuDomainDetachLease(virQEMUDriverPtr driver,
virDomainObjPtr vm,
virDomainLeaseDefPtr lease)
{
# include "qemu_domain.h"
# include "domain_conf.h"
-int qemuDomainChangeEjectableMedia(struct qemud_driver *driver,
+int qemuDomainChangeEjectableMedia(virQEMUDriverPtr driver,
virDomainObjPtr vm,
virDomainDiskDefPtr disk,
bool force);
-int qemuDomainCheckEjectableMedia(struct qemud_driver *driver,
+int qemuDomainCheckEjectableMedia(virQEMUDriverPtr driver,
virDomainObjPtr vm,
enum qemuDomainAsyncJob asyncJob);
int qemuDomainAttachPciDiskDevice(virConnectPtr conn,
- struct qemud_driver *driver,
+ virQEMUDriverPtr driver,
virDomainObjPtr vm,
virDomainDiskDefPtr disk);
-int qemuDomainAttachPciControllerDevice(struct qemud_driver *driver,
+int qemuDomainAttachPciControllerDevice(virQEMUDriverPtr driver,
virDomainObjPtr vm,
virDomainControllerDefPtr controller);
int qemuDomainAttachSCSIDisk(virConnectPtr conn,
- struct qemud_driver *driver,
+ virQEMUDriverPtr driver,
virDomainObjPtr vm,
virDomainDiskDefPtr disk);
int qemuDomainAttachUsbMassstorageDevice(virConnectPtr conn,
- struct qemud_driver *driver,
+ virQEMUDriverPtr driver,
virDomainObjPtr vm,
virDomainDiskDefPtr disk);
int qemuDomainAttachNetDevice(virConnectPtr conn,
- struct qemud_driver *driver,
+ virQEMUDriverPtr driver,
virDomainObjPtr vm,
virDomainNetDefPtr net);
-int qemuDomainAttachHostPciDevice(struct qemud_driver *driver,
+int qemuDomainAttachHostPciDevice(virQEMUDriverPtr driver,
virDomainObjPtr vm,
virDomainHostdevDefPtr hostdev);
-int qemuDomainAttachHostUsbDevice(struct qemud_driver *driver,
+int qemuDomainAttachHostUsbDevice(virQEMUDriverPtr driver,
virDomainObjPtr vm,
virDomainHostdevDefPtr hostdev);
-int qemuDomainAttachRedirdevDevice(struct qemud_driver *driver,
+int qemuDomainAttachRedirdevDevice(virQEMUDriverPtr driver,
virDomainObjPtr vm,
virDomainRedirdevDefPtr hostdev);
-int qemuDomainAttachHostDevice(struct qemud_driver *driver,
+int qemuDomainAttachHostDevice(virQEMUDriverPtr driver,
virDomainObjPtr vm,
virDomainHostdevDefPtr hostdev);
-int qemuDomainChangeGraphics(struct qemud_driver *driver,
+int qemuDomainChangeGraphics(virQEMUDriverPtr driver,
virDomainObjPtr vm,
virDomainGraphicsDefPtr dev);
-int qemuDomainChangeGraphicsPasswords(struct qemud_driver *driver,
+int qemuDomainChangeGraphicsPasswords(virQEMUDriverPtr driver,
virDomainObjPtr vm,
int type,
virDomainGraphicsAuthDefPtr auth,
const char *defaultPasswd);
-int qemuDomainChangeNet(struct qemud_driver *driver,
+int qemuDomainChangeNet(virQEMUDriverPtr driver,
virDomainObjPtr vm,
virDomainPtr dom,
virDomainDeviceDefPtr dev);
-int qemuDomainChangeNetLinkState(struct qemud_driver *driver,
+int qemuDomainChangeNetLinkState(virQEMUDriverPtr driver,
virDomainObjPtr vm,
virDomainNetDefPtr dev,
int linkstate);
-int qemuDomainDetachPciDiskDevice(struct qemud_driver *driver,
+int qemuDomainDetachPciDiskDevice(virQEMUDriverPtr driver,
virDomainObjPtr vm,
virDomainDeviceDefPtr dev);
-int qemuDomainDetachDiskDevice(struct qemud_driver *driver,
+int qemuDomainDetachDiskDevice(virQEMUDriverPtr driver,
virDomainObjPtr vm,
virDomainDeviceDefPtr dev);
-int qemuDomainDetachPciControllerDevice(struct qemud_driver *driver,
+int qemuDomainDetachPciControllerDevice(virQEMUDriverPtr driver,
virDomainObjPtr vm,
virDomainDeviceDefPtr dev);
-int qemuDomainDetachNetDevice(struct qemud_driver *driver,
+int qemuDomainDetachNetDevice(virQEMUDriverPtr driver,
virDomainObjPtr vm,
virDomainDeviceDefPtr dev);
-int qemuDomainDetachHostDevice(struct qemud_driver *driver,
+int qemuDomainDetachHostDevice(virQEMUDriverPtr driver,
virDomainObjPtr vm,
virDomainDeviceDefPtr dev);
-int qemuDomainAttachLease(struct qemud_driver *driver,
+int qemuDomainAttachLease(virQEMUDriverPtr driver,
virDomainObjPtr vm,
virDomainLeaseDefPtr lease);
-int qemuDomainDetachLease(struct qemud_driver *driver,
+int qemuDomainDetachLease(virQEMUDriverPtr driver,
virDomainObjPtr vm,
virDomainLeaseDefPtr lease);
static qemuMigrationCookieGraphicsPtr
-qemuMigrationCookieGraphicsAlloc(struct qemud_driver *driver,
+qemuMigrationCookieGraphicsAlloc(virQEMUDriverPtr driver,
virDomainGraphicsDefPtr def)
{
qemuMigrationCookieGraphicsPtr mig = NULL;
static qemuMigrationCookieNetworkPtr
-qemuMigrationCookieNetworkAlloc(struct qemud_driver *driver ATTRIBUTE_UNUSED,
+qemuMigrationCookieNetworkAlloc(virQEMUDriverPtr driver ATTRIBUTE_UNUSED,
virDomainDefPtr def)
{
qemuMigrationCookieNetworkPtr mig;
static int
qemuMigrationCookieAddGraphics(qemuMigrationCookiePtr mig,
- struct qemud_driver *driver,
+ virQEMUDriverPtr driver,
virDomainObjPtr dom)
{
if (mig->flags & QEMU_MIGRATION_COOKIE_GRAPHICS) {
static int
qemuMigrationCookieAddLockstate(qemuMigrationCookiePtr mig,
- struct qemud_driver *driver,
+ virQEMUDriverPtr driver,
virDomainObjPtr dom)
{
qemuDomainObjPrivatePtr priv = dom->privateData;
static int
qemuMigrationCookieAddNetwork(qemuMigrationCookiePtr mig,
- struct qemud_driver *driver,
+ virQEMUDriverPtr driver,
virDomainObjPtr dom)
{
if (mig->flags & QEMU_MIGRATION_COOKIE_NETWORK) {
static int
-qemuMigrationCookieXMLFormat(struct qemud_driver *driver,
+qemuMigrationCookieXMLFormat(virQEMUDriverPtr driver,
virBufferPtr buf,
qemuMigrationCookiePtr mig)
{
}
-static char *qemuMigrationCookieXMLFormatStr(struct qemud_driver *driver,
+static char *qemuMigrationCookieXMLFormatStr(virQEMUDriverPtr driver,
qemuMigrationCookiePtr mig)
{
virBuffer buf = VIR_BUFFER_INITIALIZER;
static int
qemuMigrationCookieXMLParse(qemuMigrationCookiePtr mig,
- struct qemud_driver *driver,
+ virQEMUDriverPtr driver,
xmlDocPtr doc,
xmlXPathContextPtr ctxt,
unsigned int flags)
static int
qemuMigrationCookieXMLParseStr(qemuMigrationCookiePtr mig,
- struct qemud_driver *driver,
+ virQEMUDriverPtr driver,
const char *xml,
unsigned int flags)
{
static int
qemuMigrationBakeCookie(qemuMigrationCookiePtr mig,
- struct qemud_driver *driver,
+ virQEMUDriverPtr driver,
virDomainObjPtr dom,
char **cookieout,
int *cookieoutlen,
static qemuMigrationCookiePtr
-qemuMigrationEatCookie(struct qemud_driver *driver,
+qemuMigrationEatCookie(virQEMUDriverPtr driver,
virDomainObjPtr dom,
const char *cookiein,
int cookieinlen,
* talking to the destination in the first place, we are stuck with
* the fact that older servers did not do checks on the source. */
static bool
-qemuMigrationIsAllowed(struct qemud_driver *driver, virDomainObjPtr vm,
+qemuMigrationIsAllowed(virQEMUDriverPtr driver, virDomainObjPtr vm,
virDomainDefPtr def)
{
int nsnapshots;
* Pause domain for non-live migration.
*/
int
-qemuMigrationSetOffline(struct qemud_driver *driver,
+qemuMigrationSetOffline(virQEMUDriverPtr driver,
virDomainObjPtr vm)
{
int ret;
static int
-qemuMigrationUpdateJobStatus(struct qemud_driver *driver,
+qemuMigrationUpdateJobStatus(virQEMUDriverPtr driver,
virDomainObjPtr vm,
const char *job,
enum qemuDomainAsyncJob asyncJob)
static int
-qemuMigrationWaitForCompletion(struct qemud_driver *driver, virDomainObjPtr vm,
+qemuMigrationWaitForCompletion(virQEMUDriverPtr driver, virDomainObjPtr vm,
enum qemuDomainAsyncJob asyncJob,
virConnectPtr dconn)
{
static int
-qemuDomainMigrateGraphicsRelocate(struct qemud_driver *driver,
+qemuDomainMigrateGraphicsRelocate(virQEMUDriverPtr driver,
virDomainObjPtr vm,
qemuMigrationCookiePtr cookie)
{
static int
-qemuDomainMigrateOPDRelocate(struct qemud_driver *driver ATTRIBUTE_UNUSED,
+qemuDomainMigrateOPDRelocate(virQEMUDriverPtr driver ATTRIBUTE_UNUSED,
virDomainObjPtr vm,
qemuMigrationCookiePtr cookie)
{
* qemuDomainMigratePerform3 and qemuDomainMigrateConfirm3.
*/
virDomainObjPtr
-qemuMigrationCleanup(struct qemud_driver *driver,
+qemuMigrationCleanup(virQEMUDriverPtr driver,
virDomainObjPtr vm,
virConnectPtr conn)
{
}
/* The caller is supposed to lock the vm and start a migration job. */
-char *qemuMigrationBegin(struct qemud_driver *driver,
+char *qemuMigrationBegin(virQEMUDriverPtr driver,
virDomainObjPtr vm,
const char *xmlin,
const char *dname,
*/
static void
-qemuMigrationPrepareCleanup(struct qemud_driver *driver,
+qemuMigrationPrepareCleanup(virQEMUDriverPtr driver,
virDomainObjPtr vm)
{
qemuDomainObjPrivatePtr priv = vm->privateData;
}
static int
-qemuMigrationPrepareAny(struct qemud_driver *driver,
+qemuMigrationPrepareAny(virQEMUDriverPtr driver,
virConnectPtr dconn,
const char *cookiein,
int cookieinlen,
* sets up the corresponding virStream to handle the incoming data.
*/
int
-qemuMigrationPrepareTunnel(struct qemud_driver *driver,
+qemuMigrationPrepareTunnel(virQEMUDriverPtr driver,
virConnectPtr dconn,
const char *cookiein,
int cookieinlen,
int
-qemuMigrationPrepareDirect(struct qemud_driver *driver,
+qemuMigrationPrepareDirect(virQEMUDriverPtr driver,
virConnectPtr dconn,
const char *cookiein,
int cookieinlen,
}
static int
-qemuMigrationConnect(struct qemud_driver *driver,
+qemuMigrationConnect(virQEMUDriverPtr driver,
virDomainObjPtr vm,
qemuMigrationSpecPtr spec)
{
}
static int
-qemuMigrationRun(struct qemud_driver *driver,
+qemuMigrationRun(virQEMUDriverPtr driver,
virDomainObjPtr vm,
const char *cookiein,
int cookieinlen,
/* Perform migration using QEMU's native TCP migrate support,
* not encrypted obviously
*/
-static int doNativeMigrate(struct qemud_driver *driver,
+static int doNativeMigrate(virQEMUDriverPtr driver,
virDomainObjPtr vm,
const char *uri,
const char *cookiein,
}
-static int doTunnelMigrate(struct qemud_driver *driver,
+static int doTunnelMigrate(virQEMUDriverPtr driver,
virDomainObjPtr vm,
virStreamPtr st,
const char *cookiein,
* from libvirt.c, but running in source libvirtd context,
* instead of client app context & also adding in tunnel
* handling */
-static int doPeer2PeerMigrate2(struct qemud_driver *driver,
+static int doPeer2PeerMigrate2(virQEMUDriverPtr driver,
virConnectPtr sconn ATTRIBUTE_UNUSED,
virConnectPtr dconn,
virDomainObjPtr vm,
* from libvirt.c, but running in source libvirtd context,
* instead of client app context & also adding in tunnel
* handling */
-static int doPeer2PeerMigrate3(struct qemud_driver *driver,
+static int doPeer2PeerMigrate3(virQEMUDriverPtr driver,
virConnectPtr sconn,
virConnectPtr dconn,
virDomainObjPtr vm,
}
-static int doPeer2PeerMigrate(struct qemud_driver *driver,
+static int doPeer2PeerMigrate(virQEMUDriverPtr driver,
virConnectPtr sconn,
virDomainObjPtr vm,
const char *xmlin,
* perform phase of v2 non-peer2peer migration.
*/
static int
-qemuMigrationPerformJob(struct qemud_driver *driver,
+qemuMigrationPerformJob(virQEMUDriverPtr driver,
virConnectPtr conn,
virDomainObjPtr vm,
const char *xmlin,
* This implements perform phase of v3 migration protocol.
*/
static int
-qemuMigrationPerformPhase(struct qemud_driver *driver,
+qemuMigrationPerformPhase(virQEMUDriverPtr driver,
virConnectPtr conn,
virDomainObjPtr vm,
const char *uri,
}
int
-qemuMigrationPerform(struct qemud_driver *driver,
+qemuMigrationPerform(virQEMUDriverPtr driver,
virConnectPtr conn,
virDomainObjPtr vm,
const char *xmlin,
virDomainPtr
-qemuMigrationFinish(struct qemud_driver *driver,
+qemuMigrationFinish(virQEMUDriverPtr driver,
virConnectPtr dconn,
virDomainObjPtr vm,
const char *cookiein,
}
-int qemuMigrationConfirm(struct qemud_driver *driver,
+int qemuMigrationConfirm(virQEMUDriverPtr driver,
virConnectPtr conn,
virDomainObjPtr vm,
const char *cookiein,
/* Helper function called while driver lock is held and vm is active. */
int
-qemuMigrationToFile(struct qemud_driver *driver, virDomainObjPtr vm,
+qemuMigrationToFile(virQEMUDriverPtr driver, virDomainObjPtr vm,
int fd, off_t offset, const char *path,
const char *compressor,
bool bypassSecurityDriver,
}
int
-qemuMigrationJobStart(struct qemud_driver *driver,
+qemuMigrationJobStart(virQEMUDriverPtr driver,
virDomainObjPtr vm,
enum qemuDomainAsyncJob job)
{
}
void
-qemuMigrationJobSetPhase(struct qemud_driver *driver,
+qemuMigrationJobSetPhase(virQEMUDriverPtr driver,
virDomainObjPtr vm,
enum qemuMigrationJobPhase phase)
{
}
void
-qemuMigrationJobStartPhase(struct qemud_driver *driver,
+qemuMigrationJobStartPhase(virQEMUDriverPtr driver,
virDomainObjPtr vm,
enum qemuMigrationJobPhase phase)
{
}
bool
-qemuMigrationJobFinish(struct qemud_driver *driver, virDomainObjPtr vm)
+qemuMigrationJobFinish(virQEMUDriverPtr driver, virDomainObjPtr vm)
{
return qemuDomainObjEndAsyncJob(driver, vm);
}
};
VIR_ENUM_DECL(qemuMigrationJobPhase)
-int qemuMigrationJobStart(struct qemud_driver *driver,
+int qemuMigrationJobStart(virQEMUDriverPtr driver,
virDomainObjPtr vm,
enum qemuDomainAsyncJob job)
ATTRIBUTE_NONNULL(1) ATTRIBUTE_NONNULL(2) ATTRIBUTE_RETURN_CHECK;
-void qemuMigrationJobSetPhase(struct qemud_driver *driver,
+void qemuMigrationJobSetPhase(virQEMUDriverPtr driver,
virDomainObjPtr vm,
enum qemuMigrationJobPhase phase)
ATTRIBUTE_NONNULL(1) ATTRIBUTE_NONNULL(2);
-void qemuMigrationJobStartPhase(struct qemud_driver *driver,
+void qemuMigrationJobStartPhase(virQEMUDriverPtr driver,
virDomainObjPtr vm,
enum qemuMigrationJobPhase phase)
ATTRIBUTE_NONNULL(1) ATTRIBUTE_NONNULL(2);
bool qemuMigrationJobIsActive(virDomainObjPtr vm,
enum qemuDomainAsyncJob job)
ATTRIBUTE_NONNULL(1);
-bool qemuMigrationJobFinish(struct qemud_driver *driver, virDomainObjPtr obj)
+bool qemuMigrationJobFinish(virQEMUDriverPtr driver, virDomainObjPtr obj)
ATTRIBUTE_NONNULL(1) ATTRIBUTE_NONNULL(2) ATTRIBUTE_RETURN_CHECK;
-int qemuMigrationSetOffline(struct qemud_driver *driver,
+int qemuMigrationSetOffline(virQEMUDriverPtr driver,
virDomainObjPtr vm);
-virDomainObjPtr qemuMigrationCleanup(struct qemud_driver *driver,
+virDomainObjPtr qemuMigrationCleanup(virQEMUDriverPtr driver,
virDomainObjPtr vm,
virConnectPtr conn);
-char *qemuMigrationBegin(struct qemud_driver *driver,
+char *qemuMigrationBegin(virQEMUDriverPtr driver,
virDomainObjPtr vm,
const char *xmlin,
const char *dname,
int *cookieoutlen,
unsigned long flags);
-int qemuMigrationPrepareTunnel(struct qemud_driver *driver,
+int qemuMigrationPrepareTunnel(virQEMUDriverPtr driver,
virConnectPtr dconn,
const char *cookiein,
int cookieinlen,
const char *dname,
const char *dom_xml);
-int qemuMigrationPrepareDirect(struct qemud_driver *driver,
+int qemuMigrationPrepareDirect(virQEMUDriverPtr driver,
virConnectPtr dconn,
const char *cookiein,
int cookieinlen,
const char *dname,
const char *dom_xml);
-int qemuMigrationPerform(struct qemud_driver *driver,
+int qemuMigrationPerform(virQEMUDriverPtr driver,
virConnectPtr conn,
virDomainObjPtr vm,
const char *xmlin,
unsigned long resource,
bool v3proto);
-virDomainPtr qemuMigrationFinish(struct qemud_driver *driver,
+virDomainPtr qemuMigrationFinish(virQEMUDriverPtr driver,
virConnectPtr dconn,
virDomainObjPtr vm,
const char *cookiein,
int retcode,
bool v3proto);
-int qemuMigrationConfirm(struct qemud_driver *driver,
+int qemuMigrationConfirm(virQEMUDriverPtr driver,
virConnectPtr conn,
virDomainObjPtr vm,
const char *cookiein,
int retcode);
-int qemuMigrationToFile(struct qemud_driver *driver, virDomainObjPtr vm,
+int qemuMigrationToFile(virQEMUDriverPtr driver, virDomainObjPtr vm,
int fd, off_t offset, const char *path,
const char *compressor,
bool bypassSecurityDriver,
* Returns 0 on success
*/
static int
-qemuProcessRemoveDomainStatus(struct qemud_driver *driver,
+qemuProcessRemoveDomainStatus(virQEMUDriverPtr driver,
virDomainObjPtr vm)
{
char ebuf[1024];
/* XXX figure out how to remove this */
-extern struct qemud_driver *qemu_driver;
+extern virQEMUDriverPtr qemu_driver;
/*
* This is a callback registered with a qemuAgentPtr instance,
qemuProcessHandleAgentEOF(qemuAgentPtr agent,
virDomainObjPtr vm)
{
- struct qemud_driver *driver = qemu_driver;
+ virQEMUDriverPtr driver = qemu_driver;
qemuDomainObjPrivatePtr priv;
VIR_DEBUG("Received EOF from agent on %p '%s'", vm, vm->def->name);
qemuProcessHandleAgentError(qemuAgentPtr agent ATTRIBUTE_UNUSED,
virDomainObjPtr vm)
{
- struct qemud_driver *driver = qemu_driver;
+ virQEMUDriverPtr driver = qemu_driver;
qemuDomainObjPrivatePtr priv;
VIR_DEBUG("Received error from agent on %p '%s'", vm, vm->def->name);
}
static int
-qemuConnectAgent(struct qemud_driver *driver, virDomainObjPtr vm)
+qemuConnectAgent(virQEMUDriverPtr driver, virDomainObjPtr vm)
{
qemuDomainObjPrivatePtr priv = vm->privateData;
int ret = -1;
qemuProcessHandleMonitorEOF(qemuMonitorPtr mon ATTRIBUTE_UNUSED,
virDomainObjPtr vm)
{
- struct qemud_driver *driver = qemu_driver;
+ virQEMUDriverPtr driver = qemu_driver;
virDomainEventPtr event = NULL;
qemuDomainObjPrivatePtr priv;
int eventReason = VIR_DOMAIN_EVENT_STOPPED_SHUTDOWN;
qemuProcessHandleMonitorError(qemuMonitorPtr mon ATTRIBUTE_UNUSED,
virDomainObjPtr vm)
{
- struct qemud_driver *driver = qemu_driver;
+ virQEMUDriverPtr driver = qemu_driver;
virDomainEventPtr event = NULL;
VIR_DEBUG("Received error on %p '%s'", vm, vm->def->name);
qemuProcessHandleReset(qemuMonitorPtr mon ATTRIBUTE_UNUSED,
virDomainObjPtr vm)
{
- struct qemud_driver *driver = qemu_driver;
+ virQEMUDriverPtr driver = qemu_driver;
virDomainEventPtr event;
qemuDomainObjPrivatePtr priv;
static void
qemuProcessFakeReboot(void *opaque)
{
- struct qemud_driver *driver = qemu_driver;
+ virQEMUDriverPtr driver = qemu_driver;
virDomainObjPtr vm = opaque;
qemuDomainObjPrivatePtr priv = vm->privateData;
virDomainEventPtr event = NULL;
static void
-qemuProcessShutdownOrReboot(struct qemud_driver *driver,
+qemuProcessShutdownOrReboot(virQEMUDriverPtr driver,
virDomainObjPtr vm)
{
qemuDomainObjPrivatePtr priv = vm->privateData;
qemuProcessHandleShutdown(qemuMonitorPtr mon ATTRIBUTE_UNUSED,
virDomainObjPtr vm)
{
- struct qemud_driver *driver = qemu_driver;
+ virQEMUDriverPtr driver = qemu_driver;
qemuDomainObjPrivatePtr priv;
virDomainEventPtr event = NULL;
qemuProcessHandleStop(qemuMonitorPtr mon ATTRIBUTE_UNUSED,
virDomainObjPtr vm)
{
- struct qemud_driver *driver = qemu_driver;
+ virQEMUDriverPtr driver = qemu_driver;
virDomainEventPtr event = NULL;
virDomainObjLock(vm);
virDomainObjPtr vm,
long long offset)
{
- struct qemud_driver *driver = qemu_driver;
+ virQEMUDriverPtr driver = qemu_driver;
virDomainEventPtr event;
virDomainObjLock(vm);
virDomainObjPtr vm,
int action)
{
- struct qemud_driver *driver = qemu_driver;
+ virQEMUDriverPtr driver = qemu_driver;
virDomainEventPtr watchdogEvent = NULL;
virDomainEventPtr lifecycleEvent = NULL;
int action,
const char *reason)
{
- struct qemud_driver *driver = qemu_driver;
+ virQEMUDriverPtr driver = qemu_driver;
virDomainEventPtr ioErrorEvent = NULL;
virDomainEventPtr ioErrorEvent2 = NULL;
virDomainEventPtr lifecycleEvent = NULL;
int type,
int status)
{
- struct qemud_driver *driver = qemu_driver;
+ virQEMUDriverPtr driver = qemu_driver;
virDomainEventPtr event = NULL;
const char *path;
virDomainDiskDefPtr disk;
const char *x509dname,
const char *saslUsername)
{
- struct qemud_driver *driver = qemu_driver;
+ virQEMUDriverPtr driver = qemu_driver;
virDomainEventPtr event;
virDomainEventGraphicsAddressPtr localAddr = NULL;
virDomainEventGraphicsAddressPtr remoteAddr = NULL;
const char *devAlias,
int reason)
{
- struct qemud_driver *driver = qemu_driver;
+ virQEMUDriverPtr driver = qemu_driver;
virDomainEventPtr event = NULL;
virDomainDiskDefPtr disk;
qemuProcessHandlePMWakeup(qemuMonitorPtr mon ATTRIBUTE_UNUSED,
virDomainObjPtr vm)
{
- struct qemud_driver *driver = qemu_driver;
+ virQEMUDriverPtr driver = qemu_driver;
virDomainEventPtr event = NULL;
virDomainEventPtr lifecycleEvent = NULL;
qemuProcessHandlePMSuspend(qemuMonitorPtr mon ATTRIBUTE_UNUSED,
virDomainObjPtr vm)
{
- struct qemud_driver *driver = qemu_driver;
+ virQEMUDriverPtr driver = qemu_driver;
virDomainEventPtr event = NULL;
virDomainEventPtr lifecycleEvent = NULL;
virDomainObjPtr vm,
unsigned long long actual)
{
- struct qemud_driver *driver = qemu_driver;
+ virQEMUDriverPtr driver = qemu_driver;
virDomainEventPtr event;
virDomainObjLock(vm);
qemuProcessHandlePMSuspendDisk(qemuMonitorPtr mon ATTRIBUTE_UNUSED,
virDomainObjPtr vm)
{
- struct qemud_driver *driver = qemu_driver;
+ virQEMUDriverPtr driver = qemu_driver;
virDomainEventPtr event = NULL;
virDomainEventPtr lifecycleEvent = NULL;
};
static int
-qemuConnectMonitor(struct qemud_driver *driver, virDomainObjPtr vm)
+qemuConnectMonitor(virQEMUDriverPtr driver, virDomainObjPtr vm)
{
qemuDomainObjPrivatePtr priv = vm->privateData;
int ret = -1;
static int
-qemuProcessWaitForMonitor(struct qemud_driver* driver,
+qemuProcessWaitForMonitor(virQEMUDriverPtr driver,
virDomainObjPtr vm,
qemuCapsPtr caps,
off_t pos)
}
static int
-qemuProcessDetectVcpuPIDs(struct qemud_driver *driver,
+qemuProcessDetectVcpuPIDs(virQEMUDriverPtr driver,
virDomainObjPtr vm)
{
pid_t *cpupids = NULL;
* just return a new allocated bitmap.
*/
virBitmapPtr
-qemuPrepareCpumap(struct qemud_driver *driver,
+qemuPrepareCpumap(virQEMUDriverPtr driver,
virBitmapPtr nodemask)
{
int i, hostcpus, maxcpu = QEMUD_CPUMASK_LEN;
* To be run between fork/exec of QEMU only
*/
static int
-qemuProcessInitCpuAffinity(struct qemud_driver *driver,
+qemuProcessInitCpuAffinity(virQEMUDriverPtr driver,
virDomainObjPtr vm,
virBitmapPtr nodemask)
{
static int
qemuProcessInitPasswords(virConnectPtr conn,
- struct qemud_driver *driver,
+ virQEMUDriverPtr driver,
virDomainObjPtr vm)
{
int ret = 0;
}
static int
-qemuProcessInitPCIAddresses(struct qemud_driver *driver,
+qemuProcessInitPCIAddresses(virQEMUDriverPtr driver,
virDomainObjPtr vm)
{
qemuDomainObjPrivatePtr priv = vm->privateData;
}
-static int qemuProcessNextFreePort(struct qemud_driver *driver,
+static int qemuProcessNextFreePort(virQEMUDriverPtr driver,
int startPort)
{
int i;
static void
-qemuProcessReturnPort(struct qemud_driver *driver,
+qemuProcessReturnPort(virQEMUDriverPtr driver,
int port)
{
if (port < driver->remotePortMin)
static int
-qemuProcessLimits(struct qemud_driver *driver)
+qemuProcessLimits(virQEMUDriverPtr driver)
{
struct rlimit rlim;
struct qemuProcessHookData {
virConnectPtr conn;
virDomainObjPtr vm;
- struct qemud_driver *driver;
+ virQEMUDriverPtr driver;
virBitmapPtr nodemask;
};
}
int
-qemuProcessPrepareMonitorChr(struct qemud_driver *driver,
+qemuProcessPrepareMonitorChr(virQEMUDriverPtr driver,
virDomainChrSourceDefPtr monConfig,
const char *vm)
{
* {Enter,Exit}MonitorWithDriver
*/
int
-qemuProcessStartCPUs(struct qemud_driver *driver, virDomainObjPtr vm,
+qemuProcessStartCPUs(virQEMUDriverPtr driver, virDomainObjPtr vm,
virConnectPtr conn, virDomainRunningReason reason,
enum qemuDomainAsyncJob asyncJob)
{
}
-int qemuProcessStopCPUs(struct qemud_driver *driver, virDomainObjPtr vm,
+int qemuProcessStopCPUs(virQEMUDriverPtr driver, virDomainObjPtr vm,
virDomainPausedReason reason,
enum qemuDomainAsyncJob asyncJob)
{
}
static int
-qemuProcessUpdateState(struct qemud_driver *driver, virDomainObjPtr vm)
+qemuProcessUpdateState(virQEMUDriverPtr driver, virDomainObjPtr vm)
{
qemuDomainObjPrivatePtr priv = vm->privateData;
virDomainState state;
}
static int
-qemuProcessRecoverMigration(struct qemud_driver *driver,
+qemuProcessRecoverMigration(virQEMUDriverPtr driver,
virDomainObjPtr vm,
virConnectPtr conn,
enum qemuDomainAsyncJob job,
}
static int
-qemuProcessRecoverJob(struct qemud_driver *driver,
+qemuProcessRecoverJob(virQEMUDriverPtr driver,
virDomainObjPtr vm,
virConnectPtr conn,
const struct qemuDomainJobObj *job)
struct qemuProcessReconnectData {
virConnectPtr conn;
- struct qemud_driver *driver;
+ virQEMUDriverPtr driver;
void *payload;
struct qemuDomainJobObj oldjob;
};
qemuProcessReconnect(void *opaque)
{
struct qemuProcessReconnectData *data = opaque;
- struct qemud_driver *driver = data->driver;
+ virQEMUDriverPtr driver = data->driver;
virDomainObjPtr obj = data->payload;
qemuDomainObjPrivatePtr priv;
virConnectPtr conn = data->conn;
* about.
*/
void
-qemuProcessReconnectAll(virConnectPtr conn, struct qemud_driver *driver)
+qemuProcessReconnectAll(virConnectPtr conn, virQEMUDriverPtr driver)
{
struct qemuProcessReconnectData data = {.conn = conn, .driver = driver};
virHashForEach(driver->domains.objs, qemuProcessReconnectHelper, &data);
}
int qemuProcessStart(virConnectPtr conn,
- struct qemud_driver *driver,
+ virQEMUDriverPtr driver,
virDomainObjPtr vm,
const char *migrateFrom,
int stdin_fd,
int
-qemuProcessKill(struct qemud_driver *driver,
+qemuProcessKill(virQEMUDriverPtr driver,
virDomainObjPtr vm, unsigned int flags)
{
int ret;
}
-void qemuProcessStop(struct qemud_driver *driver,
+void qemuProcessStop(virQEMUDriverPtr driver,
virDomainObjPtr vm,
virDomainShutoffReason reason,
unsigned int flags)
int qemuProcessAttach(virConnectPtr conn ATTRIBUTE_UNUSED,
- struct qemud_driver *driver,
+ virQEMUDriverPtr driver,
virDomainObjPtr vm,
pid_t pid,
const char *pidfile,
static virDomainObjPtr
-qemuProcessAutoDestroy(struct qemud_driver *driver,
+qemuProcessAutoDestroy(virQEMUDriverPtr driver,
virDomainObjPtr dom,
virConnectPtr conn)
{
return dom;
}
-int qemuProcessAutoDestroyAdd(struct qemud_driver *driver,
+int qemuProcessAutoDestroyAdd(virQEMUDriverPtr driver,
virDomainObjPtr vm,
virConnectPtr conn)
{
qemuProcessAutoDestroy);
}
-int qemuProcessAutoDestroyRemove(struct qemud_driver *driver,
+int qemuProcessAutoDestroyRemove(virQEMUDriverPtr driver,
virDomainObjPtr vm)
{
VIR_DEBUG("vm=%s", vm->def->name);
return qemuDriverCloseCallbackUnset(driver, vm, qemuProcessAutoDestroy);
}
-bool qemuProcessAutoDestroyActive(struct qemud_driver *driver,
+bool qemuProcessAutoDestroyActive(virQEMUDriverPtr driver,
virDomainObjPtr vm)
{
qemuDriverCloseCallback cb;
# include "qemu_conf.h"
# include "qemu_domain.h"
-int qemuProcessPrepareMonitorChr(struct qemud_driver *driver,
+int qemuProcessPrepareMonitorChr(virQEMUDriverPtr driver,
virDomainChrSourceDefPtr monConfig,
const char *vm);
-int qemuProcessStartCPUs(struct qemud_driver *driver,
+int qemuProcessStartCPUs(virQEMUDriverPtr driver,
virDomainObjPtr vm,
virConnectPtr conn,
virDomainRunningReason reason,
enum qemuDomainAsyncJob asyncJob);
-int qemuProcessStopCPUs(struct qemud_driver *driver,
+int qemuProcessStopCPUs(virQEMUDriverPtr driver,
virDomainObjPtr vm,
virDomainPausedReason reason,
enum qemuDomainAsyncJob asyncJob);
-void qemuProcessAutostartAll(struct qemud_driver *driver);
-void qemuProcessReconnectAll(virConnectPtr conn, struct qemud_driver *driver);
+void qemuProcessAutostartAll(virQEMUDriverPtr driver);
+void qemuProcessReconnectAll(virConnectPtr conn, virQEMUDriverPtr driver);
int qemuProcessAssignPCIAddresses(virDomainDefPtr def);
} qemuProcessStartFlags;
int qemuProcessStart(virConnectPtr conn,
- struct qemud_driver *driver,
+ virQEMUDriverPtr driver,
virDomainObjPtr vm,
const char *migrateFrom,
int stdin_fd,
VIR_QEMU_PROCESS_STOP_NO_RELABEL = 1 << 1,
} qemuProcessStopFlags;
-void qemuProcessStop(struct qemud_driver *driver,
+void qemuProcessStop(virQEMUDriverPtr driver,
virDomainObjPtr vm,
virDomainShutoffReason reason,
unsigned int flags);
int qemuProcessAttach(virConnectPtr conn,
- struct qemud_driver *driver,
+ virQEMUDriverPtr driver,
virDomainObjPtr vm,
pid_t pid,
const char *pidfile,
VIR_QEMU_PROCESS_KILL_NOCHECK = 1 << 2, /* bypass the running vm check */
} virQemuProcessKillMode;
-int qemuProcessKill(struct qemud_driver *driver,
+int qemuProcessKill(virQEMUDriverPtr driver,
virDomainObjPtr vm, unsigned int flags);
-int qemuProcessAutoDestroyInit(struct qemud_driver *driver);
-void qemuProcessAutoDestroyShutdown(struct qemud_driver *driver);
-int qemuProcessAutoDestroyAdd(struct qemud_driver *driver,
+int qemuProcessAutoDestroyInit(virQEMUDriverPtr driver);
+void qemuProcessAutoDestroyShutdown(virQEMUDriverPtr driver);
+int qemuProcessAutoDestroyAdd(virQEMUDriverPtr driver,
virDomainObjPtr vm,
virConnectPtr conn);
-int qemuProcessAutoDestroyRemove(struct qemud_driver *driver,
+int qemuProcessAutoDestroyRemove(virQEMUDriverPtr driver,
virDomainObjPtr vm);
-bool qemuProcessAutoDestroyActive(struct qemud_driver *driver,
+bool qemuProcessAutoDestroyActive(virQEMUDriverPtr driver,
virDomainObjPtr vm);
-virBitmapPtr qemuPrepareCpumap(struct qemud_driver *driver,
+virBitmapPtr qemuPrepareCpumap(virQEMUDriverPtr driver,
virBitmapPtr nodemask);
#endif /* __QEMU_PROCESS_H__ */
# include "qemu/qemu_domain.h"
# include "testutilsqemu.h"
-static struct qemud_driver driver;
+static virQEMUDriver driver;
static int
testCompareXMLToXMLFiles(const char *inxml, const char *uuid, int internal)
# include "testutilsqemu.h"
-static struct qemud_driver driver;
+static virQEMUDriver driver;
static int blankProblemElements(char *data)
{
# include "testutilsqemu.h"
static const char *abs_top_srcdir;
-static struct qemud_driver driver;
+static virQEMUDriver driver;
static unsigned char *
fakeSecretGetValue(virSecretPtr obj ATTRIBUTE_UNUSED,
# include "qemu/qemu_domain.h"
# include "testutilsqemu.h"
-static struct qemud_driver driver;
+static virQEMUDriver driver;
static int
testCompareXMLToXMLFiles(const char *inxml, const char *outxml, bool live)
# include "testutilsqemu.h"
static const char *abs_top_srcdir;
-static struct qemud_driver driver;
+static virQEMUDriver driver;
static int testCompareXMLToArgvFiles(const char *xml,
const char *cmdline,
projects / thirdparty / libvirt.git / commitdiff
