sched.c File Reference

#include <stdio.h>
#include <stdlib.h>
#include <sys/time.h>
#include <unistd.h>
#include <string.h>
#include <asterisk/sched.h>
#include <asterisk/logger.h>
#include <asterisk/channel.h>
#include <asterisk/lock.h>

Go to the source code of this file.

Defines
#define	DEBUG(a)
#define	SOONER(a, b)
Functions
sched_context *	sched_context_create (void)
	New schedule context.
void	sched_context_destroy (struct sched_context *con)
	destroys a schedule context
int	ast_sched_wait (struct sched_context *con)
	Determines number of seconds until the next outstanding event to take place.
int	ast_sched_add (struct sched_context *con, int when, ast_sched_cb callback, void *data)
	Adds a scheduled event.
int	ast_sched_del (struct sched_context *con, int id)
	Deletes a scheduled event.
void	ast_sched_dump (struct sched_context *con)
	Dumps the scheduler contents.
int	ast_sched_runq (struct sched_context *con)
	Runs the queue.

---

Define Documentation

#define DEBUG (  a   )

Definition at line 17 of file sched.c.

#define SOONER (  a, b   )

Value: (((b).tv_sec > (a).tv_sec) || \ (((b).tv_sec == (a).tv_sec) && ((b).tv_usec > (a).tv_usec))) Definition at line 32 of file sched.c. Referenced by ast_sched_runq().

---

Function Documentation

int ast_sched_add (  struct sched_context *  con, int  when, ast_sched_cb  callback, void *  data )

Adds a scheduled event. Parameters: con  Schduler 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 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) Returns 0 on success, -1 on failure Definition at line 232 of file sched.c. References ast_log(), ast_mutex_lock, ast_mutex_unlock, sched::callback, sched::data, DEBUG, sched_context::eventcnt, sched::id, sched_context::lock, LOG_DEBUG, LOG_NOTICE, sched::resched, and sched::when. { /* * Schedule callback(data) to happen when ms into the future */ struct sched *tmp; int res = -1; DEBUG(ast_log(LOG_DEBUG, "ast_sched_add()\n")); if (!when) { ast_log(LOG_NOTICE, "Scheduled event in 0 ms?\n"); return -1; } ast_mutex_lock(&con->lock); if ((tmp = sched_alloc(con))) { tmp->id = con->eventcnt++; tmp->callback = callback; tmp->data = data; tmp->resched = when; tmp->when.tv_sec = 0; tmp->when.tv_usec = 0; if (sched_settime(&tmp->when, when)) { sched_release(con, tmp); } else { schedule(con, tmp); res = tmp->id; } } ast_mutex_unlock(&con->lock); return res; }

int ast_sched_del (  struct sched_context *  con, int  id )

