自学教程：C++ virDomainObjUnlock函数代码示例

static intopenvzDomainGetState(virDomainPtr dom,                     int *state,                     int *reason,                     unsigned int flags){    struct openvz_driver *driver = dom->conn->privateData;    virDomainObjPtr vm;    int ret = -1;    virCheckFlags(0, -1);    openvzDriverLock(driver);    vm = virDomainFindByUUID(&driver->domains, dom->uuid);    openvzDriverUnlock(driver);    if (!vm) {        openvzError(VIR_ERR_NO_DOMAIN, "%s",                    _("no domain with matching uuid"));        goto cleanup;    }    ret = openvzGetVEStatus(vm, state, reason);cleanup:    if (vm)        virDomainObjUnlock(vm);    return ret;}

static virDomainPtrvmwareDomainLookupByName(virConnectPtr conn, const char *name){    struct vmware_driver *driver = conn->privateData;    virDomainObjPtr vm;    virDomainPtr dom = NULL;    vmwareDriverLock(driver);    vm = virDomainFindByName(&driver->domains, name);    vmwareDriverUnlock(driver);    if (!vm) {        vmwareError(VIR_ERR_NO_DOMAIN, NULL);        goto cleanup;    }    dom = virGetDomain(conn, vm->def->name, vm->def->uuid);    if (dom)        dom->id = vm->def->id;  cleanup:    if (vm)        virDomainObjUnlock(vm);    return dom;}

static intopenvzDomainSetAutostart(virDomainPtr dom, int autostart){    struct openvz_driver *driver = dom->conn->privateData;    virDomainObjPtr vm;    const char *prog[] = { VZCTL, "--quiet", "set", PROGRAM_SENTINAL,                           "--onboot", autostart ? "yes" : "no",                           "--save", NULL };    int ret = -1;    openvzDriverLock(driver);    vm = virDomainFindByUUID(&driver->domains, dom->uuid);    openvzDriverUnlock(driver);    if (!vm) {        openvzError(VIR_ERR_NO_DOMAIN, "%s",                    _("no domain with matching uuid"));        goto cleanup;    }    openvzSetProgramSentinal(prog, vm->def->name);    if (virRun(prog, NULL) < 0) {        goto cleanup;    }    ret = 0;cleanup:    if (vm)        virDomainObjUnlock(vm);    return ret;}

static char *vmwareDomainGetXMLDesc(virDomainPtr dom, unsigned int flags){    struct vmware_driver *driver = dom->conn->privateData;    virDomainObjPtr vm;    char *ret = NULL;    /* Flags checked by virDomainDefFormat */    vmwareDriverLock(driver);    vm = virDomainFindByUUID(&driver->domains, dom->uuid);    vmwareDriverUnlock(driver);    if (!vm) {        virReportError(VIR_ERR_NO_DOMAIN, "%s",                       _("no domain with matching uuid"));        goto cleanup;    }    ret = virDomainDefFormat(vm->def, flags);  cleanup:    if (vm)        virDomainObjUnlock(vm);    return ret;}

static intvmwareDomainCreateWithFlags(virDomainPtr dom,                            unsigned int flags ATTRIBUTE_UNUSED){    struct vmware_driver *driver = dom->conn->privateData;    virDomainObjPtr vm;    int ret = -1;    vmwareDriverLock(driver);    vm = virDomainFindByUUID(&driver->domains, dom->uuid);    if (!vm) {        char uuidstr[VIR_UUID_STRING_BUFLEN];        virUUIDFormat(dom->uuid, uuidstr);        vmwareError(VIR_ERR_NO_DOMAIN,                    _("No domain with matching uuid '%s'"), uuidstr);        goto cleanup;    }    if (virDomainObjIsActive(vm)) {        vmwareError(VIR_ERR_OPERATION_INVALID,                    "%s", _("Domain is already running"));        goto cleanup;    }    ret = vmwareStartVM(driver, vm);cleanup:    if (vm)        virDomainObjUnlock(vm);    vmwareDriverUnlock(driver);    return ret;}

static intvmwareDomainGetInfo(virDomainPtr dom, virDomainInfoPtr info){    struct vmware_driver *driver = dom->conn->privateData;    virDomainObjPtr vm;    int ret = -1;    vmwareDriverLock(driver);    vm = virDomainFindByUUID(&driver->domains, dom->uuid);    vmwareDriverUnlock(driver);    if (!vm) {        vmwareError(VIR_ERR_NO_DOMAIN, "%s",                    _("no domain with matching uuid"));        goto cleanup;    }    info->state = vm->state;    info->cpuTime = 0;    info->maxMem = vm->def->mem.max_balloon;    info->memory = vm->def->mem.cur_balloon;    info->nrVirtCpu = vm->def->vcpus;    ret = 0;  cleanup:    if (vm)        virDomainObjUnlock(vm);    return ret;}

