sched.c File Reference

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"

Include dependency graph for sched.c:

Go to the source code of this file.

Data Structures
struct	ast_sched_context
struct	sched
struct	sched_thread
Defines
#define	DEBUG(a)
#define	SCHED_MAX_CACHE   128
	Max num of schedule structs.
Functions
static void	__init_last_del_id (void)
int	ast_sched_add (struct ast_sched_context *con, int when, ast_sched_cb callback, const void *data)
	Adds a scheduled event.
int	ast_sched_add_variable (struct ast_sched_context *con, int when, ast_sched_cb callback, const void *data, int variable)
	Schedule callback(data) to happen when ms into the future.
struct ast_sched_context *	ast_sched_context_create (void)
	Create a scheduler context.
void	ast_sched_context_destroy (struct ast_sched_context *con)
	destroys a schedule context
int	ast_sched_del (struct ast_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 ast_sched_context *con)
	Dump the contents of the scheduler to LOG_DEBUG.
const void *	ast_sched_find_data (struct ast_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 ast_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 ast_sched_context *con, int when, ast_sched_cb callback, const void *data, int variable)
	replace a scheduler entry
void	ast_sched_report (struct ast_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 ast_sched_context *con)
	Launch all events which need to be run at this time.
int	ast_sched_start_thread (struct ast_sched_context *con)
	Start a thread for processing scheduler entries.
int	ast_sched_wait (struct ast_sched_context *con)
	Return the number of milliseconds until the next scheduled event.
long	ast_sched_when (struct ast_sched_context *con, int id)
	Returns the number of seconds before an event takes place.
