virBitmapNew: Don't check return value

Remove return value check from all callers.

Signed-off-by: Peter Krempa <pkrempa@redhat.com>
Reviewed-by: Ján Tomko <jtomko@redhat.com>

diff --git a/src/conf/capabilities.c b/src/conf/capabilities.c
index 610e6e8242efb09b5b4d2dc979fb63d512083ee1..4a85c6362872c2b1ca06d0518dc79840a35e6eb8 100644 (file)
--- a/src/conf/capabilities.c
+++ b/src/conf/capabilities.c
@@ -1411,9 +1411,7 @@ virCapabilitiesHostNUMAGetCpus(virCapsHostNUMAPtr caps,
     unsigned int maxcpu = virCapabilitiesHostNUMAGetMaxcpu(caps);
     ssize_t node = -1;
 
-    if (!(ret = virBitmapNew(maxcpu + 1)))
-        return NULL;
-
+    ret = virBitmapNew(maxcpu + 1);
 
     while ((node = virBitmapNextSetBit(nodemask, node)) >= 0) {
         if (virCapabilitiesHostNUMAGetCellCpus(caps, node, ret) < 0) {
@@ -1591,8 +1589,7 @@ virCapabilitiesHostNUMAInitFake(virCapsHostNUMAPtr caps)
                         cpus[cid].die_id = 0;
                         cpus[cid].socket_id = s;
                         cpus[cid].core_id = c;
-                        if (!(cpus[cid].siblings = virBitmapNew(ncpus)))
-                            goto error;
+                        cpus[cid].siblings = virBitmapNew(ncpus);
                         virBitmapCopy(cpus[cid].siblings, siblings);
                         cid++;
                     }

diff --git a/src/conf/checkpoint_conf.c b/src/conf/checkpoint_conf.c
index 914af4305da74fad74c67a820e2a3c31b2d54146..f97621dabf4f30248bc9a3e7b07aed38835ffe01 100644 (file)
--- a/src/conf/checkpoint_conf.c
+++ b/src/conf/checkpoint_conf.c
@@ -323,8 +323,7 @@ virDomainCheckpointAlignDisks(virDomainCheckpointDefPtr def)
     if (!def->ndisks)
         checkpoint_default = VIR_DOMAIN_CHECKPOINT_TYPE_BITMAP;
 
-    if (!(map = virBitmapNew(def->parent.dom->ndisks)))
-        goto cleanup;
+    map = virBitmapNew(def->parent.dom->ndisks);
 
     /* Double check requested disks.  */
     for (i = 0; i < def->ndisks; i++) {

diff --git a/src/conf/domain_addr.c b/src/conf/domain_addr.c
index 6e77a72f7c685b18e309251b0c0ba9af5390e572..9114f2d8d08129b8425c6b7e81010c3d7c218515 100644 (file)
--- a/src/conf/domain_addr.c
+++ b/src/conf/domain_addr.c
@@ -1595,8 +1595,7 @@ virDomainVirtioSerialAddrSetAddController(virDomainVirtioSerialAddrSetPtr addrs,
     if (VIR_ALLOC(cnt) < 0)
         goto cleanup;
 
-    if (!(cnt->ports = virBitmapNew(ports)))
-        goto cleanup;
+    cnt->ports = virBitmapNew(ports);
     cnt->idx = cont->idx;
 
     if ((insertAt = virDomainVirtioSerialAddrPlaceController(addrs, cnt)) < -1)
@@ -2043,8 +2042,7 @@ virDomainUSBAddressHubNew(size_t nports)
     if (VIR_ALLOC(hub) < 0)
         goto cleanup;
 
-    if (!(hub->portmap = virBitmapNew(nports)))
-        goto cleanup;
+    hub->portmap = virBitmapNew(nports);
 
     if (VIR_ALLOC_N(hub->ports, nports) < 0)
         goto cleanup;

diff --git a/src/conf/domain_conf.c b/src/conf/domain_conf.c
index b80d7c7c6ccfc1fcb1089063ae206d074de65619..2fbfd949fd3e34986ad4095b805e52331fd3ae72 100644 (file)
--- a/src/conf/domain_conf.c
+++ b/src/conf/domain_conf.c
@@ -2032,12 +2032,9 @@ virDomainDefGetVcpus(const virDomainDef *def)
 virBitmapPtr
 virDomainDefGetOnlineVcpumap(const virDomainDef *def)
 {
-    virBitmapPtr ret = NULL;
+    virBitmapPtr ret = virBitmapNew(def->maxvcpus);
     size_t i;
 
-    if (!(ret = virBitmapNew(def->maxvcpus)))
-        return NULL;
-
     for (i = 0; i < def->maxvcpus; i++) {
         if (def->vcpus[i]->online)
             ignore_value(virBitmapSetBit(ret, i));
@@ -3311,8 +3308,7 @@ virDomainIOThreadIDDefArrayInit(virDomainDefPtr def,
         return 0;
 
     /* iothread's are numbered starting at 1, account for that */
-    if (!(thrmap = virBitmapNew(iothreads + 1)))
-        return -1;
+    thrmap = virBitmapNew(iothreads + 1);
     virBitmapSetAll(thrmap);
 
     /* Clear 0 since we don't use it, then mark those which are
@@ -4505,8 +4501,8 @@ virDomainDefRejectDuplicateControllers(virDomainDefPtr def)
     max_idx[VIR_DOMAIN_CONTROLLER_TYPE_USB] = -1;
 
     for (i = 0; i < VIR_DOMAIN_CONTROLLER_TYPE_LAST; i++) {
-        if (max_idx[i] >= 0 && !(bitmaps[i] = virBitmapNew(max_idx[i] + 1)))
-            goto cleanup;
+        if (max_idx[i] >= 0)
+            bitmaps[i] = virBitmapNew(max_idx[i] + 1);
         nbitmaps++;
     }
 

diff --git a/src/conf/node_device_conf.c b/src/conf/node_device_conf.c
index a9a03ad6c22a63ad9c4c7657cf9c59867c509f23..e4782386757dea5776be6587fb122e810b722706 100644 (file)
--- a/src/conf/node_device_conf.c
+++ b/src/conf/node_device_conf.c
@@ -1143,10 +1143,8 @@ virNodeDevCapNetParseXML(xmlXPathContextPtr ctxt,
     if ((n = virXPathNodeSet("./feature", ctxt, &nodes)) < 0)
         goto out;
 
-    if (n > 0) {
-        if (!(net->features = virBitmapNew(VIR_NET_DEV_FEAT_LAST)))
-            goto out;
-    }
+    if (n > 0)
+        net->features = virBitmapNew(VIR_NET_DEV_FEAT_LAST);
 
     for (i = 0; i < n; i++) {
         int val;

diff --git a/src/conf/storage_conf.c b/src/conf/storage_conf.c
index d53d50479b33d8c0e39801db984c70c7c94ab2fe..ae63cc725e29b9a55e284d8b2ae9b646d47cc423 100644 (file)
--- a/src/conf/storage_conf.c
+++ b/src/conf/storage_conf.c
@@ -1444,8 +1444,7 @@ virStorageVolDefParseXML(virStoragePoolDefPtr pool,
         if (!def->target.compat)
             def->target.compat = g_strdup("1.1");
 
-        if (!(def->target.features = virBitmapNew(VIR_STORAGE_FILE_FEATURE_LAST)))
-            return NULL;
+        def->target.features = virBitmapNew(VIR_STORAGE_FILE_FEATURE_LAST);
 
         for (i = 0; i < n; i++) {
             int f = virStorageFileFeatureTypeFromString((const char*)nodes[i]->name);

diff --git a/src/conf/virnetworkobj.c b/src/conf/virnetworkobj.c
index 8b12ce04827ccbaaaf1f87b0bb146d839bef1409..aefe23fde1bfd4bdcd6a419221deeafd393c086a 100644 (file)
--- a/src/conf/virnetworkobj.c
+++ b/src/conf/virnetworkobj.c
@@ -110,8 +110,7 @@ virNetworkObjNew(void)
     if (!(obj = virObjectLockableNew(virNetworkObjClass)))
         return NULL;
 
-    if (!(obj->classIdMap = virBitmapNew(INIT_CLASS_ID_BITMAP_SIZE)))
-        goto error;
+    obj->classIdMap = virBitmapNew(INIT_CLASS_ID_BITMAP_SIZE);
 
     /* The first three class IDs are already taken */
     if (virBitmapSetBitExpand(obj->classIdMap, 0) < 0 ||

diff --git a/src/libxl/libxl_capabilities.c b/src/libxl/libxl_capabilities.c
index e3472acb4b826b10bbc35ad0148c8f824e7e8abf..622cba1bfca2ac0e435d039da4fc766a0f9c851a 100644 (file)
--- a/src/libxl/libxl_capabilities.c
+++ b/src/libxl/libxl_capabilities.c
@@ -296,10 +296,6 @@ libxlCapsInitNuma(libxl_ctx *ctx, virCapsPtr caps)
         cpus[node][nr_cpus_node[node]-1].core_id = cpu_topo[i].core;
         /* Allocate the siblings maps. We will be filling them later */
         cpus[node][nr_cpus_node[node]-1].siblings = virBitmapNew(nr_cpus);
-        if (!cpus[node][nr_cpus_node[node]-1].siblings) {
-            virReportOOMError();
-            goto cleanup;
-        }
     }
 
     /* Let's now populate the siblings bitmaps */

diff --git a/src/libxl/libxl_driver.c b/src/libxl/libxl_driver.c
index 80ee3ac5d047b6ebc5fa2c279b76f140cc0c07af..446449fb333518ce640eabb1dd0736a0cb654a08 100644 (file)
--- a/src/libxl/libxl_driver.c
+++ b/src/libxl/libxl_driver.c
@@ -2571,8 +2571,7 @@ libxlDomainGetVcpuPinInfo(virDomainPtr dom, int ncpumaps,
     /* Make sure coverity knows targetDef is valid at this point. */
     sa_assert(targetDef);
 
-    if (!(hostcpus = virBitmapNew(libxl_get_max_cpus(cfg->ctx))))
-        goto cleanup;
+    hostcpus = virBitmapNew(libxl_get_max_cpus(cfg->ctx));
     virBitmapSetAll(hostcpus);
 
     ret = virDomainDefGetVcpuPinInfoHelper(targetDef, maplen, ncpumaps, cpumaps,
@@ -4952,8 +4951,7 @@ libxlDomainGetNumaParameters(virDomainPtr dom,
                 virReportOOMError();
                 goto cleanup;
             }
-            if (!(nodes = virBitmapNew(numnodes)))
-                goto cleanup;
+            nodes = virBitmapNew(numnodes);
 
             rc = libxl_domain_get_nodeaffinity(cfg->ctx,
                                                vm->def->id,

diff --git a/src/lxc/lxc_controller.c b/src/lxc/lxc_controller.c
index c3cf485e2c0670d7ba70cf4c738dae2c8eb76d05..f70731bc64e5c86dae3e43637140ca5333f10133 100644 (file)
--- a/src/lxc/lxc_controller.c
+++ b/src/lxc/lxc_controller.c
@@ -756,9 +756,6 @@ static int virLXCControllerSetupCpuAffinity(virLXCControllerPtr ctrl)
         maxcpu = hostcpus;
 
     cpumap = virBitmapNew(maxcpu);
-    if (!cpumap)
-        return -1;
-
     cpumapToSet = cpumap;
 
     if (ctrl->def->cpumask) {

diff --git a/src/qemu/qemu_capabilities.c b/src/qemu/qemu_capabilities.c
index ea2e4c094834f9e9855d5723f7773c39defbb4b5..e3a934363bc4c7889a9474f691dce9bb05a422a1 100644 (file)
--- a/src/qemu/qemu_capabilities.c
+++ b/src/qemu/qemu_capabilities.c
@@ -1800,8 +1800,7 @@ virQEMUCapsNew(void)
         return NULL;
 
     qemuCaps->invalidation = true;
-    if (!(qemuCaps->flags = virBitmapNew(QEMU_CAPS_LAST)))
-        goto error;
+    qemuCaps->flags = virBitmapNew(QEMU_CAPS_LAST);
 
     if (!(qemuCaps->domCapsCache = virQEMUDomainCapsCacheNew()))
         goto error;

diff --git a/src/qemu/qemu_conf.c b/src/qemu/qemu_conf.c
index f4ed1fa061c13bbd7aef9855349375beb13761f3..2f5809e1ad1353dc4cc0e9eea7865a0dfe15622e 100644 (file)
--- a/src/qemu/qemu_conf.c
+++ b/src/qemu/qemu_conf.c
@@ -278,8 +278,7 @@ virQEMUDriverConfigPtr virQEMUDriverConfigNew(bool privileged,
     cfg->glusterDebugLevel = 4;
     cfg->stdioLogD = true;
 
-    if (!(cfg->namespaces = virBitmapNew(QEMU_DOMAIN_NS_LAST)))
-        return NULL;
+    cfg->namespaces = virBitmapNew(QEMU_DOMAIN_NS_LAST);
 
     if (privileged &&
         qemuDomainNamespaceAvailable(QEMU_DOMAIN_NS_MOUNT) &&

diff --git a/src/qemu/qemu_domain_address.c b/src/qemu/qemu_domain_address.c
index 61eb53ea2cd646edb9af538eb88c176e94060abb..a2b19da5ea807842c2a002772d3e6af0dddd6b60 100644 (file)
--- a/src/qemu/qemu_domain_address.c
+++ b/src/qemu/qemu_domain_address.c
@@ -3056,13 +3056,10 @@ qemuDomainUSBAddressAddHubs(virDomainDefPtr def)
 static virBitmapPtr
 qemuDomainGetMemorySlotMap(const virDomainDef *def)
 {
-    virBitmapPtr ret;
+    virBitmapPtr ret = virBitmapNew(def->mem.memory_slots);
     virDomainMemoryDefPtr mem;
     size_t i;
 
-    if (!(ret = virBitmapNew(def->mem.memory_slots)))
-        return NULL;
-
     for (i = 0; i < def->nmems; i++) {
         mem = def->mems[i];
 

diff --git a/src/qemu/qemu_driver.c b/src/qemu/qemu_driver.c
index 85b6a6a321779eccadea7eb79ea8565ebbc23fa5..c23dca997067f9a439e0a0aa496db968ca05804d 100644 (file)
--- a/src/qemu/qemu_driver.c
+++ b/src/qemu/qemu_driver.c
@@ -19280,18 +19280,13 @@ qemuDomainGetGuestVcpusParams(virTypedParameterPtr *params,
     virTypedParameterPtr par = NULL;
     int npar = 0;
     int maxpar = 0;
-    virBitmapPtr vcpus = NULL;
-    virBitmapPtr online = NULL;
-    virBitmapPtr offlinable = NULL;
+    virBitmapPtr vcpus = virBitmapNew(QEMU_GUEST_VCPU_MAX_ID);
+    virBitmapPtr online = virBitmapNew(QEMU_GUEST_VCPU_MAX_ID);
+    virBitmapPtr offlinable = virBitmapNew(QEMU_GUEST_VCPU_MAX_ID);
     g_autofree char *tmp = NULL;
     size_t i;
     int ret = -1;
 
-    if (!(vcpus = virBitmapNew(QEMU_GUEST_VCPU_MAX_ID)) ||
-        !(online = virBitmapNew(QEMU_GUEST_VCPU_MAX_ID)) ||
-        !(offlinable = virBitmapNew(QEMU_GUEST_VCPU_MAX_ID)))
-        goto cleanup;
-
     for (i = 0; i < ninfo; i++) {
         if (virBitmapSetBit(vcpus, info[i].id) < 0) {
             virReportError(VIR_ERR_INTERNAL_ERROR,

diff --git a/src/qemu/qemu_hotplug.c b/src/qemu/qemu_hotplug.c
index 11b549b12bacf30f97473eb6074046ab37474c4e..86ccb9bac407d30429b44f2634f5e3187d609534 100644 (file)
--- a/src/qemu/qemu_hotplug.c
+++ b/src/qemu/qemu_hotplug.c
@@ -6150,8 +6150,7 @@ qemuDomainSelectHotplugVcpuEntities(virDomainDefPtr def,
     unsigned int curvcpus = virDomainDefGetVcpus(def);
     ssize_t i;
 
-    if (!(ret = virBitmapNew(maxvcpus)))
-        return NULL;
+    ret = virBitmapNew(maxvcpus);
 
     if (nvcpus > curvcpus) {
         *enable = true;

diff --git a/src/qemu/qemu_migration_cookie.c b/src/qemu/qemu_migration_cookie.c
index c128f541dd895f11524747a1404eb201e6b79800..4b73a98f7eb70af25afe0f8ef2debb155ebc611d 100644 (file)
--- a/src/qemu/qemu_migration_cookie.c
+++ b/src/qemu/qemu_migration_cookie.c
@@ -1122,9 +1122,8 @@ qemuMigrationCookieCapsXMLParse(xmlXPathContextPtr ctxt)
     if (VIR_ALLOC(caps) < 0)
         return NULL;
 
-    if (!(caps->supported = virBitmapNew(QEMU_MIGRATION_CAP_LAST)) ||
-        !(caps->automatic = virBitmapNew(QEMU_MIGRATION_CAP_LAST)))
-        goto cleanup;
+    caps->supported = virBitmapNew(QEMU_MIGRATION_CAP_LAST);
+    caps->automatic = virBitmapNew(QEMU_MIGRATION_CAP_LAST);
 
     if ((n = virXPathNodeSet("./capabilities[1]/cap", ctxt, &nodes)) < 0)
         goto cleanup;

diff --git a/src/qemu/qemu_migration_params.c b/src/qemu/qemu_migration_params.c
index 5fde915963ecefb80ded3f394b106281e7eed3b0..df5560d39f016efbea4f5577c9f6770b1492238e 100644 (file)
--- a/src/qemu/qemu_migration_params.c
+++ b/src/qemu/qemu_migration_params.c
@@ -224,12 +224,9 @@ G_STATIC_ASSERT(G_N_ELEMENTS(qemuMigrationParamTypes) == QEMU_MIGRATION_PARAM_LA
 virBitmapPtr
 qemuMigrationParamsGetAlwaysOnCaps(qemuMigrationParty party)
 {
-    virBitmapPtr caps = NULL;
+    virBitmapPtr caps = virBitmapNew(QEMU_MIGRATION_CAP_LAST);
     size_t i;
 
-    if (!(caps = virBitmapNew(QEMU_MIGRATION_CAP_LAST)))
-        return NULL;
-
     for (i = 0; i < G_N_ELEMENTS(qemuMigrationParamsAlwaysOn); i++) {
         if (!(qemuMigrationParamsAlwaysOn[i].party & party))
             continue;
@@ -248,8 +245,7 @@ qemuMigrationParamsNew(void)
 
     params = g_new0(qemuMigrationParams, 1);
 
-    if (!(params->caps = virBitmapNew(QEMU_MIGRATION_CAP_LAST)))
-        return NULL;
+    params->caps = virBitmapNew(QEMU_MIGRATION_CAP_LAST);
 
     return g_steal_pointer(&params);
 }
@@ -1373,8 +1369,6 @@ qemuMigrationCapsCheck(virQEMUDriverPtr driver,
         return 0;
 
     priv->migrationCaps = virBitmapNew(QEMU_MIGRATION_CAP_LAST);
-    if (!priv->migrationCaps)
-        return -1;
 
     for (capStr = caps; *capStr; capStr++) {
         int cap = qemuMigrationCapabilityTypeFromString(*capStr);
@@ -1389,8 +1383,6 @@ qemuMigrationCapsCheck(virQEMUDriverPtr driver,
 
     if (virQEMUCapsGet(priv->qemuCaps, QEMU_CAPS_MIGRATION_EVENT)) {
         migEvent = virBitmapNew(QEMU_MIGRATION_CAP_LAST);
-        if (!migEvent)
-            return -1;
 
         ignore_value(virBitmapSetBit(migEvent, QEMU_MIGRATION_CAP_EVENTS));
 

diff --git a/src/qemu/qemu_monitor.c b/src/qemu/qemu_monitor.c
index eb4b04dc1a930b2a4feff50b5d1f9fa291478ca4..c6be72dabca2d4dbcdd0c1572197e3ed4fa64f24 100644 (file)
--- a/src/qemu/qemu_monitor.c
+++ b/src/qemu/qemu_monitor.c
@@ -1937,8 +1937,7 @@ qemuMonitorGetCpuHalted(qemuMonitorPtr mon,
     if (rc < 0)
         goto cleanup;
 
-    if (!(ret = virBitmapNew(maxvcpus)))
-        goto cleanup;
+    ret = virBitmapNew(maxvcpus);
 
     for (i = 0; i < ncpuentries; i++) {
         if (cpuentries[i].halted)

diff --git a/src/qemu/qemu_namespace.c b/src/qemu/qemu_namespace.c
index b0d1d0d083d7d478375a826fb1b915d1d73dfbbc..ec52fe7ea5b172dfb2779aa21f5a22acdef299b7 100644 (file)
--- a/src/qemu/qemu_namespace.c
+++ b/src/qemu/qemu_namespace.c
@@ -799,9 +799,8 @@ qemuDomainEnableNamespace(virDomainObjPtr vm,
 {
     qemuDomainObjPrivatePtr priv = vm->privateData;
 
-    if (!priv->namespaces &&
-        !(priv->namespaces = virBitmapNew(QEMU_DOMAIN_NS_LAST)))
-        return -1;
+    if (!priv->namespaces)
+        priv->namespaces = virBitmapNew(QEMU_DOMAIN_NS_LAST);
 
     if (virBitmapSetBit(priv->namespaces, ns) < 0) {
         virReportError(VIR_ERR_INTERNAL_ERROR,

diff --git a/src/qemu/qemu_process.c b/src/qemu/qemu_process.c
index 9122069cc99f890e6b1730b5c0f043517571225d..8814e61314e70466c37cbb5f888dc4eee27f7865 100644 (file)
--- a/src/qemu/qemu_process.c
+++ b/src/qemu/qemu_process.c
@@ -5870,12 +5870,9 @@ qemuProcessValidateHotpluggableVcpus(virDomainDefPtr def)
     unsigned int maxvcpus = virDomainDefGetVcpusMax(def);
     size_t i = 0;
     size_t j;
-    virBitmapPtr ordermap = NULL;
+    virBitmapPtr ordermap = virBitmapNew(maxvcpus + 1);
     int ret = -1;
 
-    if (!(ordermap = virBitmapNew(maxvcpus + 1)))
-        goto cleanup;
-
     /* validate:
      * - all hotpluggable entities to be hotplugged have the correct data
      * - vcpus belonging to a hotpluggable entity share configuration

diff --git a/src/qemu/qemu_slirp.c b/src/qemu/qemu_slirp.c
index d9105b0ff61ec74f4f65f6cad0473653dfe3a2b6..d2e4ed79be33da0cb04b9bf10db762fcb7dadc48 100644 (file)
--- a/src/qemu/qemu_slirp.c
+++ b/src/qemu/qemu_slirp.c
@@ -83,9 +83,7 @@ qemuSlirpNew(void)
 {
     g_autoptr(qemuSlirp) slirp = g_new0(qemuSlirp, 1);
 
-    if (!(slirp->features = virBitmapNew(QEMU_SLIRP_FEATURE_LAST)))
-        return NULL;
-
+    slirp->features = virBitmapNew(QEMU_SLIRP_FEATURE_LAST);
     slirp->pid = (pid_t)-1;
     slirp->fd[0] = slirp->fd[1] = -1;
 

diff --git a/src/qemu/qemu_snapshot.c b/src/qemu/qemu_snapshot.c
index c2953c179bd7cfe1ceb8160b4936ff1ce1078d3e..47df102817358dd62e4843286e21a1f874acaa8c 100644 (file)
--- a/src/qemu/qemu_snapshot.c
+++ b/src/qemu/qemu_snapshot.c
@@ -163,8 +163,7 @@ qemuSnapshotCreateInactiveExternal(virQEMUDriverPtr driver,
     if (!(qemuImgPath = qemuFindQemuImgBinary(driver)))
         goto cleanup;
 
-    if (!(created = virBitmapNew(snapdef->ndisks)))
-        goto cleanup;
+    created = virBitmapNew(snapdef->ndisks);
 
     /* If reuse is true, then qemuSnapshotPrepare already
      * ensured that the new files exist, and it was up to the user to

diff --git a/src/test/test_driver.c b/src/test/test_driver.c
index d582c207f4c5a1fe32ee736141a6071701267af5..af8fd0330828fd9ea12c499f4a6112d0cfbdc802 100644 (file)
--- a/src/test/test_driver.c
+++ b/src/test/test_driver.c
@@ -1360,8 +1360,6 @@ testOpenDefault(virConnectPtr conn)
     }
     for (i = 0; i < 16; i++) {
         virBitmapPtr siblings = virBitmapNew(16);
-        if (!siblings)
-            goto error;
         ignore_value(virBitmapSetBit(siblings, i));
         privconn->cells[i / 8].cpus[(i % 8)].id = i;
         privconn->cells[i / 8].cpus[(i % 8)].socket_id = i / 8;
@@ -2788,8 +2786,7 @@ testDomainGetEmulatorPinInfo(virDomainPtr dom,
     } else if (def->cpumask) {
         cpumask = def->cpumask;
     } else {
-        if (!(bitmap = virBitmapNew(hostcpus)))
-            goto cleanup;
+        bitmap = virBitmapNew(hostcpus);
         virBitmapSetAll(bitmap);
         cpumask = bitmap;
     }
@@ -2966,9 +2963,7 @@ static int testDomainGetVcpus(virDomainPtr domain,
     statbase = g_get_real_time();
 
     hostcpus = VIR_NODEINFO_MAXCPUS(privconn->nodeInfo);
-    if (!(allcpumap = virBitmapNew(hostcpus)))
-        goto cleanup;
-
+    allcpumap = virBitmapNew(hostcpus);
     virBitmapSetAll(allcpumap);
 
     /* Clamp to actual number of vcpus */
@@ -3081,8 +3076,7 @@ testDomainGetVcpuPinInfo(virDomainPtr dom,
     if (!(def = virDomainObjGetOneDef(privdom, flags)))
         goto cleanup;
 
-    if (!(hostcpus = virBitmapNew(VIR_NODEINFO_MAXCPUS(driver->nodeInfo))))
-        goto cleanup;
+    hostcpus = virBitmapNew(VIR_NODEINFO_MAXCPUS(driver->nodeInfo));
     virBitmapSetAll(hostcpus);
 
     ret = virDomainDefGetVcpuPinInfoHelper(def, maplen, ncpumaps, cpumaps,

diff --git a/src/util/virbitmap.c b/src/util/virbitmap.c
index 79e9ca96835218fb84d84a641bf7f777ee4c9fc3..5f6136367aaf7e82abb865eb607e8bf6bd22ca1a 100644 (file)
--- a/src/util/virbitmap.c
+++ b/src/util/virbitmap.c
@@ -433,8 +433,7 @@ virBitmapParseSeparator(const char *str,
     size_t i;
     int start, last;
 
-    if (!(*bitmap = virBitmapNew(bitmapSize)))
-        return -1;
+    *bitmap = virBitmapNew(bitmapSize);
 
     if (!str)
         goto error;
@@ -664,10 +663,7 @@ virBitmapParseUnlimited(const char *str)
 virBitmapPtr
 virBitmapNewCopy(virBitmapPtr src)
 {
-    virBitmapPtr dst;
-
-    if ((dst = virBitmapNew(src->nbits)) == NULL)
-        return NULL;
+    virBitmapPtr dst = virBitmapNew(src->nbits);
 
     if (virBitmapCopy(dst, src) != 0) {
         virBitmapFree(dst);
@@ -699,8 +695,6 @@ virBitmapNewData(const void *data,
     const unsigned char *bytes = data;
 
     bitmap = virBitmapNew(len * CHAR_BIT);
-    if (!bitmap)
-        return NULL;
 
     /* le64toh is not available, so we do the conversion by hand */
     p = bitmap->map;
@@ -1116,8 +1110,6 @@ virBitmapNewString(const char *string)
     }
 
     bitmap = virBitmapNew(len * 4);
-    if (!bitmap)
-        return NULL;
 
     for (i = 0; i < len; i++) {
         unsigned long nibble = g_ascii_xdigit_value(string[len - i - 1]);

diff --git a/src/util/vircommand.c b/src/util/vircommand.c
index 0475e22db6e810941995e8cbdf42cb4d91abf490..859d6b0ce58edd18269777cc4b81a1feb0552465 100644 (file)
--- a/src/util/vircommand.c
+++ b/src/util/vircommand.c
@@ -571,8 +571,7 @@ virCommandMassClose(virCommandPtr cmd,
         return -1;
     }
 
-    if (!(fds = virBitmapNew(openmax)))
-        return -1;
+    fds = virBitmapNew(openmax);
 
 #  ifdef __linux__
     if (virCommandMassCloseGetFDsLinux(cmd, fds) < 0)

diff --git a/src/util/virdnsmasq.c b/src/util/virdnsmasq.c
index f60577b2218b33c8c83d0cb76214a3098fa39279..44aa7ad95d16263650a6b07071b8df82e369de9d 100644 (file)
--- a/src/util/virdnsmasq.c
+++ b/src/util/virdnsmasq.c
@@ -768,14 +768,9 @@ dnsmasqCapsNewEmpty(const char *binaryPath)
         return NULL;
     if (!(caps = virObjectNew(dnsmasqCapsClass)))
         return NULL;
-    if (!(caps->flags = virBitmapNew(DNSMASQ_CAPS_LAST)))
-        goto error;
+    caps->flags = virBitmapNew(DNSMASQ_CAPS_LAST);
     caps->binaryPath = g_strdup(binaryPath ? binaryPath : DNSMASQ);
     return caps;
-
- error:
-    virObjectUnref(caps);
-    return NULL;
 }
 
 dnsmasqCapsPtr

diff --git a/src/util/virhostcpu.c b/src/util/virhostcpu.c
index c00a393def4085c76de3f0ad4a27c61d7bfd1690..28f032b9728c517b6f36b6b10a3603b71c98e757 100644 (file)
--- a/src/util/virhostcpu.c
+++ b/src/util/virhostcpu.c
@@ -268,8 +268,7 @@ virHostCPUGetSiblingsList(unsigned int cpu)
     if (rv == -2) {
         /* If the file doesn't exist, the threadis its only sibling */
         ret = virBitmapNew(cpu + 1);
-        if (ret)
-            ignore_value(virBitmapSetBit(ret, cpu));
+        ignore_value(virBitmapSetBit(ret, cpu));
     }
 
     return ret;
@@ -332,8 +331,7 @@ virHostCPUParseNode(const char *node,
         goto cleanup;
 
     /* Keep track of the CPUs that belong to the current node */
-    if (!(node_cpus_map = virBitmapNew(npresent_cpus)))
-        goto cleanup;
+    node_cpus_map = virBitmapNew(npresent_cpus);
 
     /* enumerate sockets in the node */
     sockets_map = virBitmapNew(0);
@@ -1119,9 +1117,7 @@ virHostCPUGetAvailableCPUsBitmap(void)
         if ((hostcpus = virHostCPUGetCount()) < 0)
             return NULL;
 
-        if (!(bitmap = virBitmapNew(hostcpus)))
-            return NULL;
-
+        bitmap = virBitmapNew(hostcpus);
         virBitmapSetAll(bitmap);
     }
 

diff --git a/src/util/virnetdev.c b/src/util/virnetdev.c
index c43823c7471234f168da7a0247521daeae5cfab1..76aeeba22a42cbe14d42ceae9f99e4a85f82d297 100644 (file)
--- a/src/util/virnetdev.c
+++ b/src/util/virnetdev.c
@@ -3331,8 +3331,7 @@ virNetDevGetFeatures(const char *ifname,
     struct ifreq ifr;
     VIR_AUTOCLOSE fd = -1;
 
-    if (!(*out = virBitmapNew(VIR_NET_DEV_FEAT_LAST)))
-        return -1;
+    *out = virBitmapNew(VIR_NET_DEV_FEAT_LAST);
 
     if ((fd = virNetDevSetupControl(ifname, &ifr)) < 0)
         return -1;

diff --git a/src/util/virnuma.c b/src/util/virnuma.c
index 5a1218cdf208b6861d7717fffe99c33f00920e6f..6728f62a87df079c5b1a4c711ff15abb97905168 100644 (file)
--- a/src/util/virnuma.c
+++ b/src/util/virnuma.c
@@ -273,8 +273,7 @@ virNumaGetNodeCPUs(int node,
         return -2;
     }
 
-    if (!(cpumap = virBitmapNew(max_n_cpus)))
-        return -1;
+    cpumap = virBitmapNew(max_n_cpus);
 
     for (i = 0; i < max_n_cpus; i++) {
         if (MASK_CPU_ISSET(mask, i)) {
@@ -1027,8 +1026,7 @@ virNumaGetHostMemoryNodeset(void)
     if (maxnode < 0)
         return NULL;
 
-    if (!(nodeset = virBitmapNew(maxnode + 1)))
-        return NULL;
+    nodeset = virBitmapNew(maxnode + 1);
 
     for (i = 0; i <= maxnode; i++) {
         if (!virNumaNodeIsAvailable(i))

diff --git a/src/util/virportallocator.c b/src/util/virportallocator.c
index 2d34b617a681d52cc9665a281d55faf2395a0e8f..f4507403182619e3565eb9a528ebae8a2672c4ec 100644 (file)
--- a/src/util/virportallocator.c
+++ b/src/util/virportallocator.c
@@ -70,13 +70,9 @@ virPortAllocatorNew(void)
     if (!(pa = virObjectLockableNew(virPortAllocatorClass)))
         return NULL;
 
-    if (!(pa->bitmap = virBitmapNew(VIR_PORT_ALLOCATOR_NUM_PORTS)))
-        goto error;
+    pa->bitmap = virBitmapNew(VIR_PORT_ALLOCATOR_NUM_PORTS);
 
     return pa;
- error:
-    virObjectUnref(pa);
-    return NULL;
 }
 
 static int

diff --git a/src/util/virprocess.c b/src/util/virprocess.c
index e9df56389621819c1e50325fcf3aaa73c5831856..d379f7446fe05fac5bc0d24d678683acdbc7f6f7 100644 (file)
--- a/src/util/virprocess.c
+++ b/src/util/virprocess.c
@@ -520,8 +520,7 @@ virProcessGetAffinity(pid_t pid)
         goto cleanup;
     }
 
-    if (!(ret = virBitmapNew(ncpus)))
-          goto cleanup;
+    ret = virBitmapNew(ncpus);
 
     for (i = 0; i < ncpus; i++) {
          /* coverity[overrun-local] */
@@ -580,8 +579,7 @@ virProcessGetAffinity(pid_t pid)
         return NULL;
     }
 
-    if (!(ret = virBitmapNew(sizeof(mask) * 8)))
-        return NULL;
+    ret = virBitmapNew(sizeof(mask) * 8);
 
     for (i = 0; i < sizeof(mask) * 8; i++)
         if (CPU_ISSET(i, &mask))

diff --git a/src/util/virresctrl.c b/src/util/virresctrl.c
index 2d945ff93433bdbe4acb16fb0213f0e5d48b26f1..dabfa9990e60cd92f34be6125d6673462396851d 100644 (file)
--- a/src/util/virresctrl.c
+++ b/src/util/virresctrl.c
@@ -1157,13 +1157,9 @@ virResctrlAllocUpdateMask(virResctrlAllocPtr alloc,
                      cache - a_type->nmasks + 1) < 0)
         return -1;
 
-    if (!a_type->masks[cache]) {
+    if (!a_type->masks[cache])
         a_type->masks[cache] = virBitmapNew(virBitmapSize(mask));
 
-        if (!a_type->masks[cache])
-            return -1;
-    }
-
     return virBitmapCopy(a_type->masks[cache], mask);
 }
 
@@ -1874,8 +1870,6 @@ virResctrlAllocNewFromInfo(virResctrlInfoPtr info)
 
             virBitmapFree(mask);
             mask = virBitmapNew(i_type->bits);
-            if (!mask)
-                goto error;
             virBitmapSetAll(mask);
 
             for (k = 0; k <= i_type->max_cache_id; k++) {
@@ -2102,8 +2096,6 @@ virResctrlAllocFindUnused(virResctrlAllocPtr alloc,
     }
 
     a_mask = virBitmapNew(i_type->bits);
-    if (!a_mask)
-        return -1;
 
     for (i = last_pos; i < last_pos + need_bits; i++)
         ignore_value(virBitmapSetBit(a_mask, i));

diff --git a/src/util/virstoragefile.c b/src/util/virstoragefile.c
index 229de149351e0a44e914e11f6ec2aeb4f6c433f1..a669b4ca9947533ebf68696d307d660e5288c57e 100644 (file)
--- a/src/util/virstoragefile.c
+++ b/src/util/virstoragefile.c
@@ -852,8 +852,7 @@ qcow2GetFeatures(virBitmapPtr *features,
     if (len < QCOW2v3_HDR_SIZE)
         return -1;
 
-    if (!(feat = virBitmapNew(VIR_STORAGE_FILE_FEATURE_LAST)))
-        return -1;
+    feat = virBitmapNew(VIR_STORAGE_FILE_FEATURE_LAST);
 
     /* todo: check for incompatible or autoclear features? */
     bits = virReadBufInt64BE(buf + QCOW2v3_HDR_FEATURES_COMPATIBLE);

diff --git a/src/vmx/vmx.c b/src/vmx/vmx.c
index 0e8a690d0d39b92d97108ad8e53f20b1865776b9..e0777a9ddd280105e967f73dcbc37d99e9c343af 100644 (file)
--- a/src/vmx/vmx.c
+++ b/src/vmx/vmx.c
@@ -1507,8 +1507,6 @@ virVMXParseConfig(virVMXContext *ctx,
         size_t naffs;
 
         def->cpumask = virBitmapNew(VIR_DOMAIN_CPUMASK_LEN);
-        if (!def->cpumask)
-            goto cleanup;
 
         if (!(afflist = virStringSplitCount(sched_cpu_affinity, ",", 0, &naffs)))
             goto cleanup;

diff --git a/src/vz/vz_sdk.c b/src/vz/vz_sdk.c
index c6ed9bf9ce5defdfb7d99ffb58fa35e4d6d18c30..78779746286c2565bbd793aeabcfca39d0e0ed7d 100644 (file)
--- a/src/vz/vz_sdk.c
+++ b/src/vz/vz_sdk.c
@@ -1464,8 +1464,7 @@ prlsdkConvertCpuInfo(PRL_HANDLE sdkdom,
         return -1;
 
     if (strlen(buf) == 0) {
-        if (!(def->cpumask = virBitmapNew(hostcpus)))
-            return -1;
+        def->cpumask = virBitmapNew(hostcpus);
         virBitmapSetAll(def->cpumask);
     } else {
         if (virBitmapParse(buf, &def->cpumask, hostcpus) < 0)

diff --git a/tests/qemumonitorjsontest.c b/tests/qemumonitorjsontest.c
index a0dcbba07b4d41e548561506e0cc01cc18eab590..3973c762f0b155de270b76a96dd2bcb9fa99afef 100644 (file)
--- a/tests/qemumonitorjsontest.c
+++ b/tests/qemumonitorjsontest.c
@@ -2252,9 +2252,6 @@ testQemuMonitorJSONqemuMonitorJSONGetMigrationCapabilities(const void *opaque)
     }
 
     bitmap = virBitmapNew(QEMU_MIGRATION_CAP_LAST);
-    if (!bitmap)
-        goto cleanup;
-
     ignore_value(virBitmapSetBit(bitmap, QEMU_MIGRATION_CAP_XBZRLE));
     if (!(json = qemuMigrationCapsToJSON(bitmap, bitmap)))
         goto cleanup;

diff --git a/tests/testutils.c b/tests/testutils.c
index b747f65eea5817c93eb5cb1bc186c6d969393b14..2e586e98bf00ef35eaf4b479dbd31f1e25a23be7 100644 (file)
--- a/tests/testutils.c
+++ b/tests/testutils.c
@@ -832,8 +832,7 @@ int virTestMain(int argc,
         }
     }
 
-    if (!(failedTests = virBitmapNew(1)))
-        return EXIT_FAILURE;
+    failedTests = virBitmapNew(1);
 
     ret = (func)();
 
@@ -980,9 +979,7 @@ virTestCapsBuildNUMATopology(int seq)
             cell_cpus[core_id].id = id + core_id;
             cell_cpus[core_id].socket_id = cell_id + seq;
             cell_cpus[core_id].core_id = id + core_id;
-            if (!(cell_cpus[core_id].siblings =
-                  virBitmapNew(MAX_CPUS_IN_CELL)))
-                goto error;
+            cell_cpus[core_id].siblings = virBitmapNew(MAX_CPUS_IN_CELL);
             ignore_value(virBitmapSetBit(cell_cpus[core_id].siblings, id));
         }
         id++;
@@ -997,10 +994,6 @@ virTestCapsBuildNUMATopology(int seq)
     }
 
     return g_steal_pointer(&caps);
-
- error:
-    VIR_FREE(cell_cpus);
-    return NULL;
 }
 
 static virDomainDefParserConfig virTestGenericDomainDefParserConfig = {

diff --git a/tests/virbitmaptest.c b/tests/virbitmaptest.c
index efdce51c3bff103aab0eebd2001e4e2226dccc79..77a58f0176407dc9e65b41de2630960dcac39314 100644 (file)
--- a/tests/virbitmaptest.c
+++ b/tests/virbitmaptest.c
@@ -61,8 +61,7 @@ test1(const void *data G_GNUC_UNUSED)
 
     size = 1024;
     bit = 100;
-    if (!(bitmap = virBitmapNew(size)))
-        return -1;
+    bitmap = virBitmapNew(size);
 
     if (virBitmapSetBit(bitmap, bit) < 0)
         return -1;
@@ -165,8 +164,7 @@ test3(const void *data G_GNUC_UNUSED)
     int size = 5;
     size_t i;
 
-    if ((bitmap = virBitmapNew(size)) == NULL)
-        return -1;
+    bitmap = virBitmapNew(size);
 
     for (i = 0; i < size; i++)
         ignore_value(virBitmapSetBit(bitmap, i));
@@ -214,8 +212,6 @@ test4b(const void *data G_GNUC_UNUSED)
     /* 1. zero set */
 
     bitmap = virBitmapNew(size);
-    if (!bitmap)
-        return -1;
 
     if (virBitmapNextSetBit(bitmap, -1) != -1)
         return -1;
@@ -375,8 +371,6 @@ test6(const void *v G_GNUC_UNUSED)
     int size = 64;
 
     bitmap = virBitmapNew(size);
-    if (!bitmap)
-        return -1;
 
     if (checkBitmap(bitmap, "", -1) < 0)
         return -1;
@@ -425,8 +419,6 @@ test7(const void *v G_GNUC_UNUSED)
 
     for (i = 0; i < nmaxBit; i++) {
         g_autoptr(virBitmap) bitmap = virBitmapNew(maxBit[i]);
-        if (!bitmap)
-            return -1;
 
         if (virBitmapIsAllSet(bitmap))
             return -1;

diff --git a/tools/virsh-domain.c b/tools/virsh-domain.c
index dfcba046820e24d77a13a4e2c33703c2df992895..b5e7d8f70552ae67654830629a8a87da14affc46 100644 (file)
--- a/tools/virsh-domain.c
+++ b/tools/virsh-domain.c
@@ -6840,8 +6840,7 @@ virshDomainGetVcpuBitmap(vshControl *ctl,
     if (curvcpus == 0)
         curvcpus = maxvcpus;
 
-    if (!(ret = virBitmapNew(maxvcpus)))
-        goto cleanup;
+    ret = virBitmapNew(maxvcpus);
 
     if ((nnodes = virXPathNodeSet("/domain/vcpus/vcpu", ctxt, &nodes)) <= 0) {
         /* if the specific vcpu state is missing provide a fallback */
@@ -7118,8 +7117,7 @@ virshParseCPUList(vshControl *ctl, int *cpumaplen,
     virBitmapPtr map = NULL;
 
     if (cpulist[0] == 'r') {
-        if (!(map = virBitmapNew(maxcpu)))
-            return NULL;
+        map = virBitmapNew(maxcpu);
         virBitmapSetAll(map);
     } else {
         int lastcpu;
@@ -11989,8 +11987,7 @@ virshNodeIsSuperset(xmlNodePtr n1, xmlNodePtr n2)
     if (n1_child_size == 0 && n2_child_size == 0)
         return true;
 
-    if (!(bitmap = virBitmapNew(n1_child_size)))
-        return false;
+    bitmap = virBitmapNew(n1_child_size);
 
     child2 = n2->children;
     while (child2) {