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

Macros
#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) More...
#define	AST_SCHED_CB(a)   ((ast_sched_cb)(a))
#define	AST_SCHED_DEL(sched, id)
	Remove a scheduler entry. More...
#define	AST_SCHED_DEL_ACCESSOR(sched, obj, getter, setter)
#define	ast_sched_del_object(obj, destructor, con, id)
	Convenience macro for objects and reference (del) More...
#define	AST_SCHED_DEL_SPINLOCK(sched, id, lock)
	schedule task to get deleted releasing the lock between attempts More...
#define	AST_SCHED_DEL_UNREF(sched, id, refcall)
	schedule task to get deleted and call unref function More...
#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)

Typedefs
typedef int(*	ast_sched_cb) (const void *data)
	scheduler callback More...

Functions
int	ast_sched_add (struct ast_sched_context *con, int when, ast_sched_cb callback, const void *data) attribute_warn_unused_result
	Adds a scheduled event. More...
int	ast_sched_add_variable (struct ast_sched_context *con, int when, ast_sched_cb callback, const void *data, int variable) attribute_warn_unused_result
	Adds a scheduled event with rescheduling support. More...
void	ast_sched_clean_by_callback (struct ast_sched_context *con, ast_sched_cb match, ast_sched_cb cleanup_cb)
	Clean all scheduled events with matching callback. More...
struct ast_sched_context *	ast_sched_context_create (void)
	Create a scheduler context. More...
void	ast_sched_context_destroy (struct ast_sched_context *c)
	destroys a schedule context More...
int	ast_sched_del (struct ast_sched_context *con, int id) attribute_warn_unused_result
	Deletes a scheduled event. More...
void	ast_sched_dump (struct ast_sched_context *con)
	Dumps the scheduler contents. More...
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. More...
int	ast_sched_replace (int old_id, struct ast_sched_context *con, int when, ast_sched_cb callback, const void *data) attribute_warn_unused_result
	replace a scheduler entry More...
int	ast_sched_replace_variable (int old_id, struct ast_sched_context *con, int when, ast_sched_cb callback, const void *data, int variable) attribute_warn_unused_result
	replace a scheduler entry More...
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. More...
int	ast_sched_runq (struct ast_sched_context *con)
	Runs the queue. More...
int	ast_sched_start_thread (struct ast_sched_context *con)
	Start a thread for processing scheduler entries. More...
int	ast_sched_wait (struct ast_sched_context *con) attribute_warn_unused_result
	Determines number of seconds until the next outstanding event to take place. More...
long	ast_sched_when (struct ast_sched_context *con, int id)
	Returns the number of seconds before an event takes place. More...

Detailed Description

Scheduler Routines (derived from cheops)

Definition in file sched.h.

Macro Definition Documentation

ast_sched_add_object

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

AST_SCHED_CB

#define AST_SCHED_CB

(

a

)

((ast_sched_cb)(a))

Definition at line 176 of file sched.h.

AST_SCHED_DEL

#define AST_SCHED_DEL	(		sched,
			id
	)

Remove a scheduler entry.

This is 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 46 of file sched.h.

Referenced by ack_trans(), apply_negotiated_sdp_stream(), ast_rtp_destroy(), ast_rtp_stop(), ast_sched_replace(), ast_sched_replace_variable(), build_gateway(), build_peer(), delete_users(), destroy_packet(), destroy_packets(), destroy_peer(), destroy_trans(), dnsmgr_start_refresh(), do_reload(), esc_entry_destructor(), handle_command_response(), handle_sip_publish_remove(), iax2_delete_from_sched(), iax2_destroy_helper(), iax2_frame_free(), iax2_poke_peer(), make_trunk(), mgcpsock_read(), misdn_tasks_remove(), qualify_peer(), realtime_peer(), reg_source_db(), sip_cc_agent_stop_offer_timer(), sip_cc_monitor_cancel_available_timer(), socket_process_helper(), start_batch_mode(), stream_stop(), unlink_peer(), and update_registry().

AST_SCHED_DEL_ACCESSOR

#define AST_SCHED_DEL_ACCESSOR	(		sched,
			obj,
			getter,
			setter
	)

Definition at line 59 of file sched.h.

Referenced by filestream_close().

ast_sched_del_object

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

Convenience macro for objects and reference (del)