static intvmwareDomainResume(virDomainPtr dom){    struct vmware_driver *driver = dom->conn->privateData;    virDomainObjPtr vm;    const char *cmd[] = {        VMRUN, "-T", PROGRAM_SENTINAL, "unpause", PROGRAM_SENTINAL,        NULL    };    int ret = -1;    if (driver->type == TYPE_PLAYER) {        vmwareError(VIR_ERR_INTERNAL_ERROR, "%s",                    _("vmplayer does not support libvirt suspend/resume"                      "(vmware pause/unpause) operation "));        return ret;    }    vmwareDriverLock(driver);    vm = virDomainFindByUUID(&driver->domains, dom->uuid);    vmwareDriverUnlock(driver);    if (!vm) {        vmwareError(VIR_ERR_NO_DOMAIN, "%s",                    _("no domain with matching uuid"));        goto cleanup;    }    vmwareSetSentinal(cmd, vmw_types[driver->type]);    vmwareSetSentinal(cmd, ((vmwareDomainPtr) vm->privateData)->vmxPath);    if (vm->state != VIR_DOMAIN_PAUSED) {        vmwareError(VIR_ERR_INTERNAL_ERROR, "%s",                    _("domain is not in suspend state"));        goto cleanup;    }    if (virRun(cmd, NULL) < 0)        goto cleanup;    vm->state = VIR_DOMAIN_RUNNING;    ret = 0;  cleanup:    if (vm)        virDomainObjUnlock(vm);    return ret;}

static intvmwareDomainReboot(virDomainPtr dom, unsigned int flags){    struct vmware_driver *driver = dom->conn->privateData;    const char * vmxPath = NULL;    virDomainObjPtr vm;    const char *cmd[] = {        VMRUN, "-T", PROGRAM_SENTINAL,        "reset", PROGRAM_SENTINAL, "soft", NULL    };    int ret = -1;    virCheckFlags(0, -1);    vmwareDriverLock(driver);    vm = virDomainFindByUUID(&driver->domains, dom->uuid);    vmwareDriverUnlock(driver);    if (!vm) {        virReportError(VIR_ERR_NO_DOMAIN, "%s",                       _("no domain with matching uuid"));        goto cleanup;    }    vmxPath = ((vmwareDomainPtr) vm->privateData)->vmxPath;    vmwareSetSentinal(cmd, vmw_types[driver->type]);    vmwareSetSentinal(cmd, vmxPath);    if (vmwareUpdateVMStatus(driver, vm) < 0)        goto cleanup;    if (virDomainObjGetState(vm, NULL) != VIR_DOMAIN_RUNNING) {        virReportError(VIR_ERR_INTERNAL_ERROR, "%s",                       _("domain is not in running state"));        goto cleanup;    }    if (virRun(cmd, NULL) < 0)        goto cleanup;    ret = 0;  cleanup:    if (vm)        virDomainObjUnlock(vm);    return ret;}

static intopenvzDomainCreateWithFlags(virDomainPtr dom, unsigned int flags){    struct openvz_driver *driver = dom->conn->privateData;    virDomainObjPtr vm;    const char *prog[] = {VZCTL, "--quiet", "start", PROGRAM_SENTINAL, NULL };    int ret = -1;    int status;    virCheckFlags(0, -1);    openvzDriverLock(driver);    vm = virDomainFindByName(&driver->domains, dom->name);    openvzDriverUnlock(driver);    if (!vm) {        openvzError(VIR_ERR_NO_DOMAIN, "%s",                    _("no domain with matching id"));        goto cleanup;    }    if (openvzGetVEStatus(vm, &status, NULL) == -1)        goto cleanup;    if (status != VIR_DOMAIN_SHUTOFF) {        openvzError(VIR_ERR_OPERATION_DENIED, "%s",                    _("domain is not in shutoff state"));        goto cleanup;    }    openvzSetProgramSentinal(prog, vm->def->name);    if (virRun(prog, NULL) < 0) {        goto cleanup;    }    vm->pid = strtoI(vm->def->name);    vm->def->id = vm->pid;    dom->id = vm->pid;    virDomainObjSetState(vm, VIR_DOMAIN_RUNNING, VIR_DOMAIN_RUNNING_BOOTED);    ret = 0;cleanup:    if (vm)        virDomainObjUnlock(vm);    return ret;}

