Asterisk - The Open Source Telephony Project  21.4.1
Data Structures | Macros | Functions | Variables
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"

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_contextast_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 schedsched_alloc (struct ast_sched_context *con)
 
static struct schedsched_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,
 
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.
 
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

#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

static int add_ids ( struct ast_sched_context con)
static

Add new scheduler IDs to the queue.

Return values
Thenumber of IDs added to the queue

Definition at line 312 of file sched.c.

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

313 {
314  int new_size;
315  int original_size;
316  int i;
317 
318  original_size = con->id_queue_size;
319  /* So we don't go overboard with the mallocs here, we'll just up
320  * the size of the list by a fixed amount each time instead of
321  * multiplying the size by any particular factor
322  */
323  new_size = original_size + ID_QUEUE_INCREMENT;
324  if (new_size < 0) {
325  /* Overflow. Cap it at INT_MAX. */
326  new_size = INT_MAX;
327  }
328  for (i = original_size; i < new_size; ++i) {
329  struct sched_id *new_id;
330 
331  new_id = ast_calloc(1, sizeof(*new_id));
332  if (!new_id) {
333  break;
334  }
335 
336  /*
337  * According to the API doxygen a sched ID of 0 is valid.
338  * Unfortunately, 0 was never returned historically and
339  * several users incorrectly coded usage of the returned
340  * sched ID assuming that 0 was invalid.
341  */
342  new_id->id = ++con->id_queue_size;
343 
344  AST_LIST_INSERT_TAIL(&con->id_queue, new_id, list);
345  }
346 
347  return con->id_queue_size - original_size;
348 }
Scheduler ID holder.
Definition: sched.c:70
int id_queue_size
Definition: sched.c:131
struct ast_sched_context::@394 id_queue
#define AST_LIST_INSERT_TAIL(head, elm, field)
Appends a list entry to the tail of a list.
Definition: linkedlists.h:731
#define ast_calloc(num, len)
A wrapper for calloc()
Definition: astmm.h:202
int id
Definition: sched.c:72
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
conScheduler context to add
whenhow many milliseconds to wait for event to occur
callbackfunction to call when the amount of time expires
datadata to pass to the callback
Return values
-1on failure
Returns
schedule item ID

Definition at line 567 of file sched.c.

References ast_sched_add_variable().

Referenced by ast_sched_replace(), ast_sip_schedule_task(), dns_query_recurring_resolution_callback(), do_register(), rtp_raw_write(), and rtp_red_init().

568 {
569  return ast_sched_add_variable(con, when, callback, data, 0);
570 }
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.
Definition: sched.c:526
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.

References ast_debug, ast_sched_dump(), ast_tv(), sched::callback, sched::data, sched::deleted, ast_sched_context::eventcnt, sched_id::id, sched::resched, sched::sched_id, sched_settime(), schedule(), sched::variable, and sched::when.

Referenced by ast_sched_add(), ast_sched_replace_variable(), dnsmgr_start_refresh(), and start_batch_mode().

527 {
528  struct sched *tmp;
529  int res = -1;
530 
531  DEBUG(ast_debug(1, "ast_sched_add()\n"));
532 
533  ast_mutex_lock(&con->lock);
534  if ((tmp = sched_alloc(con))) {
535  con->eventcnt++;
536  tmp->callback = callback;
537  tmp->data = data;
538  tmp->resched = when;
539  tmp->variable = variable;
540  tmp->when = ast_tv(0, 0);
541  tmp->deleted = 0;
542 
543  sched_settime(&tmp->when, when);
544  schedule(con, tmp);
545  res = tmp->sched_id->id;
546  }
547 #ifdef DUMP_SCHEDULER
548  /* Dump contents of the context while we have the lock so nothing gets screwed up by accident. */
549  ast_sched_dump(con);
550 #endif
551  if (con->sched_thread) {
552  ast_cond_signal(&con->sched_thread->cond);
553  }
554  ast_mutex_unlock(&con->lock);
555 
556  return res;
557 }
unsigned int deleted
Definition: sched.c:100
struct sched_id * sched_id
Definition: sched.c:79
static void sched_settime(struct timeval *t, int when)
given the last event *tv and the offset in milliseconds 'when', computes the next value...
Definition: sched.c:490
Definition: sched.c:76
int resched
Definition: sched.c:89
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...
Definition: sched.c:460
#define ast_debug(level,...)
Log a DEBUG message.
struct timeval when
Definition: sched.c:80
void ast_sched_dump(struct ast_sched_context *con)
Dump the contents of the scheduler to LOG_DEBUG.
Definition: sched.c:743
const void * data
Definition: sched.c:91
unsigned int eventcnt
Definition: sched.c:113
struct timeval ast_tv(ast_time_t sec, ast_suseconds_t usec)
Returns a timeval from sec, usec.
Definition: time.h:235
int variable
Definition: sched.c:90
ast_sched_cb callback
Definition: sched.c:92
int id
Definition: sched.c:72
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
conScheduler Context
matchCallback to match
cleanup_cbCallback to run
Note
The return of cleanup_cb is ignored. No events are rescheduled.

