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/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_id
	Scheduler ID holder. More...
struct	sched_thread

Macros
#define	DEBUG(a)
#define	ID_QUEUE_INCREMENT   16
#define	SCHED_MAX_CACHE   128
	Max num of schedule structs. More...

Functions
static void	__init_last_del_id (void)
static int	add_ids (struct ast_sched_context *con)
	Add new scheduler IDs to the queue. More...
int	ast_sched_add (struct ast_sched_context *con, int when, ast_sched_cb callback, const void *data)
	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)
	Schedule callback(data) to happen when ms into the future. 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 *con)
	destroys a schedule context More...
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. Deprecated in favor of ast_sched_del_nonrunning which checks running event status. More...
int	ast_sched_del_nonrunning (struct ast_sched_context *con, int id)
	Delete the schedule entry with number "id". If running, wait for the task to complete, check to see if it is rescheduled then schedule the release. It's nearly impossible that there would be two or more in the list with that id. More...
void	ast_sched_dump (struct ast_sched_context *con)
	Dump the contents of the scheduler to LOG_DEBUG. 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)
	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)
	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)
	Launch all events which need to be run at this time. 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)
	Return the number of milliseconds until the next scheduled event. More...
long	ast_sched_when (struct ast_sched_context *con, int id)
	Returns the number of seconds before an event takes place. More...
static struct sched *	sched_alloc (struct ast_sched_context *con)
static struct sched *	sched_find (struct ast_sched_context *con, int id)
static void	sched_free (struct sched *task)
static void	sched_release (struct ast_sched_context *con, struct sched *tmp)
static void *	sched_run (void *data)
static void	sched_settime (struct timeval *t, int when)
	given the last event *tv and the offset in milliseconds 'when', computes the next value, More...
static void	sched_thread_destroy (struct ast_sched_context *con)
static int	sched_time_cmp (void *va, void *vb)
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. More...
static int	set_sched_id (struct ast_sched_context *con, struct sched *new_sched)

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 marks.nosp@m.ter@.nosp@m.digiu.nosp@m.m.co.nosp@m.m

Definition in file sched.c.

Macro Definition Documentation

DEBUG

#define DEBUG

(

a

)

Definition at line 36 of file sched.c.

ID_QUEUE_INCREMENT

#define ID_QUEUE_INCREMENT   16

Definition at line 305 of file sched.c.

SCHED_MAX_CACHE

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

Function Documentation

__init_last_del_id()

static void __init_last_del_id ( void  )

static

Definition at line 58 of file sched.c.

{

add_ids()

static int add_ids ( struct ast_sched_context *  con )

static

Add new scheduler IDs to the queue.

Return values

The	number of IDs added to the queue

Definition at line 312 of file sched.c.

{
    int new_size;
    int original_size;
    int i;
 
    original_size = con->id_queue_size;
    /* So we don't go overboard with the mallocs here, we'll just up
     * the size of the list by a fixed amount each time instead of
     * multiplying the size by any particular factor
     */
    new_size = original_size + ID_QUEUE_INCREMENT;
    if (new_size < 0) {
        /* Overflow. Cap it at INT_MAX. */
        new_size = INT_MAX;
    }
    for (i = original_size; i < new_size; ++i) {
        struct sched_id *new_id;
 
        new_id = ast_calloc(1, sizeof(*new_id));
        if (!new_id) {
            break;
        }
 
        /*
         * According to the API doxygen a sched ID of 0 is valid.
         * Unfortunately, 0 was never returned historically and
         * several users incorrectly coded usage of the returned
         * sched ID assuming that 0 was invalid.
         */
        new_id->id = ++con->id_queue_size;
 
        AST_LIST_INSERT_TAIL(&con->id_queue, new_id, list);
    }
 
    return con->id_queue_size - original_size;
}

References ast_calloc, AST_LIST_INSERT_TAIL, sched_id::id, ast_sched_context::id_queue, ID_QUEUE_INCREMENT, ast_sched_context::id_queue_size, and sched_id::list.

Referenced by set_sched_id().

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

Return values

-1	on failure

Returns

schedule item ID

Definition at line 567 of file sched.c.

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

References ast_sched_add_variable(), sched::callback, sched::data, and sched::when.

Referenced by 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(), dns_query_recurring_resolution_callback(), do_register(), dundi_discover(), dundi_query(), dundi_send(), handle_cli_sched_bench(), handle_command_response(), iax2_hangup(), iax2_key_rotate(), iax2_sched_add(), mbl_call(), memory_cache_stale_update_full(), memory_cache_stale_update_object(), populate_addr(), precache_trans(), qualify_peer(), rtp_instance_parse_transport_wide_cc(), rtp_raw_write(), rtp_red_init(), run_task(), schedule_cache_expiration(), schedule_notification(), and transaction_sched_timer().

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
	)

