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

/** * virConnectListAllNetworks: * @conn: Pointer to the hypervisor connection. * @nets: Pointer to a variable to store the array containing the network *        objects or NULL if the list is not required (just returns number *        of networks). * @flags: bitwise-OR of virConnectListAllNetworksFlags. * * Collect the list of networks, and allocate an array to store those * objects. This API solves the race inherent between virConnectListNetworks * and virConnectListDefinedNetworks. * * Normally, all networks are returned; however, @flags can be used to * filter the results for a smaller list of targeted networks.  The valid * flags are divided into groups, where each group contains bits that * describe mutually exclusive attributes of a network, and where all bits * within a group describe all possible networks. * * The first group of @flags is VIR_CONNECT_LIST_NETWORKS_ACTIVE (up) and * VIR_CONNECT_LIST_NETWORKS_INACTIVE (down) to filter the networks by state. * * The second group of @flags is VIR_CONNECT_LIST_NETWORKS_PERSISTENT (defined) * and VIR_CONNECT_LIST_NETWORKS_TRANSIENT (running but not defined), to filter * the networks by whether they have persistent config or not. * * The third group of @flags is VIR_CONNECT_LIST_NETWORKS_AUTOSTART * and VIR_CONNECT_LIST_NETWORKS_NO_AUTOSTART, to filter the networks by * whether they are marked as autostart or not. * * Returns the number of networks found or -1 and sets @nets to  NULL in case * of error.  On success, the array stored into @nets is guaranteed to have an * extra allocated element set to NULL but not included in the return count, * to make iteration easier.  The caller is responsible for calling * virNetworkFree() on each array element, then calling free() on @nets. */intvirConnectListAllNetworks(virConnectPtr conn,                          virNetworkPtr **nets,                          unsigned int flags){    VIR_DEBUG("conn=%p, nets=%p, flags=0x%x", conn, nets, flags);    virResetLastError();    if (nets)        *nets = NULL;    virCheckConnectReturn(conn, -1);    if (conn->networkDriver &&        conn->networkDriver->connectListAllNetworks) {        int ret;        ret = conn->networkDriver->connectListAllNetworks(conn, nets, flags);        if (ret < 0)            goto error;        return ret;    }    virReportUnsupportedError(); error:    virDispatchError(conn);    return -1;}

/** * virDomainSnapshotLookupByName: * @domain: a domain object * @name: name for the domain snapshot * @flags: extra flags; not used yet, so callers should always pass 0 * * Try to lookup a domain snapshot based on its name. * * Returns a domain snapshot object or NULL in case of failure.  If the * domain snapshot cannot be found, then the VIR_ERR_NO_DOMAIN_SNAPSHOT * error is raised. */virDomainSnapshotPtrvirDomainSnapshotLookupByName(virDomainPtr domain,                              const char *name,                              unsigned int flags){    virConnectPtr conn;    VIR_DOMAIN_DEBUG(domain, "name=%s, flags=0x%x", name, flags);    virResetLastError();    virCheckDomainReturn(domain, NULL);    conn = domain->conn;    virCheckNonNullArgGoto(name, error);    if (conn->driver->domainSnapshotLookupByName) {        virDomainSnapshotPtr dom;        dom = conn->driver->domainSnapshotLookupByName(domain, name, flags);        if (!dom)            goto error;        return dom;    }    virReportUnsupportedError(); error:    virDispatchError(conn);    return NULL;}

/** * virDomainSnapshotGetParent: * @snapshot: a snapshot object * @flags: extra flags; not used yet, so callers should always pass 0 * * Get the parent snapshot for @snapshot, if any. * * virDomainSnapshotFree should be used to free the resources after the * snapshot object is no longer needed. * * Returns a domain snapshot object or NULL in case of failure.  If the * given snapshot is a root (no parent), then the VIR_ERR_NO_DOMAIN_SNAPSHOT * error is raised. */virDomainSnapshotPtrvirDomainSnapshotGetParent(virDomainSnapshotPtr snapshot,                           unsigned int flags){    virConnectPtr conn;    VIR_DEBUG("snapshot=%p, flags=0x%x", snapshot, flags);    virResetLastError();    virCheckDomainSnapshotReturn(snapshot, NULL);    conn = snapshot->domain->conn;    if (conn->driver->domainSnapshotGetParent) {        virDomainSnapshotPtr snap;        snap = conn->driver->domainSnapshotGetParent(snapshot, flags);        if (!snap)            goto error;        return snap;    }    virReportUnsupportedError(); error:    virDispatchError(conn);    return NULL;}

/** * virDomainSnapshotGetXMLDesc: * @snapshot: a domain snapshot object * @flags: bitwise-OR of supported virDomainSnapshotXMLFlags * * Provide an XML description of the domain snapshot, with a top-level * element of <domainsnapshot>. * * No security-sensitive data will be included unless @flags contains * VIR_DOMAIN_SNAPSHOT_XML_SECURE; this flag is rejected on read-only * connections. * * Returns a 0 terminated UTF-8 encoded XML instance or NULL in case * of error. The caller must free() the returned value. */char *virDomainSnapshotGetXMLDesc(virDomainSnapshotPtr snapshot,                            unsigned int flags){    virConnectPtr conn;    VIR_DEBUG("snapshot=%p, flags=0x%x", snapshot, flags);    virResetLastError();    virCheckDomainSnapshotReturn(snapshot, NULL);    conn = snapshot->domain->conn;    if ((conn->flags & VIR_CONNECT_RO) &&        (flags & VIR_DOMAIN_SNAPSHOT_XML_SECURE)) {        virReportError(VIR_ERR_OPERATION_DENIED, "%s",                       _("virDomainSnapshotGetXMLDesc with secure flag"));        goto error;    }    if (conn->driver->domainSnapshotGetXMLDesc) {        char *ret;        ret = conn->driver->domainSnapshotGetXMLDesc(snapshot, flags);        if (!ret)            goto error;        return ret;    }    virReportUnsupportedError(); error:    virDispatchError(conn);    return NULL;}

