- Use itti timer API for NAS within MME

standalone NAS build OK

git-svn-id: http://svn.eurecom.fr/openair4G/trunk@4619 818b1a75-f10b-46b9-bf7c-635c3b92a50f

openair-cn/NAS/EURECOM-NAS/src/nas_network.c

@@ -21,6 +21,7 @@ Description NAS procedure functions triggered by the network
 #include "nas_network.h"
 #include "commonDef.h"
 #include "nas_log.h"
+#include "nas_timer.h"
 
 #include "as_message.h"
 #include "nas_proc.h"
@@ -62,6 +63,7 @@ void nas_network_initialize(void)
 #ifdef NAS_MME
     /* Initialize the internal NAS processing data */
 # if defined(EPC_BUILD)
+    nas_timer_init();
     nas_proc_initialize(mme_config_p);
 # else
     nas_proc_initialize();

openair-cn/NAS/EURECOM-NAS/src/util/nas_timer.c

@@ -18,21 +18,23 @@ Description	Timer utilities
 
 *****************************************************************************/
 
-#if defined(NAS_MME) && defined(EPC_BUILD)
-# include "TIMER/timer.h"
-#endif
-#include "nas_timer.h"
-#include "commonDef.h"
-
-#include <assert.h>
 #include <pthread.h>
+#include <assert.h>
 #include <signal.h>
+#include <stdint.h>
 
 #include <string.h> // memset
 #include <time.h>   // clock_gettime
 #include <sys/time.h>   // setitimer
 #include <stdlib.h> // malloc, free
 
+#if defined(NAS_MME) && defined(EPC_BUILD)
+# include "intertask_interface.h"
+# include "timer.h"
+#endif
+#include "nas_timer.h"
+#include "commonDef.h"
+
 /****************************************************************************/
 /****************  E X T E R N A L    D E F I N I T I O N S  ****************/
 /****************************************************************************/
@@ -48,11 +50,15 @@ Description	Timer utilities
  * value when the timer entry was allocated.
  */
 typedef struct {
+#if !defined(EPC_BUILD)
+    pthread_t pid;          /* Thread identifier of the callback    */
+#endif
+
     struct timeval itv;     /* Initial interval timer value         */
     struct timeval tv;      /* Interval timer value                 */
+
     nas_timer_callback_t cb;    /* Callback executed at timer expiration */
-    void* args;			/* Callback argument parameters		 */
-    pthread_t pid;		/* Thread identifier of the callback	 */
+    void *args;                 /* Callback argument parameters          */
 } nas_timer_entry_t;
 
 /* Structure of a timer queue - list of active interval timer entries
@@ -63,9 +69,9 @@ typedef struct {
  */
 typedef struct _nas_timer_queue_t {
     int id;         /* Identifier of the current timer entry */
-    nas_timer_entry_t* entry;	/* The current timer entry		 */
-    struct _nas_timer_queue_t* prev;/* The previous timer entry in the queue */
-    struct _nas_timer_queue_t* next;/* The next timer entry in the queue	 */
+    nas_timer_entry_t *entry;   /* The current timer entry       */
+    struct _nas_timer_queue_t *prev;/* The previous timer entry in the queue */
+    struct _nas_timer_queue_t *next;/* The next timer entry in the queue     */
 } timer_queue_t;
 
 /* Structure of a timer database
@@ -77,19 +83,39 @@ typedef struct {
     int timer_id;   /* Identifier of the first available timer entry */
 #define TIMER_DATABASE_SIZE 256
     timer_queue_t tq[TIMER_DATABASE_SIZE];
-    timer_queue_t* head;/* Pointer to the first timer entry to be fired	 */
+    timer_queue_t *head;/* Pointer to the first timer entry to be fired  */
+
+#if !defined(EPC_BUILD)
     pthread_mutex_t mutex;
+#endif
 } nas_timer_database_t;
 
 /*
  * The timer database
  */
