apps/boot/nxboot: Enhancements to add progress messages and copy-to-RAM feature

This adds Kconfig-enabled progress messages that are output to stdout.

It also adds Kconfig-enabled option to copy the validated and bootable image to RAM

Signed-off by: Tim Hardisty <[email protected]>

Author: TimJTi

boot/nxboot/Kconfig

@@ -64,6 +64,17 @@ config NXBOOT_BOOTLOADER
 
 if NXBOOT_BOOTLOADER
 
+config NXBOOT_COPY_TO_RAM
+	bool "Copy bootable image to RAM before calling board boot-image function"
+	default n
+
+config NXBOOT_RAMSTART
+	hex "Start address in RAM that the application is to be loaded"
+	default 0x0
+	depends on NXBOOT_COPY_TO_RAM
+	---help---
+		This will be board specific.
+
 config NXBOOT_SWRESET_ONLY
 	bool "Perform update/revert only on SW reset"
 	default n
@@ -92,6 +103,10 @@ config NXBOOT_PREVENT_DOWNGRADE
 		WARNING: NXboot currently implements preferences only for
 		MAJOR.MINOR.PATCH and ignores prerelease.
 
+config NXBOOT_PRINTF_PROGRESS
+	bool "Enable progress messages to be sent to STDOUT"
+	default n
+
 endif # NXBOOT_BOOTLOADER
 
 endif # BOOT_NXBOOT

boot/nxboot/include/nxboot.h

@@ -117,6 +117,7 @@ struct nxboot_img_header
 
   struct nxboot_img_version img_version; /* Image version */
 };
+
 static_assert(CONFIG_NXBOOT_HEADER_SIZE > sizeof(struct nxboot_img_header),
               "CONFIG_NXBOOT_HEADER_SIZE has to be larger than"
               "sizeof(struct nxboot_img_header)");
@@ -131,10 +132,41 @@ struct nxboot_state
   enum nxboot_update_type next_boot;  /* nxboot_update_type with next operation */
 };
 
+enum progress_type_e
+{
+  nxboot_info = 0,       /* Prefixes arg. string with "INFO:" */
+  nxboot_error,          /* Prefixes arg. string with "ERR:" */
+  nxboot_progress_start, /* Prints arg. string with no newline to allow ..... sequence to follow */
+  nxboot_progress_dot,   /* Prints of a "." to the ..... progress sequence */
+  nxboot_progress_end,   /* Flags end of a "..." progrees sequence and prints newline */
+};
+
+enum progress_msg_e
+{
+  startup_msg              = 0,
+  found_bootable_image,
+  no_bootable_image,
+  boardioc_image_boot_fail,
+  ramcopy_started,
+  recovery_revert,
+  recovery_create,
+  update_from_update,
+  validate_primary,
+  validate_recovery,
+  validate_update,
+  recovery_created,
+  recovery_invalid,
+  update_failed,
+  power_reset,
+  soft_reset,
+};
+
 /****************************************************************************
  * Public Function Prototypes
  ****************************************************************************/
 
+void nxboot_progress(enum progress_type_e type, ...);
+
 /****************************************************************************
  * Name: nxboot_get_state
  *
@@ -148,7 +180,7 @@ struct nxboot_state
  *   state: The pointer to nxboot_state structure. The state is stored here.
  *
  * Returned Value:
- *   0 on success, -1 and sets errno on failure.
+ *   OK (0) on success, ERROR (-1) and sets errno on failure.
  *
  ****************************************************************************/
 
@@ -164,7 +196,7 @@ int nxboot_get_state(struct nxboot_state *state);
  *   if afterwards.
  *
  * Returned Value:
- *   Valid file descriptor on success, -1 and sets errno on failure.
+ *   Valid file descriptor on success, ERROR (-1) and sets errno on failure.
  *
  ****************************************************************************/
 
@@ -180,7 +212,7 @@ int nxboot_open_update_partition(void);
  *   state of the bootloader.
  *
  * Returned Value:
- *   1 means confirmed, 0 not confirmed, -1 and sets errno on failure.
+ *   1 if confirmed, OK (0) on success, ERROR (-1) and sets errno on failure.
  *
  ****************************************************************************/
 
@@ -194,14 +226,14 @@ int nxboot_get_confirm(void);
  *   its copy in update partition as a recovery.
  *
  * Returned Value:
- *   0 on success, -1 and sets errno on failure.
+ *   OK (0) on success, ERROR (-1) and sets errno on failure.
  *
  ****************************************************************************/
 
 int nxboot_confirm(void);
 
 /****************************************************************************
- * Name: nxboot_perform_swap
+ * Name: nxboot_perform_update
  *
  * Description:
  *   Checks for the possible firmware update and performs it by copying
@@ -216,10 +248,29 @@ int nxboot_confirm(void);
  *   check_only: Only repairs corrupted update, but do not start another one
  *
  * Returned Value:
- *   0 on success, -1 and sets errno on failure.
+ *   OK (0) on success, ERROR (-1) and sets errno on failure.
  *
  ****************************************************************************/
 
 int nxboot_perform_update(bool check_only);
 
