first set of cppcheck fixes
This commit is contained in:
frtabu
@@ -166,6 +166,7 @@ int config_check_unknown_cmdlineopt(char *prefix) {
|
||||
int unknowndetected=0;
|
||||
char testprefix[CONFIG_MAXOPTLENGTH];
|
||||
int finalcheck = 0;
|
||||
memset(testprefix,0,sizeof(testprefix));
|
||||
|
||||
memset(testprefix,0,sizeof(testprefix));
|
||||
if (prefix != NULL) {
|
||||
|
||||
+257
-217
@@ -2,9 +2,9 @@
|
||||
* 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 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.
|
||||
* except in compliance with the License.
|
||||
* You may obtain a copy of the License at
|
||||
*
|
||||
* http://www.openairinterface.org/?page_id=698
|
||||
@@ -28,17 +28,33 @@
|
||||
|
||||
|
||||
//-------------------------------------------------------------------------------------------------------------------------------
|
||||
char* hashtable_rc_code2string(hashtable_rc_t rcP)
|
||||
char *hashtable_rc_code2string(hashtable_rc_t rcP)
|
||||
//-------------------------------------------------------------------------------------------------------------------------------
|
||||
{
|
||||
switch (rcP) {
|
||||
case HASH_TABLE_OK: return "HASH_TABLE_OK";break;
|
||||
case HASH_TABLE_INSERT_OVERWRITTEN_DATA: return "HASH_TABLE_INSERT_OVERWRITTEN_DATA";break;
|
||||
case HASH_TABLE_KEY_NOT_EXISTS: return "HASH_TABLE_KEY_NOT_EXISTS";break;
|
||||
case HASH_TABLE_KEY_ALREADY_EXISTS: return "HASH_TABLE_KEY_ALREADY_EXISTS";break;
|
||||
case HASH_TABLE_BAD_PARAMETER_HASHTABLE: return "HASH_TABLE_BAD_PARAMETER_HASHTABLE";break;
|
||||
default: return "UNKNOWN hashtable_rc_t";
|
||||
}
|
||||
switch (rcP) {
|
||||
case HASH_TABLE_OK:
|
||||
return "HASH_TABLE_OK";
|
||||
break;
|
||||
|
||||
case HASH_TABLE_INSERT_OVERWRITTEN_DATA:
|
||||
return "HASH_TABLE_INSERT_OVERWRITTEN_DATA";
|
||||
break;
|
||||
|
||||
case HASH_TABLE_KEY_NOT_EXISTS:
|
||||
return "HASH_TABLE_KEY_NOT_EXISTS";
|
||||
break;
|
||||
|
||||
case HASH_TABLE_KEY_ALREADY_EXISTS:
|
||||
return "HASH_TABLE_KEY_ALREADY_EXISTS";
|
||||
break;
|
||||
|
||||
case HASH_TABLE_BAD_PARAMETER_HASHTABLE:
|
||||
return "HASH_TABLE_BAD_PARAMETER_HASHTABLE";
|
||||
break;
|
||||
|
||||
default:
|
||||
return "UNKNOWN hashtable_rc_t";
|
||||
}
|
||||
}
|
||||
//-------------------------------------------------------------------------------------------------------------------------------
|
||||
/*
|
||||
@@ -46,7 +62,7 @@ char* hashtable_rc_code2string(hashtable_rc_t rcP)
|
||||
* hash_free_int_func() is used when this hashtable is used to store int values as data (pointer = value).
|
||||
*/
|
||||
|
||||
void hash_free_int_func(void* memoryP){}
|
||||
void hash_free_int_func(void *memoryP) {}
|
||||
|
||||
//-------------------------------------------------------------------------------------------------------------------------------
|
||||
/*
|
||||
@@ -55,9 +71,8 @@ void hash_free_int_func(void* memoryP){}
|
||||
* This is a simple/naive hash function which adds the key's ASCII char values. It will probably generate lots of collisions on large hash tables.
|
||||
*/
|
||||
|
||||
static hash_size_t def_hashfunc(const uint64_t keyP)
|
||||
{
|
||||
return (hash_size_t)keyP;
|
||||
static hash_size_t def_hashfunc(const uint64_t keyP) {
|
||||
return (hash_size_t)keyP;
|
||||
}
|
||||
|
||||
//-------------------------------------------------------------------------------------------------------------------------------
|
||||
@@ -67,132 +82,147 @@ static hash_size_t def_hashfunc(const uint64_t keyP)
|
||||
* The user can also specify a hash function. If the hashfunc argument is NULL, a default hash function is used.
|
||||
* If an error occurred, NULL is returned. All other values in the returned hash_table_t pointer should be released with hashtable_destroy().
|
||||
*/
|
||||
hash_table_t *hashtable_create(const hash_size_t sizeP, hash_size_t (*hashfuncP)(const hash_key_t ), void (*freefuncP)(void*))
|
||||
{
|
||||
hash_table_t *hashtbl = NULL;
|
||||
hash_table_t *hashtable_create(const hash_size_t sizeP, hash_size_t (*hashfuncP)(const hash_key_t ), void (*freefuncP)(void *)) {
|
||||
hash_table_t *hashtbl = NULL;
|
||||
|
||||
if(!(hashtbl=malloc(sizeof(hash_table_t)))) {
|
||||
return NULL;
|
||||
}
|
||||
if(!(hashtbl=malloc(sizeof(hash_table_t)))) {
|
||||
return NULL;
|
||||
}
|
||||
|
||||
if(!(hashtbl->nodes=calloc(sizeP, sizeof(hash_node_t*)))) {
|
||||
free(hashtbl);
|
||||
return NULL;
|
||||
}
|
||||
if(!(hashtbl->nodes=calloc(sizeP, sizeof(hash_node_t *)))) {
|
||||
free(hashtbl);
|
||||
return NULL;
|
||||
}
|
||||
|
||||
hashtbl->size=sizeP;
|
||||
hashtbl->size=sizeP;
|
||||
|
||||
if(hashfuncP) hashtbl->hashfunc=hashfuncP;
|
||||
else hashtbl->hashfunc=def_hashfunc;
|
||||
if(hashfuncP) hashtbl->hashfunc=hashfuncP;
|
||||
else hashtbl->hashfunc=def_hashfunc;
|
||||
|
||||
if(freefuncP) hashtbl->freefunc=freefuncP;
|
||||
else hashtbl->freefunc=free;
|
||||
if(freefuncP) hashtbl->freefunc=freefuncP;
|
||||
else hashtbl->freefunc=free;
|
||||
|
||||
return hashtbl;
|
||||
return hashtbl;
|
||||
}
|
||||
//-------------------------------------------------------------------------------------------------------------------------------
|
||||
/*
|
||||
* Cleanup
|
||||
* The hashtable_destroy() walks through the linked lists for each possible hash value, and releases the elements. It also releases the nodes array and the hash_table_t.
|
||||
*/
|
||||
hashtable_rc_t hashtable_destroy(hash_table_t * hashtblP)
|
||||
{
|
||||
hash_size_t n;
|
||||
hash_node_t *node, *oldnode;
|
||||
hashtable_rc_t hashtable_destroy(hash_table_t **hashtblP) {
|
||||
hash_size_t n;
|
||||
hash_node_t *node, *oldnode;
|
||||
|
||||
if (hashtblP == NULL) {
|
||||
return HASH_TABLE_BAD_PARAMETER_HASHTABLE;
|
||||
}
|
||||
if (*hashtblP == NULL) {
|
||||
return HASH_TABLE_BAD_PARAMETER_HASHTABLE;
|
||||
}
|
||||
|
||||
for(n=0; n<hashtblP->size; ++n) {
|
||||
node=hashtblP->nodes[n];
|
||||
while(node) {
|
||||
oldnode=node;
|
||||
node=node->next;
|
||||
if (oldnode->data) {
|
||||
hashtblP->freefunc(oldnode->data);
|
||||
}
|
||||
free(oldnode);
|
||||
}
|
||||
}
|
||||
free(hashtblP->nodes);
|
||||
free(hashtblP);
|
||||
hashtblP=NULL;
|
||||
return HASH_TABLE_OK;
|
||||
}
|
||||
//-------------------------------------------------------------------------------------------------------------------------------
|
||||
hashtable_rc_t hashtable_is_key_exists (const hash_table_t * const hashtblP, const hash_key_t keyP)
|
||||
//-------------------------------------------------------------------------------------------------------------------------------
|
||||
{
|
||||
hash_node_t *node = NULL;
|
||||
hash_size_t hash = 0;
|
||||
for(n=0; n<(*hashtblP)->size; ++n) {
|
||||
node=(*hashtblP)->nodes[n];
|
||||
|
||||
if (hashtblP == NULL) {
|
||||
return HASH_TABLE_BAD_PARAMETER_HASHTABLE;
|
||||
}
|
||||
|
||||
hash=hashtblP->hashfunc(keyP)%hashtblP->size;
|
||||
node=hashtblP->nodes[hash];
|
||||
while(node) {
|
||||
if(node->key == keyP) {
|
||||
return HASH_TABLE_OK;
|
||||
}
|
||||
oldnode=node;
|
||||
node=node->next;
|
||||
|
||||
if (oldnode->data) {
|
||||
(*hashtblP)->freefunc(oldnode->data);
|
||||
}
|
||||
|
||||
free(oldnode);
|
||||
}
|
||||
}
|
||||
|
||||
free((*hashtblP)->nodes);
|
||||
free((*hashtblP));
|
||||
*hashtblP=NULL;
|
||||
return HASH_TABLE_OK;
|
||||
}
|
||||
//-------------------------------------------------------------------------------------------------------------------------------
|
||||
hashtable_rc_t hashtable_is_key_exists (const hash_table_t *const hashtblP, const hash_key_t keyP)
|
||||
//-------------------------------------------------------------------------------------------------------------------------------
|
||||
{
|
||||
hash_node_t *node = NULL;
|
||||
hash_size_t hash = 0;
|
||||
|
||||
if (hashtblP == NULL) {
|
||||
return HASH_TABLE_BAD_PARAMETER_HASHTABLE;
|
||||
}
|
||||
|
||||
hash=hashtblP->hashfunc(keyP)%hashtblP->size;
|
||||
node=hashtblP->nodes[hash];
|
||||
|
||||
while(node) {
|
||||
if(node->key == keyP) {
|
||||
return HASH_TABLE_OK;
|
||||
}
|
||||
|
||||
node=node->next;
|
||||
}
|
||||
|
||||
return HASH_TABLE_KEY_NOT_EXISTS;
|
||||
}
|
||||
//-------------------------------------------------------------------------------------------------------------------------------
|
||||
hashtable_rc_t hashtable_apply_funct_on_elements (hash_table_t *const hashtblP, void functP(hash_key_t keyP, void *dataP, void *parameterP), void *parameterP)
|
||||
//-------------------------------------------------------------------------------------------------------------------------------
|
||||
{
|
||||
hash_node_t *node = NULL;
|
||||
unsigned int i = 0;
|
||||
unsigned int num_elements = 0;
|
||||
|
||||
if (hashtblP == NULL) {
|
||||
return HASH_TABLE_BAD_PARAMETER_HASHTABLE;
|
||||
}
|
||||
|
||||
while ((num_elements < hashtblP->num_elements) && (i < hashtblP->size)) {
|
||||
if (hashtblP->nodes[i] != NULL) {
|
||||
node=hashtblP->nodes[i];
|
||||
|
||||
while(node) {
|
||||
num_elements += 1;
|
||||
functP(node->key, node->data, parameterP);
|
||||
node=node->next;
|
||||
}
|
||||
}
|
||||
return HASH_TABLE_KEY_NOT_EXISTS;
|
||||
|
||||
i += 1;
|
||||
}
|
||||
|
||||
return HASH_TABLE_OK;
|
||||
}
|
||||
//-------------------------------------------------------------------------------------------------------------------------------
|
||||
hashtable_rc_t hashtable_apply_funct_on_elements (hash_table_t *const hashtblP, void functP(hash_key_t keyP, void* dataP, void* parameterP), void* parameterP)
|
||||
hashtable_rc_t hashtable_dump_content (const hash_table_t *const hashtblP, char *const buffer_pP, int *const remaining_bytes_in_buffer_pP )
|
||||
//-------------------------------------------------------------------------------------------------------------------------------
|
||||
{
|
||||
hash_node_t *node = NULL;
|
||||
unsigned int i = 0;
|
||||
unsigned int num_elements = 0;
|
||||
if (hashtblP == NULL) {
|
||||
return HASH_TABLE_BAD_PARAMETER_HASHTABLE;
|
||||
}
|
||||
while ((num_elements < hashtblP->num_elements) && (i < hashtblP->size)) {
|
||||
if (hashtblP->nodes[i] != NULL) {
|
||||
node=hashtblP->nodes[i];
|
||||
while(node) {
|
||||
num_elements += 1;
|
||||
functP(node->key, node->data, parameterP);
|
||||
node=node->next;
|
||||
}
|
||||
}
|
||||
i += 1;
|
||||
}
|
||||
return HASH_TABLE_OK;
|
||||
}
|
||||
//-------------------------------------------------------------------------------------------------------------------------------
|
||||
hashtable_rc_t hashtable_dump_content (const hash_table_t * const hashtblP, char * const buffer_pP, int * const remaining_bytes_in_buffer_pP )
|
||||
//-------------------------------------------------------------------------------------------------------------------------------
|
||||
{
|
||||
hash_node_t *node = NULL;
|
||||
unsigned int i = 0;
|
||||
if (hashtblP == NULL) {
|
||||
hash_node_t *node = NULL;
|
||||
unsigned int i = 0;
|
||||
|
||||
if (hashtblP == NULL) {
|
||||
*remaining_bytes_in_buffer_pP = snprintf(
|
||||
buffer_pP,
|
||||
*remaining_bytes_in_buffer_pP,
|
||||
"HASH_TABLE_BAD_PARAMETER_HASHTABLE");
|
||||
return HASH_TABLE_BAD_PARAMETER_HASHTABLE;
|
||||
}
|
||||
|
||||
while ((i < hashtblP->size) && (*remaining_bytes_in_buffer_pP > 0)) {
|
||||
if (hashtblP->nodes[i] != NULL) {
|
||||
node=hashtblP->nodes[i];
|
||||
|
||||
while(node) {
|
||||
*remaining_bytes_in_buffer_pP = snprintf(
|
||||
buffer_pP,
|
||||
*remaining_bytes_in_buffer_pP,
|
||||
"HASH_TABLE_BAD_PARAMETER_HASHTABLE");
|
||||
return HASH_TABLE_BAD_PARAMETER_HASHTABLE;
|
||||
buffer_pP,
|
||||
*remaining_bytes_in_buffer_pP,
|
||||
"Key 0x%"PRIx64" Element %p\n",
|
||||
node->key,
|
||||
node->data);
|
||||
node=node->next;
|
||||
}
|
||||
}
|
||||
while ((i < hashtblP->size) && (*remaining_bytes_in_buffer_pP > 0)) {
|
||||
if (hashtblP->nodes[i] != NULL) {
|
||||
node=hashtblP->nodes[i];
|
||||
while(node) {
|
||||
*remaining_bytes_in_buffer_pP = snprintf(
|
||||
buffer_pP,
|
||||
*remaining_bytes_in_buffer_pP,
|
||||
"Key 0x%"PRIx64" Element %p\n",
|
||||
node->key,
|
||||
node->data);
|
||||
node=node->next;
|
||||
}
|
||||
}
|
||||
i += 1;
|
||||
}
|
||||
return HASH_TABLE_OK;
|
||||
|
||||
i += 1;
|
||||
}
|
||||
|
||||
return HASH_TABLE_OK;
|
||||
}
|
||||
|
||||
//-------------------------------------------------------------------------------------------------------------------------------
|
||||
@@ -200,97 +230,110 @@ hashtable_rc_t hashtable_dump_content (const hash_table_t * const hashtblP, char
|
||||
* Adding a new element
|
||||
* To make sure the hash value is not bigger than size, the result of the user provided hash function is used modulo size.
|
||||
*/
|
||||
hashtable_rc_t hashtable_insert(hash_table_t * const hashtblP, const hash_key_t keyP, void *dataP)
|
||||
{
|
||||
hash_node_t *node = NULL;
|
||||
hash_size_t hash = 0;
|
||||
if (hashtblP == NULL) {
|
||||
return HASH_TABLE_BAD_PARAMETER_HASHTABLE;
|
||||
}
|
||||
hash=hashtblP->hashfunc(keyP)%hashtblP->size;
|
||||
hashtable_rc_t hashtable_insert(hash_table_t *const hashtblP, const hash_key_t keyP, void *dataP) {
|
||||
hash_node_t *node = NULL;
|
||||
hash_size_t hash = 0;
|
||||
|
||||
node=hashtblP->nodes[hash];
|
||||
while(node) {
|
||||
if(node->key == keyP) {
|
||||
if (node->data) {
|
||||
hashtblP->freefunc(node->data);
|
||||
}
|
||||
node->data=dataP;
|
||||
return HASH_TABLE_INSERT_OVERWRITTEN_DATA;
|
||||
}
|
||||
node=node->next;
|
||||
if (hashtblP == NULL) {
|
||||
return HASH_TABLE_BAD_PARAMETER_HASHTABLE;
|
||||
}
|
||||
|
||||
hash=hashtblP->hashfunc(keyP)%hashtblP->size;
|
||||
node=hashtblP->nodes[hash];
|
||||
|
||||
while(node) {
|
||||
if(node->key == keyP) {
|
||||
if (node->data) {
|
||||
hashtblP->freefunc(node->data);
|
||||
}
|
||||
|
||||
node->data=dataP;
|
||||
return HASH_TABLE_INSERT_OVERWRITTEN_DATA;
|
||||
}
|
||||
if(!(node=malloc(sizeof(hash_node_t)))) return -1;
|
||||
node->key=keyP;
|
||||
node->data=dataP;
|
||||
if (hashtblP->nodes[hash]) {
|
||||
node->next=hashtblP->nodes[hash];
|
||||
} else {
|
||||
node->next = NULL;
|
||||
}
|
||||
hashtblP->nodes[hash]=node;
|
||||
hashtblP->num_elements += 1;
|
||||
return HASH_TABLE_OK;
|
||||
|
||||
node=node->next;
|
||||
}
|
||||
|
||||
if(!(node=malloc(sizeof(hash_node_t)))) return -1;
|
||||
|
||||
node->key=keyP;
|
||||
node->data=dataP;
|
||||
|
||||
if (hashtblP->nodes[hash]) {
|
||||
node->next=hashtblP->nodes[hash];
|
||||
} else {
|
||||
node->next = NULL;
|
||||
}
|
||||
|
||||
hashtblP->nodes[hash]=node;
|
||||
hashtblP->num_elements += 1;
|
||||
return HASH_TABLE_OK;
|
||||
}
|
||||
//-------------------------------------------------------------------------------------------------------------------------------
|
||||
/*
|
||||
* To remove an element from the hash table, we just search for it in the linked list for that hash value,
|
||||
* and remove it if it is found. If it was not found, it is an error and -1 is returned.
|
||||
*/
|
||||
hashtable_rc_t hashtable_remove(hash_table_t * const hashtblP, const hash_key_t keyP)
|
||||
{
|
||||
hash_node_t *node, *prevnode=NULL;
|
||||
hash_size_t hash = 0;
|
||||
hashtable_rc_t hashtable_remove(hash_table_t *const hashtblP, const hash_key_t keyP) {
|
||||
hash_node_t *node, *prevnode=NULL;
|
||||
hash_size_t hash = 0;
|
||||
|
||||
if (hashtblP == NULL) {
|
||||
return HASH_TABLE_BAD_PARAMETER_HASHTABLE;
|
||||
if (hashtblP == NULL) {
|
||||
return HASH_TABLE_BAD_PARAMETER_HASHTABLE;
|
||||
}
|
||||
|
||||
hash=hashtblP->hashfunc(keyP)%hashtblP->size;
|
||||
node=hashtblP->nodes[hash];
|
||||
|
||||
while(node) {
|
||||
if(node->key == keyP) {
|
||||
if(prevnode) prevnode->next=node->next;
|
||||
else hashtblP->nodes[hash]=node->next;
|
||||
|
||||
if (node->data) {
|
||||
hashtblP->freefunc(node->data);
|
||||
}
|
||||
|
||||
free(node);
|
||||
hashtblP->num_elements -= 1;
|
||||
return HASH_TABLE_OK;
|
||||
}
|
||||
hash=hashtblP->hashfunc(keyP)%hashtblP->size;
|
||||
node=hashtblP->nodes[hash];
|
||||
while(node) {
|
||||
if(node->key == keyP) {
|
||||
if(prevnode) prevnode->next=node->next;
|
||||
else hashtblP->nodes[hash]=node->next;
|
||||
if (node->data) {
|
||||
hashtblP->freefunc(node->data);
|
||||
}
|
||||
free(node);
|
||||
hashtblP->num_elements -= 1;
|
||||
return HASH_TABLE_OK;
|
||||
}
|
||||
prevnode=node;
|
||||
node=node->next;
|
||||
}
|
||||
return HASH_TABLE_KEY_NOT_EXISTS;
|
||||
|
||||
prevnode=node;
|
||||
node=node->next;
|
||||
}
|
||||
|
||||
return HASH_TABLE_KEY_NOT_EXISTS;
|
||||
}
|
||||
//-------------------------------------------------------------------------------------------------------------------------------
|
||||
/*
|
||||
* Searching for an element is easy. We just search through the linked list for the corresponding hash value.
|
||||
* NULL is returned if we didn't find it.
|
||||
*/
|
||||
hashtable_rc_t hashtable_get(const hash_table_t * const hashtblP, const hash_key_t keyP, void** dataP)
|
||||
{
|
||||
hash_node_t *node = NULL;
|
||||
hash_size_t hash = 0;
|
||||
hashtable_rc_t hashtable_get(const hash_table_t *const hashtblP, const hash_key_t keyP, void **dataP) {
|
||||
hash_node_t *node = NULL;
|
||||
hash_size_t hash = 0;
|
||||
|
||||
if (hashtblP == NULL) {
|
||||
*dataP = NULL;
|
||||
return HASH_TABLE_BAD_PARAMETER_HASHTABLE;
|
||||
}
|
||||
hash=hashtblP->hashfunc(keyP)%hashtblP->size;
|
||||
/* fprintf(stderr, "hashtable_get() key=%s, hash=%d\n", key, hash);*/
|
||||
|
||||
node=hashtblP->nodes[hash];
|
||||
|
||||
while(node) {
|
||||
if(node->key == keyP) {
|
||||
*dataP = node->data;
|
||||
return HASH_TABLE_OK;
|
||||
}
|
||||
node=node->next;
|
||||
}
|
||||
if (hashtblP == NULL) {
|
||||
*dataP = NULL;
|
||||
return HASH_TABLE_KEY_NOT_EXISTS;
|
||||
return HASH_TABLE_BAD_PARAMETER_HASHTABLE;
|
||||
}
|
||||
|
||||
hash=hashtblP->hashfunc(keyP)%hashtblP->size;
|
||||
/* fprintf(stderr, "hashtable_get() key=%s, hash=%d\n", key, hash);*/
|
||||
node=hashtblP->nodes[hash];
|
||||
|
||||
while(node) {
|
||||
if(node->key == keyP) {
|
||||
*dataP = node->data;
|
||||
return HASH_TABLE_OK;
|
||||
}
|
||||
|
||||
node=node->next;
|
||||
}
|
||||
|
||||
*dataP = NULL;
|
||||
return HASH_TABLE_KEY_NOT_EXISTS;
|
||||
}
|
||||
//-------------------------------------------------------------------------------------------------------------------------------
|
||||
/*
|
||||
@@ -304,36 +347,33 @@ hashtable_rc_t hashtable_get(const hash_table_t * const hashtblP, const hash_key
|
||||
* After that, we can just free the old table and copy the elements from newtbl to hashtbl.
|
||||
*/
|
||||
|
||||
hashtable_rc_t hashtable_resize(hash_table_t * const hashtblP, const hash_size_t sizeP)
|
||||
{
|
||||
hash_table_t newtbl;
|
||||
hash_size_t n;
|
||||
hash_node_t *node,*next;
|
||||
hashtable_rc_t hashtable_resize(hash_table_t *const hashtblP, const hash_size_t sizeP) {
|
||||
hash_table_t newtbl;
|
||||
hash_size_t n;
|
||||
hash_node_t *node,*next;
|
||||
|
||||
if (hashtblP == NULL) {
|
||||
return HASH_TABLE_BAD_PARAMETER_HASHTABLE;
|
||||
if (hashtblP == NULL) {
|
||||
return HASH_TABLE_BAD_PARAMETER_HASHTABLE;
|
||||
}
|
||||
|
||||
newtbl.size = sizeP;
|
||||
newtbl.hashfunc = hashtblP->hashfunc;
|
||||
|
||||
if(!(newtbl.nodes=calloc(sizeP, sizeof(hash_node_t *)))) return -1;
|
||||
|
||||
for(n=0; n<hashtblP->size; ++n) {
|
||||
for(node=hashtblP->nodes[n]; node; node=next) {
|
||||
next = node->next;
|
||||
hashtable_insert(&newtbl, node->key, node->data);
|
||||
// Lionel GAUTHIER: BAD CODE TO BE REWRITTEN
|
||||
hashtable_remove(hashtblP, node->key);
|
||||
}
|
||||
}
|
||||
|
||||
newtbl.size = sizeP;
|
||||
newtbl.hashfunc = hashtblP->hashfunc;
|
||||
|
||||
if(!(newtbl.nodes=calloc(sizeP, sizeof(hash_node_t*)))) return -1;
|
||||
|
||||
for(n=0; n<hashtblP->size; ++n) {
|
||||
for(node=hashtblP->nodes[n]; node; node=next) {
|
||||
next = node->next;
|
||||
hashtable_insert(&newtbl, node->key, node->data);
|
||||
// Lionel GAUTHIER: BAD CODE TO BE REWRITTEN
|
||||
hashtable_remove(hashtblP, node->key);
|
||||
|
||||
}
|
||||
}
|
||||
|
||||
free(hashtblP->nodes);
|
||||
hashtblP->size=newtbl.size;
|
||||
hashtblP->nodes=newtbl.nodes;
|
||||
|
||||
return HASH_TABLE_OK;
|
||||
free(hashtblP->nodes);
|
||||
hashtblP->size=newtbl.size;
|
||||
hashtblP->nodes=newtbl.nodes;
|
||||
return HASH_TABLE_OK;
|
||||
}
|
||||
|
||||
|
||||
|
||||
@@ -2,9 +2,9 @@
|
||||
* 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 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.
|
||||
* except in compliance with the License.
|
||||
* You may obtain a copy of the License at
|
||||
*
|
||||
* http://www.openairinterface.org/?page_id=698
|
||||
@@ -31,41 +31,41 @@ typedef uint64_t hash_key_t;
|
||||
#define HASHTABLE_NOT_A_KEY_VALUE ((uint64_t)-1)
|
||||
|
||||
typedef enum hashtable_return_code_e {
|
||||
HASH_TABLE_OK = 0,
|
||||
HASH_TABLE_INSERT_OVERWRITTEN_DATA = 1,
|
||||
HASH_TABLE_KEY_NOT_EXISTS = 2,
|
||||
HASH_TABLE_KEY_ALREADY_EXISTS = 3,
|
||||
HASH_TABLE_BAD_PARAMETER_HASHTABLE = 4,
|
||||
HASH_TABLE_SYSTEM_ERROR = 5,
|
||||
HASH_TABLE_CODE_MAX
|
||||
HASH_TABLE_OK = 0,
|
||||
HASH_TABLE_INSERT_OVERWRITTEN_DATA = 1,
|
||||
HASH_TABLE_KEY_NOT_EXISTS = 2,
|
||||
HASH_TABLE_KEY_ALREADY_EXISTS = 3,
|
||||
HASH_TABLE_BAD_PARAMETER_HASHTABLE = 4,
|
||||
HASH_TABLE_SYSTEM_ERROR = 5,
|
||||
HASH_TABLE_CODE_MAX
|
||||
} hashtable_rc_t;
|
||||
|
||||
|
||||
typedef struct hash_node_s {
|
||||
hash_key_t key;
|
||||
void *data;
|
||||
struct hash_node_s *next;
|
||||
hash_key_t key;
|
||||
void *data;
|
||||
struct hash_node_s *next;
|
||||
} hash_node_t;
|
||||
|
||||
typedef struct hash_table_s {
|
||||
hash_size_t size;
|
||||
hash_size_t num_elements;
|
||||
struct hash_node_s **nodes;
|
||||
hash_size_t (*hashfunc)(const hash_key_t);
|
||||
void (*freefunc)(void*);
|
||||
hash_size_t size;
|
||||
hash_size_t num_elements;
|
||||
struct hash_node_s **nodes;
|
||||
hash_size_t (*hashfunc)(const hash_key_t);
|
||||
void (*freefunc)(void *);
|
||||
} hash_table_t;
|
||||
|
||||
char* hashtable_rc_code2string(hashtable_rc_t rcP);
|
||||
void hash_free_int_func(void* memoryP);
|
||||
hash_table_t *hashtable_create (const hash_size_t size, hash_size_t (*hashfunc)(const hash_key_t ), void (*freefunc)(void*));
|
||||
hashtable_rc_t hashtable_destroy(hash_table_t * const hashtbl);
|
||||
hashtable_rc_t hashtable_is_key_exists (const hash_table_t * const hashtbl, const uint64_t key);
|
||||
hashtable_rc_t hashtable_apply_funct_on_elements (hash_table_t * const hashtblP, void funct(hash_key_t keyP, void* dataP, void* parameterP), void* parameterP);
|
||||
hashtable_rc_t hashtable_dump_content (const hash_table_t * const hashtblP, char * const buffer_pP, int * const remaining_bytes_in_buffer_pP );
|
||||
hashtable_rc_t hashtable_insert (hash_table_t * const hashtbl, const hash_key_t key, void *data);
|
||||
hashtable_rc_t hashtable_remove (hash_table_t * const hashtbl, const hash_key_t key);
|
||||
hashtable_rc_t hashtable_get (const hash_table_t * const hashtbl, const hash_key_t key, void **dataP);
|
||||
hashtable_rc_t hashtable_resize (hash_table_t * const hashtbl, const hash_size_t size);
|
||||
char *hashtable_rc_code2string(hashtable_rc_t rcP);
|
||||
void hash_free_int_func(void *memoryP);
|
||||
hash_table_t *hashtable_create (const hash_size_t size, hash_size_t (*hashfunc)(const hash_key_t ), void (*freefunc)(void *));
|
||||
hashtable_rc_t hashtable_destroy(hash_table_t **hashtbl);
|
||||
hashtable_rc_t hashtable_is_key_exists (const hash_table_t *const hashtbl, const uint64_t key);
|
||||
hashtable_rc_t hashtable_apply_funct_on_elements (hash_table_t *const hashtblP, void funct(hash_key_t keyP, void *dataP, void *parameterP), void *parameterP);
|
||||
hashtable_rc_t hashtable_dump_content (const hash_table_t *const hashtblP, char *const buffer_pP, int *const remaining_bytes_in_buffer_pP );
|
||||
hashtable_rc_t hashtable_insert (hash_table_t *const hashtbl, const hash_key_t key, void *data);
|
||||
hashtable_rc_t hashtable_remove (hash_table_t *const hashtbl, const hash_key_t key);
|
||||
hashtable_rc_t hashtable_get (const hash_table_t *const hashtbl, const hash_key_t key, void **dataP);
|
||||
hashtable_rc_t hashtable_resize (hash_table_t *const hashtbl, const hash_size_t size);
|
||||
|
||||
|
||||
|
||||
|
||||
+19
-85
@@ -23,19 +23,19 @@
|
||||
#include "memory_pools.h"
|
||||
|
||||
#if T_TRACER
|
||||
#include <string.h>
|
||||
#include "T.h"
|
||||
#include <string.h>
|
||||
#include "T.h"
|
||||
#endif
|
||||
|
||||
/*------------------------------------------------------------------------------*/
|
||||
const static int mp_debug = 0;
|
||||
|
||||
# define MP_DEBUG(x, args...) do { if (mp_debug) fprintf(stdout, "[MP][D]"x, ##args); fflush (stdout); } \
|
||||
while(0)
|
||||
while(0)
|
||||
|
||||
/*------------------------------------------------------------------------------*/
|
||||
#ifndef CHARS_TO_UINT32
|
||||
#define CHARS_TO_UINT32(c1, c2, c3, c4) (((c1) << 24) | ((c2) << 16) | ((c3) << 8) | (c4))
|
||||
#define CHARS_TO_UINT32(c1, c2, c3, c4) (((c1) << 24) | ((c2) << 16) | ((c3) << 8) | (c4))
|
||||
#endif
|
||||
|
||||
#define MEMORY_POOL_ITEM_INFO_NUMBER 2
|
||||
@@ -129,33 +129,25 @@ static const pool_start_mark_t POOL_START_MARK = CHARS_TO_UINT32 ('P'
|
||||
static const pools_start_mark_t POOLS_START_MARK = CHARS_TO_UINT32 ('P', 'S', 's', 't');
|
||||
|
||||
/*------------------------------------------------------------------------------*/
|
||||
static inline uint32_t items_group_number_items (items_group_t *items_group)
|
||||
{
|
||||
static inline uint32_t items_group_number_items (items_group_t *items_group) {
|
||||
return items_group->number_plus_one - 1;
|
||||
}
|
||||
|
||||
static inline uint32_t items_group_free_items (items_group_t *items_group)
|
||||
{
|
||||
static inline uint32_t items_group_free_items (items_group_t *items_group) {
|
||||
items_group_positions_t positions;
|
||||
uint32_t free_items;
|
||||
|
||||
positions.all = items_group->positions.all;
|
||||
|
||||
free_items = items_group->number_plus_one + positions.ind.put - positions.ind.get;
|
||||
free_items %= items_group->number_plus_one;
|
||||
|
||||
return free_items;
|
||||
}
|
||||
|
||||
static inline items_group_index_t items_group_get_free_item (items_group_t *items_group)
|
||||
{
|
||||
static inline items_group_index_t items_group_get_free_item (items_group_t *items_group) {
|
||||
items_group_position_t get_raw;
|
||||
items_group_position_t put;
|
||||
items_group_position_t get;
|
||||
items_group_position_t free_items;
|
||||
|
||||
items_group_index_t index = ITEMS_GROUP_INDEX_INVALID;
|
||||
|
||||
/* Get current put position */
|
||||
put = items_group->positions.ind.put % items_group->number_plus_one;
|
||||
/* Get current get position and increase it */
|
||||
@@ -193,11 +185,9 @@ static inline items_group_index_t items_group_get_free_item (items_group_t *item
|
||||
return (index);
|
||||
}
|
||||
|
||||
static inline int items_group_put_free_item (items_group_t *items_group, items_group_index_t index)
|
||||
{
|
||||
static inline int items_group_put_free_item (items_group_t *items_group, items_group_index_t index) {
|
||||
items_group_position_t put_raw;
|
||||
items_group_position_t put;
|
||||
|
||||
/* Get current put position and increase it */
|
||||
put_raw = __sync_fetch_and_add (&items_group->positions.ind.put, 1);
|
||||
put = put_raw % items_group->number_plus_one;
|
||||
@@ -209,70 +199,54 @@ static inline int items_group_put_free_item (items_group_t *items_group, items_g
|
||||
|
||||
AssertError (items_group->indexes[put] <= ITEMS_GROUP_INDEX_INVALID, return (EXIT_FAILURE),
|
||||
"Index at current put position (%d) is not marked as free (%d)!\n", put, items_group->number_plus_one);
|
||||
|
||||
/* Save freed item index at current put position */
|
||||
items_group->indexes[put] = index;
|
||||
return (EXIT_SUCCESS);
|
||||
}
|
||||
|
||||
/*------------------------------------------------------------------------------*/
|
||||
static inline memory_pools_t *memory_pools_from_handler (memory_pools_handle_t memory_pools_handle)
|
||||
{
|
||||
static inline memory_pools_t *memory_pools_from_handler (memory_pools_handle_t memory_pools_handle) {
|
||||
memory_pools_t *memory_pools;
|
||||
|
||||
/* Recover memory_pools */
|
||||
memory_pools = (memory_pools_t *) memory_pools_handle;
|
||||
/* Sanity check on passed handle */
|
||||
AssertError (memory_pools->start_mark == POOLS_START_MARK, memory_pools = NULL,
|
||||
"Handle %p is not a valid memory pools handle, start mark is missing!\n", memory_pools_handle);
|
||||
|
||||
return (memory_pools);
|
||||
}
|
||||
|
||||
static inline memory_pool_item_t *memory_pool_item_from_handler (memory_pool_item_handle_t memory_pool_item_handle)
|
||||
{
|
||||
static inline memory_pool_item_t *memory_pool_item_from_handler (memory_pool_item_handle_t memory_pool_item_handle) {
|
||||
void *address;
|
||||
memory_pool_item_t *memory_pool_item;
|
||||
|
||||
/* Recover memory_pools */
|
||||
address = memory_pool_item_handle - sizeof(memory_pool_item_start_t);
|
||||
memory_pool_item = (memory_pool_item_t *) address;
|
||||
|
||||
/* Sanity check on passed handle */
|
||||
AssertError (memory_pool_item->start.start_mark == POOL_ITEM_START_MARK, memory_pool_item = NULL,
|
||||
"Handle %p is not a valid memory pool item handle, start mark is missing!\n", memory_pool_item);
|
||||
|
||||
return (memory_pool_item);
|
||||
}
|
||||
|
||||
static inline memory_pool_item_t *memory_pool_item_from_index (memory_pool_t *memory_pool, items_group_index_t index)
|
||||
{
|
||||
static inline memory_pool_item_t *memory_pool_item_from_index (memory_pool_t *memory_pool, items_group_index_t index) {
|
||||
void *address;
|
||||
|
||||
address = (void *) memory_pool->items;
|
||||
address += index * memory_pool->pool_item_size;
|
||||
|
||||
return (address);
|
||||
}
|
||||
|
||||
/*------------------------------------------------------------------------------*/
|
||||
memory_pools_handle_t memory_pools_create (uint32_t pools_number)
|
||||
{
|
||||
memory_pools_handle_t memory_pools_create (uint32_t pools_number) {
|
||||
memory_pools_t *memory_pools;
|
||||
pool_id_t pool;
|
||||
|
||||
AssertFatal (pools_number <= MAX_POOLS_NUMBER, "Too many memory pools requested (%d/%d)!\n", pools_number, MAX_POOLS_NUMBER); /* Limit to a reasonable number of pools */
|
||||
|
||||
/* Allocate memory_pools */
|
||||
memory_pools = malloc (sizeof(memory_pools_t));
|
||||
AssertFatal (memory_pools != NULL, "Memory pools structure allocation failed!\n");
|
||||
|
||||
/* Initialize memory_pools */
|
||||
{
|
||||
memory_pools->start_mark = POOLS_START_MARK;
|
||||
memory_pools->pools_number = pools_number;
|
||||
memory_pools->pools_defined = 0;
|
||||
|
||||
/* Allocate pools */
|
||||
memory_pools->pools = calloc (pools_number, sizeof(memory_pool_t));
|
||||
AssertFatal (memory_pools->pools != NULL, "Memory pools allocation failed!\n");
|
||||
@@ -282,12 +256,10 @@ memory_pools_handle_t memory_pools_create (uint32_t pools_number)
|
||||
memory_pools->pools[pool].start_mark = POOL_START_MARK;
|
||||
}
|
||||
}
|
||||
|
||||
return ((memory_pools_handle_t) memory_pools);
|
||||
}
|
||||
|
||||
char *memory_pools_statistics(memory_pools_handle_t memory_pools_handle)
|
||||
{
|
||||
char *memory_pools_statistics(memory_pools_handle_t memory_pools_handle) {
|
||||
memory_pools_t *memory_pools;
|
||||
pool_id_t pool;
|
||||
char *statistics;
|
||||
@@ -296,13 +268,10 @@ char *memory_pools_statistics(memory_pools_handle_t memory_pools_handle)
|
||||
uint32_t allocated_pools_memory = 0;
|
||||
items_group_t *items_group;
|
||||
uint32_t pool_items_size;
|
||||
|
||||
/* Recover memory_pools */
|
||||
memory_pools = memory_pools_from_handler (memory_pools_handle);
|
||||
AssertFatal (memory_pools != NULL, "Failed to retrieve memory pool for handle %p!\n", memory_pools_handle);
|
||||
|
||||
statistics = malloc(memory_pools->pools_defined * 200);
|
||||
|
||||
printed_chars = sprintf (&statistics[0], "Pool: size, number, minimum, free, address space and memory used in Kbytes\n");
|
||||
|
||||
for (pool = 0; pool < memory_pools->pools_defined; pool++) {
|
||||
@@ -321,32 +290,25 @@ char *memory_pools_statistics(memory_pools_handle_t memory_pools_handle)
|
||||
}
|
||||
|
||||
printed_chars = sprintf (&statistics[printed_chars], "Pools memory %u Kbytes\n", allocated_pools_memory / (1024));
|
||||
|
||||
return (statistics);
|
||||
}
|
||||
|
||||
int memory_pools_add_pool (memory_pools_handle_t memory_pools_handle, uint32_t pool_items_number, uint32_t pool_item_size)
|
||||
{
|
||||
int memory_pools_add_pool (memory_pools_handle_t memory_pools_handle, uint32_t pool_items_number, uint32_t pool_item_size) {
|
||||
memory_pools_t *memory_pools;
|
||||
memory_pool_t *memory_pool;
|
||||
pool_id_t pool;
|
||||
items_group_index_t item_index;
|
||||
memory_pool_item_t *memory_pool_item;
|
||||
|
||||
AssertFatal (pool_items_number <= MAX_POOL_ITEMS_NUMBER, "Too many items for a memory pool (%u/%d)!\n", pool_items_number, MAX_POOL_ITEMS_NUMBER); /* Limit to a reasonable number of items */
|
||||
AssertFatal (pool_item_size <= MAX_POOL_ITEM_SIZE, "Item size is too big for memory pool items (%u/%d)!\n", pool_item_size, MAX_POOL_ITEM_SIZE); /* Limit to a reasonable item size */
|
||||
|
||||
/* Recover memory_pools */
|
||||
memory_pools = memory_pools_from_handler (memory_pools_handle);
|
||||
AssertFatal (memory_pools != NULL, "Failed to retrieve memory pool for handle %p!\n", memory_pools_handle);
|
||||
|
||||
/* Check number of already created pools */
|
||||
AssertFatal (memory_pools->pools_defined < memory_pools->pools_number, "Can not allocate more memory pool (%d)!\n", memory_pools->pools_number);
|
||||
|
||||
/* Select pool */
|
||||
pool = memory_pools->pools_defined;
|
||||
memory_pool = &memory_pools->pools[pool];
|
||||
|
||||
/* Initialize pool */
|
||||
{
|
||||
memory_pool->pool_id = pool;
|
||||
@@ -357,7 +319,6 @@ int memory_pools_add_pool (memory_pools_handle_t memory_pools_handle, uint32_t p
|
||||
memory_pool->items_group_free.minimum = pool_items_number;
|
||||
memory_pool->items_group_free.positions.ind.put = pool_items_number;
|
||||
memory_pool->items_group_free.positions.ind.get = 0;
|
||||
|
||||
/* Allocate free indexes */
|
||||
memory_pool->items_group_free.indexes = malloc(memory_pool->items_group_free.number_plus_one * sizeof(items_group_index_t));
|
||||
AssertFatal (memory_pool->items_group_free.indexes != NULL, "Memory pool indexes allocation failed!\n");
|
||||
@@ -369,7 +330,6 @@ int memory_pools_add_pool (memory_pools_handle_t memory_pools_handle, uint32_t p
|
||||
|
||||
/* Last index is not allocated */
|
||||
memory_pool->items_group_free.indexes[item_index] = ITEMS_GROUP_INDEX_INVALID;
|
||||
|
||||
/* Allocate items */
|
||||
memory_pool->items = calloc (pool_items_number, memory_pool->pool_item_size);
|
||||
AssertFatal (memory_pool->items != NULL, "Memory pool items allocation failed!\n");
|
||||
@@ -383,20 +343,16 @@ int memory_pools_add_pool (memory_pools_handle_t memory_pools_handle, uint32_t p
|
||||
memory_pool_item->data[memory_pool->item_data_number] = POOL_ITEM_END_MARK;
|
||||
}
|
||||
}
|
||||
|
||||
memory_pools->pools_defined ++;
|
||||
|
||||
return (0);
|
||||
}
|
||||
|
||||
memory_pool_item_handle_t memory_pools_allocate (memory_pools_handle_t memory_pools_handle, uint32_t item_size, uint16_t info_0, uint16_t info_1)
|
||||
{
|
||||
memory_pool_item_handle_t memory_pools_allocate (memory_pools_handle_t memory_pools_handle, uint32_t item_size, uint16_t info_0, uint16_t info_1) {
|
||||
memory_pools_t *memory_pools;
|
||||
memory_pool_item_t *memory_pool_item;
|
||||
memory_pool_item_handle_t memory_pool_item_handle = NULL;
|
||||
pool_id_t pool;
|
||||
items_group_index_t item_index = ITEMS_GROUP_INDEX_INVALID;
|
||||
|
||||
/* Recover memory_pools */
|
||||
memory_pools = memory_pools_from_handler (memory_pools_handle);
|
||||
AssertError (memory_pools != NULL, {}, "Failed to retrieve memory pool for handle %p!\n", memory_pools_handle);
|
||||
@@ -424,12 +380,10 @@ memory_pool_item_handle_t memory_pools_allocate (memory_pools_handle_t memory_po
|
||||
/* Sanity check on item status, must be free */
|
||||
AssertFatal (memory_pool_item->start.item_status == ITEM_STATUS_FREE, "Item status is not set to free (%d) in pool %u, item %d!\n",
|
||||
memory_pool_item->start.item_status, pool, item_index);
|
||||
|
||||
memory_pool_item->start.item_status = ITEM_STATUS_ALLOCATED;
|
||||
memory_pool_item->start.info[0] = info_0;
|
||||
memory_pool_item->start.info[1] = info_1;
|
||||
memory_pool_item_handle = memory_pool_item->data;
|
||||
|
||||
MP_DEBUG(" Alloc [%2u][%6d]{%6d}, %3u %3u, %6u, %p, %p, %p\n",
|
||||
pool, item_index,
|
||||
items_group_free_items (&memory_pools->pools[pool].items_group_free),
|
||||
@@ -445,8 +399,7 @@ memory_pool_item_handle_t memory_pools_allocate (memory_pools_handle_t memory_po
|
||||
return memory_pool_item_handle;
|
||||
}
|
||||
|
||||
int memory_pools_free (memory_pools_handle_t memory_pools_handle, memory_pool_item_handle_t memory_pool_item_handle, uint16_t info_0)
|
||||
{
|
||||
int memory_pools_free (memory_pools_handle_t memory_pools_handle, memory_pool_item_handle_t memory_pool_item_handle, uint16_t info_0) {
|
||||
memory_pools_t *memory_pools;
|
||||
memory_pool_item_t *memory_pool_item;
|
||||
pool_id_t pool;
|
||||
@@ -455,36 +408,29 @@ int memory_pools_free (memory_pools_handle_t memory_pools_handle, memory_pool_it
|
||||
uint32_t pool_item_size;
|
||||
uint16_t info_1;
|
||||
int result;
|
||||
|
||||
/* Recover memory_pools */
|
||||
memory_pools = memory_pools_from_handler (memory_pools_handle);
|
||||
AssertError (memory_pools != NULL, return (EXIT_FAILURE), "Failed to retrieve memory pools for handle %p!\n", memory_pools_handle);
|
||||
|
||||
/* Recover memory pool item */
|
||||
memory_pool_item = memory_pool_item_from_handler (memory_pool_item_handle);
|
||||
AssertError (memory_pool_item != NULL, return (EXIT_FAILURE), "Failed to retrieve memory pool item for handle %p!\n", memory_pool_item_handle);
|
||||
|
||||
info_1 = memory_pool_item->start.info[1];
|
||||
|
||||
/* Recover pool index */
|
||||
pool = memory_pool_item->start.pool_id;
|
||||
AssertFatal (pool < memory_pools->pools_defined, "Pool index is invalid (%u/%u)!\n", pool, memory_pools->pools_defined);
|
||||
|
||||
item_size = memory_pools->pools[pool].item_data_number;
|
||||
pool_item_size = memory_pools->pools[pool].pool_item_size;
|
||||
item_index = (((void *) memory_pool_item) - ((void *) memory_pools->pools[pool].items)) / pool_item_size;
|
||||
|
||||
MP_DEBUG(" Free [%2u][%6d]{%6d}, %3u %3u, %p, %p, %p, %u\n",
|
||||
pool, item_index,
|
||||
items_group_free_items (&memory_pools->pools[pool].items_group_free),
|
||||
memory_pool_item->start.info[0], info_1,
|
||||
memory_pool_item_handle, memory_pool_item,
|
||||
memory_pools->pools[pool].items, ((uint32_t) (item_size * sizeof(memory_pool_data_t))));
|
||||
|
||||
/* Sanity check on calculated item index */
|
||||
AssertFatal (memory_pool_item == memory_pool_item_from_index(&memory_pools->pools[pool], item_index),
|
||||
"Incorrect memory pool item address (%p, %p) for pool %u, item %d!\n",
|
||||
memory_pool_item, memory_pool_item_from_index(&memory_pools->pools[pool], item_index), pool, item_index);
|
||||
memory_pool_item,(void *)memory_pool_item_from_index(&memory_pools->pools[pool], item_index), pool, item_index);
|
||||
/* Sanity check on end marker, must still be present (no write overflow) */
|
||||
AssertFatal (memory_pool_item->data[item_size] == POOL_ITEM_END_MARK,
|
||||
"Memory pool item is corrupted, end mark is not present for pool %u, item %d!\n", pool, item_index);
|
||||
@@ -492,31 +438,23 @@ int memory_pools_free (memory_pools_handle_t memory_pools_handle, memory_pool_it
|
||||
AssertFatal (memory_pool_item->start.item_status == ITEM_STATUS_ALLOCATED,
|
||||
"Trying to free a non allocated (%x) memory pool item (pool %u, item %d)!\n",
|
||||
memory_pool_item->start.item_status, pool, item_index);
|
||||
|
||||
memory_pool_item->start.item_status = ITEM_STATUS_FREE;
|
||||
|
||||
result = items_group_put_free_item(&memory_pools->pools[pool].items_group_free, item_index);
|
||||
|
||||
AssertError (result == EXIT_SUCCESS, {}, "Failed to free memory pool item (pool %u, item %d)!\n", pool, item_index);
|
||||
|
||||
return (result);
|
||||
}
|
||||
|
||||
void memory_pools_set_info (memory_pools_handle_t memory_pools_handle, memory_pool_item_handle_t memory_pool_item_handle, int index, uint16_t info)
|
||||
{
|
||||
void memory_pools_set_info (memory_pools_handle_t memory_pools_handle, memory_pool_item_handle_t memory_pool_item_handle, int index, uint16_t info) {
|
||||
memory_pools_t *memory_pools;
|
||||
memory_pool_item_t *memory_pool_item;
|
||||
pool_id_t pool;
|
||||
items_group_index_t item_index;
|
||||
uint32_t item_size;
|
||||
uint32_t pool_item_size;
|
||||
|
||||
AssertFatal (index < MEMORY_POOL_ITEM_INFO_NUMBER, "Incorrect info index (%d/%d)!\n", index, MEMORY_POOL_ITEM_INFO_NUMBER);
|
||||
|
||||
/* Recover memory pool item */
|
||||
memory_pool_item = memory_pool_item_from_handler (memory_pool_item_handle);
|
||||
AssertFatal (memory_pool_item != NULL, "Failed to retrieve memory pool item for handle %p!\n", memory_pool_item_handle);
|
||||
|
||||
/* Set info[1] */
|
||||
memory_pool_item->start.info[index] = info;
|
||||
|
||||
@@ -525,26 +463,22 @@ void memory_pools_set_info (memory_pools_handle_t memory_pools_handle, memory_po
|
||||
/* Recover memory_pools */
|
||||
memory_pools = memory_pools_from_handler (memory_pools_handle);
|
||||
AssertFatal (memory_pools != NULL, "Failed to retrieve memory pool for handle %p!\n", memory_pools_handle);
|
||||
|
||||
/* Recover pool index */
|
||||
pool = memory_pool_item->start.pool_id;
|
||||
AssertFatal (pool < memory_pools->pools_defined, "Pool index is invalid (%u/%u)!\n", pool, memory_pools->pools_defined);
|
||||
|
||||
item_size = memory_pools->pools[pool].item_data_number;
|
||||
pool_item_size = memory_pools->pools[pool].pool_item_size;
|
||||
item_index = (((void *) memory_pool_item) - ((void *) memory_pools->pools[pool].items)) / pool_item_size;
|
||||
|
||||
MP_DEBUG(" Info [%2u][%6d]{%6d}, %3u %3u, %p, %p, %p, %u\n",
|
||||
pool, item_index,
|
||||
items_group_free_items (&memory_pools->pools[pool].items_group_free),
|
||||
memory_pool_item->start.info[0], memory_pool_item->start.info[1],
|
||||
memory_pool_item_handle, memory_pool_item,
|
||||
memory_pools->pools[pool].items, ((uint32_t) (item_size * sizeof(memory_pool_data_t))));
|
||||
|
||||
/* Sanity check on calculated item index */
|
||||
AssertFatal (memory_pool_item == memory_pool_item_from_index(&memory_pools->pools[pool], item_index),
|
||||
"Incorrect memory pool item address (%p, %p) for pool %u, item %d!\n",
|
||||
memory_pool_item, memory_pool_item_from_index(&memory_pools->pools[pool], item_index), pool, item_index);
|
||||
memory_pool_item, (void *)memory_pool_item_from_index(&memory_pools->pools[pool], item_index), pool, item_index);
|
||||
/* Sanity check on end marker, must still be present (no write overflow) */
|
||||
AssertFatal (memory_pool_item->data[item_size] == POOL_ITEM_END_MARK,
|
||||
"Memory pool item is corrupted, end mark is not present for pool %u, item %d!\n", pool, item_index);
|
||||
|
||||
@@ -77,17 +77,17 @@ paramdef_t telnetoptions[] = {
|
||||
/* configuration parameters for telnet utility */
|
||||
/* optname helpstr paramflags XXXptr defXXXval type numelt */
|
||||
/*--------------------------------------------------------------------------------------------------------------------------------------------------------------------*/
|
||||
{"listenaddr", "<listen ip address>\n", 0, uptr:&telnetparams.listenaddr, defstrval:"0.0.0.0", TYPE_IPV4ADDR, 0 },
|
||||
{"listenport", "<local port>\n", 0, uptr:&(telnetparams.listenport), defuintval:9090, TYPE_UINT, 0 },
|
||||
{"priority", "<scheduling policy (0-99)\n", 0, iptr:&telnetparams.priority, defuintval:0, TYPE_INT, 0 },
|
||||
{"debug", "<debug level>\n", 0, uptr:NULL, defuintval:0, TYPE_UINT, 0 },
|
||||
{"loopcount", "<loop command iterations>\n", 0, uptr:&(telnetparams.loopcount), defuintval:10, TYPE_UINT, 0 },
|
||||
{"loopdelay", "<loop command delay (ms)>\n", 0, uptr:&(telnetparams.loopdelay), defuintval:5000, TYPE_UINT, 0 },
|
||||
{"histfile", "<history file name>\n", PARAMFLAG_NOFREE, strptr:&(telnetparams.histfile), defstrval:"oaitelnet.history", TYPE_STRING, 0 },
|
||||
{"histsize", "<history sizes>\n", 0, iptr:&(telnetparams.histsize), defuintval:50, TYPE_INT, 0 },
|
||||
{"phypbsize", "<phy dump buff size (bytes)>\n",0, uptr:&(telnetparams.phyprntbuff_size),defuintval:65000, TYPE_UINT, 0 },
|
||||
{"staticmod", "<static modules selection>\n", 0, strlistptr:NULL, defstrlistval:telnet_defstatmod,TYPE_STRINGLIST,(sizeof(telnet_defstatmod)/sizeof(char *))},
|
||||
{"shrmod", "<dynamic modules selection>\n", 0, strlistptr:NULL, defstrlistval:NULL,TYPE_STRINGLIST,0 }
|
||||
{"listenaddr", "<listen ip address>", 0, uptr:&telnetparams.listenaddr, defstrval:"0.0.0.0", TYPE_IPV4ADDR, 0 },
|
||||
{"listenport", "<local port>", 0, uptr:&(telnetparams.listenport), defuintval:9090, TYPE_UINT, 0 },
|
||||
{"priority", "<scheduling policy (0-99)", 0, iptr:&telnetparams.priority, defuintval:0, TYPE_INT, 0 },
|
||||
{"debug", "<debug level>", 0, uptr:NULL, defuintval:0, TYPE_UINT, 0 },
|
||||
{"loopcount", "<loop command iterations>", 0, uptr:&(telnetparams.loopcount), defuintval:10, TYPE_UINT, 0 },
|
||||
{"loopdelay", "<loop command delay (ms)>", 0, uptr:&(telnetparams.loopdelay), defuintval:5000, TYPE_UINT, 0 },
|
||||
{"histfile", "<history file name>", PARAMFLAG_NOFREE, strptr:&(telnetparams.histfile), defstrval:"oaitelnet.history", TYPE_STRING, 0 },
|
||||
{"histsize", "<history sizes>", 0, iptr:&(telnetparams.histsize), defuintval:50, TYPE_INT, 0 },
|
||||
{"phypbsize", "<phy dump buff size (bytes)>",0, uptr:&(telnetparams.phyprntbuff_size),defuintval:65000, TYPE_UINT, 0 },
|
||||
{"staticmod", "<static modules selection>", 0, strlistptr:NULL, defstrlistval:telnet_defstatmod,TYPE_STRINGLIST,(sizeof(telnet_defstatmod)/sizeof(char *))},
|
||||
{"shrmod", "<dynamic modules selection>", 0, strlistptr:NULL, defstrlistval:NULL,TYPE_STRINGLIST,0 }
|
||||
};
|
||||
|
||||
int get_phybsize(void) {
|
||||
@@ -355,7 +355,8 @@ int setgetvar(int moduleindex,char getorset,char *params) {
|
||||
char varname[TELNET_CMD_MAXSIZE];
|
||||
char *varval=NULL;
|
||||
memset(varname,0,sizeof(varname));
|
||||
n = sscanf(params,"%s %ms",varname,&varval);
|
||||
n = sscanf(params,"%19s %ms",varname,&varval);
|
||||
|
||||
|
||||
for ( i=0 ; telnetparams.CmdParsers[moduleindex].var[i].varvalptr != NULL ; i++) {
|
||||
if ( strncasecmp(telnetparams.CmdParsers[moduleindex].var[i].varname,varname,strlen(telnetparams.CmdParsers[moduleindex].var[i].varname)) == 0) {
|
||||
@@ -475,7 +476,8 @@ int process_command(char *buf) {
|
||||
memset(cmdb,0,sizeof(cmdb));
|
||||
bufbck=strdup(buf);
|
||||
rt=CMDSTATUS_NOTFOUND;
|
||||
j = sscanf(buf,"%9s %9s %[^\t\n]",modulename,cmd,cmdb);
|
||||
j = sscanf(buf,"%9s %9s %2000[^\t\n]",modulename,cmd,cmdb);
|
||||
|
||||
|
||||
if (telnetparams.telnetdbg > 0)
|
||||
printf("process_command: %i words, module=%s cmd=%s, parameters= %s\n",j,modulename,cmd,cmdb);
|
||||
|
||||
@@ -29,7 +29,7 @@
|
||||
* \note
|
||||
* \warning
|
||||
*/
|
||||
#define _GNU_SOURCE
|
||||
#define _GNU_SOURCE
|
||||
#include <string.h>
|
||||
#include <pthread.h>
|
||||
|
||||
@@ -39,104 +39,88 @@
|
||||
#define TELNETSRV_PHYCMD_MAIN
|
||||
#include "telnetsrv_phycmd.h"
|
||||
char *prnbuff;
|
||||
extern int dump_eNB_stats(PHY_VARS_eNB *eNB, char* buffer, int length);
|
||||
extern int dump_eNB_l2_stats(char *buffer, int length);
|
||||
|
||||
void init_phytelnet(void)
|
||||
{
|
||||
prnbuff=malloc(get_phybsize() );
|
||||
if (prnbuff == NULL)
|
||||
{
|
||||
fprintf(stderr,"Error %s on malloc in init_phytelnet()\n",strerror(errno));
|
||||
}
|
||||
void init_phytelnet(void) {
|
||||
prnbuff=malloc(get_phybsize() );
|
||||
|
||||
if (prnbuff == NULL) {
|
||||
fprintf(stderr,"Error %s on malloc in init_phytelnet()\n",strerror(errno));
|
||||
}
|
||||
}
|
||||
|
||||
void display_uestatshead( telnet_printfunc_t prnt)
|
||||
{
|
||||
prnt("cc ue rnti Dmcs Umcs tao tau Dbr Dtb \n");
|
||||
void display_uestatshead( telnet_printfunc_t prnt) {
|
||||
prnt("cc ue rnti Dmcs Umcs tao tau Dbr Dtb \n");
|
||||
}
|
||||
|
||||
void dump_uestats(int debug, telnet_printfunc_t prnt, uint8_t prntflag)
|
||||
{
|
||||
void dump_uestats(int debug, telnet_printfunc_t prnt, uint8_t prntflag) {
|
||||
int p;
|
||||
prnbuff=malloc(20480);
|
||||
p=dump_eNB_l2_stats( prnbuff, 20480);
|
||||
|
||||
int p;
|
||||
|
||||
p=dump_eNB_l2_stats( prnbuff, 0);
|
||||
if(prntflag>=1)
|
||||
prnt("%s\n",prnbuff);
|
||||
if(debug>=1)
|
||||
prnt("%i bytes printed\n",p);
|
||||
if(prntflag>=1)
|
||||
prnt("%s\n",prnbuff);
|
||||
|
||||
if(debug>=1)
|
||||
prnt("%i bytes printed\n",p);
|
||||
|
||||
free(prnbuff);
|
||||
}
|
||||
|
||||
void display_uestats(int debug, telnet_printfunc_t prnt, int ue)
|
||||
{
|
||||
for (int cc=0; cc<1 ; cc++)
|
||||
{
|
||||
|
||||
|
||||
}
|
||||
void display_uestats(int debug, telnet_printfunc_t prnt, int ue) {
|
||||
for (int cc=0; cc<1 ; cc++) {
|
||||
}
|
||||
}
|
||||
|
||||
void display_phycounters(char *buf, int debug, telnet_printfunc_t prnt)
|
||||
{
|
||||
prnt(" DLSCH kb DLSCH kb/s\n");
|
||||
|
||||
dump_uestats(debug, prnt,0);
|
||||
|
||||
void display_phycounters(char *buf, int debug, telnet_printfunc_t prnt) {
|
||||
prnt(" DLSCH kb DLSCH kb/s\n");
|
||||
dump_uestats(debug, prnt,0);
|
||||
}
|
||||
|
||||
int dump_phyvars(char *buf, int debug, telnet_printfunc_t prnt)
|
||||
{
|
||||
|
||||
|
||||
int dump_phyvars(char *buf, int debug, telnet_printfunc_t prnt) {
|
||||
if (debug > 0)
|
||||
prnt("phy interface module received %s\n",buf);
|
||||
|
||||
if (debug > 0)
|
||||
prnt("phy interface module received %s\n",buf);
|
||||
if (strcasestr(buf,"phycnt") != NULL)
|
||||
{
|
||||
display_phycounters(buf, debug, prnt);
|
||||
}
|
||||
if (strcasestr(buf,"uestat") != NULL)
|
||||
{
|
||||
char *cptr=strcasestr(buf+sizeof("uestat"),"UE");
|
||||
display_uestatshead(prnt);
|
||||
if (cptr != NULL)
|
||||
{
|
||||
int ueidx = strtol( cptr+sizeof("UE"), NULL, 10);
|
||||
if (ueidx < NUMBER_OF_UE_MAX && ueidx >= 0)
|
||||
{
|
||||
display_uestats(debug, prnt,ueidx);
|
||||
}
|
||||
} /* if cptr != NULL */
|
||||
else
|
||||
{
|
||||
for (int ue=0; ue<NUMBER_OF_UE_MAX ; ue++)
|
||||
{
|
||||
display_uestats(debug, prnt,ue);
|
||||
}
|
||||
} /* else cptr != NULL */
|
||||
} /* uestat */
|
||||
if (strcasestr(buf,"uedump") != NULL)
|
||||
{
|
||||
dump_uestats(debug, prnt,1);
|
||||
}
|
||||
return 0;
|
||||
if (strcasestr(buf,"phycnt") != NULL) {
|
||||
display_phycounters(buf, debug, prnt);
|
||||
}
|
||||
|
||||
if (strcasestr(buf,"uestat") != NULL) {
|
||||
char *cptr=strcasestr(buf+sizeof("uestat"),"UE");
|
||||
display_uestatshead(prnt);
|
||||
|
||||
if (cptr != NULL) {
|
||||
int ueidx = strtol( cptr+sizeof("UE"), NULL, 10);
|
||||
|
||||
if (ueidx < NUMBER_OF_UE_MAX && ueidx >= 0) {
|
||||
display_uestats(debug, prnt,ueidx);
|
||||
}
|
||||
} /* if cptr != NULL */
|
||||
else {
|
||||
for (int ue=0; ue<NUMBER_OF_UE_MAX ; ue++) {
|
||||
display_uestats(debug, prnt,ue);
|
||||
}
|
||||
} /* else cptr != NULL */
|
||||
} /* uestat */
|
||||
|
||||
if (strcasestr(buf,"uedump") != NULL) {
|
||||
dump_uestats(debug, prnt,1);
|
||||
}
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
|
||||
|
||||
telnetshell_cmddef_t phy_cmdarray[] = {
|
||||
{"disp","[phycnt,uedump,uestat UE<x>]", dump_phyvars},
|
||||
{"disp","[phycnt,uedump,uestat UE<x>]", dump_phyvars},
|
||||
|
||||
{"","",NULL},
|
||||
{"","",NULL},
|
||||
};
|
||||
|
||||
|
||||
/*-------------------------------------------------------------------------------------*/
|
||||
void add_phy_cmds(void)
|
||||
{
|
||||
|
||||
init_phytelnet();
|
||||
add_telnetcmd("phy", phy_vardef, phy_cmdarray);
|
||||
void add_phy_cmds(void) {
|
||||
init_phytelnet();
|
||||
add_telnetcmd("phy", phy_vardef, phy_cmdarray);
|
||||
}
|
||||
|
||||
+169
-333
File diff suppressed because it is too large
Load Diff
+122
-152
@@ -34,11 +34,11 @@
|
||||
#include "log_extern.h"
|
||||
#include "assertions.h"
|
||||
#if defined(ENABLE_ITTI)
|
||||
# include "intertask_interface.h"
|
||||
# if defined(ENABLE_USE_MME)
|
||||
# include "s1ap_eNB.h"
|
||||
# include "sctp_eNB_task.h"
|
||||
# endif
|
||||
#include "intertask_interface.h"
|
||||
#if defined(ENABLE_USE_MME)
|
||||
#include "s1ap_eNB.h"
|
||||
#include "sctp_eNB_task.h"
|
||||
#endif
|
||||
#endif
|
||||
#include "SystemInformationBlockType2.h"
|
||||
|
||||
@@ -56,11 +56,10 @@
|
||||
void RCconfig_NbIoTL1(void) {
|
||||
paramdef_t NbIoT_L1_Params[] = L1PARAMS_DESC;
|
||||
paramlist_def_t NbIoT_L1_ParamList = {NBIOT_L1LIST_CONFIG_STRING,NULL,0};
|
||||
/* No component carrier for NbIoT, ignore number of CC */
|
||||
// NbIoT_L1_Params[L1_CC_IDX ].paramflags = PARAMFLAG_DONOTREAD;
|
||||
config_getlist( &NbIoT_L1_ParamList,NbIoT_L1_Params,sizeof(NbIoT_L1_Params)/sizeof(paramdef_t), NULL);
|
||||
|
||||
/* No component carrier for NbIoT, ignore number of CC */
|
||||
// NbIoT_L1_Params[L1_CC_IDX ].paramflags = PARAMFLAG_DONOTREAD;
|
||||
|
||||
config_getlist( &NbIoT_L1_ParamList,NbIoT_L1_Params,sizeof(NbIoT_L1_Params)/sizeof(paramdef_t), NULL);
|
||||
if (NbIoT_L1_ParamList.numelt > 0) {
|
||||
if (RC.L1_NB_IoT == NULL) {
|
||||
RC.L1_NB_IoT = (PHY_VARS_eNB_NB_IoT **)malloc(RC.nb_nb_iot_L1_inst*sizeof(PHY_VARS_eNB_NB_IoT *));
|
||||
@@ -68,219 +67,190 @@ void RCconfig_NbIoTL1(void) {
|
||||
memset(RC.L1_NB_IoT,0,RC.nb_nb_iot_L1_inst*sizeof(PHY_VARS_eNB_NB_IoT *));
|
||||
}
|
||||
|
||||
|
||||
for(int j = 0; j <NbIoT_L1_ParamList.numelt ; j++) {
|
||||
for(int j = 0; j <NbIoT_L1_ParamList.numelt ; j++) {
|
||||
if (RC.L1_NB_IoT[j] == NULL) {
|
||||
RC.L1_NB_IoT[j] = (PHY_VARS_eNB_NB_IoT *)malloc(sizeof(PHY_VARS_eNB_NB_IoT));
|
||||
LOG_I(PHY,"RC.L1_NB_IoT[%d] = %p\n",j,RC.L1_NB_IoT[j]);
|
||||
memset(RC.L1_NB_IoT[j],0,sizeof(PHY_VARS_eNB_NB_IoT));
|
||||
RC.L1_NB_IoT[j] = (PHY_VARS_eNB_NB_IoT *)malloc(sizeof(PHY_VARS_eNB_NB_IoT));
|
||||
LOG_I(PHY,"RC.L1_NB_IoT[%d] = %p\n",j,RC.L1_NB_IoT[j]);
|
||||
memset(RC.L1_NB_IoT[j],0,sizeof(PHY_VARS_eNB_NB_IoT));
|
||||
}
|
||||
if (strcmp(*(NbIoT_L1_ParamList.paramarray[j][L1_TRANSPORT_N_PREFERENCE_IDX].strptr), "local_mac") == 0) {
|
||||
|
||||
if (strcmp(*(NbIoT_L1_ParamList.paramarray[j][L1_TRANSPORT_N_PREFERENCE_IDX].strptr), "local_mac") == 0) {
|
||||
} else if (strcmp(*(NbIoT_L1_ParamList.paramarray[j][L1_TRANSPORT_N_PREFERENCE_IDX].strptr), "nfapi") == 0) {
|
||||
RC.L1_NB_IoT[j]->eth_params_n.local_if_name = strdup(*(NbIoT_L1_ParamList.paramarray[j][L1_LOCAL_N_IF_NAME_IDX].strptr));
|
||||
RC.L1_NB_IoT[j]->eth_params_n.my_addr = strdup(*(NbIoT_L1_ParamList.paramarray[j][L1_LOCAL_N_ADDRESS_IDX].strptr));
|
||||
RC.L1_NB_IoT[j]->eth_params_n.remote_addr = strdup(*(NbIoT_L1_ParamList.paramarray[j][L1_REMOTE_N_ADDRESS_IDX].strptr));
|
||||
RC.L1_NB_IoT[j]->eth_params_n.my_portc = *(NbIoT_L1_ParamList.paramarray[j][L1_LOCAL_N_PORTC_IDX].iptr);
|
||||
RC.L1_NB_IoT[j]->eth_params_n.remote_portc = *(NbIoT_L1_ParamList.paramarray[j][L1_REMOTE_N_PORTC_IDX].iptr);
|
||||
RC.L1_NB_IoT[j]->eth_params_n.my_portd = *(NbIoT_L1_ParamList.paramarray[j][L1_LOCAL_N_PORTD_IDX].iptr);
|
||||
RC.L1_NB_IoT[j]->eth_params_n.remote_portd = *(NbIoT_L1_ParamList.paramarray[j][L1_REMOTE_N_PORTD_IDX].iptr);
|
||||
RC.L1_NB_IoT[j]->eth_params_n.transp_preference = ETH_UDP_MODE;
|
||||
} else { // other midhaul
|
||||
}
|
||||
else if (strcmp(*(NbIoT_L1_ParamList.paramarray[j][L1_TRANSPORT_N_PREFERENCE_IDX].strptr), "nfapi") == 0) {
|
||||
RC.L1_NB_IoT[j]->eth_params_n.local_if_name = strdup(*(NbIoT_L1_ParamList.paramarray[j][L1_LOCAL_N_IF_NAME_IDX].strptr));
|
||||
RC.L1_NB_IoT[j]->eth_params_n.my_addr = strdup(*(NbIoT_L1_ParamList.paramarray[j][L1_LOCAL_N_ADDRESS_IDX].strptr));
|
||||
RC.L1_NB_IoT[j]->eth_params_n.remote_addr = strdup(*(NbIoT_L1_ParamList.paramarray[j][L1_REMOTE_N_ADDRESS_IDX].strptr));
|
||||
RC.L1_NB_IoT[j]->eth_params_n.my_portc = *(NbIoT_L1_ParamList.paramarray[j][L1_LOCAL_N_PORTC_IDX].iptr);
|
||||
RC.L1_NB_IoT[j]->eth_params_n.remote_portc = *(NbIoT_L1_ParamList.paramarray[j][L1_REMOTE_N_PORTC_IDX].iptr);
|
||||
RC.L1_NB_IoT[j]->eth_params_n.my_portd = *(NbIoT_L1_ParamList.paramarray[j][L1_LOCAL_N_PORTD_IDX].iptr);
|
||||
RC.L1_NB_IoT[j]->eth_params_n.remote_portd = *(NbIoT_L1_ParamList.paramarray[j][L1_REMOTE_N_PORTD_IDX].iptr);
|
||||
RC.L1_NB_IoT[j]->eth_params_n.transp_preference = ETH_UDP_MODE;
|
||||
}
|
||||
|
||||
else { // other midhaul
|
||||
}
|
||||
}// j=0..num_inst
|
||||
|
||||
printf("Initializing northbound interface for NB-IoT L1\n");
|
||||
l1_north_init_NB_IoT();
|
||||
} else {
|
||||
LOG_I(PHY,"No " NBIOT_L1LIST_CONFIG_STRING " configuration found");
|
||||
LOG_I(PHY,"No " NBIOT_L1LIST_CONFIG_STRING " configuration found");
|
||||
}
|
||||
}
|
||||
|
||||
void RCconfig_NbIoTmacrlc(void) {
|
||||
|
||||
|
||||
|
||||
paramdef_t NbIoT_MacRLC_Params[] = MACRLCPARAMS_DESC;
|
||||
paramlist_def_t NbIoT_MacRLC_ParamList = {NBIOT_MACRLCLIST_CONFIG_STRING,NULL,0};
|
||||
|
||||
|
||||
/* No component carrier for NbIoT, ignore number of CC */
|
||||
// NbIoT_MacRLC_Params[MACRLC_CC_IDX ].paramflags = PARAMFLAG_DONOTREAD;
|
||||
|
||||
config_getlist( &NbIoT_MacRLC_ParamList,NbIoT_MacRLC_Params,sizeof(NbIoT_MacRLC_Params)/sizeof(paramdef_t), NULL);
|
||||
|
||||
/* No component carrier for NbIoT, ignore number of CC */
|
||||
// NbIoT_MacRLC_Params[MACRLC_CC_IDX ].paramflags = PARAMFLAG_DONOTREAD;
|
||||
config_getlist( &NbIoT_MacRLC_ParamList,NbIoT_MacRLC_Params,sizeof(NbIoT_MacRLC_Params)/sizeof(paramdef_t), NULL);
|
||||
|
||||
if ( NbIoT_MacRLC_ParamList.numelt > 0) {
|
||||
mac_top_init_eNB_NB_IoT();
|
||||
for (int j=0;j<RC.nb_nb_iot_macrlc_inst;j++) {
|
||||
|
||||
for (int j=0; j<RC.nb_nb_iot_macrlc_inst; j++) {
|
||||
if (strcmp(*(NbIoT_MacRLC_ParamList.paramarray[j][MACRLC_TRANSPORT_N_PREFERENCE_IDX].strptr), "local_RRC") == 0) {
|
||||
// check number of instances is same as RRC/PDCP
|
||||
|
||||
// check number of instances is same as RRC/PDCP
|
||||
} else if (strcmp(*(NbIoT_MacRLC_ParamList.paramarray[j][MACRLC_TRANSPORT_N_PREFERENCE_IDX].strptr), "cudu") == 0) {
|
||||
RC.nb_iot_mac[j]->eth_params_n.local_if_name = strdup(*(NbIoT_MacRLC_ParamList.paramarray[j][MACRLC_LOCAL_N_IF_NAME_IDX].strptr));
|
||||
RC.nb_iot_mac[j]->eth_params_n.my_addr = strdup(*(NbIoT_MacRLC_ParamList.paramarray[j][MACRLC_LOCAL_N_ADDRESS_IDX].strptr));
|
||||
RC.nb_iot_mac[j]->eth_params_n.remote_addr = strdup(*(NbIoT_MacRLC_ParamList.paramarray[j][MACRLC_REMOTE_N_ADDRESS_IDX].strptr));
|
||||
RC.nb_iot_mac[j]->eth_params_n.my_portc = *(NbIoT_MacRLC_ParamList.paramarray[j][MACRLC_LOCAL_N_PORTC_IDX].iptr);
|
||||
RC.nb_iot_mac[j]->eth_params_n.remote_portc = *(NbIoT_MacRLC_ParamList.paramarray[j][MACRLC_REMOTE_N_PORTC_IDX].iptr);
|
||||
RC.nb_iot_mac[j]->eth_params_n.my_portd = *(NbIoT_MacRLC_ParamList.paramarray[j][MACRLC_LOCAL_N_PORTD_IDX].iptr);
|
||||
RC.nb_iot_mac[j]->eth_params_n.remote_portd = *(NbIoT_MacRLC_ParamList.paramarray[j][MACRLC_REMOTE_N_PORTD_IDX].iptr);;
|
||||
RC.nb_iot_mac[j]->eth_params_n.transp_preference = ETH_UDP_MODE;
|
||||
RC.nb_iot_mac[j]->eth_params_n.local_if_name = strdup(*(NbIoT_MacRLC_ParamList.paramarray[j][MACRLC_LOCAL_N_IF_NAME_IDX].strptr));
|
||||
RC.nb_iot_mac[j]->eth_params_n.my_addr = strdup(*(NbIoT_MacRLC_ParamList.paramarray[j][MACRLC_LOCAL_N_ADDRESS_IDX].strptr));
|
||||
RC.nb_iot_mac[j]->eth_params_n.remote_addr = strdup(*(NbIoT_MacRLC_ParamList.paramarray[j][MACRLC_REMOTE_N_ADDRESS_IDX].strptr));
|
||||
RC.nb_iot_mac[j]->eth_params_n.my_portc = *(NbIoT_MacRLC_ParamList.paramarray[j][MACRLC_LOCAL_N_PORTC_IDX].iptr);
|
||||
RC.nb_iot_mac[j]->eth_params_n.remote_portc = *(NbIoT_MacRLC_ParamList.paramarray[j][MACRLC_REMOTE_N_PORTC_IDX].iptr);
|
||||
RC.nb_iot_mac[j]->eth_params_n.my_portd = *(NbIoT_MacRLC_ParamList.paramarray[j][MACRLC_LOCAL_N_PORTD_IDX].iptr);
|
||||
RC.nb_iot_mac[j]->eth_params_n.remote_portd = *(NbIoT_MacRLC_ParamList.paramarray[j][MACRLC_REMOTE_N_PORTD_IDX].iptr);;
|
||||
RC.nb_iot_mac[j]->eth_params_n.transp_preference = ETH_UDP_MODE;
|
||||
} else { // other midhaul
|
||||
AssertFatal(1==0,"MACRLC %d: %s unknown northbound midhaul\n",j, *(NbIoT_MacRLC_ParamList.paramarray[j][MACRLC_TRANSPORT_N_PREFERENCE_IDX].strptr));
|
||||
}
|
||||
AssertFatal(1==0,"MACRLC %d: %s unknown northbound midhaul\n",j, *(NbIoT_MacRLC_ParamList.paramarray[j][MACRLC_TRANSPORT_N_PREFERENCE_IDX].strptr));
|
||||
}
|
||||
|
||||
if (strcmp(*(NbIoT_MacRLC_ParamList.paramarray[j][MACRLC_TRANSPORT_S_PREFERENCE_IDX].strptr), "local_L1") == 0) {
|
||||
|
||||
|
||||
} else if (strcmp(*(NbIoT_MacRLC_ParamList.paramarray[j][MACRLC_TRANSPORT_S_PREFERENCE_IDX].strptr), "nfapi") == 0) {
|
||||
RC.nb_iot_mac[j]->eth_params_s.local_if_name = strdup(*(NbIoT_MacRLC_ParamList.paramarray[j][MACRLC_LOCAL_S_IF_NAME_IDX].strptr));
|
||||
RC.nb_iot_mac[j]->eth_params_s.my_addr = strdup(*(NbIoT_MacRLC_ParamList.paramarray[j][MACRLC_LOCAL_S_ADDRESS_IDX].strptr));
|
||||
RC.nb_iot_mac[j]->eth_params_s.remote_addr = strdup(*(NbIoT_MacRLC_ParamList.paramarray[j][MACRLC_REMOTE_S_ADDRESS_IDX].strptr));
|
||||
RC.nb_iot_mac[j]->eth_params_s.my_portc = *(NbIoT_MacRLC_ParamList.paramarray[j][MACRLC_LOCAL_S_PORTC_IDX].iptr);
|
||||
RC.nb_iot_mac[j]->eth_params_s.remote_portc = *(NbIoT_MacRLC_ParamList.paramarray[j][MACRLC_REMOTE_S_PORTC_IDX].iptr);
|
||||
RC.nb_iot_mac[j]->eth_params_s.my_portd = *(NbIoT_MacRLC_ParamList.paramarray[j][MACRLC_LOCAL_S_PORTD_IDX].iptr);
|
||||
RC.nb_iot_mac[j]->eth_params_s.remote_portd = *(NbIoT_MacRLC_ParamList.paramarray[j][MACRLC_REMOTE_S_PORTD_IDX].iptr);
|
||||
RC.nb_iot_mac[j]->eth_params_s.transp_preference = ETH_UDP_MODE;
|
||||
RC.nb_iot_mac[j]->eth_params_s.local_if_name = strdup(*(NbIoT_MacRLC_ParamList.paramarray[j][MACRLC_LOCAL_S_IF_NAME_IDX].strptr));
|
||||
RC.nb_iot_mac[j]->eth_params_s.my_addr = strdup(*(NbIoT_MacRLC_ParamList.paramarray[j][MACRLC_LOCAL_S_ADDRESS_IDX].strptr));
|
||||
RC.nb_iot_mac[j]->eth_params_s.remote_addr = strdup(*(NbIoT_MacRLC_ParamList.paramarray[j][MACRLC_REMOTE_S_ADDRESS_IDX].strptr));
|
||||
RC.nb_iot_mac[j]->eth_params_s.my_portc = *(NbIoT_MacRLC_ParamList.paramarray[j][MACRLC_LOCAL_S_PORTC_IDX].iptr);
|
||||
RC.nb_iot_mac[j]->eth_params_s.remote_portc = *(NbIoT_MacRLC_ParamList.paramarray[j][MACRLC_REMOTE_S_PORTC_IDX].iptr);
|
||||
RC.nb_iot_mac[j]->eth_params_s.my_portd = *(NbIoT_MacRLC_ParamList.paramarray[j][MACRLC_LOCAL_S_PORTD_IDX].iptr);
|
||||
RC.nb_iot_mac[j]->eth_params_s.remote_portd = *(NbIoT_MacRLC_ParamList.paramarray[j][MACRLC_REMOTE_S_PORTD_IDX].iptr);
|
||||
RC.nb_iot_mac[j]->eth_params_s.transp_preference = ETH_UDP_MODE;
|
||||
} else { // other midhaul
|
||||
AssertFatal(1==0,"MACRLC %d: %s unknown southbound midhaul\n",j,*(NbIoT_MacRLC_ParamList.paramarray[j][MACRLC_TRANSPORT_S_PREFERENCE_IDX].strptr));
|
||||
}
|
||||
AssertFatal(1==0,"MACRLC %d: %s unknown southbound midhaul\n",j,*(NbIoT_MacRLC_ParamList.paramarray[j][MACRLC_TRANSPORT_S_PREFERENCE_IDX].strptr));
|
||||
}
|
||||
}// j=0..num_inst */
|
||||
} else {// MacRLC_ParamList.numelt > 0
|
||||
AssertFatal (0,
|
||||
"No " NBIOT_MACRLCLIST_CONFIG_STRING " configuration found");
|
||||
AssertFatal (0,
|
||||
"No " NBIOT_MACRLCLIST_CONFIG_STRING " configuration found");
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
int RCconfig_NbIoTRRC(MessageDef *msg_p, int nbiotrrc_id,eNB_RRC_INST_NB_IoT *nbiotrrc) {
|
||||
|
||||
|
||||
char instprefix[MAX_OPTNAME_SIZE*3 + 32];
|
||||
|
||||
|
||||
checkedparam_t NBIoTCheckParams[] = NBIOT_RRCPARAMS_CHECK_DESC;
|
||||
checkedparam_t NBIoTCheckParams[] = NBIOT_RRCPARAMS_CHECK_DESC_0_14;
|
||||
checkedparam_t NBIoTCheckParamsB[] = NBIOT_RRCPARAMS_CHECK_DESC_15_end;
|
||||
paramdef_t NBIoTParams[] = NBIOTRRCPARAMS_DESC;
|
||||
|
||||
paramdef_t NBIoTPrachParams[] = NBIOTRRC_NPRACH_PARAMS_DESC;
|
||||
checkedparam_t NBIoTPrachCheckParams[] = NBIOT_RRCLIST_NPRACHPARAMSCHECK_DESC;
|
||||
|
||||
paramdef_t NBIoTRRCRefParams[] = NBIOTRRCPARAMS_RRCREF_DESC;
|
||||
|
||||
paramdef_t NBIoTLteCCParams[] = NBIOT_LTECCPARAMS_DESC;
|
||||
checkedparam_t NBIoTLteCCCheckParams[] = NBIOT_LTECCPARAMS_CHECK_DESC;
|
||||
/* map parameter checking array instances to parameter definition array instances */
|
||||
|
||||
/* map parameter checking array instances to parameter definition array instances */
|
||||
for (int i=0; (i<sizeof(NBIoTParams)/sizeof(paramdef_t)) && (i<sizeof(NBIoTCheckParams)/sizeof(checkedparam_t)); i++ ) {
|
||||
NBIoTParams[i].chkPptr = &(NBIoTCheckParams[i]);
|
||||
}
|
||||
for (int i=0; (i<sizeof(NBIoTPrachParams)/sizeof(paramdef_t)) && (i<sizeof(NBIoTPrachCheckParams)/sizeof(checkedparam_t)); i++ ) {
|
||||
NBIoTPrachParams[i].chkPptr = &(NBIoTPrachCheckParams[i]);
|
||||
NBIoTParams[i].chkPptr = &(NBIoTCheckParams[i]);
|
||||
}
|
||||
|
||||
/* brut force itti message fields assignment, to be redesigned with itti replacement */
|
||||
for (int i=0; (i<sizeof(NBIoTParams)/sizeof(paramdef_t)) && (i<sizeof(NBIoTCheckParamsB)/sizeof(checkedparam_t)); i++ ) {
|
||||
NBIoTParams[i+15].chkPptr = &(NBIoTCheckParamsB[i]);
|
||||
}
|
||||
|
||||
for (int i=0; (i<sizeof(NBIoTPrachParams)/sizeof(paramdef_t)) && (i<sizeof(NBIoTPrachCheckParams)/sizeof(checkedparam_t)); i++ ) {
|
||||
NBIoTPrachParams[i].chkPptr = &(NBIoTPrachCheckParams[i]);
|
||||
}
|
||||
|
||||
/* brut force itti message fields assignment, to be redesigned with itti replacement */
|
||||
NBIoTParams[NBIOT_RACH_RARESPONSEWINDOWSIZE_NB_IDX].uptr = (uint32_t *)&(NBIOTRRC_CONFIGURATION_REQ (msg_p).rach_raResponseWindowSize_NB);
|
||||
NBIoTParams[NBIOT_RACH_MACCONTENTIONRESOLUTIONTIMER_NB_IDX].uptr = (uint32_t *)&(NBIOTRRC_CONFIGURATION_REQ (msg_p).rach_macContentionResolutionTimer_NB);
|
||||
NBIoTParams[NBIOT_RACH_POWERRAMPINGSTEP_NB_IDX].uptr = (uint32_t *)&(NBIOTRRC_CONFIGURATION_REQ (msg_p).rach_powerRampingStep_NB);
|
||||
NBIoTParams[NBIOT_RACH_POWERRAMPINGSTEP_NB_IDX].uptr = (uint32_t *)&(NBIOTRRC_CONFIGURATION_REQ (msg_p).rach_powerRampingStep_NB);
|
||||
NBIoTParams[NBIOT_RACH_PREAMBLEINITIALRECEIVEDTARGETPOWER_NB_IDX].uptr = (uint32_t *)&(NBIOTRRC_CONFIGURATION_REQ (msg_p).rach_preambleInitialReceivedTargetPower_NB);
|
||||
NBIoTParams[NBIOT_RACH_PREAMBLETRANSMAX_CE_NB_IDX].uptr = (uint32_t *)&(NBIOTRRC_CONFIGURATION_REQ (msg_p).rach_preambleTransMax_CE_NB);
|
||||
NBIoTParams[NBIOT_BCCH_MODIFICATIONPERIODCOEFF_NB_IDX].uptr = (uint32_t *)&(NBIOTRRC_CONFIGURATION_REQ (msg_p).bcch_modificationPeriodCoeff_NB);
|
||||
NBIoTParams[NBIOT_PCCH_DEFAULTPAGINGCYCLE_NB_IDX].uptr = (uint32_t *)&(NBIOTRRC_CONFIGURATION_REQ (msg_p).pcch_defaultPagingCycle_NB);
|
||||
NBIoTParams[NBIOT_NPRACH_CP_LENGTH_IDX].uptr = (uint32_t *)&(NBIOTRRC_CONFIGURATION_REQ (msg_p).nprach_CP_Length);
|
||||
NBIoTParams[NBIOT_NPRACH_RSRP_RANGE_IDX].uptr = (uint32_t *)&(NBIOTRRC_CONFIGURATION_REQ (msg_p).nprach_rsrp_range);
|
||||
|
||||
|
||||
|
||||
NBIoTParams[NBIOT_RACH_PREAMBLETRANSMAX_CE_NB_IDX].uptr = (uint32_t *)&(NBIOTRRC_CONFIGURATION_REQ (msg_p).rach_preambleTransMax_CE_NB);
|
||||
NBIoTParams[NBIOT_BCCH_MODIFICATIONPERIODCOEFF_NB_IDX].uptr = (uint32_t *)&(NBIOTRRC_CONFIGURATION_REQ (msg_p).bcch_modificationPeriodCoeff_NB);
|
||||
NBIoTParams[NBIOT_PCCH_DEFAULTPAGINGCYCLE_NB_IDX].uptr = (uint32_t *)&(NBIOTRRC_CONFIGURATION_REQ (msg_p).pcch_defaultPagingCycle_NB);
|
||||
NBIoTParams[NBIOT_NPRACH_CP_LENGTH_IDX].uptr = (uint32_t *)&(NBIOTRRC_CONFIGURATION_REQ (msg_p).nprach_CP_Length);
|
||||
NBIoTParams[NBIOT_NPRACH_RSRP_RANGE_IDX].uptr = (uint32_t *)&(NBIOTRRC_CONFIGURATION_REQ (msg_p).nprach_rsrp_range);
|
||||
NBIoTParams[NBIOT_MAXNUMPREAMBLEATTEMPTCE_NB_IDX].uptr = (uint32_t *)&(NBIOTRRC_CONFIGURATION_REQ (msg_p).maxNumPreambleAttemptCE_NB);
|
||||
|
||||
NBIoTParams[NBIOT_NPDSCH_NRS_POWER_IDX].uptr = (uint32_t *)&(NBIOTRRC_CONFIGURATION_REQ (msg_p).npdsch_nrs_Power);
|
||||
NBIoTParams[NBIOT_NPUSCH_ACK_NACK_NUMREPETITIONS_NB_IDX].uptr = (uint32_t *)&(NBIOTRRC_CONFIGURATION_REQ (msg_p). npusch_ack_nack_numRepetitions_NB);
|
||||
NBIoTParams[NBIOT_NPUSCH_SRS_SUBFRAMECONFIG_NB_IDX].uptr = (uint32_t *)&(NBIOTRRC_CONFIGURATION_REQ (msg_p). npusch_srs_SubframeConfig_NB);
|
||||
NBIoTParams[NBIOT_NPUSCH_THREETONE_CYCLICSHIFT_R13_IDX].uptr = (uint32_t *)&(NBIOTRRC_CONFIGURATION_REQ (msg_p).npusch_threeTone_CyclicShift_r13);
|
||||
NBIoTParams[NBIOT_NPDSCH_NRS_POWER_IDX].uptr = (uint32_t *)&(NBIOTRRC_CONFIGURATION_REQ (msg_p).npdsch_nrs_Power);
|
||||
NBIoTParams[NBIOT_NPUSCH_ACK_NACK_NUMREPETITIONS_NB_IDX].uptr = (uint32_t *)&(NBIOTRRC_CONFIGURATION_REQ (msg_p). npusch_ack_nack_numRepetitions_NB);
|
||||
NBIoTParams[NBIOT_NPUSCH_SRS_SUBFRAMECONFIG_NB_IDX].uptr = (uint32_t *)&(NBIOTRRC_CONFIGURATION_REQ (msg_p). npusch_srs_SubframeConfig_NB);
|
||||
NBIoTParams[NBIOT_NPUSCH_THREETONE_CYCLICSHIFT_R13_IDX].uptr = (uint32_t *)&(NBIOTRRC_CONFIGURATION_REQ (msg_p).npusch_threeTone_CyclicShift_r13);
|
||||
NBIoTParams[NBIOT_NPUSCH_SIXTONE_CYCLICSHIFT_R13_IDX].uptr = (uint32_t *)&(NBIOTRRC_CONFIGURATION_REQ (msg_p).npusch_sixTone_CyclicShift_r13);
|
||||
|
||||
NBIoTParams[NBIOT_NPUSCH_GROUPASSIGNMENTNPUSCH_R13_IDX].uptr = (uint32_t *)&(NBIOTRRC_CONFIGURATION_REQ (msg_p).npusch_groupAssignmentNPUSCH_r13);
|
||||
NBIoTParams[NBIOT_DL_GAPTHRESHOLD_NB_IDX].uptr = (uint32_t *)&(NBIOTRRC_CONFIGURATION_REQ (msg_p).dl_GapThreshold_NB);
|
||||
NBIoTParams[NBIOT_DL_GAPPERIODICITY_NB_IDX].uptr = (uint32_t *)&(NBIOTRRC_CONFIGURATION_REQ (msg_p).dl_GapPeriodicity_NB);
|
||||
|
||||
NBIoTParams[NBIOT_NPUSCH_P0_NOMINALNPUSCH_IDX].uptr = (uint32_t *)&(NBIOTRRC_CONFIGURATION_REQ (msg_p).npusch_p0_NominalNPUSCH);
|
||||
|
||||
NBIoTParams[NBIOT_DELTAPREAMBLEMSG3_IDX].uptr = (uint32_t *)&(NBIOTRRC_CONFIGURATION_REQ (msg_p).deltaPreambleMsg3);
|
||||
NBIoTParams[NBIOT_UE_TIMERSANDCONSTANTS_T300_NB_IDX].uptr = (uint32_t *)&(NBIOTRRC_CONFIGURATION_REQ (msg_p).ue_TimersAndConstants_t300_NB);
|
||||
NBIoTParams[NBIOT_DL_GAPTHRESHOLD_NB_IDX].uptr = (uint32_t *)&(NBIOTRRC_CONFIGURATION_REQ (msg_p).dl_GapThreshold_NB);
|
||||
NBIoTParams[NBIOT_DL_GAPPERIODICITY_NB_IDX].uptr = (uint32_t *)&(NBIOTRRC_CONFIGURATION_REQ (msg_p).dl_GapPeriodicity_NB);
|
||||
NBIoTParams[NBIOT_NPUSCH_P0_NOMINALNPUSCH_IDX].uptr = (uint32_t *)&(NBIOTRRC_CONFIGURATION_REQ (msg_p).npusch_p0_NominalNPUSCH);
|
||||
NBIoTParams[NBIOT_DELTAPREAMBLEMSG3_IDX].uptr = (uint32_t *)&(NBIOTRRC_CONFIGURATION_REQ (msg_p).deltaPreambleMsg3);
|
||||
NBIoTParams[NBIOT_UE_TIMERSANDCONSTANTS_T300_NB_IDX].uptr = (uint32_t *)&(NBIOTRRC_CONFIGURATION_REQ (msg_p).ue_TimersAndConstants_t300_NB);
|
||||
NBIoTParams[NBIOT_UE_TIMERSANDCONSTANTS_T301_NB_IDX].uptr = (uint32_t *)&(NBIOTRRC_CONFIGURATION_REQ (msg_p).ue_TimersAndConstants_t301_NB);
|
||||
NBIoTParams[NBIOT_UE_TIMERSANDCONSTANTS_T310_NB_IDX].uptr = (uint32_t *)&(NBIOTRRC_CONFIGURATION_REQ (msg_p).ue_TimersAndConstants_t310_NB);
|
||||
NBIoTParams[NBIOT_UE_TIMERSANDCONSTANTS_T311_NB_IDX].uptr = (uint32_t *)&(NBIOTRRC_CONFIGURATION_REQ (msg_p).ue_TimersAndConstants_t311_NB);
|
||||
NBIoTParams[NBIOT_UE_TIMERSANDCONSTANTS_N310_NB_IDX].uptr = (uint32_t *)&(NBIOTRRC_CONFIGURATION_REQ (msg_p).ue_TimersAndConstants_n310_NB);
|
||||
NBIoTParams[NBIOT_UE_TIMERSANDCONSTANTS_T310_NB_IDX].uptr = (uint32_t *)&(NBIOTRRC_CONFIGURATION_REQ (msg_p).ue_TimersAndConstants_t310_NB);
|
||||
NBIoTParams[NBIOT_UE_TIMERSANDCONSTANTS_T311_NB_IDX].uptr = (uint32_t *)&(NBIOTRRC_CONFIGURATION_REQ (msg_p).ue_TimersAndConstants_t311_NB);
|
||||
NBIoTParams[NBIOT_UE_TIMERSANDCONSTANTS_N310_NB_IDX].uptr = (uint32_t *)&(NBIOTRRC_CONFIGURATION_REQ (msg_p).ue_TimersAndConstants_n310_NB);
|
||||
NBIoTParams[NBIOT_UE_TIMERSANDCONSTANTS_N311_NB_IDX].uptr = (uint32_t *)&(NBIOTRRC_CONFIGURATION_REQ (msg_p).ue_TimersAndConstants_n311_NB);
|
||||
|
||||
sprintf(instprefix, NBIOT_RRCLIST_CONFIG_STRING ".[%i]",nbiotrrc_id);
|
||||
config_get( NBIoTParams,sizeof(NBIoTParams)/sizeof(paramdef_t),instprefix);
|
||||
|
||||
config_get( NBIoTParams,sizeof(NBIoTParams)/sizeof(paramdef_t),instprefix);
|
||||
NBIOTRRC_CONFIGURATION_REQ (msg_p).nprach_SubcarrierMSG3_RangeStart = config_get_processedint( &(NBIoTParams[NBIOT_NPRACH_SUBCARRIERMSG3_RANGESTART_IDX]) );
|
||||
NBIOTRRC_CONFIGURATION_REQ (msg_p).npusch_groupHoppingEnabled = config_get_processedint( &(NBIoTParams[NBIOT_NPUSCH_GROUPHOPPINGENABLED_IDX] ) );
|
||||
NBIOTRRC_CONFIGURATION_REQ (msg_p).dl_GapDurationCoeff_NB = config_get_processedint( &(NBIoTParams[NBIOT_DL_GAPDURATIONCOEFF_NB_IDX] ) );
|
||||
NBIOTRRC_CONFIGURATION_REQ (msg_p).npusch_groupHoppingEnabled = config_get_processedint( &(NBIoTParams[NBIOT_NPUSCH_GROUPHOPPINGENABLED_IDX] ) );
|
||||
NBIOTRRC_CONFIGURATION_REQ (msg_p).dl_GapDurationCoeff_NB = config_get_processedint( &(NBIoTParams[NBIOT_DL_GAPDURATIONCOEFF_NB_IDX] ) );
|
||||
NBIOTRRC_CONFIGURATION_REQ (msg_p).npusch_alpha = config_get_processedint( &(NBIoTParams[NBIOT_NPUSCH_ALPHA_IDX] ) );
|
||||
|
||||
for (int i=0; i<MAX_NUM_NBIOT_CELEVELS; i++) {
|
||||
char *tmpptr=NULL;
|
||||
NBIoTPrachParams[NBIOT_NPRACH_PERIODICITY_IDX ].uptr = (uint32_t *)&(NBIOTRRC_CONFIGURATION_REQ (msg_p).nprach_Periodicity[i]);
|
||||
NBIoTPrachParams[NBIOT_NPRACH_STARTTIME_IDX].uptr = (uint32_t *)&(NBIOTRRC_CONFIGURATION_REQ (msg_p).nprach_StartTime[i]);
|
||||
NBIoTPrachParams[NBIOT_NPRACH_SUBCARRIEROFFSET_IDX].uptr = (uint32_t *)&(NBIOTRRC_CONFIGURATION_REQ (msg_p).nprach_SubcarrierOffset[i]);
|
||||
NBIoTPrachParams[NBIOT_NPRACH_NUMSUBCARRIERS_IDX].uptr = (uint32_t *)&(NBIOTRRC_CONFIGURATION_REQ (msg_p).nprach_NumSubcarriers[i]);
|
||||
NBIoTPrachParams[NBIOT_NUMREPETITIONSPERPREAMBLEATTEMPT_NB_IDX].uptr = (uint32_t *)&(NBIOTRRC_CONFIGURATION_REQ (msg_p).numRepetitionsPerPreambleAttempt_NB[i]);
|
||||
NBIoTParams[NBIOT_NPDCCH_NUMREPETITIONS_RA_IDX].uptr = (uint32_t *)&(NBIOTRRC_CONFIGURATION_REQ (msg_p).npdcch_NumRepetitions_RA[i]);
|
||||
NBIoTParams[NBIOT_NPDCCH_STARTSF_CSS_RA_IDX].uptr = (uint32_t *)&(NBIOTRRC_CONFIGURATION_REQ (msg_p).npdcch_StartSF_CSS_RA[i]);
|
||||
NBIoTParams[NBIOT_NPDCCH_OFFSET_RA_IDX].strptr = &tmpptr;
|
||||
sprintf(instprefix, "%s.[%i].%s.[%i]",NBIOT_RRCLIST_CONFIG_STRING, nbiotrrc_id,NBIOT_RRCLIST_NPRACHPARAMS_CONFIG_STRING,i);
|
||||
config_get( NBIoTPrachParams,sizeof(NBIoTPrachParams)/sizeof(paramdef_t),instprefix);
|
||||
NBIOTRRC_CONFIGURATION_REQ (msg_p).npdcch_Offset_RA[i] = config_get_processedint( &(NBIoTPrachParams[NBIOT_NPDCCH_OFFSET_RA_IDX]) );
|
||||
char *tmpptr=NULL;
|
||||
NBIoTPrachParams[NBIOT_NPRACH_PERIODICITY_IDX ].uptr = (uint32_t *)&(NBIOTRRC_CONFIGURATION_REQ (msg_p).nprach_Periodicity[i]);
|
||||
NBIoTPrachParams[NBIOT_NPRACH_STARTTIME_IDX].uptr = (uint32_t *)&(NBIOTRRC_CONFIGURATION_REQ (msg_p).nprach_StartTime[i]);
|
||||
NBIoTPrachParams[NBIOT_NPRACH_SUBCARRIEROFFSET_IDX].uptr = (uint32_t *)&(NBIOTRRC_CONFIGURATION_REQ (msg_p).nprach_SubcarrierOffset[i]);
|
||||
NBIoTPrachParams[NBIOT_NPRACH_NUMSUBCARRIERS_IDX].uptr = (uint32_t *)&(NBIOTRRC_CONFIGURATION_REQ (msg_p).nprach_NumSubcarriers[i]);
|
||||
NBIoTPrachParams[NBIOT_NUMREPETITIONSPERPREAMBLEATTEMPT_NB_IDX].uptr = (uint32_t *)&(NBIOTRRC_CONFIGURATION_REQ (msg_p).numRepetitionsPerPreambleAttempt_NB[i]);
|
||||
NBIoTParams[NBIOT_NPDCCH_NUMREPETITIONS_RA_IDX].uptr = (uint32_t *)&(NBIOTRRC_CONFIGURATION_REQ (msg_p).npdcch_NumRepetitions_RA[i]);
|
||||
NBIoTParams[NBIOT_NPDCCH_STARTSF_CSS_RA_IDX].uptr = (uint32_t *)&(NBIOTRRC_CONFIGURATION_REQ (msg_p).npdcch_StartSF_CSS_RA[i]);
|
||||
NBIoTParams[NBIOT_NPDCCH_OFFSET_RA_IDX].strptr = &tmpptr;
|
||||
sprintf(instprefix, "%s.[%i].%s.[%i]",NBIOT_RRCLIST_CONFIG_STRING, nbiotrrc_id,NBIOT_RRCLIST_NPRACHPARAMS_CONFIG_STRING,i);
|
||||
config_get( NBIoTPrachParams,sizeof(NBIoTPrachParams)/sizeof(paramdef_t),instprefix);
|
||||
NBIOTRRC_CONFIGURATION_REQ (msg_p).npdcch_Offset_RA[i] = config_get_processedint( &(NBIoTPrachParams[NBIOT_NPDCCH_OFFSET_RA_IDX]) );
|
||||
}
|
||||
/* get the LTE RRC and CC this NB-IoT RRC instance is attached to */
|
||||
|
||||
/* get the LTE RRC and CC this NB-IoT RRC instance is attached to */
|
||||
sprintf(instprefix, NBIOT_RRCLIST_CONFIG_STRING ".[%i]." NBIOT_LTERRCREF_CONFIG_STRING, nbiotrrc_id );
|
||||
config_get( NBIoTRRCRefParams,sizeof(NBIoTRRCRefParams)/sizeof(paramdef_t),instprefix);
|
||||
|
||||
/* read SIB1 parameters in the LTE RRC and CC sections */
|
||||
config_get( NBIoTRRCRefParams,sizeof(NBIoTRRCRefParams)/sizeof(paramdef_t),instprefix);
|
||||
/* read SIB1 parameters in the LTE RRC and CC sections */
|
||||
sprintf(instprefix, ENB_CONFIG_STRING_ENB_LIST ".[%i]." ENB_CONFIG_STRING_COMPONENT_CARRIERS ".[%i]",
|
||||
*(NBIoTRRCRefParams[NBIOT_RRCINST_IDX].uptr), *(NBIoTRRCRefParams[NBIOT_CCINST_IDX].uptr));
|
||||
|
||||
NBIoTLteCCParams[LTECCPARAMS_TDD_CONFIG_IDX ].uptr = (uint32_t *)&(NBIOTRRC_CONFIGURATION_REQ (msg_p).tdd_config);
|
||||
NBIoTLteCCParams[LTECCPARAMS_TDD_CONFIG_S_IDX].uptr = (uint32_t *)&(NBIOTRRC_CONFIGURATION_REQ (msg_p).tdd_config_s);
|
||||
NBIoTLteCCParams[LTECCPARAMS_EUTRA_BAND_IDX ].uptr = (uint32_t *)&(NBIOTRRC_CONFIGURATION_REQ (msg_p).eutra_band);
|
||||
NBIoTLteCCParams[LTECCPARAMS_DOWNLINK_FREQUENCY_IDX].uptr = (uint32_t *)&(NBIOTRRC_CONFIGURATION_REQ (msg_p).downlink_frequency);
|
||||
*(NBIoTRRCRefParams[NBIOT_RRCINST_IDX].uptr), *(NBIoTRRCRefParams[NBIOT_CCINST_IDX].uptr));
|
||||
NBIoTLteCCParams[LTECCPARAMS_TDD_CONFIG_IDX ].uptr = (uint32_t *)&(NBIOTRRC_CONFIGURATION_REQ (msg_p).tdd_config);
|
||||
NBIoTLteCCParams[LTECCPARAMS_TDD_CONFIG_S_IDX].uptr = (uint32_t *)&(NBIOTRRC_CONFIGURATION_REQ (msg_p).tdd_config_s);
|
||||
NBIoTLteCCParams[LTECCPARAMS_EUTRA_BAND_IDX ].uptr = (uint32_t *)&(NBIOTRRC_CONFIGURATION_REQ (msg_p).eutra_band);
|
||||
NBIoTLteCCParams[LTECCPARAMS_DOWNLINK_FREQUENCY_IDX].uptr = (uint32_t *)&(NBIOTRRC_CONFIGURATION_REQ (msg_p).downlink_frequency);
|
||||
NBIoTLteCCParams[LTECCPARAMS_UPLINK_FREQUENCY_OFFSET_IDX].uptr = (uint32_t *)&(NBIOTRRC_CONFIGURATION_REQ (msg_p).uplink_frequency_offset);
|
||||
NBIoTLteCCParams[LTECCPARAMS_NID_CELL_IDX].uptr = (uint32_t *)&(NBIOTRRC_CONFIGURATION_REQ (msg_p).Nid_cell);
|
||||
NBIoTLteCCParams[LTECCPARAMS_N_RB_DL_IDX].uptr = (uint32_t *)&(NBIOTRRC_CONFIGURATION_REQ (msg_p).N_RB_DL);
|
||||
NBIoTLteCCParams[LTECCPARAMS_NID_CELL_IDX].uptr = (uint32_t *)&(NBIOTRRC_CONFIGURATION_REQ (msg_p).Nid_cell);
|
||||
NBIoTLteCCParams[LTECCPARAMS_N_RB_DL_IDX].uptr = (uint32_t *)&(NBIOTRRC_CONFIGURATION_REQ (msg_p).N_RB_DL);
|
||||
|
||||
for (int i=0; (i<sizeof(NBIoTLteCCParams)/sizeof(paramdef_t)) && (i<sizeof(NBIoTLteCCCheckParams)/sizeof(checkedparam_t)); i++ ) {
|
||||
NBIoTLteCCParams[i].chkPptr = &(NBIoTLteCCCheckParams[i]);
|
||||
NBIoTLteCCParams[i].chkPptr = &(NBIoTLteCCCheckParams[i]);
|
||||
}
|
||||
config_get( NBIoTLteCCParams,sizeof(NBIoTLteCCParams)/sizeof(paramdef_t),instprefix);
|
||||
NBIOTRRC_CONFIGURATION_REQ (msg_p).frame_type = config_get_processedint( &(NBIoTLteCCParams[LTECCPARAMS_FRAME_TYPE_IDX]) );
|
||||
|
||||
config_get( NBIoTLteCCParams,sizeof(NBIoTLteCCParams)/sizeof(paramdef_t),instprefix);
|
||||
NBIOTRRC_CONFIGURATION_REQ (msg_p).frame_type = config_get_processedint( &(NBIoTLteCCParams[LTECCPARAMS_FRAME_TYPE_IDX]) );
|
||||
NBIOTRRC_CONFIGURATION_REQ (msg_p).prefix_type = config_get_processedint( &(NBIoTLteCCParams[LTECCPARAMS_PREFIX_TYPE_IDX]) );
|
||||
NBIOTRRC_CONFIGURATION_REQ (msg_p).prefix_type = config_get_processedint( &(NBIoTLteCCParams[LTECCPARAMS_PREFIX_TYPE_UL_IDX]) );
|
||||
return 0;
|
||||
return 0;
|
||||
}
|
||||
|
||||
void RCConfig_NbIoT(RAN_CONTEXT_t *RC) {
|
||||
|
||||
paramlist_def_t NbIoT_MACRLCParamList = {NBIOT_MACRLCLIST_CONFIG_STRING,NULL,0};
|
||||
paramlist_def_t NbIoT_L1ParamList = {NBIOT_L1LIST_CONFIG_STRING,NULL,0};
|
||||
paramlist_def_t NbIoT_ParamList = {NBIOT_RRCLIST_CONFIG_STRING,NULL,0};
|
||||
|
||||
|
||||
config_getlist( &NbIoT_ParamList,NULL,0,NULL);
|
||||
RC->nb_nb_iot_rrc_inst = NbIoT_ParamList.numelt;
|
||||
|
||||
|
||||
|
||||
|
||||
config_getlist( &NbIoT_MACRLCParamList,NULL,0, NULL);
|
||||
RC->nb_nb_iot_macrlc_inst = NbIoT_MACRLCParamList.numelt;
|
||||
// Get num L1 instances
|
||||
config_getlist( &NbIoT_L1ParamList,NULL,0, NULL);
|
||||
RC->nb_nb_iot_L1_inst = NbIoT_L1ParamList.numelt;
|
||||
|
||||
config_getlist( &NbIoT_MACRLCParamList,NULL,0, NULL);
|
||||
RC->nb_nb_iot_macrlc_inst = NbIoT_MACRLCParamList.numelt;
|
||||
// Get num L1 instances
|
||||
config_getlist( &NbIoT_L1ParamList,NULL,0, NULL);
|
||||
RC->nb_nb_iot_L1_inst = NbIoT_L1ParamList.numelt;
|
||||
}
|
||||
|
||||
@@ -134,42 +134,37 @@ static const eutra_bandentry_t eutra_bandtable[] = {
|
||||
{68, 6980, 7280, 7530, 7830, 67536}
|
||||
};
|
||||
|
||||
uint32_t to_earfcn(int eutra_bandP, uint32_t dl_CarrierFreq, uint32_t bw)
|
||||
{
|
||||
|
||||
#define BANDTABLE_SIZE (sizeof(eutra_bandtable)/sizeof(eutra_bandentry_t))
|
||||
|
||||
uint32_t to_earfcn(int eutra_bandP, uint32_t dl_CarrierFreq, uint32_t bw) {
|
||||
uint32_t dl_CarrierFreq_by_100k = dl_CarrierFreq / 100000;
|
||||
int bw_by_100 = bw / 100;
|
||||
|
||||
int i;
|
||||
|
||||
AssertFatal(eutra_bandP < 69, "eutra_band %d > 68\n", eutra_bandP);
|
||||
for (i = 0; i < 69 && eutra_bandtable[i].band != eutra_bandP; i++);
|
||||
|
||||
for (i = 0; i < BANDTABLE_SIZE && eutra_bandtable[i].band != eutra_bandP; i++);
|
||||
|
||||
AssertFatal(dl_CarrierFreq_by_100k >= eutra_bandtable[i].dl_min,
|
||||
"Band %d, bw %u : DL carrier frequency %u Hz < %u\n",
|
||||
eutra_bandP, bw, dl_CarrierFreq,
|
||||
eutra_bandtable[i].dl_min);
|
||||
"Band %d, bw %u : DL carrier frequency %u Hz < %u\n",
|
||||
eutra_bandP, bw, dl_CarrierFreq,
|
||||
eutra_bandtable[i].dl_min);
|
||||
AssertFatal(dl_CarrierFreq_by_100k <=
|
||||
(eutra_bandtable[i].dl_max - bw_by_100),
|
||||
"Band %d, bw %u: DL carrier frequency %u Hz > %d\n",
|
||||
eutra_bandP, bw, dl_CarrierFreq,
|
||||
eutra_bandtable[i].dl_max - bw_by_100);
|
||||
|
||||
|
||||
(eutra_bandtable[i].dl_max - bw_by_100),
|
||||
"Band %d, bw %u: DL carrier frequency %u Hz > %d\n",
|
||||
eutra_bandP, bw, dl_CarrierFreq,
|
||||
eutra_bandtable[i].dl_max - bw_by_100);
|
||||
return (dl_CarrierFreq_by_100k - eutra_bandtable[i].dl_min +
|
||||
(eutra_bandtable[i].N_OFFs_DL / 10));
|
||||
(eutra_bandtable[i].N_OFFs_DL / 10));
|
||||
}
|
||||
|
||||
uint32_t to_earfcn_DL(int eutra_bandP, long long int dl_CarrierFreq, uint32_t bw)
|
||||
{
|
||||
|
||||
uint32_t to_earfcn_DL(int eutra_bandP, long long int dl_CarrierFreq, uint32_t bw) {
|
||||
uint32_t dl_CarrierFreq_by_100k = dl_CarrierFreq / 100000;
|
||||
int bw_by_100 = bw / 100;
|
||||
|
||||
int i;
|
||||
|
||||
AssertFatal(eutra_bandP < 69, "eutra_band %d > 68\n", eutra_bandP);
|
||||
for (i = 0; i < 69 && eutra_bandtable[i].band != eutra_bandP; i++);
|
||||
|
||||
for (i = 0; i < BANDTABLE_SIZE && eutra_bandtable[i].band != eutra_bandP; i++);
|
||||
|
||||
AssertFatal(dl_CarrierFreq_by_100k >= eutra_bandtable[i].dl_min,
|
||||
"Band %d, bw %u : DL carrier frequency %lld Hz < %u\n",
|
||||
@@ -180,22 +175,17 @@ uint32_t to_earfcn_DL(int eutra_bandP, long long int dl_CarrierFreq, uint32_t bw
|
||||
"Band %d, bw %u : DL carrier frequency %lld Hz > %d\n",
|
||||
eutra_bandP, bw, dl_CarrierFreq,
|
||||
eutra_bandtable[i].dl_max - bw_by_100);
|
||||
|
||||
|
||||
return (dl_CarrierFreq_by_100k - eutra_bandtable[i].dl_min +
|
||||
(eutra_bandtable[i].N_OFFs_DL / 10));
|
||||
}
|
||||
|
||||
uint32_t to_earfcn_UL(int eutra_bandP, long long int ul_CarrierFreq, uint32_t bw)
|
||||
{
|
||||
|
||||
uint32_t to_earfcn_UL(int eutra_bandP, long long int ul_CarrierFreq, uint32_t bw) {
|
||||
uint32_t ul_CarrierFreq_by_100k = ul_CarrierFreq / 100000;
|
||||
int bw_by_100 = bw / 100;
|
||||
|
||||
int i;
|
||||
|
||||
AssertFatal(eutra_bandP < 69, "eutra_band %d > 68\n", eutra_bandP);
|
||||
for (i = 0; i < 69 && eutra_bandtable[i].band != eutra_bandP; i++);
|
||||
|
||||
for (i = 0; i < BANDTABLE_SIZE && eutra_bandtable[i].band != eutra_bandP; i++);
|
||||
|
||||
AssertFatal(ul_CarrierFreq_by_100k >= eutra_bandtable[i].ul_min,
|
||||
"Band %d, bw %u : UL carrier frequency %lld Hz < %u\n",
|
||||
@@ -206,30 +196,26 @@ uint32_t to_earfcn_UL(int eutra_bandP, long long int ul_CarrierFreq, uint32_t bw
|
||||
"Band %d, bw %u : UL carrier frequency %lld Hz > %d\n",
|
||||
eutra_bandP, bw, ul_CarrierFreq,
|
||||
eutra_bandtable[i].ul_max - bw_by_100);
|
||||
|
||||
|
||||
return (ul_CarrierFreq_by_100k - eutra_bandtable[i].ul_min +
|
||||
((eutra_bandtable[i].N_OFFs_DL + 180000) / 10));
|
||||
}
|
||||
|
||||
uint32_t from_earfcn(int eutra_bandP, uint32_t dl_earfcn)
|
||||
{
|
||||
|
||||
uint32_t from_earfcn(int eutra_bandP, uint32_t dl_earfcn) {
|
||||
int i;
|
||||
|
||||
AssertFatal(eutra_bandP < 69, "eutra_band %d > 68\n", eutra_bandP);
|
||||
for (i = 0; i < 69 && eutra_bandtable[i].band != eutra_bandP; i++);
|
||||
|
||||
for (i = 0; i < BANDTABLE_SIZE && eutra_bandtable[i].band != eutra_bandP; i++);
|
||||
|
||||
return (eutra_bandtable[i].dl_min +
|
||||
(dl_earfcn - (eutra_bandtable[i].N_OFFs_DL / 10))) * 100000;
|
||||
(dl_earfcn - (eutra_bandtable[i].N_OFFs_DL / 10))) * 100000;
|
||||
}
|
||||
|
||||
|
||||
int32_t get_uldl_offset(int eutra_bandP)
|
||||
{
|
||||
int32_t get_uldl_offset(int eutra_bandP) {
|
||||
int i;
|
||||
|
||||
for (i = 0; i < 69 && eutra_bandtable[i].band != eutra_bandP; i++);
|
||||
for (i = 0; i < BANDTABLE_SIZE && eutra_bandtable[i].band != eutra_bandP; i++);
|
||||
|
||||
return (eutra_bandtable[i].dl_min - eutra_bandtable[i].ul_min);
|
||||
}
|
||||
|
||||
|
||||
+612
-657
File diff suppressed because it is too large
Load Diff
@@ -677,7 +677,7 @@ void
|
||||
rlc_module_cleanup (void)
|
||||
//-----------------------------------------------------------------------------
|
||||
{
|
||||
hashtable_destroy(rlc_coll_p);
|
||||
hashtable_destroy(&rlc_coll_p);
|
||||
}
|
||||
//-----------------------------------------------------------------------------
|
||||
void
|
||||
|
||||
+174
-232
@@ -50,9 +50,7 @@ static mapping rrc_status_names[] = {
|
||||
|
||||
extern RAN_CONTEXT_t RC;
|
||||
|
||||
int dump_eNB_l2_stats(char *buffer, int length)
|
||||
{
|
||||
|
||||
int dump_eNB_l2_stats(char *buffer, int length) {
|
||||
int eNB_id,UE_id,number_of_cards;
|
||||
int len= length;
|
||||
int CC_id=0;
|
||||
@@ -87,7 +85,6 @@ int dump_eNB_l2_stats(char *buffer, int length)
|
||||
unsigned int stat_timer_reordering_timed_out;
|
||||
unsigned int stat_timer_poll_retransmit_timed_out;
|
||||
unsigned int stat_timer_status_prohibit_timed_out;
|
||||
|
||||
#ifdef EXMIMO
|
||||
number_of_cards=1;
|
||||
#else
|
||||
@@ -103,35 +100,29 @@ int dump_eNB_l2_stats(char *buffer, int length)
|
||||
|
||||
for (CC_id=0 ; CC_id < MAX_NUM_CCs; CC_id++) {
|
||||
eNB->eNB_stats[CC_id].dlsch_bitrate= 0;
|
||||
|
||||
len += sprintf(&buffer[len],"eNB %d CC %d Frame %d: Active UEs %d, Available PRBs %d, nCCE %d, Scheduling decisions %d, Missed Deadlines %d \n",
|
||||
eNB_id, CC_id, eNB->frame,
|
||||
eNB->eNB_stats[CC_id].num_dlactive_UEs,
|
||||
eNB->eNB_stats[CC_id].available_prbs,
|
||||
eNB->eNB_stats[CC_id].available_ncces,
|
||||
eNB->eNB_stats[CC_id].sched_decisions,
|
||||
eNB->eNB_stats[CC_id].missed_deadlines);
|
||||
|
||||
eNB->eNB_stats[CC_id].sched_decisions,
|
||||
eNB->eNB_stats[CC_id].missed_deadlines);
|
||||
len += sprintf(&buffer[len],"BCCH , NB_TX_MAC = %d, transmitted bytes (TTI %d, total %d) MCS (TTI %d)\n",
|
||||
eNB->eNB_stats[CC_id].total_num_bcch_pdu,
|
||||
eNB->eNB_stats[CC_id].bcch_buffer,
|
||||
eNB->eNB_stats[CC_id].total_bcch_buffer,
|
||||
eNB->eNB_stats[CC_id].bcch_mcs);
|
||||
|
||||
eNB->eNB_stats[CC_id].total_num_bcch_pdu,
|
||||
eNB->eNB_stats[CC_id].bcch_buffer,
|
||||
eNB->eNB_stats[CC_id].total_bcch_buffer,
|
||||
eNB->eNB_stats[CC_id].bcch_mcs);
|
||||
len += sprintf(&buffer[len],"PCCH , NB_TX_MAC = %d, transmitted bytes (TTI %d, total %d) MCS (TTI %d)\n",
|
||||
eNB->eNB_stats[CC_id].total_num_pcch_pdu,
|
||||
eNB->eNB_stats[CC_id].pcch_buffer,
|
||||
eNB->eNB_stats[CC_id].total_pcch_buffer,
|
||||
eNB->eNB_stats[CC_id].pcch_mcs);
|
||||
|
||||
eNB->eNB_stats[CC_id].total_num_pcch_pdu,
|
||||
eNB->eNB_stats[CC_id].pcch_buffer,
|
||||
eNB->eNB_stats[CC_id].total_pcch_buffer,
|
||||
eNB->eNB_stats[CC_id].pcch_mcs);
|
||||
eNB->eNB_stats[CC_id].dlsch_bitrate=((eNB->eNB_stats[CC_id].dlsch_bytes_tx*8)/((eNB->frame + 1)*10));
|
||||
eNB->eNB_stats[CC_id].total_dlsch_pdus_tx+=eNB->eNB_stats[CC_id].dlsch_pdus_tx;
|
||||
eNB->eNB_stats[CC_id].total_dlsch_bytes_tx+=eNB->eNB_stats[CC_id].dlsch_bytes_tx;
|
||||
eNB->eNB_stats[CC_id].total_dlsch_bitrate=((eNB->eNB_stats[CC_id].total_dlsch_bytes_tx*8)/((eNB->frame + 1)*10));
|
||||
|
||||
eNB->eNB_stats[CC_id].ulsch_bitrate=((eNB->eNB_stats[CC_id].ulsch_bytes_rx*8)/((eNB->frame + 1)*10));
|
||||
eNB->eNB_stats[CC_id].total_ulsch_bitrate=((eNB->eNB_stats[CC_id].total_ulsch_bytes_rx*8)/((eNB->frame + 1)*10));
|
||||
|
||||
len += sprintf(&buffer[len],"DLSCH bitrate (TTI %u, avg %u) kbps, Transmitted bytes (TTI %u, total %u), Transmitted PDU (TTI %u, total %u) \n",
|
||||
eNB->eNB_stats[CC_id].dlsch_bitrate,
|
||||
eNB->eNB_stats[CC_id].total_dlsch_bitrate,
|
||||
@@ -139,7 +130,6 @@ int dump_eNB_l2_stats(char *buffer, int length)
|
||||
eNB->eNB_stats[CC_id].total_dlsch_bytes_tx,
|
||||
eNB->eNB_stats[CC_id].dlsch_pdus_tx,
|
||||
eNB->eNB_stats[CC_id].total_dlsch_pdus_tx);
|
||||
|
||||
len += sprintf(&buffer[len],"ULSCH bitrate (TTI %u, avg %u) kbps, Received bytes (TTI %u, total %u), Received PDU (TTI %lu, total %u) \n",
|
||||
eNB->eNB_stats[CC_id].ulsch_bitrate,
|
||||
eNB->eNB_stats[CC_id].total_ulsch_bitrate,
|
||||
@@ -154,15 +144,12 @@ int dump_eNB_l2_stats(char *buffer, int length)
|
||||
for (UE_id=UE_list->head; UE_id>=0; UE_id=UE_list->next[UE_id]) {
|
||||
for (i=0; i<UE_list->numactiveCCs[UE_id]; i++) {
|
||||
CC_id=UE_list->ordered_CCids[i][UE_id];
|
||||
|
||||
UE_list->eNB_UE_stats[CC_id][UE_id].dlsch_bitrate=((UE_list->eNB_UE_stats[CC_id][UE_id].TBS*8)/((eNB->frame + 1)*10));
|
||||
UE_list->eNB_UE_stats[CC_id][UE_id].dlsch_bitrate=((UE_list->eNB_UE_stats[CC_id][UE_id].TBS*8)/((eNB->frame + 1)*10));
|
||||
UE_list->eNB_UE_stats[CC_id][UE_id].total_dlsch_bitrate= ((UE_list->eNB_UE_stats[CC_id][UE_id].total_pdu_bytes*8)/((eNB->frame + 1)*10));
|
||||
UE_list->eNB_UE_stats[CC_id][UE_id].total_overhead_bytes+= UE_list->eNB_UE_stats[CC_id][UE_id].overhead_bytes;
|
||||
UE_list->eNB_UE_stats[CC_id][UE_id].avg_overhead_bytes=((UE_list->eNB_UE_stats[CC_id][UE_id].total_overhead_bytes*8)/((eNB->frame + 1)*10));
|
||||
|
||||
UE_list->eNB_UE_stats[CC_id][UE_id].ulsch_bitrate=((UE_list->eNB_UE_stats[CC_id][UE_id].ulsch_TBS*8)/((eNB->frame + 1)*10));
|
||||
UE_list->eNB_UE_stats[CC_id][UE_id].ulsch_bitrate=((UE_list->eNB_UE_stats[CC_id][UE_id].ulsch_TBS*8)/((eNB->frame + 1)*10));
|
||||
UE_list->eNB_UE_stats[CC_id][UE_id].total_ulsch_bitrate= ((UE_list->eNB_UE_stats[CC_id][UE_id].total_pdu_bytes_rx*8)/((eNB->frame + 1)*10));
|
||||
|
||||
len += sprintf(&buffer[len],"[MAC] UE %d (DLSCH),status %s, RNTI %x : CQI %d, MCS1 %d, MCS2 %d, RB (tx %d, retx %d, total %d), ncce (tx %d, retx %d) \n",
|
||||
UE_id,
|
||||
map_int_to_str(rrc_status_names, UE_list->eNB_UE_stats[CC_id][UE_id].rrc_status),
|
||||
@@ -176,7 +163,6 @@ int dump_eNB_l2_stats(char *buffer, int length)
|
||||
UE_list->eNB_UE_stats[CC_id][UE_id].ncce_used,
|
||||
UE_list->eNB_UE_stats[CC_id][UE_id].ncce_used_retx
|
||||
);
|
||||
|
||||
len += sprintf(&buffer[len],
|
||||
"[MAC] DLSCH bitrate (TTI %d, avg %d), Transmitted bytes "
|
||||
"(TTI %d, total %"PRIu64"), Total Transmitted PDU %d, Overhead "
|
||||
@@ -190,32 +176,28 @@ int dump_eNB_l2_stats(char *buffer, int length)
|
||||
UE_list->eNB_UE_stats[CC_id][UE_id].total_overhead_bytes,
|
||||
UE_list->eNB_UE_stats[CC_id][UE_id].avg_overhead_bytes
|
||||
);
|
||||
|
||||
|
||||
len += sprintf(&buffer[len],"[MAC] UE %d (ULSCH), Status %s, Failute timer %d, RNTI %x : rx power (normalized %d, target %d), MCS (pre %d, post %d), RB (rx %d, retx %d, total %d), Current TBS %d \n",
|
||||
len += sprintf(&buffer[len],"[MAC] UE %d (ULSCH), Status %s, Failute timer %d, RNTI %x : rx power (normalized %d, target %d), MCS (pre %d, post %d), RB (rx %d, retx %d, total %d), Current TBS %d \n",
|
||||
UE_id,
|
||||
map_int_to_str(rrc_status_names, UE_list->eNB_UE_stats[CC_id][UE_id].rrc_status),
|
||||
UE_list->UE_sched_ctrl[UE_id].ul_failure_timer,
|
||||
UE_list->UE_sched_ctrl[UE_id].ul_failure_timer,
|
||||
UE_list->eNB_UE_stats[CC_id][UE_id].crnti,
|
||||
UE_list->eNB_UE_stats[CC_id][UE_id].normalized_rx_power,
|
||||
UE_list->eNB_UE_stats[CC_id][UE_id].target_rx_power,
|
||||
UE_list->eNB_UE_stats[CC_id][UE_id].ulsch_mcs1,
|
||||
UE_list->eNB_UE_stats[CC_id][UE_id].ulsch_mcs2,
|
||||
UE_list->eNB_UE_stats[CC_id][UE_id].rbs_used_rx,
|
||||
UE_list->eNB_UE_stats[CC_id][UE_id].rbs_used_retx_rx,
|
||||
UE_list->eNB_UE_stats[CC_id][UE_id].total_rbs_used_rx,
|
||||
UE_list->eNB_UE_stats[CC_id][UE_id].ulsch_TBS
|
||||
);
|
||||
|
||||
len += sprintf(&buffer[len],
|
||||
UE_list->eNB_UE_stats[CC_id][UE_id].normalized_rx_power,
|
||||
UE_list->eNB_UE_stats[CC_id][UE_id].target_rx_power,
|
||||
UE_list->eNB_UE_stats[CC_id][UE_id].ulsch_mcs1,
|
||||
UE_list->eNB_UE_stats[CC_id][UE_id].ulsch_mcs2,
|
||||
UE_list->eNB_UE_stats[CC_id][UE_id].rbs_used_rx,
|
||||
UE_list->eNB_UE_stats[CC_id][UE_id].rbs_used_retx_rx,
|
||||
UE_list->eNB_UE_stats[CC_id][UE_id].total_rbs_used_rx,
|
||||
UE_list->eNB_UE_stats[CC_id][UE_id].ulsch_TBS
|
||||
);
|
||||
len += sprintf(&buffer[len],
|
||||
"[MAC] ULSCH bitrate (TTI %d, avg %d), received bytes (total %"PRIu64"),"
|
||||
"Total received PDU %d, Total errors %d\n",
|
||||
UE_list->eNB_UE_stats[CC_id][UE_id].ulsch_bitrate,
|
||||
"Total received PDU %d, Total errors %d\n",
|
||||
UE_list->eNB_UE_stats[CC_id][UE_id].ulsch_bitrate,
|
||||
UE_list->eNB_UE_stats[CC_id][UE_id].total_ulsch_bitrate,
|
||||
UE_list->eNB_UE_stats[CC_id][UE_id].total_pdu_bytes_rx,
|
||||
UE_list->eNB_UE_stats[CC_id][UE_id].total_num_pdus_rx,
|
||||
UE_list->eNB_UE_stats[CC_id][UE_id].num_errors_rx);
|
||||
|
||||
len+= sprintf(&buffer[len],"[MAC] Received PHR PH = %d (db)\n", UE_list->UE_template[CC_id][UE_id].phr_info);
|
||||
len+= sprintf(&buffer[len],"[MAC] Estimated size LCGID[0][1][2][3] = %u %u %u %u\n",
|
||||
UE_list->UE_template[CC_id][UE_id].ul_buffer_info[LCGID0],
|
||||
@@ -224,181 +206,164 @@ int dump_eNB_l2_stats(char *buffer, int length)
|
||||
UE_list->UE_template[CC_id][UE_id].ul_buffer_info[LCGID3]
|
||||
);
|
||||
}
|
||||
|
||||
|
||||
PROTOCOL_CTXT_SET_BY_MODULE_ID(&ctxt,
|
||||
eNB_id,
|
||||
ENB_FLAG_YES,
|
||||
UE_list->eNB_UE_stats[0][UE_id].crnti,//UE_PCCID(eNB_id,UE_id)][UE_id].crnti,
|
||||
eNB->frame,
|
||||
eNB->subframe,
|
||||
eNB_id);
|
||||
|
||||
eNB_id,
|
||||
ENB_FLAG_YES,
|
||||
UE_list->eNB_UE_stats[0][UE_id].crnti,//UE_PCCID(eNB_id,UE_id)][UE_id].crnti,
|
||||
eNB->frame,
|
||||
eNB->subframe,
|
||||
eNB_id);
|
||||
rlc_status = rlc_stat_req(&ctxt,
|
||||
SRB_FLAG_YES,
|
||||
DCCH,
|
||||
&stat_rlc_mode,
|
||||
&stat_tx_pdcp_sdu,
|
||||
&stat_tx_pdcp_bytes,
|
||||
&stat_tx_pdcp_sdu_discarded,
|
||||
&stat_tx_pdcp_bytes_discarded,
|
||||
&stat_tx_data_pdu,
|
||||
&stat_tx_data_bytes,
|
||||
&stat_tx_retransmit_pdu_by_status,
|
||||
&stat_tx_retransmit_bytes_by_status,
|
||||
&stat_tx_retransmit_pdu,
|
||||
&stat_tx_retransmit_bytes,
|
||||
&stat_tx_control_pdu,
|
||||
&stat_tx_control_bytes,
|
||||
&stat_rx_pdcp_sdu,
|
||||
&stat_rx_pdcp_bytes,
|
||||
&stat_rx_data_pdus_duplicate,
|
||||
&stat_rx_data_bytes_duplicate,
|
||||
&stat_rx_data_pdu,
|
||||
&stat_rx_data_bytes,
|
||||
&stat_rx_data_pdu_dropped,
|
||||
&stat_rx_data_bytes_dropped,
|
||||
&stat_rx_data_pdu_out_of_window,
|
||||
&stat_rx_data_bytes_out_of_window,
|
||||
&stat_rx_control_pdu,
|
||||
&stat_rx_control_bytes,
|
||||
&stat_timer_reordering_timed_out,
|
||||
&stat_timer_poll_retransmit_timed_out,
|
||||
&stat_timer_status_prohibit_timed_out);
|
||||
|
||||
SRB_FLAG_YES,
|
||||
DCCH,
|
||||
&stat_rlc_mode,
|
||||
&stat_tx_pdcp_sdu,
|
||||
&stat_tx_pdcp_bytes,
|
||||
&stat_tx_pdcp_sdu_discarded,
|
||||
&stat_tx_pdcp_bytes_discarded,
|
||||
&stat_tx_data_pdu,
|
||||
&stat_tx_data_bytes,
|
||||
&stat_tx_retransmit_pdu_by_status,
|
||||
&stat_tx_retransmit_bytes_by_status,
|
||||
&stat_tx_retransmit_pdu,
|
||||
&stat_tx_retransmit_bytes,
|
||||
&stat_tx_control_pdu,
|
||||
&stat_tx_control_bytes,
|
||||
&stat_rx_pdcp_sdu,
|
||||
&stat_rx_pdcp_bytes,
|
||||
&stat_rx_data_pdus_duplicate,
|
||||
&stat_rx_data_bytes_duplicate,
|
||||
&stat_rx_data_pdu,
|
||||
&stat_rx_data_bytes,
|
||||
&stat_rx_data_pdu_dropped,
|
||||
&stat_rx_data_bytes_dropped,
|
||||
&stat_rx_data_pdu_out_of_window,
|
||||
&stat_rx_data_bytes_out_of_window,
|
||||
&stat_rx_control_pdu,
|
||||
&stat_rx_control_bytes,
|
||||
&stat_timer_reordering_timed_out,
|
||||
&stat_timer_poll_retransmit_timed_out,
|
||||
&stat_timer_status_prohibit_timed_out);
|
||||
|
||||
if (rlc_status == RLC_OP_STATUS_OK) {
|
||||
len+=sprintf(&buffer[len],"[RLC] DCCH Mode %s, NB_SDU_TO_TX = %d (bytes %d)\tNB_SDU_TO_TX_DISC %d (bytes %d)\n",
|
||||
(stat_rlc_mode==RLC_MODE_AM)? "AM": (stat_rlc_mode==RLC_MODE_UM)?"UM":"NONE",
|
||||
stat_tx_pdcp_sdu,
|
||||
stat_tx_pdcp_bytes,
|
||||
stat_tx_pdcp_sdu_discarded,
|
||||
stat_tx_pdcp_bytes_discarded);
|
||||
|
||||
len+=sprintf(&buffer[len],"[RLC] DCCH Mode %s, NB_TX_DATA = %d (bytes %d)\tNB_TX_CONTROL %d (bytes %d)\tNB_TX_RETX %d (bytes %d)\tNB_TX_RETX_BY_STATUS = %d (bytes %d)\n",
|
||||
(stat_rlc_mode==RLC_MODE_AM)? "AM": (stat_rlc_mode==RLC_MODE_UM)?"UM":"NONE",
|
||||
stat_tx_data_pdu,
|
||||
stat_tx_data_bytes,
|
||||
stat_tx_control_pdu,
|
||||
stat_tx_control_bytes,
|
||||
stat_tx_retransmit_pdu,
|
||||
stat_tx_retransmit_bytes,
|
||||
stat_tx_retransmit_pdu_by_status,
|
||||
stat_tx_retransmit_bytes_by_status);
|
||||
|
||||
|
||||
len+=sprintf(&buffer[len],"[RLC] DCCH Mode %s, NB_RX_DATA = %d (bytes %d)\tNB_RX_CONTROL %d (bytes %d)\tNB_RX_DUPL %d (bytes %d)\tNB_RX_DROP = %d (bytes %d)\tNB_RX_OUT_OF_WINDOW = %d (bytes %d)\n",
|
||||
(stat_rlc_mode==RLC_MODE_AM)? "AM": (stat_rlc_mode==RLC_MODE_UM)?"UM":"NONE",
|
||||
stat_rx_data_pdu,
|
||||
stat_rx_data_bytes,
|
||||
stat_rx_control_pdu,
|
||||
stat_rx_control_bytes,
|
||||
stat_rx_data_pdus_duplicate,
|
||||
stat_rx_data_bytes_duplicate,
|
||||
stat_rx_data_pdu_dropped,
|
||||
stat_rx_data_bytes_dropped,
|
||||
stat_rx_data_pdu_out_of_window,
|
||||
stat_rx_data_bytes_out_of_window);
|
||||
|
||||
|
||||
len+=sprintf(&buffer[len],"[RLC] DCCH Mode %s, RX_REODERING_TIMEOUT = %d\tRX_POLL_RET_TIMEOUT %d\tRX_PROHIBIT_TIME_OUT %d\n",
|
||||
(stat_rlc_mode==RLC_MODE_AM)? "AM": (stat_rlc_mode==RLC_MODE_UM)?"UM":"NONE",
|
||||
stat_timer_reordering_timed_out,
|
||||
stat_timer_poll_retransmit_timed_out,
|
||||
stat_timer_status_prohibit_timed_out);
|
||||
|
||||
len+=sprintf(&buffer[len],"[RLC] DCCH Mode %s, NB_SDU_TO_RX = %d (bytes %d)\n",
|
||||
(stat_rlc_mode==RLC_MODE_AM)? "AM": (stat_rlc_mode==RLC_MODE_UM)?"UM":"NONE",
|
||||
stat_rx_pdcp_sdu,
|
||||
stat_rx_pdcp_bytes);
|
||||
len+=sprintf(&buffer[len],"[RLC] DCCH Mode %s, NB_SDU_TO_TX = %d (bytes %d)\tNB_SDU_TO_TX_DISC %d (bytes %d)\n",
|
||||
(stat_rlc_mode==RLC_MODE_AM)? "AM": (stat_rlc_mode==RLC_MODE_UM)?"UM":"NONE",
|
||||
stat_tx_pdcp_sdu,
|
||||
stat_tx_pdcp_bytes,
|
||||
stat_tx_pdcp_sdu_discarded,
|
||||
stat_tx_pdcp_bytes_discarded);
|
||||
len+=sprintf(&buffer[len],"[RLC] DCCH Mode %s, NB_TX_DATA = %d (bytes %d)\tNB_TX_CONTROL %d (bytes %d)\tNB_TX_RETX %d (bytes %d)\tNB_TX_RETX_BY_STATUS = %d (bytes %d)\n",
|
||||
(stat_rlc_mode==RLC_MODE_AM)? "AM": (stat_rlc_mode==RLC_MODE_UM)?"UM":"NONE",
|
||||
stat_tx_data_pdu,
|
||||
stat_tx_data_bytes,
|
||||
stat_tx_control_pdu,
|
||||
stat_tx_control_bytes,
|
||||
stat_tx_retransmit_pdu,
|
||||
stat_tx_retransmit_bytes,
|
||||
stat_tx_retransmit_pdu_by_status,
|
||||
stat_tx_retransmit_bytes_by_status);
|
||||
len+=sprintf(&buffer[len],"[RLC] DCCH Mode %s, NB_RX_DATA = %d (bytes %d)\tNB_RX_CONTROL %d (bytes %d)\tNB_RX_DUPL %d (bytes %d)\tNB_RX_DROP = %d (bytes %d)\tNB_RX_OUT_OF_WINDOW = %d (bytes %d)\n",
|
||||
(stat_rlc_mode==RLC_MODE_AM)? "AM": (stat_rlc_mode==RLC_MODE_UM)?"UM":"NONE",
|
||||
stat_rx_data_pdu,
|
||||
stat_rx_data_bytes,
|
||||
stat_rx_control_pdu,
|
||||
stat_rx_control_bytes,
|
||||
stat_rx_data_pdus_duplicate,
|
||||
stat_rx_data_bytes_duplicate,
|
||||
stat_rx_data_pdu_dropped,
|
||||
stat_rx_data_bytes_dropped,
|
||||
stat_rx_data_pdu_out_of_window,
|
||||
stat_rx_data_bytes_out_of_window);
|
||||
len+=sprintf(&buffer[len],"[RLC] DCCH Mode %s, RX_REODERING_TIMEOUT = %d\tRX_POLL_RET_TIMEOUT %d\tRX_PROHIBIT_TIME_OUT %d\n",
|
||||
(stat_rlc_mode==RLC_MODE_AM)? "AM": (stat_rlc_mode==RLC_MODE_UM)?"UM":"NONE",
|
||||
stat_timer_reordering_timed_out,
|
||||
stat_timer_poll_retransmit_timed_out,
|
||||
stat_timer_status_prohibit_timed_out);
|
||||
len+=sprintf(&buffer[len],"[RLC] DCCH Mode %s, NB_SDU_TO_RX = %d (bytes %d)\n",
|
||||
(stat_rlc_mode==RLC_MODE_AM)? "AM": (stat_rlc_mode==RLC_MODE_UM)?"UM":"NONE",
|
||||
stat_rx_pdcp_sdu,
|
||||
stat_rx_pdcp_bytes);
|
||||
}
|
||||
|
||||
|
||||
rlc_status = rlc_stat_req(&ctxt,
|
||||
SRB_FLAG_NO,
|
||||
DTCH-2, // DRB_IDENTITY
|
||||
&stat_rlc_mode,
|
||||
&stat_tx_pdcp_sdu,
|
||||
&stat_tx_pdcp_bytes,
|
||||
&stat_tx_pdcp_sdu_discarded,
|
||||
&stat_tx_pdcp_bytes_discarded,
|
||||
&stat_tx_data_pdu,
|
||||
&stat_tx_data_bytes,
|
||||
&stat_tx_retransmit_pdu_by_status,
|
||||
&stat_tx_retransmit_bytes_by_status,
|
||||
&stat_tx_retransmit_pdu,
|
||||
&stat_tx_retransmit_bytes,
|
||||
&stat_tx_control_pdu,
|
||||
&stat_tx_control_bytes,
|
||||
&stat_rx_pdcp_sdu,
|
||||
&stat_rx_pdcp_bytes,
|
||||
&stat_rx_data_pdus_duplicate,
|
||||
&stat_rx_data_bytes_duplicate,
|
||||
&stat_rx_data_pdu,
|
||||
&stat_rx_data_bytes,
|
||||
&stat_rx_data_pdu_dropped,
|
||||
&stat_rx_data_bytes_dropped,
|
||||
&stat_rx_data_pdu_out_of_window,
|
||||
&stat_rx_data_bytes_out_of_window,
|
||||
&stat_rx_control_pdu,
|
||||
&stat_rx_control_bytes,
|
||||
&stat_timer_reordering_timed_out,
|
||||
&stat_timer_poll_retransmit_timed_out,
|
||||
&stat_timer_status_prohibit_timed_out);
|
||||
|
||||
SRB_FLAG_NO,
|
||||
DTCH-2, // DRB_IDENTITY
|
||||
&stat_rlc_mode,
|
||||
&stat_tx_pdcp_sdu,
|
||||
&stat_tx_pdcp_bytes,
|
||||
&stat_tx_pdcp_sdu_discarded,
|
||||
&stat_tx_pdcp_bytes_discarded,
|
||||
&stat_tx_data_pdu,
|
||||
&stat_tx_data_bytes,
|
||||
&stat_tx_retransmit_pdu_by_status,
|
||||
&stat_tx_retransmit_bytes_by_status,
|
||||
&stat_tx_retransmit_pdu,
|
||||
&stat_tx_retransmit_bytes,
|
||||
&stat_tx_control_pdu,
|
||||
&stat_tx_control_bytes,
|
||||
&stat_rx_pdcp_sdu,
|
||||
&stat_rx_pdcp_bytes,
|
||||
&stat_rx_data_pdus_duplicate,
|
||||
&stat_rx_data_bytes_duplicate,
|
||||
&stat_rx_data_pdu,
|
||||
&stat_rx_data_bytes,
|
||||
&stat_rx_data_pdu_dropped,
|
||||
&stat_rx_data_bytes_dropped,
|
||||
&stat_rx_data_pdu_out_of_window,
|
||||
&stat_rx_data_bytes_out_of_window,
|
||||
&stat_rx_control_pdu,
|
||||
&stat_rx_control_bytes,
|
||||
&stat_timer_reordering_timed_out,
|
||||
&stat_timer_poll_retransmit_timed_out,
|
||||
&stat_timer_status_prohibit_timed_out);
|
||||
|
||||
if (rlc_status == RLC_OP_STATUS_OK) {
|
||||
len+=sprintf(&buffer[len],"[RLC] DTCH Mode %s, NB_SDU_TO_TX = %d (bytes %d)\tNB_SDU_TO_TX_DISC %d (bytes %d)\n",
|
||||
(stat_rlc_mode==RLC_MODE_AM)? "AM": (stat_rlc_mode==RLC_MODE_UM)?"UM":"NONE",
|
||||
stat_tx_pdcp_sdu,
|
||||
stat_tx_pdcp_bytes,
|
||||
stat_tx_pdcp_sdu_discarded,
|
||||
stat_tx_pdcp_bytes_discarded);
|
||||
|
||||
len+=sprintf(&buffer[len],"[RLC] DTCH Mode %s, NB_TX_DATA = %d (bytes %d)\tNB_TX_CONTROL %d (bytes %d)\tNB_TX_RETX %d (bytes %d)\tNB_TX_RETX_BY_STATUS = %d (bytes %d)\n",
|
||||
(stat_rlc_mode==RLC_MODE_AM)? "AM": (stat_rlc_mode==RLC_MODE_UM)?"UM":"NONE",
|
||||
stat_tx_data_pdu,
|
||||
stat_tx_data_bytes,
|
||||
stat_tx_control_pdu,
|
||||
stat_tx_control_bytes,
|
||||
stat_tx_retransmit_pdu,
|
||||
stat_tx_retransmit_bytes,
|
||||
stat_tx_retransmit_pdu_by_status,
|
||||
stat_tx_retransmit_bytes_by_status);
|
||||
|
||||
|
||||
len+=sprintf(&buffer[len],"[RLC] DTCH Mode %s, NB_RX_DATA = %d (bytes %d)\tNB_RX_CONTROL %d (bytes %d)\tNB_RX_DUPL %d (bytes %d)\tNB_RX_DROP = %d (bytes %d)\tNB_RX_OUT_OF_WINDOW = %d (bytes %d)\n",
|
||||
(stat_rlc_mode==RLC_MODE_AM)? "AM": (stat_rlc_mode==RLC_MODE_UM)?"UM":"NONE",
|
||||
stat_rx_data_pdu,
|
||||
stat_rx_data_bytes,
|
||||
stat_rx_control_pdu,
|
||||
stat_rx_control_bytes,
|
||||
stat_rx_data_pdus_duplicate,
|
||||
stat_rx_data_bytes_duplicate,
|
||||
stat_rx_data_pdu_dropped,
|
||||
stat_rx_data_bytes_dropped,
|
||||
stat_rx_data_pdu_out_of_window,
|
||||
stat_rx_data_bytes_out_of_window);
|
||||
|
||||
|
||||
len+=sprintf(&buffer[len],"[RLC] DTCH Mode %s, RX_REODERING_TIMEOUT = %d\tRX_POLL_RET_TIMEOUT %d\tRX_PROHIBIT_TIME_OUT %d\n",
|
||||
(stat_rlc_mode==RLC_MODE_AM)? "AM": (stat_rlc_mode==RLC_MODE_UM)?"UM":"NONE",
|
||||
stat_timer_reordering_timed_out,
|
||||
stat_timer_poll_retransmit_timed_out,
|
||||
stat_timer_status_prohibit_timed_out);
|
||||
|
||||
len+=sprintf(&buffer[len],"[RLC] DTCH Mode %s, NB_SDU_TO_RX = %d (bytes %d)\n",
|
||||
(stat_rlc_mode==RLC_MODE_AM)? "AM": (stat_rlc_mode==RLC_MODE_UM)?"UM":"NONE",
|
||||
stat_rx_pdcp_sdu,
|
||||
stat_rx_pdcp_bytes);
|
||||
|
||||
}
|
||||
len+=sprintf(&buffer[len],"[RLC] DTCH Mode %s, NB_SDU_TO_TX = %d (bytes %d)\tNB_SDU_TO_TX_DISC %d (bytes %d)\n",
|
||||
(stat_rlc_mode==RLC_MODE_AM)? "AM": (stat_rlc_mode==RLC_MODE_UM)?"UM":"NONE",
|
||||
stat_tx_pdcp_sdu,
|
||||
stat_tx_pdcp_bytes,
|
||||
stat_tx_pdcp_sdu_discarded,
|
||||
stat_tx_pdcp_bytes_discarded);
|
||||
len+=sprintf(&buffer[len],"[RLC] DTCH Mode %s, NB_TX_DATA = %d (bytes %d)\tNB_TX_CONTROL %d (bytes %d)\tNB_TX_RETX %d (bytes %d)\tNB_TX_RETX_BY_STATUS = %d (bytes %d)\n",
|
||||
(stat_rlc_mode==RLC_MODE_AM)? "AM": (stat_rlc_mode==RLC_MODE_UM)?"UM":"NONE",
|
||||
stat_tx_data_pdu,
|
||||
stat_tx_data_bytes,
|
||||
stat_tx_control_pdu,
|
||||
stat_tx_control_bytes,
|
||||
stat_tx_retransmit_pdu,
|
||||
stat_tx_retransmit_bytes,
|
||||
stat_tx_retransmit_pdu_by_status,
|
||||
stat_tx_retransmit_bytes_by_status);
|
||||
len+=sprintf(&buffer[len],"[RLC] DTCH Mode %s, NB_RX_DATA = %d (bytes %d)\tNB_RX_CONTROL %d (bytes %d)\tNB_RX_DUPL %d (bytes %d)\tNB_RX_DROP = %d (bytes %d)\tNB_RX_OUT_OF_WINDOW = %d (bytes %d)\n",
|
||||
(stat_rlc_mode==RLC_MODE_AM)? "AM": (stat_rlc_mode==RLC_MODE_UM)?"UM":"NONE",
|
||||
stat_rx_data_pdu,
|
||||
stat_rx_data_bytes,
|
||||
stat_rx_control_pdu,
|
||||
stat_rx_control_bytes,
|
||||
stat_rx_data_pdus_duplicate,
|
||||
stat_rx_data_bytes_duplicate,
|
||||
stat_rx_data_pdu_dropped,
|
||||
stat_rx_data_bytes_dropped,
|
||||
stat_rx_data_pdu_out_of_window,
|
||||
stat_rx_data_bytes_out_of_window);
|
||||
len+=sprintf(&buffer[len],"[RLC] DTCH Mode %s, RX_REODERING_TIMEOUT = %d\tRX_POLL_RET_TIMEOUT %d\tRX_PROHIBIT_TIME_OUT %d\n",
|
||||
(stat_rlc_mode==RLC_MODE_AM)? "AM": (stat_rlc_mode==RLC_MODE_UM)?"UM":"NONE",
|
||||
stat_timer_reordering_timed_out,
|
||||
stat_timer_poll_retransmit_timed_out,
|
||||
stat_timer_status_prohibit_timed_out);
|
||||
len+=sprintf(&buffer[len],"[RLC] DTCH Mode %s, NB_SDU_TO_RX = %d (bytes %d)\n",
|
||||
(stat_rlc_mode==RLC_MODE_AM)? "AM": (stat_rlc_mode==RLC_MODE_UM)?"UM":"NONE",
|
||||
stat_rx_pdcp_sdu,
|
||||
stat_rx_pdcp_bytes);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
return len + 1 /* SR: for trailing \0 */;
|
||||
}
|
||||
|
||||
#ifdef PROC
|
||||
int openair2_stats_read(char *buffer, char **my_buffer, off_t off, int length)
|
||||
{
|
||||
|
||||
int openair2_stats_read(char *buffer, char **my_buffer, off_t off, int length) {
|
||||
int len = 0,fg,Overhead, Sign;
|
||||
unsigned int i,j,k,kk;
|
||||
unsigned int Mod_id = 0,CH_index;
|
||||
@@ -417,18 +382,12 @@ int openair2_stats_read(char *buffer, char **my_buffer, off_t off, int length)
|
||||
|
||||
// if (mac_xface->is_cluster_head == 0) {
|
||||
for (k=0; k<NB_INST; k++) {
|
||||
|
||||
|
||||
|
||||
if (Mac_rlc_xface->Is_cluster_head[k] == 0) {
|
||||
#ifndef PHY_EMUL_ONE_MACHINE
|
||||
Mod_id=k-NB_CH_INST;
|
||||
|
||||
len+=sprintf(&buffer[len],"UE TTI: %d\n",Mac_rlc_xface->frame);
|
||||
|
||||
for (CH_index = 0; CH_index<NB_CNX_UE; CH_index++) {
|
||||
|
||||
|
||||
if (UE_mac_inst[Mod_id].Dcch_lchan[CH_index].Active==1) {
|
||||
len+=sprintf(&buffer[len],"CH %d: Wideband SINR %d dB---\n",
|
||||
CH_index,UE_mac_inst[Mod_id].Def_meas[CH_index].Wideband_sinr);
|
||||
@@ -440,21 +399,14 @@ int openair2_stats_read(char *buffer, char **my_buffer, off_t off, int length)
|
||||
}
|
||||
|
||||
len+=sprintf(&buffer[len],"\n");
|
||||
|
||||
|
||||
len+=sprintf(&buffer[len],"BCCH %d, NB_RX_MAC = %d (%d errors)\n",
|
||||
UE_mac_inst[Mod_id].Bcch_lchan[CH_index].Lchan_info.Lchan_id.Index,
|
||||
UE_mac_inst[Mod_id].Bcch_lchan[CH_index].Lchan_info.NB_RX,
|
||||
UE_mac_inst[Mod_id].Bcch_lchan[CH_index].Lchan_info.NB_RX_ERRORS);
|
||||
|
||||
|
||||
|
||||
len+=sprintf(&buffer[len],"CCCH %d, NB_RX_MAC = %d (%d errors)\n",
|
||||
UE_mac_inst[Mod_id].Ccch_lchan[CH_index].Lchan_info.Lchan_id.Index,
|
||||
UE_mac_inst[Mod_id].Ccch_lchan[CH_index].Lchan_info.NB_RX,
|
||||
UE_mac_inst[Mod_id].Ccch_lchan[CH_index].Lchan_info.NB_RX_ERRORS);
|
||||
|
||||
|
||||
len+=sprintf(&buffer[len],"LCHAN %d (DCCH), NB_TX_MAC = %d (%d bits/TTI, %d kbits/sec), NB_RX_MAC = %d (%d errors)\n",
|
||||
UE_mac_inst[Mod_id].Dcch_lchan[CH_index].Lchan_info.Lchan_id.Index,
|
||||
UE_mac_inst[Mod_id].Dcch_lchan[CH_index].Lchan_info.NB_TX,
|
||||
@@ -484,8 +436,6 @@ int openair2_stats_read(char *buffer, char **my_buffer, off_t off, int length)
|
||||
Pdcp_stats_rx_rate[k][CH_index][i],
|
||||
(10*Pdcp_stats_rx_rate[k][CH_index][i])>>5,
|
||||
Sign*(10*Overhead)>>5);
|
||||
|
||||
|
||||
int status = rlc_stat_req (k,
|
||||
UE_mac_inst[Mod_id].Dtch_lchan[i][CH_index].Lchan_info.Lchan_id.Index,
|
||||
&tx_pdcp_sdu,
|
||||
@@ -544,18 +494,13 @@ int openair2_stats_read(char *buffer, char **my_buffer, off_t off, int length)
|
||||
UE_mac_inst[Mod_id].Dtch_lchan[i][CH_index].Lchan_info.NB_RX_TB[kk]);
|
||||
|
||||
len+=sprintf(&buffer[len],"\n");
|
||||
|
||||
|
||||
|
||||
}
|
||||
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
#endif //PHY_EMUL_ONE_MACHINE
|
||||
} else if(Mac_rlc_xface->Is_cluster_head[k] ==1) {
|
||||
|
||||
Mod_id=k;
|
||||
len+=sprintf(&buffer[len],
|
||||
"-------------------------------------------------------------------CH %d: TTI: %d------------------------------------------------------------------\n",
|
||||
@@ -567,7 +512,6 @@ int openair2_stats_read(char *buffer, char **my_buffer, off_t off, int length)
|
||||
i,//CH_rrc_inst[Mod_id].Info.UE_list[i].L2_id[0],
|
||||
CH_mac_inst[Mod_id].Def_meas[i].Wideband_sinr,
|
||||
print_cqi(CH_mac_inst[Mod_id].Def_meas[i].cqi));
|
||||
|
||||
len+=sprintf(&buffer[len],
|
||||
"[MAC] LCHAN %d (DCCH), NB_TX_MAC= %d (%d bits/TTI, %d kbits/s), NB_RX_MAC= %d (errors %d, sacch errors %d, sach errors %d, sach_missing %d)\n\n",
|
||||
CH_mac_inst[Mod_id].Dcch_lchan[i].Lchan_info.Lchan_id.Index,
|
||||
@@ -656,7 +600,6 @@ int openair2_stats_read(char *buffer, char **my_buffer, off_t off, int length)
|
||||
CH_mac_inst[Mod_id].Dtch_lchan[j][i].Lchan_info.Req_rate,
|
||||
CH_mac_inst[Mod_id].Dtch_lchan[j][i].Lchan_info.Rx_rate,
|
||||
CH_mac_inst[Mod_id].Dtch_lchan[j][i].Lchan_info.NB_BW_REQ_RX);
|
||||
|
||||
/*
|
||||
len+=sprintf(&buffer[len]," TX per TB: ");
|
||||
for(kk=0;kk<MAX_NUMBER_TB_PER_LCHAN/2;kk++)
|
||||
@@ -672,7 +615,6 @@ int openair2_stats_read(char *buffer, char **my_buffer, off_t off, int length)
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
+173
-244
@@ -61,8 +61,7 @@ extern RAN_CONTEXT_t RC;
|
||||
static int gtpv1u_dump_socket_g;
|
||||
|
||||
//-----------------------------------------------------------------------------
|
||||
int gtpv1u_eNB_create_dump_socket(void)
|
||||
{
|
||||
int gtpv1u_eNB_create_dump_socket(void) {
|
||||
struct ifreq ifr;
|
||||
int hdrincl=1;
|
||||
|
||||
@@ -92,8 +91,7 @@ int gtpv1u_eNB_create_dump_socket(void)
|
||||
}
|
||||
|
||||
//-----------------------------------------------------------------------------
|
||||
static void gtpv1u_eNB_write_dump_socket(uint8_t *buffer_pP, uint32_t buffer_lengthP)
|
||||
{
|
||||
static void gtpv1u_eNB_write_dump_socket(uint8_t *buffer_pP, uint32_t buffer_lengthP) {
|
||||
struct sockaddr_in sin;
|
||||
memset(&sin, 0, sizeof(sin));
|
||||
sin.sin_family = AF_INET;
|
||||
@@ -108,12 +106,10 @@ static void gtpv1u_eNB_write_dump_socket(uint8_t *buffer_pP, uint32_t buffer_len
|
||||
#endif
|
||||
|
||||
//-----------------------------------------------------------------------------
|
||||
static int gtpv1u_eNB_send_init_udp(const Gtpv1uS1Req * req)
|
||||
{
|
||||
static int gtpv1u_eNB_send_init_udp(const Gtpv1uS1Req *req) {
|
||||
// Create and alloc new message
|
||||
MessageDef *message_p;
|
||||
struct in_addr addr={0};
|
||||
|
||||
struct in_addr addr= {0};
|
||||
message_p = itti_alloc_new_message(TASK_GTPV1_U, UDP_INIT);
|
||||
|
||||
if (message_p == NULL) {
|
||||
@@ -124,21 +120,20 @@ static int gtpv1u_eNB_send_init_udp(const Gtpv1uS1Req * req)
|
||||
addr.s_addr = req->enb_ip_address_for_S1u_S12_S4_up;
|
||||
UDP_INIT(message_p).address = inet_ntoa(addr);
|
||||
LOG_I(GTPU, "Tx UDP_INIT IP addr %s (%x)\n", UDP_INIT(message_p).address,UDP_INIT(message_p).port);
|
||||
|
||||
MSC_LOG_EVENT(
|
||||
MSC_GTPU_ENB,
|
||||
"0 UDP bind %s:%u",
|
||||
UDP_INIT(message_p).address,
|
||||
UDP_INIT(message_p).port);
|
||||
MSC_GTPU_ENB,
|
||||
"0 UDP bind %s:%u",
|
||||
UDP_INIT(message_p).address,
|
||||
UDP_INIT(message_p).port);
|
||||
return itti_send_msg_to_task(TASK_UDP, INSTANCE_DEFAULT, message_p);
|
||||
}
|
||||
|
||||
static int gtpv1u_s1_req(
|
||||
const instance_t instanceP,
|
||||
const Gtpv1uS1Req * const req) {
|
||||
const Gtpv1uS1Req *const req) {
|
||||
memcpy(&RC.gtpv1u_data_g->enb_ip_address_for_S1u_S12_S4_up,
|
||||
&req->enb_ip_address_for_S1u_S12_S4_up,
|
||||
sizeof (req->enb_ip_address_for_S1u_S12_S4_up));
|
||||
&req->enb_ip_address_for_S1u_S12_S4_up,
|
||||
sizeof (req->enb_ip_address_for_S1u_S12_S4_up));
|
||||
gtpv1u_eNB_send_init_udp(req);
|
||||
return 0;
|
||||
}
|
||||
@@ -148,8 +143,7 @@ NwGtpv1uRcT gtpv1u_eNB_log_request(NwGtpv1uLogMgrHandleT hLogMgr,
|
||||
uint32_t logLevel,
|
||||
NwCharT *file,
|
||||
uint32_t line,
|
||||
NwCharT *logStr)
|
||||
{
|
||||
NwCharT *logStr) {
|
||||
LOG_D(GTPU, "%s\n", logStr);
|
||||
return NW_GTPV1U_OK;
|
||||
}
|
||||
@@ -161,12 +155,10 @@ NwGtpv1uRcT gtpv1u_eNB_send_udp_msg(
|
||||
uint32_t buffer_len,
|
||||
uint32_t buffer_offset,
|
||||
uint32_t peerIpAddr,
|
||||
uint16_t peerPort)
|
||||
{
|
||||
uint16_t peerPort) {
|
||||
// Create and alloc new message
|
||||
MessageDef *message_p = NULL;
|
||||
udp_data_req_t *udp_data_req_p = NULL;
|
||||
|
||||
message_p = itti_alloc_new_message(TASK_GTPV1_U, UDP_DATA_REQ);
|
||||
|
||||
if (message_p) {
|
||||
@@ -190,8 +182,7 @@ NwGtpv1uRcT gtpv1u_eNB_send_udp_msg(
|
||||
/* Callback called when a gtpv1u message arrived on UDP interface */
|
||||
NwGtpv1uRcT gtpv1u_eNB_process_stack_req(
|
||||
NwGtpv1uUlpHandleT hUlp,
|
||||
NwGtpv1uUlpApiT *pUlpApi)
|
||||
{
|
||||
NwGtpv1uUlpApiT *pUlpApi) {
|
||||
boolean_t result = FALSE;
|
||||
teid_t teid = 0;
|
||||
hashtable_rc_t hash_rc = HASH_TABLE_KEY_NOT_EXISTS;
|
||||
@@ -204,94 +195,88 @@ NwGtpv1uRcT gtpv1u_eNB_process_stack_req(
|
||||
* - T-PDU
|
||||
* - END-MARKER
|
||||
*/
|
||||
case NW_GTPV1U_ULP_API_RECV_TPDU: {
|
||||
uint8_t buffer[4096];
|
||||
uint32_t buffer_len;
|
||||
/* Nw-gptv1u stack has processed a PDU. we can schedule it to PDCP
|
||||
* for transmission.
|
||||
*/
|
||||
teid = pUlpApi->apiInfo.recvMsgInfo.teid;
|
||||
case NW_GTPV1U_ULP_API_RECV_TPDU: {
|
||||
uint8_t buffer[4096];
|
||||
uint32_t buffer_len;
|
||||
/* Nw-gptv1u stack has processed a PDU. we can schedule it to PDCP
|
||||
* for transmission.
|
||||
*/
|
||||
teid = pUlpApi->apiInfo.recvMsgInfo.teid;
|
||||
|
||||
if (NW_GTPV1U_OK != nwGtpv1uMsgGetTpdu(pUlpApi->apiInfo.recvMsgInfo.hMsg,
|
||||
buffer, &buffer_len)) {
|
||||
LOG_E(GTPU, "Error while retrieving T-PDU");
|
||||
}
|
||||
if (NW_GTPV1U_OK != nwGtpv1uMsgGetTpdu(pUlpApi->apiInfo.recvMsgInfo.hMsg,
|
||||
buffer, &buffer_len)) {
|
||||
LOG_E(GTPU, "Error while retrieving T-PDU");
|
||||
}
|
||||
|
||||
itti_free(TASK_UDP, ((NwGtpv1uMsgT*)pUlpApi->apiInfo.recvMsgInfo.hMsg)->msgBuf);
|
||||
itti_free(TASK_UDP, ((NwGtpv1uMsgT *)pUlpApi->apiInfo.recvMsgInfo.hMsg)->msgBuf);
|
||||
#if defined(GTP_DUMP_SOCKET) && GTP_DUMP_SOCKET > 0
|
||||
gtpv1u_eNB_write_dump_socket(buffer,buffer_len);
|
||||
gtpv1u_eNB_write_dump_socket(buffer,buffer_len);
|
||||
#endif
|
||||
rc = nwGtpv1uMsgDelete(RC.gtpv1u_data_g->gtpv1u_stack,
|
||||
pUlpApi->apiInfo.recvMsgInfo.hMsg);
|
||||
|
||||
rc = nwGtpv1uMsgDelete(RC.gtpv1u_data_g->gtpv1u_stack,
|
||||
pUlpApi->apiInfo.recvMsgInfo.hMsg);
|
||||
if (rc != NW_GTPV1U_OK) {
|
||||
LOG_E(GTPU, "nwGtpv1uMsgDelete failed: 0x%x\n", rc);
|
||||
}
|
||||
if (rc != NW_GTPV1U_OK) {
|
||||
LOG_E(GTPU, "nwGtpv1uMsgDelete failed: 0x%x\n", rc);
|
||||
}
|
||||
|
||||
//-----------------------
|
||||
// GTPV1U->PDCP mapping
|
||||
//-----------------------
|
||||
hash_rc = hashtable_get(RC.gtpv1u_data_g->teid_mapping, teid, (void**)>pv1u_teid_data_p);
|
||||
//-----------------------
|
||||
// GTPV1U->PDCP mapping
|
||||
//-----------------------
|
||||
hash_rc = hashtable_get(RC.gtpv1u_data_g->teid_mapping, teid, (void **)>pv1u_teid_data_p);
|
||||
|
||||
if (hash_rc == HASH_TABLE_OK) {
|
||||
if (hash_rc == HASH_TABLE_OK) {
|
||||
#if defined(LOG_GTPU) && LOG_GTPU > 0
|
||||
LOG_D(GTPU, "Received T-PDU from gtpv1u stack teid %u size %d -> enb module id %u ue module id %u rab id %u\n",
|
||||
teid,
|
||||
buffer_len,
|
||||
gtpv1u_teid_data_p->enb_id,
|
||||
gtpv1u_teid_data_p->ue_id,
|
||||
gtpv1u_teid_data_p->eps_bearer_id);
|
||||
LOG_D(GTPU, "Received T-PDU from gtpv1u stack teid %u size %d -> enb module id %u ue module id %u rab id %u\n",
|
||||
teid,
|
||||
buffer_len,
|
||||
gtpv1u_teid_data_p->enb_id,
|
||||
gtpv1u_teid_data_p->ue_id,
|
||||
gtpv1u_teid_data_p->eps_bearer_id);
|
||||
#endif
|
||||
|
||||
//#warning "LG eps bearer mapping to DRB id to do (offset -4)"
|
||||
PROTOCOL_CTXT_SET_BY_MODULE_ID(&ctxt, gtpv1u_teid_data_p->enb_id, ENB_FLAG_YES, gtpv1u_teid_data_p->ue_id, 0, 0,gtpv1u_teid_data_p->enb_id);
|
||||
MSC_LOG_TX_MESSAGE(
|
||||
MSC_GTPU_ENB,
|
||||
MSC_PDCP_ENB,
|
||||
NULL,0,
|
||||
MSC_AS_TIME_FMT" DATA-REQ rb %u size %u",
|
||||
0,0,
|
||||
(gtpv1u_teid_data_p->eps_bearer_id) ? gtpv1u_teid_data_p->eps_bearer_id - 4: 5-4,
|
||||
buffer_len);
|
||||
|
||||
result = pdcp_data_req(
|
||||
&ctxt,
|
||||
SRB_FLAG_NO,
|
||||
(gtpv1u_teid_data_p->eps_bearer_id) ? gtpv1u_teid_data_p->eps_bearer_id - 4: 5-4,
|
||||
0, // mui
|
||||
SDU_CONFIRM_NO, // confirm
|
||||
buffer_len,
|
||||
buffer,
|
||||
PDCP_TRANSMISSION_MODE_DATA
|
||||
//#warning "LG eps bearer mapping to DRB id to do (offset -4)"
|
||||
PROTOCOL_CTXT_SET_BY_MODULE_ID(&ctxt, gtpv1u_teid_data_p->enb_id, ENB_FLAG_YES, gtpv1u_teid_data_p->ue_id, 0, 0,gtpv1u_teid_data_p->enb_id);
|
||||
MSC_LOG_TX_MESSAGE(
|
||||
MSC_GTPU_ENB,
|
||||
MSC_PDCP_ENB,
|
||||
NULL,0,
|
||||
MSC_AS_TIME_FMT" DATA-REQ rb %u size %u",
|
||||
0,0,
|
||||
(gtpv1u_teid_data_p->eps_bearer_id) ? gtpv1u_teid_data_p->eps_bearer_id - 4: 5-4,
|
||||
buffer_len);
|
||||
result = pdcp_data_req(
|
||||
&ctxt,
|
||||
SRB_FLAG_NO,
|
||||
(gtpv1u_teid_data_p->eps_bearer_id) ? gtpv1u_teid_data_p->eps_bearer_id - 4: 5-4,
|
||||
0, // mui
|
||||
SDU_CONFIRM_NO, // confirm
|
||||
buffer_len,
|
||||
buffer,
|
||||
PDCP_TRANSMISSION_MODE_DATA
|
||||
#if (LTE_RRC_VERSION >= MAKE_VERSION(14, 0, 0))
|
||||
,NULL, NULL
|
||||
,NULL, NULL
|
||||
#endif
|
||||
);
|
||||
|
||||
|
||||
if ( result == FALSE ) {
|
||||
|
||||
if (ctxt.configured == FALSE )
|
||||
LOG_W(GTPU, "PDCP data request failed, cause: RB is not configured!\n") ;
|
||||
else
|
||||
LOG_W(GTPU, "PDCP data request failed\n");
|
||||
|
||||
return NW_GTPV1U_FAILURE;
|
||||
);
|
||||
|
||||
if ( result == FALSE ) {
|
||||
if (ctxt.configured == FALSE )
|
||||
LOG_W(GTPU, "PDCP data request failed, cause: RB is not configured!\n") ;
|
||||
else
|
||||
LOG_W(GTPU, "PDCP data request failed\n");
|
||||
|
||||
return NW_GTPV1U_FAILURE;
|
||||
}
|
||||
} else {
|
||||
LOG_W(GTPU, "Received T-PDU from gtpv1u stack teid %u unknown size %u", teid, buffer_len);
|
||||
}
|
||||
|
||||
} else {
|
||||
LOG_W(GTPU, "Received T-PDU from gtpv1u stack teid %u unknown size %u", teid, buffer_len);
|
||||
}
|
||||
}
|
||||
break;
|
||||
|
||||
default: {
|
||||
LOG_E(GTPU, "Received undefined UlpApi (%02x) from gtpv1u stack!\n",
|
||||
pUlpApi->apiType);
|
||||
}
|
||||
|
||||
} // end of switch
|
||||
|
||||
|
||||
default: {
|
||||
LOG_E(GTPU, "Received undefined UlpApi (%02x) from gtpv1u stack!\n",
|
||||
pUlpApi->apiType);
|
||||
}
|
||||
} // end of switch
|
||||
|
||||
return NW_GTPV1U_OK;
|
||||
}
|
||||
|
||||
@@ -301,8 +286,7 @@ int data_recv_callback(uint16_t portP,
|
||||
uint32_t address,
|
||||
uint8_t *buffer,
|
||||
uint32_t length,
|
||||
void *arg_p)
|
||||
{
|
||||
void *arg_p) {
|
||||
gtpv1u_data_t *gtpv1u_data_p;
|
||||
|
||||
if (arg_p == NULL) {
|
||||
@@ -310,7 +294,6 @@ int data_recv_callback(uint16_t portP,
|
||||
}
|
||||
|
||||
gtpv1u_data_p = (gtpv1u_data_t *)arg_p;
|
||||
|
||||
return nwGtpv1uProcessUdpReq(gtpv1u_data_p->gtpv1u_stack,
|
||||
buffer,
|
||||
length,
|
||||
@@ -421,9 +404,7 @@ static NwGtpv1uRcT gtpv1u_start_timer_wrapper(
|
||||
uint32_t timeoutUsec,
|
||||
uint32_t tmrType,
|
||||
void *timeoutArg,
|
||||
NwGtpv1uTimerHandleT *hTmr)
|
||||
{
|
||||
|
||||
NwGtpv1uTimerHandleT *hTmr) {
|
||||
NwGtpv1uRcT rc = NW_GTPV1U_OK;
|
||||
long timer_id;
|
||||
|
||||
@@ -453,11 +434,8 @@ static NwGtpv1uRcT gtpv1u_start_timer_wrapper(
|
||||
static NwGtpv1uRcT
|
||||
gtpv1u_stop_timer_wrapper(
|
||||
NwGtpv1uTimerMgrHandleT tmrMgrHandle,
|
||||
NwGtpv1uTimerHandleT hTmr)
|
||||
{
|
||||
|
||||
NwGtpv1uTimerHandleT hTmr) {
|
||||
NwGtpv1uRcT rc = NW_GTPV1U_OK;
|
||||
|
||||
return rc;
|
||||
}
|
||||
|
||||
@@ -468,18 +446,14 @@ gtpv1u_initial_req(
|
||||
gtpv1u_data_t *gtpv1u_data_pP,
|
||||
teid_t teidP,
|
||||
tcp_udp_port_t portP,
|
||||
uint32_t address)
|
||||
{
|
||||
uint32_t address) {
|
||||
NwGtpv1uUlpApiT ulp_req;
|
||||
NwGtpv1uRcT rc = NW_GTPV1U_FAILURE;
|
||||
|
||||
memset(&ulp_req, 0, sizeof(NwGtpv1uUlpApiT));
|
||||
|
||||
ulp_req.apiType = NW_GTPV1U_ULP_API_INITIAL_REQ;
|
||||
ulp_req.apiInfo.initialReqInfo.teid = teidP;
|
||||
ulp_req.apiInfo.initialReqInfo.peerPort = portP;
|
||||
ulp_req.apiInfo.initialReqInfo.peerIp = address;
|
||||
|
||||
rc = nwGtpv1uProcessUlpReq(gtpv1u_data_pP->gtpv1u_stack, &ulp_req);
|
||||
|
||||
if (rc == NW_GTPV1U_OK) {
|
||||
@@ -500,9 +474,7 @@ gtpv1u_new_data_req(
|
||||
uint8_t *buffer_pP,
|
||||
uint32_t buf_lenP,
|
||||
uint32_t buf_offsetP
|
||||
)
|
||||
{
|
||||
|
||||
) {
|
||||
NwGtpv1uUlpApiT stack_req;
|
||||
NwGtpv1uRcT rc = NW_GTPV1U_FAILURE;
|
||||
struct gtpv1u_ue_data_s ue;
|
||||
@@ -510,17 +482,14 @@ gtpv1u_new_data_req(
|
||||
struct gtpv1u_bearer_s *bearer_p = NULL;
|
||||
hashtable_rc_t hash_rc = HASH_TABLE_KEY_NOT_EXISTS;;
|
||||
gtpv1u_data_t *gtpv1u_data_p = NULL;
|
||||
|
||||
memset(&ue, 0, sizeof(struct gtpv1u_ue_data_s));
|
||||
ue.ue_id = ue_rntiP;
|
||||
|
||||
AssertFatal(enb_module_idP >=0, "Bad parameter enb module id %u\n", enb_module_idP);
|
||||
AssertFatal((rab_idP - GTPV1U_BEARER_OFFSET)< GTPV1U_MAX_BEARERS_ID, "Bad parameter rab id %u\n", rab_idP);
|
||||
AssertFatal((rab_idP - GTPV1U_BEARER_OFFSET) >= 0 , "Bad parameter rab id %u\n", rab_idP);
|
||||
|
||||
gtpv1u_data_p = RC.gtpv1u_data_g;
|
||||
/* Check that UE context is present in ue map. */
|
||||
hash_rc = hashtable_get(gtpv1u_data_p->ue_mapping, (uint64_t)ue_rntiP, (void**)&ue_inst_p);
|
||||
hash_rc = hashtable_get(gtpv1u_data_p->ue_mapping, (uint64_t)ue_rntiP, (void **)&ue_inst_p);
|
||||
|
||||
if (hash_rc == HASH_TABLE_KEY_NOT_EXISTS ) {
|
||||
LOG_E(GTPU, "[UE %d] Trying to send data on non-existing UE context\n", ue_rntiP);
|
||||
@@ -536,18 +505,16 @@ gtpv1u_new_data_req(
|
||||
if (bearer_p->state != BEARER_UP) {
|
||||
LOG_W(GTPU, "Trying to send data over bearer with state(%u) != BEARER_UP\n",
|
||||
bearer_p->state);
|
||||
//#warning LG: HACK WHILE WAITING FOR NAS, normally return -1
|
||||
//#warning LG: HACK WHILE WAITING FOR NAS, normally return -1
|
||||
|
||||
if (bearer_p->state != BEARER_IN_CONFIG)
|
||||
return -1;
|
||||
}
|
||||
|
||||
memset(&stack_req, 0, sizeof(NwGtpv1uUlpApiT));
|
||||
|
||||
stack_req.apiType = NW_GTPV1U_ULP_API_SEND_TPDU;
|
||||
stack_req.apiInfo.sendtoInfo.teid = bearer_p->teid_sgw;
|
||||
stack_req.apiInfo.sendtoInfo.ipAddr = bearer_p->sgw_ip_addr;
|
||||
|
||||
LOG_D(GTPU, "TX TO TEID %u addr 0x%x\n",bearer_p->teid_sgw, bearer_p->sgw_ip_addr);
|
||||
rc = nwGtpv1uGpduMsgNew(gtpv1u_data_p->gtpv1u_stack,
|
||||
bearer_p->teid_sgw,
|
||||
@@ -587,10 +554,9 @@ gtpv1u_new_data_req(
|
||||
int
|
||||
gtpv1u_create_s1u_tunnel(
|
||||
const instance_t instanceP,
|
||||
const gtpv1u_enb_create_tunnel_req_t * const create_tunnel_req_pP,
|
||||
gtpv1u_enb_create_tunnel_resp_t * const create_tunnel_resp_pP
|
||||
)
|
||||
{
|
||||
const gtpv1u_enb_create_tunnel_req_t *const create_tunnel_req_pP,
|
||||
gtpv1u_enb_create_tunnel_resp_t *const create_tunnel_resp_pP
|
||||
) {
|
||||
/* Create a new nw-gtpv1-u stack req using API */
|
||||
NwGtpv1uUlpApiT stack_req;
|
||||
NwGtpv1uRcT rc = NW_GTPV1U_FAILURE;
|
||||
@@ -606,17 +572,14 @@ gtpv1u_create_s1u_tunnel(
|
||||
int ip_offset = 0;
|
||||
in_addr_t in_addr;
|
||||
int addrs_length_in_bytes= 0;
|
||||
|
||||
|
||||
MSC_LOG_RX_MESSAGE(
|
||||
MSC_GTPU_ENB,
|
||||
MSC_RRC_ENB,
|
||||
NULL,0,
|
||||
MSC_AS_TIME_FMT" CREATE_TUNNEL_REQ RNTI %"PRIx16" inst %u ntuns %u ebid %u sgw-s1u teid %u",
|
||||
0,0,create_tunnel_req_pP->rnti, instanceP,
|
||||
create_tunnel_req_pP->num_tunnels, create_tunnel_req_pP->eps_bearer_id[0],
|
||||
create_tunnel_req_pP->sgw_S1u_teid[0]);
|
||||
|
||||
MSC_GTPU_ENB,
|
||||
MSC_RRC_ENB,
|
||||
NULL,0,
|
||||
MSC_AS_TIME_FMT" CREATE_TUNNEL_REQ RNTI %"PRIx16" inst %u ntuns %u ebid %u sgw-s1u teid %u",
|
||||
0,0,create_tunnel_req_pP->rnti, instanceP,
|
||||
create_tunnel_req_pP->num_tunnels, create_tunnel_req_pP->eps_bearer_id[0],
|
||||
create_tunnel_req_pP->sgw_S1u_teid[0]);
|
||||
create_tunnel_resp_pP->rnti = create_tunnel_req_pP->rnti;
|
||||
create_tunnel_resp_pP->status = 0;
|
||||
create_tunnel_resp_pP->num_tunnels = 0;
|
||||
@@ -627,7 +590,6 @@ gtpv1u_create_s1u_tunnel(
|
||||
LOG_D(GTPU, "Rx GTPV1U_ENB_CREATE_TUNNEL_REQ ue rnti %x eps bearer id %u\n",
|
||||
create_tunnel_req_pP->rnti, eps_bearer_id);
|
||||
memset(&stack_req, 0, sizeof(NwGtpv1uUlpApiT));
|
||||
|
||||
stack_req.apiType = NW_GTPV1U_ULP_API_CREATE_TUNNEL_ENDPOINT;
|
||||
|
||||
do {
|
||||
@@ -636,7 +598,6 @@ gtpv1u_create_s1u_tunnel(
|
||||
stack_req.apiInfo.createTunnelEndPointInfo.teid = s1u_teid;
|
||||
stack_req.apiInfo.createTunnelEndPointInfo.hUlpSession = 0;
|
||||
stack_req.apiInfo.createTunnelEndPointInfo.hStackSession = 0;
|
||||
|
||||
rc = nwGtpv1uProcessUlpReq(RC.gtpv1u_data_g->gtpv1u_stack, &stack_req);
|
||||
LOG_D(GTPU, ".\n");
|
||||
} while (rc != NW_GTPV1U_OK);
|
||||
@@ -647,7 +608,6 @@ gtpv1u_create_s1u_tunnel(
|
||||
hash_rc = hashtable_get(RC.gtpv1u_data_g->ue_mapping, create_tunnel_req_pP->rnti, (void **)>pv1u_ue_data_p);
|
||||
|
||||
if ((hash_rc == HASH_TABLE_KEY_NOT_EXISTS) || (hash_rc == HASH_TABLE_OK)) {
|
||||
|
||||
if (hash_rc == HASH_TABLE_KEY_NOT_EXISTS) {
|
||||
gtpv1u_ue_data_p = calloc (1, sizeof(gtpv1u_ue_data_t));
|
||||
hash_rc = hashtable_insert(RC.gtpv1u_data_g->ue_mapping, create_tunnel_req_pP->rnti, gtpv1u_ue_data_p);
|
||||
@@ -660,7 +620,6 @@ gtpv1u_create_s1u_tunnel(
|
||||
&RC.gtpv1u_data_g->enb_ip_address_for_S1u_S12_S4_up,
|
||||
sizeof (in_addr_t));
|
||||
create_tunnel_resp_pP->enb_addr.length = sizeof (in_addr_t);
|
||||
|
||||
addrs_length_in_bytes = create_tunnel_req_pP->sgw_addr[i].length / 8;
|
||||
AssertFatal((addrs_length_in_bytes == 4) ||
|
||||
(addrs_length_in_bytes == 16) ||
|
||||
@@ -670,7 +629,7 @@ gtpv1u_create_s1u_tunnel(
|
||||
|
||||
if ((addrs_length_in_bytes == 4) ||
|
||||
(addrs_length_in_bytes == 20)) {
|
||||
in_addr = *((in_addr_t*)create_tunnel_req_pP->sgw_addr[i].buffer);
|
||||
in_addr = *((in_addr_t *)create_tunnel_req_pP->sgw_addr[i].buffer);
|
||||
ip_offset = 4;
|
||||
gtpv1u_ue_data_p->bearers[eps_bearer_id - GTPV1U_BEARER_OFFSET].sgw_ip_addr = in_addr;
|
||||
}
|
||||
@@ -688,7 +647,6 @@ gtpv1u_create_s1u_tunnel(
|
||||
gtpv1u_ue_data_p->bearers[eps_bearer_id - GTPV1U_BEARER_OFFSET].teid_sgw = create_tunnel_req_pP->sgw_S1u_teid[i];
|
||||
gtpv1u_ue_data_p->num_bearers++;
|
||||
create_tunnel_resp_pP->enb_S1u_teid[i] = s1u_teid;
|
||||
|
||||
} else {
|
||||
create_tunnel_resp_pP->enb_S1u_teid[i] = 0;
|
||||
create_tunnel_resp_pP->status = 0xFF;
|
||||
@@ -696,11 +654,10 @@ gtpv1u_create_s1u_tunnel(
|
||||
|
||||
create_tunnel_resp_pP->eps_bearer_id[i] = eps_bearer_id;
|
||||
create_tunnel_resp_pP->num_tunnels += 1;
|
||||
|
||||
//-----------------------
|
||||
// GTPV1U->PDCP mapping
|
||||
//-----------------------
|
||||
hash_rc = hashtable_get(RC.gtpv1u_data_g->teid_mapping, s1u_teid, (void**)>pv1u_teid_data_p);
|
||||
hash_rc = hashtable_get(RC.gtpv1u_data_g->teid_mapping, s1u_teid, (void **)>pv1u_teid_data_p);
|
||||
|
||||
if (hash_rc == HASH_TABLE_KEY_NOT_EXISTS) {
|
||||
gtpv1u_teid_data_p = calloc (1, sizeof(gtpv1u_teid_data_t));
|
||||
@@ -714,14 +671,14 @@ gtpv1u_create_s1u_tunnel(
|
||||
create_tunnel_resp_pP->status = 0xFF;
|
||||
}
|
||||
}
|
||||
MSC_LOG_TX_MESSAGE(
|
||||
MSC_GTPU_ENB,
|
||||
MSC_RRC_ENB,
|
||||
NULL,0,
|
||||
"0 GTPV1U_ENB_CREATE_TUNNEL_RESP rnti %x teid %x",
|
||||
create_tunnel_resp_pP->rnti,
|
||||
s1u_teid);
|
||||
|
||||
MSC_LOG_TX_MESSAGE(
|
||||
MSC_GTPU_ENB,
|
||||
MSC_RRC_ENB,
|
||||
NULL,0,
|
||||
"0 GTPV1U_ENB_CREATE_TUNNEL_RESP rnti %x teid %x",
|
||||
create_tunnel_resp_pP->rnti,
|
||||
s1u_teid);
|
||||
LOG_D(GTPU, "Tx GTPV1U_ENB_CREATE_TUNNEL_RESP ue rnti %x status %d\n",
|
||||
create_tunnel_req_pP->rnti,
|
||||
create_tunnel_resp_pP->status);
|
||||
@@ -729,12 +686,10 @@ gtpv1u_create_s1u_tunnel(
|
||||
}
|
||||
|
||||
int gtpv1u_update_s1u_tunnel(
|
||||
const instance_t instanceP,
|
||||
const gtpv1u_enb_create_tunnel_req_t * const create_tunnel_req_pP,
|
||||
const rnti_t prior_rnti
|
||||
)
|
||||
{
|
||||
|
||||
const instance_t instanceP,
|
||||
const gtpv1u_enb_create_tunnel_req_t *const create_tunnel_req_pP,
|
||||
const rnti_t prior_rnti
|
||||
) {
|
||||
/* Local tunnel end-point identifier */
|
||||
teid_t s1u_teid = 0;
|
||||
gtpv1u_teid_data_t *gtpv1u_teid_data_p = NULL;
|
||||
@@ -744,12 +699,12 @@ int gtpv1u_update_s1u_tunnel(
|
||||
hashtable_rc_t hash_rc = HASH_TABLE_KEY_NOT_EXISTS;
|
||||
int i,j;
|
||||
uint8_t bearers_num = 0,bearers_total = 0;
|
||||
|
||||
//-----------------------
|
||||
// PDCP->GTPV1U mapping
|
||||
//-----------------------
|
||||
hash_rc = hashtable_get(RC.gtpv1u_data_g->ue_mapping, prior_rnti, (void **)>pv1u_ue_data_p);
|
||||
if(hash_rc != HASH_TABLE_OK){
|
||||
|
||||
if(hash_rc != HASH_TABLE_OK) {
|
||||
LOG_E(GTPU,"Error get ue_mapping(rnti=%x) from GTPV1U hashtable error\n", prior_rnti);
|
||||
return -1;
|
||||
}
|
||||
@@ -757,65 +712,66 @@ int gtpv1u_update_s1u_tunnel(
|
||||
gtpv1u_ue_data_new_p = calloc (1, sizeof(gtpv1u_ue_data_t));
|
||||
memcpy(gtpv1u_ue_data_new_p,gtpv1u_ue_data_p,sizeof(gtpv1u_ue_data_t));
|
||||
gtpv1u_ue_data_new_p->ue_id = create_tunnel_req_pP->rnti;
|
||||
|
||||
hash_rc = hashtable_insert(RC.gtpv1u_data_g->ue_mapping, create_tunnel_req_pP->rnti, gtpv1u_ue_data_new_p);
|
||||
AssertFatal(hash_rc == HASH_TABLE_OK, "Error inserting ue_mapping in GTPV1U hashtable");
|
||||
LOG_I(GTPU, "inserting ue_mapping(rnti=%x) in GTPV1U hashtable\n",
|
||||
create_tunnel_req_pP->rnti);
|
||||
|
||||
create_tunnel_req_pP->rnti);
|
||||
hash_rc = hashtable_remove(RC.gtpv1u_data_g->ue_mapping, prior_rnti);
|
||||
LOG_I(GTPU, "hashtable_remove ue_mapping(rnti=%x) in GTPV1U hashtable\n",
|
||||
prior_rnti);
|
||||
prior_rnti);
|
||||
//-----------------------
|
||||
// GTPV1U->PDCP mapping
|
||||
//-----------------------
|
||||
bearers_total =gtpv1u_ue_data_new_p->num_bearers;
|
||||
for(j = 0;j<GTPV1U_MAX_BEARERS_ID;j++){
|
||||
|
||||
for(j = 0; j<GTPV1U_MAX_BEARERS_ID; j++) {
|
||||
if(gtpv1u_ue_data_new_p->bearers[j].state != BEARER_IN_CONFIG)
|
||||
continue;
|
||||
|
||||
bearers_num++;
|
||||
|
||||
for (i = 0; i < create_tunnel_req_pP->num_tunnels; i++) {
|
||||
if(j == (create_tunnel_req_pP->eps_bearer_id[i]-GTPV1U_BEARER_OFFSET))
|
||||
break;
|
||||
}
|
||||
if(i < create_tunnel_req_pP->num_tunnels){
|
||||
|
||||
if(i < create_tunnel_req_pP->num_tunnels) {
|
||||
s1u_teid = gtpv1u_ue_data_new_p->bearers[j].teid_eNB;
|
||||
hash_rc = hashtable_get(RC.gtpv1u_data_g->teid_mapping, s1u_teid, (void**)>pv1u_teid_data_p);
|
||||
hash_rc = hashtable_get(RC.gtpv1u_data_g->teid_mapping, s1u_teid, (void **)>pv1u_teid_data_p);
|
||||
|
||||
if (hash_rc == HASH_TABLE_OK) {
|
||||
gtpv1u_teid_data_p->ue_id = create_tunnel_req_pP->rnti;
|
||||
gtpv1u_teid_data_p->eps_bearer_id = create_tunnel_req_pP->eps_bearer_id[i];
|
||||
|
||||
LOG_I(GTPU, "updata teid_mapping te_id %u (prior_rnti %x rnti %x) in GTPV1U hashtable\n",
|
||||
s1u_teid,prior_rnti,create_tunnel_req_pP->rnti);
|
||||
}else{
|
||||
} else {
|
||||
LOG_W(GTPU, "Error get teid mapping(s1u_teid=%u) from GTPV1U hashtable", s1u_teid);
|
||||
}
|
||||
}else{
|
||||
} else {
|
||||
s1u_teid = gtpv1u_ue_data_new_p->bearers[j].teid_eNB;
|
||||
hash_rc = hashtable_remove(RC.gtpv1u_data_g->teid_mapping, s1u_teid);
|
||||
|
||||
if (hash_rc != HASH_TABLE_OK) {
|
||||
LOG_D(GTPU, "Removed user rnti %x , enb S1U teid %u not found\n", prior_rnti, s1u_teid);
|
||||
}
|
||||
|
||||
gtpv1u_ue_data_new_p->bearers[j].state = BEARER_DOWN;
|
||||
gtpv1u_ue_data_new_p->num_bearers--;
|
||||
LOG_I(GTPU, "delete teid_mapping te_id %u (rnti%x) bearer_id %d in GTPV1U hashtable\n",
|
||||
s1u_teid,prior_rnti,j+GTPV1U_BEARER_OFFSET);;
|
||||
}
|
||||
|
||||
if(bearers_num > bearers_total)
|
||||
break;
|
||||
}
|
||||
return 0;
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
//-----------------------------------------------------------------------------
|
||||
static int gtpv1u_delete_s1u_tunnel(
|
||||
const instance_t instanceP,
|
||||
const gtpv1u_enb_delete_tunnel_req_t * const req_pP)
|
||||
{
|
||||
const gtpv1u_enb_delete_tunnel_req_t *const req_pP) {
|
||||
NwGtpv1uUlpApiT stack_req;
|
||||
NwGtpv1uRcT rc = NW_GTPV1U_FAILURE;
|
||||
MessageDef *message_p = NULL;
|
||||
@@ -823,22 +779,16 @@ static int gtpv1u_delete_s1u_tunnel(
|
||||
hashtable_rc_t hash_rc = HASH_TABLE_KEY_NOT_EXISTS;
|
||||
teid_t teid_eNB = 0;
|
||||
int erab_index = 0;
|
||||
|
||||
message_p = itti_alloc_new_message(TASK_GTPV1_U, GTPV1U_ENB_DELETE_TUNNEL_RESP);
|
||||
|
||||
GTPV1U_ENB_DELETE_TUNNEL_RESP(message_p).rnti = req_pP->rnti;
|
||||
GTPV1U_ENB_DELETE_TUNNEL_RESP(message_p).status = 0;
|
||||
|
||||
|
||||
hash_rc = hashtable_get(RC.gtpv1u_data_g->ue_mapping, req_pP->rnti, (void**)>pv1u_ue_data_p);
|
||||
hash_rc = hashtable_get(RC.gtpv1u_data_g->ue_mapping, req_pP->rnti, (void **)>pv1u_ue_data_p);
|
||||
|
||||
if (hash_rc == HASH_TABLE_OK) {
|
||||
|
||||
for (erab_index = 0; erab_index < req_pP->num_erab; erab_index++) {
|
||||
teid_eNB = gtpv1u_ue_data_p->bearers[req_pP->eps_bearer_id[erab_index] - GTPV1U_BEARER_OFFSET].teid_eNB;
|
||||
LOG_D(GTPU, "Rx GTPV1U_ENB_DELETE_TUNNEL user rnti %x eNB S1U teid %u eps bearer id %u\n",
|
||||
req_pP->rnti, teid_eNB, req_pP->eps_bearer_id[erab_index]);
|
||||
|
||||
{
|
||||
memset(&stack_req, 0, sizeof(NwGtpv1uUlpApiT));
|
||||
stack_req.apiType = NW_GTPV1U_ULP_API_DESTROY_TUNNEL_ENDPOINT;
|
||||
@@ -846,7 +796,6 @@ static int gtpv1u_delete_s1u_tunnel(
|
||||
req_pP->eps_bearer_id[erab_index],
|
||||
teid_eNB);
|
||||
stack_req.apiInfo.destroyTunnelEndPointInfo.hStackSessionHandle = gtpv1u_ue_data_p->bearers[req_pP->eps_bearer_id[erab_index] - GTPV1U_BEARER_OFFSET].teid_eNB_stack_session;
|
||||
|
||||
rc = nwGtpv1uProcessUlpReq(RC.gtpv1u_data_g->gtpv1u_stack, &stack_req);
|
||||
LOG_D(GTPU, ".\n");
|
||||
}
|
||||
@@ -881,36 +830,30 @@ static int gtpv1u_delete_s1u_tunnel(
|
||||
}
|
||||
}// else silently do nothing
|
||||
|
||||
|
||||
LOG_D(GTPU, "Tx GTPV1U_ENB_DELETE_TUNNEL_RESP user rnti %x eNB S1U teid %u status %u\n",
|
||||
GTPV1U_ENB_DELETE_TUNNEL_RESP(message_p).rnti,
|
||||
GTPV1U_ENB_DELETE_TUNNEL_RESP(message_p).enb_S1u_teid,
|
||||
GTPV1U_ENB_DELETE_TUNNEL_RESP(message_p).status);
|
||||
|
||||
MSC_LOG_TX_MESSAGE(
|
||||
MSC_GTPU_ENB,
|
||||
MSC_RRC_ENB,
|
||||
NULL,0,
|
||||
"0 GTPV1U_ENB_DELETE_TUNNEL_RESP rnti %x teid %x",
|
||||
GTPV1U_ENB_DELETE_TUNNEL_RESP(message_p).rnti,
|
||||
teid_eNB);
|
||||
|
||||
MSC_GTPU_ENB,
|
||||
MSC_RRC_ENB,
|
||||
NULL,0,
|
||||
"0 GTPV1U_ENB_DELETE_TUNNEL_RESP rnti %x teid %x",
|
||||
GTPV1U_ENB_DELETE_TUNNEL_RESP(message_p).rnti,
|
||||
teid_eNB);
|
||||
return itti_send_msg_to_task(TASK_RRC_ENB, instanceP, message_p);
|
||||
}
|
||||
|
||||
|
||||
//-----------------------------------------------------------------------------
|
||||
int gtpv1u_eNB_init(void)
|
||||
{
|
||||
int gtpv1u_eNB_init(void) {
|
||||
NwGtpv1uRcT rc = NW_GTPV1U_FAILURE;
|
||||
NwGtpv1uUlpEntityT ulp;
|
||||
NwGtpv1uUdpEntityT udp;
|
||||
NwGtpv1uLogMgrEntityT log;
|
||||
NwGtpv1uTimerMgrEntityT tmr;
|
||||
|
||||
// enb_properties_p = enb_config_get()->properties[0];
|
||||
RC.gtpv1u_data_g = (gtpv1u_data_t*)calloc(sizeof(gtpv1u_data_t),1);
|
||||
|
||||
RC.gtpv1u_data_g = (gtpv1u_data_t *)calloc(sizeof(gtpv1u_data_t),1);
|
||||
LOG_I(GTPU, "Initializing GTPU stack %p\n",&RC.gtpv1u_data_g);
|
||||
//gtpv1u_data_g.gtpv1u_stack;
|
||||
/* Initialize UE hashtable */
|
||||
@@ -918,8 +861,7 @@ int gtpv1u_eNB_init(void)
|
||||
AssertFatal(RC.gtpv1u_data_g->ue_mapping != NULL, " ERROR Initializing TASK_GTPV1_U task interface: in hashtable_create returned %p\n", RC.gtpv1u_data_g->ue_mapping);
|
||||
RC.gtpv1u_data_g->teid_mapping = hashtable_create (256, NULL, NULL);
|
||||
AssertFatal(RC.gtpv1u_data_g->teid_mapping != NULL, " ERROR Initializing TASK_GTPV1_U task interface: in hashtable_create\n");
|
||||
// RC.gtpv1u_data_g.enb_ip_address_for_S1u_S12_S4_up = enb_properties_p->enb_ipv4_address_for_S1U;
|
||||
|
||||
// RC.gtpv1u_data_g.enb_ip_address_for_S1u_S12_S4_up = enb_properties_p->enb_ipv4_address_for_S1U;
|
||||
//gtpv1u_data_g.udp_data;
|
||||
RC.gtpv1u_data_g->seq_num = 0;
|
||||
RC.gtpv1u_data_g->restart_counter = 0;
|
||||
@@ -936,7 +878,6 @@ int gtpv1u_eNB_init(void)
|
||||
return -1;
|
||||
}
|
||||
|
||||
|
||||
/* Set the ULP API callback. Called once message have been processed by the
|
||||
* nw-gtpv1u stack.
|
||||
*/
|
||||
@@ -983,30 +924,26 @@ int gtpv1u_eNB_init(void)
|
||||
}
|
||||
|
||||
#endif
|
||||
|
||||
LOG_D(GTPU, "Initializing GTPV1U interface for eNB: DONE\n");
|
||||
return 0;
|
||||
}
|
||||
|
||||
//-----------------------------------------------------------------------------
|
||||
void *gtpv1u_eNB_process_itti_msg(void *notUsed) {
|
||||
/* Trying to fetch a message from the message queue.
|
||||
* If the queue is empty, this function will block till a
|
||||
* message is sent to the task.
|
||||
*/
|
||||
instance_t instance;
|
||||
MessageDef *received_message_p = NULL;
|
||||
int rc = 0;
|
||||
|
||||
itti_receive_msg(TASK_GTPV1_U, &received_message_p);
|
||||
VCD_SIGNAL_DUMPER_DUMP_FUNCTION_BY_NAME(VCD_SIGNAL_DUMPER_FUNCTIONS_GTPV1U_ENB_TASK, VCD_FUNCTION_IN);
|
||||
DevAssert(received_message_p != NULL);
|
||||
|
||||
instance = ITTI_MSG_INSTANCE(received_message_p);
|
||||
//msg_name_p = ITTI_MSG_NAME(received_message_p);
|
||||
|
||||
switch (ITTI_MSG_ID(received_message_p)) {
|
||||
/* Trying to fetch a message from the message queue.
|
||||
* If the queue is empty, this function will block till a
|
||||
* message is sent to the task.
|
||||
*/
|
||||
instance_t instance;
|
||||
MessageDef *received_message_p = NULL;
|
||||
int rc = 0;
|
||||
itti_receive_msg(TASK_GTPV1_U, &received_message_p);
|
||||
VCD_SIGNAL_DUMPER_DUMP_FUNCTION_BY_NAME(VCD_SIGNAL_DUMPER_FUNCTIONS_GTPV1U_ENB_TASK, VCD_FUNCTION_IN);
|
||||
DevAssert(received_message_p != NULL);
|
||||
instance = ITTI_MSG_INSTANCE(received_message_p);
|
||||
//msg_name_p = ITTI_MSG_NAME(received_message_p);
|
||||
|
||||
switch (ITTI_MSG_ID(received_message_p)) {
|
||||
case GTPV1U_ENB_S1_REQ:
|
||||
gtpv1u_s1_req(instance, &received_message_p->ittiMsg.gtpv1uS1Req);
|
||||
|
||||
@@ -1037,17 +974,14 @@ void *gtpv1u_eNB_process_itti_msg(void *notUsed) {
|
||||
gtpv1u_ue_data_t *gtpv1u_ue_data_p = NULL;
|
||||
teid_t enb_s1u_teid = 0;
|
||||
teid_t sgw_s1u_teid = 0;
|
||||
|
||||
VCD_SIGNAL_DUMPER_DUMP_FUNCTION_BY_NAME(VCD_SIGNAL_DUMPER_FUNCTIONS_GTPV1U_PROCESS_TUNNEL_DATA_REQ, VCD_FUNCTION_IN);
|
||||
data_req_p = >PV1U_ENB_TUNNEL_DATA_REQ(received_message_p);
|
||||
//ipv4_send_data(ipv4_data_p->sd, data_ind_p->buffer, data_ind_p->length);
|
||||
|
||||
#if defined(GTP_DUMP_SOCKET) && GTP_DUMP_SOCKET > 0
|
||||
gtpv1u_eNB_write_dump_socket(&data_req_p->buffer[data_req_p->offset],data_req_p->length);
|
||||
#endif
|
||||
memset(&stack_req, 0, sizeof(NwGtpv1uUlpApiT));
|
||||
|
||||
hash_rc = hashtable_get(RC.gtpv1u_data_g->ue_mapping, (uint64_t)data_req_p->rnti, (void**)>pv1u_ue_data_p);
|
||||
hash_rc = hashtable_get(RC.gtpv1u_data_g->ue_mapping, (uint64_t)data_req_p->rnti, (void **)>pv1u_ue_data_p);
|
||||
|
||||
if (hash_rc == HASH_TABLE_KEY_NOT_EXISTS) {
|
||||
LOG_E(GTPU, "nwGtpv1uProcessUlpReq failed: while getting ue rnti %x in hashtable ue_mapping\n", data_req_p->rnti);
|
||||
@@ -1058,7 +992,6 @@ void *gtpv1u_eNB_process_itti_msg(void *notUsed) {
|
||||
stack_req.apiType = NW_GTPV1U_ULP_API_SEND_TPDU;
|
||||
stack_req.apiInfo.sendtoInfo.teid = sgw_s1u_teid;
|
||||
stack_req.apiInfo.sendtoInfo.ipAddr = gtpv1u_ue_data_p->bearers[data_req_p->rab_id - GTPV1U_BEARER_OFFSET].sgw_ip_addr;
|
||||
|
||||
rc = nwGtpv1uGpduMsgNew(
|
||||
RC.gtpv1u_data_g->gtpv1u_stack,
|
||||
sgw_s1u_teid,
|
||||
@@ -1072,7 +1005,7 @@ void *gtpv1u_eNB_process_itti_msg(void *notUsed) {
|
||||
if (rc != NW_GTPV1U_OK) {
|
||||
LOG_E(GTPU, "nwGtpv1uGpduMsgNew failed: 0x%x\n", rc);
|
||||
MSC_LOG_EVENT(MSC_GTPU_ENB,"0 Failed send G-PDU ltid %u rtid %u size %u",
|
||||
enb_s1u_teid,sgw_s1u_teid,data_req_p->length);
|
||||
enb_s1u_teid,sgw_s1u_teid,data_req_p->length);
|
||||
(void)enb_s1u_teid; /* avoid gcc warning "set but not used" */
|
||||
} else {
|
||||
rc = nwGtpv1uProcessUlpReq(RC.gtpv1u_data_g->gtpv1u_stack, &stack_req);
|
||||
@@ -1080,19 +1013,18 @@ void *gtpv1u_eNB_process_itti_msg(void *notUsed) {
|
||||
if (rc != NW_GTPV1U_OK) {
|
||||
LOG_E(GTPU, "nwGtpv1uProcessUlpReq failed: 0x%x\n", rc);
|
||||
MSC_LOG_EVENT(MSC_GTPU_ENB,"0 Failed send G-PDU ltid %u rtid %u size %u",
|
||||
enb_s1u_teid,sgw_s1u_teid,data_req_p->length);
|
||||
enb_s1u_teid,sgw_s1u_teid,data_req_p->length);
|
||||
} else {
|
||||
MSC_LOG_TX_MESSAGE(
|
||||
MSC_GTPU_ENB,
|
||||
MSC_GTPU_SGW,
|
||||
NULL,
|
||||
0,
|
||||
MSC_AS_TIME_FMT" G-PDU ltid %u rtid %u size %u",
|
||||
0,0,
|
||||
enb_s1u_teid,
|
||||
sgw_s1u_teid,
|
||||
data_req_p->length);
|
||||
|
||||
MSC_LOG_TX_MESSAGE(
|
||||
MSC_GTPU_ENB,
|
||||
MSC_GTPU_SGW,
|
||||
NULL,
|
||||
0,
|
||||
MSC_AS_TIME_FMT" G-PDU ltid %u rtid %u size %u",
|
||||
0,0,
|
||||
enb_s1u_teid,
|
||||
sgw_s1u_teid,
|
||||
data_req_p->length);
|
||||
}
|
||||
|
||||
rc = nwGtpv1uMsgDelete(RC.gtpv1u_data_g->gtpv1u_stack,
|
||||
@@ -1113,11 +1045,11 @@ void *gtpv1u_eNB_process_itti_msg(void *notUsed) {
|
||||
|
||||
case TERMINATE_MESSAGE: {
|
||||
if (RC.gtpv1u_data_g->ue_mapping != NULL) {
|
||||
hashtable_destroy (RC.gtpv1u_data_g->ue_mapping);
|
||||
hashtable_destroy (&(RC.gtpv1u_data_g->ue_mapping));
|
||||
}
|
||||
|
||||
if (RC.gtpv1u_data_g->teid_mapping != NULL) {
|
||||
hashtable_destroy (RC.gtpv1u_data_g->teid_mapping);
|
||||
hashtable_destroy (&(RC.gtpv1u_data_g->teid_mapping));
|
||||
}
|
||||
|
||||
LOG_W(GTPU, " *** Exiting GTPU thread\n");
|
||||
@@ -1135,21 +1067,18 @@ void *gtpv1u_eNB_process_itti_msg(void *notUsed) {
|
||||
ITTI_MSG_NAME(received_message_p));
|
||||
}
|
||||
break;
|
||||
}
|
||||
}
|
||||
|
||||
rc = itti_free(ITTI_MSG_ORIGIN_ID(received_message_p), received_message_p);
|
||||
AssertFatal(rc == EXIT_SUCCESS, "Failed to free memory (%d)!\n", rc);
|
||||
received_message_p = NULL;
|
||||
VCD_SIGNAL_DUMPER_DUMP_FUNCTION_BY_NAME(VCD_SIGNAL_DUMPER_FUNCTIONS_GTPV1U_ENB_TASK, VCD_FUNCTION_OUT);
|
||||
|
||||
return NULL;
|
||||
rc = itti_free(ITTI_MSG_ORIGIN_ID(received_message_p), received_message_p);
|
||||
AssertFatal(rc == EXIT_SUCCESS, "Failed to free memory (%d)!\n", rc);
|
||||
received_message_p = NULL;
|
||||
VCD_SIGNAL_DUMPER_DUMP_FUNCTION_BY_NAME(VCD_SIGNAL_DUMPER_FUNCTIONS_GTPV1U_ENB_TASK, VCD_FUNCTION_OUT);
|
||||
return NULL;
|
||||
}
|
||||
|
||||
//-----------------------------------------------------------------------------
|
||||
void *gtpv1u_eNB_task(void *args)
|
||||
{
|
||||
void *gtpv1u_eNB_task(void *args) {
|
||||
int rc = 0;
|
||||
|
||||
rc = gtpv1u_eNB_init();
|
||||
AssertFatal(rc == 0, "gtpv1u_eNB_init Failed");
|
||||
itti_mark_task_ready(TASK_GTPV1_U);
|
||||
|
||||
Reference in New Issue
Block a user