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

static inthypervDomainDestroyFlags(virDomainPtr domain, unsigned int flags){    int result = -1;    hypervPrivate *priv = domain->conn->privateData;    Msvm_ComputerSystem *computerSystem = NULL;    bool in_transition = false;    virCheckFlags(0, -1);    if (hypervMsvmComputerSystemFromDomain(domain, &computerSystem) < 0) {        goto cleanup;    }    if (!hypervIsMsvmComputerSystemActive(computerSystem, &in_transition) ||        in_transition) {        HYPERV_ERROR(VIR_ERR_OPERATION_INVALID, "%s",                     _("Domain is not active or is in state transition"));        goto cleanup;    }    result = hypervInvokeMsvmComputerSystemRequestStateChange               (domain, MSVM_COMPUTERSYSTEM_REQUESTEDSTATE_DISABLED);  cleanup:    hypervFreeObject(priv, (hypervObject *)computerSystem);    return result;}

static inthypervDomainGetState(virDomainPtr domain, int *state, int *reason,                     unsigned int flags){    int result = -1;    hypervPrivate *priv = domain->conn->privateData;    Msvm_ComputerSystem *computerSystem = NULL;    virCheckFlags(0, -1);    if (hypervMsvmComputerSystemFromDomain(domain, &computerSystem) < 0) {        goto cleanup;    }    *state = hypervMsvmComputerSystemEnabledStateToDomainState(computerSystem);    if (reason != NULL) {        *reason = 0;    }    result = 0;  cleanup:    hypervFreeObject(priv, (hypervObject *)computerSystem);    return result;}

char *nodeDeviceGetXMLDesc(virNodeDevicePtr dev,                     unsigned int flags){    virDeviceMonitorStatePtr driver = dev->conn->devMonPrivateData;    virNodeDeviceObjPtr obj;    char *ret = NULL;    virCheckFlags(0, NULL);    nodeDeviceLock(driver);    obj = virNodeDeviceFindByName(&driver->devs, dev->name);    nodeDeviceUnlock(driver);    if (!obj) {        virReportError(VIR_ERR_NO_NODE_DEVICE,                       _("no node device with matching name '%s'"),                       dev->name);        goto cleanup;    }    update_driver_name(obj);    update_caps(obj);    ret = virNodeDeviceDefFormat(obj->def);cleanup:    if (obj)        virNodeDeviceObjUnlock(obj);    return ret;}

static inthypervDomainManagedSaveRemove(virDomainPtr domain, unsigned int flags){    int result = -1;    hypervPrivate *priv = domain->conn->privateData;    Msvm_ComputerSystem *computerSystem = NULL;    virCheckFlags(0, -1);    if (hypervMsvmComputerSystemFromDomain(domain, &computerSystem) < 0) {        goto cleanup;    }    if (computerSystem->data->EnabledState !=        MSVM_COMPUTERSYSTEM_ENABLEDSTATE_SUSPENDED) {        HYPERV_ERROR(VIR_ERR_OPERATION_INVALID, "%s",                     _("Domain has no managed save image"));        goto cleanup;    }    result = hypervInvokeMsvmComputerSystemRequestStateChange               (domain, MSVM_COMPUTERSYSTEM_REQUESTEDSTATE_DISABLED);  cleanup:    hypervFreeObject(priv, (hypervObject *)computerSystem);    return result;}

static intsecretSetValue(virSecretPtr obj,               const unsigned char *value,               size_t value_size,               unsigned int flags){    int ret = -1;    virSecretObjPtr secret;    virSecretDefPtr def;    virCheckFlags(0, -1);    if (!(secret = secretObjFromSecret(obj)))        goto cleanup;    def = virSecretObjGetDef(secret);    if (virSecretSetValueEnsureACL(obj->conn, def) < 0)        goto cleanup;    if (secretEnsureDirectory() < 0)        goto cleanup;    if (virSecretObjSetValue(secret, value, value_size) < 0)        goto cleanup;    ret = 0; cleanup:    virSecretObjEndAPI(&secret);    return ret;}

