Sun Aug 6 15:15:45 2006

Asterisk developer's documentation

---

sched.c File Reference

Scheduler Routines (from cheops-NG). More...

#include <stdio.h>
#include <stdlib.h>
#include <sys/time.h>
#include <unistd.h>
#include <string.h>
#include "asterisk.h"
#include "asterisk/sched.h"
#include "asterisk/logger.h"
#include "asterisk/channel.h"
#include "asterisk/lock.h"
#include "asterisk/utils.h"

Include dependency graph for sched.c:

Go to the source code of this file.

Defines
#define	DEBUG(a)
#define	SOONER(a, b)
Functions
int	ast_sched_add (struct sched_context *con, int when, ast_sched_cb callback, void *data)
int	ast_sched_add_variable (struct sched_context *con, int when, ast_sched_cb callback, void *data, int variable)
int	ast_sched_del (struct sched_context *con, int id)
void	ast_sched_dump (const struct sched_context *con)
int	ast_sched_runq (struct sched_context *con)
int	ast_sched_wait (struct sched_context *con)
long	ast_sched_when (struct sched_context *con, int id)
static struct sched *	sched_alloc (struct sched_context *con)
sched_context *	sched_context_create (void)
void	sched_context_destroy (struct sched_context *con)
static void	sched_release (struct sched_context *con, struct sched *tmp)
static int	sched_settime (struct timeval *tv, int when)
static void	schedule (struct sched_context *con, struct sched *s)

---

Detailed Description

Scheduler Routines (from cheops-NG).

Definition in file sched.c.

---

Define Documentation

#define DEBUG (  a   )

Definition at line 28 of file sched.c.

#define SOONER (  a, b   )

Value: (((b).tv_sec > (a).tv_sec) || \ (((b).tv_sec == (a).tv_sec) && ((b).tv_usec > (a).tv_usec))) Definition at line 48 of file sched.c. Referenced by ast_sched_runq(), and schedule().

---

Function Documentation

int ast_sched_add (  struct sched_context *  con, int  when, ast_sched_cb  callback, void *  data )

Parameters: 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 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 Returns a schedule item ID on success, -1 on failure Definition at line 260 of file sched.c. References ast_sched_add_variable(). Referenced by ast_readaudio_callback(), ast_readvideo_callback(), attempt_transmit(), 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_noanswer(), iax2_poke_peer(), iax2_provision(), make_trunk(), mgcp_postrequest(), network_thread(), parse_register_contact(), populate_addr(), precache_trans(), qualify_peer(), realtime_peer(), reg_source_db(), schedule_delivery(), sip_call(), sip_poke_noanswer(), sip_poke_peer(), sip_scheddestroy(), sip_send_all_registers(), socket_read(), submit_scheduled_batch(), submit_unscheduled_batch(), transmit_register(), update_jbsched(), and update_registry(). { return ast_sched_add_variable(con, when, callback, data, 0); }

int ast_sched_add_variable (  struct sched_context *  con, int  when, ast_sched_cb  callback, void *  data, int  variable )

