FlexRAN fixes

* properly allocate memory for scheduler name/sorting
* free mem of sc_update, include todo for slice_config
* set has_x to one, add fct whether sorting update necessary
* set n_ul/n_dl to correct value after every loop iteration
* support for delete of multiple slices
* allocate memory for scheduler name in slice_config
* check that we really set the scheduler

openair2/ENB_APP/CONTROL_MODULES/MAC/flexran_agent_mac.c

@@ -1405,40 +1405,67 @@ void flexran_create_config_structures(mid_t mod_id)
 
 void flexran_check_and_remove_slices(mid_t mod_id)
 {
-  int i;
   Protocol__FlexDlSlice **dl = sc_update[mod_id]->dl;
-  size_t n_dl = sc_update[mod_id]->n_dl;
+  Protocol__FlexDlSlice **dlreal = slice_config[mod_id]->dl;
-  for (i = 0; i < n_dl; i++) {
+  int i = 0;
+  while (i < sc_update[mod_id]->n_dl) {
     /* remove slices whose percentage is zero */
-    if (dl[i]->percentage > 0) continue;
+    if (dl[i]->percentage > 0) {
+      ++i;
+      continue;
+    }
     if (flexran_remove_dl_slice(mod_id, i) < 1) {
       LOG_W(FLEXRAN_AGENT, "[%d] can not remove slice index %d ID %d\n",
             mod_id, i, dl[i]->id);
+      ++i;
       continue;
     }
     LOG_I(FLEXRAN_AGENT, "[%d] removed slice index %d ID %d\n",
           mod_id, i, dl[i]->id);
-    /* don't update slice_config, it will be read in below */
+    if (dl[i]->n_sorting > 0) free(dl[i]->sorting);
-    /* we need to memcpy the higher slice to the position we just deleted */
+    free(dl[i]->scheduler_name);
-    memcpy(dl[i], dl[n_dl-1], sizeof(*dl[n_dl-1]));
+    if (dlreal[i]->n_sorting > 0) {
-    memset(dl[n_dl-1], 0, sizeof(*dl[n_dl-1]));
+      dlreal[i]->n_sorting = 0;
+      free(dlreal[i]->sorting);
+    }
+    free(dlreal[i]->scheduler_name);
     --sc_update[mod_id]->n_dl;
+    --slice_config[mod_id]->n_dl;
+    const size_t last = sc_update[mod_id]->n_dl;
+    /* we need to memcpy the higher slice to the position we just deleted */
+    memcpy(dl[i], dl[last], sizeof(*dl[last]));
+    memset(dl[last], 0, sizeof(*dl[last]));
+    memcpy(dlreal[i], dlreal[last], sizeof(*dlreal[last]));
+    memset(dlreal[last], 0, sizeof(*dlreal[last]));
+    /* dont increase i but recheck the slice which has been copied to here */
   }
   Protocol__FlexUlSlice **ul = sc_update[mod_id]->ul;
-  size_t n_ul = sc_update[mod_id]->n_ul;
+  Protocol__FlexUlSlice **ulreal = slice_config[mod_id]->ul;
-  for (i = 0; i < n_ul; i++) {
+  i = 0;
-    if (ul[i]->percentage > 0) continue;
+  while (i < sc_update[mod_id]->n_ul) {
+    if (ul[i]->percentage > 0) {
+      ++i;
+      continue;
+    }
     if (flexran_remove_ul_slice(mod_id, i) < 1) {
       LOG_W(FLEXRAN_AGENT, "[%d] can not remove slice index %d ID %d\n",
             mod_id, i, ul[i]->id);
+      ++i;
       continue;
     }
     LOG_I(FLEXRAN_AGENT, "[%d] removed slice index %d ID %d\n",
           mod_id, i, ul[i]->id);
-    /* see DL remarks */
+    free(ul[i]->scheduler_name);
-    memcpy(ul[i], ul[n_ul-1], sizeof(*ul[n_ul-1]));
+    free(ulreal[i]->scheduler_name);
-    memset(ul[n_ul-1], 0, sizeof(*ul[n_ul-1]));
     --sc_update[mod_id]->n_ul;
+    --slice_config[mod_id]->n_ul;
+    const size_t last = sc_update[mod_id]->n_ul;
+    /* see DL remarks */
+    memcpy(ul[i], ul[last], sizeof(*ul[last]));
+    memset(ul[last], 0, sizeof(*ul[last]));
+    memcpy(ulreal[i], ulreal[last], sizeof(*ulreal[last]));
+    memset(ulreal[last], 0, sizeof(*ulreal[last]));
+    /* dont increase i but recheck the slice which has been copied to here */
   }
 }
 
@@ -1480,12 +1507,13 @@ void flexran_agent_slice_update(mid_t mod_id)
   /* create new DL and UL slices if necessary */
   for (i = slice_config[mod_id]->n_dl; i < sc_update[mod_id]->n_dl; i++) {
     flexran_create_dl_slice(mod_id, sc_update[mod_id]->dl[i]->id);
-    slice_config[mod_id]->n_dl = flexran_get_num_dl_slices(mod_id);
   }
   for (i = slice_config[mod_id]->n_ul; i < sc_update[mod_id]->n_ul; i++) {
     flexran_create_ul_slice(mod_id, sc_update[mod_id]->ul[i]->id);
-    slice_config[mod_id]->n_ul = flexran_get_num_ul_slices(mod_id);
   }
+  slice_config[mod_id]->n_dl = flexran_get_num_dl_slices(mod_id);
+  slice_config[mod_id]->n_ul = flexran_get_num_ul_slices(mod_id);
+  changes += apply_new_slice_config(mod_id, slice_config[mod_id], sc_update[mod_id]);
   for (i = 0; i < slice_config[mod_id]->n_dl; i++) {
     changes += apply_new_slice_dl_config(mod_id,
                                          slice_config[mod_id]->dl[i],

openair2/ENB_APP/CONTROL_MODULES/MAC/flexran_agent_mac_internal.c

@@ -969,7 +969,12 @@ void flexran_agent_read_slice_dl_config(mid_t mod_id, int slice_idx, Protocol__F
   if (dl_slice->n_sorting < 1) dl_slice->sorting = NULL;
   dl_slice->accounting = flexran_get_dl_slice_accounting_policy(mod_id, slice_idx);
   dl_slice->has_accounting = 1;
-  dl_slice->scheduler_name = flexran_get_dl_slice_scheduler(mod_id, slice_idx);
+  const char *s_name = flexran_get_dl_slice_scheduler(mod_id, slice_idx);
+  if (!dl_slice->scheduler_name
+      || strcmp(dl_slice->scheduler_name, s_name) != 0) {
+    dl_slice->scheduler_name = realloc(dl_slice->scheduler_name, strlen(s_name) + 1);
+    strcpy(dl_slice->scheduler_name, s_name);
+  }
 }
 
 void flexran_agent_read_slice_ul_config(mid_t mod_id, int slice_idx, Protocol__FlexUlSlice *ul_slice)
@@ -1007,7 +1012,34 @@ void flexran_agent_read_slice_ul_config(mid_t mod_id, int slice_idx, Protocol__F
   if (ul_slice->n_sorting < 1) ul_slice->sorting = NULL;*/
   /*ul_slice->accounting = flexran_get_ul_slice_accounting_policy(mod_id, slice_idx);*/
   ul_slice->has_accounting = 0;
-  ul_slice->scheduler_name = flexran_get_ul_slice_scheduler(mod_id, slice_idx);
+  const char *s_name = flexran_get_ul_slice_scheduler(mod_id, slice_idx);
+  if (!ul_slice->scheduler_name
+      || strcmp(ul_slice->scheduler_name, s_name) != 0) {
+    ul_slice->scheduler_name = realloc(ul_slice->scheduler_name, strlen(s_name) + 1);
+    strcpy(ul_slice->scheduler_name, s_name);
+  }
+}
+
+int check_dl_sorting_update(Protocol__FlexDlSlice *old, Protocol__FlexDlSlice *new)
+{
+  /* sorting_update => true when old->n_sorting == 0 or different numbers of
+   * elements; otherwise will check * element-wise */
+  int sorting_update = old->n_sorting == 0 || (old->n_sorting != new->n_sorting);
+  for (int i = 0; i < old->n_sorting && !sorting_update; ++i) {
+    sorting_update = sorting_update || (new->sorting[i] != old->sorting[i]);
+  }
+  return sorting_update;
+}
+
+int check_ul_sorting_update(Protocol__FlexUlSlice *old, Protocol__FlexUlSlice *new)
+{
+  /* sorting_update => true when old->n_sorting == 0 or different numbers of
+   * elements; otherwise will check * element-wise */
+  int sorting_update = old->n_sorting == 0 || (old->n_sorting != new->n_sorting);
+  for (int i = 0; i < old->n_sorting && !sorting_update; ++i) {
+    sorting_update = sorting_update || (new->sorting[i] != old->sorting[i]);
+  }
+  return sorting_update;
 }
 
 void overwrite_slice_config_dl(Protocol__FlexDlSlice *exist, Protocol__FlexDlSlice *update)
@@ -1016,65 +1048,66 @@ void overwrite_slice_config_dl(Protocol__FlexDlSlice *exist, Protocol__FlexDlSli
     LOG_I(FLEXRAN_AGENT, "[DL slice %d] update label: %d -> %d\n",
           update->id, exist->label, update->label);
     exist->label = update->label;
+    exist->has_label = 1;
   }
   if (update->percentage != exist->percentage) {
     LOG_I(FLEXRAN_AGENT, "[DL slice %d] update percentage: %d -> %d\n",
           update->id, exist->percentage, update->percentage);
     exist->percentage = update->percentage;
+    exist->has_percentage = 1;
   }
   if (update->isolation != exist->isolation) {
     LOG_I(FLEXRAN_AGENT, "[DL slice %d] update isolation: %d -> %d\n",
           update->id, exist->isolation, update->isolation);
     exist->isolation = update->isolation;
+    exist->has_isolation = 1;
   }
   if (update->priority != exist->priority) {
     LOG_I(FLEXRAN_AGENT, "[DL slice %d] update priority: %d -> %d\n",
           update->id, exist->priority, update->priority);
     exist->priority = update->priority;
+    exist->has_priority = 1;
   }
   if (update->position_low != exist->position_low) {
     LOG_I(FLEXRAN_AGENT, "[DL slice %d] update position_low: %d -> %d\n",
           update->id, exist->position_low, update->position_low);
     exist->position_low = update->position_low;
+    exist->has_position_low = 1;
   }
   if (update->position_high != exist->position_high) {
     LOG_I(FLEXRAN_AGENT, "[DL slice %d] update position_high: %d -> %d\n",
           update->id, exist->position_high, update->position_high);
     exist->position_high = update->position_high;
+    exist->has_position_high = 1;
   }
   if (update->maxmcs != exist->maxmcs) {
     LOG_I(FLEXRAN_AGENT, "[DL slice %d] update maxmcs: %d -> %d\n",
           update->id, exist->maxmcs, update->maxmcs);
     exist->maxmcs = update->maxmcs;
+    exist->has_maxmcs = 1;
   }
-  int sorting_update = 0;
+  if (check_dl_sorting_update(exist, update)) {
-  int n = min(exist->n_sorting, update->n_sorting);
-  /* check whether something has changed. If update->n_sorting is 0,
-   * sorting_update will remain false, so no update will be done */
-  int i = 0;
-  while(i < n && !sorting_update) {
-    sorting_update = sorting_update || (update->sorting[i] != exist->sorting[i]);
-    i++;
-  }
-  if (sorting_update) {
     LOG_I(FLEXRAN_AGENT, "[DL slice %d] update sorting array\n", update->id);
-    if (exist->n_sorting != update->n_sorting)
+    if (exist->n_sorting != update->n_sorting) {
-      LOG_W(FLEXRAN_AGENT, "[slice %d] only writing %d elements\n",
+      exist->n_sorting = update->n_sorting;
-          update->id, n);
+      exist->sorting = realloc(exist->sorting, exist->n_sorting * sizeof(Protocol__FlexDlSorting));
-    for (int i = 0; i < n; i++)
+      if (!exist->sorting) exist->n_sorting = 0;
+    }
+    for (int i = 0; i < exist->n_sorting; i++)
       exist->sorting[i] = update->sorting[i];
   }
   if (update->accounting != exist->accounting) {
     LOG_I(FLEXRAN_AGENT, "[DL slice %d] update accounting: %d -> %d\n",
           update->id, exist->accounting, update->accounting);
     exist->accounting = update->accounting;
+    exist->has_accounting = 1;
   }
   if (!exist->scheduler_name
       || strcmp(update->scheduler_name, exist->scheduler_name) != 0) {
     LOG_I(FLEXRAN_AGENT, "[DL slice %d] update scheduler: %s -> %s\n",
           update->id, exist->scheduler_name, update->scheduler_name);
-    /* TODO dangerous? */
+    if (exist->scheduler_name) free(exist->scheduler_name);
-    exist->scheduler_name = update->scheduler_name;
+    exist->scheduler_name = strdup(update->scheduler_name);
   }
 }
 
@@ -1084,26 +1117,31 @@ void overwrite_slice_config_ul(Protocol__FlexUlSlice *exist, Protocol__FlexUlSli
     LOG_I(FLEXRAN_AGENT, "[UL slice %d] update label: %d -> %d\n",
           update->id, exist->label, update->label);
     exist->label = update->label;
+    exist->has_label = 1;
   }
   if (update->percentage != exist->percentage) {
     LOG_I(FLEXRAN_AGENT, "[UL slice %d] update percentage: %d -> %d\n",
           update->id, exist->percentage, update->percentage);
     exist->percentage = update->percentage;
+    exist->has_percentage = 1;
   }
   if (update->isolation != exist->isolation) {
     LOG_I(FLEXRAN_AGENT, "[UL slice %d] update isolation: %d -> %d\n",
           update->id, exist->isolation, update->isolation);
     exist->isolation = update->isolation;
+    exist->has_isolation = 1;
   }
   if (update->priority != exist->priority) {
     LOG_I(FLEXRAN_AGENT, "[UL slice %d] update priority: %d -> %d\n",
           update->id, exist->priority, update->priority);
     exist->priority = update->priority;
+    exist->has_priority = 1;
   }
   if (update->first_rb != exist->first_rb) {
     LOG_I(FLEXRAN_AGENT, "[UL slice %d] update first_rb: %d -> %d\n",
 	  update->id, exist->first_rb, update->first_rb);
     exist->first_rb = update ->first_rb;
+    exist->has_first_rb = 1;
   }
   /*if (update->lenght_rb != exist->lenght_rb) {
     LOG_I(FLEXRAN_AGENT, "[UL slice %d] update lenght_rb: %d -> %d\n",
@@ -1114,11 +1152,11 @@ void overwrite_slice_config_ul(Protocol__FlexUlSlice *exist, Protocol__FlexUlSli
     LOG_I(FLEXRAN_AGENT, "[UL slice %d] update maxmcs: %d -> %d\n",
           update->id, exist->maxmcs, update->maxmcs);
     exist->maxmcs = update->maxmcs;
+    exist->has_maxmcs = 1;
   }
+  /* TODO
   int sorting_update = 0;
   int n = min(exist->n_sorting, update->n_sorting);
-  /* check whether something has changed. If update-> n_sorting is 0,
-   * sorting_update will remain false, so no update will be done */
   int i = 0;
   while (i < n && !sorting_update) {
     sorting_update = sorting_update || (update->sorting[i] != exist->sorting[i]);
@@ -1132,17 +1170,19 @@ void overwrite_slice_config_ul(Protocol__FlexUlSlice *exist, Protocol__FlexUlSli
     for (i = 0; i < n; i++)
       exist->sorting[i] = update->sorting[i];
   }
+  */
   if (update->accounting != exist->accounting) {
     LOG_I(FLEXRAN_AGENT, "[UL slice %d] update accounting: %d -> %d\n",
           update->id, exist->accounting, update->accounting);
     exist->accounting = update->accounting;
+    exist->has_accounting = 1;
   }
   if (!exist->scheduler_name
       || strcmp(update->scheduler_name, exist->scheduler_name) != 0) {
     LOG_I(FLEXRAN_AGENT, "[UL slice %d] update scheduler: %s -> %s\n",
           update->id, exist->scheduler_name, update->scheduler_name);
-    /* TODO dangerous? */
+    if (exist->scheduler_name) free(exist->scheduler_name);
-    exist->scheduler_name = update->scheduler_name;
+    exist->scheduler_name = strdup(update->scheduler_name);
   }
 }
 
@@ -1181,16 +1221,16 @@ void fill_dl_slice(mid_t mod_id, Protocol__FlexDlSlice *s, Protocol__FlexDlSlice
   }
   if (s->n_sorting == 0) {
     s->n_sorting = from ? from->n_sorting : sc_update[mod_id]->dl[0]->n_sorting;
-    /* TODO Dangerous? */
+    s->sorting = calloc(s->n_sorting, sizeof(Protocol__FlexDlSorting));
-    s->sorting = from ? from->sorting : sc_update[mod_id]->dl[0]->sorting;
+    if (!s->sorting) s->n_sorting = 0;
+    for (int i = 0; i < s->n_sorting; ++i)
+      s->sorting[i] = from ? from->sorting[i] : sc_update[0]->dl[0]->sorting[i];
   }
   if (!s->has_accounting) {
-    /* TODO Dangerous? */
     s->accounting = from ? from->accounting : sc_update[mod_id]->dl[0]->accounting;
   }
   if (!s->scheduler_name) {
-    /* TODO Dangerous? */
+    s->scheduler_name = strdup(from ? from->scheduler_name : sc_update[mod_id]->dl[0]->scheduler_name);
-    s->scheduler_name = from ? from->scheduler_name : sc_update[mod_id]->dl[0]->scheduler_name;
   }
 }
 
@@ -1248,16 +1288,16 @@ void fill_ul_slice(mid_t mod_id, Protocol__FlexUlSlice *s, Protocol__FlexUlSlice
   }
   if (s->n_sorting == 0) {
     s->n_sorting = from ? from->n_sorting : sc_update[0]->ul[0]->n_sorting;
-    /* TODO Dangerous? */
+    s->sorting = calloc(s->n_sorting, sizeof(Protocol__FlexUlSorting));
-    s->sorting = from ? from->sorting : sc_update[0]->ul[0]->sorting;
+    if (!s->sorting) s->n_sorting = 0;
+    for (int i = 0; i < s->n_sorting; ++i)
+      s->sorting[i] = from ? from->sorting[i] : sc_update[0]->ul[0]->sorting[i];
   }
   if (!s->has_accounting) {
-    /* TODO Dangerous? */
     s->accounting = from ? from->accounting : sc_update[0]->ul[0]->accounting;
   }
   if (!s->scheduler_name) {
-    /* TODO Dangerous? */
+    s->scheduler_name = strdup(from ? from->scheduler_name : sc_update[mod_id]->ul[0]->scheduler_name);
-    s->scheduler_name = from ? from->scheduler_name : sc_update[mod_id]->ul[0]->scheduler_name;
   }
 }
 
@@ -1374,7 +1414,6 @@ int apply_new_slice_dl_config(mid_t mod_id, Protocol__FlexDlSlice *oldc, Protoco
    * later when reading the configuration. There is thus a direct feedback
    * whether it has been set. */
   int changes = 0;
-  int n;
   int slice_idx = flexran_find_dl_slice(mod_id, newc->id);
   if (slice_idx < 0) {
     LOG_W(FLEXRAN_AGENT, "cannot find index for slice ID %d\n", newc->id);
@@ -1404,13 +1443,9 @@ int apply_new_slice_dl_config(mid_t mod_id, Protocol__FlexDlSlice *oldc, Protoco
     flexran_set_dl_slice_maxmcs(mod_id, slice_idx, newc->maxmcs);
     changes++;
   }
-  n = min(oldc->n_sorting, newc->n_sorting);
+  if (check_dl_sorting_update(oldc, newc)) {
-  for (int i = 0; i < n; i++) {
+    flexran_set_dl_slice_sorting(mod_id, slice_idx, newc->sorting, newc->n_sorting);
-    if (oldc->sorting[i] != newc->sorting[i]) {
+    changes++;
-      flexran_set_dl_slice_sorting(mod_id, slice_idx, newc->sorting, n);
-      changes++;
-      break;
-    }
   }
   if (oldc->accounting != newc->accounting) {
     flexran_set_dl_slice_accounting_policy(mod_id, slice_idx, newc->accounting);
@@ -1418,7 +1453,9 @@ int apply_new_slice_dl_config(mid_t mod_id, Protocol__FlexDlSlice *oldc, Protoco
   }
   if (!oldc->scheduler_name
       || strcmp(oldc->scheduler_name, newc->scheduler_name) != 0) {
-    flexran_set_dl_slice_scheduler(mod_id, slice_idx, newc->scheduler_name);
+    int ret = flexran_set_dl_slice_scheduler(mod_id, slice_idx, newc->scheduler_name);
+    AssertFatal(ret, "could not set DL slice scheduler for slice %d idx %d\n",
+                newc->id, slice_idx);
     changes++;
   }
   return changes;
@@ -1430,7 +1467,6 @@ int apply_new_slice_ul_config(mid_t mod_id, Protocol__FlexUlSlice *oldc, Protoco
    * later when reading the configuration. There is thus a direct feedback
    * whether it has been set. */
   int changes = 0;
-  int n;
   int slice_idx = flexran_find_ul_slice(mod_id, newc->id);
   if (slice_idx < 0) {
     LOG_W(FLEXRAN_AGENT, "cannot find index for slice ID %d\n", newc->id);
@@ -1466,15 +1502,11 @@ int apply_new_slice_ul_config(mid_t mod_id, Protocol__FlexUlSlice *oldc, Protoco
     flexran_set_ul_slice_maxmcs(mod_id, slice_idx, newc->maxmcs);
     changes++;
   }
-  n = min(oldc->n_sorting, newc->n_sorting);
+  if (check_ul_sorting_update(oldc, newc)) {
-  for (int i = 0; i < n; i++) {
+    /*flexran_set_ul_slice_sorting(mod_id, slice_idx, newc->sorting, n);
-    if (oldc->sorting[i] != newc->sorting[i]) {
+    changes++;*/
-      /*flexran_set_ul_slice_sorting(mod_id, slice_idx, newc->sorting, n);
+    LOG_W(FLEXRAN_AGENT, "[%d][UL slice %d] setting the sorting is not supported\n",
-      changes++;*/
+        mod_id, slice_idx);
-      LOG_W(FLEXRAN_AGENT, "[%d][UL slice %d] setting the sorting is not supported\n",
-          mod_id, slice_idx);
-      break;
-    }
   }
   if (oldc->accounting != newc->accounting) {
     /*flexran_set_ul_slice_accounting_policy(mod_id, slice_idx, newc->accounting);
@@ -1484,7 +1516,9 @@ int apply_new_slice_ul_config(mid_t mod_id, Protocol__FlexUlSlice *oldc, Protoco
   }
   if (!oldc->scheduler_name
       || strcmp(oldc->scheduler_name, newc->scheduler_name) != 0) {
-    flexran_set_ul_slice_scheduler(mod_id, slice_idx, newc->scheduler_name);
+    int ret = flexran_set_ul_slice_scheduler(mod_id, slice_idx, newc->scheduler_name);
+    AssertFatal(ret, "could not set DL slice scheduler for slice %d idx %d\n",
+                newc->id, slice_idx);
     changes++;
   }
   return changes;