static intvmwareDomainUndefineFlags(virDomainPtr dom,                          unsigned int flags){    struct vmware_driver *driver = dom->conn->privateData;    virDomainObjPtr vm;    int ret = -1;    virCheckFlags(0, -1);    vmwareDriverLock(driver);    vm = virDomainFindByUUID(&driver->domains, dom->uuid);    if (!vm) {        char uuidstr[VIR_UUID_STRING_BUFLEN];        virUUIDFormat(dom->uuid, uuidstr);        virReportError(VIR_ERR_NO_DOMAIN,                       _("no domain with matching uuid '%s'"), uuidstr);        goto cleanup;    }    if (!vm->persistent) {        virReportError(VIR_ERR_OPERATION_INVALID,                       "%s", _("cannot undefine transient domain"));        goto cleanup;    }    if (vmwareUpdateVMStatus(driver, vm) < 0)        goto cleanup;    if (virDomainObjIsActive(vm)) {        vm->persistent = 0;    } else {        virDomainRemoveInactive(&driver->domains, vm);        vm = NULL;    }    ret = 0;  cleanup:    if (vm)        virDomainObjUnlock(vm);    vmwareDriverUnlock(driver);    return ret;}

static intopenvzDomainShutdownFlags(virDomainPtr dom,                          unsigned int flags) {    struct openvz_driver *driver = dom->conn->privateData;    virDomainObjPtr vm;    const char *prog[] = {VZCTL, "--quiet", "stop", PROGRAM_SENTINAL, NULL};    int ret = -1;    int status;    virCheckFlags(0, -1);    openvzDriverLock(driver);    vm = virDomainFindByUUID(&driver->domains, dom->uuid);    openvzDriverUnlock(driver);    if (!vm) {        openvzError(VIR_ERR_NO_DOMAIN, "%s",                    _("no domain with matching uuid"));        goto cleanup;    }    if (openvzGetVEStatus(vm, &status, NULL) == -1)        goto cleanup;    openvzSetProgramSentinal(prog, vm->def->name);    if (status != VIR_DOMAIN_RUNNING) {        openvzError(VIR_ERR_INTERNAL_ERROR, "%s",                    _("domain is not in running state"));        goto cleanup;    }    if (virRun(prog, NULL) < 0)        goto cleanup;    vm->def->id = -1;    virDomainObjSetState(vm, VIR_DOMAIN_SHUTOFF, VIR_DOMAIN_SHUTOFF_SHUTDOWN);    dom->id = -1;    ret = 0;cleanup:    if (vm)        virDomainObjUnlock(vm);    return ret;}

static intvmwareDomainShutdownFlags(virDomainPtr dom,                          unsigned int flags){    struct vmware_driver *driver = dom->conn->privateData;    virDomainObjPtr vm;    int ret = -1;    virCheckFlags(0, -1);    vmwareDriverLock(driver);    vm = virDomainFindByUUID(&driver->domains, dom->uuid);    if (!vm) {        virReportError(VIR_ERR_NO_DOMAIN, "%s",                       _("no domain with matching uuid"));        goto cleanup;    }    if (vmwareUpdateVMStatus(driver, vm) < 0)        goto cleanup;    if (virDomainObjGetState(vm, NULL) != VIR_DOMAIN_RUNNING) {        virReportError(VIR_ERR_INTERNAL_ERROR, "%s",                       _("domain is not in running state"));        goto cleanup;    }    if (vmwareStopVM(driver, vm, VIR_DOMAIN_SHUTOFF_SHUTDOWN) < 0)        goto cleanup;    if (!vm->persistent) {        virDomainRemoveInactive(&driver->domains, vm);        vm = NULL;    }    ret = 0;  cleanup:    if (vm)        virDomainObjUnlock(vm);    vmwareDriverUnlock(driver);    return ret;}

static intopenvzDomainUndefineFlags(virDomainPtr dom,                          unsigned int flags){    struct openvz_driver *driver = dom->conn->privateData;    virDomainObjPtr vm;    const char *prog[] = { VZCTL, "--quiet", "destroy", PROGRAM_SENTINAL, NULL };    int ret = -1;    int status;    virCheckFlags(0, -1);    openvzDriverLock(driver);    vm = virDomainFindByUUID(&driver->domains, dom->uuid);    if (!vm) {        openvzError(VIR_ERR_NO_DOMAIN, "%s",                    _("no domain with matching uuid"));        goto cleanup;    }    if (openvzGetVEStatus(vm, &status, NULL) == -1)        goto cleanup;    openvzSetProgramSentinal(prog, vm->def->name);    if (virRun(prog, NULL) < 0) {        goto cleanup;    }    if (virDomainObjIsActive(vm)) {        vm->persistent = 0;    } else {        virDomainRemoveInactive(&driver->domains, vm);        vm = NULL;    }    ret = 0;cleanup:    if (vm)        virDomainObjUnlock(vm);    openvzDriverUnlock(driver);    return ret;}

