Sat Mar 10 01:55:49 2012

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  ast_taskprocessor::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

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

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 409 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, 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().

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

const char* ast_taskprocessor_name ( struct ast_taskprocessor tps  ) 

Return the name of the taskprocessor singleton.

Since:
1.6.1

Definition at line 397 of file taskprocessor.c.

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

00398 {
00399    if (!tps) {
00400       ast_log(LOG_ERROR, "no taskprocessor specified!\n");
00401       return NULL;
00402    }
00403    return tps->name;
00404 }

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

00485 {
00486    struct tps_task *t;
00487 
00488    if (!tps || !task_exe) {
00489       ast_log(LOG_ERROR, "%s is missing!!\n", (tps) ? "task callback" : "taskprocessor");
00490       return -1;
00491    }
00492    if (!(t = tps_task_alloc(task_exe, datap))) {
00493       ast_log(LOG_ERROR, "failed to allocate task!  Can't push to '%s'\n", tps->name);
00494       return -1;
00495    }
00496    ast_mutex_lock(&tps->taskprocessor_lock);
00497    AST_LIST_INSERT_TAIL(&tps->tps_queue, t, list);
00498    tps->tps_queue_size++;
00499    ast_cond_signal(&tps->poll_cond);
00500    ast_mutex_unlock(&tps->taskprocessor_lock);
00501    return 0;
00502 }

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 470 of file taskprocessor.c.

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

Referenced by __unload_module(), and unload_module().

00471 {
00472    if (tps) {
00473       ao2_lock(tps_singletons);
00474       ao2_unlink(tps_singletons, tps);
00475       if (ao2_ref(tps, -1) > 1) {
00476          ao2_link(tps_singletons, tps);
00477       }
00478       ao2_unlock(tps_singletons);
00479    }
00480    return NULL;
00481 }

int ast_tps_init ( void   ) 

Provided by taskprocessor.c

Definition at line 122 of file taskprocessor.c.

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

Referenced by main().

00123 {
00124    if (!(tps_singletons = ao2_container_alloc(TPS_MAX_BUCKETS, tps_hash_cb, tps_cmp_cb))) {
00125       ast_log(LOG_ERROR, "taskprocessor container failed to initialize!\n");
00126       return -1;
00127    }
00128 
00129    ast_cond_init(&cli_ping_cond, NULL);
00130 
00131    ast_cli_register_multiple(taskprocessor_clis, ARRAY_LEN(taskprocessor_clis));
00132    return 0;
00133 }

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

Definition at line 190 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.

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

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

Definition at line 236 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.

00237 {
00238    char name[256];
00239    int tcount;
00240    unsigned long qsize;
00241    unsigned long maxqsize;
00242    unsigned long processed;
00243    struct ast_taskprocessor *p;
00244    struct ao2_iterator i;
00245 
00246    switch (cmd) {
00247    case CLI_INIT:
00248       e->command = "core show taskprocessors";
00249       e->usage = 
00250          "Usage: core show taskprocessors\n"
00251          "  Shows a list of instantiated task processors and their statistics\n";
00252       return NULL;
00253    case CLI_GENERATE:
00254       return NULL;   
00255    }
00256 
00257    if (a->argc != e->args)
00258       return CLI_SHOWUSAGE;
00259 
00260    ast_cli(a->fd, "\n\t+----- Processor -----+--- Processed ---+- In Queue -+- Max Depth -+");
00261    i = ao2_iterator_init(tps_singletons, 0);
00262    while ((p = ao2_iterator_next(&i))) {
00263       ast_copy_string(name, p->name, sizeof(name));
00264       qsize = p->tps_queue_size;
00265       maxqsize = p->stats->max_qsize;
00266       processed = p->stats->_tasks_processed_count;
00267       ast_cli(a->fd, "\n%24s   %17ld %12ld %12ld", name, processed, qsize, maxqsize);
00268       ao2_ref(p, -1);
00269    }
00270    ao2_iterator_destroy(&i);
00271    tcount = ao2_container_count(tps_singletons); 
00272    ast_cli(a->fd, "\n\t+---------------------+-----------------+------------+-------------+\n\t%d taskprocessors\n\n", tcount);
00273    return CLI_SUCCESS;  
00274 }

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

