int main(int argc, char *argv[]) {
int rc = 0;
if(sanity_test()) {
printf("Sanity tests failed\n");
rc = 1;
}
return 0;
}
static int
test_distributor(void)
{
static struct rte_distributor *ds;
static struct rte_distributor *db;
static struct rte_distributor *dist[2];
static struct rte_mempool *p;
int i;
if (rte_lcore_count() < 2) {
printf("ERROR: not enough cores to test distributor\n");
return -1;
}
if (db == NULL) {
db = rte_distributor_create("Test_dist_burst", rte_socket_id(),
rte_lcore_count() - 1,
RTE_DIST_ALG_BURST);
if (db == NULL) {
printf("Error creating burst distributor\n");
return -1;
}
} else {
rte_distributor_flush(db);
rte_distributor_clear_returns(db);
}
if (ds == NULL) {
ds = rte_distributor_create("Test_dist_single",
rte_socket_id(),
rte_lcore_count() - 1,
RTE_DIST_ALG_SINGLE);
if (ds == NULL) {
printf("Error creating single distributor\n");
return -1;
}
} else {
rte_distributor_flush(ds);
rte_distributor_clear_returns(ds);
}
const unsigned nb_bufs = (511 * rte_lcore_count()) < BIG_BATCH ?
(BIG_BATCH * 2) - 1 : (511 * rte_lcore_count());
if (p == NULL) {
p = rte_pktmbuf_pool_create("DT_MBUF_POOL", nb_bufs, BURST,
0, RTE_MBUF_DEFAULT_BUF_SIZE, rte_socket_id());
if (p == NULL) {
printf("Error creating mempool\n");
return -1;
}
}
dist[0] = ds;
dist[1] = db;
for (i = 0; i < 2; i++) {
worker_params.dist = dist[i];
if (i)
sprintf(worker_params.name, "burst");
else
sprintf(worker_params.name, "single");
rte_eal_mp_remote_launch(handle_work,
&worker_params, SKIP_MASTER);
if (sanity_test(&worker_params, p) < 0)
goto err;
quit_workers(&worker_params, p);
rte_eal_mp_remote_launch(handle_work_with_free_mbufs,
&worker_params, SKIP_MASTER);
if (sanity_test_with_mbuf_alloc(&worker_params, p) < 0)
goto err;
quit_workers(&worker_params, p);
if (rte_lcore_count() > 2) {
rte_eal_mp_remote_launch(handle_work_for_shutdown_test,
&worker_params,
SKIP_MASTER);
if (sanity_test_with_worker_shutdown(&worker_params,
p) < 0)
goto err;
quit_workers(&worker_params, p);
rte_eal_mp_remote_launch(handle_work_for_shutdown_test,
&worker_params,
SKIP_MASTER);
if (test_flush_with_worker_shutdown(&worker_params,
p) < 0)
goto err;
quit_workers(&worker_params, p);
} else {
printf("Too few cores to run worker shutdown test\n");
}
}
if (test_error_distributor_create_numworkers() == -1 ||
test_error_distributor_create_name() == -1) {
printf("rte_distributor_create parameter check tests failed");
return -1;
}
return 0;
err:
quit_workers(&worker_params, p);
return -1;
}
int
test_distributor(void)
{
static struct rte_distributor *d;
static struct rte_mempool *p;
if (rte_lcore_count() < 2) {
printf("ERROR: not enough cores to test distributor\n");
return -1;
}
if (d == NULL) {
d = rte_distributor_create("Test_distributor", rte_socket_id(),
rte_lcore_count() - 1);
if (d == NULL) {
printf("Error creating distributor\n");
return -1;
}
} else {
rte_distributor_flush(d);
rte_distributor_clear_returns(d);
}
const unsigned nb_bufs = (511 * rte_lcore_count()) < BIG_BATCH ?
(BIG_BATCH * 2) - 1 : (511 * rte_lcore_count());
if (p == NULL) {
p = rte_mempool_create("DT_MBUF_POOL", nb_bufs,
MBUF_SIZE, BURST,
sizeof(struct rte_pktmbuf_pool_private),
rte_pktmbuf_pool_init, NULL,
rte_pktmbuf_init, NULL,
rte_socket_id(), 0);
if (p == NULL) {
printf("Error creating mempool\n");
return -1;
}
}
rte_eal_mp_remote_launch(handle_work, d, SKIP_MASTER);
if (sanity_test(d, p) < 0)
goto err;
quit_workers(d, p);
rte_eal_mp_remote_launch(handle_work_with_free_mbufs, d, SKIP_MASTER);
if (sanity_test_with_mbuf_alloc(d, p) < 0)
goto err;
quit_workers(d, p);
if (rte_lcore_count() > 2) {
rte_eal_mp_remote_launch(handle_work_for_shutdown_test, d,
SKIP_MASTER);
if (sanity_test_with_worker_shutdown(d, p) < 0)
goto err;
quit_workers(d, p);
rte_eal_mp_remote_launch(handle_work_for_shutdown_test, d,
SKIP_MASTER);
if (test_flush_with_worker_shutdown(d, p) < 0)
goto err;
quit_workers(d, p);
} else {
printf("Not enough cores to run tests for worker shutdown\n");
}
if (test_error_distributor_create_numworkers() == -1 ||
test_error_distributor_create_name() == -1) {
printf("rte_distributor_create parameter check tests failed");
return -1;
}
return 0;
err:
quit_workers(d, p);
return -1;
}
int
main(int argc, char **argv)
{
struct server *s = NULL;
pthread_t pt, ctl;
int c, is_forward = 0;
const char *config = SR_CONFIG_FILE;
int daemon = 0;
while ((c = getopt(argc,argv,"c:vhfd")) != -1)
{
switch(c)
{
case 'c':
config = optarg;
break;
case 'h':
help(argv[0]);
exit(0);
break;
case 'f':
is_forward = 1;
break;
case 'd':
daemon = 1;
break;
case '?':
printf("Try -h please\n");
exit(0);
break;
case 'v':
printf("dnspod-sr 0.01\n");
exit(0);
break;
default:
exit(0);
break;
}
}
sanity_test(0);
drop_privilege("./");
daemonrize(daemon);
trig_signals(1);
global_now = time(NULL); //for read root.z
g_nameservers[0] = g_nameservers[1] = NULL;
init_globe();
init_mempool();
s = server_init();
s->is_forward = is_forward;
read_config(config, (char *)s->logpath, s->forward, g_nameservers);
// add default dns server 8.8.8.8, 114.114.114.114
if (g_nameservers[0] == NULL) {
assert(g_nameservers[1] == NULL);
g_nameservers[0] = strdup("119.29.29.29");
g_nameservers[1] = strdup("8.8.4.4");
}
if (g_nameservers[1] == NULL) {
if (strcmp(g_nameservers[0], "119.29.29.29") == 0) {
g_nameservers[1] = strdup("8.8.4.4");
} else {
g_nameservers[1] = strdup("119.29.29.29");
}
}
//
if (create_fetcher(s, s->nfetcher) < 0)
dns_error(0, "create worker");
if (create_author(s, s->nquizzer) < 0)
dns_error(0, "create author");
if (pthread_create(&pt, NULL, (void *) time_cron, s) != 0)
dns_error(0, "time cron error");
if (pthread_create(&ctl, NULL, (void *)recv_update, s) != 0) {
dns_error(0, "recv update thread error");
}
read_root(s->datasets, s->ttlexp);
print_basic_debug();
global_serv = s;
run_sentinel(s);
return 0;
}