sched.c

/*
 * Asterisk -- An open source telephony toolkit.
 *
 * Copyright (C) 1999 - 2010, Digium, Inc.
 *
 * Mark Spencer <markster@digium.com>
 * Russell Bryant <russell@digium.com>
 *
 * See http://www.asterisk.org for more information about
 * the Asterisk project. Please do not directly contact
 * any of the maintainers of this project for assistance;
 * the project provides a web site, mailing lists and IRC
 * channels for your use.
 *
 * This program is free software, distributed under the terms of
 * the GNU General Public License Version 2. See the LICENSE file
 * at the top of the source tree.
 */

/*! \file
 *
 * \brief Scheduler Routines (from cheops-NG)
 *
 * \author Mark Spencer <markster@digium.com>
 */

/*** MODULEINFO
	<support_level>core</support_level>
 ***/

#include "asterisk.h"

#ifdef DEBUG_SCHEDULER
#define DEBUG(a) a
#else
#define DEBUG(a)
#endif

#include <sys/time.h>

#include "asterisk/sched.h"
#include "asterisk/channel.h"
#include "asterisk/lock.h"
#include "asterisk/utils.h"
#include "asterisk/heap.h"
#include "asterisk/threadstorage.h"

/*!
 * \brief Max num of schedule structs
 *
 * \note The max number of schedule structs to keep around
 * for use.  Undefine to disable schedule structure
 * caching. (Only disable this on very low memory
 * machines)
 */
#define SCHED_MAX_CACHE 128

AST_THREADSTORAGE(last_del_id);

/*!
 * \brief Scheduler ID holder
 *
 * These form a queue on a scheduler context. When a new
 * scheduled item is created, a sched_id is popped off the
 * queue and its id is assigned to the new scheduled item.
 * When the scheduled task is complete, the sched_id on that
 * task is then pushed to the back of the queue to be re-used
 * on some future scheduled item.
 */
struct sched_id {
	/*! Immutable ID number that is copied onto the scheduled task */
	int id;
	AST_LIST_ENTRY(sched_id) list;
};

struct sched {
	AST_LIST_ENTRY(sched) list;
	/*! The ID that has been popped off the scheduler context's queue */
	struct sched_id *sched_id;
	struct timeval when;          /*!< Absolute time event should take place */
	/*!
	 * \brief Tie breaker in case the when is the same for multiple entries.
	 *
	 * \note The oldest expiring entry in the scheduler heap goes first.
	 * This is possible when multiple events are scheduled to expire at
	 * the same time by internal coding.
	 */
	unsigned int tie_breaker;
	int resched;                  /*!< When to reschedule */
	int variable;                 /*!< Use return value from callback to reschedule */
	const void *data;             /*!< Data */
	ast_sched_cb callback;        /*!< Callback */
	ssize_t __heap_index;
	/*!
	 * Used to synchronize between thread running a task and thread
	 * attempting to delete a task
	 */
	ast_cond_t cond;
	/*! Indication that a running task was deleted. */
	unsigned int deleted:1;
	/*! Indication that a running task was rescheduled. */
	unsigned int rescheduled:1;
};

struct sched_thread {
	pthread_t thread;
	ast_cond_t cond;
	unsigned int stop:1;
};

struct ast_sched_context {
	ast_mutex_t lock;
	unsigned int eventcnt;                  /*!< Number of events processed */
	unsigned int highwater;					/*!< highest count so far */
	/*! Next tie breaker in case events expire at the same time. */
	unsigned int tie_breaker;
	struct ast_heap *sched_heap;
	struct sched_thread *sched_thread;
	/*! The scheduled task that is currently executing */
	struct sched *currently_executing;
	/*! Valid while currently_executing is not NULL */
	pthread_t executing_thread_id;

#ifdef SCHED_MAX_CACHE
	AST_LIST_HEAD_NOLOCK(, sched) schedc;   /*!< Cache of unused schedule structures and how many */
	unsigned int schedccnt;
#endif
	/*! Queue of scheduler task IDs to assign */
	AST_LIST_HEAD_NOLOCK(, sched_id) id_queue;
	/*! The number of IDs in the id_queue */
	int id_queue_size;
};

