自学教程：C++ ARRAY_CARDINALITY函数代码示例

static int testQemuAddArmGuest(virCapsPtr caps){    static const char *machines[] = { "vexpress-a9",                                      "vexpress-a15",                                      "versatilepb" };    virCapsGuestMachinePtr *capsmachines = NULL;    virCapsGuestPtr guest;    capsmachines = virCapabilitiesAllocMachines(machines,                                                ARRAY_CARDINALITY(machines));    if (!capsmachines)        goto error;    guest = virCapabilitiesAddGuest(caps, "hvm", VIR_ARCH_ARMV7L,                                    "/usr/bin/qemu-system-arm", NULL,                                    ARRAY_CARDINALITY(machines),                                    capsmachines);    if (!guest)        goto error;    if (!virCapabilitiesAddGuestDomain(guest, "qemu", NULL, NULL, 0, NULL))        goto error;    return 0; error:    virCapabilitiesFreeMachines(capsmachines, ARRAY_CARDINALITY(machines));    return -1;}

static int testQemuAddS390Guest(virCapsPtr caps){    static const char *s390_machines[] = { "s390-virtio",                                           "s390-ccw-virtio" };    virCapsGuestMachinePtr *machines = NULL;    virCapsGuestPtr guest;    machines = virCapabilitiesAllocMachines(s390_machines,                                            ARRAY_CARDINALITY(s390_machines));    if (!machines)        goto error;    guest = virCapabilitiesAddGuest(caps, VIR_DOMAIN_OSTYPE_HVM, VIR_ARCH_S390X,                                    "/usr/bin/qemu-system-s390x", NULL,                                    ARRAY_CARDINALITY(s390_machines),                                    machines);    if (!guest)        goto error;    if (!virCapabilitiesAddGuestDomain(guest, VIR_DOMAIN_VIRT_QEMU, NULL, NULL, 0, NULL))        goto error;    return 0; error:    virCapabilitiesFreeMachines(machines, ARRAY_CARDINALITY(s390_machines));    return -1;}

static inttestAddCPUModels(virQEMUCapsPtr caps, bool skipLegacy){    const char *newModels[] = {        "Opteron_G3", "Opteron_G2", "Opteron_G1",        "Nehalem", "Penryn", "Conroe",    };    const char *legacyModels[] = {        "n270", "athlon", "pentium3", "pentium2", "pentium",        "486", "coreduo", "kvm32", "qemu32", "kvm64",        "core2duo", "phenom", "qemu64",    };    size_t i;    for (i = 0; i < ARRAY_CARDINALITY(newModels); i++) {        if (virQEMUCapsAddCPUDefinition(caps, newModels[i]) < 0)            return -1;    }    if (skipLegacy)        return 0;    for (i = 0; i < ARRAY_CARDINALITY(legacyModels); i++) {        if (virQEMUCapsAddCPUDefinition(caps, legacyModels[i]) < 0)            return -1;    }    return 0;}

static int testQemuAddAARCH64Guest(virCapsPtr caps){    static const char *machines[] = { "virt"};    virCapsGuestMachinePtr *capsmachines = NULL;    virCapsGuestPtr guest;    capsmachines = virCapabilitiesAllocMachines(machines,                                                ARRAY_CARDINALITY(machines));    if (!capsmachines)        goto error;    guest = virCapabilitiesAddGuest(caps, VIR_DOMAIN_OSTYPE_HVM, VIR_ARCH_AARCH64,                                    "/usr/bin/qemu-system-aarch64", NULL,                                    ARRAY_CARDINALITY(machines),                                    capsmachines);    if (!guest)        goto error;    if (!virCapabilitiesAddGuestDomain(guest, VIR_DOMAIN_VIRT_QEMU, NULL, NULL, 0, NULL))        goto error;    return 0; error:    virCapabilitiesFreeMachines(capsmachines, ARRAY_CARDINALITY(machines));    return -1;}

static int testQemuAddArmGuest(virCapsPtr caps){    static const char *machines[] = { "vexpress-a9",                                      "vexpress-a15",                                      "versatilepb" };    virCapsGuestMachinePtr *capsmachines = NULL;    virCapsGuestPtr guest;    capsmachines = virCapabilitiesAllocMachines(machines,                                                ARRAY_CARDINALITY(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),                                    capsmachines);    if (!guest)        goto error;    if (!virCapabilitiesAddGuestDomain(guest, VIR_DOMAIN_VIRT_QEMU, NULL, NULL, 0, NULL))        goto error;    return 0; error:    virCapabilitiesFreeMachines(capsmachines, ARRAY_CARDINALITY(machines));    return -1;}

