Dialplan mutexes. More...

#include "asterisk.h"
#include <signal.h>
#include "asterisk/lock.h"
#include "asterisk/file.h"
#include "asterisk/channel.h"
#include "asterisk/pbx.h"
#include "asterisk/module.h"
#include "asterisk/linkedlists.h"
#include "asterisk/astobj2.h"
#include "asterisk/utils.h"
#include "asterisk/cli.h"

Include dependency graph for func_lock.c:

Go to the source code of this file.

Data Structures
struct	channel_lock_frame

struct	lock_frame

struct	locklist

Functions
static void	__reg_module (void)

static void	__unreg_module (void)

struct ast_module *	AST_MODULE_SELF_SYM (void)

static int	get_lock (struct ast_channel chan, char lockname, int trylock)

static char *	handle_cli_locks_show (struct ast_cli_entry e, int cmd, struct ast_cli_args a)

static int	load_module (void)

static void	lock_fixup (void data, struct ast_channel oldchan, struct ast_channel *newchan)

static void	lock_free (void *data)

static int	lock_read (struct ast_channel chan, const char cmd, char data, char buf, size_t len)

static int	trylock_read (struct ast_channel chan, const char cmd, char data, char buf, size_t len)

static int	unload_module (void)

static int	unlock_read (struct ast_channel chan, const char cmd, char data, char buf, size_t len)

Variables
static struct ast_module_info	__mod_info = { .name = AST_MODULE, .flags = AST_MODFLAG_LOAD_ORDER , .description = "Dialplan mutexes" , .key = "This paragraph is copyright (c) 2006 by Digium, Inc. \In order for your module to load, it must return this \key via a function called \"key\". Any code which \includes this paragraph must be licensed under the GNU \General Public License version 2 or later (at your \option). In addition to Digium's general reservations \of rights, Digium expressly reserves the right to \allow other parties to license this paragraph under \different terms. Any use of Digium, Inc. trademarks or \logos (including \"Asterisk\" or \"Digium\") without \express written permission of Digium, Inc. is prohibited.\n" , .buildopt_sum = "30ef0c93b36035ec78c9cfd712d36d9b" , .load = load_module, .unload = unload_module, .load_pri = AST_MODPRI_DEFAULT, .support_level = AST_MODULE_SUPPORT_CORE, }

static const struct ast_module_info *	ast_module_info = &__mod_info

static struct ast_cli_entry	cli_locks_show = { .handler = handle_cli_locks_show , .summary = "List func_lock locks." ,}

static struct ast_custom_function	lock_function

static const struct ast_datastore_info	lock_info

static struct locklist	locklist = { .first = NULL, .last = NULL, .lock = { PTHREAD_RECURSIVE_MUTEX_INITIALIZER_NP , NULL, {1, 0} } , }

static struct ast_custom_function	trylock_function

static int	unloading = 0

static struct ast_custom_function	unlock_function

Detailed Description

Dialplan mutexes.

Author: Tilghman Lesher func_.nosp@m.lock.nosp@m._2007.nosp@m.@the.nosp@m.-tilg.nosp@m.hman.nosp@m..com

Definition in file func_lock.c.

Function Documentation

◆ __reg_module()

static void __reg_module ( void )

static

Definition at line 542 of file func_lock.c.

◆ __unreg_module()

static void __unreg_module ( void )

static

Definition at line 542 of file func_lock.c.

◆ AST_MODULE_SELF_SYM()

struct ast_module* AST_MODULE_SELF_SYM ( void )

Definition at line 542 of file func_lock.c.

◆ get_lock()

static int get_lock	(	struct ast_channel *	chan,
		char *	lockname,
		int	trylock
	)

static

Definition at line 186 of file func_lock.c.

