Fri Aug 17 00:17:49 2018

Asterisk developer's documentation


taskprocessor.c File Reference

Maintain a container of uniquely-named taskprocessor threads that can be shared across modules. More...

#include "asterisk.h"
#include "asterisk/_private.h"
#include "asterisk/module.h"
#include "asterisk/time.h"
#include "asterisk/astobj2.h"
#include "asterisk/cli.h"
#include "asterisk/taskprocessor.h"

Go to the source code of this file.

Data Structures

struct  ast_taskprocessor
 A ast_taskprocessor structure is a singleton by name. More...
struct  tps_queue
 Taskprocessor queue. More...
struct  tps_task
 tps_task structure is queued to a taskprocessor More...
struct  tps_taskprocessor_stats
 tps_taskprocessor_stats maintain statistics for a taskprocessor. More...

Defines

#define TPS_MAX_BUCKETS   7

Functions

struct ast_taskprocessorast_taskprocessor_get (const char *name, enum ast_tps_options create)
 Get a reference to a taskprocessor with the specified name and create the taskprocessor if necessary.
const char * ast_taskprocessor_name (struct ast_taskprocessor *tps)
 Return the name of the taskprocessor singleton.
int ast_taskprocessor_push (struct ast_taskprocessor *tps, int(*task_exe)(void *datap), void *datap)
 Push a task into the specified taskprocessor queue and signal the taskprocessor thread.
void * ast_taskprocessor_unreference (struct ast_taskprocessor *tps)
 Unreference the specified taskprocessor and its reference count will decrement.
int ast_tps_init (void)
static char * cli_tps_ping (struct ast_cli_entry *e, int cmd, struct ast_cli_args *a)
static char * cli_tps_report (struct ast_cli_entry *e, int cmd, struct ast_cli_args *a)
static int tps_cmp_cb (void *obj, void *arg, int flags)
 The astobj2 compare callback for taskprocessors.
static int tps_hash_cb (const void *obj, const int flags)
 The astobj2 hash callback for taskprocessors.
static int tps_ping_handler (void *datap)
 CLI taskprocessor ping <blah>handler function.
static void * tps_processing_function (void *data)
 The task processing function executed by a taskprocessor.
static void tps_shutdown (void)
static struct tps_tasktps_task_alloc (int(*task_exe)(void *datap), void *datap)
static void * tps_task_free (struct tps_task *task)
static int tps_taskprocessor_depth (struct ast_taskprocessor *tps)
 Return the size of the taskprocessor queue.
static void tps_taskprocessor_destroy (void *tps)
 Destroy the taskprocessor when its refcount reaches zero.
static struct tps_tasktps_taskprocessor_pop (struct ast_taskprocessor *tps)
 Remove the front task off the taskprocessor queue.
static char * tps_taskprocessor_tab_complete (struct ast_taskprocessor *p, struct ast_cli_args *a)

Variables

static ast_cond_t cli_ping_cond
 CLI taskprocessor ping <blah>operation requires a ping condition.
static ast_mutex_t cli_ping_cond_lock = { PTHREAD_RECURSIVE_MUTEX_INITIALIZER_NP , NULL, 1 }
 CLI taskprocessor ping <blah>operation requires a ping condition lock.
static struct ast_cli_entry taskprocessor_clis []
static struct ao2_containertps_singletons
 tps_singletons is the astobj2 container for taskprocessor singletons

Detailed Description

Maintain a container of uniquely-named taskprocessor threads that can be shared across modules.

Author:
Dwayne Hubbard <dhubbard@digium.com>

Definition in file taskprocessor.c.


Define Documentation

#define TPS_MAX_BUCKETS   7

Definition at line 87 of file taskprocessor.c.

Referenced by ast_tps_init().


Function Documentation

struct ast_taskprocessor* ast_taskprocessor_get ( const char *  name,
enum ast_tps_options  create 
) [read]

Get a reference to a taskprocessor with the specified name and create the taskprocessor if necessary.

The default behavior of instantiating a taskprocessor if one does not already exist can be disabled by specifying the TPS_REF_IF_EXISTS ast_tps_options as the second argument to ast_taskprocessor_get().

