Merge branch 'develop_integration_2018_w47' into 'develop'

Develop integration 2018 week 47

See merge request oai/openairinterface5g!456

cmake_targets/CMakeLists.txt

@@ -630,7 +630,6 @@ add_boolean_option(ENABLE_VCD              True  "always true now, time measurem
 add_boolean_option(ENABLE_VCD_FIFO         True  "time measurements of proc calls and var displays sent to FIFO (one more thread)")
 add_boolean_option(LINUX                   False "used in weird memcpy() in pdcp.c ???")
 add_boolean_option(LINUX_LIST              False "used only in lists.c: either use OAI implementation of lists or Linux one (should be True, but it is False")
-add_boolean_option(LOG_NO_THREAD           True  "Disable thread for log, seems always set to true")
 add_boolean_option(OPENAIR_LTE             True "Seems legacy: keep it to true")
 
 ##########################
@@ -1927,6 +1926,7 @@ add_executable(lte-softmodem
   ${OPENAIR_TARGETS}/RT/USER/lte-enb.c
   ${OPENAIR_TARGETS}/RT/USER/lte-ru.c
   ${OPENAIR_TARGETS}/RT/USER/lte-softmodem.c
+  ${OPENAIR_TARGETS}/RT/USER/lte-softmodem-common.c
   ${OPENAIR2_DIR}/ENB_APP/NB_IoT_interface.c
   ${OPENAIR1_DIR}/SIMULATION/TOOLS/taus.c
   ${OPENAIR_TARGETS}/COMMON/create_tasks.c
@@ -1966,6 +1966,7 @@ add_executable(lte-softmodem-nos1
   ${OPENAIR_TARGETS}/RT/USER/lte-enb.c
   ${OPENAIR_TARGETS}/RT/USER/lte-ru.c
   ${OPENAIR_TARGETS}/RT/USER/lte-softmodem.c
+  ${OPENAIR_TARGETS}/RT/USER/lte-softmodem-common.c
   ${OPENAIR2_DIR}/ENB_APP/NB_IoT_interface.c
   ${OPENAIR1_DIR}/SIMULATION/TOOLS/taus.c
   ${OPENAIR_TARGETS}/COMMON/create_tasks.c
@@ -2003,6 +2004,7 @@ add_executable(lte-uesoftmodem
   ${OPENAIR_TARGETS}/RT/USER/rt_wrapper.c
   ${OPENAIR_TARGETS}/RT/USER/lte-ue.c
   ${OPENAIR_TARGETS}/RT/USER/lte-uesoftmodem.c
+  ${OPENAIR_TARGETS}/RT/USER/lte-softmodem-common.c
   ${OPENAIR_TARGETS}/RT/USER/lte-ru.c
   ${OPENAIR_TARGETS}/RT/USER/rfsim.c
   ${OPENAIR1_DIR}/SIMULATION/TOOLS/taus.c
@@ -2041,6 +2043,7 @@ add_executable(lte-uesoftmodem-nos1
   ${OPENAIR_TARGETS}/RT/USER/rt_wrapper.c
   ${OPENAIR_TARGETS}/RT/USER/lte-ue.c
   ${OPENAIR_TARGETS}/RT/USER/lte-uesoftmodem.c
+  ${OPENAIR_TARGETS}/RT/USER/lte-softmodem-common.c
   ${OPENAIR_TARGETS}/RT/USER/lte-ru.c
   ${OPENAIR_TARGETS}/RT/USER/rfsim.c
   ${OPENAIR1_DIR}/SIMULATION/TOOLS/taus.c

cmake_targets/build_oai

@@ -651,6 +651,9 @@ function main() {
     compilations \
           lte-simulators coding \
           libcoding.so $dbin/libcoding.so
+#    compilations \
+#	  lte-simulators $config_libconfig_shlib \
+#	  lib$config_libconfig_shlib.so $dbin/lib$config_libconfig_shlib.so
   fi
 
   # Core simulators

common/config/config_cmdline.c

@@ -39,40 +39,38 @@
 #include "config_userapi.h"
 
 
-int parse_stringlist(paramdef_t *cfgoptions, char *val)
-{
-char *atoken;
-char *tokctx;
-char *tmpval=strdup(val);
-int   numelt=0;
-
+int parse_stringlist(paramdef_t *cfgoptions, char *val) {
+  char *atoken;
+  char *tokctx;
+  char *tmpval=strdup(val);
+  int   numelt=0;
   cfgoptions->numelt=0;
-
   atoken=strtok_r(tmpval, ",",&tokctx);
+
   while(atoken != NULL) {
     numelt++ ;
     atoken=strtok_r(NULL, ",",&tokctx);
   }
+
   free(tmpval);
   config_check_valptr(cfgoptions,(char **)&(cfgoptions->strlistptr), sizeof(char *) * numelt);
   cfgoptions->numelt=numelt;
-
   atoken=strtok_r(val, ",",&tokctx);
+
   for( int i=0; i<cfgoptions->numelt && atoken != NULL ; i++) {
     config_check_valptr(cfgoptions,&(cfgoptions->strlistptr[i]),strlen(atoken)+1);
     sprintf(cfgoptions->strlistptr[i],"%s",atoken);
     printf_params("[LIBCONFIG] %s[%i]: %s\n", cfgoptions->optname,i,cfgoptions->strlistptr[i]);
     atoken=strtok_r(NULL, ",",&tokctx);
   }
+
   return (cfgoptions->numelt > 0);
 }
 
-int processoption(paramdef_t *cfgoptions, char *value)
-{
-char *tmpval = value;
-int optisset=0;
-char defbool[2]="1";
-
+int processoption(paramdef_t *cfgoptions, char *value) {
+  char *tmpval = value;
+  int optisset=0;
+  char defbool[2]="1";
 
   if ( value == NULL) {
     if( (cfgoptions->paramflags &PARAMFLAG_BOOL) == 0 ) { /* not a boolean, argument required */
@@ -82,8 +80,8 @@ char defbool[2]="1";
       tmpval = defbool;
     }
   }
-     switch(cfgoptions->type)
-       {
+
+  switch(cfgoptions->type) {
     case TYPE_STRING:
       if (cfgoptions->numelt == 0 ) {
         config_check_valptr(cfgoptions, cfgoptions->strptr, strlen(tmpval)+1);
@@ -91,6 +89,7 @@ char defbool[2]="1";
       } else {
         sprintf( (char *)(cfgoptions->strptr), "%s",tmpval);
       }
+
       printf_cmdl("[CONFIG] %s set to  %s from command line\n", cfgoptions->optname, tmpval);
       optisset=1;
       break;
@@ -98,6 +97,7 @@ char defbool[2]="1";
     case TYPE_STRINGLIST:
       optisset=parse_stringlist(cfgoptions,tmpval);
       break;
+
     case TYPE_UINT32:
     case TYPE_INT32:
     case TYPE_UINT16:
@@ -108,6 +108,7 @@ char defbool[2]="1";
       config_assign_int(cfgoptions,cfgoptions->optname,(int32_t)strtol(tmpval,NULL,0));
       optisset=1;
       break;
+
     case TYPE_UINT64:
     case TYPE_INT64:
       config_check_valptr(cfgoptions, (char **)&(cfgoptions->i64ptr),sizeof(uint64_t));
@@ -115,10 +116,11 @@ char defbool[2]="1";
       printf_cmdl("[CONFIG] %s set to  %lli from command line\n", cfgoptions->optname, (long long)*(cfgoptions->i64ptr));
       optisset=1;
       break;
+
     case TYPE_UINTARRAY:
     case TYPE_INTARRAY:
-
       break;
+
     case TYPE_DOUBLE:
       config_check_valptr(cfgoptions, (char **)&(cfgoptions->dblptr),sizeof(double));
       *(cfgoptions->dblptr) = strtof(tmpval,NULL);
@@ -127,45 +129,83 @@ char defbool[2]="1";
       break;
 
     case TYPE_IPV4ADDR:
-
       break;
 
     default:
       fprintf(stderr,"[CONFIG] command line, %s type %i  not supported\n",cfgoptions->optname, cfgoptions->type);
       break;
   } /* switch on param type */
+
   if (optisset == 1) {
     cfgoptions->paramflags = cfgoptions->paramflags |  PARAMFLAG_PARAMSET;
   }
+
   return optisset;
 }
 
-int config_process_cmdline(paramdef_t *cfgoptions,int numoptions, char *prefix)
-{
+int config_check_cmdlineopt(char *prefix) {
+  int unknowndetected=0;
+  char testprefix[CONFIG_MAXOPTLENGTH]="";
+  int finalcheck = 0;
+
+  if (prefix != NULL) {
+    if (strcmp(prefix,CONFIG_CHECKALLSECTIONS) == 0)
+      finalcheck = 1;
+    else if (strlen(prefix) > 0) {
+      sprintf(testprefix,"--%s.",prefix);
+    }
+  }
+
+  for (int i=1; i<config_get_if()->argc ; i++) {
+    if ( !finalcheck && strstr(config_get_if()->argv[i],testprefix) == NULL ) continue;
+
+    if ( !finalcheck && testprefix[0]==0 && index(config_get_if()->argv[i],'.') != NULL) continue;
+
+    if ( !finalcheck && config_get_if()->argv[i][0] == '-' && isdigit(config_get_if()->argv[i][1])) continue;
+
+    if ( (config_get_if()->argv_info[i] & CONFIG_CMDLINEOPT_PROCESSED) == 0 ) {
+      fprintf(stderr,"[CONFIG] unknown option: %s\n",
+              config_get_if()->argv[i] );
+      unknowndetected++;
+    }
+  }
+
+  printf_cmdl("[CONFIG] %i unknown option(s) in command line starting with %s (section %s)\n",
+              unknowndetected,testprefix,((prefix==NULL)?"":prefix));
+  return unknowndetected;
+}  /* parse_cmdline*/
+
+int config_process_cmdline(paramdef_t *cfgoptions,int numoptions, char *prefix) {
   int c = config_get_if()->argc;
   int i,j;
   char *pp;
-  char cfgpath[512]; /* 512 should be enough for the sprintf below */
- 
+  char cfgpath[CONFIG_MAXOPTLENGTH];
   j = 0;
   i = 0;
+
   while (c > 0 ) {
     char *oneargv = strdup(config_get_if()->argv[i]);          /* we use strtok_r which modifies its string paramater, and we don't want argv to be modified */
+
     /* first check help options, either --help, -h or --help_<section> */
     if (strncmp(oneargv, "-h",2) == 0 || strncmp(oneargv, "--help",6) == 0 ) {
       char *tokctx;
       pp=strtok_r(oneargv, "_",&tokctx);
+      config_get_if()->argv_info[i] |= CONFIG_CMDLINEOPT_PROCESSED;
+
       if (pp == NULL || strcasecmp(pp,config_get_if()->argv[i] ) == 0 ) {
         if( prefix == NULL) {
           config_printhelp(cfgoptions,numoptions);
+
           if ( ! ( CONFIG_ISFLAGSET(CONFIG_NOEXITONHELP)))
             exit_fun("[CONFIG] Exiting after displaying help\n");
         }
       } else {
         pp=strtok_r(NULL, " ",&tokctx);
+
         if ( prefix != NULL && pp != NULL && strncasecmp(prefix,pp,strlen(pp)) == 0 ) {
           printf ("Help for %s section:\n",prefix);
           config_printhelp(cfgoptions,numoptions);
+
           if ( ! (CONFIG_ISFLAGSET(CONFIG_NOEXITONHELP))) {
             fprintf(stderr,"[CONFIG] %s %i section %s:", __FILE__, __LINE__, prefix);
             exit_fun(" Exiting after displaying help\n");
@@ -176,23 +216,29 @@ int config_process_cmdline(paramdef_t *cfgoptions,int numoptions, char *prefix)
 
     /* now, check for non help options */
     if (oneargv[0] == '-') {
-    	    for(int n=0;n<numoptions;n++) {
+      for(int n=0; n<numoptions; n++) {
         if ( ( cfgoptions[n].paramflags & PARAMFLAG_DISABLECMDLINE) != 0) {
           continue;
         }
+
         if (prefix != NULL) {
           sprintf(cfgpath,"%s.%s",prefix,cfgoptions[n].optname);
         } else {
           sprintf(cfgpath,"%s",cfgoptions[n].optname);
         }
+
         if ( ((strlen(oneargv) == 2) && (strcmp(oneargv + 1,cfgpath) == 0))  || /* short option, one "-" */
              ((strlen(oneargv) > 2) && (strcmp(oneargv + 2,cfgpath ) == 0 )) ) {
           char *valptr=NULL;
           int ret;
+          config_get_if()->argv_info[i] |= CONFIG_CMDLINEOPT_PROCESSED;
+
           if (c > 0) {
             pp = config_get_if()->argv[i+1];
+
             if (pp != NULL ) {
               ret = strlen(pp);
+
               if (ret > 0 ) {
                 if (pp[0] != '-')
                   valptr=pp;
@@ -201,19 +247,36 @@ int config_process_cmdline(paramdef_t *cfgoptions,int numoptions, char *prefix)
               }
             }
           }
+
           j += processoption(&(cfgoptions[n]), valptr);
+
           if (  valptr != NULL ) {
             i++;
+            config_get_if()->argv_info[i] |= CONFIG_CMDLINEOPT_PROCESSED;
             c--;
           }
+
           break;
         }
       } /* for n... */
     } /* if (oneargv[0] == '-') */
+
     free(oneargv);
     i++;
     c--;
   }   /* fin du while */
+
   printf_cmdl("[CONFIG] %s %i options set from command line\n",((prefix == NULL) ? "(root)":prefix),j);
+
+  if ( !(CONFIG_ISFLAGSET( CONFIG_NOCHECKUNKOPT )) ) {
+    i=config_check_cmdlineopt(prefix);
+
+    if (i > 0) {
+      fprintf(stderr,"[CONFIG] %i unknown options for section %s detected in command line\n",
+              i,((prefix==NULL)?"\"root section\"":prefix));
+      exit_fun(" Exiting after detecting errors in command line \n");
+    }
+  }
+
   return j;
 }  /* parse_cmdline*/

common/config/config_load_configmodule.c

@@ -42,17 +42,15 @@
 #include "config_userapi.h"
 #define CONFIG_SHAREDLIBFORMAT "libparams_%s.so"
 
-int load_config_sharedlib(configmodule_interface_t *cfgptr)
-{
-void *lib_handle;
-char fname[128];
-char libname[FILENAME_MAX]; 
-int st;
-
+int load_config_sharedlib(configmodule_interface_t *cfgptr) {
+  void *lib_handle;
+  char fname[128];
+  char libname[FILENAME_MAX];
+  int st;
   st=0;
   sprintf(libname,CONFIG_SHAREDLIBFORMAT,cfgptr->cfgmode);
-
   lib_handle = dlopen(libname,RTLD_NOW | RTLD_GLOBAL | RTLD_NODELETE);
+
   if (!lib_handle) {
     fprintf(stderr,"[CONFIG] %s %d Error calling dlopen(%s): %s\n",__FILE__, __LINE__, libname,dlerror());
     st = -1;
@@ -71,6 +69,7 @@ int st;
 
     sprintf (fname,"config_%s_get",cfgptr->cfgmode);
     cfgptr->get = dlsym(lib_handle,fname);
+
     if (cfgptr->get == NULL ) {
       printf("[CONFIG] %s %d no function %s for config mode %s\n",
              __FILE__, __LINE__,fname, cfgptr->cfgmode);
@@ -79,6 +78,7 @@ int st;
 
     sprintf (fname,"config_%s_getlist",cfgptr->cfgmode);
     cfgptr->getlist = dlsym(lib_handle,fname);
+
     if (cfgptr->getlist == NULL ) {
       printf("[CONFIG] %s %d no function %s for config mode %s\n",
              __FILE__, __LINE__,fname, cfgptr->cfgmode);
@@ -87,6 +87,7 @@ int st;
 
     sprintf (fname,"config_%s_end",cfgptr->cfgmode);
     cfgptr->end = dlsym(lib_handle,fname);
+
     if (cfgptr->getlist == NULL ) {
       printf("[CONFIG] %s %d no function %s for config mode %s\n",
              __FILE__, __LINE__,fname, cfgptr->cfgmode);
@@ -102,29 +103,29 @@ int nooptfunc(void) {
 };
 
 int config_cmdlineonly_getlist(paramlist_def_t *ParamList,
-                                   paramdef_t *params, int numparams, char *prefix)
-{
+                               paramdef_t *params, int numparams, char *prefix) {
   ParamList->numelt = 0;
   return 0;
 }
 
 
-int config_cmdlineonly_get(paramdef_t *cfgoptions,int numoptions, char *prefix )
-{
+int config_cmdlineonly_get(paramdef_t *cfgoptions,int numoptions, char *prefix ) {
   int defval;
   int fatalerror=0;
   int numdefvals=0;
 
-
-  for(int i=0;i<numoptions;i++) {
+  for(int i=0; i<numoptions; i++) {
     defval=0;
+
     switch(cfgoptions[i].type) {
       case TYPE_STRING:
         defval=config_setdefault_string(&(cfgoptions[i]), prefix);
         break;
+
       case TYPE_STRINGLIST:
         defval=config_setdefault_stringlist(&(cfgoptions[i]), prefix);
         break;
+
       case TYPE_UINT8:
       case TYPE_INT8:
       case TYPE_UINT16:
@@ -134,96 +135,120 @@ int config_cmdlineonly_get(paramdef_t *cfgoptions,int numoptions, char *prefix )
       case TYPE_MASK:
         defval=config_setdefault_int(&(cfgoptions[i]), prefix);
         break;
+
       case TYPE_UINT64:
       case TYPE_INT64:
         defval=config_setdefault_int64(&(cfgoptions[i]), prefix);
         break;
+
       case TYPE_UINTARRAY:
       case TYPE_INTARRAY:
         defval=config_setdefault_intlist(&(cfgoptions[i]), prefix);
         break;
+
       case TYPE_DOUBLE:
         defval=config_setdefault_double(&(cfgoptions[i]), prefix);
         break;
+
       case TYPE_IPV4ADDR:
         defval=config_setdefault_ipv4addr(&(cfgoptions[i]), prefix);
-              
         break;
+
       default:
         fprintf(stderr,"[CONFIG] %s.%s type %i  not supported\n",prefix, cfgoptions[i].optname,cfgoptions[i].type);
         fatalerror=1;
         break;
     } /* switch on param type */
+
     if (defval == 1) {
       numdefvals++;
       cfgoptions[i].paramflags = cfgoptions[i].paramflags |  PARAMFLAG_PARAMSETDEF;
     }
   } /* for loop on options */
+
   printf("[CONFIG] %s: %i/%i parameters successfully set \n",
          ((prefix == NULL)?"(root)":prefix),
          numdefvals,numoptions );
+
   if (fatalerror == 1) {
     fprintf(stderr,"[CONFIG] fatal errors found when assigning %s parameters \n",
             prefix);
   }
+
   return numdefvals;
 }
 
-configmodule_interface_t *load_configmodule(int argc, char **argv)
-{
-char *cfgparam=NULL;
-char *modeparams=NULL;
-char *cfgmode=NULL;
-char *strtokctx=NULL;
-char *atoken;
-uint32_t tmpflags=0;
-int i;
- 
-/* first parse the command line to look for the -O option */
-  for (i = 0;i<argc;i++) {
+configmodule_interface_t *load_configmodule(int argc, char **argv, uint32_t initflags) {
+  char *cfgparam=NULL;
+  char *modeparams=NULL;
+  char *cfgmode=NULL;
+  char *strtokctx=NULL;
+  char *atoken;
+  uint32_t tmpflags=0;
+  int i;
+  int OoptIdx=-1;
+
+  /* first parse the command line to look for the -O option */
+  for (i = 0; i<argc; i++) {
     if (strlen(argv[i]) < 2) continue;
+
     if ( argv[i][1] == 'O' && i < (argc -1)) {
       cfgparam = argv[i+1];
+      OoptIdx=i;
     }
+
     if ( strstr(argv[i], "help_config") != NULL  ) {
       config_printhelp(Config_Params,CONFIG_PARAMLENGTH(Config_Params));
       exit(0);
     }
+
     if ( (strcmp(argv[i]+1, "h") == 0) || (strstr(argv[i]+1, "help_") != NULL ) ) {
       tmpflags = CONFIG_HELP;
     }
   }
 
-/* look for the OAI_CONFIGMODULE environement variable */
+  /* look for the OAI_CONFIGMODULE environement variable */
   if ( cfgparam == NULL ) {
     cfgparam = getenv("OAI_CONFIGMODULE");
   }
 
-/* default */
+  /* default different for UE and softmodem because UE doesn't use config file*/
+  /* and -O option is not mandatory for UE                                    */
+  /* phy simulators behave as UE                                              */
+  /* test of exec name would better be replaced by a parameter to the l       */
+  /* oad_configmodule function */
   if (cfgparam == NULL) {
     tmpflags = tmpflags | CONFIG_NOOOPT;
-     if (strstr(argv[0],"uesoftmodem") == NULL) {
-         cfgparam = CONFIG_LIBCONFIGFILE ":" DEFAULT_CFGFILENAME;
+
+    if ( initflags &  CONFIG_ENABLECMDLINEONLY) {
+      cfgparam = CONFIG_CMDLINEONLY ":dbgl0" ;
     } else {
       cfgparam = CONFIG_CMDLINEONLY ":dbgl0" ;
+      cfgparam = CONFIG_LIBCONFIGFILE ":" DEFAULT_CFGFILENAME;
     }
   }
 
-/* parse the config parameters to set the config source */
+  /* parse the config parameters to set the config source */
   i = sscanf(cfgparam,"%m[^':']:%ms",&cfgmode,&modeparams);
+
   if (i< 0) {
     fprintf(stderr,"[CONFIG] %s, %d, sscanf error parsing config source  %s: %s\n", __FILE__, __LINE__,cfgparam, strerror(errno));
-       exit(-1);
-   }
-   else if ( i == 1 ) {
+    exit(-1) ;
+  } else if ( i == 1 ) {
     /* -O argument doesn't contain ":" separator, assume -O <conf file> option, default cfgmode to libconfig
-     with one parameter, the path to the configuration file */
+       with one parameter, the path to the configuration file cfgmode must not be NULL */
     modeparams=cfgmode;
     cfgmode=strdup(CONFIG_LIBCONFIGFILE);
   }
 
-   cfgptr = malloc(sizeof(configmodule_interface_t));
-   memset(cfgptr,0,sizeof(configmodule_interface_t));
+  cfgptr = calloc(sizeof(configmodule_interface_t),1);
+  cfgptr->argv_info = calloc(sizeof(int32_t), argc);
+  cfgptr->argv_info[0] |= CONFIG_CMDLINEOPT_PROCESSED;
+
+  if (OoptIdx >= 0) {
+    cfgptr->argv_info[OoptIdx] |= CONFIG_CMDLINEOPT_PROCESSED;
+    cfgptr->argv_info[OoptIdx+1] |= CONFIG_CMDLINEOPT_PROCESSED;
+  }
 
   cfgptr->rtflags = cfgptr->rtflags | tmpflags;
   cfgptr->argc   = argc;
@@ -231,30 +256,34 @@ int i;
   cfgptr->cfgmode=strdup(cfgmode);
   cfgptr->num_cfgP=0;
   atoken=strtok_r(modeparams,":",&strtokctx);
+
   while ( cfgptr->num_cfgP< CONFIG_MAX_OOPT_PARAMS && atoken != NULL) {
     /* look for debug level in the config parameters, it is commom to all config mode
        and will be removed frome the parameter array passed to the shared module */
     char *aptr;
     aptr=strcasestr(atoken,"dbgl");
+
     if (aptr != NULL) {
       cfgptr->rtflags = cfgptr->rtflags | strtol(aptr+4,NULL,0);
-
     } else {
       cfgptr->cfgP[cfgptr->num_cfgP] = strdup(atoken);
       cfgptr->num_cfgP++;
     }
+
     atoken = strtok_r(NULL,":",&strtokctx);
   }
 
-   
   printf("[CONFIG] get parameters from %s ",cfgmode);
-   for (i=0;i<cfgptr->num_cfgP; i++) {
+
+  for (i=0; i<cfgptr->num_cfgP; i++) {
     printf("%s ",cfgptr->cfgP[i]);
   }
+
   printf(", debug flags: 0x%08x\n",cfgptr->rtflags);
 
   if (strstr(cfgparam,CONFIG_CMDLINEONLY) == NULL) {
     i=load_config_sharedlib(cfgptr);
+
     if (i ==  0) {
       printf("[CONFIG] config module %s loaded\n",cfgmode);
       Config_Params[CONFIGPARAM_DEBUGFLAGS_IDX].uptr=&(cfgptr->rtflags);
@@ -270,22 +299,22 @@ int i;
     cfgptr->end = (configmodule_endfunc_t)nooptfunc;
   }
 
-  
-
   if (modeparams != NULL) free(modeparams);
+
   if (cfgmode != NULL) free(cfgmode);
+
   if (CONFIG_ISFLAGSET(CONFIG_ABORT)) {
     config_printhelp(Config_Params,CONFIG_PARAMLENGTH(Config_Params));
-//       exit(-1);   
+    //       exit(-1);
   }
+
   return cfgptr;
 }
 
 
 /* free memory allocated when reading parameters */
 /* config module could be initialized again after this call */
-void end_configmodule(void)
-{ 
+void end_configmodule(void) {
   if (cfgptr != NULL) {
     if (cfgptr->end != NULL) {
       printf ("[CONFIG] calling config module end function...\n");
@@ -293,29 +322,32 @@ void end_configmodule(void)
     }
 
     printf ("[CONFIG] free %u config value pointers\n",cfgptr->numptrs);
+
     for(int i=0; i<cfgptr->numptrs ; i++) {
       if (cfgptr->ptrs[i] != NULL) {
         free(cfgptr->ptrs[i]);
         cfgptr->ptrs[i]=NULL;
       }
     }
+
     cfgptr->numptrs=0;
   }
 }
 
 /* free all memory used by config module */
 /* should be called only at program exit */
-void free_configmodule(void)
-{ 
+void free_configmodule(void) {
   if (cfgptr != NULL) {
     end_configmodule();
+
     if( cfgptr->cfgmode != NULL) free(cfgptr->cfgmode);
+
     printf ("[CONFIG] free %u config parameter pointers\n",cfgptr->num_cfgP);
+
     for (int i=0; i<cfgptr->num_cfgP; i++) {
       if ( cfgptr->cfgP[i] != NULL) free(cfgptr->cfgP[i]);
     }
 
-
     free(cfgptr);
     cfgptr=NULL;
   }

common/config/config_load_configmodule.h

@@ -37,6 +37,7 @@
 #include <string.h>
 #include <stdlib.h>
 #include "common/config/config_paramdesc.h"
+#include "common/utils/T/T.h"
 #define CONFIG_MAX_OOPT_PARAMS    10     // maximum number of parameters in the -O option (-O <cfgmode>:P1:P2...
 #define CONFIG_MAX_ALLOCATEDPTRS  1024   // maximum number of parameters that can be dynamicaly allocated in the config module
 
@@ -44,12 +45,14 @@
 #define CONFIG_LIBCONFIGFILE        "libconfig"  // use libconfig file
 #define CONFIG_CMDLINEONLY          "cmdline"    // use only command line options
 #define DEFAULT_CFGFILENAME         "oai.conf"   // default config file
-
-/* rtflags bit position definitions */
+/*   bit position definition for the argv_info mask of the configmodule_interface_t structure */
+#define CONFIG_CMDLINEOPT_PROCESSED    (1<<0)   // command line option has been processed
+/*  bit position definitions for the rtflags mask of the configmodule_interface_t structure*/
 #define CONFIG_PRINTPARAMS    1                 // print parameters values while processing
 #define CONFIG_DEBUGPTR       (1<<1)            // print memory allocation/free debug messages
 #define CONFIG_DEBUGCMDLINE   (1<<2)            // print command line processing messages
-#define CONFIG_NOABORTONCHKF  (1<<3)            // disable abort execution when parameter checking function fails
+#define CONFIG_NOCHECKUNKOPT  (1<<3)            // disable check unprocessed (so invalid) command line options 
+#define CONFIG_NOABORTONCHKF  (1<<4)            // disable abort execution when parameter checking function fails
 #define CONFIG_NOEXITONHELP   (1<<19)           // do not exit after printing help
 #define CONFIG_HELP           (1<<20)           // print help message
 #define CONFIG_ABORT          (1<<21)           // config failed,abort execution 
@@ -58,10 +61,10 @@ typedef int(*configmodule_initfunc_t)(char *cfgP[],int numP);
 typedef int(*configmodule_getfunc_t)(paramdef_t *,int numparams, char *prefix);
 typedef int(*configmodule_getlistfunc_t)(paramlist_def_t *, paramdef_t *,int numparams, char *prefix);
 typedef void(*configmodule_endfunc_t)(void);
-typedef struct configmodule_interface
-{
+typedef struct configmodule_interface {
   int      argc;
   char     **argv;
+  uint32_t *argv_info;
   char     *cfgmode;
   int      num_cfgP;
   char     *cfgP[CONFIG_MAX_OOPT_PARAMS];
@@ -87,11 +90,11 @@ static char config_helpstr [] = "\n lte-softmodem -O [config mode]<:dbgl[debugfl
 
 
 static paramdef_t Config_Params[] = {
-/*-----------------------------------------------------------------------------------------------------------------------*/
-/*                                            config parameters for config module                                        */
-/*   optname              helpstr           paramflags     XXXptr       defXXXval            type       numelt           */
-/*-----------------------------------------------------------------------------------------------------------------------*/
-{"debugflags",            config_helpstr,   0,             uptr:NULL,   defintval:0,        TYPE_MASK,  0}, 
+  /*-----------------------------------------------------------------------------------------------------------------------*/
+  /*                                            config parameters for config module                                        */
+  /*   optname              helpstr           paramflags     XXXptr       defXXXval            type       numelt           */
+  /*-----------------------------------------------------------------------------------------------------------------------*/
+  {"debugflags",            config_helpstr,   0,             uptr:NULL,   defintval:0,        TYPE_MASK,  0},
 };
 
 #else
@@ -103,7 +106,8 @@ extern configmodule_interface_t *cfgptr;
 #define printf_ptrs(...)   if ( (cfgptr->rtflags & (CONFIG_DEBUGPTR)) != 0 )     { printf ( __VA_ARGS__ ); }
 #define printf_cmdl(...)   if ( (cfgptr->rtflags & (CONFIG_DEBUGCMDLINE)) != 0 ) { printf ( __VA_ARGS__ ); }
 
-extern configmodule_interface_t *load_configmodule(int argc, char **argv);
+#define CONFIG_ENABLECMDLINEONLY  (1<<1)
+extern configmodule_interface_t *load_configmodule(int argc, char **argv, uint32_t initflags);
 extern void end_configmodule(void);
 
 #endif  /* INCLUDE_CONFIG_LOADCONFIGMODULE_H */

common/config/config_paramdesc.h

@@ -38,7 +38,7 @@
 
 
 #define MAX_OPTNAME_SIZE 64
-
+#define CONFIG_MAXOPTLENGTH 512 /* max full option length, full option name exemple: (prefix1.[<index>].prefix2.optname */
 
 
 /* parameter flags definitions */
@@ -55,7 +55,6 @@
 #define PARAMFLAG_PARAMSET                (1 << 16)        // parameter has been explicitely set in get functions
 #define PARAMFLAG_PARAMSETDEF             (1 << 17)        // parameter has been set to default value in get functions
 
-
 /* checkedparam_t is possibly used in paramdef_t for specific parameter value validation */
 #define CONFIG_MAX_NUMCHECKVAL            20
 typedef struct paramdef paramdef_t;
@@ -100,8 +99,7 @@ typedef union checkedparam {
 
 /* paramdef is used to describe a parameter, array of paramdef_t strustures is used as the main parameter in */
 /* config apis used to retrieve parameters values  */
-typedef struct paramdef
-{
+typedef struct paramdef {
   char         optname[MAX_OPTNAME_SIZE]; /* parameter name, can be used as long command line option */
   char         *helpstr;                  /* help string */
   unsigned int paramflags;                /* value is a "ored" combination of above PARAMFLAG_XXXX values */

common/config/config_userapi.h

@@ -48,14 +48,16 @@ extern "C"
 #define CONFIG_ISPARAMFLAGSET(P,F) ( !!(P.paramflags & F))
 /* utility functions, to be used by configuration module and/or configuration libraries */
 extern configmodule_interface_t *config_get_if(void);
-extern char * config_check_valptr(paramdef_t *cfgoptions, char **ptr, int length) ;
+extern char *config_check_valptr(paramdef_t *cfgoptions, char **ptr, int length) ;
 extern void config_printhelp(paramdef_t *,int numparams);
 extern int config_process_cmdline(paramdef_t *params,int numparams, char *prefix);
 extern void config_assign_processedint(paramdef_t *cfgoption, int val);
 extern void config_assign_int(paramdef_t *cfgoptions, char *fullname, int val);
 extern int config_assign_ipv4addr(paramdef_t *cfgoptions, char *ipv4addr);
 
-/* apis to get parameters, to be used by oai modules, at configuration time */
+/* apis to get/check parameters, to be used by oai modules, at configuration time */
+#define CONFIG_CHECKALLSECTIONS "ALLSECTIONS"
+extern int config_check_cmdlineopt(char *prefix);
 extern int config_get(paramdef_t *params,int numparams, char *prefix);
 extern int config_getlist(paramlist_def_t *ParamList, paramdef_t *params, int numparams, char *prefix);
 

common/utils/DOC/loader/devusage.md

-The configuration module objectives are 
-1. Allow easy parameters management in oai, helping the development of a flexible, modularized and fully configurable softmodem.
-1. Use a common configuration API in all oai modules
-1. Allow development of alternative configuration sources without modifying the oai code. Today the only delivered configuration source is the libconfig format configuration file.  
+The loader objectives are 
+1. provides a common mechanism to prevent an executable to include code that is only used under specific configurations, without rebuilding the code
+1. Provide a common mechanism to allow to choose between different implementations of a given set of functions, without rebuilding the code
 
 As a developer you may need to look at these sections:
 

common/utils/LOG/DOC/addconsoletrace.md

+### Adding console traces in oai code
+#### console messages macros
+```C
+LOG_E(<component>,<format>,<argument>,...)
+LOG_W(<component>,<format>,<argument>,...)
+LOG_I(<component>,<format>,<argument>,...)
+LOG_D(<component>,<format>,<argument>,...)
+LOG_T(<component>,<format>,<argument>,...)
+)
+```
+these macros are used in place of the printf C function. The additionnal ***component*** parameter identifies the functionnal module which generates the message. At run time, the message will only be printed if the configured log level for the component is greater or equal than the macro level used in the code.
+
+| macro | level letter | level value | level name |
+|:---------|:---------------|:---------------|----------------:|
+| LOG_E |  E | 0 | error | 
+| LOG_W | W | 1 | warning |
+| LOG_I | I | 2 | informational |
+| LOG_D | D | 3 | debug |
+| LOG_T | T | 4 | trace |  
+
+component list is defined as an `enum` in  [log.h](https://gitlab.eurecom.fr/oai/openairinterface5g/blob/develop/common/utils/LOG/log.h). A new component can be defined by adding an item in this type, it must also be defined in the T tracer [T_messages.txt ](https://gitlab.eurecom.fr/oai/openairinterface5g/blob/develop/common/utils/T/T_messages.txt).
+
+Most oai sources are including LOG macros.
+
+#### conditional code macros
+
+```C
+LOG_DEBUGFLAG(<flag>)
+```
+this macro is to be used in if statements. The condition is true if the flag has been set, as described in the [run time usage page](rtusage.md) 
+```C
+if ( LOG_DEBUGFLAG(<flag>) {
+/* 
+   the code below is only executed if the corresponding
+   <flag>_debug option is set.
+ */ 
+......................
+......................
+}
+```
+[example in oai code](https://gitlab.eurecom.fr/oai/openairinterface5g/blob/develop/openair1/PHY/LTE_TRANSPORT/ulsch_demodulation.c#L396) 
+
+#### memory dump macros
+```C
+LOG_DUMPFLAG(<flag>)
+```
+this macro is to be used in if statements. The condition is true if the flag has been set, as described in the [run time usage page](rtusage.md). It is mainly provided to surround LOG_M macros or direct calls to `log_dump`which otherwise would be unconditionals.
+```C
+if ( LOG_DUMPFLAG(<flag>) {
+/* 
+   the code below is only executed if the corresponding
+   <flag>_dump option is set.
+ */ 
+LOG_M(.............
+LOG_M(.............
+log_dump(...
+}
+
+[example in oai code](https://gitlab.eurecom.fr/oai/openairinterface5g/blob/develop/openair1/PHY/LTE_TRANSPORT/prach.c#L205) 
+#### matlab format dump
+```C
+LOG_M(file, vector, data, len, dec, format)
+```
+|argument| type| description |
+|:-----------|:-------|-----------------:|
+| file       | char* |path to the fle which will contain the dump |
+|vector  |char * |name of the dump, printed at the top of the dump file |
+|data| void *| pointer to the memory to be dumpped |
+|len |  int | length of the data to be dumpped, in `dec` unit|
+| dec| int | length of each data item.Interpretation depends on format|
+|format| int | defines the type of data to be dumped|
+
+This macro can be used to dump a buffer in a format that can be used for analyze via tools like matlab or octave. **It must be surrounded by LOG_DEBUGFLAG or LOG_DUMPFLAG macros, to prevent the dump to be built unconditionally.** The LOG_M macro points to the `write_file_matlab` function implemented in  [log.c](https://gitlab.eurecom.fr/oai/openairinterface5g/blob/develop/common/utils/LOG/log.c). **This function should be revisited for more understandable implementation and ease of use (format parameter ???)**
+[example in oai code](https://gitlab.eurecom.fr/oai/openairinterface5g/blob/develop/openair1/PHY/LTE_TRANSPORT/prach.c#L205) 
+
+#### hexadecimal format dump
+```C
+LOG_DUMPMSG(c, f, b, s, x...)
+```
+dumps a memory region if the corresponding debug flag `f` is set as explained here [run time usage page](rtusage.md) 
+
+|argument| type| description |
+|:-----------|:-------|-----------------:|
+| c       | int, component id (in `comp_name_t` enum)| used to print the message, as specified by the s and x arguments |
+|f  |int  |flag used to filter the dump depending on the logs configuration. flag list is defined by the LOG_MASKMAP_INIT macro in  [log.h](https://gitlab.eurecom.fr/oai/openairinterface5g/blob/develop/common/utils/LOG/log.h) |
+|b| void *| pointer to the memory to be dumpped |
+|s |  int | length of the data to be dumpped in char|
+| x...| printf format and arguments| text string to be printed at the top of the dump|
+
+This macro can be used to conditionaly dump a buffer, bytes by bytes, giving the integer value of each byte in hexadecimal form.
+[example in oai code](https://gitlab.eurecom.fr/oai/openairinterface5g/blob/develop/openair2/RRC/LTE/rrc_eNB.c#L1181) 
+
+This macro points to the `log_dump` function, implemented in  [log.c](https://gitlab.eurecom.fr/oai/openairinterface5g/blob/develop/common/utils/LOG/log.c). This function can also dump buffers containing `double` data via the LOG_UDUMPMSG macro
+
+```C
+LOG_UDUMPMSG(c, b, s, f, x...) 
+```
+|argument| type| description |
+|:-----------|:-------|-----------------:|
+| c       | int, component id (in `comp_name_t` enum)| used to print the message, as specified by the s and x arguments |
+|b| void *| pointer to the memory to be dumpped |
+|s |  int | length of the data to be dumpped in char|
+|f|  int | format of dumped data LOG_DUMP_CHAR or  LOG_DUMP_DOUBLE|
+| x...| printf format and arguments| text string to be printed at the top of the dump|
+
+[example in oai code](https://gitlab.eurecom.fr/oai/openairinterface5g/blob/develop/openair1/SIMULATION/LTE_PHY/dlsim.c#L1974) 
+
+[logging facility developer main page](devusage.md)  
+[logging facility  main page](log.md)  
+[oai Wikis home](https://gitlab.eurecom.fr/oai/openairinterface5g/wikis/home)
\ No newline at end of file

common/utils/LOG/DOC/arch.md

+# logging facility source files
+
+The oai logging facility is implemented in two source files, located in [common/utils/LOG](LOG)
+1. [log.c](../log.c) contains logging implementation
+1.  [log.h](../log.h) is the logging facility include file containing both private and public data type definitions. It also contain API prototypes.  
+
+The logging facility doesn't create any thread, all api's are executed in the context of the caller. The tracing macro's `LOG_<X>` are all using the logRecord_mt function to output the messages. To keep this function thread safe it must perform a single system call to the output stream. The buffer used to build the message must be specific to the calling thread, which is today enforced by using a variable in the logRecord_mt stack.
+
+Data used by the logging utility are defined by the `log_t` structure which is allocated at init time, when calling the `logInit` function.
+
+[logging facility  main page](log.md)  
+[oai Wikis home](https://gitlab.eurecom.fr/oai/openairinterface5g/wikis/home)
\ No newline at end of file

common/utils/LOG/DOC/configurelog.md

+### Initializing and configuring the logging facility
+
+#### logging facility APIs
+```C
+int  logInit (void);
+```
+Allocate the internal data used by the logging utility, set the configuration, using the [configuration  module](../../../config/DOC/config.md) 
+
+```C
+void logClean (void)
+```
+Reset console attributes (color settings) and possibly close opened log files. Logging facility is still usable after this call, the internal data are not freed.
+
+```C
+int  set_log(int component, int level)
+void set_glog(int level)
+```
+Set a component or  all components logiing level. Messages which level is lower than this level are not printed to the console.
+
+```C
+void set_glog_onlinelog(int enable)
+```
+Enable or disable all logging messages. Even error level messages are discarded, which is not advised. This can be usefull to temporarily workaround high rate of logging messages.
+
+```C
+void set_component_filelog(int comp)
+void close_component_filelog(int comp)
+```
+
+Redirect or reset to stdout the output stream used by the logging facility. When the output stream is redirected to a file, it is created under /tmp with a hard-coded filename including the componemt name.
+
+```C
+SET_LOG_DEBUG(flag) 
+CLEAR_LOG_DEBUG(flag)
+SET_LOG_DUMP(flag) 
+CLEAR_LOG_DUMP(flag)
+```
+ These macros are used to set or clear the corresponding bit flag, trigerring the activation or un-activation of conditional code or memory dumps generation.
+
+Example of using the logging utility APIs can be found, for initialization and cleanup,  in [lte-softmodem.c](../../../../targets/RT/USER/lte-softmodem.c) and in the [telnet server log command implementation](../../telnetsrv/telnetsrv_proccmd.c) for a complete access to the logging facility features.
+
+#### components and debug flags definitions
+
+Adding a new component is just adding an item in the `comp_name_t` enum defined in [log.h](../log.h) . You must also declare it in the T Tracer facility [message fefinitions](../../T/T_messages.txt).
+To add a flag than can then be used for adding conditional code or memory dumps you have to add the flag definition in the `LOG_MASKMAP_INIT` macro, in [log.h](../log.h). 
+
+[logging facility developer main page](devusage.md)  
+[logging facility  main page](log.md)  
+[oai Wikis home](https://gitlab.eurecom.fr/oai/openairinterface5g/wikis/home)
\ No newline at end of file

common/utils/LOG/DOC/devusage.md

+### logging facility developer usage
+The logging facility objectives are 
+1. provide a common console tracing mechanism 
+1. Allow a flexible activation of console traces, by configuration or dynamically at any time while code is running.
+
+Most developpers will only use the log macros to add console messages to the code. The logging facility also provides an api that is used for initialization and configuration. 
+
+[Adding console traces in oaicode](addconsoletrace.md) 
+
+[Configuring the logging facility](configurelog.md) 
+
+
+[logging facility  main page](log.md)  
+[oai Wikis home](https://gitlab.eurecom.fr/oai/openairinterface5g/wikis/home)

common/utils/LOG/DOC/log.md

+# OAI console logging facility
+
+oai includes a console logging facility that any component should use when writting informational or debugging messages to the softmodem or uesoftmodem stdout stream. 
+By default, this facility is included at build-time and activated at run-time. The T Tracer and the Logging facility share common options for activation:
+
+-   To disable the logging facility (and T Tracer) at build-time use the *--disable-T-Tracer* switch:
+
+```bash
+/build_oai --disable-T-Tracer
+```
+-  To use the the T-Tracer instead of the console logging facility, use the command line option *T_stdout*.  *T_stdout* is a boolean option, which, when set to 0 (false) disable the console logging facility. All stdout messages are then sent to the T-Tracer.
+
+## Documentation
+
+* [runtime usage](rtusage.md)
+* [developer usage](devusage.md)
+* [module architecture](arch.md)
+
+[oai Wikis home](https://gitlab.eurecom.fr/oai/openairinterface5g/wikis/home)

common/utils/LOG/log.h

@@ -45,11 +45,11 @@
 #include <time.h>
 #include <stdint.h>
 #ifndef __STDC_FORMAT_MACROS
-#define __STDC_FORMAT_MACROS
+  #define __STDC_FORMAT_MACROS
 #endif
 #include <inttypes.h>
 #ifndef _GNU_SOURCE
-#define _GNU_SOURCE
+  #define _GNU_SOURCE
 #endif
 #include <pthread.h>
 #include "T.h"
@@ -118,9 +118,8 @@ extern "C" {
 #define FLAG_NOCOLOR     0x0001  /*!< \brief use colors in log messages, depending on level */
 #define FLAG_THREAD      0x0008  /*!< \brief display thread name in log messages */
 #define FLAG_LEVEL       0x0010  /*!< \brief display log level in log messages */
-#define FLAG_FUNCT     0x0020
-#define FLAG_FILE_LINE 0x0040
 #define FLAG_TIME        0x0100
+#define FLAG_INITIALIZED 0x8000
 
 #define SET_LOG_OPTION(O)   g_log->flag = (g_log->flag | O)
 #define CLEAR_LOG_OPTION(O) g_log->flag = (g_log->flag & (~O))
@@ -165,7 +164,7 @@ extern "C" {
     {"NAS",         DEBUG_NAS},\
     {"UE_TIMING",   UE_TIMING},\
     {NULL,-1}\
-}
+  }
 
 
 
@@ -251,7 +250,7 @@ typedef struct {
   log_component_t         log_component[MAX_LOG_COMPONENTS];
   char                    level2string[NUM_LOG_LEVEL];
   int                     flag;
-    char*                   filelog_name;
+  char                   *filelog_name;
   uint64_t                debug_mask;
   uint64_t                dump_mask;
 } log_t;
@@ -272,9 +271,9 @@ void log_set_instance_type (log_instance_type_t instance);
 log_t *g_log;
 #else
 #ifdef __cplusplus
-   extern "C" {
+extern "C" {
 #endif
-extern log_t *g_log;
+  extern log_t *g_log;
 #ifdef __cplusplus
 }
 #endif
@@ -283,8 +282,9 @@ extern log_t *g_log;
 #    include "log_if.h"
 /*----------------------------------------------------------------------------*/
 int  logInit (void);
+int isLogInitDone (void);
 void logRecord_mt(const char *file, const char *func, int line,int comp, int level, const char *format, ...) __attribute__ ((format (printf, 6, 7)));
-void log_dump(int component, void *buffer, int buffsize,int datatype, const char* format, ... );
+void log_dump(int component, void *buffer, int buffsize,int datatype, const char *format, ... );
 int  set_log(int component, int level);
 void set_glog(int level);
 
@@ -339,10 +339,10 @@ int32_t write_file_matlab(const char *fname, const char *vname, void *data, int
 /*   optname                            help                                                paramflags       XXXptr                    defXXXval              type   numelt */
 /*------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------*/
 #define LOG_GLOBALPARAMS_DESC { \
-{LOG_CONFIG_STRING_GLOBAL_LOG_LEVEL,    "Default log level for all componemts\n",              0,  	      strptr:(char **)&gloglevel,    defstrval:log_level_names[2].name,    TYPE_STRING,    0}, \
-{LOG_CONFIG_STRING_GLOBAL_LOG_ONLINE,   "Default console output option, for all components\n", 0,  	      iptr:&(consolelog),            defintval:1,                          TYPE_INT,       0}, \
-{LOG_CONFIG_STRING_GLOBAL_LOG_OPTIONS,  LOG_CONFIG_HELP_OPTIONS,                               0,  	      strlistptr:NULL,               defstrlistval:NULL,                   TYPE_STRINGLIST,0} \
-}
+    {LOG_CONFIG_STRING_GLOBAL_LOG_LEVEL,    "Default log level for all componemts\n",              0,         strptr:(char **)&gloglevel,    defstrval:log_level_names[2].name,    TYPE_STRING,    0}, \
+    {LOG_CONFIG_STRING_GLOBAL_LOG_ONLINE,   "Default console output option, for all components\n", 0,         iptr:&(consolelog),            defintval:1,                          TYPE_INT,       0}, \
+    {LOG_CONFIG_STRING_GLOBAL_LOG_OPTIONS,  LOG_CONFIG_HELP_OPTIONS,                               0,         strlistptr:NULL,               defstrlistval:NULL,                   TYPE_STRINGLIST,0} \
+  }
 
 #define LOG_OPTIONS_IDX   2
 /*----------------------------------------------------------------------------------*/
@@ -355,22 +355,22 @@ int32_t write_file_matlab(const char *fname, const char *vname, void *data, int
 // debugging macros
 #define LOG_F  LOG_I           /* because  LOG_F was originaly to dump a message or buffer but is also used as a regular level...., to dump use LOG_DUMPMSG */
 #  if T_TRACER
-     /* per component, level dependant macros */
+/* per component, level dependant macros */
 #    define LOG_E(c, x...) do { if (T_stdout) { if( g_log->log_component[c].level >= OAILOG_ERR    ) logRecord_mt(__FILE__, __FUNCTION__, __LINE__,c, OAILOG_ERR, x)     ;} else { T(T_LEGACY_ ## c ## _ERROR, T_PRINTF(x))   ;}} while (0)
 #    define LOG_W(c, x...) do { if (T_stdout) { if( g_log->log_component[c].level >= OAILOG_WARNING) logRecord_mt(__FILE__, __FUNCTION__, __LINE__,c, OAILOG_WARNING, x) ;} else { T(T_LEGACY_ ## c ## _WARNING, T_PRINTF(x)) ;}} while (0)
 #    define LOG_I(c, x...) do { if (T_stdout) { if( g_log->log_component[c].level >= OAILOG_INFO   ) logRecord_mt(__FILE__, __FUNCTION__, __LINE__,c, OAILOG_INFO, x)    ;} else { T(T_LEGACY_ ## c ## _INFO, T_PRINTF(x))    ;}} while (0)
 #    define LOG_D(c, x...) do { if (T_stdout) { if( g_log->log_component[c].level >= OAILOG_DEBUG  ) logRecord_mt(__FILE__, __FUNCTION__, __LINE__,c, OAILOG_DEBUG, x)   ;} else { T(T_LEGACY_ ## c ## _DEBUG, T_PRINTF(x))   ;}} while (0)
 #    define LOG_T(c, x...) do { if (T_stdout) { if( g_log->log_component[c].level >= OAILOG_TRACE  ) logRecord_mt(__FILE__, __FUNCTION__, __LINE__,c, OAILOG_TRACE, x)   ;} else { T(T_LEGACY_ ## c ## _TRACE, T_PRINTF(x))   ;}} while (0)
-    /* macro used to dump a buffer or a message as in openair2/RRC/LTE/RRC_eNB.c, replaces LOG_F macro */
+/* macro used to dump a buffer or a message as in openair2/RRC/LTE/RRC_eNB.c, replaces LOG_F macro */
 #    define LOG_DUMPMSG(c, f, b, s, x...) do {  if(g_log->dump_mask & f) log_dump(c, b, s, LOG_DUMP_CHAR, x)  ;}   while (0)  /* */
 #    define nfapi_log(FILE, FNC, LN, COMP, LVL, F...)  do { if (T_stdout) { logRecord_mt(__FILE__, __FUNCTION__, __LINE__,COMP, LVL, F)  ;}}   while (0)  /* */
-     /* bitmask dependant macros, to isolate debugging code */
+/* bitmask dependant macros, to isolate debugging code */
 #    define LOG_DEBUGFLAG(D) (g_log->debug_mask & D)
 
-     /* bitmask dependant macros, to generate debug file such as matlab file or message dump */
+/* bitmask dependant macros, to generate debug file such as matlab file or message dump */
 #    define LOG_DUMPFLAG(D) (g_log->dump_mask & D)
 #    define LOG_M(file, vector, data, len, dec, format) do { write_file_matlab(file, vector, data, len, dec, format);} while(0)/* */
-     /* define variable only used in LOG macro's */
+/* define variable only used in LOG macro's */
 #    define LOG_VAR(A,B) A B
 #  else /* T_TRACER: remove all debugging and tracing messages, except errors */
 #    define LOG_I(c, x...) /* */
@@ -420,7 +420,7 @@ static __inline__ uint64_t rdtsc(void) {
 
 extern double cpuf;
 
-static inline uint64_t checkTCPU(int timeout, char * file, int line) {
+static inline uint64_t checkTCPU(int timeout, char *file, int line) {
   static uint64_t __thread lastCPUTime=0;
   static uint64_t __thread last=0;
   uint64_t cur=rdtsc();
@@ -429,25 +429,29 @@ static inline uint64_t checkTCPU(int timeout, char * file, int line) {
   uint64_t CPUTime=CPUt.tv_sec*1000*1000+CPUt.tv_nsec/1000;
   double microCycles=(double)(cpuf*1000);
   int duration=(int)((cur-last)/microCycles);
+
   if ( last!=0 && duration > timeout ) {
     //struct timespec ts;
     //clock_gettime(CLOCK_MONOTONIC, &ts);
     printf("%s:%d lte-ue delay %d (exceed %d), CPU for this period: %lld\n", file, line,
            duration, timeout, (long long)CPUTime-lastCPUTime );
   }
+
   last=cur;
   lastCPUTime=CPUTime;
   return cur;
 }
 
-static inline unsigned long long checkT(int timeout, char * file, int line) {
+static inline unsigned long long checkT(int timeout, char *file, int line) {
   static unsigned long long __thread last=0;
   unsigned long long cur=rdtsc();
   int microCycles=(int)(cpuf*1000);
   int duration=(int)((cur-last)/microCycles);
+
   if ( last!=0 && duration > timeout )
     printf("%s:%d lte-ue delay %d (exceed %d)\n", file, line,
            duration, timeout);
+
   last=cur;
   return cur;
 }
@@ -458,7 +462,7 @@ typedef struct m {
   uint64_t maxArray[11];
 } Meas;
 
-static inline void printMeas(char * txt, Meas *M, int period) {
+static inline void printMeas(char *txt, Meas *M, int period) {
   if (M->iterations%period == 0 ) {
     char txt2[512];
     sprintf(txt2,"%s avg=%" PRIu64 " iterations=%" PRIu64 " max=%"
@@ -476,13 +480,13 @@ static inline void printMeas(char * txt, Meas *M, int period) {
   }
 }
 
-static inline int cmpint(const void* a, const void* b) {
-    uint64_t* aa=(uint64_t*)a;
-    uint64_t* bb=(uint64_t*)b;
+static inline int cmpint(const void *a, const void *b) {
+  uint64_t *aa=(uint64_t *)a;
+  uint64_t *bb=(uint64_t *)b;
   return (int)(*aa-*bb);
 }
 
-static inline void updateTimes(uint64_t start, Meas *M, int period, char * txt) {
+static inline void updateTimes(uint64_t start, Meas *M, int period, char *txt) {
   if (start!=0) {
     uint64_t end=rdtsc();
     long long diff=(end-start)/(cpuf*1000);

common/utils/T/genids.c

@@ -8,27 +8,35 @@ char **unique_ids;
 int unique_ids_size;
 int unique_ids_maxsize;
 
-int cmp(const void *p1, const void *p2)
-{
-  return strcmp(*(char * const *)p1, *(char * const *)p2);
+int cmp(const void *p1, const void *p2) {
+  return strcmp(*(char *const *)p1, *(char *const *)p2);
 }
 
 /* return 1 if s was not already known, 0 if it was */
-int new_unique_id(char *s, char *input_file)
-{
+int new_unique_id(char *s, char *input_file) {
   if (unique_ids_size)
     if (bsearch(&s, unique_ids, unique_ids_size, sizeof(char *), cmp) != NULL) {
       printf("error: ID %s is not unique in %s\n", s, input_file);
       return 0;
     }
+
   if (unique_ids_size == unique_ids_maxsize) {
     unique_ids_maxsize += 256;
     unique_ids = realloc(unique_ids, unique_ids_maxsize * sizeof(char *));
-    if (unique_ids == NULL) { printf("erorr: out of memory\n"); abort(); }
+
+    if (unique_ids == NULL) {
+      printf("error: out of memory\n");
+      abort();
     }
+  }
+
   unique_ids[unique_ids_size] = strdup(s);
-  if (unique_ids[unique_ids_size] == NULL)
-    { printf("erorr: out of memory\n"); abort(); }
+
+  if (unique_ids[unique_ids_size] == NULL) {
+    printf("error: out of memory\n");
+    abort();
+  }
+
   unique_ids_size++;
   qsort(unique_ids, unique_ids_size, sizeof(char *), cmp);
   return 1;
@@ -38,14 +46,17 @@ char *bufname;
 int bufname_size;
 int bufname_maxsize;
 
-void putname(int c)
-{
+void putname(int c) {
   if (bufname_size == bufname_maxsize) {
     bufname_maxsize += 256;
     bufname = realloc(bufname, bufname_maxsize);
-    if (bufname == NULL)
-      { printf("erorr: memory allocation error\n"); exit(1); }
+
+    if (bufname == NULL) {
+      printf("error: memory allocation error\n");
+      exit(1);
+    }
   }
+
   bufname[bufname_size] = c;
   bufname_size++;
 }
@@ -54,42 +65,54 @@ char *bufvalue;
 int bufvalue_size;
 int bufvalue_maxsize;
 
-void putvalue(int c)
-{
+void putvalue(int c) {
   if (bufvalue_size == bufvalue_maxsize) {
     bufvalue_maxsize += 256;
     bufvalue = realloc(bufvalue, bufvalue_maxsize);
-    if (bufvalue == NULL)
-      { printf("error: memory allocation error\n"); exit(1); }
+
+    if (bufvalue == NULL) {
+      printf("error: memory allocation error\n");
+      exit(1);
+    }
   }
+
   bufvalue[bufvalue_size] = c;
   bufvalue_size++;
 }
 
-void smash_spaces(FILE *f)
-{
+void smash_spaces(FILE *f) {
   int c;
+
   while (1) {
     c = fgetc(f);
+
     if (isspace(c)) continue;
+
     if (c == ' ') continue;
+
     if (c == '\t') continue;
+
     if (c == '\n') continue;
+
     if (c == 10 || c == 13) continue;
+
     if (c == '#') {
       while (1) {
         c = fgetc(f);
+
         if (c == '\n' || c == EOF) break;
       }
+
       continue;
     }
+
     break;
   }
+
   if (c != EOF) ungetc(c, f);
 }
 
-void get_line(FILE *f, char **name, char **value)
-{
+void get_line(FILE *f, char **name, char **value) {
   int c;
   bufname_size = 0;
   bufvalue_size = 0;
@@ -97,23 +120,39 @@ void get_line(FILE *f, char **name, char **value)
   *value = NULL;
   smash_spaces(f);
   c = fgetc(f);
-  while (!(c == '=' || isspace(c) || c == EOF)) { putname(c); c = fgetc(f); }
+
+  while (!(c == '=' || isspace(c) || c == EOF)) {
+    putname(c);
+    c = fgetc(f);
+  }
+
   if (c == EOF) return;
+
   putname(0);
+
   while (!(c == EOF || c == '=')) c = fgetc(f);
+
   if (c == EOF) return;
+
   smash_spaces(f);
   c = fgetc(f);
-  while (!(c == 10 || c == 13 || c == EOF)) { putvalue(c); c = fgetc(f); }
+
+  while (!(c == 10 || c == 13 || c == EOF)) {
+    putvalue(c);
+    c = fgetc(f);
+  }
+
   putvalue(0);
+
   if (bufname_size <= 1) return;
+
   if (bufvalue_size <= 1) return;
+
   *name = bufname;
   *value = bufvalue;
 }
 
-int main(int n, char **v)
-{
+int main(int n, char **v) {
   FILE *in;
   FILE *out;
   char *name;
@@ -121,36 +160,54 @@ int main(int n, char **v)
   char *in_name;
   char *out_name;
 
-  if (n != 3) { printf("error: gimme <source> <dest>\n"); exit(1); }
+  if (n != 3) {
+    printf("error: gimme <source> <dest>\n");
+    exit(1);
+  }
 
   n = 0;
-
   in_name = v[1];
   out_name = v[2];
+  in = fopen(in_name, "r");
+
+  if (in == NULL) {
+    perror(in_name);
+    exit(1);
+  }
 
-  in = fopen(in_name, "r"); if (in == NULL) { perror(in_name); exit(1); }
-  out = fopen(out_name, "w"); if (out == NULL) { perror(out_name); exit(1); }
+  out = fopen(out_name, "w");
+
+  if (out == NULL) {
+    perror(out_name);
+    exit(1);
+  }
 
   fprintf(out, "/* generated file, do not edit by hand */\n\n");
 
   while (1) {
     get_line(in, &name, &value);
+
     if (name == NULL) break;
+
     if (isspace(value[strlen(value)-1])) {
       printf("error: bad value '%s' (no space at the end please!)\n", value);
       unlink(out_name);
       exit(1);
     }
+
     if (!strcmp(name, "ID")) {
-      if (!new_unique_id(value, in_name)) { unlink(out_name); exit(1); }
+      if (!new_unique_id(value, in_name)) {
+        unlink(out_name);
+        exit(1);
+      }
+
       fprintf(out, "#define T_%s T_ID(%d)\n", value, n);
       n++;
     }
   }
-  fprintf(out, "#define T_NUMBER_OF_IDS %d\n", n);
 
+  fprintf(out, "#define T_NUMBER_OF_IDS %d\n", n);
   fclose(in);
   fclose(out);
-
   return 0;
 }

common/utils/telnetsrv/DOC/telnetlog.md

@@ -93,3 +93,4 @@ Connection closed by foreign host.
 
 [oai telnetserver home](telnetsrv.md)  
 [oai telnetserver usage home](telnetusage.md)
+[oai Wikis home](https://gitlab.eurecom.fr/oai/openairinterface5g/wikis/home)
\ No newline at end of file

openair1/SIMULATION/LTE_PHY/dlsim.c

@@ -988,7 +988,7 @@ int main(int argc, char **argv)
   if (transmission_mode>1) pa=dBm3;
   printf("dlsim: tmode %d, pa %d\n",transmission_mode,pa);
 
-  AssertFatal(load_configmodule(argc,argv) != NULL,
+  AssertFatal(load_configmodule(argc,argv, CONFIG_ENABLECMDLINEONLY) != NULL,
 	      "cannot load configuration module, exiting\n");
   logInit();
   set_glog_onlinelog(true);

openair1/SIMULATION/LTE_PHY/ulsim.c

@@ -429,7 +429,7 @@ int main(int argc, char **argv) {
   cpu_freq_GHz = (double)get_cpu_freq_GHz();
   cpuf = cpu_freq_GHz;
   printf("Detected cpu_freq %f GHz\n",cpu_freq_GHz);
-  AssertFatal(load_configmodule(argc,argv) != NULL,
+  AssertFatal(load_configmodule(argc,argv,CONFIG_ENABLECMDLINEONLY) != NULL,
               "cannot load configuration module, exiting\n");
   logInit();
   // enable these lines if you need debug info

openair2/ENB_APP/enb_app.c

@@ -43,10 +43,14 @@
 #   include "s1ap_eNB.h"
 #   include "sctp_eNB_task.h"
 #   include "gtpv1u_eNB_task.h"
+/* temporary warning removale while implementing noS1 */
+/* as config option                                   */
 #   else
+#     ifdef EPC_MODE_ENABLED
+#       undef  EPC_MODE_ENABLED
+#     endif
 #     define EPC_MODE_ENABLED 0
 #   endif
-
 #   include "x2ap_eNB.h"
 #   include "x2ap_messages_types.h"
 #   define X2AP_ENB_REGISTER_RETRY_DELAY   10

openair2/ENB_APP/enb_config.c

@@ -289,7 +289,7 @@ void RCconfig_L1(void) {
       }
     }// j=0..num_inst
 
-    printf("Initializing northbound interface for L1\n");
+    LOG_I(ENB_APP,"Initializing northbound interface for L1\n");
     l1_north_init_eNB();
   } else {
     LOG_I(PHY,"No " CONFIG_STRING_L1_LIST " configuration found");
@@ -360,16 +360,16 @@ void RCconfig_macrlc() {
         RC.mac[j]->eth_params_s.remote_portd             = *(MacRLC_ParamList.paramarray[j][MACRLC_REMOTE_S_PORTD_IDX].iptr);
         RC.mac[j]->eth_params_s.transp_preference        = ETH_UDP_MODE;
         sf_ahead = 2; // Cannot cope with 4 subframes betweem RX and TX - set it to 2
-        printf("**************** vnf_port:%d\n", RC.mac[j]->eth_params_s.my_portc);
+        LOG_I(ENB_APP,"**************** vnf_port:%d\n", RC.mac[j]->eth_params_s.my_portc);
         configure_nfapi_vnf(RC.mac[j]->eth_params_s.my_addr, RC.mac[j]->eth_params_s.my_portc);
-        printf("**************** RETURNED FROM configure_nfapi_vnf() vnf_port:%d\n", RC.mac[j]->eth_params_s.my_portc);
+        LOG_I(ENB_APP,"**************** RETURNED FROM configure_nfapi_vnf() vnf_port:%d\n", RC.mac[j]->eth_params_s.my_portc);
       } else { // other midhaul
         AssertFatal(1==0,"MACRLC %d: %s unknown southbound midhaul\n",j,*(MacRLC_ParamList.paramarray[j][MACRLC_TRANSPORT_S_PREFERENCE_IDX].strptr));
       }
 
       if (strcmp(*(MacRLC_ParamList.paramarray[j][MACRLC_SCHED_MODE_IDX].strptr), "default") == 0) {
         global_scheduler_mode=SCHED_MODE_DEFAULT;
-        printf("sched mode = default %d [%s]\n",global_scheduler_mode,*(MacRLC_ParamList.paramarray[j][MACRLC_SCHED_MODE_IDX].strptr));
+        LOG_I(ENB_APP,"sched mode = default %d [%s]\n",global_scheduler_mode,*(MacRLC_ParamList.paramarray[j][MACRLC_SCHED_MODE_IDX].strptr));
       } else if (strcmp(*(MacRLC_ParamList.paramarray[j][MACRLC_SCHED_MODE_IDX].strptr), "fairRR") == 0) {
         global_scheduler_mode=SCHED_MODE_FAIR_RR;
         printf("sched mode = fairRR %d [%s]\n",global_scheduler_mode,*(MacRLC_ParamList.paramarray[j][MACRLC_SCHED_MODE_IDX].strptr));
@@ -550,7 +550,7 @@ int RCconfig_RRC(MessageDef *msg_p, uint32_t i, eNB_RRC_INST *rrc) {
       enb_id = *(ENBParamList.paramarray[i][ENB_ENB_ID_IDX].uptr);
     }
 
-    printf("RRC %d: Southbound Transport %s\n",i,*(ENBParamList.paramarray[i][ENB_TRANSPORT_S_PREFERENCE_IDX].strptr));
+    LOG_I(ENB_APP,"RRC %d: Southbound Transport %s\n",i,*(ENBParamList.paramarray[i][ENB_TRANSPORT_S_PREFERENCE_IDX].strptr));
 
     if (strcmp(*(ENBParamList.paramarray[i][ENB_TRANSPORT_S_PREFERENCE_IDX].strptr), "local_mac") == 0) {
     } else if (strcmp(*(ENBParamList.paramarray[i][ENB_TRANSPORT_S_PREFERENCE_IDX].strptr), "cudu") == 0) {
@@ -2494,8 +2494,7 @@ int RCconfig_X2(MessageDef *msg_p, uint32_t i) {
 int RCconfig_parallel(void) {
   char *parallel_conf = NULL;
   char *worker_conf   = NULL;
-  extern char *parallel_config;
-  extern char *worker_config;
+
   paramdef_t ThreadParams[]  = THREAD_CONF_DESC;
   paramlist_def_t THREADParamList = {THREAD_CONFIG_STRING_THREAD_STRUCT,NULL,0};
   config_getlist( &THREADParamList,NULL,0,NULL);
@@ -2514,9 +2513,10 @@ int RCconfig_parallel(void) {
     worker_conf   = strdup("WORKER_ENABLE");
   }
 
-  if(parallel_config == NULL) set_parallel_conf(parallel_conf);
 
-  if(worker_config == NULL)   set_worker_conf(worker_conf);
+  set_parallel_conf(parallel_conf);
+  set_worker_conf(worker_conf);
+
 
   return 0;
 }

openair2/LAYER2/MAC/eNB_scheduler.c

@@ -30,7 +30,7 @@
  */
 
 #include "assertions.h"
-
+#include "targets/RT/USER/lte-softmodem.h"
 #include "LAYER2/MAC/mac.h"
 #include "LAYER2/MAC/mac_extern.h"
 
@@ -64,7 +64,7 @@
 #define DEBUG_eNB_SCHEDULER 1
 
 extern RAN_CONTEXT_t RC;
-extern int phy_test;
+
 
 uint16_t pdcch_order_table[6] = { 31, 31, 511, 2047, 2047, 8191 };
 
@@ -660,7 +660,7 @@ eNB_dlsch_ulsch_scheduler(module_id_t module_idP, frame_t frameP,
 
   if ((subframeP == 0) && (frameP & 3) == 0)
       schedule_mib(module_idP, frameP, subframeP);
-  if (phy_test == 0){
+  if (get_softmodem_params()->phy_test == 0){
     // This schedules SI for legacy LTE and eMTC starting in subframeP
     schedule_SI(module_idP, frameP, subframeP);
     // This schedules Paging in subframeP

openair2/LAYER2/MAC/ue_procedures.c

@@ -65,7 +65,6 @@
 #define DEBUG_HEADER_PARSING 1
 #define ENABLE_MAC_PAYLOAD_DEBUG 1
 
-extern uint8_t usim_test;
 
 extern UL_IND_t *UL_INFO;
 
@@ -2020,7 +2019,7 @@ ue_get_sdu(module_id_t module_idP, int CC_id, frame_t frameP,
 	    {
 
 		// Workaround for issue in OAI eNB or EPC which are not able to process SRB2 message multiplexed with SRB1 on the same MAC PDU
-		if ((usim_test == 0) && (lcid == DCCH1)
+		if (( get_softmodem_params()->usim_test == 0) && (lcid == DCCH1)
 		    && (lcid_rlc_pdu_count == 0) && (num_sdus)) {
 
 		    // Skip SRB2 multiplex if at least one SRB1 SDU is already multiplexed

openair2/RRC/LTE/rrc_eNB.c

@@ -85,7 +85,12 @@
 #   else
 #      include "../../S1AP/s1ap_eNB.h"
 #   endif
+/* temporary warning removale while implementing noS1 */
+/* as config option                                   */
 #else
+#   ifdef EPC_MODE_ENABLED
+#      undef  EPC_MODE_ENABLED
+#   endif
 #   define EPC_MODE_ENABLED 0
 #endif
 

openair3/NAS/UE/EMM/Authentication.c

@@ -68,14 +68,9 @@ Description Defines the authentication EMM procedure executed by the
 #include "usim_api.h"
 #include "secu_defs.h"
 #include "Authentication.h"
+#include "targets/RT/USER/lte-softmodem.h"
 
 
-/****************************************************************************/
-/****************  E X T E R N A L    D E F I N I T I O N S  ****************/
-/****************************************************************************/
-
-extern uint8_t usim_test;
-
 /****************************************************************************/
 /*******************  L O C A L    D E F I N I T I O N S  *******************/
 /****************************************************************************/
@@ -211,7 +206,7 @@ int emm_proc_authentication_request(nas_user_t *user, int native_ksi, int ksi,
        * of the core network by means of the received AUTN parameter and
        * request the USIM to compute RES, CK and IK for given RAND
        */
-      if(usim_test == 0)
+      if(get_softmodem_params()->usim_test == 0)
       {
         rc = usim_api_authenticate(&user->usim_data, rand, autn, &auts, &res, &ck, &ik);
       }

openair3/NAS/UE/EMM/SAP/EmmDeregisteredNormalService.c

@@ -47,7 +47,7 @@ Description Implements the EPS Mobility Management procedures executed
 #include "commonDef.h"
 #include "networkDef.h"
 #include "nas_log.h"
-
+#include "targets/RT/USER/lte-softmodem.h"
 #include "emm_proc.h"
 
 #include <assert.h>
@@ -55,7 +55,7 @@ Description Implements the EPS Mobility Management procedures executed
 /****************************************************************************/
 /****************  E X T E R N A L    D E F I N I T I O N S  ****************/
 /****************************************************************************/
-extern uint8_t usim_test;
+
 
 /****************************************************************************/
 /*******************  L O C A L    D E F I N I T I O N S  *******************/
@@ -110,7 +110,7 @@ int EmmDeregisteredNormalService(nas_user_t *user, const emm_reg_t *evt)
     /*
      * Initiate the attach procedure for EPS services
      */
-    if(usim_test == 0)
+    if(get_softmodem_params()->usim_test == 0)
     {
       rc = emm_proc_attach(user, EMM_ATTACH_TYPE_EPS);
     }

targets/COMMON/create_tasks.c

@@ -23,6 +23,7 @@
 # include "intertask_interface.h"
 # include "create_tasks.h"
 # include "common/utils/LOG/log.h"
+# include "targets/RT/USER/lte-softmodem.h"
 
 # ifdef OPENAIR2
 #   if defined(ENABLE_USE_MME)
@@ -32,7 +33,12 @@
 #     include "nas_ue_task.h"
 #     include "udp_eNB_task.h"
 #     include "gtpv1u_eNB_task.h"
+/* temporary warning removale while implementing noS1 */
+/* as config option                                   */
 #   else
+#     ifdef EPC_MODE_ENABLED
+#       undef  EPC_MODE_ENABLED
+#     endif
 #     define EPC_MODE_ENABLED 0
 #   endif
 #   if ENABLE_RAL
@@ -43,7 +49,6 @@
 # endif
 # include "enb_app.h"
 
-extern int emulate_rf;
 
 int create_tasks(uint32_t enb_nb)
 {
@@ -79,7 +84,7 @@ int create_tasks(uint32_t enb_nb)
           LOG_E(S1AP, "Create task for S1AP failed\n");
           return -1;
         }
-        if(!emulate_rf){
+        if(!(get_softmodem_params()->emulate_rf)){
           if (itti_create_task (TASK_UDP, udp_eNB_task, NULL) < 0) {
             LOG_E(UDP_, "Create task for UDP failed\n");
             return -1;

targets/RT/USER/lte-ru.c

@@ -90,6 +90,7 @@
 #include "common/utils/LOG/vcd_signal_dumper.h"
 #include "UTIL/OPT/opt.h"
 #include "enb_config.h"
+#include "targets/RT/USER/lte-softmodem.h" 
 //#include "PHY/TOOLS/time_meas.h"
 
 /* these variables have to be defined before including ENB_APP/enb_paramdef.h */
@@ -117,16 +118,14 @@ static int DEFENBS[] = {0};
 #include "pdcp.h"
 
 extern volatile int                    oai_exit;
-extern int emulate_rf;
-extern int numerology;
-extern clock_source_t clock_source;
+
 
 extern PARALLEL_CONF_t get_thread_parallel_conf(void);
 extern WORKER_CONF_t   get_thread_worker_conf(void);
 extern void  phy_init_RU(RU_t*);
 extern void  phy_free_RU(RU_t*);
 
-void init_RU(char*);
+
 void stop_RU(int nb_ru);
 void do_ru_sync(RU_t *ru);
 
@@ -699,6 +698,7 @@ static void* emulatedRF_thread(void* param) {
   RU_proc_t *proc = (RU_proc_t *) param;
   int microsec = 500; // length of time to sleep, in miliseconds
   struct timespec req = {0};
+  int numerology = get_softmodem_params()->numerology;
   req.tv_sec = 0;
   req.tv_nsec = (numerology>0)? ((microsec * 1000L)/numerology):(microsec * 1000L)*2;
   cpu_set_t cpuset;
@@ -743,7 +743,7 @@ void rx_rf(RU_t *ru,int *frame,int *subframe) {
   VCD_SIGNAL_DUMPER_DUMP_FUNCTION_BY_NAME( VCD_SIGNAL_DUMPER_FUNCTIONS_TRX_READ, 1 );
 
   old_ts = proc->timestamp_rx;
-  if(emulate_rf){
+  if(get_softmodem_params()->emulate_rf){
     wait_on_condition(&proc->mutex_emulateRF,&proc->cond_emulateRF,&proc->instance_cnt_emulateRF,"emulatedRF_thread");
     release_thread(&proc->mutex_emulateRF,&proc->instance_cnt_emulateRF,"emulatedRF_thread");
     rxs = fp->samples_per_tti;
@@ -1352,7 +1352,7 @@ void fill_rf_config(RU_t *ru, char *rf_config_file) {
   LTE_DL_FRAME_PARMS *fp   = &ru->frame_parms;
   openair0_config_t *cfg   = &ru->openair0_cfg;
   //printf("////////////////numerology in config = %d\n",numerology);
-
+  int numerology = get_softmodem_params()->numerology;
   if(fp->N_RB_DL == 100) {
     if(numerology == 0){
       if (fp->threequarter_fs) {
@@ -1411,7 +1411,7 @@ void fill_rf_config(RU_t *ru, char *rf_config_file) {
   cfg->num_rb_dl=fp->N_RB_DL;
   cfg->tx_num_channels=ru->nb_tx;
   cfg->rx_num_channels=ru->nb_rx;
-  cfg->clock_source=clock_source;
+  cfg->clock_source=get_softmodem_params()->clock_source;
 
   for (i=0; i<ru->nb_tx; i++) {
     
@@ -1561,7 +1561,7 @@ static void* ru_thread_tx( void* param ) {
   	  
     // do OFDM if needed
     if ((ru->fh_north_asynch_in == NULL) && (ru->feptx_ofdm)) ru->feptx_ofdm(ru);
-    if(!emulate_rf){    
+    if(!(get_softmodem_params()->emulate_rf)){    
       // do outgoing fronthaul (south) if needed
       if ((ru->fh_north_asynch_in == NULL) && (ru->fh_south_out)) ru->fh_south_out(ru);
   	      
@@ -1613,7 +1613,7 @@ static void* ru_thread( void* param ) {
 
   LOG_I(PHY,"Starting RU %d (%s,%s),\n",ru->idx,eNB_functions[ru->function],eNB_timing[ru->if_timing]);
 
-  if(emulate_rf){
+  if(get_softmodem_params()->emulate_rf){
     fill_rf_config(ru,ru->rf_config_file);
     init_frame_parms(&ru->frame_parms,1);
     phy_init_RU(ru);
@@ -1659,7 +1659,7 @@ static void* ru_thread( void* param ) {
 
   wait_sync("ru_thread");
 
-  if(!emulate_rf){
+  if(!(get_softmodem_params()->emulate_rf)){
     // Start RF device if any
     if (ru->start_rf) {
       if (ru->start_rf(ru) != 0)
@@ -1794,7 +1794,7 @@ static void* ru_thread( void* param ) {
       
       // do OFDM if needed
       if ((ru->fh_north_asynch_in == NULL) && (ru->feptx_ofdm)) ru->feptx_ofdm(ru);
-      if(!emulate_rf){
+      if(!(get_softmodem_params()->emulate_rf)){
         // do outgoing fronthaul (south) if needed
         if ((ru->fh_north_asynch_in == NULL) && (ru->fh_south_out)) ru->fh_south_out(ru);
         
@@ -1817,7 +1817,7 @@ static void* ru_thread( void* param ) {
 
   printf( "Exiting ru_thread \n");
 
-  if (!emulate_rf){
+  if (!(get_softmodem_params()->emulate_rf)){
     if (ru->stop_rf != NULL) {
       if (ru->stop_rf(ru) != 0)
         LOG_E(HW,"Could not stop the RF device\n");
@@ -2198,7 +2198,7 @@ void init_RU_proc(RU_t *ru) {
     pthread_create( &proc->pthread_rf_tx, NULL, rf_tx, (void*)ru );
 #endif
 
-  if(emulate_rf)
+  if(get_softmodem_params()->emulate_rf)
     pthread_create( &proc->pthread_emulateRF, attr_emulateRF, emulatedRF_thread, (void*)proc );
 
   if (get_thread_parallel_conf() == PARALLEL_RU_L1_SPLIT || get_thread_parallel_conf() == PARALLEL_RU_L1_TRX_SPLIT)

targets/RT/USER/lte-softmodem-common.c

+/*
+ * Licensed to the OpenAirInterface (OAI) Software Alliance under one or more
+ * contributor license agreements.  See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The OpenAirInterface Software Alliance licenses this file to You under
+ * the OAI Public License, Version 1.1  (the "License"); you may not use this file
+ * except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.openairinterface.org/?page_id=698
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *-------------------------------------------------------------------------------
+ * For more information about the OpenAirInterface (OAI) Software Alliance:
+ *      contact@openairinterface.org
+ */
+
+/*! \file lte-softmodem-common.c
+ * \brief Top-level threads for eNodeB
+ * \author Nokia BellLabs France, francois Taburet
+ * \date 2012
+ * \version 0.1
+ * \company Eurecom
+ * \email: francois.taburet@nokia-bell-labs.com
+ * \note
+ * \warning
+ */
+
+#include "lte-softmodem.h"
+#include "UTIL/OPT/opt.h"
+#include "common/config/config_userapi.h"
+#include "common/utils/load_module_shlib.h"
+static softmodem_params_t softmodem_params;
+
+uint64_t get_softmodem_optmask(void) {
+     return softmodem_params.optmask;
+}
+
+uint64_t set_softmodem_optmask(uint64_t bitmask) {
+     softmodem_params.optmask = softmodem_params.optmask | bitmask;
+     return softmodem_params.optmask;
+}
+
+softmodem_params_t* get_softmodem_params(void) {
+     return &softmodem_params;
+}
+
+void set_parallel_conf(char *parallel_conf)
+{
+  if(strcmp(parallel_conf,"PARALLEL_SINGLE_THREAD")==0)           softmodem_params.thread_struct.parallel_conf = PARALLEL_SINGLE_THREAD;
+  else if(strcmp(parallel_conf,"PARALLEL_RU_L1_SPLIT")==0)        softmodem_params.thread_struct.parallel_conf = PARALLEL_RU_L1_SPLIT;
+  else if(strcmp(parallel_conf,"PARALLEL_RU_L1_TRX_SPLIT")==0)    softmodem_params.thread_struct.parallel_conf = PARALLEL_RU_L1_TRX_SPLIT;
+  printf("[CONFIG] parallel conf is set to %d\n",softmodem_params.thread_struct.parallel_conf);
+} 
+void set_worker_conf(char *worker_conf)
+{
+  if(strcmp(worker_conf,"WORKER_DISABLE")==0)                     softmodem_params.thread_struct.worker_conf = WORKER_DISABLE;
+  else if(strcmp(worker_conf,"WORKER_ENABLE")==0)                 softmodem_params.thread_struct.worker_conf = WORKER_ENABLE;
+  printf("[CONFIG] worker conf is set to %d\n",softmodem_params.thread_struct.worker_conf);
+} 
+PARALLEL_CONF_t get_thread_parallel_conf(void)
+{
+  return softmodem_params.thread_struct.parallel_conf;
+} 
+WORKER_CONF_t get_thread_worker_conf(void)
+{
+  return softmodem_params.thread_struct.worker_conf;
+}  
+void get_common_options(void)
+{
+char *parallel_config=NULL;
+char *worker_config=NULL;
+
+
+uint32_t online_log_messages;
+uint32_t glog_level ;
+uint32_t start_telnetsrv;
+uint32_t noS1;
+uint32_t nokrnmod;
+uint32_t nonbiot;
+paramdef_t cmdline_params[] =CMDLINE_PARAMS_DESC ;
+paramdef_t cmdline_logparams[] =CMDLINE_LOGPARAMS_DESC ;
+
+
+
+  config_process_cmdline( cmdline_params,sizeof(cmdline_params)/sizeof(paramdef_t),NULL); 
+
+  if (strlen(in_path) > 0) {
+      opt_type = OPT_PCAP;
+      opt_enabled=1;
+      printf("Enabling OPT for PCAP  with the following file %s \n",in_path);
+  }
+  if (strlen(in_ip) > 0) {
+      opt_enabled=1;
+      opt_type = OPT_WIRESHARK;
+      printf("Enabling OPT for wireshark for local interface");
+  }
+
+  config_process_cmdline( cmdline_logparams,sizeof(cmdline_logparams)/sizeof(paramdef_t),NULL);
+
+  if(config_isparamset(cmdline_logparams,CMDLINE_ONLINELOG_IDX)) {
+      set_glog_onlinelog(online_log_messages);
+  }
+  if(config_isparamset(cmdline_logparams,CMDLINE_GLOGLEVEL_IDX)) {
+      set_glog(glog_level);
+  }
+  if (start_telnetsrv) {
+     load_module_shlib("telnetsrv",NULL,0,NULL);
+  }
+
+  if (noS1) {
+     set_softmodem_optmask(SOFTMODEM_NOS1_BIT);
+  }
+  if (nokrnmod) {
+     set_softmodem_optmask(SOFTMODEM_NOKRNMOD_BIT);
+  } 
+  if (nonbiot) {
+     set_softmodem_optmask(SOFTMODEM_NONBIOT_BIT);
+  } 
+  if(parallel_config != NULL) set_parallel_conf(parallel_config);
+  if(worker_config != NULL)   set_worker_conf(worker_config);
+}

targets/RT/USER/lte-ue.c

@@ -58,8 +58,8 @@
 #include "UTIL/MATH/oml.h"
 #include "common/utils/LOG/vcd_signal_dumper.h"
 #include "UTIL/OPT/opt.h"
-
-
+#include "lte-softmodem.h"
+#include "common/config/config_userapi.h"
 #include "T.h"
 
 extern double cpuf;
@@ -158,12 +158,21 @@ static const eutra_band_t eutra_bands[] = {
 };
 
 
-
+threads_t threads= {-1,-1,-1,-1,-1,-1,-1};
 
 pthread_t                       main_ue_thread;
 pthread_attr_t                  attr_UE_thread;
 struct sched_param              sched_param_UE_thread;
 
+
+void get_uethreads_params(void) {
+  paramdef_t cmdline_threadsparams[] =CMDLINE_UETHREADSPARAMS_DESC;
+
+
+  config_process_cmdline( cmdline_threadsparams,sizeof(cmdline_threadsparams)/sizeof(paramdef_t),NULL);
+}
+
+
 void phy_init_lte_ue_transport(PHY_VARS_UE *ue,int absraction_flag);
 
 PHY_VARS_UE* init_ue_vars(LTE_DL_FRAME_PARMS *frame_parms,
@@ -179,7 +188,7 @@ PHY_VARS_UE* init_ue_vars(LTE_DL_FRAME_PARMS *frame_parms,
     memcpy(&(ue->frame_parms), frame_parms, sizeof(LTE_DL_FRAME_PARMS));
   }
 
-
+  ue->hw_timing_advance=get_softmodem_params()->hw_timing_advance;
   ue->Mod_id      = UE_id;
   ue->mac_enabled = 1;
 

targets/RT/USER/rfsim.c

@@ -62,7 +62,6 @@ sim_t sim;
 
 
 void init_ru_devices(void);
-void init_RU(const char*);
 void *rfsim_top(void *n_frames);
 
 void wait_RUs(void)