void noit_check_resolver_init() {
static int initialized = 0;
int32_t cnt;
mtev_conf_section_t *servers, *searchdomains;
eventer_t e;
DCLOCK();
if(initialized != 0) {
DCUNLOCK();
return;
}
if(dns_init(NULL, 0) < 0)
mtevL(noit_error, "dns initialization failed.\n");
dns_ctx = dns_new(NULL);
if(dns_init(dns_ctx, 0) != 0) {
mtevL(noit_error, "dns initialization failed.\n");
DCUNLOCK();
exit(-1);
}
/* Optional servers */
servers = mtev_conf_get_sections(MTEV_CONF_ROOT, "//resolver//server", &cnt);
if(cnt) {
int i;
char server[128];
dns_add_serv(dns_ctx, NULL); /* reset */
for(i=0;i<cnt;i++) {
if(mtev_conf_get_stringbuf(servers[i], "self::node()",
server, sizeof(server))) {
if(mtev_conf_env_off(servers[i], NULL)) {
mtevL(noit_error, "DNS server %s environmentally ignored.\n", server);
}
else if(dns_add_serv(dns_ctx, server) < 0) {
mtevL(noit_error, "Failed adding DNS server: %s\n", server);
}
}
}
}
mtev_conf_release_sections(servers, cnt);
searchdomains = mtev_conf_get_sections(MTEV_CONF_ROOT, "//resolver//search", &cnt);
if(cnt) {
int i;
char search[128];
dns_add_srch(dns_ctx, NULL); /* reset */
for(i=0;i<cnt;i++) {
if(mtev_conf_get_stringbuf(searchdomains[i], "self::node()",
search, sizeof(search))) {
if(mtev_conf_env_off(searchdomains[i], NULL)) {
mtevL(noit_error, "DNS search %s environmentally ignored.\n", search);
}
else if(dns_add_srch(dns_ctx, search) < 0) {
mtevL(noit_error, "Failed adding DNS search path: %s\n", search);
}
else if(dns_search_flag) dns_search_flag = 0; /* enable search */
}
}
}
mtev_conf_release_sections(searchdomains, cnt);
if(mtev_conf_get_int32(MTEV_CONF_ROOT, "//resolver/@ndots", &cnt))
dns_set_opt(dns_ctx, DNS_OPT_NDOTS, cnt);
if(mtev_conf_get_int32(MTEV_CONF_ROOT, "//resolver/@ntries", &cnt))
dns_set_opt(dns_ctx, DNS_OPT_NTRIES, cnt);
if(mtev_conf_get_int32(MTEV_CONF_ROOT, "//resolver/@timeout", &cnt))
dns_set_opt(dns_ctx, DNS_OPT_TIMEOUT, cnt);
if(dns_open(dns_ctx) < 0) {
mtevL(noit_error, "dns open failed.\n");
DCUNLOCK();
exit(-1);
}
eventer_name_callback("dns_cache_callback", dns_cache_callback);
dns_set_tmcbck(dns_ctx, dns_cache_utm_fn, dns_ctx);
e = eventer_alloc_fd(dns_cache_callback, dns_ctx, dns_sock(dns_ctx),
EVENTER_READ|EVENTER_EXCEPTION);
eventer_add(e);
mtev_skiplist *dc = mtev_skiplist_alloc();
mtev_skiplist_set_compare(dc, name_lookup, name_lookup_k);
mtev_skiplist_add_index(dc, refresh_idx, refresh_idx_k);
ck_pr_barrier();
nc_dns_cache = dc;
/* maybe load it from cache */
if(noit_resolver_cache_load_hook_exists()) {
struct timeval now;
char *key;
void *data;
int len;
mtev_gettimeofday(&now, NULL);
while(noit_resolver_cache_load_hook_invoke(&key, &data, &len) == MTEV_HOOK_CONTINUE) {
dns_cache_node *n;
n = calloc(1, sizeof(*n));
if(dns_cache_node_deserialize(n, data, len) >= 0) {
n->target = strdup(key);
/* if the TTL indicates that it will expire in less than 60 seconds
* (including stuff that should have already expired), then fudge
* the last_updated time to make it expire some random time within
* the next 60 seconds.
*/
if(n->last_needed > now.tv_sec || n->last_updated > now.tv_sec) {
dns_cache_node_free(n);
break; /* impossible */
}
n->last_needed = now.tv_sec;
if(n->last_updated + n->ttl < now.tv_sec + 60) {
int fudge = MIN(60, n->ttl) + 1;
n->last_updated = now.tv_sec - n->ttl + (lrand48() % fudge);
}
mtev_skiplist_insert(nc_dns_cache, n);
n = NULL;
}
else {
mtevL(noit_error, "Failed to deserialize resolver cache record.\n");
}
if(n) dns_cache_node_free(n);
if(key) free(key);
if(data) free(data);
}
}
noit_check_resolver_loop(NULL, 0, NULL, NULL);
register_console_dns_cache_commands();
mtev_hash_init(&etc_hosts_cache);
noit_check_etc_hosts_cache_refresh(NULL, 0, NULL, NULL);
initialized = 1;
DCUNLOCK();
}
static void *
test(void *c)
{
struct context *context = c;
struct entry *entry;
ck_hp_fifo_entry_t *fifo_entry;
ck_hp_record_t record;
int i, j;
if (aff_iterate(&a)) {
perror("ERROR: Could not affine thread");
exit(EXIT_FAILURE);
}
ck_hp_register(&fifo_hp, &record, malloc(sizeof(void *) * 2));
ck_pr_inc_uint(&barrier);
while (ck_pr_load_uint(&barrier) < (unsigned int)nthr);
for (i = 0; i < ITERATIONS; i++) {
for (j = 0; j < size; j++) {
fifo_entry = malloc(sizeof(ck_hp_fifo_entry_t));
entry = malloc(sizeof(struct entry));
entry->tid = context->tid;
ck_hp_fifo_enqueue_mpmc(&record, &fifo, fifo_entry, entry);
ck_pr_barrier();
fifo_entry = ck_hp_fifo_dequeue_mpmc(&record, &fifo, &entry);
if (fifo_entry == NULL) {
ck_error("ERROR [%u] Queue should never be empty.\n", context->tid);
}
ck_pr_barrier();
if (entry->tid < 0 || entry->tid >= nthr) {
ck_error("ERROR [%u] Incorrect value in entry.\n", entry->tid);
}
ck_hp_free(&record, &fifo_entry->hazard, fifo_entry, fifo_entry);
}
}
for (i = 0; i < ITERATIONS; i++) {
for (j = 0; j < size; j++) {
fifo_entry = malloc(sizeof(ck_hp_fifo_entry_t));
entry = malloc(sizeof(struct entry));
entry->tid = context->tid;
while (ck_hp_fifo_tryenqueue_mpmc(&record, &fifo, fifo_entry, entry) == false)
ck_pr_stall();
while (fifo_entry = ck_hp_fifo_trydequeue_mpmc(&record, &fifo, &entry), fifo_entry == NULL)
ck_pr_stall();
if (entry->tid < 0 || entry->tid >= nthr) {
ck_error("ERROR [%u] Incorrect value in entry.\n", entry->tid);
}
ck_hp_free(&record, &fifo_entry->hazard, fifo_entry, fifo_entry);
}
}
ck_pr_inc_uint(&e_barrier);
while (ck_pr_load_uint(&e_barrier) < (unsigned int)nthr);
return (NULL);
}
