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

voidisc_stats_detach(isc_stats_t **statsp) {	isc_stats_t *stats;	REQUIRE(statsp != NULL && ISC_STATS_VALID(*statsp));	stats = *statsp;	*statsp = NULL;	LOCK(&stats->lock);	stats->references--;	UNLOCK(&stats->lock);	if (stats->references == 0) {		isc_mem_put(stats->mctx, stats->copiedcounters,			    sizeof(isc_stat_t) * stats->ncounters);		isc_mem_put(stats->mctx, stats->counters,			    sizeof(isc_stat_t) * stats->ncounters);		DESTROYLOCK(&stats->lock);#ifdef ISC_RWLOCK_USEATOMIC		isc_rwlock_destroy(&stats->counterlock);#endif		isc_mem_putanddetach(&stats->mctx, stats, sizeof(*stats));	}}

/* * Called when bind is shutting down */static voiddlopen_dlz_destroy(void *driverarg, void *dbdata) {	dlopen_data_t *cd = (dlopen_data_t *) dbdata;	isc_mem_t *mctx;	UNUSED(driverarg);	if (cd->dlz_destroy) {		MAYBE_LOCK(cd);		cd->dlz_destroy(cd->dbdata);		MAYBE_UNLOCK(cd);	}	if (cd->dl_path)		isc_mem_free(cd->mctx, cd->dl_path);	if (cd->dlzname)		isc_mem_free(cd->mctx, cd->dlzname);	if (cd->dl_handle)		FreeLibrary(cd->dl_handle);	DESTROYLOCK(&cd->lock);	mctx = cd->mctx;	isc_mem_put(mctx, cd, sizeof(*cd));	isc_mem_destroy(&mctx);}

static voiddestroy(isc_hash_t **hctxp) {	isc_hash_t *hctx;	isc_mem_t *mctx;	unsigned char canary0[4], canary1[4];	REQUIRE(hctxp != NULL && *hctxp != NULL);	hctx = *hctxp;	*hctxp = NULL;	LOCK(&hctx->lock);	isc_refcount_destroy(&hctx->refcnt);	mctx = hctx->mctx;#ifdef BIND9	if (hctx->entropy != NULL)		isc_entropy_detach(&hctx->entropy);#endif	if (hctx->rndvector != NULL)		isc_mem_put(mctx, hctx->rndvector, hctx->vectorlen);	UNLOCK(&hctx->lock);	DESTROYLOCK(&hctx->lock);	memcpy(canary0, hctx + 1, sizeof(canary0));	memset(hctx, 0, sizeof(isc_hash_t));	memcpy(canary1, hctx + 1, sizeof(canary1));	INSIST(memcmp(canary0, canary1, sizeof(canary0)) == 0);	isc_mem_put(mctx, hctx, sizeof(isc_hash_t));	isc_mem_detach(&mctx);}

static voidns_interface_destroy(ns_interface_t *ifp) {	isc_mem_t *mctx = ifp->mgr->mctx;	int disp;	REQUIRE(NS_INTERFACE_VALID(ifp));	ns_interface_shutdown(ifp);	for (disp = 0; disp < ifp->nudpdispatch; disp++)		if (ifp->udpdispatch[disp] != NULL) {			dns_dispatch_changeattributes(ifp->udpdispatch[disp], 0,						    DNS_DISPATCHATTR_NOLISTEN);			dns_dispatch_detach(&(ifp->udpdispatch[disp]));		}	if (ifp->tcpsocket != NULL)		isc_socket_detach(&ifp->tcpsocket);	DESTROYLOCK(&ifp->lock);	ns_interfacemgr_detach(&ifp->mgr);	ifp->magic = 0;	isc_mem_put(mctx, ifp, sizeof(*ifp));}

static voidtask_finished(isc__task_t *task) {	isc__taskmgr_t *manager = task->manager;	REQUIRE(EMPTY(task->events));	REQUIRE(EMPTY(task->on_shutdown));	REQUIRE(task->references == 0);	REQUIRE(task->state == task_state_done);	XTRACE("task_finished");	LOCK(&manager->lock);	UNLINK(manager->tasks, task, link);#ifdef USE_WORKER_THREADS	if (FINISHED(manager)) {		/*		 * All tasks have completed and the		 * task manager is exiting.  Wake up		 * any idle worker threads so they		 * can exit.		 */		BROADCAST(&manager->work_available);	}#endif /* USE_WORKER_THREADS */	UNLOCK(&manager->lock);	DESTROYLOCK(&task->lock);	task->common.impmagic = 0;	task->common.magic = 0;	isc_mem_put(manager->mctx, task, sizeof(*task));}

static inline voiddestroy(dns_ssutable_t *table) {	isc_mem_t *mctx;	REQUIRE(VALID_SSUTABLE(table));	mctx = table->mctx;	while (!ISC_LIST_EMPTY(table->rules)) {		dns_ssurule_t *rule = ISC_LIST_HEAD(table->rules);		if (rule->identity != NULL) {			dns_name_free(rule->identity, mctx);			isc_mem_put(mctx, rule->identity, sizeof(dns_name_t));		}		if (rule->name != NULL) {			dns_name_free(rule->name, mctx);			isc_mem_put(mctx, rule->name, sizeof(dns_name_t));		}		if (rule->types != NULL)			isc_mem_put(mctx, rule->types,				    rule->ntypes * sizeof(dns_rdatatype_t));		ISC_LIST_UNLINK(table->rules, rule, link);		rule->magic = 0;		isc_mem_put(mctx, rule, sizeof(dns_ssurule_t));	}	DESTROYLOCK(&table->lock);	table->magic = 0;	isc_mem_putanddetach(&table->mctx, table, sizeof(dns_ssutable_t));}

static voiddestroy(isc_hash_t **hctxp) {	isc_hash_t *hctx;	isc_mem_t *mctx;	REQUIRE(hctxp != NULL && *hctxp != NULL);	hctx = *hctxp;	*hctxp = NULL;	LOCK(&hctx->lock);	isc_refcount_destroy(&hctx->refcnt);	mctx = hctx->mctx;	if (hctx->entropy != NULL)		isc_entropy_detach(&hctx->entropy);	if (hctx->rndvector != NULL)		isc_mem_put(mctx, hctx->rndvector, hctx->vectorlen);	UNLOCK(&hctx->lock);	DESTROYLOCK(&hctx->lock);	memset(hctx, 0, sizeof(isc_hash_t));	isc_mem_put(mctx, hctx, sizeof(isc_hash_t));	isc_mem_detach(&mctx);}

static voiddestroy(isc__timer_t *timer) {	isc__timermgr_t *manager = timer->manager;	/*	 * The caller must ensure it is safe to destroy the timer.	 */	LOCK(&manager->lock);	(void)isc_task_purgerange(timer->task,				  timer,				  ISC_TIMEREVENT_FIRSTEVENT,				  ISC_TIMEREVENT_LASTEVENT,				  NULL);	deschedule(timer);	UNLINK(manager->timers, timer, link);	UNLOCK(&manager->lock);	isc_task_detach(&timer->task);	DESTROYLOCK(&timer->lock);	timer->common.impmagic = 0;	timer->common.magic = 0;	isc_mem_put(manager->mctx, timer, sizeof(*timer));}

/** * Free dynamically allocated memory associated with given set of settings. * @pre *set is initialized set of settings, set != NULL && *set != NULL * @post *set == NULL */voidsettings_set_free(settings_set_t **set) {	isc_mem_t *mctx = NULL;	setting_t *s = NULL;	if (set == NULL || *set == NULL)		return;	if ((*set)->mctx != NULL) {		mctx = (*set)->mctx;		if ((*set)->lock != NULL) {			DESTROYLOCK((*set)->lock);			SAFE_MEM_PUT_PTR(mctx, (*set)->lock);		}		for (s = (*set)->first_setting; s->name != NULL; s++) {			if (s->is_dynamic)				isc_mem_free(mctx, s->value.value_char);		}		if ((*set)->first_setting != NULL)			isc_mem_free(mctx, (*set)->first_setting);		isc_mem_free(mctx, (*set)->name);		isc_mem_free(mctx, *set);		isc_mem_detach(&mctx);	}	*set = NULL;}

voiddns_keytable_detach(dns_keytable_t **keytablep) {	isc_boolean_t destroy = ISC_FALSE;	dns_keytable_t *keytable;	/*	 * Detach *keytablep from its keytable.	 */	REQUIRE(keytablep != NULL && VALID_KEYTABLE(*keytablep));	keytable = *keytablep;	RWLOCK(&keytable->rwlock, isc_rwlocktype_write);	INSIST(keytable->references > 0);	keytable->references--;	LOCK(&keytable->lock);	if (keytable->references == 0 && keytable->active_nodes == 0)		destroy = ISC_TRUE;	UNLOCK(&keytable->lock);	RWUNLOCK(&keytable->rwlock, isc_rwlocktype_write);	if (destroy) {		dns_rbt_destroy(&keytable->table);		isc_rwlock_destroy(&keytable->rwlock);		DESTROYLOCK(&keytable->lock);		keytable->magic = 0;		isc_mem_putanddetach(&keytable->mctx,				     keytable, sizeof(*keytable));	}	*keytablep = NULL;}

voidisc_quota_destroy(isc_quota_t *quota) {    INSIST(quota->used == 0);    quota->max = -1;    quota->used = -1;    quota->soft = ISC_FALSE;    DESTROYLOCK(&quota->lock);}

voidisc_quota_destroy(isc_quota_t *quota) {	INSIST(quota->used == 0);	quota->max = 0;	quota->used = 0;	quota->soft = 0;	DESTROYLOCK(&quota->lock);}

ISC_APPFUNC_SCOPE voidisc__app_ctxfinish(isc_appctx_t *ctx0) {	isc__appctx_t *ctx = (isc__appctx_t *)ctx0;	REQUIRE(VALID_APPCTX(ctx));	DESTROYLOCK(&ctx->lock);}

ISC_TASKFUNC_SCOPE isc_result_tisc__task_create(isc_taskmgr_t *manager0, unsigned int quantum,		 isc_task_t **taskp){	isc__taskmgr_t *manager = (isc__taskmgr_t *)manager0;	isc__task_t *task;	isc_boolean_t exiting;	isc_result_t result;	REQUIRE(VALID_MANAGER(manager));	REQUIRE(taskp != NULL && *taskp == NULL);	task = isc_mem_get(manager->mctx, sizeof(*task));	if (task == NULL)		return (ISC_R_NOMEMORY);	XTRACE("isc_task_create");	task->manager = manager;	result = isc_mutex_init(&task->lock);	if (result != ISC_R_SUCCESS) {		isc_mem_put(manager->mctx, task, sizeof(*task));		return (result);	}	task->state = task_state_idle;	task->references = 1;	INIT_LIST(task->events);	INIT_LIST(task->on_shutdown);	task->quantum = quantum;	task->flags = 0;	task->now = 0;	memset(task->name, 0, sizeof(task->name));	task->tag = NULL;	INIT_LINK(task, link);	INIT_LINK(task, ready_link);	INIT_LINK(task, ready_priority_link);	exiting = ISC_FALSE;	LOCK(&manager->lock);	if (!manager->exiting) {		if (task->quantum == 0)			task->quantum = manager->default_quantum;		APPEND(manager->tasks, task, link);	} else		exiting = ISC_TRUE;	UNLOCK(&manager->lock);	if (exiting) {		DESTROYLOCK(&task->lock);		isc_mem_put(manager->mctx, task, sizeof(*task));		return (ISC_R_SHUTTINGDOWN);	}	task->common.methods = (isc_taskmethods_t *)&taskmethods;	task->common.magic = ISCAPI_TASK_MAGIC;	task->common.impmagic = TASK_MAGIC;	*taskp = (isc_task_t *)task;	return (ISC_R_SUCCESS);}

static voidns_interfacemgr_destroy(ns_interfacemgr_t *mgr) {	REQUIRE(NS_INTERFACEMGR_VALID(mgr));	dns_aclenv_destroy(&mgr->aclenv);	ns_listenlist_detach(&mgr->listenon4);	ns_listenlist_detach(&mgr->listenon6);	clearlistenon(mgr);	DESTROYLOCK(&mgr->lock);	mgr->magic = 0;	isc_mem_putanddetach(&mgr->mctx, mgr, sizeof(*mgr));}

static voiddestroy_listener(void *arg) {	ns_statschannel_t *listener = arg;	REQUIRE(listener != NULL);	REQUIRE(!ISC_LINK_LINKED(listener, link));	/* We don't have to acquire the lock here since it's already unlinked */	dns_acl_detach(&listener->acl);	DESTROYLOCK(&listener->lock);	isc_mem_putanddetach(&listener->mctx, listener, sizeof(*listener));}

isc_result_tisc_ratelimiter_create(isc_mem_t *mctx, isc_timermgr_t *timermgr,		       isc_task_t *task, isc_ratelimiter_t **ratelimiterp){	isc_result_t result;	isc_ratelimiter_t *rl;	INSIST(ratelimiterp != NULL && *ratelimiterp == NULL);	rl = isc_mem_get(mctx, sizeof(*rl));	if (rl == NULL)		return ISC_R_NOMEMORY;	rl->mctx = mctx;	rl->refs = 1;	rl->task = task;	isc_interval_set(&rl->interval, 0, 0);	rl->timer = NULL;	rl->pertic = 1;	rl->state = isc_ratelimiter_idle;	ISC_LIST_INIT(rl->pending);	result = isc_mutex_init(&rl->lock);	if (result != ISC_R_SUCCESS)		goto free_mem;	result = isc_timer_create(timermgr, isc_timertype_inactive,				  NULL, NULL, rl->task, ratelimiter_tick,				  rl, &rl->timer);	if (result != ISC_R_SUCCESS)		goto free_mutex;	/*	 * Increment the reference count to indicate that we may	 * (soon) have events outstanding.	 */	rl->refs++;	ISC_EVENT_INIT(&rl->shutdownevent,		       sizeof(isc_event_t),		       0, NULL, ISC_RATELIMITEREVENT_SHUTDOWN,		       ratelimiter_shutdowncomplete, rl, rl, NULL, NULL);	*ratelimiterp = rl;	return (ISC_R_SUCCESS);free_mutex:	DESTROYLOCK(&rl->lock);free_mem:	isc_mem_put(mctx, rl, sizeof(*rl));	return (result);}

isc_result_tdns_dbtable_create(isc_mem_t *mctx, dns_rdataclass_t rdclass,		   dns_dbtable_t **dbtablep){	dns_dbtable_t *dbtable;	isc_result_t result;	REQUIRE(mctx != NULL);	REQUIRE(dbtablep != NULL && *dbtablep == NULL);	dbtable = (dns_dbtable_t *)isc_mem_get(mctx, sizeof(*dbtable));	if (dbtable == NULL)		return (ISC_R_NOMEMORY);	dbtable->rbt = NULL;	result = dns_rbt_create(mctx, dbdetach, NULL, &dbtable->rbt);	if (result != ISC_R_SUCCESS)		goto clean1;	result = isc_mutex_init(&dbtable->lock);	if (result != ISC_R_SUCCESS)		goto clean2;	result = isc_rwlock_init(&dbtable->tree_lock, 0, 0);	if (result != ISC_R_SUCCESS)		goto clean3;	dbtable->default_db = NULL;	dbtable->mctx = NULL;	isc_mem_attach(mctx, &dbtable->mctx);	dbtable->rdclass = rdclass;	dbtable->magic = DBTABLE_MAGIC;	dbtable->references = 1;	*dbtablep = dbtable;	return (ISC_R_SUCCESS); clean3:	DESTROYLOCK(&dbtable->lock); clean2:	dns_rbt_destroy(&dbtable->rbt); clean1:	isc_mem_putanddetach(&mctx, dbtable, sizeof(*dbtable));	return (result);}

static voidmanager_free(isc_taskmgr_t *manager) {	isc_mem_t *mctx;#ifdef ISC_PLATFORM_USETHREADS	(void)isc_condition_destroy(&manager->exclusive_granted);	(void)isc_condition_destroy(&manager->work_available);	isc_mem_free(manager->mctx, manager->threads);#endif /* ISC_PLATFORM_USETHREADS */	DESTROYLOCK(&manager->lock);	manager->magic = 0;	mctx = manager->mctx;	isc_mem_put(mctx, manager, sizeof(*manager));	isc_mem_detach(&mctx);}

voiddns_badcache_destroy(dns_badcache_t **bcp) {	dns_badcache_t *bc;	REQUIRE(bcp != NULL && *bcp != NULL);	bc = *bcp;	dns_badcache_flush(bc);	bc->magic = 0;	DESTROYLOCK(&bc->lock);	isc_mem_put(bc->mctx, bc->table, sizeof(dns_bcentry_t *) * bc->size);	isc_mem_putanddetach(&bc->mctx, bc, sizeof(dns_badcache_t));	*bcp = NULL;}

isc_result_tdns_keytable_create(isc_mem_t *mctx, dns_keytable_t **keytablep) {	dns_keytable_t *keytable;	isc_result_t result;	/*	 * Create a keytable.	 */	REQUIRE(keytablep != NULL && *keytablep == NULL);	keytable = isc_mem_get(mctx, sizeof(*keytable));	if (keytable == NULL)		return (ISC_R_NOMEMORY);	keytable->table = NULL;	result = dns_rbt_create(mctx, free_keynode, mctx, &keytable->table);	if (result != ISC_R_SUCCESS)		goto cleanup_keytable;	result = isc_mutex_init(&keytable->lock);	if (result != ISC_R_SUCCESS)		goto cleanup_rbt;	result = isc_rwlock_init(&keytable->rwlock, 0, 0);	if (result != ISC_R_SUCCESS)		goto cleanup_lock;	keytable->mctx = NULL;	isc_mem_attach(mctx, &keytable->mctx);	keytable->active_nodes = 0;	keytable->references = 1;	keytable->magic = KEYTABLE_MAGIC;	*keytablep = keytable;	return (ISC_R_SUCCESS);   cleanup_lock:	DESTROYLOCK(&keytable->lock);   cleanup_rbt:	dns_rbt_destroy(&keytable->table);   cleanup_keytable:	isc_mem_putanddetach(&mctx, keytable, sizeof(*keytable));	return (result);}

static voidlwdclientmgr_destroy(ns_lwdclientmgr_t *cm) {	ns_lwdclient_t *client;	ns_lwreslistener_t *listener;	LOCK(&cm->lock);	if (!SHUTTINGDOWN(cm)) {		UNLOCK(&cm->lock);		return;	}	/*	 * Run through the idle list and free the clients there.  Idle	 * clients do not have a recv running nor do they have any finds	 * or similar running.	 */	client = ISC_LIST_HEAD(cm->idle);	while (client != NULL) {		ns_lwdclient_log(50, "destroying client %p, manager %p",				 client, cm);		ISC_LIST_UNLINK(cm->idle, client, link);		isc_mem_put(cm->mctx, client, sizeof(*client));		client = ISC_LIST_HEAD(cm->idle);	}	if (!ISC_LIST_EMPTY(cm->running)) {		UNLOCK(&cm->lock);		return;	}	UNLOCK(&cm->lock);	lwres_context_destroy(&cm->lwctx);	cm->view = NULL;	isc_socket_detach(&cm->sock);	isc_task_detach(&cm->task);	DESTROYLOCK(&cm->lock);	listener = cm->listener;	ns_lwreslistener_unlinkcm(listener, cm);	ns_lwdclient_log(50, "destroying manager %p", cm);	isc_mem_put(cm->mctx, cm, sizeof(*cm));	ns_lwreslistener_detach(&listener);}

static voidns_interfacemgr_destroy(ns_interfacemgr_t *mgr) {	REQUIRE(NS_INTERFACEMGR_VALID(mgr));#ifdef USE_ROUTE_SOCKET	if (mgr->route != NULL)		isc_socket_detach(&mgr->route);	if (mgr->task != NULL)		isc_task_detach(&mgr->task);#endif	dns_aclenv_destroy(&mgr->aclenv);	ns_listenlist_detach(&mgr->listenon4);	ns_listenlist_detach(&mgr->listenon6);	clearlistenon(mgr);	DESTROYLOCK(&mgr->lock);	mgr->magic = 0;	isc_mem_putanddetach(&mgr->mctx, mgr, sizeof(*mgr));}

/* * Initialize a semaphore. * * sem - allocated semaphore that will be initialized * value - number of times we can acquire the semaphore. */isc_result_tsemaphore_init(semaphore_t *sem, int value){	isc_result_t result;	REQUIRE(sem != NULL);	REQUIRE(value > 0);	sem->value = value;	result = isc_mutex_init(&sem->mutex);	if (result != ISC_R_SUCCESS)		return result;	result = isc_condition_init(&sem->cond);	if (result != ISC_R_SUCCESS)		DESTROYLOCK(&sem->mutex);	return result;}