static int openvzDomainIsPersistent(virDomainPtr dom){    struct openvz_driver *driver = dom->conn->privateData;    virDomainObjPtr obj;    int ret = -1;    openvzDriverLock(driver);    obj = virDomainFindByUUID(&driver->domains, dom->uuid);    openvzDriverUnlock(driver);    if (!obj) {        openvzError(VIR_ERR_NO_DOMAIN, NULL);        goto cleanup;    }    ret = obj->persistent;cleanup:    if (obj)        virDomainObjUnlock(obj);    return ret;}

static int openvzDomainGetInfo(virDomainPtr dom,                               virDomainInfoPtr info) {    struct openvz_driver *driver = dom->conn->privateData;    virDomainObjPtr vm;    int state;    int ret = -1;    openvzDriverLock(driver);    vm = virDomainFindByUUID(&driver->domains, dom->uuid);    openvzDriverUnlock(driver);    if (!vm) {        openvzError(VIR_ERR_NO_DOMAIN, "%s",                    _("no domain with matching uuid"));        goto cleanup;    }    if (openvzGetVEStatus(vm, &state, NULL) == -1)        goto cleanup;    info->state = state;    if (info->state != VIR_DOMAIN_RUNNING) {        info->cpuTime = 0;    } else {        if (openvzGetProcessInfo(&(info->cpuTime), dom->id) < 0) {            openvzError(VIR_ERR_OPERATION_FAILED,                        _("cannot read cputime for domain %d"), dom->id);            goto cleanup;        }    }    info->maxMem = vm->def->mem.max_balloon;    info->memory = vm->def->mem.cur_balloon;    info->nrVirtCpu = vm->def->vcpus;    ret = 0;cleanup:    if (vm)        virDomainObjUnlock(vm);    return ret;}

static intvmwareDomainIsActive(virDomainPtr dom){    struct vmware_driver *driver = dom->conn->privateData;    virDomainObjPtr obj;    int ret = -1;    vmwareDriverLock(driver);    obj = virDomainFindByUUID(&driver->domains, dom->uuid);    vmwareDriverUnlock(driver);    if (!obj) {        vmwareError(VIR_ERR_NO_DOMAIN, NULL);        goto cleanup;    }    ret = virDomainObjIsActive(obj);  cleanup:    if (obj)        virDomainObjUnlock(obj);    return ret;}

static intvmwareDomainShutdown(virDomainPtr dom){    struct vmware_driver *driver = dom->conn->privateData;    virDomainObjPtr vm;    int ret = -1;    vmwareDriverLock(driver);    vm = virDomainFindByUUID(&driver->domains, dom->uuid);    if (!vm) {        vmwareError(VIR_ERR_NO_DOMAIN, "%s",                    _("no domain with matching uuid"));        goto cleanup;    }    if (vm->state != VIR_DOMAIN_RUNNING) {        vmwareError(VIR_ERR_INTERNAL_ERROR, "%s",                    _("domain is not in running state"));        goto cleanup;    }    if (vmwareStopVM(driver, vm) < 0)        goto cleanup;    if (!vm->persistent) {        virDomainRemoveInactive(&driver->domains, vm);        vm = NULL;    }    ret = 0;  cleanup:    if (vm)        virDomainObjUnlock(vm);    vmwareDriverUnlock(driver);    return ret;}

static char *openvzGetOSType(virDomainPtr dom){    struct  openvz_driver *driver = dom->conn->privateData;    virDomainObjPtr vm;    char *ret = NULL;    openvzDriverLock(driver);    vm = virDomainFindByUUID(&driver->domains, dom->uuid);    openvzDriverUnlock(driver);    if (!vm) {        openvzError(VIR_ERR_NO_DOMAIN, NULL);        goto cleanup;    }    if (!(ret = strdup(vm->def->os.type)))        virReportOOMError();cleanup:    if (vm)        virDomainObjUnlock(vm);    return ret;}

static int openvzDomainResume(virDomainPtr dom) {  struct openvz_driver *driver = dom->conn->privateData;  virDomainObjPtr vm;  const char *prog[] = {VZCTL, "--quiet", "chkpnt", PROGRAM_SENTINAL, "--resume", NULL};  int ret = -1;  openvzDriverLock(driver);  vm = virDomainFindByUUID(&driver->domains, dom->uuid);  openvzDriverUnlock(driver);  if (!vm) {      openvzError(VIR_ERR_NO_DOMAIN, "%s",                  _("no domain with matching uuid"));      goto cleanup;  }  if (!virDomainObjIsActive(vm)) {      openvzError(VIR_ERR_OPERATION_INVALID, "%s",                  _("Domain is not running"));      goto cleanup;  }  if (virDomainObjGetState(vm, NULL) == VIR_DOMAIN_PAUSED) {      openvzSetProgramSentinal(prog, vm->def->name);      if (virRun(prog, NULL) < 0) {          goto cleanup;      }      virDomainObjSetState(vm, VIR_DOMAIN_RUNNING, VIR_DOMAIN_RUNNING_UNPAUSED);  }  ret = 0;cleanup:  if (vm)      virDomainObjUnlock(vm);  return ret;}