Parameters:
name The name of the taskprocessor
create Use 0 by default or specify TPS_REF_IF_EXISTS to return NULL if the taskprocessor does not already exist return A pointer to a reference counted taskprocessor under normal conditions, or NULL if the TPS_REF_IF_EXISTS reference type is specified and the taskprocessor does not exist
Since:
1.6.1

Definition at line 424 of file taskprocessor.c.

References ao2_alloc, ao2_find, ao2_link, ao2_lock, ao2_ref, ao2_unlock, ast_calloc, ast_cond_init, ast_log(), ast_mutex_init, ast_pthread_create, AST_PTHREADT_NULL, ast_strdup, ast_strlen_zero(), LOG_ERROR, LOG_WARNING, ast_taskprocessor::name, OBJ_POINTER, ast_taskprocessor::poll_cond, ast_taskprocessor::poll_thread, ast_taskprocessor::poll_thread_run, ast_taskprocessor::stats, ast_taskprocessor::taskprocessor_lock, tps_processing_function(), TPS_REF_IF_EXISTS, tps_singletons, and tps_taskprocessor_destroy().

Referenced by ast_cc_init(), ast_event_init(), cli_tps_ping(), load_module(), load_objects(), and load_pbx().

00425 {
00426    struct ast_taskprocessor *p, tmp_tps = {
00427       .name = name,
00428    };
00429       
00430    if (ast_strlen_zero(name)) {
00431       ast_log(LOG_ERROR, "requesting a nameless taskprocessor!!!\n");
00432       return NULL;
00433    }
00434    ao2_lock(tps_singletons);
00435    p = ao2_find(tps_singletons, &tmp_tps, OBJ_POINTER);
00436    if (p) {
00437       ao2_unlock(tps_singletons);
00438       return p;
00439    }
00440    if (create & TPS_REF_IF_EXISTS) {
00441       /* calling function does not want a new taskprocessor to be created if it doesn't already exist */
00442       ao2_unlock(tps_singletons);
00443       return NULL;
00444    }
00445    /* create a new taskprocessor */
00446    if (!(p = ao2_alloc(sizeof(*p), tps_taskprocessor_destroy))) {
00447       ao2_unlock(tps_singletons);
00448       ast_log(LOG_WARNING, "failed to create taskprocessor '%s'\n", name);
00449       return NULL;
00450    }
00451 
00452    ast_cond_init(&p->poll_cond, NULL);
00453    ast_mutex_init(&p->taskprocessor_lock);
00454 
00455    if (!(p->stats = ast_calloc(1, sizeof(*p->stats)))) {
00456       ao2_unlock(tps_singletons);
00457       ast_log(LOG_WARNING, "failed to create taskprocessor stats for '%s'\n", name);
00458       ao2_ref(p, -1);
00459       return NULL;
00460    }
00461    if (!(p->name = ast_strdup(name))) {
00462       ao2_unlock(tps_singletons);
00463       ao2_ref(p, -1);
00464       return NULL;
00465    }
00466    p->poll_thread_run = 1;
00467    p->poll_thread = AST_PTHREADT_NULL;
00468    if (ast_pthread_create(&p->poll_thread, NULL, tps_processing_function, p) < 0) {
00469       ao2_unlock(tps_singletons);
00470       ast_log(LOG_ERROR, "Taskprocessor '%s' failed to create the processing thread.\n", p->name);
00471       ao2_ref(p, -1);
00472       return NULL;
00473    }
00474    if (!(ao2_link(tps_singletons, p))) {
00475       ao2_unlock(tps_singletons);
00476       ast_log(LOG_ERROR, "Failed to add taskprocessor '%s' to container\n", p->name);
00477       ao2_ref(p, -1);
00478       return NULL;
00479    }
00480    ao2_unlock(tps_singletons);
00481    return p;
00482 }

const char* ast_taskprocessor_name ( struct ast_taskprocessor tps  ) 

Return the name of the taskprocessor singleton.

Since:
1.6.1

Definition at line 412 of file taskprocessor.c.

References ast_log(), LOG_ERROR, and ast_taskprocessor::name.

00413 {
00414    if (!tps) {
00415       ast_log(LOG_ERROR, "no taskprocessor specified!\n");
00416       return NULL;
00417    }
00418    return tps->name;
00419 }

