VBoot Reference: 18 Exabytes ought to be enough for everybody

src/platform/vboot_reference/tests/test_common.c

 /* Copyright (c) 2010 The Chromium OS Authors. All rights reserved.
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  *
  * Common functions used by tests.
  */
 
 #include "test_common.h"
 
 #include <stdio.h>
@@ skipping 19 matching lines @@
     fprintf(stderr, "%s Test " COL_RED "FAILED\n" COL_STOP, testname);
     gTestSuccess = 0;
     return 0;
   }
 }
 
 FirmwareImage* GenerateTestFirmwareImage(int algorithm,
                                          const uint8_t* firmware_sign_key,
                                          int firmware_key_version,
                                          int firmware_version,
-                                         int firmware_len,
+                                         uint64_t firmware_len,
                                          const char* root_key_file,
                                          const char* firmware_key_file,
                                          uint8_t firmware_data_fill_char) {
   FirmwareImage* image = FirmwareImageNew();
 
   Memcpy(image->magic, FIRMWARE_MAGIC, FIRMWARE_MAGIC_SIZE);
   image->firmware_sign_algorithm = algorithm;
   image->firmware_sign_key = (uint8_t*) Malloc(
       RSAProcessedKeySize(image->firmware_sign_algorithm));
   Memcpy(image->firmware_sign_key, firmware_sign_key,
@@ skipping 26 matching lines @@
     FirmwareImageFree(image);
     return NULL;
   }
   return image;
 }
 
 uint8_t* GenerateTestFirmwareBlob(int algorithm,
                                   const uint8_t* firmware_sign_key,
                                   int firmware_key_version,
                                   int firmware_version,
-                                  int firmware_len,
+                                  uint64_t firmware_len,
                                   const char* root_key_file,
                                   const char* firmware_key_file) {
   FirmwareImage* image = NULL;
   uint8_t* firmware_blob = NULL;
   uint64_t firmware_blob_len = 0;
 
   image = GenerateTestFirmwareImage(algorithm,
                                     firmware_sign_key,
                                     firmware_key_version,
                                     firmware_version,
@@ skipping 37 matching lines @@
   FirmwareImageFree(image);
   return firmware_blob;
 }
 
 
 KernelImage* GenerateTestKernelImage(int firmware_sign_algorithm,
                                      int kernel_sign_algorithm,
                                      const uint8_t* kernel_sign_key,
                                      int kernel_key_version,
                                      int kernel_version,
-                                     int kernel_len,
+                                     uint64_t kernel_len,
                                      const char* firmware_key_file,
                                      const char* kernel_key_file,
                                      uint8_t kernel_data_fill_char) {
   KernelImage* image = KernelImageNew();
 
   Memcpy(image->magic, KERNEL_MAGIC, KERNEL_MAGIC_SIZE);
   image->header_version = 1;
   image->firmware_sign_algorithm = firmware_sign_algorithm;
   image->kernel_sign_algorithm = kernel_sign_algorithm;
   image->kernel_key_version = kernel_key_version;
@@ skipping 34 matching lines @@
   }
 
   return image;
 }
 
 uint8_t* GenerateTestKernelBlob(int firmware_sign_algorithm,
                                 int kernel_sign_algorithm,
                                 const uint8_t* kernel_sign_key,
                                 int kernel_key_version,
                                 int kernel_version,
-                                int kernel_len,
+                                uint64_t kernel_len,
                                 const char* firmware_key_file,
                                 const char* kernel_key_file) {
   KernelImage* image = NULL;
   uint8_t* kernel_blob = NULL;
   uint64_t kernel_blob_len = 0;
 
   image = GenerateTestKernelImage(firmware_sign_algorithm,
                                   kernel_sign_algorithm,
                                   kernel_sign_key,
                                   kernel_key_version,
@@ skipping 31 matching lines @@
  if (!image)
    return NULL;
  if (is_corrupt) {
    /* Invalidate image. */
    Memset(image->kernel_data, 'X', image->options.kernel_len);
  }
  kernel_blob = GetKernelBlob(image, &len);
  KernelImageFree(image);
  return kernel_blob;
 }