The astobj2 compare callback for taskprocessors.

Definition at line 340 of file taskprocessor.c.

References CMP_MATCH, CMP_STOP, and ast_taskprocessor::name.

Referenced by ast_tps_init().

00341 {
00342    struct ast_taskprocessor *lhs = obj, *rhs = arg;
00343 
00344    return !strcasecmp(lhs->name, rhs->name) ? CMP_MATCH | CMP_STOP : 0;
00345 }

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

The astobj2 hash callback for taskprocessors.

Definition at line 332 of file taskprocessor.c.

References ast_str_case_hash(), and ast_taskprocessor::name.

Referenced by ast_tps_init().

00333 {
00334    const struct ast_taskprocessor *tps = obj;
00335 
00336    return ast_str_case_hash(tps->name);
00337 }

static int tps_ping_handler ( void *  datap  )  [static]

CLI taskprocessor ping <blah>

handler function.

Definition at line 181 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().

00182 {
00183    ast_mutex_lock(&cli_ping_cond_lock);
00184    ast_cond_signal(&cli_ping_cond);
00185    ast_mutex_unlock(&cli_ping_cond_lock);
00186    return 0;
00187 }

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

The task processing function executed by a taskprocessor.

Definition at line 277 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().

00278 {
00279    struct ast_taskprocessor *i = data;
00280    struct tps_task *t;
00281    int size;
00282 
00283    if (!i) {
00284       ast_log(LOG_ERROR, "cannot start thread_function loop without a ast_taskprocessor structure.\n");
00285       return NULL;
00286    }
00287 
00288    while (i->poll_thread_run) {
00289       ast_mutex_lock(&i->taskprocessor_lock);
00290       if (!i->poll_thread_run) {
00291          ast_mutex_unlock(&i->taskprocessor_lock);
00292          break;
00293       }
00294       if (!(size = tps_taskprocessor_depth(i))) {
00295          ast_cond_wait(&i->poll_cond, &i->taskprocessor_lock);
00296          if (!i->poll_thread_run) {
00297             ast_mutex_unlock(&i->taskprocessor_lock);
00298             break;
00299          }
00300       }
00301       ast_mutex_unlock(&i->taskprocessor_lock);
00302       /* stuff is in the queue */
00303       if (!(t = tps_taskprocessor_pop(i))) {
00304          ast_log(LOG_ERROR, "Wtf?? %d tasks in the queue, but we're popping blanks!\n", size);
00305          continue;
00306       }
00307       if (!t->execute) {
00308          ast_log(LOG_WARNING, "Task is missing a function to execute!\n");
00309          tps_task_free(t);
00310          continue;
00311       }
00312       t->execute(t->datap);
00313  
00314       ast_mutex_lock(&i->taskprocessor_lock);
00315       if (i->stats) {
00316          i->stats->_tasks_processed_count++;
00317          if (size > i->stats->max_qsize) {
00318             i->stats->max_qsize = size;
00319          }
00320       }
00321       ast_mutex_unlock(&i->taskprocessor_lock);
00322  
00323       tps_task_free(t);
00324    }
00325    while ((t = tps_taskprocessor_pop(i))) {
00326       tps_task_free(t);
00327    }
00328    return NULL;
00329 }

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

Definition at line 136 of file taskprocessor.c.

References ast_calloc, and tps_task::execute.

Referenced by ast_taskprocessor_push().

00137 {
00138    struct tps_task *t;
00139    if ((t = ast_calloc(1, sizeof(*t)))) {
00140       t->execute = task_exe;
00141       t->datap = datap;
00142    }
00143    return t;
00144 }

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

Definition at line 147 of file taskprocessor.c.

References ast_free.

Referenced by tps_processing_function().