int ast_taskprocessor_push ( struct ast_taskprocessor tps,
int(*)(void *datap)  task_exe,
void *  datap 
)

Push a task into the specified taskprocessor queue and signal the taskprocessor thread.

Parameters:
tps The taskprocessor structure
task_exe The task handling function to push into the taskprocessor queue
datap The data to be used by the task handling function
Return values:
0 success
-1 failure
Since:
1.6.1

Definition at line 499 of file taskprocessor.c.

References ast_cond_signal, AST_LIST_INSERT_TAIL, ast_log(), ast_mutex_lock, ast_mutex_unlock, LOG_ERROR, ast_taskprocessor::name, ast_taskprocessor::poll_cond, ast_taskprocessor::taskprocessor_lock, ast_taskprocessor::tps_queue, ast_taskprocessor::tps_queue_size, and tps_task_alloc().

Referenced by ast_cc_agent_status_response(), ast_cc_monitor_failed(), ast_cc_monitor_party_b_free(), ast_cc_monitor_status_request(), ast_cc_monitor_stop_ringing(), ast_event_queue(), cc_request_state_change(), cli_tps_ping(), device_state_cb(), generic_agent_devstate_cb(), generic_monitor_devstate_cb(), handle_cc_status(), iax2_transmit(), mwi_sub_event_cb(), and mwi_unsub_event_cb().

00500 {
00501    struct tps_task *t;
00502 
00503    if (!tps || !task_exe) {
00504       ast_log(LOG_ERROR, "%s is missing!!\n", (tps) ? "task callback" : "taskprocessor");
00505       return -1;
00506    }
00507    if (!(t = tps_task_alloc(task_exe, datap))) {
00508       ast_log(LOG_ERROR, "failed to allocate task!  Can't push to '%s'\n", tps->name);
00509       return -1;
00510    }
00511    ast_mutex_lock(&tps->taskprocessor_lock);
00512    AST_LIST_INSERT_TAIL(&tps->tps_queue, t, list);
00513    tps->tps_queue_size++;
00514    ast_cond_signal(&tps->poll_cond);
00515    ast_mutex_unlock(&tps->taskprocessor_lock);
00516    return 0;
00517 }

void* ast_taskprocessor_unreference ( struct ast_taskprocessor tps  ) 

Unreference the specified taskprocessor and its reference count will decrement.

Taskprocessors use astobj2 and will unlink from the taskprocessor singleton container and destroy themself when the taskprocessor reference count reaches zero.

Parameters:
tps taskprocessor to unreference
Returns:
NULL
Since:
1.6.1

Definition at line 485 of file taskprocessor.c.

References ao2_link, ao2_lock, ao2_ref, ao2_unlink, ao2_unlock, and tps_singletons.

Referenced by __unload_module(), cc_shutdown(), event_shutdown(), unload_module(), and unload_pbx().

00486 {
00487    if (tps) {
00488       ao2_lock(tps_singletons);
00489       ao2_unlink(tps_singletons, tps);
00490       if (ao2_ref(tps, -1) > 1) {
00491          ao2_link(tps_singletons, tps);
00492       }
00493       ao2_unlock(tps_singletons);
00494    }
00495    return NULL;
00496 }

int ast_tps_init ( void   ) 

Provided by taskprocessor.c

Definition at line 134 of file taskprocessor.c.

References ao2_container_alloc, ARRAY_LEN, ast_cli_register_multiple(), ast_cond_init, ast_log(), ast_register_atexit(), cli_ping_cond, LOG_ERROR, taskprocessor_clis, tps_cmp_cb(), tps_hash_cb(), TPS_MAX_BUCKETS, tps_shutdown(), and tps_singletons.

Referenced by main().

00135 {
00136    if (!(tps_singletons = ao2_container_alloc(TPS_MAX_BUCKETS, tps_hash_cb, tps_cmp_cb))) {
00137       ast_log(LOG_ERROR, "taskprocessor container failed to initialize!\n");
00138       return -1;
00139    }
00140 
00141    ast_cond_init(&cli_ping_cond, NULL);
00142 
00143    ast_cli_register_multiple(taskprocessor_clis, ARRAY_LEN(taskprocessor_clis));
00144 
00145    ast_register_atexit(tps_shutdown);
00146 
00147    return 0;
00148 }