Definition at line 409 of file sched.c.

References ast_heap_peek(), ast_heap_remove(), sched::callback, and sched::data.

410 {
411  int i = 1;
412  struct sched *current;
413 
414  ast_mutex_lock(&con->lock);
415  while ((current = ast_heap_peek(con->sched_heap, i))) {
416  if (current->callback != match) {
417  i++;
418  continue;
419  }
420 
421  ast_heap_remove(con->sched_heap, current);
422 
423  cleanup_cb(current->data);
424  sched_release(con, current);
425  }
426  ast_mutex_unlock(&con->lock);
427 }
Definition: sched.c:76
const void * data
Definition: sched.c:91
void * ast_heap_remove(struct ast_heap *h, void *elm)
Remove a specific element from a heap.
Definition: heap.c:251
void * ast_heap_peek(struct ast_heap *h, unsigned int index)
Peek at an element on a heap.
Definition: heap.c:267
ast_sched_cb callback
Definition: sched.c:92
struct ast_sched_context* ast_sched_context_create ( void  )

Create a scheduler context.

Return values
NULLon failure
Returns
a malloc'd sched_context structure

Definition at line 238 of file sched.c.

References ast_calloc, ast_heap_create, AST_LIST_HEAD_INIT_NOLOCK, ast_sched_context_destroy(), ast_sched_context::eventcnt, and ast_sched_context::id_queue.

Referenced by __ast_channel_alloc_ap(), ast_sip_initialize_scheduler(), dns_core_init(), load_module(), and mbl_load_device().

239 {
240  struct ast_sched_context *tmp;
241 
242  if (!(tmp = ast_calloc(1, sizeof(*tmp)))) {
243  return NULL;
244  }
245 
246  ast_mutex_init(&tmp->lock);
247  tmp->eventcnt = 1;
248 
250 
251  if (!(tmp->sched_heap = ast_heap_create(8, sched_time_cmp,
252  offsetof(struct sched, __heap_index)))) {
254  return NULL;
255  }
256 
257  return tmp;
258 }
Definition: sched.c:76
void ast_sched_context_destroy(struct ast_sched_context *con)
destroys a schedule context
Definition: sched.c:271
struct ast_sched_context::@394 id_queue
#define ast_calloc(num, len)
A wrapper for calloc()
Definition: astmm.h:202
#define ast_heap_create(init_height, cmp_fn, index_offset)
Create a max heap.
Definition: heap.h:100
#define AST_LIST_HEAD_INIT_NOLOCK(head)
Initializes a list head structure.
Definition: linkedlists.h:681
unsigned int eventcnt
Definition: sched.c:113
void ast_sched_context_destroy ( struct ast_sched_context c)

destroys a schedule context

Parameters
cContext to free

Definition at line 271 of file sched.c.

References ast_heap_destroy(), ast_heap_pop(), AST_LIST_REMOVE_HEAD, ast_sched_context::id_queue, and ast_sched_context::schedc.

Referenced by ast_channel_destructor(), ast_hangup(), ast_sched_context_create(), ast_sip_initialize_scheduler(), load_module(), mbl_load_device(), and unload_module().