Definition at line 349 of file sched.h.

AST_SCHED_DEL_SPINLOCK

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

AST_SCHED_DEL_UNREF

#define AST_SCHED_DEL_UNREF	(		sched,
			id,
			refcall
	)

schedule task to get deleted and call unref function

Only calls unref function if the delete succeeded.

See also

AST_SCHED_DEL

Since

1.6.1

Definition at line 80 of file sched.h.

Referenced by __cleanup_registration(), __shutdown_mwi_subscription(), __start_mwi_subscription(), __start_register_timeout(), __start_reregister_timeout(), __start_t38_abort_timer(), __stop_provisional_keepalive(), __stop_register_timeout(), __stop_reinvite_retry(), __stop_reinviteid(), __stop_retrans_pkt(), __stop_t38_abort_timer(), __update_provisional_keepalive_full(), ast_dns_resolve_recurring_cancel(), ast_rtp_stop(), build_peer(), do_cancel_destroy(), do_dialog_unlink_sched_items(), do_stop_session_timer(), handle_response_invite(), parse_register_contact(), peer_sched_cleanup(), pubsub_on_rx_publish_request(), remove_all_from_cache(), rtcp_debug_test_addr(), schedule_cache_expiration(), sip_poke_peer(), and sip_unregister().

AST_SCHED_REPLACE

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

Definition at line 125 of file sched.h.

Referenced by schedule_calendar_event().

AST_SCHED_REPLACE_UNREF

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

Referenced by build_peer(), handle_response_peerpoke(), handle_sip_publish_modify(), handle_sip_publish_refresh(), pubsub_on_rx_publish_request(), realtime_peer(), reg_source_db(), sip_call(), sip_keepalive_all_peers(), sip_poke_all_peers(), sip_poke_noanswer(), sip_poke_peer(), and sip_send_keepalive().

AST_SCHED_REPLACE_VARIABLE

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

Definition at line 114 of file sched.h.

AST_SCHED_REPLACE_VARIABLE_UNREF

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

Typedef Documentation

ast_sched_cb

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

scheduler callback

A scheduler callback takes a pointer with callback data and

Return values

0	if the callback should not be rescheduled
non-zero	if the callback should be scheduled again

Definition at line 175 of file sched.h.

Function Documentation

ast_sched_add()

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 565 of file sched.c.

References ast_sched_add_variable().

Referenced by __sip_scheddestroy(), __start_mwi_subscription(), __start_register_timeout(), __start_reregister_timeout(), __start_session_timer(), __start_t38_abort_timer(), __update_provisional_keepalive_full(), ast_readaudio_callback(), ast_readvideo_callback(), ast_rtp_interpret(), ast_sched_replace(), ast_sip_schedule_task(), AST_TEST_DEFINE(), build_peer(), cc_generic_agent_start_offer_timer(), cc_generic_monitor_request_cc(), cleanup_registration(), create_esc_entry(), dialog_unlink_all(), dns_query_recurring_resolution_callback(), do_register(), dundi_discover(), dundi_query(), dundi_send(), handle_cli_sched_bench(), handle_command_response(), handle_keepalive_message(), handle_response_invite(), iax2_hangup(), iax2_key_rotate(), iax2_sched_add(), mbl_call(), memory_cache_stale_update_full(), memory_cache_stale_update_object(), mgcp_postrequest(), network_change_stasis_cb(), parse_register_contact(), populate_addr(), precache_trans(), qualify_peer(), rtcp_debug_test_addr(), rtp_instance_parse_transport_wide_cc(), rtp_raw_write(), rtp_red_init(), run_task(), sched_check_pendings(), schedule_cache_expiration(), schedule_notification(), shutdown_mwi_subscription(), sip_cancel_destroy(), sip_cc_agent_start_offer_timer(), sip_cc_monitor_request_cc(), sip_hangup(), sip_scheddestroy_full(), skinny_sched_add(), skinny_session(), start_mwi_subscription(), start_register_timeout(), start_reregister_timeout(), start_session_timer(), start_t38_abort_timer(), stop_provisional_keepalive(), stop_register_timeout(), stop_reinvite_retry(), stop_reinviteid(), stop_retrans_pkt(), stop_session_timer(), stop_t38_abort_timer(), and update_provisional_keepalive().

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

ast_sched_add_variable()

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

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

