func_lock.c File Reference

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 = AST_BUILDOPT_SUM, .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 554 of file func_lock.c.

__unreg_module()

static void __unreg_module ( void  )

static

Definition at line 554 of file func_lock.c.

AST_MODULE_SELF_SYM()

struct ast_module * AST_MODULE_SELF_SYM

(

void

)

Definition at line 554 of file func_lock.c.

get_lock()

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

static

Definition at line 198 of file func_lock.c.

{
    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;
}

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, current, ast_datastore::data, channel_lock_frame::list, channel_lock_frame::lock_frame, lock_info, LOG_ERROR, NULL, ast_module_info::self, and unloading.

Referenced by lock_read(), and trylock_read().

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 446 of file func_lock.c.

{
    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;
}

References a, 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, current, lock_frame::entries, NULL, and ast_cli_entry::usage.

load_module()

static int load_module ( void  )

static

Definition at line 544 of file func_lock.c.

{
    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;
}

References AST_CFE_READ, ast_cli_register, ast_custom_function_register_escalating, cli_locks_show, lock_function, trylock_function, and unlock_function.

lock_fixup()

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

static

Definition at line 177 of file func_lock.c.

{
    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);
}

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, lock_info, NULL, and lock_frame::owner.

lock_free()

static void lock_free ( void *  data )

static

Definition at line 154 of file func_lock.c.

{
    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);
}

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.

lock_read()

static int lock_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.

{
    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;
}

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

trylock_read()

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

static

Definition at line 434 of file func_lock.c.

{
    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;
}

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

unload_module()

static int unload_module ( void  )

static

Definition at line 497 of file func_lock.c.

{
    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;
}

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, cli_locks_show, current, lock_frame::entries, lock_function, LOG_WARNING, trylock_function, unloading, and unlock_function.

unlock_read()

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

static

Definition at line 370 of file func_lock.c.

{
    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;
}

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, buf, lock_frame::cond, lock_frame::count, ast_datastore::data, len(), channel_lock_frame::list, channel_lock_frame::lock_frame, lock_info, LOG_WARNING, lock_frame::mutex, lock_frame::name, NULL, and lock_frame::owner.

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 = AST_BUILDOPT_SUM, .load = load_module, .unload = unload_module, .load_pri = AST_MODPRI_DEFAULT, .support_level = AST_MODULE_SUPPORT_CORE, }

static

Definition at line 554 of file func_lock.c.

ast_module_info

const struct ast_module_info* ast_module_info = &__mod_info

static

Definition at line 554 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 495 of file func_lock.c.

Referenced by load_module(), and unload_module().

lock_function

struct ast_custom_function lock_function

static

Initial value:

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

Definition at line 477 of file func_lock.c.

Referenced by load_module(), and unload_module().

lock_info

const struct ast_datastore_info lock_info

static

Initial value:

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

Definition at line 127 of file func_lock.c.

Referenced by dummy_start(), get_lock(), lock_fixup(), and unlock_read().

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 483 of file func_lock.c.

Referenced by load_module(), and unload_module().

unloading

int unloading = 0

static

Definition at line 125 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 489 of file func_lock.c.

Referenced by load_module(), and unload_module().