static char * cli_tps_ping ( struct ast_cli_entry e,
int  cmd,
struct ast_cli_args a 
) [static]

Definition at line 205 of file taskprocessor.c.

References ao2_ref, ast_cli_args::argc, ast_cli_args::argv, ast_cli(), ast_cond_timedwait, ast_mutex_lock, ast_mutex_unlock, ast_samp2tv(), ast_taskprocessor_get(), ast_taskprocessor_push(), ast_tvadd(), ast_tvnow(), ast_tvsub(), CLI_FAILURE, CLI_GENERATE, CLI_INIT, cli_ping_cond, cli_ping_cond_lock, CLI_SHOWUSAGE, CLI_SUCCESS, ast_cli_entry::command, ast_cli_args::fd, name, tps_ping_handler(), TPS_REF_IF_EXISTS, tps_taskprocessor_tab_complete(), and ast_cli_entry::usage.

00206 {
00207    struct timeval begin, end, delta;
00208    const char *name;
00209    struct timeval when;
00210    struct timespec ts;
00211    struct ast_taskprocessor *tps = NULL;
00212 
00213    switch (cmd) {
00214    case CLI_INIT:
00215       e->command = "core ping taskprocessor";
00216       e->usage = 
00217          "Usage: core ping taskprocessor <taskprocessor>\n"
00218          "  Displays the time required for a task to be processed\n";
00219       return NULL;
00220    case CLI_GENERATE:
00221       return tps_taskprocessor_tab_complete(tps, a);
00222    }
00223 
00224    if (a->argc != 4)
00225       return CLI_SHOWUSAGE;
00226 
00227    name = a->argv[3];
00228    if (!(tps = ast_taskprocessor_get(name, TPS_REF_IF_EXISTS))) {
00229       ast_cli(a->fd, "\nping failed: %s not found\n\n", name);
00230       return CLI_SUCCESS;
00231    }
00232    ast_cli(a->fd, "\npinging %s ...", name);
00233    when = ast_tvadd((begin = ast_tvnow()), ast_samp2tv(1000, 1000));
00234    ts.tv_sec = when.tv_sec;
00235    ts.tv_nsec = when.tv_usec * 1000;
00236    ast_mutex_lock(&cli_ping_cond_lock);
00237    if (ast_taskprocessor_push(tps, tps_ping_handler, 0) < 0) {
00238       ast_cli(a->fd, "\nping failed: could not push task to %s\n\n", name);
00239       ao2_ref(tps, -1);
00240       return CLI_FAILURE;
00241    }
00242    ast_cond_timedwait(&cli_ping_cond, &cli_ping_cond_lock, &ts);
00243    ast_mutex_unlock(&cli_ping_cond_lock);
00244    end = ast_tvnow();
00245    delta = ast_tvsub(end, begin);
00246    ast_cli(a->fd, "\n\t%24s ping time: %.1ld.%.6ld sec\n\n", name, (long)delta.tv_sec, (long int)delta.tv_usec);
00247    ao2_ref(tps, -1);
00248    return CLI_SUCCESS;  
00249 }

static char * cli_tps_report ( struct ast_cli_entry e,
int  cmd,
struct ast_cli_args a 
) [static]

Definition at line 251 of file taskprocessor.c.

References tps_taskprocessor_stats::_tasks_processed_count, ao2_container_count(), ao2_iterator_destroy(), ao2_iterator_init(), ao2_iterator_next, ao2_ref, ast_cli_args::argc, ast_cli_entry::args, ast_cli(), ast_copy_string(), CLI_GENERATE, CLI_INIT, CLI_SHOWUSAGE, CLI_SUCCESS, ast_cli_entry::command, ast_cli_args::fd, tps_taskprocessor_stats::max_qsize, ast_taskprocessor::name, name, ast_taskprocessor::stats, ast_taskprocessor::tps_queue_size, tps_singletons, and ast_cli_entry::usage.

