#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_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. | |
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> | |
static void * | tps_processing_function (void *data) |
The task processing function executed by a taskprocessor. | |
static struct tps_task * | tps_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_task * | tps_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> | |
static ast_mutex_t | cli_ping_cond_lock = { PTHREAD_RECURSIVE_MUTEX_INITIALIZER_NP , NULL, 1 } |
CLI taskprocessor ping <blah> | |
static struct ast_cli_entry | taskprocessor_clis [] |
static struct ao2_container * | tps_singletons |
tps_singletons is the astobj2 container for taskprocessor singletons |
Definition in file taskprocessor.c.
#define TPS_MAX_BUCKETS 7 |
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().
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 |
Definition at line 407 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().
00408 { 00409 struct ast_taskprocessor *p, tmp_tps = { 00410 .name = name, 00411 }; 00412 00413 if (ast_strlen_zero(name)) { 00414 ast_log(LOG_ERROR, "requesting a nameless taskprocessor!!!\n"); 00415 return NULL; 00416 } 00417 ao2_lock(tps_singletons); 00418 p = ao2_find(tps_singletons, &tmp_tps, OBJ_POINTER); 00419 if (p) { 00420 ao2_unlock(tps_singletons); 00421 return p; 00422 } 00423 if (create & TPS_REF_IF_EXISTS) { 00424 /* calling function does not want a new taskprocessor to be created if it doesn't already exist */ 00425 ao2_unlock(tps_singletons); 00426 return NULL; 00427 } 00428 /* create a new taskprocessor */ 00429 if (!(p = ao2_alloc(sizeof(*p), tps_taskprocessor_destroy))) { 00430 ao2_unlock(tps_singletons); 00431 ast_log(LOG_WARNING, "failed to create taskprocessor '%s'\n", name); 00432 return NULL; 00433 } 00434 00435 ast_cond_init(&p->poll_cond, NULL); 00436 ast_mutex_init(&p->taskprocessor_lock); 00437 00438 if (!(p->stats = ast_calloc(1, sizeof(*p->stats)))) { 00439 ao2_unlock(tps_singletons); 00440 ast_log(LOG_WARNING, "failed to create taskprocessor stats for '%s'\n", name); 00441 ao2_ref(p, -1); 00442 return NULL; 00443 } 00444 if (!(p->name = ast_strdup(name))) { 00445 ao2_unlock(tps_singletons); 00446 ao2_ref(p, -1); 00447 return NULL; 00448 } 00449 p->poll_thread_run = 1; 00450 p->poll_thread = AST_PTHREADT_NULL; 00451 if (ast_pthread_create(&p->poll_thread, NULL, tps_processing_function, p) < 0) { 00452 ao2_unlock(tps_singletons); 00453 ast_log(LOG_ERROR, "Taskprocessor '%s' failed to create the processing thread.\n", p->name); 00454 ao2_ref(p, -1); 00455 return NULL; 00456 } 00457 if (!(ao2_link(tps_singletons, p))) { 00458 ao2_unlock(tps_singletons); 00459 ast_log(LOG_ERROR, "Failed to add taskprocessor '%s' to container\n", p->name); 00460 ao2_ref(p, -1); 00461 return NULL; 00462 } 00463 ao2_unlock(tps_singletons); 00464 return p; 00465 }
const char* ast_taskprocessor_name | ( | struct ast_taskprocessor * | tps | ) |
Return the name of the taskprocessor singleton.
Definition at line 395 of file taskprocessor.c.
References ast_log(), LOG_ERROR, and ast_taskprocessor::name.
00396 { 00397 if (!tps) { 00398 ast_log(LOG_ERROR, "no taskprocessor specified!\n"); 00399 return NULL; 00400 } 00401 return tps->name; 00402 }
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.
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 |
0 | success | |
-1 | failure |
Definition at line 482 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().
00483 { 00484 struct tps_task *t; 00485 00486 if (!tps || !task_exe) { 00487 ast_log(LOG_ERROR, "%s is missing!!\n", (tps) ? "task callback" : "taskprocessor"); 00488 return -1; 00489 } 00490 if (!(t = tps_task_alloc(task_exe, datap))) { 00491 ast_log(LOG_ERROR, "failed to allocate task! Can't push to '%s'\n", tps->name); 00492 return -1; 00493 } 00494 ast_mutex_lock(&tps->taskprocessor_lock); 00495 AST_LIST_INSERT_TAIL(&tps->tps_queue, t, list); 00496 tps->tps_queue_size++; 00497 ast_cond_signal(&tps->poll_cond); 00498 ast_mutex_unlock(&tps->taskprocessor_lock); 00499 return 0; 00500 }
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.
tps | taskprocessor to unreference |
Definition at line 468 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().
00469 { 00470 if (tps) { 00471 ao2_lock(tps_singletons); 00472 ao2_unlink(tps_singletons, tps); 00473 if (ao2_ref(tps, -1) > 1) { 00474 ao2_link(tps_singletons, tps); 00475 } 00476 ao2_unlock(tps_singletons); 00477 } 00478 return NULL; 00479 }
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 189 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.
00190 { 00191 struct timeval begin, end, delta; 00192 const char *name; 00193 struct timeval when; 00194 struct timespec ts; 00195 struct ast_taskprocessor *tps = NULL; 00196 00197 switch (cmd) { 00198 case CLI_INIT: 00199 e->command = "core ping taskprocessor"; 00200 e->usage = 00201 "Usage: core ping taskprocessor <taskprocessor>\n" 00202 " Displays the time required for a task to be processed\n"; 00203 return NULL; 00204 case CLI_GENERATE: 00205 return tps_taskprocessor_tab_complete(tps, a); 00206 } 00207 00208 if (a->argc != 4) 00209 return CLI_SHOWUSAGE; 00210 00211 name = a->argv[3]; 00212 if (!(tps = ast_taskprocessor_get(name, TPS_REF_IF_EXISTS))) { 00213 ast_cli(a->fd, "\nping failed: %s not found\n\n", name); 00214 return CLI_SUCCESS; 00215 } 00216 ast_cli(a->fd, "\npinging %s ...", name); 00217 when = ast_tvadd((begin = ast_tvnow()), ast_samp2tv(1000, 1000)); 00218 ts.tv_sec = when.tv_sec; 00219 ts.tv_nsec = when.tv_usec * 1000; 00220 ast_mutex_lock(&cli_ping_cond_lock); 00221 if (ast_taskprocessor_push(tps, tps_ping_handler, 0) < 0) { 00222 ast_cli(a->fd, "\nping failed: could not push task to %s\n\n", name); 00223 ao2_ref(tps, -1); 00224 return CLI_FAILURE; 00225 } 00226 ast_cond_timedwait(&cli_ping_cond, &cli_ping_cond_lock, &ts); 00227 ast_mutex_unlock(&cli_ping_cond_lock); 00228 end = ast_tvnow(); 00229 delta = ast_tvsub(end, begin); 00230 ast_cli(a->fd, "\n\t%24s ping time: %.1ld.%.6ld sec\n\n", name, (long)delta.tv_sec, (long int)delta.tv_usec); 00231 ao2_ref(tps, -1); 00232 return CLI_SUCCESS; 00233 }
static char * cli_tps_report | ( | struct ast_cli_entry * | e, | |
int | cmd, | |||
struct ast_cli_args * | a | |||
) | [static] |
Definition at line 235 of file taskprocessor.c.
References tps_taskprocessor_stats::_tasks_processed_count, ao2_container_count(), 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.
00236 { 00237 char name[256]; 00238 int tcount; 00239 unsigned long qsize; 00240 unsigned long maxqsize; 00241 unsigned long processed; 00242 struct ast_taskprocessor *p; 00243 struct ao2_iterator i; 00244 00245 switch (cmd) { 00246 case CLI_INIT: 00247 e->command = "core show taskprocessors"; 00248 e->usage = 00249 "Usage: core show taskprocessors\n" 00250 " Shows a list of instantiated task processors and their statistics\n"; 00251 return NULL; 00252 case CLI_GENERATE: 00253 return NULL; 00254 } 00255 00256 if (a->argc != e->args) 00257 return CLI_SHOWUSAGE; 00258 00259 ast_cli(a->fd, "\n\t+----- Processor -----+--- Processed ---+- In Queue -+- Max Depth -+"); 00260 i = ao2_iterator_init(tps_singletons, 0); 00261 while ((p = ao2_iterator_next(&i))) { 00262 ast_copy_string(name, p->name, sizeof(name)); 00263 qsize = p->tps_queue_size; 00264 maxqsize = p->stats->max_qsize; 00265 processed = p->stats->_tasks_processed_count; 00266 ast_cli(a->fd, "\n%24s %17ld %12ld %12ld", name, processed, qsize, maxqsize); 00267 ao2_ref(p, -1); 00268 } 00269 tcount = ao2_container_count(tps_singletons); 00270 ast_cli(a->fd, "\n\t+---------------------+-----------------+------------+-------------+\n\t%d taskprocessors\n\n", tcount); 00271 return CLI_SUCCESS; 00272 }
static int tps_cmp_cb | ( | void * | obj, | |
void * | arg, | |||
int | flags | |||
) | [static] |
The astobj2 compare callback for taskprocessors.
Definition at line 338 of file taskprocessor.c.
References CMP_MATCH, CMP_STOP, and ast_taskprocessor::name.
Referenced by ast_tps_init().
00339 { 00340 struct ast_taskprocessor *lhs = obj, *rhs = arg; 00341 00342 return !strcasecmp(lhs->name, rhs->name) ? CMP_MATCH | CMP_STOP : 0; 00343 }
static int tps_hash_cb | ( | const void * | obj, | |
const int | flags | |||
) | [static] |
The astobj2 hash callback for taskprocessors.
Definition at line 330 of file taskprocessor.c.
References ast_str_case_hash(), and ast_taskprocessor::name.
Referenced by ast_tps_init().
00331 { 00332 const struct ast_taskprocessor *tps = obj; 00333 00334 return ast_str_case_hash(tps->name); 00335 }
static int tps_ping_handler | ( | void * | datap | ) | [static] |
CLI taskprocessor ping <blah>
handler function.
Definition at line 180 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().
00181 { 00182 ast_mutex_lock(&cli_ping_cond_lock); 00183 ast_cond_signal(&cli_ping_cond); 00184 ast_mutex_unlock(&cli_ping_cond_lock); 00185 return 0; 00186 }
static void * tps_processing_function | ( | void * | data | ) | [static] |
The task processing function executed by a taskprocessor.
Definition at line 275 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().
00276 { 00277 struct ast_taskprocessor *i = data; 00278 struct tps_task *t; 00279 int size; 00280 00281 if (!i) { 00282 ast_log(LOG_ERROR, "cannot start thread_function loop without a ast_taskprocessor structure.\n"); 00283 return NULL; 00284 } 00285 00286 while (i->poll_thread_run) { 00287 ast_mutex_lock(&i->taskprocessor_lock); 00288 if (!i->poll_thread_run) { 00289 ast_mutex_unlock(&i->taskprocessor_lock); 00290 break; 00291 } 00292 if (!(size = tps_taskprocessor_depth(i))) { 00293 ast_cond_wait(&i->poll_cond, &i->taskprocessor_lock); 00294 if (!i->poll_thread_run) { 00295 ast_mutex_unlock(&i->taskprocessor_lock); 00296 break; 00297 } 00298 } 00299 ast_mutex_unlock(&i->taskprocessor_lock); 00300 /* stuff is in the queue */ 00301 if (!(t = tps_taskprocessor_pop(i))) { 00302 ast_log(LOG_ERROR, "Wtf?? %d tasks in the queue, but we're popping blanks!\n", size); 00303 continue; 00304 } 00305 if (!t->execute) { 00306 ast_log(LOG_WARNING, "Task is missing a function to execute!\n"); 00307 tps_task_free(t); 00308 continue; 00309 } 00310 t->execute(t->datap); 00311 00312 ast_mutex_lock(&i->taskprocessor_lock); 00313 if (i->stats) { 00314 i->stats->_tasks_processed_count++; 00315 if (size > i->stats->max_qsize) { 00316 i->stats->max_qsize = size; 00317 } 00318 } 00319 ast_mutex_unlock(&i->taskprocessor_lock); 00320 00321 tps_task_free(t); 00322 } 00323 while ((t = tps_taskprocessor_pop(i))) { 00324 tps_task_free(t); 00325 } 00326 return NULL; 00327 }
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 389 of file taskprocessor.c.
References ast_taskprocessor::tps_queue_size.
Referenced by tps_processing_function().
static void tps_taskprocessor_destroy | ( | void * | tps | ) | [static] |
Destroy the taskprocessor when its refcount reaches zero.
Definition at line 346 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().
00347 { 00348 struct ast_taskprocessor *t = tps; 00349 00350 if (!tps) { 00351 ast_log(LOG_ERROR, "missing taskprocessor\n"); 00352 return; 00353 } 00354 ast_log(LOG_DEBUG, "destroying taskprocessor '%s'\n", t->name); 00355 /* kill it */ 00356 ast_mutex_lock(&t->taskprocessor_lock); 00357 t->poll_thread_run = 0; 00358 ast_cond_signal(&t->poll_cond); 00359 ast_mutex_unlock(&t->taskprocessor_lock); 00360 pthread_join(t->poll_thread, NULL); 00361 t->poll_thread = AST_PTHREADT_NULL; 00362 ast_mutex_destroy(&t->taskprocessor_lock); 00363 ast_cond_destroy(&t->poll_cond); 00364 /* free it */ 00365 if (t->stats) { 00366 ast_free(t->stats); 00367 t->stats = NULL; 00368 } 00369 ast_free((char *) t->name); 00370 }
static struct tps_task * tps_taskprocessor_pop | ( | struct ast_taskprocessor * | tps | ) | [static] |
Remove the front task off the taskprocessor queue.
Definition at line 373 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().
00374 { 00375 struct tps_task *task; 00376 00377 if (!tps) { 00378 ast_log(LOG_ERROR, "missing taskprocessor\n"); 00379 return NULL; 00380 } 00381 ast_mutex_lock(&tps->taskprocessor_lock); 00382 if ((task = AST_LIST_REMOVE_HEAD(&tps->tps_queue, list))) { 00383 tps->tps_queue_size--; 00384 } 00385 ast_mutex_unlock(&tps->taskprocessor_lock); 00386 return task; 00387 }
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_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 return name; 00177 }
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().