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

virNetClientStreamPtr virNetClientStreamNew(virNetClientProgramPtr prog,                                            int proc,                                            unsigned serial){    virNetClientStreamPtr st;    if (VIR_ALLOC(st) < 0) {        virReportOOMError();        return NULL;    }    st->refs = 1;    st->prog = prog;    st->proc = proc;    st->serial = serial;    if (virMutexInit(&st->lock) < 0) {        virNetError(VIR_ERR_INTERNAL_ERROR, "%s",                    _("cannot initialize mutex"));        VIR_FREE(st);        return NULL;    }    virNetClientProgramRef(prog);    return st;}

/** * virObjectEventStateNew: * * Allocate a new event state object. */virObjectEventStatePtrvirObjectEventStateNew(void){    virObjectEventStatePtr state = NULL;    if (VIR_ALLOC(state) < 0)        goto error;    if (virMutexInit(&state->lock) < 0) {        virReportSystemError(errno, "%s",                             _("unable to initialize state mutex"));        VIR_FREE(state);        goto error;    }    if (VIR_ALLOC(state->callbacks) < 0)        goto error;    if (!(state->queue = virObjectEventQueueNew()))        goto error;    state->timer = -1;    return state; error:    virObjectEventStateFree(state);    return NULL;}

int virCondInit(virCondPtr c){    c->waiters = NULL;    if (virMutexInit(&c->lock) < 0)        return -1;    return 0;}

virNetSASLContextPtr virNetSASLContextNewClient(void){    virNetSASLContextPtr ctxt;    int err;    err = sasl_client_init(NULL);    if (err != SASL_OK) {        virNetError(VIR_ERR_AUTH_FAILED,                    _("failed to initialize SASL library: %d (%s)"),                    err, sasl_errstring(err, NULL, NULL));        return NULL;    }    if (VIR_ALLOC(ctxt) < 0) {        virReportOOMError();        return NULL;    }    if (virMutexInit(&ctxt->lock) < 0) {        virNetError(VIR_ERR_INTERNAL_ERROR, "%s",                    _("Failed to initialized mutex"));        VIR_FREE(ctxt);        return NULL;    }    ctxt->refs = 1;    return ctxt;}

/** * virLogStartup: * * Initialize the logging module * * Returns 0 if successful, and -1 in case or error */int virLogStartup(void) {    const char *pbm = NULL;    if (virLogInitialized)        return -1;    if (virMutexInit(&virLogMutex) < 0)        return -1;    virLogInitialized = 1;    virLogLock();    if (VIR_ALLOC_N(virLogBuffer, virLogSize + 1) < 0) {        /*         * The debug buffer is not a critical component, allow startup         * even in case of failure to allocate it in case of a         * configuration mistake.         */        virLogSize = 64 * 1024;        if (VIR_ALLOC_N(virLogBuffer, virLogSize + 1) < 0) {            pbm = "Failed to allocate debug buffer: deactivating debug log/n";            virLogSize = 0;        } else {            pbm = "Failed to allocate debug buffer: reduced to 64 kB/n";        }    }    virLogLen = 0;    virLogStart = 0;    virLogEnd = 0;    virLogDefaultPriority = VIR_LOG_DEFAULT;    virLogUnlock();    if (pbm)        VIR_WARN("%s", pbm);    return 0;}

virNetSASLContextPtr virNetSASLContextNewServer(const char *const*usernameWhitelist){    virNetSASLContextPtr ctxt;    int err;    err = sasl_server_init(NULL, "libvirt");    if (err != SASL_OK) {        virNetError(VIR_ERR_AUTH_FAILED,                    _("failed to initialize SASL library: %d (%s)"),                    err, sasl_errstring(err, NULL, NULL));        return NULL;    }    if (VIR_ALLOC(ctxt) < 0) {        virReportOOMError();        return NULL;    }    if (virMutexInit(&ctxt->lock) < 0) {        virNetError(VIR_ERR_INTERNAL_ERROR, "%s",                    _("Failed to initialized mutex"));        VIR_FREE(ctxt);        return NULL;    }    ctxt->usernameWhitelist = usernameWhitelist;    ctxt->refs = 1;    return ctxt;}