static virDomainPtr openvzDomainLookupByUUID(virConnectPtr conn,                                             const unsigned char *uuid) {    struct  openvz_driver *driver = conn->privateData;    virDomainObjPtr vm;    virDomainPtr dom = NULL;    openvzDriverLock(driver);    vm = virDomainFindByUUID(&driver->domains, uuid);    openvzDriverUnlock(driver);    if (!vm) {        openvzError(VIR_ERR_NO_DOMAIN, NULL);        goto cleanup;    }    dom = virGetDomain(conn, vm->def->name, vm->def->uuid);    if (dom)        dom->id = vm->def->id;cleanup:    if (vm)        virDomainObjUnlock(vm);    return dom;}

static int openvzDomainSetVcpusFlags(virDomainPtr dom, unsigned int nvcpus,                                     unsigned int flags){    virDomainObjPtr         vm;    struct openvz_driver   *driver = dom->conn->privateData;    int                     ret = -1;    if (flags != VIR_DOMAIN_AFFECT_LIVE) {        openvzError(VIR_ERR_INVALID_ARG, _("unsupported flags (0x%x)"), flags);        return -1;    }    openvzDriverLock(driver);    vm = virDomainFindByUUID(&driver->domains, dom->uuid);    openvzDriverUnlock(driver);    if (!vm) {        openvzError(VIR_ERR_NO_DOMAIN, "%s",                    _("no domain with matching uuid"));        goto cleanup;    }    if (nvcpus <= 0) {        openvzError(VIR_ERR_INTERNAL_ERROR, "%s",                    _("VCPUs should be >= 1"));        goto cleanup;    }    openvzDomainSetVcpusInternal(vm, nvcpus);    ret = 0;cleanup:    if (vm)        virDomainObjUnlock(vm);    return ret;}

static intopenvzDomainGetAutostart(virDomainPtr dom, int *autostart){    struct openvz_driver *driver = dom->conn->privateData;    virDomainObjPtr vm;    char *value = NULL;    int ret = -1;    openvzDriverLock(driver);    vm = virDomainFindByUUID(&driver->domains, dom->uuid);    openvzDriverUnlock(driver);    if (!vm) {        openvzError(VIR_ERR_NO_DOMAIN, "%s",                    _("no domain with matching uuid"));        goto cleanup;    }    if (openvzReadVPSConfigParam(strtoI(vm->def->name), "ONBOOT", &value) < 0) {        openvzError(VIR_ERR_INTERNAL_ERROR, "%s",                    _("Could not read container config"));        goto cleanup;    }    *autostart = 0;    if (STREQ(value,"yes"))        *autostart = 1;    ret = 0;cleanup:    VIR_FREE(value);    if (vm)        virDomainObjUnlock(vm);    return ret;}

