upstream/bind9
1
0
Fork 0
mirror of https://github.com/isc-projects/bind9.git synced 2026-06-09 04:52:05 -04:00
Code Issues Projects Releases Packages Wiki Activity Actions

reduce memory consumption of the remaining QP databases

Browse source 
use dynamically allocated names instead of fixednames in
forward.c, keytable.c, nametree.c, and nta.c
This commit is contained in:
Evan Hunt 2024-03-13 13:42:57 -07:00
parent c0fcc2899e
commit 17186e06bb
6 changed files with 45 additions and 56 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

7
lib/dns/forward.c
View file

@ -75,13 +75,13 @@ new_forwarders(isc_mem_t *mctx, const dns_name_t *name,
forwarders = isc_mem_get(mctx, sizeof(*forwarders));
*forwarders = (dns_forwarders_t){
.fwdpolicy = fwdpolicy,
.name = DNS_NAME_INITEMPTY,
.fwdrs = ISC_LIST_INITIALIZER,
};
isc_mem_attach(mctx, &forwarders->mctx);
isc_refcount_init(&forwarders->references, 1);
forwarders->name = dns_fixedname_initname(&forwarders->fn);
dns_name_copy(name, forwarders->name);
dns_name_dupwithoffsets(name, mctx, &forwarders->name);
return (forwarders);
}
@ -212,6 +212,7 @@ destroy_forwarders(dns_forwarders_t *forwarders) {
}
isc_mem_put(forwarders->mctx, fwd, sizeof(*fwd));
}
dns_name_free(&forwarders->name, forwarders->mctx);
isc_mem_putanddetach(&forwarders->mctx, forwarders,
sizeof(*forwarders));
}
@ -240,7 +241,7 @@ static size_t
qp_makekey(dns_qpkey_t key, void *uctx ISC_ATTR_UNUSED, void *pval,
uint32_t ival ISC_ATTR_UNUSED) {
dns_forwarders_t *fwd = pval;
return (dns_qpkey_fromname(key, fwd->name));
return (dns_qpkey_fromname(key, &fwd->name));
}
static void

3
lib/dns/include/dns/forward.h
View file

@ -42,8 +42,7 @@ struct dns_forwarders {
dns_fwdpolicy_t fwdpolicy;
isc_mem_t *mctx;
isc_refcount_t references;
dns_fixedname_t fn;
dns_name_t *name;
dns_name_t name;
};
void

24
lib/dns/keytable.c
View file