00252 {
00253    char name[256];
00254    int tcount;
00255    unsigned long qsize;
00256    unsigned long maxqsize;
00257    unsigned long processed;
00258    struct ast_taskprocessor *p;
00259    struct ao2_iterator i;
00260 
00261    switch (cmd) {
00262    case CLI_INIT:
00263       e->command = "core show taskprocessors";
00264       e->usage = 
00265          "Usage: core show taskprocessors\n"
00266          "  Shows a list of instantiated task processors and their statistics\n";
00267       return NULL;
00268    case CLI_GENERATE:
00269       return NULL;   
00270    }
00271 
00272    if (a->argc != e->args)
00273       return CLI_SHOWUSAGE;
00274 
00275    ast_cli(a->fd, "\n\t+----- Processor -----+--- Processed ---+- In Queue -+- Max Depth -+");
00276    i = ao2_iterator_init(tps_singletons, 0);
00277    while ((p = ao2_iterator_next(&i))) {
00278       ast_copy_string(name, p->name, sizeof(name));
00279       qsize = p->tps_queue_size;
00280       maxqsize = p->stats->max_qsize;
00281       processed = p->stats->_tasks_processed_count;
00282       ast_cli(a->fd, "\n%24s   %17lu %12lu %12lu", name, processed, qsize, maxqsize);
00283       ao2_ref(p, -1);
00284    }
00285    ao2_iterator_destroy(&i);
00286    tcount = ao2_container_count(tps_singletons); 
00287    ast_cli(a->fd, "\n\t+---------------------+-----------------+------------+-------------+\n\t%d taskprocessors\n\n", tcount);
00288    return CLI_SUCCESS;  
00289 }

static int tps_cmp_cb ( void *  obj,
void *  arg,
int  flags 
) [static]

The astobj2 compare callback for taskprocessors.

Definition at line 355 of file taskprocessor.c.

References CMP_MATCH, CMP_STOP, and ast_taskprocessor::name.

Referenced by ast_tps_init().

00356 {
00357    struct ast_taskprocessor *lhs = obj, *rhs = arg;
00358 
00359    return !strcasecmp(lhs->name, rhs->name) ? CMP_MATCH | CMP_STOP : 0;
00360 }

static int tps_hash_cb ( const void *  obj,
const int  flags 
) [static]

The astobj2 hash callback for taskprocessors.

Definition at line 347 of file taskprocessor.c.

References ast_str_case_hash(), and ast_taskprocessor::name.

Referenced by ast_tps_init().

00348 {
00349    const struct ast_taskprocessor *tps = obj;
00350 
00351    return ast_str_case_hash(tps->name);
00352 }

static int tps_ping_handler ( void *  datap  )  [static]

CLI taskprocessor ping <blah>handler function.

Definition at line 196 of file taskprocessor.c.

References ast_cond_signal, ast_mutex_lock, ast_mutex_unlock, cli_ping_cond, and cli_ping_cond_lock.

Referenced by cli_tps_ping().

00197 {
00198    ast_mutex_lock(&cli_ping_cond_lock);
00199    ast_cond_signal(&cli_ping_cond);
00200    ast_mutex_unlock(&cli_ping_cond_lock);
00201    return 0;
00202 }

static void * tps_processing_function ( void *  data  )  [static]

The task processing function executed by a taskprocessor.

Definition at line 292 of file taskprocessor.c.

References tps_taskprocessor_stats::_tasks_processed_count, ast_cond_wait, ast_log(), ast_mutex_lock, ast_mutex_unlock, tps_task::datap, tps_task::execute, LOG_ERROR, LOG_WARNING, tps_taskprocessor_stats::max_qsize, ast_taskprocessor::poll_cond, ast_taskprocessor::poll_thread_run, ast_taskprocessor::stats, ast_taskprocessor::taskprocessor_lock, tps_task_free(), tps_taskprocessor_depth(), and tps_taskprocessor_pop().

Referenced by ast_taskprocessor_get().