int qemuTestCapsCacheInsert(virQEMUCapsCachePtr cache,                            virQEMUCapsPtr caps){    size_t i;    virQEMUCapsPtr tmpCaps;    if (caps) {        tmpCaps = caps;    } else {        if (!(tmpCaps = virQEMUCapsNew()))            return -ENOMEM;    }    for (i = 0; i < ARRAY_CARDINALITY(QEMUBinList); i++) {        virObjectRef(tmpCaps);        if (virHashUpdateEntry(cache->binaries,                               QEMUBinList[i],                               tmpCaps) < 0) {            virObjectUnref(tmpCaps);            return -1;        }    }    if (!caps)        virObjectUnref(tmpCaps);    return 0;}

static intgather_capability(LibHalContext *ctx, const char *udi,                  const char *cap_name,                  virNodeDevCapsDefPtr *caps_p){    caps_tbl_entry *entry;    entry = bsearch(&cap_name, caps_tbl, ARRAY_CARDINALITY(caps_tbl),                    sizeof(caps_tbl[0]), cmpstringp);    if (entry) {        virNodeDevCapsDefPtr caps;        if (VIR_ALLOC(caps) < 0)            return ENOMEM;        caps->type = entry->type;        if (entry->gather_fn) {            int rv = (*entry->gather_fn)(ctx, udi, &caps->data);            if (rv != 0) {                virNodeDevCapsDefFree(caps);                return rv;            }        }        caps->next = *caps_p;        *caps_p = caps;    }    return 0;}

static virCapsGuestMachinePtr *testQemuAllocMachines(int *nmachines){    virCapsGuestMachinePtr *machines;    static const char *const x86_machines[] = {        "pc", "isapc"    };    machines = virCapabilitiesAllocMachines(x86_machines,                                            ARRAY_CARDINALITY(x86_machines));    if (machines == NULL)        return NULL;    *nmachines = ARRAY_CARDINALITY(x86_machines);    return machines;}

static int64_tread_bd_stat(int device, int domid, const char *str){    static const char *paths[] = {        "/sys/bus/xen-backend/devices/vbd-%d-%d/statistics/%s",        "/sys/bus/xen-backend/devices/tap-%d-%d/statistics/%s",        "/sys/devices/xen-backend/vbd-%d-%d/statistics/%s",        "/sys/devices/xen-backend/tap-%d-%d/statistics/%s"    };    int i;    char *path;    int64_t r;    for (i = 0; i < ARRAY_CARDINALITY(paths); ++i) {        if (virAsprintf(&path, paths[i], domid, device, str) < 0) {            virReportOOMError();            return -1;        }        r = read_stat(path);        VIR_FREE(path);        if (r >= 0) {            return r;        }    }    return -1;}

