extern struct qemud_driver *qemu_driver;
+static virConnect conn;
+
static int qemudDispatchFailure(struct qemud_packet_server_data *out) {
virErrorPtr err = virGetLastError();
+ if (!err)
+ err = virConnGetLastError(&conn);
out->type = QEMUD_SERVER_PKT_FAILURE;
- out->qemud_packet_server_data_u.failureReply.code = err->code;
- strncpy(out->qemud_packet_server_data_u.failureReply.message,
- err->message, QEMUD_MAX_ERROR_LEN-1);
- out->qemud_packet_server_data_u.failureReply.message[QEMUD_MAX_ERROR_LEN-1] = '\0';
+ if (err) {
+ out->qemud_packet_server_data_u.failureReply.code = err->code;
+ strncpy(out->qemud_packet_server_data_u.failureReply.message,
+ err->message, QEMUD_MAX_ERROR_LEN-1);
+ out->qemud_packet_server_data_u.failureReply.message[QEMUD_MAX_ERROR_LEN-1] = '\0';
+ } else {
+ out->qemud_packet_server_data_u.failureReply.code = VIR_ERR_INTERNAL_ERROR;
+ strcpy(out->qemud_packet_server_data_u.failureReply.message,
+ "Unknown error");
+ }
return 0;
}
static int qemudDispatchGetVersion(struct qemud_packet_client_data *in ATTRIBUTE_UNUSED, struct qemud_packet_server_data *out) {
- int version = qemudGetVersion(qemu_driver);
- if (version < 0) {
+ int ret;
+ unsigned long version;
+ ret = qemudGetVersion(&conn, &version);
+ if (ret < 0) {
if (qemudDispatchFailure(out) < 0)
return -1;
} else {
}
static int qemudDispatchGetNodeInfo(struct qemud_packet_client_data *in ATTRIBUTE_UNUSED, struct qemud_packet_server_data *out) {
- if (qemudGetNodeInfo(&out->qemud_packet_server_data_u.getNodeInfoReply.memory,
- out->qemud_packet_server_data_u.getNodeInfoReply.model,
- sizeof(out->qemud_packet_server_data_u.getNodeInfoReply.model),
- &out->qemud_packet_server_data_u.getNodeInfoReply.cpus,
- &out->qemud_packet_server_data_u.getNodeInfoReply.mhz,
- &out->qemud_packet_server_data_u.getNodeInfoReply.nodes,
- &out->qemud_packet_server_data_u.getNodeInfoReply.sockets,
- &out->qemud_packet_server_data_u.getNodeInfoReply.cores,
- &out->qemud_packet_server_data_u.getNodeInfoReply.threads) < 0) {
+ virNodeInfo info;
+ if (qemudGetNodeInfo(&conn,
+ &info) < 0) {
if (qemudDispatchFailure(out) < 0)
return -1;
return 0;
}
+ out->qemud_packet_server_data_u.getNodeInfoReply.memory = info.memory;
+ out->qemud_packet_server_data_u.getNodeInfoReply.cpus = info.cpus;
+ out->qemud_packet_server_data_u.getNodeInfoReply.mhz = info.mhz;
+ out->qemud_packet_server_data_u.getNodeInfoReply.nodes = info.nodes;
+ out->qemud_packet_server_data_u.getNodeInfoReply.sockets = info.sockets;
+ out->qemud_packet_server_data_u.getNodeInfoReply.cores = info.cores;
+ out->qemud_packet_server_data_u.getNodeInfoReply.threads = info.threads;
+
out->type = QEMUD_SERVER_PKT_GET_NODEINFO;
+ strncpy(out->qemud_packet_server_data_u.getNodeInfoReply.model, info.model,
+ sizeof(out->qemud_packet_server_data_u.getNodeInfoReply.model)-1);
out->qemud_packet_server_data_u.getNodeInfoReply.model[sizeof(out->qemud_packet_server_data_u.getNodeInfoReply.model)-1] = '\0';
return 0;
qemudDispatchGetCapabilities (struct qemud_packet_client_data *in ATTRIBUTE_UNUSED,
struct qemud_packet_server_data *out)
{
- char *xml = qemudGetCapabilities(qemu_driver);
+ char *xml = qemudGetCapabilities(&conn);
if (strlen(xml) > QEMUD_MAX_XML_LEN) {
- qemudReportError(NULL, NULL, NULL, VIR_ERR_XML_ERROR, NULL);
+ qemudReportError(&conn, NULL, NULL, VIR_ERR_XML_ERROR, NULL);
qemudDispatchFailure(out);
free(xml);
return 0;
static int qemudDispatchListDomains(struct qemud_packet_client_data *in ATTRIBUTE_UNUSED, struct qemud_packet_server_data *out) {
int i, ndomains, domains[QEMUD_MAX_NUM_DOMAINS];
- ndomains = qemudListDomains(qemu_driver,
+ ndomains = qemudListDomains(&conn,
domains,
QEMUD_MAX_NUM_DOMAINS);
if (ndomains < 0) {
}
static int qemudDispatchNumDomains(struct qemud_packet_client_data *in ATTRIBUTE_UNUSED, struct qemud_packet_server_data *out) {
- int ndomains = qemudNumDomains(qemu_driver);
+ int ndomains = qemudNumDomains(&conn);
if (ndomains < 0) {
if (qemudDispatchFailure(out) < 0)
return -1;
static int qemudDispatchDomainCreate(struct qemud_packet_client_data *in, struct qemud_packet_server_data *out) {
in->qemud_packet_client_data_u.domainCreateRequest.xml[QEMUD_MAX_XML_LEN-1] ='\0';
- struct qemud_vm *vm = qemudDomainCreate(qemu_driver, in->qemud_packet_client_data_u.domainCreateRequest.xml);
- if (!vm) {
+ virDomainPtr dom = qemudDomainCreate(&conn, in->qemud_packet_client_data_u.domainCreateRequest.xml, 0);
+ if (!dom) {
if (qemudDispatchFailure(out) < 0)
return -1;
} else {
out->type = QEMUD_SERVER_PKT_DOMAIN_CREATE;
- out->qemud_packet_server_data_u.domainCreateReply.id = vm->id;
- memcpy(out->qemud_packet_server_data_u.domainCreateReply.uuid, vm->def->uuid, QEMUD_UUID_RAW_LEN);
- strncpy(out->qemud_packet_server_data_u.domainCreateReply.name, vm->def->name, QEMUD_MAX_NAME_LEN-1);
+ out->qemud_packet_server_data_u.domainCreateReply.id = dom->id;
+ memcpy(out->qemud_packet_server_data_u.domainCreateReply.uuid, dom->uuid, QEMUD_UUID_RAW_LEN);
+ strncpy(out->qemud_packet_server_data_u.domainCreateReply.name, dom->name, QEMUD_MAX_NAME_LEN-1);
out->qemud_packet_server_data_u.domainCreateReply.name[QEMUD_MAX_NAME_LEN-1] = '\0';
+ free(dom);
}
return 0;
}
static int qemudDispatchDomainLookupByID(struct qemud_packet_client_data *in, struct qemud_packet_server_data *out) {
- struct qemud_vm *vm = qemudFindVMByID(qemu_driver, in->qemud_packet_client_data_u.domainLookupByIDRequest.id);
- if (!vm) {
+ virDomainPtr dom = qemudDomainLookupByID(&conn, in->qemud_packet_client_data_u.domainLookupByIDRequest.id);
+ if (!dom) {
if (qemudDispatchFailure(out) < 0)
return -1;
} else {
out->type = QEMUD_SERVER_PKT_DOMAIN_LOOKUP_BY_ID;
- memcpy(out->qemud_packet_server_data_u.domainLookupByIDReply.uuid, vm->def->uuid, QEMUD_UUID_RAW_LEN);
- strncpy(out->qemud_packet_server_data_u.domainLookupByIDReply.name, vm->def->name, QEMUD_MAX_NAME_LEN-1);
+ memcpy(out->qemud_packet_server_data_u.domainLookupByIDReply.uuid, dom->uuid, QEMUD_UUID_RAW_LEN);
+ strncpy(out->qemud_packet_server_data_u.domainLookupByIDReply.name, dom->name, QEMUD_MAX_NAME_LEN-1);
out->qemud_packet_server_data_u.domainLookupByIDReply.name[QEMUD_MAX_NAME_LEN-1] = '\0';
+ free(dom);
}
return 0;
}
static int qemudDispatchDomainLookupByUUID(struct qemud_packet_client_data *in, struct qemud_packet_server_data *out) {
- struct qemud_vm *vm = qemudFindVMByUUID(qemu_driver, in->qemud_packet_client_data_u.domainLookupByUUIDRequest.uuid);
- if (!vm) {
+ virDomainPtr dom = qemudDomainLookupByUUID(&conn, in->qemud_packet_client_data_u.domainLookupByUUIDRequest.uuid);
+ if (!dom) {
if (qemudDispatchFailure(out) < 0)
return -1;
} else {
out->type = QEMUD_SERVER_PKT_DOMAIN_LOOKUP_BY_UUID;
- out->qemud_packet_server_data_u.domainLookupByUUIDReply.id = vm->id;
- strncpy(out->qemud_packet_server_data_u.domainLookupByUUIDReply.name, vm->def->name, QEMUD_MAX_NAME_LEN-1);
+ out->qemud_packet_server_data_u.domainLookupByUUIDReply.id = dom->id;
+ strncpy(out->qemud_packet_server_data_u.domainLookupByUUIDReply.name, dom->name, QEMUD_MAX_NAME_LEN-1);
out->qemud_packet_server_data_u.domainLookupByUUIDReply.name[QEMUD_MAX_NAME_LEN-1] = '\0';
+ free(dom);
}
return 0;
}
static int qemudDispatchDomainLookupByName(struct qemud_packet_client_data *in, struct qemud_packet_server_data *out) {
/* Paranoia NULL termination */
in->qemud_packet_client_data_u.domainLookupByNameRequest.name[QEMUD_MAX_NAME_LEN-1] = '\0';
- struct qemud_vm *vm = qemudFindVMByName(qemu_driver, in->qemud_packet_client_data_u.domainLookupByNameRequest.name);
- if (!vm) {
+ virDomainPtr dom = qemudDomainLookupByName(&conn, in->qemud_packet_client_data_u.domainLookupByNameRequest.name);
+ if (!dom) {
if (qemudDispatchFailure(out) < 0)
return -1;
} else {
out->type = QEMUD_SERVER_PKT_DOMAIN_LOOKUP_BY_NAME;
- out->qemud_packet_server_data_u.domainLookupByNameReply.id = vm->id;
- memcpy(out->qemud_packet_server_data_u.domainLookupByNameReply.uuid, vm->def->uuid, QEMUD_UUID_RAW_LEN);
+ out->qemud_packet_server_data_u.domainLookupByNameReply.id = dom->id;
+ memcpy(out->qemud_packet_server_data_u.domainLookupByNameReply.uuid, dom->uuid, QEMUD_UUID_RAW_LEN);
+ free(dom);
}
return 0;
}
static int qemudDispatchDomainSuspend(struct qemud_packet_client_data *in, struct qemud_packet_server_data *out) {
- int ret = qemudDomainSuspend(qemu_driver, in->qemud_packet_client_data_u.domainSuspendRequest.id);
+ virDomainPtr dom = qemudDomainLookupByID(&conn, in->qemud_packet_client_data_u.domainSuspendRequest.id);
+ int ret;
+ if (!dom) {
+ if (qemudDispatchFailure(out) < 0)
+ return -1;
+ return 0;
+ }
+
+ ret = qemudDomainSuspend(dom);
+ free(dom);
if (ret < 0) {
if (qemudDispatchFailure(out) < 0)
return -1;
}
static int qemudDispatchDomainResume(struct qemud_packet_client_data *in, struct qemud_packet_server_data *out) {
- int ret = qemudDomainResume(qemu_driver, in->qemud_packet_client_data_u.domainResumeRequest.id);
+ virDomainPtr dom = qemudDomainLookupByID(&conn, in->qemud_packet_client_data_u.domainResumeRequest.id);
+ int ret;
+ if (!dom) {
+ if (qemudDispatchFailure(out) < 0)
+ return -1;
+ return 0;
+ }
+
+ ret = qemudDomainResume(dom);
+ free(dom);
if (ret < 0) {
if (qemudDispatchFailure(out) < 0)
return -1;
}
static int qemudDispatchDomainDestroy(struct qemud_packet_client_data *in, struct qemud_packet_server_data *out) {
- if (qemudDomainDestroy(qemu_driver, in->qemud_packet_client_data_u.domainDestroyRequest.id) < 0) {
+ virDomainPtr dom = qemudDomainLookupByID(&conn, in->qemud_packet_client_data_u.domainDestroyRequest.id);
+ int ret;
+ if (!dom) {
+ if (qemudDispatchFailure(out) < 0)
+ return -1;
+ return 0;
+ }
+
+ ret = qemudDomainDestroy(dom);
+ free(dom);
+ if (ret < 0) {
if (qemudDispatchFailure(out) < 0)
return -1;
} else {
}
static int qemudDispatchDomainGetInfo(struct qemud_packet_client_data *in, struct qemud_packet_server_data *out) {
- int runstate;
- unsigned long long cpuTime;
- unsigned long memory;
- unsigned long maxmem;
- unsigned int nrVirtCpu;
-
- int ret = qemudDomainGetInfo(qemu_driver, in->qemud_packet_client_data_u.domainGetInfoRequest.uuid,
- &runstate,
- &cpuTime,
- &maxmem,
- &memory,
- &nrVirtCpu);
- if (ret < 0) {
+ virDomainInfo info;
+ virDomainPtr dom = qemudDomainLookupByUUID(&conn, in->qemud_packet_client_data_u.domainGetInfoRequest.uuid);
+
+ if (!dom) {
+ if (qemudDispatchFailure(out) < 0)
+ return -1;
+ return 0;
+ }
+
+ if (qemudDomainGetInfo(dom, &info) < 0) {
if (qemudDispatchFailure(out) < 0)
return -1;
} else {
out->type = QEMUD_SERVER_PKT_DOMAIN_GET_INFO;
- out->qemud_packet_server_data_u.domainGetInfoReply.runstate = runstate;
- out->qemud_packet_server_data_u.domainGetInfoReply.cpuTime = cpuTime;
- out->qemud_packet_server_data_u.domainGetInfoReply.maxmem = maxmem;
- out->qemud_packet_server_data_u.domainGetInfoReply.memory = memory;
- out->qemud_packet_server_data_u.domainGetInfoReply.nrVirtCpu = nrVirtCpu;
+ out->qemud_packet_server_data_u.domainGetInfoReply.runstate = info.state;
+ out->qemud_packet_server_data_u.domainGetInfoReply.cpuTime = info.cpuTime;
+ out->qemud_packet_server_data_u.domainGetInfoReply.maxmem = info.maxMem;
+ out->qemud_packet_server_data_u.domainGetInfoReply.memory = info.memory;
+ out->qemud_packet_server_data_u.domainGetInfoReply.nrVirtCpu = info.nrVirtCpu;
}
return 0;
}
static int qemudDispatchDomainSave(struct qemud_packet_client_data *in, struct qemud_packet_server_data *out) {
+ virDomainPtr dom = qemudDomainLookupByID(&conn, in->qemud_packet_client_data_u.domainSaveRequest.id);
+ int ret;
+ if (!dom) {
+ if (qemudDispatchFailure(out) < 0)
+ return -1;
+ return 0;
+ }
+
/* Paranoia NULL termination */
in->qemud_packet_client_data_u.domainSaveRequest.file[PATH_MAX-1] ='\0';
- int ret = qemudDomainSave(qemu_driver,
- in->qemud_packet_client_data_u.domainSaveRequest.id,
- in->qemud_packet_client_data_u.domainSaveRequest.file);
+ ret = qemudDomainSave(dom,
+ in->qemud_packet_client_data_u.domainSaveRequest.file);
+ free(dom);
if (ret < 0) {
if (qemudDispatchFailure(out) < 0)
return -1;
}
static int qemudDispatchDomainRestore(struct qemud_packet_client_data *in, struct qemud_packet_server_data *out) {
- int id;
+ int ret;
/* Paranoia null termination */
in->qemud_packet_client_data_u.domainRestoreRequest.file[PATH_MAX-1] ='\0';
- id = qemudDomainRestore(qemu_driver, in->qemud_packet_client_data_u.domainRestoreRequest.file);
- if (id < 0) {
+ ret = qemudDomainRestore(&conn, in->qemud_packet_client_data_u.domainRestoreRequest.file);
+ if (ret < 0) {
if (qemudDispatchFailure(out) < 0)
return -1;
} else {
out->type = QEMUD_SERVER_PKT_DOMAIN_RESTORE;
- out->qemud_packet_server_data_u.domainRestoreReply.id = id;
+ out->qemud_packet_server_data_u.domainRestoreReply.id = ret;
}
return 0;
}
static int qemudDispatchDumpXML(struct qemud_packet_client_data *in, struct qemud_packet_server_data *out) {
- int ret;
- ret = qemudDomainDumpXML(qemu_driver,
- in->qemud_packet_client_data_u.domainDumpXMLRequest.uuid,
- out->qemud_packet_server_data_u.domainDumpXMLReply.xml,
- QEMUD_MAX_XML_LEN);
- if (ret < 0) {
+ virDomainPtr dom = qemudDomainLookupByUUID(&conn, in->qemud_packet_client_data_u.domainDumpXMLRequest.uuid);
+ char *ret;
+ if (!dom) {
+ if (qemudDispatchFailure(out) < 0)
+ return -1;
+ return 0;
+ }
+
+ ret = qemudDomainDumpXML(dom, 0);
+ free(dom);
+ if (!ret) {
if (qemudDispatchFailure(out) < 0)
return -1;
} else {
out->type = QEMUD_SERVER_PKT_DUMP_XML;
+ strncpy(out->qemud_packet_server_data_u.domainDumpXMLReply.xml,
+ ret, QEMUD_MAX_XML_LEN-1);
+ out->qemud_packet_server_data_u.domainDumpXMLReply.xml[QEMUD_MAX_XML_LEN-1] = '\0';
+ free(ret);
}
return 0;
}
if (!(names = malloc(sizeof(char *)*QEMUD_MAX_NUM_DOMAINS)))
return -1;
- for (i = 0 ; i < QEMUD_MAX_NUM_DOMAINS ; i++) {
- names[i] = &out->qemud_packet_server_data_u.listDefinedDomainsReply.domains[i*QEMUD_MAX_NAME_LEN];
- }
-
- ndomains = qemudListDefinedDomains(qemu_driver,
+ ndomains = qemudListDefinedDomains(&conn,
names,
QEMUD_MAX_NUM_DOMAINS);
+ for (i = 0 ; i < ndomains ; i++) {
+ strncpy(&out->qemud_packet_server_data_u.listDefinedDomainsReply.domains[i*QEMUD_MAX_NAME_LEN],
+ names[i],
+ QEMUD_MAX_NAME_LEN);
+ free(names[i]);
+ }
+
free(names);
if (ndomains < 0) {
if (qemudDispatchFailure(out) < 0)
out->type = QEMUD_SERVER_PKT_LIST_DEFINED_DOMAINS;
out->qemud_packet_server_data_u.listDefinedDomainsReply.numDomains = ndomains;
}
- printf("%d %d\n", out->type, out->qemud_packet_server_data_u.listDefinedDomainsReply.numDomains);
- for (i = 0 ; i < ndomains;i++) {
- printf("[%s]\n", &out->qemud_packet_server_data_u.listDefinedDomainsReply.domains[i*QEMUD_MAX_NAME_LEN]);
- }
return 0;
}
static int qemudDispatchNumDefinedDomains(struct qemud_packet_client_data *in ATTRIBUTE_UNUSED, struct qemud_packet_server_data *out) {
- int ndomains = qemudNumDefinedDomains(qemu_driver);
+ int ndomains = qemudNumDefinedDomains(&conn);
if (ndomains < 0) {
if (qemudDispatchFailure(out) < 0)
return -1;
}
static int qemudDispatchDomainStart(struct qemud_packet_client_data *in, struct qemud_packet_server_data *out) {
- struct qemud_vm *vm;
+ virDomainPtr dom = qemudDomainLookupByUUID(&conn, in->qemud_packet_client_data_u.domainStartRequest.uuid);
+ int ret;
+ if (!dom) {
+ if (qemudDispatchFailure(out) < 0)
+ return -1;
+ return 0;
+ }
- if (!(vm = qemudDomainStart(qemu_driver, in->qemud_packet_client_data_u.domainStartRequest.uuid))) {
+ ret = qemudDomainStart(dom);
+ free(dom);
+ if (ret < 0) {
if (qemudDispatchFailure(out) < 0)
return -1;
} else {
out->type = QEMUD_SERVER_PKT_DOMAIN_START;
- out->qemud_packet_server_data_u.domainStartReply.id = vm->id;
+ out->qemud_packet_server_data_u.domainStartReply.id = dom->id;
}
return 0;
}
static int qemudDispatchDomainDefine(struct qemud_packet_client_data *in, struct qemud_packet_server_data *out) {
in->qemud_packet_client_data_u.domainDefineRequest.xml[QEMUD_MAX_XML_LEN-1] ='\0';
- struct qemud_vm *vm = qemudDomainDefine(qemu_driver, in->qemud_packet_client_data_u.domainDefineRequest.xml);
- if (!vm) {
+ virDomainPtr dom = qemudDomainDefine(&conn, in->qemud_packet_client_data_u.domainDefineRequest.xml);
+ if (!dom) {
if (qemudDispatchFailure(out) < 0)
return -1;
} else {
out->type = QEMUD_SERVER_PKT_DOMAIN_DEFINE;
- memcpy(out->qemud_packet_server_data_u.domainDefineReply.uuid, vm->def->uuid, QEMUD_UUID_RAW_LEN);
- strncpy(out->qemud_packet_server_data_u.domainDefineReply.name, vm->def->name, QEMUD_MAX_NAME_LEN-1);
+ memcpy(out->qemud_packet_server_data_u.domainDefineReply.uuid, dom->uuid, QEMUD_UUID_RAW_LEN);
+ strncpy(out->qemud_packet_server_data_u.domainDefineReply.name, dom->name, QEMUD_MAX_NAME_LEN-1);
out->qemud_packet_server_data_u.domainDefineReply.name[QEMUD_MAX_NAME_LEN-1] = '\0';
}
return 0;
}
static int qemudDispatchDomainUndefine(struct qemud_packet_client_data *in, struct qemud_packet_server_data *out) {
- int ret = qemudDomainUndefine(qemu_driver, in->qemud_packet_client_data_u.domainUndefineRequest.uuid);
+ virDomainPtr dom = qemudDomainLookupByUUID(&conn, in->qemud_packet_client_data_u.domainUndefineRequest.uuid);
+ int ret;
+ if (!dom) {
+ if (qemudDispatchFailure(out) < 0)
+ return -1;
+ return 0;
+ }
+ ret = qemudDomainUndefine(dom);
+ free(dom);
if (ret < 0) {
if (qemudDispatchFailure(out) < 0)
return -1;
}
static int qemudDispatchNumNetworks(struct qemud_packet_client_data *in ATTRIBUTE_UNUSED, struct qemud_packet_server_data *out) {
- int nnetworks = qemudNumNetworks(qemu_driver);
+ int nnetworks = qemudNumNetworks(&conn);
if (nnetworks < 0) {
if (qemudDispatchFailure(out) < 0)
return -1;
if (!(names = malloc(sizeof(char *)*QEMUD_MAX_NUM_NETWORKS)))
return -1;
- for (i = 0 ; i < QEMUD_MAX_NUM_NETWORKS ; i++) {
- names[i] = &out->qemud_packet_server_data_u.listNetworksReply.networks[i*QEMUD_MAX_NAME_LEN];
- }
-
- int nnetworks = qemudListNetworks(qemu_driver,
+ int nnetworks = qemudListNetworks(&conn,
names,
QEMUD_MAX_NUM_NETWORKS);
+ for (i = 0 ; i < nnetworks ; i++) {
+ strncpy(&out->qemud_packet_server_data_u.listNetworksReply.networks[i*QEMUD_MAX_NAME_LEN],
+ names[i],
+ QEMUD_MAX_NAME_LEN);
+ free(names[i]);
+ }
free(names);
if (nnetworks < 0) {
if (qemudDispatchFailure(out) < 0)
}
static int qemudDispatchNumDefinedNetworks(struct qemud_packet_client_data *in ATTRIBUTE_UNUSED, struct qemud_packet_server_data *out) {
- int nnetworks = qemudNumDefinedNetworks(qemu_driver);
+ int nnetworks = qemudNumDefinedNetworks(&conn);
if (nnetworks < 0) {
if (qemudDispatchFailure(out) < 0)
return -1;
if (!(names = malloc(sizeof(char *)*QEMUD_MAX_NUM_NETWORKS)))
return -1;
- for (i = 0 ; i < QEMUD_MAX_NUM_NETWORKS ; i++) {
- names[i] = &out->qemud_packet_server_data_u.listDefinedNetworksReply.networks[i*QEMUD_MAX_NAME_LEN];
- }
-
- int nnetworks = qemudListDefinedNetworks(qemu_driver,
+ int nnetworks = qemudListDefinedNetworks(&conn,
names,
QEMUD_MAX_NUM_NETWORKS);
+
+ for (i = 0 ; i < nnetworks ; i++) {
+ strncpy(&out->qemud_packet_server_data_u.listDefinedNetworksReply.networks[i*QEMUD_MAX_NAME_LEN],
+ names[i],
+ QEMUD_MAX_NAME_LEN);
+ free(names[i]);
+ }
free(names);
if (nnetworks < 0) {
if (qemudDispatchFailure(out) < 0)
static int qemudDispatchNetworkCreate(struct qemud_packet_client_data *in, struct qemud_packet_server_data *out) {
in->qemud_packet_client_data_u.networkCreateRequest.xml[QEMUD_MAX_XML_LEN-1] ='\0';
- struct qemud_network *network = qemudNetworkCreate(qemu_driver, in->qemud_packet_client_data_u.networkCreateRequest.xml);
- if (!network) {
+ virNetworkPtr net = qemudNetworkCreate(&conn, in->qemud_packet_client_data_u.networkCreateRequest.xml);
+ if (!net) {
if (qemudDispatchFailure(out) < 0)
return -1;
} else {
out->type = QEMUD_SERVER_PKT_NETWORK_CREATE;
- memcpy(out->qemud_packet_server_data_u.networkCreateReply.uuid, network->def->uuid, QEMUD_UUID_RAW_LEN);
- strncpy(out->qemud_packet_server_data_u.networkCreateReply.name, network->def->name, QEMUD_MAX_NAME_LEN-1);
+ memcpy(out->qemud_packet_server_data_u.networkCreateReply.uuid, net->uuid, QEMUD_UUID_RAW_LEN);
+ strncpy(out->qemud_packet_server_data_u.networkCreateReply.name, net->name, QEMUD_MAX_NAME_LEN-1);
out->qemud_packet_server_data_u.networkCreateReply.name[QEMUD_MAX_NAME_LEN-1] = '\0';
+ free(net);
}
return 0;
}
static int qemudDispatchNetworkDefine(struct qemud_packet_client_data *in, struct qemud_packet_server_data *out) {
in->qemud_packet_client_data_u.networkDefineRequest.xml[QEMUD_MAX_XML_LEN-1] ='\0';
- struct qemud_network *network = qemudNetworkDefine(qemu_driver, in->qemud_packet_client_data_u.networkDefineRequest.xml);
- if (!network) {
+ virNetworkPtr net = qemudNetworkDefine(&conn, in->qemud_packet_client_data_u.networkDefineRequest.xml);
+ if (!net) {
if (qemudDispatchFailure(out) < 0)
return -1;
} else {
out->type = QEMUD_SERVER_PKT_NETWORK_DEFINE;
- memcpy(out->qemud_packet_server_data_u.networkDefineReply.uuid, network->def->uuid, QEMUD_UUID_RAW_LEN);
- strncpy(out->qemud_packet_server_data_u.networkDefineReply.name, network->def->name, QEMUD_MAX_NAME_LEN-1);
+ memcpy(out->qemud_packet_server_data_u.networkDefineReply.uuid, net->uuid, QEMUD_UUID_RAW_LEN);
+ strncpy(out->qemud_packet_server_data_u.networkDefineReply.name, net->name, QEMUD_MAX_NAME_LEN-1);
out->qemud_packet_server_data_u.networkDefineReply.name[QEMUD_MAX_NAME_LEN-1] = '\0';
+ free(net);
}
return 0;
}
static int qemudDispatchNetworkUndefine(struct qemud_packet_client_data *in, struct qemud_packet_server_data *out) {
- int ret = qemudNetworkUndefine(qemu_driver, in->qemud_packet_client_data_u.networkUndefineRequest.uuid);
+ virNetworkPtr net = qemudNetworkLookupByUUID(&conn, in->qemud_packet_client_data_u.networkUndefineRequest.uuid);
+ int ret;
+ if (!net) {
+ if (qemudDispatchFailure(out) < 0)
+ return -1;
+ }
+
+ ret = qemudNetworkUndefine(net);
+ free(net);
if (ret < 0) {
if (qemudDispatchFailure(out) < 0)
return -1;
}
static int qemudDispatchNetworkStart(struct qemud_packet_client_data *in, struct qemud_packet_server_data *out) {
- struct qemud_network *network;
+ virNetworkPtr net = qemudNetworkLookupByUUID(&conn, in->qemud_packet_client_data_u.networkStartRequest.uuid);
+ int ret;
+ if (!net) {
+ if (qemudDispatchFailure(out) < 0)
+ return -1;
+ }
- if (!(network = qemudNetworkStart(qemu_driver, in->qemud_packet_client_data_u.networkStartRequest.uuid))) {
+ ret = qemudNetworkStart(net);
+ free(net);
+ if (ret < 0) {
if (qemudDispatchFailure(out) < 0)
return -1;
} else {
}
static int qemudDispatchNetworkDestroy(struct qemud_packet_client_data *in, struct qemud_packet_server_data *out) {
- if (qemudNetworkDestroy(qemu_driver, in->qemud_packet_client_data_u.networkDestroyRequest.uuid) < 0) {
+ virNetworkPtr net = qemudNetworkLookupByUUID(&conn, in->qemud_packet_client_data_u.networkDestroyRequest.uuid);
+ int ret;
+ if (!net) {
+ if (qemudDispatchFailure(out) < 0)
+ return -1;
+ }
+
+ ret = qemudNetworkDestroy(net);
+ free(net);
+ if (ret < 0) {
if (qemudDispatchFailure(out) < 0)
return -1;
} else {
}
static int qemudDispatchNetworkDumpXML(struct qemud_packet_client_data *in, struct qemud_packet_server_data *out) {
- int ret = qemudNetworkDumpXML(qemu_driver,
- in->qemud_packet_client_data_u.networkDumpXMLRequest.uuid,
- out->qemud_packet_server_data_u.networkDumpXMLReply.xml, QEMUD_MAX_XML_LEN);
- if (ret < 0) {
+ virNetworkPtr net = qemudNetworkLookupByUUID(&conn, in->qemud_packet_client_data_u.networkDumpXMLRequest.uuid);
+ char *ret;
+ if (!net) {
+ if (qemudDispatchFailure(out) < 0)
+ return -1;
+ }
+
+ ret = qemudNetworkDumpXML(net, 0);
+ free(net);
+ if (!ret) {
if (qemudDispatchFailure(out) < 0)
return -1;
} else {
out->type = QEMUD_SERVER_PKT_NETWORK_DUMP_XML;
+ strncpy(out->qemud_packet_server_data_u.networkDumpXMLReply.xml, ret, QEMUD_MAX_XML_LEN-1);
+ out->qemud_packet_server_data_u.networkDumpXMLReply.xml[QEMUD_MAX_XML_LEN-1] = '\0';
+ free(ret);
}
return 0;
}
static int qemudDispatchNetworkGetBridgeName(struct qemud_packet_client_data *in, struct qemud_packet_server_data *out) {
- int ret = qemudNetworkGetBridgeName(qemu_driver,
- in->qemud_packet_client_data_u.networkDumpXMLRequest.uuid,
- out->qemud_packet_server_data_u.networkGetBridgeNameReply.ifname, QEMUD_MAX_IFNAME_LEN);
- if (ret < 0) {
+ virNetworkPtr net = qemudNetworkLookupByUUID(&conn, in->qemud_packet_client_data_u.networkDumpXMLRequest.uuid);
+ char *ret;
+ if (!net) {
+ if (qemudDispatchFailure(out) < 0)
+ return -1;
+ }
+
+ ret = qemudNetworkGetBridgeName(net);
+ free(net);
+ if (!ret) {
if (qemudDispatchFailure(out) < 0)
return -1;
} else {
out->type = QEMUD_SERVER_PKT_NETWORK_GET_BRIDGE_NAME;
+ strncpy(out->qemud_packet_server_data_u.networkGetBridgeNameReply.ifname, ret, QEMUD_MAX_IFNAME_LEN-1);
+ out->qemud_packet_server_data_u.networkGetBridgeNameReply.ifname[QEMUD_MAX_IFNAME_LEN-1] = '\0';
+ free(ret);
}
return 0;
}
-static int qemudDispatchDomainGetAutostart(struct qemud_packet_client_data *in, struct qemud_packet_server_data *out)
-{
+static int qemudDispatchDomainGetAutostart(struct qemud_packet_client_data *in, struct qemud_packet_server_data *out) {
+ virDomainPtr dom = qemudDomainLookupByUUID(&conn, in->qemud_packet_client_data_u.domainGetAutostartRequest.uuid);
int ret;
int autostart;
+ if (!dom) {
+ if (qemudDispatchFailure(out) < 0)
+ return -1;
+ return 0;
+ }
autostart = 0;
- ret = qemudDomainGetAutostart(qemu_driver,
- in->qemud_packet_client_data_u.domainGetAutostartRequest.uuid,
+ ret = qemudDomainGetAutostart(dom,
&autostart);
+ free(dom);
if (ret < 0) {
if (qemudDispatchFailure(out) < 0)
return -1;
return 0;
}
-static int qemudDispatchDomainSetAutostart(struct qemud_packet_client_data *in, struct qemud_packet_server_data *out)
-{
+static int qemudDispatchDomainSetAutostart(struct qemud_packet_client_data *in, struct qemud_packet_server_data *out) {
+ virDomainPtr dom = qemudDomainLookupByUUID(&conn, in->qemud_packet_client_data_u.domainSetAutostartRequest.uuid);
int ret;
+ if (!dom) {
+ if (qemudDispatchFailure(out) < 0)
+ return -1;
+ return 0;
+ }
- ret = qemudDomainSetAutostart(qemu_driver,
- in->qemud_packet_client_data_u.domainGetAutostartRequest.uuid,
+ ret = qemudDomainSetAutostart(dom,
in->qemud_packet_client_data_u.domainSetAutostartRequest.autostart);
+ free(dom);
if (ret < 0) {
if (qemudDispatchFailure(out) < 0)
return -1;
return 0;
}
-static int qemudDispatchNetworkGetAutostart(struct qemud_packet_client_data *in, struct qemud_packet_server_data *out)
-{
+static int qemudDispatchNetworkGetAutostart(struct qemud_packet_client_data *in, struct qemud_packet_server_data *out) {
+ virNetworkPtr net = qemudNetworkLookupByUUID(&conn, in->qemud_packet_client_data_u.networkGetAutostartRequest.uuid);
int ret;
int autostart;
+ if (!net) {
+ if (qemudDispatchFailure(out) < 0)
+ return -1;
+ }
autostart = 0;
- ret = qemudNetworkGetAutostart(qemu_driver,
- in->qemud_packet_client_data_u.networkGetAutostartRequest.uuid,
+ ret = qemudNetworkGetAutostart(net,
&autostart);
+ free(net);
if (ret < 0) {
if (qemudDispatchFailure(out) < 0)
return -1;
return 0;
}
-static int qemudDispatchNetworkSetAutostart(struct qemud_packet_client_data *in, struct qemud_packet_server_data *out)
-{
+static int qemudDispatchNetworkSetAutostart(struct qemud_packet_client_data *in, struct qemud_packet_server_data *out) {
+ virNetworkPtr net = qemudNetworkLookupByUUID(&conn, in->qemud_packet_client_data_u.networkGetAutostartRequest.uuid);
int ret;
+ if (!net) {
+ if (qemudDispatchFailure(out) < 0)
+ return -1;
+ }
- ret = qemudNetworkSetAutostart(qemu_driver,
- in->qemud_packet_client_data_u.networkGetAutostartRequest.uuid,
+ ret = qemudNetworkSetAutostart(net,
in->qemud_packet_client_data_u.networkSetAutostartRequest.autostart);
+ free(net);
if (ret < 0) {
if (qemudDispatchFailure(out) < 0)
return -1;
qemudDebug("> Dispatching request type %d, readonly ? %d",
in->type, client->readonly);
+ if (!conn.magic) {
+ qemudOpen(&conn, "qemu:///session", 0);
+ conn.magic = 1;
+ }
virResetLastError();
+ virConnResetLastError(&conn);
memset(out, 0, sizeof(*out));
if (qemudExec(argv, &vm->pid, &vm->stdout, &vm->stderr) == 0) {
vm->id = driver->nextvmid++;
- vm->state = QEMUD_STATE_RUNNING;
+ vm->state = VIR_DOMAIN_RUNNING;
driver->ninactivevms--;
driver->nactivevms++;
vm->pid = -1;
vm->id = -1;
- vm->state = QEMUD_STATE_STOPPED;
+ vm->state = VIR_DOMAIN_SHUTOFF;
if (vm->newDef) {
qemudFreeVMDef(vm->def);
qemudDispatchVMFailure(driver, vm, fd);
}
-int qemudMonitorCommand(struct qemud_driver *driver ATTRIBUTE_UNUSED,
- struct qemud_vm *vm,
- const char *cmd,
- char **reply) {
+static int qemudMonitorCommand(struct qemud_driver *driver ATTRIBUTE_UNUSED,
+ struct qemud_vm *vm,
+ const char *cmd,
+ char **reply) {
int size = 0;
char *buf = NULL;
}
-static int qemudGetMemInfo(unsigned int *memory) {
+static int qemudGetMemInfo(unsigned long *memory) {
FILE *meminfo = fopen("/proc/meminfo", "r");
char line[1024];
return 0;
}
-int qemudGetNodeInfo(unsigned int *memory,
- char *cpuModel, int cpuModelLength,
- unsigned int *cpus, unsigned int *mhz,
- unsigned int *nodes, unsigned int *sockets,
- unsigned int *cores, unsigned int *threads) {
+virDrvOpenStatus qemudOpen(virConnectPtr conn,
+ const char *name,
+ int flags ATTRIBUTE_UNUSED) {
+ uid_t uid = getuid();
+
+ if (qemu_driver == NULL)
+ return VIR_DRV_OPEN_DECLINED;
+
+ if (uid) {
+ if (strcmp(name, "qemu:///session"))
+ return VIR_DRV_OPEN_DECLINED;
+ } else {
+ if (strcmp(name, "qemu:///system"))
+ return VIR_DRV_OPEN_DECLINED;
+ }
+
+ conn->privateData = qemu_driver;
+
+ return VIR_DRV_OPEN_SUCCESS;
+}
+
+static int qemudClose(virConnectPtr conn) {
+ /*struct qemud_driver *driver = (struct qemud_driver *)conn->privateData;*/
+
+ conn->privateData = NULL;
+
+ return 0;
+}
+
+static const char *qemudGetType(virConnectPtr conn ATTRIBUTE_UNUSED) {
+ return "qemu";
+}
+
+static int qemudGetMaxVCPUs(virConnectPtr conn ATTRIBUTE_UNUSED,
+ const char *type) {
+ if (!type)
+ return 16;
+
+ if (!strcmp(type, "qemu"))
+ return 16;
+
+ /* XXX future KVM will support SMP. Need to probe
+ kernel to figure out KVM module version i guess */
+ if (!strcmp(type, "kvm"))
+ return 1;
+
+ if (!strcmp(type, "kqemu"))
+ return 1;
+ return -1;
+}
+
+int qemudGetNodeInfo(virConnectPtr conn ATTRIBUTE_UNUSED,
+ virNodeInfoPtr node) {
struct utsname info;
if (uname(&info) < 0)
return -1;
- strncpy(cpuModel, info.machine, cpuModelLength-1);
- cpuModel[cpuModelLength-1] = '\0';
+ strncpy(node->model, info.machine, sizeof(node->model)-1);
+ node->model[sizeof(node->model)-1] = '\0';
- if (qemudGetMemInfo(memory) < 0)
+ if (qemudGetMemInfo(&(node->memory)) < 0)
return -1;
- if (qemudGetCPUInfo(cpus, mhz, nodes, sockets, cores, threads) < 0)
+ if (qemudGetCPUInfo(&(node->cpus), &(node->mhz), &(node->nodes),
+ &(node->sockets), &(node->cores), &(node->threads)) < 0)
return -1;
return 0;
}
-char *qemudGetCapabilities(struct qemud_driver *driver ATTRIBUTE_UNUSED) {
+char *qemudGetCapabilities(virConnectPtr conn ATTRIBUTE_UNUSED) {
struct utsname utsname;
int i, j, r;
int have_kqemu = 0;
/* Construct the XML. */
xml = virBufferNew (1024);
if (!xml) {
- qemudReportError(NULL, NULL, NULL, VIR_ERR_NO_MEMORY, NULL);
+ qemudReportError(conn, NULL, NULL, VIR_ERR_NO_MEMORY, NULL);
return NULL;
}
if (r == -1) {
vir_buffer_failed:
virBufferFree (xml);
- qemudReportError(NULL, NULL, NULL, VIR_ERR_NO_MEMORY, NULL);
+ qemudReportError(conn, NULL, NULL, VIR_ERR_NO_MEMORY, NULL);
return NULL;
}
return NULL;
}
-int qemudGetVersion(struct qemud_driver *driver) {
+virDomainPtr qemudDomainLookupByID(virConnectPtr conn ATTRIBUTE_UNUSED,
+ int id) {
+ struct qemud_driver *driver = (struct qemud_driver *)conn->privateData;
+ struct qemud_vm *vm = qemudFindVMByID(driver, id);
+ virDomainPtr dom;
+
+ if (!vm) {
+ qemudReportError(conn, NULL, NULL, VIR_ERR_INTERNAL_ERROR, "no domain with matching id");
+ return NULL;
+ }
+
+ dom = calloc(1, sizeof(struct _virDomain));
+ if (!dom) {
+ qemudReportError(conn, NULL, NULL, VIR_ERR_NO_MEMORY, "virDomainPtr");
+ return NULL;
+ }
+
+ dom->conn = conn;
+ dom->id = vm->id;
+ dom->name = vm->def->name;
+ memcpy(dom->uuid, vm->def->uuid, sizeof(dom->uuid));
+ return dom;
+}
+virDomainPtr qemudDomainLookupByUUID(virConnectPtr conn ATTRIBUTE_UNUSED,
+ const unsigned char *uuid) {
+ struct qemud_driver *driver = (struct qemud_driver *)conn->privateData;
+ struct qemud_vm *vm = qemudFindVMByUUID(driver, uuid);
+ virDomainPtr dom;
+
+ if (!vm) {
+ qemudReportError(conn, NULL, NULL, VIR_ERR_INTERNAL_ERROR, "no domain with matching uuid");
+ return NULL;
+ }
+
+ dom = calloc(1, sizeof(struct _virDomain));
+ if (!dom) {
+ qemudReportError(conn, NULL, NULL, VIR_ERR_NO_MEMORY, "virDomainPtr");
+ return NULL;
+ }
+
+ dom->conn = conn;
+ dom->id = vm->id;
+ dom->name = vm->def->name;
+ memcpy(dom->uuid, vm->def->uuid, sizeof(dom->uuid));
+ return dom;
+}
+virDomainPtr qemudDomainLookupByName(virConnectPtr conn ATTRIBUTE_UNUSED,
+ const char *name) {
+ struct qemud_driver *driver = (struct qemud_driver *)conn->privateData;
+ struct qemud_vm *vm = qemudFindVMByName(driver, name);
+ virDomainPtr dom;
+
+ if (!vm) {
+ qemudReportError(conn, NULL, NULL, VIR_ERR_INTERNAL_ERROR, "no domain with matching name");
+ return NULL;
+ }
+
+ dom = calloc(1, sizeof(struct _virDomain));
+ if (!dom) {
+ qemudReportError(conn, NULL, NULL, VIR_ERR_NO_MEMORY, "virDomainPtr");
+ return NULL;
+ }
+
+ dom->conn = conn;
+ dom->id = vm->id;
+ dom->name = vm->def->name;
+ memcpy(dom->uuid, vm->def->uuid, sizeof(dom->uuid));
+ return dom;
+}
+
+int qemudGetVersion(virConnectPtr conn, unsigned long *version) {
+ struct qemud_driver *driver = (struct qemud_driver *)conn->privateData;
if (qemudExtractVersion(driver) < 0)
return -1;
- return driver->qemuVersion;
+ *version = qemu_driver->qemuVersion;
+ return 0;
}
-int qemudListDomains(struct qemud_driver *driver, int *ids, int nids) {
+int qemudListDomains(virConnectPtr conn, int *ids, int nids) {
+ struct qemud_driver *driver = (struct qemud_driver *)conn->privateData;
struct qemud_vm *vm = driver->vms;
int got = 0;
while (vm && got < nids) {
}
return got;
}
-int qemudNumDomains(struct qemud_driver *driver) {
+int qemudNumDomains(virConnectPtr conn) {
+ struct qemud_driver *driver = (struct qemud_driver *)conn->privateData;
return driver->nactivevms;
}
-struct qemud_vm *qemudDomainCreate(struct qemud_driver *driver, const char *xml) {
-
+virDomainPtr qemudDomainCreate(virConnectPtr conn, const char *xml,
+ unsigned int flags ATTRIBUTE_UNUSED) {
struct qemud_vm_def *def;
struct qemud_vm *vm;
+ virDomainPtr dom;
+ struct qemud_driver *driver = (struct qemud_driver *)conn->privateData;
if (!(def = qemudParseVMDef(driver, xml, NULL)))
return NULL;
return NULL;
}
- return vm;
+ dom = calloc(1, sizeof(struct _virDomain));
+ if (!dom) {
+ qemudReportError(conn, NULL, NULL, VIR_ERR_NO_MEMORY, "virDomainPtr");
+ return NULL;
+ }
+
+ dom->conn = conn;
+ dom->id = vm->id;
+ dom->name = vm->def->name;
+ memcpy(dom->uuid, vm->def->uuid, sizeof(dom->uuid));
+
+ return dom;
}
-int qemudDomainSuspend(struct qemud_driver *driver, int id) {
+int qemudDomainSuspend(virDomainPtr dom) {
+ struct qemud_driver *driver = (struct qemud_driver *)dom->conn->privateData;
char *info;
- struct qemud_vm *vm = qemudFindVMByID(driver, id);
+ struct qemud_vm *vm = qemudFindVMByID(driver, dom->id);
if (!vm) {
- qemudReportError(NULL, NULL, NULL, VIR_ERR_INVALID_DOMAIN, "no domain with matching id %d", id);
+ qemudReportError(dom->conn, dom, NULL, VIR_ERR_INVALID_DOMAIN, "no domain with matching id %d", dom->id);
return -1;
}
if (!qemudIsActiveVM(vm)) {
- qemudReportError(NULL, NULL, NULL, VIR_ERR_OPERATION_FAILED, "domain is not running");
+ qemudReportError(dom->conn, dom, NULL, VIR_ERR_OPERATION_FAILED, "domain is not running");
return -1;
}
- if (vm->state == QEMUD_STATE_PAUSED)
+ if (vm->state == VIR_DOMAIN_PAUSED)
return 0;
if (qemudMonitorCommand(driver, vm, "stop\n", &info) < 0) {
- qemudReportError(NULL, NULL, NULL, VIR_ERR_OPERATION_FAILED, "suspend operation failed");
+ qemudReportError(dom->conn, dom, NULL, VIR_ERR_OPERATION_FAILED, "suspend operation failed");
return -1;
}
- vm->state = QEMUD_STATE_PAUSED;
+ vm->state = VIR_DOMAIN_PAUSED;
qemudDebug("Reply %s", info);
free(info);
return 0;
}
-int qemudDomainResume(struct qemud_driver *driver, int id) {
+int qemudDomainResume(virDomainPtr dom) {
+ struct qemud_driver *driver = (struct qemud_driver *)dom->conn->privateData;
char *info;
- struct qemud_vm *vm = qemudFindVMByID(driver, id);
+ struct qemud_vm *vm = qemudFindVMByID(driver, dom->id);
if (!vm) {
- qemudReportError(NULL, NULL, NULL, VIR_ERR_INVALID_DOMAIN, "no domain with matching id %d", id);
+ qemudReportError(dom->conn, dom, NULL, VIR_ERR_INVALID_DOMAIN, "no domain with matching id %d", dom->id);
return -1;
}
if (!qemudIsActiveVM(vm)) {
- qemudReportError(NULL, NULL, NULL, VIR_ERR_OPERATION_FAILED, "domain is not running");
+ qemudReportError(dom->conn, dom, NULL, VIR_ERR_OPERATION_FAILED, "domain is not running");
return -1;
}
- if (vm->state == QEMUD_STATE_RUNNING)
+ if (vm->state == VIR_DOMAIN_RUNNING)
return 0;
if (qemudMonitorCommand(driver, vm, "cont\n", &info) < 0) {
- qemudReportError(NULL, NULL, NULL, VIR_ERR_OPERATION_FAILED, "resume operation failed");
+ qemudReportError(dom->conn, dom, NULL, VIR_ERR_OPERATION_FAILED, "resume operation failed");
return -1;
}
- vm->state = QEMUD_STATE_RUNNING;
+ vm->state = VIR_DOMAIN_RUNNING;
qemudDebug("Reply %s", info);
free(info);
return 0;
}
-int qemudDomainDestroy(struct qemud_driver *driver, int id) {
- struct qemud_vm *vm = qemudFindVMByID(driver, id);
+int qemudDomainDestroy(virDomainPtr dom) {
+ struct qemud_driver *driver = (struct qemud_driver *)dom->conn->privateData;
+ struct qemud_vm *vm = qemudFindVMByID(driver, dom->id);
+ int ret;
if (!vm) {
- qemudReportError(NULL, NULL, NULL, VIR_ERR_INVALID_DOMAIN,
- "no domain with matching id %d", id);
+ qemudReportError(dom->conn, dom, NULL, VIR_ERR_INVALID_DOMAIN,
+ "no domain with matching id %d", dom->id);
return -1;
}
- return qemudShutdownVMDaemon(driver, vm);
+ ret = qemudShutdownVMDaemon(driver, vm);
+ free(dom);
+ return ret;
}
-int qemudDomainGetInfo(struct qemud_driver *driver, const unsigned char *uuid,
- int *runstate,
- unsigned long long *cputime,
- unsigned long *maxmem,
- unsigned long *memory,
- unsigned int *nrVirtCpu) {
- struct qemud_vm *vm = qemudFindVMByUUID(driver, uuid);
+static char *qemudDomainGetOSType(virDomainPtr dom) {
+ struct qemud_driver *driver = (struct qemud_driver *)dom->conn->privateData;
+ struct qemud_vm *vm = qemudFindVMByUUID(driver, dom->uuid);
+ char *type;
+
+ if (!vm) {
+ qemudReportError(dom->conn, dom, NULL, VIR_ERR_INVALID_DOMAIN,
+ "no domain with matching uuid");
+ return NULL;
+ }
+
+ if (!(type = strdup(vm->def->os.type))) {
+ qemudReportError(dom->conn, dom, NULL, VIR_ERR_NO_MEMORY, "ostype");
+ return NULL;
+ }
+ return type;
+}
+
+int qemudDomainGetInfo(virDomainPtr dom,
+ virDomainInfoPtr info) {
+ struct qemud_driver *driver = (struct qemud_driver *)dom->conn->privateData;
+ struct qemud_vm *vm = qemudFindVMByUUID(driver, dom->uuid);
if (!vm) {
- qemudReportError(NULL, NULL, NULL, VIR_ERR_INVALID_DOMAIN, "no domain with matching uuid");
+ qemudReportError(dom->conn, dom, NULL, VIR_ERR_INVALID_DOMAIN, "no domain with matching uuid");
return -1;
}
- *runstate = vm->state;
+ info->state = vm->state;
if (!qemudIsActiveVM(vm)) {
- *cputime = 0;
+ info->cpuTime = 0;
} else {
- if (qemudGetProcessInfo(cputime, vm->pid) < 0) {
- qemudReportError(NULL, NULL, NULL, VIR_ERR_OPERATION_FAILED, "cannot read cputime for domain");
+ if (qemudGetProcessInfo(&(info->cpuTime), vm->pid) < 0) {
+ qemudReportError(dom->conn, dom, NULL, VIR_ERR_OPERATION_FAILED, "cannot read cputime for domain");
return -1;
}
}
- *maxmem = vm->def->maxmem;
- *memory = vm->def->memory;
- *nrVirtCpu = vm->def->vcpus;
+ info->maxMem = vm->def->maxmem;
+ info->memory = vm->def->memory;
+ info->nrVirtCpu = vm->def->vcpus;
return 0;
}
-int qemudDomainSave(struct qemud_driver *driver, int id,
+int qemudDomainSave(virDomainPtr dom,
const char *path ATTRIBUTE_UNUSED) {
- struct qemud_vm *vm = qemudFindVMByID(driver, id);
+ struct qemud_driver *driver = (struct qemud_driver *)dom->conn->privateData;
+ struct qemud_vm *vm = qemudFindVMByID(driver, dom->id);
if (!vm) {
- qemudReportError(NULL, NULL, NULL, VIR_ERR_INVALID_DOMAIN, "no domain with matching id %d", id);
+ qemudReportError(dom->conn, dom, NULL, VIR_ERR_INVALID_DOMAIN, "no domain with matching id %d", dom->id);
return -1;
}
if (!qemudIsActiveVM(vm)) {
- qemudReportError(NULL, NULL, NULL, VIR_ERR_OPERATION_FAILED, "domain is not running");
+ qemudReportError(dom->conn, dom, NULL, VIR_ERR_OPERATION_FAILED, "domain is not running");
return -1;
}
- qemudReportError(NULL, NULL, NULL, VIR_ERR_OPERATION_FAILED, "save is not supported");
+ qemudReportError(dom->conn, dom, NULL, VIR_ERR_OPERATION_FAILED, "save is not supported");
return -1;
}
-int qemudDomainRestore(struct qemud_driver *driver ATTRIBUTE_UNUSED,
+int qemudDomainRestore(virConnectPtr conn,
const char *path ATTRIBUTE_UNUSED) {
- qemudReportError(NULL, NULL, NULL, VIR_ERR_OPERATION_FAILED, "restore is not supported");
+ /*struct qemud_driver *driver = (struct qemud_driver *)conn->privateData;*/
+ qemudReportError(conn, NULL, NULL, VIR_ERR_OPERATION_FAILED, "restore is not supported");
return -1;
}
-int qemudDomainDumpXML(struct qemud_driver *driver, const unsigned char *uuid, char *xml, int xmllen) {
- struct qemud_vm *vm = qemudFindVMByUUID(driver, uuid);
- char *vmxml;
+char *qemudDomainDumpXML(virDomainPtr dom,
+ int flags ATTRIBUTE_UNUSED) {
+ struct qemud_driver *driver = (struct qemud_driver *)dom->conn->privateData;
+ struct qemud_vm *vm = qemudFindVMByUUID(driver, dom->uuid);
if (!vm) {
- qemudReportError(NULL, NULL, NULL, VIR_ERR_INVALID_DOMAIN, "no domain with matching uuid");
- return -1;
+ qemudReportError(dom->conn, dom, NULL, VIR_ERR_INVALID_DOMAIN, "no domain with matching uuid");
+ return NULL;
}
- vmxml = qemudGenerateXML(driver, vm, vm->def, 1);
- if (!vmxml)
- return -1;
-
- strncpy(xml, vmxml, xmllen);
- xml[xmllen-1] = '\0';
-
- free(vmxml);
-
- return 0;
+ return qemudGenerateXML(driver, vm, vm->def, 1);
}
-int qemudListDefinedDomains(struct qemud_driver *driver, char *const*names, int nnames) {
+int qemudListDefinedDomains(virConnectPtr conn,
+ char **const names, int nnames) {
+ struct qemud_driver *driver = (struct qemud_driver *)conn->privateData;
struct qemud_vm *vm = driver->vms;
- int got = 0;
+ int got = 0, i;
while (vm && got < nnames) {
if (!qemudIsActiveVM(vm)) {
- strncpy(names[got], vm->def->name, QEMUD_MAX_NAME_LEN-1);
- names[got][QEMUD_MAX_NAME_LEN-1] = '\0';
+ if (!(names[got] = strdup(vm->def->name))) {
+ qemudReportError(conn, NULL, NULL, VIR_ERR_NO_MEMORY, "names");
+ goto cleanup;
+ }
got++;
}
vm = vm->next;
}
return got;
+
+ cleanup:
+ for (i = 0 ; i < got ; i++)
+ free(names[i]);
+ return -1;
}
-int qemudNumDefinedDomains(struct qemud_driver *driver) {
+int qemudNumDefinedDomains(virConnectPtr conn) {
+ struct qemud_driver *driver = (struct qemud_driver *)conn->privateData;
return driver->ninactivevms;
}
-struct qemud_vm *qemudDomainStart(struct qemud_driver *driver, const unsigned char *uuid) {
- struct qemud_vm *vm = qemudFindVMByUUID(driver, uuid);
+int qemudDomainStart(virDomainPtr dom) {
+ struct qemud_driver *driver = (struct qemud_driver *)dom->conn->privateData;
+ struct qemud_vm *vm = qemudFindVMByUUID(driver, dom->uuid);
if (!vm) {
- qemudReportError(NULL, NULL, NULL, VIR_ERR_INVALID_DOMAIN,
+ qemudReportError(dom->conn, dom, NULL, VIR_ERR_INVALID_DOMAIN,
"no domain with matching uuid");
- return NULL;
+ return -1;
}
- return qemudStartVMDaemon(driver, vm) < 0 ? NULL : vm;
+ return qemudStartVMDaemon(driver, vm);
}
-struct qemud_vm *qemudDomainDefine(struct qemud_driver *driver, const char *xml) {
+virDomainPtr qemudDomainDefine(virConnectPtr conn, const char *xml) {
+ struct qemud_driver *driver = (struct qemud_driver *)conn->privateData;
struct qemud_vm_def *def;
struct qemud_vm *vm;
+ virDomainPtr dom;
if (!(def = qemudParseVMDef(driver, xml, NULL)))
return NULL;
return NULL;
}
- return vm;
+ dom = calloc(1, sizeof(struct _virDomain));
+ if (!dom) {
+ qemudReportError(conn, NULL, NULL, VIR_ERR_NO_MEMORY, "virDomainPtr");
+ return NULL;
+ }
+
+ dom->conn = conn;
+ dom->id = vm->id;
+ dom->name = vm->def->name;
+ memcpy(dom->uuid, vm->def->uuid, sizeof(dom->uuid));
+ return dom;
}
-int qemudDomainUndefine(struct qemud_driver *driver, const unsigned char *uuid) {
- struct qemud_vm *vm = qemudFindVMByUUID(driver, uuid);
+int qemudDomainUndefine(virDomainPtr dom) {
+ struct qemud_driver *driver = (struct qemud_driver *)dom->conn->privateData;
+ struct qemud_vm *vm = qemudFindVMByUUID(driver, dom->uuid);
if (!vm) {
- qemudReportError(NULL, NULL, NULL, VIR_ERR_INVALID_DOMAIN, "no domain with matching uuid");
+ qemudReportError(dom->conn, dom, NULL, VIR_ERR_INVALID_DOMAIN, "no domain with matching uuid");
return -1;
}
if (qemudIsActiveVM(vm)) {
- qemudReportError(NULL, NULL, NULL, VIR_ERR_INTERNAL_ERROR, "cannot delete active domain");
+ qemudReportError(dom->conn, dom, NULL, VIR_ERR_INTERNAL_ERROR, "cannot delete active domain");
return -1;
}
return 0;
}
-int qemudDomainGetAutostart(struct qemud_driver *driver,
- const unsigned char *uuid,
- int *autostart) {
- struct qemud_vm *vm = qemudFindVMByUUID(driver, uuid);
+int qemudDomainGetAutostart(virDomainPtr dom,
+ int *autostart) {
+ struct qemud_driver *driver = (struct qemud_driver *)dom->conn->privateData;
+ struct qemud_vm *vm = qemudFindVMByUUID(driver, dom->uuid);
if (!vm) {
- qemudReportError(NULL, NULL, NULL, VIR_ERR_INVALID_DOMAIN, "no domain with matching uuid");
+ qemudReportError(dom->conn, dom, NULL, VIR_ERR_INVALID_DOMAIN, "no domain with matching uuid");
return -1;
}
return 0;
}
-int qemudDomainSetAutostart(struct qemud_driver *driver,
- const unsigned char *uuid,
- int autostart) {
- struct qemud_vm *vm = qemudFindVMByUUID(driver, uuid);
+int qemudDomainSetAutostart(virDomainPtr dom,
+ int autostart) {
+ struct qemud_driver *driver = (struct qemud_driver *)dom->conn->privateData;
+ struct qemud_vm *vm = qemudFindVMByUUID(driver, dom->uuid);
if (!vm) {
- qemudReportError(NULL, NULL, NULL, VIR_ERR_INVALID_DOMAIN, "no domain with matching uuid");
+ qemudReportError(dom->conn, dom, NULL, VIR_ERR_INVALID_DOMAIN, "no domain with matching uuid");
return -1;
}
int err;
if ((err = qemudEnsureDir(driver->autostartDir))) {
- qemudReportError(NULL, NULL, NULL, VIR_ERR_INTERNAL_ERROR,
+ qemudReportError(dom->conn, dom, NULL, VIR_ERR_INTERNAL_ERROR,
"cannot create autostart directory %s: %s",
driver->autostartDir, strerror(err));
return -1;
}
if (symlink(vm->configFile, vm->autostartLink) < 0) {
- qemudReportError(NULL, NULL, NULL, VIR_ERR_INTERNAL_ERROR,
+ qemudReportError(dom->conn, dom, NULL, VIR_ERR_INTERNAL_ERROR,
"Failed to create symlink '%s' to '%s': %s",
vm->autostartLink, vm->configFile, strerror(errno));
return -1;
}
} else {
if (unlink(vm->autostartLink) < 0 && errno != ENOENT && errno != ENOTDIR) {
- qemudReportError(NULL, NULL, NULL, VIR_ERR_INTERNAL_ERROR,
+ qemudReportError(dom->conn, dom, NULL, VIR_ERR_INTERNAL_ERROR,
"Failed to delete symlink '%s': %s",
vm->autostartLink, strerror(errno));
return -1;
return NULL;
}
-int qemudNumNetworks(struct qemud_driver *driver) {
+virNetworkPtr qemudNetworkLookupByUUID(virConnectPtr conn ATTRIBUTE_UNUSED,
+ const unsigned char *uuid) {
+ struct qemud_driver *driver = (struct qemud_driver *)conn->privateData;
+ struct qemud_network *network = qemudFindNetworkByUUID(driver, uuid);
+ virNetworkPtr net;
+
+ if (!network) {
+ qemudReportError(conn, NULL, NULL, VIR_ERR_INTERNAL_ERROR, "no network with matching uuid");
+ return NULL;
+ }
+
+ net = calloc(1, sizeof(struct _virNetwork));
+ if (!net) {
+ qemudReportError(conn, NULL, NULL, VIR_ERR_NO_MEMORY, "virNetworkPtr");
+ return NULL;
+ }
+
+ net->conn = conn;
+ net->name = network->def->name;
+ memcpy(net->uuid, network->def->uuid, sizeof(net->uuid));
+ return net;
+}
+virNetworkPtr qemudNetworkLookupByName(virConnectPtr conn ATTRIBUTE_UNUSED,
+ const char *name) {
+ struct qemud_driver *driver = (struct qemud_driver *)conn->privateData;
+ struct qemud_network *network = qemudFindNetworkByName(driver, name);
+ virNetworkPtr net;
+
+ if (!network) {
+ qemudReportError(conn, NULL, NULL, VIR_ERR_INTERNAL_ERROR, "no network with matching name");
+ return NULL;
+ }
+
+ net = calloc(1, sizeof(struct _virNetwork));
+ if (!net) {
+ qemudReportError(conn, NULL, NULL, VIR_ERR_NO_MEMORY, "virNetworkPtr");
+ return NULL;
+ }
+
+ net->conn = conn;
+ net->name = network->def->name;
+ memcpy(net->uuid, network->def->uuid, sizeof(net->uuid));
+ return net;
+}
+
+static virDrvOpenStatus qemudOpenNetwork(virConnectPtr conn,
+ const char *name ATTRIBUTE_UNUSED,
+ int flags ATTRIBUTE_UNUSED) {
+ if (!qemu_driver)
+ return VIR_DRV_OPEN_DECLINED;
+
+ conn->networkPrivateData = qemu_driver;
+ return VIR_DRV_OPEN_SUCCESS;
+}
+
+static int qemudCloseNetwork(virConnectPtr conn) {
+ conn->networkPrivateData = NULL;
+ return 0;
+}
+
+int qemudNumNetworks(virConnectPtr conn) {
+ struct qemud_driver *driver = (struct qemud_driver *)conn->networkPrivateData;
return driver->nactivenetworks;
}
-int qemudListNetworks(struct qemud_driver *driver, char *const*names, int nnames) {
+int qemudListNetworks(virConnectPtr conn, char **const names, int nnames) {
+ struct qemud_driver *driver = (struct qemud_driver *)conn->networkPrivateData;
struct qemud_network *network = driver->networks;
- int got = 0;
+ int got = 0, i;
while (network && got < nnames) {
if (qemudIsActiveNetwork(network)) {
- strncpy(names[got], network->def->name, QEMUD_MAX_NAME_LEN-1);
- names[got][QEMUD_MAX_NAME_LEN-1] = '\0';
+ if (!(names[got] = strdup(network->def->name))) {
+ qemudReportError(conn, NULL, NULL, VIR_ERR_NO_MEMORY, "names");
+ goto cleanup;
+ }
got++;
}
network = network->next;
}
return got;
+
+ cleanup:
+ for (i = 0 ; i < got ; i++)
+ free(names[i]);
+ return -1;
}
-int qemudNumDefinedNetworks(struct qemud_driver *driver) {
+int qemudNumDefinedNetworks(virConnectPtr conn) {
+ struct qemud_driver *driver = (struct qemud_driver *)conn->networkPrivateData;
return driver->ninactivenetworks;
}
-int qemudListDefinedNetworks(struct qemud_driver *driver, char *const*names, int nnames) {
+int qemudListDefinedNetworks(virConnectPtr conn, char **const names, int nnames) {
+ struct qemud_driver *driver = (struct qemud_driver *)conn->networkPrivateData;
struct qemud_network *network = driver->networks;
- int got = 0;
+ int got = 0, i;
while (network && got < nnames) {
if (!qemudIsActiveNetwork(network)) {
- strncpy(names[got], network->def->name, QEMUD_MAX_NAME_LEN-1);
- names[got][QEMUD_MAX_NAME_LEN-1] = '\0';
+ if (!(names[got] = strdup(network->def->name))) {
+ qemudReportError(conn, NULL, NULL, VIR_ERR_NO_MEMORY, "names");
+ goto cleanup;
+ }
got++;
}
network = network->next;
}
return got;
+
+ cleanup:
+ for (i = 0 ; i < got ; i++)
+ free(names[i]);
+ return -1;
}
-struct qemud_network *qemudNetworkCreate(struct qemud_driver *driver, const char *xml) {
+virNetworkPtr qemudNetworkCreate(virConnectPtr conn, const char *xml) {
+ struct qemud_driver *driver = (struct qemud_driver *)conn->networkPrivateData;
struct qemud_network_def *def;
struct qemud_network *network;
+ virNetworkPtr net;
if (!(def = qemudParseNetworkDef(driver, xml, NULL)))
return NULL;
return NULL;
}
- return network;
+ net = calloc(1, sizeof(struct _virNetwork));
+ if (!net) {
+ qemudReportError(conn, NULL, NULL, VIR_ERR_NO_MEMORY, "virNetworkPtr");
+ return NULL;
+ }
+
+ net->conn = conn;
+ net->name = network->def->name;
+ memcpy(net->uuid, network->def->uuid, sizeof(net->uuid));
+
+ return net;
}
-struct qemud_network *qemudNetworkDefine(struct qemud_driver *driver, const char *xml) {
+virNetworkPtr qemudNetworkDefine(virConnectPtr conn, const char *xml) {
+ struct qemud_driver *driver = (struct qemud_driver *)conn->networkPrivateData;
struct qemud_network_def *def;
struct qemud_network *network;
+ virNetworkPtr net;
if (!(def = qemudParseNetworkDef(driver, xml, NULL)))
return NULL;
return NULL;
}
- return network;
+ net = calloc(1, sizeof(struct _virNetwork));
+ if (!net) {
+ qemudReportError(conn, NULL, NULL, VIR_ERR_NO_MEMORY, "virNetworkPtr");
+ return NULL;
+ }
+
+ net->conn = conn;
+ net->name = network->def->name;
+ memcpy(net->uuid, network->def->uuid, sizeof(net->uuid));
+
+ return net;
}
-int qemudNetworkUndefine(struct qemud_driver *driver, const unsigned char *uuid) {
- struct qemud_network *network = qemudFindNetworkByUUID(driver, uuid);
+int qemudNetworkUndefine(virNetworkPtr net) {
+ struct qemud_driver *driver = (struct qemud_driver *)net->conn->networkPrivateData;
+ struct qemud_network *network = qemudFindNetworkByUUID(driver, net->uuid);
if (!network) {
- qemudReportError(NULL, NULL, NULL, VIR_ERR_INVALID_DOMAIN, "no network with matching uuid");
+ qemudReportError(net->conn, NULL, net, VIR_ERR_INVALID_DOMAIN, "no network with matching uuid");
return -1;
}
return 0;
}
-struct qemud_network *qemudNetworkStart(struct qemud_driver *driver, const unsigned char *uuid) {
- struct qemud_network *network = qemudFindNetworkByUUID(driver, uuid);
+int qemudNetworkStart(virNetworkPtr net) {
+ struct qemud_driver *driver = (struct qemud_driver *)net->conn->networkPrivateData;
+ struct qemud_network *network = qemudFindNetworkByUUID(driver, net->uuid);
if (!network) {
- qemudReportError(NULL, NULL, NULL, VIR_ERR_INVALID_NETWORK,
+ qemudReportError(net->conn, NULL, net, VIR_ERR_INVALID_NETWORK,
"no network with matching uuid");
- return NULL;
+ return -1;
}
- return qemudStartNetworkDaemon(driver, network) < 0 ? NULL : network;
+ return qemudStartNetworkDaemon(driver, network);
}
-int qemudNetworkDestroy(struct qemud_driver *driver, const unsigned char *uuid) {
- struct qemud_network *network = qemudFindNetworkByUUID(driver, uuid);
+int qemudNetworkDestroy(virNetworkPtr net) {
+ struct qemud_driver *driver = (struct qemud_driver *)net->conn->networkPrivateData;
+ struct qemud_network *network = qemudFindNetworkByUUID(driver, net->uuid);
if (!network) {
- qemudReportError(NULL, NULL, NULL, VIR_ERR_INVALID_NETWORK,
+ qemudReportError(net->conn, NULL, net, VIR_ERR_INVALID_NETWORK,
"no network with matching uuid");
return -1;
}
return qemudShutdownNetworkDaemon(driver, network);
}
-int qemudNetworkDumpXML(struct qemud_driver *driver, const unsigned char *uuid, char *xml, int xmllen) {
- struct qemud_network *network = qemudFindNetworkByUUID(driver, uuid);
- char *networkxml;
+char *qemudNetworkDumpXML(virNetworkPtr net, int flags ATTRIBUTE_UNUSED) {
+ struct qemud_driver *driver = (struct qemud_driver *)net->conn->networkPrivateData;
+ struct qemud_network *network = qemudFindNetworkByUUID(driver, net->uuid);
+
if (!network) {
- qemudReportError(NULL, NULL, NULL, VIR_ERR_INVALID_NETWORK, "no network with matching uuid");
- return -1;
+ qemudReportError(net->conn, NULL, net, VIR_ERR_INVALID_NETWORK,
+ "no network with matching uuid");
+ return NULL;
}
- networkxml = qemudGenerateNetworkXML(driver, network, network->def);
- if (!networkxml)
- return -1;
-
- strncpy(xml, networkxml, xmllen);
- xml[xmllen-1] = '\0';
-
- free(networkxml);
-
- return 0;
+ return qemudGenerateNetworkXML(driver, network, network->def);
}
-int qemudNetworkGetBridgeName(struct qemud_driver *driver, const unsigned char *uuid, char *ifname, int ifnamelen) {
- struct qemud_network *network = qemudFindNetworkByUUID(driver, uuid);
-
+char *qemudNetworkGetBridgeName(virNetworkPtr net) {
+ struct qemud_driver *driver = (struct qemud_driver *)net->conn->networkPrivateData;
+ struct qemud_network *network = qemudFindNetworkByUUID(driver, net->uuid);
+ char *bridge;
if (!network) {
- qemudReportError(NULL, NULL, NULL, VIR_ERR_INVALID_NETWORK, "no network with matching id");
- return -1;
+ qemudReportError(net->conn, NULL, net, VIR_ERR_INVALID_NETWORK, "no network with matching id");
+ return NULL;
}
- strncpy(ifname, network->bridge, ifnamelen);
- ifname[ifnamelen-1] = '\0';
-
- return 0;
+ bridge = strdup(network->bridge);
+ if (!bridge) {
+ qemudReportError(net->conn, NULL, net, VIR_ERR_NO_MEMORY, "bridge");
+ return NULL;
+ }
+ return bridge;
}
-int qemudNetworkGetAutostart(struct qemud_driver *driver,
- const unsigned char *uuid,
+int qemudNetworkGetAutostart(virNetworkPtr net,
int *autostart) {
- struct qemud_network *network = qemudFindNetworkByUUID(driver, uuid);
+ struct qemud_driver *driver = (struct qemud_driver *)net->conn->networkPrivateData;
+ struct qemud_network *network = qemudFindNetworkByUUID(driver, net->uuid);
if (!network) {
- qemudReportError(NULL, NULL, NULL, VIR_ERR_INVALID_NETWORK, "no network with matching uuid");
+ qemudReportError(net->conn, NULL, net, VIR_ERR_INVALID_NETWORK, "no network with matching uuid");
return -1;
}
return 0;
}
-int qemudNetworkSetAutostart(struct qemud_driver *driver,
- const unsigned char *uuid,
+int qemudNetworkSetAutostart(virNetworkPtr net,
int autostart) {
- struct qemud_network *network = qemudFindNetworkByUUID(driver, uuid);
+ struct qemud_driver *driver = (struct qemud_driver *)net->conn->networkPrivateData;
+ struct qemud_network *network = qemudFindNetworkByUUID(driver, net->uuid);
if (!network) {
- qemudReportError(NULL, NULL, NULL, VIR_ERR_INVALID_NETWORK, "no network with matching uuid");
+ qemudReportError(net->conn, NULL, net, VIR_ERR_INVALID_NETWORK, "no network with matching uuid");
return -1;
}
int err;
if ((err = qemudEnsureDir(driver->networkAutostartDir))) {
- qemudReportError(NULL, NULL, NULL, VIR_ERR_INTERNAL_ERROR,
+ qemudReportError(net->conn, NULL, net, VIR_ERR_INTERNAL_ERROR,
"cannot create autostart directory %s: %s",
driver->networkAutostartDir, strerror(err));
return -1;
}
if (symlink(network->configFile, network->autostartLink) < 0) {
- qemudReportError(NULL, NULL, NULL, VIR_ERR_INTERNAL_ERROR,
+ qemudReportError(net->conn, NULL, net, VIR_ERR_INTERNAL_ERROR,
"Failed to create symlink '%s' to '%s': %s",
network->autostartLink, network->configFile, strerror(errno));
return -1;
}
} else {
if (unlink(network->autostartLink) < 0 && errno != ENOENT && errno != ENOTDIR) {
- qemudReportError(NULL, NULL, NULL, VIR_ERR_INTERNAL_ERROR,
+ qemudReportError(net->conn, NULL, net, VIR_ERR_INTERNAL_ERROR,
"Failed to delete symlink '%s': %s",
network->autostartLink, strerror(errno));
return -1;
return 0;
}
+static virDriver qemuDriver = {
+ VIR_DRV_QEMU,
+ "QEMU",
+ LIBVIR_VERSION_NUMBER,
+ qemudOpen, /* open */
+ qemudClose, /* close */
+ qemudGetType, /* type */
+ qemudGetVersion, /* version */
+ NULL, /* hostname */
+ NULL, /* uri */
+ qemudGetMaxVCPUs, /* getMaxVcpus */
+ qemudGetNodeInfo, /* nodeGetInfo */
+ qemudGetCapabilities, /* getCapabilities */
+ qemudListDomains, /* listDomains */
+ qemudNumDomains, /* numOfDomains */
+ qemudDomainCreate, /* domainCreateLinux */
+ qemudDomainLookupByID, /* domainLookupByID */
+ qemudDomainLookupByUUID, /* domainLookupByUUID */
+ qemudDomainLookupByName, /* domainLookupByName */
+ qemudDomainSuspend, /* domainSuspend */
+ qemudDomainResume, /* domainResume */
+ qemudDomainDestroy, /* domainShutdown */
+ NULL, /* domainReboot */
+ qemudDomainDestroy, /* domainDestroy */
+ qemudDomainGetOSType, /* domainGetOSType */
+ NULL, /* domainGetMaxMemory */
+ NULL, /* domainSetMaxMemory */
+ NULL, /* domainSetMemory */
+ qemudDomainGetInfo, /* domainGetInfo */
+ qemudDomainSave, /* domainSave */
+ qemudDomainRestore, /* domainRestore */
+ NULL, /* domainCoreDump */
+ NULL, /* domainSetVcpus */
+ NULL, /* domainPinVcpu */
+ NULL, /* domainGetVcpus */
+ NULL, /* domainGetMaxVcpus */
+ qemudDomainDumpXML, /* domainDumpXML */
+ qemudListDefinedDomains, /* listDomains */
+ qemudNumDefinedDomains, /* numOfDomains */
+ qemudDomainStart, /* domainCreate */
+ qemudDomainDefine, /* domainDefineXML */
+ qemudDomainUndefine, /* domainUndefine */
+ NULL, /* domainAttachDevice */
+ NULL, /* domainDetachDevice */
+ qemudDomainGetAutostart, /* domainGetAutostart */
+ qemudDomainSetAutostart, /* domainSetAutostart */
+ NULL, /* domainGetSchedulerType */
+ NULL, /* domainGetSchedulerParameters */
+ NULL, /* domainSetSchedulerParameters */
+};
+
+static virNetworkDriver qemuNetworkDriver = {
+ qemudOpenNetwork, /* open */
+ qemudCloseNetwork, /* close */
+ qemudNumNetworks, /* numOfNetworks */
+ qemudListNetworks, /* listNetworks */
+ qemudNumDefinedNetworks, /* numOfDefinedNetworks */
+ qemudListDefinedNetworks, /* listDefinedNetworks */
+ qemudNetworkLookupByUUID, /* networkLookupByUUID */
+ qemudNetworkLookupByName, /* networkLookupByName */
+ qemudNetworkCreate, /* networkCreateXML */
+ qemudNetworkDefine, /* networkDefineXML */
+ qemudNetworkUndefine, /* networkUndefine */
+ qemudNetworkStart, /* networkCreate */
+ qemudNetworkDestroy, /* networkDestroy */
+ qemudNetworkDumpXML, /* networkDumpXML */
+ qemudNetworkGetBridgeName, /* networkGetBridgeName */
+ qemudNetworkGetAutostart, /* networkGetAutostart */
+ qemudNetworkSetAutostart, /* networkSetAutostart */
+};
+
+
/*
* Local variables:
* indent-tabs-mode: nil
projects / libvirt.git / commitdiff