int qemuTestCapsCacheInsert(virQEMUCapsCachePtr cache, const char *binary, virQEMUCapsPtr caps) { int ret; if (caps) { /* Our caps were created artificially, so we don't want * virQEMUCapsCacheFree() to attempt to deallocate them */ virObjectRef(caps); } else { caps = virQEMUCapsNew(); if (!caps) return -ENOMEM; } /* We can have repeating names for our test data sets, * so make sure there's no old copy */ virHashRemoveEntry(cache->binaries, binary); ret = virHashAddEntry(cache->binaries, binary, caps); if (ret < 0) virObjectUnref(caps); else qemuTestCapsName = binary; return ret; }
int virLXCProcessAutoDestroyRemove(virLXCDriverPtr driver, virDomainObjPtr vm) { char uuidstr[VIR_UUID_STRING_BUFLEN]; virUUIDFormat(vm->def->uuid, uuidstr); VIR_DEBUG("vm=%s uuid=%s", vm->def->name, uuidstr); if (virHashRemoveEntry(driver->autodestroy, uuidstr) < 0) return -1; return 0; }
void virCloseCallbacksRun(virCloseCallbacksPtr closeCallbacks, virConnectPtr conn, virDomainObjListPtr domains, void *opaque) { virCloseCallbacksListPtr list; size_t i; VIR_DEBUG("conn=%p", conn); /* We must not hold the lock while running the callbacks, * so first we obtain the list of callbacks, then remove * them all from the hash. At that point we can release * the lock and run the callbacks safely. */ virObjectLock(closeCallbacks); list = virCloseCallbacksGetForConn(closeCallbacks, conn); if (!list) { virObjectUnlock(closeCallbacks); return; } for (i = 0; i < list->nentries; i++) { char uuidstr[VIR_UUID_STRING_BUFLEN]; virUUIDFormat(list->entries[i].uuid, uuidstr); virHashRemoveEntry(closeCallbacks->list, uuidstr); } virObjectUnlock(closeCallbacks); for (i = 0; i < list->nentries; i++) { virDomainObjPtr vm; /* Grab a ref and lock to the vm */ if (!(vm = virDomainObjListFindByUUIDRef(domains, list->entries[i].uuid))) { char uuidstr[VIR_UUID_STRING_BUFLEN]; virUUIDFormat(list->entries[i].uuid, uuidstr); VIR_DEBUG("No domain object with UUID %s", uuidstr); continue; } /* Remove the ref taken out during virCloseCallbacksSet since * we're about to call the callback function and we have another * ref anyway (so it cannot be deleted). * * Call the callback function, ignoring the return since it might be * NULL. Once we're done with the object, then end the API usage. */ virObjectUnref(vm); ignore_value(list->entries[i].callback(vm, conn, opaque)); virDomainObjEndAPI(&vm); } VIR_FREE(list->entries); VIR_FREE(list); }
/** * virHashSteal: * @table: the hash table * @name: the name of the userdata * * Find the userdata specified by @name * and remove it from the hash without freeing it. * * Returns the a pointer to the userdata */ void *virHashSteal(virHashTablePtr table, const void *name) { void *data = virHashLookup(table, name); if (data) { virHashDataFree dataFree = table->dataFree; table->dataFree = NULL; virHashRemoveEntry(table, name); table->dataFree = dataFree; } return data; }
static void virLXCProcessAutoDestroyDom(void *payload, const void *name, void *opaque) { struct virLXCProcessAutoDestroyData *data = opaque; virConnectPtr conn = payload; const char *uuidstr = name; unsigned char uuid[VIR_UUID_BUFLEN]; virDomainObjPtr dom; virDomainEventPtr event = NULL; virLXCDomainObjPrivatePtr priv; VIR_DEBUG("conn=%p uuidstr=%s thisconn=%p", conn, uuidstr, data->conn); if (data->conn != conn) return; if (virUUIDParse(uuidstr, uuid) < 0) { VIR_WARN("Failed to parse %s", uuidstr); return; } if (!(dom = virDomainObjListFindByUUID(data->driver->domains, uuid))) { VIR_DEBUG("No domain object to kill"); return; } priv = dom->privateData; VIR_DEBUG("Killing domain"); virLXCProcessStop(data->driver, dom, VIR_DOMAIN_SHUTOFF_DESTROYED); virDomainAuditStop(dom, "destroyed"); event = virDomainEventNewFromObj(dom, VIR_DOMAIN_EVENT_STOPPED, VIR_DOMAIN_EVENT_STOPPED_DESTROYED); priv->doneStopEvent = true; if (dom && !dom->persistent) virDomainObjListRemove(data->driver->domains, dom); if (dom) virObjectUnlock(dom); if (event) virDomainEventStateQueue(data->driver->domainEventState, event); virHashRemoveEntry(data->driver->autodestroy, uuidstr); }
void virCloseCallbacksRun(virCloseCallbacksPtr closeCallbacks, virConnectPtr conn, virDomainObjListPtr domains, void *opaque) { virCloseCallbacksListPtr list; size_t i; VIR_DEBUG("conn=%p", conn); /* We must not hold the lock while running the callbacks, * so first we obtain the list of callbacks, then remove * them all from the hash. At that point we can release * the lock and run the callbacks safely. */ virObjectLock(closeCallbacks); list = virCloseCallbacksGetForConn(closeCallbacks, conn); if (!list) return; for (i = 0; i < list->nentries; i++) { char uuidstr[VIR_UUID_STRING_BUFLEN]; virUUIDFormat(list->entries[i].uuid, uuidstr); virHashRemoveEntry(closeCallbacks->list, uuidstr); } virObjectUnlock(closeCallbacks); for (i = 0; i < list->nentries; i++) { virDomainObjPtr vm; if (!(vm = virDomainObjListFindByUUID(domains, list->entries[i].uuid))) { char uuidstr[VIR_UUID_STRING_BUFLEN]; virUUIDFormat(list->entries[i].uuid, uuidstr); VIR_DEBUG("No domain object with UUID %s", uuidstr); continue; } vm = list->entries[i].callback(vm, conn, opaque); if (vm) virObjectUnlock(vm); } VIR_FREE(list->entries); VIR_FREE(list); }
void virNWFilterUnlockIface(const char *ifname) { virNWFilterIfaceLockPtr ifaceLock; virMutexLock(&ifaceMapLock); ifaceLock = virHashLookup(ifaceLockMap, ifname); if (ifaceLock) { virMutexUnlock(&ifaceLock->lock); ifaceLock->refctr--; if (ifaceLock->refctr == 0) virHashRemoveEntry(ifaceLockMap, ifname); } virMutexUnlock(&ifaceMapLock); }
int virDomainCCWAddressReleaseAddr(virDomainCCWAddressSetPtr addrs, virDomainDeviceInfoPtr dev) { char *addr; int ret; addr = virDomainCCWAddressAsString(&(dev->addr.ccw)); if (!addr) return -1; if ((ret = virHashRemoveEntry(addrs->defined, addr)) == 0 && dev->addr.ccw.cssid == addrs->next.cssid && dev->addr.ccw.ssid == addrs->next.ssid && dev->addr.ccw.devno < addrs->next.devno) { addrs->next.devno = dev->addr.ccw.devno; addrs->next.assigned = false; } VIR_FREE(addr); return ret; }
int virCloseCallbacksUnset(virCloseCallbacksPtr closeCallbacks, virDomainObjPtr vm, virCloseCallback cb) { char uuidstr[VIR_UUID_STRING_BUFLEN]; virDriverCloseDefPtr closeDef; int ret = -1; virUUIDFormat(vm->def->uuid, uuidstr); VIR_DEBUG("vm=%s, uuid=%s, cb=%p", vm->def->name, uuidstr, cb); virObjectLock(closeCallbacks); closeDef = virHashLookup(closeCallbacks->list, uuidstr); if (!closeDef) goto cleanup; if (closeDef->cb && closeDef->cb != cb) { virReportError(VIR_ERR_INTERNAL_ERROR, _("Trying to remove mismatching close callback for" " domain %s"), vm->def->name); goto cleanup; } if (virHashRemoveEntry(closeCallbacks->list, uuidstr) < 0) goto cleanup; virObjectUnref(vm); ret = 0; cleanup: virObjectUnlock(closeCallbacks); if (!ret) virObjectUnref(closeCallbacks); return ret; }