mirror of
https://gitlab.isc.org/isc-projects/bind9
synced 2025-08-31 06:25:31 +00:00
ae6a34cbda
All databases in the codebase follow the same structure: a database is an associative container from DNS names to nodes, and each node is an associative container from RR types to RR data. Each database implementation (qpzone, qpcache, sdlz, builtin, dyndb) has its own corresponding node type (qpznode, qpcnode, etc). However, some code needs to work with nodes generically regardless of their specific type - for example, to acquire locks, manage references, or register/unregister slabs from the heap. Currently, these generic node operations are implemented as methods in the database vtable, which creates problematic coupling between database and node lifetimes. If a node outlives its parent database, the node destructor will destroy all RR data, and each RR data destructor will try to unregister from heaps by calling a virtual function from the database vtable. Since the database was already freed, this causes a crash. This commit breaks the coupling by standardizing the layout of all database nodes, adding a dedicated vtable for node operations, and moving node-specific methods from the database vtable to the node vtable.
233 lines
6.7 KiB
C
233 lines
6.7 KiB
C
/*
|
|
* Copyright (C) Internet Systems Consortium, Inc. ("ISC")
|
|
*
|
|
* SPDX-License-Identifier: MPL-2.0
|
|
*
|
|
* This Source Code Form is subject to the terms of the Mozilla Public
|
|
* License, v. 2.0. If a copy of the MPL was not distributed with this
|
|
* file, you can obtain one at https://mozilla.org/MPL/2.0/.
|
|
*
|
|
* See the COPYRIGHT file distributed with this work for additional
|
|
* information regarding copyright ownership.
|
|
*/
|
|
|
|
#include <inttypes.h>
|
|
#include <sched.h> /* IWYU pragma: keep */
|
|
#include <setjmp.h>
|
|
#include <stdarg.h>
|
|
#include <stddef.h>
|
|
#include <stdlib.h>
|
|
#include <string.h>
|
|
#include <unistd.h>
|
|
|
|
#define UNIT_TESTING
|
|
#include <cmocka.h>
|
|
|
|
#include <isc/lib.h>
|
|
#include <isc/util.h>
|
|
|
|
#include <dns/lib.h>
|
|
#include <dns/rdatalist.h>
|
|
#include <dns/rdataset.h>
|
|
#include <dns/rdatastruct.h>
|
|
#define KEEP_BEFORE
|
|
|
|
/* Include the main file */
|
|
|
|
#pragma GCC diagnostic push
|
|
#pragma GCC diagnostic ignored "-Wshadow"
|
|
#undef CHECK
|
|
#include "qpcache.c"
|
|
#pragma GCC diagnostic pop
|
|
|
|
#undef CHECK
|
|
#include <tests/dns.h>
|
|
|
|
/* Set to true (or use -v option) for verbose output */
|
|
static bool verbose = false;
|
|
|
|
/*
|
|
* Add to a cache DB 'db' an rdataset of type 'rtype' at a name
|
|
* <idx>.example.com. The rdataset would contain one data, and rdata_len is
|
|
* its length. 'rtype' is supposed to be some private type whose data can be
|
|
* arbitrary (and it doesn't matter in this test).
|
|
*/
|
|
static void
|
|
overmempurge_addrdataset(dns_db_t *db, isc_stdtime_t now, int idx,
|
|
dns_rdatatype_t rtype, size_t rdata_len,
|
|
bool longname) {
|
|
isc_result_t result;
|
|
dns_rdata_t rdata;
|
|
dns_dbnode_t *node = NULL;
|
|
dns_rdatalist_t rdatalist;
|
|
dns_rdataset_t rdataset;
|
|
dns_fixedname_t fname;
|
|
dns_name_t *name;
|
|
char namebuf[DNS_NAME_FORMATSIZE];
|
|
unsigned char rdatabuf[65535] = { 0 }; /* large enough for any valid
|
|
RDATA */
|
|
|
|
REQUIRE(rdata_len <= sizeof(rdatabuf));
|
|
|
|
if (longname) {
|
|
/*
|
|
* Build a longest possible name (in wire format) that would
|
|
* result in a new rbt node with the long name data.
|
|
*/
|
|
snprintf(namebuf, sizeof(namebuf),
|
|
"%010d.%010dabcdef%010dabcdef%010dabcdef%010dabcde."
|
|
"%010dabcdef%010dabcdef%010dabcdef%010dabcde."
|
|
"%010dabcdef%010dabcdef%010dabcdef%010dabcde."
|
|
"%010dabcdef%010dabcdef%010dabcdef01.",
|
|
idx, idx, idx, idx, idx, idx, idx, idx, idx, idx, idx,
|
|
idx, idx, idx, idx, idx);
|
|
} else {
|
|
snprintf(namebuf, sizeof(namebuf), "%d.example.com.", idx);
|
|
}
|
|
dns_test_namefromstring(namebuf, &fname);
|
|
name = dns_fixedname_name(&fname);
|
|
|
|
result = dns_db_findnode(db, name, true, &node);
|
|
assert_int_equal(result, ISC_R_SUCCESS);
|
|
assert_non_null(node);
|
|
|
|
dns_rdata_init(&rdata);
|
|
rdata.length = rdata_len;
|
|
rdata.data = rdatabuf;
|
|
rdata.rdclass = dns_rdataclass_in;
|
|
rdata.type = rtype;
|
|
|
|
dns_rdatalist_init(&rdatalist);
|
|
rdatalist.rdclass = dns_rdataclass_in;
|
|
rdatalist.type = rtype;
|
|
rdatalist.ttl = 3600;
|
|
ISC_LIST_APPEND(rdatalist.rdata, &rdata, link);
|
|
|
|
dns_rdataset_init(&rdataset);
|
|
dns_rdatalist_tordataset(&rdatalist, &rdataset);
|
|
|
|
result = dns_db_addrdataset(db, node, NULL, now, &rdataset, 0, NULL);
|
|
assert_int_equal(result, ISC_R_SUCCESS);
|
|
|
|
dns_db_detachnode(&node);
|
|
}
|
|
|
|
static void
|
|
cleanup_all_deadnodes(dns_db_t *db) {
|
|
qpcache_t *qpdb = (qpcache_t *)db;
|
|
qpcache_ref(qpdb);
|
|
for (uint16_t locknum = 0; locknum < qpdb->buckets_count; locknum++) {
|
|
cleanup_deadnodes(qpdb, locknum);
|
|
}
|
|
qpcache_unref(qpdb);
|
|
}
|
|
|
|
ISC_LOOP_TEST_IMPL(overmempurge_bigrdata) {
|
|
size_t maxcache = 2097152U; /* 2MB - same as DNS_CACHE_MINSIZE */
|
|
size_t hiwater = maxcache - (maxcache >> 3); /* borrowed from cache.c */
|
|
size_t lowater = maxcache - (maxcache >> 2); /* ditto */
|
|
isc_result_t result;
|
|
dns_db_t *db = NULL;
|
|
isc_mem_t *mctx = NULL;
|
|
isc_stdtime_t now = isc_stdtime_now();
|
|
size_t i;
|
|
|
|
isc_mem_create("test", &mctx);
|
|
|
|
result = dns_db_create(mctx, CACHEDB_DEFAULT, dns_rootname,
|
|
dns_dbtype_cache, dns_rdataclass_in, 0, NULL,
|
|
&db);
|
|
assert_int_equal(result, ISC_R_SUCCESS);
|
|
|
|
isc_mem_setwater(mctx, hiwater, lowater);
|
|
|
|
/*
|
|
* Add cache entries with minimum size of data until 'overmem'
|
|
* condition is triggered.
|
|
* This should eventually happen, but we also limit the number of
|
|
* iteration to avoid an infinite loop in case something gets wrong.
|
|
*/
|
|
for (i = 0; !isc_mem_isovermem(mctx) && i < (maxcache / 10); i++) {
|
|
overmempurge_addrdataset(db, now, i, 50053, 0, false);
|
|
}
|
|
assert_true(isc_mem_isovermem(mctx));
|
|
|
|
/*
|
|
* Then try to add the same number of entries, each has very large data.
|
|
* 'overmem purge' should keep the total cache size from exceeding
|
|
* the 'hiwater' mark too much. So we should be able to assume the
|
|
* cache size doesn't reach the "max".
|
|
*/
|
|
while (i-- > 0) {
|
|
overmempurge_addrdataset(db, now, i, 50054, 65535, false);
|
|
cleanup_all_deadnodes(db);
|
|
if (verbose) {
|
|
print_message("# inuse: %zd max: %zd\n",
|
|
isc_mem_inuse(mctx), maxcache);
|
|
}
|
|
assert_true(isc_mem_inuse(mctx) < maxcache);
|
|
}
|
|
|
|
dns_db_detach(&db);
|
|
isc_mem_detach(&mctx);
|
|
isc_loopmgr_shutdown();
|
|
}
|
|
|
|
ISC_LOOP_TEST_IMPL(overmempurge_longname) {
|
|
size_t maxcache = 2097152U; /* 2MB - same as DNS_CACHE_MINSIZE */
|
|
size_t hiwater = maxcache - (maxcache >> 3); /* borrowed from cache.c */
|
|
size_t lowater = maxcache - (maxcache >> 2); /* ditto */
|
|
isc_result_t result;
|
|
dns_db_t *db = NULL;
|
|
isc_mem_t *mctx = NULL;
|
|
isc_stdtime_t now = isc_stdtime_now();
|
|
size_t i;
|
|
|
|
isc_mem_create("test", &mctx);
|
|
|
|
result = dns_db_create(mctx, CACHEDB_DEFAULT, dns_rootname,
|
|
dns_dbtype_cache, dns_rdataclass_in, 0, NULL,
|
|
&db);
|
|
assert_int_equal(result, ISC_R_SUCCESS);
|
|
|
|
isc_mem_setwater(mctx, hiwater, lowater);
|
|
|
|
/*
|
|
* Add cache entries with minimum size of data until 'overmem'
|
|
* condition is triggered.
|
|
* This should eventually happen, but we also limit the number of
|
|
* iteration to avoid an infinite loop in case something gets wrong.
|
|
*/
|
|
for (i = 0; !isc_mem_isovermem(mctx) && i < (maxcache / 10); i++) {
|
|
overmempurge_addrdataset(db, now, i, 50053, 0, false);
|
|
}
|
|
assert_true(isc_mem_isovermem(mctx));
|
|
|
|
/*
|
|
* Then try to add the same number of entries, each has very long name.
|
|
* 'overmem purge' should keep the total cache size from not exceeding
|
|
* the 'hiwater' mark too much. So we should be able to assume the cache
|
|
* size doesn't reach the "max".
|
|
*/
|
|
while (i-- > 0) {
|
|
overmempurge_addrdataset(db, now, i, 50054, 0, true);
|
|
cleanup_all_deadnodes(db);
|
|
if (verbose) {
|
|
print_message("# inuse: %zd max: %zd\n",
|
|
isc_mem_inuse(mctx), maxcache);
|
|
}
|
|
assert_true(isc_mem_inuse(mctx) < maxcache);
|
|
}
|
|
|
|
dns_db_detach(&db);
|
|
isc_mem_detach(&mctx);
|
|
isc_loopmgr_shutdown();
|
|
}
|
|
|
|
ISC_TEST_LIST_START
|
|
ISC_TEST_ENTRY_CUSTOM(overmempurge_bigrdata, setup_managers, teardown_managers)
|
|
ISC_TEST_ENTRY_CUSTOM(overmempurge_longname, setup_managers, teardown_managers)
|
|
ISC_TEST_LIST_END
|
|
|
|
ISC_TEST_MAIN
|