//.........这里部分代码省略.........            p++; /* definitely has a ':' in it, see above */            this_port = virParseNumber (&p);            if (this_port == -1 || p-uri_in != strlen (uri_in)) {                qemuReportError(VIR_ERR_INVALID_ARG,                                "%s", _("URI ended with incorrect ':port'"));                goto cleanup;            }        }    }    if (*uri_out)        VIR_DEBUG("Generated uri_out=%s", *uri_out);    /* Parse the domain XML. */    if (!(def = virDomainDefParseString(driver->caps, dom_xml,                                        VIR_DOMAIN_XML_INACTIVE)))        goto cleanup;    if (!qemuMigrationIsAllowed(def))        goto cleanup;    /* Target domain name, maybe renamed. */    if (dname) {        VIR_FREE(def->name);        def->name = strdup(dname);        if (def->name == NULL)            goto cleanup;    }    if (virDomainObjIsDuplicate(&driver->domains, def, 1) < 0)        goto cleanup;    if (!(vm = virDomainAssignDef(driver->caps,                                  &driver->domains,                                  def, true))) {        /* virDomainAssignDef already set the error */        goto cleanup;    }    def = NULL;    priv = vm->privateData;    if (qemuDomainObjBeginJobWithDriver(driver, vm) < 0)        goto cleanup;    priv->jobActive = QEMU_JOB_MIGRATION_OUT;    /* Domain starts inactive, even if the domain XML had an id field. */    vm->def->id = -1;    /* Start the QEMU daemon, with the same command-line arguments plus     * -incoming tcp:0.0.0.0:port     */    snprintf (migrateFrom, sizeof (migrateFrom), "tcp:0.0.0.0:%d", this_port);    if (qemuProcessStart(dconn, driver, vm, migrateFrom, true,                         -1, NULL, VIR_VM_OP_MIGRATE_IN_START) < 0) {        qemuAuditDomainStart(vm, "migrated", false);        /* Note that we don't set an error here because qemuProcessStart         * should have already done that.         */        if (!vm->persistent) {            if (qemuDomainObjEndJob(vm) > 0)                virDomainRemoveInactive(&driver->domains, vm);            vm = NULL;        }        goto endjob;    }    qemuAuditDomainStart(vm, "migrated", true);    event = virDomainEventNewFromObj(vm,                                     VIR_DOMAIN_EVENT_STARTED,                                     VIR_DOMAIN_EVENT_STARTED_MIGRATED);    ret = 0;endjob:    if (vm &&        qemuDomainObjEndJob(vm) == 0)        vm = NULL;    /* We set a fake job active which is held across     * API calls until the finish() call. This prevents     * any other APIs being invoked while incoming     * migration is taking place     */    if (vm &&        virDomainObjIsActive(vm)) {        priv->jobActive = QEMU_JOB_MIGRATION_IN;        priv->jobInfo.type = VIR_DOMAIN_JOB_UNBOUNDED;        priv->jobStart = timeval_to_ms(now);    }cleanup:    VIR_FREE(hostname);    virDomainDefFree(def);    if (ret != 0)        VIR_FREE(*uri_out);    if (vm)        virDomainObjUnlock(vm);    if (event)        qemuDomainEventQueue(driver, event);    return ret;}

//.........这里部分代码省略.........            priv->jobInfo.type = VIR_DOMAIN_JOB_NONE;            qemuReportError(VIR_ERR_OPERATION_FAILED,                            _("%s: %s"), job, _("is not active"));            break;        case QEMU_MONITOR_MIGRATION_STATUS_ACTIVE:            priv->jobInfo.dataTotal = memTotal;            priv->jobInfo.dataRemaining = memRemaining;            priv->jobInfo.dataProcessed = memProcessed;            priv->jobInfo.memTotal = memTotal;            priv->jobInfo.memRemaining = memRemaining;            priv->jobInfo.memProcessed = memProcessed;            break;        case QEMU_MONITOR_MIGRATION_STATUS_COMPLETED:            priv->jobInfo.type = VIR_DOMAIN_JOB_COMPLETED;            ret = 0;            break;        case QEMU_MONITOR_MIGRATION_STATUS_ERROR:            priv->jobInfo.type = VIR_DOMAIN_JOB_FAILED;            qemuReportError(VIR_ERR_OPERATION_FAILED,                            _("%s: %s"), job, _("unexpectedly failed"));            break;        case QEMU_MONITOR_MIGRATION_STATUS_CANCELLED:            priv->jobInfo.type = VIR_DOMAIN_JOB_CANCELLED;            qemuReportError(VIR_ERR_OPERATION_FAILED,                            _("%s: %s"), job, _("canceled by client"));            break;        }        virDomainObjUnlock(vm);        qemuDriverUnlock(driver);        nanosleep(&ts, NULL);        qemuDriverLock(driver);        virDomainObjLock(vm);    }cleanup:    return ret;}/* Prepare is the first step, and it runs on the destination host. * * This version starts an empty VM listening on a localhost TCP port, and * sets up the corresponding virStream to handle the incoming data. */intqemuMigrationPrepareTunnel(struct qemud_driver *driver,                           virConnectPtr dconn,                           virStreamPtr st,                           const char *dname,                           const char *dom_xml){    virDomainDefPtr def = NULL;    virDomainObjPtr vm = NULL;    virDomainEventPtr event = NULL;    int ret = -1;    int internalret;    int dataFD[2] = { -1, -1 };    virBitmapPtr qemuCaps = NULL;