static void *sched_run(void *data)
{
	struct ast_sched_context *con = data;

	while (!con->sched_thread->stop) {
		int ms;
		struct timespec ts = {
			.tv_sec = 0,
		};

		ast_mutex_lock(&con->lock);

		if (con->sched_thread->stop) {
			ast_mutex_unlock(&con->lock);
			return NULL;
		}

		ms = ast_sched_wait(con);

		if (ms == -1) {
			ast_cond_wait(&con->sched_thread->cond, &con->lock);
		} else {
			struct timeval tv;
			tv = ast_tvadd(ast_tvnow(), ast_samp2tv(ms, 1000));
			ts.tv_sec = tv.tv_sec;
			ts.tv_nsec = tv.tv_usec * 1000;
			ast_cond_timedwait(&con->sched_thread->cond, &con->lock, &ts);
		}

		ast_mutex_unlock(&con->lock);

		if (con->sched_thread->stop) {
			return NULL;
		}

		ast_sched_runq(con);
	}

	return NULL;
}

static void sched_thread_destroy(struct ast_sched_context *con)
{
	if (!con->sched_thread) {
		return;
	}

	if (con->sched_thread->thread != AST_PTHREADT_NULL) {
		ast_mutex_lock(&con->lock);
		con->sched_thread->stop = 1;
		ast_cond_signal(&con->sched_thread->cond);
		ast_mutex_unlock(&con->lock);
		pthread_join(con->sched_thread->thread, NULL);
		con->sched_thread->thread = AST_PTHREADT_NULL;
	}

	ast_cond_destroy(&con->sched_thread->cond);

	ast_free(con->sched_thread);

	con->sched_thread = NULL;
}

int ast_sched_start_thread(struct ast_sched_context *con)
{
	struct sched_thread *st;

	if (con->sched_thread) {
		ast_log(LOG_ERROR, "Thread already started on this scheduler context\n");
		return -1;
	}

	if (!(st = ast_calloc(1, sizeof(*st)))) {
		return -1;
	}

	ast_cond_init(&st->cond, NULL);

	st->thread = AST_PTHREADT_NULL;

	con->sched_thread = st;

	if (ast_pthread_create_background(&st->thread, NULL, sched_run, con)) {
		ast_log(LOG_ERROR, "Failed to create scheduler thread\n");
		sched_thread_destroy(con);
		return -1;
	}

	return 0;
}

static int sched_time_cmp(void *va, void *vb)
{
	struct sched *a = va;
	struct sched *b = vb;
	int cmp;

	cmp = ast_tvcmp(b->when, a->when);
	if (!cmp) {
		cmp = b->tie_breaker - a->tie_breaker;
	}
	return cmp;
}

struct ast_sched_context *ast_sched_context_create(void)
{
	struct ast_sched_context *tmp;

	if (!(tmp = ast_calloc(1, sizeof(*tmp)))) {
		return NULL;
	}

	ast_mutex_init(&tmp->lock);
	tmp->eventcnt = 1;

	AST_LIST_HEAD_INIT_NOLOCK(&tmp->id_queue);

	if (!(tmp->sched_heap = ast_heap_create(8, sched_time_cmp,
			offsetof(struct sched, __heap_index)))) {
		ast_sched_context_destroy(tmp);
		return NULL;
	}

	return tmp;
}

static void sched_free(struct sched *task)
{
	/* task->sched_id will be NULL most of the time, but when the
	 * scheduler context shuts down, it will free all scheduled
	 * tasks, and in that case, the task->sched_id will be non-NULL
	 */
	ast_free(task->sched_id);
	ast_cond_destroy(&task->cond);
	ast_free(task);
}

void ast_sched_context_destroy(struct ast_sched_context *con)
{
	struct sched *s;
	struct sched_id *sid;

	sched_thread_destroy(con);
	con->sched_thread = NULL;

	ast_mutex_lock(&con->lock);

#ifdef SCHED_MAX_CACHE
	while ((s = AST_LIST_REMOVE_HEAD(&con->schedc, list))) {
		sched_free(s);
	}
#endif

	if (con->sched_heap) {
		while ((s = ast_heap_pop(con->sched_heap))) {
			sched_free(s);
		}
		ast_heap_destroy(con->sched_heap);
		con->sched_heap = NULL;
	}

	while ((sid = AST_LIST_REMOVE_HEAD(&con->id_queue, list))) {
		ast_free(sid);
	}

	ast_mutex_unlock(&con->lock);
	ast_mutex_destroy(&con->lock);

	ast_free(con);
}