@ -51,8 +51,7 @@ struct dns_keynode {
isc_mem_t *mctx;
isc_refcount_t references;
isc_rwlock_t rwlock;
dns_fixedname_t fn;
dns_name_t *name;
dns_name_t name;
dns_rdatalist_t *dslist;
dns_rdataset_t dsset;
bool managed;
@ -119,6 +118,7 @@ destroy_keynode(dns_keynode_t *knode) {
knode->dslist = NULL;
}
dns_name_free(&knode->name, knode->mctx);
isc_mem_putanddetach(&knode->mctx, knode, sizeof(dns_keynode_t));
}
@ -272,7 +272,7 @@ delete_ds(dns_qp_t *qp, dns_keytable_t *keytable, dns_keynode_t *knode,
/*
* Replace knode with a new instance without the DS.
*/
newnode = new_keynode(knode->name, NULL, keytable, knode->managed,
newnode = new_keynode(&knode->name, NULL, keytable, knode->managed,
knode->initial);
for (rdata = ISC_LIST_HEAD(knode->dslist->rdata); rdata != NULL;
rdata = ISC_LIST_NEXT(rdata, link))
@ -285,7 +285,7 @@ delete_ds(dns_qp_t *qp, dns_keytable_t *keytable, dns_keynode_t *knode,
}
}
result = dns_qp_deletename(qp, knode->name, &pval, NULL);
result = dns_qp_deletename(qp, &knode->name, &pval, NULL);
INSIST(result == ISC_R_SUCCESS);
INSIST(pval == knode);
@ -312,14 +312,14 @@ new_keynode(const dns_name_t *name, dns_rdata_ds_t *ds,
REQUIRE(!initial || managed);
knode = isc_mem_get(keytable->mctx, sizeof(dns_keynode_t));
*knode = (dns_keynode_t){ .magic = KEYNODE_MAGIC };
*knode = (dns_keynode_t){ .name = DNS_NAME_INITEMPTY,
.magic = KEYNODE_MAGIC };
dns_rdataset_init(&knode->dsset);
isc_refcount_init(&knode->references, 1);
isc_rwlock_init(&knode->rwlock);
knode->name = dns_fixedname_initname(&knode->fn);
dns_name_copy(name, knode->name);
dns_name_dupwithoffsets(name, keytable->mctx, &knode->name);
/*
* If a DS was supplied, initialize an rdatalist.
@ -522,7 +522,7 @@ dns_keytable_finddeepestmatch(dns_keytable_t *keytable, const dns_name_t *name,
keynode = pval;
if (result == ISC_R_SUCCESS || result == DNS_R_PARTIALMATCH) {
dns_name_copy(keynode->name, foundname);
dns_name_copy(&keynode->name, foundname);
result = ISC_R_SUCCESS;
}
@ -551,7 +551,7 @@ dns_keytable_issecuredomain(dns_keytable_t *keytable, const dns_name_t *name,
if (result == ISC_R_SUCCESS || result == DNS_R_PARTIALMATCH) {
keynode = pval;
if (foundname != NULL) {
dns_name_copy(keynode->name, foundname);
dns_name_copy(&keynode->name, foundname);
}
*wantdnssecp = true;
result = ISC_R_SUCCESS;
@ -618,7 +618,7 @@ keynode_dslist_totext(dns_keynode_t *keynode, isc_buffer_t **text) {
return (ISC_R_SUCCESS);
}
dns_name_format(keynode->name, namebuf, sizeof(namebuf));
dns_name_format(&keynode->name, namebuf, sizeof(namebuf));
for (result = dns_rdataset_first(&dsset); result == ISC_R_SUCCESS;
result = dns_rdataset_next(&dsset))
@ -694,7 +694,7 @@ dns_keytable_forall(dns_keytable_t *keytable,
while (dns_qpiter_next(&iter, NULL, &pval, NULL) == ISC_R_SUCCESS) {
dns_keynode_t *knode = pval;
(*func)(keytable, knode, knode->name, arg);
(*func)(keytable, knode, &knode->name, arg);
}
dns_qpread_destroy(keytable->table, &qpr);
@ -844,7 +844,7 @@ static size_t
qp_makekey(dns_qpkey_t key, void *uctx ISC_ATTR_UNUSED, void *pval,
uint32_t ival ISC_ATTR_UNUSED) {
dns_keynode_t *keynode = pval;
return (dns_qpkey_fromname(key, keynode->name));
return (dns_qpkey_fromname(key, &keynode->name));
}
static void

25
lib/dns/nametree.c
View file

@ -41,8 +41,7 @@ struct dns_nametree {
struct dns_ntnode {
isc_mem_t *mctx;
isc_refcount_t references;
dns_fixedname_t fn;
dns_name_t *name;
dns_name_t name;
bool set;
uint8_t *bits;
};
@ -70,6 +69,7 @@ destroy_ntnode(dns_ntnode_t *node) {
isc_mem_cput(node->mctx, node->bits, node->bits[0],
sizeof(char));
}
dns_name_free(&node->name, node->mctx);
isc_mem_putanddetach(&node->mctx, node, sizeof(dns_ntnode_t));
}
@ -104,20 +104,8 @@ dns_nametree_create(isc_mem_t *mctx, dns_nametree_type_t type, const char *name,
static void
destroy_nametree(dns_nametree_t *nametree) {
/* dns_qpread_t qpr; */
/* dns_qpiter_t iter; */
/* void *pval = NULL; */
nametree->magic = 0;
/* dns_qpmulti_query(nametree->table, &qpr); */
/* dns_qpiter_init(&qpr, &iter); */
/* while (dns_qpiter_next(&iter, &pval, NULL) == ISC_R_SUCCESS) { */
/* dns_ntnode_t *n = pval; */
/* dns_ntnode_detach(&n); */
/* } */
/* dns_qpread_destroy(nametree->table, &qpr); */
dns_qpmulti_destroy(&nametree->table);
isc_mem_putanddetach(&nametree->mctx, nametree, sizeof(*nametree));
@ -132,12 +120,13 @@ ISC_REFCOUNT_IMPL(dns_nametree, destroy_nametree);
static dns_ntnode_t *
newnode(isc_mem_t *mctx, const dns_name_t *name) {
dns_ntnode_t *node = isc_mem_get(mctx, sizeof(*node));
*node = (dns_ntnode_t){ 0 };
*node = (dns_ntnode_t){
.name = DNS_NAME_INITEMPTY,
};
isc_mem_attach(mctx, &node->mctx);
isc_refcount_init(&node->references, 1);
node->name = dns_fixedname_initname(&node->fn);
dns_name_copy(name, node->name);
dns_name_dupwithoffsets(name, mctx, &node->name);
return (node);
}
@ -327,7 +316,7 @@ static size_t
qp_makekey(dns_qpkey_t key, void *uctx ISC_ATTR_UNUSED, void *pval,
uint32_t ival ISC_ATTR_UNUSED) {
dns_ntnode_t *ntnode = pval;
return (dns_qpkey_fromname(key, ntnode->name));
return (dns_qpkey_fromname(key, &ntnode->name));
}
static void

32
lib/dns/nta.c
View file

@ -60,8 +60,7 @@ struct dns__nta {
dns_fetch_t *fetch;
dns_rdataset_t rdataset;
dns_rdataset_t sigrdataset;
dns_fixedname_t fn;
dns_name_t *name;
dns_name_t name;
isc_stdtime_t expiry;
bool shuttingdown;
};
@ -104,6 +103,7 @@ dns__nta_destroy(dns__nta_t *nta) {
dns_resolver_destroyfetch(&nta->fetch);
}
isc_loop_detach(&nta->loop);
dns_name_free(&nta->name, nta->mctx);
isc_mem_putanddetach(&nta->mctx, nta, sizeof(*nta));
}
@ -240,9 +240,9 @@ checkbogus(void *arg) {
dns__nta_ref(nta); /* for dns_resolver_createfetch */
result = dns_resolver_createfetch(
resolver, nta->name, dns_rdatatype_nsec, NULL, NULL, NULL, NULL,
0, DNS_FETCHOPT_NONTA, 0, NULL, nta->loop, fetch_done, nta,
&nta->rdataset, &nta->sigrdataset, &nta->fetch);
resolver, &nta->name, dns_rdatatype_nsec, NULL, NULL, NULL,
NULL, 0, DNS_FETCHOPT_NONTA, 0, NULL, nta->loop, fetch_done,
nta, &nta->rdataset, &nta->sigrdataset, &nta->fetch);
if (result != ISC_R_SUCCESS) {
dns__nta_detach(&nta); /* for dns_resolver_createfetch() */
}
@ -278,6 +278,7 @@ nta_create(dns_ntatable_t *ntatable, const dns_name_t *name,
nta = isc_mem_get(ntatable->mctx, sizeof(dns__nta_t));
*nta = (dns__nta_t){
.ntatable = ntatable,
.name = DNS_NAME_INITEMPTY,
.magic = NTA_MAGIC,
};
isc_mem_attach(ntatable->mctx, &nta->mctx);
@ -288,8 +289,7 @@ nta_create(dns_ntatable_t *ntatable, const dns_name_t *name,
isc_refcount_init(&nta->references, 1);
nta->name = dns_fixedname_initname(&nta->fn);
dns_name_copy(name, nta->name);
dns_name_dupwithoffsets(name, nta->mctx, &nta->name);
*target = nta;
}
@ -316,7 +316,7 @@ dns_ntatable_add(dns_ntatable_t *ntatable, const dns_name_t *name, bool force,
result = dns_qp_insert(qp, nta, 0);
switch (result) {
case ISC_R_EXISTS:
result = dns_qp_getname(qp, nta->name, &pval, NULL);
result = dns_qp_getname(qp, &nta->name, &pval, NULL);
if (result == ISC_R_SUCCESS) {
/*
* an NTA already existed: throw away the
@ -379,16 +379,16 @@ delete_expired(void *arg) {
RWLOCK(&ntatable->rwlock, isc_rwlocktype_write);
dns_qpmulti_write(ntatable->table, &qp);
result = dns_qp_getname(qp, nta->name, &pval, NULL);
result = dns_qp_getname(qp, &nta->name, &pval, NULL);
if (result == ISC_R_SUCCESS &&
((dns__nta_t *)pval)->expiry == nta->expiry && !nta->shuttingdown)
{
char nb[DNS_NAME_FORMATSIZE];
dns_name_format(nta->name, nb, sizeof(nb));
dns_name_format(&nta->name, nb, sizeof(nb));
isc_log_write(dns_lctx, DNS_LOGCATEGORY_DNSSEC,
DNS_LOGMODULE_NTA, ISC_LOG_INFO,
"deleting expired NTA at %s", nb);
dns_qp_deletename(qp, nta->name, NULL, NULL);
dns_qp_deletename(qp, &nta->name, NULL, NULL);
dns__nta_shutdown(nta);
dns__nta_unref(nta);
}
@ -425,7 +425,7 @@ dns_ntatable_covered(dns_ntatable_t *ntatable, isc_stdtime_t now,
* Found a NTA that's an ancestor of 'name'; we
* now have to make sure 'anchor' isn't below it.
*/
if (!dns_name_issubdomain(nta->name, anchor)) {
if (!dns_name_issubdomain(&nta->name, anchor)) {
goto done;
}
/* Ancestor match */
@ -487,7 +487,7 @@ dns_ntatable_totext(dns_ntatable_t *ntatable, const char *view,
sizeof("expired: \n")];
isc_time_t t;
dns_name_format(n->name, nbuf, sizeof(nbuf));
dns_name_format(&n->name, nbuf, sizeof(nbuf));
if (n->expiry != 0xffffffffU) {
/* Normal NTA entries */
@ -549,7 +549,7 @@ dns_ntatable_save(dns_ntatable_t *ntatable, FILE *fp) {
}
isc_buffer_init(&b, nbuf, sizeof(nbuf));
result = dns_name_totext(n->name, 0, &b);
result = dns_name_totext(&n->name, 0, &b);
if (result != ISC_R_SUCCESS) {
continue;
}
@ -586,7 +586,7 @@ dns__nta_shutdown_cb(void *arg) {
if (isc_log_wouldlog(dns_lctx, ISC_LOG_DEBUG(3))) {
char nb[DNS_NAME_FORMATSIZE];
dns_name_format(nta->name, nb, sizeof(nb));
dns_name_format(&nta->name, nb, sizeof(nb));
isc_log_write(dns_lctx, DNS_LOGCATEGORY_DNSSEC,
DNS_LOGMODULE_NTA, ISC_LOG_DEBUG(3),
"shutting down NTA %p at %s", nta, nb);
@ -650,7 +650,7 @@ static size_t
qp_makekey(dns_qpkey_t key, void *uctx ISC_ATTR_UNUSED, void *pval,
uint32_t ival ISC_ATTR_UNUSED) {
dns__nta_t *nta = pval;
return (dns_qpkey_fromname(key, nta->name));
return (dns_qpkey_fromname(key, &nta->name));
}
static void

10
lib/dns/resolver.c
View file

@ -3459,12 +3459,12 @@ fctx_getaddresses(fetchctx_t *fctx, bool badcache) {
if (result == ISC_R_SUCCESS || result == DNS_R_PARTIALMATCH) {
fwd = ISC_LIST_HEAD(forwarders->fwdrs);
fctx->fwdpolicy = forwarders->fwdpolicy;
dns_name_copy(forwarders->name, fctx->fwdname);
dns_name_copy(&forwarders->name, fctx->fwdname);
if (fctx->fwdpolicy == dns_fwdpolicy_only &&
isstrictsubdomain(forwarders->name, fctx->domain))
isstrictsubdomain(&forwarders->name, fctx->domain))
{
fcount_decr(fctx);
dns_name_copy(forwarders->name, fctx->domain);
dns_name_copy(&forwarders->name, fctx->domain);
result = fcount_incr(fctx, true);
if (result != ISC_R_SUCCESS) {
dns_forwarders_detach(&forwarders);
@ -4565,7 +4565,7 @@ fctx_create(dns_resolver_t *res, isc_loop_t *loop, const dns_name_t *name,
&forwarders);
if (result == ISC_R_SUCCESS || result == DNS_R_PARTIALMATCH) {
fctx->fwdpolicy = forwarders->fwdpolicy;
dns_name_copy(forwarders->name, fctx->fwdname);
dns_name_copy(&forwarders->name, fctx->fwdname);
dns_forwarders_detach(&forwarders);
}
@ -6555,7 +6555,7 @@ name_external(const dns_name_t *name, dns_rdatatype_t type, fetchctx_t *fctx) {
* See if the forwarder declaration is better.
*/
if (result == ISC_R_SUCCESS || result == DNS_R_PARTIALMATCH) {
bool better = !dns_name_equal(forwarders->name,
bool better = !dns_name_equal(&forwarders->name,
fctx->fwdname);
dns_forwarders_detach(&forwarders);
return (better);