mir/bind
2
0
Fork 0
mirror of https://gitlab.isc.org/isc-projects/bind9 synced 2025-08-25 03:27:18 +00:00
Code Issues Releases Wiki Activity
bind/lib/isc/taskpool.c

156 lines
3.6 KiB
C
Raw Normal View History

Created a new type isc_taskpool_t, a pool of isc_task_t objects to be shared by multiple users. This is intended for use by things like zones, which would need hordes of tasks if each one had a separate task.
1999-10-21 00:32:15 +00:00
/*
Update license headers to not include years in copyright in all applicable files
2018-02-23 09:53:12 +01:00
* Copyright (C) Internet Systems Consortium, Inc. ("ISC")
Trailing whitespace trimmed. Perhaps running "perl util/spacewhack.pl in your own CVS tree will help minimize CVS conflicts. Maybe not. Blame Graff for getting me to trim all trailing whitespace.
2000-08-01 01:33:37 +00:00
*
4401. [misc] Change LICENSE to MPL 2.0.
2016-06-27 14:56:38 +10:00
* 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
update all copyright headers to eliminate the typo
2020-09-14 16:20:40 -07:00
* file, you can obtain one at https://mozilla.org/MPL/2.0/.
Update license headers to not include years in copyright in all applicable files
2018-02-23 09:53:12 +01:00
*
* See the COPYRIGHT file distributed with this work for additional
* information regarding copyright ownership.
Created a new type isc_taskpool_t, a pool of isc_task_t objects to be shared by multiple users. This is intended for use by things like zones, which would need hordes of tasks if each one had a separate task.
1999-10-21 00:32:15 +00:00
*/
1851. [doc] Doxygen comment markup. [RT #11398]
2005-04-27 04:57:32 +00:00
/*! \file */
add RCS id string
2000-06-22 22:00:42 +00:00
Replace custom isc_boolean_t with C standard bool type
2018-04-17 08:29:14 -07:00
#include <stdbool.h>
<isc/task.h> does not need <isc/mem.h> or <isc/result.h>.
2000-04-28 04:26:08 +00:00
#include <isc/mem.h>
3131. [func] Improve scalability by allocating one zone task per 100 zones at startup time, rather than using a fixed-size task table. [RT #24406]
2011-07-06 01:36:32 +00:00
#include <isc/random.h>
Created a new type isc_taskpool_t, a pool of isc_task_t objects to be shared by multiple users. This is intended for use by things like zones, which would need hordes of tasks if each one had a separate task.
1999-10-21 00:32:15 +00:00
#include <isc/taskpool.h>
include isc/util.h
2000-04-28 01:12:23 +00:00
#include <isc/util.h>
Created a new type isc_taskpool_t, a pool of isc_task_t objects to be shared by multiple users. This is intended for use by things like zones, which would need hordes of tasks if each one had a separate task.
1999-10-21 00:32:15 +00:00
/***
*** Types.
***/
struct isc_taskpool {
apply the modified style
2020-02-13 14:44:37 -08:00
isc_mem_t *mctx;
Use clang-format to reformat the source files
2020-02-12 13:59:18 +01:00
isc_taskmgr_t *tmgr;
apply the modified style
2020-02-13 14:44:37 -08:00
unsigned int ntasks;
unsigned int quantum;
isc_task_t **tasks;
Created a new type isc_taskpool_t, a pool of isc_task_t objects to be shared by multiple users. This is intended for use by things like zones, which would need hordes of tasks if each one had a separate task.
1999-10-21 00:32:15 +00:00
};
3131. [func] Improve scalability by allocating one zone task per 100 zones at startup time, rather than using a fixed-size task table. [RT #24406]
2011-07-06 01:36:32 +00:00
Created a new type isc_taskpool_t, a pool of isc_task_t objects to be shared by multiple users. This is intended for use by things like zones, which would need hordes of tasks if each one had a separate task.
1999-10-21 00:32:15 +00:00
/***
*** Functions.
***/
Clear the pointer to destroyed object early using the semantic patch Also disable the semantic patch as the code needs tweaks here and there because some destroy functions might not destroy the object and return early if the object is still in use.
2020-02-08 04:37:54 -08:00
static void
3131. [func] Improve scalability by allocating one zone task per 100 zones at startup time, rather than using a fixed-size task table. [RT #24406]
2011-07-06 01:36:32 +00:00
alloc_pool(isc_taskmgr_t *tmgr, isc_mem_t *mctx, unsigned int ntasks,
apply the modified style
2020-02-13 14:44:37 -08:00
unsigned int quantum, isc_taskpool_t **poolp) {
Created a new type isc_taskpool_t, a pool of isc_task_t objects to be shared by multiple users. This is intended for use by things like zones, which would need hordes of tasks if each one had a separate task.
1999-10-21 00:32:15 +00:00
isc_taskpool_t *pool;
apply the modified style
2020-02-13 14:44:37 -08:00
unsigned int i;
Trailing whitespace trimmed. Perhaps running "perl util/spacewhack.pl in your own CVS tree will help minimize CVS conflicts. Maybe not. Blame Graff for getting me to trim all trailing whitespace.
2000-08-01 01:33:37 +00:00
sizeof style
2001-11-27 01:56:32 +00:00
pool = isc_mem_get(mctx, sizeof(*pool));
3520. [bug] 'mctx' was not being referenced counted in some places where it should have been. [RT #32794]
2013-03-08 14:38:03 +11:00
pool->mctx = NULL;
isc_mem_attach(mctx, &pool->mctx);
Created a new type isc_taskpool_t, a pool of isc_task_t objects to be shared by multiple users. This is intended for use by things like zones, which would need hordes of tasks if each one had a separate task.
1999-10-21 00:32:15 +00:00
pool->ntasks = ntasks;
3131. [func] Improve scalability by allocating one zone task per 100 zones at startup time, rather than using a fixed-size task table. [RT #24406]
2011-07-06 01:36:32 +00:00
pool->quantum = quantum;
pool->tmgr = tmgr;
Created a new type isc_taskpool_t, a pool of isc_task_t objects to be shared by multiple users. This is intended for use by things like zones, which would need hordes of tasks if each one had a separate task.
1999-10-21 00:32:15 +00:00
pool->tasks = isc_mem_get(mctx, ntasks * sizeof(isc_task_t *));
Clear the pointer to destroyed object early using the semantic patch Also disable the semantic patch as the code needs tweaks here and there because some destroy functions might not destroy the object and return early if the object is still in use.
2020-02-08 04:37:54 -08:00
for (i = 0; i < ntasks; i++) {
Created a new type isc_taskpool_t, a pool of isc_task_t objects to be shared by multiple users. This is intended for use by things like zones, which would need hordes of tasks if each one had a separate task.
1999-10-21 00:32:15 +00:00
pool->tasks[i] = NULL;
Clear the pointer to destroyed object early using the semantic patch Also disable the semantic patch as the code needs tweaks here and there because some destroy functions might not destroy the object and return early if the object is still in use.
2020-02-08 04:37:54 -08:00
}
3131. [func] Improve scalability by allocating one zone task per 100 zones at startup time, rather than using a fixed-size task table. [RT #24406]
2011-07-06 01:36:32 +00:00
*poolp = pool;
}
isc_result_t
Use clang-format to reformat the source files
2020-02-12 13:59:18 +01:00
isc_taskpool_create(isc_taskmgr_t *tmgr, isc_mem_t *mctx, unsigned int ntasks,
Refactor taskmgr to run on top of netmgr This commit changes the taskmgr to run the individual tasks on the netmgr internal workers. While an effort has been put into keeping the taskmgr interface intact, couple of changes have been made: * The taskmgr has no concept of universal privileged mode - rather the tasks are either privileged or unprivileged (normal). The privileged tasks are run as a first thing when the netmgr is unpaused. There are now four different queues in in the netmgr: 1. priority queue - netievent on the priority queue are run even when the taskmgr enter exclusive mode and netmgr is paused. This is needed to properly start listening on the interfaces, free resources and resume. 2. privileged task queue - only privileged tasks are queued here and this is the first queue that gets processed when network manager is unpaused using isc_nm_resume(). All netmgr workers need to clean the privileged task queue before they all proceed normal operation. Both task queues are processed when the workers are finished. 3. task queue - only (traditional) task are scheduled here and this queue along with privileged task queues are process when the netmgr workers are finishing. This is needed to process the task shutdown events. 4. normal queue - this is the queue with netmgr events, e.g. reading, sending, callbacks and pretty much everything is processed here. * The isc_taskmgr_create() now requires initialized netmgr (isc_nm_t) object. * The isc_nm_destroy() function now waits for indefinite time, but it will print out the active objects when in tracing mode (-DNETMGR_TRACE=1 and -DNETMGR_TRACE_VERBOSE=1), the netmgr has been made a little bit more asynchronous and it might take longer time to shutdown all the active networking connections. * Previously, the isc_nm_stoplistening() was a synchronous operation. This has been changed and the isc_nm_stoplistening() just schedules the child sockets to stop listening and exits. This was needed to prevent a deadlock as the the (traditional) tasks are now executed on the netmgr threads. * The socket selection logic in isc__nm_udp_send() was flawed, but fortunatelly, it was broken, so we never hit the problem where we created uvreq_t on a socket from nmhandle_t, but then a different socket could be picked up and then we were trying to run the send callback on a socket that had different threadid than currently running.
2021-04-09 11:31:19 +02:00
unsigned int quantum, bool priv, isc_taskpool_t **poolp) {
apply the modified style
2020-02-13 14:44:37 -08:00
unsigned int i;
3131. [func] Improve scalability by allocating one zone task per 100 zones at startup time, rather than using a fixed-size task table. [RT #24406]
2011-07-06 01:36:32 +00:00
isc_taskpool_t *pool = NULL;
INSIST(ntasks > 0);
update copyright notice
2011-07-07 23:47:50 +00:00
3131. [func] Improve scalability by allocating one zone task per 100 zones at startup time, rather than using a fixed-size task table. [RT #24406]
2011-07-06 01:36:32 +00:00
/* Allocate the pool structure */
Clear the pointer to destroyed object early using the semantic patch Also disable the semantic patch as the code needs tweaks here and there because some destroy functions might not destroy the object and return early if the object is still in use.
2020-02-08 04:37:54 -08:00
alloc_pool(tmgr, mctx, ntasks, quantum, &pool);
3131. [func] Improve scalability by allocating one zone task per 100 zones at startup time, rather than using a fixed-size task table. [RT #24406]
2011-07-06 01:36:32 +00:00
/* Create the tasks */
Created a new type isc_taskpool_t, a pool of isc_task_t objects to be shared by multiple users. This is intended for use by things like zones, which would need hordes of tasks if each one had a separate task.
1999-10-21 00:32:15 +00:00
for (i = 0; i < ntasks; i++) {
Refactor taskmgr to run on top of netmgr This commit changes the taskmgr to run the individual tasks on the netmgr internal workers. While an effort has been put into keeping the taskmgr interface intact, couple of changes have been made: * The taskmgr has no concept of universal privileged mode - rather the tasks are either privileged or unprivileged (normal). The privileged tasks are run as a first thing when the netmgr is unpaused. There are now four different queues in in the netmgr: 1. priority queue - netievent on the priority queue are run even when the taskmgr enter exclusive mode and netmgr is paused. This is needed to properly start listening on the interfaces, free resources and resume. 2. privileged task queue - only privileged tasks are queued here and this is the first queue that gets processed when network manager is unpaused using isc_nm_resume(). All netmgr workers need to clean the privileged task queue before they all proceed normal operation. Both task queues are processed when the workers are finished. 3. task queue - only (traditional) task are scheduled here and this queue along with privileged task queues are process when the netmgr workers are finishing. This is needed to process the task shutdown events. 4. normal queue - this is the queue with netmgr events, e.g. reading, sending, callbacks and pretty much everything is processed here. * The isc_taskmgr_create() now requires initialized netmgr (isc_nm_t) object. * The isc_nm_destroy() function now waits for indefinite time, but it will print out the active objects when in tracing mode (-DNETMGR_TRACE=1 and -DNETMGR_TRACE_VERBOSE=1), the netmgr has been made a little bit more asynchronous and it might take longer time to shutdown all the active networking connections. * Previously, the isc_nm_stoplistening() was a synchronous operation. This has been changed and the isc_nm_stoplistening() just schedules the child sockets to stop listening and exits. This was needed to prevent a deadlock as the the (traditional) tasks are now executed on the netmgr threads. * The socket selection logic in isc__nm_udp_send() was flawed, but fortunatelly, it was broken, so we never hit the problem where we created uvreq_t on a socket from nmhandle_t, but then a different socket could be picked up and then we were trying to run the send callback on a socket that had different threadid than currently running.
2021-04-09 11:31:19 +02:00
isc_result_t result = isc_task_create_bound(tmgr, quantum,
&pool->tasks[i], i);
Created a new type isc_taskpool_t, a pool of isc_task_t objects to be shared by multiple users. This is intended for use by things like zones, which would need hordes of tasks if each one had a separate task.
1999-10-21 00:32:15 +00:00
if (result != ISC_R_SUCCESS) {
isc_taskpool_destroy(&pool);
return (result);
}
Refactor taskmgr to run on top of netmgr This commit changes the taskmgr to run the individual tasks on the netmgr internal workers. While an effort has been put into keeping the taskmgr interface intact, couple of changes have been made: * The taskmgr has no concept of universal privileged mode - rather the tasks are either privileged or unprivileged (normal). The privileged tasks are run as a first thing when the netmgr is unpaused. There are now four different queues in in the netmgr: 1. priority queue - netievent on the priority queue are run even when the taskmgr enter exclusive mode and netmgr is paused. This is needed to properly start listening on the interfaces, free resources and resume. 2. privileged task queue - only privileged tasks are queued here and this is the first queue that gets processed when network manager is unpaused using isc_nm_resume(). All netmgr workers need to clean the privileged task queue before they all proceed normal operation. Both task queues are processed when the workers are finished. 3. task queue - only (traditional) task are scheduled here and this queue along with privileged task queues are process when the netmgr workers are finishing. This is needed to process the task shutdown events. 4. normal queue - this is the queue with netmgr events, e.g. reading, sending, callbacks and pretty much everything is processed here. * The isc_taskmgr_create() now requires initialized netmgr (isc_nm_t) object. * The isc_nm_destroy() function now waits for indefinite time, but it will print out the active objects when in tracing mode (-DNETMGR_TRACE=1 and -DNETMGR_TRACE_VERBOSE=1), the netmgr has been made a little bit more asynchronous and it might take longer time to shutdown all the active networking connections. * Previously, the isc_nm_stoplistening() was a synchronous operation. This has been changed and the isc_nm_stoplistening() just schedules the child sockets to stop listening and exits. This was needed to prevent a deadlock as the the (traditional) tasks are now executed on the netmgr threads. * The socket selection logic in isc__nm_udp_send() was flawed, but fortunatelly, it was broken, so we never hit the problem where we created uvreq_t on a socket from nmhandle_t, but then a different socket could be picked up and then we were trying to run the send callback on a socket that had different threadid than currently running.
2021-04-09 11:31:19 +02:00
isc_task_setprivilege(pool->tasks[i], priv);
2134. [func] Additional statistics support. [RT #16666]
2007-02-13 02:49:08 +00:00
isc_task_setname(pool->tasks[i], "taskpool", NULL);
Created a new type isc_taskpool_t, a pool of isc_task_t objects to be shared by multiple users. This is intended for use by things like zones, which would need hordes of tasks if each one had a separate task.
1999-10-21 00:32:15 +00:00
}
3131. [func] Improve scalability by allocating one zone task per 100 zones at startup time, rather than using a fixed-size task table. [RT #24406]
2011-07-06 01:36:32 +00:00
Created a new type isc_taskpool_t, a pool of isc_task_t objects to be shared by multiple users. This is intended for use by things like zones, which would need hordes of tasks if each one had a separate task.
1999-10-21 00:32:15 +00:00
*poolp = pool;
return (ISC_R_SUCCESS);
}
3131. [func] Improve scalability by allocating one zone task per 100 zones at startup time, rather than using a fixed-size task table. [RT #24406]
2011-07-06 01:36:32 +00:00
void
apply the modified style
2020-02-13 14:44:37 -08:00
isc_taskpool_gettask(isc_taskpool_t *pool, isc_task_t **targetp) {
Change isc_random() to be just PRNG, and add isc_nonce_buf() that uses CSPRNG This commit reverts the previous change to use system provided entropy, as (SYS_)getrandom is very slow on Linux because it is a syscall. The change introduced in this commit adds a new call isc_nonce_buf that uses CSPRNG from cryptographic library provider to generate secure data that can be and must be used for generating nonces. Example usage would be DNS cookies. The isc_random() API has been changed to use fast PRNG that is not cryptographically secure, but runs entirely in user space. Two contestants have been considered xoroshiro family of the functions by Villa&Blackman and PCG by O'Neill. After a consideration the xoshiro128starstar function has been used as uint32_t random number provider because it is very fast and has good enough properties for our usage pattern. The other change introduced in the commit is the more extensive usage of isc_random_uniform in places where the usage pattern was isc_random() % n to prevent modulo bias. For usage patterns where only 16 or 8 bits are needed (DNS Message ID), the isc_random() functions has been renamed to isc_random32(), and isc_random16() and isc_random8() functions have been introduced by &-ing the isc_random32() output with 0xffff and 0xff. Please note that the functions that uses stripped down bit count doesn't pass our NIST SP 800-22 based random test.
2018-05-28 15:22:23 +02:00
isc_task_attach(pool->tasks[isc_random_uniform(pool->ntasks)], targetp);
3131. [func] Improve scalability by allocating one zone task per 100 zones at startup time, rather than using a fixed-size task table. [RT #24406]
2011-07-06 01:36:32 +00:00
}
int
apply the modified style
2020-02-13 14:44:37 -08:00
isc_taskpool_size(isc_taskpool_t *pool) {
3131. [func] Improve scalability by allocating one zone task per 100 zones at startup time, rather than using a fixed-size task table. [RT #24406]
2011-07-06 01:36:32 +00:00
REQUIRE(pool != NULL);
return (pool->ntasks);
}
isc_result_t
Refactor taskmgr to run on top of netmgr This commit changes the taskmgr to run the individual tasks on the netmgr internal workers. While an effort has been put into keeping the taskmgr interface intact, couple of changes have been made: * The taskmgr has no concept of universal privileged mode - rather the tasks are either privileged or unprivileged (normal). The privileged tasks are run as a first thing when the netmgr is unpaused. There are now four different queues in in the netmgr: 1. priority queue - netievent on the priority queue are run even when the taskmgr enter exclusive mode and netmgr is paused. This is needed to properly start listening on the interfaces, free resources and resume. 2. privileged task queue - only privileged tasks are queued here and this is the first queue that gets processed when network manager is unpaused using isc_nm_resume(). All netmgr workers need to clean the privileged task queue before they all proceed normal operation. Both task queues are processed when the workers are finished. 3. task queue - only (traditional) task are scheduled here and this queue along with privileged task queues are process when the netmgr workers are finishing. This is needed to process the task shutdown events. 4. normal queue - this is the queue with netmgr events, e.g. reading, sending, callbacks and pretty much everything is processed here. * The isc_taskmgr_create() now requires initialized netmgr (isc_nm_t) object. * The isc_nm_destroy() function now waits for indefinite time, but it will print out the active objects when in tracing mode (-DNETMGR_TRACE=1 and -DNETMGR_TRACE_VERBOSE=1), the netmgr has been made a little bit more asynchronous and it might take longer time to shutdown all the active networking connections. * Previously, the isc_nm_stoplistening() was a synchronous operation. This has been changed and the isc_nm_stoplistening() just schedules the child sockets to stop listening and exits. This was needed to prevent a deadlock as the the (traditional) tasks are now executed on the netmgr threads. * The socket selection logic in isc__nm_udp_send() was flawed, but fortunatelly, it was broken, so we never hit the problem where we created uvreq_t on a socket from nmhandle_t, but then a different socket could be picked up and then we were trying to run the send callback on a socket that had different threadid than currently running.
2021-04-09 11:31:19 +02:00
isc_taskpool_expand(isc_taskpool_t **sourcep, unsigned int size, bool priv,
apply the modified style
2020-02-13 14:44:37 -08:00
isc_taskpool_t **targetp) {
3131. [func] Improve scalability by allocating one zone task per 100 zones at startup time, rather than using a fixed-size task table. [RT #24406]
2011-07-06 01:36:32 +00:00
isc_taskpool_t *pool;
REQUIRE(sourcep != NULL && *sourcep != NULL);
REQUIRE(targetp != NULL && *targetp == NULL);
pool = *sourcep;
Clear the pointer to destroyed object early using the semantic patch Also disable the semantic patch as the code needs tweaks here and there because some destroy functions might not destroy the object and return early if the object is still in use.
2020-02-08 04:37:54 -08:00
*sourcep = NULL;
3131. [func] Improve scalability by allocating one zone task per 100 zones at startup time, rather than using a fixed-size task table. [RT #24406]
2011-07-06 01:36:32 +00:00
if (size > pool->ntasks) {
isc_taskpool_t *newpool = NULL;
apply the modified style
2020-02-13 14:44:37 -08:00
unsigned int i;
3131. [func] Improve scalability by allocating one zone task per 100 zones at startup time, rather than using a fixed-size task table. [RT #24406]
2011-07-06 01:36:32 +00:00
/* Allocate a new pool structure */
Use clang-format to reformat the source files
2020-02-12 13:59:18 +01:00
alloc_pool(pool->tmgr, pool->mctx, size, pool->quantum,
&newpool);
3131. [func] Improve scalability by allocating one zone task per 100 zones at startup time, rather than using a fixed-size task table. [RT #24406]
2011-07-06 01:36:32 +00:00
/* Copy over the tasks from the old pool */
for (i = 0; i < pool->ntasks; i++) {
newpool->tasks[i] = pool->tasks[i];
pool->tasks[i] = NULL;
}
/* Create new tasks */
for (i = pool->ntasks; i < size; i++) {
Refactor taskmgr to run on top of netmgr This commit changes the taskmgr to run the individual tasks on the netmgr internal workers. While an effort has been put into keeping the taskmgr interface intact, couple of changes have been made: * The taskmgr has no concept of universal privileged mode - rather the tasks are either privileged or unprivileged (normal). The privileged tasks are run as a first thing when the netmgr is unpaused. There are now four different queues in in the netmgr: 1. priority queue - netievent on the priority queue are run even when the taskmgr enter exclusive mode and netmgr is paused. This is needed to properly start listening on the interfaces, free resources and resume. 2. privileged task queue - only privileged tasks are queued here and this is the first queue that gets processed when network manager is unpaused using isc_nm_resume(). All netmgr workers need to clean the privileged task queue before they all proceed normal operation. Both task queues are processed when the workers are finished. 3. task queue - only (traditional) task are scheduled here and this queue along with privileged task queues are process when the netmgr workers are finishing. This is needed to process the task shutdown events. 4. normal queue - this is the queue with netmgr events, e.g. reading, sending, callbacks and pretty much everything is processed here. * The isc_taskmgr_create() now requires initialized netmgr (isc_nm_t) object. * The isc_nm_destroy() function now waits for indefinite time, but it will print out the active objects when in tracing mode (-DNETMGR_TRACE=1 and -DNETMGR_TRACE_VERBOSE=1), the netmgr has been made a little bit more asynchronous and it might take longer time to shutdown all the active networking connections. * Previously, the isc_nm_stoplistening() was a synchronous operation. This has been changed and the isc_nm_stoplistening() just schedules the child sockets to stop listening and exits. This was needed to prevent a deadlock as the the (traditional) tasks are now executed on the netmgr threads. * The socket selection logic in isc__nm_udp_send() was flawed, but fortunatelly, it was broken, so we never hit the problem where we created uvreq_t on a socket from nmhandle_t, but then a different socket could be picked up and then we were trying to run the send callback on a socket that had different threadid than currently running.
2021-04-09 11:31:19 +02:00
isc_result_t result =
isc_task_create_bound(pool->tmgr, pool->quantum,
&newpool->tasks[i], i);
3131. [func] Improve scalability by allocating one zone task per 100 zones at startup time, rather than using a fixed-size task table. [RT #24406]
2011-07-06 01:36:32 +00:00
if (result != ISC_R_SUCCESS) {
Clear the pointer to destroyed object early using the semantic patch Also disable the semantic patch as the code needs tweaks here and there because some destroy functions might not destroy the object and return early if the object is still in use.
2020-02-08 04:37:54 -08:00
*sourcep = pool;
3131. [func] Improve scalability by allocating one zone task per 100 zones at startup time, rather than using a fixed-size task table. [RT #24406]
2011-07-06 01:36:32 +00:00
isc_taskpool_destroy(&newpool);
return (result);
}
Refactor taskmgr to run on top of netmgr This commit changes the taskmgr to run the individual tasks on the netmgr internal workers. While an effort has been put into keeping the taskmgr interface intact, couple of changes have been made: * The taskmgr has no concept of universal privileged mode - rather the tasks are either privileged or unprivileged (normal). The privileged tasks are run as a first thing when the netmgr is unpaused. There are now four different queues in in the netmgr: 1. priority queue - netievent on the priority queue are run even when the taskmgr enter exclusive mode and netmgr is paused. This is needed to properly start listening on the interfaces, free resources and resume. 2. privileged task queue - only privileged tasks are queued here and this is the first queue that gets processed when network manager is unpaused using isc_nm_resume(). All netmgr workers need to clean the privileged task queue before they all proceed normal operation. Both task queues are processed when the workers are finished. 3. task queue - only (traditional) task are scheduled here and this queue along with privileged task queues are process when the netmgr workers are finishing. This is needed to process the task shutdown events. 4. normal queue - this is the queue with netmgr events, e.g. reading, sending, callbacks and pretty much everything is processed here. * The isc_taskmgr_create() now requires initialized netmgr (isc_nm_t) object. * The isc_nm_destroy() function now waits for indefinite time, but it will print out the active objects when in tracing mode (-DNETMGR_TRACE=1 and -DNETMGR_TRACE_VERBOSE=1), the netmgr has been made a little bit more asynchronous and it might take longer time to shutdown all the active networking connections. * Previously, the isc_nm_stoplistening() was a synchronous operation. This has been changed and the isc_nm_stoplistening() just schedules the child sockets to stop listening and exits. This was needed to prevent a deadlock as the the (traditional) tasks are now executed on the netmgr threads. * The socket selection logic in isc__nm_udp_send() was flawed, but fortunatelly, it was broken, so we never hit the problem where we created uvreq_t on a socket from nmhandle_t, but then a different socket could be picked up and then we were trying to run the send callback on a socket that had different threadid than currently running.
2021-04-09 11:31:19 +02:00
isc_task_setprivilege(newpool->tasks[i], priv);
3131. [func] Improve scalability by allocating one zone task per 100 zones at startup time, rather than using a fixed-size task table. [RT #24406]
2011-07-06 01:36:32 +00:00
isc_task_setname(newpool->tasks[i], "taskpool", NULL);
}
isc_taskpool_destroy(&pool);
pool = newpool;
}
*targetp = pool;
return (ISC_R_SUCCESS);
Created a new type isc_taskpool_t, a pool of isc_task_t objects to be shared by multiple users. This is intended for use by things like zones, which would need hordes of tasks if each one had a separate task.
1999-10-21 00:32:15 +00:00
}
void
apply the modified style
2020-02-13 14:44:37 -08:00
isc_taskpool_destroy(isc_taskpool_t **poolp) {
unsigned int i;
Created a new type isc_taskpool_t, a pool of isc_task_t objects to be shared by multiple users. This is intended for use by things like zones, which would need hordes of tasks if each one had a separate task.
1999-10-21 00:32:15 +00:00
isc_taskpool_t *pool = *poolp;
Clear the pointer to destroyed object early using the semantic patch Also disable the semantic patch as the code needs tweaks here and there because some destroy functions might not destroy the object and return early if the object is still in use.
2020-02-08 04:37:54 -08:00
*poolp = NULL;
Created a new type isc_taskpool_t, a pool of isc_task_t objects to be shared by multiple users. This is intended for use by things like zones, which would need hordes of tasks if each one had a separate task.
1999-10-21 00:32:15 +00:00
for (i = 0; i < pool->ntasks; i++) {
Use clang-tidy to add curly braces around one-line statements The command used to reformat the files in this commit was: ./util/run-clang-tidy \ -clang-tidy-binary clang-tidy-11 -clang-apply-replacements-binary clang-apply-replacements-11 \ -checks=-*,readability-braces-around-statements \ -j 9 \ -fix \ -format \ -style=file \ -quiet clang-format -i --style=format $(git ls-files '*.c' '*.h') uncrustify -c .uncrustify.cfg --replace --no-backup $(git ls-files '*.c' '*.h') clang-format -i --style=format $(git ls-files '*.c' '*.h')
2020-02-13 21:48:23 +01:00
if (pool->tasks[i] != NULL) {
Created a new type isc_taskpool_t, a pool of isc_task_t objects to be shared by multiple users. This is intended for use by things like zones, which would need hordes of tasks if each one had a separate task.
1999-10-21 00:32:15 +00:00
isc_task_detach(&pool->tasks[i]);
Use clang-tidy to add curly braces around one-line statements The command used to reformat the files in this commit was: ./util/run-clang-tidy \ -clang-tidy-binary clang-tidy-11 -clang-apply-replacements-binary clang-apply-replacements-11 \ -checks=-*,readability-braces-around-statements \ -j 9 \ -fix \ -format \ -style=file \ -quiet clang-format -i --style=format $(git ls-files '*.c' '*.h') uncrustify -c .uncrustify.cfg --replace --no-backup $(git ls-files '*.c' '*.h') clang-format -i --style=format $(git ls-files '*.c' '*.h')
2020-02-13 21:48:23 +01:00
}
Created a new type isc_taskpool_t, a pool of isc_task_t objects to be shared by multiple users. This is intended for use by things like zones, which would need hordes of tasks if each one had a separate task.
1999-10-21 00:32:15 +00:00
}
isc_mem_put(pool->mctx, pool->tasks,
pool->ntasks * sizeof(isc_task_t *));
3520. [bug] 'mctx' was not being referenced counted in some places where it should have been. [RT #32794]
2013-03-08 14:38:03 +11:00
isc_mem_putanddetach(&pool->mctx, pool, sizeof(*pool));
Created a new type isc_taskpool_t, a pool of isc_task_t objects to be shared by multiple users. This is intended for use by things like zones, which would need hordes of tasks if each one had a separate task.
1999-10-21 00:32:15 +00:00
}
Reference in New Issue Copy Permalink