Wed Jan 8 2020 09:50:20

Asterisk developer's documentation


sched.h File Reference

Scheduler Routines (derived from cheops) More...

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)
 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. More...
 
#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)
 
#define ast_sched_thread_del(st, id)
 Delete a scheduler entry. More...
 
#define SCHED_MAX_CACHE   128
 Max num of schedule structs. More...
 

Typedefs

typedef int(* ast_sched_cb )(const void *data)
 callback for a cheops scheduler A cheops scheduler callback takes a pointer with callback data and More...
 

Functions

int ast_sched_add (struct sched_context *con, int when, ast_sched_cb callback, const void *data) attribute_warn_unused_result
 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. More...
 
int ast_sched_add_variable (struct sched_context *con, int when, ast_sched_cb callback, const void *data, int variable) attribute_warn_unused_result
 Schedule callback(data) to happen when ms into the future. More...
 
int ast_sched_del (struct sched_context *con, int id) attribute_warn_unused_result
 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). More...
 
void ast_sched_dump (struct sched_context *con)
 Dumps the scheduler contents Debugging: Dump the contents of the scheduler to stderr. More...
 
const void * ast_sched_find_data (struct 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 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 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 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 sched_context *con)
 Runs the queue. More...
 
int ast_sched_thread_add (struct ast_sched_thread *st, int when, ast_sched_cb cb, const void *data)
 Add a scheduler entry. More...
 
int ast_sched_thread_add_variable (struct ast_sched_thread *st, int when, ast_sched_cb cb, const void *data, int variable)
 Add a variable reschedule time scheduler entry. More...
 
struct ast_sched_threadast_sched_thread_create (void)
 Create a scheduler with a dedicated thread. More...
 
struct ast_sched_threadast_sched_thread_destroy (struct ast_sched_thread *st)
 Destroy a scheduler and its thread. More...
 
struct sched_contextast_sched_thread_get_context (struct ast_sched_thread *st)
 Get the scheduler context for a given ast_sched_thread. More...
 
void ast_sched_thread_poke (struct ast_sched_thread *st)
 Force re-processing of the scheduler context. More...
 
int ast_sched_wait (struct sched_context *con) attribute_warn_unused_result
 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. More...
 
long ast_sched_when (struct sched_context *con, int id)
 Returns the number of seconds before an event takes place. More...
 
struct sched_contextsched_context_create (void)
 New schedule context. More...
 
void sched_context_destroy (struct sched_context *c)
 destroys a schedule context Destroys (free's) the given sched_context structure More...
 

Detailed Description

Scheduler Routines (derived from cheops)

Definition in file sched.h.

Macro Definition Documentation

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

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

Definition at line 161 of file sched.h.

#define AST_SCHED_DEL (   sched,
  id 
)

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

Referenced by __oh323_destroy(), __oh323_update_info(), __sip_reliable_xmit(), __sip_semi_ack(), ack_trans(), ast_rtp_destroy(), ast_rtp_stop(), ast_sched_replace(), ast_sched_replace_variable(), build_gateway(), build_peer(), destroy_packet(), destroy_packets(), destroy_peer(), destroy_trans(), dialog_unlink_all(), dnsmgr_start_refresh(), do_reload(), esc_entry_destructor(), filestream_close(), handle_command_response(), handle_request_cancel(), handle_sip_publish_remove(), mgcpsock_read(), misdn_tasks_remove(), qualify_peer(), receive_digit(), sip_cc_agent_stop_offer_timer(), sip_cc_monitor_cancel_available_timer(), sip_registry_destroy(), sip_send_all_mwi_subscriptions(), sip_subscribe_mwi_destroy(), and submit_unscheduled_batch().

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

Convenience macro for objects and reference (del)

Definition at line 301 of file sched.h.

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

Referenced by iax2_destroy_helper().

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

Definition at line 113 of file sched.h.

Referenced by schedule_calendar_event().

#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 
)

Definition at line 102 of file sched.h.

Referenced by __sip_reliable_xmit().

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

#define ast_sched_thread_del (   st,
  id 
)
Value:
({ \
struct sched_context *__tmp_context = ast_sched_thread_get_context(st); \
AST_SCHED_DEL(__tmp_context, id); \
})
#define AST_SCHED_DEL(sched, id)
a loop construct to ensure that the scheduled task get deleted. The idea is that if we loop attemptin...
Definition: sched.h:51
struct sched_context * ast_sched_thread_get_context(struct ast_sched_thread *st)
Get the scheduler context for a given ast_sched_thread.
Definition: sched.c:138

Delete a scheduler entry.

This uses the AST_SCHED_DEL macro internally.

Parameters
stthe handle to the scheduler and thread
idscheduler entry id to delete
Return values
0success
non-zerofailure

Definition at line 403 of file sched.h.

Referenced by build_peer(), cc_generic_agent_stop_offer_timer(), cc_generic_monitor_cancel_available_timer(), delete_users(), iax2_destroy_helper(), iax2_frame_free(), iax2_poke_peer(), iax2_sched_replace(), make_trunk(), realtime_peer(), reg_source_db(), schedule_delivery(), socket_process(), unlink_peer(), and update_registry().

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

Referenced by sched_release().

Typedef Documentation

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

callback for a cheops scheduler A cheops scheduler callback takes a pointer with callback data and

Returns
returns a 0 if it should not be run again, or non-zero if it should be rescheduled to run again

Definition at line 160 of file sched.h.

Function Documentation