static intvirStorageBackendZFSBuildPool(virConnectPtr conn ATTRIBUTE_UNUSED,                              virStoragePoolObjPtr pool,                              unsigned int flags){    virCommandPtr cmd = NULL;    size_t i;    int ret = -1;    virCheckFlags(0, -1);    if (pool->def->source.ndevice == 0) {        virReportError(VIR_ERR_CONFIG_UNSUPPORTED,                       "%s", _("missing source devices"));        return -1;    }    cmd = virCommandNewArgList(ZPOOL, "create",                               pool->def->source.name, NULL);    for (i = 0; i < pool->def->source.ndevice; i++)        virCommandAddArg(cmd, pool->def->source.devices[i].path);    if (virCommandRun(cmd, NULL) < 0)        goto cleanup;    ret = 0; cleanup:    virCommandFree(cmd);    return ret;}

static intsecretSetValue(virSecretPtr secret,               const unsigned char *value,               size_t value_size,               unsigned int flags){    int ret = -1;    virSecretObjPtr obj;    virSecretDefPtr def;    virObjectEventPtr event = NULL;    virCheckFlags(0, -1);    if (!(obj = secretObjFromSecret(secret)))        goto cleanup;    def = virSecretObjGetDef(obj);    if (virSecretSetValueEnsureACL(secret->conn, def) < 0)        goto cleanup;    if (virSecretObjSetValue(obj, value, value_size) < 0)        goto cleanup;    event = virSecretEventValueChangedNew(def->uuid,                                          def->usage_type,                                          def->usage_id);    ret = 0; cleanup:    virSecretObjEndAPI(&obj);    if (event)        virObjectEventStateQueue(driver->secretEventState, event);    return ret;}

static intbhyveDomainGetState(virDomainPtr domain,                    int *state,                    int *reason,                    unsigned int flags){    virDomainObjPtr vm;    int ret = -1;    virCheckFlags(0, -1);    if (!(vm = bhyveDomObjFromDomain(domain)))        goto cleanup;    if (virDomainGetStateEnsureACL(domain->conn, vm->def) < 0)       goto cleanup;    *state = virDomainObjGetState(vm, reason);    ret = 0; cleanup:    if (vm)        virObjectUnlock(vm);    return ret;}

static int virLockManagerSanlockNew(virLockManagerPtr lock,                                    unsigned int type,                                    size_t nparams,                                    virLockManagerParamPtr params,                                    unsigned int flags){    virLockManagerParamPtr param;    virLockManagerSanlockPrivatePtr priv;    int i;    virCheckFlags(0, -1);    if (!driver) {        virReportError(VIR_ERR_INTERNAL_ERROR, "%s",                       _("Sanlock plugin is not initialized"));        return -1;    }    if (type != VIR_LOCK_MANAGER_OBJECT_TYPE_DOMAIN) {        virReportError(VIR_ERR_INTERNAL_ERROR,                       _("Unsupported object type %d"), type);        return -1;    }    if (VIR_ALLOC(priv) < 0) {        virReportOOMError();        return -1;    }    priv->flags = flags;    for (i = 0; i < nparams; i++) {        param = &params[i];        if (STREQ(param->key, "uuid")) {            memcpy(priv->vm_uuid, param->value.uuid, 16);        } else if (STREQ(param->key, "name")) {            if (!virStrcpy(priv->vm_name, param->value.str, SANLK_NAME_LEN)) {                virReportError(VIR_ERR_INTERNAL_ERROR,                               _("Domain name '%s' exceeded %d characters"),                               param->value.str, SANLK_NAME_LEN);                goto error;            }        } else if (STREQ(param->key, "pid")) {            priv->vm_pid = param->value.ui;        } else if (STREQ(param->key, "id")) {            priv->vm_id = param->value.ui;        } else if (STREQ(param->key, "uri")) {            priv->vm_uri = param->value.cstr;        }    }    lock->privateData = priv;    return 0;error:    VIR_FREE(priv);    return -1;}