static virDomainPtropenvzDomainDefineXML(virConnectPtr conn, const char *xml){    struct openvz_driver *driver =  conn->privateData;    virDomainDefPtr vmdef = NULL;    virDomainObjPtr vm = NULL;    virDomainPtr dom = NULL;    openvzDriverLock(driver);    if ((vmdef = virDomainDefParseString(driver->caps, xml,                                         1 << VIR_DOMAIN_VIRT_OPENVZ,                                         VIR_DOMAIN_XML_INACTIVE)) == NULL)        goto cleanup;    vm = virDomainFindByName(&driver->domains, vmdef->name);    if (vm) {        openvzError(VIR_ERR_OPERATION_FAILED,                    _("Already an OPENVZ VM active with the id '%s'"),                    vmdef->name);        goto cleanup;    }    if (!(vm = virDomainAssignDef(driver->caps,                                  &driver->domains, vmdef, false)))        goto cleanup;    vmdef = NULL;    vm->persistent = 1;    if (openvzSetInitialConfig(vm->def) < 0) {        VIR_ERROR(_("Error creating initial configuration"));        goto cleanup;    }    /* TODO: set quota */    if (openvzSetDefinedUUID(strtoI(vm->def->name), vm->def->uuid) < 0) {        openvzError(VIR_ERR_INTERNAL_ERROR, "%s",                    _("Could not set UUID"));        goto cleanup;    }    if (openvzDomainSetNetworkConfig(conn, vm->def) < 0)        goto cleanup;    if (vm->def->vcpus != vm->def->maxvcpus) {        openvzError(VIR_ERR_CONFIG_UNSUPPORTED, "%s",                    _("current vcpu count must equal maximum"));        goto cleanup;    }    if (vm->def->maxvcpus > 0) {        if (openvzDomainSetVcpusInternal(vm, vm->def->maxvcpus) < 0) {            openvzError(VIR_ERR_INTERNAL_ERROR, "%s",                        _("Could not set number of virtual cpu"));             goto cleanup;        }    }    if (vm->def->mem.cur_balloon > 0) {        if (openvzDomainSetMemoryInternal(vm, vm->def->mem.cur_balloon) < 0) {            openvzError(VIR_ERR_INTERNAL_ERROR, "%s",                        _("Could not set memory size"));             goto cleanup;        }    }    dom = virGetDomain(conn, vm->def->name, vm->def->uuid);    if (dom)        dom->id = -1;cleanup:    virDomainDefFree(vmdef);    if (vm)        virDomainObjUnlock(vm);    openvzDriverUnlock(driver);    return dom;}

static virDomainPtrvmwareDomainCreateXML(virConnectPtr conn, const char *xml,                      unsigned int flags ATTRIBUTE_UNUSED){    struct vmware_driver *driver = conn->privateData;    virDomainDefPtr vmdef = NULL;    virDomainObjPtr vm = NULL;    virDomainPtr dom = NULL;    char *vmx = NULL;    char *vmxPath = NULL;    vmwareDomainPtr pDomain = NULL;    virVMXContext ctx;    ctx.formatFileName = vmwareCopyVMXFileName;    vmwareDriverLock(driver);    if ((vmdef = virDomainDefParseString(driver->caps, xml,                                         VIR_DOMAIN_XML_INACTIVE)) == NULL)        goto cleanup;    if (virDomainObjIsDuplicate(&driver->domains, vmdef, 1) < 0)        goto cleanup;    /* generate vmx file */    vmx = virVMXFormatConfig(&ctx, driver->caps, vmdef, 7);    if (vmx == NULL)        goto cleanup;    if (vmwareVmxPath(vmdef, &vmxPath) < 0)        goto cleanup;    /* create vmx file */    if (virFileWriteStr(vmxPath, vmx, S_IRUSR|S_IWUSR) < 0) {        vmwareError(VIR_ERR_INTERNAL_ERROR,                    _("Failed to write vmx file '%s'"), vmxPath);        goto cleanup;    }    /* assign def */    if (!(vm = virDomainAssignDef(driver->caps,                                  &driver->domains, vmdef, false)))        goto cleanup;    pDomain = vm->privateData;    pDomain->vmxPath = strdup(vmxPath);    vmwareDomainConfigDisplay(pDomain, vmdef);    vmdef = NULL;    if (vmwareStartVM(driver, vm) < 0) {        virDomainRemoveInactive(&driver->domains, vm);        vm = NULL;        goto cleanup;    }    dom = virGetDomain(conn, vm->def->name, vm->def->uuid);    if (dom)        dom->id = vm->def->id;cleanup:    virDomainDefFree(vmdef);    VIR_FREE(vmx);    VIR_FREE(vmxPath);    if(vm)        virDomainObjUnlock(vm);    vmwareDriverUnlock(driver);    return dom;}