Deletes a scheduled event. Parameters: con  scheduling context to delete item from id  ID of the scheduled item to delete Remove this event from being run. A procedure should not remove its own event, but return 0 instead. Returns 0 on success, -1 on failure Definition at line 263 of file sched.c. References ast_log(), ast_mutex_lock, ast_mutex_unlock, CRASH, DEBUG, sched_context::lock, LOG_DEBUG, LOG_NOTICE, sched::next, sched_context::schedcnt, and sched_context::schedq. Referenced by ast_closestream(). { /* * Delete the schedule entry with number * "id". It's nearly impossible that there * would be two or more in the list with that * id. */ struct sched *last=NULL, *s; DEBUG(ast_log(LOG_DEBUG, "ast_sched_del()\n")); ast_mutex_lock(&con->lock); s = con->schedq; while(s) { if (s->id == id) { if (last) last->next = s->next; else con->schedq = s->next; con->schedcnt--; sched_release(con, s); break; } last = s; s = s->next; } ast_mutex_unlock(&con->lock); if (!s) { ast_log(LOG_NOTICE, "Attempted to delete non-existant schedule entry %d!\n", id); #ifdef DO_CRASH CRASH; #endif return -1; } else return 0; }

void ast_sched_dump (  struct sched_context *  con  )

Dumps the scheduler contents. Parameters: con  Context to dump Debugging: Dump the contents of the scheduler to stderr Definition at line 299 of file sched.c. References ast_log(), sched::callback, sched::data, sched_context::eventcnt, sched::id, LOG_DEBUG, sched::next, sched_context::schedq, and sched::when. { /* * Dump the contents of the scheduler to * stderr */ struct sched *q; struct timeval tv; time_t s, ms; gettimeofday(&tv, NULL); #ifdef SCHED_MAX_CACHE ast_log(LOG_DEBUG, "Asterisk Schedule Dump (%d in Q, %d Total, %d Cache)\n", con-> schedcnt, con->eventcnt - 1, con->schedccnt); #else ast_log(LOG_DEBUG, "Asterisk Schedule Dump (%d in Q, %d Total)\n", con-> schedcnt, con->eventcnt - 1); #endif ast_log(LOG_DEBUG, "=================================================\n"); ast_log(LOG_DEBUG, "|ID Callback Data Time (sec:ms) |\n"); ast_log(LOG_DEBUG, "+-----+-----------+-----------+-----------------+\n"); q = con->schedq; while(q) { s = q->when.tv_sec - tv.tv_sec; ms = q->when.tv_usec - tv.tv_usec; if (ms < 0) { ms += 1000000; s--; } ast_log(LOG_DEBUG, "|%.4d | %p | %p | %.6ld : %.6ld |\n", q->id, q->callback, q->data, (long)s, (long)ms); q=q->next; } ast_log(LOG_DEBUG, "=================================================\n"); }

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. Returns the number of events processed. Definition at line 340 of file sched.c. References ast_log(), ast_mutex_lock, ast_mutex_unlock, sched::callback, sched::data, DEBUG, sched_context::lock, LOG_DEBUG, LOG_NOTICE, sched::next, sched::resched, sched_context::schedcnt, sched_context::schedq, SOONER, and sched::when. { /* * Launch all events which need to be run at this time. */ struct sched *current; struct timeval tv; int x=0; int res; DEBUG(ast_log(LOG_DEBUG, "ast_sched_runq()\n")); ast_mutex_lock(&con->lock); for(;;) { if (!con->schedq) break; if (gettimeofday(&tv, NULL)) { /* This should never happen */ ast_log(LOG_NOTICE, "gettimeofday() failed!\n"); break; } /* 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. */ tv.tv_usec += 1000; if (SOONER(con->schedq->when, tv)) { current = con->schedq; con->schedq = con->schedq->next; 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->resched)) { sched_release(con, current); } else schedule(con, current); } else { /* No longer needed, so release it */ sched_release(con, current); } x++; } else break; } ast_mutex_unlock(&con->lock); return x; }

int ast_sched_wait (  struct sched_context *  con  )

Determines number of seconds until the next outstanding event to take place. Parameters: con  context to act upon 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. Returns "-1" if there is nothing there are no scheduled events (and thus the poll should not timeout) Definition at line 141 of file sched.c. References ast_log(), ast_mutex_lock, ast_mutex_unlock, DEBUG, sched_context::lock, LOG_DEBUG, sched_context::schedq, and sched::when. Referenced by ast_waitstream(), ast_waitstream_fr(), and ast_waitstream_full(). { /* * Return the number of milliseconds * until the next scheduled event */ struct timeval tv; int ms; DEBUG(ast_log(LOG_DEBUG, "ast_sched_wait()\n")); ast_mutex_lock(&con->lock); if (!con->schedq) { ms = -1; } else if (gettimeofday(&tv, NULL) < 0) { /* This should never happen */ ms = 0; } else { ms = (con->schedq->when.tv_sec - tv.tv_sec) * 1000; ms += (con->schedq->when.tv_usec - tv.tv_usec) / 1000; if (ms < 0) ms = 0; } ast_mutex_unlock(&con->lock); return ms; }

struct sched_context* sched_context_create (  void   )

New schedule context. Definition at line 62 of file sched.c. References malloc. Referenced by ast_channel_alloc(). { struct sched_context *tmp; tmp = malloc(sizeof(struct sched_context)); if (tmp) { memset(tmp, 0, sizeof(struct sched_context)); ast_mutex_init(&tmp->lock); tmp->eventcnt = 1; tmp->schedcnt = 0; tmp->schedq = NULL; #ifdef SCHED_MAX_CACHE tmp->schedc = NULL; tmp->schedccnt = 0; #endif } return tmp; }

void sched_context_destroy (  struct sched_context *  c  )

destroys a schedule context Parameters: c  Context to free Destroys (free's) the given sched_context structure Returns 0 on success, -1 on failure Definition at line 80 of file sched.c. References ast_mutex_destroy, ast_mutex_lock, ast_mutex_unlock, free, sched_context::lock, sched::next, s, and sched_context::schedq. Referenced by ast_hangup(). { struct sched *s, *sl; ast_mutex_lock(&con->lock); #ifdef SCHED_MAX_CACHE /* Eliminate the cache */ s = con->schedc; while(s) { sl = s; s = s->next; free(sl); } #endif /* And the queue */ s = con->schedq; while(s) { sl = s; s = s->next; free(sl); } /* And the context */ ast_mutex_unlock(&con->lock); ast_mutex_destroy(&con->lock); free(con); }

---