minor code cleanup
[asterisk/asterisk.git] / sched.c
diff --git a/sched.c b/sched.c
old mode 100755 (executable)
new mode 100644 (file)
index a3d6c72..56a16bd
--- a/sched.c
+++ b/sched.c
@@ -1,14 +1,26 @@
 /*
- * Asterisk -- A telephony toolkit for Linux.
- * 
+ * Asterisk -- An open source telephony toolkit.
+ *
+ * Copyright (C) 1999 - 2005, Digium, Inc.
+ *
  * Mark Spencer <markster@digium.com>
  *
- * Copyright(C) Mark Spencer
- * 
- * Distributed under the terms of the GNU General Public License (GPL) Version 2
+ * 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
  *
- * Scheduler Routines (from cheops-NG)
+ * \brief Scheduler Routines (from cheops-NG)
  *
+ * \author Mark Spencer <markster@digium.com>
  */
 
 #ifdef DEBUG_SCHEDULER
@@ -38,29 +50,23 @@ ASTERISK_FILE_VERSION(__FILE__, "$Revision$")
                                         (((b).tv_sec == (a).tv_sec) && ((b).tv_usec > (a).tv_usec)))
 
 struct sched {
-       struct sched *next;             /* Next event in the list */
-       int id;                         /* ID number of event */
-       struct timeval when;            /* Absolute time event should take place */
-       int resched;                    /* When to reschedule */
-       int variable;           /* Use return value from callback to reschedule */
-       void *data;                     /* Data */
-       ast_sched_cb callback;          /* Callback */
+       struct sched *next;             /*!< Next event in the list */
+       int id;                         /*!< ID number of event */
+       struct timeval when;            /*!< Absolute time event should take place */
+       int resched;                    /*!< When to reschedule */
+       int variable;                   /*!< Use return value from callback to reschedule */
+       void *data;                     /*!< Data */
+       ast_sched_cb callback;          /*!< Callback */
 };
 
 struct sched_context {
        ast_mutex_t lock;
-       /* Number of events processed */
-       int eventcnt;
-
-       /* Number of outstanding schedule events */
-       int schedcnt;
-
-       /* Schedule entry and main queue */
-       struct sched *schedq;
+       int eventcnt;                   /*!< Number of events processed */
+       int schedcnt;                   /*!< Number of outstanding schedule events */
+       struct sched *schedq;           /*!< Schedule entry and main queue */
 
 #ifdef SCHED_MAX_CACHE
-       /* Cache of unused schedule structures and how many */
-       struct sched *schedc;
+       struct sched *schedc;           /*!< Cache of unused schedule structures and how many */
        int schedccnt;
 #endif
 };
@@ -68,18 +74,13 @@ struct sched_context {
 struct sched_context *sched_context_create(void)
 {
        struct sched_context *tmp;
-       tmp = malloc(sizeof(struct sched_context));
-       if (tmp) {
-               memset(tmp, 0, sizeof(struct sched_context));
-               ast_mutex_init(&tmp->lock);
-               tmp->eventcnt = 1;
-               tmp->schedcnt = 0;
-               tmp->schedq = NULL;
-#ifdef SCHED_MAX_CACHE
-               tmp->schedc = NULL;
-               tmp->schedccnt = 0;
-#endif
-       }
+
+       if (!(tmp = ast_calloc(1, sizeof(*tmp))))
+               return NULL;
+
+       ast_mutex_init(&tmp->lock);
+       tmp->eventcnt = 1;
+       
        return tmp;
 }
 
@@ -144,12 +145,12 @@ static void sched_release(struct sched_context *con, struct sched *tmp)
                free(tmp);
 }
 
+/*! \brief
+ * Return the number of milliseconds 
+ * until the next scheduled event
+ */
 int ast_sched_wait(struct sched_context *con)
 {
-       /*
-        * Return the number of milliseconds 
-        * until the next scheduled event
-        */
        int ms;
        DEBUG(ast_log(LOG_DEBUG, "ast_sched_wait()\n"));
        ast_mutex_lock(&con->lock);
@@ -166,13 +167,13 @@ int ast_sched_wait(struct sched_context *con)
 }
 
 
+/*! \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 sched_context *con, struct sched *s)
 {
-       /*
-        * Take a sched structure and put it in the
-        * queue, such that the soonest event is
-        * first in the list. 
-        */
         
        struct sched *last=NULL;
        struct sched *current=con->schedq;
@@ -191,7 +192,7 @@ static void schedule(struct sched_context *con, struct sched *s)
        con->schedcnt++;
 }
 
-/*
+/*! \brief
  * given the last event *tv and the offset in milliseconds 'when',
  * computes the next value,
  */
@@ -211,11 +212,11 @@ static int sched_settime(struct timeval *tv, int when)
 }
 
 
+/*! \brief
+ * Schedule callback(data) to happen when ms into the future
+ */
 int ast_sched_add_variable(struct sched_context *con, int when, ast_sched_cb callback, void *data, int variable)
 {
-       /*
-        * Schedule callback(data) to happen when ms into the future
-        */
        struct sched *tmp;
        int res = -1;
        DEBUG(ast_log(LOG_DEBUG, "ast_sched_add()\n"));
@@ -251,14 +252,14 @@ int ast_sched_add(struct sched_context *con, int when, ast_sched_cb callback, vo
        return ast_sched_add_variable(con, when, callback, data, 0);
 }
 
+/*! \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.
+ */
 int ast_sched_del(struct sched_context *con, int id)
 {
-       /*
-        * Delete the schedule entry with number
-        * "id".  It's nearly impossible that there
-        * would be two or more in the list with that
-        * id.
-        */
        struct sched *last=NULL, *s;
        DEBUG(ast_log(LOG_DEBUG, "ast_sched_del()\n"));
        ast_mutex_lock(&con->lock);
@@ -316,17 +317,17 @@ void ast_sched_dump(const struct sched_context *con)
                        q->callback,
                        q->data,
                        delta.tv_sec,
-                       delta.tv_usec);
+                       (long int)delta.tv_usec);
        }
        ast_log(LOG_DEBUG, "=============================================================\n");
        
 }
 
+/*! \brief
+ * Launch all events which need to be run at this time.
+ */
 int ast_sched_runq(struct sched_context *con)
 {
-       /*
-        * Launch all events which need to be run at this time.
-        */
        struct sched *current;
        struct timeval tv;
        int x=0;
@@ -390,15 +391,14 @@ long ast_sched_when(struct sched_context *con,int id)
        DEBUG(ast_log(LOG_DEBUG, "ast_sched_when()\n"));
 
        ast_mutex_lock(&con->lock);
-       s=con->schedq;
-       while (s!=NULL) {
-               if (s->id==id) break;
-               s=s->next;
+       for (s = con->schedq; s; s = s->next) {
+               if (s->id == id)
+                       break;
        }
        secs=-1;
        if (s!=NULL) {
                struct timeval now = ast_tvnow();
-               secs=s->when.tv_sec-now.tv_sec;
+               secs = s->when.tv_sec - now.tv_sec;
        }
        ast_mutex_unlock(&con->lock);
        return secs;