static virDrvOpenStatusparallelsStorageOpen(virConnectPtr conn,                     virConnectAuthPtr auth ATTRIBUTE_UNUSED,                     unsigned int flags){    virStorageDriverStatePtr storageState;    virCheckFlags(VIR_CONNECT_RO, VIR_DRV_OPEN_ERROR);    if (STRNEQ(conn->driver->name, "Parallels"))        return VIR_DRV_OPEN_DECLINED;    if (VIR_ALLOC(storageState) < 0)        return VIR_DRV_OPEN_ERROR;    if (virMutexInit(&storageState->lock) < 0) {        VIR_FREE(storageState);        return VIR_DRV_OPEN_ERROR;    }    conn->storagePrivateData = storageState;    parallelsStorageLock(storageState);    if (parallelsLoadPools(conn))        goto error;    parallelsStorageUnlock(storageState);    return VIR_DRV_OPEN_SUCCESS; error:    parallelsStorageUnlock(storageState);    parallelsStorageClose(conn);    return -1;}

/** * virNodeSuspendInit: * * Get the system-wide sleep states supported by the host, such as * Suspend-to-RAM, Suspend-to-Disk, or Hybrid-Suspend, so that a request * to suspend/hibernate the host can be handled appropriately based on * this information. * * Returns 0 if successful, and -1 in case of error. */int virNodeSuspendInit(void){    if (virMutexInit(&virNodeSuspendMutex) < 0)        return -1;    return 0;}

/** * virGetConnect: * * Allocates a new hypervisor connection structure * * Returns a new pointer or NULL in case of error. */virConnectPtrvirGetConnect(void) {    virConnectPtr ret;    if (VIR_ALLOC(ret) < 0) {        virReportOOMError();        goto failed;    }    if (virMutexInit(&ret->lock) < 0) {        VIR_FREE(ret);        goto failed;    }    ret->magic = VIR_CONNECT_MAGIC;    ret->driver = NULL;    ret->networkDriver = NULL;    ret->privateData = NULL;    ret->networkPrivateData = NULL;    ret->interfacePrivateData = NULL;    ret->refs = 1;    return ret;failed:    if (ret != NULL) {        virMutexDestroy(&ret->lock);        VIR_FREE(ret);    }    return NULL;}

virInterfaceObjPtr virInterfaceAssignDef(virInterfaceObjListPtr interfaces,                                         virInterfaceDefPtr def){    virInterfaceObjPtr iface;    if ((iface = virInterfaceFindByName(interfaces, def->name))) {        virInterfaceDefFree(iface->def);        iface->def = def;        return iface;    }    if (VIR_ALLOC(iface) < 0)        return NULL;    if (virMutexInit(&iface->lock) < 0) {        virReportError(VIR_ERR_INTERNAL_ERROR,                       "%s", _("cannot initialize mutex"));        VIR_FREE(iface);        return NULL;    }    virInterfaceObjLock(iface);    iface->def = def;    if (VIR_REALLOC_N(interfaces->objs, interfaces->count + 1) < 0) {        VIR_FREE(iface);        return NULL;    }    interfaces->objs[interfaces->count] = iface;    interfaces->count++;    return iface;}

virNetSASLContextPtr virNetSASLContextNewClient(void){    virNetSASLContextPtr ctxt;    int err;    if (virNetSASLContextInitialize() < 0)        return NULL;    err = sasl_client_init(NULL);    if (err != SASL_OK) {        virReportError(VIR_ERR_AUTH_FAILED,                       _("failed to initialize SASL library: %d (%s)"),                       err, sasl_errstring(err, NULL, NULL));        return NULL;    }    if (!(ctxt = virObjectNew(virNetSASLContextClass)))        return NULL;    if (virMutexInit(&ctxt->lock) < 0) {        virReportError(VIR_ERR_INTERNAL_ERROR, "%s",                       _("Failed to initialized mutex"));        VIR_FREE(ctxt);        return NULL;    }    return ctxt;}

