Initialize the bad block table when create the bct file from scratch,

data_layout.c

 /**
  * Copyright (c) 2011 NVIDIA Corporation.  All rights reserved.
  *
  * See file CREDITS for list of people who contributed to this
  * project.
  *
  * This program is free software; you can redistribute it and/or
  * modify it under the terms of the GNU General Public License as
  * published by the Free Software Foundation; either version 2 of
  * the License, or (at your option) any later version.
@@ skipping 62 matching lines @@
 set_bl_data(build_image_context *context,
                         u_int32_t instance,
                         u_int32_t start_blk,
                         u_int32_t start_page,
                         u_int32_t length);
 
 static int write_bootloaders(build_image_context *context);
 
 static void find_new_journal_blk(build_image_context *context);
 static int finish_update(build_image_context *context);
+static void init_bad_block_table(build_image_context *context);
+
 static u_int32_t
 iceil_log2(u_int32_t a, u_int32_t b)
 {
         return (a + (1 << b) - 1) >> b;
 }
 
+/* Returns the smallest power of 2 >= a */
+static u_int32_t
+ceil_log2(u_int32_t a)
+{
+        u_int32_t result;
+
+        result = log2(a);
+        if ((1UL << result) < a)
+                result++;
+
+        return result;
+}
+
+static void init_bad_block_table(build_image_context *context)
+{
+        u_int32_t bytes_per_entry;
+        nvboot_badblock_table *table;
+        nvboot_config_table *bct;
+
+        bct = (nvboot_config_table *)(context->bct);
+
+        assert(context != NULL);
+        assert(bct != NULL);
+
+        table = &(bct->badblock_table);
+
+        bytes_per_entry = ICEIL(context->partition_size,
+                                NVBOOT_BAD_BLOCK_TABLE_SIZE);
+        table->block_size_log2 = context->block_size_log2;
+        table->virtual_blk_size_log2 = NV_MAX(ceil_log2(bytes_per_entry),
+                                        table->block_size_log2);
+        table->entries_used = iceil_log2(context->partition_size,
+                                        table->virtual_blk_size_log2);
+}
+
 static block_data *new_block(u_int32_t blk_number, u_int32_t block_size)
 {
         block_data *new_block = malloc(sizeof(block_data));
         if (new_block == NULL)
                 return NULL;
 
         new_block->blk_number = blk_number;
         new_block->pages_used = 0;
         new_block->data = malloc(block_size);
         if (new_block->data == NULL) {
@@ skipping 798 matching lines @@
 
         SET_VALUE(boot_data_version, NVBOOT_BOOTDATA_VERSION(2, 1));
         GET_VALUE(bct_size,  &bct_size);
         GET_VALUE(hash_size, &hash_size);
         GET_VALUE(reserved_size, &reserved_size);
         GET_VALUE(reserved_offset, &reserved_offset);
 
         pages_per_bct = iceil_log2(bct_size, context->page_size_log2);
         pages_per_blk = (1 << (context->block_size_log2
                 - context->page_size_log2));
-
+        /* Initialize the bad block table field. */
+        init_bad_block_table(context);
         /* Fill the reserved data w/the padding pattern. */
         write_padding(context->bct + reserved_offset, reserved_size);
 
         /* Device is new */
         /* Find the new journal block starting at block 1. */
         find_new_journal_blk(context);
 
         e = erase_block(context, context->journal_blk);
         if (e != 0)
                 goto fail;
@@ skipping 103 matching lines @@
                         size_t bytes = pages_to_write * context->page_size;
 
                         if (fwrite(data, 1, bytes, context->raw_file) != bytes)
                                 return -1;
                 }
         }
 
         free(empty_blk);
         return 0;
 }