Prefer the GLib version of the macro.
Signed-off-by: Ján Tomko <jtomko@redhat.com>
Reviewed-by: Michal Privoznik <mprivozn@redhat.com>
halt='use GLib macros: G_GNUC_<ATTRIBUTE_SUFFIX> for most' \
$(_sc_search_regexp)
+sc_prohibit_non_glib_macros:
+ @prohibit='ARRAY_CARDINALITY' \
+ in_vc_files='\.[ch]$$' \
+ halt='use GLib macros: G_N_ELEMENTS' \
+ $(_sc_search_regexp)
+
sc_prohibit_int_index:
@prohibit='\<(int|unsigned)\s*\*?index\>(\s|,|;)' \
halt='use different name than 'index' for declaration' \
static virAccessDriverPtr virAccessManagerFindDriver(const char *name)
{
size_t i;
- for (i = 0; i < ARRAY_CARDINALITY(accessDrivers); i++) {
+ for (i = 0; i < G_N_ELEMENTS(accessDrivers); i++) {
if (STREQ(name, accessDrivers[i]->name))
return accessDrivers[i];
}
#define VIR_DOMAIN_CAPS_ENUM_SET(capsEnum, ...) \
do { \
unsigned int __values[] = {__VA_ARGS__}; \
- size_t __nvalues = ARRAY_CARDINALITY(__values); \
+ size_t __nvalues = G_N_ELEMENTS(__values); \
virDomainCapsEnumSet(&(capsEnum), #capsEnum, \
__nvalues, __values); \
} while (0)
if (!model)
return 0;
- for (i = 0; i < ARRAY_CARDINALITY(virDomainNetModelTypeList); i++) {
+ for (i = 0; i < G_N_ELEMENTS(virDomainNetModelTypeList); i++) {
if (STRCASEEQ(virDomainNetModelTypeList[i], model)) {
net->model = i;
return 0;
virStoragePoolTypeInfoLookup(int type)
{
size_t i;
- for (i = 0; i < ARRAY_CARDINALITY(poolTypeInfo); i++)
+ for (i = 0; i < G_N_ELEMENTS(poolTypeInfo); i++)
if (poolTypeInfo[i].poolType == type)
return &poolTypeInfo[i];
};
size_t i;
- for (i = 0; i < ARRAY_CARDINALITY(map); i++) {
+ for (i = 0; i < G_N_ELEMENTS(map); i++) {
if (flags & map[i].snap_flag) {
flags &= ~map[i].snap_flag;
moment_flags |= map[i].moment_flag;
return NULL;
}
- for (i = 0; i < ARRAY_CARDINALITY(drivers); i++) {
+ for (i = 0; i < G_N_ELEMENTS(drivers); i++) {
for (j = 0; j < drivers[i]->narch; j++) {
if (arch == drivers[i]->arch[j])
return drivers[i];
{
size_t i;
- for (i = 0; i < ARRAY_CARDINALITY(drivers); i++) {
+ for (i = 0; i < G_N_ELEMENTS(drivers); i++) {
if (STREQ_NULLABLE(name, drivers[i]->name))
return drivers[i];
}
struct cpuArchDriver cpuDriverArm = {
.name = "arm",
.arch = archs,
- .narch = ARRAY_CARDINALITY(archs),
+ .narch = G_N_ELEMENTS(archs),
.compare = virCPUarmCompare,
.decode = NULL,
.encode = NULL,
if (cpu->arch != VIR_ARCH_NONE) {
bool found = false;
- for (i = 0; i < ARRAY_CARDINALITY(archs); i++) {
+ for (i = 0; i < G_N_ELEMENTS(archs); i++) {
if (archs[i] == cpu->arch) {
found = true;
break;
struct cpuArchDriver cpuDriverPPC64 = {
.name = "ppc64",
.arch = archs,
- .narch = ARRAY_CARDINALITY(archs),
+ .narch = G_N_ELEMENTS(archs),
.compare = virCPUppc64Compare,
.decode = ppc64DriverDecode,
.encode = NULL,
struct cpuArchDriver cpuDriverS390 = {
.name = "s390",
.arch = archs,
- .narch = ARRAY_CARDINALITY(archs),
+ .narch = G_N_ELEMENTS(archs),
.compare = virCPUs390Compare,
.decode = NULL,
.encode = NULL,
{ \
.name = (char *) Name, \
.data = { \
- .len = ARRAY_CARDINALITY(Name ## _data), \
+ .len = G_N_ELEMENTS(Name ## _data), \
.items = Name ## _data, \
} \
}
x86FeatureFindInternal(const char *name)
{
size_t i;
- size_t count = ARRAY_CARDINALITY(x86_kvm_features);
+ size_t count = G_N_ELEMENTS(x86_kvm_features);
for (i = 0; i < count; i++) {
if (STREQ(x86_kvm_features[i].name, name))
if (cpu->arch != VIR_ARCH_NONE) {
bool found = false;
- for (i = 0; i < ARRAY_CARDINALITY(archs); i++) {
+ for (i = 0; i < G_N_ELEMENTS(archs); i++) {
if (archs[i] == cpu->arch) {
found = true;
break;
struct cpuArchDriver cpuDriverX86 = {
.name = "x86",
.arch = archs,
- .narch = ARRAY_CARDINALITY(archs),
+ .narch = G_N_ELEMENTS(archs),
.compare = virCPUx86Compare,
.decode = x86DecodeCPUData,
.encode = x86Encode,
if (item->handle)
curl_share_cleanup(item->handle);
- for (i = 0; i < ARRAY_CARDINALITY(item->locks); ++i)
+ for (i = 0; i < G_N_ELEMENTS(item->locks); ++i)
virMutexDestroy(&item->locks[i]);
})
curl_share_setopt(shared->handle, CURLSHOPT_SHARE,
CURL_LOCK_DATA_DNS);
- for (i = 0; i < ARRAY_CARDINALITY(shared->locks); ++i) {
+ for (i = 0; i < G_N_ELEMENTS(shared->locks); ++i) {
if (virMutexInit(&shared->locks[i]) < 0) {
virReportError(VIR_ERR_INTERNAL_ERROR, "%s",
_("Could not initialize a CURL (share) mutex"));
((a) ? !(b) || STRNEQ((a), (b)) : !!(b))
#define NUL_TERMINATE(buf) do { (buf)[sizeof(buf)-1] = '\0'; } while (0)
-#define ARRAY_CARDINALITY(Array) (sizeof(Array) / sizeof(*(Array)))
/**
* G_GNUC_NO_INLINE:
unsigned long long bandwidth = 0;
if (!virTypedParamsCheck(params, nparams, compatParams,
- ARRAY_CARDINALITY(compatParams))) {
+ G_N_ELEMENTS(compatParams))) {
virReportError(VIR_ERR_ARGUMENT_UNSUPPORTED, "%s",
_("Some parameters are not supported by migration "
"protocol 2"));
unsigned long long bandwidth = 0;
if (!virTypedParamsCheck(params, nparams, compatParams,
- ARRAY_CARDINALITY(compatParams))) {
+ G_N_ELEMENTS(compatParams))) {
virReportError(VIR_ERR_ARGUMENT_UNSUPPORTED, "%s",
_("Some parameters are not supported by migration "
"protocol 3"));
}
if (!virTypedParamsCheck(params, nparams, compatParams,
- ARRAY_CARDINALITY(compatParams))) {
+ G_N_ELEMENTS(compatParams))) {
virReportError(VIR_ERR_ARGUMENT_UNSUPPORTED, "%s",
_("Migration APIs with extensible parameters are not "
"supported but extended parameters were passed"));
* Example how to use this API:
*
* unsigned int pages[] = { 4, 2048, 1048576}
- * unsigned int npages = ARRAY_CARDINALITY(pages);
+ * unsigned int npages = G_N_ELEMENTS(pages);
* int startcell = 0;
* unsigned int cellcount = 2;
*
if (!(cpudata = virCPUDataNew(cpu->arch)))
goto error;
- ncaps = ARRAY_CARDINALITY(cpuid);
+ ncaps = G_N_ELEMENTS(cpuid);
if (libxlCapsAddCPUID(cpudata, cpuid, ncaps) < 0)
goto error;
- ncaps = ARRAY_CARDINALITY(cpuid_ver1);
+ ncaps = G_N_ELEMENTS(cpuid_ver1);
if (version > LIBXL_HWCAP_V0 &&
libxlCapsAddCPUID(cpudata, cpuid_ver1, ncaps) < 0)
goto error;
}
/* Too many arch flavours - highly unlikely ! */
- if (i >= ARRAY_CARDINALITY(guest_archs))
+ if (i >= G_N_ELEMENTS(guest_archs))
continue;
/* Didn't find a match, so create a new one */
if (i == nr_guest_archs)
#ifdef HAVE_XEN_PVH
if (hvm && i == nr_guest_archs-1) {
/* Ensure we have not exhausted the guest_archs array */
- if (nr_guest_archs >= ARRAY_CARDINALITY(guest_archs))
+ if (nr_guest_archs >= G_N_ELEMENTS(guest_archs))
continue;
i = nr_guest_archs;
nr_guest_archs++;
fmt = id = -1;
/* Find any disk prefixes we know about */
- for (i = 0; i < ARRAY_CARDINALITY(drive_prefix); i++) {
+ for (i = 0; i < G_N_ELEMENTS(drive_prefix); i++) {
if (STRPREFIX(virtpath, drive_prefix[i]) &&
!virDiskNameParse(virtpath, &disk, &partition)) {
fmt = i;
fds[0].events = POLLIN;
fds[0].revents = 0;
- ret = poll(fds, ARRAY_CARDINALITY(fds), timeout);
+ ret = poll(fds, G_N_ELEMENTS(fds), timeout);
if (ret < 0) {
if (errno == EAGAIN || errno == EINTR)
continue;
static virConnectAuth virConnectAuthConfig = {
.credtype = virConnectCredType,
- .ncredtype = ARRAY_CARDINALITY(virConnectCredType),
+ .ncredtype = G_N_ELEMENTS(virConnectCredType),
};
/* On P2P mode there is only the Perform3 phase and we need to handle
};
size_t i;
- for (i = 0; i < ARRAY_CARDINALITY(translation_table); i++)
+ for (i = 0; i < G_N_ELEMENTS(translation_table); i++)
if (STREQ(translation_table[i][from_libxl], feature_name))
return translation_table[i][!from_libxl];
return feature_name;
.value = { .str = lease->lockspace },
},
};
- size_t nparams = ARRAY_CARDINALITY(lparams);
+ size_t nparams = G_N_ELEMENTS(lparams);
if (!lease->lockspace)
nparams--;
if (!(lock = virLockManagerNew(virLockManagerPluginGetDriver(plugin),
VIR_LOCK_MANAGER_OBJECT_TYPE_DOMAIN,
- ARRAY_CARDINALITY(params),
+ G_N_ELEMENTS(params),
params,
flags)))
goto error;
}
if (!(lockd->dmn = virNetDaemonNewPostExecRestart(child,
- ARRAY_CARDINALITY(serverNames),
+ G_N_ELEMENTS(serverNames),
serverNames,
virLockDaemonNewServerPostExecRestart,
(void*)(intptr_t)(privileged ? 0x1 : 0x0))))
}
if (virSystemdGetActivation(actmap,
- ARRAY_CARDINALITY(actmap),
+ G_N_ELEMENTS(actmap),
&act) < 0) {
ret = VIR_LOCK_DAEMON_ERR_NETWORK;
goto cleanup;
};
virConnectAuth auth = {
.credtype = authTypes,
- .ncredtype = ARRAY_CARDINALITY(authTypes),
+ .ncredtype = G_N_ELEMENTS(authTypes),
.cb = authCallback,
};
}
if (!(logd->dmn = virNetDaemonNewPostExecRestart(child,
- ARRAY_CARDINALITY(serverNames),
+ G_N_ELEMENTS(serverNames),
serverNames,
virLogDaemonNewServerPostExecRestart,
(void*)(intptr_t)(privileged ? 0x1 : 0x0))))
}
if (virSystemdGetActivation(actmap,
- ARRAY_CARDINALITY(actmap),
+ G_N_ELEMENTS(actmap),
&act) < 0) {
ret = VIR_LOG_DAEMON_ERR_NETWORK;
goto cleanup;
{
size_t i;
- for (i = 0; i < ARRAY_CARDINALITY(lxcBasicMounts); i++) {
+ for (i = 0; i < G_N_ELEMENTS(lxcBasicMounts); i++) {
if (STREQ(path, lxcBasicMounts[i].dst))
return true;
}
VIR_DEBUG("Mounting basic filesystems");
- for (i = 0; i < ARRAY_CARDINALITY(lxcBasicMounts); i++) {
+ for (i = 0; i < G_N_ELEMENTS(lxcBasicMounts); i++) {
bool bindOverReadonly;
virLXCBasicMountInfo const *mnt = &lxcBasicMounts[i];
{ "/proc/self/fd", "/dev/fd" },
};
- for (i = 0; i < ARRAY_CARDINALITY(links); i++) {
+ for (i = 0; i < G_N_ELEMENTS(links); i++) {
if (symlink(links[i].src, links[i].dst) < 0) {
virReportSystemError(errno,
_("Failed to symlink device %s to %s"),
goto cleanup;
/* Populate /dev/ with a few important bits */
- for (i = 0; i < ARRAY_CARDINALITY(devs); i++) {
+ for (i = 0; i < G_N_ELEMENTS(devs); i++) {
if (virAsprintf(&path, "/%s/%s.dev/%s",
LXC_STATE_DIR, ctrl->def->name, devs[i].path) < 0)
goto cleanup;
if (!(mon->program = virNetClientProgramNew(VIR_LXC_MONITOR_PROGRAM,
VIR_LXC_MONITOR_PROGRAM_VERSION,
virLXCMonitorEvents,
- ARRAY_CARDINALITY(virLXCMonitorEvents),
+ G_N_ELEMENTS(virLXCMonitorEvents),
mon)))
goto error;
{
caps_tbl_entry *entry;
- entry = bsearch(&cap_name, caps_tbl, ARRAY_CARDINALITY(caps_tbl),
+ entry = bsearch(&cap_name, caps_tbl, G_N_ELEMENTS(caps_tbl),
sizeof(caps_tbl[0]), cmpstringp);
if (entry) {
DBusError err;
/* Ensure caps_tbl is sorted by capability name */
- qsort(caps_tbl, ARRAY_CARDINALITY(caps_tbl), sizeof(caps_tbl[0]),
+ qsort(caps_tbl, G_N_ELEMENTS(caps_tbl), sizeof(caps_tbl[0]),
cmpstringp);
if (VIR_ALLOC(driver) < 0)
{
size_t i;
- for (i = 0; i < ARRAY_CARDINALITY(subsystem_blacklist); i++) {
+ for (i = 0; i < G_N_ELEMENTS(subsystem_blacklist); i++) {
const char *s = subsystem_blacklist[i];
if (udev_enumerate_add_nomatch_subsystem(udev_enumerate, s) < 0) {
virReportSystemError(errno, "%s", _("failed to add susbsystem filter"));
virNWFilterSnoopReqLock(req);
if (req->binding->portdevname && req->threadkey) {
- for (i = 0; i < ARRAY_CARDINALITY(pcapConf); i++) {
+ for (i = 0; i < G_N_ELEMENTS(pcapConf); i++) {
pcapConf[i].handle =
virNWFilterSnoopDHCPOpen(req->binding->portdevname,
&req->binding->mac,
while (!error) {
if (virNWFilterSnoopAdjustPoll(pcapConf,
- ARRAY_CARDINALITY(pcapConf),
+ G_N_ELEMENTS(pcapConf),
fds, &pollTo) < 0) {
break;
}
if (pollTo < 0 || pollTo > SNOOP_POLL_MAX_TIMEOUT_MS)
pollTo = SNOOP_POLL_MAX_TIMEOUT_MS;
- n = poll(fds, ARRAY_CARDINALITY(fds), pollTo);
+ n = poll(fds, G_N_ELEMENTS(fds), pollTo);
if (n < 0) {
if (errno != EAGAIN && errno != EINTR)
req->jobCompletionStatus != 0)
goto exit;
- for (i = 0; n > 0 && i < ARRAY_CARDINALITY(fds); i++) {
+ for (i = 0; n > 0 && i < G_N_ELEMENTS(fds); i++) {
if (!fds[i].revents)
continue;
VIR_FREE(threadkey);
- for (i = 0; i < ARRAY_CARDINALITY(pcapConf); i++) {
+ for (i = 0; i < G_N_ELEMENTS(pcapConf); i++) {
if (pcapConf[i].handle)
pcap_close(pcapConf[i].handle);
}
pcap_freecode(&fp);
while (req->status == 0 && vmaddr == 0) {
- int n = poll(fds, ARRAY_CARDINALITY(fds), PKT_TIMEOUT_MS);
+ int n = poll(fds, G_N_ELEMENTS(fds), PKT_TIMEOUT_MS);
if (threadsTerminate || req->terminate) {
req->status = ECANCELED;
if (dir & LIBSSH2_SESSION_BLOCK_OUTBOUND)
fds[0].events |= POLLOUT;
- return poll(fds, ARRAY_CARDINALITY(fds), -1);
+ return poll(fds, G_N_ELEMENTS(fds), -1);
}
/* this function is the layer that manipulates the ssh channel itself
}
/*
- for (i = 0; i < ARRAY_CARDINALITY(eventHandlers); i++) {
+ for (i = 0; i < G_N_ELEMENTS(eventHandlers); i++) {
if (STREQ(eventHandlers[i].type, type)) {
virJSONValuePtr data = virJSONValueObjectGet(obj, "data");
VIR_DEBUG("handle %s handler=%p data=%p", type,
static virQEMUCapsObjectTypeProps virQEMUCapsDeviceProps[] = {
{ "virtio-blk-pci", virQEMUCapsDevicePropsVirtioBlk,
- ARRAY_CARDINALITY(virQEMUCapsDevicePropsVirtioBlk),
+ G_N_ELEMENTS(virQEMUCapsDevicePropsVirtioBlk),
-1 },
{ "virtio-net-pci", virQEMUCapsDevicePropsVirtioNet,
- ARRAY_CARDINALITY(virQEMUCapsDevicePropsVirtioNet),
+ G_N_ELEMENTS(virQEMUCapsDevicePropsVirtioNet),
QEMU_CAPS_DEVICE_VIRTIO_NET },
{ "virtio-scsi-pci", virQEMUCapsDevicePropsVirtioSCSI,
- ARRAY_CARDINALITY(virQEMUCapsDevicePropsVirtioSCSI),
+ G_N_ELEMENTS(virQEMUCapsDevicePropsVirtioSCSI),
QEMU_CAPS_VIRTIO_SCSI },
{ "virtio-blk-ccw", virQEMUCapsDevicePropsVirtioBlk,
- ARRAY_CARDINALITY(virQEMUCapsDevicePropsVirtioBlk),
+ G_N_ELEMENTS(virQEMUCapsDevicePropsVirtioBlk),
QEMU_CAPS_VIRTIO_CCW },
{ "virtio-net-ccw", virQEMUCapsDevicePropsVirtioNet,
- ARRAY_CARDINALITY(virQEMUCapsDevicePropsVirtioNet),
+ G_N_ELEMENTS(virQEMUCapsDevicePropsVirtioNet),
QEMU_CAPS_DEVICE_VIRTIO_NET },
{ "virtio-scsi-ccw", virQEMUCapsDevicePropsVirtioSCSI,
- ARRAY_CARDINALITY(virQEMUCapsDevicePropsVirtioSCSI),
+ G_N_ELEMENTS(virQEMUCapsDevicePropsVirtioSCSI),
QEMU_CAPS_VIRTIO_SCSI },
{ "virtio-blk-s390", virQEMUCapsDevicePropsVirtioBlk,
- ARRAY_CARDINALITY(virQEMUCapsDevicePropsVirtioBlk),
+ G_N_ELEMENTS(virQEMUCapsDevicePropsVirtioBlk),
QEMU_CAPS_VIRTIO_S390 },
{ "virtio-net-s390", virQEMUCapsDevicePropsVirtioNet,
- ARRAY_CARDINALITY(virQEMUCapsDevicePropsVirtioNet),
+ G_N_ELEMENTS(virQEMUCapsDevicePropsVirtioNet),
QEMU_CAPS_DEVICE_VIRTIO_NET },
{ "vfio-pci", virQEMUCapsDevicePropsVfioPCI,
- ARRAY_CARDINALITY(virQEMUCapsDevicePropsVfioPCI),
+ G_N_ELEMENTS(virQEMUCapsDevicePropsVfioPCI),
QEMU_CAPS_DEVICE_VFIO_PCI },
{ "scsi-hd", virQEMUCapsDevicePropsSCSIDisk,
- ARRAY_CARDINALITY(virQEMUCapsDevicePropsSCSIDisk),
+ G_N_ELEMENTS(virQEMUCapsDevicePropsSCSIDisk),
-1 },
{ "ide-hd", virQEMUCapsDevicePropsIDEDrive,
- ARRAY_CARDINALITY(virQEMUCapsDevicePropsIDEDrive),
+ G_N_ELEMENTS(virQEMUCapsDevicePropsIDEDrive),
-1 },
{ "PIIX4_PM", virQEMUCapsDevicePropsPiix4PM,
- ARRAY_CARDINALITY(virQEMUCapsDevicePropsPiix4PM),
+ G_N_ELEMENTS(virQEMUCapsDevicePropsPiix4PM),
-1 },
{ "usb-redir", virQEMUCapsDevicePropsUSBRedir,
- ARRAY_CARDINALITY(virQEMUCapsDevicePropsUSBRedir),
+ G_N_ELEMENTS(virQEMUCapsDevicePropsUSBRedir),
QEMU_CAPS_USB_REDIR },
{ "i440FX-pcihost", virQEMUCapsDevicePropsI440FXPCIHost,
- ARRAY_CARDINALITY(virQEMUCapsDevicePropsI440FXPCIHost),
+ G_N_ELEMENTS(virQEMUCapsDevicePropsI440FXPCIHost),
-1 },
{ "q35-pcihost", virQEMUCapsDevicePropsQ35PCIHost,
- ARRAY_CARDINALITY(virQEMUCapsDevicePropsQ35PCIHost),
+ G_N_ELEMENTS(virQEMUCapsDevicePropsQ35PCIHost),
-1 },
{ "usb-storage", virQEMUCapsDevicePropsUSBStorage,
- ARRAY_CARDINALITY(virQEMUCapsDevicePropsUSBStorage),
+ G_N_ELEMENTS(virQEMUCapsDevicePropsUSBStorage),
QEMU_CAPS_DEVICE_USB_STORAGE },
{ "kvm-pit", virQEMUCapsDevicePropsKVMPit,
- ARRAY_CARDINALITY(virQEMUCapsDevicePropsKVMPit),
+ G_N_ELEMENTS(virQEMUCapsDevicePropsKVMPit),
-1 },
{ "VGA", virQEMUCapsDevicePropsVGA,
- ARRAY_CARDINALITY(virQEMUCapsDevicePropsVGA),
+ G_N_ELEMENTS(virQEMUCapsDevicePropsVGA),
QEMU_CAPS_DEVICE_VGA },
{ "vmware-svga", virQEMUCapsDevicePropsVmwareSvga,
- ARRAY_CARDINALITY(virQEMUCapsDevicePropsVmwareSvga),
+ G_N_ELEMENTS(virQEMUCapsDevicePropsVmwareSvga),
QEMU_CAPS_DEVICE_VMWARE_SVGA },
{ "qxl", virQEMUCapsDevicePropsQxl,
- ARRAY_CARDINALITY(virQEMUCapsDevicePropsQxl),
+ G_N_ELEMENTS(virQEMUCapsDevicePropsQxl),
QEMU_CAPS_DEVICE_QXL },
{ "virtio-gpu-pci", virQEMUCapsDevicePropsVirtioGpu,
- ARRAY_CARDINALITY(virQEMUCapsDevicePropsVirtioGpu),
+ G_N_ELEMENTS(virQEMUCapsDevicePropsVirtioGpu),
QEMU_CAPS_DEVICE_VIRTIO_GPU },
{ "virtio-gpu-device", virQEMUCapsDevicePropsVirtioGpu,
- ARRAY_CARDINALITY(virQEMUCapsDevicePropsVirtioGpu),
+ G_N_ELEMENTS(virQEMUCapsDevicePropsVirtioGpu),
QEMU_CAPS_DEVICE_VIRTIO_GPU },
{ "ICH9-LPC", virQEMUCapsDevicePropsICH9,
- ARRAY_CARDINALITY(virQEMUCapsDevicePropsICH9),
+ G_N_ELEMENTS(virQEMUCapsDevicePropsICH9),
-1 },
{ "virtio-balloon-pci", virQEMUCapsDevicePropsVirtioBalloon,
- ARRAY_CARDINALITY(virQEMUCapsDevicePropsVirtioBalloon),
+ G_N_ELEMENTS(virQEMUCapsDevicePropsVirtioBalloon),
-1 },
{ "virtio-balloon-ccw", virQEMUCapsDevicePropsVirtioBalloon,
- ARRAY_CARDINALITY(virQEMUCapsDevicePropsVirtioBalloon),
+ G_N_ELEMENTS(virQEMUCapsDevicePropsVirtioBalloon),
-1 },
{ "virtio-balloon-device", virQEMUCapsDevicePropsVirtioBalloon,
- ARRAY_CARDINALITY(virQEMUCapsDevicePropsVirtioBalloon),
+ G_N_ELEMENTS(virQEMUCapsDevicePropsVirtioBalloon),
-1 },
{ "nec-usb-xhci", virQEMUCapsDevicePropsUSBNECXHCI,
- ARRAY_CARDINALITY(virQEMUCapsDevicePropsUSBNECXHCI),
+ G_N_ELEMENTS(virQEMUCapsDevicePropsUSBNECXHCI),
QEMU_CAPS_NEC_USB_XHCI },
{ "intel-iommu", virQEMUCapsDevicePropsIntelIOMMU,
- ARRAY_CARDINALITY(virQEMUCapsDevicePropsIntelIOMMU),
+ G_N_ELEMENTS(virQEMUCapsDevicePropsIntelIOMMU),
QEMU_CAPS_DEVICE_INTEL_IOMMU },
{ "spapr-pci-host-bridge", virQEMUCapsDevicePropsSpaprPCIHostBridge,
- ARRAY_CARDINALITY(virQEMUCapsDevicePropsSpaprPCIHostBridge),
+ G_N_ELEMENTS(virQEMUCapsDevicePropsSpaprPCIHostBridge),
QEMU_CAPS_DEVICE_SPAPR_PCI_HOST_BRIDGE },
{ "virtio-gpu-ccw", virQEMUCapsDevicePropsVirtioGpu,
- ARRAY_CARDINALITY(virQEMUCapsDevicePropsVirtioGpu),
+ G_N_ELEMENTS(virQEMUCapsDevicePropsVirtioGpu),
QEMU_CAPS_DEVICE_VIRTIO_GPU_CCW },
{ "virtual-css-bridge", virQEMUCapsObjectPropsVirtualCSSBridge,
- ARRAY_CARDINALITY(virQEMUCapsObjectPropsVirtualCSSBridge),
+ G_N_ELEMENTS(virQEMUCapsObjectPropsVirtualCSSBridge),
QEMU_CAPS_CCW },
{ "mch", virQEMUCapsDevicePropsMCH,
- ARRAY_CARDINALITY(virQEMUCapsDevicePropsMCH),
+ G_N_ELEMENTS(virQEMUCapsDevicePropsMCH),
QEMU_CAPS_DEVICE_MCH },
{ "nvdimm", virQEMUCapsDevicePropsNVDIMM,
- ARRAY_CARDINALITY(virQEMUCapsDevicePropsNVDIMM),
+ G_N_ELEMENTS(virQEMUCapsDevicePropsNVDIMM),
QEMU_CAPS_DEVICE_NVDIMM },
};
static virQEMUCapsObjectTypeProps virQEMUCapsObjectProps[] = {
{ "memory-backend-file", virQEMUCapsObjectPropsMemoryBackendFile,
- ARRAY_CARDINALITY(virQEMUCapsObjectPropsMemoryBackendFile),
+ G_N_ELEMENTS(virQEMUCapsObjectPropsMemoryBackendFile),
QEMU_CAPS_OBJECT_MEMORY_FILE },
{ "memory-backend-memfd", virQEMUCapsObjectPropsMemoryBackendMemfd,
- ARRAY_CARDINALITY(virQEMUCapsObjectPropsMemoryBackendMemfd),
+ G_N_ELEMENTS(virQEMUCapsObjectPropsMemoryBackendMemfd),
QEMU_CAPS_OBJECT_MEMORY_MEMFD },
{ "max-x86_64-cpu", virQEMUCapsObjectPropsMaxX86CPU,
- ARRAY_CARDINALITY(virQEMUCapsObjectPropsMaxX86CPU),
+ G_N_ELEMENTS(virQEMUCapsObjectPropsMaxX86CPU),
QEMU_CAPS_X86_MAX_CPU },
};
static virQEMUCapsObjectTypeProps virQEMUCapsMachineProps[] = {
{ "pseries", virQEMUCapsMachinePropsPSeries,
- ARRAY_CARDINALITY(virQEMUCapsMachinePropsPSeries),
+ G_N_ELEMENTS(virQEMUCapsMachinePropsPSeries),
-1 },
{ "virt", virQEMUCapsMachinePropsVirt,
- ARRAY_CARDINALITY(virQEMUCapsMachinePropsVirt),
+ G_N_ELEMENTS(virQEMUCapsMachinePropsVirt),
-1 },
};
return -1;
virQEMUCapsProcessStringFlags(qemuCaps,
- ARRAY_CARDINALITY(virQEMUCapsCommands),
+ G_N_ELEMENTS(virQEMUCapsCommands),
virQEMUCapsCommands,
ncommands, commands);
virStringListFreeCount(commands, ncommands);
return -1;
virQEMUCapsProcessStringFlags(qemuCaps,
- ARRAY_CARDINALITY(virQEMUCapsEvents),
+ G_N_ELEMENTS(virQEMUCapsEvents),
virQEMUCapsEvents,
nevents, events);
virStringListFreeCount(events, nevents);
if ((nvalues = qemuMonitorGetObjectTypes(mon, &values)) < 0)
return -1;
virQEMUCapsProcessStringFlags(qemuCaps,
- ARRAY_CARDINALITY(virQEMUCapsObjectTypes),
+ G_N_ELEMENTS(virQEMUCapsObjectTypes),
virQEMUCapsObjectTypes,
nvalues, values);
virStringListFreeCount(values, nvalues);
if (virQEMUCapsProbeQMPGenericProps(qemuCaps,
mon,
virQEMUCapsDeviceProps,
- ARRAY_CARDINALITY(virQEMUCapsDeviceProps),
+ G_N_ELEMENTS(virQEMUCapsDeviceProps),
qemuMonitorGetDeviceProps) < 0)
return -1;
virQEMUCapsProbeQMPGenericProps(qemuCaps,
mon,
virQEMUCapsObjectProps,
- ARRAY_CARDINALITY(virQEMUCapsObjectProps),
+ G_N_ELEMENTS(virQEMUCapsObjectProps),
qemuMonitorGetObjectProps) < 0)
return -1;
"sim", /* VIR_ARCH_XTENSA */
"sim", /* VIR_ARCH_XTENSAEB */
};
-verify(ARRAY_CARDINALITY(preferredMachines) == VIR_ARCH_LAST);
+verify(G_N_ELEMENTS(preferredMachines) == VIR_ARCH_LAST);
static int
if (!virQEMUCapsGet(qemuCaps, QEMU_CAPS_QOM_LIST_PROPERTIES))
return 0;
- for (i = 0; i < ARRAY_CARDINALITY(virQEMUCapsMachineProps); i++) {
+ for (i = 0; i < G_N_ELEMENTS(virQEMUCapsMachineProps); i++) {
virQEMUCapsObjectTypeProps props = virQEMUCapsMachineProps[i];
const char *canon = virQEMUCapsGetCanonicalMachine(qemuCaps, props.type);
VIR_AUTOFREE(char *) type = NULL;
return -1;
if (nentries > 0) {
- for (i = 0; i < ARRAY_CARDINALITY(virQEMUCapsTPMModelsToCaps); i++) {
+ for (i = 0; i < G_N_ELEMENTS(virQEMUCapsTPMModelsToCaps); i++) {
const char *needle = virDomainTPMModelTypeToString(
virQEMUCapsTPMModelsToCaps[i].type);
if (virStringListHasString((const char **)entries, needle))
return -1;
if (nentries > 0) {
- for (i = 0; i < ARRAY_CARDINALITY(virQEMUCapsTPMTypesToCaps); i++) {
+ for (i = 0; i < G_N_ELEMENTS(virQEMUCapsTPMTypesToCaps); i++) {
const char *needle = virDomainTPMBackendTypeToString(
virQEMUCapsTPMTypesToCaps[i].type);
if (virStringListHasString((const char **)entries, needle))
char **values;
size_t i, j;
- for (i = 0; i < ARRAY_CARDINALITY(virQEMUCapsCommandLine); i++) {
+ for (i = 0; i < G_N_ELEMENTS(virQEMUCapsCommandLine); i++) {
if ((nvalues = qemuMonitorGetCommandLineOptionParameters(mon,
virQEMUCapsCommandLine[i].option,
&values,
return -1;
virQEMUCapsProcessStringFlags(qemuCaps,
- ARRAY_CARDINALITY(virQEMUCapsMigration),
+ G_N_ELEMENTS(virQEMUCapsMigration),
virQEMUCapsMigration,
ncaps, caps);
virStringListFreeCount(caps, ncaps);
int rc;
size_t i;
- for (i = 0; i < ARRAY_CARDINALITY(kmod); i++) {
+ for (i = 0; i < G_N_ELEMENTS(kmod); i++) {
VIR_FREE(value);
rc = virFileReadValueString(&value, "/sys/module/%s/parameters/nested",
kmod[i]);
return -1;
schemareply = NULL;
- for (i = 0; i < ARRAY_CARDINALITY(virQEMUCapsQMPSchemaQueries); i++) {
+ for (i = 0; i < G_N_ELEMENTS(virQEMUCapsQMPSchemaQueries); i++) {
entry = virQEMUCapsQMPSchemaQueries + i;
if (virQEMUQAPISchemaPathExists(entry->value, schema))
}
/* probe also for basic event support */
- for (i = 0; i < ARRAY_CARDINALITY(virQEMUCapsEvents); i++) {
+ for (i = 0; i < G_N_ELEMENTS(virQEMUCapsEvents); i++) {
entry = virQEMUCapsEvents + i;
if (virQEMUQAPISchemaPathExists(entry->value, schema))
static const struct virQEMUCapsMachineTypeFilter virQEMUCapsMachineFilter[] = {
/* { "blah", virQEMUCapsMachineBLAHFilter,
- ARRAY_CARDINALITY(virQEMUCapsMachineBLAHFilter) }, */
+ G_N_ELEMENTS(virQEMUCapsMachineBLAHFilter) }, */
{ "", NULL, 0 },
};
if (!machineType)
return;
- for (i = 0; i < ARRAY_CARDINALITY(virQEMUCapsMachineFilter); i++) {
+ for (i = 0; i < G_N_ELEMENTS(virQEMUCapsMachineFilter); i++) {
const struct virQEMUCapsMachineTypeFilter *filter = &virQEMUCapsMachineFilter[i];
size_t j;
priv->microcodeVersion = virHostCPUGetMicrocodeVersion();
- for (i = 0; i < ARRAY_CARDINALITY(binaryFilters); i++) {
- for (j = 0; j < ARRAY_CARDINALITY(archs); j++) {
+ for (i = 0; i < G_N_ELEMENTS(binaryFilters); i++) {
+ for (j = 0; j < G_N_ELEMENTS(archs); j++) {
struct virQEMUCapsSearchData data = {
.arch = archs[j],
.binaryFilter = binaryFilters[i],
VIR_DOMAIN_CONTROLLER_TYPE_VIRTIO_SERIAL,
};
- for (i = 0; i < ARRAY_CARDINALITY(contOrder); i++) {
+ for (i = 0; i < G_N_ELEMENTS(contOrder); i++) {
if (qemuBuildControllersByTypeCommandLine(cmd, def, qemuCaps, contOrder[i]) < 0)
return -1;
}
VIR_STRDUP(sm->doi, doi) < 0)
return NULL;
- for (j = 0; j < ARRAY_CARDINALITY(virtTypes); j++) {
+ for (j = 0; j < G_N_ELEMENTS(virtTypes); j++) {
lbl = qemuSecurityGetBaseLabel(sec_managers[i], virtTypes[j]);
type = virDomainVirtTypeToString(virtTypes[j]);
if (lbl &&
"ibm,nvlink-speed", "memory-region"};
size_t i;
- for (i = 0; i < ARRAY_CARDINALITY(nvlink2Files); i++) {
+ for (i = 0; i < G_N_ELEMENTS(nvlink2Files); i++) {
VIR_AUTOFREE(char *) file = NULL;
if ((virAsprintf(&file, "/sys/bus/pci/devices/%s/of_node/%s",
fds[0].events = fds[1].events = POLLIN;
fds[0].revents = fds[1].revents = 0;
- ret = poll(fds, ARRAY_CARDINALITY(fds), timeout);
+ ret = poll(fds, G_N_ELEMENTS(fds), timeout);
if (ret < 0) {
if (errno == EAGAIN || errno == EINTR)
static virConnectAuth virConnectAuthConfig = {
.credtype = virConnectCredType,
- .ncredtype = ARRAY_CARDINALITY(virConnectCredType),
+ .ncredtype = G_N_ELEMENTS(virConnectCredType),
};
[QEMU_MIGRATION_PARAM_MAX_POSTCOPY_BANDWIDTH] = QEMU_MIGRATION_PARAM_TYPE_ULL,
[QEMU_MIGRATION_PARAM_MULTIFD_CHANNELS] = QEMU_MIGRATION_PARAM_TYPE_INT,
};
-verify(ARRAY_CARDINALITY(qemuMigrationParamTypes) == QEMU_MIGRATION_PARAM_LAST);
+verify(G_N_ELEMENTS(qemuMigrationParamTypes) == QEMU_MIGRATION_PARAM_LAST);
virBitmapPtr
if (!(caps = virBitmapNew(QEMU_MIGRATION_CAP_LAST)))
return NULL;
- for (i = 0; i < ARRAY_CARDINALITY(qemuMigrationParamsAlwaysOn); i++) {
+ for (i = 0; i < G_N_ELEMENTS(qemuMigrationParamsAlwaysOn); i++) {
if (!(qemuMigrationParamsAlwaysOn[i].party & party))
continue;
if (!(migParams = qemuMigrationParamsNew()))
return NULL;
- for (i = 0; i < ARRAY_CARDINALITY(qemuMigrationParamsFlagMap); i++) {
+ for (i = 0; i < G_N_ELEMENTS(qemuMigrationParamsFlagMap); i++) {
qemuMigrationCapability cap = qemuMigrationParamsFlagMap[i].cap;
if (qemuMigrationParamsFlagMap[i].party & party &&
}
}
- for (i = 0; i < ARRAY_CARDINALITY(qemuMigrationParamsTPMap); i++) {
+ for (i = 0; i < G_N_ELEMENTS(qemuMigrationParamsTPMap); i++) {
const qemuMigrationParamsTPMapItem *item = &qemuMigrationParamsTPMap[i];
if (!(item->party & party))
return -1;
}
- for (i = 0; i < ARRAY_CARDINALITY(qemuMigrationParamsTPMap); i++) {
+ for (i = 0; i < G_N_ELEMENTS(qemuMigrationParamsTPMap); i++) {
const qemuMigrationParamsTPMapItem *item = &qemuMigrationParamsTPMap[i];
if (!(item->party & QEMU_MIGRATION_DESTINATION))
}
}
- for (i = 0; i < ARRAY_CARDINALITY(qemuMigrationParamsAlwaysOn); i++) {
+ for (i = 0; i < G_N_ELEMENTS(qemuMigrationParamsAlwaysOn); i++) {
cap = qemuMigrationParamsAlwaysOn[i].cap;
if (qemuMigrationParamsAlwaysOn[i].party & party &&
qemuMonitorEmitEvent(mon, type, seconds, micros, details);
VIR_FREE(details);
- handler = bsearch(type, eventHandlers, ARRAY_CARDINALITY(eventHandlers),
+ handler = bsearch(type, eventHandlers, G_N_ELEMENTS(eventHandlers),
sizeof(eventHandlers[0]), qemuMonitorEventCompare);
if (handler) {
VIR_DEBUG("handle %s handler=%p data=%p", type,
if (!(metatype = virJSONValueObjectGetString(cur, "meta-type")))
return -2;
- for (i = 0; i < ARRAY_CARDINALITY(traverseMetaType); i++) {
+ for (i = 0; i < G_N_ELEMENTS(traverseMetaType); i++) {
if (STREQ(metatype, traverseMetaType[i].metatype))
return traverseMetaType[i].func(cur, ctxt);
}
return -1;
#endif /* ! WITH_IP */
- if (virSystemdGetActivation(actmap, ARRAY_CARDINALITY(actmap), &act) < 0)
+ if (virSystemdGetActivation(actmap, G_N_ELEMENTS(actmap), &act) < 0)
return -1;
#ifdef WITH_IP
fprintf(stderr, "\n");
fprintf(stderr, "%s\n", _("Options:"));
- for (i = 0; i < ARRAY_CARDINALITY(opthelp); i++)
+ for (i = 0; i < G_N_ELEMENTS(opthelp); i++)
fprintf(stderr, " %-22s %s\n", opthelp[i].opts,
_(opthelp[i].help));
fprintf(stderr, "\n");
VIR_DOMAIN_EVENT_CALLBACK(remoteRelayDomainEventBlockThreshold),
};
-verify(ARRAY_CARDINALITY(domainEventCallbacks) == VIR_DOMAIN_EVENT_ID_LAST);
+verify(G_N_ELEMENTS(domainEventCallbacks) == VIR_DOMAIN_EVENT_ID_LAST);
static int
remoteRelayNetworkEventLifecycle(virConnectPtr conn,
VIR_NETWORK_EVENT_CALLBACK(remoteRelayNetworkEventLifecycle),
};
-verify(ARRAY_CARDINALITY(networkEventCallbacks) == VIR_NETWORK_EVENT_ID_LAST);
+verify(G_N_ELEMENTS(networkEventCallbacks) == VIR_NETWORK_EVENT_ID_LAST);
static int
remoteRelayStoragePoolEventLifecycle(virConnectPtr conn,
VIR_STORAGE_POOL_EVENT_CALLBACK(remoteRelayStoragePoolEventRefresh),
};
-verify(ARRAY_CARDINALITY(storageEventCallbacks) == VIR_STORAGE_POOL_EVENT_ID_LAST);
+verify(G_N_ELEMENTS(storageEventCallbacks) == VIR_STORAGE_POOL_EVENT_ID_LAST);
static int
remoteRelayNodeDeviceEventLifecycle(virConnectPtr conn,
VIR_NODE_DEVICE_EVENT_CALLBACK(remoteRelayNodeDeviceEventUpdate),
};
-verify(ARRAY_CARDINALITY(nodeDeviceEventCallbacks) == VIR_NODE_DEVICE_EVENT_ID_LAST);
+verify(G_N_ELEMENTS(nodeDeviceEventCallbacks) == VIR_NODE_DEVICE_EVENT_ID_LAST);
static int
remoteRelaySecretEventLifecycle(virConnectPtr conn,
VIR_SECRET_EVENT_CALLBACK(remoteRelaySecretEventValueChanged),
};
-verify(ARRAY_CARDINALITY(secretEventCallbacks) == VIR_SECRET_EVENT_ID_LAST);
+verify(G_N_ELEMENTS(secretEventCallbacks) == VIR_SECRET_EVENT_ID_LAST);
static void
remoteRelayDomainQemuMonitorEvent(virConnectPtr conn,
};
ssize_t i;
- for (i = 0; i < (ssize_t) ARRAY_CARDINALITY(drivers) && !*probeduri; i++) {
+ for (i = 0; i < (ssize_t) G_N_ELEMENTS(drivers) && !*probeduri; i++) {
VIR_AUTOFREE(char *) daemonname = NULL;
VIR_AUTOFREE(char *) daemonpath = NULL;
};
ssize_t i;
- for (i = 0; i < (ssize_t) ARRAY_CARDINALITY(drivers) && !*probeduri; i++) {
+ for (i = 0; i < (ssize_t) G_N_ELEMENTS(drivers) && !*probeduri; i++) {
VIR_AUTOFREE(char *) sockname = NULL;
if (virAsprintf(&sockname, "%s/libvirt/virt%sd-%s",
if (!(priv->remoteProgram = virNetClientProgramNew(REMOTE_PROGRAM,
REMOTE_PROTOCOL_VERSION,
remoteEvents,
- ARRAY_CARDINALITY(remoteEvents),
+ G_N_ELEMENTS(remoteEvents),
conn)))
goto failed;
if (!(priv->lxcProgram = virNetClientProgramNew(LXC_PROGRAM,
if (!(priv->qemuProgram = virNetClientProgramNew(QEMU_PROGRAM,
QEMU_PROTOCOL_VERSION,
qemuEvents,
- ARRAY_CARDINALITY(qemuEvents),
+ G_N_ELEMENTS(qemuEvents),
conn)))
goto failed;
remote_domain_open_graphics_args args;
struct private_data *priv = dom->conn->privateData;
int fdin[] = { fd };
- size_t fdinlen = ARRAY_CARDINALITY(fdin);
+ size_t fdinlen = G_N_ELEMENTS(fdin);
remoteDriverLock(priv);
print "{ $comment\n ${name},\n $arglen,\n (xdrproc_t)$argfilter,\n $retlen,\n (xdrproc_t)$retfilter,\n true,\n $priority\n},\n";
}
print "};\n";
- print "size_t ${structprefix}NProcs = ARRAY_CARDINALITY(${structprefix}Procs);\n";
+ print "size_t ${structprefix}NProcs = G_N_ELEMENTS(${structprefix}Procs);\n";
}
# Bodies for client functions ("remote_client_bodies.h").
const char *keys[] = { "identity", "id_dsa", "id_ecdsa", "id_ed25519", "id_rsa" };
- for (i = 0; i < ARRAY_CARDINALITY(keys); ++i) {
+ for (i = 0; i < G_N_ELEMENTS(keys); ++i) {
int ret = virNetClientCheckKeyExists(homedir, keys[i], retPath);
if (ret != 0)
return ret;
ignore_value(pthread_sigmask(SIG_BLOCK, &blockedsigs, &oldmask));
repoll:
- ret = poll(fds, ARRAY_CARDINALITY(fds), -1);
+ ret = poll(fds, G_N_ELEMENTS(fds), -1);
if (ret < 0 && (errno == EAGAIN || errno == EINTR))
goto repoll;
ignore_value(pthread_sigmask(SIG_BLOCK, &blockedsigs, &oldmask));
repoll2:
- ret = poll(fds, ARRAY_CARDINALITY(fds), -1);
+ ret = poll(fds, G_N_ELEMENTS(fds), -1);
if (ret < 0 && (errno == EAGAIN || errno == EINTR))
goto repoll2;
ignore_value(pthread_sigmask(SIG_BLOCK, &blockedsigs, &oldmask));
repoll:
- ret = poll(fds, ARRAY_CARDINALITY(fds), timeout);
+ ret = poll(fds, G_N_ELEMENTS(fds), timeout);
if (ret < 0 && (errno == EAGAIN || errno == EINTR))
goto repoll;
virSecurityManagerMetadataLockStatePtr state;
int ret;
- if (!(state = virSecurityManagerMetadataLock(data->mgr, paths, ARRAY_CARDINALITY(paths))))
+ if (!(state = virSecurityManagerMetadataLock(data->mgr, paths, G_N_ELEMENTS(paths))))
return -1;
ret = virSecurityMoveRememberedLabel(SECURITY_DAC_NAME, data->src, data->dst);
VIR_DEBUG("name=%s", NULLSTR(name));
- for (i = 0; i < ARRAY_CARDINALITY(security_drivers) && !drv; i++) {
+ for (i = 0; i < G_N_ELEMENTS(security_drivers) && !drv; i++) {
virSecurityDriverPtr tmp = security_drivers[i];
if (name &&
virSecurityManagerMetadataLockStatePtr state;
int ret;
- if (!(state = virSecurityManagerMetadataLock(data->mgr, paths, ARRAY_CARDINALITY(paths))))
+ if (!(state = virSecurityManagerMetadataLock(data->mgr, paths, G_N_ELEMENTS(paths))))
return -1;
ret = virSecurityMoveRememberedLabel(SECURITY_SELINUX_NAME, data->src, data->dst);
"/etc/libvirt-sandbox/services/" /* for virt-sandbox service config */
};
- const int nropaths = ARRAY_CARDINALITY(restricted);
- const int nrwpaths = ARRAY_CARDINALITY(restricted_rw);
- const int nopaths = ARRAY_CARDINALITY(override);
+ const int nropaths = G_N_ELEMENTS(restricted);
+ const int nrwpaths = G_N_ELEMENTS(restricted_rw);
+ const int nopaths = G_N_ELEMENTS(override);
if (path == NULL) {
vah_error(NULL, 0, _("bad pathname"));
goto error;
}
- for (i = 0; i < ARRAY_CARDINALITY(guest_types); i++) {
+ for (i = 0; i < G_N_ELEMENTS(guest_types); i++) {
if ((guest = virCapabilitiesAddGuest(caps,
guest_types[i],
VIR_ARCH_I686,
{ "xtensaeb", 32, VIR_ARCH_BIG_ENDIAN },
};
-verify(ARRAY_CARDINALITY(virArchData) == VIR_ARCH_LAST);
+verify(G_N_ELEMENTS(virArchData) == VIR_ARCH_LAST);
/**
[VIR_AUDIT_RECORD_RESOURCE] = AUDIT_VIRT_RESOURCE,
};
- if (type >= ARRAY_CARDINALITY(record_types) || record_types[type] == 0)
+ if (type >= G_N_ELEMENTS(record_types) || record_types[type] == 0)
VIR_WARN("Unknown audit record type %d", type);
else if (audit_log_user_message(auditfd, record_types[type], str, NULL,
clientaddr, clienttty, success) < 0) {
};
VIR_DEBUG("Setting up inheritance %s -> %s", parent->path, group->path);
- for (i = 0; i < ARRAY_CARDINALITY(inherit_values); i++) {
+ for (i = 0; i < G_N_ELEMENTS(inherit_values); i++) {
VIR_AUTOFREE(char *) value = NULL;
if (virCgroupGetValueStr(parent,
return -1;
/* sum up all entries of the same kind, from all devices */
- for (i = 0; i < ARRAY_CARDINALITY(value_names); i++) {
+ for (i = 0; i < G_N_ELEMENTS(value_names); i++) {
p1 = str1;
p2 = str2;
return -1;
}
- for (i = 0; i < ARRAY_CARDINALITY(value_names); i++) {
+ for (i = 0; i < G_N_ELEMENTS(value_names); i++) {
if (!(p1 = strstr(p1, value_names[i]))) {
virReportError(VIR_ERR_INTERNAL_ERROR,
_("Cannot find byte %sstats for block device '%s'"),
}
/* sum up all entries of the same kind, from all devices */
- for (i = 0; i < ARRAY_CARDINALITY(value_names); i++) {
+ for (i = 0; i < G_N_ELEMENTS(value_names); i++) {
p1 = str1;
while ((p1 = strstr(p1, value_names[i]))) {
return -1;
}
- for (i = 0; i < ARRAY_CARDINALITY(value_names); i++) {
+ for (i = 0; i < G_N_ELEMENTS(value_names); i++) {
if (!(p1 = strstr(p1, value_names[i]))) {
virReportError(VIR_ERR_INTERNAL_ERROR,
_("Cannot find byte '%s' stats for block device '%s'"),
};
-verify(ARRAY_CARDINALITY(hashinfo) == VIR_CRYPTO_HASH_LAST);
+verify(G_N_ELEMENTS(hashinfo) == VIR_CRYPTO_HASH_LAST);
ssize_t
virCryptoHashBuf(virCryptoHash hash,
static bool virDBusIsBasicType(char c)
{
- return !!memchr(virDBusBasicTypes, c, ARRAY_CARDINALITY(virDBusBasicTypes));
+ return !!memchr(virDBusBasicTypes, c, G_N_ELEMENTS(virDBusBasicTypes));
}
/*
static const char *const name ## TypeList[] = { __VA_ARGS__ }; \
const char *name ## TypeToString(int type) { \
return virEnumToString(name ## TypeList, \
- ARRAY_CARDINALITY(name ## TypeList), \
+ G_N_ELEMENTS(name ## TypeList), \
type); \
} \
int name ## TypeFromString(const char *type) { \
return virEnumFromString(name ## TypeList, \
- ARRAY_CARDINALITY(name ## TypeList), \
+ G_N_ELEMENTS(name ## TypeList), \
type); \
} \
- verify(ARRAY_CARDINALITY(name ## TypeList) == lastVal)
+ verify(G_N_ELEMENTS(name ## TypeList) == lastVal)
#define VIR_ENUM_DECL(name) \
const char *name ## TypeToString(int type); \
};
size_t i;
- for (i = 0; i < ARRAY_CARDINALITY(commands); i++) {
+ for (i = 0; i < G_N_ELEMENTS(commands); i++) {
if (!virFileIsExecutable(commands[i])) {
virReportSystemError(errno,
_("direct firewall backend requested, but %s is not available"),
}
param->value = 0;
- for (j = 0; j < ARRAY_CARDINALITY(cpu_map[i].idx); j++)
+ for (j = 0; j < G_N_ELEMENTS(cpu_map[i].idx); j++)
param->value += cpu_times[offset + cpu_map[i].idx[j]] * TICK_TO_NSEC;
}
bool changed = false;
iptablesGlobalChainData data[] = {
{ layer, "filter",
- filter_chains, ARRAY_CARDINALITY(filter_chains), &changed },
+ filter_chains, G_N_ELEMENTS(filter_chains), &changed },
{ layer, "nat",
- natmangle_chains, ARRAY_CARDINALITY(natmangle_chains), &changed },
+ natmangle_chains, G_N_ELEMENTS(natmangle_chains), &changed },
{ layer, "mangle",
- natmangle_chains, ARRAY_CARDINALITY(natmangle_chains), &changed },
+ natmangle_chains, G_N_ELEMENTS(natmangle_chains), &changed },
};
size_t i;
virFirewallStartTransaction(fw, 0);
- for (i = 0; i < ARRAY_CARDINALITY(data); i++)
+ for (i = 0; i < G_N_ELEMENTS(data); i++)
virFirewallAddRuleFull(fw, data[i].layer,
false, iptablesPrivateChainCreate,
&(data[i]), "--table", data[i].table,
[VIR_KEYCODE_SET_QNUM] = virKeyCodeTable_qnum,
};
-#define VIR_KEYMAP_ENTRY_MAX ARRAY_CARDINALITY(virKeyCodeTable_linux)
-
-verify(VIR_KEYMAP_ENTRY_MAX == ARRAY_CARDINALITY(virKeyCodeTable_atset1));
-verify(VIR_KEYMAP_ENTRY_MAX == ARRAY_CARDINALITY(virKeyCodeTable_atset2));
-verify(VIR_KEYMAP_ENTRY_MAX == ARRAY_CARDINALITY(virKeyCodeTable_atset3));
-verify(VIR_KEYMAP_ENTRY_MAX == ARRAY_CARDINALITY(virKeyCodeTable_osx));
-verify(VIR_KEYMAP_ENTRY_MAX == ARRAY_CARDINALITY(virKeyCodeTable_xtkbd));
-verify(VIR_KEYMAP_ENTRY_MAX == ARRAY_CARDINALITY(virKeyCodeTable_usb));
-verify(VIR_KEYMAP_ENTRY_MAX == ARRAY_CARDINALITY(virKeyCodeTable_win32));
-verify(VIR_KEYMAP_ENTRY_MAX == ARRAY_CARDINALITY(virKeyCodeTable_qnum));
-verify(VIR_KEYMAP_ENTRY_MAX == ARRAY_CARDINALITY(virKeyNameTable_linux));
-verify(VIR_KEYMAP_ENTRY_MAX == ARRAY_CARDINALITY(virKeyNameTable_osx));
-verify(VIR_KEYMAP_ENTRY_MAX == ARRAY_CARDINALITY(virKeyNameTable_win32));
+#define VIR_KEYMAP_ENTRY_MAX G_N_ELEMENTS(virKeyCodeTable_linux)
+
+verify(VIR_KEYMAP_ENTRY_MAX == G_N_ELEMENTS(virKeyCodeTable_atset1));
+verify(VIR_KEYMAP_ENTRY_MAX == G_N_ELEMENTS(virKeyCodeTable_atset2));
+verify(VIR_KEYMAP_ENTRY_MAX == G_N_ELEMENTS(virKeyCodeTable_atset3));
+verify(VIR_KEYMAP_ENTRY_MAX == G_N_ELEMENTS(virKeyCodeTable_osx));
+verify(VIR_KEYMAP_ENTRY_MAX == G_N_ELEMENTS(virKeyCodeTable_xtkbd));
+verify(VIR_KEYMAP_ENTRY_MAX == G_N_ELEMENTS(virKeyCodeTable_usb));
+verify(VIR_KEYMAP_ENTRY_MAX == G_N_ELEMENTS(virKeyCodeTable_win32));
+verify(VIR_KEYMAP_ENTRY_MAX == G_N_ELEMENTS(virKeyCodeTable_qnum));
+verify(VIR_KEYMAP_ENTRY_MAX == G_N_ELEMENTS(virKeyNameTable_linux));
+verify(VIR_KEYMAP_ENTRY_MAX == G_N_ELEMENTS(virKeyNameTable_osx));
+verify(VIR_KEYMAP_ENTRY_MAX == G_N_ELEMENTS(virKeyNameTable_win32));
VIR_ENUM_IMPL(virKeycodeSet,
VIR_KEYCODE_SET_LAST,
const char *msg = "Stack trace not available on this platform\n";
#define STRIP_DEPTH 3
- size = backtrace(array, ARRAY_CARDINALITY(array));
+ size = backtrace(array, G_N_ELEMENTS(array));
if (size) {
backtrace_symbols_fd(array + STRIP_DEPTH, size - STRIP_DEPTH, fd);
ignore_value(safewrite(fd, "\n", 1));
struct journalState state;
state.iov = iov;
- state.iov_end = iov + ARRAY_CARDINALITY(iov);
+ state.iov_end = iov + G_N_ELEMENTS(iov);
state.bufs = iov_bufs;
- state.bufs_end = iov_bufs + ARRAY_CARDINALITY(iov_bufs);
+ state.bufs_end = iov_bufs + G_N_ELEMENTS(iov_bufs);
journalAddString(&state, "MESSAGE", rawstr);
journalAddInt(&state, "PRIORITY",
};
# endif
- for (i = 0; i < ARRAY_CARDINALITY(ethtool_cmds); i++) {
+ for (i = 0; i < G_N_ELEMENTS(ethtool_cmds); i++) {
cmd.cmd = ethtool_cmds[i].cmd;
if (virNetDevFeatureAvailable(fd, ifr, &cmd))
ignore_value(virBitmapSetBit(bitmap, ethtool_cmds[i].feat));
# if HAVE_DECL_ETHTOOL_GFLAGS
cmd.cmd = ETHTOOL_GFLAGS;
if (virNetDevFeatureAvailable(fd, ifr, &cmd)) {
- for (i = 0; i < ARRAY_CARDINALITY(flags); i++) {
+ for (i = 0; i < G_N_ELEMENTS(flags); i++) {
if (cmd.data & flags[i].cmd)
ignore_value(virBitmapSetBit(bitmap, flags[i].feat));
}
fds[0].fd = fd;
fds[0].events = POLLIN;
- n = poll(fds, ARRAY_CARDINALITY(fds), NETLINK_ACK_TIMEOUT_S);
+ n = poll(fds, G_N_ELEMENTS(fds), NETLINK_ACK_TIMEOUT_S);
if (n <= 0) {
if (n < 0)
virReportSystemError(errno, "%s",
.attrConfig = PERF_COUNT_SW_EMULATION_FAULTS
},
};
-verify(ARRAY_CARDINALITY(attrs) == VIR_PERF_EVENT_LAST);
+verify(G_N_ELEMENTS(attrs) == VIR_PERF_EVENT_LAST);
typedef struct virPerfEventAttr *virPerfEventAttrPtr;
*nfdlist = 0;
*fdlist = NULL;
- for (i = 0; i < ARRAY_CARDINALITY(ns); i++) {
+ for (i = 0; i < G_N_ELEMENTS(ns); i++) {
int fd;
VIR_AUTOFREE(char *) nsfile = NULL;
4+4+4, 8, 512, NULL, vmdk4GetBackingStore, NULL
},
};
-verify(ARRAY_CARDINALITY(fileTypeInfo) == VIR_STORAGE_FILE_LAST);
+verify(G_N_ELEMENTS(fileTypeInfo) == VIR_STORAGE_FILE_LAST);
/* qcow2 compatible features in the order they appear on-disk */
static const int qcow2CompatibleFeatureArray[] = {
VIR_STORAGE_FILE_FEATURE_LAZY_REFCOUNTS,
};
-verify(ARRAY_CARDINALITY(qcow2CompatibleFeatureArray) ==
+verify(G_N_ELEMENTS(qcow2CompatibleFeatureArray) ==
QCOW2_COMPATIBLE_FEATURE_LAST);
static int
return -1;
}
- for (i = 0; i < ARRAY_CARDINALITY(jsonParsers); i++) {
+ for (i = 0; i < G_N_ELEMENTS(jsonParsers); i++) {
if (STREQ(drvname, jsonParsers[i].drvname))
return jsonParsers[i].func(src, file, jsonParsers[i].opaque);
}
dev = strrchr(devpath, '/');
if (dev) {
dev++;
- for (i = 0; i < ARRAY_CARDINALITY(prefix); i++) {
+ for (i = 0; i < G_N_ELEMENTS(prefix); i++) {
if (virAsprintf(&path, "/sys/class/%s%s/device/cancel",
prefix[i], dev) < 0)
goto cleanup;
virMutexLock(&swtpm_tools_lock);
- for (i = 0; i < ARRAY_CARDINALITY(prgs); i++) {
+ for (i = 0; i < G_N_ELEMENTS(prgs); i++) {
VIR_AUTOFREE(char *) path = NULL;
bool findit = *prgs[i].path == NULL;
struct stat statbuf;
static char const* const drive_prefix[] = {"fd", "hd", "vd", "sd", "xvd", "ubd"};
size_t i;
- for (i = 0; i < ARRAY_CARDINALITY(drive_prefix); i++) {
+ for (i = 0; i < G_N_ELEMENTS(drive_prefix); i++) {
if (STRPREFIX(name, drive_prefix[i])) {
ptr = name + strlen(drive_prefix[i]);
break;
*path = NULL;
- if (GetWindowsDirectory(windowsdir, ARRAY_CARDINALITY(windowsdir))) {
+ if (GetWindowsDirectory(windowsdir, G_N_ELEMENTS(windowsdir))) {
const char *tmp;
/* Usually X:\Windows, but in terminal server environments
* might be an UNC path, AFAIK.
}
/* Try the known locations. */
- for (i = 0; i < ARRAY_CARDINALITY(knownDirs); ++i) {
+ for (i = 0; i < G_N_ELEMENTS(knownDirs); ++i) {
if (tryLoadOne(knownDirs[i], true, true, version) >= 0)
return 0;
}
* the VMware hypervisor. We look this up first since we use it
* for auto detection of the backend
*/
- for (i = 0; i < ARRAY_CARDINALITY(vmrun_candidates); i++) {
+ for (i = 0; i < G_N_ELEMENTS(vmrun_candidates); i++) {
vmrun = virFindFileInPath(vmrun_candidates[i]);
if (vmrun == NULL)
continue;
if (virCapabilitiesInitCaches(caps) < 0)
goto error;
- verify(ARRAY_CARDINALITY(archs) == ARRAY_CARDINALITY(emulators));
+ verify(G_N_ELEMENTS(archs) == G_N_ELEMENTS(emulators));
- for (i = 0; i < ARRAY_CARDINALITY(ostypes); i++)
- for (j = 0; j < ARRAY_CARDINALITY(archs); j++)
- for (k = 0; k < ARRAY_CARDINALITY(emulators); k++)
+ for (i = 0; i < G_N_ELEMENTS(ostypes); i++)
+ for (j = 0; j < G_N_ELEMENTS(archs); j++)
+ for (k = 0; k < G_N_ELEMENTS(emulators); k++)
if (vzCapsAddGuestDomain(caps, ostypes[i], archs[j],
emulators[k], virt_types[k]) < 0)
goto error;
ret = EXIT_SUCCESS;
cleanup:
- for (i = 0; i < ARRAY_CARDINALITY(buffers); i++)
+ for (i = 0; i < G_N_ELEMENTS(buffers); i++)
free(buffers[i]);
fclose(log);
free(newenv);
char *directoryName = NULL;
char *directoryAndFileName = NULL;
- for (i = 0; i < ARRAY_CARDINALITY(paths); ++i) {
+ for (i = 0; i < G_N_ELEMENTS(paths); ++i) {
VIR_FREE(datastoreName);
VIR_FREE(directoryName);
VIR_FREE(directoryAndFileName);
esxVI_DateTime dateTime;
long long calendarTime;
- for (i = 0; i < ARRAY_CARDINALITY(times); ++i) {
+ for (i = 0; i < G_N_ELEMENTS(times); ++i) {
dateTime.value = (char *)times[i].dateTime;
if (esxVI_DateTime_ConvertToCalendarTime(&dateTime,
size_t i;
char *escaped = NULL;
- for (i = 0; i < ARRAY_CARDINALITY(datastoreItems); ++i) {
+ for (i = 0; i < G_N_ELEMENTS(datastoreItems); ++i) {
VIR_FREE(escaped);
escaped = esxUtil_EscapeDatastoreItem(datastoreItems[i].string);
size_t i;
char *utf8 = NULL;
- for (i = 0; i < ARRAY_CARDINALITY(windows1252ToUTF8); ++i) {
+ for (i = 0; i < G_N_ELEMENTS(windows1252ToUTF8); ++i) {
VIR_FREE(utf8);
utf8 = virVMXConvertToUTF8("Windows-1252",
size_t i;
char *offset = rules;
- for (i = 0; i < ARRAY_CARDINALITY(commonRules); i++) {
+ for (i = 0; i < G_N_ELEMENTS(commonRules); i++) {
char *tmp = strstr(offset, commonRules[i]);
size_t len = strlen(commonRules[i]);
if (tmp) {
if (virAsprintf(&conf, "%s/openvzutilstest.conf", abs_srcdir) < 0)
return -1;
- for (i = 0; i < ARRAY_CARDINALITY(configParams); ++i) {
+ for (i = 0; i < G_N_ELEMENTS(configParams); ++i) {
if (openvzReadConfigParam(conf, configParams[i].param,
&value) != configParams[i].ret) {
goto cleanup;
PREFIX "/share/qemu/firmware/61-ovmf.json",
PREFIX "/share/qemu/firmware/70-aavmf.json",
};
- const size_t nexpected = ARRAY_CARDINALITY(expected);
+ const size_t nexpected = G_N_ELEMENTS(expected);
if (VIR_STRDUP(fakehome, abs_srcdir "/qemufirmwaredata/home/user/.config") < 0)
return -1;
do { \
unsigned int interfaces[] = {__VA_ARGS__}; \
struct supportedData data = {machine, arch, secure, fwlist, \
- interfaces, ARRAY_CARDINALITY(interfaces)}; \
+ interfaces, G_N_ELEMENTS(interfaces)}; \
if (virTestRun("QEMU FW SUPPORTED " machine " " #arch, \
testSupportedFW, &data) < 0) \
ret = -1; \
return -1;
if (qemuMonitorJSONSendKey(qemuMonitorTestGetMonitor(test),
- 0, keycodes, ARRAY_CARDINALITY(keycodes)) < 0)
+ 0, keycodes, G_N_ELEMENTS(keycodes)) < 0)
return -1;
return 0;
if (qemuMonitorJSONSendKey(qemuMonitorTestGetMonitor(test),
31337, keycodes,
- ARRAY_CARDINALITY(keycodes)) < 0)
+ G_N_ELEMENTS(keycodes)) < 0)
return -1;
return 0;
SYSCONFDIR "/qemu/vhost-user/40-gpu.json",
PREFIX "/share/qemu/vhost-user/60-gpu.json",
};
- const size_t nexpected = ARRAY_CARDINALITY(expected);
+ const size_t nexpected = G_N_ELEMENTS(expected);
if (VIR_STRDUP(fakehome, abs_srcdir "/qemuvhostuserdata/home/user/.config") < 0)
return -1;
{
size_t i;
- for (i = 0; i < ARRAY_CARDINALITY(testCommandPassSafeFDs); i++) {
+ for (i = 0; i < G_N_ELEMENTS(testCommandPassSafeFDs); i++) {
if (testCommandPassSafeFDs[i] == fd) {
if (!real_virCommandPassFD)
VIR_MOCK_REAL_INIT(virCommandPassFD);
if (ARCH_IS_X86(arch)) {
if (virQEMUCapsAddCPUDefinitions(caps, VIR_DOMAIN_VIRT_KVM, x86Models,
- ARRAY_CARDINALITY(x86Models),
+ G_N_ELEMENTS(x86Models),
VIR_DOMCAPS_CPU_USABLE_UNKNOWN) < 0 ||
virQEMUCapsAddCPUDefinitions(caps, VIR_DOMAIN_VIRT_QEMU, x86Models,
- ARRAY_CARDINALITY(x86Models),
+ G_N_ELEMENTS(x86Models),
VIR_DOMCAPS_CPU_USABLE_UNKNOWN) < 0)
return -1;
if (!skipLegacy) {
if (virQEMUCapsAddCPUDefinitions(caps, VIR_DOMAIN_VIRT_KVM,
x86LegacyModels,
- ARRAY_CARDINALITY(x86LegacyModels),
+ G_N_ELEMENTS(x86LegacyModels),
VIR_DOMCAPS_CPU_USABLE_UNKNOWN) < 0 ||
virQEMUCapsAddCPUDefinitions(caps, VIR_DOMAIN_VIRT_QEMU,
x86LegacyModels,
- ARRAY_CARDINALITY(x86LegacyModels),
+ G_N_ELEMENTS(x86LegacyModels),
VIR_DOMCAPS_CPU_USABLE_UNKNOWN) < 0)
return -1;
}
} else if (ARCH_IS_ARM(arch)) {
if (virQEMUCapsAddCPUDefinitions(caps, VIR_DOMAIN_VIRT_KVM, armModels,
- ARRAY_CARDINALITY(armModels),
+ G_N_ELEMENTS(armModels),
VIR_DOMCAPS_CPU_USABLE_UNKNOWN) < 0 ||
virQEMUCapsAddCPUDefinitions(caps, VIR_DOMAIN_VIRT_QEMU, armModels,
- ARRAY_CARDINALITY(armModels),
+ G_N_ELEMENTS(armModels),
VIR_DOMCAPS_CPU_USABLE_UNKNOWN) < 0)
return -1;
} else if (ARCH_IS_PPC64(arch)) {
if (virQEMUCapsAddCPUDefinitions(caps, VIR_DOMAIN_VIRT_KVM, ppc64Models,
- ARRAY_CARDINALITY(ppc64Models),
+ G_N_ELEMENTS(ppc64Models),
VIR_DOMCAPS_CPU_USABLE_UNKNOWN) < 0 ||
virQEMUCapsAddCPUDefinitions(caps, VIR_DOMAIN_VIRT_QEMU, ppc64Models,
- ARRAY_CARDINALITY(ppc64Models),
+ G_N_ELEMENTS(ppc64Models),
VIR_DOMCAPS_CPU_USABLE_UNKNOWN) < 0)
return -1;
} else if (ARCH_IS_S390(arch)) {
if (virQEMUCapsAddCPUDefinitions(caps, VIR_DOMAIN_VIRT_KVM, s390xModels,
- ARRAY_CARDINALITY(s390xModels),
+ G_N_ELEMENTS(s390xModels),
VIR_DOMCAPS_CPU_USABLE_UNKNOWN) < 0)
return -1;
}
const char
*virTestCounterNext(void)
{
- size_t len = ARRAY_CARDINALITY(virtTestCounterStr);
+ size_t len = G_N_ELEMENTS(virtTestCounterStr);
/* calculate length of the rest of the string */
len -= (virtTestCounterPrefixEndOffset - virtTestCounterStr);
.sockets = 1,
.cores = 2,
.threads = 1,
- .nfeatures = ARRAY_CARDINALITY(cpuDefaultFeatures),
- .nfeatures_max = ARRAY_CARDINALITY(cpuDefaultFeatures),
+ .nfeatures = G_N_ELEMENTS(cpuDefaultFeatures),
+ .nfeatures_max = G_N_ELEMENTS(cpuDefaultFeatures),
.features = cpuDefaultFeatures,
};
.sockets = 1,
.cores = 2,
.threads = 2,
- .nfeatures = ARRAY_CARDINALITY(cpuHaswellFeatures),
- .nfeatures_max = ARRAY_CARDINALITY(cpuHaswellFeatures),
+ .nfeatures = G_N_ELEMENTS(cpuHaswellFeatures),
+ .nfeatures_max = G_N_ELEMENTS(cpuHaswellFeatures),
.features = cpuHaswellFeatures,
};
};
machines = virCapabilitiesAllocMachines(x86_machines,
- ARRAY_CARDINALITY(x86_machines));
+ G_N_ELEMENTS(x86_machines));
if (machines == NULL)
return NULL;
- *nmachines = ARRAY_CARDINALITY(x86_machines);
+ *nmachines = G_N_ELEMENTS(x86_machines);
return machines;
}
return NULL;
machines = virCapabilitiesAllocMachines(x86_machines,
- ARRAY_CARDINALITY(x86_machines));
+ G_N_ELEMENTS(x86_machines));
if (machines == NULL) {
VIR_FREE(canonical);
return NULL;
machines[1]->canonical = canonical;
- *nmachines = ARRAY_CARDINALITY(x86_machines);
+ *nmachines = G_N_ELEMENTS(x86_machines);
return machines;
}
"sifive_e",
"virt",
"sifive_u" };
- static const int nmachines = ARRAY_CARDINALITY(names);
+ static const int nmachines = G_N_ELEMENTS(names);
virCapsGuestMachinePtr *machines = NULL;
virCapsGuestPtr guest;
"sifive_e",
"virt",
"sifive_u" };
- static const int nmachines = ARRAY_CARDINALITY(names);
+ static const int nmachines = G_N_ELEMENTS(names);
virCapsGuestMachinePtr *machines = NULL;
virCapsGuestPtr guest;
virCapsGuestPtr guest;
machines = virCapabilitiesAllocMachines(s390_machines,
- ARRAY_CARDINALITY(s390_machines));
+ G_N_ELEMENTS(s390_machines));
if (!machines)
goto error;
guest = virCapabilitiesAddGuest(caps, VIR_DOMAIN_OSTYPE_HVM, VIR_ARCH_S390X,
QEMUBinList[TEST_UTILS_QEMU_BIN_S390X],
NULL,
- ARRAY_CARDINALITY(s390_machines),
+ G_N_ELEMENTS(s390_machines),
machines);
if (!guest)
goto error;
return 0;
error:
- virCapabilitiesFreeMachines(machines, ARRAY_CARDINALITY(s390_machines));
+ virCapabilitiesFreeMachines(machines, G_N_ELEMENTS(s390_machines));
return -1;
}
virCapsGuestPtr guest;
capsmachines = virCapabilitiesAllocMachines(machines,
- ARRAY_CARDINALITY(machines));
+ G_N_ELEMENTS(machines));
if (!capsmachines)
goto error;
guest = virCapabilitiesAddGuest(caps, VIR_DOMAIN_OSTYPE_HVM, VIR_ARCH_ARMV6L,
QEMUBinList[TEST_UTILS_QEMU_BIN_ARM],
NULL,
- ARRAY_CARDINALITY(machines),
+ G_N_ELEMENTS(machines),
capsmachines);
if (!guest)
goto error;
return 0;
error:
- virCapabilitiesFreeMachines(capsmachines, ARRAY_CARDINALITY(machines));
+ virCapabilitiesFreeMachines(capsmachines, G_N_ELEMENTS(machines));
return -1;
}
virCapsGuestPtr guest;
capsmachines = virCapabilitiesAllocMachines(machines,
- ARRAY_CARDINALITY(machines));
+ G_N_ELEMENTS(machines));
if (!capsmachines)
goto error;
guest = virCapabilitiesAddGuest(caps, VIR_DOMAIN_OSTYPE_HVM, VIR_ARCH_ARMV7L,
QEMUBinList[TEST_UTILS_QEMU_BIN_ARM],
NULL,
- ARRAY_CARDINALITY(machines),
+ G_N_ELEMENTS(machines),
capsmachines);
if (!guest)
goto error;
return 0;
error:
- virCapabilitiesFreeMachines(capsmachines, ARRAY_CARDINALITY(machines));
+ virCapabilitiesFreeMachines(capsmachines, G_N_ELEMENTS(machines));
return -1;
}
virCapsGuestPtr guest;
capsmachines = virCapabilitiesAllocMachines(machines,
- ARRAY_CARDINALITY(machines));
+ G_N_ELEMENTS(machines));
if (!capsmachines)
goto error;
guest = virCapabilitiesAddGuest(caps, VIR_DOMAIN_OSTYPE_HVM, VIR_ARCH_AARCH64,
QEMUBinList[TEST_UTILS_QEMU_BIN_AARCH64],
NULL,
- ARRAY_CARDINALITY(machines),
+ G_N_ELEMENTS(machines),
capsmachines);
if (!guest)
goto error;
return 0;
error:
- virCapabilitiesFreeMachines(capsmachines, ARRAY_CARDINALITY(machines));
+ virCapabilitiesFreeMachines(capsmachines, G_N_ELEMENTS(machines));
return -1;
}
return -ENOMEM;
}
- for (i = 0; i < ARRAY_CARDINALITY(QEMUBinList); i++) {
+ for (i = 0; i < G_N_ELEMENTS(QEMUBinList); i++) {
virObjectRef(tmpCaps);
if (virFileCacheInsertData(cache, QEMUBinList[i], tmpCaps) < 0) {
virObjectUnref(tmpCaps);
VIR_TEST_VERBOSE("");
- for (i = 0; i < ARRAY_CARDINALITY(archs); ++i) {
+ for (i = 0; i < G_N_ELEMENTS(archs); ++i) {
char *cap = testQemuGetLatestCapsForArch(archs[i], "xml");
if (!cap || virHashAddEntry(capslatest, archs[i], cap) < 0)
caps->host.cpu = virCPUDefCopy(&cpuDefaultData);
- nmachines = ARRAY_CARDINALITY(x86_machines);
+ nmachines = G_N_ELEMENTS(x86_machines);
if ((machines = virCapabilitiesAllocMachines(x86_machines, nmachines)) == NULL)
goto cleanup;
if ((guest = virCapabilitiesAddGuest(caps, VIR_DOMAIN_OSTYPE_HVM,
if (virCapabilitiesAddGuestDomain(guest, VIR_DOMAIN_VIRT_XEN, NULL,
NULL, 0, NULL) == NULL)
goto cleanup;
- nmachines = ARRAY_CARDINALITY(xen_machines);
+ nmachines = G_N_ELEMENTS(xen_machines);
if ((machines = virCapabilitiesAllocMachines(xen_machines, nmachines)) == NULL)
goto cleanup;
if (virCapabilitiesAddGuestDomain(guest, VIR_DOMAIN_VIRT_XEN, NULL,
NULL, 0, NULL) == NULL)
goto cleanup;
- nmachines = ARRAY_CARDINALITY(pvh_machines);
+ nmachines = G_N_ELEMENTS(pvh_machines);
if ((machines = virCapabilitiesAllocMachines(pvh_machines, nmachines)) == NULL)
goto cleanup;
size_t i;
char *diskName = NULL;
- for (i = 0; i < ARRAY_CARDINALITY(diskNames); ++i) {
+ for (i = 0; i < G_N_ELEMENTS(diskNames); ++i) {
VIR_FREE(diskName);
diskName = virIndexToDiskName(i, "sd");
int partition;
struct testDiskName *disk = NULL;
- for (i = 0; i < ARRAY_CARDINALITY(diskNamesPart); ++i) {
+ for (i = 0; i < G_N_ELEMENTS(diskNamesPart); ++i) {
disk = &diskNamesPart[i];
if (virDiskNameParse(disk->name, &idx, &partition))
return -1;
}
}
- for (i = 0; i < ARRAY_CARDINALITY(diskNamesInvalid); ++i) {
+ for (i = 0; i < G_N_ELEMENTS(diskNamesInvalid); ++i) {
if (!virDiskNameParse(diskNamesInvalid[i], &idx, &partition)) {
VIR_TEST_DEBUG("Should Fail [%s]", diskNamesInvalid[i]);
return -1;
size_t i;
unsigned long version;
- for (i = 0; i < ARRAY_CARDINALITY(versions); ++i) {
+ for (i = 0; i < G_N_ELEMENTS(versions); ++i) {
result = virParseVersionString(versions[i].string, &version,
versions[i].allowMissing);
unsigned int result;
size_t i;
- for (i = 0; i < ARRAY_CARDINALITY(roundData); i++) {
+ for (i = 0; i < G_N_ELEMENTS(roundData); i++) {
result = VIR_ROUND_UP_POWER_OF_TWO(roundData[i].input);
if (roundData[i].output != result) {
VIR_TEST_DEBUG("\nInput number [%u]", roundData[i].input);
virBitmapPtr bitmap = NULL;
ssize_t i, j;
- if (ARRAY_CARDINALITY(bitsPos) + ARRAY_CARDINALITY(bitsPosInv) != size)
+ if (G_N_ELEMENTS(bitsPos) + G_N_ELEMENTS(bitsPosInv) != size)
goto error;
/* 0. empty set */
j = 0;
i = -1;
- while (j < ARRAY_CARDINALITY(bitsPos)) {
+ while (j < G_N_ELEMENTS(bitsPos)) {
i = virBitmapNextSetBit(bitmap, i);
if (i != bitsPos[j++])
goto error;
j = 0;
i = -1;
- while (j < ARRAY_CARDINALITY(bitsPosInv)) {
+ while (j < G_N_ELEMENTS(bitsPosInv)) {
i = virBitmapNextClearBit(bitmap, i);
if (i != bitsPosInv[j++])
goto error;
size_t i = 0;
int ret = -1;
- for (i = 0; i < ARRAY_CARDINALITY(strings); i++) {
+ for (i = 0; i < G_N_ELEMENTS(strings); i++) {
map = virBitmapNewString(strings[i]);
str = virBitmapToString(map, false, true);
"inactive_file",
"unevictable"
};
- unsigned long long values[ARRAY_CARDINALITY(expected_values)];
+ unsigned long long values[G_N_ELEMENTS(expected_values)];
if ((rv = virCgroupNewPartition("/virtualmachines", true,
(1 << VIR_CGROUP_CONTROLLER_MEMORY),
goto cleanup;
}
- for (i = 0; i < ARRAY_CARDINALITY(expected_values); i++) {
+ for (i = 0; i < G_N_ELEMENTS(expected_values); i++) {
/* NB: virCgroupGetMemoryStat returns a KiB scaled value */
if ((expected_values[i] >> 10) != values[i]) {
fprintf(stderr,
"requests read",
"requests written"
};
- long long values[ARRAY_CARDINALITY(expected_values)];
+ long long values[G_N_ELEMENTS(expected_values)];
if ((rv = virCgroupNewPartition("/virtualmachines", true,
(1 << VIR_CGROUP_CONTROLLER_BLKIO),
goto cleanup;
}
- for (i = 0; i < ARRAY_CARDINALITY(expected_values); i++) {
+ for (i = 0; i < G_N_ELEMENTS(expected_values); i++) {
if (expected_values[i] != values[i]) {
fprintf(stderr,
"Wrong value for %s from virCgroupBlkioIoServiced (expected %lld)\n",
"requests read",
"requests written"
};
- long long values[ARRAY_CARDINALITY(expected_values0)];
+ long long values[G_N_ELEMENTS(expected_values0)];
if ((rv = virCgroupNewPartition("/virtualmachines", true,
(1 << VIR_CGROUP_CONTROLLER_BLKIO),
goto cleanup;
}
- for (i = 0; i < ARRAY_CARDINALITY(expected_values0); i++) {
+ for (i = 0; i < G_N_ELEMENTS(expected_values0); i++) {
if (expected_values0[i] != values[i]) {
fprintf(stderr,
"Wrong value for %s from virCgroupGetBlkioIoDeviceServiced (expected %lld)\n",
goto cleanup;
}
- for (i = 0; i < ARRAY_CARDINALITY(expected_values1); i++) {
+ for (i = 0; i < G_N_ELEMENTS(expected_values1); i++) {
if (expected_values1[i] != values[i]) {
fprintf(stderr,
"Wrong value for %s from virCgroupGetBlkioIoDeviceServiced (expected %lld)\n",
# define DO_TEST_MOUNT_SUBTREE(name, path, prefix, mounts, rev) \
do { \
struct testFileGetMountSubtreeData data = { \
- path, prefix, mounts, ARRAY_CARDINALITY(mounts), rev \
+ path, prefix, mounts, G_N_ELEMENTS(mounts), rev \
}; \
if (virTestRun(name, testFileGetMountSubtree, &data) < 0) \
ret = -1; \
"--jump", "REJECT", NULL);
for (i = 0; lines[i] != NULL; i++) {
- if (expectedLineNum >= ARRAY_CARDINALITY(expectedLines)) {
+ if (expectedLineNum >= G_N_ELEMENTS(expectedLines)) {
expectedLineError = true;
break;
}
/* entries are added in reverse order so that they will be linked in
* collision list in the same order as in the uuids array
*/
- for (i = ARRAY_CARDINALITY(uuids) - 1; i >= 0; i--) {
+ for (i = G_N_ELEMENTS(uuids) - 1; i >= 0; i--) {
ssize_t oldsize = virHashTableSize(hash);
if (virHashAddEntry(hash, uuids[i], (void *) uuids[i]) < 0) {
virHashFree(hash);
}
}
- for (i = 0; i < ARRAY_CARDINALITY(uuids); i++) {
+ for (i = 0; i < G_N_ELEMENTS(uuids); i++) {
if (!virHashLookup(hash, uuids[i])) {
VIR_TEST_VERBOSE("\nentry \"%s\" could not be found", uuids[i]);
virHashFree(hash);
if (!(hash = testHashInit(info->count)))
return -1;
- if (testHashCheckCount(hash, ARRAY_CARDINALITY(uuids)) < 0)
+ if (testHashCheckCount(hash, G_N_ELEMENTS(uuids)) < 0)
goto cleanup;
ret = 0;
static int
testHashUpdate(const void *data G_GNUC_UNUSED)
{
- int count = ARRAY_CARDINALITY(uuids) + ARRAY_CARDINALITY(uuids_new);
+ int count = G_N_ELEMENTS(uuids) + G_N_ELEMENTS(uuids_new);
virHashTablePtr hash;
size_t i;
int ret = -1;
if (!(hash = testHashInit(0)))
return -1;
- for (i = 0; i < ARRAY_CARDINALITY(uuids_subset); i++) {
+ for (i = 0; i < G_N_ELEMENTS(uuids_subset); i++) {
if (virHashUpdateEntry(hash, uuids_subset[i], (void *) 1) < 0) {
VIR_TEST_VERBOSE("\nentry \"%s\" could not be updated",
uuids_subset[i]);
}
}
- for (i = 0; i < ARRAY_CARDINALITY(uuids_new); i++) {
+ for (i = 0; i < G_N_ELEMENTS(uuids_new); i++) {
if (virHashUpdateEntry(hash, uuids_new[i], (void *) 1) < 0) {
VIR_TEST_VERBOSE("\nnew entry \"%s\" could not be updated",
uuids_new[i]);
static int
testHashRemove(const void *data G_GNUC_UNUSED)
{
- int count = ARRAY_CARDINALITY(uuids) - ARRAY_CARDINALITY(uuids_subset);
+ int count = G_N_ELEMENTS(uuids) - G_N_ELEMENTS(uuids_subset);
virHashTablePtr hash;
size_t i;
int ret = -1;
if (!(hash = testHashInit(0)))
return -1;
- for (i = 0; i < ARRAY_CARDINALITY(uuids_subset); i++) {
+ for (i = 0; i < G_N_ELEMENTS(uuids_subset); i++) {
if (virHashRemoveEntry(hash, uuids_subset[i]) < 0) {
VIR_TEST_VERBOSE("\nentry \"%s\" could not be removed",
uuids_subset[i]);
const int testHashCountRemoveForEachSome =
- ARRAY_CARDINALITY(uuids) - ARRAY_CARDINALITY(uuids_subset);
+ G_N_ELEMENTS(uuids) - G_N_ELEMENTS(uuids_subset);
static int
testHashRemoveForEachSome(void *payload G_GNUC_UNUSED,
virHashTablePtr hash = data;
size_t i;
- for (i = 0; i < ARRAY_CARDINALITY(uuids_subset); i++) {
+ for (i = 0; i < G_N_ELEMENTS(uuids_subset); i++) {
if (STREQ(uuids_subset[i], name)) {
if (virHashRemoveEntry(hash, name) < 0) {
VIR_TEST_VERBOSE("\nentry \"%s\" could not be removed",
static int
testHashSteal(const void *data G_GNUC_UNUSED)
{
- int count = ARRAY_CARDINALITY(uuids) - ARRAY_CARDINALITY(uuids_subset);
+ int count = G_N_ELEMENTS(uuids) - G_N_ELEMENTS(uuids_subset);
virHashTablePtr hash;
size_t i;
int ret = -1;
if (!(hash = testHashInit(0)))
return -1;
- for (i = 0; i < ARRAY_CARDINALITY(uuids_subset); i++) {
+ for (i = 0; i < G_N_ELEMENTS(uuids_subset); i++) {
if (!virHashSteal(hash, uuids_subset[i])) {
VIR_TEST_VERBOSE("\nentry \"%s\" could not be stolen",
uuids_subset[i]);
bool rem = false;
size_t i;
- for (i = 0; i < ARRAY_CARDINALITY(uuids_subset); i++) {
+ for (i = 0; i < G_N_ELEMENTS(uuids_subset); i++) {
if (STREQ(uuids_subset[i], name)) {
rem = true;
break;
goto cleanup;
}
- if (testHashCheckCount(hash, ARRAY_CARDINALITY(uuids) - count) < 0)
+ if (testHashCheckCount(hash, G_N_ELEMENTS(uuids) - count) < 0)
goto cleanup;
ret = 0;
}
-const int testSearchIndex = ARRAY_CARDINALITY(uuids_subset) / 2;
+const int testSearchIndex = G_N_ELEMENTS(uuids_subset) / 2;
static int
testHashSearchIter(const void *payload G_GNUC_UNUSED,
goto cleanup;
}
- if (testHashCheckCount(hash, ARRAY_CARDINALITY(uuids)) < 0)
+ if (testHashCheckCount(hash, G_N_ELEMENTS(uuids)) < 0)
goto cleanup;
ret = 0;
if (virInitialize() < 0)
return EXIT_FAILURE;
- for (i = 0; i < ARRAY_CARDINALITY(nodeData); i++)
+ for (i = 0; i < G_N_ELEMENTS(nodeData); i++)
if (virTestRun(nodeData[i].testName, linuxTestHostCPU, &nodeData[i]) != 0)
ret = -1;
.fake_cmd_output = "iscsiadm_sendtargets",
.portal = "10.20.30.40:3260,1",
.expected_targets = targets,
- .nexpected = ARRAY_CARDINALITY(targets),
+ .nexpected = G_N_ELEMENTS(targets),
};
if (virTestRun("ISCSI scan targets", testISCSIScanTargets, &infoTargets) < 0)
rv = -1;
if (virNetMessageEncodeHeader(msg) < 0)
goto cleanup;
- if (ARRAY_CARDINALITY(expect) != msg->bufferOffset) {
+ if (G_N_ELEMENTS(expect) != msg->bufferOffset) {
VIR_DEBUG("Expect message offset %zu got %zu",
sizeof(expect), msg->bufferOffset);
goto cleanup;
if (virNetMessageEncodePayload(msg, (xdrproc_t)xdr_virNetMessageError, &err) < 0)
goto cleanup;
- if (ARRAY_CARDINALITY(expect) != msg->bufferLength) {
+ if (G_N_ELEMENTS(expect) != msg->bufferLength) {
VIR_DEBUG("Expect message length %zu got %zu",
sizeof(expect), msg->bufferLength);
goto cleanup;
if (virNetMessageEncodePayloadRaw(msg, stream, strlen(stream)) < 0)
goto cleanup;
- if (ARRAY_CARDINALITY(expect) != msg->bufferLength) {
+ if (G_N_ELEMENTS(expect) != msg->bufferLength) {
VIR_DEBUG("Expect message length %zu got %zu",
sizeof(expect), msg->bufferLength);
goto cleanup;
testTLSWriteCertChain("cacertchain-ctx.pem",
certchain,
- ARRAY_CARDINALITY(certchain));
+ G_N_ELEMENTS(certchain));
DO_CTX_TEST(true, "cacertchain-ctx.pem", servercertlevel3areq.filename, false);
DO_CTX_TEST(false, "cacertchain-ctx.pem", clientcertlevel2breq.filename, false);
testTLSWriteCertChain("cacertchain-sess.pem",
certchain,
- ARRAY_CARDINALITY(certchain));
+ G_N_ELEMENTS(certchain));
DO_SESS_TEST("cacertchain-sess.pem", servercertlevel3areq.filename, clientcertlevel2breq.filename,
false, false, "libvirt.org", NULL);
size_t *npages)
{
const int pages_def[] = { 4, 2 * 1024, 1 * 1024 * 1024};
- const int npages_def = ARRAY_CARDINALITY(pages_def);
+ const int npages_def = G_N_ELEMENTS(pages_def);
size_t i = 0;
if (pages_size)
{
int ret = -1;
virPCIDevicePtr dev[] = {NULL, NULL, NULL};
- size_t i, nDev = ARRAY_CARDINALITY(dev);
+ size_t i, nDev = G_N_ELEMENTS(dev);
virPCIDeviceListPtr activeDevs = NULL, inactiveDevs = NULL;
int count;
{
int ret = -1;
virPCIDevicePtr dev[] = {NULL, NULL, NULL};
- size_t i, nDev = ARRAY_CARDINALITY(dev);
+ size_t i, nDev = G_N_ELEMENTS(dev);
virPCIDeviceListPtr activeDevs = NULL, inactiveDevs = NULL;
int count;
{
int ret = -1;
virPCIDevicePtr dev[] = {NULL, NULL, NULL};
- size_t i, nDev = ARRAY_CARDINALITY(dev);
+ size_t i, nDev = G_N_ELEMENTS(dev);
virPCIDeviceListPtr activeDevs = NULL, inactiveDevs = NULL;
int count;
is_authorized = 0;
is_challenge = 0;
retdetails = retdetailscancelled;
- retdetailslen = ARRAY_CARDINALITY(retdetailscancelled) / 2;
+ retdetailslen = G_N_ELEMENTS(retdetailscancelled) / 2;
} else if (STREQ(actionid, "org.libvirt.test.details")) {
size_t i;
is_authorized = 0;
char bytes[] = { FILEBYTE, FILEBYTE0, FILEBYTE1 };
size_t total = 0;
- if (nregions > ARRAY_CARDINALITY(bytes)) {
+ if (nregions > G_N_ELEMENTS(bytes)) {
fprintf(stderr, "Too many regions %zu\n", nregions);
return -1;
}
goto cleanup;
if (testRotatingFileReaderAssertBufferContent(buf, got,
- ARRAY_CARDINALITY(regions),
+ G_N_ELEMENTS(regions),
regions) < 0)
goto cleanup;
goto cleanup;
if (testRotatingFileReaderAssertBufferContent(buf, got,
- ARRAY_CARDINALITY(regions),
+ G_N_ELEMENTS(regions),
regions) < 0)
goto cleanup;
goto cleanup;
if (testRotatingFileReaderAssertBufferContent(buf, got,
- ARRAY_CARDINALITY(regions),
+ G_N_ELEMENTS(regions),
regions) < 0)
goto cleanup;
goto cleanup;
if (testRotatingFileReaderAssertBufferContent(buf, got,
- ARRAY_CARDINALITY(regions),
+ G_N_ELEMENTS(regions),
regions) < 0)
goto cleanup;
*linkpath = NULL;
- for (i = 0; i < ARRAY_CARDINALITY(testPathCanonicalizeSymlinks); i++) {
+ for (i = 0; i < G_N_ELEMENTS(testPathCanonicalizeSymlinks); i++) {
if (STREQ(path, testPathCanonicalizeSymlinks[i][0])) {
if (VIR_STRDUP(*linkpath, testPathCanonicalizeSymlinks[i][1]) < 0)
return -1;
{
size_t i;
- for (i = 0; i < ARRAY_CARDINALITY(backingchain); i++) {
+ for (i = 0; i < G_N_ELEMENTS(backingchain); i++) {
backingchain[i].type = VIR_STORAGE_TYPE_FILE;
- if (i < ARRAY_CARDINALITY(backingchain) - 1)
+ if (i < G_N_ELEMENTS(backingchain) - 1)
backingchain[i].backingStore = &backingchain[i + 1];
else
backingchain[i].backingStore = NULL;
data = (struct testChainData){ \
start, format, { __VA_ARGS__ }, 0, flags, \
}; \
- for (i = 0; i < ARRAY_CARDINALITY(data.files); i++) \
+ for (i = 0; i < G_N_ELEMENTS(data.files); i++) \
if (data.files[i]) \
data.nfiles++; \
if (virTestRun(virTestCounterNext(), \
ret = 0;
cleanup:
- for (i = 0; i < ARRAY_CARDINALITY(array); i++)
+ for (i = 0; i < G_N_ELEMENTS(array); i++)
VIR_FREE(array[i]);
return ret;
}
int ret = -1;
size_t i;
- qsort(randlist, ARRAY_CARDINALITY(randlist), sizeof(randlist[0]),
+ qsort(randlist, G_N_ELEMENTS(randlist), sizeof(randlist[0]),
virStringSortCompare);
- qsort(randrlist, ARRAY_CARDINALITY(randrlist), sizeof(randrlist[0]),
+ qsort(randrlist, G_N_ELEMENTS(randrlist), sizeof(randrlist[0]),
virStringSortRevCompare);
- for (i = 0; i < ARRAY_CARDINALITY(randlist); i++) {
+ for (i = 0; i < G_N_ELEMENTS(randlist); i++) {
if (STRNEQ(randlist[i], sortlist[i])) {
fprintf(stderr, "sortlist[%zu] '%s' != randlist[%zu] '%s'\n",
i, sortlist[i], i, randlist[i]);
int nicindexes[] = {
2, 1729, 87539319,
};
- size_t nnicindexes = ARRAY_CARDINALITY(nicindexes);
+ size_t nnicindexes = G_N_ELEMENTS(nicindexes);
if (virSystemdCreateMachine("demo",
"lxc",
uuid,
map[1].family = AF_INET;
map[1].port = virNetSocketGetPort(sockIP[0]);
- if (virSystemdGetActivation(map, ARRAY_CARDINALITY(map), &act) < 0)
+ if (virSystemdGetActivation(map, G_N_ELEMENTS(map), &act) < 0)
goto cleanup;
if (act == NULL) {
}
#define PARAMS_ARRAY(...) ((virTypedParameter[]){ __VA_ARGS__ })
-#define PARAMS_SIZE(...) ARRAY_CARDINALITY(PARAMS_ARRAY(__VA_ARGS__))
+#define PARAMS_SIZE(...) G_N_ELEMENTS(PARAMS_ARRAY(__VA_ARGS__))
#define PARAMS(...) \
.params = PARAMS_ARRAY(__VA_ARGS__), \
virTypedParameterPtr *filtered = NULL;
- nfiltered = virTypedParamsFilter(params, ARRAY_CARDINALITY(params),
+ nfiltered = virTypedParamsFilter(params, G_N_ELEMENTS(params),
"foo", &filtered);
if (nfiltered != 3)
goto cleanup;
VIR_FREE(filtered);
filtered = NULL;
- nfiltered = virTypedParamsFilter(params, ARRAY_CARDINALITY(params),
+ nfiltered = virTypedParamsFilter(params, G_N_ELEMENTS(params),
"bar", &filtered);
if (nfiltered != 2)
};
picked = virTypedParamsGetStringList(params,
- ARRAY_CARDINALITY(params),
+ G_N_ELEMENTS(params),
"bar",
&strings);
{ "block-threshold",
VIR_DOMAIN_EVENT_CALLBACK(virshEventBlockThresholdPrint), },
};
-verify(VIR_DOMAIN_EVENT_ID_LAST == ARRAY_CARDINALITY(virshDomainEventCallbacks));
+verify(VIR_DOMAIN_EVENT_ID_LAST == G_N_ELEMENTS(virshDomainEventCallbacks));
static const vshCmdInfo info_event[] = {
{.name = "help",
{ "lifecycle",
VIR_NETWORK_EVENT_CALLBACK(vshEventLifecyclePrint), },
};
-verify(VIR_NETWORK_EVENT_ID_LAST == ARRAY_CARDINALITY(virshNetworkEventCallbacks));
+verify(VIR_NETWORK_EVENT_ID_LAST == G_N_ELEMENTS(virshNetworkEventCallbacks));
static const vshCmdInfo info_network_event[] = {
{.name = "help",
VIR_NODE_DEVICE_EVENT_CALLBACK(vshEventLifecyclePrint), },
{ "update", vshEventGenericPrint, }
};
-verify(VIR_NODE_DEVICE_EVENT_ID_LAST == ARRAY_CARDINALITY(virshNodeDeviceEventCallbacks));
+verify(VIR_NODE_DEVICE_EVENT_ID_LAST == G_N_ELEMENTS(virshNodeDeviceEventCallbacks));
static const vshCmdInfo info_node_device_event[] = {
VIR_STORAGE_POOL_EVENT_CALLBACK(vshEventLifecyclePrint), },
{ "refresh", vshEventGenericPrint, }
};
-verify(VIR_STORAGE_POOL_EVENT_ID_LAST == ARRAY_CARDINALITY(virshPoolEventCallbacks));
+verify(VIR_STORAGE_POOL_EVENT_ID_LAST == G_N_ELEMENTS(virshPoolEventCallbacks));
static const vshCmdInfo info_pool_event[] = {
VIR_SECRET_EVENT_CALLBACK(vshEventLifecyclePrint), },
{ "value-changed", vshEventGenericPrint, },
};
-verify(VIR_SECRET_EVENT_ID_LAST == ARRAY_CARDINALITY(virshSecretEventCallbacks));
+verify(VIR_SECRET_EVENT_ID_LAST == G_N_ELEMENTS(virshSecretEventCallbacks));
static const vshCmdInfo info_secret_event[] = {
{.name = "help",
N_("NOTE"),
};
-verify(ARRAY_CARDINALITY(failMessages) == VIR_HOST_VALIDATE_LAST);
+verify(G_N_ELEMENTS(failMessages) == VIR_HOST_VALIDATE_LAST);
static const char *failEscapeCodes[] = {
"\033[31m",
"\033[34m",
};
-verify(ARRAY_CARDINALITY(failEscapeCodes) == VIR_HOST_VALIDATE_LAST);
+verify(G_N_ELEMENTS(failEscapeCodes) == VIR_HOST_VALIDATE_LAST);
void virHostMsgFail(virHostValidateLevel level,
const char *format,
projects / libvirt.git / commitdiff