272 {
273  struct sched *s;
274  struct sched_id *sid;
275 
276  sched_thread_destroy(con);
277  con->sched_thread = NULL;
278 
279  ast_mutex_lock(&con->lock);
280 
281 #ifdef SCHED_MAX_CACHE
282  while ((s = AST_LIST_REMOVE_HEAD(&con->schedc, list))) {
283  sched_free(s);
284  }
285 #endif
286 
287  if (con->sched_heap) {
288  while ((s = ast_heap_pop(con->sched_heap))) {
289  sched_free(s);
290  }
291  ast_heap_destroy(con->sched_heap);
292  con->sched_heap = NULL;
293  }
294 
295  while ((sid = AST_LIST_REMOVE_HEAD(&con->id_queue, list))) {
296  ast_free(sid);
297  }
298 
299  ast_mutex_unlock(&con->lock);
300  ast_mutex_destroy(&con->lock);
301 
302  ast_free(con);
303 }
Definition: sched.c:76
struct ast_heap * ast_heap_destroy(struct ast_heap *h)
Destroy a max heap.
Definition: heap.c:146
Scheduler ID holder.
Definition: sched.c:70
void * ast_heap_pop(struct ast_heap *h)
Pop the max element off of the heap.
Definition: heap.c:262
struct ast_sched_context::@394 id_queue
#define AST_LIST_REMOVE_HEAD(head, field)
Removes and returns the head entry from a list.
Definition: linkedlists.h:833
struct ast_sched_context::@393 schedc
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.

References ast_sched_del_nonrunning().

Referenced by ast_rtp_prop_set(), ast_rtp_stop(), and ast_sip_sched_task_cancel().

615 {
616  return ast_sched_del_nonrunning(con, id) ? -1 : 0;
617 }
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.
Definition: sched.c:627
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.

References ast_debug, ast_heap_remove(), ast_log_backtrace(), ast_sched_dump(), ast_threadstorage_get(), sched::callback, sched::cond, ast_sched_context::currently_executing, sched::deleted, ast_sched_context::executing_thread_id, sched_id::id, sched::rescheduled, and sched::sched_id.

Referenced by ast_sched_del().