static int virFDStreamOpenInternal(virStreamPtr st,                                   int fd,                                   virCommandPtr cmd,                                   int errfd,                                   unsigned long long length){    struct virFDStreamData *fdst;    VIR_DEBUG("st=%p fd=%d cmd=%p errfd=%d length=%llu",              st, fd, cmd, errfd, length);    if ((st->flags & VIR_STREAM_NONBLOCK) &&        virSetNonBlock(fd) < 0)        return -1;    if (VIR_ALLOC(fdst) < 0)        return -1;    fdst->fd = fd;    fdst->cmd = cmd;    fdst->errfd = errfd;    fdst->length = length;    if (virMutexInit(&fdst->lock) < 0) {        VIR_FREE(fdst);        virReportError(VIR_ERR_INTERNAL_ERROR, "%s",                       _("Unable to initialize mutex"));        return -1;    }    st->driver = &virFDStreamDrv;    st->privateData = fdst;    return 0;}

static inttestCompareFiles(const char *xml, const char *sexpr){  char *sexprData = NULL;  char *gotxml = NULL;  int id;  char * tty;  int vncport;  int ret = -1;  virDomainDefPtr def = NULL;  virConnectPtr conn;  struct _xenUnifiedPrivate priv;  conn = virGetConnect();  if (!conn) goto fail;  if (virTestLoadFile(sexpr, &sexprData) < 0)      goto fail;  memset(&priv, 0, sizeof(priv));  /* Many puppies died to bring you this code. */  priv.caps = caps;  conn->privateData = &priv;  if (virMutexInit(&priv.lock) < 0)      goto fail;  if (xenGetDomIdFromSxprString(sexprData, &id) < 0)      goto fail;  xenUnifiedLock(&priv);  tty = xenStoreDomainGetConsolePath(conn, id);  vncport = xenStoreDomainGetVNCPort(conn, id);  xenUnifiedUnlock(&priv);  if (!(def = xenParseSxprString(sexprData,                                 tty, vncport, caps, xmlopt)))      goto fail;  if (!virDomainDefCheckABIStability(def, def)) {      fprintf(stderr, "ABI stability check failed on %s", xml);      goto fail;  }  if (!(gotxml = virDomainDefFormat(def, caps, 0)))      goto fail;  if (virTestCompareToFile(gotxml, xml) < 0)      goto fail;  ret = 0; fail:  VIR_FREE(sexprData);  VIR_FREE(gotxml);  virDomainDefFree(def);  virObjectUnref(conn);  return ret;}

static int virNetDevVethCreateMutexOnceInit(void){    if (virMutexInit(&virNetDevVethCreateMutex) < 0) {        virReportSystemError(errno, "%s", _("unable to init mutex"));        return -1;    }    return 0;}

int virThreadInitialize(void){    if (virMutexInit(&virThreadLocalLock) < 0)        return -1;    if (virThreadLocalInit(&virCondEvent, virCondEventCleanup) < 0)        return -1;    return 0;}

static int virNodeSuspendOnceInit(void){    if (virMutexInit(&virNodeSuspendMutex) < 0) {        virReportError(VIR_ERR_INTERNAL_ERROR, "%s",                       _("Unable to initialize mutex"));        return -1;    }    return 0;}