static char *bhyveConnectDomainXMLToNative(virConnectPtr conn,                              const char *format,                              const char *xmlData,                              unsigned int flags){    virBuffer buf = VIR_BUFFER_INITIALIZER;    bhyveConnPtr privconn = conn->privateData;    virDomainDefPtr def = NULL;    virCommandPtr cmd = NULL, loadcmd = NULL;    virCapsPtr caps = NULL;    char *ret = NULL;    virCheckFlags(0, NULL);    if (virConnectDomainXMLToNativeEnsureACL(conn) < 0)        goto cleanup;    if (STRNEQ(format, BHYVE_CONFIG_FORMAT_ARGV)) {        virReportError(VIR_ERR_INVALID_ARG,                       _("Unsupported config type %s"), format);        goto cleanup;    }    if (!(caps = bhyveDriverGetCapabilities(privconn)))        goto cleanup;    if (!(def = virDomainDefParseString(xmlData, caps, privconn->xmlopt,                                  1 << VIR_DOMAIN_VIRT_BHYVE,                                  VIR_DOMAIN_XML_INACTIVE)))        goto cleanup;    if (bhyveDomainAssignAddresses(def, NULL) < 0)        goto cleanup;    if (!(loadcmd = virBhyveProcessBuildLoadCmd(privconn, def)))        goto cleanup;    if (!(cmd = virBhyveProcessBuildBhyveCmd(privconn, def, true)))        goto cleanup;    virBufferAdd(&buf, virCommandToString(loadcmd), -1);    virBufferAddChar(&buf, '/n');    virBufferAdd(&buf, virCommandToString(cmd), -1);    if (virBufferError(&buf)) {        virReportOOMError();        goto cleanup;    }    ret = virBufferContentAndReset(&buf); cleanup:    virCommandFree(loadcmd);    virCommandFree(cmd);    virDomainDefFree(def);    virObjectUnref(caps);    return ret;}

virNodeDevicePtrnodeDeviceLookupSCSIHostByWWN(virConnectPtr conn,                              const char *wwnn,                              const char *wwpn,                              unsigned int flags){    size_t i;    virNodeDeviceObjListPtr devs = &driver->devs;    virNodeDevCapsDefPtr cap = NULL;    virNodeDeviceObjPtr obj = NULL;    virNodeDeviceDefPtr def;    virNodeDevicePtr dev = NULL;    virCheckFlags(0, NULL);    nodeDeviceLock();    for (i = 0; i < devs->count; i++) {        obj = devs->objs[i];        virNodeDeviceObjLock(obj);        def = virNodeDeviceObjGetDef(obj);        cap = def->caps;        while (cap) {            if (cap->data.type == VIR_NODE_DEV_CAP_SCSI_HOST) {                nodeDeviceSysfsGetSCSIHostCaps(&cap->data.scsi_host);                if (cap->data.scsi_host.flags &                    VIR_NODE_DEV_CAP_FLAG_HBA_FC_HOST) {                    if (STREQ(cap->data.scsi_host.wwnn, wwnn) &&                        STREQ(cap->data.scsi_host.wwpn, wwpn)) {                        if (virNodeDeviceLookupSCSIHostByWWNEnsureACL(conn, def) < 0)                            goto error;                        if ((dev = virGetNodeDevice(conn, def->name))) {                            if (VIR_STRDUP(dev->parent, def->parent) < 0) {                                virObjectUnref(dev);                                dev = NULL;                            }                        }                        virNodeDeviceObjUnlock(obj);                        goto out;                    }                }            }            cap = cap->next;        }        virNodeDeviceObjUnlock(obj);    } out:    nodeDeviceUnlock();    return dev; error:    virNodeDeviceObjUnlock(obj);    goto out;}

int adminClientClose(virNetServerClientPtr client,                     unsigned int flags){    virCheckFlags(0, -1);    virNetServerClientClose(client);    return 0;}

/** * @pool storage pool to build * @flags controls the pool formatting behaviour * * Does not support @flags, if provided an error will occur. * * Returns 0 on success, -1 on error */static intvirStorageBackendVzPoolBuild(virStoragePoolObjPtr pool,                             unsigned int flags){    virCheckFlags(0, -1);    return virStorageBackendBuildLocal(pool);}