Adds a scheduled event with rescheduling support.

Definition at line 524 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, sched::deleted, ast_sched_context::eventcnt, sched_id::id, ast_sched_context::lock, sched::resched, sched_alloc(), sched::sched_id, sched_settime(), ast_sched_context::sched_thread, schedule(), tmp(), sched::variable, and sched::when.

Referenced by __sip_reliable_xmit(), _misdn_tasks_add_variable(), apply_negotiated_sdp_stream(), ast_sched_add(), ast_sched_replace_variable(), dnsmgr_start_refresh(), do_reload(), global_loaded(), monitored_transport_state_callback(), start_batch_mode(), 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))) {
      con->eventcnt++;
      tmp->callback = callback;
      tmp->data = data;
      tmp->resched = when;
      tmp->variable = variable;
      tmp->when = ast_tv(0, 0);
      tmp->deleted = 0;

      sched_settime(&tmp->when, when);
      schedule(con, tmp);
      res = tmp->sched_id->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
   if (con->sched_thread) {
      ast_cond_signal(&con->sched_thread->cond);
   }
   ast_mutex_unlock(&con->lock);

   return res;
}

ast_sched_clean_by_callback()

void ast_sched_clean_by_callback	(	struct ast_sched_context *	con,
		ast_sched_cb	match,
		ast_sched_cb	cleanup_cb
	)

Clean all scheduled events with matching callback.

Parameters

con	Scheduler Context
match	Callback to match
cleanup_cb	Callback to run

Note

The return of cleanup_cb is ignored. No events are rescheduled.

Definition at line 407 of file sched.c.

References ast_heap_peek(), ast_heap_remove(), ast_mutex_lock, ast_mutex_unlock, sched::callback, cleanup_cb(), sched::data, ast_sched_context::lock, ast_sched_context::sched_heap, and sched_release().

Referenced by __unload_module(), ast_sip_destroy_transport_management(), and global_loaded().

{
   int i = 1;
   struct sched *current;

   ast_mutex_lock(&con->lock);
   while ((current = ast_heap_peek(con->sched_heap, i))) {
      if (current->callback != match) {
         i++;
         continue;
      }

      ast_heap_remove(con->sched_heap, current);

      cleanup_cb(current->data);
      sched_release(con, current);
   }
   ast_mutex_unlock(&con->lock);
}

ast_sched_context_create()

struct ast_sched_context* ast_sched_context_create

(

void

)

Create a scheduler context.

Returns

Returns a malloc'd sched_context structure, NULL on failure

Definition at line 236 of file sched.c.

References ast_calloc, ast_heap_create, AST_LIST_HEAD_INIT_NOLOCK, ast_mutex_init, ast_sched_context_destroy(), ast_sched_context::eventcnt, ast_sched_context::id_queue, ast_sched_context::lock, NULL, ast_sched_context::sched_heap, sched_time_cmp(), and tmp().

Referenced by __ast_channel_alloc_ap(), ast_sip_initialize_distributor(), ast_sip_initialize_scheduler(), ast_sip_initialize_transport_management(), AST_TEST_DEFINE(), dns_core_init(), handle_cli_sched_bench(), load_module(), mbl_load_device(), 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;

   AST_LIST_HEAD_INIT_NOLOCK(&tmp->id_queue);

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

ast_sched_context_destroy()

void ast_sched_context_destroy

(

struct ast_sched_context *

c

)

destroys a schedule context

Parameters

c	Context to free

Definition at line 269 of file sched.c.

References ast_free, ast_heap_destroy(), ast_heap_pop(), AST_LIST_REMOVE_HEAD, ast_mutex_destroy, ast_mutex_lock, ast_mutex_unlock, ast_sched_context::id_queue, sched_id::list, ast_sched_context::lock, NULL, sched_free(), ast_sched_context::sched_heap, ast_sched_context::sched_thread, sched_thread_destroy(), and ast_sched_context::schedc.

Referenced by __unload_module(), ast_channel_destructor(), ast_hangup(), ast_sched_context_create(), ast_sched_context_destroy_wrapper(), ast_sip_destroy_distributor(), ast_sip_destroy_scheduler(), ast_sip_destroy_transport_management(), ast_sip_initialize_scheduler(), ast_sip_initialize_transport_management(), AST_TEST_DEFINE(), cdr_engine_shutdown(), dns_shutdown(), handle_cli_sched_bench(), load_module(), mbl_load_device(), misdn_tasks_destroy(), stun_start_monitor(), stun_stop_monitor(), and unload_module().