/** * virDomainSnapshotListChildrenNames: * @snapshot: a domain snapshot object * @names: array to collect the list of names of snapshots * @nameslen: size of @names * @flags: bitwise-OR of supported virDomainSnapshotListFlags * * Collect the list of domain snapshots that are children of the given * snapshot, and store their names in @names.  The value to use for * @nameslen can be determined by virDomainSnapshotNumChildren() with * the same @flags. * * If @flags lacks VIR_DOMAIN_SNAPSHOT_LIST_DESCENDANTS or contains * VIR_DOMAIN_SNAPSHOT_LIST_TOPOLOGICAL, and no other connection is * modifying snapshots, then it is guaranteed that for any snapshot in * the resulting list, no snapshots later in the list can be reached * by a sequence of virDomainSnapshotGetParent() starting from that * earlier snapshot; otherwise, the order of snapshots in the * resulting list is unspecified. * * By default, this command covers only direct children. It is also * possible to expand things to cover all descendants, when @flags * includes VIR_DOMAIN_SNAPSHOT_LIST_DESCENDANTS. Additional filters * are provided via the same @flags values as documented in * virDomainSnapshotListAllChildren(). * * Note that this command is inherently racy: another connection can * define a new snapshot between a call to virDomainSnapshotNumChildren() * and this call.  You are only guaranteed that all currently defined * snapshots were listed if the return is less than @nameslen.  Likewise, * you should be prepared for virDomainSnapshotLookupByName() to fail when * converting a name from this call into a snapshot object, if another * connection deletes the snapshot in the meantime.  For more control over * the results, see virDomainSnapshotListAllChildren(). * * Returns the number of domain snapshots found or -1 in case of error. * The caller is responsible to call free() for each member of the array. */intvirDomainSnapshotListChildrenNames(virDomainSnapshotPtr snapshot,                                   char **names, int nameslen,                                   unsigned int flags){    virConnectPtr conn;    VIR_DEBUG("snapshot=%p, names=%p, nameslen=%d, flags=0x%x",              snapshot, names, nameslen, flags);    virResetLastError();    virCheckDomainSnapshotReturn(snapshot, -1);    conn = snapshot->domain->conn;    virCheckNonNullArgGoto(names, error);    virCheckNonNegativeArgGoto(nameslen, error);    if (conn->driver->domainSnapshotListChildrenNames) {        int ret = conn->driver->domainSnapshotListChildrenNames(snapshot,                                                                names,                                                                nameslen,                                                                flags);        if (ret < 0)            goto error;        return ret;    }    virReportUnsupportedError(); error:    virDispatchError(conn);    return -1;}

/** * virDomainQemuAgentCommand: * @domain: a domain object * @cmd: the guest agent command string * @timeout: timeout seconds * @flags: execution flags * * Execute an arbitrary Guest Agent command. * * Issue @cmd to the guest agent running in @domain. * @timeout must be -2, -1, 0 or positive. * VIR_DOMAIN_QEMU_AGENT_COMMAND_BLOCK(-2): meaning to block forever waiting for * a result. * VIR_DOMAIN_QEMU_AGENT_COMMAND_DEFAULT(-1): use default timeout value. * VIR_DOMAIN_QEMU_AGENT_COMMAND_NOWAIT(0): does not wait. * positive value: wait for @timeout seconds * * Returns strings if success, NULL in failure. */char *virDomainQemuAgentCommand(virDomainPtr domain,                          const char *cmd,                          int timeout,                          unsigned int flags){    virConnectPtr conn;    char *ret;    VIR_DOMAIN_DEBUG(domain, "cmd=%s, timeout=%d, flags=%x",                     cmd, timeout, flags);    virResetLastError();    virCheckDomainReturn(domain, NULL);    conn = domain->conn;    virCheckReadOnlyGoto(conn->flags, error);    if (conn->driver->domainQemuAgentCommand) {        ret = conn->driver->domainQemuAgentCommand(domain, cmd,                                                   timeout, flags);        if (!ret)            goto error;        return ret;    }    virReportUnsupportedError();error:    virDispatchError(conn);    return NULL;}

static inttestLogParseFilters(const void *opaque){    int ret = -1;    int nfilters;    const struct testLogData *data = opaque;    nfilters = virLogParseFilters(data->str);    if (nfilters < 0) {        if (!data->pass) {            VIR_TEST_DEBUG("Got expected error: %s/n",                           virGetLastErrorMessage());            virResetLastError();            ret = 0;            goto cleanup;        }    } else if (nfilters != data->count) {        VIR_TEST_DEBUG("Expected number of parsed outputs is %d, "                       "but got %d/n", data->count, nfilters);        goto cleanup;    } else if (!data->pass) {        VIR_TEST_DEBUG("Test should have failed/n");        goto cleanup;    }    ret = 0; cleanup:    virLogReset();    return ret;}