virNodeDevicePtrnodeDeviceCreateXML(virConnectPtr conn,                    const char *xmlDesc,                    unsigned int flags){    virNodeDeviceDriverStatePtr driver = conn->nodeDevicePrivateData;    virNodeDeviceDefPtr def = NULL;    char *wwnn = NULL, *wwpn = NULL;    int parent_host = -1;    virNodeDevicePtr dev = NULL;    const char *virt_type = NULL;    virCheckFlags(0, NULL);    virt_type  = virConnectGetType(conn);    nodeDeviceLock(driver);    def = virNodeDeviceDefParseString(xmlDesc, CREATE_DEVICE, virt_type);    if (def == NULL) {        goto cleanup;    }    if (virNodeDeviceCreateXMLEnsureACL(conn, def) < 0)        goto cleanup;    if (virNodeDeviceGetWWNs(def, &wwnn, &wwpn) == -1) {        goto cleanup;    }    if (virNodeDeviceGetParentHost(&driver->devs,                                   def->name,                                   def->parent,                                   &parent_host) == -1) {        goto cleanup;    }    if (virManageVport(parent_host,                       wwpn,                       wwnn,                       VPORT_CREATE) == -1) {        goto cleanup;    }    dev = find_new_device(conn, wwnn, wwpn);    /* We don't check the return value, because one way or another,     * we're returning what we get... */    if (dev == NULL) {        virReportError(VIR_ERR_NO_NODE_DEVICE, NULL);    } cleanup:    nodeDeviceUnlock(driver);    virNodeDeviceDefFree(def);    VIR_FREE(wwnn);    VIR_FREE(wwpn);    return dev;}

virNetServerPtradminConnectLookupServer(virNetDaemonPtr dmn,                         const char *name,                         unsigned int flags){    virCheckFlags(flags, NULL);    return virNetDaemonGetServer(dmn, name);}

static char *esxStoragePoolGetXMLDesc(virStoragePoolPtr pool, unsigned int flags){    char *xml = NULL;    esxPrivate *priv = pool->conn->privateData;    esxVI_HostInternetScsiHba *hostInternetScsiHba = NULL;    esxVI_HostInternetScsiHbaStaticTarget *target;    virStoragePoolDef def;    virCheckFlags(0, NULL);    memset(&def, 0, sizeof(def));    if (esxVI_LookupHostInternetScsiHba(priv->primary, &hostInternetScsiHba))        goto cleanup;    for (target = hostInternetScsiHba->configuredStaticTarget;         target; target = target->_next) {        if (STREQ(target->iScsiName, pool->name))            break;    }    if (!target) {        /* pool not found */        virReportError(VIR_ERR_INTERNAL_ERROR,                       _("Could not find storage pool with name '%s'"),                       pool->name);        goto cleanup;    }    def.name = pool->name;    memcpy(def.uuid, pool->uuid, VIR_UUID_BUFLEN);    def.type = VIR_STORAGE_POOL_ISCSI;    def.source.initiator.iqn = target->iScsiName;    def.source.nhost = 1;    if (VIR_ALLOC_N(def.source.hosts, def.source.nhost) < 0)        goto cleanup;    def.source.hosts[0].name = target->address;    if (target->port)        def.source.hosts[0].port = target->port->value;    /* TODO: add CHAP authentication params */    xml = virStoragePoolDefFormat(&def); cleanup:    VIR_FREE(def.source.hosts);    esxVI_HostInternetScsiHba_Free(&hostInternetScsiHba);    return xml;}

static intadminConnectSetLoggingOutputs(virNetDaemonPtr dmn ATTRIBUTE_UNUSED,                              const char *outputs,                              unsigned int flags){    virCheckFlags(0, -1);    return virLogSetOutputs(outputs);}

virNetServerClientPtradminServerLookupClient(virNetServerPtr srv,                        unsigned long long id,                        unsigned int flags){    virCheckFlags(0, NULL);    return virNetServerGetClient(srv, id);}

static intadminConnectSetLoggingFilters(virNetDaemonPtr dmn ATTRIBUTE_UNUSED,                              const char *filters,                              unsigned int flags){    virCheckFlags(0, -1);    return virLogSetFilters(filters);}

static int parallelsConnectListAllNetworks(virConnectPtr conn,                                           virNetworkPtr **nets,                                           unsigned int flags){    parallelsConnPtr privconn = conn->privateData;    virCheckFlags(VIR_CONNECT_LIST_NETWORKS_FILTERS_ALL, -1);    return virNetworkObjListExport(conn, privconn->networks, nets, NULL, flags);}

static intlightosConnectListAllDomains(virConnectPtr conn,virDomainPtr **domains,unsigned int flags){        lightosConnPtr privconn = conn->privateData;    int ret;    virCheckFlags(VIR_CONNECT_LIST_DOMAINS_FILTERS_ALL,-1);    ret = virDomainObjListExport(privconn->domains,conn,domains,NULL,flags);    return ret;}

