sched.h File Reference

Scheduler Routines (derived from cheops). More...

This graph shows which files directly or indirectly include this file:

Go to the source code of this file.

Data Structures
struct	ast_cb_names
Defines
#define	ast_sched_add_object(obj, con, when, callback)   ast_sched_add((con),(when),(callback), ASTOBJ_REF((obj)))
	Convenience macro for objects and reference (add).
#define	AST_SCHED_CB(a)   ((ast_sched_cb)(a))
#define	AST_SCHED_DEL(sched, id)
	a loop construct to ensure that the scheduled task get deleted. The idea is that if we loop attempting to remove the scheduled task, then whatever callback had been running will complete and reinsert the task into the scheduler.
#define	ast_sched_del_object(obj, destructor, con, id)
	Convenience macro for objects and reference (del).
#define	AST_SCHED_DEL_SPINLOCK(sched, id, lock)
	schedule task to get deleted releasing the lock between attempts
#define	AST_SCHED_DEL_UNREF(sched, id, refcall)
	schedule task to get deleted and call unref function
#define	AST_SCHED_REPLACE(id, sched, when, callback, data)   AST_SCHED_REPLACE_VARIABLE(id, sched, when, callback, data, 0)
#define	AST_SCHED_REPLACE_UNREF(id, sched, when, callback, data, unrefcall, addfailcall, refcall)   AST_SCHED_REPLACE_VARIABLE_UNREF(id, sched, when, callback, data, 0, unrefcall, addfailcall, refcall)
#define	AST_SCHED_REPLACE_VARIABLE(id, sched, when, callback, data, variable)
#define	AST_SCHED_REPLACE_VARIABLE_UNREF(id, sched, when, callback, data, variable, unrefcall, addfailcall, refcall)
#define	ast_sched_thread_del(st, id)
	Delete a scheduler entry.
#define	SCHED_MAX_CACHE   128
	Max num of schedule structs.
Typedefs
typedef int(*	ast_sched_cb )(const void *data)
	callback for a cheops scheduler A cheops scheduler callback takes a pointer with callback data and
Functions
int	ast_sched_add (struct sched_context *con, int when, ast_sched_cb callback, const void *data) attribute_warn_unused_result
	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) attribute_warn_unused_result
	Schedule callback(data) to happen when ms into the future.
int	ast_sched_del (struct sched_context *con, int id) attribute_warn_unused_result
	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).
void	ast_sched_dump (struct sched_context *con)
	Dumps the scheduler contents Debugging: Dump the contents of the scheduler to stderr.
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) attribute_warn_unused_result
	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) attribute_warn_unused_result
	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)
	Runs the queue.
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) attribute_warn_unused_result
	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.
struct sched_context *	sched_context_create (void)
	New schedule context.
void	sched_context_destroy (struct sched_context *c)
	destroys a schedule context Destroys (free's) the given sched_context structure

---

Detailed Description

Scheduler Routines (derived from cheops).

Definition in file sched.h.

---

Define Documentation

#define ast_sched_add_object	(	obj,
		con,
		when,
		callback		)	ast_sched_add((con),(when),(callback), ASTOBJ_REF((obj)))

Convenience macro for objects and reference (add).

Definition at line 295 of file sched.h.

#define AST_SCHED_CB

(

a

)

((ast_sched_cb)(a))

Definition at line 161 of file sched.h.

#define AST_SCHED_DEL	(	sched,
		id		)

a loop construct to ensure that the scheduled task get deleted. The idea is that if we loop attempting to remove the scheduled task, then whatever callback had been running will complete and reinsert the task into the scheduler.

Since macro expansion essentially works like pass-by-name parameter passing, this macro will still work correctly even if the id of the task to delete changes. This holds as long as the name of the id which could change is passed to the macro and not a copy of the value of the id.

Definition at line 51 of file sched.h.

Referenced by __oh323_destroy(), __oh323_update_info(), __sip_reliable_xmit(), __sip_semi_ack(), ack_trans(), ast_closestream(), ast_rtcp_write_rr(), ast_rtcp_write_sr(), ast_rtp_destroy(), ast_rtp_stop(), ast_sched_replace(), ast_sched_replace_variable(), build_gateway(), build_peer(), destroy_packet(), destroy_packets(), destroy_peer(), destroy_trans(), dialog_unlink_all(), dnsmgr_start_refresh(), do_reload(), filestream_destructor(), handle_command_response(), handle_request_cancel(), mgcpsock_read(), misdn_tasks_remove(), qualify_peer(), receive_digit(), sip_hangup(), sip_registry_destroy(), sip_send_all_mwi_subscriptions(), sip_subscribe_mwi_destroy(), and submit_unscheduled_batch().

#define ast_sched_del_object	(	obj,
		destructor,
		con,
		id		)