References ast_calloc, ast_channel_datastore_add(), ast_channel_datastore_find(), ast_cond_init, ast_cond_signal, ast_cond_timedwait, ast_datastore_alloc, ast_datastore_free(), ast_free, AST_LIST_HEAD, AST_LIST_HEAD_INIT, AST_LIST_INSERT_TAIL, AST_LIST_LOCK, AST_LIST_TRAVERSE, AST_LIST_UNLOCK, ast_log, ast_module_ref, ast_mutex_destroy, ast_mutex_init, ast_mutex_lock, ast_mutex_unlock, ast_tvnow(), channel_lock_frame::channel, lock_frame::cond, lock_frame::count, ast_datastore::data, lock_frame::entries, channel_lock_frame::list, channel_lock_frame::lock_frame, LOG_ERROR, lock_frame::mutex, lock_frame::name, NULL, lock_frame::owner, lock_frame::requesters, ast_module_info::self, and unloading.

Referenced by lock_read(), and trylock_read().

 {
    struct ast_datastore *lock_store = ast_channel_datastore_find(chan, &lock_info, NULL);
    struct lock_frame *current;
    struct channel_lock_frame *clframe = NULL;
    AST_LIST_HEAD(, channel_lock_frame) *list;
    int res = 0;
    struct timespec timeout = { 0, };
    struct timeval now;
 
    if (!lock_store) {
       if (unloading) {
          ast_log(LOG_ERROR, "%sLOCK has no datastore and func_lock is unloading, failing.\n",
                trylock ? "TRY" : "");
          return -1;
       }
 
       lock_store = ast_datastore_alloc(&lock_info, NULL);
       if (!lock_store) {
          ast_log(LOG_ERROR, "Unable to allocate new datastore.  No locks will be obtained.\n");
          return -1;
       }
 
       list = ast_calloc(1, sizeof(*list));
       if (!list) {
          ast_log(LOG_ERROR,
             "Unable to allocate datastore list head.  %sLOCK will fail.\n",
             trylock ? "TRY" : "");
          ast_datastore_free(lock_store);
          return -1;
       }
 
       lock_store->data = list;
       AST_LIST_HEAD_INIT(list);
       ast_channel_datastore_add(chan, lock_store);
 
       /* We cannot unload until this channel has released the lock_store */
       ast_module_ref(ast_module_info->self);
    } else
       list = lock_store->data;
 
    /* Lock already exists? */
    AST_LIST_LOCK(&locklist);
    AST_LIST_TRAVERSE(&locklist, current, entries) {
       if (strcmp(current->name, lockname) == 0) {
          break;
       }
    }
 
    if (!current) {
       if (unloading) {
          ast_log(LOG_ERROR,
             "Lock doesn't exist whilst unloading.  %sLOCK will fail.\n",
             trylock ? "TRY" : "");
          /* Don't bother */
          AST_LIST_UNLOCK(&locklist);
          return -1;
       }
 
       /* Create new lock entry */
       current = ast_calloc(1, sizeof(*current) + strlen(lockname) + 1);
       if (!current) {
          AST_LIST_UNLOCK(&locklist);
          return -1;
       }
 
       strcpy(current->name, lockname); /* SAFE */
       if ((res = ast_mutex_init(&current->mutex))) {
          ast_log(LOG_ERROR, "Unable to initialize mutex: %s\n", strerror(res));
          ast_free(current);
          AST_LIST_UNLOCK(&locklist);
          return -1;
       }
       if ((res = ast_cond_init(&current->cond, NULL))) {
          ast_log(LOG_ERROR, "Unable to initialize condition variable: %s\n", strerror(res));
          ast_mutex_destroy(&current->mutex);
          ast_free(current);
          AST_LIST_UNLOCK(&locklist);
          return -1;
       }
       AST_LIST_INSERT_TAIL(&locklist, current, entries);
    }
    /* Add to requester list */
    ast_mutex_lock(&current->mutex);
    current->requesters++;
    ast_mutex_unlock(&current->mutex);
    AST_LIST_UNLOCK(&locklist);
 
    /* Found lock or created one - now find or create the corresponding link in the channel */
    AST_LIST_LOCK(list);
    AST_LIST_TRAVERSE(list, clframe, list) {
       if (clframe->lock_frame == current) {
          break;
       }
    }
 
    if (!clframe) {
       if (unloading) {
          ast_log(LOG_ERROR,
             "Busy unloading.  %sLOCK will fail.\n",
             trylock ? "TRY" : "");
          /* Don't bother */
          ast_mutex_lock(&current->mutex);
          current->requesters--;
          ast_mutex_unlock(&current->mutex);
          AST_LIST_UNLOCK(list);
          return -1;
       }
 
       if (!(clframe = ast_calloc(1, sizeof(*clframe)))) {
          ast_log(LOG_ERROR,
             "Unable to allocate channel lock frame.  %sLOCK will fail.\n",
             trylock ? "TRY" : "");
          ast_mutex_lock(&current->mutex);
          current->requesters--;
          ast_mutex_unlock(&current->mutex);
          AST_LIST_UNLOCK(list);
          return -1;
       }
 
       clframe->lock_frame = current;
       clframe->channel = chan;
       AST_LIST_INSERT_TAIL(list, clframe, list);
    }
    AST_LIST_UNLOCK(list);
 
    /* If we already own the lock, then we're being called recursively.
     * Keep track of how many times that is, because we need to unlock
     * the same amount, before we'll release this one.
     */
    if (current->owner == chan) {
       /* We're not a requester, we already have it */
       ast_mutex_lock(&current->mutex);
       current->requesters--;
       ast_mutex_unlock(&current->mutex);
       current->count++;
       return 0;
    }
 
    /* Wait up to three seconds from now for LOCK. */
    now = ast_tvnow();
    timeout.tv_sec = now.tv_sec + 3;
    timeout.tv_nsec = now.tv_usec * 1000;
 
    ast_mutex_lock(&current->mutex);
 
    res = 0;
    while (!trylock && !res && current->owner) {
       res = ast_cond_timedwait(&current->cond, &current->mutex, &timeout);
    }
    if (current->owner) {
       /* timeout;
        * trylock; or
        * cond_timedwait failed.
        *
        * either way, we fail to obtain the lock.
        */
       res = -1;
    } else {
       current->owner = chan;
       current->count++;
       res = 0;
    }
    /* Remove from requester list */
    current->requesters--;
    if (res && unloading)
       ast_cond_signal(&current->cond);
    ast_mutex_unlock(&current->mutex);
 
    return res;
 }