Parameters: 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 Returns a schedule item ID on success, -1 on failure Definition at line 225 of file sched.c. References ast_log(), ast_mutex_lock(), ast_mutex_unlock(), ast_sched_dump(), sched::callback, sched::data, DEBUG, sched_context::eventcnt, sched::id, sched_context::lock, LOG_DEBUG, LOG_NOTICE, sched::resched, sched_alloc(), sched_release(), sched_settime(), schedule(), sched::variable, and sched::when. Referenced by __sip_reliable_xmit(), ast_sched_add(), dnsmgr_start_refresh(), and do_reload(). { /* * Schedule callback(data) to happen when ms into the future */ struct sched *tmp; int res = -1; DEBUG(ast_log(LOG_DEBUG, "ast_sched_add()\n")); if (!when) { ast_log(LOG_NOTICE, "Scheduled event in 0 ms?\n"); return -1; } ast_mutex_lock(&con->lock); if ((tmp = sched_alloc(con))) { tmp->id = con->eventcnt++; tmp->callback = callback; tmp->data = data; tmp->resched = when; tmp->variable = variable; tmp->when = ast_tv(0, 0); if (sched_settime(&tmp->when, when)) { sched_release(con, tmp); } else { schedule(con, tmp); res = tmp->id; } } #ifdef DUMP_SCHEDULER /* Dump contents of the context while we have the lock so nothing gets screwed up by accident. */ ast_sched_dump(con); #endif ast_mutex_unlock(&con->lock); return res; }

int ast_sched_del (  struct sched_context *  con, int  id )

Parameters: con  scheduling context to delete item from id  ID of the scheduled item to delete Remove this event from being run. A procedure should not remove its own event, but return 0 instead. Returns 0 on success, -1 on failure Definition at line 265 of file sched.c. References ast_log(), ast_mutex_lock(), ast_mutex_unlock(), ast_sched_dump(), CRASH, DEBUG, last, sched_context::lock, LOG_DEBUG, LOG_NOTICE, sched::next, s, sched_release(), sched_context::schedcnt, and sched_context::schedq. Referenced by __sip_ack(), __sip_destroy(), __sip_semi_ack(), ack_trans(), ast_closestream(), 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(), handle_response_peerpoke(), handle_response_register(), iax2_ack_registry(), iax2_destroy(), iax2_do_register(), iax2_dprequest(), iax2_frame_free(), iax2_poke_peer(), iax2_predestroy(), iax2_provision(), make_trunk(), mgcpsock_read(), parse_register_contact(), qualify_peer(), realtime_peer(), reg_source_db(), schedule_delivery(), sip_cancel_destroy(), sip_destroy_peer(), sip_poke_peer(), sip_registry_destroy(), sip_scheddestroy(), sip_send_all_registers(), socket_read(), stop_stuff(), submit_unscheduled_batch(), transmit_register(), update_jbsched(), and update_registry(). { /* * Delete the schedule entry with number * "id". It's nearly impossible that there * would be two or more in the list with that * id. */ struct sched *last=NULL, *s; DEBUG(ast_log(LOG_DEBUG, "ast_sched_del()\n")); ast_mutex_lock(&con->lock); s = con->schedq; while(s) { if (s->id == id) { if (last) last->next = s->next; else con->schedq = s->next; con->schedcnt--; sched_release(con, s); break; } last = s; s = s->next; } #ifdef DUMP_SCHEDULER /* Dump contents of the context while we have the lock so nothing gets screwed up by accident. */ ast_sched_dump(con); #endif ast_mutex_unlock(&con->lock); if (!s) { ast_log(LOG_NOTICE, "Attempted to delete nonexistent schedule entry %d!\n", id); #ifdef DO_CRASH CRASH; #endif return -1; } else return 0; }

void ast_sched_dump (  const struct sched_context *  con  )

Parameters: con  Context to dump Debugging: Dump the contents of the scheduler to stderr Definition at line 305 of file sched.c. References ast_log(), ast_tvsub(), sched::callback, sched::data, sched_context::eventcnt, sched::id, LOG_DEBUG, sched::next, sched_context::schedcnt, sched_context::schedq, and sched::when. Referenced by ast_sched_add_variable(), and ast_sched_del(). { /* * Dump the contents of the scheduler to * stderr */ struct sched *q; struct timeval tv = ast_tvnow(); #ifdef SCHED_MAX_CACHE ast_log(LOG_DEBUG, "Asterisk Schedule Dump (%d in Q, %d Total, %d Cache)\n", con->schedcnt, con->eventcnt - 1, con->schedccnt); #else ast_log(LOG_DEBUG, "Asterisk Schedule Dump (%d in Q, %d Total)\n", con->schedcnt, con->eventcnt - 1); #endif ast_log(LOG_DEBUG, "=============================================================\n"); ast_log(LOG_DEBUG, "|ID Callback Data Time (sec:ms) |\n"); ast_log(LOG_DEBUG, "+-----+-----------------+-----------------+-----------------+\n"); for (q = con->schedq; q; q = q->next) { struct timeval delta = ast_tvsub(q->when, tv); ast_log(LOG_DEBUG, "|%.4d | %-15p | %-15p | %.6ld : %.6ld |\n", q->id, q->callback, q->data, delta.tv_sec, (long int)delta.tv_usec); } ast_log(LOG_DEBUG, "=============================================================\n"); }

int ast_sched_runq (  struct sched_context *  con  )

Parameters: con  Scheduling context to run Run the queue, executing all callbacks which need to be performed at this time. Returns the number of events processed. Definition at line 336 of file sched.c. References ast_log(), ast_mutex_lock(), ast_mutex_unlock(), ast_tvadd(), sched::callback, sched::data, DEBUG, sched_context::lock, LOG_DEBUG, sched::next, sched::resched, sched_release(), sched_settime(), sched_context::schedcnt, sched_context::schedq, schedule(), SOONER, sched::variable, and sched::when. Referenced by background_detect_exec(), do_cdr(), do_monitor(), do_refresh(), network_thread(), and reload_config(). { /* * Launch all events which need to be run at this time. */ struct sched *current; struct timeval tv; int x=0; int res; DEBUG(ast_log(LOG_DEBUG, "ast_sched_runq()\n")); ast_mutex_lock(&con->lock); for(;;) { if (!con->schedq) break; /* schedule all events which are going to expire within 1ms. * We only care about millisecond accuracy anyway, so this will * help us get more than one event at one time if they are very * close together. */ tv = ast_tvadd(ast_tvnow(), ast_tv(0, 1000)); if (SOONER(con->schedq->when, tv)) { current = con->schedq; con->schedq = con->schedq->next; con->schedcnt--; /* * At this point, the schedule queue is still intact. We * have removed the first event and the rest is still there, * so it's permissible for the callback to add new events, but * trying to delete itself won't work because it isn't in * the schedule queue. If that's what it wants to do, it * should return 0. */ ast_mutex_unlock(&con->lock); res = current->callback(current->data); ast_mutex_lock(&con->lock); if (res) { /* * If they return non-zero, we should schedule them to be * run again. */ if (sched_settime(&current->when, current->variable? res : current->resched)) { sched_release(con, current); } else schedule(con, current); } else { /* No longer needed, so release it */ sched_release(con, current); } x++; } else break; } ast_mutex_unlock(&con->lock); return x; }

int ast_sched_wait (  struct sched_context *  con  )

Parameters: con  context to act upon 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. Returns "-1" if there is nothing there are no scheduled events (and thus the poll should not timeout) Definition at line 158 of file sched.c. References ast_log(), ast_mutex_lock(), ast_mutex_unlock(), DEBUG, sched_context::lock, LOG_DEBUG, sched_context::schedq, and sched::when. Referenced by ast_waitstream(), ast_waitstream_exten(), ast_waitstream_fr(), ast_waitstream_full(), background_detect_exec(), do_cdr(), do_monitor(), do_refresh(), and network_thread(). { /* * Return the number of milliseconds * until the next scheduled event */ int ms; DEBUG(ast_log(LOG_DEBUG, "ast_sched_wait()\n")); ast_mutex_lock(&con->lock); if (!con->schedq) { ms = -1; } else { ms = ast_tvdiff_ms(con->schedq->when, ast_tvnow()); if (ms < 0) ms = 0; } ast_mutex_unlock(&con->lock); return ms; }

long ast_sched_when (  struct sched_context *  con, int  id )

Parameters: con  Context to use id  Id to dump Definition at line 397 of file sched.c. References ast_log(), ast_mutex_lock(), ast_mutex_unlock(), DEBUG, sched::id, sched_context::lock, LOG_DEBUG, sched::next, s, sched_context::schedq, and sched::when. Referenced by _sip_show_peer(), handle_cli_status(), and parse_register_contact(). { struct sched *s; long secs; DEBUG(ast_log(LOG_DEBUG, "ast_sched_when()\n")); ast_mutex_lock(&con->lock); s=con->schedq; while (s!=NULL) { if (s->id==id) break; s=s->next; } secs=-1; if (s!=NULL) { struct timeval now = ast_tvnow(); secs=s->when.tv_sec-now.tv_sec; } ast_mutex_unlock(&con->lock); return secs; }

static struct sched* sched_alloc (  struct sched_context *  con  )  [static]

Definition at line 123 of file sched.c. References malloc. Referenced by ast_sched_add_variable(). { /* * We keep a small cache of schedule entries * to minimize the number of necessary malloc()'s */ struct sched *tmp; #ifdef SCHED_MAX_CACHE if (con->schedc) { tmp = con->schedc; con->schedc = con->schedc->next; con->schedccnt--; } else #endif tmp = malloc(sizeof(struct sched)); return tmp; }

struct sched_context* sched_context_create (  void   )

New schedule context Definition at line 79 of file sched.c. References ast_mutex_init(), and malloc. Referenced by ast_cdr_engine_init(), ast_channel_alloc(), dnsmgr_init(), and load_module(). { struct sched_context *tmp; tmp = malloc(sizeof(struct sched_context)); if (tmp) { memset(tmp, 0, sizeof(struct sched_context)); ast_mutex_init(&tmp->lock); tmp->eventcnt = 1; tmp->schedcnt = 0; tmp->schedq = NULL; #ifdef SCHED_MAX_CACHE tmp->schedc = NULL; tmp->schedccnt = 0; #endif } return tmp; }

void sched_context_destroy (  struct sched_context *  c  )

Parameters: c  Context to free Destroys (free's) the given sched_context structure Returns 0 on success, -1 on failure Definition at line 97 of file sched.c. References ast_mutex_destroy(), ast_mutex_lock(), ast_mutex_unlock(), free, sched_context::lock, sched::next, s, and sched_context::schedq. Referenced by __unload_module(), ast_channel_free(), ast_hangup(), and unload_module(). { struct sched *s, *sl; ast_mutex_lock(&con->lock); #ifdef SCHED_MAX_CACHE /* Eliminate the cache */ s = con->schedc; while(s) { sl = s; s = s->next; free(sl); } #endif /* And the queue */ s = con->schedq; while(s) { sl = s; s = s->next; free(sl); } /* And the context */ ast_mutex_unlock(&con->lock); ast_mutex_destroy(&con->lock); free(con); }

static void sched_release (  struct sched_context *  con, struct sched *  tmp )  [static]

Definition at line 141 of file sched.c. References free, sched::next, and SCHED_MAX_CACHE. Referenced by ast_sched_add_variable(), ast_sched_del(), and ast_sched_runq(). { /* * Add to the cache, or just free() if we * already have too many cache entries */ #ifdef SCHED_MAX_CACHE if (con->schedccnt < SCHED_MAX_CACHE) { tmp->next = con->schedc; con->schedc = tmp; con->schedccnt++; } else #endif free(tmp); }

static int sched_settime (  struct timeval *  tv, int  when )  [static]

Definition at line 209 of file sched.c. References ast_log(), ast_tvadd(), and LOG_DEBUG. Referenced by ast_sched_add_variable(), and ast_sched_runq(). { struct timeval now = ast_tvnow(); /*ast_log(LOG_DEBUG, "TV -> %lu,%lu\n", tv->tv_sec, tv->tv_usec);*/ if (ast_tvzero(*tv)) /* not supplied, default to now */ *tv = now; *tv = ast_tvadd(*tv, ast_samp2tv(when, 1000)); if (ast_tvcmp(*tv, now) < 0) { ast_log(LOG_DEBUG, "Request to schedule in the past?!?!\n"); *tv = now; } return 0; }

static void schedule (  struct sched_context *  con, struct sched *  s )  [static]

Definition at line 180 of file sched.c. References last, sched::next, sched_context::schedcnt, sched_context::schedq, SOONER, and sched::when. Referenced by ast_sched_add_variable(), and ast_sched_runq(). { /* * Take a sched structure and put it in the * queue, such that the soonest event is * first in the list. */ struct sched *last=NULL; struct sched *current=con->schedq; while(current) { if (SOONER(s->when, current->when)) break; last = current; current = current->next; } /* Insert this event into the schedule */ s->next = current; if (last) last->next = s; else con->schedq = s; con->schedcnt++; }

---