#define ID_QUEUE_INCREMENT 16

/*!
 * \brief Add new scheduler IDs to the queue.
 *
 * \retval The number of IDs added to the queue
 */
static int add_ids(struct ast_sched_context *con)
{
	int new_size;
	int original_size;
	int i;

	original_size = con->id_queue_size;
	/* So we don't go overboard with the mallocs here, we'll just up
	 * the size of the list by a fixed amount each time instead of
	 * multiplying the size by any particular factor
	 */
	new_size = original_size + ID_QUEUE_INCREMENT;
	if (new_size < 0) {
		/* Overflow. Cap it at INT_MAX. */
		new_size = INT_MAX;
	}
	for (i = original_size; i < new_size; ++i) {
		struct sched_id *new_id;

		new_id = ast_calloc(1, sizeof(*new_id));
		if (!new_id) {
			break;
		}

		/*
		 * According to the API doxygen a sched ID of 0 is valid.
		 * Unfortunately, 0 was never returned historically and
		 * several users incorrectly coded usage of the returned
		 * sched ID assuming that 0 was invalid.
		 */
		new_id->id = ++con->id_queue_size;

		AST_LIST_INSERT_TAIL(&con->id_queue, new_id, list);
	}

	return con->id_queue_size - original_size;
}

static int set_sched_id(struct ast_sched_context *con, struct sched *new_sched)
{
	if (AST_LIST_EMPTY(&con->id_queue) && (add_ids(con) == 0)) {
		return -1;
	}

	new_sched->sched_id = AST_LIST_REMOVE_HEAD(&con->id_queue, list);
	return 0;
}

static void sched_release(struct ast_sched_context *con, struct sched *tmp)
{
	if (tmp->sched_id) {
		AST_LIST_INSERT_TAIL(&con->id_queue, tmp->sched_id, list);
		tmp->sched_id = NULL;
	}

	/*
	 * Add to the cache, or just free() if we
	 * already have too many cache entries
	 */
#ifdef SCHED_MAX_CACHE
	if (con->schedccnt < SCHED_MAX_CACHE) {
		AST_LIST_INSERT_HEAD(&con->schedc, tmp, list);
		con->schedccnt++;
	} else
#endif
		sched_free(tmp);
}

static struct sched *sched_alloc(struct ast_sched_context *con)
{
	struct sched *tmp;

	/*
	 * We keep a small cache of schedule entries
	 * to minimize the number of necessary malloc()'s
	 */
#ifdef SCHED_MAX_CACHE
	if ((tmp = AST_LIST_REMOVE_HEAD(&con->schedc, list))) {
		con->schedccnt--;
	} else
#endif
	{
		tmp = ast_calloc(1, sizeof(*tmp));
		if (!tmp) {
			return NULL;
		}
		ast_cond_init(&tmp->cond, NULL);
	}

	if (set_sched_id(con, tmp)) {
		sched_release(con, tmp);
		return NULL;
	}

	return tmp;
}

void ast_sched_clean_by_callback(struct ast_sched_context *con, ast_sched_cb match, ast_sched_cb cleanup_cb)
{
	int i = 1;
	struct sched *current;

	ast_mutex_lock(&con->lock);
	while ((current = ast_heap_peek(con->sched_heap, i))) {
		if (current->callback != match) {
			i++;
			continue;
		}

		ast_heap_remove(con->sched_heap, current);

		cleanup_cb(current->data);
		sched_release(con, current);
	}
	ast_mutex_unlock(&con->lock);
}

/*! \brief
 * Return the number of milliseconds
 * until the next scheduled event
 */
int ast_sched_wait(struct ast_sched_context *con)
{
	int ms;
	struct sched *s;

	DEBUG(ast_debug(1, "ast_sched_wait()\n"));

	ast_mutex_lock(&con->lock);
	if ((s = ast_heap_peek(con->sched_heap, 1))) {
		ms = ast_tvdiff_ms(s->when, ast_tvnow());
		if (ms < 0) {
			ms = 0;
		}
	} else {
		ms = -1;
	}
	ast_mutex_unlock(&con->lock);

	return ms;
}


/*! \brief
 * Take a sched structure and put it in the
 * queue, such that the soonest event is
 * first in the list.
 */