628 {
629  struct sched *s = NULL;
630  int *last_id = ast_threadstorage_get(&last_del_id, sizeof(int));
631  int res = 0;
632 
633  DEBUG(ast_debug(1, "ast_sched_del(%d)\n", id));
634 
635  if (id < 0) {
636  return 0;
637  }
638 
639  ast_mutex_lock(&con->lock);
640 
641  s = sched_find(con, id);
642  if (s) {
643  if (!ast_heap_remove(con->sched_heap, s)) {
644  ast_log(LOG_WARNING,"sched entry %d not in the sched heap?\n", s->sched_id->id);
645  }
646  sched_release(con, s);
647  } else if (con->currently_executing && (id == con->currently_executing->sched_id->id)) {
648  if (con->executing_thread_id == pthread_self()) {
649  /* The scheduled callback is trying to delete itself.
650  * Not good as that is a deadlock. */
651  ast_log(LOG_ERROR,
652  "BUG! Trying to delete sched %d from within the callback %p. "
653  "Ignoring so we don't deadlock\n",
654  id, con->currently_executing->callback);
656  /* We'll return -1 below because s is NULL.
657  * The caller will rightly assume that the unscheduling failed. */
658  } else {
659  s = con->currently_executing;
660  s->deleted = 1;
661  /* Wait for executing task to complete so that the caller of
662  * ast_sched_del() does not free memory out from under the task. */
663  while (con->currently_executing && (id == con->currently_executing->sched_id->id)) {
664  ast_cond_wait(&s->cond, &con->lock);
665  }
666  /* This is not rescheduled so the caller of ast_sched_del_nonrunning needs to know
667  * that it was still deleted
668  */
669  if (!s->rescheduled) {
670  res = -2;
671  }
672  /* ast_sched_runq knows we are waiting on this item and is passing responsibility for
673  * its destruction to us
674  */
675  sched_release(con, s);
676  s = NULL;
677  }
678  }
679 
680 #ifdef DUMP_SCHEDULER
681  /* Dump contents of the context while we have the lock so nothing gets screwed up by accident. */
682  ast_sched_dump(con);
683 #endif
684  if (con->sched_thread) {
685  ast_cond_signal(&con->sched_thread->cond);
686  }
687  ast_mutex_unlock(&con->lock);
688 
689  if(res == -2){
690  return res;
691  }
692  else if (!s && *last_id != id) {
693  ast_debug(1, "Attempted to delete nonexistent schedule entry %d!\n", id);
694  /* Removing nonexistent schedule entry shouldn't trigger assert (it was enabled in DEV_MODE);
695  * because in many places entries is deleted without having valid id. */
696  *last_id = id;
697  return -1;
698  } else if (!s) {
699  return -1;
700  }
701 
702  return res;
703 }
unsigned int deleted
Definition: sched.c:100
struct sched_id * sched_id
Definition: sched.c:79
void * ast_threadstorage_get(struct ast_threadstorage *ts, size_t init_size)
Retrieve thread storage.
Definition: sched.c:76
void ast_log_backtrace(void)
Log a backtrace of the current thread's execution stack to the Asterisk log.
Definition: logger.c:2510
pthread_t executing_thread_id
Definition: sched.c:122
#define ast_debug(level,...)
Log a DEBUG message.
void ast_sched_dump(struct ast_sched_context *con)
Dump the contents of the scheduler to LOG_DEBUG.
Definition: sched.c:743
struct sched * currently_executing
Definition: sched.c:120
unsigned int rescheduled
Definition: sched.c:102
void * ast_heap_remove(struct ast_heap *h, void *elm)
Remove a specific element from a heap.
Definition: heap.c:251
ast_cond_t cond
Definition: sched.c:98
ast_sched_cb callback
Definition: sched.c:92
int id
Definition: sched.c:72
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.

References ast_heap_peek(), ast_heap_size(), ast_tvnow(), ast_tvsub(), ast_sched_context::eventcnt, and ast_sched_context::highwater.

Referenced by ast_sched_add_variable(), and ast_sched_del_nonrunning().

744 {
745  struct sched *q;
746  struct timeval when;
747  int x;
748  size_t heap_size;
749 
750  if (!DEBUG_ATLEAST(1)) {
751  return;
752  }
753 
754  when = ast_tvnow();
755 #ifdef SCHED_MAX_CACHE
756  ast_log(LOG_DEBUG, "Asterisk Schedule Dump (%zu in Q, %u Total, %u Cache, %u high-water)\n",
757  ast_heap_size(con->sched_heap), con->eventcnt - 1, con->schedccnt, con->highwater);
758 #else
759  ast_log(LOG_DEBUG, "Asterisk Schedule Dump (%zu in Q, %u Total, %u high-water)\n",
760  ast_heap_size(con->sched_heap), con->eventcnt - 1, con->highwater);
761 #endif
762 
763  ast_log(LOG_DEBUG, "=============================================================\n");
764  ast_log(LOG_DEBUG, "|ID Callback Data Time (sec:ms) |\n");
765  ast_log(LOG_DEBUG, "+-----+-----------------+-----------------+-----------------+\n");
766  ast_mutex_lock(&con->lock);
767  heap_size = ast_heap_size(con->sched_heap);
768  for (x = 1; x <= heap_size; x++) {
769  struct timeval delta;
770  q = ast_heap_peek(con->sched_heap, x);
771  delta = ast_tvsub(q->when, when);
772  ast_log(LOG_DEBUG, "|%.4d | %-15p | %-15p | %.6ld : %.6ld |\n",
773  q->sched_id->id,
774  q->callback,
775  q->data,
776  (long)delta.tv_sec,
777  (long int)delta.tv_usec);
778  }
779  ast_mutex_unlock(&con->lock);
780  ast_log(LOG_DEBUG, "=============================================================\n");
781 }
Definition: sched.c:76
struct timeval ast_tvnow(void)
Returns current timeval. Meant to replace calls to gettimeofday().
Definition: time.h:159
unsigned int eventcnt
Definition: sched.c:113
size_t ast_heap_size(struct ast_heap *h)
Get the current size of a heap.
Definition: heap.c:276
void * ast_heap_peek(struct ast_heap *h, unsigned int index)
Peek at an element on a heap.
Definition: heap.c:267
struct timeval ast_tvsub(struct timeval a, struct timeval b)
Returns the difference of two timevals a - b.
Definition: extconf.c:2297
unsigned int highwater
Definition: sched.c:114
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
conscheduling context in which to search fro the matching id
idID of the scheduled item to find
Return values
NULLif 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.

