src/lxc/lxc_conf.c
src/lxc/lxc_controller.c
src/lxc/lxc_driver.c
-src/lxc/lxc_monitor.c
src/lxc/lxc_process.c
src/libxl/libxl_driver.c
src/libxl/libxl_conf.c
static int virDomainObjOnceInit(void)
{
- if (!(virDomainObjClass = virClassNew(virClassForObject(),
+ if (!(virDomainObjClass = virClassNew(virClassForObjectLockable(),
"virDomainObj",
sizeof(virDomainObj),
virDomainObjDispose)))
const int *id = data;
int want = 0;
- virDomainObjLock(obj);
+ virObjectLock(obj);
if (virDomainObjIsActive(obj) &&
obj->def->id == *id)
want = 1;
- virDomainObjUnlock(obj);
+ virObjectUnlock(obj);
return want;
}
virDomainObjPtr obj;
obj = virHashSearch(doms->objs, virDomainObjListSearchID, &id);
if (obj)
- virDomainObjLock(obj);
+ virObjectLock(obj);
return obj;
}
obj = virHashLookup(doms->objs, uuidstr);
if (obj)
- virDomainObjLock(obj);
+ virObjectLock(obj);
return obj;
}
virDomainObjPtr obj = (virDomainObjPtr)payload;
int want = 0;
- virDomainObjLock(obj);
+ virObjectLock(obj);
if (STREQ(obj->def->name, (const char *)data))
want = 1;
- virDomainObjUnlock(obj);
+ virObjectUnlock(obj);
return want;
}
virDomainObjPtr obj;
obj = virHashSearch(doms->objs, virDomainObjListSearchName, name);
if (obj)
- virDomainObjLock(obj);
+ virObjectLock(obj);
return obj;
}
if (dom->privateDataFreeFunc)
(dom->privateDataFreeFunc)(dom->privateData);
- virMutexDestroy(&dom->lock);
-
virDomainSnapshotObjListFree(dom->snapshots);
}
if (virDomainObjInitialize() < 0)
return NULL;
- if (!(domain = virObjectNew(virDomainObjClass)))
+ if (!(domain = virObjectLockableNew(virDomainObjClass)))
return NULL;
- if (virMutexInit(&domain->lock) < 0) {
- virReportError(VIR_ERR_INTERNAL_ERROR,
- "%s", _("cannot initialize mutex"));
- VIR_FREE(domain);
- return NULL;
- }
-
if (caps &&
caps->privateDataAllocFunc) {
if (!(domain->privateData = (caps->privateDataAllocFunc)())) {
if (!(domain->snapshots = virDomainSnapshotObjListNew()))
goto error;
- virDomainObjLock(domain);
+ virObjectLock(domain);
virDomainObjSetState(domain, VIR_DOMAIN_SHUTOFF,
VIR_DOMAIN_SHUTOFF_UNKNOWN);
char uuidstr[VIR_UUID_STRING_BUFLEN];
virUUIDFormat(dom->def->uuid, uuidstr);
- virDomainObjUnlock(dom);
+ virObjectUnlock(dom);
virHashRemoveEntry(doms->objs, uuidstr);
}
notify,
opaque);
if (dom) {
- virDomainObjUnlock(dom);
+ virObjectUnlock(dom);
if (!liveStatus)
dom->persistent = 1;
}
ret = dupVM;
cleanup:
if (vm)
- virDomainObjUnlock(vm);
+ virObjectUnlock(vm);
return ret;
}
-void virDomainObjLock(virDomainObjPtr obj)
-{
- virMutexLock(&obj->lock);
-}
-
-void virDomainObjUnlock(virDomainObjPtr obj)
-{
- virMutexUnlock(&obj->lock);
-}
-
-
static void virDomainObjListCountActive(void *payload, const void *name ATTRIBUTE_UNUSED, void *data)
{
virDomainObjPtr obj = payload;
int *count = data;
- virDomainObjLock(obj);
+ virObjectLock(obj);
if (virDomainObjIsActive(obj))
(*count)++;
- virDomainObjUnlock(obj);
+ virObjectUnlock(obj);
}
static void virDomainObjListCountInactive(void *payload, const void *name ATTRIBUTE_UNUSED, void *data)
{
virDomainObjPtr obj = payload;
int *count = data;
- virDomainObjLock(obj);
+ virObjectLock(obj);
if (!virDomainObjIsActive(obj))
(*count)++;
- virDomainObjUnlock(obj);
+ virObjectUnlock(obj);
}
int virDomainObjListNumOfDomains(virDomainObjListPtr doms, int active)
{
virDomainObjPtr obj = payload;
struct virDomainIDData *data = opaque;
- virDomainObjLock(obj);
+ virObjectLock(obj);
if (virDomainObjIsActive(obj) && data->numids < data->maxids)
data->ids[data->numids++] = obj->def->id;
- virDomainObjUnlock(obj);
+ virObjectUnlock(obj);
}
int virDomainObjListGetActiveIDs(virDomainObjListPtr doms,
if (data->oom)
return;
- virDomainObjLock(obj);
+ virObjectLock(obj);
if (!virDomainObjIsActive(obj) && data->numnames < data->maxnames) {
if (!(data->names[data->numnames] = strdup(obj->def->name)))
data->oom = 1;
else
data->numnames++;
}
- virDomainObjUnlock(obj);
+ virObjectUnlock(obj);
}
if (data->error)
return;
- virDomainObjLock(vm);
+ virObjectLock(vm);
/* check if the domain matches the filter */
/* filter by active state */
data->domains[data->ndomains++] = dom;
cleanup:
- virDomainObjUnlock(vm);
+ virObjectUnlock(vm);
return;
}
#undef MATCH
typedef struct _virDomainObj virDomainObj;
typedef virDomainObj *virDomainObjPtr;
struct _virDomainObj {
- virObject object;
-
- virMutex lock;
+ virObjectLockable parent;
pid_t pid;
virDomainStateReason state;
virDomainDefPtr def,
unsigned int check_active);
-void virDomainObjLock(virDomainObjPtr obj);
-void virDomainObjUnlock(virDomainObjPtr obj);
-
int virDomainObjListNumOfDomains(virDomainObjListPtr doms, int active);
int virDomainObjListGetActiveIDs(virDomainObjListPtr doms,
virDomainObjListGetInactiveNames;
virDomainObjListInit;
virDomainObjListNumOfDomains;
-virDomainObjLock;
virDomainObjNew;
virDomainObjSetDefTransient;
virDomainObjSetState;
virDomainObjTaint;
-virDomainObjUnlock;
virDomainPausedReasonTypeFromString;
virDomainPausedReasonTypeToString;
virDomainPciRombarModeTypeFromString;
virDomainObjPtr vm = payload;
virErrorPtr err;
- virDomainObjLock(vm);
+ virObjectLock(vm);
virResetLastError();
if (vm->autostart && !virDomainObjIsActive(vm) &&
}
if (vm)
- virDomainObjUnlock(vm);
+ virObjectUnlock(vm);
}
static int
virDomainEventPtr dom_event = NULL;
libxlDriverLock(driver);
- virDomainObjLock(vm);
+ virObjectLock(vm);
libxlDriverUnlock(driver);
if (event->type == LIBXL_EVENT_TYPE_DOMAIN_SHUTDOWN) {
cleanup:
if (vm)
- virDomainObjUnlock(vm);
+ virObjectUnlock(vm);
if (dom_event) {
libxlDriverLock(driver);
libxlDomainEventQueue(driver, dom_event);
int len;
uint8_t *data = NULL;
- virDomainObjLock(vm);
+ virObjectLock(vm);
/* Does domain still exist? */
rc = libxl_domain_info(driver->ctx, &d_info, vm->def->id);
/* Recreate domain death et. al. events */
libxlCreateDomEvents(vm);
- virDomainObjUnlock(vm);
+ virObjectUnlock(vm);
return;
out:
if (!vm->persistent)
virDomainRemoveInactive(&driver->domains, vm);
else
- virDomainObjUnlock(vm);
+ virObjectUnlock(vm);
}
static void
cleanup:
virDomainDefFree(def);
if (vm)
- virDomainObjUnlock(vm);
+ virObjectUnlock(vm);
libxlDriverUnlock(driver);
return dom;
}
cleanup:
if (vm)
- virDomainObjUnlock(vm);
+ virObjectUnlock(vm);
return dom;
}
cleanup:
if (vm)
- virDomainObjUnlock(vm);
+ virObjectUnlock(vm);
return dom;
}
cleanup:
if (vm)
- virDomainObjUnlock(vm);
+ virObjectUnlock(vm);
return dom;
}
cleanup:
if (vm)
- virDomainObjUnlock(vm);
+ virObjectUnlock(vm);
if (event) {
libxlDriverLock(driver);
libxlDomainEventQueue(driver, event);
cleanup:
if (vm)
- virDomainObjUnlock(vm);
+ virObjectUnlock(vm);
if (event) {
libxlDriverLock(driver);
libxlDomainEventQueue(driver, event);
cleanup:
if (vm)
- virDomainObjUnlock(vm);
+ virObjectUnlock(vm);
libxlDriverUnlock(driver);
return ret;
}
cleanup:
if (vm)
- virDomainObjUnlock(vm);
+ virObjectUnlock(vm);
libxlDriverUnlock(driver);
return ret;
}
cleanup:
if (vm)
- virDomainObjUnlock(vm);
+ virObjectUnlock(vm);
if (event)
libxlDomainEventQueue(driver, event);
libxlDriverUnlock(driver);
cleanup:
if (vm)
- virDomainObjUnlock(vm);
+ virObjectUnlock(vm);
return type;
}
cleanup:
if (vm)
- virDomainObjUnlock(vm);
+ virObjectUnlock(vm);
return ret;
}
cleanup:
if (vm)
- virDomainObjUnlock(vm);
+ virObjectUnlock(vm);
return ret;
}
cleanup:
if (vm)
- virDomainObjUnlock(vm);
+ virObjectUnlock(vm);
return ret;
}
cleanup:
if (vm)
- virDomainObjUnlock(vm);
+ virObjectUnlock(vm);
return ret;
}
cleanup:
if (vm)
- virDomainObjUnlock(vm);
+ virObjectUnlock(vm);
libxlDriverUnlock(driver);
return ret;
}
virReportSystemError(errno, "%s", _("cannot close file"));
virDomainDefFree(def);
if (vm)
- virDomainObjUnlock(vm);
+ virObjectUnlock(vm);
libxlDriverUnlock(driver);
return ret;
}
}
cleanup:
if (vm)
- virDomainObjUnlock(vm);
+ virObjectUnlock(vm);
if (event) {
libxlDriverLock(driver);
libxlDomainEventQueue(driver, event);
cleanup:
if (vm)
- virDomainObjUnlock(vm);
+ virObjectUnlock(vm);
libxlDriverUnlock(driver);
VIR_FREE(name);
return ret;
libxlDriverPrivatePtr driver = opaque;
char *name;
- virDomainObjLock(vm);
+ virObjectLock(vm);
if (!(name = libxlDomainManagedSavePath(driver, vm)))
goto cleanup;
vm->hasManagedSave = virFileExists(name);
cleanup:
- virDomainObjUnlock(vm);
+ virObjectUnlock(vm);
VIR_FREE(name);
}
cleanup:
if (vm)
- virDomainObjUnlock(vm);
+ virObjectUnlock(vm);
libxlDriverUnlock(driver);
return ret;
}
cleanup:
VIR_FREE(name);
if (vm)
- virDomainObjUnlock(vm);
+ virObjectUnlock(vm);
libxlDriverUnlock(driver);
return ret;
}
cleanup:
VIR_FREE(bitmask);
if (vm)
- virDomainObjUnlock(vm);
+ virObjectUnlock(vm);
return ret;
}
cleanup:
if (vm)
- virDomainObjUnlock(vm);
+ virObjectUnlock(vm);
return ret;
}
cleanup:
if (vm)
- virDomainObjUnlock(vm);
+ virObjectUnlock(vm);
return ret;
}
cleanup:
if (vm)
- virDomainObjUnlock(vm);
+ virObjectUnlock(vm);
return ret;
}
cleanup:
if (vm)
- virDomainObjUnlock(vm);
+ virObjectUnlock(vm);
return ret;
}
cleanup:
if (vm)
- virDomainObjUnlock(vm);
+ virObjectUnlock(vm);
libxlDriverUnlock(driver);
return ret;
}
cleanup:
virDomainDefFree(def);
if (vm)
- virDomainObjUnlock(vm);
+ virObjectUnlock(vm);
if (event)
libxlDomainEventQueue(driver, event);
libxlDriverUnlock(driver);
cleanup:
VIR_FREE(name);
if (vm)
- virDomainObjUnlock(vm);
+ virObjectUnlock(vm);
if (event)
libxlDomainEventQueue(driver, event);
libxlDriverUnlock(driver);
virDomainDefFree(vmdef);
virDomainDeviceDefFree(dev);
if (vm)
- virDomainObjUnlock(vm);
+ virObjectUnlock(vm);
libxlDriverUnlock(driver);
return ret;
}
cleanup:
if (vm)
- virDomainObjUnlock(vm);
+ virObjectUnlock(vm);
return ret;
}
VIR_FREE(configFile);
VIR_FREE(autostartLink);
if (vm)
- virDomainObjUnlock(vm);
+ virObjectUnlock(vm);
libxlDriverUnlock(driver);
return ret;
}
cleanup:
if (vm)
- virDomainObjUnlock(vm);
+ virObjectUnlock(vm);
return ret;
}
cleanup:
if (vm)
- virDomainObjUnlock(vm);
+ virObjectUnlock(vm);
return ret;
}
cleanup:
if (vm)
- virDomainObjUnlock(vm);
+ virObjectUnlock(vm);
return ret;
}
cleanup:
if (obj)
- virDomainObjUnlock(obj);
+ virObjectUnlock(obj);
return ret;
}
cleanup:
if (obj)
- virDomainObjUnlock(obj);
+ virObjectUnlock(obj);
return ret;
}
cleanup:
if (vm)
- virDomainObjUnlock(vm);
+ virObjectUnlock(vm);
return ret;
}
cleanup:
if (vm)
- virDomainObjUnlock(vm);
+ virObjectUnlock(vm);
return dom;
}
cleanup:
if (vm)
- virDomainObjUnlock(vm);
+ virObjectUnlock(vm);
return dom;
}
cleanup:
if (vm)
- virDomainObjUnlock(vm);
+ virObjectUnlock(vm);
return dom;
}
cleanup:
if (obj)
- virDomainObjUnlock(obj);
+ virObjectUnlock(obj);
return ret;
}
cleanup:
if (obj)
- virDomainObjUnlock(obj);
+ virObjectUnlock(obj);
return ret;
}
cleanup:
if (obj)
- virDomainObjUnlock(obj);
+ virObjectUnlock(obj);
return ret;
}
cleanup:
virDomainDefFree(def);
if (vm)
- virDomainObjUnlock(vm);
+ virObjectUnlock(vm);
if (event)
virDomainEventStateQueue(driver->domainEventState, event);
lxcDriverUnlock(driver);
cleanup:
if (vm)
- virDomainObjUnlock(vm);
+ virObjectUnlock(vm);
if (event)
virDomainEventStateQueue(driver->domainEventState, event);
lxcDriverUnlock(driver);
if (cgroup)
virCgroupFree(&cgroup);
if (vm)
- virDomainObjUnlock(vm);
+ virObjectUnlock(vm);
return ret;
}
cleanup:
if (vm)
- virDomainObjUnlock(vm);
+ virObjectUnlock(vm);
return ret;
}
cleanup:
if (vm)
- virDomainObjUnlock(vm);
+ virObjectUnlock(vm);
return ret;
}
cleanup:
if (vm)
- virDomainObjUnlock(vm);
+ virObjectUnlock(vm);
return ret;
}
cleanup:
if (vm)
- virDomainObjUnlock(vm);
+ virObjectUnlock(vm);
return ret;
}
cleanup:
if (vm)
- virDomainObjUnlock(vm);
+ virObjectUnlock(vm);
if (cgroup)
virCgroupFree(&cgroup);
return ret;
if (cgroup)
virCgroupFree(&cgroup);
if (vm)
- virDomainObjUnlock(vm);
+ virObjectUnlock(vm);
lxcDriverUnlock(driver);
return ret;
}
if (cgroup)
virCgroupFree(&cgroup);
if (vm)
- virDomainObjUnlock(vm);
+ virObjectUnlock(vm);
lxcDriverUnlock(driver);
return ret;
}
cleanup:
if (vm)
- virDomainObjUnlock(vm);
+ virObjectUnlock(vm);
return ret;
}
cleanup:
if (vm)
- virDomainObjUnlock(vm);
+ virObjectUnlock(vm);
if (event)
virDomainEventStateQueue(driver->domainEventState, event);
lxcDriverUnlock(driver);
cleanup:
virDomainDefFree(def);
if (vm)
- virDomainObjUnlock(vm);
+ virObjectUnlock(vm);
if (event)
virDomainEventStateQueue(driver->domainEventState, event);
lxcDriverUnlock(driver);
cleanup:
if (vm)
- virDomainObjUnlock(vm);
+ virObjectUnlock(vm);
lxcDriverUnlock(driver);
return ret;
}
cleanup:
if (vm)
- virDomainObjUnlock(vm);
+ virObjectUnlock(vm);
if (event)
virDomainEventStateQueue(driver->domainEventState, event);
lxcDriverUnlock(driver);
virDomainDefFree(vmdef);
virCgroupFree(&group);
if (vm)
- virDomainObjUnlock(vm);
+ virObjectUnlock(vm);
lxcDriverUnlock(driver);
return ret;
}
cleanup:
virCgroupFree(&group);
if (vm)
- virDomainObjUnlock(vm);
+ virObjectUnlock(vm);
lxcDriverUnlock(driver);
return ret;
}
cleanup:
virCgroupFree(&group);
if (vm)
- virDomainObjUnlock(vm);
+ virObjectUnlock(vm);
lxcDriverUnlock(driver);
return ret;
}
if (group)
virCgroupFree(&group);
if (vm)
- virDomainObjUnlock(vm);
+ virObjectUnlock(vm);
lxcDriverUnlock(driver);
return ret;
}
cleanup:
if (vm)
- virDomainObjUnlock(vm);
+ virObjectUnlock(vm);
return ret;
}
#else
cleanup:
if (vm)
- virDomainObjUnlock(vm);
+ virObjectUnlock(vm);
return ret;
}
VIR_FREE(configFile);
VIR_FREE(autostartLink);
if (vm)
- virDomainObjUnlock(vm);
+ virObjectUnlock(vm);
lxcDriverUnlock(driver);
return ret;
}
if (event)
virDomainEventStateQueue(driver->domainEventState, event);
if (vm)
- virDomainObjUnlock(vm);
+ virObjectUnlock(vm);
lxcDriverUnlock(driver);
return ret;
}
if (event)
virDomainEventStateQueue(driver->domainEventState, event);
if (vm)
- virDomainObjUnlock(vm);
+ virObjectUnlock(vm);
lxcDriverUnlock(driver);
return ret;
}
ret = 0;
cleanup:
if (vm)
- virDomainObjUnlock(vm);
+ virObjectUnlock(vm);
lxcDriverUnlock(driver);
return ret;
}
cleanup:
if (vm)
- virDomainObjUnlock(vm);
+ virObjectUnlock(vm);
return ret;
}
cleanup:
VIR_FREE(vroot);
if (vm)
- virDomainObjUnlock(vm);
+ virObjectUnlock(vm);
return ret;
}
cleanup:
VIR_FREE(vroot);
if (vm)
- virDomainObjUnlock(vm);
+ virObjectUnlock(vm);
return ret;
}
virDomainDeviceDefFree(dev_copy);
virDomainDeviceDefFree(dev);
if (vm)
- virDomainObjUnlock(vm);
+ virObjectUnlock(vm);
lxcDriverUnlock(driver);
return ret;
}
ret = nfds;
cleanup:
- virDomainObjUnlock(vm);
+ virObjectUnlock(vm);
return ret;
}
#define VIR_FROM_THIS VIR_FROM_LXC
struct _virLXCMonitor {
- virObject parent;
-
- virMutex lock;
+ virObjectLockable parent;
virDomainObjPtr vm;
virLXCMonitorCallbacks cb;
static int virLXCMonitorOnceInit(void)
{
- if (!(virLXCMonitorClass = virClassNew(virClassForObject(),
+ if (!(virLXCMonitorClass = virClassNew(virClassForObjectLockable(),
"virLXCMonitor",
sizeof(virLXCMonitor),
virLXCMonitorDispose)))
virDomainObjPtr vm;
VIR_DEBUG("EOF notify mon=%p", mon);
- virLXCMonitorLock(mon);
+ virObjectLock(mon);
eofNotify = mon->cb.eofNotify;
vm = mon->vm;
- virLXCMonitorUnlock(mon);
+ virObjectUnlock(mon);
if (eofNotify) {
VIR_DEBUG("EOF callback mon=%p vm=%p", mon, vm);
if (virLXCMonitorInitialize() < 0)
return NULL;
- if (!(mon = virObjectNew(virLXCMonitorClass)))
- return NULL;
-
- if (virMutexInit(&mon->lock) < 0) {
- virReportError(VIR_ERR_INTERNAL_ERROR, "%s",
- _("cannot initialize monitor mutex"));
- VIR_FREE(mon);
+ if (!(mon = virObjectLockableNew(virLXCMonitorClass)))
return NULL;
- }
if (virAsprintf(&sockpath, "%s/%s.sock",
socketdir, vm->def->name) < 0)
VIR_DEBUG("mon=%p", mon);
if (mon->cb.destroy)
(mon->cb.destroy)(mon, mon->vm);
- virMutexDestroy(&mon->lock);
virObjectUnref(mon->program);
}
mon->client = NULL;
}
}
-
-
-void virLXCMonitorLock(virLXCMonitorPtr mon)
-{
- virMutexLock(&mon->lock);
-}
-
-
-void virLXCMonitorUnlock(virLXCMonitorPtr mon)
-{
- virMutexUnlock(&mon->lock);
-}
virDomainRemoveInactive(&data->driver->domains, dom);
if (dom)
- virDomainObjUnlock(dom);
+ virObjectUnlock(dom);
if (event)
virDomainEventStateQueue(data->driver->domainEventState, event);
virHashRemoveEntry(data->driver->autodestroy, uuidstr);
VIR_DEBUG("mon=%p vm=%p", mon, vm);
lxcDriverLock(driver);
- virDomainObjLock(vm);
+ virObjectLock(vm);
lxcDriverUnlock(driver);
priv = vm->privateData;
}
if (vm)
- virDomainObjUnlock(vm);
+ virObjectUnlock(vm);
if (event) {
lxcDriverLock(driver);
virDomainEventStateQueue(driver->domainEventState, event);
virDomainObjPtr vm = payload;
const struct virLXCProcessAutostartData *data = opaque;
- virDomainObjLock(vm);
+ virObjectLock(vm);
if (vm->autostart &&
!virDomainObjIsActive(vm)) {
int ret = virLXCProcessStart(data->conn, data->driver, vm, false,
virDomainEventStateQueue(data->driver->domainEventState, event);
}
}
- virDomainObjUnlock(vm);
+ virObjectUnlock(vm);
}
virLXCDriverPtr driver = opaque;
virLXCDomainObjPrivatePtr priv;
- virDomainObjLock(vm);
+ virObjectLock(vm);
VIR_DEBUG("Reconnect id=%d pid=%d state=%d", vm->def->id, vm->pid, vm->state.state);
priv = vm->privateData;
}
cleanup:
- virDomainObjUnlock(vm);
+ virObjectUnlock(vm);
return;
error:
int i, err;
bool skipIface;
- virDomainObjLock(obj);
+ virObjectLock(obj);
if (virDomainObjIsActive(obj)) {
for (i = 0; i < vm->nnets; i++) {
}
}
- virDomainObjUnlock(obj);
+ virObjectUnlock(obj);
}
goto cleanup;
}
- virDomainObjUnlock(dom);
+ virObjectUnlock(dom);
dom = NULL;
}
cleanup:
if (vm)
- virDomainObjUnlock(vm);
+ virObjectUnlock(vm);
return hostname;
error:
cleanup:
if (vm)
- virDomainObjUnlock(vm);
+ virObjectUnlock(vm);
return dom;
}
cleanup:
if (vm)
- virDomainObjUnlock(vm);
+ virObjectUnlock(vm);
return ret;
}
cleanup:
if (vm)
- virDomainObjUnlock(vm);
+ virObjectUnlock(vm);
return dom;
}
cleanup:
if (vm)
- virDomainObjUnlock(vm);
+ virObjectUnlock(vm);
return dom;
}
cleanup:
if (vm)
- virDomainObjUnlock(vm);
+ virObjectUnlock(vm);
return ret;
}
cleanup:
if (vm)
- virDomainObjUnlock(vm);
+ virObjectUnlock(vm);
return ret;
}
cleanup:
if (obj)
- virDomainObjUnlock(obj);
+ virObjectUnlock(obj);
return ret;
}
cleanup:
if (obj)
- virDomainObjUnlock(obj);
+ virObjectUnlock(obj);
return ret;
}
cleanup:
if (vm)
- virDomainObjUnlock(vm);
+ virObjectUnlock(vm);
return ret;
}
cleanup:
if (vm)
- virDomainObjUnlock(vm);
+ virObjectUnlock(vm);
return ret;
}
cleanup:
if (vm)
- virDomainObjUnlock(vm);
+ virObjectUnlock(vm);
return ret;
}
cleanup:
if (vm)
- virDomainObjUnlock(vm);
+ virObjectUnlock(vm);
return ret;
}
cleanup:
if (vm)
- virDomainObjUnlock(vm);
+ virObjectUnlock(vm);
return ret;
}
cleanup:
virDomainDefFree(vmdef);
if (vm)
- virDomainObjUnlock(vm);
+ virObjectUnlock(vm);
openvzDriverUnlock(driver);
return dom;
}
cleanup:
virDomainDefFree(vmdef);
if (vm)
- virDomainObjUnlock(vm);
+ virObjectUnlock(vm);
openvzDriverUnlock(driver);
return dom;
}
cleanup:
if (vm)
- virDomainObjUnlock(vm);
+ virObjectUnlock(vm);
return ret;
}
cleanup:
if (vm)
- virDomainObjUnlock(vm);
+ virObjectUnlock(vm);
openvzDriverUnlock(driver);
return ret;
}
cleanup:
if (vm)
- virDomainObjUnlock(vm);
+ virObjectUnlock(vm);
return ret;
}
VIR_FREE(value);
if (vm)
- virDomainObjUnlock(vm);
+ virObjectUnlock(vm);
return ret;
}
cleanup:
if (vm)
- virDomainObjUnlock(vm);
+ virObjectUnlock(vm);
return ret;
}
cleanup:
if (vm)
- virDomainObjUnlock(vm);
+ virObjectUnlock(vm);
return ret;
}
openvzDriverUnlock(driver);
virDomainDeviceDefFree(dev);
if (vm)
- virDomainObjUnlock(vm);
+ virObjectUnlock(vm);
return ret;
}
else
dom->autostart = 0;
- virDomainObjUnlock(dom);
+ virObjectUnlock(dom);
return dom;
cleanup:
if (dom)
- virDomainObjUnlock(dom);
+ virObjectUnlock(dom);
return ret;
}
cleanup:
if (dom)
- virDomainObjUnlock(dom);
+ virObjectUnlock(dom);
return ret;
}
cleanup:
if (dom)
- virDomainObjUnlock(dom);
+ virObjectUnlock(dom);
return ret;
}
cleanup:
if (privdom)
- virDomainObjUnlock(privdom);
+ virObjectUnlock(privdom);
return ret;
}
cleanup:
if (privdom)
- virDomainObjUnlock(privdom);
+ virObjectUnlock(privdom);
parallelsDriverUnlock(privconn);
return ret;
}
cleanup:
if (privdom)
- virDomainObjUnlock(privdom);
+ virObjectUnlock(privdom);
parallelsDriverUnlock(privconn);
return ret;
}
cleanup:
if (privdom)
- virDomainObjUnlock(privdom);
+ virObjectUnlock(privdom);
return ret;
}
cleanup:
if (privdom)
- virDomainObjUnlock(privdom);
+ virObjectUnlock(privdom);
return ret;
}
cleanup:
if (privdom)
- virDomainObjUnlock(privdom);
+ virObjectUnlock(privdom);
return ret;
}
cleanup:
if (privdom)
- virDomainObjUnlock(privdom);
+ virObjectUnlock(privdom);
return ret;
}
}
if (parallelsApplyChanges(conn, olddom, def) < 0) {
- virDomainObjUnlock(olddom);
+ virObjectUnlock(olddom);
goto cleanup;
}
- virDomainObjUnlock(olddom);
+ virObjectUnlock(olddom);
if (!(dom = virDomainAssignDef(privconn->caps,
&privconn->domains, def, false))) {
cleanup:
virDomainDefFree(def);
if (dom)
- virDomainObjUnlock(dom);
+ virObjectUnlock(dom);
parallelsDriverUnlock(privconn);
return ret;
}
To lock the virDomainObjPtr
- virDomainObjLock()
+ virObjectLock()
- Acquires the virDomainObjPtr lock
- virDomainObjUnlock()
+ virObjectUnlock()
- Releases the virDomainObjPtr lock
...monitor job progress...
qemuDomainObjExitMonitorWithDriver(driver, obj);
- virDomainObjUnlock(obj);
+ virObjectUnlock(obj);
sleep(aWhile);
- virDomainObjLock(obj);
+ virObjectLock(obj);
}
...do final work...
struct _qemuAgent {
- virObject object;
+ virObjectLockable parent;
- virMutex lock; /* also used to protect fd */
virCond notify;
int fd;
static int qemuAgentOnceInit(void)
{
- if (!(qemuAgentClass = virClassNew(virClassForObject(),
+ if (!(qemuAgentClass = virClassNew(virClassForObjectLockable(),
"qemuAgent",
sizeof(qemuAgent),
qemuAgentDispose)))
}
#endif
-void qemuAgentLock(qemuAgentPtr mon)
-{
- virMutexLock(&mon->lock);
-}
-
-
-void qemuAgentUnlock(qemuAgentPtr mon)
-{
- virMutexUnlock(&mon->lock);
-}
-
static void qemuAgentDispose(void *obj)
{
if (mon->cb && mon->cb->destroy)
(mon->cb->destroy)(mon, mon->vm);
ignore_value(virCondDestroy(&mon->notify));
- virMutexDestroy(&mon->lock);
VIR_FREE(mon->buffer);
}
virObjectRef(mon);
/* lock access to the monitor and protect fd */
- qemuAgentLock(mon);
+ virObjectLock(mon);
#if DEBUG_IO
VIR_DEBUG("Agent %p I/O on watch %d fd %d events %d", mon, watch, fd, events);
#endif
/* Make sure anyone waiting wakes up now */
virCondSignal(&mon->notify);
- qemuAgentUnlock(mon);
+ virObjectUnlock(mon);
virObjectUnref(mon);
VIR_DEBUG("Triggering EOF callback");
(eofNotify)(mon, vm);
/* Make sure anyone waiting wakes up now */
virCondSignal(&mon->notify);
- qemuAgentUnlock(mon);
+ virObjectUnlock(mon);
virObjectUnref(mon);
VIR_DEBUG("Triggering error callback");
(errorNotify)(mon, vm);
} else {
- qemuAgentUnlock(mon);
+ virObjectUnlock(mon);
virObjectUnref(mon);
}
}
if (qemuAgentInitialize() < 0)
return NULL;
- if (!(mon = virObjectNew(qemuAgentClass)))
+ if (!(mon = virObjectLockableNew(qemuAgentClass)))
return NULL;
- if (virMutexInit(&mon->lock) < 0) {
- virReportSystemError(errno, "%s",
- _("cannot initialize monitor mutex"));
- VIR_FREE(mon);
- return NULL;
- }
+ mon->fd = -1;
if (virCondInit(&mon->notify) < 0) {
virReportSystemError(errno, "%s",
_("cannot initialize monitor condition"));
- virMutexDestroy(&mon->lock);
- VIR_FREE(mon);
+ virObjectUnref(mon);
return NULL;
}
- mon->fd = -1;
mon->vm = vm;
mon->cb = cb;
- qemuAgentLock(mon);
switch (config->type) {
case VIR_DOMAIN_CHR_TYPE_UNIX:
if (mon->fd == -1)
goto cleanup;
+ virObjectRef(mon);
if ((mon->watch = virEventAddHandle(mon->fd,
VIR_EVENT_HANDLE_HANGUP |
VIR_EVENT_HANDLE_ERROR |
qemuAgentIO,
mon,
virObjectFreeCallback)) < 0) {
+ virObjectUnref(mon);
virReportError(VIR_ERR_INTERNAL_ERROR, "%s",
_("unable to register monitor events"));
goto cleanup;
}
- virObjectRef(mon);
VIR_DEBUG("New mon %p fd =%d watch=%d", mon, mon->fd, mon->watch);
- qemuAgentUnlock(mon);
return mon;
* so kill the callbacks now.
*/
mon->cb = NULL;
- qemuAgentUnlock(mon);
qemuAgentClose(mon);
return NULL;
}
VIR_DEBUG("mon=%p", mon);
- qemuAgentLock(mon);
+ virObjectLock(mon);
if (mon->fd >= 0) {
if (mon->watch)
mon->msg->finished = 1;
virCondSignal(&mon->notify);
}
- qemuAgentUnlock(mon);
+ virObjectUnlock(mon);
virObjectUnref(mon);
}
qemuAgentUpdateWatch(mon);
while (!mon->msg->finished) {
- if ((then && virCondWaitUntil(&mon->notify, &mon->lock, then) < 0) ||
- (!then && virCondWait(&mon->notify, &mon->lock) < 0)) {
+ if ((then && virCondWaitUntil(&mon->notify, &mon->parent.lock, then) < 0) ||
+ (!then && virCondWait(&mon->notify, &mon->parent.lock) < 0)) {
if (errno == ETIMEDOUT) {
virReportError(VIR_ERR_AGENT_UNRESPONSIVE, "%s",
_("Guest agent not available for now"));
virDomainChrSourceDefPtr config,
qemuAgentCallbacksPtr cb);
-void qemuAgentLock(qemuAgentPtr mon);
-void qemuAgentUnlock(qemuAgentPtr mon);
-
void qemuAgentClose(qemuAgentPtr mon);
typedef enum {
goto cleanup;
}
- qemuMonitorLock(mon);
+ virObjectLock(mon);
if (qemuMonitorSetCapabilities(mon) < 0) {
virErrorPtr err = virGetLastError();
cleanup:
if (mon)
- qemuMonitorUnlock(mon);
+ virObjectUnlock(mon);
qemuMonitorClose(mon);
virCommandAbort(cmd);
virCommandFree(cmd);
dom = closeDef->cb(data->driver, dom, data->conn);
if (dom)
- virDomainObjUnlock(dom);
+ virObjectUnlock(dom);
virHashRemoveEntry(data->driver->closeCallbacks, uuidstr);
}
}
while (!nested && !qemuDomainNestedJobAllowed(priv, job)) {
- if (virCondWaitUntil(&priv->job.asyncCond, &obj->lock, then) < 0)
+ if (virCondWaitUntil(&priv->job.asyncCond, &obj->parent.lock, then) < 0)
goto error;
}
while (priv->job.active) {
- if (virCondWaitUntil(&priv->job.cond, &obj->lock, then) < 0)
+ if (virCondWaitUntil(&priv->job.cond, &obj->parent.lock, then) < 0)
goto error;
}
}
if (driver_locked) {
- virDomainObjUnlock(obj);
+ virObjectUnlock(obj);
qemuDriverLock(driver);
- virDomainObjLock(obj);
+ virObjectLock(obj);
}
if (qemuDomainTrackJob(job))
"%s", _("cannot acquire job mutex"));
priv->jobs_queued--;
if (driver_locked) {
- virDomainObjUnlock(obj);
+ virObjectUnlock(obj);
qemuDriverLock(driver);
- virDomainObjLock(obj);
+ virObjectLock(obj);
}
virObjectUnref(obj);
return -1;
" monitor without asking for a nested job is dangerous");
}
- qemuMonitorLock(priv->mon);
+ virObjectLock(priv->mon);
virObjectRef(priv->mon);
ignore_value(virTimeMillisNow(&priv->monStart));
- virDomainObjUnlock(obj);
+ virObjectUnlock(obj);
if (driver_locked)
qemuDriverUnlock(driver);
hasRefs = virObjectUnref(priv->mon);
if (hasRefs)
- qemuMonitorUnlock(priv->mon);
+ virObjectUnlock(priv->mon);
if (driver_locked)
qemuDriverLock(driver);
- virDomainObjLock(obj);
+ virObjectLock(obj);
priv->monStart = 0;
if (!hasRefs)
{
qemuDomainObjPrivatePtr priv = obj->privateData;
- qemuAgentLock(priv->agent);
+ virObjectLock(priv->agent);
virObjectRef(priv->agent);
ignore_value(virTimeMillisNow(&priv->agentStart));
- virDomainObjUnlock(obj);
+ virObjectUnlock(obj);
if (driver_locked)
qemuDriverUnlock(driver);
hasRefs = virObjectUnref(priv->agent);
if (hasRefs)
- qemuAgentUnlock(priv->agent);
+ virObjectUnlock(priv->agent);
if (driver_locked)
qemuDriverLock(driver);
- virDomainObjLock(obj);
+ virObjectLock(obj);
priv->agentStart = 0;
if (!hasRefs)
virDomainObjPtr obj)
{
virObjectRef(obj);
- virDomainObjUnlock(obj);
+ virObjectUnlock(obj);
qemuDriverUnlock(driver);
}
virDomainObjPtr obj)
{
qemuDriverLock(driver);
- virDomainObjLock(obj);
+ virObjectLock(obj);
virObjectUnref(obj);
}
if (data->driver->autoStartBypassCache)
flags |= VIR_DOMAIN_START_BYPASS_CACHE;
- virDomainObjLock(vm);
+ virObjectLock(vm);
virResetLastError();
if (vm->autostart &&
!virDomainObjIsActive(vm)) {
cleanup:
if (vm)
- virDomainObjUnlock(vm);
+ virObjectUnlock(vm);
}
VIR_DOMAIN_SNAPSHOT_PARSE_DISKS |
VIR_DOMAIN_SNAPSHOT_PARSE_INTERNAL);
- virDomainObjLock(vm);
+ virObjectLock(vm);
if (virAsprintf(&snapDir, "%s/%s", baseDir, vm->def->name) < 0) {
VIR_ERROR(_("Failed to allocate memory for snapshot directory for domain %s"),
vm->def->name);
if (dir)
closedir(dir);
VIR_FREE(snapDir);
- virDomainObjUnlock(vm);
+ virObjectUnlock(vm);
}
virDomainObjPtr vm = (virDomainObjPtr)payload;
virDomainDefPtr def = vm->def;
- virDomainObjLock(vm);
+ virObjectLock(vm);
for (i = 0; i < def->nnets; i++) {
virDomainNetDefPtr net = def->nets[i];
}
}
- virDomainObjUnlock(vm);
+ virObjectUnlock(vm);
}
cleanup:
if (vm)
- virDomainObjUnlock(vm);
+ virObjectUnlock(vm);
return dom;
}
cleanup:
if (vm)
- virDomainObjUnlock(vm);
+ virObjectUnlock(vm);
return dom;
}
cleanup:
if (vm)
- virDomainObjUnlock(vm);
+ virObjectUnlock(vm);
return dom;
}
cleanup:
if (obj)
- virDomainObjUnlock(obj);
+ virObjectUnlock(obj);
return ret;
}
cleanup:
if (obj)
- virDomainObjUnlock(obj);
+ virObjectUnlock(obj);
return ret;
}
cleanup:
if (obj)
- virDomainObjUnlock(obj);
+ virObjectUnlock(obj);
return ret;
}
cleanup:
virDomainDefFree(def);
if (vm)
- virDomainObjUnlock(vm);
+ virObjectUnlock(vm);
if (event) {
qemuDomainEventQueue(driver, event);
if (event2)
cleanup:
if (vm)
- virDomainObjUnlock(vm);
+ virObjectUnlock(vm);
if (event)
qemuDomainEventQueue(driver, event);
cleanup:
if (vm)
- virDomainObjUnlock(vm);
+ virObjectUnlock(vm);
if (event)
qemuDomainEventQueue(driver, event);
qemuDriverUnlock(driver);
cleanup:
if (vm)
- virDomainObjUnlock(vm);
+ virObjectUnlock(vm);
return ret;
}
cleanup:
if (vm)
- virDomainObjUnlock(vm);
+ virObjectUnlock(vm);
return ret;
}
cleanup:
if (vm)
- virDomainObjUnlock(vm);
+ virObjectUnlock(vm);
return ret;
}
cleanup:
if (vm)
- virDomainObjUnlock(vm);
+ virObjectUnlock(vm);
if (event)
qemuDomainEventQueue(driver, event);
qemuDriverUnlock(driver);
cleanup:
if (vm)
- virDomainObjUnlock(vm);
+ virObjectUnlock(vm);
return type;
}
cleanup:
if (vm)
- virDomainObjUnlock(vm);
+ virObjectUnlock(vm);
return ret;
}
cleanup:
if (vm)
- virDomainObjUnlock(vm);
+ virObjectUnlock(vm);
return ret;
}
cleanup:
if (vm)
- virDomainObjUnlock(vm);
+ virObjectUnlock(vm);
qemuDriverUnlock(driver);
return ret;
}
cleanup:
if (vm)
- virDomainObjUnlock(vm);
+ virObjectUnlock(vm);
return ret;
}
cleanup:
if (vm)
- virDomainObjUnlock(vm);
+ virObjectUnlock(vm);
return ret;
}
cleanup:
if (vm)
- virDomainObjUnlock(vm);
+ virObjectUnlock(vm);
return ret;
}
cleanup:
if (vm)
- virDomainObjUnlock(vm);
+ virObjectUnlock(vm);
return ret;
}
if (event)
qemuDomainEventQueue(driver, event);
if (vm)
- virDomainObjUnlock(vm);
+ virObjectUnlock(vm);
return ret;
}
cleanup:
if (vm)
- virDomainObjUnlock(vm);
+ virObjectUnlock(vm);
qemuDriverUnlock(driver);
return ret;
cleanup:
if (vm)
- virDomainObjUnlock(vm);
+ virObjectUnlock(vm);
qemuDriverUnlock(driver);
VIR_FREE(name);
virQEMUDriverPtr driver = opaque;
char *name;
- virDomainObjLock(vm);
+ virObjectLock(vm);
if (!(name = qemuDomainManagedSavePath(driver, vm)))
goto cleanup;
vm->hasManagedSave = virFileExists(name);
cleanup:
- virDomainObjUnlock(vm);
+ virObjectUnlock(vm);
VIR_FREE(name);
}
return -1;
ret = vm->hasManagedSave;
- virDomainObjUnlock(vm);
+ virObjectUnlock(vm);
return ret;
}
cleanup:
VIR_FREE(name);
- virDomainObjUnlock(vm);
+ virObjectUnlock(vm);
qemuDriverUnlock(driver);
return ret;
}
cleanup:
if (vm)
- virDomainObjUnlock(vm);
+ virObjectUnlock(vm);
if (event)
qemuDomainEventQueue(driver, event);
qemuDriverUnlock(driver);
cleanup:
if (vm)
- virDomainObjUnlock(vm);
+ virObjectUnlock(vm);
return ret;
}
virQEMUDriverPtr driver = opaque;
qemuDriverLock(driver);
- virDomainObjLock(wdEvent->vm);
+ virObjectLock(wdEvent->vm);
switch (wdEvent->action) {
case VIR_DOMAIN_WATCHDOG_ACTION_DUMP:
ignore_value(qemuDomainObjEndAsyncJob(driver, wdEvent->vm));
unlock:
- virDomainObjUnlock(wdEvent->vm);
+ virObjectUnlock(wdEvent->vm);
virObjectUnref(wdEvent->vm);
qemuDriverUnlock(driver);
VIR_FREE(wdEvent);
cleanup:
if (vm)
- virDomainObjUnlock(vm);
+ virObjectUnlock(vm);
return ret;
}
if (cgroup_dom)
virCgroupFree(&cgroup_dom);
if (vm)
- virDomainObjUnlock(vm);
+ virObjectUnlock(vm);
virBitmapFree(pcpumap);
return ret;
}
cleanup:
if (vm)
- virDomainObjUnlock(vm);
+ virObjectUnlock(vm);
return ret;
}
virBitmapFree(pcpumap);
if (vm)
- virDomainObjUnlock(vm);
+ virObjectUnlock(vm);
return ret;
}
cleanup:
if (vm)
- virDomainObjUnlock(vm);
+ virObjectUnlock(vm);
return ret;
}
cleanup:
if (vm)
- virDomainObjUnlock(vm);
+ virObjectUnlock(vm);
return ret;
}
cleanup:
if (vm)
- virDomainObjUnlock(vm);
+ virObjectUnlock(vm);
return ret;
}
cleanup:
if (vm)
- virDomainObjUnlock(vm);
+ virObjectUnlock(vm);
qemuDriverUnlock(driver);
return ret;
}
cleanup:
if (vm)
- virDomainObjUnlock(vm);
+ virObjectUnlock(vm);
qemuDriverUnlock(driver);
return ret;
}
VIR_FORCE_CLOSE(fd);
virFileWrapperFdFree(wrapperFd);
if (vm)
- virDomainObjUnlock(vm);
+ virObjectUnlock(vm);
qemuDriverUnlock(driver);
return ret;
}
cleanup:
if (vm)
- virDomainObjUnlock(vm);
+ virObjectUnlock(vm);
qemuDriverUnlock(driver);
return ret;
}
cleanup:
if (vm)
- virDomainObjUnlock(vm);
+ virObjectUnlock(vm);
qemuDriverUnlock(driver);
return ret;
}
cleanup:
virDomainDefFree(def);
if (vm)
- virDomainObjUnlock(vm);
+ virObjectUnlock(vm);
if (event)
qemuDomainEventQueue(driver, event);
virObjectUnref(caps);
cleanup:
VIR_FREE(name);
if (vm)
- virDomainObjUnlock(vm);
+ virObjectUnlock(vm);
if (event)
qemuDomainEventQueue(driver, event);
qemuDriverUnlock(driver);
virDomainDeviceDefFree(dev_copy);
virDomainDeviceDefFree(dev);
if (vm)
- virDomainObjUnlock(vm);
+ virObjectUnlock(vm);
qemuDriverUnlock(driver);
return ret;
}
cleanup:
if (vm)
- virDomainObjUnlock(vm);
+ virObjectUnlock(vm);
return ret;
}
VIR_FREE(configFile);
VIR_FREE(autostartLink);
if (vm)
- virDomainObjUnlock(vm);
+ virObjectUnlock(vm);
qemuDriverUnlock(driver);
return ret;
}
cleanup:
virCgroupFree(&group);
if (vm)
- virDomainObjUnlock(vm);
+ virObjectUnlock(vm);
qemuDriverUnlock(driver);
return ret;
}
if (group)
virCgroupFree(&group);
if (vm)
- virDomainObjUnlock(vm);
+ virObjectUnlock(vm);
qemuDriverUnlock(driver);
return ret;
}
cleanup:
virCgroupFree(&group);
if (vm)
- virDomainObjUnlock(vm);
+ virObjectUnlock(vm);
qemuDriverUnlock(driver);
return ret;
}
if (group)
virCgroupFree(&group);
if (vm)
- virDomainObjUnlock(vm);
+ virObjectUnlock(vm);
qemuDriverUnlock(driver);
return ret;
}
cleanup:
virCgroupFree(&group);
if (vm)
- virDomainObjUnlock(vm);
+ virObjectUnlock(vm);
qemuDriverUnlock(driver);
return ret;
}
VIR_FREE(nodeset);
virCgroupFree(&group);
if (vm)
- virDomainObjUnlock(vm);
+ virObjectUnlock(vm);
qemuDriverUnlock(driver);
return ret;
}
virDomainDefFree(vmdef);
virCgroupFree(&group);
if (vm)
- virDomainObjUnlock(vm);
+ virObjectUnlock(vm);
qemuDriverUnlock(driver);
return ret;
}
cleanup:
virCgroupFree(&group);
if (vm)
- virDomainObjUnlock(vm);
+ virObjectUnlock(vm);
qemuDriverUnlock(driver);
return ret;
}
cleanup:
VIR_FREE(device);
if (vm)
- virDomainObjUnlock(vm);
+ virObjectUnlock(vm);
return ret;
}
cleanup:
if (vm)
- virDomainObjUnlock(vm);
+ virObjectUnlock(vm);
return ret;
}
cleanup:
if (vm)
- virDomainObjUnlock(vm);
+ virObjectUnlock(vm);
return ret;
}
cleanup:
if (vm)
- virDomainObjUnlock(vm);
+ virObjectUnlock(vm);
return ret;
}
#else
virNetDevBandwidthFree(newBandwidth);
virCgroupFree(&group);
if (vm)
- virDomainObjUnlock(vm);
+ virObjectUnlock(vm);
qemuDriverUnlock(driver);
return ret;
}
if (group)
virCgroupFree(&group);
if (vm)
- virDomainObjUnlock(vm);
+ virObjectUnlock(vm);
qemuDriverUnlock(driver);
return ret;
}
cleanup:
if (vm)
- virDomainObjUnlock(vm);
+ virObjectUnlock(vm);
return ret;
}
cleanup:
VIR_FORCE_CLOSE(fd);
if (vm)
- virDomainObjUnlock(vm);
+ virObjectUnlock(vm);
return ret;
}
unlink(tmp);
VIR_FREE(tmp);
if (vm)
- virDomainObjUnlock(vm);
+ virObjectUnlock(vm);
return ret;
}
virStorageFileFreeMetadata(meta);
VIR_FORCE_CLOSE(fd);
if (vm)
- virDomainObjUnlock(vm);
+ virObjectUnlock(vm);
return ret;
}
cleanup:
if (vm)
- virDomainObjUnlock(vm);
+ virObjectUnlock(vm);
qemuDriverUnlock(driver);
return xml;
cleanup:
if (vm)
- virDomainObjUnlock(vm);
+ virObjectUnlock(vm);
qemuDriverUnlock(driver);
return ret;
}
cleanup:
if (vm)
- virDomainObjUnlock(vm);
+ virObjectUnlock(vm);
return ret;
}
cleanup:
if (vm)
- virDomainObjUnlock(vm);
+ virObjectUnlock(vm);
return ret;
}
cleanup:
if (vm)
- virDomainObjUnlock(vm);
+ virObjectUnlock(vm);
return ret;
}
cleanup:
if (vm)
- virDomainObjUnlock(vm);
+ virObjectUnlock(vm);
return ret;
}
cleanup:
if (vm)
- virDomainObjUnlock(vm);
+ virObjectUnlock(vm);
return ret;
}
} else if (snap) {
virDomainSnapshotObjListRemove(vm->snapshots, snap);
}
- virDomainObjUnlock(vm);
+ virObjectUnlock(vm);
}
virDomainSnapshotDefFree(def);
VIR_FREE(xml);
cleanup:
if (vm)
- virDomainObjUnlock(vm);
+ virObjectUnlock(vm);
return n;
}
cleanup:
if (vm)
- virDomainObjUnlock(vm);
+ virObjectUnlock(vm);
return n;
}
cleanup:
if (vm)
- virDomainObjUnlock(vm);
+ virObjectUnlock(vm);
return n;
}
cleanup:
if (vm)
- virDomainObjUnlock(vm);
+ virObjectUnlock(vm);
return n;
}
cleanup:
if (vm)
- virDomainObjUnlock(vm);
+ virObjectUnlock(vm);
return n;
}
cleanup:
if (vm)
- virDomainObjUnlock(vm);
+ virObjectUnlock(vm);
return n;
}
cleanup:
if (vm)
- virDomainObjUnlock(vm);
+ virObjectUnlock(vm);
return snapshot;
}
cleanup:
if (vm)
- virDomainObjUnlock(vm);
+ virObjectUnlock(vm);
return ret;
}
cleanup:
if (vm)
- virDomainObjUnlock(vm);
+ virObjectUnlock(vm);
return parent;
}
cleanup:
if (vm)
- virDomainObjUnlock(vm);
+ virObjectUnlock(vm);
return snapshot;
}
cleanup:
if (vm)
- virDomainObjUnlock(vm);
+ virObjectUnlock(vm);
return xml;
}
cleanup:
if (vm)
- virDomainObjUnlock(vm);
+ virObjectUnlock(vm);
return ret;
}
cleanup:
if (vm)
- virDomainObjUnlock(vm);
+ virObjectUnlock(vm);
return ret;
}
qemuDomainEventQueue(driver, event2);
}
if (vm)
- virDomainObjUnlock(vm);
+ virObjectUnlock(vm);
qemuDriverUnlock(driver);
return ret;
cleanup:
if (vm)
- virDomainObjUnlock(vm);
+ virObjectUnlock(vm);
qemuDriverUnlock(driver);
return ret;
}
cleanup:
if (vm)
- virDomainObjUnlock(vm);
+ virObjectUnlock(vm);
return ret;
}
virObjectUnref(caps);
virDomainChrSourceDefFree(monConfig);
if (vm)
- virDomainObjUnlock(vm);
+ virObjectUnlock(vm);
qemuDriverUnlock(driver);
VIR_FREE(pidfile);
return dom;
cleanup:
if (vm)
- virDomainObjUnlock(vm);
+ virObjectUnlock(vm);
return ret;
}
cleanup:
if (vm)
- virDomainObjUnlock(vm);
+ virObjectUnlock(vm);
return ret;
}
if (ret <= 0)
break;
- virDomainObjUnlock(vm);
+ virObjectUnlock(vm);
qemuDriverUnlock(driver);
nanosleep(&ts, NULL);
qemuDriverLock(driver);
- virDomainObjLock(vm);
+ virObjectLock(vm);
if (!virDomainObjIsActive(vm)) {
virReportError(VIR_ERR_OPERATION_INVALID, "%s",
cleanup:
VIR_FREE(device);
if (vm)
- virDomainObjUnlock(vm);
+ virObjectUnlock(vm);
if (event)
qemuDomainEventQueue(driver, event);
qemuDriverUnlock(driver);
virCgroupFree(&cgroup);
VIR_FREE(device);
if (vm)
- virDomainObjUnlock(vm);
+ virObjectUnlock(vm);
return ret;
}
cleanup:
VIR_FREE(device);
if (vm)
- virDomainObjUnlock(vm);
+ virObjectUnlock(vm);
return ret;
}
cleanup:
if (vm)
- virDomainObjUnlock(vm);
+ virObjectUnlock(vm);
qemuDriverUnlock(driver);
return ret;
}
cleanup:
VIR_FREE(device);
if (vm)
- virDomainObjUnlock(vm);
+ virObjectUnlock(vm);
qemuDriverUnlock(driver);
return ret;
}
cleanup:
VIR_FREE(device);
if (vm)
- virDomainObjUnlock(vm);
+ virObjectUnlock(vm);
qemuDriverUnlock(driver);
return ret;
}
cleanup:
if (vm)
- virDomainObjUnlock(vm);
+ virObjectUnlock(vm);
virHashFree(table);
if (ret < 0) {
for (i = 0; i < n; i++)
cleanup:
if (vm)
- virDomainObjUnlock(vm);
+ virObjectUnlock(vm);
return ret;
no_memory:
virReportOOMError();
cleanup:
if (vm)
- virDomainObjUnlock(vm);
+ virObjectUnlock(vm);
return ret;
}
cleanup:
virCgroupFree(&group);
if (vm)
- virDomainObjUnlock(vm);
+ virObjectUnlock(vm);
qemuDriverUnlock(driver);
return ret;
}
cleanup:
if (vm)
- virDomainObjUnlock(vm);
+ virObjectUnlock(vm);
return ret;
}
cleanup:
if (vm)
- virDomainObjUnlock(vm);
+ virObjectUnlock(vm);
return ret;
}
cleanup:
if (vm)
- virDomainObjUnlock(vm);
+ virObjectUnlock(vm);
return result;
}
cleanup:
if (vm)
- virDomainObjUnlock(vm);
+ virObjectUnlock(vm);
return ret;
}
goto cleanup;
}
- virDomainObjUnlock(vm);
+ virObjectUnlock(vm);
qemuDriverUnlock(driver);
nanosleep(&ts, NULL);
qemuDriverLock(driver);
- virDomainObjLock(vm);
+ virObjectLock(vm);
}
cleanup:
VIR_FORCE_CLOSE(dataFD[1]);
if (vm) {
if (ret >= 0 || vm->persistent)
- virDomainObjUnlock(vm);
+ virObjectUnlock(vm);
else
qemuDomainRemoveInactive(driver, vm);
}
cleanup:
if (vm)
- virDomainObjUnlock(vm);
+ virObjectUnlock(vm);
if (event)
qemuDomainEventQueue(driver, event);
return ret;
cleanup:
if (vm)
- virDomainObjUnlock(vm);
+ virObjectUnlock(vm);
if (event)
qemuDomainEventQueue(driver, event);
return ret;
cleanup:
if (vm) {
VIR_FREE(priv->origname);
- virDomainObjUnlock(vm);
+ virObjectUnlock(vm);
}
if (event)
qemuDomainEventQueue(driver, event);
#define DEBUG_RAW_IO 0
struct _qemuMonitor {
- virObject object;
+ virObjectLockable parent;
- virMutex lock; /* also used to protect fd */
virCond notify;
int fd;
static int qemuMonitorOnceInit(void)
{
- if (!(qemuMonitorClass = virClassNew(virClassForObject(),
+ if (!(qemuMonitorClass = virClassNew(virClassForObjectLockable(),
"qemuMonitor",
sizeof(qemuMonitor),
qemuMonitorDispose)))
}
#endif
-void qemuMonitorLock(qemuMonitorPtr mon)
-{
- virMutexLock(&mon->lock);
-}
-
-void qemuMonitorUnlock(qemuMonitorPtr mon)
-{
- virMutexUnlock(&mon->lock);
-}
-
-
static void qemuMonitorDispose(void *obj)
{
qemuMonitorPtr mon = obj;
(mon->cb->destroy)(mon, mon->vm);
if (virCondDestroy(&mon->notify) < 0)
{}
- virMutexDestroy(&mon->lock);
VIR_FREE(mon->buffer);
}
virObjectRef(mon);
/* lock access to the monitor and protect fd */
- qemuMonitorLock(mon);
+ virObjectLock(mon);
#if DEBUG_IO
VIR_DEBUG("Monitor %p I/O on watch %d fd %d events %d", mon, watch, fd, events);
#endif
if (mon->fd == -1 || mon->watch == 0) {
- qemuMonitorUnlock(mon);
+ virObjectUnlock(mon);
virObjectUnref(mon);
return;
}
/* Make sure anyone waiting wakes up now */
virCondSignal(&mon->notify);
- qemuMonitorUnlock(mon);
+ virObjectUnlock(mon);
virObjectUnref(mon);
VIR_DEBUG("Triggering EOF callback");
(eofNotify)(mon, vm);
/* Make sure anyone waiting wakes up now */
virCondSignal(&mon->notify);
- qemuMonitorUnlock(mon);
+ virObjectUnlock(mon);
virObjectUnref(mon);
VIR_DEBUG("Triggering error callback");
(errorNotify)(mon, vm);
} else {
- qemuMonitorUnlock(mon);
+ virObjectUnlock(mon);
virObjectUnref(mon);
}
}
if (qemuMonitorInitialize() < 0)
return NULL;
- if (!(mon = virObjectNew(qemuMonitorClass)))
+ if (!(mon = virObjectLockableNew(qemuMonitorClass)))
return NULL;
- if (virMutexInit(&mon->lock) < 0) {
- virReportError(VIR_ERR_INTERNAL_ERROR, "%s",
- _("cannot initialize monitor mutex"));
- VIR_FREE(mon);
- return NULL;
- }
+ mon->fd = -1;
if (virCondInit(&mon->notify) < 0) {
virReportError(VIR_ERR_INTERNAL_ERROR, "%s",
_("cannot initialize monitor condition"));
- virMutexDestroy(&mon->lock);
- VIR_FREE(mon);
- return NULL;
+ goto cleanup;
}
mon->fd = fd;
mon->hasSendFD = hasSendFD;
if (json)
mon->wait_greeting = 1;
mon->cb = cb;
- qemuMonitorLock(mon);
+ virObjectLock(mon);
if (virSetCloseExec(mon->fd) < 0) {
virReportError(VIR_ERR_INTERNAL_ERROR,
}
+ virObjectRef(mon);
if ((mon->watch = virEventAddHandle(mon->fd,
VIR_EVENT_HANDLE_HANGUP |
VIR_EVENT_HANDLE_ERROR |
qemuMonitorIO,
mon,
virObjectFreeCallback)) < 0) {
+ virObjectUnref(mon);
virReportError(VIR_ERR_INTERNAL_ERROR, "%s",
_("unable to register monitor events"));
goto cleanup;
}
- virObjectRef(mon);
PROBE(QEMU_MONITOR_NEW,
"mon=%p refs=%d fd=%d",
- mon, mon->object.refs, mon->fd);
- qemuMonitorUnlock(mon);
+ mon, mon->parent.parent.refs, mon->fd);
+ virObjectUnlock(mon);
return mon;
* so kill the callbacks now.
*/
mon->cb = NULL;
- qemuMonitorUnlock(mon);
+ virObjectUnlock(mon);
/* The caller owns 'fd' on failure */
mon->fd = -1;
if (mon->watch)
if (!mon)
return;
- qemuMonitorLock(mon);
+ virObjectLock(mon);
PROBE(QEMU_MONITOR_CLOSE,
- "mon=%p refs=%d", mon, mon->object.refs);
+ "mon=%p refs=%d", mon, mon->parent.parent.refs);
if (mon->fd >= 0) {
if (mon->watch) {
virCondSignal(&mon->notify);
}
- qemuMonitorUnlock(mon);
+ virObjectUnlock(mon);
virObjectUnref(mon);
}
mon, mon->msg->txBuffer, mon->msg->txFD);
while (!mon->msg->finished) {
- if (virCondWait(&mon->notify, &mon->lock) < 0) {
+ if (virCondWait(&mon->notify, &mon->parent.lock) < 0) {
virReportError(VIR_ERR_INTERNAL_ERROR, "%s",
_("Unable to wait on monitor condition"));
goto cleanup;
#define QEMU_MONITOR_CALLBACK(mon, ret, callback, ...) \
do { \
virObjectRef(mon); \
- qemuMonitorUnlock(mon); \
+ virObjectUnlock(mon); \
if ((mon)->cb && (mon)->cb->callback) \
(ret) = ((mon)->cb->callback)(mon, __VA_ARGS__); \
- qemuMonitorLock(mon); \
+ virObjectLock(mon); \
virObjectUnref(mon); \
} while (0)
int qemuMonitorSetCapabilities(qemuMonitorPtr mon);
-void qemuMonitorLock(qemuMonitorPtr mon);
-void qemuMonitorUnlock(qemuMonitorPtr mon);
-
int qemuMonitorSetLink(qemuMonitorPtr mon,
const char *name,
enum virDomainNetInterfaceLinkState state) ;
VIR_DEBUG("Received EOF from agent on %p '%s'", vm, vm->def->name);
qemuDriverLock(driver);
- virDomainObjLock(vm);
+ virObjectLock(vm);
priv = vm->privateData;
if (priv->agent == agent &&
!virObjectUnref(priv->agent))
priv->agent = NULL;
- virDomainObjUnlock(vm);
+ virObjectUnlock(vm);
qemuDriverUnlock(driver);
qemuAgentClose(agent);
VIR_DEBUG("Received error from agent on %p '%s'", vm, vm->def->name);
qemuDriverLock(driver);
- virDomainObjLock(vm);
+ virObjectLock(vm);
priv = vm->privateData;
priv->agentError = true;
- virDomainObjUnlock(vm);
+ virObjectUnlock(vm);
qemuDriverUnlock(driver);
}
virObjectRef(vm);
ignore_value(virTimeMillisNow(&priv->agentStart));
- virDomainObjUnlock(vm);
+ virObjectUnlock(vm);
qemuDriverUnlock(driver);
agent = qemuAgentOpen(vm,
&agentCallbacks);
qemuDriverLock(driver);
- virDomainObjLock(vm);
+ virObjectLock(vm);
priv->agentStart = 0;
if (virSecurityManagerClearSocketLabel(driver->securityManager,
VIR_DEBUG("Received EOF on %p '%s'", vm, vm->def->name);
qemuDriverLock(driver);
- virDomainObjLock(vm);
+ virObjectLock(vm);
priv = vm->privateData;
}
unlock:
- virDomainObjUnlock(vm);
+ virObjectUnlock(vm);
cleanup:
if (event)
VIR_DEBUG("Received error on %p '%s'", vm, vm->def->name);
qemuDriverLock(driver);
- virDomainObjLock(vm);
+ virObjectLock(vm);
((qemuDomainObjPrivatePtr) vm->privateData)->monError = true;
event = virDomainEventControlErrorNewFromObj(vm);
if (event)
qemuDomainEventQueue(driver, event);
- virDomainObjUnlock(vm);
+ virObjectUnlock(vm);
qemuDriverUnlock(driver);
}
virDomainDiskDefPtr disk;
int ret = -1;
- virDomainObjLock(vm);
+ virObjectLock(vm);
disk = qemuProcessFindDomainDiskByPath(vm, path);
if (!disk)
ret = qemuProcessGetVolumeQcowPassphrase(conn, disk, secretRet, secretLen);
cleanup:
- virDomainObjUnlock(vm);
+ virObjectUnlock(vm);
return ret;
}
virDomainEventPtr event;
qemuDomainObjPrivatePtr priv;
- virDomainObjLock(vm);
+ virObjectLock(vm);
event = virDomainEventRebootNewFromObj(vm);
priv = vm->privateData;
if (priv->agent)
qemuAgentNotifyEvent(priv->agent, QEMU_AGENT_EVENT_RESET);
- virDomainObjUnlock(vm);
+ virObjectUnlock(vm);
if (event) {
qemuDriverLock(driver);
int ret = -1;
VIR_DEBUG("vm=%p", vm);
qemuDriverLock(driver);
- virDomainObjLock(vm);
+ virObjectLock(vm);
if (qemuDomainObjBeginJob(driver, vm, QEMU_JOB_MODIFY) < 0)
goto cleanup;
VIR_QEMU_PROCESS_KILL_FORCE));
}
if (virObjectUnref(vm))
- virDomainObjUnlock(vm);
+ virObjectUnlock(vm);
}
if (event)
qemuDomainEventQueue(driver, event);
VIR_DEBUG("vm=%p", vm);
- virDomainObjLock(vm);
+ virObjectLock(vm);
priv = vm->privateData;
if (priv->gotShutdown) {
qemuProcessShutdownOrReboot(driver, vm);
unlock:
- virDomainObjUnlock(vm);
+ virObjectUnlock(vm);
if (event) {
qemuDriverLock(driver);
virQEMUDriverPtr driver = qemu_driver;
virDomainEventPtr event = NULL;
- virDomainObjLock(vm);
+ virObjectLock(vm);
if (virDomainObjGetState(vm, NULL) == VIR_DOMAIN_RUNNING) {
qemuDomainObjPrivatePtr priv = vm->privateData;
}
unlock:
- virDomainObjUnlock(vm);
+ virObjectUnlock(vm);
if (event) {
qemuDriverLock(driver);
virQEMUDriverPtr driver = qemu_driver;
virDomainEventPtr event = NULL;
- virDomainObjLock(vm);
+ virObjectLock(vm);
if (virDomainObjGetState(vm, NULL) == VIR_DOMAIN_PAUSED) {
qemuDomainObjPrivatePtr priv = vm->privateData;
}
unlock:
- virDomainObjUnlock(vm);
+ virObjectUnlock(vm);
if (event) {
qemuDriverLock(driver);
virQEMUDriverPtr driver = qemu_driver;
virDomainEventPtr event;
- virDomainObjLock(vm);
+ virObjectLock(vm);
event = virDomainEventRTCChangeNewFromObj(vm, offset);
if (vm->def->clock.offset == VIR_DOMAIN_CLOCK_OFFSET_VARIABLE)
if (virDomainSaveStatus(driver->caps, driver->stateDir, vm) < 0)
VIR_WARN("unable to save domain status with RTC change");
- virDomainObjUnlock(vm);
+ virObjectUnlock(vm);
if (event) {
qemuDriverLock(driver);
virDomainEventPtr watchdogEvent = NULL;
virDomainEventPtr lifecycleEvent = NULL;
- virDomainObjLock(vm);
+ virObjectLock(vm);
watchdogEvent = virDomainEventWatchdogNewFromObj(vm, action);
if (action == VIR_DOMAIN_EVENT_WATCHDOG_PAUSE &&
}
if (vm)
- virDomainObjUnlock(vm);
+ virObjectUnlock(vm);
if (watchdogEvent || lifecycleEvent) {
qemuDriverLock(driver);
const char *devAlias;
virDomainDiskDefPtr disk;
- virDomainObjLock(vm);
+ virObjectLock(vm);
disk = qemuProcessFindDomainDiskByAlias(vm, diskAlias);
if (disk) {
if (virDomainSaveStatus(driver->caps, driver->stateDir, vm) < 0)
VIR_WARN("Unable to save status on vm %s after IO error", vm->def->name);
}
- virDomainObjUnlock(vm);
+ virObjectUnlock(vm);
if (ioErrorEvent || ioErrorEvent2 || lifecycleEvent) {
qemuDriverLock(driver);
const char *path;
virDomainDiskDefPtr disk;
- virDomainObjLock(vm);
+ virObjectLock(vm);
disk = qemuProcessFindDomainDiskByAlias(vm, diskAlias);
if (disk) {
disk->mirroring = true;
}
- virDomainObjUnlock(vm);
+ virObjectUnlock(vm);
if (event) {
qemuDriverLock(driver);
goto no_memory;
}
- virDomainObjLock(vm);
+ virObjectLock(vm);
event = virDomainEventGraphicsNewFromObj(vm, phase, localAddr, remoteAddr, authScheme, subject);
- virDomainObjUnlock(vm);
+ virObjectUnlock(vm);
if (event) {
qemuDriverLock(driver);
virDomainEventPtr event = NULL;
virDomainDiskDefPtr disk;
- virDomainObjLock(vm);
+ virObjectLock(vm);
disk = qemuProcessFindDomainDiskByAlias(vm, devAlias);
if (disk) {
}
}
- virDomainObjUnlock(vm);
+ virObjectUnlock(vm);
if (event) {
qemuDriverLock(driver);
virDomainEventPtr event = NULL;
virDomainEventPtr lifecycleEvent = NULL;
- virDomainObjLock(vm);
+ virObjectLock(vm);
event = virDomainEventPMWakeupNewFromObj(vm);
/* Don't set domain status back to running if it wasn't paused
}
}
- virDomainObjUnlock(vm);
+ virObjectUnlock(vm);
if (event || lifecycleEvent) {
qemuDriverLock(driver);
virDomainEventPtr event = NULL;
virDomainEventPtr lifecycleEvent = NULL;
- virDomainObjLock(vm);
+ virObjectLock(vm);
event = virDomainEventPMSuspendNewFromObj(vm);
if (virDomainObjGetState(vm, NULL) == VIR_DOMAIN_RUNNING) {
qemuAgentNotifyEvent(priv->agent, QEMU_AGENT_EVENT_SUSPEND);
}
- virDomainObjUnlock(vm);
+ virObjectUnlock(vm);
if (event || lifecycleEvent) {
qemuDriverLock(driver);
virQEMUDriverPtr driver = qemu_driver;
virDomainEventPtr event;
- virDomainObjLock(vm);
+ virObjectLock(vm);
event = virDomainEventBalloonChangeNewFromObj(vm, actual);
VIR_DEBUG("Updating balloon from %lld to %lld kb",
if (virDomainSaveStatus(driver->caps, driver->stateDir, vm) < 0)
VIR_WARN("unable to save domain status with balloon change");
- virDomainObjUnlock(vm);
+ virObjectUnlock(vm);
if (event) {
qemuDriverLock(driver);
virDomainEventPtr event = NULL;
virDomainEventPtr lifecycleEvent = NULL;
- virDomainObjLock(vm);
+ virObjectLock(vm);
event = virDomainEventPMSuspendDiskNewFromObj(vm);
if (virDomainObjGetState(vm, NULL) == VIR_DOMAIN_RUNNING) {
qemuAgentNotifyEvent(priv->agent, QEMU_AGENT_EVENT_SUSPEND);
}
- virDomainObjUnlock(vm);
+ virObjectUnlock(vm);
if (event || lifecycleEvent) {
qemuDriverLock(driver);
virObjectRef(vm);
ignore_value(virTimeMillisNow(&priv->monStart));
- virDomainObjUnlock(vm);
+ virObjectUnlock(vm);
qemuDriverUnlock(driver);
mon = qemuMonitorOpen(vm,
&monitorCallbacks);
qemuDriverLock(driver);
- virDomainObjLock(vm);
+ virObjectLock(vm);
priv->monStart = 0;
if (mon == NULL) {
VIR_FREE(data);
qemuDriverLock(driver);
- virDomainObjLock(obj);
+ virObjectLock(obj);
VIR_DEBUG("Reconnect monitor to %p '%s'", obj, obj->def->name);
obj = NULL;
if (obj && virObjectUnref(obj))
- virDomainObjUnlock(obj);
+ virObjectUnlock(obj);
qemuDriverUnlock(driver);
if (obj) {
if (!virDomainObjIsActive(obj)) {
if (virObjectUnref(obj))
- virDomainObjUnlock(obj);
+ virObjectUnlock(obj);
qemuDriverUnlock(driver);
return;
}
if (!obj->persistent)
qemuDomainRemoveInactive(driver, obj);
else
- virDomainObjUnlock(obj);
+ virObjectUnlock(obj);
}
}
qemuDriverUnlock(driver);
* this early phase.
*/
- virDomainObjLock(obj);
+ virObjectLock(obj);
qemuDomainObjRestoreJob(obj, &data->oldjob);
if (!obj->persistent)
qemuDomainRemoveInactive(src->driver, obj);
else
- virDomainObjUnlock(obj);
+ virObjectUnlock(obj);
}
goto error;
}
- virDomainObjUnlock(obj);
+ virObjectUnlock(obj);
return;
if (driver) {
virObjectRef(vm);
- virDomainObjUnlock(vm);
+ virObjectUnlock(vm);
qemuDriverLock(driver);
- virDomainObjLock(vm);
+ virObjectLock(vm);
virObjectUnref(vm);
}
domobj->persistent = 1;
if (testDomainStartState(conn, domobj, VIR_DOMAIN_RUNNING_BOOTED) < 0) {
- virDomainObjUnlock(domobj);
+ virObjectUnlock(domobj);
goto error;
}
- virDomainObjUnlock(domobj);
+ virObjectUnlock(domobj);
if (!(netdef = virNetworkDefParseString(defaultNetworkXML)))
goto error;
dom->persistent = 1;
if (testDomainStartState(conn, dom, VIR_DOMAIN_RUNNING_BOOTED) < 0) {
- virDomainObjUnlock(dom);
+ virObjectUnlock(dom);
goto error;
}
- virDomainObjUnlock(dom);
+ virObjectUnlock(dom);
}
VIR_FREE(domains);
cleanup:
if (obj)
- virDomainObjUnlock(obj);
+ virObjectUnlock(obj);
return ret;
}
cleanup:
if (obj)
- virDomainObjUnlock(obj);
+ virObjectUnlock(obj);
return ret;
}
cleanup:
if (dom)
- virDomainObjUnlock(dom);
+ virObjectUnlock(dom);
if (event)
testDomainEventQueue(privconn, event);
virDomainDefFree(def);
cleanup:
if (dom)
- virDomainObjUnlock(dom);
+ virObjectUnlock(dom);
return ret;
}
cleanup:
if (dom)
- virDomainObjUnlock(dom);
+ virObjectUnlock(dom);
return ret;
}
cleanup:
if (dom)
- virDomainObjUnlock(dom);
+ virObjectUnlock(dom);
return ret;
}
ret = 0;
cleanup:
if (privdom)
- virDomainObjUnlock(privdom);
+ virObjectUnlock(privdom);
if (event)
testDomainEventQueue(privconn, event);
testDriverUnlock(privconn);
cleanup:
if (privdom)
- virDomainObjUnlock(privdom);
+ virObjectUnlock(privdom);
if (event) {
testDriverLock(privconn);
testDomainEventQueue(privconn, event);
cleanup:
if (privdom)
- virDomainObjUnlock(privdom);
+ virObjectUnlock(privdom);
if (event) {
testDriverLock(privconn);
ret = 0;
cleanup:
if (privdom)
- virDomainObjUnlock(privdom);
+ virObjectUnlock(privdom);
if (event)
testDomainEventQueue(privconn, event);
testDriverUnlock(privconn);
ret = 0;
cleanup:
if (privdom)
- virDomainObjUnlock(privdom);
+ virObjectUnlock(privdom);
if (event)
testDomainEventQueue(privconn, event);
testDriverUnlock(privconn);
cleanup:
if (privdom)
- virDomainObjUnlock(privdom);
+ virObjectUnlock(privdom);
return ret;
}
cleanup:
if (privdom)
- virDomainObjUnlock(privdom);
+ virObjectUnlock(privdom);
return ret;
}
unlink(path);
}
if (privdom)
- virDomainObjUnlock(privdom);
+ virObjectUnlock(privdom);
if (event)
testDomainEventQueue(privconn, event);
testDriverUnlock(privconn);
VIR_FREE(xml);
VIR_FORCE_CLOSE(fd);
if (dom)
- virDomainObjUnlock(dom);
+ virObjectUnlock(dom);
if (event)
testDomainEventQueue(privconn, event);
testDriverUnlock(privconn);
cleanup:
VIR_FORCE_CLOSE(fd);
if (privdom)
- virDomainObjUnlock(privdom);
+ virObjectUnlock(privdom);
if (event)
testDomainEventQueue(privconn, event);
testDriverUnlock(privconn);
cleanup:
if (privdom)
- virDomainObjUnlock(privdom);
+ virObjectUnlock(privdom);
return ret;
}
cleanup:
if (privdom)
- virDomainObjUnlock(privdom);
+ virObjectUnlock(privdom);
return ret;
}
cleanup:
if (privdom)
- virDomainObjUnlock(privdom);
+ virObjectUnlock(privdom);
return ret;
}
cleanup:
if (vm)
- virDomainObjUnlock(vm);
+ virObjectUnlock(vm);
return ret;
}
cleanup:
if (privdom)
- virDomainObjUnlock(privdom);
+ virObjectUnlock(privdom);
return ret;
}
ret = maxinfo;
cleanup:
if (privdom)
- virDomainObjUnlock(privdom);
+ virObjectUnlock(privdom);
return ret;
}
ret = 0;
cleanup:
if (privdom)
- virDomainObjUnlock(privdom);
+ virObjectUnlock(privdom);
return ret;
}
cleanup:
if (privdom)
- virDomainObjUnlock(privdom);
+ virObjectUnlock(privdom);
return ret;
}
cleanup:
virDomainDefFree(def);
if (dom)
- virDomainObjUnlock(dom);
+ virObjectUnlock(dom);
if (event)
testDomainEventQueue(privconn, event);
testDriverUnlock(privconn);
cleanup:
if (privdom)
- virDomainObjUnlock(privdom);
+ virObjectUnlock(privdom);
if (event)
testDomainEventQueue(privconn, event);
testDriverUnlock(privconn);
cleanup:
if (privdom)
- virDomainObjUnlock(privdom);
+ virObjectUnlock(privdom);
if (event)
testDomainEventQueue(privconn, event);
testDriverUnlock(privconn);
cleanup:
if (privdom)
- virDomainObjUnlock(privdom);
+ virObjectUnlock(privdom);
return ret;
}
cleanup:
if (privdom)
- virDomainObjUnlock(privdom);
+ virObjectUnlock(privdom);
return ret;
}
cleanup:
if (privdom)
- virDomainObjUnlock(privdom);
+ virObjectUnlock(privdom);
return ret;
}
cleanup:
if (privdom)
- virDomainObjUnlock(privdom);
+ virObjectUnlock(privdom);
return ret;
}
ret = 0;
error:
if (privdom)
- virDomainObjUnlock(privdom);
+ virObjectUnlock(privdom);
return ret;
}
ret = 0;
error:
if (privdom)
- virDomainObjUnlock(privdom);
+ virObjectUnlock(privdom);
return ret;
}
virDomainObjPtr vm = payload;
const struct umlAutostartData *data = opaque;
- virDomainObjLock(vm);
+ virObjectLock(vm);
if (vm->autostart &&
!virDomainObjIsActive(vm)) {
int ret;
umlDomainEventQueue(data->driver, event);
}
}
- virDomainObjUnlock(vm);
+ virObjectUnlock(vm);
}
static void
if (e->mask & IN_DELETE) {
VIR_DEBUG("Got inotify domain shutdown '%s'", name);
if (!virDomainObjIsActive(dom)) {
- virDomainObjUnlock(dom);
+ virObjectUnlock(dom);
continue;
}
} else if (e->mask & (IN_CREATE | IN_MODIFY)) {
VIR_DEBUG("Got inotify domain startup '%s'", name);
if (virDomainObjIsActive(dom)) {
- virDomainObjUnlock(dom);
+ virObjectUnlock(dom);
continue;
}
if (umlReadPidFile(driver, dom) < 0) {
- virDomainObjUnlock(dom);
+ virObjectUnlock(dom);
continue;
}
}
}
if (dom)
- virDomainObjUnlock(dom);
+ virObjectUnlock(dom);
}
cleanup:
virDomainObjPtr dom = payload;
struct uml_driver *driver = opaque;
- virDomainObjLock(dom);
+ virObjectLock(dom);
if (virDomainObjIsActive(dom)) {
umlShutdownVMDaemon(driver, dom, VIR_DOMAIN_SHUTOFF_SHUTDOWN);
virDomainAuditStop(dom, "shutdown");
}
- virDomainObjUnlock(dom);
+ virObjectUnlock(dom);
}
/**
virDomainRemoveInactive(&data->driver->domains, dom);
if (dom)
- virDomainObjUnlock(dom);
+ virObjectUnlock(dom);
if (event)
umlDomainEventQueue(data->driver, event);
virHashRemoveEntry(data->driver->autodestroy, uuidstr);
cleanup:
if (vm)
- virDomainObjUnlock(vm);
+ virObjectUnlock(vm);
return dom;
}
cleanup:
if (vm)
- virDomainObjUnlock(vm);
+ virObjectUnlock(vm);
return dom;
}
cleanup:
if (vm)
- virDomainObjUnlock(vm);
+ virObjectUnlock(vm);
return dom;
}
cleanup:
if (obj)
- virDomainObjUnlock(obj);
+ virObjectUnlock(obj);
return ret;
}
cleanup:
if (obj)
- virDomainObjUnlock(obj);
+ virObjectUnlock(obj);
return ret;
}
cleanup:
if (obj)
- virDomainObjUnlock(obj);
+ virObjectUnlock(obj);
return ret;
}
cleanup:
virDomainDefFree(def);
if (vm)
- virDomainObjUnlock(vm);
+ virObjectUnlock(vm);
if (event)
umlDomainEventQueue(driver, event);
umlDriverUnlock(driver);
cleanup:
VIR_FREE(info);
if (vm)
- virDomainObjUnlock(vm);
+ virObjectUnlock(vm);
return ret;
}
cleanup:
if (vm)
- virDomainObjUnlock(vm);
+ virObjectUnlock(vm);
if (event)
umlDomainEventQueue(driver, event);
umlDriverUnlock(driver);
cleanup:
if (vm)
- virDomainObjUnlock(vm);
+ virObjectUnlock(vm);
return type;
}
cleanup:
if (vm)
- virDomainObjUnlock(vm);
+ virObjectUnlock(vm);
return ret;
}
cleanup:
if (vm)
- virDomainObjUnlock(vm);
+ virObjectUnlock(vm);
return ret;
}
cleanup:
if (vm)
- virDomainObjUnlock(vm);
+ virObjectUnlock(vm);
return ret;
}
cleanup:
if (vm)
- virDomainObjUnlock(vm);
+ virObjectUnlock(vm);
return ret;
}
cleanup:
if (vm)
- virDomainObjUnlock(vm);
+ virObjectUnlock(vm);
return ret;
}
cleanup:
if (vm)
- virDomainObjUnlock(vm);
+ virObjectUnlock(vm);
return ret;
}
cleanup:
if (vm)
- virDomainObjUnlock(vm);
+ virObjectUnlock(vm);
if (event)
umlDomainEventQueue(driver, event);
umlDriverUnlock(driver);
cleanup:
virDomainDefFree(def);
if (vm)
- virDomainObjUnlock(vm);
+ virObjectUnlock(vm);
umlDriverUnlock(driver);
return dom;
}
cleanup:
if (vm)
- virDomainObjUnlock(vm);
+ virObjectUnlock(vm);
umlDriverUnlock(driver);
return ret;
}
virDomainDeviceDefFree(dev);
if (vm)
- virDomainObjUnlock(vm);
+ virObjectUnlock(vm);
umlDriverUnlock(driver);
return ret;
}
cleanup:
virDomainDeviceDefFree(dev);
if (vm)
- virDomainObjUnlock(vm);
+ virObjectUnlock(vm);
umlDriverUnlock(driver);
return ret;
}
cleanup:
if (vm)
- virDomainObjUnlock(vm);
+ virObjectUnlock(vm);
umlDriverUnlock(driver);
return ret;
}
VIR_FREE(configFile);
VIR_FREE(autostartLink);
if (vm)
- virDomainObjUnlock(vm);
+ virObjectUnlock(vm);
umlDriverUnlock(driver);
return ret;
}
cleanup:
VIR_FORCE_CLOSE(fd);
if (vm)
- virDomainObjUnlock(vm);
+ virObjectUnlock(vm);
return ret;
}
ret = 0;
cleanup:
if (vm)
- virDomainObjUnlock(vm);
+ virObjectUnlock(vm);
umlDriverUnlock(driver);
return ret;
}
VIR_DOMAIN_RUNNING_UNKNOWN);
vm->persistent = 1;
- virDomainObjUnlock(vm);
+ virObjectUnlock(vm);
vmdef = NULL;
vm = NULL;
VIR_FREE(fileName);
VIR_FREE(vmxPath);
if (vm)
- virDomainObjUnlock(vm);
+ virObjectUnlock(vm);
vmwareDriverUnlock(driver);
return dom;
}
ret = 0;
cleanup:
if (vm)
- virDomainObjUnlock(vm);
+ virObjectUnlock(vm);
vmwareDriverUnlock(driver);
return ret;
}
cleanup:
if (vm)
- virDomainObjUnlock(vm);
+ virObjectUnlock(vm);
return ret;
}
cleanup:
if (vm)
- virDomainObjUnlock(vm);
+ virObjectUnlock(vm);
return ret;
}
cleanup:
if (vm)
- virDomainObjUnlock(vm);
+ virObjectUnlock(vm);
return ret;
}
VIR_FREE(vmx);
VIR_FREE(vmxPath);
if (vm)
- virDomainObjUnlock(vm);
+ virObjectUnlock(vm);
vmwareDriverUnlock(driver);
return dom;
}
cleanup:
if (vm)
- virDomainObjUnlock(vm);
+ virObjectUnlock(vm);
vmwareDriverUnlock(driver);
return ret;
}
cleanup:
if (vm)
- virDomainObjUnlock(vm);
+ virObjectUnlock(vm);
vmwareDriverUnlock(driver);
return ret;
}
cleanup:
if (vm)
- virDomainObjUnlock(vm);
+ virObjectUnlock(vm);
return dom;
}
cleanup:
if (vm)
- virDomainObjUnlock(vm);
+ virObjectUnlock(vm);
return ret;
}
cleanup:
if (vm)
- virDomainObjUnlock(vm);
+ virObjectUnlock(vm);
return dom;
}
cleanup:
if (vm)
- virDomainObjUnlock(vm);
+ virObjectUnlock(vm);
return dom;
}
cleanup:
if (obj)
- virDomainObjUnlock(obj);
+ virObjectUnlock(obj);
return ret;
}
cleanup:
if (obj)
- virDomainObjUnlock(obj);
+ virObjectUnlock(obj);
return ret;
}
cleanup:
if (vm)
- virDomainObjUnlock(vm);
+ virObjectUnlock(vm);
return ret;
}
{
struct vmware_driver *driver = data;
virDomainObjPtr vm = payload;
- virDomainObjLock(vm);
+ virObjectLock(vm);
ignore_value(vmwareUpdateVMStatus(driver, vm));
- virDomainObjUnlock(vm);
+ virObjectUnlock(vm);
}
static void
cleanup:
if (vm)
- virDomainObjUnlock(vm);
+ virObjectUnlock(vm);
return ret;
}
cleanup:
if (vm)
- virDomainObjUnlock(vm);
+ virObjectUnlock(vm);
return ret;
}
virObjectUnref(test->server);
if (test->mon) {
- qemuMonitorUnlock(test->mon);
+ virObjectUnlock(test->mon);
qemuMonitorClose(test->mon);
}
json ? 1 : 0,
&qemuCallbacks)))
goto error;
- qemuMonitorLock(test->mon);
+ virObjectLock(test->mon);
if (virNetSocketAccept(test->server, &test->client) < 0)
goto error;
projects / people / liuw / libxenctrl-split / libvirt.git / commitdiff