00148 {
00149    if (task) {
00150       ast_free(task);
00151    }
00152    return NULL;
00153 }

static int tps_taskprocessor_depth ( struct ast_taskprocessor tps  )  [static]

Return the size of the taskprocessor queue.

Definition at line 391 of file taskprocessor.c.

References ast_taskprocessor::tps_queue_size.

Referenced by tps_processing_function().

00392 {
00393    return (tps) ? tps->tps_queue_size : -1;
00394 }

static void tps_taskprocessor_destroy ( void *  tps  )  [static]

Destroy the taskprocessor when its refcount reaches zero.

Definition at line 348 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().

00349 {
00350    struct ast_taskprocessor *t = tps;
00351    
00352    if (!tps) {
00353       ast_log(LOG_ERROR, "missing taskprocessor\n");
00354       return;
00355    }
00356    ast_log(LOG_DEBUG, "destroying taskprocessor '%s'\n", t->name);
00357    /* kill it */  
00358    ast_mutex_lock(&t->taskprocessor_lock);
00359    t->poll_thread_run = 0;
00360    ast_cond_signal(&t->poll_cond);
00361    ast_mutex_unlock(&t->taskprocessor_lock);
00362    pthread_join(t->poll_thread, NULL);
00363    t->poll_thread = AST_PTHREADT_NULL;
00364    ast_mutex_destroy(&t->taskprocessor_lock);
00365    ast_cond_destroy(&t->poll_cond);
00366    /* free it */
00367    if (t->stats) {
00368       ast_free(t->stats);
00369       t->stats = NULL;
00370    }
00371    ast_free((char *) t->name);
00372 }

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

Remove the front task off the taskprocessor queue.

Definition at line 375 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().

00376 {
00377    struct tps_task *task;
00378 
00379    if (!tps) {
00380       ast_log(LOG_ERROR, "missing taskprocessor\n");
00381       return NULL;
00382    }
00383    ast_mutex_lock(&tps->taskprocessor_lock);
00384    if ((task = AST_LIST_REMOVE_HEAD(&tps->tps_queue, list))) {
00385       tps->tps_queue_size--;
00386    }
00387    ast_mutex_unlock(&tps->taskprocessor_lock);
00388    return task;
00389 }

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

Definition at line 156 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().

00157 {
00158    int tklen;
00159    int wordnum = 0;
00160    char *name = NULL;
00161    struct ao2_iterator i;
00162 
00163    if (a->pos != 3)
00164       return NULL;
00165 
00166    tklen = strlen(a->word);
00167    i = ao2_iterator_init(tps_singletons, 0);
00168    while ((p = ao2_iterator_next(&i))) {
00169       if (!strncasecmp(a->word, p->name, tklen) && ++wordnum > a->n) {
00170          name = ast_strdup(p->name);
00171          ao2_ref(p, -1);
00172          break;
00173       }
00174       ao2_ref(p, -1);
00175    }
00176    ao2_iterator_destroy(&i);
00177    return name;
00178 }


Variable Documentation

ast_cond_t cli_ping_cond [static]

CLI taskprocessor ping <blah>

operation requires a ping condition.

Definition at line 88 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 91 of file taskprocessor.c.

Referenced by cli_tps_ping(), and tps_ping_handler().

struct ast_cli_entry taskprocessor_clis[] [static]

Initial value:

 {
   { .handler =  cli_tps_ping , .summary =  "Ping a named task processor" ,__VA_ARGS__ },
   { .handler =  cli_tps_report , .summary =  "List instantiated task processors and statistics" ,__VA_ARGS__ },
}

Definition at line 116 of file taskprocessor.c.

Referenced by ast_tps_init().

struct ao2_container* tps_singletons [static]

tps_singletons is the astobj2 container for taskprocessor singletons

Definition at line 85 of file taskprocessor.c.

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


Generated on Sat Mar 10 01:55:49 2012 for Asterisk - The Open Source Telephony Project by  doxygen 1.4.7