static virLogDaemonPtrvirLogDaemonNewPostExecRestart(virJSONValuePtr object, bool privileged,                               virLogDaemonConfigPtr config){    virLogDaemonPtr logd;    virJSONValuePtr child;    if (VIR_ALLOC(logd) < 0)        return NULL;    if (virMutexInit(&logd->lock) < 0) {        virReportError(VIR_ERR_INTERNAL_ERROR, "%s",                       _("Unable to initialize mutex"));        VIR_FREE(logd);        return NULL;    }    if (!(child = virJSONValueObjectGet(object, "daemon"))) {        virReportError(VIR_ERR_INTERNAL_ERROR, "%s",                       _("Malformed daemon data from JSON file"));        goto error;    }    if (!(logd->dmn = virNetDaemonNewPostExecRestart(child)))        goto error;    if (!(logd->srv = virNetDaemonAddServerPostExec(logd->dmn,                                                    "virtlogd",                                                    virLogDaemonClientNew,                                                    virLogDaemonClientNewPostExecRestart,                                                    virLogDaemonClientPreExecRestart,                                                    virLogDaemonClientFree,                                                    (void*)(intptr_t)(privileged ? 0x1 : 0x0))))        goto error;    if (!(child = virJSONValueObjectGet(object, "handler"))) {        virReportError(VIR_ERR_INTERNAL_ERROR, "%s",                       _("Malformed daemon data from JSON file"));        goto error;    }    if (!(logd->handler = virLogHandlerNewPostExecRestart(child,                                                          privileged,                                                          config->max_size,                                                          config->max_backups,                                                          virLogDaemonInhibitor,                                                          logd)))        goto error;    return logd; error:    virLogDaemonFree(logd);    return NULL;}

static virNetClientPtr virNetClientNew(virNetSocketPtr sock,                                       const char *hostname){    virNetClientPtr client = NULL;    int wakeupFD[2] = { -1, -1 };    if (pipe2(wakeupFD, O_CLOEXEC) < 0) {        virReportSystemError(errno, "%s",                             _("unable to make pipe"));        goto error;    }    if (VIR_ALLOC(client) < 0)        goto no_memory;    client->refs = 1;    if (virMutexInit(&client->lock) < 0)        goto error;    client->sock = sock;    client->wakeupReadFD = wakeupFD[0];    client->wakeupSendFD = wakeupFD[1];    wakeupFD[0] = wakeupFD[1] = -1;    if (hostname &&        !(client->hostname = strdup(hostname)))        goto no_memory;    /* Set up a callback to listen on the socket data */    client->refs++;    if (virNetSocketAddIOCallback(client->sock,                                  VIR_EVENT_HANDLE_READABLE,                                  virNetClientIncomingEvent,                                  client,                                  virNetClientEventFree) < 0) {        client->refs--;        VIR_DEBUG("Failed to add event watch, disabling events");    }    PROBE(RPC_CLIENT_NEW,          "client=%p refs=%d sock=%p",          client, client->refs, client->sock);    return client;no_memory:    virReportOOMError();error:    VIR_FORCE_CLOSE(wakeupFD[0]);    VIR_FORCE_CLOSE(wakeupFD[1]);    virNetClientFree(client);    return NULL;}

static virNetServerClientPtrvirNetServerClientNewInternal(virNetSocketPtr sock,                              int auth,                              bool readonly,                              size_t nrequests_max,                              virNetTLSContextPtr tls){    virNetServerClientPtr client;    if (virNetServerClientInitialize() < 0)        return NULL;    if (!(client = virObjectNew(virNetServerClientClass)))        return NULL;    if (virMutexInit(&client->lock) < 0) {        VIR_FREE(client);        return NULL;    }    client->sock = virObjectRef(sock);    client->auth = auth;    client->readonly = readonly;    client->tlsCtxt = virObjectRef(tls);    client->nrequests_max = nrequests_max;    client->sockTimer = virEventAddTimeout(-1, virNetServerClientSockTimerFunc,                                           client, NULL);    if (client->sockTimer < 0)        goto error;    /* Prepare one for packet receive */    if (!(client->rx = virNetMessageNew(true)))        goto error;    client->rx->bufferLength = VIR_NET_MESSAGE_LEN_MAX;    if (VIR_ALLOC_N(client->rx->buffer, client->rx->bufferLength) < 0) {        virReportOOMError();        goto error;    }    client->nrequests = 1;    PROBE(RPC_SERVER_CLIENT_NEW,          "client=%p sock=%p",          client, client->sock);    return client;error:    virObjectUnref(client);    return NULL;}