00293 {
00294    struct ast_taskprocessor *i = data;
00295    struct tps_task *t;
00296    int size;
00297 
00298    if (!i) {
00299       ast_log(LOG_ERROR, "cannot start thread_function loop without a ast_taskprocessor structure.\n");
00300       return NULL;
00301    }
00302 
00303    while (i->poll_thread_run) {
00304       ast_mutex_lock(&i->taskprocessor_lock);
00305       if (!i->poll_thread_run) {
00306          ast_mutex_unlock(&i->taskprocessor_lock);
00307          break;
00308       }
00309       if (!(size = tps_taskprocessor_depth(i))) {
00310          ast_cond_wait(&i->poll_cond, &i->taskprocessor_lock);
00311          if (!i->poll_thread_run) {
00312             ast_mutex_unlock(&i->taskprocessor_lock);
00313             break;
00314          }
00315       }
00316       ast_mutex_unlock(&i->taskprocessor_lock);
00317       /* stuff is in the queue */
00318       if (!(t = tps_taskprocessor_pop(i))) {
00319          ast_log(LOG_ERROR, "Wtf?? %d tasks in the queue, but we're popping blanks!\n", size);
00320          continue;
00321       }
00322       if (!t->execute) {
00323          ast_log(LOG_WARNING, "Task is missing a function to execute!\n");
00324          tps_task_free(t);
00325          continue;
00326       }
00327       t->execute(t->datap);
00328  
00329       ast_mutex_lock(&i->taskprocessor_lock);
00330       if (i->stats) {
00331          i->stats->_tasks_processed_count++;
00332          if (size > i->stats->max_qsize) {
00333             i->stats->max_qsize = size;
00334          }
00335       }
00336       ast_mutex_unlock(&i->taskprocessor_lock);
00337  
00338       tps_task_free(t);
00339    }
00340    while ((t = tps_taskprocessor_pop(i))) {
00341       tps_task_free(t);
00342    }
00343    return NULL;
00344 }

static void tps_shutdown ( void   )  [static]

Definition at line 126 of file taskprocessor.c.

References ao2_t_ref, ARRAY_LEN, ast_cli_unregister_multiple(), taskprocessor_clis, and tps_singletons.

Referenced by ast_tps_init().

00127 {
00128    ast_cli_unregister_multiple(taskprocessor_clis, ARRAY_LEN(taskprocessor_clis));
00129    ao2_t_ref(tps_singletons, -1, "Unref tps_singletons in shutdown");
00130    tps_singletons = NULL;
00131 }

static struct tps_task* tps_task_alloc ( int(*)(void *datap)  task_exe,
void *  datap 
) [static, read]

Definition at line 151 of file taskprocessor.c.

References ast_calloc, tps_task::datap, and tps_task::execute.

Referenced by ast_taskprocessor_push().

00152 {
00153    struct tps_task *t;
00154    if ((t = ast_calloc(1, sizeof(*t)))) {
00155       t->execute = task_exe;
00156       t->datap = datap;
00157    }
00158    return t;
00159 }

static void* tps_task_free ( struct tps_task task  )  [static]

Definition at line 162 of file taskprocessor.c.

References ast_free.

Referenced by tps_processing_function().

00163 {
00164    if (task) {
00165       ast_free(task);
00166    }
00167    return NULL;
00168 }

static int tps_taskprocessor_depth ( struct ast_taskprocessor tps  )  [static]

Return the size of the taskprocessor queue.

Definition at line 406 of file taskprocessor.c.

References ast_taskprocessor::tps_queue_size.

Referenced by tps_processing_function().

00407 {
00408    return (tps) ? tps->tps_queue_size : -1;
00409 }

static void tps_taskprocessor_destroy ( void *  tps  )  [static]

Destroy the taskprocessor when its refcount reaches zero.

Definition at line 363 of file taskprocessor.c.

References ast_cond_destroy, ast_cond_signal, ast_free, ast_log(), ast_mutex_destroy, ast_mutex_lock, ast_mutex_unlock, AST_PTHREADT_NULL, LOG_DEBUG, LOG_ERROR, ast_taskprocessor::name, ast_taskprocessor::poll_cond, ast_taskprocessor::poll_thread, ast_taskprocessor::poll_thread_run, ast_taskprocessor::stats, and ast_taskprocessor::taskprocessor_lock.

Referenced by ast_taskprocessor_get().

