sched.h File Reference

Go to the source code of this file.

Defines
#define	SCHED_MAX_CACHE   128
	Max num of schedule structs.
#define	AST_SCHED_CB(a)   ((ast_sched_cb)(a))
Typedefs
typedef int(*	ast_sched_cb )(void *data)
	callback for a cheops scheduler
Functions
sched_context *	sched_context_create (void)
	New schedule context.
void	sched_context_destroy (struct sched_context *c)
	destroys a schedule context
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.
int	ast_sched_wait (struct sched_context *con)
	Determines number of seconds until the next outstanding event to take place.
int	ast_sched_runq (struct sched_context *con)
	Runs the queue.
void	ast_sched_dump (struct sched_context *con)
	Dumps the scheduler contents.

---

Define Documentation

#define AST_SCHED_CB (  a   )     ((ast_sched_cb)(a))

Definition at line 54 of file sched.h.

#define SCHED_MAX_CACHE   128

Max num of schedule structs. 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 28 of file sched.h.

---

Typedef Documentation

typedef int(* ast_sched_cb)(void *data)

callback for a cheops scheduler A cheops scheduler callback takes a pointer with callback data and returns a 0 if it should not be run again, or non-zero if it should be rescheduled to run again Definition at line 53 of file sched.h. Referenced by ast_sched_add().

---

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 229 of file sched.c. References ast_log(), ast_mutex_lock, ast_mutex_unlock, ast_sched_cb, DEBUG, sched_context::eventcnt, sched_context::lock, LOG_DEBUG, and LOG_NOTICE. { /* * 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 260 of file sched.c. References ast_log(), ast_mutex_lock, ast_mutex_unlock, CRASH, DEBUG, sched_context::lock, LOG_DEBUG, LOG_NOTICE, sched::next, s, 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 296 of file sched.c. References ast_log(), sched_context::eventcnt, LOG_DEBUG, s, and sched_context::schedq. { /* * 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 337 of file sched.c. References ast_log(), ast_mutex_lock, ast_mutex_unlock, DEBUG, sched_context::lock, LOG_DEBUG, LOG_NOTICE, sched::next, sched_context::schedcnt, sched_context::schedq, SOONER, and sched::when. Referenced by ast_waitstream(), ast_waitstream_fr(), and ast_waitstream_full(). { /* * 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 138 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 61 of file sched.c. References ast_mutex_init, and malloc. Referenced by ast_channel_alloc(). { struct sched_context *tmp; tmp = malloc(sizeof(struct sched_context)); if (tmp) { 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 78 of file sched.c. References ast_mutex_lock, ast_mutex_unlock, free, sched_context::lock, 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); free(con); }

---