VBoot Reference: Output debug information using debug() instead of fprintf().

src/platform/vboot_reference/tests/kernel_verify_benchmark.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.
  *
  * Timing benchmark for verifying a firmware image.
  */
 
 #include <stdio.h>
 #include <stdlib.h>
 
@@ skipping 55 matching lines @@
   firmware_key_size = siglen_map[firmware_sign_algorithm] * 8;  /* in bits. */
   kernel_key_size = siglen_map[kernel_sign_algorithm] * 8;  /* in bits. */
   snprintf(firmware_sign_key_file, FILE_NAME_SIZE, "testkeys/key_rsa%d.pem",
            firmware_key_size);
   snprintf(kernel_sign_key_file, FILE_NAME_SIZE, "testkeys/key_rsa%d.pem",
            kernel_key_size);
   snprintf(file_name, FILE_NAME_SIZE, "testkeys/key_rsa%d.keyb",
            kernel_key_size);
   kernel_sign_key = BufferFromFile(file_name, &len);
   if (!kernel_sign_key) {
-    fprintf(stderr, "Couldn't read pre-processed public kernel signing key.\n");
+    debug("Couldn't read pre-processed public kernel signing key.\n");
     error_code = 1;
     goto cleanup;
   }
 
   /* Generate test images. */
   for (i = 0; i < NUM_SIZES_TO_TEST; ++i) {
     kernel_blobs[i] = GenerateTestKernelBlob(firmware_sign_algorithm,
                                              kernel_sign_algorithm,
                                              kernel_sign_key,
                                              1,  /* kernel key version. */
                                              1,  /* kernel version. */
                                              g_kernel_sizes_to_test[i],
                                              firmware_sign_key_file,
                                              kernel_sign_key_file);
     if (!kernel_blobs[i]) {
-      fprintf(stderr, "Couldn't generate test firmware images.\n");
+      debug("Couldn't generate test firmware images.\n");
       error_code = 1;
       goto cleanup;
     }
   }
 
   /* Get pre-processed key used for verification. */
   snprintf(file_name, FILE_NAME_SIZE, "testkeys/key_rsa%d.keyb",
            firmware_key_size);
   firmware_key_blob = BufferFromFile(file_name, &len);
   if (!firmware_key_blob) {
-    fprintf(stderr, "Couldn't read pre-processed firmware public key.\n");
+    debug("Couldn't read pre-processed firmware public key.\n");
     error_code = 1;
     goto cleanup;
   }
 
   /* Now run the timing tests. */
   for (i = 0; i < NUM_SIZES_TO_TEST; ++i) {
     StartTimer(&ct);
     for (j = 0; j < NUM_OPERATIONS; ++j) {
       if (VERIFY_KERNEL_SUCCESS !=
           VerifyKernel(firmware_key_blob, kernel_blobs[i], 0))
-        fprintf(stderr, "Warning: Kernel Verification Failed.\n");
+        debug("Warning: Kernel Verification Failed.\n");
     }
     StopTimer(&ct);
     msecs = (float) GetDurationMsecs(&ct) / NUM_OPERATIONS;
     fprintf(stderr,
             "# Kernel (%s, Algo = %s / %s):"
             "\t%.02f ms/verification\n",
             g_kernel_size_labels[i],
             algo_strings[firmware_sign_algorithm],
             algo_strings[kernel_sign_algorithm],
             msecs);
@@ skipping 24 matching lines @@
       if (siglen_map[j] > siglen_map[i])
         continue;
       if (siglen_map[j] == siglen_map[i] && hash_size_map[j] > hash_size_map[i])
         continue;
       if (0 != (error_code = SpeedTestAlgorithm(i, j)))
         return error_code;
     }
   }
   return 0;
 }