References sched::data.

590 {
591  struct sched *s;
592  const void *data = NULL;
593 
594  ast_mutex_lock(&con->lock);
595 
596  s = sched_find(con, id);
597  if (s) {
598  data = s->data;
599  }
600 
601  ast_mutex_unlock(&con->lock);
602 
603  return data;
604 }
Definition: sched.c:76
const void * data
Definition: sched.c:91
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
-1on failure
Returns
scheduled item ID

Definition at line 559 of file sched.c.

References ast_sched_add(), and AST_SCHED_DEL.

560 {
561  if (old_id > -1) {
562  AST_SCHED_DEL(con, old_id);
563  }
564  return ast_sched_add(con, when, callback, data);
565 }
int ast_sched_add(struct ast_sched_context *con, int when, ast_sched_cb callback, const void *data)
Adds a scheduled event.
Definition: sched.c:567
#define AST_SCHED_DEL(sched, id)
Remove a scheduler entry.
Definition: sched.h:46
struct timeval when
Definition: sched.c:80
const void * data
Definition: sched.c:91
ast_sched_cb callback
Definition: sched.c:92
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
-1on failure
Returns
scheduled item ID

Definition at line 514 of file sched.c.

References ast_sched_add_variable(), and AST_SCHED_DEL.

515 {
516  /* 0 means the schedule item is new; do not delete */
517  if (old_id > 0) {
518  AST_SCHED_DEL(con, old_id);
519  }
521 }
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.
Definition: sched.c:526
#define AST_SCHED_DEL(sched, id)
Remove a scheduler entry.
Definition: sched.h:46
struct timeval when
Definition: sched.c:80
const void * data
Definition: sched.c:91
int variable
Definition: sched.c:90
ast_sched_cb callback
Definition: sched.c:92
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
conSchedule context to check
bufdynamic string to store report
cbnamesto check against
Since
1.6.1

Definition at line 705 of file sched.c.

References ast_heap_peek(), ast_heap_size(), ast_str_append(), ast_str_set(), sched::callback, and ast_sched_context::highwater.

706 {
707  int i, x;
708  struct sched *cur;
709  int countlist[cbnames->numassocs + 1];
710  size_t heap_size;
711 
712  memset(countlist, 0, sizeof(countlist));
713  ast_str_set(buf, 0, " Highwater = %u\n schedcnt = %zu\n", con->highwater, ast_heap_size(con->sched_heap));
714 
715  ast_mutex_lock(&con->lock);
716 
717  heap_size = ast_heap_size(con->sched_heap);
718  for (x = 1; x <= heap_size; x++) {
719  cur = ast_heap_peek(con->sched_heap, x);
720  /* match the callback to the cblist */
721  for (i = 0; i < cbnames->numassocs; i++) {
722  if (cur->callback == cbnames->cblist[i]) {
723  break;
724  }
725  }
726  if (i < cbnames->numassocs) {
727  countlist[i]++;
728  } else {
729  countlist[cbnames->numassocs]++;
730  }
731  }
732 
733  ast_mutex_unlock(&con->lock);
734 
735  for (i = 0; i < cbnames->numassocs; i++) {
736  ast_str_append(buf, 0, " %s : %d\n", cbnames->list[i], countlist[i]);
737  }
738 
739  ast_str_append(buf, 0, " <unknown> : %d\n", countlist[cbnames->numassocs]);
740 }
Definition: sched.c:76
int ast_str_append(struct ast_str **buf, ssize_t max_len, const char *fmt,...)
Append to a thread local dynamic string.
Definition: strings.h:1139
int ast_str_set(struct ast_str **buf, ssize_t max_len, const char *fmt,...)
Set a dynamic string using variable arguments.
Definition: strings.h:1113
size_t ast_heap_size(struct ast_heap *h)
Get the current size of a heap.
Definition: heap.c:276
void * ast_heap_peek(struct ast_heap *h, unsigned int index)
Peek at an element on a heap.
Definition: heap.c:267
unsigned int highwater
Definition: sched.c:114
ast_sched_cb callback
Definition: sched.c:92
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.