Schedule callback(data) to happen when ms into the future.

Adds a scheduled event with rescheduling support.

Definition at line 526 of file sched.c.

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

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, ast_sched_context::lock, sched_alloc(), sched_settime(), ast_sched_context::sched_thread, schedule(), tmp(), sched::variable, and sched::when.

Referenced by 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().

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

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

References ast_heap_peek(), ast_heap_remove(), ast_mutex_lock, ast_mutex_unlock, cleanup_cb(), current, ast_sched_context::lock, match(), ast_sched_context::sched_heap, and sched_release().

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

ast_sched_context_create()

struct ast_sched_context * ast_sched_context_create

(

void

)

Create a scheduler context.

Return values

NULL	on failure

Returns

a malloc'd sched_context structure

Definition at line 238 of file sched.c.

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

References ast_calloc, ast_heap_create, AST_LIST_HEAD_INIT_NOLOCK, ast_mutex_init, ast_sched_context_destroy(), NULL, sched_time_cmp(), and tmp().

Referenced by __ast_channel_alloc_ap(), aeap_general_initialize(), 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(), and stun_start_monitor().

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

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

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(), aeap_general_finalize(), 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(), stun_start_monitor(), stun_stop_monitor(), and unload_module().

ast_sched_del()

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. Deprecated in favor of ast_sched_del_nonrunning which checks running event status.

Deletes a scheduled event.

Definition at line 614 of file sched.c.

{
    return ast_sched_del_nonrunning(con, id) ? -1 : 0;
}

References ast_sched_del_nonrunning().

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(), and handle_cli_sched_bench().

ast_sched_del_nonrunning()

int ast_sched_del_nonrunning	(	struct ast_sched_context *	con,
		int	id
	)

Delete the schedule entry with number "id". If running, wait for the task to complete, check to see if it is rescheduled then schedule the release. It's nearly impossible that there would be two or more in the list with that id.

Deletes a scheduled event with care against the event running.

Definition at line 627 of file sched.c.

{
    struct sched *s = NULL;
    int *last_id = ast_threadstorage_get(&last_del_id, sizeof(int));
    int res = 0;
 
    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);
            }
            /* This is not rescheduled so the caller of ast_sched_del_nonrunning needs to know
             * that it was still deleted
             */
            if (!s->rescheduled) {
                res = -2;
            }
            /* ast_sched_runq knows we are waiting on this item and is passing responsibility for
             * its destruction to us
             */
            sched_release(con, s);
            s = NULL;
        }
    }
 
#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(res == -2){
        return res;
    }
    else 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 res;
}

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, id, sched_id::id, last_del_id, ast_sched_context::lock, LOG_ERROR, LOG_WARNING, NULL, sched::rescheduled, sched_find(), ast_sched_context::sched_heap, sched::sched_id, sched_release(), and ast_sched_context::sched_thread.

Referenced by ast_sched_del().

ast_sched_dump()

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

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

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_nonrunning(), and handle_dump_sched().

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

Return values

NULL	if not found

Returns

the data field from the matching sched struct if found.