-static nas_timer_database_t _nas_timer_db = {0, {}, NULL, PTHREAD_MUTEX_INITIALIZER};
+static nas_timer_database_t _nas_timer_db = {
+    0,
+    {},
+    NULL
+#if !defined(EPC_BUILD)
+    , PTHREAD_MUTEX_INITIALIZER
+#endif
+};
+
+#if defined(EPC_BUILD)
+#define nas_timer_lock_db()
+#define nas_timer_unlock_db()
+#else
+#define nas_timer_lock_db()     pthread_mutex_lock(&_nas_timer_db.mutex)
+#define nas_timer_unlock_db()   pthread_mutex_unlock(&_nas_timer_db.mutex)
+#endif
 
 /*
  * The handler executed whenever the system timer expires
  */
+#if !defined(EPC_BUILD)
 static void _nas_timer_handler(int signal);
+#endif
 
 /*
  * -----------------------------------------------------------------------------
@@ -100,23 +126,26 @@ static void _nas_timer_db_init(void);
 
 static int _nas_timer_db_get_id(void);
 static int _nas_timer_db_is_active(int id);
-static nas_timer_entry_t* _nas_timer_db_create_entry(long sec, nas_timer_callback_t cb, void* args);
+static nas_timer_entry_t *_nas_timer_db_create_entry(long sec,
+        nas_timer_callback_t cb, void *args);
 static void _nas_timer_db_delete_entry(int id);
 
-static void _nas_timer_db_insert_entry(int id, nas_timer_entry_t* te);
-static int _nas_timer_db_insert(timer_queue_t* entry);
+static void _nas_timer_db_insert_entry(int id, nas_timer_entry_t *te);
+static int _nas_timer_db_insert(timer_queue_t *entry);
 
-static nas_timer_entry_t* _nas_timer_db_remove_entry(int id);
-static int _nas_timer_db_remove(timer_queue_t* entry);
+static nas_timer_entry_t *_nas_timer_db_remove_entry(int id);
+static int _nas_timer_db_remove(timer_queue_t *entry);
 
 /*
  * -----------------------------------------------------------------------------
  *      Operator functions for timeval structures
  * -----------------------------------------------------------------------------
  */
-static int _nas_timer_cmp(const struct timeval* a, const struct timeval* b);
-static void _nas_timer_add(const struct timeval* a, const struct timeval* b, struct timeval* result);
-static int _nas_timer_sub(const struct timeval* a, const struct timeval* b, struct timeval* result);
+static int _nas_timer_cmp(const struct timeval *a, const struct timeval *b);
+static void _nas_timer_add(const struct timeval *a, const struct timeval *b,
+                           struct timeval *result);
+static int _nas_timer_sub(const struct timeval *a, const struct timeval *b,
+                          struct timeval *result);
 
 /****************************************************************************/
 /******************  E X P O R T E D    F U N C T I O N S  ******************/
@@ -141,6 +170,7 @@ int nas_timer_init(void)
     /* Initialize the timer database */
     _nas_timer_db_init();
 
+#if !defined(EPC_BUILD)
     /* Setup the timer database handler */
     struct sigaction act;
 
@@ -152,9 +182,9 @@ int nas_timer_init(void)
     (void) sigdelset (&act.sa_mask, SIGILL);
     (void) sigdelset (&act.sa_mask, SIGTRAP);
     (void) sigdelset (&act.sa_mask, SIGIOT);
-#ifndef LINUX
+# ifndef LINUX
     (void) sigdelset (&act.sa_mask, SIGEMT);
-#endif
+# endif
     (void) sigdelset (&act.sa_mask, SIGFPE);
     (void) sigdelset (&act.sa_mask, SIGBUS);
     (void) sigdelset (&act.sa_mask, SIGSEGV);
@@ -164,6 +194,7 @@ int nas_timer_init(void)
     if ( sigaction (SIGALRM, &act, 0) < 0 ) {
         return (RETURNerror);
     }
+#endif
     return (RETURNok);
 }
 