/** * virAdmServerGetThreadPoolParameters: * @srv: a valid server object reference * @params: pointer to a list of typed parameters which will be allocated *          to store all returned parameters * @nparams: pointer which will hold the number of params returned in @params * @flags: extra flags; not used yet, so callers should always pass 0 * * Retrieves threadpool parameters from @srv. Upon successful completion, * @params will be allocated automatically to hold all returned data, setting * @nparams accordingly. * When extracting parameters from @params, following search keys are * supported: *      VIR_THREADPOOL_WORKERS_MIN *      VIR_THREADPOOL_WORKERS_MAX *      VIR_THREADPOOL_WORKERS_PRIORITY *      VIR_THREADPOOL_WORKERS_FREE *      VIR_THREADPOOL_WORKERS_CURRENT * * Returns 0 on success, -1 in case of an error. */intvirAdmServerGetThreadPoolParameters(virAdmServerPtr srv,                                    virTypedParameterPtr *params,                                    int *nparams,                                    unsigned int flags){    int ret = -1;    VIR_DEBUG("srv=%p, params=%p, nparams=%p, flags=%x",              srv, params, nparams, flags);    virResetLastError();    virCheckAdmServerReturn(srv, -1);    virCheckNonNullArgGoto(params, error);    if ((ret = remoteAdminServerGetThreadPoolParameters(srv, params, nparams,                                                        flags)) < 0)        goto error;    return ret; error:    virDispatchError(NULL);    return -1;}

/** * virConnectListAllNodeDevices: * @conn: Pointer to the hypervisor connection. * @devices: Pointer to a variable to store the array containing the node *           device objects or NULL if the list is not required (just returns *           number of node devices). * @flags: bitwise-OR of virConnectListAllNodeDevices. * * Collect the list of node devices, and allocate an array to store those * objects. * * Normally, all node devices are returned; however, @flags can be used to * filter the results for a smaller list of targeted node devices.  The valid * flags are divided into groups, where each group contains bits that * describe mutually exclusive attributes of a node device, and where all bits * within a group describe all possible node devices. * * Only one group of the @flags is provided to filter the node devices by * capability type, flags include: *   VIR_CONNECT_LIST_NODE_DEVICES_CAP_SYSTEM *   VIR_CONNECT_LIST_NODE_DEVICES_CAP_PCI_DEV *   VIR_CONNECT_LIST_NODE_DEVICES_CAP_USB_DEV *   VIR_CONNECT_LIST_NODE_DEVICES_CAP_USB_INTERFACE *   VIR_CONNECT_LIST_NODE_DEVICES_CAP_NET *   VIR_CONNECT_LIST_NODE_DEVICES_CAP_SCSI_HOST *   VIR_CONNECT_LIST_NODE_DEVICES_CAP_SCSI_TARGET *   VIR_CONNECT_LIST_NODE_DEVICES_CAP_SCSI *   VIR_CONNECT_LIST_NODE_DEVICES_CAP_STORAGE *   VIR_CONNECT_LIST_NODE_DEVICES_CAP_FC_HOST *   VIR_CONNECT_LIST_NODE_DEVICES_CAP_VPORTS *   VIR_CONNECT_LIST_NODE_DEVICES_CAP_SCSI_GENERIC * * Returns the number of node devices found or -1 and sets @devices to NULL in * case of error.  On success, the array stored into @devices is guaranteed to * have an extra allocated element set to NULL but not included in the return * count, to make iteration easier.  The caller is responsible for calling * virNodeDeviceFree() on each array element, then calling free() on * @devices. */intvirConnectListAllNodeDevices(virConnectPtr conn,                             virNodeDevicePtr **devices,                             unsigned int flags){    VIR_DEBUG("conn=%p, devices=%p, flags=%x", conn, devices, flags);    virResetLastError();    if (devices)        *devices = NULL;    virCheckConnectReturn(conn, -1);    if (conn->nodeDeviceDriver &&        conn->nodeDeviceDriver->connectListAllNodeDevices) {        int ret;        ret = conn->nodeDeviceDriver->connectListAllNodeDevices(conn, devices, flags);        if (ret < 0)            goto error;        return ret;    }    virReportUnsupportedError(); error:    virDispatchError(conn);    return -1;}

static void virLXCProcessMonitorInitNotify(virLXCMonitorPtr mon ATTRIBUTE_UNUSED,                                           pid_t initpid,                                           virDomainObjPtr vm){    virLXCDriverPtr driver = lxc_driver;    virLXCDomainObjPrivatePtr priv;    virLXCDriverConfigPtr cfg = virLXCDriverGetConfig(driver);    ino_t inode;    virObjectLock(vm);    priv = vm->privateData;    priv->initpid = initpid;    if (virLXCProcessGetNsInode(initpid, "pid", &inode) < 0) {        virErrorPtr err = virGetLastError();        VIR_WARN("Cannot obtain pid NS inode for %llu: %s",                 (unsigned long long)initpid,                 err && err->message ? err->message : "<unknown>");        virResetLastError();        inode = 0;    }    virDomainAuditInit(vm, initpid, inode);    if (virDomainSaveStatus(lxc_driver->xmlopt, cfg->stateDir, vm) < 0)        VIR_WARN("Cannot update XML with PID for LXC %s", vm->def->name);    virObjectUnlock(vm);    virObjectUnref(cfg);}

