/** * virGetStorageVol: * @conn: the hypervisor connection * @pool: pool owning the volume * @name: pointer to the storage vol name * @key: pointer to unique key of the volume * * Lookup if the storage vol is already registered for that connection, * if yes return a new pointer to it, if no allocate a new structure, * and register it in the table. In any case a corresponding call to * virUnrefStorageVol() is needed to not leak data. * * Returns a pointer to the storage vol, or NULL in case of failure */ virStorageVolPtr virGetStorageVol(virConnectPtr conn, const char *pool, const char *name, const char *key) { virStorageVolPtr ret = NULL; if (!VIR_IS_CONNECT(conn)) { virLibConnError(VIR_ERR_INVALID_ARG, _("no connection")); return NULL; } if (name == NULL) { virLibConnError(VIR_ERR_INVALID_ARG, _("missing name")); return NULL; } if (key == NULL) { virLibConnError(VIR_ERR_INVALID_ARG, _("missing key")); return NULL; } virMutexLock(&conn->lock); if (VIR_ALLOC(ret) < 0) { virMutexUnlock(&conn->lock); virReportOOMError(); goto error; } ret->pool = strdup(pool); if (ret->pool == NULL) { virMutexUnlock(&conn->lock); virReportOOMError(); goto error; } ret->name = strdup(name); if (ret->name == NULL) { virMutexUnlock(&conn->lock); virReportOOMError(); goto error; } if (virStrcpyStatic(ret->key, key) == NULL) { virMutexUnlock(&conn->lock); virLibConnError(VIR_ERR_INTERNAL_ERROR, _("Volume key %s too large for destination"), key); goto error; } ret->magic = VIR_STORAGE_VOL_MAGIC; ret->conn = conn; conn->refs++; ret->refs++; virMutexUnlock(&conn->lock); return(ret); error: if (ret != NULL) { VIR_FREE(ret->name); VIR_FREE(ret->pool); VIR_FREE(ret); } return(NULL); }
/** * virGetInterface: * @conn: the hypervisor connection * @name: pointer to the interface name * @mac: pointer to the mac * * Lookup if the interface is already registered for that connection, * if yes return a new pointer to it (possibly updating the MAC * address), if no allocate a new structure, and register it in the * table. In any case a corresponding call to virUnrefInterface() is * needed to not leak data. * * Returns a pointer to the interface, or NULL in case of failure */ virInterfacePtr virGetInterface(virConnectPtr conn, const char *name, const char *mac) { virInterfacePtr ret = NULL; if (!VIR_IS_CONNECT(conn)) { virLibConnError(VIR_ERR_INVALID_ARG, _("no connection")); return NULL; } if (name == NULL) { virLibConnError(VIR_ERR_INVALID_ARG, _("missing name")); return NULL; } /* a NULL mac from caller is okay. Treat it as blank */ if (mac == NULL) mac = ""; virMutexLock(&conn->lock); if (VIR_ALLOC(ret) < 0) { virMutexUnlock(&conn->lock); virReportOOMError(); goto error; } ret->name = strdup(name); if (ret->name == NULL) { virMutexUnlock(&conn->lock); virReportOOMError(); goto error; } ret->mac = strdup(mac); if (ret->mac == NULL) { virMutexUnlock(&conn->lock); virReportOOMError(); goto error; } ret->magic = VIR_INTERFACE_MAGIC; ret->conn = conn; conn->refs++; ret->refs++; virMutexUnlock(&conn->lock); return(ret); error: if (ret != NULL) { VIR_FREE(ret->name); VIR_FREE(ret->mac); VIR_FREE(ret); } return(NULL); }
/** * virGetSecret: * @conn: the hypervisor connection * @uuid: secret UUID * * Lookup if the secret is already registered for that connection, if so return * a pointer to it, otherwise allocate a new structure, and register it in the * table. In any case a corresponding call to virUnrefSecret() is needed to not * leak data. * * Returns a pointer to the secret, or NULL in case of failure */ virSecretPtr virGetSecret(virConnectPtr conn, const unsigned char *uuid, int usageType, const char *usageID) { virSecretPtr ret = NULL; char uuidstr[VIR_UUID_STRING_BUFLEN]; if (!VIR_IS_CONNECT(conn)) { virLibConnError(VIR_ERR_INVALID_ARG, _("no connection")); return NULL; } if (uuid == NULL) { virLibConnError(VIR_ERR_INVALID_ARG, _("missing uuid")); return NULL; } if (usageID == NULL) { virLibConnError(VIR_ERR_INVALID_ARG, _("missing usageID")); return NULL; } virMutexLock(&conn->lock); virUUIDFormat(uuid, uuidstr); if (VIR_ALLOC(ret) < 0) { virMutexUnlock(&conn->lock); virReportOOMError(); goto error; } ret->magic = VIR_SECRET_MAGIC; ret->conn = conn; memcpy(&(ret->uuid[0]), uuid, VIR_UUID_BUFLEN); ret->usageType = usageType; if (!(ret->usageID = strdup(usageID))) { virMutexUnlock(&conn->lock); virReportOOMError(); goto error; } conn->refs++; ret->refs++; virMutexUnlock(&conn->lock); return ret; error: if (ret != NULL) { VIR_FREE(ret->usageID); VIR_FREE(ret); } return NULL; }
/** * virGetStoragePool: * @conn: the hypervisor connection * @name: pointer to the storage pool name * @uuid: pointer to the uuid * * Lookup if the storage pool is already registered for that connection, * if yes return a new pointer to it, if no allocate a new structure, * and register it in the table. In any case a corresponding call to * virUnrefStoragePool() is needed to not leak data. * * Returns a pointer to the network, or NULL in case of failure */ virStoragePoolPtr virGetStoragePool(virConnectPtr conn, const char *name, const unsigned char *uuid) { virStoragePoolPtr ret = NULL; char uuidstr[VIR_UUID_STRING_BUFLEN]; if (!VIR_IS_CONNECT(conn)) { virLibConnError(VIR_ERR_INVALID_ARG, _("no connection")); return NULL; } if (name == NULL) { virLibConnError(VIR_ERR_INVALID_ARG, _("missing name")); return NULL; } if (uuid == NULL) { virLibConnError(VIR_ERR_INVALID_ARG, _("missing uuid")); return NULL; } virMutexLock(&conn->lock); virUUIDFormat(uuid, uuidstr); if (VIR_ALLOC(ret) < 0) { virMutexUnlock(&conn->lock); virReportOOMError(); goto error; } ret->name = strdup(name); if (ret->name == NULL) { virMutexUnlock(&conn->lock); virReportOOMError(); goto error; } ret->magic = VIR_STORAGE_POOL_MAGIC; ret->conn = conn; memcpy(&(ret->uuid[0]), uuid, VIR_UUID_BUFLEN); conn->refs++; ret->refs++; virMutexUnlock(&conn->lock); return(ret); error: if (ret != NULL) { VIR_FREE(ret->name); VIR_FREE(ret); } return(NULL); }
/** * virGetInterface: * @conn: the hypervisor connection * @name: pointer to the interface name * @mac: pointer to the mac * * Lookup if the interface is already registered for that connection, * if yes return a new pointer to it (possibly updating the MAC * address), if no allocate a new structure, and register it in the * table. In any case a corresponding call to virObjectUnref() is * needed to not leak data. * * Returns a pointer to the interface, or NULL in case of failure */ virInterfacePtr virGetInterface(virConnectPtr conn, const char *name, const char *mac) { virInterfacePtr ret = NULL; if (virDataTypesInitialize() < 0) return NULL; if (!VIR_IS_CONNECT(conn)) { virLibConnError(VIR_ERR_INVALID_CONN, "%s", _("no connection")); return NULL; } virCheckNonNullArgReturn(name, NULL); /* a NULL mac from caller is okay. Treat it as blank */ if (mac == NULL) mac = ""; if (!(ret = virObjectNew(virInterfaceClass))) return NULL; if (VIR_STRDUP(ret->name, name) < 0 || VIR_STRDUP(ret->mac, mac) < 0) goto error; ret->conn = virObjectRef(conn); return ret; error: virObjectUnref(ret); return NULL; }
/** * virGetNodeDevice: * @conn: the hypervisor connection * @name: device name (unique on node) * * Lookup if the device is already registered for that connection, * if yes return a new pointer to it, if no allocate a new structure, * and register it in the table. In any case a corresponding call to * virObjectUnref() is needed to not leak data. * * Returns a pointer to the node device, or NULL in case of failure */ virNodeDevicePtr virGetNodeDevice(virConnectPtr conn, const char *name) { virNodeDevicePtr ret = NULL; if (virDataTypesInitialize() < 0) return NULL; if (!VIR_IS_CONNECT(conn)) { virLibConnError(VIR_ERR_INVALID_CONN, "%s", _("no connection")); return NULL; } virCheckNonNullArgReturn(name, NULL); if (!(ret = virObjectNew(virNodeDeviceClass))) return NULL; if (VIR_STRDUP(ret->name, name) < 0) goto error; ret->conn = virObjectRef(conn); return ret; error: virObjectUnref(ret); return NULL; }
/** * virGetSecret: * @conn: the hypervisor connection * @uuid: secret UUID * * Lookup if the secret is already registered for that connection, if so return * a pointer to it, otherwise allocate a new structure, and register it in the * table. In any case a corresponding call to virObjectUnref() is needed to not * leak data. * * Returns a pointer to the secret, or NULL in case of failure */ virSecretPtr virGetSecret(virConnectPtr conn, const unsigned char *uuid, int usageType, const char *usageID) { virSecretPtr ret = NULL; if (virDataTypesInitialize() < 0) return NULL; if (!VIR_IS_CONNECT(conn)) { virLibConnError(VIR_ERR_INVALID_CONN, "%s", _("no connection")); return NULL; } virCheckNonNullArgReturn(uuid, NULL); virCheckNonNullArgReturn(usageID, NULL); if (!(ret = virObjectNew(virSecretClass))) return NULL; memcpy(&(ret->uuid[0]), uuid, VIR_UUID_BUFLEN); ret->usageType = usageType; if (VIR_STRDUP(ret->usageID, usageID) < 0) goto error; ret->conn = virObjectRef(conn); return ret; error: virObjectUnref(ret); return NULL; }
/** * virGetNWFilter: * @conn: the hypervisor connection * @name: pointer to the network filter pool name * @uuid: pointer to the uuid * * Lookup if the network filter is already registered for that connection, * if yes return a new pointer to it, if no allocate a new structure, * and register it in the table. In any case a corresponding call to * virObjectUnref() is needed to not leak data. * * Returns a pointer to the network, or NULL in case of failure */ virNWFilterPtr virGetNWFilter(virConnectPtr conn, const char *name, const unsigned char *uuid) { virNWFilterPtr ret = NULL; if (virDataTypesInitialize() < 0) return NULL; if (!VIR_IS_CONNECT(conn)) { virLibConnError(VIR_ERR_INVALID_CONN, "%s", _("no connection")); return NULL; } virCheckNonNullArgReturn(name, NULL); virCheckNonNullArgReturn(uuid, NULL); if (!(ret = virObjectNew(virNWFilterClass))) return NULL; if (VIR_STRDUP(ret->name, name) < 0) goto error; memcpy(&(ret->uuid[0]), uuid, VIR_UUID_BUFLEN); ret->conn = virObjectRef(conn); return ret; error: virObjectUnref(ret); return NULL; }
virDomainSnapshotPtr virGetDomainSnapshot(virDomainPtr domain, const char *name) { virDomainSnapshotPtr ret = NULL; if (virDataTypesInitialize() < 0) return NULL; if (!VIR_IS_DOMAIN(domain)) { virLibConnError(VIR_ERR_INVALID_DOMAIN, "%s", _("bad domain")); return NULL; } virCheckNonNullArgReturn(name, NULL); if (!(ret = virObjectNew(virDomainSnapshotClass))) return NULL; if (VIR_STRDUP(ret->name, name) < 0) goto cleanup; ret->domain = virObjectRef(domain); return ret; cleanup: virObjectUnref(ret); return NULL; }
/** * virDomainQemuAgentCommand: * @domain: a domain object * @cmd: the guest agent command string * @timeout: timeout seconds * @flags: execution flags * * Execute an arbitrary Guest Agent command. * * Issue @cmd to the guest agent running in @domain. * @timeout must be -2, -1, 0 or positive. * VIR_DOMAIN_QEMU_AGENT_COMMAND_BLOCK(-2): meaning to block forever waiting for * a result. * VIR_DOMAIN_QEMU_AGENT_COMMAND_DEFAULT(-1): use default timeout value. * VIR_DOMAIN_QEMU_AGENT_COMMAND_NOWAIT(0): does not wait. * positive value: wait for @timeout seconds * * Returns strings if success, NULL in failure. */ char * virDomainQemuAgentCommand(virDomainPtr domain, const char *cmd, int timeout, unsigned int flags) { virConnectPtr conn; VIR_DEBUG("domain=%p, cmd=%s, timeout=%d, flags=%x", domain, cmd, timeout, flags); if (!VIR_IS_CONNECTED_DOMAIN(domain)) { virLibDomainError(NULL, VIR_ERR_INVALID_DOMAIN, __FUNCTION__); virDispatchError(NULL); return NULL; } if (domain->conn->flags & VIR_CONNECT_RO) { virLibDomainError(NULL, VIR_ERR_OPERATION_DENIED, __FUNCTION__); return NULL; } conn = domain->conn; if (conn->driver->qemuDomainArbitraryAgentCommand) { return conn->driver->qemuDomainArbitraryAgentCommand(domain, cmd, timeout, flags); } virLibConnError(conn, VIR_ERR_NO_SUPPORT, __FUNCTION__); /* Copy to connection error object for back compatibility */ virDispatchError(conn); return NULL; }
/** * virDomainQemuAttach: * @conn: pointer to a hypervisor connection * @pid_value: the UNIX process ID of the external QEMU process * @flags: optional flags, currently unused * * This API is QEMU specific, so it will only work with hypervisor * connections to the QEMU driver. * * This API will attach to an externally launched QEMU process * identified by @pid. There are several requirements to successfully * attach to an external QEMU process: * * - It must have been started with a monitor socket using the UNIX * domain socket protocol. * - No device hotplug/unplug, or other configuration changes can * have been made via the monitor since it started. * - The '-name' and '-uuid' arguments should have been set (not * mandatory, but strongly recommended) * * To date, the only platforms we know of where pid_t is larger than * unsigned int (64-bit Windows) also lack UNIX sockets, so the choice * of @pid_value as an unsigned int should not present any difficulties. * * If successful, then the guest will appear in the list of running * domains for this connection, and other APIs should operate * normally (provided the above requirements were honored). * * Returns a new domain object on success, NULL otherwise */ virDomainPtr virDomainQemuAttach(virConnectPtr conn, unsigned int pid_value, unsigned int flags) { pid_t pid = pid_value; VIR_DEBUG("conn=%p, pid=%u, flags=%x", conn, pid_value, flags); virResetLastError(); if (!VIR_IS_CONNECT(conn)) { virLibConnError(NULL, VIR_ERR_INVALID_CONN, __FUNCTION__); virDispatchError(NULL); return NULL; } virCheckPositiveArgGoto(pid_value, error); if (pid != pid_value) { virReportInvalidArg(pid_value, _("pid_value in %s is too large"), __FUNCTION__); goto error; } if (conn->flags & VIR_CONNECT_RO) { virLibDomainError(domain, VIR_ERR_OPERATION_DENIED, __FUNCTION__); goto error; } if (conn->driver->qemuDomainAttach) { virDomainPtr ret; ret = conn->driver->qemuDomainAttach(conn, pid_value, flags); if (!ret) goto error; return ret; } virLibConnError(conn, VIR_ERR_NO_SUPPORT, __FUNCTION__); error: virDispatchError(conn); return NULL; }
/** * virGetStorageVol: * @conn: the hypervisor connection * @pool: pool owning the volume * @name: pointer to the storage vol name * @key: pointer to unique key of the volume * * Lookup if the storage vol is already registered for that connection, * if yes return a new pointer to it, if no allocate a new structure, * and register it in the table. In any case a corresponding call to * virUnrefStorageVol() is needed to not leak data. * * Returns a pointer to the storage vol, or NULL in case of failure */ virStorageVolPtr virGetStorageVol(virConnectPtr conn, const char *pool, const char *name, const char *key) { virStorageVolPtr ret = NULL; if (!VIR_IS_CONNECT(conn)) { virLibConnError(VIR_ERR_INVALID_CONN, _("no connection")); return NULL; } virCheckNonNullArgReturn(name, NULL); virCheckNonNullArgReturn(key, NULL); virMutexLock(&conn->lock); if (VIR_ALLOC(ret) < 0) { virMutexUnlock(&conn->lock); virReportOOMError(); goto error; } ret->pool = strdup(pool); if (ret->pool == NULL) { virMutexUnlock(&conn->lock); virReportOOMError(); goto error; } ret->name = strdup(name); if (ret->name == NULL) { virMutexUnlock(&conn->lock); virReportOOMError(); goto error; } ret->key = strdup(key); if (ret->key == NULL) { virMutexUnlock(&conn->lock); virReportOOMError(); goto error; } ret->magic = VIR_STORAGE_VOL_MAGIC; ret->conn = conn; conn->refs++; ret->refs++; virMutexUnlock(&conn->lock); return ret; error: if (ret != NULL) { VIR_FREE(ret->key); VIR_FREE(ret->name); VIR_FREE(ret->pool); VIR_FREE(ret); } return NULL; }
/** * virGetNodeDevice: * @conn: the hypervisor connection * @name: device name (unique on node) * * Lookup if the device is already registered for that connection, * if yes return a new pointer to it, if no allocate a new structure, * and register it in the table. In any case a corresponding call to * virUnrefNodeDevice() is needed to not leak data. * * Returns a pointer to the node device, or NULL in case of failure */ virNodeDevicePtr virGetNodeDevice(virConnectPtr conn, const char *name) { virNodeDevicePtr ret = NULL; if (!VIR_IS_CONNECT(conn)) { virLibConnError(VIR_ERR_INVALID_ARG, _("no connection")); return NULL; } if (name == NULL) { virLibConnError(VIR_ERR_INVALID_ARG, _("missing name")); return NULL; } virMutexLock(&conn->lock); if (VIR_ALLOC(ret) < 0) { virMutexUnlock(&conn->lock); virReportOOMError(); goto error; } ret->magic = VIR_NODE_DEVICE_MAGIC; ret->conn = conn; ret->name = strdup(name); if (ret->name == NULL) { virMutexUnlock(&conn->lock); virReportOOMError(); goto error; } conn->refs++; ret->refs++; virMutexUnlock(&conn->lock); return(ret); error: if (ret != NULL) { VIR_FREE(ret->name); VIR_FREE(ret); } return(NULL); }
virDomainSnapshotPtr virGetDomainSnapshot(virDomainPtr domain, const char *name) { virDomainSnapshotPtr ret = NULL; if (!VIR_IS_DOMAIN(domain)) { virLibConnError(VIR_ERR_INVALID_ARG, _("bad domain")); return NULL; } if (name == NULL) { virLibConnError(VIR_ERR_INVALID_ARG, _("missing name")); return NULL; } virMutexLock(&domain->conn->lock); if (VIR_ALLOC(ret) < 0) { virMutexUnlock(&domain->conn->lock); virReportOOMError(); goto error; } ret->name = strdup(name); if (ret->name == NULL) { virMutexUnlock(&domain->conn->lock); virReportOOMError(); goto error; } ret->magic = VIR_SNAPSHOT_MAGIC; ret->domain = domain; domain->refs++; ret->refs++; virMutexUnlock(&domain->conn->lock); return(ret); error: if (ret != NULL) { VIR_FREE(ret->name); VIR_FREE(ret); } return(NULL); }
/** * virGetDomain: * @conn: the hypervisor connection * @name: pointer to the domain name * @uuid: pointer to the uuid * * Lookup if the domain is already registered for that connection, * if yes return a new pointer to it, if no allocate a new structure, * and register it in the table. In any case a corresponding call to * virUnrefDomain() is needed to not leak data. * * Returns a pointer to the domain, or NULL in case of failure */ virDomainPtr virGetDomain(virConnectPtr conn, const char *name, const unsigned char *uuid) { virDomainPtr ret = NULL; char uuidstr[VIR_UUID_STRING_BUFLEN]; if (!VIR_IS_CONNECT(conn)) { virLibConnError(VIR_ERR_INVALID_CONN, _("no connection")); return NULL; } virCheckNonNullArgReturn(name, NULL); virCheckNonNullArgReturn(uuid, NULL); virMutexLock(&conn->lock); virUUIDFormat(uuid, uuidstr); if (VIR_ALLOC(ret) < 0) { virMutexUnlock(&conn->lock); virReportOOMError(); goto error; } ret->name = strdup(name); if (ret->name == NULL) { virMutexUnlock(&conn->lock); virReportOOMError(); goto error; } ret->magic = VIR_DOMAIN_MAGIC; ret->conn = conn; ret->id = -1; memcpy(&(ret->uuid[0]), uuid, VIR_UUID_BUFLEN); conn->refs++; ret->refs++; virMutexUnlock(&conn->lock); return ret; error: if (ret != NULL) { VIR_FREE(ret->name); VIR_FREE(ret); } return NULL; }
int virDomainQemuMonitorCommand(virDomainPtr domain, const char *cmd, char **result, unsigned int flags) { virConnectPtr conn; VIR_DEBUG("domain=%p, cmd=%s, result=%p, flags=%u", domain, cmd, result, flags); virResetLastError(); if (!VIR_IS_CONNECTED_DOMAIN(domain)) { virLibDomainError(NULL, VIR_ERR_INVALID_DOMAIN, __FUNCTION__); virDispatchError(NULL); return -1; } conn = domain->conn; if (result == NULL) { virLibDomainError(domain, VIR_ERR_INVALID_ARG, __FUNCTION__); goto error; } if (conn->flags & VIR_CONNECT_RO) { virLibDomainError(domain, VIR_ERR_OPERATION_DENIED, __FUNCTION__); goto error; } if (conn->driver->qemuDomainMonitorCommand) { int ret; ret = conn->driver->qemuDomainMonitorCommand(domain, cmd, result, flags); if (ret < 0) goto error; return ret; } virLibConnError(conn, VIR_ERR_NO_SUPPORT, __FUNCTION__); error: virDispatchError(conn); return -1; }
/** * virDomainLxcOpenNamespace: * @domain: a domain object * @fdlist: pointer to an array to be filled with FDs * @flags: currently unused, pass 0 * * This API is LXC specific, so it will only work with hypervisor * connections to the LXC driver. * * Open the namespaces associated with the container @domain. * The @fdlist array will be allocated to a suitable size, * and filled with file descriptors for the namespaces. It * is the caller's responsibility to close the file descriptors * * The returned file descriptors are intended to be used with * the setns() system call. * * Returns the number of opened file descriptors, or -1 on error */ int virDomainLxcOpenNamespace(virDomainPtr domain, int **fdlist, unsigned int flags) { virConnectPtr conn; VIR_DEBUG("domain=%p, fdlist=%p flags=%x", domain, fdlist, flags); virResetLastError(); if (!VIR_IS_CONNECTED_DOMAIN(domain)) { virLibDomainError(NULL, VIR_ERR_INVALID_DOMAIN, __FUNCTION__); virDispatchError(NULL); return -1; } conn = domain->conn; virCheckNonNullArgGoto(fdlist, error); if (conn->flags & VIR_CONNECT_RO) { virLibDomainError(domain, VIR_ERR_OPERATION_DENIED, __FUNCTION__); goto error; } if (conn->driver->domainLxcOpenNamespace) { int ret; ret = conn->driver->domainLxcOpenNamespace(domain, fdlist, flags); if (ret < 0) goto error; return ret; } virLibConnError(conn, VIR_ERR_NO_SUPPORT, __FUNCTION__); error: virDispatchError(conn); return -1; }
/** * virUnrefConnect: * @conn: the hypervisor connection to unreference * * Unreference the connection. If the use count drops to zero, the structure is * actually freed. * * Returns the reference count or -1 in case of failure. */ int virUnrefConnect(virConnectPtr conn) { int refs; if ((!VIR_IS_CONNECT(conn))) { virLibConnError(VIR_ERR_INVALID_CONN, _("no connection")); return -1; } virMutexLock(&conn->lock); VIR_DEBUG("unref connection %p %d", conn, conn->refs); conn->refs--; refs = conn->refs; if (refs == 0) { virReleaseConnect(conn); /* Already unlocked mutex */ return 0; } virMutexUnlock(&conn->lock); return refs; }
/** * virUnrefSecret: * @secret: the secret to unreference * * Unreference the secret. If the use count drops to zero, the structure is * actually freed. * * Returns the reference count or -1 in case of failure. */ int virUnrefSecret(virSecretPtr secret) { int refs; if (!VIR_IS_CONNECTED_SECRET(secret)) { virLibConnError(VIR_ERR_INVALID_SECRET, _("bad secret or no connection")); return -1; } virMutexLock(&secret->conn->lock); VIR_DEBUG("unref secret %p %p %d", secret, secret->uuid, secret->refs); secret->refs--; refs = secret->refs; if (refs == 0) { virReleaseSecret(secret); /* Already unlocked mutex */ return 0; } virMutexUnlock(&secret->conn->lock); return refs; }
/** * virUnrefDomain: * @domain: the domain to unreference * * Unreference the domain. If the use count drops to zero, the structure is * actually freed. * * Returns the reference count or -1 in case of failure. */ int virUnrefDomain(virDomainPtr domain) { int refs; if (!VIR_IS_CONNECTED_DOMAIN(domain)) { virLibConnError(VIR_ERR_INVALID_DOMAIN, _("bad domain or no connection")); return -1; } virMutexLock(&domain->conn->lock); VIR_DEBUG("unref domain %p %s %d", domain, domain->name, domain->refs); domain->refs--; refs = domain->refs; if (refs == 0) { virReleaseDomain(domain); /* Already unlocked mutex */ return 0; } virMutexUnlock(&domain->conn->lock); return refs; }
/** * virUnrefInterface: * @interface: the interface to unreference * * Unreference the interface. If the use count drops to zero, the structure is * actually freed. * * Returns the reference count or -1 in case of failure. */ int virUnrefInterface(virInterfacePtr iface) { int refs; if (!VIR_IS_CONNECTED_INTERFACE(iface)) { virLibConnError(VIR_ERR_INVALID_INTERFACE, _("bad interface or no connection")); return -1; } virMutexLock(&iface->conn->lock); VIR_DEBUG("unref interface %p %s %d", iface, iface->name, iface->refs); iface->refs--; refs = iface->refs; if (refs == 0) { virReleaseInterface(iface); /* Already unlocked mutex */ return 0; } virMutexUnlock(&iface->conn->lock); return refs; }
/** * virUnrefStorageVol: * @vol: the vol to unreference * * Unreference the vol. If the use count drops to zero, the structure is * actually freed. * * Returns the reference count or -1 in case of failure. */ int virUnrefStorageVol(virStorageVolPtr vol) { int refs; if (!VIR_IS_CONNECTED_STORAGE_VOL(vol)) { virLibConnError(VIR_ERR_INVALID_STORAGE_VOL, _("bad storage volume or no connection")); return -1; } virMutexLock(&vol->conn->lock); VIR_DEBUG("unref vol %p %s %d", vol, vol->name, vol->refs); vol->refs--; refs = vol->refs; if (refs == 0) { virReleaseStorageVol(vol); /* Already unlocked mutex */ return 0; } virMutexUnlock(&vol->conn->lock); return refs; }
/** * virUnrefStoragePool: * @pool: the pool to unreference * * Unreference the pool. If the use count drops to zero, the structure is * actually freed. * * Returns the reference count or -1 in case of failure. */ int virUnrefStoragePool(virStoragePoolPtr pool) { int refs; if (!VIR_IS_CONNECTED_STORAGE_POOL(pool)) { virLibConnError(VIR_ERR_INVALID_STORAGE_POOL, _("bad storage pool or no connection")); return -1; } virMutexLock(&pool->conn->lock); VIR_DEBUG("unref pool %p %s %d", pool, pool->name, pool->refs); pool->refs--; refs = pool->refs; if (refs == 0) { virReleaseStoragePool(pool); /* Already unlocked mutex */ return 0; } virMutexUnlock(&pool->conn->lock); return refs; }
/** * virUnrefNetwork: * @network: the network to unreference * * Unreference the network. If the use count drops to zero, the structure is * actually freed. * * Returns the reference count or -1 in case of failure. */ int virUnrefNetwork(virNetworkPtr network) { int refs; if (!VIR_IS_CONNECTED_NETWORK(network)) { virLibConnError(VIR_ERR_INVALID_NETWORK, _("bad network or no connection")); return -1; } virMutexLock(&network->conn->lock); VIR_DEBUG("unref network %p %s %d", network, network->name, network->refs); network->refs--; refs = network->refs; if (refs == 0) { virReleaseNetwork(network); /* Already unlocked mutex */ return 0; } virMutexUnlock(&network->conn->lock); return refs; }
int virUnrefDomainSnapshot(virDomainSnapshotPtr snapshot) { int refs; if (!VIR_IS_DOMAIN_SNAPSHOT(snapshot)) { virLibConnError(VIR_ERR_INVALID_DOMAIN_SNAPSHOT, _("not a snapshot")); return -1; } virMutexLock(&snapshot->domain->conn->lock); VIR_DEBUG("unref snapshot %p %s %d", snapshot, snapshot->name, snapshot->refs); snapshot->refs--; refs = snapshot->refs; if (refs == 0) { virReleaseDomainSnapshot(snapshot); /* Already unlocked mutex */ return 0; } virMutexUnlock(&snapshot->domain->conn->lock); return refs; }
/** * virGetStorageVol: * @conn: the hypervisor connection * @pool: pool owning the volume * @name: pointer to the storage vol name * @key: pointer to unique key of the volume * @privateData: pointer to driver specific private data * @freeFunc: private data cleanup function pointer specfic to driver * * Lookup if the storage vol is already registered for that connection, * if yes return a new pointer to it, if no allocate a new structure, * and register it in the table. In any case a corresponding call to * virObjectUnref() is needed to not leak data. * * Returns a pointer to the storage vol, or NULL in case of failure */ virStorageVolPtr virGetStorageVol(virConnectPtr conn, const char *pool, const char *name, const char *key, void *privateData, virFreeCallback freeFunc) { virStorageVolPtr ret = NULL; if (virDataTypesInitialize() < 0) return NULL; if (!VIR_IS_CONNECT(conn)) { virLibConnError(VIR_ERR_INVALID_CONN, "%s", _("no connection")); return NULL; } virCheckNonNullArgReturn(pool, NULL); virCheckNonNullArgReturn(name, NULL); virCheckNonNullArgReturn(key, NULL); if (!(ret = virObjectNew(virStorageVolClass))) return NULL; if (VIR_STRDUP(ret->pool, pool) < 0 || VIR_STRDUP(ret->name, name) < 0 || VIR_STRDUP(ret->key, key) < 0) goto error; ret->conn = virObjectRef(conn); /* set driver specific data */ ret->privateData = privateData; ret->privateDataFreeFunc = freeFunc; return ret; error: virObjectUnref(ret); return NULL; }
/** * virUnrefNWFilter: * @nwfilter: the nwfilter to unreference * * Unreference the networkf itler. If the use count drops to zero, the * structure is actually freed. * * Returns the reference count or -1 in case of failure. */ int virUnrefNWFilter(virNWFilterPtr nwfilter) { int refs; if (!VIR_IS_CONNECTED_NWFILTER(nwfilter)) { virLibConnError(VIR_ERR_INVALID_NWFILTER, _("bad nwfilter or no connection")); return -1; } virMutexLock(&nwfilter->conn->lock); VIR_DEBUG("unref nwfilter %p %s %d", nwfilter, nwfilter->name, nwfilter->refs); nwfilter->refs--; refs = nwfilter->refs; if (refs == 0) { virReleaseNWFilter(nwfilter); /* Already unlocked mutex */ return 0; } virMutexUnlock(&nwfilter->conn->lock); return refs; }
/** * virGetStoragePool: * @conn: the hypervisor connection * @name: pointer to the storage pool name * @uuid: pointer to the uuid * @privateData: pointer to driver specific private data * @freeFunc: private data cleanup function pointer specfic to driver * * Lookup if the storage pool is already registered for that connection, * if yes return a new pointer to it, if no allocate a new structure, * and register it in the table. In any case a corresponding call to * virObjectUnref() is needed to not leak data. * * Returns a pointer to the storage pool, or NULL in case of failure */ virStoragePoolPtr virGetStoragePool(virConnectPtr conn, const char *name, const unsigned char *uuid, void *privateData, virFreeCallback freeFunc) { virStoragePoolPtr ret = NULL; if (virDataTypesInitialize() < 0) return NULL; if (!VIR_IS_CONNECT(conn)) { virLibConnError(VIR_ERR_INVALID_CONN, "%s", _("no connection")); return NULL; } virCheckNonNullArgReturn(name, NULL); virCheckNonNullArgReturn(uuid, NULL); if (!(ret = virObjectNew(virStoragePoolClass))) return NULL; if (VIR_STRDUP(ret->name, name) < 0) goto error; ret->conn = virObjectRef(conn); memcpy(&(ret->uuid[0]), uuid, VIR_UUID_BUFLEN); /* set the driver specific data */ ret->privateData = privateData; ret->privateDataFreeFunc = freeFunc; return ret; error: virObjectUnref(ret); return NULL; }