virThreadPoolPtrvirThreadPoolNewFull(size_t minWorkers,                     size_t maxWorkers,                     size_t prioWorkers,                     virThreadPoolJobFunc func,                     const char *funcName,                     void *opaque){    virThreadPoolPtr pool;    if (minWorkers > maxWorkers)        minWorkers = maxWorkers;    if (VIR_ALLOC(pool) < 0)        return NULL;    pool->jobList.tail = pool->jobList.head = NULL;    pool->jobFunc = func;    pool->jobFuncName = funcName;    pool->jobOpaque = opaque;    if (virMutexInit(&pool->mutex) < 0)        goto error;    if (virCondInit(&pool->cond) < 0)        goto error;    if (virCondInit(&pool->quit_cond) < 0)        goto error;    pool->minWorkers = minWorkers;    pool->maxWorkers = maxWorkers;    pool->maxPrioWorkers = prioWorkers;    if (virThreadPoolExpand(pool, minWorkers, false) < 0)        goto error;    if (prioWorkers) {        if (virCondInit(&pool->prioCond) < 0)            goto error;        if (virThreadPoolExpand(pool, prioWorkers, true) < 0)            goto error;    }    return pool; error:    virThreadPoolFree(pool);    return NULL;}

int qemuTestDriverInit(virQEMUDriver *driver){    virSecurityManagerPtr mgr = NULL;    memset(driver, 0, sizeof(*driver));    if (virMutexInit(&driver->lock) < 0)        return -1;    driver->config = virQEMUDriverConfigNew(false);    if (!driver->config)        goto error;    /* Overwrite some default paths so it's consistent for tests. */    VIR_FREE(driver->config->libDir);    VIR_FREE(driver->config->channelTargetDir);    if (VIR_STRDUP(driver->config->libDir, "/tmp/lib") < 0 ||        VIR_STRDUP(driver->config->channelTargetDir, "/tmp/channel") < 0)        goto error;    driver->caps = testQemuCapsInit();    if (!driver->caps)        goto error;    /* Using /dev/null for libDir and cacheDir automatically produces errors     * upon attempt to use any of them */    driver->qemuCapsCache = virQEMUCapsCacheNew("/dev/null", "/dev/null", 0, 0);    if (!driver->qemuCapsCache)        goto error;    driver->xmlopt = virQEMUDriverCreateXMLConf(driver);    if (!driver->xmlopt)        goto error;    if (qemuTestCapsCacheInsert(driver->qemuCapsCache, "empty", NULL) < 0)        goto error;    if (!(mgr = virSecurityManagerNew("none", "qemu",                                      VIR_SECURITY_MANAGER_PRIVILEGED)))        goto error;    if (!(driver->securityManager = virSecurityManagerNewStack(mgr)))        goto error;    return 0; error:    virObjectUnref(mgr);    qemuTestDriverFree(driver);    return -1;}

intvirNWFilterIPAddrMapInit(void){    ipAddressMap = virNWFilterHashTableCreate(0);    if (!ipAddressMap)        return -1;    if (virMutexInit(&ipAddressMapLock) < 0) {        virNWFilterIPAddrMapShutdown();        return -1;    }    return 0;}

/** * virLogStartup: * * Initialize the logging module * * Returns 0 if successful, and -1 in case or error */int virLogStartup(void) {    if (virLogInitialized)        return(-1);    if (virMutexInit(&virLogMutex) < 0)        return -1;    virLogInitialized = 1;    virLogLock();    virLogLen = 0;    virLogStart = 0;    virLogEnd = 0;    virLogDefaultPriority = VIR_LOG_DEFAULT;    virLogUnlock();    return(0);}