{
   struct sched *s;
   struct sched_id *sid;

   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))) {
      sched_free(s);
   }
#endif

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

   while ((sid = AST_LIST_REMOVE_HEAD(&con->id_queue, list))) {
      ast_free(sid);
   }

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

   ast_free(con);
}

ast_sched_del()

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

Deletes a scheduled event.

Definition at line 610 of file sched.c.

References ast_cond_signal, ast_cond_wait, ast_debug, ast_heap_remove(), ast_log, ast_log_backtrace(), ast_mutex_lock, ast_mutex_unlock, ast_sched_dump(), ast_threadstorage_get(), sched::callback, sched::cond, sched_thread::cond, ast_sched_context::currently_executing, DEBUG, sched::deleted, ast_sched_context::executing_thread_id, sched_id::id, last_del_id, ast_sched_context::lock, LOG_ERROR, LOG_WARNING, NULL, sched_find(), ast_sched_context::sched_heap, sched::sched_id, sched_release(), and ast_sched_context::sched_thread.

Referenced by ast_rtp_prop_set(), ast_rtp_stop(), ast_sip_sched_task_cancel(), AST_TEST_DEFINE(), cc_generic_agent_stop_offer_timer(), cc_generic_monitor_cancel_available_timer(), destroy_event(), handle_cli_sched_bench(), handle_keepalive_message(), skinny_register(), skinny_sched_del(), and skinny_session_cleanup().

{
   struct sched *s = NULL;
   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 = sched_find(con, id);
   if (s) {
      if (!ast_heap_remove(con->sched_heap, s)) {
         ast_log(LOG_WARNING,"sched entry %d not in the sched heap?\n", s->sched_id->id);
      }
      sched_release(con, s);
   } else if (con->currently_executing && (id == con->currently_executing->sched_id->id)) {
      if (con->executing_thread_id == pthread_self()) {
         /* The scheduled callback is trying to delete itself.
          * Not good as that is a deadlock. */
         ast_log(LOG_ERROR,
            "BUG! Trying to delete sched %d from within the callback %p.  "
            "Ignoring so we don't deadlock\n",
            id, con->currently_executing->callback);
         ast_log_backtrace();
         /* We'll return -1 below because s is NULL.
          * The caller will rightly assume that the unscheduling failed. */
      } else {
         s = con->currently_executing;
         s->deleted = 1;
         /* Wait for executing task to complete so that the caller of
          * ast_sched_del() does not free memory out from under the task. */
         while (con->currently_executing && (id == con->currently_executing->sched_id->id)) {
            ast_cond_wait(&s->cond, &con->lock);
         }
         /* Do not sched_release() here because ast_sched_runq() will do it */
      }
   }

#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
   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);
      /* Removing nonexistent schedule entry shouldn't trigger assert (it was enabled in DEV_MODE);
       * because in many places entries is deleted without having valid id. */
      *last_id = id;
      return -1;
   } else if (!s) {
      return -1;
   }

   return 0;
}

ast_sched_dump()

void ast_sched_dump

(

struct ast_sched_context *

con

)

Dumps the scheduler contents.

Debugging: Dump the contents of the scheduler to stderr

Parameters

con	Context to dump

Dumps the scheduler contents.

Definition at line 712 of file sched.c.

References ast_heap_peek(), ast_heap_size(), ast_log, ast_mutex_lock, ast_mutex_unlock, ast_tvnow(), ast_tvsub(), DEBUG_ATLEAST, ast_sched_context::eventcnt, ast_sched_context::highwater, ast_sched_context::lock, LOG_DEBUG, ast_sched_context::sched_heap, and ast_sched_context::schedccnt.

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