Since

1.6.1

Definition at line 589 of file sched.c.

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

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

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	on failure

Returns

scheduled item ID

Definition at line 559 of file sched.c.

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

References ast_sched_add(), AST_SCHED_DEL, sched::callback, sched::data, and sched::when.

Referenced by iax2_sched_replace().

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	on failure

Returns

scheduled item ID

Definition at line 514 of file sched.c.

{
    /* 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);
}

References ast_sched_add_variable(), and AST_SCHED_DEL.

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

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

References ast_heap_peek(), ast_heap_size(), ast_mutex_lock, ast_mutex_unlock, ast_str_append(), ast_str_set(), buf, 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.

ast_sched_runq()

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

{
    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 (current->deleted) {
            /*
             * Another thread is waiting on this scheduled item.  That thread
             * will be responsible for it's destruction
             */
            current->rescheduled = res ? 1 : 0;
        } else if (res) {
            /*
             * 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;
}

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(), current, ast_sched_context::currently_executing, DEBUG, ast_sched_context::executing_thread_id, ast_sched_context::lock, NULL, ast_sched_context::sched_heap, sched_release(), sched_settime(), and schedule().

Referenced by AST_TEST_DEFINE(), background_detect_exec(), dial_exec_full(), do_cdr(), do_monitor(), do_monitor_headset(), do_refresh(), handle_speechrecognize(), network_thread(), sched_run(), speech_background(), wait_for_winner(), and waitstream_core().

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

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

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 aeap_general_initialize(), ast_sip_initialize_distributor(), ast_sip_initialize_scheduler(), ast_sip_initialize_transport_management(), AST_TEST_DEFINE(), dns_core_init(), load_module(), and stun_start_monitor().

ast_sched_wait()

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

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

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(), network_thread(), sched_run(), speech_background(), wait_for_winner(), and waitstream_core().

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

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

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

Referenced by handle_cli_status().

sched_alloc()

static struct sched * sched_alloc ( struct ast_sched_context *  con )

static

Definition at line 380 of file sched.c.

{
    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));
        if (!tmp) {
            return NULL;
        }
        ast_cond_init(&tmp->cond, NULL);
    }
 
    if (set_sched_id(con, tmp)) {
        sched_release(con, tmp);
        return NULL;
    }
 
    return tmp;
}

References ast_calloc, ast_cond_init, AST_LIST_REMOVE_HEAD, sched::list, NULL, sched_release(), ast_sched_context::schedc, ast_sched_context::schedccnt, set_sched_id(), and tmp().

Referenced by ast_sched_add_variable().

sched_find()

static struct sched * sched_find ( struct ast_sched_context *  con, int  id  )

static

Definition at line 572 of file sched.c.

{
    int x;
    size_t heap_size;
 
    heap_size = ast_heap_size(con->sched_heap);
    for (x = 1; x <= heap_size; x++) {
        struct sched *cur = ast_heap_peek(con->sched_heap, x);
 
        if (cur->sched_id->id == id) {
            return cur;
        }
    }
 
    return NULL;
}

References ast_heap_peek(), ast_heap_size(), sched_id::id, NULL, ast_sched_context::sched_heap, and sched::sched_id.

Referenced by ast_sched_del_nonrunning(), ast_sched_find_data(), and ast_sched_when().

sched_free()

static void sched_free ( struct sched *  task )

static

Definition at line 260 of file sched.c.

{
    /* task->sched_id will be NULL most of the time, but when the
     * scheduler context shuts down, it will free all scheduled
     * tasks, and in that case, the task->sched_id will be non-NULL
     */
    ast_free(task->sched_id);
    ast_cond_destroy(&task->cond);
    ast_free(task);
}

References ast_cond_destroy, ast_free, and task().

Referenced by ast_sched_context_destroy(), and sched_release().

sched_release()

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

static

Definition at line 360 of file sched.c.

