added nvm support for leader router id allocation. (#1626)

nvm support for MLE-ID to router id mapping
maintained by the leader. This enables the leader
to reallocate router ids even after restart.

Author: deepakvenugopal

source/6LoWPAN/Thread/thread_common.c

@@ -524,6 +524,7 @@ thread_leader_info_t *thread_allocate_and_init_leader_private_data(void)
     thread_leader_info_t *leader_info = ns_dyn_mem_alloc(sizeof(thread_leader_info_t));
     if (leader_info) {
         leader_info->leader_id_seq_timer = ID_SEQUENCE_PERIOD;
+        leader_info->leader_nvm_sync_timer = 0;
     }
     return leader_info;
 }

source/6LoWPAN/Thread/thread_common.h

@@ -48,6 +48,8 @@
  */
 #define ROUTER_ID_REUSE_DELAY 100 //Seconds
 
+#define LEADER_NVM_SYNC_DELAY 30 // Leader router ids write delay to NVM
+
 #define ROUTER_ID_INFINITY_DELAY 90 //Seconds
 
 #define NETWORK_ID_TIMEOUT 120 //seconds
@@ -145,6 +147,7 @@ typedef struct thread_leader_info_s {
     uint8_t leader_id_seq_timer;
     uint8_t master_router_id_mask[8];
     uint8_t maskSeq;
+    uint8_t leader_nvm_sync_timer;
 } thread_leader_info_t;
 
 typedef struct thread_leader_data_s {

source/6LoWPAN/Thread/thread_leader_service.c

@@ -733,6 +733,28 @@ static void thread_leader_allocate_router_id_by_allocated_id(thread_leader_info_
     info->thread_router_id_list[router_id].reUsePossible = false;
 }
 
+void thread_leader_mleid_rloc_map_populate(thread_nvm_mleid_rloc_map *mleid_rloc_map, thread_leader_info_t *leader_private_info)
+{
+    for (uint8_t i = 0; i < 64; i++) {
+        if (bit_test(leader_private_info->master_router_id_mask, i)) {
+            memcpy(mleid_rloc_map->mleid_rloc_map[i].mle_id, leader_private_info->thread_router_id_list[i].eui64, 8);
+        }
+    }
+}
+
+static int thread_leader_update_mleid_rloc_map_in_nvm(protocol_interface_info_entry_t *cur)
+{
+    thread_nvm_mleid_rloc_map *mleid_rloc_map = ns_dyn_mem_temporary_alloc(sizeof(thread_nvm_mleid_rloc_map));
+    if (!mleid_rloc_map) {
+        return -1;
+    }
+    memset(mleid_rloc_map, 0, sizeof(thread_nvm_mleid_rloc_map));
+    thread_leader_mleid_rloc_map_populate(mleid_rloc_map, cur->thread_info->leader_private_data);
+    thread_nvm_store_mleid_rloc_map_write(mleid_rloc_map);
+    ns_dyn_mem_free(mleid_rloc_map);
+    return 0;
+}
+
 static int thread_leader_service_router_id_allocate(const uint8_t *eui64, protocol_interface_info_entry_t *cur, thread_leader_service_router_id_resp_t *reponse)
 {
     int ret_val = -1;
@@ -793,6 +815,8 @@ static int thread_leader_service_router_id_allocate(const uint8_t *eui64, protoc
         if (!bit_test(leader_private_ptr->master_router_id_mask, id)) {
             if (leader_private_ptr->thread_router_id_list[id].reUsePossible) {
                 allocated_id = id;
+                // new id allocated save to nvm after delay
+                leader_private_ptr->leader_nvm_sync_timer = LEADER_NVM_SYNC_DELAY;
                 break;
             }
         }
@@ -847,6 +871,7 @@ static int thread_leader_service_router_id_deallocate(const uint8_t *eui64, prot
                 //Active ID
                 if (memcmp(eui64, leader_private_ptr->thread_router_id_list[i].eui64, 8) == 0) {
                     tr_debug("Release Router Id %d", i);
+                    leader_private_ptr->leader_nvm_sync_timer = LEADER_NVM_SYNC_DELAY;
                     thread_leader_service_route_mask_bit_clear(leader_private_ptr, i);
                     leader_private_ptr->thread_router_id_list[i].reUsePossible = true;
                     leader_private_ptr->thread_router_id_list[i].validLifeTime = 0;
@@ -1318,6 +1343,8 @@ static void thread_leader_service_interface_setup_activate(protocol_interface_in
     //SET Router ID
     thread_leader_allocate_router_id_by_allocated_id(private, routerId, cur->mac);
     thread_old_partition_data_purge(cur);
+    // remove any existing rloc mapping in nvm
+    thread_nvm_store_mleid_rloc_map_remove();
     cur->lowpan_address_mode = NET_6LOWPAN_GP16_ADDRESS;
     thread_bootstrap_update_ml16_address(cur, cur->thread_info->routerShortAddress);
     thread_generate_ml64_address(cur);
@@ -1500,6 +1527,16 @@ void thread_leader_service_timer(protocol_interface_info_entry_t *cur, uint32_t
         thread_leader_service_network_data_changed(cur, false, false);
     }
 
+    if (cur->thread_info->leader_private_data->leader_nvm_sync_timer) {
+        if ((cur->thread_info->leader_private_data->leader_nvm_sync_timer) > ticks) {
+            cur->thread_info->leader_private_data->leader_nvm_sync_timer -= ticks;
+        }
+        else {
+            cur->thread_info->leader_private_data->leader_nvm_sync_timer = 0;
+            thread_leader_update_mleid_rloc_map_in_nvm(cur);
+        }
+    }
+
     thread_leader_service_router_id_valid_lifetime_update(cur, ticks);
 
 }
@@ -1619,22 +1656,33 @@ int thread_leader_service_thread_partitition_restart(int8_t interface_id, mle_tl
     }
     //Learn network data, we remove own data from here it should be re given by application
     //thread_management_network_data_register(cur->id, networkData.dataPtr, networkData.tlvLen, address16 );
-
+    thread_nvm_mleid_rloc_map *mleid_rloc_map = ns_dyn_mem_temporary_alloc(sizeof(thread_nvm_mleid_rloc_map));
+    if (!mleid_rloc_map) {
+        return -1;
+    }
+    if (thread_nvm_store_mleid_rloc_map_read(mleid_rloc_map) != THREAD_NVM_FILE_SUCCESS) {
+        memset(mleid_rloc_map, 0, sizeof(thread_nvm_mleid_rloc_map));
+    }
     // initialize private data
     thread_info(cur)->leader_private_data->maskSeq = *routing->dataPtr;
-    memcpy(thread_info(cur)->leader_private_data->master_router_id_mask,routing->dataPtr + 1,8);
+    memcpy(thread_info(cur)->leader_private_data->master_router_id_mask,routing->dataPtr + 1, 8);
     for (int i = 0; i < 64; i++) {
-        memset(thread_info(cur)->leader_private_data->thread_router_id_list[i].eui64,0,8);
         if (bit_test(thread_info(cur)->leader_private_data->master_router_id_mask, i)) {
             //Active ID
             thread_info(cur)->leader_private_data->thread_router_id_list[i].reUsePossible = false;
-
+            memcpy(thread_info(cur)->leader_private_data->thread_router_id_list[i].eui64, mleid_rloc_map->mleid_rloc_map[i].mle_id, 8);
         } else {
             // Free id
             thread_info(cur)->leader_private_data->thread_router_id_list[i].reUsePossible = true;
+            // clear the mleid in both local router id list and nvm
+            memset(thread_info(cur)->leader_private_data->thread_router_id_list[i].eui64, 0, 8);
+            memset(mleid_rloc_map->mleid_rloc_map[i].mle_id, 0, 8);
         }
         thread_info(cur)->leader_private_data->thread_router_id_list[i].validLifeTime = 0xffffffff;
     }
+    // write back updated map to store
+    thread_nvm_store_mleid_rloc_map_write(mleid_rloc_map);
+    ns_dyn_mem_free(mleid_rloc_map);
     // Clear network data (if exists) and propagate new empty network data
     thread_network_data_free_and_clean(&cur->thread_info->networkDataStorage);
     thread_network_data_base_init(&cur->thread_info->networkDataStorage);

source/6LoWPAN/Thread/thread_nvm_store.c

@@ -52,6 +52,9 @@ const char *FAST_DATA_FILE = "f_d";
 const char *LINK_INFO_FILE = "l_i";
 #define LINK_INFO_DATA_VERSION 1
 
+const char *LEADER_INFO_FILE = "ld_i";
+#define LEADER_INFO_DATA_VERSION 1
+
 typedef struct {
     uint8_t mac[8];
     uint16_t short_addr;
@@ -88,6 +91,7 @@ static void thread_nvm_store_link_info_delayed_write(uint32_t seconds);
 #define DEVICE_CONF_STRING_LEN (strlen(DEVICE_CONF_FILE)+strlen(thread_nvm_store_get_root_path())+1)
 #define PENDING_CONF_STRING_LEN (strlen(THREAD_NVM_PENDING_CONF_FILE)+strlen(thread_nvm_store_get_root_path())+1)
 #define LINK_INFO_STRING_LEN (strlen(LINK_INFO_FILE)+strlen(thread_nvm_store_get_root_path())+1)
+#define LEADER_INFO_STRING_LEN (strlen(LEADER_INFO_FILE)+strlen(thread_nvm_store_get_root_path())+1)
 
 
 thread_nvm_fast_data_t cached_fast_data;
@@ -117,6 +121,62 @@ static int root_path_valid(void)
     }
     return 1;
 }
+
+int thread_nvm_store_mleid_rloc_map_write(thread_nvm_mleid_rloc_map *mleid_rloc_map)
+{
+    char lc_data_path[LEADER_INFO_STRING_LEN];
+    if (!root_path_valid()) {
+        return THREAD_NVM_FILE_ROOT_PATH_INVALID;
+    }
+    thread_nvm_store_create_path(lc_data_path, LEADER_INFO_FILE);
+    tr_debug("writing to store rloc mapping info");
+    return thread_nvm_store_write(lc_data_path, mleid_rloc_map, sizeof(thread_nvm_mleid_rloc_map), LEADER_INFO_DATA_VERSION);
+}
+
+int thread_nvm_store_mleid_rloc_map_read(thread_nvm_mleid_rloc_map *mleid_rloc_map)
+{
+    char lc_data_path[LEADER_INFO_STRING_LEN];
+    uint32_t version;
+    if (NULL==mleid_rloc_map) {
+        return THREAD_NVM_FILE_PARAMETER_INVALID;
+    }
+    if (!root_path_valid()) {
+        return THREAD_NVM_FILE_ROOT_PATH_INVALID;
+    }
+    thread_nvm_store_create_path(lc_data_path, LEADER_INFO_FILE);
+
+    int ret = thread_nvm_store_read(lc_data_path, mleid_rloc_map, sizeof(thread_nvm_mleid_rloc_map), &version);
+
+    if (LEADER_INFO_DATA_VERSION!=version) {
+        tr_info("Leader data map version mismatch %"PRIu32, version);
+        thread_nvm_store_mleid_rloc_map_remove();
+        return THREAD_NVM_FILE_VERSION_WRONG;
+    }
+    if (THREAD_NVM_FILE_SUCCESS!=ret) {
+        tr_info("Leader data map read failed");
+        thread_nvm_store_mleid_rloc_map_remove();
+    }
+    return ret;
+}
+
+int thread_nvm_store_mleid_rloc_map_remove(void)
+{
+    int status;
+    tr_info("thread_nvm_store_leader_info_remove");
+
+    if (!ns_file_system_get_root_path()) {
+        return THREAD_NVM_FILE_ROOT_PATH_INVALID;
+    }
+
+    char lc_data_path[LEADER_INFO_STRING_LEN];
+    thread_nvm_store_create_path(lc_data_path, LEADER_INFO_FILE);
+    status = remove(lc_data_path);
+    if (status != 0) {
+      return THREAD_NVM_FILE_REMOVE_ERROR;
+    }
+    return THREAD_NVM_FILE_SUCCESS;
+}
+
 int thread_nvm_store_device_configuration_write(uint8_t *mac_ptr, uint8_t *mleid_ptr)
 {
    thread_nvm_device_conf_t d_c;

source/6LoWPAN/Thread/thread_nvm_store.h

@@ -67,6 +67,15 @@ typedef struct {
     uint8_t mle_id[8];
 } thread_nvm_device_conf_t;
 
+typedef struct {
+    uint8_t mle_id[8];
+} thread_nvm_rloc_map_entry_t;
+
+typedef struct {
+    // mapping is in order from 0 to 63
+    thread_nvm_rloc_map_entry_t mleid_rloc_map[64];
+} thread_nvm_mleid_rloc_map;
+
 /* reads all fast data from nvm, if the return values is THREAD_NVM_FILE_ROOT_PATH_INVALID, the cached values are returned.  */
 int thread_nvm_store_fast_data_read(thread_nvm_fast_data_t* fast_data);
 /* stores all fast data to nvm */
@@ -87,6 +96,9 @@ int thread_nvm_store_active_configuration_remove(void);
 
 int thread_nvm_store_device_configuration_write(uint8_t *mac_ptr, uint8_t *mleid_ptr);
 int thread_nvm_store_device_configuration_read(uint8_t *mac_ptr, uint8_t *mleid_ptr);
+int thread_nvm_store_mleid_rloc_map_write(thread_nvm_mleid_rloc_map *mleid_rloc_map);
+int thread_nvm_store_mleid_rloc_map_read(thread_nvm_mleid_rloc_map *mleid_rloc_map);
+int thread_nvm_store_mleid_rloc_map_remove(void);
 int thread_nvm_store_pending_configuration_write(void *data, uint16_t size);
 int thread_nvm_store_pending_configuration_read(void *data, uint16_t size);
 int thread_nvm_store_pending_configuration_remove(void);

source/6LoWPAN/Thread/thread_router_bootstrap.c

@@ -410,6 +410,8 @@ static void thread_router_synch_receive_cb(int8_t interface_id, mle_message_t *m
                cur->thread_info->thread_leader_data->dataVersion--;
                cur->thread_info->thread_leader_data->stableDataVersion--;
                thread_network_data_request_send(cur, mle_msg->packet_src_address, true);
+               // remove any existing rloc mapping in nvm
+               thread_nvm_store_mleid_rloc_map_remove();
                tr_info("Router synch OK as Router");
             }