◆ handle_cli_locks_show()

static char* handle_cli_locks_show	(	struct ast_cli_entry *	e,
		int	cmd,
		struct ast_cli_args *	a
	)

static

Definition at line 434 of file func_lock.c.

References ast_channel_name(), ast_cli(), AST_LIST_LOCK, AST_LIST_TRAVERSE, AST_LIST_UNLOCK, ast_mutex_lock, ast_mutex_unlock, c, CLI_GENERATE, CLI_INIT, ast_cli_entry::command, lock_frame::entries, ast_cli_args::fd, lock_frame::mutex, lock_frame::name, NULL, lock_frame::owner, lock_frame::requesters, and ast_cli_entry::usage.

 {
    int c = 0;
    struct lock_frame* current;
    switch (cmd) {
    case CLI_INIT:
       e->command = "dialplan locks show";
       e->usage =
          "Usage: dialplan locks show\n"
          "       List all locks known to func_lock, along with their current status.\n";
       return NULL;
    case CLI_GENERATE:
       return NULL;
    }
 
    ast_cli(a->fd, "func_lock locks:\n");
    ast_cli(a->fd, "%-40s Requesters Owner\n", "Name");
    AST_LIST_LOCK(&locklist);
    AST_LIST_TRAVERSE(&locklist, current, entries) {
       ast_mutex_lock(&current->mutex);
       ast_cli(a->fd, "%-40s %-10d %s\n", current->name, current->requesters,
             current->owner ? ast_channel_name(current->owner) : "(unlocked)");
       ast_mutex_unlock(&current->mutex);
       c++;
    }
    AST_LIST_UNLOCK(&locklist);
    ast_cli(a->fd, "%d total locks listed.\n", c);
 
    return 0;
 }

◆ load_module()

static int load_module ( void )

static

Definition at line 532 of file func_lock.c.

