Mon May 14 04:52:48 2007

Asterisk developer's documentation


sched.c File Reference

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

#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"

Include dependency graph for sched.c:

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)
 Deletes a scheduled event Remove this event from being run. A procedure should not remove its own event, but return 0 instead.
void ast_sched_dump (const struct sched_context *con)
 Dumps the scheduler contents Debugging: Dump the contents of the scheduler to stderr.
int ast_sched_runq (struct sched_context *con)
 Runs the queue.
int ast_sched_wait (struct sched_context *con)
 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.
long ast_sched_when (struct sched_context *con, int id)
 Returns the number of seconds before an event takes place.
static struct schedsched_alloc (struct sched_context *con)
sched_contextsched_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.


Detailed Description

Scheduler Routines (from cheops-NG).

Author:
Mark Spencer <markster@digium.com>

Definition in file sched.c.


Define Documentation

#define DEBUG (  ) 

Definition at line 36 of file sched.c.


Function Documentation

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.

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
Returns:
Returns a schedule item ID on success, -1 on failure

Definition at line 247 of file sched.c.

References ast_sched_add_variable().

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(), 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(), 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

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:
Returns a schedule item ID on success, -1 on failure

Definition at line 214 of file sched.c.

References ast_log(), ast_mutex_lock(), ast_mutex_unlock(), ast_sched_dump(), DEBUG, sched_context::eventcnt, sched_context::lock, LOG_DEBUG, LOG_NOTICE, option_debug, sched_alloc(), sched_release(), sched_settime(), and schedule().

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 
)

Deletes a scheduled event Remove this event from being run. A procedure should not remove its own event, but return 0 instead.

Parameters:
con scheduling context to delete item from
id ID of the scheduled item to delete
Returns:
Returns 0 on success, -1 on failure

Definition at line 258 of file sched.c.

References AST_LIST_REMOVE_CURRENT, AST_LIST_TRAVERSE_SAFE_BEGIN, AST_LIST_TRAVERSE_SAFE_END, ast_log(), ast_mutex_lock(), ast_mutex_unlock(), ast_sched_dump(), CRASH, DEBUG, sched_context::lock, LOG_DEBUG, option_debug, s, sched_release(), and sched_context::schedcnt.

Referenced by __oh323_destroy(), __oh323_update_info(), __sip_ack(), __sip_destroy(), __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(), 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(), 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  ) 

Dumps the scheduler contents Debugging: Dump the contents of the scheduler to stderr.

Parameters:
con Context to dump

Definition at line 295 of file sched.c.

References AST_LIST_TRAVERSE, ast_log(), ast_tvsub(), sched_context::eventcnt, LOG_DEBUG, and sched_context::schedcnt.

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  ) 

Runs the queue.

Parameters:
con Scheduling context to run Run the queue, executing all callbacks which need to be performed at this time.
con context to act upon
Returns:
Returns the number of events processed.

Definition at line 325 of file sched.c.

References AST_LIST_EMPTY, AST_LIST_FIRST, AST_LIST_REMOVE_HEAD, ast_log(), ast_mutex_lock(), ast_mutex_unlock(), ast_tvadd(), DEBUG, sched_context::lock, LOG_DEBUG, sched_release(), sched_settime(), sched_context::schedcnt, and schedule().

Referenced by background_detect_exec(), do_cdr(), do_monitor(), do_refresh(), misdn_tasks_thread_func(), network_thread(), nv_background_detect_exec(), 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(&current->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  ) 

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.

Parameters:
con context to act upon
Returns:
Returns "-1" if there is nothing there are no scheduled events (and thus the poll should not timeout)

Definition at line 148 of file sched.c.

References AST_LIST_EMPTY, AST_LIST_FIRST, ast_log(), ast_mutex_lock(), ast_mutex_unlock(), DEBUG, sched_context::lock, and LOG_DEBUG.

Referenced by background_detect_exec(), do_cdr(), do_monitor(), do_refresh(), misdn_tasks_thread_func(), network_thread(), nv_background_detect_exec(), 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.

Parameters:
con Context to use
id Id to dump

Definition at line 382 of file sched.c.

References AST_LIST_TRAVERSE, ast_log(), ast_mutex_lock(), ast_mutex_unlock(), DEBUG, sched_context::lock, LOG_DEBUG, and s.

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]

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   ) 

New schedule context.

Note:
Create a scheduling context
Returns:
Returns a malloc'd sched_context structure, NULL on failure

Definition at line 75 of file sched.c.

References ast_calloc, and ast_mutex_init().

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

Parameters:
c Context to free
Returns:
Returns 0 on success, -1 on failure

Definition at line 88 of file sched.c.

References AST_LIST_REMOVE_HEAD, ast_mutex_destroy(), ast_mutex_lock(), ast_mutex_unlock(), free, sched_context::lock, and s.

Referenced by __unload_module(), 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, s, 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 }


Generated on Mon May 14 04:52:49 2007 for Asterisk - the Open Source PBX by  doxygen 1.5.1