/** * virAdmServerSetClientLimits: * @srv: a valid server object reference * @params: pointer to client limits object * @nparams: number of parameters in @params * @flags: extra flags; not used yet, so callers should always pass 0 * * Change client limits configuration on server @srv. * * Caller is responsible for allocating @params prior to calling this function. * See 'Manage per-server client limits' in libvirt-admin.h for * supported parameters in @params. * * Returns 0 if the limits have been changed successfully or -1 in case of an * error. */intvirAdmServerSetClientLimits(virAdmServerPtr srv,                            virTypedParameterPtr params,                            int nparams,                            unsigned int flags){    int ret = -1;    VIR_DEBUG("srv=%p, params=%p, nparams=%d, flags=%x", srv, params, nparams,              flags);    VIR_TYPED_PARAMS_DEBUG(params, nparams);    virResetLastError();    virCheckAdmServerGoto(srv, error);    virCheckNonNullArgGoto(params, error);    virCheckNonNegativeArgGoto(nparams, error);    if ((ret = remoteAdminServerSetClientLimits(srv, params, nparams,                                                flags)) < 0)        goto error;    return ret; error:    virDispatchError(NULL);    return ret;}

/** * virDomainLxcOpenNamespace: * @domain: a domain object * @fdlist: pointer to an array to be filled with FDs * @flags: currently unused, pass 0 * * This API is LXC specific, so it will only work with hypervisor * connections to the LXC driver. * * Open the namespaces associated with the container @domain. * The @fdlist array will be allocated to a suitable size, * and filled with file descriptors for the namespaces. It * is the caller's responsibility to close the file descriptors * * The returned file descriptors are intended to be used with * the setns() system call. * * Returns the number of opened file descriptors, or -1 on error */intvirDomainLxcOpenNamespace(virDomainPtr domain,                          int **fdlist,                          unsigned int flags){    virConnectPtr conn;    VIR_DOMAIN_DEBUG(domain, "fdlist=%p flags=%x", fdlist, flags);    virResetLastError();    virCheckDomainReturn(domain, -1);    conn = domain->conn;    virCheckNonNullArgGoto(fdlist, error);    virCheckReadOnlyGoto(conn->flags, error);    if (conn->driver->domainLxcOpenNamespace) {        int ret;        ret = conn->driver->domainLxcOpenNamespace(domain,                                                   fdlist,                                                   flags);        if (ret < 0)            goto error;        return ret;    }    virReportUnsupportedError(); error:    virDispatchError(conn);    return -1;}

static intqemuSetupDiskPathAllow(virDomainDiskDefPtr disk,                       const char *path,                       size_t depth ATTRIBUTE_UNUSED,                       void *opaque){    virDomainObjPtr vm = opaque;    qemuDomainObjPrivatePtr priv = vm->privateData;    int ret;    VIR_DEBUG("Process path %s for disk", path);    ret = virCgroupAllowDevicePath(priv->cgroup, path,                                   (disk->readonly ? VIR_CGROUP_DEVICE_READ                                    : VIR_CGROUP_DEVICE_RW));    virDomainAuditCgroupPath(vm, priv->cgroup, "allow", path,                             disk->readonly ? "r" : "rw", ret == 0);    /* Get this for root squash NFS */    if (ret < 0 &&        virLastErrorIsSystemErrno(EACCES)) {        VIR_DEBUG("Ignoring EACCES for %s", path);        virResetLastError();        ret = 0;    }    return ret;}

/** * virNetworkSetAutostart: * @network: a network object * @autostart: whether the network should be automatically started 0 or 1 * * Configure the network to be automatically started * when the host machine boots. * * Returns -1 in case of error, 0 in case of success */intvirNetworkSetAutostart(virNetworkPtr network,                       int autostart){    virConnectPtr conn;    VIR_DEBUG("network=%p, autostart=%d", network, autostart);    virResetLastError();    virCheckNetworkReturn(network, -1);    conn = network->conn;    virCheckReadOnlyGoto(conn->flags, error);    if (conn->networkDriver && conn->networkDriver->networkSetAutostart) {        int ret;        ret = conn->networkDriver->networkSetAutostart(network, autostart);        if (ret < 0)            goto error;        return ret;    }    virReportUnsupportedError(); error:    virDispatchError(network->conn);    return -1;}

static voidvirStorageBackendFileSystemNetFindNFSPoolSources(virNetfsDiscoverState *state){    /*     *  # showmount --no-headers -e HOSTNAME     *  /tmp   *     *  /A dir demo1.foo.bar,demo2.foo.bar     *     * Extract directory name (including possible interior spaces ...).     */    const char *regexes[] = {        "^(/.*//S) +//S+$"    };    int vars[] = {        1    };    virCommandPtr cmd = NULL;    cmd = virCommandNewArgList(SHOWMOUNT,                               "--no-headers",                               "--exports",                               state->host,                               NULL);    if (virCommandRunRegex(cmd, 1, regexes, vars,                           virStorageBackendFileSystemNetFindPoolSourcesFunc,                           &state, NULL) < 0)        virResetLastError();    virCommandFree(cmd);}

/** * virNodeListDevices: * @conn: pointer to the hypervisor connection * @cap: capability name * @names: array to collect the list of node device names * @maxnames: size of @names * @flags: extra flags; not used yet, so callers should always pass 0 * * Collect the list of node devices, and store their names in @names * * For more control over the results, see virConnectListAllNodeDevices(). * * If the optional 'cap'  argument is non-NULL, then the count * will be restricted to devices with the specified capability * * Returns the number of node devices found or -1 in case of error */intvirNodeListDevices(virConnectPtr conn,                   const char *cap,                   char **const names, int maxnames,                   unsigned int flags){    VIR_DEBUG("conn=%p, cap=%s, names=%p, maxnames=%d, flags=%x",          conn, cap, names, maxnames, flags);    virResetLastError();    virCheckConnectReturn(conn, -1);    virCheckNonNullArgGoto(names, error);    virCheckNonNegativeArgGoto(maxnames, error);    if (conn->nodeDeviceDriver && conn->nodeDeviceDriver->nodeListDevices) {        int ret;        ret = conn->nodeDeviceDriver->nodeListDevices(conn, cap, names, maxnames, flags);        if (ret < 0)            goto error;        return ret;    }    virReportUnsupportedError(); error:    virDispatchError(conn);    return -1;}