static virDomainPtropenvzDomainCreateXML(virConnectPtr conn, const char *xml,                      unsigned int flags){    struct openvz_driver *driver =  conn->privateData;    virDomainDefPtr vmdef = NULL;    virDomainObjPtr vm = NULL;    virDomainPtr dom = NULL;    const char *progstart[] = {VZCTL, "--quiet", "start", PROGRAM_SENTINAL, NULL};    virCheckFlags(0, NULL);    openvzDriverLock(driver);    if ((vmdef = virDomainDefParseString(driver->caps, xml,                                         1 << VIR_DOMAIN_VIRT_OPENVZ,                                         VIR_DOMAIN_XML_INACTIVE)) == NULL)        goto cleanup;    vm = virDomainFindByName(&driver->domains, vmdef->name);    if (vm) {        openvzError(VIR_ERR_OPERATION_FAILED,                    _("Already an OPENVZ VM defined with the id '%s'"),                   vmdef->name);        goto cleanup;    }    if (!(vm = virDomainAssignDef(driver->caps,                                  &driver->domains, vmdef, false)))        goto cleanup;    vmdef = NULL;    /* All OpenVZ domains seem to be persistent - this is a bit of a violation     * of this libvirt API which is intended for transient domain creation */    vm->persistent = 1;    if (openvzSetInitialConfig(vm->def) < 0) {        VIR_ERROR(_("Error creating initial configuration"));        goto cleanup;    }    if (openvzSetDefinedUUID(strtoI(vm->def->name), vm->def->uuid) < 0) {        openvzError(VIR_ERR_INTERNAL_ERROR, "%s",                    _("Could not set UUID"));        goto cleanup;    }    if (openvzDomainSetNetworkConfig(conn, vm->def) < 0)        goto cleanup;    openvzSetProgramSentinal(progstart, vm->def->name);    if (virRun(progstart, NULL) < 0) {        goto cleanup;    }    vm->pid = strtoI(vm->def->name);    vm->def->id = vm->pid;    virDomainObjSetState(vm, VIR_DOMAIN_RUNNING, VIR_DOMAIN_RUNNING_BOOTED);    if (vm->def->maxvcpus > 0) {        if (openvzDomainSetVcpusInternal(vm, vm->def->maxvcpus) < 0) {            openvzError(VIR_ERR_INTERNAL_ERROR, "%s",                        _("Could not set number of virtual cpu"));            goto cleanup;        }    }    dom = virGetDomain(conn, vm->def->name, vm->def->uuid);    if (dom)        dom->id = vm->def->id;cleanup:    virDomainDefFree(vmdef);    if (vm)        virDomainObjUnlock(vm);    openvzDriverUnlock(driver);    return dom;}

static virDomainPtrvmwareDomainDefineXML(virConnectPtr conn, const char *xml){    struct vmware_driver *driver = conn->privateData;    virDomainDefPtr vmdef = NULL;    virDomainObjPtr vm = NULL;    virDomainPtr dom = NULL;    char *vmx = NULL;    char *directoryName = NULL;    char *fileName = NULL;    char *vmxPath = NULL;    vmwareDomainPtr pDomain = NULL;    virVMXContext ctx;    ctx.formatFileName = vmwareCopyVMXFileName;    vmwareDriverLock(driver);    if ((vmdef = virDomainDefParseString(driver->caps, xml,                                         1 << VIR_DOMAIN_VIRT_VMWARE,                                         VIR_DOMAIN_XML_INACTIVE)) == NULL)        goto cleanup;    if (virDomainObjIsDuplicate(&driver->domains, vmdef, 1) < 0)        goto cleanup;    /* generate vmx file */    vmx = virVMXFormatConfig(&ctx, driver->caps, vmdef, 7);    if (vmx == NULL)        goto cleanup;    if (vmwareVmxPath(vmdef, &vmxPath) < 0)        goto cleanup;    /* create vmx file */    if (virFileWriteStr(vmxPath, vmx, S_IRUSR|S_IWUSR) < 0) {        virReportError(VIR_ERR_INTERNAL_ERROR,                       _("Failed to write vmx file '%s'"), vmxPath);        goto cleanup;    }    /* assign def */    if (!(vm = virDomainAssignDef(driver->caps,                                  &driver->domains, vmdef, false)))        goto cleanup;    pDomain = vm->privateData;    if ((pDomain->vmxPath = strdup(vmxPath)) == NULL) {        virReportOOMError();        goto cleanup;    }    vmwareDomainConfigDisplay(pDomain, vmdef);    vmdef = NULL;    vm->persistent = 1;    dom = virGetDomain(conn, vm->def->name, vm->def->uuid);    if (dom)        dom->id = -1;  cleanup:    virDomainDefFree(vmdef);    VIR_FREE(vmx);    VIR_FREE(directoryName);    VIR_FREE(fileName);    VIR_FREE(vmxPath);    if (vm)        virDomainObjUnlock(vm);    vmwareDriverUnlock(driver);    return dom;}