Lines Matching defs:zmgr
278 dns_zonemgr_t *zmgr;
279 ISC_LINK(dns_zone_t) link; /* Used by zmgr. */
1000 zmgr_start_xfrin_ifquota(dns_zonemgr_t *zmgr, dns_zone_t *zone);
1002 zmgr_resume_xfrs(dns_zonemgr_t *zmgr, bool multi);
1004 zonemgr_free(dns_zonemgr_t *zmgr);
1049 zmgr_tlsctx_attach(dns_zonemgr_t *zmgr, isc_tlsctx_cache_t **ptlsctx_cache);
1058 *\li 'zmgr' is a valid zone manager.
1264 REQUIRE(zone->zmgr == NULL);
2448 if (zone->zmgr == NULL) {
2677 if (zone->zmgr != NULL && zone->db != NULL) {
5757 return zone->zmgr;
12248 dns_zonemgr_t *zmgr;
12279 zmgr = notify->zone->zmgr;
12280 result = isc_ratelimiter_dequeue(zmgr->startupnotifyrl,
12288 notify->zone->zmgr->notifyrl, notify->zone->loop,
12489 startup ? notify->zone->zmgr->startupnotifyrl
12490 : notify->zone->zmgr->notifyrl,
12625 zmgr_tlsctx_attach(notify->zone->zmgr, &zmgr_tlsctx_cache);
13178 dns_zonemgr_unreachableadd(zone->zmgr, &curraddr,
13614 dns_zonemgr_unreachableadd(zone->zmgr, &curraddr,
13962 zone->zmgr, &curraddr,
14205 if (dns_zonemgr_unreachable(zone->zmgr, &curraddr,
14355 result = isc_ratelimiter_enqueue(zone->zmgr->refreshrl, zone->loop,
14881 if (zone->zmgr != NULL) {
14882 RWLOCK(&zone->zmgr->rwlock, isc_rwlocktype_write);
14883 if (zone->statelist == &zone->zmgr->waiting_for_xfrin) {
14884 ISC_LIST_UNLINK(zone->zmgr->waiting_for_xfrin, zone,
14889 if (zone->statelist == &zone->zmgr->xfrin_in_progress) {
14890 ISC_LIST_UNLINK(zone->zmgr->xfrin_in_progress, zone,
14893 zmgr_resume_xfrs(zone->zmgr, false);
14895 RWUNLOCK(&zone->zmgr->rwlock, isc_rwlocktype_write);
14907 if (zone->zmgr != NULL) {
14908 dns_zonemgr_releasezone(zone->zmgr, zone);
15569 dns_zonemgr_unreachabledel(zone->zmgr, from, to);
17487 * Lock hierarchy: zmgr, zone, raw.
18068 if (zone->zmgr != NULL &&
18069 zone->statelist == &zone->zmgr->xfrin_in_progress)
18072 RWLOCK(&zone->zmgr->rwlock, isc_rwlocktype_write);
18073 ISC_LIST_UNLINK(zone->zmgr->xfrin_in_progress, zone, statelink);
18075 zmgr_resume_xfrs(zone->zmgr, false);
18076 RWUNLOCK(&zone->zmgr->rwlock, isc_rwlocktype_write);
18123 * Lock hierarchy: zmgr, zone, raw.
18290 dns_zonemgr_t *zmgr = zone->zmgr;
18296 RWLOCK(&zmgr->rwlock, isc_rwlocktype_write);
18297 ISC_LIST_APPEND(zmgr->waiting_for_xfrin, zone, statelink);
18299 zone->statelist = &zmgr->waiting_for_xfrin;
18300 result = zmgr_start_xfrin_ifquota(zmgr, zone);
18301 RWUNLOCK(&zmgr->rwlock, isc_rwlocktype_write);
18400 if (dns_zonemgr_unreachable(zone->zmgr, &primaryaddr, &zone->sourceaddr,
18531 zmgr_tlsctx_attach(zone->zmgr, &zmgr_tlsctx_cache);
18552 * zmgr->xfrin_in_progress.
18678 zmgr_tlsctx_attach(zone->zmgr, &zmgr_tlsctx_cache);
18891 dns_zone_first(dns_zonemgr_t *zmgr, dns_zone_t **first) {
18892 REQUIRE(DNS_ZONEMGR_VALID(zmgr));
18895 *first = ISC_LIST_HEAD(zmgr->zones);
18908 zonemgr_keymgmt_init(dns_zonemgr_t *zmgr) {
18909 dns_keymgmt_t *mgmt = isc_mem_get(zmgr->mctx, sizeof(*mgmt));
18915 isc_mem_attach(zmgr->mctx, &mgmt->mctx);
18919 zmgr->keymgmt = mgmt;
18923 zonemgr_keymgmt_destroy(dns_zonemgr_t *zmgr) {
18924 dns_keymgmt_t *mgmt = zmgr->keymgmt;
18947 zonemgr_keymgmt_add(dns_zonemgr_t *zmgr, dns_zone_t *zone,
18949 dns_keymgmt_t *mgmt = zmgr->keymgmt;
18996 zonemgr_keymgmt_delete(dns_zonemgr_t *zmgr, dns_keyfileio_t **deleted) {
18997 REQUIRE(DNS_KEYMGMT_VALID(zmgr->keymgmt));
19000 dns_keymgmt_t *mgmt = zmgr->keymgmt;
19026 dns_zonemgr_t *zmgr = NULL;
19034 zmgr = isc_mem_get(mctx, sizeof(*zmgr));
19036 *zmgr = (dns_zonemgr_t){
19044 isc_refcount_init(&zmgr->refs, 1);
19045 isc_mem_attach(mctx, &zmgr->mctx);
19047 ISC_LIST_INIT(zmgr->zones);
19048 ISC_LIST_INIT(zmgr->waiting_for_xfrin);
19049 ISC_LIST_INIT(zmgr->xfrin_in_progress);
19050 memset(zmgr->unreachable, 0, sizeof(zmgr->unreachable));
19052 atomic_init(&zmgr->unreachable[i].expire, 0);
19054 isc_rwlock_init(&zmgr->rwlock);
19057 isc_rwlock_init(&zmgr->urlock);
19059 isc_ratelimiter_create(loop, &zmgr->checkdsrl);
19060 isc_ratelimiter_create(loop, &zmgr->notifyrl);
19061 isc_ratelimiter_create(loop, &zmgr->refreshrl);
19062 isc_ratelimiter_create(loop, &zmgr->startupnotifyrl);
19063 isc_ratelimiter_create(loop, &zmgr->startuprefreshrl);
19065 zmgr->mctxpool = isc_mem_cget(zmgr->mctx, zmgr->workers,
19066 sizeof(zmgr->mctxpool[0]));
19067 for (size_t i = 0; i < zmgr->workers; i++) {
19068 isc_mem_create(&zmgr->mctxpool[i]);
19069 isc_mem_setname(zmgr->mctxpool[i], "zonemgr-mctxpool");
19073 zonemgr_keymgmt_init(zmgr);
19076 setrl(zmgr->checkdsrl, &zmgr->checkdsrate, 20);
19077 setrl(zmgr->notifyrl, &zmgr->notifyrate, 20);
19078 setrl(zmgr->startupnotifyrl, &zmgr->startupnotifyrate, 20);
19079 setrl(zmgr->refreshrl, &zmgr->serialqueryrate, 20);
19080 setrl(zmgr->startuprefreshrl, &zmgr->startupserialqueryrate, 20);
19081 isc_ratelimiter_setpushpop(zmgr->startupnotifyrl, true);
19082 isc_ratelimiter_setpushpop(zmgr->startuprefreshrl, true);
19084 zmgr->tlsctx_cache = NULL;
19085 isc_rwlock_init(&zmgr->tlsctx_cache_rwlock);
19087 zmgr->magic = ZONEMGR_MAGIC;
19089 *zmgrp = zmgr;
19093 dns_zonemgr_createzone(dns_zonemgr_t *zmgr, dns_zone_t **zonep) {
19098 REQUIRE(DNS_ZONEMGR_VALID(zmgr));
19101 if (zmgr->mctxpool == NULL) {
19105 tid = isc_random_uniform(zmgr->workers);
19107 mctx = zmgr->mctxpool[tid];
19120 dns_zonemgr_managezone(dns_zonemgr_t *zmgr, dns_zone_t *zone) {
19122 REQUIRE(DNS_ZONEMGR_VALID(zmgr));
19124 RWLOCK(&zmgr->rwlock, isc_rwlocktype_write);
19127 REQUIRE(zone->zmgr == NULL);
19129 isc_loop_t *loop = isc_loop_get(zmgr->loopmgr, zone->tid);
19132 zonemgr_keymgmt_add(zmgr, zone, &zone->kfio);
19135 ISC_LIST_APPEND(zmgr->zones, zone, link);
19136 zone->zmgr = zmgr;
19138 isc_refcount_increment(&zmgr->refs);
19141 RWUNLOCK(&zmgr->rwlock, isc_rwlocktype_write);
19146 dns_zonemgr_releasezone(dns_zonemgr_t *zmgr, dns_zone_t *zone) {
19148 REQUIRE(DNS_ZONEMGR_VALID(zmgr));
19149 REQUIRE(zone->zmgr == zmgr);
19151 RWLOCK(&zmgr->rwlock, isc_rwlocktype_write);
19154 ISC_LIST_UNLINK(zmgr->zones, zone, link);
19157 zonemgr_keymgmt_delete(zmgr, &zone->kfio);
19169 zone->zmgr = NULL;
19172 RWUNLOCK(&zmgr->rwlock, isc_rwlocktype_write);
19174 dns_zonemgr_detach(&zmgr);
19189 dns_zonemgr_t *zmgr;
19192 zmgr = *zmgrp;
19194 REQUIRE(DNS_ZONEMGR_VALID(zmgr));
19196 if (isc_refcount_decrement(&zmgr->refs) == 1) {
19197 zonemgr_free(zmgr);
19202 dns_zonemgr_forcemaint(dns_zonemgr_t *zmgr) {
19203 REQUIRE(DNS_ZONEMGR_VALID(zmgr));
19205 RWLOCK(&zmgr->rwlock, isc_rwlocktype_read);
19206 for (dns_zone_t *zone = ISC_LIST_HEAD(zmgr->zones); zone != NULL;
19216 RWUNLOCK(&zmgr->rwlock, isc_rwlocktype_read);
19224 RWLOCK(&zmgr->rwlock, isc_rwlocktype_write);
19225 zmgr_resume_xfrs(zmgr, true);
19226 RWUNLOCK(&zmgr->rwlock, isc_rwlocktype_write);
19231 dns_zonemgr_resumexfrs(dns_zonemgr_t *zmgr) {
19232 REQUIRE(DNS_ZONEMGR_VALID(zmgr));
19234 RWLOCK(&zmgr->rwlock, isc_rwlocktype_write);
19235 zmgr_resume_xfrs(zmgr, true);
19236 RWUNLOCK(&zmgr->rwlock, isc_rwlocktype_write);
19240 dns_zonemgr_shutdown(dns_zonemgr_t *zmgr) {
19243 REQUIRE(DNS_ZONEMGR_VALID(zmgr));
19245 isc_ratelimiter_shutdown(zmgr->checkdsrl);
19246 isc_ratelimiter_shutdown(zmgr->notifyrl);
19247 isc_ratelimiter_shutdown(zmgr->refreshrl);
19248 isc_ratelimiter_shutdown(zmgr->startupnotifyrl);
19249 isc_ratelimiter_shutdown(zmgr->startuprefreshrl);
19251 for (size_t i = 0; i < zmgr->workers; i++) {
19252 isc_mem_detach(&zmgr->mctxpool[i]);
19255 RWLOCK(&zmgr->rwlock, isc_rwlocktype_read);
19256 for (zone = ISC_LIST_HEAD(zmgr->zones); zone != NULL;
19263 RWUNLOCK(&zmgr->rwlock, isc_rwlocktype_read);
19267 zonemgr_free(dns_zonemgr_t *zmgr) {
19268 REQUIRE(ISC_LIST_EMPTY(zmgr->zones));
19270 zmgr->magic = 0;
19272 isc_refcount_destroy(&zmgr->refs);
19273 isc_ratelimiter_detach(&zmgr->checkdsrl);
19274 isc_ratelimiter_detach(&zmgr->notifyrl);
19275 isc_ratelimiter_detach(&zmgr->refreshrl);
19276 isc_ratelimiter_detach(&zmgr->startupnotifyrl);
19277 isc_ratelimiter_detach(&zmgr->startuprefreshrl);
19279 isc_mem_cput(zmgr->mctx, zmgr->mctxpool, zmgr->workers,
19280 sizeof(zmgr->mctxpool[0]));
19282 isc_rwlock_destroy(&zmgr->urlock);
19283 isc_rwlock_destroy(&zmgr->rwlock);
19284 isc_rwlock_destroy(&zmgr->tlsctx_cache_rwlock);
19286 zonemgr_keymgmt_destroy(zmgr);
19288 if (zmgr->tlsctx_cache != NULL) {
19289 isc_tlsctx_cache_detach(&zmgr->tlsctx_cache);
19291 isc_mem_putanddetach(&zmgr->mctx, zmgr, sizeof(*zmgr));
19295 dns_zonemgr_settransfersin(dns_zonemgr_t *zmgr, uint32_t value) {
19296 REQUIRE(DNS_ZONEMGR_VALID(zmgr));
19298 zmgr->transfersin = value;
19302 dns_zonemgr_gettransfersin(dns_zonemgr_t *zmgr) {
19303 REQUIRE(DNS_ZONEMGR_VALID(zmgr));
19305 return zmgr->transfersin;
19309 dns_zonemgr_settransfersperns(dns_zonemgr_t *zmgr, uint32_t value) {
19310 REQUIRE(DNS_ZONEMGR_VALID(zmgr));
19312 zmgr->transfersperns = value;
19316 dns_zonemgr_gettransfersperns(dns_zonemgr_t *zmgr) {
19317 REQUIRE(DNS_ZONEMGR_VALID(zmgr));
19319 return zmgr->transfersperns;
19330 zmgr_resume_xfrs(dns_zonemgr_t *zmgr, bool multi) {
19334 for (zone = ISC_LIST_HEAD(zmgr->waiting_for_xfrin); zone != NULL;
19339 result = zmgr_start_xfrin_ifquota(zmgr, zone);
19380 zmgr_start_xfrin_ifquota(dns_zonemgr_t *zmgr, dns_zone_t *zone) {
19412 maxtransfersin = zmgr->transfersin;
19413 maxtransfersperns = zmgr->transfersperns;
19425 for (x = ISC_LIST_HEAD(zmgr->xfrin_in_progress); x != NULL;
19457 INSIST(zone->statelist == &zmgr->waiting_for_xfrin);
19458 ISC_LIST_UNLINK(zmgr->waiting_for_xfrin, zone, statelink);
19459 ISC_LIST_APPEND(zmgr->xfrin_in_progress, zone, statelink);
19460 zone->statelist = &zmgr->xfrin_in_progress;
19532 dns_zonemgr_setcheckdsrate(dns_zonemgr_t *zmgr, unsigned int value) {
19533 REQUIRE(DNS_ZONEMGR_VALID(zmgr));
19535 setrl(zmgr->checkdsrl, &zmgr->checkdsrate, value);
19539 dns_zonemgr_setnotifyrate(dns_zonemgr_t *zmgr, unsigned int value) {
19540 REQUIRE(DNS_ZONEMGR_VALID(zmgr));
19542 setrl(zmgr->notifyrl, &zmgr->notifyrate, value);
19546 dns_zonemgr_setstartupnotifyrate(dns_zonemgr_t *zmgr, unsigned int value) {
19547 REQUIRE(DNS_ZONEMGR_VALID(zmgr));
19549 setrl(zmgr->startupnotifyrl, &zmgr->startupnotifyrate, value);
19553 dns_zonemgr_setserialqueryrate(dns_zonemgr_t *zmgr, unsigned int value) {
19554 REQUIRE(DNS_ZONEMGR_VALID(zmgr));
19556 setrl(zmgr->refreshrl, &zmgr->serialqueryrate, value);
19558 setrl(zmgr->startuprefreshrl, &zmgr->startupserialqueryrate, value);
19562 dns_zonemgr_getnotifyrate(dns_zonemgr_t *zmgr) {
19563 REQUIRE(DNS_ZONEMGR_VALID(zmgr));
19565 return zmgr->notifyrate;
19569 dns_zonemgr_getstartupnotifyrate(dns_zonemgr_t *zmgr) {
19570 REQUIRE(DNS_ZONEMGR_VALID(zmgr));
19572 return zmgr->startupnotifyrate;
19576 dns_zonemgr_getserialqueryrate(dns_zonemgr_t *zmgr) {
19577 REQUIRE(DNS_ZONEMGR_VALID(zmgr));
19579 return zmgr->serialqueryrate;
19583 dns_zonemgr_unreachable(dns_zonemgr_t *zmgr, isc_sockaddr_t *remote,
19589 REQUIRE(DNS_ZONEMGR_VALID(zmgr));
19591 RWLOCK(&zmgr->urlock, isc_rwlocktype_read);
19593 if (atomic_load(&zmgr->unreachable[i].expire) >= seconds &&
19594 isc_sockaddr_equal(&zmgr->unreachable[i].remote, remote) &&
19595 isc_sockaddr_equal(&zmgr->unreachable[i].local, local))
19597 atomic_store_relaxed(&zmgr->unreachable[i].last,
19599 count = zmgr->unreachable[i].count;
19603 RWUNLOCK(&zmgr->urlock, isc_rwlocktype_read);
19608 dns_zonemgr_unreachabledel(dns_zonemgr_t *zmgr, isc_sockaddr_t *remote,
19612 REQUIRE(DNS_ZONEMGR_VALID(zmgr));
19614 RWLOCK(&zmgr->urlock, isc_rwlocktype_read);
19616 if (isc_sockaddr_equal(&zmgr->unreachable[i].remote, remote) &&
19617 isc_sockaddr_equal(&zmgr->unreachable[i].local, local))
19619 atomic_store_relaxed(&zmgr->unreachable[i].expire, 0);
19623 RWUNLOCK(&zmgr->urlock, isc_rwlocktype_read);
19627 dns_zonemgr_unreachableadd(dns_zonemgr_t *zmgr, isc_sockaddr_t *remote,
19633 REQUIRE(DNS_ZONEMGR_VALID(zmgr));
19635 RWLOCK(&zmgr->urlock, isc_rwlocktype_write);
19638 if (isc_sockaddr_equal(&zmgr->unreachable[i].remote, remote) &&
19639 isc_sockaddr_equal(&zmgr->unreachable[i].local, local))
19644 &zmgr->unreachable[i].expire);
19648 if (atomic_load_relaxed(&zmgr->unreachable[i].expire) < seconds)
19654 if (atomic_load_relaxed(&zmgr->unreachable[i].last) < last) {
19655 last = atomic_load_relaxed(&zmgr->unreachable[i].last);
19667 zmgr->unreachable[slot].count = 1;
19669 zmgr->unreachable[slot].count++;
19671 atomic_store_relaxed(&zmgr->unreachable[slot].expire,
19673 atomic_store_relaxed(&zmgr->unreachable[slot].last, seconds);
19675 zmgr->unreachable[slot].remote = *remote;
19676 zmgr->unreachable[slot].local = *local;
19679 RWUNLOCK(&zmgr->urlock, isc_rwlocktype_write);
19688 RWLOCK(&zone->zmgr->rwlock, isc_rwlocktype_read);
19690 if (zone->statelist == &zone->zmgr->xfrin_in_progress &&
19696 RWUNLOCK(&zone->zmgr->rwlock, isc_rwlocktype_read);
19938 dns_zonemgr_getcount(dns_zonemgr_t *zmgr, dns_zonestate_t state) {
19942 REQUIRE(DNS_ZONEMGR_VALID(zmgr));
19944 RWLOCK(&zmgr->rwlock, isc_rwlocktype_read);
19947 for (zone = ISC_LIST_HEAD(zmgr->xfrin_in_progress);
19954 for (zone = ISC_LIST_HEAD(zmgr->waiting_for_xfrin);
19961 for (zone = ISC_LIST_HEAD(zmgr->zones); zone != NULL;
19970 for (zone = ISC_LIST_HEAD(zmgr->zones); zone != NULL;
19979 for (zone = ISC_LIST_HEAD(zmgr->zones); zone != NULL;
19990 for (zone = ISC_LIST_HEAD(zmgr->zones); zone != NULL;
20006 RWUNLOCK(&zmgr->rwlock, isc_rwlocktype_read);
20018 if (zone->zmgr == NULL) {
20030 RWLOCK(&zone->zmgr->rwlock, isc_rwlocktype_read);
20036 if (zone->statelist == &zone->zmgr->xfrin_in_progress) {
20043 } else if (zone->statelist == &zone->zmgr->waiting_for_xfrin) {
20070 RWUNLOCK(&zone->zmgr->rwlock, isc_rwlocktype_read);
21533 newcheckds->zone->zmgr->checkdsrl,
21651 checkds->zone->zmgr->checkdsrl, checkds->zone->loop,
23278 * Lock hierarchy: zmgr, zone, raw.
23369 * Lock hierarchy: zmgr, zone, raw.
23373 dns_zonemgr_t *zmgr;
23376 REQUIRE(zone->zmgr != NULL);
23381 REQUIRE(raw->zmgr == NULL);
23388 * Lock hierarchy: zmgr, zone, raw.
23390 zmgr = zone->zmgr;
23391 RWLOCK(&zmgr->rwlock, isc_rwlocktype_write);
23404 ISC_LIST_APPEND(zmgr->zones, raw, link);
23405 raw->zmgr = zmgr;
23406 isc_refcount_increment(&zmgr->refs);
23410 RWUNLOCK(&zmgr->rwlock, isc_rwlocktype_write);
24554 dns_zonemgr_set_tlsctx_cache(dns_zonemgr_t *zmgr,
24556 REQUIRE(DNS_ZONEMGR_VALID(zmgr));
24559 RWLOCK(&zmgr->tlsctx_cache_rwlock, isc_rwlocktype_write);
24561 if (zmgr->tlsctx_cache != NULL) {
24562 isc_tlsctx_cache_detach(&zmgr->tlsctx_cache);
24565 isc_tlsctx_cache_attach(tlsctx_cache, &zmgr->tlsctx_cache);
24567 RWUNLOCK(&zmgr->tlsctx_cache_rwlock, isc_rwlocktype_write);
24571 zmgr_tlsctx_attach(dns_zonemgr_t *zmgr, isc_tlsctx_cache_t **ptlsctx_cache) {
24572 REQUIRE(DNS_ZONEMGR_VALID(zmgr));
24575 RWLOCK(&zmgr->tlsctx_cache_rwlock, isc_rwlocktype_read);
24577 INSIST(zmgr->tlsctx_cache != NULL);
24578 isc_tlsctx_cache_attach(zmgr->tlsctx_cache, ptlsctx_cache);
24580 RWUNLOCK(&zmgr->tlsctx_cache_rwlock, isc_rwlocktype_read);