/** * virDomainQemuAttach: * @conn: pointer to a hypervisor connection * @pid_value: the UNIX process ID of the external QEMU process * @flags: optional flags, currently unused * * This API is QEMU specific, so it will only work with hypervisor * connections to the QEMU driver. * * This API will attach to an externally launched QEMU process * identified by @pid. There are several requirements to successfully * attach to an external QEMU process: * *   - It must have been started with a monitor socket using the UNIX *     domain socket protocol. *   - No device hotplug/unplug, or other configuration changes can *     have been made via the monitor since it started. *   - The '-name' and '-uuid' arguments should have been set (not *     mandatory, but strongly recommended) * * To date, the only platforms we know of where pid_t is larger than * unsigned int (64-bit Windows) also lack UNIX sockets, so the choice * of @pid_value as an unsigned int should not present any difficulties. * * If successful, then the guest will appear in the list of running * domains for this connection, and other APIs should operate * normally (provided the above requirements were honored). * * Returns a new domain object on success, NULL otherwise */virDomainPtrvirDomainQemuAttach(virConnectPtr conn,                    unsigned int pid_value,                    unsigned int flags){    pid_t pid = pid_value;    VIR_DEBUG("conn=%p, pid=%u, flags=%x", conn, pid_value, flags);    virResetLastError();    virCheckConnectReturn(conn, NULL);    virCheckPositiveArgGoto(pid_value, error);    if (pid != pid_value) {        virReportInvalidArg(pid_value,                            _("pid_value in %s is too large"),                            __FUNCTION__);        goto error;    }    virCheckReadOnlyGoto(conn->flags, error);    if (conn->driver->domainQemuAttach) {        virDomainPtr ret;        ret = conn->driver->domainQemuAttach(conn, pid_value, flags);        if (!ret)            goto error;        return ret;    }    virReportUnsupportedError();error:    virDispatchError(conn);    return NULL;}

/** * virNodeDeviceLookupSCSIHostByWWN: * @conn: pointer to the hypervisor connection * @wwnn: WWNN of the SCSI Host. * @wwpn: WWPN of the SCSI Host. * @flags: extra flags; not used yet, so callers should always pass 0 * * Lookup SCSI Host which is capable with 'fc_host' by its WWNN and WWPN. * * virNodeDeviceFree should be used to free the resources after the * node device object is no longer needed. * * Returns a virNodeDevicePtr if found, NULL otherwise. */virNodeDevicePtrvirNodeDeviceLookupSCSIHostByWWN(virConnectPtr conn,                                 const char *wwnn,                                 const char *wwpn,                                 unsigned int flags){    VIR_DEBUG("conn=%p, wwnn=%p, wwpn=%p, flags=%x", conn, wwnn, wwpn, flags);    virResetLastError();    virCheckConnectReturn(conn, NULL);    virCheckNonNullArgGoto(wwnn, error);    virCheckNonNullArgGoto(wwpn, error);    if (conn->nodeDeviceDriver &&        conn->nodeDeviceDriver->nodeDeviceLookupSCSIHostByWWN) {        virNodeDevicePtr ret;        ret = conn->nodeDeviceDriver->nodeDeviceLookupSCSIHostByWWN(conn, wwnn,                                                             wwpn, flags);        if (!ret)            goto error;        return ret;    }    virReportUnsupportedError(); error:    virDispatchError(conn);    return NULL;}

/** * virDomainQemuMonitorCommand: * @domain: a domain object * @cmd: the qemu monitor command string * @result: a string returned by @cmd * @flags: bitwise-or of supported virDomainQemuMonitorCommandFlags * * This API is QEMU specific, so it will only work with hypervisor * connections to the QEMU driver. * * Send an arbitrary monitor command @cmd to @domain through the * qemu monitor. There are several requirements to safely and * successfully use this API: * *   - A @cmd that queries state without making any modifications is safe *   - A @cmd that alters state that is also tracked by libvirt is unsafe, *     and may cause libvirtd to crash *   - A @cmd that alters state not tracked by the current version of *     libvirt is possible as a means to test new qemu features before *     they have support in libvirt, but no guarantees are made to safety * * If VIR_DOMAIN_QEMU_MONITOR_COMMAND_HMP is set, the command is * considered to be a human monitor command and libvirt will automatically * convert it into QMP if needed.  In that case the @result will also * be converted back from QMP. * * If successful, @result will be filled with the string output of the * @cmd, and the caller must free this string. * * Returns 0 in case of success, -1 in case of failure * */intvirDomainQemuMonitorCommand(virDomainPtr domain, const char *cmd,                            char **result, unsigned int flags){    virConnectPtr conn;    VIR_DOMAIN_DEBUG(domain, "cmd=%s, result=%p, flags=%x",                     cmd, result, flags);    virResetLastError();    virCheckDomainReturn(domain, -1);    conn = domain->conn;    virCheckNonNullArgGoto(result, error);    virCheckReadOnlyGoto(conn->flags, error);    if (conn->driver->domainQemuMonitorCommand) {        int ret;        ret = conn->driver->domainQemuMonitorCommand(domain, cmd, result,                                                     flags);        if (ret < 0)            goto error;        return ret;    }    virReportUnsupportedError();error:    virDispatchError(conn);    return -1;}