int ast_sched_add ( struct 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
Returns
Returns a schedule item ID on success, -1 on failure

Definition at line 446 of file sched.c.

References ast_sched_add_variable().

Referenced by __oh323_update_info(), ast_readaudio_callback(), ast_readvideo_callback(), ast_rtp_raw_write(), ast_rtp_read(), ast_sched_replace(), ast_sched_thread_add(), build_peer(), create_esc_entry(), do_register(), do_reload(), dundi_discover(), dundi_query(), dundi_send(), handle_command_response(), handle_request_invite(), handle_response_invite(), handle_response_subscribe(), mgcp_postrequest(), network_change_event_cb(), parse_register_contact(), populate_addr(), precache_trans(), qualify_peer(), receive_digit(), rtp_red_init(), sip_cc_agent_start_offer_timer(), sip_cc_monitor_request_cc(), sip_hangup(), sip_scheddestroy(), sip_send_all_mwi_subscriptions(), start_session_timer(), submit_scheduled_batch(), submit_unscheduled_batch(), transmit_register(), and update_provisional_keepalive().

447 {
448  return ast_sched_add_variable(con, when, callback, data, 0);
449 }
int ast_sched_add_variable(struct sched_context *con, int when, ast_sched_cb callback, const void *data, int variable) attribute_warn_unused_result
Schedule callback(data) to happen when ms into the future.
Definition: sched.c:406
int ast_sched_add_variable ( struct 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

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
variableIf 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

Definition at line 406 of file sched.c.

References ast_debug, ast_mutex_lock, ast_mutex_unlock, ast_sched_dump(), ast_tv(), sched::callback, sched::data, DEBUG, sched_context::eventcnt, sched::id, sched_context::lock, option_debug, sched::resched, sched_alloc(), sched_release(), sched_settime(), schedule(), sched::variable, and sched::when.

Referenced by _misdn_tasks_add_variable(), ast_sched_add(), ast_sched_replace_variable(), ast_sched_thread_add_variable(), dnsmgr_start_refresh(), and do_reload().

407 {
408  struct sched *tmp;
409  int res = -1;
410 
411  DEBUG(ast_debug(1, "ast_sched_add()\n"));
412 
413  ast_mutex_lock(&con->lock);
414  if ((tmp = sched_alloc(con))) {
415  tmp->id = con->eventcnt++;
416  tmp->callback = callback;
417  tmp->data = data;
418  tmp->resched = when;
419  tmp->variable = variable;
420  tmp->when = ast_tv(0, 0);
421  if (sched_settime(&tmp->when, when)) {
422  sched_release(con, tmp);
423  } else {
424  schedule(con, tmp);
425  res = tmp->id;
426  }
427  }
428 #ifdef DUMP_SCHEDULER
429  /* Dump contents of the context while we have the lock so nothing gets screwed up by accident. */
430  if (option_debug)
431  ast_sched_dump(con);
432 #endif
433  ast_mutex_unlock(&con->lock);
434 
435  return res;
436 }
static void sched_release(struct sched_context *con, struct sched *tmp)
Definition: sched.c:314
int option_debug
Definition: asterisk.c:182
static struct sched * sched_alloc(struct sched_context *con)
Definition: sched.c:296
void ast_sched_dump(struct sched_context *con)
Dumps the scheduler contents Debugging: Dump the contents of the scheduler to stderr.
Definition: sched.c:565
Definition: sched.c:57
#define ast_mutex_lock(a)
Definition: lock.h:155
int resched
Definition: sched.c:61
#define ast_debug(level,...)
Log a DEBUG message.
Definition: logger.h:236
struct timeval when
Definition: sched.c:60
ast_mutex_t lock
Definition: sched.c:69
int id
Definition: sched.c:59
static void schedule(struct 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:361
const void * data
Definition: sched.c:63
struct timeval ast_tv(ast_time_t sec, ast_suseconds_t usec)
Returns a timeval from sec, usec.
Definition: time.h:179
#define DEBUG(a)
Definition: sched.c:40
int variable
Definition: sched.c:62
static int 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:380
ast_sched_cb callback
Definition: sched.c:64
unsigned int eventcnt
Definition: sched.c:70
#define ast_mutex_unlock(a)
Definition: lock.h:156
int ast_sched_del ( struct 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
conscheduling context to delete item from
idID of the scheduled item to delete
Returns
Returns 0 on success, -1 on failure

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).

Definition at line 468 of file sched.c.

References ast_assert, ast_debug, ast_hashtab_lookup(), ast_hashtab_remove_this_object(), ast_heap_remove(), ast_log(), ast_mutex_lock, ast_mutex_unlock, ast_sched_dump(), ast_threadstorage_get(), DEBUG, sched::id, last_del_id, sched_context::lock, LOG_WARNING, option_debug, sched_context::sched_heap, sched_release(), sched_context::schedcnt, and sched_context::schedq_ht.

Referenced by __sip_ack(), ast_rtp_prop_set(), ast_rtp_stop(), and destroy_event().

472 {
473  struct sched *s, tmp = {
474  .id = id,
475  };
476  int *last_id = ast_threadstorage_get(&last_del_id, sizeof(int));
477 
478  DEBUG(ast_debug(1, "ast_sched_del(%d)\n", id));
479 
480  if (id < 0) {
481  return 0;
482  }
483 
484  ast_mutex_lock(&con->lock);
485  s = ast_hashtab_lookup(con->schedq_ht, &tmp);
486  if (s) {
487  if (!ast_heap_remove(con->sched_heap, s)) {
488  ast_log(LOG_WARNING,"sched entry %d not in the sched heap?\n", s->id);
489  }
490 
492  ast_log(LOG_WARNING,"Found sched entry %d, then couldn't remove it?\n", s->id);
493  }
494 
495  con->schedcnt--;
496 
497  sched_release(con, s);
498  }
499 
500 #ifdef DUMP_SCHEDULER
501  /* Dump contents of the context while we have the lock so nothing gets screwed up by accident. */
502  if (option_debug)
503  ast_sched_dump(con);
504 #endif
505  ast_mutex_unlock(&con->lock);
506 
507  if (!s && *last_id != id) {
508  ast_debug(1, "Attempted to delete nonexistent schedule entry %d!\n", id);
509 #ifndef AST_DEVMODE
510  ast_assert(s != NULL);
511 #else
512  {
513  char buf[100];
514  snprintf(buf, sizeof(buf), "s != NULL, id=%d", id);
515  _ast_assert(0, buf, file, line, function);
516  }
517 #endif
518  *last_id = id;
519  return -1;
520  } else if (!s) {
521  return -1;
522  }
523 
524  return 0;
525 }
static struct ast_threadstorage last_del_id
Definition: sched.c:55
void * ast_hashtab_lookup(struct ast_hashtab *tab, const void *obj)
Lookup this object in the hash table.
Definition: hashtab.c:534
void * ast_threadstorage_get(struct ast_threadstorage *ts, size_t init_size)
Retrieve thread storage.
static void sched_release(struct sched_context *con, struct sched *tmp)
Definition: sched.c:314
struct ast_hashtab * schedq_ht
Definition: sched.c:73
int option_debug
Definition: asterisk.c:182
void ast_sched_dump(struct sched_context *con)
Dumps the scheduler contents Debugging: Dump the contents of the scheduler to stderr.
Definition: sched.c:565
#define LOG_WARNING
Definition: logger.h:144
Definition: sched.c:57
#define ast_assert(a)
Definition: utils.h:738
#define ast_mutex_lock(a)
Definition: lock.h:155
#define ast_debug(level,...)
Log a DEBUG message.
Definition: logger.h:236
struct ast_heap * sched_heap
Definition: sched.c:74
ast_mutex_t lock
Definition: sched.c:69
int id
Definition: sched.c:59
void ast_log(int level, const char *file, int line, const char *function, const char *fmt,...)
Used for sending a log message This is the standard logger function. Probably the only way you will i...
Definition: logger.c:1207
void * ast_heap_remove(struct ast_heap *h, void *elm)
Remove a specific element from a heap.
Definition: heap.c:284
#define DEBUG(a)
Definition: sched.c:40
enum queue_result id
Definition: app_queue.c:1090
unsigned int schedcnt
Definition: sched.c:71
#define ast_mutex_unlock(a)
Definition: lock.h:156
void * ast_hashtab_remove_this_object(struct ast_hashtab *tab, void *obj)
Hash the object and then compare ptrs in bucket list instead of calling the compare routine...
Definition: hashtab.c:859
void ast_sched_dump ( struct sched_context con)

Dumps the scheduler contents Debugging: Dump the contents of the scheduler to stderr.

Parameters
conContext to dump

Dumps the scheduler contents Debugging: Dump the contents of the scheduler to stderr.

Definition at line 565 of file sched.c.

References ast_debug, ast_heap_peek(), ast_heap_size(), ast_mutex_lock, ast_mutex_unlock, ast_tvnow(), ast_tvsub(), sched_context::eventcnt, sched_context::highwater, sched_context::lock, sched_context::sched_heap, sched_context::schedccnt, and sched_context::schedcnt.

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

566 {
567  struct sched *q;
568  struct timeval when = ast_tvnow();
569  int x;
570  size_t heap_size;
571 #ifdef SCHED_MAX_CACHE
572  ast_debug(1, "Asterisk Schedule Dump (%u in Q, %u Total, %u Cache, %u high-water)\n", con->schedcnt, con->eventcnt - 1, con->schedccnt, con->highwater);
573 #else
574  ast_debug(1, "Asterisk Schedule Dump (%u in Q, %u Total, %u high-water)\n", con->schedcnt, con->eventcnt - 1, con->highwater);
575 #endif
576 
577  ast_debug(1, "=============================================================\n");
578  ast_debug(1, "|ID Callback Data Time (sec:ms) |\n");
579  ast_debug(1, "+-----+-----------------+-----------------+-----------------+\n");
580  ast_mutex_lock(&con->lock);
581  heap_size = ast_heap_size(con->sched_heap);
582  for (x = 1; x <= heap_size; x++) {
583  struct timeval delta;
584  q = ast_heap_peek(con->sched_heap, x);
585  delta = ast_tvsub(q->when, when);
586  ast_debug(1, "|%.4d | %-15p | %-15p | %.6ld : %.6ld |\n",
587  q->id,
588  q->callback,
589  q->data,
590  (long)delta.tv_sec,
591  (long int)delta.tv_usec);
592  }
593  ast_mutex_unlock(&con->lock);
594  ast_debug(1, "=============================================================\n");
595 }
Definition: sched.c:57
struct timeval ast_tvnow(void)
Returns current timeval. Meant to replace calls to gettimeofday().
Definition: time.h:142
#define ast_mutex_lock(a)
Definition: lock.h:155
#define ast_debug(level,...)
Log a DEBUG message.
Definition: logger.h:236
struct ast_heap * sched_heap
Definition: sched.c:74
unsigned int schedccnt
Definition: sched.c:78
ast_mutex_t lock
Definition: sched.c:69
unsigned int highwater
Definition: sched.c:72
size_t ast_heap_size(struct ast_heap *h)
Get the current size of a heap.
Definition: heap.c:309
void * ast_heap_peek(struct ast_heap *h, unsigned int index)
Peek at an element on a heap.
Definition: heap.c:300
struct timeval ast_tvsub(struct timeval a, struct timeval b)
Returns the difference of two timevals a - b.
Definition: utils.c:1601
unsigned int eventcnt
Definition: sched.c:70
unsigned int schedcnt
Definition: sched.c:71
#define ast_mutex_unlock(a)
Definition: lock.h:156
const void* ast_sched_find_data ( struct 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
Returns
the data field from the matching sched struct if found; else return NULL if not found.
Since
1.6.1

Definition at line 451 of file sched.c.

References ast_hashtab_lookup(), sched::data, sched::id, and sched_context::schedq_ht.

452 {
453  struct sched tmp,*res;
454  tmp.id = id;
455  res = ast_hashtab_lookup(con->schedq_ht, &tmp);
456  if (res)
457  return res->data;
458  return NULL;
459 }
void * ast_hashtab_lookup(struct ast_hashtab *tab, const void *obj)
Lookup this object in the hash table.
Definition: hashtab.c:534
struct ast_hashtab * schedq_ht
Definition: sched.c:73
Definition: sched.c:57
int id
Definition: sched.c:59
const void * data
Definition: sched.c:63
enum queue_result id
Definition: app_queue.c:1090
int ast_sched_replace ( int  old_id,
struct 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
-1failure
otherwise,returnsscheduled item ID

Definition at line 438 of file sched.c.

References ast_sched_add(), and AST_SCHED_DEL.

439 {
440  if (old_id > -1) {
441  AST_SCHED_DEL(con, old_id);
442  }
443  return ast_sched_add(con, when, callback, data);
444 }
int ast_sched_add(struct sched_context *con, int when, ast_sched_cb callback, const void *data) attribute_warn_unused_result
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.
Definition: sched.c:446
#define AST_SCHED_DEL(sched, id)
a loop construct to ensure that the scheduled task get deleted. The idea is that if we loop attemptin...
Definition: sched.h:51
struct timeval when
Definition: sched.c:60
const void * data
Definition: sched.c:63
ast_sched_cb callback
Definition: sched.c:64
int ast_sched_replace_variable ( int  old_id,
struct 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
-1failure
otherwise,returnsscheduled item ID

Definition at line 394 of file sched.c.

References ast_sched_add_variable(), and AST_SCHED_DEL.

395 {
396  /* 0 means the schedule item is new; do not delete */
397  if (old_id > 0) {
398  AST_SCHED_DEL(con, old_id);
399  }
401 }
int ast_sched_add_variable(struct sched_context *con, int when, ast_sched_cb callback, const void *data, int variable) attribute_warn_unused_result
Schedule callback(data) to happen when ms into the future.
Definition: sched.c:406
#define AST_SCHED_DEL(sched, id)
a loop construct to ensure that the scheduled task get deleted. The idea is that if we loop attemptin...
Definition: sched.h:51
struct timeval when
Definition: sched.c:60
const void * data
Definition: sched.c:63
int variable
Definition: sched.c:62
ast_sched_cb callback
Definition: sched.c:64
void ast_sched_report ( struct 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 527 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, sched_context::highwater, ast_cb_names::list, sched_context::lock, ast_cb_names::numassocs, sched_context::sched_heap, and sched_context::schedcnt.

Referenced by sip_show_sched().

528 {
529  int i, x;
530  struct sched *cur;
531  int countlist[cbnames->numassocs + 1];
532  size_t heap_size;
533 
534  memset(countlist, 0, sizeof(countlist));
535  ast_str_set(buf, 0, " Highwater = %u\n schedcnt = %u\n", con->highwater, con->schedcnt);
536 
537  ast_mutex_lock(&con->lock);
538 
539  heap_size = ast_heap_size(con->sched_heap);
540  for (x = 1; x <= heap_size; x++) {
541  cur = ast_heap_peek(con->sched_heap, x);
542  /* match the callback to the cblist */
543  for (i = 0; i < cbnames->numassocs; i++) {
544  if (cur->callback == cbnames->cblist[i]) {
545  break;
546  }
547  }
548  if (i < cbnames->numassocs) {
549  countlist[i]++;
550  } else {
551  countlist[cbnames->numassocs]++;
552  }
553  }
554 
555  ast_mutex_unlock(&con->lock);
556 
557  for (i = 0; i < cbnames->numassocs; i++) {
558  ast_str_append(buf, 0, " %s : %d\n", cbnames->list[i], countlist[i]);
559  }
560 
561  ast_str_append(buf, 0, " <unknown> : %d\n", countlist[cbnames->numassocs]);
562 }
char * list[10]
Definition: sched.h:165
ast_sched_cb cblist[10]
Definition: sched.h:166
Definition: sched.c:57
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:900
#define ast_mutex_lock(a)
Definition: lock.h:155
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:874
int numassocs
Definition: sched.h:164
struct ast_heap * sched_heap
Definition: sched.c:74
ast_mutex_t lock
Definition: sched.c:69
unsigned int highwater
Definition: sched.c:72
size_t ast_heap_size(struct ast_heap *h)
Get the current size of a heap.
Definition: heap.c:309
void * ast_heap_peek(struct ast_heap *h, unsigned int index)
Peek at an element on a heap.
Definition: heap.c:300
ast_sched_cb callback
Definition: sched.c:64
unsigned int schedcnt
Definition: sched.c:71
#define ast_mutex_unlock(a)
Definition: lock.h:156
int ast_sched_runq ( struct sched_context con)

Runs the queue.

Parameters
conScheduling context to run Run the queue, executing all callbacks which need to be performed at this time.
concontext to act upon
Returns
Returns the number of events processed.

Runs the queue.

Definition at line 600 of file sched.c.

References ast_debug, ast_hashtab_remove_this_object(), ast_heap_peek(), ast_heap_pop(), ast_log(), ast_mutex_lock, ast_mutex_unlock, ast_tv(), ast_tvadd(), ast_tvcmp(), ast_tvnow(), sched::callback, sched::data, DEBUG, sched::id, sched_context::lock, LOG_ERROR, sched::resched, sched_context::sched_heap, sched_release(), sched_settime(), sched_context::schedcnt, sched_context::schedq_ht, schedule(), sched::variable, and sched::when.

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

601 {
602  struct sched *current;
603  struct timeval when;
604  int numevents;
605  int res;
606 
607  DEBUG(ast_debug(1, "ast_sched_runq()\n"));
608 
609  ast_mutex_lock(&con->lock);
610 
611  when = ast_tvadd(ast_tvnow(), ast_tv(0, 1000));
612  for (numevents = 0; (current = ast_heap_peek(con->sched_heap, 1)); numevents++) {
613  /* schedule all events which are going to expire within 1ms.
614  * We only care about millisecond accuracy anyway, so this will
615  * help us get more than one event at one time if they are very
616  * close together.
617  */
618  if (ast_tvcmp(current->when, when) != -1) {
619  break;
620  }
621 
622  current = ast_heap_pop(con->sched_heap);
623 
624  if (!ast_hashtab_remove_this_object(con->schedq_ht, current)) {
625  ast_log(LOG_ERROR,"Sched entry %d was in the schedq list but not in the hashtab???\n", current->id);
626  }
627 
628  con->schedcnt--;
629 
630  /*
631  * At this point, the schedule queue is still intact. We
632  * have removed the first event and the rest is still there,
633  * so it's permissible for the callback to add new events, but
634  * trying to delete itself won't work because it isn't in
635  * the schedule queue. If that's what it wants to do, it
636  * should return 0.
637  */
638 
639  ast_mutex_unlock(&con->lock);
640  res = current->callback(current->data);
641  ast_mutex_lock(&con->lock);
642 
643  if (res) {
644  /*
645  * If they return non-zero, we should schedule them to be
646  * run again.
647  */
648  if (sched_settime(&current->when, current->variable? res : current->resched)) {
649  sched_release(con, current);
650  } else {
651  schedule(con, current);
652  }
653  } else {
654  /* No longer needed, so release it */
655  sched_release(con, current);
656  }
657  }
658 
659  ast_mutex_unlock(&con->lock);
660 
661  return numevents;
662 }
static void sched_release(struct sched_context *con, struct sched *tmp)
Definition: sched.c:314
struct ast_hashtab * schedq_ht
Definition: sched.c:73
Definition: sched.c:57
struct timeval ast_tvnow(void)
Returns current timeval. Meant to replace calls to gettimeofday().
Definition: time.h:142
#define ast_mutex_lock(a)
Definition: lock.h:155
void * ast_heap_pop(struct ast_heap *h)
Pop the max element off of the heap.
Definition: heap.c:295
int resched
Definition: sched.c:61
#define ast_debug(level,...)
Log a DEBUG message.
Definition: logger.h:236
struct ast_heap * sched_heap
Definition: sched.c:74
struct timeval when
Definition: sched.c:60
ast_mutex_t lock
Definition: sched.c:69
#define LOG_ERROR
Definition: logger.h:155
int ast_tvcmp(struct timeval _a, struct timeval _b)
Compres two struct timeval instances returning -1, 0, 1 if the first arg is smaller, equal or greater to the second.
Definition: time.h:120
int id
Definition: sched.c:59
struct timeval ast_tvadd(struct timeval a, struct timeval b)
Returns the sum of two timevals a + b.
Definition: utils.c:1587
void ast_log(int level, const char *file, int line, const char *function, const char *fmt,...)
Used for sending a log message This is the standard logger function. Probably the only way you will i...
Definition: logger.c:1207
static void schedule(struct 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:361
const void * data
Definition: sched.c:63
struct timeval ast_tv(ast_time_t sec, ast_suseconds_t usec)
Returns a timeval from sec, usec.
Definition: time.h:179
void * ast_heap_peek(struct ast_heap *h, unsigned int index)
Peek at an element on a heap.
Definition: heap.c:300
#define DEBUG(a)
Definition: sched.c:40
int variable
Definition: sched.c:62
static int sched_settime(struct timeval *t, int when)
given the last event *tv and the offset in milliseconds &#39;when&#39;, computes the next value...
Definition: sched.c:380
ast_sched_cb callback
Definition: sched.c:64
unsigned int schedcnt
Definition: sched.c:71
#define ast_mutex_unlock(a)
Definition: lock.h:156
void * ast_hashtab_remove_this_object(struct ast_hashtab *tab, void *obj)
Hash the object and then compare ptrs in bucket list instead of calling the compare routine...
Definition: hashtab.c:859
int ast_sched_thread_add ( struct ast_sched_thread st,
int  when,
ast_sched_cb  cb,
const void *  data 
)

Add a scheduler entry.

Parameters
stthe handle to the scheduler and thread
whenthe number of ms in the future to run the task. A value <= 0 is treated as "run now".
cbthe function to call when the scheduled time arrives
datathe parameter to pass to the scheduler callback
Return values
-1Failure
>=0Sched ID of added task

Definition at line 210 of file sched.c.

References ast_cond_signal, ast_mutex_lock, ast_mutex_unlock, ast_sched_add(), ast_sched_thread::cond, ast_sched_thread::context, and ast_sched_thread::lock.

Referenced by cc_generic_agent_start_offer_timer(), cc_generic_monitor_request_cc(), iax2_hangup(), iax2_key_rotate(), iax2_sched_add(), and iax2_sched_replace().

212 {
213  int res;
214 
215  ast_mutex_lock(&st->lock);
216  res = ast_sched_add(st->context, when, cb, data);
217  if (res != -1) {
218  ast_cond_signal(&st->cond);
219  }
220  ast_mutex_unlock(&st->lock);
221 
222  return res;
223 }
ast_mutex_t lock
Definition: sched.c:84
int ast_sched_add(struct sched_context *con, int when, ast_sched_cb callback, const void *data) attribute_warn_unused_result
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.
Definition: sched.c:446
ast_cond_t cond
Definition: sched.c:85
#define ast_mutex_lock(a)
Definition: lock.h:155
#define ast_cond_signal(cond)
Definition: lock.h:169
struct sched_context * context
Definition: sched.c:86
#define ast_mutex_unlock(a)
Definition: lock.h:156
int ast_sched_thread_add_variable ( struct ast_sched_thread st,
int  when,
ast_sched_cb  cb,
const void *  data,
int  variable 
)

Add a variable reschedule time scheduler entry.

Parameters
stthe handle to the scheduler and thread
whenthe number of ms in the future to run the task. A value <= 0 is treated as "run now".
cbthe function to call when the scheduled time arrives
datathe parameter to pass to the scheduler callback
variableIf this value is non-zero, then the scheduler will use the return value of the scheduler as the amount of time in the future to run the task again. Normally, a return value of 0 means do not re-schedule, and non-zero means re-schedule using the time provided when the scheduler entry was first created.
Return values
-1Failure
>=0Sched ID of added task

Definition at line 195 of file sched.c.

References ast_cond_signal, ast_mutex_lock, ast_mutex_unlock, ast_sched_add_variable(), ast_sched_thread::cond, ast_sched_thread::context, and ast_sched_thread::lock.

Referenced by stun_start_monitor().

197 {
198  int res;
199 
200  ast_mutex_lock(&st->lock);
201  res = ast_sched_add_variable(st->context, when, cb, data, variable);
202  if (res != -1) {
203  ast_cond_signal(&st->cond);
204  }
205  ast_mutex_unlock(&st->lock);
206 
207  return res;
208 }
ast_mutex_t lock
Definition: sched.c:84
int ast_sched_add_variable(struct sched_context *con, int when, ast_sched_cb callback, const void *data, int variable) attribute_warn_unused_result
Schedule callback(data) to happen when ms into the future.
Definition: sched.c:406
ast_cond_t cond
Definition: sched.c:85
#define ast_mutex_lock(a)
Definition: lock.h:155
#define ast_cond_signal(cond)
Definition: lock.h:169
struct sched_context * context
Definition: sched.c:86
#define ast_mutex_unlock(a)
Definition: lock.h:156
struct ast_sched_thread* ast_sched_thread_create ( void  )

Create a scheduler with a dedicated thread.

This function should be used to allocate a scheduler context and a dedicated thread for processing scheduler entries. The thread is started immediately.

Return values
NULLerror
non-NULLa handle to the scheduler and its dedicated thread.

Definition at line 167 of file sched.c.

References ast_calloc, ast_cond_init, ast_log(), ast_mutex_init, ast_pthread_create_background, AST_PTHREADT_NULL, ast_sched_thread_destroy(), ast_sched_thread::cond, ast_sched_thread::context, ast_sched_thread::lock, LOG_ERROR, sched_context_create(), sched_run(), and ast_sched_thread::thread.

Referenced by ast_cc_init(), load_module(), and stun_start_monitor().

168 {
169  struct ast_sched_thread *st;
170 
171  if (!(st = ast_calloc(1, sizeof(*st)))) {
172  return NULL;
173  }
174 
175  ast_mutex_init(&st->lock);
176  ast_cond_init(&st->cond, NULL);
177 
179 
180  if (!(st->context = sched_context_create())) {
181  ast_log(LOG_ERROR, "Failed to create scheduler\n");
183  return NULL;
184  }
185 
186  if (ast_pthread_create_background(&st->thread, NULL, sched_run, st)) {
187  ast_log(LOG_ERROR, "Failed to create scheduler thread\n");
189  return NULL;
190  }
191 
192  return st;
193 }
ast_mutex_t lock
Definition: sched.c:84
struct ast_sched_thread * ast_sched_thread_destroy(struct ast_sched_thread *st)
Destroy a scheduler and its thread.
Definition: sched.c:143
static void * sched_run(void *data)
Definition: sched.c:90
#define ast_cond_init(cond, attr)
Definition: lock.h:167
ast_cond_t cond
Definition: sched.c:85
#define ast_pthread_create_background(a, b, c, d)
Definition: utils.h:426
#define AST_PTHREADT_NULL
Definition: lock.h:65
struct sched_context * context
Definition: sched.c:86
#define LOG_ERROR
Definition: logger.h:155
void ast_log(int level, const char *file, int line, const char *function, const char *fmt,...)
Used for sending a log message This is the standard logger function. Probably the only way you will i...
Definition: logger.c:1207
pthread_t thread
Definition: sched.c:83
struct sched_context * sched_context_create(void)
New schedule context.
Definition: sched.c:246
#define ast_calloc(a, b)
Definition: astmm.h:82
#define ast_mutex_init(pmutex)
Definition: lock.h:152
struct ast_sched_thread* ast_sched_thread_destroy ( struct ast_sched_thread st)

Destroy a scheduler and its thread.

This function is used to destroy a scheduler context and the dedicated thread that was created for handling scheduler entries. Any entries in the scheduler that have not yet been processed will be thrown away. Once this function is called, the handle must not be used again.

Parameters
stthe handle to the scheduler and thread
Returns
NULL for convenience

Definition at line 143 of file sched.c.

References ast_cond_destroy, ast_cond_signal, ast_free, ast_mutex_destroy, ast_mutex_lock, ast_mutex_unlock, AST_PTHREADT_NULL, ast_sched_thread::cond, ast_sched_thread::context, ast_sched_thread::lock, sched_context_destroy(), ast_sched_thread::stop, and ast_sched_thread::thread.

Referenced by __unload_module(), ast_sched_thread_create(), cc_shutdown(), load_module(), stun_start_monitor(), and stun_stop_monitor().

144 {
145  if (st->thread != AST_PTHREADT_NULL) {
146  ast_mutex_lock(&st->lock);
147  st->stop = 1;
148  ast_cond_signal(&st->cond);
149  ast_mutex_unlock(&st->lock);
150  pthread_join(st->thread, NULL);
152  }
153 
154  ast_mutex_destroy(&st->lock);
155  ast_cond_destroy(&st->cond);
156 
157  if (st->context) {
159  st->context = NULL;
160  }
161 
162  ast_free(st);
163 
164  return NULL;
165 }
ast_mutex_t lock
Definition: sched.c:84
ast_cond_t cond
Definition: sched.c:85
#define ast_mutex_lock(a)
Definition: lock.h:155
#define ast_cond_signal(cond)
Definition: lock.h:169
#define AST_PTHREADT_NULL
Definition: lock.h:65
struct sched_context * context
Definition: sched.c:86
void sched_context_destroy(struct sched_context *c)
destroys a schedule context Destroys (free&#39;s) the given sched_context structure
Definition: sched.c:267
#define ast_cond_destroy(cond)
Definition: lock.h:168
unsigned int stop
Definition: sched.c:87
pthread_t thread
Definition: sched.c:83
#define ast_free(a)
Definition: astmm.h:97
#define ast_mutex_destroy(a)
Definition: lock.h:154
#define ast_mutex_unlock(a)
Definition: lock.h:156
struct sched_context* ast_sched_thread_get_context ( struct ast_sched_thread st)

Get the scheduler context for a given ast_sched_thread.

This function should be used only when direct access to the scheduler context is required. Its use is discouraged unless necessary. The cases where this is currently required is when you want to take advantage of one of the AST_SCHED macros.

Parameters
stthe handle to the scheduler and thread
Returns
the sched_context associated with an ast_sched_thread

Definition at line 138 of file sched.c.

References ast_sched_thread::context.

Referenced by iax2_destroy_helper().

139 {
140  return st->context;
141 }
struct sched_context * context
Definition: sched.c:86
void ast_sched_thread_poke ( struct ast_sched_thread st)

Force re-processing of the scheduler context.

Parameters
stthe handle to the scheduler and thread
Returns
nothing

Definition at line 131 of file sched.c.

References ast_cond_signal, ast_mutex_lock, ast_mutex_unlock, ast_sched_thread::cond, and ast_sched_thread::lock.

132 {
133  ast_mutex_lock(&st->lock);
134  ast_cond_signal(&st->cond);
135  ast_mutex_unlock(&st->lock);
136 }
ast_mutex_t lock
Definition: sched.c:84
ast_cond_t cond
Definition: sched.c:85
#define ast_mutex_lock(a)
Definition: lock.h:155
#define ast_cond_signal(cond)
Definition: lock.h:169
#define ast_mutex_unlock(a)
Definition: lock.h:156
int ast_sched_wait ( struct 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
concontext 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 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.

Definition at line 334 of file sched.c.

References ast_debug, ast_heap_peek(), ast_mutex_lock, ast_mutex_unlock, ast_tvdiff_ms(), ast_tvnow(), DEBUG, sched_context::lock, sched_context::sched_heap, and sched::when.

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

335 {
336  int ms;
337  struct sched *s;
338 
339  DEBUG(ast_debug(1, "ast_sched_wait()\n"));
340 
341  ast_mutex_lock(&con->lock);
342  if ((s = ast_heap_peek(con->sched_heap, 1))) {
343  ms = ast_tvdiff_ms(s->when, ast_tvnow());
344  if (ms < 0) {
345  ms = 0;
346  }
347  } else {
348  ms = -1;
349  }
350  ast_mutex_unlock(&con->lock);
351 
352  return ms;
353 }
Definition: sched.c:57
struct timeval ast_tvnow(void)
Returns current timeval. Meant to replace calls to gettimeofday().
Definition: time.h:142
#define ast_mutex_lock(a)
Definition: lock.h:155
int64_t ast_tvdiff_ms(struct timeval end, struct timeval start)
Computes the difference (in milliseconds) between two struct timeval instances.
Definition: time.h:90
#define ast_debug(level,...)
Log a DEBUG message.
Definition: logger.h:236
struct ast_heap * sched_heap
Definition: sched.c:74
struct timeval when
Definition: sched.c:60
ast_mutex_t lock
Definition: sched.c:69
void * ast_heap_peek(struct ast_heap *h, unsigned int index)
Peek at an element on a heap.
Definition: heap.c:300
#define DEBUG(a)
Definition: sched.c:40
#define ast_mutex_unlock(a)
Definition: lock.h:156
long ast_sched_when ( struct 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 664 of file sched.c.

References ast_debug, ast_hashtab_lookup(), ast_mutex_lock, ast_mutex_unlock, ast_tvnow(), DEBUG, sched::id, sched_context::lock, sched_context::schedq_ht, and sched::when.

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

665 {
666  struct sched *s, tmp;
667  long secs = -1;
668  DEBUG(ast_debug(1, "ast_sched_when()\n"));
669 
670  ast_mutex_lock(&con->lock);
671 
672  /* these next 2 lines replace a lookup loop */
673  tmp.id = id;
674  s = ast_hashtab_lookup(con->schedq_ht, &tmp);
675 
676  if (s) {
677  struct timeval now = ast_tvnow();
678  secs = s->when.tv_sec - now.tv_sec;
679  }
680  ast_mutex_unlock(&con->lock);
681 
682  return secs;
683 }
void * ast_hashtab_lookup(struct ast_hashtab *tab, const void *obj)
Lookup this object in the hash table.
Definition: hashtab.c:534
struct ast_hashtab * schedq_ht
Definition: sched.c:73
Definition: sched.c:57
struct timeval ast_tvnow(void)
Returns current timeval. Meant to replace calls to gettimeofday().
Definition: time.h:142
#define ast_mutex_lock(a)
Definition: lock.h:155
#define ast_debug(level,...)
Log a DEBUG message.
Definition: logger.h:236
struct timeval when
Definition: sched.c:60
ast_mutex_t lock
Definition: sched.c:69
int id
Definition: sched.c:59
#define DEBUG(a)
Definition: sched.c:40
enum queue_result id
Definition: app_queue.c:1090
#define ast_mutex_unlock(a)
Definition: lock.h:156
struct sched_context* sched_context_create ( void  )

New schedule context.

Note
Create a scheduling context
Returns
Returns a malloc'd sched_context structure, NULL on failure

Definition at line 246 of file sched.c.

References ast_calloc, ast_hashtab_create(), ast_hashtab_newsize_java(), ast_hashtab_resize_java(), ast_heap_create(), ast_mutex_init, sched_context::eventcnt, sched_context::lock, sched_cmp(), sched_context_destroy(), sched_hash(), sched_context::sched_heap, sched_time_cmp(), and sched_context::schedq_ht.

Referenced by __ast_channel_alloc_ap(), ast_cdr_engine_init(), ast_sched_thread_create(), dnsmgr_init(), load_module(), and misdn_tasks_init().

247 {
248  struct sched_context *tmp;
249 
250  if (!(tmp = ast_calloc(1, sizeof(*tmp))))
251  return NULL;
252 
253  ast_mutex_init(&tmp->lock);
254  tmp->eventcnt = 1;
255 
257 
258  if (!(tmp->sched_heap = ast_heap_create(8, sched_time_cmp,
259  offsetof(struct sched, __heap_index)))) {
261  return NULL;
262  }
263 
264  return tmp;
265 }
static unsigned int sched_hash(const void *obj)
Definition: sched.c:234
int ast_hashtab_newsize_java(struct ast_hashtab *tab)
Create a prime number roughly 2x the current table size.
Definition: hashtab.c:131
struct ast_hashtab * schedq_ht
Definition: sched.c:73
Definition: sched.c:57
int ast_hashtab_resize_java(struct ast_hashtab *tab)
Determines if a table resize should occur using the Java algorithm (if the table load factor is 75% o...
Definition: hashtab.c:88
struct ast_heap * sched_heap
Definition: sched.c:74
static int sched_cmp(const void *a, const void *b)
Definition: sched.c:227
struct ast_hashtab * ast_hashtab_create(int initial_buckets, int(*compare)(const void *a, const void *b), int(*resize)(struct ast_hashtab *), int(*newsize)(struct ast_hashtab *tab), unsigned int(*hash)(const void *obj), int do_locking)
Create the hashtable list.
Definition: hashtab.c:226
ast_mutex_t lock
Definition: sched.c:69
void sched_context_destroy(struct sched_context *c)
destroys a schedule context Destroys (free&#39;s) the given sched_context structure
Definition: sched.c:267
static int sched_time_cmp(void *a, void *b)
Definition: sched.c:241
#define ast_calloc(a, b)
Definition: astmm.h:82
struct ast_heap * ast_heap_create(unsigned int init_height, ast_heap_cmp_fn cmp_fn, ssize_t index_offset)
Create a max heap.
Definition: heap.c:118
#define ast_mutex_init(pmutex)
Definition: lock.h:152
unsigned int eventcnt
Definition: sched.c:70
void sched_context_destroy ( struct sched_context c)

destroys a schedule context Destroys (free's) the given sched_context structure

Parameters
cContext to free
Returns
Returns 0 on success, -1 on failure

Definition at line 267 of file sched.c.

References ast_free, ast_hashtab_destroy(), ast_heap_destroy(), ast_heap_pop(), AST_LIST_REMOVE_HEAD, ast_mutex_destroy, ast_mutex_lock, ast_mutex_unlock, sched_context::lock, sched_context::sched_heap, sched_context::schedc, and sched_context::schedq_ht.

Referenced by ast_channel_destructor(), ast_hangup(), ast_sched_thread_destroy(), cdr_engine_shutdown(), dnsmgr_shutdown(), load_module(), misdn_tasks_destroy(), sched_context_create(), and unload_module().

268 {
269  struct sched *s;
270 
271  ast_mutex_lock(&con->lock);
272 
273 #ifdef SCHED_MAX_CACHE
274  /* Eliminate the cache */
275  while ((s = AST_LIST_REMOVE_HEAD(&con->schedc, list)))
276  ast_free(s);
277 #endif
278 
279  if (con->sched_heap) {
280  while ((s = ast_heap_pop(con->sched_heap))) {
281  ast_free(s);
282  }
283  ast_heap_destroy(con->sched_heap);
284  con->sched_heap = NULL;
285  }
286 
287  ast_hashtab_destroy(con->schedq_ht, NULL);
288  con->schedq_ht = NULL;
289 
290  /* And the context */
291  ast_mutex_unlock(&con->lock);
292  ast_mutex_destroy(&con->lock);
293  ast_free(con);
294 }
Definition: sched.c:57
struct ast_heap * ast_heap_destroy(struct ast_heap *h)
Destroy a max heap.
Definition: heap.c:163
#define ast_mutex_lock(a)
Definition: lock.h:155
void * ast_heap_pop(struct ast_heap *h)
Pop the max element off of the heap.
Definition: heap.c:295
#define AST_LIST_REMOVE_HEAD(head, field)
Removes and returns the head entry from a list.
Definition: linkedlists.h:818
struct sched::@296 list
#define ast_free(a)
Definition: astmm.h:97
#define ast_mutex_destroy(a)
Definition: lock.h:154
#define ast_mutex_unlock(a)
Definition: lock.h:156
void ast_hashtab_destroy(struct ast_hashtab *tab, void(*objdestroyfunc)(void *obj))
This func will free the hash table and all its memory.
Definition: hashtab.c:388