References ast_debug, ast_heap_peek(), ast_heap_pop(), ast_tv(), ast_tvadd(), ast_tvcmp(), ast_tvnow(), sched::callback, sched::cond, ast_sched_context::currently_executing, sched::data, sched::deleted, ast_sched_context::executing_thread_id, sched::resched, sched::rescheduled, sched_settime(), schedule(), sched::variable, and sched::when.

Referenced by dial_exec_full(), speech_background(), and waitstream_core().

787 {
788  struct sched *current;
789  struct timeval when;
790  int numevents;
791  int res;
792 
793  DEBUG(ast_debug(1, "ast_sched_runq()\n"));
794 
795  ast_mutex_lock(&con->lock);
796 
797  when = ast_tvadd(ast_tvnow(), ast_tv(0, 1000));
798  for (numevents = 0; (current = ast_heap_peek(con->sched_heap, 1)); numevents++) {
799  /* schedule all events which are going to expire within 1ms.
800  * We only care about millisecond accuracy anyway, so this will
801  * help us get more than one event at one time if they are very
802  * close together.
803  */
804  if (ast_tvcmp(current->when, when) != -1) {
805  break;
806  }
807 
808  current = ast_heap_pop(con->sched_heap);
809 
810  /*
811  * At this point, the schedule queue is still intact. We
812  * have removed the first event and the rest is still there,
813  * so it's permissible for the callback to add new events, but
814  * trying to delete itself won't work because it isn't in
815  * the schedule queue. If that's what it wants to do, it
816  * should return 0.
817  */
818 
819  con->currently_executing = current;
820  con->executing_thread_id = pthread_self();
821  ast_mutex_unlock(&con->lock);
822  res = current->callback(current->data);
823  ast_mutex_lock(&con->lock);
824  con->currently_executing = NULL;
825  ast_cond_signal(&current->cond);
826 
827  if (current->deleted) {
828  /*
829  * Another thread is waiting on this scheduled item. That thread
830  * will be responsible for it's destruction
831  */
832  current->rescheduled = res ? 1 : 0;
833  } else if (res) {
834  /*
835  * If they return non-zero, we should schedule them to be
836  * run again.
837  */
838  sched_settime(&current->when, current->variable ? res : current->resched);
839  schedule(con, current);
840  } else {
841  /* No longer needed, so release it */
842  sched_release(con, current);
843  }
844  }
845 
846  ast_mutex_unlock(&con->lock);
847 
848  return numevents;
849 }
unsigned int deleted
Definition: sched.c:100
static void sched_settime(struct timeval *t, int when)
given the last event *tv and the offset in milliseconds 'when', computes the next value...
Definition: sched.c:490
Definition: sched.c:76
struct timeval ast_tvnow(void)
Returns current timeval. Meant to replace calls to gettimeofday().
Definition: time.h:159
void * ast_heap_pop(struct ast_heap *h)
Pop the max element off of the heap.
Definition: heap.c:262
int resched
Definition: sched.c:89
pthread_t executing_thread_id
Definition: sched.c:122
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...
Definition: sched.c:460
#define ast_debug(level,...)
Log a DEBUG message.
struct timeval when
Definition: sched.c:80
int ast_tvcmp(struct timeval _a, struct timeval _b)
Compress two struct timeval instances returning -1, 0, 1 if the first arg is smaller, equal or greater to the second.
Definition: time.h:137
struct timeval ast_tvadd(struct timeval a, struct timeval b)
Returns the sum of two timevals a + b.
Definition: extconf.c:2282
const void * data
Definition: sched.c:91
struct sched * currently_executing
Definition: sched.c:120
unsigned int rescheduled
Definition: sched.c:102
ast_cond_t cond
Definition: sched.c:98
struct timeval ast_tv(ast_time_t sec, ast_suseconds_t usec)
Returns a timeval from sec, usec.
Definition: time.h:235
void * ast_heap_peek(struct ast_heap *h, unsigned int index)
Peek at an element on a heap.
Definition: heap.c:267
int variable
Definition: sched.c:90
ast_sched_cb callback
Definition: sched.c:92
int ast_sched_start_thread ( struct ast_sched_context con)

