c47ccf630f
- if the TCP quota has been exceeded but there are no clients listening
for new connections on the interface, we can now force attachment to the
quota using isc_quota_force(), instead of carrying on with the quota not
attached.
- the TCP client quota is now referenced via a reference-counted
'ns_tcpconn' object, one of which is created whenever a client begins
listening for new connections, and attached to by members of that
client's pipeline group. when the last reference to the tcpconn
object is detached, it is freed and the TCP quota slot is released.
- reduce code duplication by adding mark_tcp_active() function.
- convert counters to atomic.
(cherry picked from commit 7e8222378ca24f1302a0c1c638565050ab04681b)
(cherry picked from commit 4939451275722bfda490ea86ca13e84f6bc71e46)
(cherry picked from commit 13f7c918b8)
114 lines
2.3 KiB
C
114 lines
2.3 KiB
C
/*
|
|
* Copyright (C) Internet Systems Consortium, Inc. ("ISC")
|
|
*
|
|
* 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 http://mozilla.org/MPL/2.0/.
|
|
*
|
|
* See the COPYRIGHT file distributed with this work for additional
|
|
* information regarding copyright ownership.
|
|
*/
|
|
|
|
|
|
/*! \file */
|
|
|
|
#include <config.h>
|
|
|
|
#include <stddef.h>
|
|
|
|
#include <isc/quota.h>
|
|
#include <isc/util.h>
|
|
|
|
isc_result_t
|
|
isc_quota_init(isc_quota_t *quota, int max) {
|
|
quota->max = max;
|
|
quota->used = 0;
|
|
quota->soft = 0;
|
|
return (isc_mutex_init("a->lock));
|
|
}
|
|
|
|
void
|
|
isc_quota_destroy(isc_quota_t *quota) {
|
|
INSIST(quota->used == 0);
|
|
quota->max = 0;
|
|
quota->used = 0;
|
|
quota->soft = 0;
|
|
DESTROYLOCK("a->lock);
|
|
}
|
|
|
|
void
|
|
isc_quota_soft(isc_quota_t *quota, int soft) {
|
|
LOCK("a->lock);
|
|
quota->soft = soft;
|
|
UNLOCK("a->lock);
|
|
}
|
|
|
|
void
|
|
isc_quota_max(isc_quota_t *quota, int max) {
|
|
LOCK("a->lock);
|
|
quota->max = max;
|
|
UNLOCK("a->lock);
|
|
}
|
|
|
|
isc_result_t
|
|
isc_quota_reserve(isc_quota_t *quota) {
|
|
isc_result_t result;
|
|
LOCK("a->lock);
|
|
if (quota->max == 0 || quota->used < quota->max) {
|
|
if (quota->soft == 0 || quota->used < quota->soft)
|
|
result = ISC_R_SUCCESS;
|
|
else
|
|
result = ISC_R_SOFTQUOTA;
|
|
quota->used++;
|
|
} else
|
|
result = ISC_R_QUOTA;
|
|
UNLOCK("a->lock);
|
|
return (result);
|
|
}
|
|
|
|
void
|
|
isc_quota_release(isc_quota_t *quota) {
|
|
LOCK("a->lock);
|
|
INSIST(quota->used > 0);
|
|
quota->used--;
|
|
UNLOCK("a->lock);
|
|
}
|
|
|
|
static isc_result_t
|
|
doattach(isc_quota_t *quota, isc_quota_t **p, bool force) {
|
|
isc_result_t result;
|
|
REQUIRE(p != NULL && *p == NULL);
|
|
|
|
result = isc_quota_reserve(quota);
|
|
if (result == ISC_R_SUCCESS || result == ISC_R_SOFTQUOTA) {
|
|
*p = quota;
|
|
} else if (result == ISC_R_QUOTA && force) {
|
|
/* attach anyway */
|
|
LOCK("a->lock);
|
|
quota->used++;
|
|
UNLOCK("a->lock);
|
|
|
|
*p = quota;
|
|
result = ISC_R_SUCCESS;
|
|
}
|
|
|
|
return (result);
|
|
}
|
|
|
|
isc_result_t
|
|
isc_quota_attach(isc_quota_t *quota, isc_quota_t **p) {
|
|
return (doattach(quota, p, false));
|
|
}
|
|
|
|
isc_result_t
|
|
isc_quota_force(isc_quota_t *quota, isc_quota_t **p) {
|
|
return (doattach(quota, p, true));
|
|
}
|
|
|
|
void
|
|
isc_quota_detach(isc_quota_t **p) {
|
|
INSIST(p != NULL && *p != NULL);
|
|
isc_quota_release(*p);
|
|
*p = NULL;
|
|
}
|