References AST_CFE_READ, ast_cli_register, and ast_custom_function_register_escalating.

 {
    int res = ast_custom_function_register_escalating(&lock_function, AST_CFE_READ);
    res |= ast_custom_function_register_escalating(&trylock_function, AST_CFE_READ);
    res |= ast_custom_function_register_escalating(&unlock_function, AST_CFE_READ);
    res |= ast_cli_register(&cli_locks_show);
 
    return res;
 }

◆ lock_fixup()

static void lock_fixup	(	void *	data,
		struct ast_channel *	oldchan,
		struct ast_channel *	newchan
	)

static

Definition at line 165 of file func_lock.c.

References ast_channel_datastore_find(), AST_LIST_HEAD, AST_LIST_LOCK, AST_LIST_TRAVERSE, AST_LIST_UNLOCK, channel_lock_frame::channel, ast_datastore::data, channel_lock_frame::list, channel_lock_frame::lock_frame, NULL, and lock_frame::owner.

 {
    struct ast_datastore *lock_store = ast_channel_datastore_find(oldchan, &lock_info, NULL);
    AST_LIST_HEAD(, channel_lock_frame) *list;
    struct channel_lock_frame *clframe = NULL;
 
    if (!lock_store) {
       return;
    }
    list = lock_store->data;
 
    AST_LIST_LOCK(list);
    AST_LIST_TRAVERSE(list, clframe, list) {
       if (clframe->lock_frame->owner == oldchan) {
          clframe->lock_frame->owner = newchan;
       }
       clframe->channel = newchan;
    }
    AST_LIST_UNLOCK(list);
 }

◆ lock_free()

static void lock_free ( void * data )

static

Definition at line 142 of file func_lock.c.

References ast_cond_signal, ast_free, AST_LIST_HEAD, AST_LIST_HEAD_DESTROY, AST_LIST_LOCK, AST_LIST_REMOVE_HEAD, AST_LIST_UNLOCK, ast_module_unref, ast_mutex_lock, ast_mutex_unlock, channel_lock_frame::channel, lock_frame::cond, lock_frame::count, channel_lock_frame::list, channel_lock_frame::lock_frame, lock_frame::mutex, NULL, lock_frame::owner, and ast_module_info::self.

 {
    AST_LIST_HEAD(, channel_lock_frame) *oldlist = data;
    struct channel_lock_frame *clframe;
    AST_LIST_LOCK(oldlist);
    while ((clframe = AST_LIST_REMOVE_HEAD(oldlist, list))) {
       /* Only unlock if we own the lock */
       if (clframe->channel == clframe->lock_frame->owner) {
          ast_mutex_lock(&clframe->lock_frame->mutex);
          clframe->lock_frame->count = 0;
          clframe->lock_frame->owner = NULL;
          ast_cond_signal(&clframe->lock_frame->cond);
          ast_mutex_unlock(&clframe->lock_frame->mutex);
       }
       ast_free(clframe);
    }
    AST_LIST_UNLOCK(oldlist);
    AST_LIST_HEAD_DESTROY(oldlist);
    ast_free(oldlist);
 
    ast_module_unref(ast_module_info->self);
 }

◆ lock_read()

static int lock_read	(	struct ast_channel *	chan,
		const char *	cmd,
		char *	data,
		char *	buf,
		size_t	len
	)

static

Definition at line 410 of file func_lock.c.

References ast_autoservice_start(), ast_autoservice_stop(), ast_copy_string(), and get_lock().

 {
    if (!chan) {
       return -1;
    }
    ast_autoservice_start(chan);
    ast_copy_string(buf, get_lock(chan, data, 0) ? "0" : "1", len);
    ast_autoservice_stop(chan);
 
    return 0;
 }

◆ trylock_read()

static int trylock_read	(	struct ast_channel *	chan,
		const char *	cmd,
		char *	data,
		char *	buf,
		size_t	len
	)

static

Definition at line 422 of file func_lock.c.

References ast_autoservice_start(), ast_autoservice_stop(), ast_copy_string(), and get_lock().

 {
    if (!chan) {
       return -1;
    }
    ast_autoservice_start(chan);
    ast_copy_string(buf, get_lock(chan, data, 1) ? "0" : "1", len);
    ast_autoservice_stop(chan);
 
    return 0;
 }