static void schedule(struct ast_sched_context *con, struct sched *s)
{
	size_t size;

	size = ast_heap_size(con->sched_heap);

	/* Record the largest the scheduler heap became for reporting purposes. */
	if (con->highwater <= size) {
		con->highwater = size + 1;
	}

	/* Determine the tie breaker value for the new entry. */
	if (size) {
		++con->tie_breaker;
	} else {
		/*
		 * Restart the sequence for the first entry to make integer
		 * roll over more unlikely.
		 */
		con->tie_breaker = 0;
	}
	s->tie_breaker = con->tie_breaker;

	ast_heap_push(con->sched_heap, s);
}

/*! \brief
 * given the last event *tv and the offset in milliseconds 'when',
 * computes the next value,
 */
static void sched_settime(struct timeval *t, int when)
{
	struct timeval now = ast_tvnow();

	if (when < 0) {
		/*
		 * A negative when value is likely a bug as it
		 * represents a VERY large timeout time.
		 */
		ast_log(LOG_WARNING,
			"Bug likely: Negative time interval %d (interpreted as %u ms) requested!\n",
			when, (unsigned int) when);
		ast_assert(0);
	}

	/*ast_debug(1, "TV -> %lu,%lu\n", tv->tv_sec, tv->tv_usec);*/
	if (ast_tvzero(*t))	/* not supplied, default to now */
		*t = now;
	*t = ast_tvadd(*t, ast_samp2tv(when, 1000));
	if (ast_tvcmp(*t, now) < 0) {
		*t = now;
	}
}

int ast_sched_replace_variable(int old_id, struct ast_sched_context *con, int when, ast_sched_cb callback, const void *data, int variable)
{
	/* 0 means the schedule item is new; do not delete */
	if (old_id > 0) {
		AST_SCHED_DEL(con, old_id);
	}
	return ast_sched_add_variable(con, when, callback, data, variable);
}

/*! \brief
 * Schedule callback(data) to happen when ms into the future
 */
int ast_sched_add_variable(struct ast_sched_context *con, int when, ast_sched_cb callback, const void *data, int variable)
{
	struct sched *tmp;
	int res = -1;

	DEBUG(ast_debug(1, "ast_sched_add()\n"));

	ast_mutex_lock(&con->lock);
	if ((tmp = sched_alloc(con))) {
		con->eventcnt++;
		tmp->callback = callback;
		tmp->data = data;
		tmp->resched = when;
		tmp->variable = variable;
		tmp->when = ast_tv(0, 0);
		tmp->deleted = 0;

		sched_settime(&tmp->when, when);
		schedule(con, tmp);
		res = tmp->sched_id->id;
	}
#ifdef DUMP_SCHEDULER
	/* Dump contents of the context while we have the lock so nothing gets screwed up by accident. */
	ast_sched_dump(con);
#endif
	if (con->sched_thread) {
		ast_cond_signal(&con->sched_thread->cond);
	}
	ast_mutex_unlock(&con->lock);

	return res;
}

int ast_sched_replace(int old_id, struct ast_sched_context *con, int when, ast_sched_cb callback, const void *data)
{
	if (old_id > -1) {
		AST_SCHED_DEL(con, old_id);
	}
	return ast_sched_add(con, when, callback, data);
}

int ast_sched_add(struct ast_sched_context *con, int when, ast_sched_cb callback, const void *data)
{
	return ast_sched_add_variable(con, when, callback, data, 0);
}

static struct sched *sched_find(struct ast_sched_context *con, int id)
{
	int x;
	size_t heap_size;

	heap_size = ast_heap_size(con->sched_heap);
	for (x = 1; x <= heap_size; x++) {
		struct sched *cur = ast_heap_peek(con->sched_heap, x);

		if (cur->sched_id->id == id) {
			return cur;
		}
	}

	return NULL;
}

const void *ast_sched_find_data(struct ast_sched_context *con, int id)
{
	struct sched *s;
	const void *data = NULL;

	ast_mutex_lock(&con->lock);

	s = sched_find(con, id);
	if (s) {
		data = s->data;
	}

	ast_mutex_unlock(&con->lock);

	return data;
}

/*! \brief
 * Delete the schedule entry with number
 * "id".  It's nearly impossible that there
 * would be two or more in the list with that
 * id.
 * Deprecated in favor of ast_sched_del_nonrunning
 * which checks running event status.
 */