+/****************************************************************************
+ * Name: nxboot_ramcopy
+ *
+ * Description:
+ *   Copies the (already) validate bootable image to RAM memory
+ *
+ *   NOTE - no checking that the RAM location is correct, nor that the
+ *          image size is appropriate for that RAM address!
+ *
+ * Input parameters:
+ *   none
+ *
+ * Returned Value:
+ *   OK (0) on success, ERROR (-1) on fail
+ *
+ ****************************************************************************/
+
+int nxboot_ramcopy(void);
+
 #endif /* __BOOT_NXBOOT_INCLUDE_NXBOOT_H */

boot/nxboot/loader/boot.c

@@ -106,6 +106,10 @@ static uint32_t calculate_crc(int fd, struct nxboot_img_header *header)
       off += readsiz;
       remain -= readsiz;
       crc = crc32part((uint8_t *)buf, readsiz, crc);
+      if ((remain % 25) == 0)
+        {
+          nxboot_progress(nxboot_progress_dot);
+        }
     }
 
   free(buf);
@@ -202,6 +206,10 @@ static int copy_partition(int from, int where, struct nxboot_state *state,
 
       off += readsiz;
       remain -= readsiz;
+      if ((remain % 25) == 0)
+        {
+          nxboot_progress(nxboot_progress_dot);
+        }
     }
 
   free(buf);
@@ -218,6 +226,7 @@ static bool validate_image(int fd)
       return false;
     }
 
+  syslog(LOG_INFO, "Validating image.\n");
   return calculate_crc(fd, &header) == header.crc;
 }
 