◆ unload_module()

static int unload_module ( void )

static

Definition at line 485 of file func_lock.c.

References ast_cli_unregister(), ast_cond_destroy, ast_cond_wait, ast_custom_function_unregister(), ast_free, AST_LIST_HEAD_DESTROY, AST_LIST_LOCK, AST_LIST_REMOVE_HEAD, AST_LIST_UNLOCK, ast_log, ast_mutex_destroy, ast_mutex_lock, ast_mutex_unlock, lock_frame::cond, lock_frame::entries, LOG_WARNING, lock_frame::mutex, lock_frame::name, lock_frame::owner, lock_frame::requesters, and unloading.

 {
    struct lock_frame *current;
 
    /* Module flag */
    unloading = 1;
 
    /* Make it impossible for new requesters to be added
     * NOTE:  channels could already be in get_lock() */
    ast_custom_function_unregister(&lock_function);
    ast_custom_function_unregister(&trylock_function);
 
    ast_cli_unregister(&cli_locks_show);
 
    AST_LIST_LOCK(&locklist);
    while ((current = AST_LIST_REMOVE_HEAD(&locklist, entries))) {
       int warned = 0;
       ast_mutex_lock(&current->mutex);
       while (current->owner || current->requesters) {
          if (!warned) {
             ast_log(LOG_WARNING, "Waiting for %d requesters for %s lock %s.\n",
                   current->requesters, current->owner ? "locked" : "unlocked",
                   current->name);
             warned = 1;
          }
          /* either the mutex is locked, or other parties are currently in get_lock,
           * we need to wait for all of those to clear first */
          ast_cond_wait(&current->cond, &current->mutex);
       }
       ast_mutex_unlock(&current->mutex);
       /* At this point we know:
        * 1. the lock has been released,
        * 2. there are no requesters (nor should any be able to sneak in).
        */
       ast_mutex_destroy(&current->mutex);
       ast_cond_destroy(&current->cond);
       ast_free(current);
    }
    AST_LIST_UNLOCK(&locklist);
    AST_LIST_HEAD_DESTROY(&locklist);
 
    /* At this point we can safely stop access to UNLOCK */
    ast_custom_function_unregister(&unlock_function);
 
    return 0;
 }

◆ unlock_read()

static int unlock_read	(	struct ast_channel *	chan,
		const char *	cmd,
		char *	data,
		char *	buf,
		size_t	len
	)

static

Definition at line 358 of file func_lock.c.

References ast_channel_datastore_find(), ast_cond_signal, ast_copy_string(), ast_debug, AST_LIST_HEAD, AST_LIST_LOCK, AST_LIST_TRAVERSE, AST_LIST_UNLOCK, ast_log, ast_mutex_lock, ast_mutex_unlock, lock_frame::cond, lock_frame::count, ast_datastore::data, channel_lock_frame::list, channel_lock_frame::lock_frame, LOG_WARNING, lock_frame::mutex, lock_frame::name, NULL, and lock_frame::owner.

 {
    struct ast_datastore *lock_store;
    struct channel_lock_frame *clframe;
    AST_LIST_HEAD(, channel_lock_frame) *list;
 
    if (!chan) {
       return -1;
    }
 
    lock_store = ast_channel_datastore_find(chan, &lock_info, NULL);
    if (!lock_store) {
       ast_log(LOG_WARNING, "No datastore for dialplan locks.  Nothing was ever locked!\n");
       ast_copy_string(buf, "0", len);
       return 0;
    }
 
    if (!(list = lock_store->data)) {
       ast_debug(1, "This should NEVER happen\n");
       ast_copy_string(buf, "0", len);
       return 0;
    }
 
    /* Find item in the channel list */
    AST_LIST_LOCK(list);
    AST_LIST_TRAVERSE(list, clframe, list) {
       if (clframe->lock_frame && clframe->lock_frame->owner == chan && strcmp(clframe->lock_frame->name, data) == 0) {
          break;
       }
    }
    /* We never destroy anything until channel destruction, which will never
     * happen while this routine is executing, so we don't need to hold the
     * lock beyond this point. */
    AST_LIST_UNLOCK(list);
 
    if (!clframe) {
       /* We didn't have this lock in the first place */
       ast_copy_string(buf, "0", len);
       return 0;
    }
 
    if (--clframe->lock_frame->count == 0) {
       ast_mutex_lock(&clframe->lock_frame->mutex);
       clframe->lock_frame->owner = NULL;
       ast_cond_signal(&clframe->lock_frame->cond);
       ast_mutex_unlock(&clframe->lock_frame->mutex);
    }
 
    ast_copy_string(buf, "1", len);
    return 0;
 }