/** * virAdmConnectOpen: * @name: uri of the daemon to connect to, NULL for default * @flags: unused, must be 0 * * Opens connection to admin interface of the daemon. * * Returns @virAdmConnectPtr object or NULL on error */virAdmConnectPtrvirAdmConnectOpen(const char *name, unsigned int flags){    char *sock_path = NULL;    char *alias = NULL;    virAdmConnectPtr conn = NULL;    virConfPtr conf = NULL;    if (virAdmInitialize() < 0)        goto error;    VIR_DEBUG("flags=%x", flags);    virResetLastError();    virCheckFlags(VIR_CONNECT_NO_ALIASES, NULL);    if (!(conn = virAdmConnectNew()))        goto error;    if (virConfLoadConfig(&conf, "libvirt-admin.conf") < 0)        goto error;    if (!name && !(name = virAdmGetDefaultURI(conf)))        goto error;    if ((!(flags & VIR_CONNECT_NO_ALIASES) &&         virURIResolveAlias(conf, name, &alias) < 0))        goto error;    if (!(conn->uri = virURIParse(alias ? alias : name)))        goto error;    if (!(sock_path = getSocketPath(conn->uri)))        goto error;    if (!(conn->privateData = remoteAdminPrivNew(sock_path)))        goto error;    conn->privateDataFreeFunc = remoteAdminPrivFree;    if (remoteAdminConnectOpen(conn, flags) < 0)        goto error; cleanup:    VIR_FREE(sock_path);    VIR_FREE(alias);    virConfFree(conf);    return conn; error:    virDispatchError(NULL);    virObjectUnref(conn);    conn = NULL;    goto cleanup;}

static virDrvOpenStatushypervNodeDeviceOpen(virConnectPtr conn,                     virConnectAuthPtr auth ATTRIBUTE_UNUSED,                     unsigned int flags){    virCheckFlags(VIR_CONNECT_RO, VIR_DRV_OPEN_ERROR);    if (conn->driver->no != VIR_DRV_HYPERV)        return VIR_DRV_OPEN_DECLINED;    return VIR_DRV_OPEN_SUCCESS;}

static int virLockManagerSanlockAddResource(virLockManagerPtr lock,                                            unsigned int type,                                            const char *name,                                            size_t nparams,                                            virLockManagerParamPtr params,                                            unsigned int flags){    virLockManagerSanlockPrivatePtr priv = lock->privateData;    virCheckFlags(VIR_LOCK_MANAGER_RESOURCE_READONLY |                  VIR_LOCK_MANAGER_RESOURCE_SHARED, -1);    if (priv->res_count == SANLK_MAX_RESOURCES) {        virReportError(VIR_ERR_INTERNAL_ERROR,                       _("Too many resources %d for object"),                       SANLK_MAX_RESOURCES);        return -1;    }    /* Treat R/O resources as a no-op lock request */    if (flags & VIR_LOCK_MANAGER_RESOURCE_READONLY)        return 0;    switch (type) {    case VIR_LOCK_MANAGER_RESOURCE_TYPE_DISK:        if (driver->autoDiskLease) {            if (virLockManagerSanlockAddDisk(lock, name, nparams, params,                                             !!(flags & VIR_LOCK_MANAGER_RESOURCE_SHARED)) < 0)                return -1;            if (virLockManagerSanlockCreateLease(priv->res_args[priv->res_count-1]) < 0)                return -1;        } else {            if (!(flags & (VIR_LOCK_MANAGER_RESOURCE_SHARED |                           VIR_LOCK_MANAGER_RESOURCE_READONLY)))                priv->hasRWDisks = true;            /* Ignore disk resources without error */        }        break;    case VIR_LOCK_MANAGER_RESOURCE_TYPE_LEASE:        if (virLockManagerSanlockAddLease(lock, name, nparams, params,                                          !!(flags & VIR_LOCK_MANAGER_RESOURCE_SHARED)) < 0)            return -1;        break;    default:        /* Ignore other resources, without error */        break;    }    return 0;}

