static int hypervDomainDestroyFlags(virDomainPtr domain, unsigned int flags) { int result = -1; hypervPrivate *priv = domain->conn->privateData; Msvm_ComputerSystem *computerSystem = NULL; bool in_transition = false; virCheckFlags(0, -1); if (hypervMsvmComputerSystemFromDomain(domain, &computerSystem) < 0) { goto cleanup; } if (!hypervIsMsvmComputerSystemActive(computerSystem, &in_transition) || in_transition) { HYPERV_ERROR(VIR_ERR_OPERATION_INVALID, "%s", _("Domain is not active or is in state transition")); goto cleanup; } result = hypervInvokeMsvmComputerSystemRequestStateChange (domain, MSVM_COMPUTERSYSTEM_REQUESTEDSTATE_DISABLED); cleanup: hypervFreeObject(priv, (hypervObject *)computerSystem); return result; }
static int hypervDomainGetState(virDomainPtr domain, int *state, int *reason, unsigned int flags) { int result = -1; hypervPrivate *priv = domain->conn->privateData; Msvm_ComputerSystem *computerSystem = NULL; virCheckFlags(0, -1); if (hypervMsvmComputerSystemFromDomain(domain, &computerSystem) < 0) { goto cleanup; } *state = hypervMsvmComputerSystemEnabledStateToDomainState(computerSystem); if (reason != NULL) { *reason = 0; } result = 0; cleanup: hypervFreeObject(priv, (hypervObject *)computerSystem); return result; }
char * nodeDeviceGetXMLDesc(virNodeDevicePtr dev, unsigned int flags) { virDeviceMonitorStatePtr driver = dev->conn->devMonPrivateData; virNodeDeviceObjPtr obj; char *ret = NULL; virCheckFlags(0, NULL); nodeDeviceLock(driver); obj = virNodeDeviceFindByName(&driver->devs, dev->name); nodeDeviceUnlock(driver); if (!obj) { virReportError(VIR_ERR_NO_NODE_DEVICE, _("no node device with matching name '%s'"), dev->name); goto cleanup; } update_driver_name(obj); update_caps(obj); ret = virNodeDeviceDefFormat(obj->def); cleanup: if (obj) virNodeDeviceObjUnlock(obj); return ret; }
static int hypervDomainManagedSaveRemove(virDomainPtr domain, unsigned int flags) { int result = -1; hypervPrivate *priv = domain->conn->privateData; Msvm_ComputerSystem *computerSystem = NULL; virCheckFlags(0, -1); if (hypervMsvmComputerSystemFromDomain(domain, &computerSystem) < 0) { goto cleanup; } if (computerSystem->data->EnabledState != MSVM_COMPUTERSYSTEM_ENABLEDSTATE_SUSPENDED) { HYPERV_ERROR(VIR_ERR_OPERATION_INVALID, "%s", _("Domain has no managed save image")); goto cleanup; } result = hypervInvokeMsvmComputerSystemRequestStateChange (domain, MSVM_COMPUTERSYSTEM_REQUESTEDSTATE_DISABLED); cleanup: hypervFreeObject(priv, (hypervObject *)computerSystem); return result; }
static int secretSetValue(virSecretPtr obj, const unsigned char *value, size_t value_size, unsigned int flags) { int ret = -1; virSecretObjPtr secret; virSecretDefPtr def; virCheckFlags(0, -1); if (!(secret = secretObjFromSecret(obj))) goto cleanup; def = virSecretObjGetDef(secret); if (virSecretSetValueEnsureACL(obj->conn, def) < 0) goto cleanup; if (secretEnsureDirectory() < 0) goto cleanup; if (virSecretObjSetValue(secret, value, value_size) < 0) goto cleanup; ret = 0; cleanup: virSecretObjEndAPI(&secret); return ret; }
static int virStorageBackendZFSBuildPool(virConnectPtr conn ATTRIBUTE_UNUSED, virStoragePoolObjPtr pool, unsigned int flags) { virCommandPtr cmd = NULL; size_t i; int ret = -1; virCheckFlags(0, -1); if (pool->def->source.ndevice == 0) { virReportError(VIR_ERR_CONFIG_UNSUPPORTED, "%s", _("missing source devices")); return -1; } cmd = virCommandNewArgList(ZPOOL, "create", pool->def->source.name, NULL); for (i = 0; i < pool->def->source.ndevice; i++) virCommandAddArg(cmd, pool->def->source.devices[i].path); if (virCommandRun(cmd, NULL) < 0) goto cleanup; ret = 0; cleanup: virCommandFree(cmd); return ret; }
static int secretSetValue(virSecretPtr secret, const unsigned char *value, size_t value_size, unsigned int flags) { int ret = -1; virSecretObjPtr obj; virSecretDefPtr def; virObjectEventPtr event = NULL; virCheckFlags(0, -1); if (!(obj = secretObjFromSecret(secret))) goto cleanup; def = virSecretObjGetDef(obj); if (virSecretSetValueEnsureACL(secret->conn, def) < 0) goto cleanup; if (virSecretObjSetValue(obj, value, value_size) < 0) goto cleanup; event = virSecretEventValueChangedNew(def->uuid, def->usage_type, def->usage_id); ret = 0; cleanup: virSecretObjEndAPI(&obj); if (event) virObjectEventStateQueue(driver->secretEventState, event); return ret; }
static int bhyveDomainGetState(virDomainPtr domain, int *state, int *reason, unsigned int flags) { virDomainObjPtr vm; int ret = -1; virCheckFlags(0, -1); if (!(vm = bhyveDomObjFromDomain(domain))) goto cleanup; if (virDomainGetStateEnsureACL(domain->conn, vm->def) < 0) goto cleanup; *state = virDomainObjGetState(vm, reason); ret = 0; cleanup: if (vm) virObjectUnlock(vm); return ret; }
static int virLockManagerSanlockNew(virLockManagerPtr lock, unsigned int type, size_t nparams, virLockManagerParamPtr params, unsigned int flags) { virLockManagerParamPtr param; virLockManagerSanlockPrivatePtr priv; int i; virCheckFlags(0, -1); if (!driver) { virReportError(VIR_ERR_INTERNAL_ERROR, "%s", _("Sanlock plugin is not initialized")); return -1; } if (type != VIR_LOCK_MANAGER_OBJECT_TYPE_DOMAIN) { virReportError(VIR_ERR_INTERNAL_ERROR, _("Unsupported object type %d"), type); return -1; } if (VIR_ALLOC(priv) < 0) { virReportOOMError(); return -1; } priv->flags = flags; for (i = 0; i < nparams; i++) { param = ¶ms[i]; if (STREQ(param->key, "uuid")) { memcpy(priv->vm_uuid, param->value.uuid, 16); } else if (STREQ(param->key, "name")) { if (!virStrcpy(priv->vm_name, param->value.str, SANLK_NAME_LEN)) { virReportError(VIR_ERR_INTERNAL_ERROR, _("Domain name '%s' exceeded %d characters"), param->value.str, SANLK_NAME_LEN); goto error; } } else if (STREQ(param->key, "pid")) { priv->vm_pid = param->value.ui; } else if (STREQ(param->key, "id")) { priv->vm_id = param->value.ui; } else if (STREQ(param->key, "uri")) { priv->vm_uri = param->value.cstr; } } lock->privateData = priv; return 0; error: VIR_FREE(priv); return -1; }
static char * bhyveConnectDomainXMLToNative(virConnectPtr conn, const char *format, const char *xmlData, unsigned int flags) { virBuffer buf = VIR_BUFFER_INITIALIZER; bhyveConnPtr privconn = conn->privateData; virDomainDefPtr def = NULL; virCommandPtr cmd = NULL, loadcmd = NULL; virCapsPtr caps = NULL; char *ret = NULL; virCheckFlags(0, NULL); if (virConnectDomainXMLToNativeEnsureACL(conn) < 0) goto cleanup; if (STRNEQ(format, BHYVE_CONFIG_FORMAT_ARGV)) { virReportError(VIR_ERR_INVALID_ARG, _("Unsupported config type %s"), format); goto cleanup; } if (!(caps = bhyveDriverGetCapabilities(privconn))) goto cleanup; if (!(def = virDomainDefParseString(xmlData, caps, privconn->xmlopt, 1 << VIR_DOMAIN_VIRT_BHYVE, VIR_DOMAIN_XML_INACTIVE))) goto cleanup; if (bhyveDomainAssignAddresses(def, NULL) < 0) goto cleanup; if (!(loadcmd = virBhyveProcessBuildLoadCmd(privconn, def))) goto cleanup; if (!(cmd = virBhyveProcessBuildBhyveCmd(privconn, def, true))) goto cleanup; virBufferAdd(&buf, virCommandToString(loadcmd), -1); virBufferAddChar(&buf, '\n'); virBufferAdd(&buf, virCommandToString(cmd), -1); if (virBufferError(&buf)) { virReportOOMError(); goto cleanup; } ret = virBufferContentAndReset(&buf); cleanup: virCommandFree(loadcmd); virCommandFree(cmd); virDomainDefFree(def); virObjectUnref(caps); return ret; }
virNodeDevicePtr nodeDeviceLookupSCSIHostByWWN(virConnectPtr conn, const char *wwnn, const char *wwpn, unsigned int flags) { size_t i; virNodeDeviceObjListPtr devs = &driver->devs; virNodeDevCapsDefPtr cap = NULL; virNodeDeviceObjPtr obj = NULL; virNodeDeviceDefPtr def; virNodeDevicePtr dev = NULL; virCheckFlags(0, NULL); nodeDeviceLock(); for (i = 0; i < devs->count; i++) { obj = devs->objs[i]; virNodeDeviceObjLock(obj); def = virNodeDeviceObjGetDef(obj); cap = def->caps; while (cap) { if (cap->data.type == VIR_NODE_DEV_CAP_SCSI_HOST) { nodeDeviceSysfsGetSCSIHostCaps(&cap->data.scsi_host); if (cap->data.scsi_host.flags & VIR_NODE_DEV_CAP_FLAG_HBA_FC_HOST) { if (STREQ(cap->data.scsi_host.wwnn, wwnn) && STREQ(cap->data.scsi_host.wwpn, wwpn)) { if (virNodeDeviceLookupSCSIHostByWWNEnsureACL(conn, def) < 0) goto error; if ((dev = virGetNodeDevice(conn, def->name))) { if (VIR_STRDUP(dev->parent, def->parent) < 0) { virObjectUnref(dev); dev = NULL; } } virNodeDeviceObjUnlock(obj); goto out; } } } cap = cap->next; } virNodeDeviceObjUnlock(obj); } out: nodeDeviceUnlock(); return dev; error: virNodeDeviceObjUnlock(obj); goto out; }
int adminClientClose(virNetServerClientPtr client, unsigned int flags) { virCheckFlags(0, -1); virNetServerClientClose(client); return 0; }
/** * @pool storage pool to build * @flags controls the pool formatting behaviour * * Does not support @flags, if provided an error will occur. * * Returns 0 on success, -1 on error */ static int virStorageBackendVzPoolBuild(virStoragePoolObjPtr pool, unsigned int flags) { virCheckFlags(0, -1); return virStorageBackendBuildLocal(pool); }
virNodeDevicePtr nodeDeviceCreateXML(virConnectPtr conn, const char *xmlDesc, unsigned int flags) { virNodeDeviceDriverStatePtr driver = conn->nodeDevicePrivateData; virNodeDeviceDefPtr def = NULL; char *wwnn = NULL, *wwpn = NULL; int parent_host = -1; virNodeDevicePtr dev = NULL; const char *virt_type = NULL; virCheckFlags(0, NULL); virt_type = virConnectGetType(conn); nodeDeviceLock(driver); def = virNodeDeviceDefParseString(xmlDesc, CREATE_DEVICE, virt_type); if (def == NULL) { goto cleanup; } if (virNodeDeviceCreateXMLEnsureACL(conn, def) < 0) goto cleanup; if (virNodeDeviceGetWWNs(def, &wwnn, &wwpn) == -1) { goto cleanup; } if (virNodeDeviceGetParentHost(&driver->devs, def->name, def->parent, &parent_host) == -1) { goto cleanup; } if (virManageVport(parent_host, wwpn, wwnn, VPORT_CREATE) == -1) { goto cleanup; } dev = find_new_device(conn, wwnn, wwpn); /* We don't check the return value, because one way or another, * we're returning what we get... */ if (dev == NULL) { virReportError(VIR_ERR_NO_NODE_DEVICE, NULL); } cleanup: nodeDeviceUnlock(driver); virNodeDeviceDefFree(def); VIR_FREE(wwnn); VIR_FREE(wwpn); return dev; }
virNetServerPtr adminConnectLookupServer(virNetDaemonPtr dmn, const char *name, unsigned int flags) { virCheckFlags(flags, NULL); return virNetDaemonGetServer(dmn, name); }
static char * esxStoragePoolGetXMLDesc(virStoragePoolPtr pool, unsigned int flags) { char *xml = NULL; esxPrivate *priv = pool->conn->privateData; esxVI_HostInternetScsiHba *hostInternetScsiHba = NULL; esxVI_HostInternetScsiHbaStaticTarget *target; virStoragePoolDef def; virCheckFlags(0, NULL); memset(&def, 0, sizeof(def)); if (esxVI_LookupHostInternetScsiHba(priv->primary, &hostInternetScsiHba)) goto cleanup; for (target = hostInternetScsiHba->configuredStaticTarget; target; target = target->_next) { if (STREQ(target->iScsiName, pool->name)) break; } if (!target) { /* pool not found */ virReportError(VIR_ERR_INTERNAL_ERROR, _("Could not find storage pool with name '%s'"), pool->name); goto cleanup; } def.name = pool->name; memcpy(def.uuid, pool->uuid, VIR_UUID_BUFLEN); def.type = VIR_STORAGE_POOL_ISCSI; def.source.initiator.iqn = target->iScsiName; def.source.nhost = 1; if (VIR_ALLOC_N(def.source.hosts, def.source.nhost) < 0) goto cleanup; def.source.hosts[0].name = target->address; if (target->port) def.source.hosts[0].port = target->port->value; /* TODO: add CHAP authentication params */ xml = virStoragePoolDefFormat(&def); cleanup: VIR_FREE(def.source.hosts); esxVI_HostInternetScsiHba_Free(&hostInternetScsiHba); return xml; }
static int adminConnectSetLoggingOutputs(virNetDaemonPtr dmn ATTRIBUTE_UNUSED, const char *outputs, unsigned int flags) { virCheckFlags(0, -1); return virLogSetOutputs(outputs); }
virNetServerClientPtr adminServerLookupClient(virNetServerPtr srv, unsigned long long id, unsigned int flags) { virCheckFlags(0, NULL); return virNetServerGetClient(srv, id); }
static int adminConnectSetLoggingFilters(virNetDaemonPtr dmn ATTRIBUTE_UNUSED, const char *filters, unsigned int flags) { virCheckFlags(0, -1); return virLogSetFilters(filters); }
static int parallelsConnectListAllNetworks(virConnectPtr conn, virNetworkPtr **nets, unsigned int flags) { parallelsConnPtr privconn = conn->privateData; virCheckFlags(VIR_CONNECT_LIST_NETWORKS_FILTERS_ALL, -1); return virNetworkObjListExport(conn, privconn->networks, nets, NULL, flags); }
static int lightosConnectListAllDomains(virConnectPtr conn,virDomainPtr **domains,unsigned int flags){ lightosConnPtr privconn = conn->privateData; int ret; virCheckFlags(VIR_CONNECT_LIST_DOMAINS_FILTERS_ALL,-1); ret = virDomainObjListExport(privconn->domains,conn,domains,NULL,flags); return ret; }
/** * virAdmConnectOpen: * @name: uri of the daemon to connect to, NULL for default * @flags: unused, must be 0 * * Opens connection to admin interface of the daemon. * * Returns @virAdmConnectPtr object or NULL on error */ virAdmConnectPtr virAdmConnectOpen(const char *name, unsigned int flags) { char *sock_path = NULL; char *alias = NULL; virAdmConnectPtr conn = NULL; virConfPtr conf = NULL; if (virAdmInitialize() < 0) goto error; VIR_DEBUG("flags=%x", flags); virResetLastError(); virCheckFlags(VIR_CONNECT_NO_ALIASES, NULL); if (!(conn = virAdmConnectNew())) goto error; if (virConfLoadConfig(&conf, "libvirt-admin.conf") < 0) goto error; if (!name && !(name = virAdmGetDefaultURI(conf))) goto error; if ((!(flags & VIR_CONNECT_NO_ALIASES) && virURIResolveAlias(conf, name, &alias) < 0)) goto error; if (!(conn->uri = virURIParse(alias ? alias : name))) goto error; if (!(sock_path = getSocketPath(conn->uri))) goto error; if (!(conn->privateData = remoteAdminPrivNew(sock_path))) goto error; conn->privateDataFreeFunc = remoteAdminPrivFree; if (remoteAdminConnectOpen(conn, flags) < 0) goto error; cleanup: VIR_FREE(sock_path); VIR_FREE(alias); virConfFree(conf); return conn; error: virDispatchError(NULL); virObjectUnref(conn); conn = NULL; goto cleanup; }
static virDrvOpenStatus hypervNodeDeviceOpen(virConnectPtr conn, virConnectAuthPtr auth ATTRIBUTE_UNUSED, unsigned int flags) { virCheckFlags(VIR_CONNECT_RO, VIR_DRV_OPEN_ERROR); if (conn->driver->no != VIR_DRV_HYPERV) return VIR_DRV_OPEN_DECLINED; return VIR_DRV_OPEN_SUCCESS; }
static int virLockManagerSanlockAddResource(virLockManagerPtr lock, unsigned int type, const char *name, size_t nparams, virLockManagerParamPtr params, unsigned int flags) { virLockManagerSanlockPrivatePtr priv = lock->privateData; virCheckFlags(VIR_LOCK_MANAGER_RESOURCE_READONLY | VIR_LOCK_MANAGER_RESOURCE_SHARED, -1); if (priv->res_count == SANLK_MAX_RESOURCES) { virReportError(VIR_ERR_INTERNAL_ERROR, _("Too many resources %d for object"), SANLK_MAX_RESOURCES); return -1; } /* Treat R/O resources as a no-op lock request */ if (flags & VIR_LOCK_MANAGER_RESOURCE_READONLY) return 0; switch (type) { case VIR_LOCK_MANAGER_RESOURCE_TYPE_DISK: if (driver->autoDiskLease) { if (virLockManagerSanlockAddDisk(lock, name, nparams, params, !!(flags & VIR_LOCK_MANAGER_RESOURCE_SHARED)) < 0) return -1; if (virLockManagerSanlockCreateLease(priv->res_args[priv->res_count-1]) < 0) return -1; } else { if (!(flags & (VIR_LOCK_MANAGER_RESOURCE_SHARED | VIR_LOCK_MANAGER_RESOURCE_READONLY))) priv->hasRWDisks = true; /* Ignore disk resources without error */ } break; case VIR_LOCK_MANAGER_RESOURCE_TYPE_LEASE: if (virLockManagerSanlockAddLease(lock, name, nparams, params, !!(flags & VIR_LOCK_MANAGER_RESOURCE_SHARED)) < 0) return -1; break; default: /* Ignore other resources, without error */ break; } return 0; }
static virStoragePoolPtr parallelsStoragePoolDefineXML(virConnectPtr conn, const char *xml, unsigned int flags) { parallelsConnPtr privconn = conn->privateData; virStoragePoolDefPtr def; virStoragePoolObjPtr pool = NULL; virStoragePoolPtr ret = NULL; virCheckFlags(0, NULL); parallelsDriverLock(privconn); if (!(def = virStoragePoolDefParseString(xml))) goto cleanup; if (def->type != VIR_STORAGE_POOL_DIR) { virReportError(VIR_ERR_NO_SUPPORT, "%s", _("Only local directories are supported")); goto cleanup; } if (virStoragePoolObjIsDuplicate(&privconn->pools, def, 0) < 0) goto cleanup; if (virStoragePoolSourceFindDuplicate(&privconn->pools, def) < 0) goto cleanup; if (parallelsStoragePoolGetAlloc(def)) goto cleanup; if (!(pool = virStoragePoolObjAssignDef(&privconn->pools, def))) goto cleanup; if (virStoragePoolObjSaveDef(conn->storagePrivateData, pool, def) < 0) { virStoragePoolObjRemove(&privconn->pools, pool); def = NULL; goto cleanup; } def = NULL; if (VIR_STRDUP(pool->configFile, "\0") < 0) goto cleanup; ret = virGetStoragePool(conn, pool->def->name, pool->def->uuid, NULL, NULL); cleanup: virStoragePoolDefFree(def); if (pool) virStoragePoolObjUnlock(pool); parallelsDriverUnlock(privconn); return ret; }
/* Returns the number of outputs stored in @outputs */ static int adminConnectGetLoggingOutputs(char **outputs, unsigned int flags) { char *tmp = NULL; virCheckFlags(0, -1); if (!(tmp = virLogGetOutputs())) return -1; *outputs = tmp; return virLogGetNbOutputs(); }
static int call(virAdmConnectPtr conn, unsigned int flags, int proc_nr, xdrproc_t args_filter, char *args, xdrproc_t ret_filter, char *ret) { virCheckFlags(0, -1); return callFull(conn, conn->privateData, NULL, 0, NULL, NULL, proc_nr, args_filter, args, ret_filter, ret); }
static int secretConnectListAllSecrets(virConnectPtr conn, virSecretPtr **secrets, unsigned int flags) { virCheckFlags(VIR_CONNECT_LIST_SECRETS_FILTERS_ALL, -1); if (virConnectListAllSecretsEnsureACL(conn) < 0) return -1; return virSecretObjListExport(conn, driver->secrets, secrets, virConnectListAllSecretsCheckACL, flags); }
/* Returns the number of defined filters or -1 in case of an error */ static int adminConnectGetLoggingFilters(char **filters, unsigned int flags) { char *tmp = NULL; int ret = 0; virCheckFlags(0, -1); if ((ret = virLogGetNbFilters()) > 0 && !(tmp = virLogGetFilters())) return -1; *filters = tmp; return ret; }
static virDrvOpenStatus lightosConnectOpen(virConnectPtr conn, virConnectAuthPtr auth ATTRIBUTE_UNUSED, unsigned int flags) { virCheckFlags(VIR_CONNECT_RO, VIR_DRV_OPEN_ERROR); if (lightosInitialize() < 0) return VIR_DRV_OPEN_ERROR; // if(conn->uri == NULL) // if (lightos_driver == NULL) // return VIR_DRV_OPEN_DECLINED; if (!conn->uri) return VIR_DRV_OPEN_DECLINED; if (!conn->uri->scheme || STRNEQ(conn->uri->scheme, "lightos")) return VIR_DRV_OPEN_DECLINED; /* From this point on, the connection is for us. */ if (!conn->uri->path || conn->uri->path[0] == '\0' || (conn->uri->path[0] == '/' && conn->uri->path[1] == '\0')) { virReportError(VIR_ERR_INVALID_ARG, "%s", _("lightosOpen: supply a path or use lightos:///default")); return VIR_DRV_OPEN_ERROR; } // if (STREQ(conn->uri->path, "/default")) // ret = testOpenDefault(conn); // printf("need call lightosOpen\n"); if(lightos_driver == NULL) virReportError(VIR_ERR_INTERNAL_ERROR, "%s",_("lightos state driver is ont active!!!!")); // if (STREQ(conn->uri->path, "/default")) // { // if(virConnectOpenEnsureACL(conn)< 0) // return VIR_DRV_OPEN_ERROR; // } conn->privateData = lightos_driver; return VIR_DRV_OPEN_SUCCESS; }