Start a thread for processing scheduler entries.

Parameters
conthe scheduler context this thread will manage
Return values
0success
non-zerofailure

Definition at line 197 of file sched.c.

References ast_calloc.

Referenced by ast_sip_initialize_scheduler(), dns_core_init(), and load_module().

198 {
199  struct sched_thread *st;
200 
201  if (con->sched_thread) {
202  ast_log(LOG_ERROR, "Thread already started on this scheduler context\n");
203  return -1;
204  }
205 
206  if (!(st = ast_calloc(1, sizeof(*st)))) {
207  return -1;
208  }
209 
210  ast_cond_init(&st->cond, NULL);
211 
212  st->thread = AST_PTHREADT_NULL;
213 
214  con->sched_thread = st;
215 
216  if (ast_pthread_create_background(&st->thread, NULL, sched_run, con)) {
217  ast_log(LOG_ERROR, "Failed to create scheduler thread\n");
218  sched_thread_destroy(con);
219  return -1;
220  }
221 
222  return 0;
223 }
#define ast_calloc(num, len)
A wrapper for calloc()
Definition: astmm.h:202
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.

References ast_debug, ast_heap_peek(), ast_tvdiff_ms(), ast_tvnow(), and sched::when.

Referenced by dial_exec_full(), speech_background(), and waitstream_core().

434 {
435  int ms;
436  struct sched *s;
437 
438  DEBUG(ast_debug(1, "ast_sched_wait()\n"));
439 
440  ast_mutex_lock(&con->lock);
441  if ((s = ast_heap_peek(con->sched_heap, 1))) {
442  ms = ast_tvdiff_ms(s->when, ast_tvnow());
443  if (ms < 0) {
444  ms = 0;
445  }
446  } else {
447  ms = -1;
448  }
449  ast_mutex_unlock(&con->lock);
450 
451  return ms;
452 }
Definition: sched.c:76
struct timeval ast_tvnow(void)
Returns current timeval. Meant to replace calls to gettimeofday().
Definition: time.h:159
int64_t ast_tvdiff_ms(struct timeval end, struct timeval start)
Computes the difference (in milliseconds) between two struct timeval instances.
Definition: time.h:107
#define ast_debug(level,...)
Log a DEBUG message.
struct timeval when
Definition: sched.c:80
void * ast_heap_peek(struct ast_heap *h, unsigned int index)
Peek at an element on a heap.
Definition: heap.c:267
long ast_sched_when ( struct ast_sched_context con,
int  id 
)

Returns the number of seconds before an event takes place.

Parameters
conContext to use
idId to dump

Definition at line 851 of file sched.c.

References ast_debug, ast_tvnow(), and sched::when.

852 {
853  struct sched *s;
854  long secs = -1;
855  DEBUG(ast_debug(1, "ast_sched_when()\n"));
856 
857  ast_mutex_lock(&con->lock);
858 
859  s = sched_find(con, id);
860  if (s) {
861  struct timeval now = ast_tvnow();
862  secs = s->when.tv_sec - now.tv_sec;
863  }
864 
865  ast_mutex_unlock(&con->lock);
866 
867  return secs;
868 }
Definition: sched.c:76
struct timeval ast_tvnow(void)
Returns current timeval. Meant to replace calls to gettimeofday().
Definition: time.h:159
#define ast_debug(level,...)
Log a DEBUG message.
struct timeval when
Definition: sched.c:80