ComputerSurge/bind9
3
0
Fork 0
Code Pull Requests 1 Activity

Cleanup better

Browse Source
This commit is contained in:
Witold Kręcicki
2020-02-10 10:44:35 +01:00
parent cc0b84e84b
commit a65d7597a9
3 changed files with 256 additions and 126 deletions
Download Patch File Download Diff File Expand all files Collapse all files
lib/dns/include/dns/lowac.h
+1 -1
View File
@@ -13,5 +13,5 @@ isc_result_t
dns_lowac_put(dns_lowac_t *lowac, dns_name_t *name, char* packet, int size);
isc_result_t
dns_lowac_get(dns_lowac_t *lowac, dns_name_t *name, char* blob, int* blobsize, bool tcp);
dns_lowac_get(dns_lowac_t *lowac, dns_name_t *name, unsigned char* blob, int* blobsize, bool tcp);
lib/dns/lowac.c
+254 -125
View File
@@ -9,6 +9,7 @@
#include <isc/time.h>
#include <isc/util.h>
#include <isc/random.h>
#include <isc/refcount.h>
#include <dns/name.h>
#include <dns/lowac.h>
#include <stdlib.h>
@@ -17,27 +18,42 @@
#include <ck_fifo.h>
#include <ck_queue.h>
#define MAXIMUM_PKT_SIZE 1024
struct dns_lowac_entry {
dns_name_t name;
uint16_t flags;
isc_time_t expire;
ck_ht_hash_t hash;
char blob[1024];
uint32_t blobsize;
dns_name_t name;
isc_region_t key;
uint16_t flags;
isc_time_t expire;
ck_ht_hash_t hash;
unsigned char blob[MAXIMUM_PKT_SIZE];
uint32_t blobsize;
isc_refcount_t refcount;
/*
* Set to 'true' when we enqueue this entry on remq.
* Nothing serious will happen if we enqueue the entry
* on remq multiple times as we're refcounting.
* It's not locked in any way as it can only change
* from false to true during runtime.
*/
bool remq_enqueued;
bool inht;
};
struct dns_lowac {
bool running;
ck_ht_t ht;
isc_mem_t * mctx;
isc_interval_t expiry;
isc_thread_t thread;
int count;
ck_fifo_mpmc_t inq;
ck_fifo_mpmc_t remq;
bool running;
ck_ht_t ht;
isc_mem_t * mctx;
isc_interval_t expiry;
isc_thread_t thread;
int count;
ck_ht_iterator_t htit;
ck_fifo_mpmc_t inq;
ck_fifo_mpmc_t remq;
};
static void *
@@ -74,96 +90,182 @@ static struct ck_malloc my_allocator = {
static void
free_entry(dns_lowac_t *lowac, dns_lowac_entry_t *entry) {
//fprintf(stderr, "XXX ENTRY NAME %p\n", entry);
dns_name_free(&entry->name, lowac->mctx);
isc_mem_put(lowac->mctx, entry, sizeof(*entry));
}
static bool
dequeue_input_entry(dns_lowac_t*lowac) {
dns_lowac_entry_t *entry = NULL;
ck_fifo_mpmc_entry_t *garbage = NULL;
if (ck_fifo_mpmc_dequeue(&lowac->inq, &entry,
&garbage) == true) {
isc_mem_put(lowac->mctx, garbage,
sizeof(*garbage));
ck_ht_entry_t htentry;
ck_ht_entry_t oldhtentry;
ck_ht_entry_set(&htentry, entry->hash, entry->key.base,
entry->key.length, entry);
ck_ht_entry_set(&oldhtentry, entry->hash, entry->key.base,
entry->key.length, NULL);
if (ck_ht_get_spmc(&lowac->ht, entry->hash,
&oldhtentry) == false) {
/* We don't have this entry in hashtable */
if (ck_ht_put_spmc(&lowac->ht, entry->hash,
&htentry) == false) {
printf("oddness but might happen\n");
/* We can do it safely as it never was in
* hashtable */
RUNTIME_CHECK(isc_refcount_decrement(&entry->
refcount) ==
0);
free_entry(lowac, entry);
} else {
entry->inht = true;
lowac->count++;
}
} else {
dns_lowac_entry_t *oldentry =
ck_ht_entry_value(&oldhtentry);
/* Note: set without remove doesn't seem to work
* properly */
RUNTIME_CHECK(ck_ht_remove_spmc(&lowac->ht,
entry->hash,
&oldhtentry) == true);
oldentry->inht = false;
RUNTIME_CHECK(ck_ht_set_spmc(&lowac->ht, entry->hash,
&htentry) == true);
if (oldentry->remq_enqueued) {
isc_refcount_decrement(&oldentry->refcount);
} else {
/*
* We don't need to increment refcount since we
* have not decremented it
* when removing from hashtable
*/
ck_fifo_mpmc_entry_t *qentry =
isc_mem_get(lowac->mctx,
(sizeof(
ck_fifo_mpmc_entry_t)));
entry->remq_enqueued = true;
ck_fifo_mpmc_enqueue(&lowac->remq, qentry,
entry);
}
}
return (true);
}
return (false);
}
static int
expire_entries(dns_lowac_t *lowac) {
isc_time_t now;
isc_time_now(&now);
int iterated = 0;
ck_ht_entry_t *htitentry = NULL;
bool iterok = ck_ht_next(&lowac->ht, &lowac->htit, &htitentry);
if (!iterok) {
ck_ht_iterator_init(&lowac->htit);
iterok = ck_ht_next(&lowac->ht, &lowac->htit, &htitentry);
}
while (iterok && htitentry != NULL && iterated < 256) {
dns_lowac_entry_t *entry = ck_ht_entry_value(
htitentry);
if (isc_time_compare(&entry->expire, &now) < 0) {
RUNTIME_CHECK(ck_ht_remove_spmc(&lowac->ht,
entry->hash,
htitentry) == true);
entry->inht = false;
dns_lowac_entry_t *ent2 = ck_ht_entry_value(htitentry);
RUNTIME_CHECK(ent2 == entry);
/*
* We don't need to increment refcount since we have
* not decremented it when removing from hashtable.
*/
ck_fifo_mpmc_entry_t *qentry =
isc_mem_get(lowac->mctx,
(sizeof(
ck_fifo_mpmc_entry_t)));
entry->remq_enqueued = true;
ck_fifo_mpmc_enqueue(&lowac->remq, qentry, entry);
}
iterok = ck_ht_next(&lowac->ht, &lowac->htit, &htitentry);
iterated++;
}
if (!iterok) {
ck_ht_iterator_init(&lowac->htit);
}
return (iterated);
}
/*
* Iterate over remq.
* If the entry is in HT - remove it, requeue.
* If the entry is not in HT but it is referenced - requeue.
* If the entry is not referenced - free.
*/
static int
cleanup_entries(dns_lowac_t *lowac) {
ck_ht_entry_t htentry;
dns_lowac_entry_t *entry;
ck_fifo_mpmc_entry_t *qentry = NULL;
int removed = 0;
int max = 100;
while (--max > 0 &&
ck_fifo_mpmc_dequeue(&lowac->remq, &entry, &qentry) == true)
{
int rc = isc_refcount_decrement(&entry->refcount);
if (entry->inht) {
/*
* Remove entry from the hashtable, we'll remove the
* entry itself in the next iteration.
*/
ck_ht_entry_set(&htentry, entry->hash, entry->key.base,
entry->key.length, entry);
RUNTIME_CHECK(ck_ht_remove_spmc(&lowac->ht,
entry->hash,
&htentry) == true);
entry->inht = false;
isc_refcount_increment(&entry->refcount);
ck_fifo_mpmc_enqueue(&lowac->remq, qentry, entry);
} else {
if (rc > 1) {
/* Requeue if still in use */
isc_refcount_increment(&entry->refcount);
ck_fifo_mpmc_enqueue(&lowac->remq, qentry,
entry);
} else {
isc_mem_put(lowac->mctx, qentry,
sizeof(*qentry));
removed++;
free_entry(lowac, entry);
lowac->count--;
}
}
}
return (removed);
}
static void *
rthread(void *d) {
dns_lowac_t *lowac = (dns_lowac_t*) d;
ck_ht_iterator_t htit = CK_HT_ITERATOR_INITIALIZER;
ck_ht_entry_t *htitentry = NULL;
ck_ht_iterator_init(&lowac->htit);
while (lowac->running) {
dns_lowac_entry_t *entry = NULL;
ck_fifo_mpmc_entry_t *garbage = NULL;
if (ck_fifo_mpmc_dequeue(&lowac->inq, &entry,
&garbage) == true) {
isc_mem_put(lowac->mctx, garbage,
sizeof(*garbage));
ck_ht_entry_t htentry;
ck_ht_entry_t oldhtentry;
isc_region_t r;
dns_name_toregion(&entry->name, &r);
ck_ht_entry_set(&htentry, entry->hash, r.base, r.length, entry);
ck_ht_entry_set(&oldhtentry, entry->hash, r.base, r.length, NULL);
if (ck_ht_get_spmc(&lowac->ht, entry->hash,
&oldhtentry) == false) {
if (ck_ht_put_spmc(&lowac->ht, entry->hash, &htentry) == false) {
//fprintf(stderr, "XXX put false ENTRY NAME %p\n", entry);
free_entry(lowac, entry);
} else {
lowac->count++;
}
} else {
dns_lowac_entry_t *oldentry =
ck_ht_entry_value(&oldhtentry);
//fprintf(stderr, "XXX replace ENTRY NAME %p %p\n", oldentry, htentry.value);
free_entry(lowac, oldentry);
RUNTIME_CHECK(ck_ht_remove_spmc(&lowac->ht, entry->hash, &oldhtentry) == true);
RUNTIME_CHECK(ck_ht_set_spmc(&lowac->ht, entry->hash, &htentry) == true);
//fprintf(stderr, "XXX old got %p\n", ck_ht_entry_value(&htentry));
}
isc_thread_yield();
} else {
isc_time_t now;
isc_time_now(&now);
int removed = 0;
/* ck_ht_entry_t htentry;
dns_lowac_entry_t *entry;
ck_fifo_mpmc_entry_t *garbage = NULL;
// TODO race here!
while (ck_fifo_mpmc_dequeue(&lowac->remq, &entry,
&garbage) == true) {
removed++;
isc_mem_put(lowac->mctx, garbage,
sizeof(*garbage));
if (ck_ht_get_spmc(&lowac->ht, entry->hash,
&htentry) == true) {
RUNTIME_CHECK(ck_ht_remove_spmc(&lowac->ht, entry->hash, &htentry) == true);
} else {
printf("Oddness\n");
}
free_entry(lowac, entry);
lowac->count--;
}
*/
ck_ht_iterator_init(&htit);
bool iterok = ck_ht_next(&lowac->ht, &htit, &htitentry);
while (iterok && htitentry != NULL && removed < 256) {
dns_lowac_entry_t *entry = ck_ht_entry_value(
htitentry);
if (isc_time_compare(&entry->expire,
&now) < 0) {
RUNTIME_CHECK(ck_ht_remove_spmc(&lowac->ht, entry->hash, htitentry) == true);
dns_lowac_entry_t *ent2 = ck_ht_entry_value(htitentry);
RUNTIME_CHECK(ent2 == entry);
//fprintf(stderr, "XXX free timeout ENTRY NAME %p\n", entry);
free_entry(lowac, entry);
lowac->count--;
}
removed++;
iterok = ck_ht_next(&lowac->ht, &htit, &htitentry);
}
if (!iterok) {
ck_ht_iterator_init(&htit);
}
// INSIST(ck_ht_gc(&lowac->ht, 64,
// isc_random32()) == true);
bool dequeued = dequeue_input_entry(lowac);
if (!dequeued) {
expire_entries(lowac);
int removed = cleanup_entries(lowac);
if (removed < 256) {
usleep(1000);
usleep(10000);
} else {
RUNTIME_CHECK(ck_ht_gc(&lowac->ht, 128,
isc_random32()));
}
}
}
@@ -172,9 +274,11 @@ rthread(void *d) {
dns_lowac_t*
dns_lowac_create(isc_mem_t *mctx) {
dns_lowac_t *lowac = isc_mem_get(mctx, sizeof(dns_lowac_t));
ck_fifo_mpmc_entry_t *inq_stub = isc_mem_get(mctx, sizeof(ck_fifo_mpmc_entry_t));
ck_fifo_mpmc_entry_t *remq_stub = isc_mem_get(mctx, sizeof(ck_fifo_mpmc_entry_t));
ck_fifo_mpmc_entry_t *inq_stub =
isc_mem_get(mctx, sizeof(ck_fifo_mpmc_entry_t));
ck_fifo_mpmc_entry_t *remq_stub =
isc_mem_get(mctx, sizeof(ck_fifo_mpmc_entry_t));
ck_fifo_mpmc_init(&lowac->inq, inq_stub);
ck_fifo_mpmc_init(&lowac->remq, remq_stub);
lowac->count = 0;
@@ -186,7 +290,7 @@ dns_lowac_create(isc_mem_t *mctx) {
abort();
}
isc_mem_attach(mctx, &lowac->mctx);
isc_interval_set(&lowac->expiry, 60, 0);
isc_interval_set(&lowac->expiry, 30, 0);
isc_thread_create(rthread, lowac, &lowac->thread);
return (lowac);
}
@@ -197,33 +301,43 @@ dns_lowac_destroy(dns_lowac_t *lowac) {
isc_thread_join(lowac->thread, NULL);
dns_lowac_entry_t *entry;
ck_fifo_mpmc_entry_t *fentry;
while (ck_ht_count(&lowac->ht)>0) {
/* Entries in inq can only be in inq, it's safe to free them */
while (ck_fifo_mpmc_dequeue(&lowac->inq,
&entry,
&fentry))
{
isc_mem_put(lowac->mctx, fentry, sizeof(*fentry));
free_entry(lowac, entry);
}
/*
* Entries in remq can be freed only if they're no longer referenced
* by either multiple occurences in queue or HT
*/
while (ck_fifo_mpmc_dequeue(&lowac->remq,
&entry,
&fentry))
{
if (isc_refcount_decrement(&entry->refcount) == 0) {
free_entry(lowac, entry);
}
isc_mem_put(lowac->mctx, fentry, sizeof(*fentry));
}
/* Finally we free rest of entries from HT */
while (ck_ht_count(&lowac->ht) > 0) {
ck_ht_gc(&lowac->ht, 0, 0);
ck_ht_iterator_t htit = CK_HT_ITERATOR_INITIALIZER;
ck_ht_entry_t *htitentry = NULL;
while (ck_ht_next(&lowac->ht, &htit, &htitentry)) {
entry = ck_ht_entry_value(htitentry);
ck_ht_remove_spmc(&lowac->ht, entry->hash, htitentry);
//fprintf(stderr, "XXX cleanup %p\n", entry);
free_entry(lowac, entry);
}
}
while (ck_fifo_mpmc_dequeue(&lowac->inq,
&entry,
&fentry))
{
isc_mem_put(lowac->mctx, fentry, sizeof(*fentry));
//fprintf(stderr, "XXX cleanup2 %p\n", entry);
free_entry(lowac, entry);
}
while (ck_fifo_mpmc_dequeue(&lowac->remq,
&entry,
&fentry))
{
isc_mem_put(lowac->mctx, fentry, sizeof(*fentry));
}
ck_fifo_mpmc_deinit(&lowac->inq, &fentry);
isc_mem_put(lowac->mctx, fentry, sizeof(*fentry));
@@ -239,7 +353,7 @@ dns_lowac_put(dns_lowac_t *lowac, dns_name_t *name, char*packet, int size) {
if (!lowac->running) {
return (ISC_R_SHUTTINGDOWN);
}
if (size > 1024) {
if (size > MAXIMUM_PKT_SIZE) {
return (ISC_R_FAILURE);
}
dns_lowac_entry_t *entry = isc_mem_get(lowac->mctx, sizeof(*entry));
@@ -248,9 +362,14 @@ dns_lowac_put(dns_lowac_t *lowac, dns_name_t *name, char*packet, int size) {
memcpy(entry->blob, packet, size);
isc_time_nowplusinterval(&entry->expire, &lowac->expiry);
entry->blobsize = size;
isc_region_t r;
dns_name_toregion(&entry->name, &r);
ck_ht_hash(&entry->hash, &lowac->ht, r.base, r.length);
isc_refcount_init(&entry->refcount, 1);
entry->remq_enqueued = false;
entry->inht = false;
dns_name_toregion(&entry->name, &entry->key);
ck_ht_hash(&entry->hash, &lowac->ht, entry->key.base,
entry->key.length);
ck_fifo_mpmc_entry_t *qentry =
isc_mem_get(lowac->mctx, (sizeof(ck_fifo_mpmc_entry_t)));
ck_fifo_mpmc_enqueue(&lowac->inq, qentry, entry);
@@ -259,8 +378,8 @@ dns_lowac_put(dns_lowac_t *lowac, dns_name_t *name, char*packet, int size) {
isc_result_t
dns_lowac_get(dns_lowac_t *lowac, dns_name_t *name, char *blob, int *blobsize,
bool tcp) {
dns_lowac_get(dns_lowac_t *lowac, dns_name_t *name, unsigned char *blob,
int *blobsize, bool tcp) {
ck_ht_entry_t htentry;
ck_ht_hash_t h;
isc_region_t r;
@@ -272,12 +391,21 @@ dns_lowac_get(dns_lowac_t *lowac, dns_name_t *name, char *blob, int *blobsize,
return (ISC_R_NOTFOUND);
} else {
dns_lowac_entry_t *entry = ck_ht_entry_value(&htentry);
int oldrc = isc_refcount_increment(&entry->refcount);
RUNTIME_CHECK(oldrc > 0);
if (entry->remq_enqueued) {
/* This entry is being removed, bail */
isc_refcount_decrement(&entry->refcount);
return (ISC_R_NOTFOUND);
}
isc_time_t now;
isc_time_now(&now);
if (isc_time_compare(&entry->expire, &now) < 0) {
/* ck_fifo_mpmc_entry_t *qentry =
isc_mem_get(lowac->mctx, (sizeof(ck_fifo_mpmc_entry_t)));
ck_fifo_mpmc_enqueue(&lowac->remq, qentry, entry); */
ck_fifo_mpmc_entry_t *qentry =
isc_mem_get(lowac->mctx,
(sizeof(ck_fifo_mpmc_entry_t)));
entry->remq_enqueued = true;
ck_fifo_mpmc_enqueue(&lowac->remq, qentry, entry);
return (ISC_R_NOTFOUND);
}
if (tcp) {
@@ -289,6 +417,7 @@ dns_lowac_get(dns_lowac_t *lowac, dns_name_t *name, char *blob, int *blobsize,
memcpy(blob, entry->blob, entry->blobsize);
*blobsize = entry->blobsize;
}
isc_refcount_decrement(&entry->refcount);
return (ISC_R_SUCCESS);
}
return (ISC_R_FAILURE);
lib/dns/view.c
+1
View File
@@ -279,6 +279,7 @@ dns_view_create(isc_mem_t *mctx, dns_rdataclass_t rdclass,
view, NULL, NULL, NULL);
view->viewlist = NULL;
view->magic = DNS_VIEW_MAGIC;
/* TODO we might destroy the view (and LOWAC) when we still need it on shutdown! */
view->lowac = dns_lowac_create(view->mctx);
*viewp = view;