/** * virNodeDeviceListCaps: * @dev: the device * @names: array to collect the list of capability names * @maxnames: size of @names * * Lists the names of the capabilities supported by the device. * * Returns the number of capability names listed in @names or -1 * in case of error. */intvirNodeDeviceListCaps(virNodeDevicePtr dev,                      char **const names,                      int maxnames){    VIR_DEBUG("dev=%p, conn=%p, names=%p, maxnames=%d",          dev, dev ? dev->conn : NULL, names, maxnames);    virResetLastError();    virCheckNodeDeviceReturn(dev, -1);    virCheckNonNullArgGoto(names, error);    virCheckNonNegativeArgGoto(maxnames, error);    if (dev->conn->nodeDeviceDriver && dev->conn->nodeDeviceDriver->nodeDeviceListCaps) {        int ret;        ret = dev->conn->nodeDeviceDriver->nodeDeviceListCaps(dev, names, maxnames);        if (ret < 0)            goto error;        return ret;    }    virReportUnsupportedError(); error:    virDispatchError(dev->conn);    return -1;}

/** * virDomainSnapshotDelete: * @snapshot: a domain snapshot object * @flags: bitwise-OR of supported virDomainSnapshotDeleteFlags * * Delete the snapshot. * * If @flags is 0, then just this snapshot is deleted, and changes * from this snapshot are automatically merged into children * snapshots.  If @flags includes VIR_DOMAIN_SNAPSHOT_DELETE_CHILDREN, * then this snapshot and any descendant snapshots are deleted.  If * @flags includes VIR_DOMAIN_SNAPSHOT_DELETE_CHILDREN_ONLY, then any * descendant snapshots are deleted, but this snapshot remains.  These * two flags are mutually exclusive. * * If @flags includes VIR_DOMAIN_SNAPSHOT_DELETE_METADATA_ONLY, then * any snapshot metadata tracked by libvirt is removed while keeping * the snapshot contents intact; if a hypervisor does not require any * libvirt metadata to track snapshots, then this flag is silently * ignored. * * Returns 0 if the selected snapshot(s) were successfully deleted, * -1 on error. */intvirDomainSnapshotDelete(virDomainSnapshotPtr snapshot,                        unsigned int flags){    virConnectPtr conn;    VIR_DEBUG("snapshot=%p, flags=0x%x", snapshot, flags);    virResetLastError();    virCheckDomainSnapshotReturn(snapshot, -1);    conn = snapshot->domain->conn;    virCheckReadOnlyGoto(conn->flags, error);    VIR_EXCLUSIVE_FLAGS_GOTO(VIR_DOMAIN_SNAPSHOT_DELETE_CHILDREN,                             VIR_DOMAIN_SNAPSHOT_DELETE_CHILDREN_ONLY,                             error);    if (conn->driver->domainSnapshotDelete) {        int ret = conn->driver->domainSnapshotDelete(snapshot, flags);        if (ret < 0)            goto error;        return ret;    }    virReportUnsupportedError(); error:    virDispatchError(conn);    return -1;}

/** * virNodeDeviceDetachFlags: * @dev: pointer to the node device * @driverName: name of backend driver that will be used *              for later device assignment to a domain. NULL *              means "use the hypervisor default driver" * @flags: extra flags; not used yet, so callers should always pass 0 * * Detach the node device from the node itself so that it may be * assigned to a guest domain. * * Depending on the hypervisor, this may involve operations such as * unbinding any device drivers from the device, binding the device to * a dummy device driver and resetting the device. Different backend * drivers expect the device to be bound to different dummy * devices. For example, QEMU's "kvm" backend driver (the default) * expects the device to be bound to "pci-stub", but its "vfio" * backend driver expects the device to be bound to "vfio-pci". * * If the device is currently in use by the node, this method may * fail. * * Once the device is not assigned to any guest, it may be re-attached * to the node using the virNodeDeviceReAttach() method. * * Returns 0 in case of success, -1 in case of failure. */intvirNodeDeviceDetachFlags(virNodeDevicePtr dev,                         const char *driverName,                         unsigned int flags){    VIR_DEBUG("dev=%p, conn=%p driverName=%s flags=%x",              dev, dev ? dev->conn : NULL,              driverName ? driverName : "(default)", flags);    virResetLastError();    virCheckNodeDeviceReturn(dev, -1);    virCheckReadOnlyGoto(dev->conn->flags, error);    if (dev->conn->driver->nodeDeviceDetachFlags) {        int ret;        ret = dev->conn->driver->nodeDeviceDetachFlags(dev, driverName, flags);        if (ret < 0)            goto error;        return ret;    }    virReportUnsupportedError(); error:    virDispatchError(dev->conn);    return -1;}