static struct sched *	sched_alloc (struct ast_sched_context *con)
static int	sched_cmp (const void *a, const void *b)
static unsigned int	sched_hash (const void *obj)
static void	sched_release (struct ast_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 void	sched_thread_destroy (struct ast_sched_context *con)
static int	sched_time_cmp (void *a, void *b)
static void	schedule (struct ast_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 , }

---

Detailed Description

Scheduler Routines (from cheops-NG)

Author:

Mark Spencer <markster@digium.com>

Definition in file sched.c.

---

Define Documentation

#define DEBUG

(

a

)

Definition at line 41 of file sched.c.

Referenced by ast_sched_add_variable(), ast_sched_del(), ast_sched_runq(), ast_sched_wait(), and ast_sched_when().

#define SCHED_MAX_CACHE   128

Max num of schedule structs.

Note:

The max number of schedule structs to keep around for use. Undefine to disable schedule structure caching. (Only disable this on very low memory machines)

Definition at line 64 of file sched.c.

Referenced by sched_release().

---

Function Documentation

static void __init_last_del_id

(

void

)

[static]

Definition at line 66 of file sched.c.

{

int ast_sched_add	(	struct ast_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

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 417 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(), build_peer(), cc_generic_agent_start_offer_timer(), cc_generic_monitor_request_cc(), create_esc_entry(), do_register(), do_reload(), dtls_srtp_setup(), dundi_discover(), dundi_query(), dundi_send(), handle_command_response(), handle_request_invite(), handle_response_invite(), handle_response_subscribe(), iax2_hangup(), iax2_key_rotate(), iax2_sched_add(), 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(), skinny_sched_add(), start_session_timer(), submit_scheduled_batch(), submit_unscheduled_batch(), transmit_register(), and update_provisional_keepalive().

{
   return ast_sched_add_variable(con, when, callback, data, 0);
}

int ast_sched_add_variable	(	struct ast_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.

Definition at line 374 of file sched.c.

References ast_cond_signal, ast_debug, ast_mutex_lock, ast_mutex_unlock, ast_sched_dump(), ast_tv(), sched::callback, sched_thread::cond, sched::data, DEBUG, ast_sched_context::eventcnt, sched::id, ast_sched_context::lock, option_debug, sched::resched, sched_alloc(), sched_release(), sched_settime(), ast_sched_context::sched_thread, schedule(), sched::variable, and sched::when.

Referenced by _misdn_tasks_add_variable(), ast_sched_add(), ast_sched_replace_variable(), dnsmgr_start_refresh(), do_reload(), and stun_start_monitor().

{
   struct sched *tmp;
   int res = -1;

   DEBUG(ast_debug(1, "ast_sched_add()\n"));

   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. */
   if (option_debug)
      ast_sched_dump(con);
#endif
   if (con->sched_thread) {
      ast_cond_signal(&con->sched_thread->cond);
   }
   ast_mutex_unlock(&con->lock);

   return res;
}

struct ast_sched_context* ast_sched_context_create

(

void

)

[read]

Create a scheduler context.

Returns:

Returns a malloc'd sched_context structure, NULL on failure

Definition at line 210 of file sched.c.

References sched::__heap_index, ast_calloc, ast_hashtab_create(), ast_hashtab_newsize_java(), ast_hashtab_resize_java(), ast_heap_create(), ast_mutex_init, ast_sched_context_destroy(), ast_sched_context::eventcnt, ast_sched_context::lock, sched_cmp(), sched_hash(), ast_sched_context::sched_heap, sched_time_cmp(), and ast_sched_context::schedq_ht.

Referenced by __ast_channel_alloc_ap(), ast_cc_init(), ast_cdr_engine_init(), dnsmgr_init(), load_module(), misdn_tasks_init(), and stun_start_monitor().

{
   struct ast_sched_context *tmp;

   if (!(tmp = ast_calloc(1, sizeof(*tmp)))) {
      return NULL;
   }

   ast_mutex_init(&tmp->lock);
   tmp->eventcnt = 1;

   tmp->schedq_ht = ast_hashtab_create(23, sched_cmp, ast_hashtab_resize_java, ast_hashtab_newsize_java, sched_hash, 1);

   if (!(tmp->sched_heap = ast_heap_create(8, sched_time_cmp,
         offsetof(struct sched, __heap_index)))) {
      ast_sched_context_destroy(tmp);
      return NULL;
   }

   return tmp;
}

void ast_sched_context_destroy

(

struct ast_sched_context *

c

)

destroys a schedule context

Parameters:

c	Context to free

Definition at line 232 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::list, ast_sched_context::lock, ast_sched_context::sched_heap, ast_sched_context::sched_thread, sched_thread_destroy(), ast_sched_context::schedc, and ast_sched_context::schedq_ht.

Referenced by __unload_module(), ast_channel_destructor(), ast_hangup(), ast_sched_context_create(), cc_shutdown(), cdr_engine_shutdown(), dnsmgr_shutdown(), load_module(), misdn_tasks_destroy(), stun_start_monitor(), stun_stop_monitor(), and unload_module().

{
   struct sched *s;

   sched_thread_destroy(con);
   con->sched_thread = NULL;

   ast_mutex_lock(&con->lock);

#ifdef SCHED_MAX_CACHE
   while ((s = AST_LIST_REMOVE_HEAD(&con->schedc, list))) {
      ast_free(s);
   }
#endif

   if (con->sched_heap) {
      while ((s = ast_heap_pop(con->sched_heap))) {
         ast_free(s);
      }
      ast_heap_destroy(con->sched_heap);
      con->sched_heap = NULL;
   }

   ast_hashtab_destroy(con->schedq_ht, NULL);
   con->schedq_ht = NULL;

   ast_mutex_unlock(&con->lock);
   ast_mutex_destroy(&con->lock);

   ast_free(con);
}

int ast_sched_del	(	struct ast_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.

Definition at line 439 of file sched.c.

References ast_assert, ast_cond_signal, 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(), sched_thread::cond, DEBUG, sched::id, last_del_id, ast_sched_context::lock, LOG_WARNING, option_debug, ast_sched_context::sched_heap, sched_release(), ast_sched_context::sched_thread, ast_sched_context::schedcnt, and ast_sched_context::schedq_ht.

Referenced by __sip_ack(), ast_rtp_prop_set(), ast_rtp_stop(), cc_generic_agent_stop_offer_timer(), cc_generic_monitor_cancel_available_timer(), destroy_event(), and skinny_sched_del().

{
   struct sched *s, tmp = {
      .id = id,
   };
   int *last_id = ast_threadstorage_get(&last_del_id, sizeof(int));

   DEBUG(ast_debug(1, "ast_sched_del(%d)\n", id));

   if (id < 0) {
      return 0;
   }

   ast_mutex_lock(&con->lock);
   s = ast_hashtab_lookup(con->schedq_ht, &tmp);
   if (s) {
      if (!ast_heap_remove(con->sched_heap, s)) {
         ast_log(LOG_WARNING,"sched entry %d not in the sched heap?\n", s->id);
      }

      if (!ast_hashtab_remove_this_object(con->schedq_ht, s)) {
         ast_log(LOG_WARNING,"Found sched entry %d, then couldn't remove it?\n", s->id);
      }

      con->schedcnt--;

      sched_release(con, s);
   }

#ifdef DUMP_SCHEDULER
   /* Dump contents of the context while we have the lock so nothing gets screwed up by accident. */
   if (option_debug)
      ast_sched_dump(con);
#endif
   if (con->sched_thread) {
      ast_cond_signal(&con->sched_thread->cond);
   }
   ast_mutex_unlock(&con->lock);

   if (!s && *last_id != id) {
      ast_debug(1, "Attempted to delete nonexistent schedule entry %d!\n", id);
#ifndef AST_DEVMODE
      ast_assert(s != NULL);
#else
      {
      char buf[100];
      snprintf(buf, sizeof(buf), "s != NULL, id=%d", id);
      _ast_assert(0, buf, file, line, function);
      }
#endif
      *last_id = id;
      return -1;
   } else if (!s) {
      return -1;
   }

   return 0;
}

void ast_sched_dump

(

struct ast_sched_context *

con

)

Dump the contents of the scheduler to LOG_DEBUG.

Dumps the scheduler contents.

Definition at line 539 of file sched.c.

References ast_debug, ast_heap_peek(), ast_heap_size(), ast_mutex_lock, ast_mutex_unlock, ast_tvnow(), ast_tvsub(), ast_sched_context::eventcnt, ast_sched_context::highwater, ast_sched_context::lock, ast_sched_context::sched_heap, ast_sched_context::schedccnt, and ast_sched_context::schedcnt.

Referenced by ast_sched_add_variable(), ast_sched_del(), handle_dump_sched(), sip_do_reload(), and unload_module().

{
   struct sched *q;
   struct timeval when = ast_tvnow();
   int x;
   size_t heap_size;
#ifdef SCHED_MAX_CACHE
   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);
#else
   ast_debug(1, "Asterisk Schedule Dump (%d in Q, %d Total, %d high-water)\n", con->schedcnt, con->eventcnt - 1, con->highwater);
#endif

   ast_debug(1, "=============================================================\n");
   ast_debug(1, "|ID    Callback          Data              Time  (sec:ms)   |\n");
   ast_debug(1, "+-----+-----------------+-----------------+-----------------+\n");
   ast_mutex_lock(&con->lock);
   heap_size = ast_heap_size(con->sched_heap);
   for (x = 1; x <= heap_size; x++) {
      struct timeval delta;
      q = ast_heap_peek(con->sched_heap, x);
      delta = ast_tvsub(q->when, when);
      ast_debug(1, "|%.4d | %-15p | %-15p | %.6ld : %.6ld |\n",
         q->id,
         q->callback,
         q->data,
         (long)delta.tv_sec,
         (long int)delta.tv_usec);
   }
   ast_mutex_unlock(&con->lock);
   ast_debug(1, "=============================================================\n");
}

const void* ast_sched_find_data	(	struct ast_sched_context *	con,
		int	id
	)

Find a sched structure and return the data field associated with it.

Parameters:

con	scheduling context in which to search fro the matching id
id	ID of the scheduled item to find

Returns:

the data field from the matching sched struct if found; else return NULL if not found.

Since:

1.6.1

Definition at line 422 of file sched.c.

References ast_hashtab_lookup(), sched::data, sched::id, and ast_sched_context::schedq_ht.

{
   struct sched tmp,*res;
   tmp.id = id;
   res = ast_hashtab_lookup(con->schedq_ht, &tmp);
   if (res)
      return res->data;
   return NULL;
}

int ast_sched_replace	(	int	old_id,
		struct ast_sched_context *	con,
		int	when,
		ast_sched_cb	callback,
		const void *	data
	)

replace a scheduler entry

Deprecated:

You should use the AST_SCHED_REPLACE() macro instead.

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.

Return values:

-1	failure
otherwise,returns	scheduled item ID

Definition at line 409 of file sched.c.

References ast_sched_add(), and AST_SCHED_DEL.

Referenced by iax2_sched_replace().

{
   if (old_id > -1) {
      AST_SCHED_DEL(con, old_id);
   }
   return ast_sched_add(con, when, callback, data);
}

int ast_sched_replace_variable	(	int	old_id,
		struct ast_sched_context *	con,
		int	when,
		ast_sched_cb	callback,
		const void *	data,
		int	variable
	)

replace a scheduler entry

Deprecated:

You should use the AST_SCHED_REPLACE_VARIABLE() macro instead.

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.

Return values:

-1	failure
otherwise,returns	scheduled item ID

Definition at line 362 of file sched.c.

References ast_sched_add_variable(), and AST_SCHED_DEL.

{
   /* 0 means the schedule item is new; do not delete */
   if (old_id > 0) {
      AST_SCHED_DEL(con, old_id);
   }
   return ast_sched_add_variable(con, when, callback, data, variable);
}

void ast_sched_report	(	struct ast_sched_context *	con,
		struct ast_str **	buf,
		struct ast_cb_names *	cbnames
	)

Show statics on what it is in the schedule queue.

Parameters:

con	Schedule context to check
buf	dynamic string to store report
cbnames	to check against

Since:

1.6.1

Definition at line 501 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, ast_sched_context::highwater, ast_cb_names::list, ast_sched_context::lock, ast_cb_names::numassocs, ast_sched_context::sched_heap, and ast_sched_context::schedcnt.

Referenced by sip_show_sched().

{
   int i, x;
   struct sched *cur;
   int countlist[cbnames->numassocs + 1];
   size_t heap_size;

   memset(countlist, 0, sizeof(countlist));
   ast_str_set(buf, 0, " Highwater = %d\n schedcnt = %d\n", con->highwater, con->schedcnt);

   ast_mutex_lock(&con->lock);

   heap_size = ast_heap_size(con->sched_heap);
   for (x = 1; x <= heap_size; x++) {
      cur = ast_heap_peek(con->sched_heap, x);
      /* match the callback to the cblist */
      for (i = 0; i < cbnames->numassocs; i++) {
         if (cur->callback == cbnames->cblist[i]) {
            break;
         }
      }
      if (i < cbnames->numassocs) {
         countlist[i]++;
      } else {
         countlist[cbnames->numassocs]++;
      }
   }

   ast_mutex_unlock(&con->lock);

   for (i = 0; i < cbnames->numassocs; i++) {
      ast_str_append(buf, 0, "    %s : %d\n", cbnames->list[i], countlist[i]);
   }

   ast_str_append(buf, 0, "   <unknown> : %d\n", countlist[cbnames->numassocs]);
}

int ast_sched_runq

(

struct ast_sched_context *

con

)

Launch all events which need to be run at this time.

Runs the queue.

Definition at line 574 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, ast_sched_context::lock, LOG_ERROR, sched::resched, ast_sched_context::sched_heap, sched_release(), sched_settime(), ast_sched_context::schedcnt, ast_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().

{
   struct sched *current;
   struct timeval when;
   int numevents;
   int res;

   DEBUG(ast_debug(1, "ast_sched_runq()\n"));

   ast_mutex_lock(&con->lock);

   when = ast_tvadd(ast_tvnow(), ast_tv(0, 1000));
   for (numevents = 0; (current = ast_heap_peek(con->sched_heap, 1)); numevents++) {
      /* 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.
       */
      if (ast_tvcmp(current->when, when) != -1) {
         break;
      }

      current = ast_heap_pop(con->sched_heap);

      if (!ast_hashtab_remove_this_object(con->schedq_ht, current)) {
         ast_log(LOG_ERROR,"Sched entry %d was in the schedq list but not in the hashtab???\n", current->id);
      }

      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);
      }
   }

   ast_mutex_unlock(&con->lock);

   return numevents;
}

int ast_sched_start_thread

(

struct ast_sched_context *

con

)

Start a thread for processing scheduler entries.

Parameters:

con	the scheduler context this thread will manage

Return values:

0	success
non-zero	failure

Definition at line 163 of file sched.c.

References ast_calloc, ast_cond_init, ast_log(), ast_pthread_create_background, AST_PTHREADT_NULL, sched_thread::cond, LOG_ERROR, sched_run(), ast_sched_context::sched_thread, sched_thread_destroy(), and sched_thread::thread.

Referenced by ast_cc_init(), load_module(), and stun_start_monitor().

{
   struct sched_thread *st;

   if (con->sched_thread) {
      ast_log(LOG_ERROR, "Thread already started on this scheduler context\n");
      return -1;
   }

   if (!(st = ast_calloc(1, sizeof(*st)))) {
      return -1;
   }

   ast_cond_init(&st->cond, NULL);

   st->thread = AST_PTHREADT_NULL;

   con->sched_thread = st;

   if (ast_pthread_create_background(&st->thread, NULL, sched_run, con)) {
      ast_log(LOG_ERROR, "Failed to create scheduler thread\n");
      sched_thread_destroy(con);
      return -1;
   }

   return 0;
}

int ast_sched_wait

(

struct ast_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.

Definition at line 302 of file sched.c.

References ast_debug, ast_heap_peek(), ast_mutex_lock, ast_mutex_unlock, ast_tvdiff_ms(), ast_tvnow(), DEBUG, ast_sched_context::lock, ast_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().

{
   int ms;
   struct sched *s;

   DEBUG(ast_debug(1, "ast_sched_wait()\n"));

   ast_mutex_lock(&con->lock);
   if ((s = ast_heap_peek(con->sched_heap, 1))) {
      ms = ast_tvdiff_ms(s->when, ast_tvnow());
      if (ms < 0) {
         ms = 0;
      }
   } else {
      ms = -1;
   }
   ast_mutex_unlock(&con->lock);

   return ms;
}

long ast_sched_when	(	struct ast_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 638 of file sched.c.

References ast_debug, ast_hashtab_lookup(), ast_mutex_lock, ast_mutex_unlock, ast_tvnow(), DEBUG, sched::id, ast_sched_context::lock, ast_sched_context::schedq_ht, and sched::when.

Referenced by _sip_show_peer(), handle_cli_status(), and parse_register_contact().

{
   struct sched *s, tmp;
   long secs = -1;
   DEBUG(ast_debug(1, "ast_sched_when()\n"));

   ast_mutex_lock(&con->lock);

   /* these next 2 lines replace a lookup loop */
   tmp.id = id;
   s = ast_hashtab_lookup(con->schedq_ht, &tmp);

   if (s) {
      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 ast_sched_context *

con

)

[static, read]

Definition at line 264 of file sched.c.

References ast_calloc, AST_LIST_REMOVE_HEAD, sched::list, ast_sched_context::schedc, and ast_sched_context::schedccnt.

Referenced by ast_sched_add_variable().

{
   struct sched *tmp;

   /*
    * We keep a small cache of schedule entries
    * to minimize the number of necessary malloc()'s
    */
#ifdef SCHED_MAX_CACHE
   if ((tmp = AST_LIST_REMOVE_HEAD(&con->schedc, list)))
      con->schedccnt--;
   else
#endif
      tmp = ast_calloc(1, sizeof(*tmp));

   return tmp;
}

static int sched_cmp	(	const void *	a,
		const void *	b
	)		[static]

Definition at line 191 of file sched.c.

References sched::id.

Referenced by ast_sched_context_create().

{
   const struct sched *as = a;
   const struct sched *bs = b;
   return as->id != bs->id; /* return 0 on a match like strcmp would */
}

static unsigned int sched_hash

(

const void *

obj

)

[static]

Definition at line 198 of file sched.c.

References sched::id.

Referenced by ast_sched_context_create().

{
   const struct sched *s = obj;
   unsigned int h = s->id;
   return h;
}

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

Definition at line 282 of file sched.c.

References ast_free, AST_LIST_INSERT_HEAD, sched::list, SCHED_MAX_CACHE, ast_sched_context::schedc, and ast_sched_context::schedccnt.

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) {
      AST_LIST_INSERT_HEAD(&con->schedc, tmp, list);
      con->schedccnt++;
   } else
#endif
      ast_free(tmp);
}

static void* sched_run

(

void *

data

)

[static]

Definition at line 100 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(), sched_thread::cond, sched::data, ast_sched_context::lock, ast_sched_context::sched_thread, and sched_thread::stop.

Referenced by ast_sched_start_thread().

{
   struct ast_sched_context *con = data;

   while (!con->sched_thread->stop) {
      int ms;
      struct timespec ts = {
         .tv_sec = 0,
      };

      ast_mutex_lock(&con->lock);

      if (con->sched_thread->stop) {
         ast_mutex_unlock(&con->lock);
         return NULL;
      }

      ms = ast_sched_wait(con);

      if (ms == -1) {
         ast_cond_wait(&con->sched_thread->cond, &con->lock);
      } else {
         struct timeval tv;
         tv = ast_tvadd(ast_tvnow(), ast_samp2tv(ms, 1000));
         ts.tv_sec = tv.tv_sec;
         ts.tv_nsec = tv.tv_usec * 1000;
         ast_cond_timedwait(&con->sched_thread->cond, &con->lock, &ts);
      }

      ast_mutex_unlock(&con->lock);

      if (con->sched_thread->stop) {
         return NULL;
      }

      ast_sched_runq(con);
   }

   return NULL;
}

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 348 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().

{
   struct timeval now = ast_tvnow();

   /*ast_debug(1, "TV -> %lu,%lu\n", tv->tv_sec, tv->tv_usec);*/
   if (ast_tvzero(*t))  /* not supplied, default to now */
      *t = now;
   *t = ast_tvadd(*t, ast_samp2tv(when, 1000));
   if (ast_tvcmp(*t, now) < 0) {
      *t = now;
   }
   return 0;
}

static void sched_thread_destroy

(

struct ast_sched_context *

con

)

[static]

Definition at line 141 of file sched.c.

References ast_cond_destroy, ast_cond_signal, ast_free, ast_mutex_lock, ast_mutex_unlock, AST_PTHREADT_NULL, sched_thread::cond, ast_sched_context::lock, ast_sched_context::sched_thread, sched_thread::stop, and sched_thread::thread.

Referenced by ast_sched_context_destroy(), and ast_sched_start_thread().

{
   if (!con->sched_thread) {
      return;
   }

   if (con->sched_thread->thread != AST_PTHREADT_NULL) {
      ast_mutex_lock(&con->lock);
      con->sched_thread->stop = 1;
      ast_cond_signal(&con->sched_thread->cond);
      ast_mutex_unlock(&con->lock);
      pthread_join(con->sched_thread->thread, NULL);
      con->sched_thread->thread = AST_PTHREADT_NULL;
   }

   ast_cond_destroy(&con->sched_thread->cond);

   ast_free(con->sched_thread);

   con->sched_thread = NULL;
}

static int sched_time_cmp	(	void *	a,
		void *	b
	)		[static]

Definition at line 205 of file sched.c.

References ast_tvcmp(), and sched::when.

Referenced by ast_sched_context_create().

{
   return ast_tvcmp(((struct sched *) b)->when, ((struct sched *) a)->when);
}

static void schedule	(	struct ast_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 329 of file sched.c.

References ast_hashtab_insert_safe(), ast_heap_push(), ast_log(), ast_sched_context::highwater, sched::id, LOG_WARNING, ast_sched_context::sched_heap, ast_sched_context::schedcnt, and ast_sched_context::schedq_ht.

Referenced by ast_sched_add_variable(), and ast_sched_runq().

{
   ast_heap_push(con->sched_heap, s);

   if (!ast_hashtab_insert_safe(con->schedq_ht, s)) {
      ast_log(LOG_WARNING,"Schedule Queue entry %d is already in table!\n", s->id);
   }

   con->schedcnt++;

   if (con->schedcnt > con->highwater) {
      con->highwater = con->schedcnt;
   }
}

---

Variable Documentation

struct ast_threadstorage last_del_id = { .once = PTHREAD_ONCE_INIT , .key_init = __init_last_del_id , .custom_init = NULL , } [static]

Definition at line 66 of file sched.c.

Referenced by ast_sched_del().