{
   struct sched *q;
   struct timeval when;
   int x;
   size_t heap_size;

   if (!DEBUG_ATLEAST(1)) {
      return;
   }

   when = ast_tvnow();
#ifdef SCHED_MAX_CACHE
   ast_log(LOG_DEBUG, "Asterisk Schedule Dump (%zu in Q, %u Total, %u Cache, %u high-water)\n",
      ast_heap_size(con->sched_heap), con->eventcnt - 1, con->schedccnt, con->highwater);
#else
   ast_log(LOG_DEBUG, "Asterisk Schedule Dump (%zu in Q, %u Total, %u high-water)\n",
      ast_heap_size(con->sched_heap), con->eventcnt - 1, con->highwater);
#endif

   ast_log(LOG_DEBUG, "=============================================================\n");
   ast_log(LOG_DEBUG, "|ID    Callback          Data              Time  (sec:ms)   |\n");
   ast_log(LOG_DEBUG, "+-----+-----------------+-----------------+-----------------+\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_log(LOG_DEBUG, "|%.4d | %-15p | %-15p | %.6ld : %.6ld |\n",
         q->sched_id->id,
         q->callback,
         q->data,
         (long)delta.tv_sec,
         (long int)delta.tv_usec);
   }
   ast_mutex_unlock(&con->lock);
   ast_log(LOG_DEBUG, "=============================================================\n");
}

ast_sched_find_data()

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 587 of file sched.c.

References ast_mutex_lock, ast_mutex_unlock, sched::data, ast_sched_context::lock, NULL, and sched_find().

{
   struct sched *s;
   const void *data = NULL;

   ast_mutex_lock(&con->lock);

   s = sched_find(con, id);
   if (s) {
      data = s->data;
   }

   ast_mutex_unlock(&con->lock);

   return data;
}

ast_sched_replace()

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

ast_sched_replace_variable()

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

ast_sched_report()

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 674 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, and ast_sched_context::sched_heap.

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 = %u\n schedcnt = %zu\n", con->highwater, ast_heap_size(con->sched_heap));

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

ast_sched_runq()

int ast_sched_runq

(

struct ast_sched_context *

con

)

Runs the queue.

Run the queue, executing all callbacks which need to be performed at this time.

Parameters

con	Scheduling context to run
con	context to act upon

Returns

Returns the number of events processed.

Runs the queue.

Definition at line 755 of file sched.c.

References ast_cond_signal, ast_debug, ast_heap_peek(), ast_heap_pop(), ast_mutex_lock, ast_mutex_unlock, ast_tv(), ast_tvadd(), ast_tvcmp(), ast_tvnow(), sched::callback, sched::cond, ast_sched_context::currently_executing, sched::data, DEBUG, sched::deleted, ast_sched_context::executing_thread_id, ast_sched_context::lock, NULL, sched::resched, ast_sched_context::sched_heap, sched_release(), sched_settime(), schedule(), sched::variable, and sched::when.

Referenced by AST_TEST_DEFINE(), background_detect_exec(), dial_exec_full(), do_cdr(), do_monitor(), do_monitor_headset(), do_refresh(), handle_speechrecognize(), misdn_tasks_thread_func(), network_thread(), reload_config(), sched_run(), speech_background(), unload_module(), 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);

      /*
       * 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.
       */

      con->currently_executing = current;
      con->executing_thread_id = pthread_self();
      ast_mutex_unlock(&con->lock);
      res = current->callback(current->data);
      ast_mutex_lock(&con->lock);
      con->currently_executing = NULL;
      ast_cond_signal(&current->cond);

      if (res && !current->deleted) {
         /*
          * If they return non-zero, we should schedule them to be
          * run again.
          */
         sched_settime(&current->when, current->variable ? res : current->resched);
         schedule(con, current);
      } else {
         /* No longer needed, so release it */
         sched_release(con, current);
      }
   }

   ast_mutex_unlock(&con->lock);

   return numevents;
}

ast_sched_start_thread()

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 195 of file sched.c.

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

Referenced by ast_sip_initialize_distributor(), ast_sip_initialize_scheduler(), ast_sip_initialize_transport_management(), dns_core_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;
}

ast_sched_wait()

int ast_sched_wait

(

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

Determines number of seconds until the next outstanding event to take place.

Definition at line 431 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 AST_TEST_DEFINE(), background_detect_exec(), dial_exec_full(), do_cdr(), do_monitor(), do_monitor_headset(), 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;
}

ast_sched_when()

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 814 of file sched.c.

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

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

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

   ast_mutex_lock(&con->lock);

   s = sched_find(con, id);
   if (s) {
      struct timeval now = ast_tvnow();
      secs = s->when.tv_sec - now.tv_sec;
   }

   ast_mutex_unlock(&con->lock);

   return secs;
}