@@ -185,28 +216,43 @@ int nas_timer_init(void)
  **      Others:    None                                       **
  **                                                                        **
  ***************************************************************************/
-int nas_timer_start(long sec, nas_timer_callback_t cb, void* args)
+int nas_timer_start(long sec, nas_timer_callback_t cb, void *args)
 {
+    int id;
+    nas_timer_entry_t *te;
+#if defined(EPC_BUILD)
+    int ret;
+    long timer_id;
+#endif
+
     /* Do not start null timer */
     if (sec == 0) {
         return (NAS_TIMER_INACTIVE_ID);
     }
 
     /* Get an identifier for the new timer entry */
-    int id = _nas_timer_db_get_id();
+    id = _nas_timer_db_get_id();
     if (id < 0) {
         /* No available timer entry found */
         return (NAS_TIMER_INACTIVE_ID);
     }
 
     /* Create a new timer entry */
-    nas_timer_entry_t* te = _nas_timer_db_create_entry(sec, cb, args);
+    te = _nas_timer_db_create_entry(sec, cb, args);
     if (te == NULL) {
         return (NAS_TIMER_INACTIVE_ID);
     }
 
     /* Insert the new entry into the timer queue */
     _nas_timer_db_insert_entry(id, te);
+#if defined(EPC_BUILD)
+    ret = timer_setup(sec, 0, TASK_NAS, INSTANCE_DEFAULT, TIMER_PERIODIC, args, &timer_id);
+
+    if (ret == -1) {
+        return NAS_TIMER_INACTIVE_ID;
+    }
+#endif
+
     return (id);
 }
 
