Scheduler Routines (from cheops-NG). More...
#include "asterisk.h"
#include <sys/time.h>
#include "asterisk/sched.h"
#include "asterisk/channel.h"
#include "asterisk/lock.h"
#include "asterisk/utils.h"
#include "asterisk/linkedlists.h"
#include "asterisk/dlinkedlists.h"
#include "asterisk/hashtab.h"
#include "asterisk/heap.h"
#include "asterisk/threadstorage.h"
Go to the source code of this file.
Data Structures | |
struct | ast_sched_thread |
struct | sched |
struct | sched_context |
Defines | |
#define | DEBUG(a) |
Functions | |
static void | __init_last_del_id (void) |
int | ast_sched_add (struct sched_context *con, int when, ast_sched_cb callback, const void *data) |
Adds a scheduled event Schedule an event to take place at some point in the future. callback will be called with data as the argument, when milliseconds into the future (approximately) If callback returns 0, no further events will be re-scheduled. | |
int | ast_sched_add_variable (struct sched_context *con, int when, ast_sched_cb callback, const void *data, int variable) |
Schedule callback(data) to happen when ms into the future. | |
int | ast_sched_del (struct sched_context *con, int id) |
Delete the schedule entry with number "id". It's nearly impossible that there would be two or more in the list with that id. | |
void | ast_sched_dump (struct sched_context *con) |
Dump the contents of the scheduler to LOG_DEBUG. | |
const void * | ast_sched_find_data (struct sched_context *con, int id) |
Find a sched structure and return the data field associated with it. | |
int | ast_sched_replace (int old_id, struct sched_context *con, int when, ast_sched_cb callback, const void *data) |
replace a scheduler entry | |
int | ast_sched_replace_variable (int old_id, struct sched_context *con, int when, ast_sched_cb callback, const void *data, int variable) |
replace a scheduler entry | |
void | ast_sched_report (struct sched_context *con, struct ast_str **buf, struct ast_cb_names *cbnames) |
Show statics on what it is in the schedule queue. | |
int | ast_sched_runq (struct sched_context *con) |
Launch all events which need to be run at this time. | |
int | ast_sched_thread_add (struct ast_sched_thread *st, int when, ast_sched_cb cb, const void *data) |
Add a scheduler entry. | |
int | ast_sched_thread_add_variable (struct ast_sched_thread *st, int when, ast_sched_cb cb, const void *data, int variable) |
Add a variable reschedule time scheduler entry. | |
struct ast_sched_thread * | ast_sched_thread_create (void) |
Create a scheduler with a dedicated thread. | |
struct ast_sched_thread * | ast_sched_thread_destroy (struct ast_sched_thread *st) |
Destroy a scheduler and its thread. | |
struct sched_context * | ast_sched_thread_get_context (struct ast_sched_thread *st) |
Get the scheduler context for a given ast_sched_thread. | |
void | ast_sched_thread_poke (struct ast_sched_thread *st) |
Force re-processing of the scheduler context. | |
int | ast_sched_wait (struct sched_context *con) |
Return the number of milliseconds until the next scheduled event. | |
long | ast_sched_when (struct sched_context *con, int id) |
Returns the number of seconds before an event takes place. | |
static struct sched * | sched_alloc (struct sched_context *con) |
static int | sched_cmp (const void *a, const void *b) |
struct sched_context * | sched_context_create (void) |
New schedule context. | |
void | sched_context_destroy (struct sched_context *con) |
destroys a schedule context Destroys (free's) the given sched_context structure | |
static unsigned int | sched_hash (const void *obj) |
static void | sched_release (struct sched_context *con, struct sched *tmp) |
static void * | sched_run (void *data) |
static int | sched_settime (struct timeval *t, int when) |
given the last event *tv and the offset in milliseconds 'when', computes the next value, | |
static int | sched_time_cmp (void *a, void *b) |
static void | schedule (struct sched_context *con, struct sched *s) |
Take a sched structure and put it in the queue, such that the soonest event is first in the list. | |
Variables | |
static struct ast_threadstorage | last_del_id = { .once = PTHREAD_ONCE_INIT , .key_init = __init_last_del_id , .custom_init = NULL , } |
Scheduler Routines (from cheops-NG).
Definition in file sched.c.
int ast_sched_add | ( | struct sched_context * | con, | |
int | when, | |||
ast_sched_cb | callback, | |||
const void * | data | |||
) |
Adds a scheduled event Schedule an event to take place at some point in the future. callback will be called with data as the argument, when milliseconds into the future (approximately) If callback returns 0, no further events will be re-scheduled.
con | Scheduler context to add | |
when | how many milliseconds to wait for event to occur | |
callback | function to call when the amount of time expires | |
data | data to pass to the callback |
Definition at line 446 of file sched.c.
References ast_sched_add_variable().
Referenced by __oh323_update_info(), ast_readaudio_callback(), ast_readvideo_callback(), ast_rtp_raw_write(), ast_rtp_read(), ast_sched_replace(), ast_sched_thread_add(), build_peer(), create_esc_entry(), do_register(), do_reload(), dundi_discover(), dundi_query(), dundi_send(), handle_command_response(), handle_request_invite(), handle_response_invite(), handle_response_subscribe(), mgcp_postrequest(), network_change_event_cb(), parse_register_contact(), populate_addr(), precache_trans(), qualify_peer(), receive_digit(), rtp_red_init(), sip_cc_agent_start_offer_timer(), sip_cc_monitor_request_cc(), sip_hangup(), sip_scheddestroy(), sip_send_all_mwi_subscriptions(), start_session_timer(), submit_scheduled_batch(), submit_unscheduled_batch(), transmit_register(), and update_provisional_keepalive().
00447 { 00448 return ast_sched_add_variable(con, when, callback, data, 0); 00449 }
int ast_sched_add_variable | ( | struct sched_context * | con, | |
int | when, | |||
ast_sched_cb | callback, | |||
const void * | data, | |||
int | variable | |||
) |
Schedule callback(data) to happen when ms into the future.
Adds a scheduled event with rescheduling support
con | Scheduler context to add | |
when | how many milliseconds to wait for event to occur | |
callback | function to call when the amount of time expires | |
data | data to pass to the callback | |
variable | If true, the result value of callback function will be used for rescheduling Schedule an event to take place at some point in the future. Callback will be called with data as the argument, when milliseconds into the future (approximately) If callback returns 0, no further events will be re-scheduled |
Definition at line 406 of file sched.c.
References ast_debug, ast_mutex_lock, ast_mutex_unlock, ast_sched_dump(), ast_tv(), sched::callback, sched::data, DEBUG, sched_context::eventcnt, sched::id, sched_context::lock, option_debug, sched::resched, sched_alloc(), sched_release(), sched_settime(), schedule(), sched::variable, and sched::when.
Referenced by _misdn_tasks_add_variable(), ast_sched_add(), ast_sched_replace_variable(), ast_sched_thread_add_variable(), dnsmgr_start_refresh(), and do_reload().
00407 { 00408 struct sched *tmp; 00409 int res = -1; 00410 00411 DEBUG(ast_debug(1, "ast_sched_add()\n")); 00412 00413 ast_mutex_lock(&con->lock); 00414 if ((tmp = sched_alloc(con))) { 00415 tmp->id = con->eventcnt++; 00416 tmp->callback = callback; 00417 tmp->data = data; 00418 tmp->resched = when; 00419 tmp->variable = variable; 00420 tmp->when = ast_tv(0, 0); 00421 if (sched_settime(&tmp->when, when)) { 00422 sched_release(con, tmp); 00423 } else { 00424 schedule(con, tmp); 00425 res = tmp->id; 00426 } 00427 } 00428 #ifdef DUMP_SCHEDULER 00429 /* Dump contents of the context while we have the lock so nothing gets screwed up by accident. */ 00430 if (option_debug) 00431 ast_sched_dump(con); 00432 #endif 00433 ast_mutex_unlock(&con->lock); 00434 00435 return res; 00436 }
int ast_sched_del | ( | struct sched_context * | con, | |
int | id | |||
) |
Delete the schedule entry with number "id". It's nearly impossible that there would be two or more in the list with that id.
Deletes a scheduled event Remove this event from being run. A procedure should not remove its own event, but return 0 instead. In most cases, you should not call this routine directly, but use the AST_SCHED_DEL() macro instead (especially if you don't intend to do something different when it returns failure).
Definition at line 468 of file sched.c.
References ast_assert, ast_debug, ast_hashtab_lookup(), ast_hashtab_remove_this_object(), ast_heap_remove(), ast_log(), ast_mutex_lock, ast_mutex_unlock, ast_sched_dump(), ast_threadstorage_get(), DEBUG, sched::id, last_del_id, sched_context::lock, LOG_WARNING, option_debug, sched_context::sched_heap, sched_release(), sched_context::schedcnt, and sched_context::schedq_ht.
Referenced by __sip_ack(), ast_rtp_prop_set(), ast_rtp_stop(), and destroy_event().
00472 { 00473 struct sched *s, tmp = { 00474 .id = id, 00475 }; 00476 int *last_id = ast_threadstorage_get(&last_del_id, sizeof(int)); 00477 00478 DEBUG(ast_debug(1, "ast_sched_del(%d)\n", id)); 00479 00480 if (id < 0) { 00481 return 0; 00482 } 00483 00484 ast_mutex_lock(&con->lock); 00485 s = ast_hashtab_lookup(con->schedq_ht, &tmp); 00486 if (s) { 00487 if (!ast_heap_remove(con->sched_heap, s)) { 00488 ast_log(LOG_WARNING,"sched entry %d not in the sched heap?\n", s->id); 00489 } 00490 00491 if (!ast_hashtab_remove_this_object(con->schedq_ht, s)) { 00492 ast_log(LOG_WARNING,"Found sched entry %d, then couldn't remove it?\n", s->id); 00493 } 00494 00495 con->schedcnt--; 00496 00497 sched_release(con, s); 00498 } 00499 00500 #ifdef DUMP_SCHEDULER 00501 /* Dump contents of the context while we have the lock so nothing gets screwed up by accident. */ 00502 if (option_debug) 00503 ast_sched_dump(con); 00504 #endif 00505 ast_mutex_unlock(&con->lock); 00506 00507 if (!s && *last_id != id) { 00508 ast_debug(1, "Attempted to delete nonexistent schedule entry %d!\n", id); 00509 #ifndef AST_DEVMODE 00510 ast_assert(s != NULL); 00511 #else 00512 { 00513 char buf[100]; 00514 snprintf(buf, sizeof(buf), "s != NULL, id=%d", id); 00515 _ast_assert(0, buf, file, line, function); 00516 } 00517 #endif 00518 *last_id = id; 00519 return -1; 00520 } else if (!s) { 00521 return -1; 00522 } 00523 00524 return 0; 00525 }
void ast_sched_dump | ( | struct sched_context * | con | ) |
Dump the contents of the scheduler to LOG_DEBUG.
Dumps the scheduler contents Debugging: Dump the contents of the scheduler to stderr.
Definition at line 565 of file sched.c.
References ast_debug, ast_heap_peek(), ast_heap_size(), ast_mutex_lock, ast_mutex_unlock, ast_tvnow(), ast_tvsub(), sched_context::eventcnt, sched_context::highwater, sched_context::lock, sched_context::sched_heap, sched_context::schedccnt, and sched_context::schedcnt.
Referenced by ast_sched_add_variable(), ast_sched_del(), handle_dump_sched(), sip_do_reload(), and unload_module().
00566 { 00567 struct sched *q; 00568 struct timeval when = ast_tvnow(); 00569 int x; 00570 size_t heap_size; 00571 #ifdef SCHED_MAX_CACHE 00572 ast_debug(1, "Asterisk Schedule Dump (%d in Q, %d Total, %d Cache, %d high-water)\n", con->schedcnt, con->eventcnt - 1, con->schedccnt, con->highwater); 00573 #else 00574 ast_debug(1, "Asterisk Schedule Dump (%d in Q, %d Total, %d high-water)\n", con->schedcnt, con->eventcnt - 1, con->highwater); 00575 #endif 00576 00577 ast_debug(1, "=============================================================\n"); 00578 ast_debug(1, "|ID Callback Data Time (sec:ms) |\n"); 00579 ast_debug(1, "+-----+-----------------+-----------------+-----------------+\n"); 00580 ast_mutex_lock(&con->lock); 00581 heap_size = ast_heap_size(con->sched_heap); 00582 for (x = 1; x <= heap_size; x++) { 00583 struct timeval delta; 00584 q = ast_heap_peek(con->sched_heap, x); 00585 delta = ast_tvsub(q->when, when); 00586 ast_debug(1, "|%.4d | %-15p | %-15p | %.6ld : %.6ld |\n", 00587 q->id, 00588 q->callback, 00589 q->data, 00590 (long)delta.tv_sec, 00591 (long int)delta.tv_usec); 00592 } 00593 ast_mutex_unlock(&con->lock); 00594 ast_debug(1, "=============================================================\n"); 00595 }
const void* ast_sched_find_data | ( | struct sched_context * | con, | |
int | id | |||
) |
Find a sched structure and return the data field associated with it.
con | scheduling context in which to search fro the matching id | |
id | ID of the scheduled item to find |
Definition at line 451 of file sched.c.
References ast_hashtab_lookup(), sched::data, sched::id, and sched_context::schedq_ht.
00452 { 00453 struct sched tmp,*res; 00454 tmp.id = id; 00455 res = ast_hashtab_lookup(con->schedq_ht, &tmp); 00456 if (res) 00457 return res->data; 00458 return NULL; 00459 }
int ast_sched_replace | ( | int | old_id, | |
struct sched_context * | con, | |||
int | when, | |||
ast_sched_cb | callback, | |||
const void * | data | |||
) |
replace a scheduler entry
This deletes the scheduler entry for old_id if it exists, and then calls ast_sched_add to create a new entry. A negative old_id will be ignored.
-1 | failure | |
otherwise,returns | scheduled item ID |
Definition at line 438 of file sched.c.
References ast_sched_add(), and AST_SCHED_DEL.
00439 { 00440 if (old_id > -1) { 00441 AST_SCHED_DEL(con, old_id); 00442 } 00443 return ast_sched_add(con, when, callback, data); 00444 }
int ast_sched_replace_variable | ( | int | old_id, | |
struct sched_context * | con, | |||
int | when, | |||
ast_sched_cb | callback, | |||
const void * | data, | |||
int | variable | |||
) |
replace a scheduler entry
This deletes the scheduler entry for old_id if it exists, and then calls ast_sched_add to create a new entry. A negative old_id will be ignored.
-1 | failure | |
otherwise,returns | scheduled item ID |
Definition at line 394 of file sched.c.
References ast_sched_add_variable(), and AST_SCHED_DEL.
00395 { 00396 /* 0 means the schedule item is new; do not delete */ 00397 if (old_id > 0) { 00398 AST_SCHED_DEL(con, old_id); 00399 } 00400 return ast_sched_add_variable(con, when, callback, data, variable); 00401 }
void ast_sched_report | ( | struct sched_context * | con, | |
struct ast_str ** | buf, | |||
struct ast_cb_names * | cbnames | |||
) |
Show statics on what it is in the schedule queue.
con | Schedule context to check | |
buf | dynamic string to store report | |
cbnames | to check against |
Definition at line 527 of file sched.c.
References ast_heap_peek(), ast_heap_size(), ast_mutex_lock, ast_mutex_unlock, ast_str_append(), ast_str_set(), sched::callback, ast_cb_names::cblist, sched_context::highwater, ast_cb_names::list, sched_context::lock, ast_cb_names::numassocs, sched_context::sched_heap, and sched_context::schedcnt.
Referenced by sip_show_sched().
00528 { 00529 int i, x; 00530 struct sched *cur; 00531 int countlist[cbnames->numassocs + 1]; 00532 size_t heap_size; 00533 00534 memset(countlist, 0, sizeof(countlist)); 00535 ast_str_set(buf, 0, " Highwater = %d\n schedcnt = %d\n", con->highwater, con->schedcnt); 00536 00537 ast_mutex_lock(&con->lock); 00538 00539 heap_size = ast_heap_size(con->sched_heap); 00540 for (x = 1; x <= heap_size; x++) { 00541 cur = ast_heap_peek(con->sched_heap, x); 00542 /* match the callback to the cblist */ 00543 for (i = 0; i < cbnames->numassocs; i++) { 00544 if (cur->callback == cbnames->cblist[i]) { 00545 break; 00546 } 00547 } 00548 if (i < cbnames->numassocs) { 00549 countlist[i]++; 00550 } else { 00551 countlist[cbnames->numassocs]++; 00552 } 00553 } 00554 00555 ast_mutex_unlock(&con->lock); 00556 00557 for (i = 0; i < cbnames->numassocs; i++) { 00558 ast_str_append(buf, 0, " %s : %d\n", cbnames->list[i], countlist[i]); 00559 } 00560 00561 ast_str_append(buf, 0, " <unknown> : %d\n", countlist[cbnames->numassocs]); 00562 }
int ast_sched_runq | ( | struct sched_context * | con | ) |
Launch all events which need to be run at this time.
Runs the queue.
Definition at line 600 of file sched.c.
References ast_debug, ast_hashtab_remove_this_object(), ast_heap_peek(), ast_heap_pop(), ast_log(), ast_mutex_lock, ast_mutex_unlock, ast_tv(), ast_tvadd(), ast_tvcmp(), ast_tvnow(), sched::callback, sched::data, DEBUG, sched::id, sched_context::lock, LOG_ERROR, sched::resched, sched_context::sched_heap, sched_release(), sched_settime(), sched_context::schedcnt, sched_context::schedq_ht, schedule(), sched::variable, and sched::when.
Referenced by background_detect_exec(), dial_exec_full(), do_cdr(), do_monitor(), do_refresh(), handle_speechrecognize(), misdn_tasks_thread_func(), network_thread(), reload_config(), sched_run(), speech_background(), wait_for_winner(), and waitstream_core().
00601 { 00602 struct sched *current; 00603 struct timeval when; 00604 int numevents; 00605 int res; 00606 00607 DEBUG(ast_debug(1, "ast_sched_runq()\n")); 00608 00609 ast_mutex_lock(&con->lock); 00610 00611 when = ast_tvadd(ast_tvnow(), ast_tv(0, 1000)); 00612 for (numevents = 0; (current = ast_heap_peek(con->sched_heap, 1)); numevents++) { 00613 /* schedule all events which are going to expire within 1ms. 00614 * We only care about millisecond accuracy anyway, so this will 00615 * help us get more than one event at one time if they are very 00616 * close together. 00617 */ 00618 if (ast_tvcmp(current->when, when) != -1) { 00619 break; 00620 } 00621 00622 current = ast_heap_pop(con->sched_heap); 00623 00624 if (!ast_hashtab_remove_this_object(con->schedq_ht, current)) { 00625 ast_log(LOG_ERROR,"Sched entry %d was in the schedq list but not in the hashtab???\n", current->id); 00626 } 00627 00628 con->schedcnt--; 00629 00630 /* 00631 * At this point, the schedule queue is still intact. We 00632 * have removed the first event and the rest is still there, 00633 * so it's permissible for the callback to add new events, but 00634 * trying to delete itself won't work because it isn't in 00635 * the schedule queue. If that's what it wants to do, it 00636 * should return 0. 00637 */ 00638 00639 ast_mutex_unlock(&con->lock); 00640 res = current->callback(current->data); 00641 ast_mutex_lock(&con->lock); 00642 00643 if (res) { 00644 /* 00645 * If they return non-zero, we should schedule them to be 00646 * run again. 00647 */ 00648 if (sched_settime(¤t->when, current->variable? res : current->resched)) { 00649 sched_release(con, current); 00650 } else { 00651 schedule(con, current); 00652 } 00653 } else { 00654 /* No longer needed, so release it */ 00655 sched_release(con, current); 00656 } 00657 } 00658 00659 ast_mutex_unlock(&con->lock); 00660 00661 return numevents; 00662 }
int ast_sched_thread_add | ( | struct ast_sched_thread * | st, | |
int | when, | |||
ast_sched_cb | cb, | |||
const void * | data | |||
) |
Add a scheduler entry.
st | the handle to the scheduler and thread | |
when | the number of ms in the future to run the task. A value <= 0 is treated as "run now". | |
cb | the function to call when the scheduled time arrives | |
data | the parameter to pass to the scheduler callback |
-1 | Failure | |
>=0 | Sched ID of added task |
Definition at line 210 of file sched.c.
References ast_cond_signal, ast_mutex_lock, ast_mutex_unlock, ast_sched_add(), ast_sched_thread::cond, ast_sched_thread::context, and ast_sched_thread::lock.
Referenced by cc_generic_agent_start_offer_timer(), cc_generic_monitor_request_cc(), iax2_hangup(), iax2_key_rotate(), iax2_sched_add(), and iax2_sched_replace().
00212 { 00213 int res; 00214 00215 ast_mutex_lock(&st->lock); 00216 res = ast_sched_add(st->context, when, cb, data); 00217 if (res != -1) { 00218 ast_cond_signal(&st->cond); 00219 } 00220 ast_mutex_unlock(&st->lock); 00221 00222 return res; 00223 }
int ast_sched_thread_add_variable | ( | struct ast_sched_thread * | st, | |
int | when, | |||
ast_sched_cb | cb, | |||
const void * | data, | |||
int | variable | |||
) |
Add a variable reschedule time scheduler entry.
st | the handle to the scheduler and thread | |
when | the number of ms in the future to run the task. A value <= 0 is treated as "run now". | |
cb | the function to call when the scheduled time arrives | |
data | the parameter to pass to the scheduler callback | |
variable | If this value is non-zero, then the scheduler will use the return value of the scheduler as the amount of time in the future to run the task again. Normally, a return value of 0 means do not re-schedule, and non-zero means re-schedule using the time provided when the scheduler entry was first created. |
-1 | Failure | |
>=0 | Sched ID of added task |
Definition at line 195 of file sched.c.
References ast_cond_signal, ast_mutex_lock, ast_mutex_unlock, ast_sched_add_variable(), ast_sched_thread::cond, ast_sched_thread::context, and ast_sched_thread::lock.
Referenced by stun_start_monitor().
00197 { 00198 int res; 00199 00200 ast_mutex_lock(&st->lock); 00201 res = ast_sched_add_variable(st->context, when, cb, data, variable); 00202 if (res != -1) { 00203 ast_cond_signal(&st->cond); 00204 } 00205 ast_mutex_unlock(&st->lock); 00206 00207 return res; 00208 }
struct ast_sched_thread* ast_sched_thread_create | ( | void | ) | [read] |
Create a scheduler with a dedicated thread.
This function should be used to allocate a scheduler context and a dedicated thread for processing scheduler entries. The thread is started immediately.
NULL | error | |
non-NULL | a handle to the scheduler and its dedicated thread. |
Definition at line 167 of file sched.c.
References ast_calloc, ast_cond_init, ast_log(), ast_mutex_init, ast_pthread_create_background, AST_PTHREADT_NULL, ast_sched_thread_destroy(), ast_sched_thread::cond, ast_sched_thread::context, ast_sched_thread::lock, LOG_ERROR, sched_context_create(), sched_run(), and ast_sched_thread::thread.
Referenced by ast_cc_init(), load_module(), and stun_start_monitor().
00168 { 00169 struct ast_sched_thread *st; 00170 00171 if (!(st = ast_calloc(1, sizeof(*st)))) { 00172 return NULL; 00173 } 00174 00175 ast_mutex_init(&st->lock); 00176 ast_cond_init(&st->cond, NULL); 00177 00178 st->thread = AST_PTHREADT_NULL; 00179 00180 if (!(st->context = sched_context_create())) { 00181 ast_log(LOG_ERROR, "Failed to create scheduler\n"); 00182 ast_sched_thread_destroy(st); 00183 return NULL; 00184 } 00185 00186 if (ast_pthread_create_background(&st->thread, NULL, sched_run, st)) { 00187 ast_log(LOG_ERROR, "Failed to create scheduler thread\n"); 00188 ast_sched_thread_destroy(st); 00189 return NULL; 00190 } 00191 00192 return st; 00193 }
struct ast_sched_thread* ast_sched_thread_destroy | ( | struct ast_sched_thread * | st | ) | [read] |
Destroy a scheduler and its thread.
This function is used to destroy a scheduler context and the dedicated thread that was created for handling scheduler entries. Any entries in the scheduler that have not yet been processed will be thrown away. Once this function is called, the handle must not be used again.
st | the handle to the scheduler and thread |
Definition at line 143 of file sched.c.
References ast_cond_destroy, ast_cond_signal, ast_free, ast_mutex_destroy, ast_mutex_lock, ast_mutex_unlock, AST_PTHREADT_NULL, ast_sched_thread::cond, ast_sched_thread::context, ast_sched_thread::lock, sched_context_destroy(), ast_sched_thread::stop, and ast_sched_thread::thread.
Referenced by __unload_module(), ast_sched_thread_create(), cc_shutdown(), load_module(), stun_start_monitor(), and stun_stop_monitor().
00144 { 00145 if (st->thread != AST_PTHREADT_NULL) { 00146 ast_mutex_lock(&st->lock); 00147 st->stop = 1; 00148 ast_cond_signal(&st->cond); 00149 ast_mutex_unlock(&st->lock); 00150 pthread_join(st->thread, NULL); 00151 st->thread = AST_PTHREADT_NULL; 00152 } 00153 00154 ast_mutex_destroy(&st->lock); 00155 ast_cond_destroy(&st->cond); 00156 00157 if (st->context) { 00158 sched_context_destroy(st->context); 00159 st->context = NULL; 00160 } 00161 00162 ast_free(st); 00163 00164 return NULL; 00165 }
struct sched_context* ast_sched_thread_get_context | ( | struct ast_sched_thread * | st | ) | [read] |
Get the scheduler context for a given ast_sched_thread.
This function should be used only when direct access to the scheduler context is required. Its use is discouraged unless necessary. The cases where this is currently required is when you want to take advantage of one of the AST_SCHED macros.
st | the handle to the scheduler and thread |
Definition at line 138 of file sched.c.
References ast_sched_thread::context.
Referenced by iax2_destroy_helper().
00139 { 00140 return st->context; 00141 }
void ast_sched_thread_poke | ( | struct ast_sched_thread * | st | ) |
Force re-processing of the scheduler context.
st | the handle to the scheduler and thread |
Definition at line 131 of file sched.c.
References ast_cond_signal, ast_mutex_lock, ast_mutex_unlock, ast_sched_thread::cond, and ast_sched_thread::lock.
00132 { 00133 ast_mutex_lock(&st->lock); 00134 ast_cond_signal(&st->cond); 00135 ast_mutex_unlock(&st->lock); 00136 }
int ast_sched_wait | ( | struct sched_context * | con | ) |
Return the number of milliseconds until the next scheduled event.
Determines number of seconds until the next outstanding event to take place Determine the number of seconds until the next outstanding event should take place, and return the number of milliseconds until it needs to be run. This value is perfect for passing to the poll call.
Definition at line 334 of file sched.c.
References ast_debug, ast_heap_peek(), ast_mutex_lock, ast_mutex_unlock, ast_tvdiff_ms(), ast_tvnow(), DEBUG, sched_context::lock, sched_context::sched_heap, and sched::when.
Referenced by background_detect_exec(), dial_exec_full(), do_cdr(), do_monitor(), do_refresh(), handle_speechrecognize(), misdn_tasks_thread_func(), network_thread(), sched_run(), speech_background(), wait_for_winner(), and waitstream_core().
00335 { 00336 int ms; 00337 struct sched *s; 00338 00339 DEBUG(ast_debug(1, "ast_sched_wait()\n")); 00340 00341 ast_mutex_lock(&con->lock); 00342 if ((s = ast_heap_peek(con->sched_heap, 1))) { 00343 ms = ast_tvdiff_ms(s->when, ast_tvnow()); 00344 if (ms < 0) { 00345 ms = 0; 00346 } 00347 } else { 00348 ms = -1; 00349 } 00350 ast_mutex_unlock(&con->lock); 00351 00352 return ms; 00353 }
long ast_sched_when | ( | struct sched_context * | con, | |
int | id | |||
) |
Returns the number of seconds before an event takes place.
con | Context to use | |
id | Id to dump |
Definition at line 664 of file sched.c.
References ast_debug, ast_hashtab_lookup(), ast_mutex_lock, ast_mutex_unlock, ast_tvnow(), DEBUG, sched::id, sched_context::lock, sched_context::schedq_ht, and sched::when.
Referenced by _sip_show_peer(), handle_cli_status(), and parse_register_contact().
00665 { 00666 struct sched *s, tmp; 00667 long secs = -1; 00668 DEBUG(ast_debug(1, "ast_sched_when()\n")); 00669 00670 ast_mutex_lock(&con->lock); 00671 00672 /* these next 2 lines replace a lookup loop */ 00673 tmp.id = id; 00674 s = ast_hashtab_lookup(con->schedq_ht, &tmp); 00675 00676 if (s) { 00677 struct timeval now = ast_tvnow(); 00678 secs = s->when.tv_sec - now.tv_sec; 00679 } 00680 ast_mutex_unlock(&con->lock); 00681 00682 return secs; 00683 }
static struct sched* sched_alloc | ( | struct sched_context * | con | ) | [static, read] |
Definition at line 296 of file sched.c.
References ast_calloc, AST_LIST_REMOVE_HEAD, sched_context::schedc, and sched_context::schedccnt.
Referenced by ast_sched_add_variable().
00297 { 00298 struct sched *tmp; 00299 00300 /* 00301 * We keep a small cache of schedule entries 00302 * to minimize the number of necessary malloc()'s 00303 */ 00304 #ifdef SCHED_MAX_CACHE 00305 if ((tmp = AST_LIST_REMOVE_HEAD(&con->schedc, list))) 00306 con->schedccnt--; 00307 else 00308 #endif 00309 tmp = ast_calloc(1, sizeof(*tmp)); 00310 00311 return tmp; 00312 }
static int sched_cmp | ( | const void * | a, | |
const void * | b | |||
) | [static] |
struct sched_context* sched_context_create | ( | void | ) | [read] |
New schedule context.
Definition at line 246 of file sched.c.
References ast_calloc, ast_hashtab_create(), ast_hashtab_newsize_java(), ast_hashtab_resize_java(), ast_heap_create(), ast_mutex_init, sched_context::eventcnt, sched_context::lock, sched_cmp(), sched_context_destroy(), sched_hash(), sched_context::sched_heap, sched_time_cmp(), and sched_context::schedq_ht.
Referenced by __ast_channel_alloc_ap(), ast_cdr_engine_init(), ast_sched_thread_create(), dnsmgr_init(), load_module(), and misdn_tasks_init().
00247 { 00248 struct sched_context *tmp; 00249 00250 if (!(tmp = ast_calloc(1, sizeof(*tmp)))) 00251 return NULL; 00252 00253 ast_mutex_init(&tmp->lock); 00254 tmp->eventcnt = 1; 00255 00256 tmp->schedq_ht = ast_hashtab_create(23, sched_cmp, ast_hashtab_resize_java, ast_hashtab_newsize_java, sched_hash, 1); 00257 00258 if (!(tmp->sched_heap = ast_heap_create(8, sched_time_cmp, 00259 offsetof(struct sched, __heap_index)))) { 00260 sched_context_destroy(tmp); 00261 return NULL; 00262 } 00263 00264 return tmp; 00265 }
void sched_context_destroy | ( | struct sched_context * | c | ) |
destroys a schedule context Destroys (free's) the given sched_context structure
c | Context to free |
Definition at line 267 of file sched.c.
References ast_free, ast_hashtab_destroy(), ast_heap_destroy(), ast_heap_pop(), AST_LIST_REMOVE_HEAD, ast_mutex_destroy, ast_mutex_lock, ast_mutex_unlock, sched_context::lock, sched_context::sched_heap, sched_context::schedc, and sched_context::schedq_ht.
Referenced by ast_channel_destructor(), ast_hangup(), ast_sched_thread_destroy(), cdr_engine_shutdown(), dnsmgr_shutdown(), load_module(), misdn_tasks_destroy(), sched_context_create(), and unload_module().
00268 { 00269 struct sched *s; 00270 00271 ast_mutex_lock(&con->lock); 00272 00273 #ifdef SCHED_MAX_CACHE 00274 /* Eliminate the cache */ 00275 while ((s = AST_LIST_REMOVE_HEAD(&con->schedc, list))) 00276 ast_free(s); 00277 #endif 00278 00279 if (con->sched_heap) { 00280 while ((s = ast_heap_pop(con->sched_heap))) { 00281 ast_free(s); 00282 } 00283 ast_heap_destroy(con->sched_heap); 00284 con->sched_heap = NULL; 00285 } 00286 00287 ast_hashtab_destroy(con->schedq_ht, NULL); 00288 con->schedq_ht = NULL; 00289 00290 /* And the context */ 00291 ast_mutex_unlock(&con->lock); 00292 ast_mutex_destroy(&con->lock); 00293 ast_free(con); 00294 }
static unsigned int sched_hash | ( | const void * | obj | ) | [static] |
static void sched_release | ( | struct sched_context * | con, | |
struct sched * | tmp | |||
) | [static] |
Definition at line 314 of file sched.c.
References ast_free, AST_LIST_INSERT_HEAD, SCHED_MAX_CACHE, sched_context::schedc, and sched_context::schedccnt.
Referenced by ast_sched_add_variable(), ast_sched_del(), and ast_sched_runq().
00315 { 00316 /* 00317 * Add to the cache, or just free() if we 00318 * already have too many cache entries 00319 */ 00320 00321 #ifdef SCHED_MAX_CACHE 00322 if (con->schedccnt < SCHED_MAX_CACHE) { 00323 AST_LIST_INSERT_HEAD(&con->schedc, tmp, list); 00324 con->schedccnt++; 00325 } else 00326 #endif 00327 ast_free(tmp); 00328 }
static void* sched_run | ( | void * | data | ) | [static] |
Definition at line 90 of file sched.c.
References ast_cond_timedwait, ast_cond_wait, ast_mutex_lock, ast_mutex_unlock, ast_samp2tv(), ast_sched_runq(), ast_sched_wait(), ast_tvadd(), ast_tvnow(), ast_sched_thread::cond, ast_sched_thread::context, ast_sched_thread::lock, and ast_sched_thread::stop.
Referenced by ast_sched_thread_create().
00091 { 00092 struct ast_sched_thread *st = data; 00093 00094 while (!st->stop) { 00095 int ms; 00096 struct timespec ts = { 00097 .tv_sec = 0, 00098 }; 00099 00100 ast_mutex_lock(&st->lock); 00101 00102 if (st->stop) { 00103 ast_mutex_unlock(&st->lock); 00104 return NULL; 00105 } 00106 00107 ms = ast_sched_wait(st->context); 00108 00109 if (ms == -1) { 00110 ast_cond_wait(&st->cond, &st->lock); 00111 } else { 00112 struct timeval tv; 00113 tv = ast_tvadd(ast_tvnow(), ast_samp2tv(ms, 1000)); 00114 ts.tv_sec = tv.tv_sec; 00115 ts.tv_nsec = tv.tv_usec * 1000; 00116 ast_cond_timedwait(&st->cond, &st->lock, &ts); 00117 } 00118 00119 ast_mutex_unlock(&st->lock); 00120 00121 if (st->stop) { 00122 return NULL; 00123 } 00124 00125 ast_sched_runq(st->context); 00126 } 00127 00128 return NULL; 00129 }
static int sched_settime | ( | struct timeval * | t, | |
int | when | |||
) | [static] |
given the last event *tv and the offset in milliseconds 'when', computes the next value,
Definition at line 380 of file sched.c.
References ast_samp2tv(), ast_tvadd(), ast_tvcmp(), ast_tvnow(), and ast_tvzero().
Referenced by ast_sched_add_variable(), and ast_sched_runq().
00381 { 00382 struct timeval now = ast_tvnow(); 00383 00384 /*ast_debug(1, "TV -> %lu,%lu\n", tv->tv_sec, tv->tv_usec);*/ 00385 if (ast_tvzero(*t)) /* not supplied, default to now */ 00386 *t = now; 00387 *t = ast_tvadd(*t, ast_samp2tv(when, 1000)); 00388 if (ast_tvcmp(*t, now) < 0) { 00389 *t = now; 00390 } 00391 return 0; 00392 }
static int sched_time_cmp | ( | void * | a, | |
void * | b | |||
) | [static] |
Definition at line 241 of file sched.c.
References ast_tvcmp().
Referenced by sched_context_create().
static void schedule | ( | struct sched_context * | con, | |
struct sched * | s | |||
) | [static] |
Take a sched structure and put it in the queue, such that the soonest event is first in the list.
Definition at line 361 of file sched.c.
References ast_hashtab_insert_safe(), ast_heap_push(), ast_log(), sched_context::highwater, sched::id, LOG_WARNING, sched_context::sched_heap, sched_context::schedcnt, and sched_context::schedq_ht.
Referenced by ast_sched_add_variable(), and ast_sched_runq().
00362 { 00363 ast_heap_push(con->sched_heap, s); 00364 00365 if (!ast_hashtab_insert_safe(con->schedq_ht, s)) { 00366 ast_log(LOG_WARNING,"Schedule Queue entry %d is already in table!\n", s->id); 00367 } 00368 00369 con->schedcnt++; 00370 00371 if (con->schedcnt > con->highwater) { 00372 con->highwater = con->schedcnt; 00373 } 00374 }
struct ast_threadstorage last_del_id = { .once = PTHREAD_ONCE_INIT , .key_init = __init_last_del_id , .custom_init = NULL , } [static] |
Definition at line 55 of file sched.c.
Referenced by ast_sched_del().