Lines Matching defs:header
76 #define EXISTS(header) \
77 ((atomic_load_acquire(&(header)->attributes) & \
79 #define NONEXISTENT(header) \
80 ((atomic_load_acquire(&(header)->attributes) & \
82 #define IGNORE(header) \
83 ((atomic_load_acquire(&(header)->attributes) & \
85 #define NXDOMAIN(header) \
86 ((atomic_load_acquire(&(header)->attributes) & \
88 #define STALE(header) \
89 ((atomic_load_acquire(&(header)->attributes) & \
91 #define STALE_WINDOW(header) \
92 ((atomic_load_acquire(&(header)->attributes) & \
94 #define RESIGN(header) \
95 ((atomic_load_acquire(&(header)->attributes) & \
97 #define OPTOUT(header) \
98 ((atomic_load_acquire(&(header)->attributes) & \
100 #define NEGATIVE(header) \
101 ((atomic_load_acquire(&(header)->attributes) & \
103 #define PREFETCH(header) \
104 ((atomic_load_acquire(&(header)->attributes) & \
106 #define CASESET(header) \
107 ((atomic_load_acquire(&(header)->attributes) & \
109 #define ZEROTTL(header) \
110 ((atomic_load_acquire(&(header)->attributes) & \
112 #define ANCIENT(header) \
113 ((atomic_load_acquire(&(header)->attributes) & \
115 #define STATCOUNT(header) \
116 ((atomic_load_acquire(&(header)->attributes) & \
119 #define STALE_TTL(header, rbtdb) \
120 (NXDOMAIN(header) ? 0 : rbtdb->common.serve_stale_ttl)
122 #define ACTIVE(header, now) \
123 (((header)->ttl > (now)) || ((header)->ttl == (now) && ZEROTTL(header)))
162 * TTL-based header expiration doesn't take too long, but it should be large
292 dns_slabheader_t *header = &(dns_slabheader_t){
297 if (!EXISTS(header) || !STATCOUNT(header)) {
301 if (NEGATIVE(header)) {
302 if (NXDOMAIN(header)) {
306 base = DNS_TYPEPAIR_COVERS(header->type);
309 base = DNS_TYPEPAIR_TYPE(header->type);
312 if (STALE(header)) {
315 if (ANCIENT(header)) {
328 dns__rbtdb_setttl(dns_slabheader_t *header, dns_ttl_t newttl) {
329 dns_ttl_t oldttl = header->ttl;
331 header->ttl = newttl;
333 if (header->db == NULL || !dns_db_iscache(header->db)) {
340 if (header->heap == NULL || header->heap_index == 0 || newttl == oldttl)
346 isc_heap_increased(header->heap, header->heap_index);
348 isc_heap_decreased(header->heap, header->heap_index);
352 isc_heap_delete(header->heap, header->heap_index);
384 * This function sets the heap index into the header.
763 add_changed(dns_slabheader_t *header,
766 dns_rbtdb_t *rbtdb = (dns_rbtdb_t *)header->db;
780 dns_rbtnode_t *node = (dns_rbtnode_t *)header->node;
803 dns_slabheader_t *header = NULL, *dcurrent = NULL;
815 for (header = node->data; header != NULL; header = header->next) {
816 if (header->serial == serial) {
817 DNS_SLABHEADER_SETATTR(header,
821 for (dcurrent = header->down; dcurrent != NULL;
837 dns__rbtdb_mark(dns_slabheader_t *header, uint_least16_t flag) {
838 uint_least16_t attributes = atomic_load_acquire(&header->attributes);
851 &header->attributes, &attributes, newattributes));
857 stats = dns_db_getrrsetstats(header->db);
859 update_rrsetstats(stats, header->type, attributes, false);
860 update_rrsetstats(stats, header->type, newattributes, true);
865 mark_ancient(dns_slabheader_t *header) {
866 dns__rbtdb_setttl(header, 0);
867 dns__rbtdb_mark(header, DNS_SLABHEADERATTR_ANCIENT);
868 RBTDB_HEADERNODE(header)->dirty = 1;
1667 dns_slabheader_t *header = NULL, *header_next = NULL;
1678 for (header = node->data; header != NULL; header = header_next) {
1679 header_next = header->next;
1681 if (header->serial <= version->serial &&
1682 !IGNORE(header))
1684 if (NONEXISTENT(header)) {
1685 header = NULL;
1689 header = header->down;
1691 } while (header != NULL);
1693 if (header != NULL &&
1694 (header->type == dns_rdatatype_nsec3param))
1699 raw = dns_slabheader_raw(header);
1785 dns_slabheader_t *header = NULL;
1961 for (header = HEAD(resigned_list); header != NULL;
1962 header = HEAD(resigned_list))
1968 ISC_LIST_UNLINK(resigned_list, header, link);
1970 lock = &rbtdb->node_locks[RBTDB_HEADERNODE(header)->locknum]
1973 if (rollback && !IGNORE(header)) {
1975 rbtdb, RBTDB_HEADERNODE(header)->locknum,
1976 header);
1978 dns__rbtdb_decref(rbtdb, RBTDB_HEADERNODE(header), least_serial,
2127 dns_slabheader_t *header, isc_stdtime_t now,
2130 bool stale = STALE(header);
2131 bool ancient = ANCIENT(header);
2136 * the header count below. However, since the actual counter value
2150 * Mark header stale or ancient if the RRset is no longer active.
2152 if (!ACTIVE(header, now)) {
2153 dns_ttl_t stale_ttl = header->ttl + STALE_TTL(header, rbtdb);
2174 rdataset->type = DNS_TYPEPAIR_TYPE(header->type);
2175 rdataset->covers = DNS_TYPEPAIR_COVERS(header->type);
2176 rdataset->ttl = header->ttl - now;
2177 rdataset->trust = header->trust;
2179 if (NEGATIVE(header)) {
2182 if (NXDOMAIN(header)) {
2185 if (OPTOUT(header)) {
2188 if (PREFETCH(header)) {
2193 dns_ttl_t stale_ttl = header->ttl + STALE_TTL(header, rbtdb);
2199 if (STALE_WINDOW(header)) {
2203 } else if (IS_CACHE(rbtdb) && !ACTIVE(header, now)) {
2205 rdataset->ttl = header->ttl;
2208 rdataset->count = atomic_fetch_add_relaxed(&header->count, 1);
2212 rdataset->slab.raw = dns_slabheader_raw(header);
2219 rdataset->slab.noqname = header->noqname;
2220 if (header->noqname != NULL) {
2223 rdataset->slab.closest = header->closest;
2224 if (header->closest != NULL) {
2231 if (RESIGN(header)) {
2233 rdataset->resign = (header->resign << 1) | header->resign_lsb;
2415 dns_slabheader_t *header = NULL, *header_next = NULL;
2426 for (header = node->data; header != NULL; header = header_next) {
2427 header_next = header->next;
2428 if (!prio_type(header->type)) {
2436 if (header->type == dns_rdatatype_cname) {
2441 if (header->serial <= serial && !IGNORE(header))
2447 if (NONEXISTENT(header)) {
2448 header = NULL;
2452 header = header->down;
2454 } while (header != NULL);
2455 if (header != NULL) {
2465 rdtype = DNS_TYPEPAIR_TYPE(header->type);
2475 if (header->serial <= serial &&
2476 !IGNORE(header))
2482 if (NONEXISTENT(header)) {
2483 header = NULL;
2487 header = header->down;
2489 } while (header != NULL);
2490 if (header != NULL) {
2504 recordsize(dns_slabheader_t *header, unsigned int namelen) {
2505 return dns_rdataslab_rdatasize((unsigned char *)header,
2506 sizeof(*header)) +
2513 dns_slabheader_t *header, unsigned int namelen) {
2514 unsigned char *hdr = (unsigned char *)header;
2515 size_t hdrsize = sizeof(*header);
2520 rbtversion->xfrsize += recordsize(header, namelen);
2523 rbtversion->xfrsize -= recordsize(header, namelen);
2538 prio_header(dns_slabheader_t *header) {
2539 if (NEGATIVE(header) && prio_type(DNS_TYPEPAIR_COVERS(header->type))) {
2543 return prio_type(header->type);
2553 dns_slabheader_t *header = NULL, *sigheader = NULL;
2708 * If header isn't NULL, we've found the right type. There may be
2712 header = topheader;
2713 while (header != NULL && IGNORE(header)) {
2714 header = header->down;
2716 if (header != NULL) {
2717 header_nx = NONEXISTENT(header) ? true : false;
2734 if (rbtversion == NULL && trust < header->trust &&
2735 (ACTIVE(header, now) || header_nx))
2740 rbtdb, rbtnode, header, now,
2756 * that is the union of 'newheader' and 'header'.
2760 INSIST(rbtversion->serial >= header->serial);
2772 newheader->ttl != header->ttl)
2775 } else if (newheader->ttl != header->ttl) {
2780 (unsigned char *)header,
2785 (dns_rdatatype_t)header->type, flags,
2790 * If 'header' has the same serial number as
2802 dns_slabheader_copycase(newheader, header);
2804 RESIGN(header) &&
2805 resign_sooner(header, newheader))
2807 newheader->resign = header->resign;
2809 header->resign_lsb;
2815 (dns_rdatatype_t)(header->type),
2830 if (IS_CACHE(rbtdb) && ACTIVE(header, now) &&
2831 header->type == dns_rdatatype_ns && !header_nx &&
2832 !newheader_nx && header->trust >= newheader->trust &&
2833 dns_rdataslab_equalx((unsigned char *)header,
2837 (dns_rdatatype_t)header->type))
2843 if (header->ttl > newheader->ttl) {
2844 dns__rbtdb_setttl(header, newheader->ttl);
2846 if (header->last_used != now) {
2848 rbtdb->lru[RBTDB_HEADERNODE(header)
2850 header, link);
2851 header->last_used = now;
2853 rbtdb->lru[RBTDB_HEADERNODE(header)
2855 header, link);
2857 if (header->noqname == NULL &&
2860 header->noqname = newheader->noqname;
2863 if (header->closest == NULL &&
2866 header->closest = newheader->closest;
2872 rbtdb, rbtnode, header, now,
2884 if (IS_CACHE(rbtdb) && ACTIVE(header, now) &&
2885 header->type == dns_rdatatype_ns && !header_nx &&
2886 !newheader_nx && header->trust <= newheader->trust)
2888 if (newheader->ttl > header->ttl) {
2889 newheader->ttl = header->ttl;
2892 if (IS_CACHE(rbtdb) && ACTIVE(header, now) &&
2894 (header->type == dns_rdatatype_a ||
2895 header->type == dns_rdatatype_aaaa ||
2896 header->type == dns_rdatatype_ds ||
2897 header->type == DNS_SIGTYPE(dns_rdatatype_ds)) &&
2899 header->trust >= newheader->trust &&
2900 dns_rdataslab_equal((unsigned char *)header,
2908 if (header->ttl > newheader->ttl) {
2909 dns__rbtdb_setttl(header, newheader->ttl);
2911 if (header->last_used != now) {
2913 rbtdb->lru[RBTDB_HEADERNODE(header)
2915 header, link);
2916 header->last_used = now;
2918 rbtdb->lru[RBTDB_HEADERNODE(header)
2920 header, link);
2922 if (header->noqname == NULL &&
2925 header->noqname = newheader->noqname;
2928 if (header->closest == NULL &&
2931 header->closest = newheader->closest;
2937 rbtdb, rbtnode, header, now,
2972 * There are no other references to 'header' when
2973 * loading, so we MAY clean up 'header' now.
2975 * loading, we MUST clean up 'header' now.
2985 header,
2988 dns_slabheader_destroy(&header);
3009 header DNS__DB_FLARG_PASS);
3024 mark_ancient(header);
3031 header,
3063 header DNS__DB_FLARG_PASS);
3124 * header to the database only
3133 * and the header at the same time, but there is
3134 * no direct link between those two header, so
3511 dns_slabheader_t *header = NULL, *newheader = NULL;
3586 * If header isn't NULL, we've found the right type. There may be
3590 header = topheader;
3591 while (header != NULL && IGNORE(header)) {
3592 header = header->down;
3594 if (header != NULL && EXISTS(header)) {
3600 if (newheader->ttl != header->ttl) {
3606 (unsigned char *)header,
3610 (dns_rdatatype_t)header->type, flags,
3617 dns_slabheader_copycase(newheader, header);
3618 if (RESIGN(header)) {
3621 newheader->resign = header->resign;
3622 newheader->resign_lsb = header->resign_lsb;
3629 * header, not newheader.
3642 * add a nonexistent header instead.
3662 update_recordsandxfrsize(false, rbtversion, header,
3675 header DNS__DB_FLARG_PASS);
3698 dns__rbtdb_bindrdataset(rbtdb, rbtnode, header, 0,
4135 dns_slabheader_t *header) {
4136 dns_ttl_t stale_ttl = header->ttl + STALE_TTL(header, rbtdb);
4141 if (NONEXISTENT(header)) {
4146 * If this is a zone or this header still active then return it.
4148 if (!IS_CACHE(rbtdb) || ACTIVE(header, rbtiterator->common.now)) {
4168 dns_slabheader_t *header = NULL, *top_next = NULL;
4174 for (header = rbtnode->data; header != NULL; header = top_next) {
4175 top_next = header->next;
4178 if (!NONEXISTENT(header)) {
4181 header = header->down;
4182 } else if (header->serial <= serial && !IGNORE(header))
4185 header))
4187 header = NULL;
4191 header = header->down;
4193 } while (header != NULL);
4194 if (header != NULL) {
4201 rbtiterator->current = header;
4203 if (header == NULL) {
4216 dns_slabheader_t *header = NULL, *top_next = NULL;
4223 header = rbtiterator->current;
4224 if (header == NULL) {
4230 type = header->type;
4231 rdtype = DNS_TYPEPAIR_TYPE(header->type);
4232 if (NEGATIVE(header)) {
4233 covers = DNS_TYPEPAIR_COVERS(header->type);
4240 * Find the start of the header chain for the next type
4243 top_next = header->next;
4254 header = header->down != NULL ? header->down : top_next;
4256 header = top_next;
4258 for (; header != NULL; header = top_next) {
4259 top_next = header->next;
4262 if (!NONEXISTENT(header)) {
4265 header = header->down;
4266 } else if (header->serial <= serial && !IGNORE(header))
4269 header))
4271 header = NULL;
4275 header = header->down;
4277 } while (header != NULL);
4278 if (header != NULL) {
4282 * Find the start of the header chain for the next type
4294 rbtiterator->current = header;
4296 if (header == NULL) {
4309 dns_slabheader_t *header = NULL;
4312 header = rbtiterator->current;
4313 REQUIRE(header != NULL);
4317 dns__rbtdb_bindrdataset(rbtdb, rbtnode, header, rbtiterator->common.now,
4941 dns_slabheader_t *header = data;
4942 dns_rbtdb_t *rbtdb = (dns_rbtdb_t *)header->db;
4944 if (header->heap != NULL && header->heap_index != 0) {
4945 isc_heap_delete(header->heap, header->heap_index);
4949 update_rrsetstats(rbtdb->rrsetstats, header->type,
4950 atomic_load_acquire(&header->attributes),
4953 if (ISC_LINK_LINKED(header, link)) {
4954 int idx = RBTDB_HEADERNODE(header)->locknum;
4956 ISC_LIST_UNLINK(rbtdb->lru[idx], header, link);
4959 if (header->noqname != NULL) {
4960 dns_slabheader_freeproof(db->mctx, &header->noqname);
4962 if (header->closest != NULL) {
4963 dns_slabheader_freeproof(db->mctx, &header->closest);
4978 dns_slabheader_t *header = isc_heap_element(heap, 1);
4980 if (header == NULL) {
4985 dns_ttl_t ttl = header->ttl;
4989 ttl += STALE_TTL(header, rbtdb);
4994 * The header at the top of this TTL heap is not yet
5002 dns__cacherbt_expireheader(header, tlocktypep,