#define DEVICE_PTY_MAJOR 136
#define DEVICE_SND_MAJOR 116
-bool qemuCgroupControllerActive(virQEMUDriverPtr driver,
- int controller)
-{
- return virCgroupHasController(driver->cgroup, controller);
-}
-
static int
qemuSetupDiskPathAllow(virDomainDiskDefPtr disk,
const char *path,
size_t depth ATTRIBUTE_UNUSED,
void *opaque)
{
- qemuCgroupData *data = opaque;
+ virDomainObjPtr vm = opaque;
+ qemuDomainObjPrivatePtr priv = vm->privateData;
int rc;
VIR_DEBUG("Process path %s for disk", path);
- rc = virCgroupAllowDevicePath(data->cgroup, path,
+ rc = virCgroupAllowDevicePath(priv->cgroup, path,
(disk->readonly ? VIR_CGROUP_DEVICE_READ
: VIR_CGROUP_DEVICE_RW));
- virDomainAuditCgroupPath(data->vm, data->cgroup, "allow", path,
+ virDomainAuditCgroupPath(vm, priv->cgroup, "allow", path,
disk->readonly ? "r" : "rw", rc);
if (rc < 0) {
if (rc == -EACCES) { /* Get this for root squash NFS */
int qemuSetupDiskCgroup(virDomainObjPtr vm,
- virCgroupPtr cgroup,
virDomainDiskDefPtr disk)
{
- qemuCgroupData data = { vm, cgroup };
+ qemuDomainObjPrivatePtr priv = vm->privateData;
+
+ if (!virCgroupHasController(priv->cgroup,
+ VIR_CGROUP_CONTROLLER_DEVICES))
+ return 0;
+
return virDomainDiskDefForeachPath(disk,
true,
qemuSetupDiskPathAllow,
- &data);
+ vm);
}
size_t depth ATTRIBUTE_UNUSED,
void *opaque)
{
- qemuCgroupData *data = opaque;
+ virDomainObjPtr vm = opaque;
+ qemuDomainObjPrivatePtr priv = vm->privateData;
int rc;
VIR_DEBUG("Process path %s for disk", path);
- rc = virCgroupDenyDevicePath(data->cgroup, path,
+ rc = virCgroupDenyDevicePath(priv->cgroup, path,
VIR_CGROUP_DEVICE_RWM);
- virDomainAuditCgroupPath(data->vm, data->cgroup, "deny", path, "rwm", rc);
+ virDomainAuditCgroupPath(vm, priv->cgroup, "deny", path, "rwm", rc);
if (rc < 0) {
if (rc == -EACCES) { /* Get this for root squash NFS */
VIR_DEBUG("Ignoring EACCES for %s", path);
int qemuTeardownDiskCgroup(virDomainObjPtr vm,
- virCgroupPtr cgroup,
virDomainDiskDefPtr disk)
{
- qemuCgroupData data = { vm, cgroup };
+ qemuDomainObjPrivatePtr priv = vm->privateData;
+
+ if (!virCgroupHasController(priv->cgroup,
+ VIR_CGROUP_CONTROLLER_DEVICES))
+ return 0;
+
return virDomainDiskDefForeachPath(disk,
true,
qemuTeardownDiskPathDeny,
- &data);
+ vm);
}
static int
qemuSetupChrSourceCgroup(virDomainDefPtr def,
virDomainChrSourceDefPtr dev,
- qemuCgroupData *data)
+ void *opaque)
{
+ virDomainObjPtr vm = opaque;
+ qemuDomainObjPrivatePtr priv = vm->privateData;
int rc;
if (dev->type != VIR_DOMAIN_CHR_TYPE_DEV)
VIR_DEBUG("Process path '%s' for device", dev->data.file.path);
- rc = virCgroupAllowDevicePath(data->cgroup, dev->data.file.path,
+ rc = virCgroupAllowDevicePath(priv->cgroup, dev->data.file.path,
VIR_CGROUP_DEVICE_RW);
- virDomainAuditCgroupPath(data->vm, data->cgroup, "allow",
+ virDomainAuditCgroupPath(vm, priv->cgroup, "allow",
dev->data.file.path, "rw", rc);
if (rc < 0) {
virReportSystemError(-rc,
virDomainChrDefPtr dev,
void *opaque)
{
- qemuCgroupData *data = opaque;
-
- return qemuSetupChrSourceCgroup(def, &dev->source, data);
+ return qemuSetupChrSourceCgroup(def, &dev->source, opaque);
}
static int
qemuSetupTPMCgroup(virDomainDefPtr def,
virDomainTPMDefPtr dev,
- qemuCgroupData *data)
+ void *opaque)
{
int rc = 0;
switch (dev->type) {
case VIR_DOMAIN_TPM_TYPE_PASSTHROUGH:
rc = qemuSetupChrSourceCgroup(def, &dev->data.passthrough.source,
- data);
+ opaque);
break;
case VIR_DOMAIN_TPM_TYPE_LAST:
break;
const char *path,
void *opaque)
{
- qemuCgroupData *data = opaque;
+ virDomainObjPtr vm = opaque;
+ qemuDomainObjPrivatePtr priv = vm->privateData;
int rc;
VIR_DEBUG("Process path '%s' for USB device", path);
- rc = virCgroupAllowDevicePath(data->cgroup, path,
+ rc = virCgroupAllowDevicePath(priv->cgroup, path,
VIR_CGROUP_DEVICE_RW);
- virDomainAuditCgroupPath(data->vm, data->cgroup, "allow", path, "rw", rc);
+ virDomainAuditCgroupPath(vm, priv->cgroup, "allow", path, "rw", rc);
if (rc < 0) {
virReportSystemError(-rc,
_("Unable to allow device %s"),
return 0;
}
+
+int qemuInitCgroup(virQEMUDriverPtr driver,
+ virDomainObjPtr vm)
+{
+ int rc;
+ qemuDomainObjPrivatePtr priv = vm->privateData;
+ virCgroupPtr driverGroup = NULL;
+ virQEMUDriverConfigPtr cfg = virQEMUDriverGetConfig(driver);
+
+ virCgroupFree(&priv->cgroup);
+
+ rc = virCgroupForDriver("qemu", &driverGroup,
+ cfg->privileged, true,
+ cfg->cgroupControllers);
+ if (rc != 0) {
+ if (rc == -ENXIO ||
+ rc == -EPERM ||
+ rc == -EACCES) { /* No cgroups mounts == success */
+ VIR_DEBUG("No cgroups present/configured/accessible, ignoring error");
+ goto done;
+ }
+
+ virReportSystemError(-rc,
+ _("Unable to create cgroup for %s"),
+ vm->def->name);
+ goto cleanup;
+ }
+
+ rc = virCgroupForDomain(driverGroup, vm->def->name, &priv->cgroup, 1);
+ if (rc != 0) {
+ virReportSystemError(-rc,
+ _("Unable to create cgroup for %s"),
+ vm->def->name);
+ goto cleanup;
+ }
+
+done:
+ rc = 0;
+cleanup:
+ virCgroupFree(&driverGroup);
+ virObjectUnref(cfg);
+ return rc;
+}
+
+
int qemuSetupCgroup(virQEMUDriverPtr driver,
virDomainObjPtr vm,
virBitmapPtr nodemask)
{
- virCgroupPtr cgroup = NULL;
- int rc;
+ int rc = -1;
unsigned int i;
virQEMUDriverConfigPtr cfg = virQEMUDriverGetConfig(driver);
+ qemuDomainObjPrivatePtr priv = vm->privateData;
const char *const *deviceACL =
cfg->cgroupDeviceACL ?
(const char *const *)cfg->cgroupDeviceACL :
defaultDeviceACL;
- if (driver->cgroup == NULL)
- goto done; /* Not supported, so claim success */
+ if (qemuInitCgroup(driver, vm) < 0)
+ return -1;
- rc = virCgroupForDomain(driver->cgroup, vm->def->name, &cgroup, 1);
- if (rc != 0) {
- virReportSystemError(-rc,
- _("Unable to create cgroup for %s"),
- vm->def->name);
- goto cleanup;
- }
+ if (!priv->cgroup)
+ goto done;
- if (qemuCgroupControllerActive(driver, VIR_CGROUP_CONTROLLER_DEVICES)) {
- qemuCgroupData data = { vm, cgroup };
- rc = virCgroupDenyAllDevices(cgroup);
- virDomainAuditCgroup(vm, cgroup, "deny", "all", rc == 0);
+ if (virCgroupHasController(priv->cgroup, VIR_CGROUP_CONTROLLER_DEVICES)) {
+ rc = virCgroupDenyAllDevices(priv->cgroup);
+ virDomainAuditCgroup(vm, priv->cgroup, "deny", "all", rc == 0);
if (rc != 0) {
if (rc == -EPERM) {
VIR_WARN("Group devices ACL is not accessible, disabling whitelisting");
}
for (i = 0; i < vm->def->ndisks ; i++) {
- if (qemuSetupDiskCgroup(vm, cgroup, vm->def->disks[i]) < 0)
+ if (qemuSetupDiskCgroup(vm, vm->def->disks[i]) < 0)
goto cleanup;
}
- rc = virCgroupAllowDeviceMajor(cgroup, 'c', DEVICE_PTY_MAJOR,
+ rc = virCgroupAllowDeviceMajor(priv->cgroup, 'c', DEVICE_PTY_MAJOR,
VIR_CGROUP_DEVICE_RW);
- virDomainAuditCgroupMajor(vm, cgroup, "allow", DEVICE_PTY_MAJOR,
+ virDomainAuditCgroupMajor(vm, priv->cgroup, "allow", DEVICE_PTY_MAJOR,
"pty", "rw", rc == 0);
if (rc != 0) {
virReportSystemError(-rc, "%s",
((vm->def->graphics[0]->type == VIR_DOMAIN_GRAPHICS_TYPE_VNC &&
cfg->vncAllowHostAudio) ||
(vm->def->graphics[0]->type == VIR_DOMAIN_GRAPHICS_TYPE_SDL)))) {
- rc = virCgroupAllowDeviceMajor(cgroup, 'c', DEVICE_SND_MAJOR,
+ rc = virCgroupAllowDeviceMajor(priv->cgroup, 'c', DEVICE_SND_MAJOR,
VIR_CGROUP_DEVICE_RW);
- virDomainAuditCgroupMajor(vm, cgroup, "allow", DEVICE_SND_MAJOR,
+ virDomainAuditCgroupMajor(vm, priv->cgroup, "allow", DEVICE_SND_MAJOR,
"sound", "rw", rc == 0);
if (rc != 0) {
virReportSystemError(-rc, "%s",
continue;
}
- rc = virCgroupAllowDevicePath(cgroup, deviceACL[i],
+ rc = virCgroupAllowDevicePath(priv->cgroup, deviceACL[i],
VIR_CGROUP_DEVICE_RW);
- virDomainAuditCgroupPath(vm, cgroup, "allow", deviceACL[i], "rw", rc);
+ virDomainAuditCgroupPath(vm, priv->cgroup, "allow", deviceACL[i], "rw", rc);
if (rc < 0 &&
rc != -ENOENT) {
virReportSystemError(-rc,
if (virDomainChrDefForeach(vm->def,
true,
qemuSetupChardevCgroup,
- &data) < 0)
+ vm) < 0)
goto cleanup;
- if (vm->def->tpm)
- qemuSetupTPMCgroup(vm->def,
+ if (vm->def->tpm &&
+ (qemuSetupTPMCgroup(vm->def,
vm->def->tpm,
- &data);
+ vm) < 0))
+ goto cleanup;
for (i = 0; i < vm->def->nhostdevs; i++) {
virDomainHostdevDefPtr hostdev = vm->def->hostdevs[i];
goto cleanup;
if (virUSBDeviceFileIterate(usb, qemuSetupHostUsbDeviceCgroup,
- &data) < 0) {
+ vm) < 0) {
virUSBDeviceFree(usb);
goto cleanup;
}
}
if (vm->def->blkio.weight != 0) {
- if (qemuCgroupControllerActive(driver, VIR_CGROUP_CONTROLLER_BLKIO)) {
- rc = virCgroupSetBlkioWeight(cgroup, vm->def->blkio.weight);
+ if (virCgroupHasController(priv->cgroup, VIR_CGROUP_CONTROLLER_BLKIO)) {
+ rc = virCgroupSetBlkioWeight(priv->cgroup, vm->def->blkio.weight);
if (rc != 0) {
virReportSystemError(-rc,
_("Unable to set io weight for domain %s"),
}
if (vm->def->blkio.ndevices) {
- if (qemuCgroupControllerActive(driver, VIR_CGROUP_CONTROLLER_BLKIO)) {
+ if (virCgroupHasController(priv->cgroup, VIR_CGROUP_CONTROLLER_BLKIO)) {
for (i = 0; i < vm->def->blkio.ndevices; i++) {
virBlkioDeviceWeightPtr dw = &vm->def->blkio.devices[i];
if (!dw->weight)
continue;
- rc = virCgroupSetBlkioDeviceWeight(cgroup, dw->path,
+ rc = virCgroupSetBlkioDeviceWeight(priv->cgroup, dw->path,
dw->weight);
if (rc != 0) {
virReportSystemError(-rc,
}
}
- if (qemuCgroupControllerActive(driver, VIR_CGROUP_CONTROLLER_MEMORY)) {
+ if (virCgroupHasController(priv->cgroup, VIR_CGROUP_CONTROLLER_MEMORY)) {
unsigned long long hard_limit = vm->def->mem.hard_limit;
if (!hard_limit) {
hard_limit += vm->def->ndisks * 32768;
}
- rc = virCgroupSetMemoryHardLimit(cgroup, hard_limit);
+ rc = virCgroupSetMemoryHardLimit(priv->cgroup, hard_limit);
if (rc != 0) {
virReportSystemError(-rc,
_("Unable to set memory hard limit for domain %s"),
goto cleanup;
}
if (vm->def->mem.soft_limit != 0) {
- rc = virCgroupSetMemorySoftLimit(cgroup, vm->def->mem.soft_limit);
+ rc = virCgroupSetMemorySoftLimit(priv->cgroup, vm->def->mem.soft_limit);
if (rc != 0) {
virReportSystemError(-rc,
_("Unable to set memory soft limit for domain %s"),
}
if (vm->def->mem.swap_hard_limit != 0) {
- rc = virCgroupSetMemSwapHardLimit(cgroup, vm->def->mem.swap_hard_limit);
+ rc = virCgroupSetMemSwapHardLimit(priv->cgroup, vm->def->mem.swap_hard_limit);
if (rc != 0) {
virReportSystemError(-rc,
_("Unable to set swap hard limit for domain %s"),
}
if (vm->def->cputune.shares != 0) {
- if (qemuCgroupControllerActive(driver, VIR_CGROUP_CONTROLLER_CPU)) {
- rc = virCgroupSetCpuShares(cgroup, vm->def->cputune.shares);
+ if (virCgroupHasController(priv->cgroup, VIR_CGROUP_CONTROLLER_CPU)) {
+ rc = virCgroupSetCpuShares(priv->cgroup, vm->def->cputune.shares);
if (rc != 0) {
virReportSystemError(-rc,
_("Unable to set io cpu shares for domain %s"),
(vm->def->numatune.memory.placement_mode ==
VIR_NUMA_TUNE_MEM_PLACEMENT_MODE_AUTO)) &&
vm->def->numatune.memory.mode == VIR_DOMAIN_NUMATUNE_MEM_STRICT &&
- qemuCgroupControllerActive(driver, VIR_CGROUP_CONTROLLER_CPUSET)) {
+ virCgroupHasController(priv->cgroup, VIR_CGROUP_CONTROLLER_CPUSET)) {
char *mask = NULL;
if (vm->def->numatune.memory.placement_mode ==
VIR_NUMA_TUNE_MEM_PLACEMENT_MODE_AUTO)
goto cleanup;
}
- rc = virCgroupSetCpusetMems(cgroup, mask);
+ rc = virCgroupSetCpusetMems(priv->cgroup, mask);
VIR_FREE(mask);
if (rc != 0) {
virReportSystemError(-rc,
goto cleanup;
}
}
-done:
- virObjectUnref(cfg);
- virCgroupFree(&cgroup);
- return 0;
+done:
+ rc = 0;
cleanup:
virObjectUnref(cfg);
- if (cgroup) {
- virCgroupRemove(cgroup);
- virCgroupFree(&cgroup);
- }
- return -1;
+ return rc == 0 ? 0 : -1;
}
int qemuSetupCgroupVcpuBW(virCgroupPtr cgroup, unsigned long long period,
return rc;
}
-int qemuSetupCgroupForVcpu(virQEMUDriverPtr driver, virDomainObjPtr vm)
+int qemuSetupCgroupForVcpu(virDomainObjPtr vm)
{
- virCgroupPtr cgroup = NULL;
virCgroupPtr cgroup_vcpu = NULL;
qemuDomainObjPrivatePtr priv = vm->privateData;
virDomainDefPtr def = vm->def;
long long quota = vm->def->cputune.quota;
if ((period || quota) &&
- (!driver->cgroup ||
- !qemuCgroupControllerActive(driver, VIR_CGROUP_CONTROLLER_CPU))) {
+ !virCgroupHasController(priv->cgroup, VIR_CGROUP_CONTROLLER_CPU)) {
virReportError(VIR_ERR_CONFIG_UNSUPPORTED, "%s",
_("cgroup cpu is required for scheduler tuning"));
return -1;
* with virProcessInfoSetAffinity, thus the lack of cgroups is not fatal
* here.
*/
- if (driver->cgroup == NULL)
+ if (priv->cgroup == NULL)
return 0;
- rc = virCgroupForDomain(driver->cgroup, vm->def->name, &cgroup, 0);
- if (rc != 0) {
- virReportSystemError(-rc,
- _("Unable to find cgroup for %s"),
- vm->def->name);
- goto cleanup;
- }
-
if (priv->nvcpupids == 0 || priv->vcpupids[0] == vm->pid) {
/* If we don't know VCPU<->PID mapping or all vcpu runs in the same
* thread, we cannot control each vcpu.
*/
VIR_WARN("Unable to get vcpus' pids.");
- virCgroupFree(&cgroup);
return 0;
}
for (i = 0; i < priv->nvcpupids; i++) {
- rc = virCgroupForVcpu(cgroup, i, &cgroup_vcpu, 1);
+ rc = virCgroupForVcpu(priv->cgroup, i, &cgroup_vcpu, 1);
if (rc < 0) {
virReportSystemError(-rc,
_("Unable to create vcpu cgroup for %s(vcpu:"
}
/* Set vcpupin in cgroup if vcpupin xml is provided */
- if (qemuCgroupControllerActive(driver, VIR_CGROUP_CONTROLLER_CPUSET)) {
+ if (virCgroupHasController(priv->cgroup, VIR_CGROUP_CONTROLLER_CPUSET)) {
/* find the right CPU to pin, otherwise
* qemuSetupCgroupVcpuPin will fail. */
for (j = 0; j < def->cputune.nvcpupin; j++) {
virCgroupFree(&cgroup_vcpu);
}
- virCgroupFree(&cgroup);
return 0;
cleanup:
virCgroupFree(&cgroup_vcpu);
}
- if (cgroup) {
- virCgroupRemove(cgroup);
- virCgroupFree(&cgroup);
- }
-
return -1;
}
{
virBitmapPtr cpumask = NULL;
virBitmapPtr cpumap = NULL;
- virCgroupPtr cgroup = NULL;
virCgroupPtr cgroup_emulator = NULL;
virDomainDefPtr def = vm->def;
+ qemuDomainObjPrivatePtr priv = vm->privateData;
unsigned long long period = vm->def->cputune.emulator_period;
long long quota = vm->def->cputune.emulator_quota;
int rc;
if ((period || quota) &&
- (!driver->cgroup ||
- !qemuCgroupControllerActive(driver, VIR_CGROUP_CONTROLLER_CPU))) {
+ !virCgroupHasController(priv->cgroup, VIR_CGROUP_CONTROLLER_CPU)) {
virReportError(VIR_ERR_CONFIG_UNSUPPORTED, "%s",
_("cgroup cpu is required for scheduler tuning"));
return -1;
}
- if (driver->cgroup == NULL)
+ if (priv->cgroup == NULL)
return 0; /* Not supported, so claim success */
- rc = virCgroupForDomain(driver->cgroup, vm->def->name, &cgroup, 0);
- if (rc != 0) {
- virReportSystemError(-rc,
- _("Unable to find cgroup for %s"),
- vm->def->name);
- goto cleanup;
- }
-
- rc = virCgroupForEmulator(cgroup, &cgroup_emulator, 1);
+ rc = virCgroupForEmulator(priv->cgroup, &cgroup_emulator, 1);
if (rc < 0) {
virReportSystemError(-rc,
_("Unable to create emulator cgroup for %s"),
goto cleanup;
}
- rc = virCgroupMoveTask(cgroup, cgroup_emulator);
+ rc = virCgroupMoveTask(priv->cgroup, cgroup_emulator);
if (rc < 0) {
virReportSystemError(-rc,
_("Unable to move tasks from domain cgroup to "
}
if (cpumask) {
- if (qemuCgroupControllerActive(driver, VIR_CGROUP_CONTROLLER_CPUSET)) {
+ if (virCgroupHasController(priv->cgroup, VIR_CGROUP_CONTROLLER_CPUSET)) {
rc = qemuSetupCgroupEmulatorPin(cgroup_emulator, cpumask);
if (rc < 0)
goto cleanup;
}
if (period || quota) {
- if (qemuCgroupControllerActive(driver, VIR_CGROUP_CONTROLLER_CPU)) {
+ if (virCgroupHasController(priv->cgroup, VIR_CGROUP_CONTROLLER_CPU)) {
if ((rc = qemuSetupCgroupVcpuBW(cgroup_emulator, period,
quota)) < 0)
goto cleanup;
}
virCgroupFree(&cgroup_emulator);
- virCgroupFree(&cgroup);
virBitmapFree(cpumap);
return 0;
virCgroupFree(&cgroup_emulator);
}
- if (cgroup) {
- virCgroupRemove(cgroup);
- virCgroupFree(&cgroup);
- }
-
return rc;
}
-int qemuRemoveCgroup(virQEMUDriverPtr driver,
- virDomainObjPtr vm,
- int quiet)
+int qemuRemoveCgroup(virDomainObjPtr vm)
{
- virCgroupPtr cgroup;
- int rc;
+ qemuDomainObjPrivatePtr priv = vm->privateData;
- if (driver->cgroup == NULL)
+ if (priv->cgroup == NULL)
return 0; /* Not supported, so claim success */
- rc = virCgroupForDomain(driver->cgroup, vm->def->name, &cgroup, 0);
- if (rc != 0) {
- if (!quiet)
- virReportError(VIR_ERR_INTERNAL_ERROR,
- _("Unable to find cgroup for %s"),
- vm->def->name);
- return rc;
- }
-
- rc = virCgroupRemove(cgroup);
- virCgroupFree(&cgroup);
- return rc;
+ return virCgroupRemove(priv->cgroup);
}
-int qemuAddToCgroup(virQEMUDriverPtr driver,
- virDomainDefPtr def)
+int qemuAddToCgroup(virDomainObjPtr vm)
{
- virCgroupPtr cgroup = NULL;
- int ret = -1;
+ qemuDomainObjPrivatePtr priv = vm->privateData;
int rc;
- if (driver->cgroup == NULL)
+ if (priv->cgroup == NULL)
return 0; /* Not supported, so claim success */
- rc = virCgroupForDomain(driver->cgroup, def->name, &cgroup, 0);
- if (rc != 0) {
- virReportSystemError(-rc,
- _("unable to find cgroup for domain %s"),
- def->name);
- goto cleanup;
- }
-
- rc = virCgroupAddTask(cgroup, getpid());
+ rc = virCgroupAddTask(priv->cgroup, getpid());
if (rc != 0) {
virReportSystemError(-rc,
_("unable to add domain %s task %d to cgroup"),
- def->name, getpid());
- goto cleanup;
+ vm->def->name, getpid());
+ return -1;
}
- ret = 0;
-
-cleanup:
- virCgroupFree(&cgroup);
- return ret;
+ return 0;
}
void *opaque)
{
char *driverConf = NULL;
- int rc;
virConnectPtr conn = NULL;
char ebuf[1024];
char *membase = NULL;
goto error;
}
- rc = virCgroupForDriver("qemu", &qemu_driver->cgroup, privileged, 1,
- cfg->cgroupControllers);
- if (rc < 0) {
- VIR_INFO("Unable to create cgroup for driver: %s",
- virStrerror(-rc, ebuf, sizeof(ebuf)));
- }
-
qemu_driver->qemuImgBinary = virFindFileInPath("kvm-img");
if (!qemu_driver->qemuImgBinary)
qemu_driver->qemuImgBinary = virFindFileInPath("qemu-img");
/* Free domain callback list */
virDomainEventStateFree(qemu_driver->domainEventState);
- virCgroupFree(&qemu_driver->cgroup);
-
virLockManagerPluginUnref(qemu_driver->lockManager);
virMutexDestroy(&qemu_driver->lock);
int vcpus = oldvcpus;
pid_t *cpupids = NULL;
int ncpupids;
- virCgroupPtr cgroup = NULL;
virCgroupPtr cgroup_vcpu = NULL;
- bool cgroup_available = false;
qemuDomainObjEnterMonitor(driver, vm);
goto cleanup;
}
- cgroup_available = (virCgroupForDomain(driver->cgroup, vm->def->name,
- &cgroup, 0) == 0);
-
if (nvcpus > oldvcpus) {
for (i = oldvcpus; i < nvcpus; i++) {
- if (cgroup_available) {
+ if (priv->cgroup) {
int rv = -1;
/* Create cgroup for the onlined vcpu */
- rv = virCgroupForVcpu(cgroup, i, &cgroup_vcpu, 1);
+ rv = virCgroupForVcpu(priv->cgroup, i, &cgroup_vcpu, 1);
if (rv < 0) {
virReportSystemError(-rv,
_("Unable to create vcpu cgroup for %s(vcpu:"
vcpupin->vcpuid = i;
vm->def->cputune.vcpupin[vm->def->cputune.nvcpupin++] = vcpupin;
- if (cgroup_available) {
+ if (cgroup_vcpu) {
if (qemuSetupCgroupVcpuPin(cgroup_vcpu,
vm->def->cputune.vcpupin,
vm->def->cputune.nvcpupin, i) < 0) {
for (i = oldvcpus - 1; i >= nvcpus; i--) {
virDomainVcpuPinDefPtr vcpupin = NULL;
- if (cgroup_available) {
+ if (priv->cgroup) {
int rv = -1;
- rv = virCgroupForVcpu(cgroup, i, &cgroup_vcpu, 0);
+ rv = virCgroupForVcpu(priv->cgroup, i, &cgroup_vcpu, 0);
if (rv < 0) {
virReportSystemError(-rv,
_("Unable to access vcpu cgroup for %s(vcpu:"
vm->def->vcpus = vcpus;
VIR_FREE(cpupids);
virDomainAuditVcpu(vm, oldvcpus, nvcpus, "update", rc == 1);
- if (cgroup)
- virCgroupFree(&cgroup);
if (cgroup_vcpu)
virCgroupFree(&cgroup_vcpu);
return ret;
virQEMUDriverPtr driver = dom->conn->privateData;
virDomainObjPtr vm;
virDomainDefPtr persistentDef = NULL;
- virCgroupPtr cgroup_dom = NULL;
virCgroupPtr cgroup_vcpu = NULL;
int ret = -1;
qemuDomainObjPrivatePtr priv;
}
/* Configure the corresponding cpuset cgroup before set affinity. */
- if (qemuCgroupControllerActive(driver, VIR_CGROUP_CONTROLLER_CPUSET)) {
- if (virCgroupForDomain(driver->cgroup, vm->def->name, &cgroup_dom, 0) == 0 &&
- virCgroupForVcpu(cgroup_dom, vcpu, &cgroup_vcpu, 0) == 0 &&
+ if (virCgroupHasController(priv->cgroup, VIR_CGROUP_CONTROLLER_CPUSET)) {
+ if (virCgroupForVcpu(priv->cgroup, vcpu, &cgroup_vcpu, 0) == 0 &&
qemuSetupCgroupVcpuPin(cgroup_vcpu, newVcpuPin, newVcpuPinNum, vcpu) < 0) {
virReportError(VIR_ERR_OPERATION_INVALID,
_("failed to set cpuset.cpus in cgroup"
cleanup:
if (cgroup_vcpu)
virCgroupFree(&cgroup_vcpu);
- if (cgroup_dom)
- virCgroupFree(&cgroup_dom);
if (vm)
virObjectUnlock(vm);
virBitmapFree(pcpumap);
{
virQEMUDriverPtr driver = dom->conn->privateData;
virDomainObjPtr vm;
- virCgroupPtr cgroup_dom = NULL;
virCgroupPtr cgroup_emulator = NULL;
pid_t pid;
virDomainDefPtr persistentDef = NULL;
goto cleanup;
}
- if (qemuCgroupControllerActive(driver,
- VIR_CGROUP_CONTROLLER_CPUSET)) {
+ if (virCgroupHasController(priv->cgroup,
+ VIR_CGROUP_CONTROLLER_CPUSET)) {
/*
* Configure the corresponding cpuset cgroup.
* If no cgroup for domain or hypervisor exists, do nothing.
*/
- if (virCgroupForDomain(driver->cgroup, vm->def->name,
- &cgroup_dom, 0) == 0) {
- if (virCgroupForEmulator(cgroup_dom, &cgroup_emulator, 0) == 0) {
- if (qemuSetupCgroupEmulatorPin(cgroup_emulator,
- newVcpuPin[0]->cpumask) < 0) {
- virReportError(VIR_ERR_OPERATION_INVALID, "%s",
- _("failed to set cpuset.cpus in cgroup"
- " for emulator threads"));
- goto cleanup;
- }
+ if (virCgroupForEmulator(priv->cgroup, &cgroup_emulator, 0) == 0) {
+ if (qemuSetupCgroupEmulatorPin(cgroup_emulator,
+ newVcpuPin[0]->cpumask) < 0) {
+ virReportError(VIR_ERR_OPERATION_INVALID, "%s",
+ _("failed to set cpuset.cpus in cgroup"
+ " for emulator threads"));
+ goto cleanup;
}
}
} else {
cleanup:
if (cgroup_emulator)
virCgroupFree(&cgroup_emulator);
- if (cgroup_dom)
- virCgroupFree(&cgroup_dom);
virBitmapFree(pcpumap);
virObjectUnref(caps);
if (vm)
if (qemuDomainDetermineDiskChain(driver, disk, false) < 0)
goto end;
- if (qemuCgroupControllerActive(driver, VIR_CGROUP_CONTROLLER_DEVICES)) {
- if (virCgroupForDomain(driver->cgroup, vm->def->name, &cgroup, 0)) {
- virReportError(VIR_ERR_INTERNAL_ERROR,
- _("Unable to find cgroup for %s"),
- vm->def->name);
- goto end;
- }
- if (qemuSetupDiskCgroup(vm, cgroup, disk) < 0)
- goto end;
- }
+ if (qemuSetupDiskCgroup(vm, disk) < 0)
+ goto end;
switch (disk->device) {
case VIR_DOMAIN_DISK_DEVICE_CDROM:
}
if (ret != 0 && cgroup) {
- if (qemuTeardownDiskCgroup(vm, cgroup, disk) < 0)
+ if (qemuTeardownDiskCgroup(vm, disk) < 0)
VIR_WARN("Failed to teardown cgroup for disk path %s",
NULLSTR(disk->src));
}
end:
if (ret != 0)
ignore_value(qemuRemoveSharedDisk(driver, disk, vm->def->name));
- if (cgroup)
- virCgroupFree(&cgroup);
virObjectUnref(caps);
virDomainDeviceDefFree(dev_copy);
return ret;
virDomainDiskDefPtr disk = dev->data.disk;
virDomainDiskDefPtr orig_disk = NULL;
virDomainDiskDefPtr tmp = NULL;
- virCgroupPtr cgroup = NULL;
virDomainDeviceDefPtr dev_copy = NULL;
virCapsPtr caps = NULL;
int ret = -1;
if (qemuDomainDetermineDiskChain(driver, disk, false) < 0)
goto end;
- if (qemuCgroupControllerActive(driver, VIR_CGROUP_CONTROLLER_DEVICES)) {
- if (virCgroupForDomain(driver->cgroup,
- vm->def->name, &cgroup, 0) != 0) {
- virReportError(VIR_ERR_INTERNAL_ERROR,
- _("Unable to find cgroup for %s"),
- vm->def->name);
- goto end;
- }
- if (qemuSetupDiskCgroup(vm, cgroup, disk) < 0)
- goto end;
- }
+ if (qemuSetupDiskCgroup(vm, disk) < 0)
+ goto end;
switch (disk->device) {
case VIR_DOMAIN_DISK_DEVICE_CDROM:
break;
}
- if (ret != 0 && cgroup) {
- if (qemuTeardownDiskCgroup(vm, cgroup, disk) < 0)
- VIR_WARN("Failed to teardown cgroup for disk path %s",
- NULLSTR(disk->src));
- }
+ if (ret != 0 &&
+ qemuTeardownDiskCgroup(vm, disk) < 0)
+ VIR_WARN("Failed to teardown cgroup for disk path %s",
+ NULLSTR(disk->src));
+
end:
- if (cgroup)
- virCgroupFree(&cgroup);
virObjectUnref(caps);
virDomainDeviceDefFree(dev_copy);
return ret;
virQEMUDriverPtr driver = dom->conn->privateData;
char *ret = NULL;
int rc;
+ virDomainObjPtr vm = NULL;
+ qemuDomainObjPrivatePtr priv;
+
+ vm = virDomainObjListFindByUUID(driver->domains, dom->uuid);
+ if (vm == NULL) {
+ virReportError(VIR_ERR_INTERNAL_ERROR,
+ _("No such domain %s"), dom->uuid);
+ goto cleanup;
+ }
+ priv = vm->privateData;
- if (!qemuCgroupControllerActive(driver, VIR_CGROUP_CONTROLLER_CPU)) {
+ if (!virCgroupHasController(priv->cgroup, VIR_CGROUP_CONTROLLER_CPU)) {
virReportError(VIR_ERR_OPERATION_INVALID,
"%s", _("cgroup CPU controller is not mounted"));
goto cleanup;
}
if (nparams) {
- rc = qemuGetCpuBWStatus(driver->cgroup);
+ rc = qemuGetCpuBWStatus(priv->cgroup);
if (rc < 0)
goto cleanup;
else if (rc == 0)
virReportOOMError();
cleanup:
+ if (vm)
+ virObjectUnlock(vm);
return ret;
}
{
virQEMUDriverPtr driver = dom->conn->privateData;
int i;
- virCgroupPtr group = NULL;
virDomainObjPtr vm = NULL;
virDomainDefPtr persistentDef = NULL;
int ret = -1;
virQEMUDriverConfigPtr cfg = NULL;
virCapsPtr caps = NULL;
+ qemuDomainObjPrivatePtr priv;
virCheckFlags(VIR_DOMAIN_AFFECT_LIVE |
VIR_DOMAIN_AFFECT_CONFIG, -1);
if (!(vm = qemuDomObjFromDomain(dom)))
return -1;
+ priv = vm->privateData;
cfg = virQEMUDriverGetConfig(driver);
if (!(caps = virQEMUDriverGetCapabilities(driver, false)))
goto cleanup;
goto cleanup;
if (flags & VIR_DOMAIN_AFFECT_LIVE) {
- if (!qemuCgroupControllerActive(driver, VIR_CGROUP_CONTROLLER_BLKIO)) {
+ if (!virCgroupHasController(priv->cgroup, VIR_CGROUP_CONTROLLER_BLKIO)) {
virReportError(VIR_ERR_OPERATION_INVALID, "%s",
_("blkio cgroup isn't mounted"));
goto cleanup;
}
-
- if (virCgroupForDomain(driver->cgroup, vm->def->name, &group, 0) != 0) {
- virReportError(VIR_ERR_INTERNAL_ERROR,
- _("cannot find cgroup for domain %s"),
- vm->def->name);
- goto cleanup;
- }
}
ret = 0;
continue;
}
- rc = virCgroupSetBlkioWeight(group, params[i].value.ui);
+ rc = virCgroupSetBlkioWeight(priv->cgroup, params[i].value.ui);
if (rc != 0) {
virReportSystemError(-rc, "%s",
_("unable to set blkio weight tunable"));
continue;
}
for (j = 0; j < ndevices; j++) {
- rc = virCgroupSetBlkioDeviceWeight(group,
+ rc = virCgroupSetBlkioDeviceWeight(priv->cgroup,
devices[j].path,
devices[j].weight);
if (rc < 0) {
}
cleanup:
- virCgroupFree(&group);
if (vm)
virObjectUnlock(vm);
virObjectUnref(caps);
{
virQEMUDriverPtr driver = dom->conn->privateData;
int i, j;
- virCgroupPtr group = NULL;
virDomainObjPtr vm = NULL;
virDomainDefPtr persistentDef = NULL;
unsigned int val;
int ret = -1;
int rc;
virCapsPtr caps = NULL;
+ qemuDomainObjPrivatePtr priv;
virCheckFlags(VIR_DOMAIN_AFFECT_LIVE |
VIR_DOMAIN_AFFECT_CONFIG |
if (!(vm = qemuDomObjFromDomain(dom)))
return -1;
+ priv = vm->privateData;
+
if (!(caps = virQEMUDriverGetCapabilities(driver, false)))
goto cleanup;
goto cleanup;
if (flags & VIR_DOMAIN_AFFECT_LIVE) {
- if (!qemuCgroupControllerActive(driver, VIR_CGROUP_CONTROLLER_BLKIO)) {
+ if (!virCgroupHasController(priv->cgroup, VIR_CGROUP_CONTROLLER_BLKIO)) {
virReportError(VIR_ERR_OPERATION_INVALID, "%s",
_("blkio cgroup isn't mounted"));
goto cleanup;
}
-
- if (virCgroupForDomain(driver->cgroup, vm->def->name, &group, 0) != 0) {
- virReportError(VIR_ERR_INTERNAL_ERROR,
- _("cannot find cgroup for domain %s"), vm->def->name);
- goto cleanup;
- }
}
if (flags & VIR_DOMAIN_AFFECT_LIVE) {
switch (i) {
case 0: /* fill blkio weight here */
- rc = virCgroupGetBlkioWeight(group, &val);
+ rc = virCgroupGetBlkioWeight(priv->cgroup, &val);
if (rc != 0) {
virReportSystemError(-rc, "%s",
_("unable to get blkio weight"));
ret = 0;
cleanup:
- if (group)
- virCgroupFree(&group);
if (vm)
virObjectUnlock(vm);
virObjectUnref(caps);
{
virQEMUDriverPtr driver = dom->conn->privateData;
virDomainDefPtr persistentDef = NULL;
- virCgroupPtr group = NULL;
virDomainObjPtr vm = NULL;
unsigned long long swap_hard_limit;
unsigned long long memory_hard_limit;
int ret = -1;
int rc;
virCapsPtr caps = NULL;
+ qemuDomainObjPrivatePtr priv;
virCheckFlags(VIR_DOMAIN_AFFECT_LIVE |
VIR_DOMAIN_AFFECT_CONFIG, -1);
if (!(vm = qemuDomObjFromDomain(dom)))
return -1;
+ priv = vm->privateData;
cfg = virQEMUDriverGetConfig(driver);
if (!(caps = virQEMUDriverGetCapabilities(driver, false)))
goto cleanup;
if (flags & VIR_DOMAIN_AFFECT_LIVE) {
- if (!qemuCgroupControllerActive(driver, VIR_CGROUP_CONTROLLER_MEMORY)) {
+ if (!virCgroupHasController(priv->cgroup, VIR_CGROUP_CONTROLLER_MEMORY)) {
virReportError(VIR_ERR_OPERATION_INVALID,
"%s", _("cgroup memory controller is not mounted"));
goto cleanup;
}
-
- if (virCgroupForDomain(driver->cgroup, vm->def->name, &group, 0) != 0) {
- virReportError(VIR_ERR_INTERNAL_ERROR,
- _("cannot find cgroup for domain %s"), vm->def->name);
- goto cleanup;
- }
}
#define VIR_GET_LIMIT_PARAMETER(PARAM, VALUE) \
if (set_swap_hard_limit) {
if (flags & VIR_DOMAIN_AFFECT_LIVE) {
- if ((rc = virCgroupSetMemSwapHardLimit(group, swap_hard_limit)) < 0) {
+ if ((rc = virCgroupSetMemSwapHardLimit(priv->cgroup, swap_hard_limit)) < 0) {
virReportSystemError(-rc, "%s",
_("unable to set memory swap_hard_limit tunable"));
goto cleanup;
if (set_memory_hard_limit) {
if (flags & VIR_DOMAIN_AFFECT_LIVE) {
- if ((rc = virCgroupSetMemoryHardLimit(group, memory_hard_limit)) < 0) {
+ if ((rc = virCgroupSetMemoryHardLimit(priv->cgroup, memory_hard_limit)) < 0) {
virReportSystemError(-rc, "%s",
_("unable to set memory hard_limit tunable"));
goto cleanup;
if (set_memory_soft_limit) {
if (flags & VIR_DOMAIN_AFFECT_LIVE) {
- if ((rc = virCgroupSetMemorySoftLimit(group, memory_soft_limit)) < 0) {
+ if ((rc = virCgroupSetMemorySoftLimit(priv->cgroup, memory_soft_limit)) < 0) {
virReportSystemError(-rc, "%s",
_("unable to set memory soft_limit tunable"));
goto cleanup;
ret = 0;
cleanup:
- virCgroupFree(&group);
virObjectUnlock(vm);
virObjectUnref(caps);
virObjectUnref(cfg);
{
virQEMUDriverPtr driver = dom->conn->privateData;
int i;
- virCgroupPtr group = NULL;
virDomainObjPtr vm = NULL;
virDomainDefPtr persistentDef = NULL;
int ret = -1;
int rc;
virCapsPtr caps = NULL;
+ qemuDomainObjPrivatePtr priv;
virCheckFlags(VIR_DOMAIN_AFFECT_LIVE |
VIR_DOMAIN_AFFECT_CONFIG |
if (!(vm = qemuDomObjFromDomain(dom)))
return -1;
+ priv = vm->privateData;
if (!(caps = virQEMUDriverGetCapabilities(driver, false)))
goto cleanup;
goto cleanup;
if (flags & VIR_DOMAIN_AFFECT_LIVE) {
- if (!qemuCgroupControllerActive(driver, VIR_CGROUP_CONTROLLER_MEMORY)) {
+ if (!virCgroupHasController(priv->cgroup, VIR_CGROUP_CONTROLLER_MEMORY)) {
virReportError(VIR_ERR_OPERATION_INVALID,
"%s", _("cgroup memory controller is not mounted"));
goto cleanup;
}
-
- if (virCgroupForDomain(driver->cgroup, vm->def->name, &group, 0) != 0) {
- virReportError(VIR_ERR_INTERNAL_ERROR,
- _("cannot find cgroup for domain %s"), vm->def->name);
- goto cleanup;
- }
}
if ((*nparams) == 0) {
virTypedParameterPtr param = ¶ms[i];
unsigned long long val = 0;
- /* Coverity does not realize that if we get here, group is set. */
- sa_assert(group);
-
switch (i) {
case 0: /* fill memory hard limit here */
- rc = virCgroupGetMemoryHardLimit(group, &val);
+ rc = virCgroupGetMemoryHardLimit(priv->cgroup, &val);
if (rc != 0) {
virReportSystemError(-rc, "%s",
_("unable to get memory hard limit"));
break;
case 1: /* fill memory soft limit here */
- rc = virCgroupGetMemorySoftLimit(group, &val);
+ rc = virCgroupGetMemorySoftLimit(priv->cgroup, &val);
if (rc != 0) {
virReportSystemError(-rc, "%s",
_("unable to get memory soft limit"));
break;
case 2: /* fill swap hard limit here */
- rc = virCgroupGetMemSwapHardLimit(group, &val);
+ rc = virCgroupGetMemSwapHardLimit(priv->cgroup, &val);
if (rc != 0) {
virReportSystemError(-rc, "%s",
_("unable to get swap hard limit"));
ret = 0;
cleanup:
- if (group)
- virCgroupFree(&group);
if (vm)
virObjectUnlock(vm);
virObjectUnref(caps);
virQEMUDriverPtr driver = dom->conn->privateData;
int i;
virDomainDefPtr persistentDef = NULL;
- virCgroupPtr group = NULL;
virDomainObjPtr vm = NULL;
int ret = -1;
virQEMUDriverConfigPtr cfg = NULL;
virCapsPtr caps = NULL;
+ qemuDomainObjPrivatePtr priv;
virCheckFlags(VIR_DOMAIN_AFFECT_LIVE |
VIR_DOMAIN_AFFECT_CONFIG, -1);
if (!(vm = qemuDomObjFromDomain(dom)))
return -1;
+ priv = vm->privateData;
cfg = virQEMUDriverGetConfig(driver);
if (!(caps = virQEMUDriverGetCapabilities(driver, false)))
goto cleanup;
if (flags & VIR_DOMAIN_AFFECT_LIVE) {
- if (!qemuCgroupControllerActive(driver, VIR_CGROUP_CONTROLLER_CPUSET)) {
+ if (!virCgroupHasController(priv->cgroup, VIR_CGROUP_CONTROLLER_CPUSET)) {
virReportError(VIR_ERR_OPERATION_INVALID,
"%s", _("cgroup cpuset controller is not mounted"));
goto cleanup;
}
-
- if (virCgroupForDomain(driver->cgroup, vm->def->name, &group, 0) != 0) {
- virReportError(VIR_ERR_INTERNAL_ERROR,
- _("cannot find cgroup for domain %s"),
- vm->def->name);
- goto cleanup;
- }
}
ret = 0;
continue;
}
- if ((rc = virCgroupSetCpusetMems(group, nodeset_str) != 0)) {
+ if ((rc = virCgroupSetCpusetMems(priv->cgroup, nodeset_str) != 0)) {
virReportSystemError(-rc, "%s",
_("unable to set numa tunable"));
virBitmapFree(nodeset);
}
cleanup:
- virCgroupFree(&group);
if (vm)
virObjectUnlock(vm);
virObjectUnref(caps);
{
virQEMUDriverPtr driver = dom->conn->privateData;
int i;
- virCgroupPtr group = NULL;
virDomainObjPtr vm = NULL;
virDomainDefPtr persistentDef = NULL;
char *nodeset = NULL;
int ret = -1;
int rc;
virCapsPtr caps = NULL;
+ qemuDomainObjPrivatePtr priv;
virCheckFlags(VIR_DOMAIN_AFFECT_LIVE |
VIR_DOMAIN_AFFECT_CONFIG |
if (!(vm = qemuDomObjFromDomain(dom)))
return -1;
+ priv = vm->privateData;
+
if (!(caps = virQEMUDriverGetCapabilities(driver, false)))
goto cleanup;
}
if (flags & VIR_DOMAIN_AFFECT_LIVE) {
- if (!qemuCgroupControllerActive(driver, VIR_CGROUP_CONTROLLER_MEMORY)) {
+ if (!virCgroupHasController(priv->cgroup, VIR_CGROUP_CONTROLLER_MEMORY)) {
virReportError(VIR_ERR_OPERATION_INVALID,
"%s", _("cgroup memory controller is not mounted"));
goto cleanup;
}
-
- if (virCgroupForDomain(driver->cgroup, vm->def->name, &group, 0) != 0) {
- virReportError(VIR_ERR_INTERNAL_ERROR,
- _("cannot find cgroup for domain %s"),
- vm->def->name);
- goto cleanup;
- }
}
for (i = 0; i < QEMU_NB_NUMA_PARAM && i < *nparams; i++) {
if (!nodeset)
nodeset = strdup("");
} else {
- rc = virCgroupGetCpusetMems(group, &nodeset);
+ rc = virCgroupGetCpusetMems(priv->cgroup, &nodeset);
if (rc != 0) {
virReportSystemError(-rc, "%s",
_("unable to get numa nodeset"));
cleanup:
VIR_FREE(nodeset);
- virCgroupFree(&group);
if (vm)
virObjectUnlock(vm);
virObjectUnref(caps);
int rc;
virQEMUDriverConfigPtr cfg = NULL;
virCapsPtr caps = NULL;
+ qemuDomainObjPrivatePtr priv;
virCheckFlags(VIR_DOMAIN_AFFECT_LIVE |
VIR_DOMAIN_AFFECT_CONFIG, -1);
if (!(vm = qemuDomObjFromDomain(dom)))
return -1;
+ priv = vm->privateData;
cfg = virQEMUDriverGetConfig(driver);
if (!(caps = virQEMUDriverGetCapabilities(driver, false)))
}
if (flags & VIR_DOMAIN_AFFECT_LIVE) {
- if (!qemuCgroupControllerActive(driver, VIR_CGROUP_CONTROLLER_CPU)) {
+ if (!virCgroupHasController(priv->cgroup, VIR_CGROUP_CONTROLLER_CPU)) {
virReportError(VIR_ERR_OPERATION_INVALID,
"%s", _("cgroup CPU controller is not mounted"));
goto cleanup;
}
- if (virCgroupForDomain(driver->cgroup, vm->def->name, &group, 0) != 0) {
- virReportError(VIR_ERR_INTERNAL_ERROR,
- _("cannot find cgroup for domain %s"),
- vm->def->name);
- goto cleanup;
- }
}
for (i = 0; i < nparams; i++) {
if (STREQ(param->field, VIR_DOMAIN_SCHEDULER_CPU_SHARES)) {
if (flags & VIR_DOMAIN_AFFECT_LIVE) {
- if ((rc = virCgroupSetCpuShares(group, value_ul))) {
+ if ((rc = virCgroupSetCpuShares(priv->cgroup, value_ul))) {
virReportSystemError(-rc, "%s",
_("unable to set cpu shares tunable"));
goto cleanup;
cleanup:
virDomainDefFree(vmdef);
- virCgroupFree(&group);
if (vm)
virObjectUnlock(vm);
virObjectUnref(caps);
}
static int
-qemuGetVcpusBWLive(virDomainObjPtr vm, virCgroupPtr cgroup,
+qemuGetVcpusBWLive(virDomainObjPtr vm,
unsigned long long *period, long long *quota)
{
virCgroupPtr cgroup_vcpu = NULL;
priv = vm->privateData;
if (priv->nvcpupids == 0 || priv->vcpupids[0] == vm->pid) {
/* We do not create sub dir for each vcpu */
- rc = qemuGetVcpuBWLive(cgroup, period, quota);
+ rc = qemuGetVcpuBWLive(priv->cgroup, period, quota);
if (rc < 0)
goto cleanup;
}
/* get period and quota for vcpu0 */
- rc = virCgroupForVcpu(cgroup, 0, &cgroup_vcpu, 0);
+ rc = virCgroupForVcpu(priv->cgroup, 0, &cgroup_vcpu, 0);
if (!cgroup_vcpu) {
virReportSystemError(-rc,
_("Unable to find vcpu cgroup for %s(vcpu: 0)"),
unsigned int flags)
{
virQEMUDriverPtr driver = dom->conn->privateData;
- virCgroupPtr group = NULL;
virDomainObjPtr vm = NULL;
unsigned long long shares;
unsigned long long period;
int saved_nparams = 0;
virDomainDefPtr persistentDef;
virCapsPtr caps = NULL;
+ qemuDomainObjPrivatePtr priv;
virCheckFlags(VIR_DOMAIN_AFFECT_LIVE |
VIR_DOMAIN_AFFECT_CONFIG |
/* We don't return strings, and thus trivially support this flag. */
flags &= ~VIR_TYPED_PARAM_STRING_OKAY;
+ if (!(vm = qemuDomObjFromDomain(dom)))
+ goto cleanup;
+
+ priv = vm->privateData;
+
if (*nparams > 1) {
- rc = qemuGetCpuBWStatus(driver->cgroup);
+ rc = qemuGetCpuBWStatus(priv->cgroup);
if (rc < 0)
goto cleanup;
cpu_bw_status = !!rc;
}
- if (!(vm = qemuDomObjFromDomain(dom)))
- goto cleanup;
-
if (!(caps = virQEMUDriverGetCapabilities(driver, false)))
goto cleanup;
goto out;
}
- if (!qemuCgroupControllerActive(driver, VIR_CGROUP_CONTROLLER_CPU)) {
+ if (!virCgroupHasController(priv->cgroup, VIR_CGROUP_CONTROLLER_CPU)) {
virReportError(VIR_ERR_OPERATION_INVALID,
"%s", _("cgroup CPU controller is not mounted"));
goto cleanup;
}
- if (virCgroupForDomain(driver->cgroup, vm->def->name, &group, 0) != 0) {
- virReportError(VIR_ERR_INTERNAL_ERROR,
- _("cannot find cgroup for domain %s"), vm->def->name);
- goto cleanup;
- }
-
- rc = virCgroupGetCpuShares(group, &shares);
+ rc = virCgroupGetCpuShares(priv->cgroup, &shares);
if (rc != 0) {
virReportSystemError(-rc, "%s",
_("unable to get cpu shares tunable"));
}
if (*nparams > 1 && cpu_bw_status) {
- rc = qemuGetVcpusBWLive(vm, group, &period, "a);
+ rc = qemuGetVcpusBWLive(vm, &period, "a);
if (rc != 0)
goto cleanup;
}
if (*nparams > 3 && cpu_bw_status) {
- rc = qemuGetEmulatorBandwidthLive(vm, group, &emulator_period,
+ rc = qemuGetEmulatorBandwidthLive(vm, priv->cgroup, &emulator_period,
&emulator_quota);
if (rc != 0)
goto cleanup;
ret = 0;
cleanup:
- virCgroupFree(&group);
if (vm)
virObjectUnlock(vm);
virObjectUnref(caps);
{
virQEMUDriverPtr driver = dom->conn->privateData;
int i;
- virCgroupPtr group = NULL;
virDomainObjPtr vm = NULL;
virDomainDefPtr persistentDef = NULL;
int ret = -1;
cleanup:
virNetDevBandwidthFree(bandwidth);
virNetDevBandwidthFree(newBandwidth);
- virCgroupFree(&group);
if (vm)
virObjectUnlock(vm);
virObjectUnref(caps);
{
virQEMUDriverPtr driver = dom->conn->privateData;
int i;
- virCgroupPtr group = NULL;
virDomainObjPtr vm = NULL;
virDomainDefPtr def = NULL;
virDomainDefPtr persistentDef = NULL;
ret = 0;
cleanup:
- if (group)
- virCgroupFree(&group);
if (vm)
virObjectUnlock(vm);
virObjectUnref(caps);
static int
qemuDomainPrepareDiskChainElement(virQEMUDriverPtr driver,
virDomainObjPtr vm,
- virCgroupPtr cgroup,
virDomainDiskDefPtr disk,
const char *file,
qemuDomainDiskChainMode mode)
if (virSecurityManagerRestoreImageLabel(driver->securityManager,
vm->def, disk) < 0)
VIR_WARN("Unable to restore security label on %s", disk->src);
- if (cgroup && qemuTeardownDiskCgroup(vm, cgroup, disk) < 0)
+ if (qemuTeardownDiskCgroup(vm, disk) < 0)
VIR_WARN("Failed to teardown cgroup for disk path %s", disk->src);
if (virDomainLockDiskDetach(driver->lockManager, vm, disk) < 0)
VIR_WARN("Unable to release lock on %s", disk->src);
} else if (virDomainLockDiskAttach(driver->lockManager, cfg->uri,
vm, disk) < 0 ||
- (cgroup && qemuSetupDiskCgroup(vm, cgroup, disk) < 0) ||
+ qemuSetupDiskCgroup(vm, disk) < 0 ||
virSecurityManagerSetImageLabel(driver->securityManager,
vm->def, disk) < 0) {
goto cleanup;
static int
qemuDomainSnapshotCreateSingleDiskActive(virQEMUDriverPtr driver,
virDomainObjPtr vm,
- virCgroupPtr cgroup,
virDomainSnapshotDiskDefPtr snap,
virDomainDiskDefPtr disk,
virDomainDiskDefPtr persistDisk,
virStorageFileFreeMetadata(disk->backingChain);
disk->backingChain = NULL;
- if (qemuDomainPrepareDiskChainElement(driver, vm, cgroup, disk, source,
+ if (qemuDomainPrepareDiskChainElement(driver, vm, disk, source,
VIR_DISK_CHAIN_READ_WRITE) < 0) {
- qemuDomainPrepareDiskChainElement(driver, vm, cgroup, disk, source,
+ qemuDomainPrepareDiskChainElement(driver, vm, disk, source,
VIR_DISK_CHAIN_NO_ACCESS);
goto cleanup;
}
static void
qemuDomainSnapshotUndoSingleDiskActive(virQEMUDriverPtr driver,
virDomainObjPtr vm,
- virCgroupPtr cgroup,
virDomainDiskDefPtr origdisk,
virDomainDiskDefPtr disk,
virDomainDiskDefPtr persistDisk,
goto cleanup;
}
- qemuDomainPrepareDiskChainElement(driver, vm, cgroup, disk, origdisk->src,
+ qemuDomainPrepareDiskChainElement(driver, vm, disk, origdisk->src,
VIR_DISK_CHAIN_NO_ACCESS);
if (need_unlink && stat(disk->src, &st) == 0 &&
S_ISREG(st.st_mode) && unlink(disk->src) < 0)
int i;
bool persist = false;
bool reuse = (flags & VIR_DOMAIN_SNAPSHOT_CREATE_REUSE_EXT) != 0;
- virCgroupPtr cgroup = NULL;
virQEMUDriverConfigPtr cfg = virQEMUDriverGetConfig(driver);
if (!virDomainObjIsActive(vm)) {
goto cleanup;
}
- if (qemuCgroupControllerActive(driver, VIR_CGROUP_CONTROLLER_DEVICES) &&
- virCgroupForDomain(driver->cgroup, vm->def->name, &cgroup, 0)) {
- virReportError(VIR_ERR_INTERNAL_ERROR,
- _("Unable to find cgroup for %s"),
- vm->def->name);
- goto cleanup;
- }
- /* 'cgroup' is still NULL if cgroups are disabled. */
-
if (virQEMUCapsGet(priv->qemuCaps, QEMU_CAPS_TRANSACTION)) {
if (!(actions = virJSONValueNewArray())) {
virReportOOMError();
}
}
- ret = qemuDomainSnapshotCreateSingleDiskActive(driver, vm, cgroup,
+ ret = qemuDomainSnapshotCreateSingleDiskActive(driver, vm,
&snap->def->disks[i],
vm->def->disks[i],
persistDisk, actions,
persistDisk = vm->newDef->disks[indx];
}
- qemuDomainSnapshotUndoSingleDiskActive(driver, vm, cgroup,
+ qemuDomainSnapshotUndoSingleDiskActive(driver, vm,
snap->def->dom->disks[i],
vm->def->disks[i],
persistDisk,
qemuDomainObjExitMonitor(driver, vm);
cleanup:
- virCgroupFree(&cgroup);
if (ret == 0 || !virQEMUCapsGet(priv->qemuCaps, QEMU_CAPS_TRANSACTION)) {
if (virDomainSaveStatus(driver->xmlopt, cfg->stateDir, vm) < 0 ||
virDomainBlockJobInfo info;
const char *format = virStorageFileFormatTypeToString(disk->mirrorFormat);
bool resume = false;
- virCgroupPtr cgroup = NULL;
char *oldsrc = NULL;
int oldformat;
virStorageFileMetadataPtr oldchain = NULL;
* label the entire chain. This action is safe even if the
* backing chain has already been labeled; but only necessary when
* we know for sure that there is a backing chain. */
- if (disk->mirrorFormat && disk->mirrorFormat != VIR_STORAGE_FILE_RAW &&
- qemuCgroupControllerActive(driver, VIR_CGROUP_CONTROLLER_DEVICES) &&
- virCgroupForDomain(driver->cgroup, vm->def->name, &cgroup, 0) < 0) {
- virReportError(VIR_ERR_INTERNAL_ERROR,
- _("Unable to find cgroup for %s"),
- vm->def->name);
- goto cleanup;
- }
oldsrc = disk->src;
oldformat = disk->format;
oldchain = disk->backingChain;
if (disk->mirrorFormat && disk->mirrorFormat != VIR_STORAGE_FILE_RAW &&
(virDomainLockDiskAttach(driver->lockManager, cfg->uri,
vm, disk) < 0 ||
- (cgroup && qemuSetupDiskCgroup(vm, cgroup, disk) < 0) ||
+ qemuSetupDiskCgroup(vm, disk) < 0 ||
virSecurityManagerSetImageLabel(driver->securityManager, vm->def,
disk) < 0)) {
disk->src = oldsrc;
disk->mirroring = false;
cleanup:
- if (cgroup)
- virCgroupFree(&cgroup);
if (resume && virDomainObjIsActive(vm) &&
qemuProcessStartCPUs(driver, vm, conn,
VIR_DOMAIN_RUNNING_UNPAUSED,
struct stat st;
bool need_unlink = false;
char *mirror = NULL;
- virCgroupPtr cgroup = NULL;
virQEMUDriverConfigPtr cfg = NULL;
/* Preliminaries: find the disk we are editing, sanity checks */
_("domain is not running"));
goto cleanup;
}
- if (qemuCgroupControllerActive(driver, VIR_CGROUP_CONTROLLER_DEVICES) &&
- virCgroupForDomain(driver->cgroup, vm->def->name, &cgroup, 0) < 0) {
- virReportError(VIR_ERR_INTERNAL_ERROR,
- _("Unable to find cgroup for %s"),
- vm->def->name);
- goto cleanup;
- }
device = qemuDiskPathToAlias(vm, path, &idx);
if (!device) {
goto endjob;
}
- if (qemuDomainPrepareDiskChainElement(driver, vm, cgroup, disk, dest,
+ if (qemuDomainPrepareDiskChainElement(driver, vm, disk, dest,
VIR_DISK_CHAIN_READ_WRITE) < 0) {
- qemuDomainPrepareDiskChainElement(driver, vm, cgroup, disk, dest,
+ qemuDomainPrepareDiskChainElement(driver, vm, disk, dest,
VIR_DISK_CHAIN_NO_ACCESS);
goto endjob;
}
virDomainAuditDisk(vm, NULL, dest, "mirror", ret >= 0);
qemuDomainObjExitMonitor(driver, vm);
if (ret < 0) {
- qemuDomainPrepareDiskChainElement(driver, vm, cgroup, disk, dest,
+ qemuDomainPrepareDiskChainElement(driver, vm, disk, dest,
VIR_DISK_CHAIN_NO_ACCESS);
goto endjob;
}
}
cleanup:
- if (cgroup)
- virCgroupFree(&cgroup);
VIR_FREE(device);
if (vm)
virObjectUnlock(vm);
virStorageFileMetadataPtr top_meta = NULL;
const char *top_parent = NULL;
const char *base_canon = NULL;
- virCgroupPtr cgroup = NULL;
bool clean_access = false;
virCheckFlags(VIR_DOMAIN_BLOCK_COMMIT_SHALLOW, -1);
* revoke access to files removed from the chain, when the commit
* operation succeeds, but doing that requires tracking the
* operation in XML across libvirtd restarts. */
- if (qemuCgroupControllerActive(driver, VIR_CGROUP_CONTROLLER_DEVICES) &&
- virCgroupForDomain(driver->cgroup, vm->def->name, &cgroup, 0) < 0) {
- virReportError(VIR_ERR_INTERNAL_ERROR,
- _("Unable to find cgroup for %s"),
- vm->def->name);
- goto endjob;
- }
clean_access = true;
- if (qemuDomainPrepareDiskChainElement(driver, vm, cgroup, disk, base_canon,
+ if (qemuDomainPrepareDiskChainElement(driver, vm, disk, base_canon,
VIR_DISK_CHAIN_READ_WRITE) < 0 ||
(top_parent && top_parent != disk->src &&
- qemuDomainPrepareDiskChainElement(driver, vm, cgroup, disk,
+ qemuDomainPrepareDiskChainElement(driver, vm, disk,
top_parent,
VIR_DISK_CHAIN_READ_WRITE) < 0))
goto endjob;
endjob:
if (ret < 0 && clean_access) {
/* Revert access to read-only, if possible. */
- qemuDomainPrepareDiskChainElement(driver, vm, cgroup, disk, base_canon,
+ qemuDomainPrepareDiskChainElement(driver, vm, disk, base_canon,
VIR_DISK_CHAIN_READ_ONLY);
if (top_parent && top_parent != disk->src)
- qemuDomainPrepareDiskChainElement(driver, vm, cgroup, disk,
+ qemuDomainPrepareDiskChainElement(driver, vm, disk,
top_parent,
VIR_DISK_CHAIN_READ_ONLY);
}
- if (cgroup)
- virCgroupFree(&cgroup);
if (qemuDomainObjEndJob(driver, vm) == 0) {
vm = NULL;
goto cleanup;
/* qemuDomainGetCPUStats() with start_cpu == -1 */
static int
-qemuDomainGetTotalcpuStats(virCgroupPtr group,
+qemuDomainGetTotalcpuStats(virDomainObjPtr vm,
virTypedParameterPtr params,
int nparams)
{
unsigned long long cpu_time;
int ret;
+ qemuDomainObjPrivatePtr priv = vm->privateData;
if (nparams == 0) /* return supported number of params */
return QEMU_NB_TOTAL_CPU_STAT_PARAM;
/* entry 0 is cputime */
- ret = virCgroupGetCpuacctUsage(group, &cpu_time);
+ ret = virCgroupGetCpuacctUsage(priv->cgroup, &cpu_time);
if (ret < 0) {
virReportSystemError(-ret, "%s", _("unable to get cpu account"));
return -1;
unsigned long long user;
unsigned long long sys;
- ret = virCgroupGetCpuacctStat(group, &user, &sys);
+ ret = virCgroupGetCpuacctStat(priv->cgroup, &user, &sys);
if (ret < 0) {
virReportSystemError(-ret, "%s", _("unable to get cpu account"));
return -1;
* s3 = t03 + t13
*/
static int
-getSumVcpuPercpuStats(virCgroupPtr group,
- unsigned int nvcpu,
+getSumVcpuPercpuStats(virDomainObjPtr vm,
unsigned long long *sum_cpu_time,
unsigned int num)
{
int ret = -1;
int i;
char *buf = NULL;
+ qemuDomainObjPrivatePtr priv = vm->privateData;
virCgroupPtr group_vcpu = NULL;
- for (i = 0; i < nvcpu; i++) {
+ for (i = 0; i < priv->nvcpupids; i++) {
char *pos;
unsigned long long tmp;
int j;
- if (virCgroupForVcpu(group, i, &group_vcpu, 0) < 0) {
+ if (virCgroupForVcpu(priv->cgroup, i, &group_vcpu, 0) < 0) {
virReportError(VIR_ERR_INTERNAL_ERROR, "%s",
_("error accessing cgroup cpuacct for vcpu"));
goto cleanup;
static int
qemuDomainGetPercpuStats(virDomainObjPtr vm,
- virCgroupPtr group,
virTypedParameterPtr params,
unsigned int nparams,
int start_cpu,
}
/* we get percpu cputime accounting info. */
- if (virCgroupGetCpuacctPercpuUsage(group, &buf))
+ if (virCgroupGetCpuacctPercpuUsage(priv->cgroup, &buf))
goto cleanup;
pos = buf;
memset(params, 0, nparams * ncpus);
virReportOOMError();
goto cleanup;
}
- if (getSumVcpuPercpuStats(group, priv->nvcpupids, sum_cpu_time, n) < 0)
+ if (getSumVcpuPercpuStats(vm, sum_cpu_time, n) < 0)
goto cleanup;
sum_cpu_pos = sum_cpu_time;
static int
qemuDomainGetCPUStats(virDomainPtr domain,
- virTypedParameterPtr params,
- unsigned int nparams,
- int start_cpu,
- unsigned int ncpus,
- unsigned int flags)
+ virTypedParameterPtr params,
+ unsigned int nparams,
+ int start_cpu,
+ unsigned int ncpus,
+ unsigned int flags)
{
- virQEMUDriverPtr driver = domain->conn->privateData;
- virCgroupPtr group = NULL;
virDomainObjPtr vm = NULL;
int ret = -1;
bool isActive;
+ qemuDomainObjPrivatePtr priv;
virCheckFlags(VIR_TYPED_PARAM_STRING_OKAY, -1);
if (!(vm = qemuDomObjFromDomain(domain)))
return -1;
+ priv = vm->privateData;
+
isActive = virDomainObjIsActive(vm);
if (!isActive) {
virReportError(VIR_ERR_OPERATION_INVALID, "%s",
goto cleanup;
}
- if (!qemuCgroupControllerActive(driver, VIR_CGROUP_CONTROLLER_CPUACCT)) {
+ if (!virCgroupHasController(priv->cgroup, VIR_CGROUP_CONTROLLER_CPUACCT)) {
virReportError(VIR_ERR_OPERATION_INVALID,
"%s", _("cgroup CPUACCT controller is not mounted"));
goto cleanup;
}
- if (virCgroupForDomain(driver->cgroup, vm->def->name, &group, 0) != 0) {
- virReportError(VIR_ERR_INTERNAL_ERROR,
- _("cannot find cgroup for domain %s"), vm->def->name);
- goto cleanup;
- }
-
if (start_cpu == -1)
- ret = qemuDomainGetTotalcpuStats(group, params, nparams);
+ ret = qemuDomainGetTotalcpuStats(vm, params, nparams);
else
- ret = qemuDomainGetPercpuStats(vm, group, params, nparams,
+ ret = qemuDomainGetPercpuStats(vm, params, nparams,
start_cpu, ncpus);
cleanup:
- virCgroupFree(&group);
if (vm)
virObjectUnlock(vm);
return ret;
projects / people / liuw / libxenctrl-split / libvirt.git / commitdiff