static intmymain(void){    int ret = 0;    int i;    const char *nodeData[] = {        "test1",# if !(defined(__powerpc__) ||                  /       defined(__powerpc64__))        "test2",        "test3",        "test4",        "test5",        "test6",# endif    };    if (virInitialize() < 0)        return EXIT_FAILURE;    for (i = 0 ; i < ARRAY_CARDINALITY(nodeData); i++)      if (virtTestRun(nodeData[i], 1, linuxTestNodeInfo, nodeData[i]) != 0)        ret = -1;    return ret==0 ? EXIT_SUCCESS : EXIT_FAILURE;}

static int lxcContainerPopulateDevices(void){    int i;    const struct {        int maj;        int min;        mode_t mode;        const char *path;    } devs[] = {        { LXC_DEV_MAJ_MEMORY, LXC_DEV_MIN_NULL, 0666, "/dev/null" },        { LXC_DEV_MAJ_MEMORY, LXC_DEV_MIN_ZERO, 0666, "/dev/zero" },        { LXC_DEV_MAJ_MEMORY, LXC_DEV_MIN_FULL, 0666, "/dev/full" },        { LXC_DEV_MAJ_TTY, LXC_DEV_MIN_CONSOLE, 0600, "/dev/console" },        { LXC_DEV_MAJ_MEMORY, LXC_DEV_MIN_RANDOM, 0666, "/dev/random" },        { LXC_DEV_MAJ_MEMORY, LXC_DEV_MIN_URANDOM, 0666, "/dev/urandom" },    };    /* Populate /dev/ with a few important bits */    for (i = 0 ; i < ARRAY_CARDINALITY(devs) ; i++) {        dev_t dev = makedev(devs[i].maj, devs[i].min);        if (mknod(devs[i].path, S_IFCHR, dev) < 0 ||            chmod(devs[i].path, devs[i].mode)) {            virReportSystemError(errno,                                 _("Failed to make device %s"),                                 devs[i].path);            return -1;        }    }    if (access("/dev/pts/ptmx", W_OK) == 0) {        if (symlink("/dev/pts/ptmx", "/dev/ptmx") < 0) {            virReportSystemError(errno, "%s",                                 _("Failed to create symlink /dev/ptmx to /dev/pts/ptmx"));            return -1;        }    } else {        dev_t dev = makedev(LXC_DEV_MAJ_TTY, LXC_DEV_MIN_PTMX);        if (mknod("/dev/ptmx", S_IFCHR, dev) < 0 ||            chmod("/dev/ptmx", 0666)) {            virReportSystemError(errno, "%s",                                 _("Failed to make device /dev/ptmx"));            return -1;        }    }    /* XXX we should allow multiple consoles per container     * for tty2, tty3, etc, but the domain XML does not     * handle this yet     */    if (symlink("/dev/pts/0", "/dev/tty1") < 0) {        virReportSystemError(errno, "%s",                             _("Failed to symlink /dev/pts/0 to /dev/tty1"));        return -1;    }    return 0;}

static int lxcContainerMountBasicFS(virDomainFSDefPtr root){    const struct {        const char *src;        const char *dst;        const char *type;    } mnts[] = {        { "/dev", "/dev", "tmpfs" },        { "/proc", "/proc", "proc" },        { "/sys", "/sys", "sysfs" },#if WITH_SELINUX        { "none", "/selinux", "selinuxfs" },#endif    };    int i, rc = -1;    char *devpts;    if (virAsprintf(&devpts, "/.oldroot%s/dev/pts", root->src) < 0) {        virReportOOMError();        return rc;    }    for (i = 0 ; i < ARRAY_CARDINALITY(mnts) ; i++) {        if (virFileMakePath(mnts[i].dst) != 0) {            virReportSystemError(errno,                                 _("Failed to mkdir %s"),                                 mnts[i].src);            goto cleanup;        }        if (mount(mnts[i].src, mnts[i].dst, mnts[i].type, 0, NULL) < 0) {            virReportSystemError(errno,                                 _("Failed to mount %s on %s"),                                 mnts[i].type, mnts[i].type);            goto cleanup;        }    }    if ((rc = virFileMakePath("/dev/pts") != 0)) {        virReportSystemError(rc, "%s",                             _("Cannot create /dev/pts"));        goto cleanup;    }    VIR_DEBUG("Trying to move %s to %s", devpts, "/dev/pts");    if ((rc = mount(devpts, "/dev/pts", NULL, MS_MOVE, NULL)) < 0) {        virReportSystemError(errno, "%s",                             _("Failed to mount /dev/pts in container"));        goto cleanup;    }    rc = 0; cleanup:    VIR_FREE(devpts);    return rc;}

static virHashTablePtrtestHashInit(int size){    virHashTablePtr hash;    ssize_t i;    if (!(hash = virHashCreate(size, NULL)))        return NULL;    /* entires 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--) {        ssize_t oldsize = virHashTableSize(hash);        if (virHashAddEntry(hash, uuids[i], (void *) uuids[i]) < 0) {            virHashFree(hash);            return NULL;        }        if (virHashTableSize(hash) != oldsize && virTestGetDebug()) {            VIR_WARN("hash grown from %zd to %zd",                     (size_t)oldsize, (size_t)virHashTableSize(hash));        }    }    for (i = 0; i < ARRAY_CARDINALITY(uuids); i++) {        if (!virHashLookup(hash, uuids[i])) {            if (virTestGetVerbose()) {                VIR_WARN("/nentry /"%s/" could not be found/n",                         uuids[i]);            }            virHashFree(hash);            return NULL;        }    }    if (size && size != virHashTableSize(hash) && virTestGetDebug())        fprintf(stderr, "/n");    return hash;}

/** * Tries to locate and load VBoxXPCOMC.so/dylib/dll, resolving all the related * function pointers. * * @returns 0 on success, -1 on failure. */intVBoxCGlueInit(unsigned int *version){    int i;    static const char *knownDirs[] = {        "/usr/lib/virtualbox",        "/usr/lib/virtualbox-ose",        "/usr/lib64/virtualbox",        "/usr/lib64/virtualbox-ose",        "/usr/lib/VirtualBox",        "/opt/virtualbox",        "/opt/VirtualBox",        "/opt/virtualbox/i386",        "/opt/VirtualBox/i386",        "/opt/virtualbox/amd64",        "/opt/VirtualBox/amd64",        "/usr/local/lib/virtualbox",        "/usr/local/lib/VirtualBox",        "/Applications/VirtualBox.app/Contents/MacOS"    };    const char *home = getenv("VBOX_APP_HOME");    /* If the user specifies the location, try only that. */    if (home != NULL) {        if (tryLoadOne(home, false, false, version) < 0) {            return -1;        }    }    /* Try the additionally configured location. */    if (VBOX_XPCOMC_DIR[0] != '/0') {        if (tryLoadOne(VBOX_XPCOMC_DIR, true, true, version) >= 0) {            return 0;        }    }    /* Try the known locations. */    for (i = 0; i < ARRAY_CARDINALITY(knownDirs); ++i) {        if (tryLoadOne(knownDirs[i], true, true, version) >= 0) {            return 0;        }    }    /* Finally try the dynamic linker search path. */    if (tryLoadOne(NULL, false, true, version) >= 0) {        return 0;    }    /* No luck, return failure. */    return -1;}

static void testRemoveCommonRules(char *rules){    size_t i;    char *offset = rules;    for (i = 0; i < ARRAY_CARDINALITY(commonRules); i++) {        char *tmp = strstr(offset, commonRules[i]);        size_t len = strlen(commonRules[i]);        if (tmp) {            memmove(tmp, tmp + len, (strlen(tmp) + 1) - len);            offset = tmp;        }    }}

/* * TODO: Adapt virNumaGetHugePageInfo{Path,Dir} to use sysfs so that the * paths can be modified and this function can be thrown away and instead we'd * have copied info from /sys (as we do with /sys/devices/system). */intvirNumaGetPages(int node,                unsigned int **pages_size,                unsigned int **pages_avail,                unsigned int **pages_free,                size_t *npages){    const int pages_def[] = { 4, 2 * 1024, 1 * 1024 * 1024};    const int npages_def = ARRAY_CARDINALITY(pages_def);    size_t i = 0;    if (pages_size)        *pages_size = NULL;    if (pages_avail)        *pages_avail = NULL;    if (pages_free)        *pages_free = NULL;    *npages = 0;    if ((pages_size && VIR_ALLOC_N(*pages_size, npages_def) < 0) ||        (pages_avail && VIR_ALLOC_N(*pages_avail, npages_def) < 0) ||        (pages_free && VIR_ALLOC_N(*pages_free, npages_def) < 0)) {        VIR_FREE(*pages_size);        VIR_FREE(*pages_avail);        return -1;    }    *npages = npages_def;    if (pages_size)        memcpy(*pages_size, pages_def, sizeof(pages_def));    node++;    if (node <= 0)        node = 32;    if (pages_avail || pages_free) {        for (i = 0; i < *npages; i++) {            if (pages_avail)                (*pages_avail)[i] = (node + i) * 2 << 10;            if (pages_free)                (*pages_free)[i] = (node + i) * 1 << 10;        }    }    return 0;}

static struct cpuArchDriver *cpuGetSubDriverByName(const char *name){    size_t i;    for (i = 0; i < ARRAY_CARDINALITY(drivers); i++) {        if (STREQ_NULLABLE(name, drivers[i]->name))            return drivers[i];    }    virReportError(VIR_ERR_INTERNAL_ERROR,                   _("CPU driver '%s' does not exist"),                   name);    return NULL;}

static char *errtok(char *s, int *err) {    char *t = skipws(s);    s = findws(t);    if (s == t) {        *err = AUG_NOERROR;        return s;    }    for (*err = 0; *err < ARRAY_CARDINALITY(errtokens); *err += 1) {        const char *e = errtokens[*err];        if (strlen(e) == s - t && STREQLEN(e, t, s - t))            return s;    }    fprintf(stderr, "errtok: '%s'/n", t);    die("unknown error code");}

intvirDomainSnapshotObjListGetNames(virDomainSnapshotObjListPtr snapshots,                                 virDomainMomentObjPtr from,                                 char **const names,                                 int maxnames,                                 unsigned int flags){    /* Convert public flags into common flags */    unsigned int moment_flags = 0;    struct { int snap_flag; int moment_flag; } map[] = {        { VIR_DOMAIN_SNAPSHOT_LIST_ROOTS,          VIR_DOMAIN_MOMENT_LIST_ROOTS, },        { VIR_DOMAIN_SNAPSHOT_LIST_TOPOLOGICAL,          VIR_DOMAIN_MOMENT_LIST_TOPOLOGICAL, },        { VIR_DOMAIN_SNAPSHOT_LIST_LEAVES,          VIR_DOMAIN_MOMENT_LIST_LEAVES, },        { VIR_DOMAIN_SNAPSHOT_LIST_NO_LEAVES,          VIR_DOMAIN_MOMENT_LIST_NO_LEAVES, },        { VIR_DOMAIN_SNAPSHOT_LIST_METADATA,          VIR_DOMAIN_MOMENT_LIST_METADATA, },        { VIR_DOMAIN_SNAPSHOT_LIST_NO_METADATA,          VIR_DOMAIN_MOMENT_LIST_NO_METADATA, },    };    size_t i;    for (i = 0; i < ARRAY_CARDINALITY(map); i++) {        if (flags & map[i].snap_flag) {            flags &= ~map[i].snap_flag;            moment_flags |= map[i].moment_flag;        }    }    /* For ease of coding the visitor, it is easier to zero each group     * where all of the bits are set.  */    if ((flags & VIR_DOMAIN_SNAPSHOT_FILTERS_LEAVES) ==        VIR_DOMAIN_SNAPSHOT_FILTERS_LEAVES)        flags &= ~VIR_DOMAIN_SNAPSHOT_FILTERS_LEAVES;    if ((flags & VIR_DOMAIN_SNAPSHOT_FILTERS_STATUS) ==        VIR_DOMAIN_SNAPSHOT_FILTERS_STATUS)        flags &= ~VIR_DOMAIN_SNAPSHOT_FILTERS_STATUS;    if ((flags & VIR_DOMAIN_SNAPSHOT_FILTERS_LOCATION) ==        VIR_DOMAIN_SNAPSHOT_FILTERS_LOCATION)        flags &= ~VIR_DOMAIN_SNAPSHOT_FILTERS_LOCATION;    return virDomainMomentObjListGetNames(snapshots->base, from, names,                                          maxnames, moment_flags,                                          virDomainSnapshotFilter, flags);}

virSecurityDriverPtr virSecurityDriverLookup(const char *name,                                             const char *virtDriver){    virSecurityDriverPtr drv = NULL;    size_t i;    VIR_DEBUG("name=%s", NULLSTR(name));    for (i = 0; i < ARRAY_CARDINALITY(security_drivers) && !drv; i++) {        virSecurityDriverPtr tmp = security_drivers[i];        if (name &&            STRNEQ(tmp->name, name))            continue;        switch (tmp->probe(virtDriver)) {        case SECURITY_DRIVER_ENABLE:            VIR_DEBUG("Probed name=%s", tmp->name);            drv = tmp;            break;        case SECURITY_DRIVER_DISABLE:            VIR_DEBUG("Not enabled name=%s", tmp->name);            if (name && STREQ(tmp->name, name)) {                virReportError(VIR_ERR_CONFIG_UNSUPPORTED,                               _("Security driver %s not enabled"),                               name);                return NULL;            }            break;        case SECURITY_DRIVER_ERROR:        default:            return NULL;        }    }    if (!drv) {        virReportError(VIR_ERR_INTERNAL_ERROR,                       _("Security driver %s not found"),                       NULLSTR(name));        return NULL;    }    return drv;}

static inttestHashGrow(const void *data){    const struct testInfo *info = data;    virHashTablePtr hash;    int ret = -1;    if (!(hash = testHashInit(info->count)))        return -1;    if (testHashCheckCount(hash, ARRAY_CARDINALITY(uuids)) < 0)        goto cleanup;    ret = 0;cleanup:    virHashFree(hash);    return ret;}

static voidvirLogStackTraceToFd(int fd){    void *array[100];    int size;    static bool doneWarning = false;    const char *msg = "Stack trace not available on this platform/n";#define STRIP_DEPTH 3    size = backtrace(array, ARRAY_CARDINALITY(array));    if (size) {        backtrace_symbols_fd(array +  STRIP_DEPTH, size - STRIP_DEPTH, fd);        ignore_value(safewrite(fd, "/n", 1));    } else if (!doneWarning) {        ignore_value(safewrite(fd, msg, strlen(msg)));        doneWarning = true;    }#undef STRIP_DEPTH}

int virProcessGetNamespaces(pid_t pid,                            size_t *nfdlist,                            int **fdlist){    int ret = -1;    char *nsfile = NULL;    size_t i = 0;    const char *ns[] = { "user", "ipc", "uts", "net", "pid", "mnt" };    *nfdlist = 0;    *fdlist = NULL;    for (i = 0; i < ARRAY_CARDINALITY(ns); i++) {        int fd;        if (virAsprintf(&nsfile, "/proc/%llu/ns/%s",                        (unsigned long long)pid,                        ns[i]) < 0)            goto cleanup;        if ((fd = open(nsfile, O_RDONLY)) >= 0) {            if (VIR_EXPAND_N(*fdlist, *nfdlist, 1) < 0) {                VIR_FORCE_CLOSE(fd);                goto cleanup;            }            (*fdlist)[(*nfdlist)-1] = fd;        }        VIR_FREE(nsfile);    }    ret = 0; cleanup:    VIR_FREE(nsfile);    if (ret < 0) {        for (i = 0; i < *nfdlist; i++)            VIR_FORCE_CLOSE((*fdlist)[i]);        VIR_FREE(*fdlist);    }    return ret;}

static intmymain(void){    int ret = 0;    size_t i;    const struct linuxTestNodeInfoData nodeData[] = {        {"test1", VIR_ARCH_X86_64},        {"test1", VIR_ARCH_PPC},        {"test2", VIR_ARCH_X86_64},        {"test3", VIR_ARCH_X86_64},        {"test4", VIR_ARCH_X86_64},        {"test5", VIR_ARCH_X86_64},        {"test6", VIR_ARCH_X86_64},        {"test7", VIR_ARCH_X86_64},        {"test8", VIR_ARCH_X86_64},        {"raspberrypi", VIR_ARCH_ARMV6L},        {"f21-mustang", VIR_ARCH_AARCH64},        {"rhelsa-3.19.0-mustang", VIR_ARCH_AARCH64},        {"deconfigured-cpus", VIR_ARCH_PPC64},    };    if (virInitialize() < 0)        return EXIT_FAILURE;    for (i = 0; i < ARRAY_CARDINALITY(nodeData); i++)      if (virtTestRun(nodeData[i].testName, linuxTestNodeInfo, &nodeData[i]) != 0)        ret = -1;# define DO_TEST_CPU_STATS(name, ncpus) /    do { /        static struct nodeCPUStatsData data = { name, ncpus }; /        if (virtTestRun("CPU stats " name, linuxTestNodeCPUStats, &data) < 0) /            ret = -1; /    } while (0)    DO_TEST_CPU_STATS("24cpu", 24);    return ret == 0 ? EXIT_SUCCESS : EXIT_FAILURE;}

static void testListInterfaces(CuTest *tc) {    int nint;    char **names;    static const char *const exp_names[] =        { "br0", "bond0", "lo", "eth3", "eth4" };    static const int exp_nint = ARRAY_CARDINALITY(exp_names);    nint = ncf_num_of_interfaces(ncf, NETCF_IFACE_ACTIVE|NETCF_IFACE_INACTIVE);    CuAssertIntEquals(tc, exp_nint, nint);    if (ALLOC_N(names, nint) < 0)        die("allocation failed");    nint = ncf_list_interfaces(ncf, nint, names, NETCF_IFACE_ACTIVE|NETCF_IFACE_INACTIVE);    CuAssertIntEquals(tc, exp_nint, nint);    for (int i=0; i < exp_nint; i++) {        int found = 0;        for (int j=0; j < nint; j++) {            if (STREQ(names[j], exp_names[i]))                found = 1;        }        CuAssert(tc, "Unknown interface name", found);    }}

static int virCgroupCpuSetInherit(virCgroupPtr parent, virCgroupPtr group){    int i;    int rc = 0;    const char *inherit_values[] = {        "cpuset.cpus",        "cpuset.mems",    };    VIR_DEBUG("Setting up inheritance %s -> %s", parent->path, group->path);    for (i = 0; i < ARRAY_CARDINALITY(inherit_values) ; i++) {        char *value;        rc = virCgroupGetValueStr(parent,                                  VIR_CGROUP_CONTROLLER_CPUSET,                                  inherit_values[i],                                  &value);        if (rc != 0) {            VIR_ERROR(_("Failed to get %s %d"), inherit_values[i], rc);            break;        }        VIR_DEBUG("Inherit %s = %s", inherit_values[i], value);        rc = virCgroupSetValueStr(group,                                  VIR_CGROUP_CONTROLLER_CPUSET,                                  inherit_values[i],                                  value);        VIR_FREE(value);        if (rc != 0) {            VIR_ERROR(_("Failed to set %s %d"), inherit_values[i], rc);            break;        }    }    return rc;}

static int testRotatingFileReaderAssertBufferContent(const char *buf,                                                     size_t buflen,                                                     size_t nregions,                                                     size_t *sizes){    size_t i, j;    char bytes[] = { FILEBYTE, FILEBYTE0, FILEBYTE1 };    size_t total = 0;    if (nregions > ARRAY_CARDINALITY(bytes)) {        fprintf(stderr, "Too many regions %zu/n", nregions);        return -1;    }    for (i = 0; i < nregions; i++)        total += sizes[i];    if (total != buflen) {        fprintf(stderr, "Expected %zu bytes in file not %zu/n",                total, buflen);        return -1;    }    for (i = 0; i < nregions; i++) {        char want = bytes[nregions - (i + 1)];        for (j = 0; j < sizes[i]; j++) {            if (*buf != want) {                fprintf(stderr,                        "Expected '0x%x' but got '0x%x' at region %zu byte %zu/n",                        want & 0xff, *buf & 0xff, i, j);                return -1;            }            buf++;        }    }    return 0;}

static struct cpuArchDriver *cpuGetSubDriver(virArch arch){    size_t i;    size_t j;    if (arch == VIR_ARCH_NONE) {        virReportError(VIR_ERR_INTERNAL_ERROR,                       "%s", _("undefined hardware architecture"));        return NULL;    }    for (i = 0; i < ARRAY_CARDINALITY(drivers); i++) {        for (j = 0; j < drivers[i]->narch; j++) {            if (arch == drivers[i]->arch[j])                return drivers[i];        }    }    virReportError(VIR_ERR_NO_SUPPORT,                   _("'%s' architecture is not supported by CPU driver"),                   virArchToString(arch));    return NULL;}

    unsigned int leaseFlags = 0;    virLockManagerParam lparams[] = {        { .type = VIR_LOCK_MANAGER_PARAM_TYPE_STRING,          .key = "path",          .value = { .str = lease->path },        },        { .type = VIR_LOCK_MANAGER_PARAM_TYPE_ULONG,          .key = "offset",          .value = { .ul = lease->offset },        },        { .type = VIR_LOCK_MANAGER_PARAM_TYPE_STRING,          .key = "lockspace",          .value = { .str = lease->lockspace },        },    };    size_t nparams = ARRAY_CARDINALITY(lparams);    if (!lease->lockspace)        nparams--;    VIR_DEBUG("Add lease %s", lease->path);    if (virLockManagerAddResource(lock,                                  VIR_LOCK_MANAGER_RESOURCE_TYPE_LEASE,                                  lease->key,                                  nparams,                                  lparams,                                  leaseFlags) < 0) {        VIR_DEBUG("Failed to add lease %s", lease->path);        return -1;    }    return 0;}