Lines Matching refs:bucket
87 #define DNS_ADB_INVALIDBUCKET (-1) /*%< invalid bucket address */
125 * XXXRTH Have a per-bucket structure that contains all of these?
139 * XXXRTH Have a per-bucket structure that contains all of these?
587 unsigned int i, n, bucket;
653 bucket = isc_sockaddr_hash(&e->sockaddr, true) % n;
654 e->lock_bucket = bucket;
655 ISC_LIST_APPEND(newentries[bucket], e, plink);
658 newentry_refcnt[bucket]++;
664 bucket = isc_sockaddr_hash(&e->sockaddr, true) % n;
665 e->lock_bucket = bucket;
666 ISC_LIST_APPEND(newdeadentries[bucket], e, plink);
669 newentry_refcnt[bucket]++;
752 unsigned int bucket;
818 bucket = dns_name_fullhash(&name->name, true) % n;
819 name->lock_bucket = bucket;
820 ISC_LIST_APPEND(newnames[bucket], name, plink);
823 newname_refcnt[bucket]++;
829 bucket = dns_name_fullhash(&name->name, true) % n;
830 name->lock_bucket = bucket;
831 ISC_LIST_APPEND(newdeadnames[bucket], name, plink);
834 newname_refcnt[bucket]++;
904 * Requires the adbname bucket be locked and that no entry buckets be locked.
1055 * Requires the name's bucket be locked.
1062 int bucket;
1111 bucket = name->lock_bucket;
1112 ISC_LIST_UNLINK(adb->names[bucket], name, plink);
1113 ISC_LIST_APPEND(adb->deadnames[bucket], name, plink);
1121 * Requires the name's bucket be locked and no entry buckets be locked.
1170 * Requires the name's bucket be locked.
1173 link_name(dns_adb_t *adb, int bucket, dns_adbname_t *name) {
1176 ISC_LIST_PREPEND(adb->names[bucket], name, plink);
1177 name->lock_bucket = bucket;
1178 adb->name_refcnt[bucket]++;
1182 * Requires the name's bucket be locked.
1186 int bucket;
1189 bucket = name->lock_bucket;
1190 INSIST(bucket != DNS_ADB_INVALIDBUCKET);
1193 ISC_LIST_UNLINK(adb->deadnames[bucket], name, plink);
1195 ISC_LIST_UNLINK(adb->names[bucket], name, plink);
1198 INSIST(adb->name_refcnt[bucket] > 0);
1199 adb->name_refcnt[bucket]--;
1200 if (adb->name_sd[bucketbucket] == 0) {
1207 * Requires the entry's bucket be locked.
1210 link_entry(dns_adb_t *adb, int bucket, dns_adbentry_t *entry) {
1216 e = ISC_LIST_TAIL(adb->entries[bucket]);
1227 ISC_LIST_UNLINK(adb->entries[bucket], e, plink);
1228 ISC_LIST_PREPEND(adb->deadentries[bucket], e, plink);
1232 ISC_LIST_PREPEND(adb->entries[bucket], entry, plink);
1233 entry->lock_bucket = bucket;
1234 adb->entry_refcnt[bucket]++;
1238 * Requires the entry's bucket be locked.
1242 int bucket;
1245 bucket = entry->lock_bucket;
1246 INSIST(bucket != DNS_ADB_INVALIDBUCKET);
1249 ISC_LIST_UNLINK(adb->deadentries[bucket], entry, plink);
1251 ISC_LIST_UNLINK(adb->entries[bucket], entry, plink);
1254 INSIST(adb->entry_refcnt[bucket] > 0);
1255 adb->entry_refcnt[bucket]--;
1256 if (adb->entry_sd[bucket] && adb->entry_refcnt[bucket] == 0) {
1277 unsigned int bucket;
1282 for (bucket = 0; bucket < adb->nnames; bucket++) {
1283 LOCK(&adb->namelocks[bucket]);
1284 adb->name_sd[bucket] = true;
1286 name = ISC_LIST_HEAD(adb->names[bucket]);
1289 * This bucket has no names. We must decrement the
1311 UNLOCK(&adb->namelocks[bucket]);
1322 unsigned int bucket;
1327 for (bucket = 0; bucket < adb->nentries; bucket++) {
1328 LOCK(&adb->entrylocks[bucket]);
1329 adb->entry_sd[bucket] = true;
1331 entry = ISC_LIST_HEAD(adb->entries[bucket]);
1332 if (adb->entry_refcnt[bucket] == 0) {
1334 * This bucket has no entries. We must decrement the
1357 UNLOCK(&adb->entrylocks[bucket]);
1363 * Name bucket must be locked
1377 * Assumes the name bucket is locked.
1520 * Assumes the name bucket is locked.
1669 int bucket;
1671 bucket = entry->lock_bucket;
1674 LOCK(&adb->entrylocks[bucket]);
1680 UNLOCK(&adb->entrylocks[bucket]);
1687 int bucket;
1691 bucket = entry->lock_bucket;
1694 LOCK(&adb->entrylocks[bucket]);
1702 (adb->entry_sd[bucket] || entry->expires == 0 || overmem ||
1710 UNLOCK(&adb->entrylocks[bucket]);
2074 * Search for the name. NOTE: The bucket is kept locked on both
2084 int bucket;
2086 bucket = dns_name_fullhash(name, false) % adb->nnames;
2089 LOCK(&adb->namelocks[bucket]);
2090 *bucketp = bucket;
2091 } else if (*bucketp != bucket) {
2093 LOCK(&adb->namelocks[bucket]);
2094 *bucketp = bucket;
2097 adbname = ISC_LIST_HEAD(adb->names[bucket]);
2114 * Search for the address. NOTE: The bucket is kept locked on both
2121 * the bucket changes.
2127 int bucket;
2129 bucket = isc_sockaddr_hash(addr, true) % adb->nentries;
2132 LOCK(&adb->entrylocks[bucket]);
2133 *bucketp = bucket;
2134 } else if (*bucketp != bucket) {
2136 LOCK(&adb->entrylocks[bucket]);
2137 *bucketp = bucket;
2141 for (entry = ISC_LIST_HEAD(adb->entries[bucket]); entry != NULL;
2150 ISC_LIST_UNLINK(adb->entries[bucket], entry, plink);
2151 ISC_LIST_PREPEND(adb->entries[bucket], entry, plink);
2160 * Entry bucket MUST be locked!
2231 int bucket;
2233 bucket = DNS_ADB_INVALIDBUCKET;
2239 bucket = entry->lock_bucket;
2240 INSIST(bucket != DNS_ADB_INVALIDBUCKET);
2241 LOCK(&adb->entrylocks[bucket]);
2267 UNLOCK(&adb->entrylocks[bucket]);
2268 bucket = DNS_ADB_INVALIDBUCKET;
2277 bucket = entry->lock_bucket;
2278 INSIST(bucket != DNS_ADB_INVALIDBUCKET);
2279 LOCK(&adb->entrylocks[bucket]);
2305 UNLOCK(&adb->entrylocks[bucket]);
2306 bucket = DNS_ADB_INVALIDBUCKET;
2312 if (bucket != DNS_ADB_INVALIDBUCKET) {
2313 UNLOCK(&adb->entrylocks[bucket]);
2336 * Name bucket must be locked; adb may be locked; no other locks held.
2384 * Name bucket must be locked; adb may be locked; no other locks held.
2387 check_stale_name(dns_adb_t *adb, int bucket, isc_stdtime_t now) {
2393 INSIST(bucket != DNS_ADB_INVALIDBUCKET);
2403 victim = ISC_LIST_TAIL(adb->names[bucket]);
2432 * Entry bucket must be locked; adb may be locked; no other locks held.
2468 cleanup_names(dns_adb_t *adb, int bucket, isc_stdtime_t now) {
2473 DP(CLEAN_LEVEL, "cleaning name bucket %d", bucket);
2475 LOCK(&adb->namelocks[bucket]);
2476 if (adb->name_sd[bucket]) {
2477 UNLOCK(&adb->namelocks[bucket]);
2481 name = ISC_LIST_HEAD(adb->names[bucket]);
2491 UNLOCK(&adb->namelocks[bucket]);
2499 cleanup_entries(dns_adb_t *adb, int bucket, isc_stdtime_t now) {
2503 DP(CLEAN_LEVEL, "cleaning entry bucket %d", bucket);
2505 LOCK(&adb->entrylocks[bucket]);
2506 entry = ISC_LIST_HEAD(adb->entries[bucket]);
2513 UNLOCK(&adb->entrylocks[bucket]);
2671 * Initialize the bucket locks for names and elements.
2913 int bucket;
2991 bucket = DNS_ADB_INVALIDBUCKET;
2992 adbname = find_name_and_lock(adb, name, find->options, &bucket);
2993 INSIST(bucket != DNS_ADB_INVALIDBUCKET);
2994 if (adb->name_sd[bucket]) {
3010 check_stale_name(adb, bucket, now);
3018 link_name(adb, bucket, adbname);
3030 ISC_LIST_UNLINK(adb->names[bucket], adbname, plink);
3031 ISC_LIST_PREPEND(adb->names[bucket], adbname, plink);
3219 find->name_bucket = bucket;
3274 UNLOCK(&adb->namelocks[bucket]);
3284 int bucket;
3301 bucket = find->name_bucket;
3302 INSIST(bucket == DNS_ADB_INVALIDBUCKET);
3342 int bucket;
3355 bucket = find->name_bucket;
3356 if (bucket == DNS_ADB_INVALIDBUCKET) {
3363 unlock_bucket = bucket;
3365 bucket = find->name_bucket;
3366 if (bucket != DNS_ADB_INVALIDBUCKET) {
3372 bucket = DNS_ADB_INVALIDBUCKET;
3373 POST(bucket);
3482 fprintf(f, "; bucket %zu\n", i);
3874 int bucket;
3890 bucket = name->lock_bucket;
3891 LOCK(&adb->namelocks[bucket]);
3936 UNLOCK(&adb->namelocks[bucket]);
4054 UNLOCK(&adb->namelocks[bucket]);
4150 int bucket;
4157 bucket = addr->entry->lock_bucket;
4158 LOCK(&adb->entrylocks[bucket]);
4181 UNLOCK(&adb->entrylocks[bucket]);
4189 int bucket;
4196 bucket = addr->entry->lock_bucket;
4197 LOCK(&adb->entrylocks[bucket]);
4204 UNLOCK(&adb->entrylocks[bucket]);
4209 int bucket;
4214 bucket = addr->entry->lock_bucket;
4215 LOCK(&adb->entrylocks[bucket]);
4219 UNLOCK(&adb->entrylocks[bucket]);
4253 int bucket;
4262 bucket = addr->entry->lock_bucket;
4263 LOCK(&adb->entrylocks[bucket]);
4277 UNLOCK(&adb->entrylocks[bucket]);
4360 int bucket;
4366 bucket = addr->entry->lock_bucket;
4367 LOCK(&adb->entrylocks[bucket]);
4390 UNLOCK(&adb->entrylocks[bucket]);
4396 int bucket;
4401 bucket = addr->entry->lock_bucket;
4402 LOCK(&adb->entrylocks[bucket]);
4416 UNLOCK(&adb->entrylocks[bucket]);
4421 int bucket;
4426 bucket = addr->entry->lock_bucket;
4427 LOCK(&adb->entrylocks[bucket]);
4453 UNLOCK(&adb->entrylocks[bucket]);
4458 int bucket;
4463 bucket = addr->entry->lock_bucket;
4464 LOCK(&adb->entrylocks[bucket]);
4501 UNLOCK(&adb->entrylocks[bucket]);
4506 int bucket;
4511 bucket = addr->entry->lock_bucket;
4512 LOCK(&adb->entrylocks[bucket]);
4532 UNLOCK(&adb->entrylocks[bucket]);
4537 int bucket;
4543 bucket
4544 LOCK(&adb->entrylocks[bucket]);
4546 UNLOCK(&adb->entrylocks[bucket]);
4553 int bucket;
4559 bucket = addr->entry->lock_bucket;
4560 LOCK(&adb->entrylocks[bucket]);
4579 UNLOCK(&adb->entrylocks[bucket]);
4587 int bucket;
4592 bucket = addr->entry->lock_bucket;
4593 LOCK(&adb->entrylocks[bucket]);
4612 UNLOCK(&adb->entrylocks[bucket]);
4618 int bucket;
4623 bucket = addr->entry->lock_bucket;
4624 LOCK(&adb->entrylocks[bucket]);
4633 UNLOCK(&adb->entrylocks[bucket]);
4641 int bucket;
4653 bucket = DNS_ADB_INVALIDBUCKET;
4654 entry = find_entry_and_lock(adb, sa, &bucket, now);
4655 INSIST(bucket != DNS_ADB_INVALIDBUCKET);
4656 if (adb->entry_sd[bucket]) {
4670 link_entry(adb, bucket, entry);
4686 UNLOCK(&adb->entrylocks[bucket]);
4695 int bucket;
4710 bucket = addr->entry->lock_bucket;
4711 LOCK(&adb->entrylocks[bucket]);
4720 UNLOCK(&adb->entrylocks[bucket]);
4761 unsigned int bucket;
4767 bucket = dns_name_hash(name, false) % adb->nnames;
4768 LOCK(&adb->namelocks[bucket]);
4769 adbname = ISC_LIST_HEAD(adb->names[bucket]);
4779 UNLOCK(&adb->namelocks[bucket]);
Indexes created Tue May 05 00:25:04 UTC 2026