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_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>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_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>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_container * | tps_singletons |
tps_singletons is the astobj2 container for taskprocessor singletons |
Maintain a container of uniquely-named taskprocessor threads that can be shared across modules.
Definition in file taskprocessor.c.
#define TPS_MAX_BUCKETS 7 |
Definition at line 87 of file taskprocessor.c.
Referenced by ast_tps_init().
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().
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 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.
Definition at line 412 of file taskprocessor.c.
References ast_log(), LOG_ERROR, and ast_taskprocessor::name.
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 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.
tps | taskprocessor to unreference |
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 %17ld %12ld %12ld", 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 }
ast_cond_t cli_ping_cond [static] |
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] |
{ 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().