Convenience macro for objects and reference (del).

Definition at line 301 of file sched.h.

#define AST_SCHED_DEL_SPINLOCK	(	sched,
		id,
		lock		)

schedule task to get deleted releasing the lock between attempts

Since:

1.6.1

Definition at line 86 of file sched.h.

Referenced by iax2_destroy_helper().

#define AST_SCHED_DEL_UNREF	(	sched,
		id,
		refcall		)

schedule task to get deleted and call unref function

See also:

AST_SCHED_DEL

Since:

1.6.1

Definition at line 69 of file sched.h.

Referenced by __sip_destroy(), build_peer(), dialog_unlink_all(), handle_request_do(), handle_response_invite(), handle_response_register(), interpret_t38_parameters(), parse_register_contact(), reload_config(), restart_session_timer(), send_response(), sip_hangup(), sip_poke_peer(), sip_unregister(), stop_session_timer(), and update_provisional_keepalive().

#define AST_SCHED_REPLACE	(	id,
		sched,
		when,
		callback,
		data		)	AST_SCHED_REPLACE_VARIABLE(id, sched, when, callback, data, 0)

Definition at line 113 of file sched.h.

#define AST_SCHED_REPLACE_UNREF	(	id,
		sched,
		when,
		callback,
		data,
		unrefcall,
		addfailcall,
		refcall		)	AST_SCHED_REPLACE_VARIABLE_UNREF(id, sched, when, callback, data, 0, unrefcall, addfailcall, refcall)

Definition at line 137 of file sched.h.

Referenced by handle_response_peerpoke(), handle_response_register(), realtime_peer(), reg_source_db(), sip_call(), sip_poke_all_peers(), sip_poke_noanswer(), sip_poke_peer(), sip_send_all_registers(), and transmit_register().

#define AST_SCHED_REPLACE_VARIABLE	(	id,
		sched,
		when,
		callback,
		data,
		variable		)

Definition at line 102 of file sched.h.

Referenced by __sip_reliable_xmit().

#define AST_SCHED_REPLACE_VARIABLE_UNREF	(	id,
		sched,
		when,
		callback,
		data,
		variable,
		unrefcall,
		addfailcall,
		refcall		)

Note:

Not currently used in the source?

Since:

1.6.1

Definition at line 120 of file sched.h.

#define ast_sched_thread_del	(	st,
		id		)

Value:

({ \
   struct sched_context *__tmp_context = ast_sched_thread_get_context(st); \
   AST_SCHED_DEL(__tmp_context, id); \
})

Delete a scheduler entry.

This uses the AST_SCHED_DEL macro internally.

Parameters:

	st	the handle to the scheduler and thread
	id	scheduler entry id to delete

Return values:

	0	success
	non-zero	failure

Definition at line 403 of file sched.h.

Referenced by build_peer(), delete_users(), iax2_destroy_helper(), iax2_frame_free(), iax2_poke_peer(), iax2_sched_replace(), make_trunk(), realtime_peer(), reg_source_db(), schedule_delivery(), socket_process(), unlink_peer(), and update_registry().

#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 37 of file sched.h.

Referenced by sched_release().

---

Typedef Documentation

typedef int(* ast_sched_cb)(const void *data)

callback for a cheops scheduler A cheops scheduler callback takes a pointer with callback data and

Returns:

returns a 0 if it should not be run again, or non-zero if it should be rescheduled to run again

Definition at line 160 of file sched.h.

---

Function Documentation

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.

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 439 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(), do_register(), do_reload(), dundi_discover(), dundi_query(), dundi_send(), handle_command_response(), handle_request_invite(), handle_response_invite(), handle_response_subscribe(), mgcp_postrequest(), parse_register_contact(), populate_addr(), precache_trans(), qualify_peer(), queue_request(), receive_digit(), rtp_red_init(), sip_scheddestroy(), sip_send_all_mwi_subscriptions(), 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 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

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

{
   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
   ast_mutex_unlock(&con->lock);

   return res;
}

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

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 461 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(), DEBUG, sched::id, sched_context::lock, LOG_WARNING, option_debug, s, sched_context::sched_heap, sched_release(), sched_context::schedcnt, and sched_context::schedq_ht.

Referenced by __sip_ack(), and sip_cancel_destroy().

{
   struct sched *s, tmp = {
      .id = id,
   };

   DEBUG(ast_debug(1, "ast_sched_del(%d)\n", id));
   
   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
   ast_mutex_unlock(&con->lock);

   if (!s) {
      ast_debug(1, "Attempted to delete nonexistent schedule entry %d!\n", id);
#ifndef AST_DEVMODE
      ast_assert(s != NULL);
#else
      _ast_assert(0, "s != NULL", file, line, function);
#endif
      return -1;
   }
   
   return 0;
}

