mir/bind
2
0
Fork 0
mirror of https://gitlab.isc.org/isc-projects/bind9 synced 2025-08-31 06:25:31 +00:00
Code Issues Releases Wiki Activity

In dns_zonemgr_unreachable use atomics to avoid unnecessary

Browse Source 
write locking.

Unreachable cache in zonemgr is realized as an static LRU list.
When we 'use' an entry we need to update the last-used time, we
can use atomics to do so without the necessity to upgrading
read-lock to write-lock.
This commit is contained in:
Witold Kręcicki
2019-06-05 22:07:50 +02:00
parent 34db730ee3
commit 68eb9a7c6a
1 changed files with 43 additions and 63 deletions
Download Patch File Download Diff File Expand all files Collapse all files

106
lib/dns/zone.c
View File

@@ -501,7 +501,7 @@ struct dns_zone {
#define DNS_ZONELOADFLAG_THAW 0x00000002U /* Thaw the zone on successful
load. */
#define UNREACH_CHACHE_SIZE 10U
#define UNREACH_CACHE_SIZE 10U
#define UNREACH_HOLD_TIME 600 /* 10 minutes */
#define CHECK(op) \
@@ -512,9 +512,9 @@ struct dns_zone {
struct dns_unreachable {
isc_sockaddr_t remote;
isc_sockaddr_t local;
uint32_t expire;
uint32_t last;
uint32_t count;
atomic_uint_fast32_t expire;
atomic_uint_fast32_t last;
uint32_t count;
};
struct dns_zonemgr {
@@ -557,7 +557,7 @@ struct dns_zonemgr {
/* Locked by urlock. */
/* LRU cache */
struct dns_unreachable unreachable[UNREACH_CHACHE_SIZE];
struct dns_unreachable unreachable[UNREACH_CACHE_SIZE];
};
/*%
@@ -17339,30 +17339,24 @@ dns_zonemgr_unreachable(dns_zonemgr_t *zmgr, isc_sockaddr_t *remote,
isc_sockaddr_t *local, isc_time_t *now)
{
unsigned int i;
isc_rwlocktype_t locktype;
isc_result_t result;
uint32_t seconds = isc_time_seconds(now);
uint32_t count = 0;
REQUIRE(DNS_ZONEMGR_VALID(zmgr));
locktype = isc_rwlocktype_read;
RWLOCK(&zmgr->urlock, locktype);
for (i = 0; i < UNREACH_CHACHE_SIZE; i++) {
RWLOCK(&zmgr->urlock, isc_rwlocktype_read);
for (i = 0; i < UNREACH_CACHE_SIZE; i++) {
if (zmgr->unreachable[i].expire >= seconds &&
isc_sockaddr_equal(&zmgr->unreachable[i].remote, remote) &&
isc_sockaddr_equal(&zmgr->unreachable[i].local, local)) {
result = isc_rwlock_tryupgrade(&zmgr->urlock);
if (result == ISC_R_SUCCESS) {
locktype = isc_rwlocktype_write;
zmgr->unreachable[i].last = seconds;
count = zmgr->unreachable[i].count;
}
atomic_store_relaxed(&zmgr->unreachable[i].last,
seconds);
count = zmgr->unreachable[i].count;
break;
}
}
RWUNLOCK(&zmgr->urlock, locktype);
return (i < UNREACH_CHACHE_SIZE && count > 1U);
RWUNLOCK(&zmgr->urlock, isc_rwlocktype_read);
return (i < UNREACH_CACHE_SIZE && count > 1U);
}
void
@@ -17370,9 +17364,6 @@ dns_zonemgr_unreachabledel(dns_zonemgr_t *zmgr, isc_sockaddr_t *remote,
isc_sockaddr_t *local)
{
unsigned int i;
isc_rwlocktype_t locktype;
isc_result_t result;
char master[ISC_SOCKADDR_FORMATSIZE];
char source[ISC_SOCKADDR_FORMATSIZE];
@@ -17381,27 +17372,15 @@ dns_zonemgr_unreachabledel(dns_zonemgr_t *zmgr, isc_sockaddr_t *remote,
REQUIRE(DNS_ZONEMGR_VALID(zmgr));
locktype = isc_rwlocktype_read;
RWLOCK(&zmgr->urlock, locktype);
for (i = 0; i < UNREACH_CHACHE_SIZE; i++) {
RWLOCK(&zmgr->urlock, isc_rwlocktype_read);
for (i = 0; i < UNREACH_CACHE_SIZE; i++) {
if (isc_sockaddr_equal(&zmgr->unreachable[i].remote, remote) &&
isc_sockaddr_equal(&zmgr->unreachable[i].local, local)) {
if (zmgr->unreachable[i].expire == 0)
break;
result = isc_rwlock_tryupgrade(&zmgr->urlock);
if (result == ISC_R_SUCCESS) {
locktype = isc_rwlocktype_write;
zmgr->unreachable[i].expire = 0;
isc_log_write(dns_lctx, DNS_LOGCATEGORY_GENERAL,
DNS_LOGMODULE_ZONE, ISC_LOG_INFO,
"master %s (source %s) deleted "
"from unreachable cache",
master, source);
}
atomic_store_relaxed(&zmgr->unreachable[i].expire, 0);
break;
}
}
RWUNLOCK(&zmgr->urlock, locktype);
RWUNLOCK(&zmgr->urlock, isc_rwlocktype_read);
}
void
@@ -17410,54 +17389,55 @@ dns_zonemgr_unreachableadd(dns_zonemgr_t *zmgr, isc_sockaddr_t *remote,
{
uint32_t seconds = isc_time_seconds(now);
uint32_t last = seconds;
unsigned int i, slot = UNREACH_CHACHE_SIZE, oldest = 0;
unsigned int i, slot = UNREACH_CACHE_SIZE, oldest = 0;
REQUIRE(DNS_ZONEMGR_VALID(zmgr));
RWLOCK(&zmgr->urlock, isc_rwlocktype_write);
for (i = 0; i < UNREACH_CHACHE_SIZE; i++) {
for (i = 0; i < UNREACH_CACHE_SIZE; i++) {
/* Existing entry? */
if (isc_sockaddr_equal(&zmgr->unreachable[i].remote, remote) &&
isc_sockaddr_equal(&zmgr->unreachable[i].local, local))
break;
/* Empty slot? */
if (zmgr->unreachable[i].expire < seconds)
if (atomic_load_relaxed(&zmgr->unreachable[i].expire) < seconds) {
slot = i;
}
/* Least recently used slot? */
if (zmgr->unreachable[i].last < last) {
last = zmgr->unreachable[i].last;
if (atomic_load_relaxed(&zmgr->unreachable[i].last) < last) {
last = atomic_load_relaxed(&zmgr->unreachable[i].last);
oldest = i;
}
}
if (i < UNREACH_CHACHE_SIZE) {
if (i < UNREACH_CACHE_SIZE) {
/*
* Found a existing entry. Update the expire timer and
* last usage timestamps.
*/
zmgr->unreachable[i].expire = seconds + UNREACH_HOLD_TIME;
zmgr->unreachable[i].last = seconds;
if (zmgr->unreachable[i].expire < seconds)
if (atomic_load_relaxed(&zmgr->unreachable[i].expire)
< seconds) {
zmgr->unreachable[i].count = 1;
else
} else {
zmgr->unreachable[i].count++;
} else if (slot != UNREACH_CHACHE_SIZE) {
/*
* Found a empty slot. Add a new entry to the cache.
*/
zmgr->unreachable[slot].expire = seconds + UNREACH_HOLD_TIME;
zmgr->unreachable[slot].last = seconds;
zmgr->unreachable[slot].remote = *remote;
zmgr->unreachable[slot].local = *local;
zmgr->unreachable[slot].count = 1;
}
atomic_store_relaxed(&zmgr->unreachable[i].expire,
seconds + UNREACH_HOLD_TIME);
atomic_store_relaxed(&zmgr->unreachable[i].last, seconds);
} else {
/*
* Replace the least recently used entry in the cache.
* We need to write a new entry.
*/
zmgr->unreachable[oldest].expire = seconds + UNREACH_HOLD_TIME;
zmgr->unreachable[oldest].last = seconds;
zmgr->unreachable[oldest].remote = *remote;
zmgr->unreachable[oldest].local = *local;
zmgr->unreachable[oldest].count = 1;
if (slot == UNREACH_CACHE_SIZE) {
/*
* We don't have an empty slot, use the oldest one.
*/
slot = oldest;
}
atomic_store_relaxed(&zmgr->unreachable[slot].expire,
seconds + UNREACH_HOLD_TIME);
atomic_store_relaxed(&zmgr->unreachable[slot].last, seconds);
zmgr->unreachable[slot].count = 1;
zmgr->unreachable[slot].remote = *remote;
zmgr->unreachable[slot].local = *local;
}
RWUNLOCK(&zmgr->urlock, isc_rwlocktype_write);
}