#include "asterisk.h"
#include <stdio.h>
#include <stdlib.h>
#include <sys/time.h>
#include <unistd.h>
#include <string.h>
#include "asterisk/sched.h"
#include "asterisk/logger.h"
#include "asterisk/channel.h"
#include "asterisk/lock.h"
#include "asterisk/utils.h"
#include "asterisk/linkedlists.h"
#include "asterisk/options.h"
Go to the source code of this file.
Data Structures | |
struct | sched |
struct | sched_context |
Defines | |
#define | DEBUG(a) |
Functions | |
int | ast_sched_add (struct sched_context *con, int when, ast_sched_cb callback, 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, 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 (const struct sched_context *con) |
Dump the contents of the scheduler to LOG_DEBUG. | |
int | ast_sched_runq (struct sched_context *con) |
Launch all events which need to be run at this time. | |
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) |
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 void | sched_release (struct sched_context *con, struct sched *tmp) |
static int | sched_settime (struct timeval *tv, int when) |
given the last event *tv and the offset in milliseconds 'when', computes the next value, | |
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. |
Definition in file sched.c.
int ast_sched_add | ( | struct sched_context * | con, | |
int | when, | |||
ast_sched_cb | callback, | |||
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 247 of file sched.c.
Referenced by __attempt_transmit(), __iax2_poke_noanswer(), __oh323_update_info(), __send_lagrq(), __send_ping(), ast_readaudio_callback(), ast_readvideo_callback(), ast_rtp_raw_write(), ast_rtp_read(), auth_fail(), build_peer(), do_register(), do_reload(), dundi_discover(), dundi_query(), dundi_send(), find_callno(), handle_command_response(), handle_response_peerpoke(), handle_response_register(), iax2_ack_registry(), iax2_call(), iax2_do_register(), iax2_dprequest(), iax2_poke_peer(), iax2_provision(), make_trunk(), mgcp_postrequest(), network_thread(), parse_register_contact(), populate_addr(), precache_trans(), qualify_peer(), realtime_peer(), receive_digit(), reg_source_db(), sip_call(), sip_poke_all_peers(), sip_poke_noanswer(), sip_poke_peer(), sip_scheddestroy(), sip_send_all_registers(), socket_process(), submit_scheduled_batch(), submit_unscheduled_batch(), transmit_register(), update_jbsched(), and update_registry().
00248 { 00249 return ast_sched_add_variable(con, when, callback, data, 0); 00250 }
int ast_sched_add_variable | ( | struct sched_context * | con, | |
int | when, | |||
ast_sched_cb | callback, | |||
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 214 of file sched.c.
Referenced by __sip_reliable_xmit(), _misdn_tasks_add_variable(), ast_sched_add(), dnsmgr_start_refresh(), and do_reload().
00215 { 00216 struct sched *tmp; 00217 int res = -1; 00218 DEBUG(ast_log(LOG_DEBUG, "ast_sched_add()\n")); 00219 if (!when) { 00220 ast_log(LOG_NOTICE, "Scheduled event in 0 ms?\n"); 00221 return -1; 00222 } 00223 ast_mutex_lock(&con->lock); 00224 if ((tmp = sched_alloc(con))) { 00225 tmp->id = con->eventcnt++; 00226 tmp->callback = callback; 00227 tmp->data = data; 00228 tmp->resched = when; 00229 tmp->variable = variable; 00230 tmp->when = ast_tv(0, 0); 00231 if (sched_settime(&tmp->when, when)) { 00232 sched_release(con, tmp); 00233 } else { 00234 schedule(con, tmp); 00235 res = tmp->id; 00236 } 00237 } 00238 #ifdef DUMP_SCHEDULER 00239 /* Dump contents of the context while we have the lock so nothing gets screwed up by accident. */ 00240 if (option_debug) 00241 ast_sched_dump(con); 00242 #endif 00243 ast_mutex_unlock(&con->lock); 00244 return res; 00245 }
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.
Definition at line 258 of file sched.c.
Referenced by __oh323_destroy(), __oh323_update_info(), __sip_ack(), __sip_destroy(), __sip_reliable_xmit(), __sip_semi_ack(), ack_trans(), ast_closestream(), ast_rtcp_write_rr(), ast_rtcp_write_sr(), ast_rtp_destroy(), ast_rtp_stop(), auth_fail(), build_gateway(), build_peer(), delete_users(), destroy_packet(), destroy_packets(), destroy_peer(), destroy_trans(), dnsmgr_start_refresh(), do_reload(), handle_command_response(), handle_response_invite(), handle_response_peerpoke(), handle_response_register(), iax2_ack_registry(), iax2_destroy_helper(), iax2_do_register(), iax2_dprequest(), iax2_frame_free(), iax2_poke_peer(), iax2_provision(), make_trunk(), mgcpsock_read(), misdn_tasks_remove(), parse_register_contact(), qualify_peer(), realtime_peer(), receive_digit(), reg_source_db(), schedule_delivery(), sip_cancel_destroy(), sip_destroy_peer(), sip_poke_all_peers(), sip_poke_peer(), sip_registry_destroy(), sip_scheddestroy(), sip_send_all_registers(), socket_process(), submit_unscheduled_batch(), transmit_register(), update_jbsched(), and update_registry().
00259 { 00260 struct sched *s; 00261 00262 DEBUG(ast_log(LOG_DEBUG, "ast_sched_del()\n")); 00263 00264 ast_mutex_lock(&con->lock); 00265 AST_LIST_TRAVERSE_SAFE_BEGIN(&con->schedq, s, list) { 00266 if (s->id == id) { 00267 AST_LIST_REMOVE_CURRENT(&con->schedq, list); 00268 con->schedcnt--; 00269 sched_release(con, s); 00270 break; 00271 } 00272 } 00273 AST_LIST_TRAVERSE_SAFE_END 00274 00275 #ifdef DUMP_SCHEDULER 00276 /* Dump contents of the context while we have the lock so nothing gets screwed up by accident. */ 00277 if (option_debug) 00278 ast_sched_dump(con); 00279 #endif 00280 ast_mutex_unlock(&con->lock); 00281 00282 if (!s) { 00283 if (option_debug) 00284 ast_log(LOG_DEBUG, "Attempted to delete nonexistent schedule entry %d!\n", id); 00285 #ifdef DO_CRASH 00286 CRASH; 00287 #endif 00288 return -1; 00289 } 00290 00291 return 0; 00292 }
void ast_sched_dump | ( | const 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 295 of file sched.c.
Referenced by ast_sched_add_variable(), and ast_sched_del().
00296 { 00297 struct sched *q; 00298 struct timeval tv = ast_tvnow(); 00299 #ifdef SCHED_MAX_CACHE 00300 ast_log(LOG_DEBUG, "Asterisk Schedule Dump (%d in Q, %d Total, %d Cache)\n", con->schedcnt, con->eventcnt - 1, con->schedccnt); 00301 #else 00302 ast_log(LOG_DEBUG, "Asterisk Schedule Dump (%d in Q, %d Total)\n", con->schedcnt, con->eventcnt - 1); 00303 #endif 00304 00305 ast_log(LOG_DEBUG, "=============================================================\n"); 00306 ast_log(LOG_DEBUG, "|ID Callback Data Time (sec:ms) |\n"); 00307 ast_log(LOG_DEBUG, "+-----+-----------------+-----------------+-----------------+\n"); 00308 AST_LIST_TRAVERSE(&con->schedq, q, list) { 00309 struct timeval delta = ast_tvsub(q->when, tv); 00310 00311 ast_log(LOG_DEBUG, "|%.4d | %-15p | %-15p | %.6ld : %.6ld |\n", 00312 q->id, 00313 q->callback, 00314 q->data, 00315 delta.tv_sec, 00316 (long int)delta.tv_usec); 00317 } 00318 ast_log(LOG_DEBUG, "=============================================================\n"); 00319 00320 }
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 325 of file sched.c.
Referenced by background_detect_exec(), do_cdr(), do_monitor(), do_refresh(), misdn_tasks_thread_func(), network_thread(), reload_config(), sched_thread(), speech_background(), wait_for_winner(), and waitstream_core().
00326 { 00327 struct sched *current; 00328 struct timeval tv; 00329 int numevents; 00330 int res; 00331 00332 DEBUG(ast_log(LOG_DEBUG, "ast_sched_runq()\n")); 00333 00334 ast_mutex_lock(&con->lock); 00335 00336 for (numevents = 0; !AST_LIST_EMPTY(&con->schedq); numevents++) { 00337 /* schedule all events which are going to expire within 1ms. 00338 * We only care about millisecond accuracy anyway, so this will 00339 * help us get more than one event at one time if they are very 00340 * close together. 00341 */ 00342 tv = ast_tvadd(ast_tvnow(), ast_tv(0, 1000)); 00343 if (ast_tvcmp(AST_LIST_FIRST(&con->schedq)->when, tv) != -1) 00344 break; 00345 00346 current = AST_LIST_REMOVE_HEAD(&con->schedq, list); 00347 con->schedcnt--; 00348 00349 /* 00350 * At this point, the schedule queue is still intact. We 00351 * have removed the first event and the rest is still there, 00352 * so it's permissible for the callback to add new events, but 00353 * trying to delete itself won't work because it isn't in 00354 * the schedule queue. If that's what it wants to do, it 00355 * should return 0. 00356 */ 00357 00358 ast_mutex_unlock(&con->lock); 00359 res = current->callback(current->data); 00360 ast_mutex_lock(&con->lock); 00361 00362 if (res) { 00363 /* 00364 * If they return non-zero, we should schedule them to be 00365 * run again. 00366 */ 00367 if (sched_settime(¤t->when, current->variable? res : current->resched)) { 00368 sched_release(con, current); 00369 } else 00370 schedule(con, current); 00371 } else { 00372 /* No longer needed, so release it */ 00373 sched_release(con, current); 00374 } 00375 } 00376 00377 ast_mutex_unlock(&con->lock); 00378 00379 return numevents; 00380 }
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 148 of file sched.c.
Referenced by background_detect_exec(), do_cdr(), do_monitor(), do_refresh(), misdn_tasks_thread_func(), network_thread(), sched_thread(), speech_background(), wait_for_winner(), and waitstream_core().
00149 { 00150 int ms; 00151 00152 DEBUG(ast_log(LOG_DEBUG, "ast_sched_wait()\n")); 00153 00154 ast_mutex_lock(&con->lock); 00155 if (AST_LIST_EMPTY(&con->schedq)) { 00156 ms = -1; 00157 } else { 00158 ms = ast_tvdiff_ms(AST_LIST_FIRST(&con->schedq)->when, ast_tvnow()); 00159 if (ms < 0) 00160 ms = 0; 00161 } 00162 ast_mutex_unlock(&con->lock); 00163 00164 return ms; 00165 }
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 382 of file sched.c.
Referenced by _sip_show_peer(), handle_cli_status(), and parse_register_contact().
00383 { 00384 struct sched *s; 00385 long secs = -1; 00386 DEBUG(ast_log(LOG_DEBUG, "ast_sched_when()\n")); 00387 00388 ast_mutex_lock(&con->lock); 00389 AST_LIST_TRAVERSE(&con->schedq, s, list) { 00390 if (s->id == id) 00391 break; 00392 } 00393 if (s) { 00394 struct timeval now = ast_tvnow(); 00395 secs = s->when.tv_sec - now.tv_sec; 00396 } 00397 ast_mutex_unlock(&con->lock); 00398 00399 return secs; 00400 }
static struct sched* sched_alloc | ( | struct sched_context * | con | ) | [static, read] |
Definition at line 110 of file sched.c.
References ast_calloc, and AST_LIST_REMOVE_HEAD.
Referenced by ast_sched_add_variable().
00111 { 00112 struct sched *tmp; 00113 00114 /* 00115 * We keep a small cache of schedule entries 00116 * to minimize the number of necessary malloc()'s 00117 */ 00118 #ifdef SCHED_MAX_CACHE 00119 if ((tmp = AST_LIST_REMOVE_HEAD(&con->schedc, list))) 00120 con->schedccnt--; 00121 else 00122 #endif 00123 tmp = ast_calloc(1, sizeof(*tmp)); 00124 00125 return tmp; 00126 }
struct sched_context* sched_context_create | ( | void | ) | [read] |
New schedule context.
Definition at line 75 of file sched.c.
Referenced by ast_cdr_engine_init(), ast_channel_alloc(), dnsmgr_init(), load_module(), and misdn_tasks_init().
00076 { 00077 struct sched_context *tmp; 00078 00079 if (!(tmp = ast_calloc(1, sizeof(*tmp)))) 00080 return NULL; 00081 00082 ast_mutex_init(&tmp->lock); 00083 tmp->eventcnt = 1; 00084 00085 return tmp; 00086 }
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 88 of file sched.c.
Referenced by __unload_module(), ast_channel_alloc(), ast_channel_free(), ast_hangup(), load_module(), misdn_tasks_destroy(), and unload_module().
00089 { 00090 struct sched *s; 00091 00092 ast_mutex_lock(&con->lock); 00093 00094 #ifdef SCHED_MAX_CACHE 00095 /* Eliminate the cache */ 00096 while ((s = AST_LIST_REMOVE_HEAD(&con->schedc, list))) 00097 free(s); 00098 #endif 00099 00100 /* And the queue */ 00101 while ((s = AST_LIST_REMOVE_HEAD(&con->schedq, list))) 00102 free(s); 00103 00104 /* And the context */ 00105 ast_mutex_unlock(&con->lock); 00106 ast_mutex_destroy(&con->lock); 00107 free(con); 00108 }
static void sched_release | ( | struct sched_context * | con, | |
struct sched * | tmp | |||
) | [static] |
Definition at line 128 of file sched.c.
References AST_LIST_INSERT_HEAD, free, and SCHED_MAX_CACHE.
Referenced by ast_sched_add_variable(), ast_sched_del(), and ast_sched_runq().
00129 { 00130 /* 00131 * Add to the cache, or just free() if we 00132 * already have too many cache entries 00133 */ 00134 00135 #ifdef SCHED_MAX_CACHE 00136 if (con->schedccnt < SCHED_MAX_CACHE) { 00137 AST_LIST_INSERT_HEAD(&con->schedc, tmp, list); 00138 con->schedccnt++; 00139 } else 00140 #endif 00141 free(tmp); 00142 }
static int sched_settime | ( | struct timeval * | tv, | |
int | when | |||
) | [static] |
given the last event *tv and the offset in milliseconds 'when', computes the next value,
Definition at line 195 of file sched.c.
References ast_log(), ast_tvadd(), and LOG_DEBUG.
Referenced by ast_sched_add_variable(), and ast_sched_runq().
00196 { 00197 struct timeval now = ast_tvnow(); 00198 00199 /*ast_log(LOG_DEBUG, "TV -> %lu,%lu\n", tv->tv_sec, tv->tv_usec);*/ 00200 if (ast_tvzero(*tv)) /* not supplied, default to now */ 00201 *tv = now; 00202 *tv = ast_tvadd(*tv, ast_samp2tv(when, 1000)); 00203 if (ast_tvcmp(*tv, now) < 0) { 00204 ast_log(LOG_DEBUG, "Request to schedule in the past?!?!\n"); 00205 *tv = now; 00206 } 00207 return 0; 00208 }
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 173 of file sched.c.
References AST_LIST_INSERT_BEFORE_CURRENT, AST_LIST_INSERT_TAIL, AST_LIST_TRAVERSE_SAFE_BEGIN, AST_LIST_TRAVERSE_SAFE_END, and sched_context::schedcnt.
Referenced by ast_sched_add_variable(), and ast_sched_runq().
00174 { 00175 00176 struct sched *cur = NULL; 00177 00178 AST_LIST_TRAVERSE_SAFE_BEGIN(&con->schedq, cur, list) { 00179 if (ast_tvcmp(s->when, cur->when) == -1) { 00180 AST_LIST_INSERT_BEFORE_CURRENT(&con->schedq, s, list); 00181 break; 00182 } 00183 } 00184 AST_LIST_TRAVERSE_SAFE_END 00185 if (!cur) 00186 AST_LIST_INSERT_TAIL(&con->schedq, s, list); 00187 00188 con->schedcnt++; 00189 }