00364 {
00365    struct ast_taskprocessor *t = tps;
00366    
00367    if (!tps) {
00368       ast_log(LOG_ERROR, "missing taskprocessor\n");
00369       return;
00370    }
00371    ast_log(LOG_DEBUG, "destroying taskprocessor '%s'\n", t->name);
00372    /* kill it */  
00373    ast_mutex_lock(&t->taskprocessor_lock);
00374    t->poll_thread_run = 0;
00375    ast_cond_signal(&t->poll_cond);
00376    ast_mutex_unlock(&t->taskprocessor_lock);
00377    pthread_join(t->poll_thread, NULL);
00378    t->poll_thread = AST_PTHREADT_NULL;
00379    ast_mutex_destroy(&t->taskprocessor_lock);
00380    ast_cond_destroy(&t->poll_cond);
00381    /* free it */
00382    if (t->stats) {
00383       ast_free(t->stats);
00384       t->stats = NULL;
00385    }
00386    ast_free((char *) t->name);
00387 }

static struct tps_task * tps_taskprocessor_pop ( struct ast_taskprocessor tps  )  [static, read]

Remove the front task off the taskprocessor queue.

Definition at line 390 of file taskprocessor.c.

References AST_LIST_REMOVE_HEAD, ast_log(), ast_mutex_lock, ast_mutex_unlock, LOG_ERROR, ast_taskprocessor::taskprocessor_lock, ast_taskprocessor::tps_queue, and ast_taskprocessor::tps_queue_size.

Referenced by tps_processing_function().

00391 {
00392    struct tps_task *task;
00393 
00394    if (!tps) {
00395       ast_log(LOG_ERROR, "missing taskprocessor\n");
00396       return NULL;
00397    }
00398    ast_mutex_lock(&tps->taskprocessor_lock);
00399    if ((task = AST_LIST_REMOVE_HEAD(&tps->tps_queue, list))) {
00400       tps->tps_queue_size--;
00401    }
00402    ast_mutex_unlock(&tps->taskprocessor_lock);
00403    return task;
00404 }

static char* tps_taskprocessor_tab_complete ( struct ast_taskprocessor p,
struct ast_cli_args a 
) [static]

Definition at line 171 of file taskprocessor.c.

References ao2_iterator_destroy(), ao2_iterator_init(), ao2_iterator_next, ao2_ref, ast_strdup, ast_cli_args::n, ast_taskprocessor::name, name, ast_cli_args::pos, tps_singletons, and ast_cli_args::word.

Referenced by cli_tps_ping().

00172 {
00173    int tklen;
00174    int wordnum = 0;
00175    char *name = NULL;
00176    struct ao2_iterator i;
00177 
00178    if (a->pos != 3)
00179       return NULL;
00180 
00181    tklen = strlen(a->word);
00182    i = ao2_iterator_init(tps_singletons, 0);
00183    while ((p = ao2_iterator_next(&i))) {
00184       if (!strncasecmp(a->word, p->name, tklen) && ++wordnum > a->n) {
00185          name = ast_strdup(p->name);
00186          ao2_ref(p, -1);
00187          break;
00188       }
00189       ao2_ref(p, -1);
00190    }
00191    ao2_iterator_destroy(&i);
00192    return name;
00193 }


Variable Documentation

CLI taskprocessor ping <blah>operation requires a ping condition.

Definition at line 92 of file taskprocessor.c.

Referenced by ast_tps_init(), cli_tps_ping(), and tps_ping_handler().

ast_mutex_t cli_ping_cond_lock = { PTHREAD_RECURSIVE_MUTEX_INITIALIZER_NP , NULL, 1 } [static]

CLI taskprocessor ping <blah>operation requires a ping condition lock.

Definition at line 95 of file taskprocessor.c.

Referenced by cli_tps_ping(), and tps_ping_handler().

struct ast_cli_entry taskprocessor_clis[] [static]
Initial value:
 {
   AST_CLI_DEFINE(cli_tps_ping, "Ping a named task processor"),
   AST_CLI_DEFINE(cli_tps_report, "List instantiated task processors and statistics"),
}

Definition at line 120 of file taskprocessor.c.

Referenced by ast_tps_init(), and tps_shutdown().

struct ao2_container* tps_singletons [static]

tps_singletons is the astobj2 container for taskprocessor singletons

Definition at line 89 of file taskprocessor.c.

Referenced by ast_taskprocessor_get(), ast_taskprocessor_unreference(), ast_tps_init(), cli_tps_report(), tps_shutdown(), and tps_taskprocessor_tab_complete().


Generated on 17 Aug 2018 for Asterisk - The Open Source Telephony Project by  doxygen 1.6.1