int ast_sched_del(struct ast_sched_context *con, int id)
{
	return ast_sched_del_nonrunning(con, id) ? -1 : 0;
}

/*! \brief
 * Delete the schedule entry with number "id".
 * If running, wait for the task to complete,
 * check to see if it is rescheduled then
 * schedule the release.
 * It's nearly impossible that there would be
 * two or more in the list with that id.
 */
int ast_sched_del_nonrunning(struct ast_sched_context *con, int id)
{
	struct sched *s = NULL;
	int *last_id = ast_threadstorage_get(&last_del_id, sizeof(int));
	int res = 0;

	DEBUG(ast_debug(1, "ast_sched_del(%d)\n", id));

	if (id < 0) {
		return 0;
	}

	ast_mutex_lock(&con->lock);

	s = sched_find(con, id);
	if (s) {
		if (!ast_heap_remove(con->sched_heap, s)) {
			ast_log(LOG_WARNING,"sched entry %d not in the sched heap?\n", s->sched_id->id);
		}
		sched_release(con, s);
	} else if (con->currently_executing && (id == con->currently_executing->sched_id->id)) {
		if (con->executing_thread_id == pthread_self()) {
			/* The scheduled callback is trying to delete itself.
			 * Not good as that is a deadlock. */
			ast_log(LOG_ERROR,
				"BUG! Trying to delete sched %d from within the callback %p.  "
				"Ignoring so we don't deadlock\n",
				id, con->currently_executing->callback);
			ast_log_backtrace();
			/* We'll return -1 below because s is NULL.
			 * The caller will rightly assume that the unscheduling failed. */
		} else {
			s = con->currently_executing;
			s->deleted = 1;
			/* Wait for executing task to complete so that the caller of
			 * ast_sched_del() does not free memory out from under the task. */
			while (con->currently_executing && (id == con->currently_executing->sched_id->id)) {
				ast_cond_wait(&s->cond, &con->lock);
			}
			/* This is not rescheduled so the caller of ast_sched_del_nonrunning needs to know
			 * that it was still deleted
			 */
			if (!s->rescheduled) {
				res = -2;
			}
			/* ast_sched_runq knows we are waiting on this item and is passing responsibility for
			 * its destruction to us
			 */
			sched_release(con, s);
			s = NULL;
		}
	}

#ifdef DUMP_SCHEDULER
	/* Dump contents of the context while we have the lock so nothing gets screwed up by accident. */
	ast_sched_dump(con);
#endif
	if (con->sched_thread) {
		ast_cond_signal(&con->sched_thread->cond);
	}
	ast_mutex_unlock(&con->lock);

	if(res == -2){
		return res;
	}
	else if (!s && *last_id != id) {
		ast_debug(1, "Attempted to delete nonexistent schedule entry %d!\n", id);
		/* Removing nonexistent schedule entry shouldn't trigger assert (it was enabled in DEV_MODE);
		 * because in many places entries is deleted without having valid id. */
		*last_id = id;
		return -1;
	} else if (!s) {
		return -1;
	}

	return res;
}

void ast_sched_report(struct ast_sched_context *con, struct ast_str **buf, struct ast_cb_names *cbnames)
{
	int i, x;
	struct sched *cur;
	int countlist[cbnames->numassocs + 1];
	size_t heap_size;

	memset(countlist, 0, sizeof(countlist));
	ast_str_set(buf, 0, " Highwater = %u\n schedcnt = %zu\n", con->highwater, ast_heap_size(con->sched_heap));

	ast_mutex_lock(&con->lock);

	heap_size = ast_heap_size(con->sched_heap);
	for (x = 1; x <= heap_size; x++) {
		cur = ast_heap_peek(con->sched_heap, x);
		/* match the callback to the cblist */
		for (i = 0; i < cbnames->numassocs; i++) {
			if (cur->callback == cbnames->cblist[i]) {
				break;
			}
		}
		if (i < cbnames->numassocs) {
			countlist[i]++;
		} else {
			countlist[cbnames->numassocs]++;
		}
	}

	ast_mutex_unlock(&con->lock);

	for (i = 0; i < cbnames->numassocs; i++) {
		ast_str_append(buf, 0, "    %s : %d\n", cbnames->list[i], countlist[i]);
	}

	ast_str_append(buf, 0, "   <unknown> : %d\n", countlist[cbnames->numassocs]);
}