Variable Documentation

◆ __mod_info

struct ast_module_info __mod_info = { .name = AST_MODULE, .flags = AST_MODFLAG_LOAD_ORDER , .description = "Dialplan mutexes" , .key = "This paragraph is copyright (c) 2006 by Digium, Inc. \In order for your module to load, it must return this \key via a function called \"key\". Any code which \includes this paragraph must be licensed under the GNU \General Public License version 2 or later (at your \option). In addition to Digium's general reservations \of rights, Digium expressly reserves the right to \allow other parties to license this paragraph under \different terms. Any use of Digium, Inc. trademarks or \logos (including \"Asterisk\" or \"Digium\") without \express written permission of Digium, Inc. is prohibited.\n" , .buildopt_sum = "30ef0c93b36035ec78c9cfd712d36d9b" , .load = load_module, .unload = unload_module, .load_pri = AST_MODPRI_DEFAULT, .support_level = AST_MODULE_SUPPORT_CORE, }

static

Definition at line 542 of file func_lock.c.

◆ ast_module_info

const struct ast_module_info* ast_module_info = &__mod_info

static

Definition at line 542 of file func_lock.c.

◆ cli_locks_show

struct ast_cli_entry cli_locks_show = { .handler = handle_cli_locks_show , .summary = "List func_lock locks." ,}

static

Definition at line 483 of file func_lock.c.

◆ lock_function

struct ast_custom_function lock_function

static

Initial value:

= {
   .name = "LOCK",
   .read = lock_read,
   .read_max = 2,
}

Definition at line 465 of file func_lock.c.

◆ lock_info

const struct ast_datastore_info lock_info

static

Initial value:

= {
   .type = "MUTEX",
   .destroy = lock_free,
   .chan_fixup = lock_fixup,
}

Definition at line 115 of file func_lock.c.

Referenced by ast_dump_locks(), ast_find_lock_info(), ast_log_show_lock(), ast_mark_lock_acquired(), ast_mark_lock_failed(), ast_remove_lock_info(), ast_restore_lock_info(), ast_store_lock_info(), ast_suspend_lock_info(), dummy_start(), and lock_info_destroy().

◆ locklist

struct locklist locklist = { .first = NULL, .last = NULL, .lock = { PTHREAD_RECURSIVE_MUTEX_INITIALIZER_NP , NULL, {1, 0} } , }

static

◆ trylock_function

struct ast_custom_function trylock_function

static

Initial value:

= {
   .name = "TRYLOCK",
   .read = trylock_read,
   .read_max = 2,
}

Definition at line 471 of file func_lock.c.

◆ unloading

int unloading = 0

static

Definition at line 113 of file func_lock.c.

Referenced by get_lock(), and unload_module().

◆ unlock_function

struct ast_custom_function unlock_function

static

Initial value:

= {
   .name = "UNLOCK",
   .read = unlock_read,
   .read_max = 2,
}

Definition at line 477 of file func_lock.c.

Data Structures

Functions

Variables

Detailed Description

Function Documentation

◆ __reg_module()

◆ __unreg_module()

◆ AST_MODULE_SELF_SYM()

◆ get_lock()

◆ handle_cli_locks_show()

◆ load_module()

◆ lock_fixup()

◆ lock_free()

◆ lock_read()

◆ trylock_read()

◆ unload_module()

◆ unlock_read()

Variable Documentation

◆ __mod_info

◆ ast_module_info

◆ cli_locks_show

◆ lock_function

◆ lock_info

◆ locklist

◆ trylock_function

◆ unloading

◆ unlock_function