@@ -268,18 +277,24 @@ static enum nxboot_update_type
                   struct nxboot_img_header *update_header,
                   struct nxboot_img_header *recovery_header)
 {
+  nxboot_progress(nxboot_progress_start, validate_primary);
   bool primary_valid = validate_image(primary);
+  nxboot_progress(nxboot_progress_end);
 
+  nxboot_progress(nxboot_progress_start, validate_update);
   if (update_header->magic == NXBOOT_HEADER_MAGIC && validate_image(update))
     {
       if (primary_header->crc != update_header->crc ||
           !compare_versions(&primary_header->img_version,
           &update_header->img_version) || !primary_valid)
         {
+          nxboot_progress(nxboot_progress_end);
           return NXBOOT_UPDATE_TYPE_UPDATE;
         }
     }
 
+  nxboot_progress(nxboot_progress_end);
+
   if (IS_INTERNAL_MAGIC(recovery_header->magic) && state->recovery_valid &&
       ((IS_INTERNAL_MAGIC(primary_header->magic) &&
       !state->primary_confirmed) || !primary_valid))
@@ -292,6 +307,7 @@ static enum nxboot_update_type
 
 static int perform_update(struct nxboot_state *state, bool check_only)
 {
+  int successful;
   int update;
   int recovery;
   int primary;
@@ -331,18 +347,25 @@ static int perform_update(struct nxboot_state *state, bool check_only)
       recovery = secondary;
     }
 
+  nxboot_progress(nxboot_progress_start, validate_primary);
   if (state->next_boot == NXBOOT_UPDATE_TYPE_REVERT &&
       (!check_only || !validate_image(primary)))
     {
+      nxboot_progress(nxboot_progress_end);
       if (state->recovery_valid)
         {
           syslog(LOG_INFO, "Reverting image to recovery.\n");
+          nxboot_progress(nxboot_progress_start, recovery_revert);
           copy_partition(recovery, primary, state, false);
+          nxboot_progress(nxboot_progress_end);
         }
     }
   else
     {
+      nxboot_progress(nxboot_progress_end);
+      nxboot_progress(nxboot_progress_start, validate_primary);
       primary_valid = validate_image(primary);
+      nxboot_progress(nxboot_progress_end);
       if (primary_valid && check_only)
         {
           /* Skip if primary image is valid (does not mather whether
@@ -368,21 +391,33 @@ static int perform_update(struct nxboot_state *state, bool check_only)
            */
 
           syslog(LOG_INFO, "Creating recovery image.\n");
+          nxboot_progress(nxboot_progress_start, recovery_create);
           copy_partition(primary, recovery, state, false);
-          if (!validate_image(recovery))
+          nxboot_progress(nxboot_progress_end);
+          nxboot_progress(nxboot_progress_start, validate_recovery);
+          successful = validate_image(recovery);
+          nxboot_progress(nxboot_progress_end);
+          if (!successful)
             {
-              syslog(LOG_INFO, "New recovery is not valid, stop update.\n");
+              syslog(LOG_INFO,
+                            "New recovery is not valid,stop update.\n");
+              nxboot_progress(nxboot_info, recovery_invalid);
               goto perform_update_done;
             }
 
           syslog(LOG_INFO, "Recovery image created.\n");
+          nxboot_progress(nxboot_info, recovery_created);
         }
 
-      if (validate_image(update))
+      nxboot_progress(nxboot_progress_start, validate_update);
+      successful = validate_image(update);
+      nxboot_progress(nxboot_progress_end);
+      if (successful)
         {
           /* Perform update only if update slot contains valid image. */
 
           syslog(LOG_INFO, "Updating from update image.\n");
+          nxboot_progress(nxboot_progress_start, update_from_update);
           if (copy_partition(update, primary, state, true) >= 0)
             {
               /* Erase the first sector of update partition. This marks the
@@ -393,6 +428,8 @@ static int perform_update(struct nxboot_state *state, bool check_only)
 
               flash_partition_erase_first_sector(update);
             }
+
+          nxboot_progress(nxboot_progress_end);
         }
     }
 
@@ -403,6 +440,46 @@ static int perform_update(struct nxboot_state *state, bool check_only)
   return OK;
 }
 
+#ifdef CONFIG_NXBOOT_COPY_TO_RAM
+int nxboot_ramcopy(void)
+{
+  int ret = OK;
+  int primary;
+  struct nxboot_img_header header;
+  ssize_t bytes;
+  static uint8_t *buf;
+
+  primary = flash_partition_open(CONFIG_NXBOOT_PRIMARY_SLOT_PATH);
+  if (primary < 0)
+    {
+      return ERROR;
+    }
+
+  get_image_header(primary, &header);
+  buf = malloc(header.size);
+  if (!buf)
+    {
+      ret = ERROR;
+      goto exit_with_error;
+    }
+
+  bytes = pread(primary, buf, header.size, header.header_size);
+  if (bytes != header.size)
+    {
+      ret = ERROR;
+      goto exit_with_error;
+    }
+
+  memcpy((uint32_t *)CONFIG_NXBOOT_RAMSTART, buf, header.size);
+
+exit_with_error:
+  flash_partition_close(primary);
+  free(buf);
+
+  return ret;
+}
+#endif
+
 /****************************************************************************
  * Public Functions
  ****************************************************************************/
@@ -528,7 +605,9 @@ int nxboot_get_state(struct nxboot_state *state)
       state->update = NXBOOT_TERTIARY_SLOT_NUM;
     }
 
+  nxboot_progress(nxboot_progress_start, validate_recovery);
   state->recovery_valid = validate_image(recovery);
+  nxboot_progress(nxboot_progress_end);
   state->recovery_present = primary_header.crc == recovery_header->crc;
 
   /* The image is confirmed if it has either NXBOOT_HEADER_MAGIC or a
@@ -611,7 +690,7 @@ int nxboot_get_confirm(void)
   int recovery;
   int recovery_pointer;
   char *path;
-  int ret = 0;
+  int ret = OK;
   struct nxboot_img_header primary_header;
   struct nxboot_img_header recovery_header;
 
@@ -799,6 +878,7 @@ int nxboot_perform_update(bool check_only)
            */
 
           syslog(LOG_ERR, "Update process failed: %s\n", strerror(errno));
+          nxboot_progress(nxboot_error, update_failed);
         }
     }
 
@@ -823,3 +903,4 @@ int nxboot_perform_update(bool check_only)
 
   return ret;
 }
+

boot/nxboot/loader/flash.c

@@ -202,8 +202,8 @@ int flash_partition_read(int fd, void *buf, size_t count, off_t off)
   nbytes = read(fd, buf, count);
   if (nbytes != count)
     {
-      syslog(LOG_ERR, "Read from offset %ld failed %s\n",
-              off, strerror(errno));
+      syslog(LOG_ERR, "Read from offset %ld failed %s\n", off,
+                      strerror(errno));
       return ERROR;
     }
 
@@ -265,7 +265,7 @@ int flash_partition_erase_first_sector(int fd)
   if (ret < 0)
     {
       syslog(LOG_ERR, "Could not erase the partition: %s\n",
-              strerror(errno));
+                      strerror(errno));
       return ERROR;
     }
 
@@ -295,7 +295,8 @@ int flash_partition_info(int fd, struct flash_partition_info *info)
   ret = ioctl(fd, MTDIOC_GEOMETRY, (unsigned long)((uintptr_t)&geometry));
   if (ret < 0)
     {
-      syslog(LOG_ERR, "ioctl MTDIOC_GEOMETRY failed: %s\n", strerror(errno));
+      syslog(LOG_ERR, "ioctl MTDIOC_GEOMETRY failed: %s\n",
+                              strerror(errno));
       return ERROR;
     }