/*! \brief Dump the contents of the scheduler to LOG_DEBUG */
void ast_sched_dump(struct ast_sched_context *con)
{
	struct sched *q;
	struct timeval when;
	int x;
	size_t heap_size;

	if (!DEBUG_ATLEAST(1)) {
		return;
	}

	when = ast_tvnow();
#ifdef SCHED_MAX_CACHE
	ast_log(LOG_DEBUG, "Asterisk Schedule Dump (%zu in Q, %u Total, %u Cache, %u high-water)\n",
		ast_heap_size(con->sched_heap), con->eventcnt - 1, con->schedccnt, con->highwater);
#else
	ast_log(LOG_DEBUG, "Asterisk Schedule Dump (%zu in Q, %u Total, %u high-water)\n",
		ast_heap_size(con->sched_heap), con->eventcnt - 1, con->highwater);
#endif

	ast_log(LOG_DEBUG, "=============================================================\n");
	ast_log(LOG_DEBUG, "|ID    Callback          Data              Time  (sec:ms)   |\n");
	ast_log(LOG_DEBUG, "+-----+-----------------+-----------------+-----------------+\n");
	ast_mutex_lock(&con->lock);
	heap_size = ast_heap_size(con->sched_heap);
	for (x = 1; x <= heap_size; x++) {
		struct timeval delta;
		q = ast_heap_peek(con->sched_heap, x);
		delta = ast_tvsub(q->when, when);
		ast_log(LOG_DEBUG, "|%.4d | %-15p | %-15p | %.6ld : %.6ld |\n",
			q->sched_id->id,
			q->callback,
			q->data,
			(long)delta.tv_sec,
			(long int)delta.tv_usec);
	}
	ast_mutex_unlock(&con->lock);
	ast_log(LOG_DEBUG, "=============================================================\n");
}

/*! \brief
 * Launch all events which need to be run at this time.
 */
int ast_sched_runq(struct ast_sched_context *con)
{
	struct sched *current;
	struct timeval when;
	int numevents;
	int res;

	DEBUG(ast_debug(1, "ast_sched_runq()\n"));

	ast_mutex_lock(&con->lock);

	when = ast_tvadd(ast_tvnow(), ast_tv(0, 1000));
	for (numevents = 0; (current = ast_heap_peek(con->sched_heap, 1)); numevents++) {
		/* schedule all events which are going to expire within 1ms.
		 * We only care about millisecond accuracy anyway, so this will
		 * help us get more than one event at one time if they are very
		 * close together.
		 */
		if (ast_tvcmp(current->when, when) != -1) {
			break;
		}

		current = ast_heap_pop(con->sched_heap);

		/*
		 * At this point, the schedule queue is still intact.  We
		 * have removed the first event and the rest is still there,
		 * so it's permissible for the callback to add new events, but
		 * trying to delete itself won't work because it isn't in
		 * the schedule queue.  If that's what it wants to do, it
		 * should return 0.
		 */

		con->currently_executing = current;
		con->executing_thread_id = pthread_self();
		ast_mutex_unlock(&con->lock);
		res = current->callback(current->data);
		ast_mutex_lock(&con->lock);
		con->currently_executing = NULL;
		ast_cond_signal(&current->cond);

		if (current->deleted) {
			/*
			 * Another thread is waiting on this scheduled item.  That thread
			 * will be responsible for it's destruction
			 */
			current->rescheduled = res ? 1 : 0;
		} else if (res) {
			/*
			 * If they return non-zero, we should schedule them to be
			 * run again.
			 */
			sched_settime(&current->when, current->variable ? res : current->resched);
			schedule(con, current);
		} else {
			/* No longer needed, so release it */
			sched_release(con, current);
		}
	}

	ast_mutex_unlock(&con->lock);

	return numevents;
}

long ast_sched_when(struct ast_sched_context *con,int id)
{
	struct sched *s;
	long secs = -1;
	DEBUG(ast_debug(1, "ast_sched_when()\n"));

	ast_mutex_lock(&con->lock);

	s = sched_find(con, id);
	if (s) {
		struct timeval now = ast_tvnow();
		secs = s->when.tv_sec - now.tv_sec;
	}

	ast_mutex_unlock(&con->lock);

	return secs;
}