maki/openairinterface5g
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

If unknown scheduler, save message and contact controller

Browse Source
This commit is contained in:
Robert Schmidt
2020-10-06 17:44:16 +02:00
parent 9de83a047a
commit 0f641b7d9c
1 changed files with 142 additions and 0 deletions
Download Patch File Download Diff File Expand all files Collapse all files
openair2/ENB_APP/CONTROL_MODULES/MAC/flexran_agent_mac.c
+142
View File
@@ -40,6 +40,8 @@
#include "common/utils/LOG/log.h"
#include <dlfcn.h>
/*Array containing the Agent-MAC interfaces*/
AGENT_MAC_xface *agent_mac_xface[NUM_MAX_ENB];
@@ -53,6 +55,13 @@ struct lfds700_ringbuffer_state ringbuffer_state[NUM_MAX_ENB];
struct lfds700_ringbuffer_element *slice_config_array[NUM_MAX_ENB];
struct lfds700_ringbuffer_state slice_config_ringbuffer_state[NUM_MAX_ENB];
/* Ringbuffer related to slice configuration if we need to wait for additional
* controller information */
struct lfds700_ringbuffer_element *store_slice_config_array[NUM_MAX_ENB];
struct lfds700_ringbuffer_state store_slice_config_ringbuffer_state[NUM_MAX_ENB];
/* stores the (increasing) xid for messages to prevent double use */
int xid = 50;
/* Ringbuffer-related to slice configuration */
struct lfds700_ringbuffer_element *ue_assoc_array[NUM_MAX_ENB];
struct lfds700_ringbuffer_state ue_assoc_ringbuffer_state[NUM_MAX_ENB];
@@ -1363,6 +1372,19 @@ void flexran_agent_init_mac_agent(mid_t mod_id) {
&scrng,
NULL);
struct lfds700_misc_prng_state sscrng;
i = posix_memalign((void **) &store_slice_config_array[mod_id],
LFDS700_PAL_ATOMIC_ISOLATION_IN_BYTES,
sizeof(struct lfds700_ringbuffer_element) * num_elements);
AssertFatal(i == 0,
"posix_memalign(): could not allocate aligned memory\n");
lfds700_ringbuffer_init_valid_on_current_logical_core(
&store_slice_config_ringbuffer_state[mod_id],
store_slice_config_array[mod_id],
num_elements,
&sscrng,
NULL);
struct lfds700_misc_prng_state uarng;
i = posix_memalign((void **) &ue_assoc_array[mod_id],
LFDS700_PAL_ATOMIC_ISOLATION_IN_BYTES,
@@ -1659,6 +1681,8 @@ int flexran_agent_unregister_mac_xface(mid_t mod_id)
free(dl_mac_config_array[mod_id]);
lfds700_ringbuffer_cleanup(&slice_config_ringbuffer_state[mod_id], NULL );
free(slice_config_array[mod_id]);
lfds700_ringbuffer_cleanup(&store_slice_config_ringbuffer_state[mod_id], NULL );
free(store_slice_config_array[mod_id]);
lfds700_ringbuffer_cleanup(&ue_assoc_ringbuffer_state[mod_id], NULL );
free(ue_assoc_array[mod_id]);
lfds700_misc_library_cleanup();
@@ -1698,6 +1722,69 @@ void helper_destroy_mac_slice_config(Protocol__FlexSliceConfig *slice_config) {
flexran_agent_destroy_mac_slice_config(&helper);
}
int check_scheduler(mid_t mod_id, char *s) {
return dlsym(NULL, s) != NULL;
}
void request_scheduler(mid_t mod_id, char *s, int xid) {
LOG_W(FLEXRAN_AGENT,
"unknown scheduler %s, requesting controller to send it\n",
s);
Protocol__FlexControlDelegationRequest *req = malloc(sizeof(Protocol__FlexControlDelegationRequest));
DevAssert(req);
protocol__flex_control_delegation_request__init(req);
Protocol__FlexHeader *header = NULL;
int rc = flexran_create_header(
xid, PROTOCOL__FLEX_TYPE__FLPT_DELEGATE_REQUEST, &header);
AssertFatal(rc == 0, "%s(): cannot create header\n", __func__);
req->header = header;
req->delegation_type = PROTOCOL__FLEX_CONTROL_DELEGATION_TYPE__FLCDT_MAC_DL_UE_SCHEDULER;
req->name = strdup(s);
Protocol__FlexranMessage *msg = malloc(sizeof(Protocol__FlexranMessage));
DevAssert(msg);
protocol__flexran_message__init(msg);
msg->msg_case = PROTOCOL__FLEXRAN_MESSAGE__MSG_CONTROL_DEL_REQ_MSG;
msg->msg_dir = PROTOCOL__FLEXRAN_DIRECTION__INITIATING_MESSAGE;
msg->control_del_req_msg = req;
int size = 0;
void *data = flexran_agent_pack_message(msg, &size);
if (flexran_agent_msg_send(mod_id, FLEXRAN_AGENT_DEFAULT, data, size, 0) < 0)
LOG_E(FLEXRAN_AGENT, "%s(): error while sending message\n", __func__);
}
Protocol__FlexranMessage *request_scheduler_timeout(
mid_t mod_id,
const Protocol__FlexranMessage *msg) {
const Protocol__FlexEnbConfigReply *ecr = msg->enb_config_reply_msg;
struct lfds700_misc_prng_state ls;
LFDS700_MISC_MAKE_VALID_ON_CURRENT_LOGICAL_CORE_INITS_COMPLETED_BEFORE_NOW_ON_ANY_OTHER_LOGICAL_CORE;
lfds700_misc_prng_init(&ls);
Protocol__FlexranMessage *smsg = NULL;
struct lfds700_ringbuffer_state *state = &store_slice_config_ringbuffer_state[mod_id];
if (lfds700_ringbuffer_read(state, NULL, (void **) &smsg, &ls)) {
AssertFatal(msg == smsg,
"expected and returned enb_config_reply are not the same\n");
AssertFatal(ecr->header->xid == smsg->enb_config_reply_msg->header->xid,
"expected and returned enb_config_reply are not the same\n");
} else {
LOG_E(FLEXRAN_AGENT, "%s(): could not read config from ringbuffer\n", __func__);
}
/* call the helper so that scheduler names are correctly freed */
helper_destroy_mac_slice_config(ecr->cell_config[0]->slice_config);
ecr->cell_config[0]->slice_config = NULL;
/* we should not call flexran_agent_destroy_enb_config_reply(smsg); since
* upon timer removal, this is automatically done */
LOG_W(FLEXRAN_AGENT,
"remove stored slice config (xid %d) after timeout\n",
ecr->header->xid);
flexran_agent_destroy_timer(mod_id, ecr->header->xid);
return NULL;
}
void prepare_update_slice_config(mid_t mod_id, Protocol__FlexSliceConfig **slice_config) {
if (!*slice_config) return;
/* just use the memory and set to NULL in original */
@@ -1709,6 +1796,61 @@ void prepare_update_slice_config(mid_t mod_id, Protocol__FlexSliceConfig **slice
lfds700_misc_prng_init(&ls);
enum lfds700_misc_flag overwrite_occurred_flag;
int put_on_hold = 0;
if (sc->dl->scheduler && !check_scheduler(mod_id, sc->dl->scheduler)) {
request_scheduler(mod_id, sc->dl->scheduler, xid++);
put_on_hold = 1;
}
for (int i = 0; i < sc->dl->n_slices; ++i) {
Protocol__FlexSlice *sl = sc->dl->slices[i];
if (sl->scheduler && !check_scheduler(mod_id, sl->scheduler)) {
request_scheduler(mod_id, sl->scheduler, xid++);
put_on_hold = 1;
}
}
if (put_on_hold) {
Protocol__FlexEnbConfigReply *reply = malloc(sizeof(Protocol__FlexEnbConfigReply));
DevAssert(reply);
protocol__flex_enb_config_reply__init(reply);
/* use the last used xid so we can correlate answer and waiting config */
int rc = flexran_create_header(
xid - 1, PROTOCOL__FLEX_TYPE__FLPT_GET_ENB_CONFIG_REPLY, &reply->header);
AssertFatal(rc == 0, "%s(): cannot create header\n", __func__);
reply->n_cell_config = 1;
reply->cell_config = malloc(sizeof(Protocol__FlexCellConfig *));
DevAssert(reply->cell_config);
reply->cell_config[0] = malloc(sizeof(Protocol__FlexCellConfig));
DevAssert(reply->cell_config[0]);
protocol__flex_cell_config__init(reply->cell_config[0]);
reply->cell_config[0]->slice_config = sc;
Protocol__FlexranMessage *msg = malloc(sizeof(Protocol__FlexranMessage));
DevAssert(msg);
protocol__flexran_message__init(msg);
msg->msg_case = PROTOCOL__FLEXRAN_MESSAGE__MSG_ENB_CONFIG_REPLY_MSG;
msg->msg_dir = PROTOCOL__FLEXRAN_DIRECTION__INITIATING_MESSAGE;
msg->enb_config_reply_msg = reply;
Protocol__FlexEnbConfigReply *o;
lfds700_ringbuffer_write(&store_slice_config_ringbuffer_state[mod_id],
NULL,
(void *)msg,
&overwrite_occurred_flag,
NULL,
(void **) &o,
&ls);
AssertFatal(overwrite_occurred_flag == LFDS700_MISC_FLAG_LOWERED,
"unhandled: stored slice config for controller has been overwritten\n");
flexran_agent_create_timer(mod_id,
3000,
FLEXRAN_AGENT_TIMER_TYPE_PERIODIC,
xid - 1,
request_scheduler_timeout,
msg); /* need reply for xid */
return;
}
Protocol__FlexSliceConfig *overwritten_sc;
lfds700_ringbuffer_write(&slice_config_ringbuffer_state[mod_id],
NULL,