{
    if (tmp->sched_id) {
        AST_LIST_INSERT_TAIL(&con->id_queue, tmp->sched_id, list);
        tmp->sched_id = NULL;
    }
 
    /*
     * 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
        sched_free(tmp);
}

References AST_LIST_INSERT_HEAD, AST_LIST_INSERT_TAIL, ast_sched_context::id_queue, sched_id::list, NULL, sched_free(), SCHED_MAX_CACHE, ast_sched_context::schedc, ast_sched_context::schedccnt, and tmp().

Referenced by ast_sched_clean_by_callback(), ast_sched_del_nonrunning(), ast_sched_runq(), and sched_alloc().

sched_run()

static void * sched_run ( void *  data )

static

Definition at line 134 of file sched.c.

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

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, ast_sched_context::lock, NULL, ast_sched_context::sched_thread, and sched_thread::stop.

Referenced by ast_sched_start_thread().

sched_settime()

static void 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 490 of file sched.c.

{
    struct timeval now = ast_tvnow();
 
    if (when < 0) {
        /*
         * A negative when value is likely a bug as it
         * represents a VERY large timeout time.
         */
        ast_log(LOG_WARNING,
            "Bug likely: Negative time interval %d (interpreted as %u ms) requested!\n",
            when, (unsigned int) when);
        ast_assert(0);
    }
 
    /*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;
    }
}

References ast_assert, ast_log, ast_samp2tv(), ast_tvadd(), ast_tvcmp(), ast_tvnow(), ast_tvzero(), and LOG_WARNING.

Referenced by ast_sched_add_variable(), and ast_sched_runq().

sched_thread_destroy()

static void sched_thread_destroy ( struct ast_sched_context *  con )

static

Definition at line 175 of file sched.c.

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

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, NULL, ast_sched_context::sched_thread, sched_thread::stop, and sched_thread::thread.

Referenced by ast_sched_context_destroy(), and ast_sched_start_thread().

sched_time_cmp()

static int sched_time_cmp ( void *  va, void *  vb  )

static

Definition at line 225 of file sched.c.

{
    struct sched *a = va;
    struct sched *b = vb;
    int cmp;
 
    cmp = ast_tvcmp(b->when, a->when);
    if (!cmp) {
        cmp = b->tie_breaker - a->tie_breaker;
    }
    return cmp;
}

References a, ast_tvcmp(), and b.

Referenced by ast_sched_context_create().

schedule()

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

{
    size_t size;
 
    size = ast_heap_size(con->sched_heap);
 
    /* Record the largest the scheduler heap became for reporting purposes. */
    if (con->highwater <= size) {
        con->highwater = size + 1;
    }
 
    /* Determine the tie breaker value for the new entry. */
    if (size) {
        ++con->tie_breaker;
    } else {
        /*
         * Restart the sequence for the first entry to make integer
         * roll over more unlikely.
         */
        con->tie_breaker = 0;
    }
    s->tie_breaker = con->tie_breaker;
 
    ast_heap_push(con->sched_heap, s);
}

References ast_heap_push, ast_heap_size(), ast_sched_context::highwater, ast_sched_context::sched_heap, sched::tie_breaker, and ast_sched_context::tie_breaker.

Referenced by ast_sched_add_variable(), and ast_sched_runq().

set_sched_id()

static int set_sched_id ( struct ast_sched_context *  con, struct sched *  new_sched  )

static

Definition at line 350 of file sched.c.

{
    if (AST_LIST_EMPTY(&con->id_queue) && (add_ids(con) == 0)) {
        return -1;
    }
 
    new_sched->sched_id = AST_LIST_REMOVE_HEAD(&con->id_queue, list);
    return 0;
}

References add_ids(), AST_LIST_EMPTY, AST_LIST_REMOVE_HEAD, ast_sched_context::id_queue, sched_id::list, and sched::sched_id.

Referenced by sched_alloc().

Variable Documentation

last_del_id

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

static

Definition at line 58 of file sched.c.

Referenced by ast_sched_del_nonrunning().