void ast_sched_dump

(

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 546 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(), 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 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 444 of file sched.c.

References ast_hashtab_lookup(), sched::data, sched::id, and 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 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 431 of file sched.c.

References ast_sched_add(), and AST_SCHED_DEL.

{
   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 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 387 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 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 508 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().

{
   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 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 581 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().

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

   DEBUG(ast_debug(1, "ast_sched_runq()\n"));
      
   ast_mutex_lock(&con->lock);

   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.
       */
      when = ast_tvadd(ast_tvnow(), ast_tv(0, 1000));
      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_thread_add	(	struct ast_sched_thread *	st,
		int	when,
		ast_sched_cb	cb,
		const void *	data
	)

Add a scheduler entry.

Parameters:

	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

Return values:

	-1	Failure
	>=0	Sched ID of added task

Definition at line 203 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 iax2_hangup(), iax2_key_rotate(), iax2_sched_add(), and iax2_sched_replace().

{
   int res;

   ast_mutex_lock(&st->lock);
   res = ast_sched_add(st->context, when, cb, data);
   if (res != -1) {
      ast_cond_signal(&st->cond);
   }
   ast_mutex_unlock(&st->lock);

   return res;
}

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.

Parameters:

	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.

Return values:

	-1	Failure
	>=0	Sched ID of added task

Definition at line 188 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.

{
   int res;

   ast_mutex_lock(&st->lock);
   res = ast_sched_add_variable(st->context, when, cb, data, variable);
   if (res != -1) {
      ast_cond_signal(&st->cond);
   }
   ast_mutex_unlock(&st->lock);

   return res;
}

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.

Return values:

	NULL	error
	non-NULL	a handle to the scheduler and its dedicated thread.

Definition at line 160 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 load_module().

{
   struct ast_sched_thread *st;

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

   ast_mutex_init(&st->lock);
   ast_cond_init(&st->cond, NULL);

   st->thread = AST_PTHREADT_NULL;

   if (!(st->context = sched_context_create())) {
      ast_log(LOG_ERROR, "Failed to create scheduler\n");
      ast_sched_thread_destroy(st);
      return NULL;
   }
   
   if (ast_pthread_create_background(&st->thread, NULL, sched_run, st)) {
      ast_log(LOG_ERROR, "Failed to create scheduler thread\n");
      ast_sched_thread_destroy(st);
      return NULL;
   }

   return st;
}

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.

Parameters:

st

the handle to the scheduler and thread

Returns:

NULL for convenience

Definition at line 136 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(), and load_module().

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

   ast_mutex_destroy(&st->lock);
   ast_cond_destroy(&st->cond);

   if (st->context) {
      sched_context_destroy(st->context);
      st->context = NULL;
   }

   ast_free(st);

   return NULL;
}

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.

Parameters:

st

the handle to the scheduler and thread

Returns:

the sched_context associated with an ast_sched_thread

Definition at line 131 of file sched.c.

References ast_sched_thread::context.

Referenced by iax2_destroy_helper().

{
   return st->context;
}

void ast_sched_thread_poke

(

struct ast_sched_thread *

st

)

Force re-processing of the scheduler context.

Parameters:

st

the handle to the scheduler and thread

Returns:

nothing

Definition at line 124 of file sched.c.

References ast_cond_signal(), ast_mutex_lock(), ast_mutex_unlock(), ast_sched_thread::cond, and ast_sched_thread::lock.

Referenced by iax2_transmit().

{
   ast_mutex_lock(&st->lock);
   ast_cond_signal(&st->cond);
   ast_mutex_unlock(&st->lock);
}

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 327 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, s, 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 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 645 of file sched.c.

References ast_debug, ast_hashtab_lookup(), ast_mutex_lock(), ast_mutex_unlock(), ast_tvnow(), DEBUG, sched::id, sched_context::lock, s, 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;
}

struct sched_context* sched_context_create

(

void

)

[read]

New schedule context.

Note:

Create a scheduling context

Returns:

Returns a malloc'd sched_context structure, NULL on failure

Definition at line 239 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().

{
   struct 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)))) {
      sched_context_destroy(tmp);
      return NULL;
   }

   return tmp;
}

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 260 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, s, sched_context::sched_heap, sched_context::schedc, and sched_context::schedq_ht.

Referenced by __ast_channel_alloc_ap(), ast_channel_free(), ast_hangup(), ast_sched_thread_destroy(), load_module(), misdn_tasks_destroy(), sched_context_create(), and unload_module().

{
   struct sched *s;

   ast_mutex_lock(&con->lock);

#ifdef SCHED_MAX_CACHE
   /* Eliminate the 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;
   
   /* And the context */
   ast_mutex_unlock(&con->lock);
   ast_mutex_destroy(&con->lock);
   ast_free(con);
}