void *remoteAdmClientNew(virNetServerClientPtr client ATTRIBUTE_UNUSED,                   void *opaque){    struct daemonAdmClientPrivate *priv;    uid_t clientuid;    gid_t clientgid;    pid_t clientpid;    unsigned long long timestamp;    if (virNetServerClientGetUNIXIdentity(client,                                          &clientuid,                                          &clientgid,                                          &clientpid,                                          &timestamp) < 0)        return NULL;    VIR_DEBUG("New client pid %lld uid %lld",              (long long)clientpid,              (long long)clientuid);    if (geteuid() != clientuid) {        virReportRestrictedError(_("Disallowing client %lld with uid %lld"),                                 (long long)clientpid,                                 (long long)clientuid);        return NULL;    }    if (VIR_ALLOC(priv) < 0)        return NULL;    if (virMutexInit(&priv->lock) < 0) {        VIR_FREE(priv);        virReportSystemError(errno, "%s", _("unable to init mutex"));        return NULL;    }    /*     * We don't necessarily need to ref this object right now as there     * must be one ref being held throughout the life of the daemon,     * but let's just be safe for future.     */    priv->dmn = virObjectRef(opaque);    return priv;}

static intvirLogOnceInit(void){    if (virMutexInit(&virLogMutex) < 0)        return -1;    virLogLock();    virLogDefaultPriority = VIR_LOG_DEFAULT;    if (VIR_ALLOC_QUIET(virLogRegex) >= 0) {        if (regcomp(virLogRegex, VIR_LOG_REGEX, REG_EXTENDED) != 0)            VIR_FREE(virLogRegex);    }    virLogUnlock();    return 0;}

virNetSASLSessionPtr virNetSASLSessionNewClient(virNetSASLContextPtr ctxt ATTRIBUTE_UNUSED,                                                const char *service,                                                const char *hostname,                                                const char *localAddr,                                                const char *remoteAddr,                                                const sasl_callback_t *cbs){    virNetSASLSessionPtr sasl = NULL;    int err;    if (VIR_ALLOC(sasl) < 0) {        virReportOOMError();        goto cleanup;    }    if (virMutexInit(&sasl->lock) < 0) {        virNetError(VIR_ERR_INTERNAL_ERROR, "%s",                    _("Failed to initialized mutex"));        VIR_FREE(sasl);        return NULL;    }    sasl->refs = 1;    /* Arbitrary size for amount of data we can encode in a single block */    sasl->maxbufsize = 1 << 16;    err = sasl_client_new(service,                          hostname,                          localAddr,                          remoteAddr,                          cbs,                          SASL_SUCCESS_DATA,                          &sasl->conn);    if (err != SASL_OK) {        virNetError(VIR_ERR_AUTH_FAILED,                    _("Failed to create SASL client context: %d (%s)"),                    err, sasl_errstring(err, NULL, NULL));        goto cleanup;    }    return sasl;cleanup:    virNetSASLSessionFree(sasl);    return NULL;}

static virLogDaemonPtrvirLogDaemonNew(virLogDaemonConfigPtr config, bool privileged){    virLogDaemonPtr logd;    if (VIR_ALLOC(logd) < 0)        return NULL;    if (virMutexInit(&logd->lock) < 0) {        virReportError(VIR_ERR_INTERNAL_ERROR, "%s",                       _("Unable to initialize mutex"));        VIR_FREE(logd);        return NULL;    }    if (!(logd->srv = virNetServerNew("virtlogd", 1,                                      1, 1, 0, config->max_clients,                                      config->max_clients, -1, 0,                                      NULL,                                      virLogDaemonClientNew,                                      virLogDaemonClientPreExecRestart,                                      virLogDaemonClientFree,                                      (void*)(intptr_t)(privileged ? 0x1 : 0x0))))        goto error;    if (!(logd->dmn = virNetDaemonNew()) ||        virNetDaemonAddServer(logd->dmn, logd->srv) < 0)        goto error;    if (!(logd->handler = virLogHandlerNew(privileged,                                           config->max_size,                                           config->max_backups,                                           virLogDaemonInhibitor,                                           logd)))        goto error;    return logd; error:    virLogDaemonFree(logd);    return NULL;}