static virStoragePoolPtrparallelsStoragePoolDefineXML(virConnectPtr conn,                              const char *xml, unsigned int flags){    parallelsConnPtr privconn = conn->privateData;    virStoragePoolDefPtr def;    virStoragePoolObjPtr pool = NULL;    virStoragePoolPtr ret = NULL;    virCheckFlags(0, NULL);    parallelsDriverLock(privconn);    if (!(def = virStoragePoolDefParseString(xml)))        goto cleanup;    if (def->type != VIR_STORAGE_POOL_DIR) {        virReportError(VIR_ERR_NO_SUPPORT, "%s",                       _("Only local directories are supported"));        goto cleanup;    }    if (virStoragePoolObjIsDuplicate(&privconn->pools, def, 0) < 0)        goto cleanup;    if (virStoragePoolSourceFindDuplicate(&privconn->pools, def) < 0)        goto cleanup;    if (parallelsStoragePoolGetAlloc(def))        goto cleanup;    if (!(pool = virStoragePoolObjAssignDef(&privconn->pools, def)))        goto cleanup;    if (virStoragePoolObjSaveDef(conn->storagePrivateData, pool, def) < 0) {        virStoragePoolObjRemove(&privconn->pools, pool);        def = NULL;        goto cleanup;    }    def = NULL;    if (VIR_STRDUP(pool->configFile, "/0") < 0)        goto cleanup;    ret = virGetStoragePool(conn, pool->def->name, pool->def->uuid,                            NULL, NULL); cleanup:    virStoragePoolDefFree(def);    if (pool)        virStoragePoolObjUnlock(pool);    parallelsDriverUnlock(privconn);    return ret;}

/* Returns the number of outputs stored in @outputs */static intadminConnectGetLoggingOutputs(char **outputs, unsigned int flags){    char *tmp = NULL;    virCheckFlags(0, -1);    if (!(tmp = virLogGetOutputs()))        return -1;    *outputs = tmp;    return virLogGetNbOutputs();}

static intcall(virAdmConnectPtr conn,     unsigned int flags,     int proc_nr,     xdrproc_t args_filter, char *args,     xdrproc_t ret_filter, char *ret){    virCheckFlags(0, -1);    return callFull(conn, conn->privateData,                    NULL, 0, NULL, NULL, proc_nr,                    args_filter, args, ret_filter, ret);}

static intsecretConnectListAllSecrets(virConnectPtr conn,                            virSecretPtr **secrets,                            unsigned int flags){    virCheckFlags(VIR_CONNECT_LIST_SECRETS_FILTERS_ALL, -1);    if (virConnectListAllSecretsEnsureACL(conn) < 0)        return -1;    return virSecretObjListExport(conn, driver->secrets, secrets,                                  virConnectListAllSecretsCheckACL,                                  flags);}

/* Returns the number of defined filters or -1 in case of an error */static intadminConnectGetLoggingFilters(char **filters, unsigned int flags){    char *tmp = NULL;    int ret = 0;    virCheckFlags(0, -1);    if ((ret = virLogGetNbFilters()) > 0 && !(tmp = virLogGetFilters()))        return -1;    *filters = tmp;    return ret;}

static virDrvOpenStatuslightosConnectOpen(virConnectPtr conn,		   virConnectAuthPtr auth ATTRIBUTE_UNUSED,		   unsigned int flags){    virCheckFlags(VIR_CONNECT_RO, VIR_DRV_OPEN_ERROR);    if (lightosInitialize() < 0)        return VIR_DRV_OPEN_ERROR; //   if(conn->uri == NULL)//	if (lightos_driver == NULL)//		return VIR_DRV_OPEN_DECLINED;        if (!conn->uri)        return VIR_DRV_OPEN_DECLINED;    if (!conn->uri->scheme || STRNEQ(conn->uri->scheme, "lightos"))        return VIR_DRV_OPEN_DECLINED;    /* From this point on, the connection is for us. */    if (!conn->uri->path        || conn->uri->path[0] == '/0'        || (conn->uri->path[0] == '/' && conn->uri->path[1] == '/0')) {        virReportError(VIR_ERR_INVALID_ARG,                       "%s", _("lightosOpen: supply a path or use lightos:///default"));        return VIR_DRV_OPEN_ERROR;    }//    if (STREQ(conn->uri->path, "/default"))//        ret = testOpenDefault(conn);//  	printf("need call lightosOpen/n");    if(lightos_driver == NULL)        virReportError(VIR_ERR_INTERNAL_ERROR,		"%s",_("lightos state driver is ont active!!!!")); //   if (STREQ(conn->uri->path, "/default"))  //  {//	if(virConnectOpenEnsureACL(conn)< 0) //           return VIR_DRV_OPEN_ERROR;   // }    conn->privateData = lightos_driver;    return VIR_DRV_OPEN_SUCCESS;}