diff --git a/framework/include/binary_manager/binary_manager.h b/framework/include/binary_manager/binary_manager.h index ddcf708528..25c393ee52 100644 --- a/framework/include/binary_manager/binary_manager.h +++ b/framework/include/binary_manager/binary_manager.h @@ -32,6 +32,11 @@ * Included Files ***************************************************************************/ #include +#include + +#ifdef __cplusplus +extern "C" { +#endif /**************************************************************************** * Pre-processor Definitions @@ -69,6 +74,17 @@ binmgr_result_type_e binary_manager_get_update_info(char *binary_name, binary_up * @since TizenRT v3.0 */ binmgr_result_type_e binary_manager_get_update_info_all(binary_update_info_list_t *binary_info_list); + +/** + * @brief Get the all binaries information in inactive partition + * @details @b #include \n + * It requests the binary manager to get the information of all binaries in inactive partition. + * @param[out] binary_info_list The address value to receive the binary information list + * @return A defined value of binmgr_result_type_e in + * 0 (BINMGR_OK) On success. On failure, negative value is returned. + * @since TizenRT v3.0 + */ +binmgr_result_type_e binary_manager_get_inactive_info_all(binary_update_info_list_t *binary_info_list); #endif /** @@ -150,6 +166,19 @@ binmgr_result_type_e binary_manager_get_state(char *binary_name, int *state); */ binmgr_result_type_e binary_manager_set_bootparam(uint8_t type, binary_setbp_result_t *update_result); +/** + * @brief Swap partition to inactive partition + * @details @b #include \n + * It sends a message the binary manager to update boot paramer to swap opposite partition. + * @return A defined value of binmgr_result_type_e in + * 0 (BINMGR_OK) on success. On failure, negative value is returned. + * @since TizenRT v5.0 + */ +binmgr_result_type_e binary_manager_swap_partition(void); +#ifdef __cplusplus +} +#endif + #endif /** * @} diff --git a/framework/src/binary_manager/binary_manager_interface.c b/framework/src/binary_manager/binary_manager_interface.c index e6b492b3be..67c1b778e5 100644 --- a/framework/src/binary_manager/binary_manager_interface.c +++ b/framework/src/binary_manager/binary_manager_interface.c @@ -59,6 +59,8 @@ binmgr_result_type_e binary_manager_set_request(binmgr_request_t *request_msg, i case BINMGR_SETBP: request_msg->data.type = *(uint8_t *)arg; break; + case BINMGR_SWAPBP: + break; #endif case BINMGR_REGISTER_STATECB: if (arg == NULL) { diff --git a/framework/src/binary_manager/binary_manager_update.c b/framework/src/binary_manager/binary_manager_update.c index d03143e5be..166e62a583 100644 --- a/framework/src/binary_manager/binary_manager_update.c +++ b/framework/src/binary_manager/binary_manager_update.c @@ -244,3 +244,66 @@ binmgr_result_type_e binary_manager_get_current_path(char *binary_name, char *do return response_msg.result; } + +binmgr_result_type_e binary_manager_swap_partition(void) +{ +#ifndef CONFIG_USE_BP + /* In the case of 3.1 bootloader, we dont have bp. So we need not + * update the bp to swap partitions, it is automatically done on + * reboot, so return success */ + return BINMGR_OK; +#else + binmgr_result_type_e ret; + binmgr_request_t request_msg; + binmgr_setbp_response_t response_msg; + + ret = binary_manager_set_request(&request_msg, BINMGR_SWAPBP, NULL); + if (ret != BINMGR_OK) { + return ret; + } + + ret = binary_manager_send_request(&request_msg); + if (ret != BINMGR_OK) { + return ret; + } + + ret = binary_manager_receive_response(&response_msg, sizeof(binmgr_response_t)); + if (ret != BINMGR_OK) { + return ret; + } + + return response_msg.result; +#endif +} + +binmgr_result_type_e binary_manager_get_inactive_info_all(binary_update_info_list_t *binary_info_list) +{ + binmgr_result_type_e ret; + binmgr_request_t request_msg; + binmgr_getinfo_all_response_t response_msg; + + ret = binary_manager_set_request(&request_msg, BINMGR_GET_INFO_INACTIVE_ALL, NULL); + if (ret != BINMGR_OK) { + return ret; + } + + ret = binary_manager_send_request(&request_msg); + if (ret != BINMGR_OK) { + return ret; + } + + ret = binary_manager_receive_response(&response_msg, sizeof(binmgr_getinfo_all_response_t)); + if (ret != BINMGR_OK) { + return ret; + } + + if (response_msg.result == BINMGR_OK) { + /* Copy binary info list data */ + memset(binary_info_list, 0, sizeof(binary_update_info_list_t)); + memcpy(binary_info_list, &response_msg.data, sizeof(binary_update_info_list_t)); + } else { + bmdbg("Binary manager getinfo_inactive_all FAIL %d\n", response_msg.result); + } + + return response_msg.result; +} diff --git a/os/include/tinyara/binary_manager.h b/os/include/tinyara/binary_manager.h index 939bbd1116..373b02b950 100644 --- a/os/include/tinyara/binary_manager.h +++ b/os/include/tinyara/binary_manager.h @@ -28,6 +28,10 @@ #include #include +#ifdef __cplusplus +extern "C" { +#endif + #ifdef CONFIG_BINARY_MANAGER /**************************************************************************** * Pre-processor Definitions @@ -125,6 +129,10 @@ enum binmgr_request_msg_type { #ifdef CONFIG_BINMGR_RECOVERY BINMGR_FAULT, #endif +#ifdef CONFIG_USE_BP + BINMGR_SWAPBP, +#endif + BINMGR_GET_INFO_INACTIVE_ALL, }; /* Result values of returned from binary manager. */ @@ -254,6 +262,11 @@ struct binmgr_request_s { }; typedef struct binmgr_request_s binmgr_request_t; +struct binmgr_response_s { + binmgr_result_type_e result; +}; +typedef struct binmgr_response_s binmgr_response_t; + struct binmgr_setbp_response_s { binmgr_result_type_e result; binary_setbp_result_t data; @@ -300,14 +313,6 @@ void binary_manager_register_respart(int part_num, int part_size, uint32_t part_ int binary_manager_mount_resource(void); void binary_manager_deinit_modules(void); -#ifdef __cplusplus -#define EXTERN extern "C" -extern "C" { -#else -#define EXTERN extern -#endif - -#undef EXTERN #ifdef __cplusplus } #endif diff --git a/os/kernel/binary_manager/binary_manager.c b/os/kernel/binary_manager/binary_manager.c index e53f9921e4..7283f527a8 100644 --- a/os/kernel/binary_manager/binary_manager.c +++ b/os/kernel/binary_manager/binary_manager.c @@ -211,6 +211,9 @@ int binary_manager(int argc, char *argv[]) case BINMGR_GET_INFO_ALL: binary_manager_get_info_all(request_msg.requester_pid); break; + case BINMGR_GET_INFO_INACTIVE_ALL: + binary_manager_get_inactive_info_all(request_msg.requester_pid); + break; case BINMGR_GET_DOWNLOAD_PATH: binary_manager_get_inactive_path(request_msg.requester_pid, request_msg.data.bin_name); break; @@ -221,6 +224,9 @@ int binary_manager(int argc, char *argv[]) case BINMGR_SETBP: binary_manager_update_bootparam(request_msg.requester_pid, request_msg.data.type); break; + case BINMGR_SWAPBP: + binary_manager_swap_bootparam(request_msg.requester_pid); + break; #endif case BINMGR_UPDATE: #ifdef CONFIG_APP_BINARY_SEPARATION diff --git a/os/kernel/binary_manager/binary_manager.h b/os/kernel/binary_manager/binary_manager.h index 5bc78daabc..12e57a3f2c 100644 --- a/os/kernel/binary_manager/binary_manager.h +++ b/os/kernel/binary_manager/binary_manager.h @@ -302,8 +302,10 @@ int binary_manager_update_kernel_binary(void); #ifdef CONFIG_RESOURCE_FS binmgr_resinfo_t *binary_manager_get_resdata(void); int binary_manager_unmount_resource(void); -int binary_manager_check_resource_update(void); +int binary_manager_check_resource_update(bool check_updatable); #endif +int binary_manager_check_kernel_update(bool check_updatable); +int binary_manager_check_user_update(int bin_idx, bool check_updatable); /**************************************************************************** * Binary Manager Main Thread diff --git a/os/kernel/binary_manager/binary_manager_bootparam.c b/os/kernel/binary_manager/binary_manager_bootparam.c index 46745e7efe..b48badd05a 100644 --- a/os/kernel/binary_manager/binary_manager_bootparam.c +++ b/os/kernel/binary_manager/binary_manager_bootparam.c @@ -27,6 +27,7 @@ #include #include +#include #include "binary_manager.h" @@ -284,8 +285,8 @@ void binary_manager_update_bootparam(int requester_pid, uint8_t type) if (BM_CHECK_GROUP(type, BINARY_KERNEL)) { /* Update bootparam and Reboot if new kernel binary exists */ - ret = binary_manager_check_kernel_update(); - if (ret == BINMGR_OK) { + ret = binary_manager_check_kernel_update(true); + if (ret > 0) { /* Update index for inactive partition */ update_bp_data.active_idx ^= 1; } else if (ret == BINMGR_ALREADY_UPDATED || ret == BINMGR_NOT_FOUND) { @@ -301,8 +302,8 @@ void binary_manager_update_bootparam(int requester_pid, uint8_t type) #ifdef CONFIG_RESOURCE_FS if (BM_CHECK_GROUP(type, BINARY_RESOURCE)) { /* Update bootparam if new resource binary exists */ - ret = binary_manager_check_resource_update(); - if (ret == BINMGR_OK) { + ret = binary_manager_check_resource_update(true); + if (ret > 0) { /* Update index for inactive partition */ update_bp_data.resource_active_idx ^= 1; } else if (ret == BINMGR_ALREADY_UPDATED || ret == BINMGR_NOT_FOUND) { @@ -324,8 +325,8 @@ void binary_manager_update_bootparam(int requester_pid, uint8_t type) /* Reload binaries if new binary is scanned */ for (bin_idx = 1; bin_idx <= bin_count; bin_idx++) { /* Scan binary files */ - ret = binary_manager_check_user_update(bin_idx); - if (ret == BINMGR_OK) { + ret = binary_manager_check_user_update(bin_idx, true); + if (ret > 0) { /* Update index for inactive partition */ update_bp_data.app_data[BIN_BPIDX(bin_idx)].useidx ^= 1; need_update = true; @@ -345,8 +346,8 @@ void binary_manager_update_bootparam(int requester_pid, uint8_t type) #ifdef CONFIG_SUPPORT_COMMON_BINARY if (BM_CHECK_GROUP(type, BINARY_COMMON)) { - ret = binary_manager_check_user_update(BM_CMNLIB_IDX); - if (ret == BINMGR_OK) { + ret = binary_manager_check_user_update(BM_CMNLIB_IDX, true); + if (ret > 0) { /* Update index for inactive partition */ update_bp_data.app_data[BIN_BPIDX(BM_CMNLIB_IDX)].useidx ^= 1; } else if (ret == BINMGR_ALREADY_UPDATED || ret == BINMGR_NOT_FOUND) { @@ -376,7 +377,9 @@ void binary_manager_update_bootparam(int requester_pid, uint8_t type) } send_response: - kmm_free(bootparam); + if (bootparam) { + kmm_free(bootparam); + } response_msg.result = ret; snprintf(q_name, BIN_PRIVMQ_LEN, "%s%d", BINMGR_RESPONSE_MQ_PREFIX, requester_pid); binary_manager_send_response(q_name, &response_msg, sizeof(binmgr_setbp_response_t)); @@ -422,3 +425,96 @@ void binary_manager_set_bpidx(uint8_t index) { g_bp_info.inuse_idx = index; } + +void binary_manager_swap_bootparam(int requester_pid) +{ + int ret; + char *bootparam; + bool is_all_updatable; + char q_name[BIN_PRIVMQ_LEN]; + binmgr_bpdata_t update_bp_data; + binmgr_response_t response_msg; +#ifdef CONFIG_APP_BINARY_SEPARATION + int bin_idx; + uint32_t bin_count; +#endif + + memset((void *)&response_msg, 0, sizeof(binmgr_response_t)); + + if (requester_pid < 0) { + bmdbg("Invalid requester pid %d\n", requester_pid); + return; + } + + bootparam = (char *)kmm_malloc(BOOTPARAM_SIZE); + if (!bootparam) { + bmdbg("Fail to malloc to read BP\n"); + ret = BINMGR_OUT_OF_MEMORY; + goto send_response; + } + memset(bootparam, 0xff, BOOTPARAM_SIZE); + + response_msg.result = BINMGR_OK; + is_all_updatable = true; + + /* Get current bootparam data */ + memcpy(&update_bp_data, binary_manager_get_bpdata(), sizeof(binmgr_bpdata_t)); + update_bp_data.version++; + + /* Update bootparam and Reboot if valid kernel binary exists */ + ret = binary_manager_check_kernel_update(false); + if (ret < 0) { + bmdbg("Fail to find valid kernel binary, %d\n", ret); + goto send_response; + } + update_bp_data.active_idx ^= 1; + +#ifdef CONFIG_RESOURCE_FS + /* Update bootparam if valid resource binary exists */ + ret = binary_manager_check_resource_update(false); + if (ret < 0) { + bmdbg("Fail to find valid resource binary, %d\n", ret); + goto send_response; + } + update_bp_data.resource_active_idx ^= 1; +#endif + +#ifdef CONFIG_APP_BINARY_SEPARATION + bin_count = binary_manager_get_ucount(); + for (bin_idx = 1; bin_idx <= bin_count; bin_idx++) { + /* Scan binary files */ + ret = binary_manager_check_user_update(bin_idx, false); + if (ret < 0) { + bmdbg("Fail to find valid user binary, %d\n", ret); + goto send_response; + } + update_bp_data.app_data[BIN_BPIDX(bin_idx)].useidx ^= 1; + } + +#ifdef CONFIG_SUPPORT_COMMON_BINARY + ret = binary_manager_check_user_update(BM_CMNLIB_IDX, false); + if (ret < 0) { + bmdbg("Fail to find valid common binary, %d\n", ret); + goto send_response; + } + update_bp_data.app_data[BIN_BPIDX(BM_CMNLIB_IDX)].useidx ^= 1; +#endif +#endif + + /* Then, Write bootparam with updated bootparam data */ + memcpy(bootparam, &update_bp_data, sizeof(binmgr_bpdata_t)); + ret = binary_manager_write_bootparam(bootparam); + if (ret == BINMGR_OK) { + bmvdbg("Update BP SUCCESS\n"); + } else { + bmdbg("Fail to update BP, %d\n", ret); + } + +send_response: + if (bootparam) { + kmm_free(bootparam); + } + response_msg.result = ret; + snprintf(q_name, BIN_PRIVMQ_LEN, "%s%d", BINMGR_RESPONSE_MQ_PREFIX, requester_pid); + binary_manager_send_response(q_name, &response_msg, sizeof(binmgr_response_t)); +} diff --git a/os/kernel/binary_manager/binary_manager_data.c b/os/kernel/binary_manager/binary_manager_data.c index fd4087bad8..d3787faea6 100644 --- a/os/kernel/binary_manager/binary_manager_data.c +++ b/os/kernel/binary_manager/binary_manager_data.c @@ -165,14 +165,16 @@ bool binary_manager_scan_kbin(void) } /************************************************************************************* -* Name: binary_manager_check_kernel_update -* -* Description: -* This function checks that new kernel binary exists on inactive partition -* and verifies the update is needed by comparing running version with new version. -* -*************************************************************************************/ -int binary_manager_check_kernel_update(void) + * Name: binary_manager_check_kernel_update + * + * Description: + * This function checks that new user binary exists in their own inactive partition. + * If check_updatable is true, validate whole binary by checking CRC + * and it checks version by comparing running version with version of binary in inactive partition. + * Otherwise, it just checks header data of binary. + * + *******************************************************************************************/ +int binary_manager_check_kernel_update(bool check_updatable) { int ret; int inactive_partidx; @@ -194,8 +196,12 @@ int binary_manager_check_kernel_update(void) /* Verify kernel binary on the partition without running binary */ snprintf(filepath, BINARY_PATH_LEN, BINMGR_DEVNAME_FMT, kernel_info.part_info[inactive_partidx].devnum); - ret = binary_manager_read_header(BINARY_KERNEL, filepath, (void *)&header_data, true); + ret = binary_manager_read_header(BINARY_KERNEL, filepath, (void *)&header_data, check_updatable); if (ret == BINMGR_OK) { + if (!check_updatable) { + bmvdbg("Found valid kernel binary in inactive partition %d\n", kernel_info.part_info[inactive_partidx].devnum); + return header_data.version; + } #ifdef CONFIG_BINMGR_UPDATE_SAME_VERSION if (kernel_info.version <= header_data.version) { #else @@ -203,12 +209,14 @@ int binary_manager_check_kernel_update(void) #endif /* Need to update bootparam and reboot */ bmvdbg("Found new kernel binary in inactive partition %d\n", kernel_info.part_info[inactive_partidx].devnum); - return BINMGR_OK; - } else { - bmvdbg("Latest version is running, version %d\n", kernel_info.version); - return BINMGR_ALREADY_UPDATED; + return header_data.version; } + + /* Running version is the latest */ + bmvdbg("Latest version is running, version %d\n", kernel_info.version); + return BINMGR_ALREADY_UPDATED; } + bmdbg("No valid kernel binary in inactive partition\n"); return ret; } @@ -250,8 +258,8 @@ int binary_manager_check_update(void) goto reboot; } #else - ret = binary_manager_check_kernel_update(); - if (ret == BINMGR_OK) { + ret = binary_manager_check_kernel_update(true); + if (ret > 0) { /* Reboot to switch kernel binary in another partition. */ goto reboot; } else if (ret != BINMGR_ALREADY_UPDATED && ret != BINMGR_NOT_FOUND) { @@ -272,8 +280,8 @@ int binary_manager_check_update(void) for (bin_idx = 1; bin_idx <= bin_count; bin_idx++) { #endif /* Scan binary files */ - ret = binary_manager_check_user_update(bin_idx); - if (ret == BINMGR_OK) { + ret = binary_manager_check_user_update(bin_idx, true); + if (ret > 0) { /* Update index for inactive partition */ BIN_USEIDX(bin_idx) ^= 1; need_update = true; @@ -495,11 +503,13 @@ bool binary_manager_scan_ubin_all(void) * Name: binary_manager_check_user_update * * Description: - * This function checks that new user binary exists on inactive partition - * and verifies the update is needed by comparing running version with new version. + * This function checks that new user binary exists in their own inactive partition. + * If check_updatable is true, validate whole binary by checking CRC + * and it checks version by comparing running version with version of binary in inactive partition. + * Otherwise, it just checks header data of binary. * *******************************************************************************************/ -int binary_manager_check_user_update(int bin_idx) +int binary_manager_check_user_update(int bin_idx, bool check_updatable) { int ret; int part_idx; @@ -531,10 +541,10 @@ int binary_manager_check_user_update(int bin_idx) #endif snprintf(devpath, BINARY_PATH_LEN, BINMGR_DEVNAME_FMT, BIN_PARTNUM(bin_idx, part_idx)); if (bin_idx == BM_CMNLIB_IDX) { - ret = binary_manager_read_header(BINARY_COMMON, devpath, (void *)&common_header_data, true); + ret = binary_manager_read_header(BINARY_COMMON, devpath, (void *)&common_header_data, check_updatable); version = common_header_data.version; } else { - ret = binary_manager_read_header(BINARY_USERAPP, devpath, (void *)&user_header_data, true); + ret = binary_manager_read_header(BINARY_USERAPP, devpath, (void *)&user_header_data, check_updatable); version = user_header_data.bin_ver; } if (ret == BINMGR_OK) { @@ -542,19 +552,23 @@ int binary_manager_check_user_update(int bin_idx) if (bin_idx != BM_CMNLIB_IDX) { BIN_LOAD_PRIORITY(bin_idx, part_idx) = user_header_data.loading_priority; } + if (!check_updatable) { + bmvdbg("Found valid binary in part %d\n", version, BIN_PARTNUM(bin_idx, part_idx)); + return version; + } #ifdef CONFIG_BINMGR_UPDATE_SAME_VERSION if (running_ver <= version) { #else if (running_ver < version) { #endif - bmvdbg("Found Latest version %u in part %d\n", version, BIN_PARTNUM(bin_idx, part_idx)); - return BINMGR_OK; - } else { - bmdbg("No update! Latest version is running, version %d\n", running_ver); - return BINMGR_ALREADY_UPDATED; + bmvdbg("Found Latest version %u in part %d\n", version, BIN_PARTNUM(bin_idx, part_idx)); + return version; } + /* Running version is the latest */ + bmdbg("No update! Latest version is running, version %d\n", running_ver); + return BINMGR_ALREADY_UPDATED; } - + bmdbg("No valid binary in inactive partition\n"); return ret; } diff --git a/os/kernel/binary_manager/binary_manager_getinfo.c b/os/kernel/binary_manager/binary_manager_getinfo.c index c063c99d89..930f8cfd6b 100644 --- a/os/kernel/binary_manager/binary_manager_getinfo.c +++ b/os/kernel/binary_manager/binary_manager_getinfo.c @@ -325,3 +325,99 @@ int binary_manager_get_inactive_path(int requester_pid, char *bin_name) { return binary_manager_get_path(requester_pid, bin_name, true); } + +/**************************************************************************** + * Name: binary_manager_get_inactive_info_all + * + * Description: + * This function gets info of all registered binaries in inactive(non-running) partition. + * + ****************************************************************************/ +void binary_manager_get_inactive_info_all(int requester_pid) +{ + int ret; +#ifdef CONFIG_APP_BINARY_SEPARATION + int bin_idx; + uint32_t bin_count; +#endif +#ifdef CONFIG_RESOURCE_FS + binmgr_resinfo_t *resinfo; +#endif + int result_idx; + char q_name[BIN_PRIVMQ_LEN]; + binmgr_kinfo_t *kerinfo; + binmgr_getinfo_all_response_t response_msg; + + if (requester_pid < 0) { + bmdbg("Invalid requester pid %d\n", requester_pid); + return; + } + snprintf(q_name, BIN_PRIVMQ_LEN, "%s%d", BINMGR_RESPONSE_MQ_PREFIX, requester_pid); + + result_idx = 0; + memset((void *)&response_msg, 0, sizeof(binmgr_getinfo_all_response_t)); + response_msg.result = BINMGR_OK; + + /* Get kernel data */ + kerinfo = binary_manager_get_kdata(); + strncpy(response_msg.data.bin_info[result_idx].name, "kernel", BIN_NAME_MAX); + + ret = binary_manager_check_kernel_update(false); + if (ret > 0) { + response_msg.data.bin_info[result_idx].version = ret; + } else { + response_msg.data.bin_info[result_idx].version = -1; + response_msg.result = BINMGR_NOT_FOUND; + } + if (kerinfo->part_count > 1) { + response_msg.data.bin_info[result_idx].available_size = kerinfo->part_info[kerinfo->inuse_idx ^ 1].size; + } else { + response_msg.data.bin_info[result_idx].available_size = -1; + } + result_idx++; + +#ifdef CONFIG_APP_BINARY_SEPARATION + /* User binaries data */ + bin_count = binary_manager_get_ucount(); +#ifdef CONFIG_SUPPORT_COMMON_BINARY + for (bin_idx = 0; bin_idx <= bin_count; bin_idx++) { +#else + for (bin_idx = 1; bin_idx <= bin_count; bin_idx++) { +#endif + response_msg.data.bin_info[result_idx].available_size = BIN_PARTSIZE(bin_idx, (BIN_USEIDX(bin_idx) ^ 1)); + strncpy(response_msg.data.bin_info[result_idx].name, BIN_NAME(bin_idx) , BIN_NAME_MAX); + ret = binary_manager_check_user_update(bin_idx, false); + if (ret > 0) { + response_msg.data.bin_info[result_idx].version = ret; + } else { + response_msg.data.bin_info[result_idx].version = -1; + response_msg.result = BINMGR_NOT_FOUND; + } + result_idx++; + } +#endif +#ifdef CONFIG_RESOURCE_FS + /* Get resource data */ + resinfo = binary_manager_get_resdata(); + strncpy(response_msg.data.bin_info[result_idx].name, "resource", BIN_NAME_MAX); + + ret = binary_manager_check_resource_update(false); + if (ret > 0) { + response_msg.data.bin_info[result_idx].version = ret; + } else { + response_msg.data.bin_info[result_idx].version = -1; + response_msg.result = BINMGR_NOT_FOUND; + } + if (resinfo->part_count > 1) { + response_msg.data.bin_info[result_idx].available_size = resinfo->part_info[resinfo->inuse_idx ^ 1].size; + } else { + response_msg.data.bin_info[result_idx].available_size = -1; + } + result_idx++; +#endif + if (response_msg.result == BINMGR_OK) { + response_msg.data.bin_count = result_idx; + } + + binary_manager_send_response(q_name, &response_msg, sizeof(binmgr_getinfo_all_response_t)); +} diff --git a/os/kernel/binary_manager/binary_manager_resource.c b/os/kernel/binary_manager/binary_manager_resource.c index d4e30a1c3d..37637a48ca 100644 --- a/os/kernel/binary_manager/binary_manager_resource.c +++ b/os/kernel/binary_manager/binary_manager_resource.c @@ -209,14 +209,16 @@ int binary_manager_unmount_resource(void) } /************************************************************************************* -* Name: binary_manager_check_resource_update -* -* Description: -* This function checks that new resource binary exists on inactive partition -* and verifies the update is needed by comparing running version with new version. -* -*************************************************************************************/ -int binary_manager_check_resource_update(void) + * Name: binary_manager_check_resource_update + * + * Description: + * This function checks that new user binary exists in their own inactive partition. + * If check_updatable is true, validate whole binary by checking CRC + * and it checks version by comparing running version with version of binary in inactive partition. + * Otherwise, it just checks header data of binary. + * + *******************************************************************************************/ +int binary_manager_check_resource_update(bool check_updatable) { int ret; int inactive_partidx; @@ -227,8 +229,12 @@ int binary_manager_check_resource_update(void) /* Verify resource binary on the partition without running binary */ snprintf(filepath, BINARY_PATH_LEN, BINMGR_DEVNAME_FMT, resource_info.part_info[inactive_partidx].devnum); - ret = binary_manager_read_header(BINARY_RESOURCE, filepath, (void *)&header_data, true); + ret = binary_manager_read_header(BINARY_RESOURCE, filepath, (void *)&header_data, check_updatable); if (ret == BINMGR_OK) { + if (!check_updatable) { + bmvdbg("Found valid resource binary in inactive partition %d\n", resource_info.part_info[inactive_partidx].devnum); + return header_data.version; + } #ifdef CONFIG_BINMGR_UPDATE_SAME_VERSION if (resource_info.version <= header_data.version) { #else @@ -236,11 +242,13 @@ int binary_manager_check_resource_update(void) #endif /* Need to update bootparam and reboot */ bmvdbg("Found new resource binary in inactive partition %d\n", resource_info.part_info[inactive_partidx].devnum); - return BINMGR_OK; - } else { - bmdbg("Latest version is running, version %d\n", resource_info.version); - return BINMGR_ALREADY_UPDATED; + return header_data.version; } + + /* Running version is the latest */ + bmdbg("Latest version is running, version %d\n", resource_info.version); + return BINMGR_ALREADY_UPDATED; } + bmdbg("No valid resource binary in inactive partition\n"); return ret; }