@@ -262,7 +308,7 @@ int nas_timer_restart(int id)
     /* Check if the timer entry is active */
     if (_nas_timer_db_is_active(id)) {
         /* Remove the entry from the timer queue */
-	nas_timer_entry_t* te = _nas_timer_db_remove_entry(id);
+        nas_timer_entry_t *te = _nas_timer_db_remove_entry(id);
         /* Initialize its interval timer value */
         te->tv = te->itv;
         /* Insert again the entry into the timer queue */
@@ -295,13 +341,22 @@ int nas_timer_restart(int id)
  **      Others:    _nas_timer_db                              **
  **                                                                        **
  ***************************************************************************/
+#if defined(EPC_BUILD)
+void nas_timer_handle_signal_expiry(long timer_id, void *arg_p)
+{
+    /* Get the timer entry for which the system timer expired */
+    nas_timer_entry_t *te = _nas_timer_db.head->entry;
+
+    te->cb(te->args);
+}
+#else
 static void _nas_timer_handler(int signal)
 {
     /* At least one timer has been started */
     assert( (_nas_timer_db.head != NULL) && (_nas_timer_db.head->entry != NULL) );
 
     /* Get the timer entry for which the system timer expired */
-    nas_timer_entry_t* te = _nas_timer_db.head->entry;
+    nas_timer_entry_t *te = _nas_timer_db.head->entry;
 
     /* Execute the callback function */
     pthread_attr_t attr;
@@ -313,12 +368,15 @@ static void _nas_timer_handler(int signal)
 
     /* Wait for the thread to terminate before releasing the timer entry */
     if (rc == 0) {
-	void* result = NULL;
+        void *result = NULL;
         (void) pthread_join(te->pid, &result);
         /* TODO: Check returned result ??? */
-	if (result) free(result);
+        if (result) {
+            free(result);
+        }
     }
 }
+#endif
 
 /*
  * -----------------------------------------------------------------------------
@@ -341,7 +399,8 @@ static void _nas_timer_handler(int signal)
  ***************************************************************************/
 static void _nas_timer_db_init(void)
 {
-    for (int i = 0; i < TIMER_DATABASE_SIZE; i++) {
+    int i;
+    for (i = 0; i < TIMER_DATABASE_SIZE; i++) {
         _nas_timer_db.tq[i].id = NAS_TIMER_INACTIVE_ID;
     }
 }
@@ -423,11 +482,11 @@ static int _nas_timer_db_is_active(int id)
  **      Others:    None                                       **
  **                                                                        **
  ***************************************************************************/
-static nas_timer_entry_t* _nas_timer_db_create_entry(
+static nas_timer_entry_t *_nas_timer_db_create_entry(
     long sec, nas_timer_callback_t cb,
-    void* args)
+    void *args)
 {
-    nas_timer_entry_t* te = (nas_timer_entry_t*)malloc(sizeof(nas_timer_entry_t));
+    nas_timer_entry_t *te = (nas_timer_entry_t *)malloc(sizeof(nas_timer_entry_t));
     if (te != NULL) {
         te->itv.tv_sec = sec;
         te->itv.tv_usec = 0;
@@ -482,20 +541,22 @@ static void _nas_timer_db_delete_entry(int id)
  **      Others:    _nas_timer_db                              **
  **                                                                        **
  ***************************************************************************/
-static void _nas_timer_db_insert_entry(int id, nas_timer_entry_t* te)
+static void _nas_timer_db_insert_entry(int id, nas_timer_entry_t *te)
 {
+    struct itimerval it;
+    struct timespec  ts;
+    struct timeval   current_time;
+    int restart;
+
     /* Enqueue the new timer entry */
     _nas_timer_db.tq[id].id = id;
     _nas_timer_db.tq[id].entry = te;
 
     /* Save its interval timer value */
-    struct itimerval it;
     it.it_interval.tv_sec = it.it_interval.tv_usec = 0;
     it.it_value = te->tv;
 
     /* Update its interval timer value */
-    struct timespec ts;
-    struct timeval current_time;
     clock_gettime(CLOCK_MONOTONIC, &ts);
     current_time.tv_sec = ts.tv_sec;
     current_time.tv_usec = ts.tv_nsec/1000;
@@ -503,18 +564,22 @@ static void _nas_timer_db_insert_entry(int id, nas_timer_entry_t* te)
     _nas_timer_add(&te->tv, &current_time, &te->tv);
 
     /* Insert the new timer entry into the list of active entries */
-    pthread_mutex_lock(&_nas_timer_db.mutex);
-    int restart = _nas_timer_db_insert(&_nas_timer_db.tq[id]);
-    pthread_mutex_unlock(&_nas_timer_db.mutex);
+    nas_timer_lock_db();
+    restart = _nas_timer_db_insert(&_nas_timer_db.tq[id]);
+    nas_timer_unlock_db();
 
+#if defined(EPC_BUILD)
     if (restart) {
         /* The new entry is the first entry of the list;
          * restart the system timer */
         setitimer(ITIMER_REAL, &it, 0);
     }
+#else
+    (void)(restart);
+#endif
 }
 
-static int _nas_timer_db_insert(timer_queue_t* entry)
+static int _nas_timer_db_insert(timer_queue_t *entry)
 {
     timer_queue_t *prev, *next; /* previous and next entry in the list  */
     /*
@@ -540,8 +605,7 @@ static int _nas_timer_db_insert(timer_queue_t* entry)
     if (entry->prev != NULL) {
         /* prev <--> entry <--> next */
         entry->prev->next = entry;
-    }
-    else {
+    } else {
         /* The new entry is the first entry of the list */
         _nas_timer_db.head = entry;
         return TRUE;
@@ -567,44 +631,53 @@ static int _nas_timer_db_insert(timer_queue_t* entry)
  **      Others:    _nas_timer_db                              **
  **                                                                        **
  ***************************************************************************/
-static nas_timer_entry_t* _nas_timer_db_remove_entry(int id)
+static nas_timer_entry_t *_nas_timer_db_remove_entry(int id)
 {
+    int restart;
+
     /* The identifier of the timer is valid within the timer queue */
     assert(_nas_timer_db.tq[id].id == id);
 
     /* Remove the timer entry from the list of active entries */
-    pthread_mutex_lock(&_nas_timer_db.mutex);
-    int restart = _nas_timer_db_remove(&_nas_timer_db.tq[id]);
-    pthread_mutex_unlock(&_nas_timer_db.mutex);
+    nas_timer_lock_db();
+    restart = _nas_timer_db_remove(&_nas_timer_db.tq[id]);
+    nas_timer_unlock_db();
 
     if (restart) {
         int rc;
         /* The entry was the first entry of the list;
          * the system timer needs to be restarted */
         struct itimerval it;
-	it.it_interval.tv_sec = it.it_interval.tv_usec = 0;
+        struct timeval tv;
         struct timespec ts;
+
+        it.it_interval.tv_sec = it.it_interval.tv_usec = 0;
+
         clock_gettime(CLOCK_MONOTONIC, &ts);
-	struct timeval time;
-	time.tv_sec = ts.tv_sec;
-	time.tv_usec = ts.tv_nsec/1000;
+
+        tv.tv_sec = ts.tv_sec;
+        tv.tv_usec = ts.tv_nsec/1000;
         /* tv = tv - time() */
-	rc = _nas_timer_sub(&_nas_timer_db.head->entry->tv, &time, &it.it_value);
+        rc = _nas_timer_sub(&_nas_timer_db.head->entry->tv, &tv, &it.it_value);
+
+#if defined(EPC_BUILD)
+        (void)(rc);
+#else
         if (rc < 0) {
-	    /* The system timer should has already expired */
+            /* The system timer should have already expired */
             _nas_timer_handler(SIGALRM);
-	}
-	else {
+        } else {
             /* Restart the system timer */
             setitimer(ITIMER_REAL, &it, 0);
         }
+#endif
     }
 
     /* Return a pointer to the removed entry */
     return (_nas_timer_db.tq[id].entry);
 }
 
-static int _nas_timer_db_remove(timer_queue_t* entry)
+static int _nas_timer_db_remove(timer_queue_t *entry)
 {
     /* Update the pointer from the previous entry */
     /* prev ---> entry ---> next */
@@ -619,14 +692,15 @@ static int _nas_timer_db_remove(timer_queue_t* entry)
         /* prev --------------> next */
         /* prev <-------------- next */
         entry->prev->next = entry->next;
-    }
-    else {
+    } else {
         /* The entry was the first entry of the list */
         _nas_timer_db.head = entry->next;
         if (_nas_timer_db.head != NULL) {
             /* Other timers are scheduled to expire */
             return TRUE;
         }
+#if !defined(EPC_BUILD)
+        {
             /* No more timer is scheduled to expire; stop the system timer */
             struct itimerval it;
             it.it_interval.tv_sec = it.it_interval.tv_usec = 0;
@@ -634,6 +708,8 @@ static int _nas_timer_db_remove(timer_queue_t* entry)
             setitimer(ITIMER_REAL, &it, 0);
             return FALSE;
         }
+#endif
+    }
     /* The entry was NOT the first entry of the list */
     return FALSE;
 }
@@ -658,16 +734,17 @@ static int _nas_timer_db_remove(timer_queue_t* entry)
  **      Others:    None                                       **
  **                                                                        **
  ***************************************************************************/
-static int _nas_timer_cmp(const struct timeval* a, const struct timeval* b)
+static int _nas_timer_cmp(const struct timeval *a, const struct timeval *b)
 {
-    if (a->tv_sec < b->tv_sec)
+    if (a->tv_sec < b->tv_sec) {
         return -1;
-    else if (a->tv_sec > b->tv_sec)
+    } else if (a->tv_sec > b->tv_sec) {
         return 1;
-    else if (a->tv_usec < b->tv_usec)
+    } else if (a->tv_usec < b->tv_usec) {
         return -1;
-    else if (a->tv_usec > b->tv_usec)
+    } else if (a->tv_usec > b->tv_usec) {
         return 1;
+    }
     return 0;
 }
 
@@ -686,8 +763,8 @@ static int _nas_timer_cmp(const struct timeval* a, const struct timeval* b)
  **      Others:    None                                       **
  **                                                                        **
  ***************************************************************************/
-static void _nas_timer_add(const struct timeval* a, const struct timeval* b,
-		       struct timeval* result)
+static void _nas_timer_add(const struct timeval *a, const struct timeval *b,
+                           struct timeval *result)
 {
     result->tv_sec = a->tv_sec + b->tv_sec;
     result->tv_usec = a->tv_usec + b->tv_usec;
@@ -712,8 +789,8 @@ static void _nas_timer_add(const struct timeval* a, const struct timeval* b,
  **      Others:    None                                       **
  **                                                                        **
  ***************************************************************************/
-static int _nas_timer_sub(const struct timeval* a, const struct timeval* b,
-		      struct timeval* result)
+static int _nas_timer_sub(const struct timeval *a, const struct timeval *b,
+                          struct timeval *result)
 {
     if (_nas_timer_cmp(a,b) > 0 ) {
         result->tv_sec = a->tv_sec - b->tv_sec;

openair-cn/NAS/EURECOM-NAS/src/util/nas_timer.h

@@ -41,7 +41,7 @@ struct nas_timer_t {
 };
 
 /* Type of the callback executed when the timer expired */
-typedef void* (*nas_timer_callback_t)(void*);
+typedef void *(*nas_timer_callback_t)(void *);
 
 /****************************************************************************/
 /********************  G L O B A L    V A R I A B L E S  ********************/
@@ -51,16 +51,13 @@ typedef void* (*nas_timer_callback_t)(void*);
 /******************  E X P O R T E D    F U N C T I O N S  ******************/
 /****************************************************************************/
 
-#if defined(NAS_MME) && defined(EPC_BUILD)
-# define nas_timer_init
-# define nas_timer_start
-# define nas_timer_stop
-# define nas_timer_restart
-#else
 int nas_timer_init(void);
-int nas_timer_start(long sec, nas_timer_callback_t cb, void* args);
+int nas_timer_start(long sec, nas_timer_callback_t cb, void *args);
 int nas_timer_stop(int id);
 int nas_timer_restart(int id);
+
+#if defined(EPC_BUILD)
+void nas_timer_handle_signal_expiry(long timer_id, void *arg_p);
 #endif
 
 #endif /* __NAS_TIMER_H__ */

openair-cn/NAS/Makefile.inc

@@ -370,6 +370,8 @@ libnas_ies_SRCS = \
 libnas_utils_SRCS = \
     EURECOM-NAS/src/util/nas_log.h      \
     EURECOM-NAS/src/util/nas_log.c      \
+    EURECOM-NAS/src/util/nas_timer.h      \
+    EURECOM-NAS/src/util/nas_timer.c      \
     EURECOM-NAS/src/util/TLVEncoder.h      \
     EURECOM-NAS/src/util/TLVEncoder.c      \
     EURECOM-NAS/src/util/TLVDecoder.h      \

openair-cn/NAS/nas_main.c

@@ -44,6 +44,7 @@
 # include "nas_proc.h"
 # include "emm_main.h"
 # include "nas_log.h"
+# include "nas_timer.h"
 #endif
 
 #define NAS_ERROR(x, args...) do { fprintf(stderr, "[NAS] [E]"x, ##args); } while(0)
@@ -133,6 +134,14 @@ next_message:
             } break;
 #endif
 
+            case TIMER_HAS_EXPIRED: {
+#if !defined(DISABLE_USE_NAS)
+                /* Call the NAS timer api */
+                nas_timer_handle_signal_expiry(TIMER_HAS_EXPIRED(received_message_p).timer_id,
+                                               TIMER_HAS_EXPIRED(received_message_p).arg);
+#endif
+            } break;
+
             case TERMINATE_MESSAGE: {
                 itti_exit_task();
             } break;