/** * virDomainListAllSnapshots: * @domain: a domain object * @snaps: pointer to variable to store the array containing snapshot objects *         or NULL if the list is not required (just returns number of *         snapshots) * @flags: bitwise-OR of supported virDomainSnapshotListFlags * * Collect the list of domain snapshots for the given domain and allocate * an array to store those objects.  This API solves the race inherent in * virDomainSnapshotListNames(). * * If @flags contains VIR_DOMAIN_SNAPSHOT_LIST_TOPOLOGICAL and @snaps * is non-NULL, and no other connection is modifying snapshots, then * it is guaranteed that for any snapshot in the resulting list, no * snapshots later in the list can be reached by a sequence of * virDomainSnapshotGetParent() starting from that earlier snapshot; * otherwise, the order of snapshots in the resulting list is * unspecified. * * By default, this command covers all snapshots. It is also possible * to limit things to just snapshots with no parents, when @flags * includes VIR_DOMAIN_SNAPSHOT_LIST_ROOTS.  Additional filters are * provided in groups listed below. Within a group, bits are mutually * exclusive, where all possible snapshots are described by exactly * one bit from the group. Some hypervisors might reject particular * flags where it cannot make a distinction for filtering. If the set * of filter flags selected forms an impossible combination, the * hypervisor may return either 0 or an error. * * The first group of @flags is VIR_DOMAIN_SNAPSHOT_LIST_LEAVES and * VIR_DOMAIN_SNAPSHOT_LIST_NO_LEAVES, to filter based on snapshots that * have no further children (a leaf snapshot). * * The next group of @flags is VIR_DOMAIN_SNAPSHOT_LIST_METADATA and * VIR_DOMAIN_SNAPSHOT_LIST_NO_METADATA, for filtering snapshots based on * whether they have metadata that would prevent the removal of the last * reference to a domain. * * The next group of @flags is VIR_DOMAIN_SNAPSHOT_LIST_INACTIVE, * VIR_DOMAIN_SNAPSHOT_LIST_ACTIVE, and VIR_DOMAIN_SNAPSHOT_LIST_DISK_ONLY, * for filtering snapshots based on what domain state is tracked by the * snapshot. * * The next group of @flags is VIR_DOMAIN_SNAPSHOT_LIST_INTERNAL and * VIR_DOMAIN_SNAPSHOT_LIST_EXTERNAL, for filtering snapshots based on * whether the snapshot is stored inside the disk images or as * additional files. * * Returns the number of domain snapshots found or -1 and sets @snaps to * NULL in case of error.  On success, the array stored into @snaps is * guaranteed to have an extra allocated element set to NULL but not included * in the return count, to make iteration easier.  The caller is responsible * for calling virDomainSnapshotFree() on each array element, then calling * free() on @snaps. */intvirDomainListAllSnapshots(virDomainPtr domain, virDomainSnapshotPtr **snaps,                          unsigned int flags){    virConnectPtr conn;    VIR_DOMAIN_DEBUG(domain, "snaps=%p, flags=0x%x", snaps, flags);    virResetLastError();    if (snaps)        *snaps = NULL;    virCheckDomainReturn(domain, -1);    conn = domain->conn;    if (conn->driver->domainListAllSnapshots) {        int ret = conn->driver->domainListAllSnapshots(domain, snaps, flags);        if (ret < 0)            goto error;        return ret;    }    virReportUnsupportedError(); error:    virDispatchError(conn);    return -1;}

/** * virNodeDeviceCreateXML: * @conn: pointer to the hypervisor connection * @xmlDesc: string containing an XML description of the device to be created * @flags: extra flags; not used yet, so callers should always pass 0 * * Create a new device on the VM host machine, for example, virtual * HBAs created using vport_create. * * virNodeDeviceFree should be used to free the resources after the * node device object is no longer needed. * * Returns a node device object if successful, NULL in case of failure */virNodeDevicePtrvirNodeDeviceCreateXML(virConnectPtr conn,                       const char *xmlDesc,                       unsigned int flags){    VIR_DEBUG("conn=%p, xmlDesc=%s, flags=%x", conn, xmlDesc, flags);    virResetLastError();    virCheckConnectReturn(conn, NULL);    virCheckReadOnlyGoto(conn->flags, error);    virCheckNonNullArgGoto(xmlDesc, error);    if (conn->nodeDeviceDriver &&        conn->nodeDeviceDriver->nodeDeviceCreateXML) {        virNodeDevicePtr dev = conn->nodeDeviceDriver->nodeDeviceCreateXML(conn, xmlDesc, flags);        if (dev == NULL)            goto error;        return dev;    }    virReportUnsupportedError(); error:    virDispatchError(conn);    return NULL;}

/** * virDomainSnapshotListAllChildren: * @snapshot: a domain snapshot object * @snaps: pointer to variable to store the array containing snapshot objects *         or NULL if the list is not required (just returns number of *         snapshots) * @flags: bitwise-OR of supported virDomainSnapshotListFlags * * Collect the list of domain snapshots that are children of the given * snapshot, and allocate an array to store those objects.  This API solves * the race inherent in virDomainSnapshotListChildrenNames(). * * If @flags lacks VIR_DOMAIN_SNAPSHOT_LIST_DESCENDANTS or contains * VIR_DOMAIN_SNAPSHOT_LIST_TOPOLOGICAL, @snaps is non-NULL, and no * other connection is modifying snapshots, then it is guaranteed that * for any snapshot in the resulting list, no snapshots later in the * list can be reached by a sequence of virDomainSnapshotGetParent() * starting from that earlier snapshot; otherwise, the order of * snapshots in the resulting list is unspecified. * * By default, this command covers only direct children. It is also * possible to expand things to cover all descendants, when @flags * includes VIR_DOMAIN_SNAPSHOT_LIST_DESCENDANTS. Additional filters * are provided via the remaining @flags values as documented in * virDomainListAllSnapshots(), with the exception that * VIR_DOMAIN_SNAPSHOT_LIST_ROOTS is not supported (in fact, * VIR_DOMAIN_SNAPSHOT_LIST_DESCENDANTS has the same bit value but * opposite semantics of widening rather than narrowing the listing). * * Returns the number of domain snapshots found or -1 and sets @snaps to * NULL in case of error.  On success, the array stored into @snaps is * guaranteed to have an extra allocated element set to NULL but not included * in the return count, to make iteration easier.  The caller is responsible * for calling virDomainSnapshotFree() on each array element, then calling * free() on @snaps. */intvirDomainSnapshotListAllChildren(virDomainSnapshotPtr snapshot,                                 virDomainSnapshotPtr **snaps,                                 unsigned int flags){    virConnectPtr conn;    VIR_DEBUG("snapshot=%p, snaps=%p, flags=0x%x", snapshot, snaps, flags);    virResetLastError();    if (snaps)        *snaps = NULL;    virCheckDomainSnapshotReturn(snapshot, -1);    conn = snapshot->domain->conn;    if (conn->driver->domainSnapshotListAllChildren) {        int ret = conn->driver->domainSnapshotListAllChildren(snapshot, snaps,                                                              flags);        if (ret < 0)            goto error;        return ret;    }    virReportUnsupportedError(); error:    virDispatchError(conn);    return -1;}