virNetSASLSessionPtr virNetSASLSessionNewServer(virNetSASLContextPtr ctxt ATTRIBUTE_UNUSED,                                                const char *service,                                                const char *localAddr,                                                const char *remoteAddr){    virNetSASLSessionPtr sasl = NULL;    int err;    if (!(sasl = virObjectNew(virNetSASLSessionClass)))        return NULL;    if (virMutexInit(&sasl->lock) < 0) {        virReportError(VIR_ERR_INTERNAL_ERROR, "%s",                       _("Failed to initialized mutex"));        VIR_FREE(sasl);        return NULL;    }    /* Arbitrary size for amount of data we can encode in a single block */    sasl->maxbufsize = 1 << 16;    err = sasl_server_new(service,                          NULL,                          NULL,                          localAddr,                          remoteAddr,                          NULL,                          SASL_SUCCESS_DATA,                          &sasl->conn);    if (err != SASL_OK) {        virReportError(VIR_ERR_AUTH_FAILED,                       _("Failed to create SASL client context: %d (%s)"),                       err, sasl_errstring(err, NULL, NULL));        goto cleanup;    }    return sasl;cleanup:    virObjectUnref(sasl);    return NULL;}

static intvirLogOnceInit(void){    const char *pbm = NULL;    if (virMutexInit(&virLogMutex) < 0)        return -1;    virLogLock();    if (VIR_ALLOC_N_QUIET(virLogBuffer, virLogSize + 1) < 0) {        /*         * The debug buffer is not a critical component, allow startup         * even in case of failure to allocate it in case of a         * configuration mistake.         */        virLogSize = 64 * 1024;        if (VIR_ALLOC_N_QUIET(virLogBuffer, virLogSize + 1) < 0) {            pbm = "Failed to allocate debug buffer: deactivating debug log/n";            virLogSize = 0;        } else {            pbm = "Failed to allocate debug buffer: reduced to 64 kB/n";        }    }    virLogLen = 0;    virLogStart = 0;    virLogEnd = 0;    virLogDefaultPriority = VIR_LOG_DEFAULT;    if (VIR_ALLOC_QUIET(virLogRegex) >= 0) {        if (regcomp(virLogRegex, VIR_LOG_REGEX, REG_EXTENDED) != 0)            VIR_FREE(virLogRegex);    }    virLogUnlock();    if (pbm)        VIR_WARN("%s", pbm);    return 0;}

virKeepAlivePtrvirKeepAliveNew(int interval,                unsigned int count,                void *client,                virKeepAliveSendFunc sendCB,                virKeepAliveDeadFunc deadCB,                virKeepAliveFreeFunc freeCB){    virKeepAlivePtr ka;    VIR_DEBUG("client=%p, interval=%d, count=%u", client, interval, count);    if (VIR_ALLOC(ka) < 0) {        virReportOOMError();        return NULL;    }    if (virMutexInit(&ka->lock) < 0) {        VIR_FREE(ka);        return NULL;    }    ka->refs = 1;    ka->interval = interval;    ka->count = count;    ka->countToDeath = count;    ka->timer = -1;    ka->client = client;    ka->sendCB = sendCB;    ka->deadCB = deadCB;    ka->freeCB = freeCB;    PROBE(RPC_KEEPALIVE_NEW,          "ka=%p client=%p refs=%d",          ka, ka->client, ka->refs);    return ka;}