/** * virNodeDeviceDestroy: * @dev: a device object * * Destroy the device object. The virtual device (only works for vHBA * currently) is removed from the host operating system.  This function * may require privileged access. * * Returns 0 in case of success and -1 in case of failure. */intvirNodeDeviceDestroy(virNodeDevicePtr dev){    VIR_DEBUG("dev=%p", dev);    virResetLastError();    virCheckNodeDeviceReturn(dev, -1);    virCheckReadOnlyGoto(dev->conn->flags, error);    if (dev->conn->nodeDeviceDriver &&        dev->conn->nodeDeviceDriver->nodeDeviceDestroy) {        int retval = dev->conn->nodeDeviceDriver->nodeDeviceDestroy(dev);        if (retval < 0) {            goto error;        }        return 0;    }    virReportUnsupportedError(); error:    virDispatchError(dev->conn);    return -1;}

/** * virDomainSnapshotCurrent: * @domain: a domain object * @flags: extra flags; not used yet, so callers should always pass 0 * * Get the current snapshot for a domain, if any. * * virDomainSnapshotFree should be used to free the resources after the * snapshot object is no longer needed. * * Returns a domain snapshot object or NULL in case of failure.  If the * current domain snapshot cannot be found, then the VIR_ERR_NO_DOMAIN_SNAPSHOT * error is raised. */virDomainSnapshotPtrvirDomainSnapshotCurrent(virDomainPtr domain,                         unsigned int flags){    virConnectPtr conn;    VIR_DOMAIN_DEBUG(domain, "flags=0x%x", flags);    virResetLastError();    virCheckDomainReturn(domain, NULL);    conn = domain->conn;    if (conn->driver->domainSnapshotCurrent) {        virDomainSnapshotPtr snap;        snap = conn->driver->domainSnapshotCurrent(domain, flags);        if (!snap)            goto error;        return snap;    }    virReportUnsupportedError(); error:    virDispatchError(conn);    return NULL;}

static intcpuTestCompare(const void *arg){    const struct data *data = arg;    int ret = -1;    virCPUDefPtr host = NULL;    virCPUDefPtr cpu = NULL;    virCPUCompareResult result;    if (!(host = cpuTestLoadXML(data->arch, data->host)) ||        !(cpu = cpuTestLoadXML(data->arch, data->name)))        goto cleanup;    result = cpuCompare(host, cpu);    if (data->result == VIR_CPU_COMPARE_ERROR)        virResetLastError();    if (data->result != result) {        if (virTestGetVerbose()) {            fprintf(stderr, "/nExpected result %s, got %s/n",                    cpuTestCompResStr(data->result),                    cpuTestCompResStr(result));            /* Pad to line up with test name ... in virTestRun */            fprintf(stderr, "%74s", "... ");        }        goto cleanup;    }    ret = 0;cleanup:    virCPUDefFree(host);    virCPUDefFree(cpu);    return ret;}

/** * virDomainSnapshotHasMetadata: * @snapshot: a snapshot object * @flags: extra flags; not used yet, so callers should always pass 0 * * Determine if the given snapshot is associated with libvirt metadata * that would prevent the deletion of the domain. * * Returns 1 if the snapshot has metadata, 0 if the snapshot exists without * help from libvirt, or -1 on error. */intvirDomainSnapshotHasMetadata(virDomainSnapshotPtr snapshot,                             unsigned int flags){    virConnectPtr conn;    VIR_DEBUG("snapshot=%p, flags=0x%x", snapshot, flags);    virResetLastError();    virCheckDomainSnapshotReturn(snapshot, -1);    conn = snapshot->domain->conn;    if (conn->driver->domainSnapshotHasMetadata) {        int ret;        ret = conn->driver->domainSnapshotHasMetadata(snapshot, flags);        if (ret < 0)            goto error;        return ret;    }    virReportUnsupportedError(); error:    virDispatchError(conn);    return -1;}

/** * virNetworkGetBridgeName: * @network: a network object * * Provides a bridge interface name to which a domain may connect * a network interface in order to join the network. * * Returns a 0 terminated interface name, or NULL in case of error. *         the caller must free() the returned value. */char *virNetworkGetBridgeName(virNetworkPtr network){    virConnectPtr conn;    VIR_DEBUG("network=%p", network);    virResetLastError();    virCheckNetworkReturn(network, NULL);    conn = network->conn;    if (conn->networkDriver && conn->networkDriver->networkGetBridgeName) {        char *ret;        ret = conn->networkDriver->networkGetBridgeName(network);        if (!ret)            goto error;        return ret;    }    virReportUnsupportedError(); error:    virDispatchError(network->conn);    return NULL;}