Split crash metadata into description and signature.

Signature will be used for deduplication while the description is human-readable for reporting.

For runner, the signature will be the same as the description, which is compatible with the current behavior.

PiperOrigin-RevId: 758781852

Author: xinhaoyuan

centipede/centipede.cc

@@ -206,8 +206,9 @@ void Centipede::CorpusFromFiles(const Environment &env, std::string_view dir) {
 absl::Status Centipede::CrashesToFiles(const Environment &env,
                                        std::string_view dir) {
   std::vector<std::string> reproducer_dirs;
+  const auto wd = WorkDir{env};
   auto reproducer_match_status = RemoteGlobMatch(
-      WorkDir{env}.CrashReproducerDirPaths().AllShardsGlob(), reproducer_dirs);
+      wd.CrashReproducerDirPaths().AllShardsGlob(), reproducer_dirs);
   if (!reproducer_match_status.ok() &&
       !absl::IsNotFound(reproducer_match_status)) {
     return reproducer_match_status;
@@ -225,27 +226,18 @@ absl::Status Centipede::CrashesToFiles(const Environment &env,
       RETURN_IF_NOT_OK(RemoteFileCopy(
           reproducer_path,
           (std::filesystem::path{dir} / absl::StrCat(id, ".data")).string()));
-    }
-  }
-  std::vector<std::string> metadata_dirs;
-  auto metadata_match_status = RemoteGlobMatch(
-      WorkDir{env}.CrashMetadataDirPaths().AllShardsGlob(), metadata_dirs);
-  if (!metadata_match_status.ok() && !absl::IsNotFound(metadata_match_status)) {
-    return metadata_match_status;
-  }
-  for (const auto &metadata_dir : metadata_dirs) {
-    ASSIGN_OR_RETURN_IF_NOT_OK(
-        std::vector<std::string> metadata_paths,
-        RemoteListFiles(metadata_dir, /*recursively=*/false));
-    for (const auto &metadata_path : metadata_paths) {
-      std::string id = std::filesystem::path{metadata_path}.filename();
-      if (crash_ids.erase(id) == 0) {
-        continue;
-      }
+      const auto shard_index = wd.CrashReproducerDirPaths().GetShardIndex(
+          std::filesystem::path{reproducer_path}.parent_path().string());
+      CHECK(shard_index.has_value());
+      const auto metadata_dir = wd.CrashMetadataDirPaths().Shard(*shard_index);
+      const auto description_filename = absl::StrCat(id, ".desc");
+      const auto signature_filename = absl::StrCat(id, ".sig");
+      RETURN_IF_NOT_OK(RemoteFileCopy(
+          (std::filesystem::path{metadata_dir} / description_filename).string(),
+          (std::filesystem::path{dir} / description_filename).string()));
       RETURN_IF_NOT_OK(RemoteFileCopy(
-          metadata_path,
-          (std::filesystem::path{dir} / absl::StrCat(id, ".metadata"))
-              .string()));
+          (std::filesystem::path{metadata_dir} / signature_filename).string(),
+          (std::filesystem::path{dir} / signature_filename).string()));
     }
   }
   return absl::OkStatus();
@@ -886,6 +878,9 @@ void Centipede::ReportCrash(std::string_view binary,
               << "\nExit code            : " << batch_result.exit_code()
               << "\nFailure              : "
               << batch_result.failure_description()
+              << "\nSignature            : "
+              << AsPrintableString(AsByteSpan(batch_result.failure_signature()),
+                                   /*max_len=*/32)
               << "\nNumber of inputs     : " << input_vec.size()
               << "\nNumber of inputs read: " << batch_result.num_outputs_read()
               << (batch_result.IsSetupFailure()
@@ -900,6 +895,12 @@ void Centipede::ReportCrash(std::string_view binary,
     LOG(INFO).NoPrefix() << "\n";
   };
 
+  if (batch_result.IsIgnoredFailure()) {
+    LOG(INFO) << "Skip further processing of "
+              << batch_result.failure_description();
+    return;
+  }
+
   if (batch_result.IsSkippedTest()) {
     log_execution_failure("Skipped Test: ");
     LOG(INFO) << "Requesting early stop due to skipped test.";
@@ -968,21 +969,28 @@ void Centipede::ReportCrash(std::string_view binary,
       std::string input_file_path = std::filesystem::path(crash_dir) / hash;
       auto crash_metadata_dir = wd_.CrashMetadataDirPaths().MyShard();
       CHECK_OK(RemoteMkdir(crash_metadata_dir));
-      std::string crash_metadata_file_path =
+      std::string crash_metadata_path_prefix =
           std::filesystem::path(crash_metadata_dir) / hash;
       LOG(INFO) << log_prefix << "Detected crash-reproducing input:"
                 << "\nInput index    : " << input_idx << "\nInput bytes    : "
                 << AsPrintableString(one_input, /*max_len=*/32)
                 << "\nExit code      : " << one_input_batch_result.exit_code()
                 << "\nFailure        : "
                 << one_input_batch_result.failure_description()
+                << "\nSignature      : "
+                << AsPrintableString(
+                       AsByteSpan(one_input_batch_result.failure_signature()),
+                       /*max_len=*/32)
                 << "\nSaving input to: " << input_file_path
                 << "\nSaving crash"  //
-                << "\nmetadata to    : " << crash_metadata_file_path;
+                << "\nmetadata to    : " << crash_metadata_path_prefix << ".*";
       CHECK_OK(RemoteFileSetContents(input_file_path, one_input));
-      CHECK_OK(
-          RemoteFileSetContents(crash_metadata_file_path,
-                                one_input_batch_result.failure_description()));
+      CHECK_OK(RemoteFileSetContents(
+          absl::StrCat(crash_metadata_path_prefix, ".desc"),
+          one_input_batch_result.failure_description()));
+      CHECK_OK(RemoteFileSetContents(
+          absl::StrCat(crash_metadata_path_prefix, ".sig"),
+          one_input_batch_result.failure_signature()));
       return;
     }
   }

centipede/centipede_callbacks.cc

@@ -157,7 +157,7 @@ Command &CentipedeCallbacks::GetOrCreateCommandForBinary(
       absl::StrCat(":shmem:arg1=", inputs_blobseq_.path(),
                    ":arg2=", outputs_blobseq_.path(),
                    ":failure_description_path=", failure_description_path_,
-                   ":"),
+                   ":failure_signature_path=", failure_signature_path_, ":"),
       disable_coverage)};
 
   if (env_.clang_coverage_binary == binary)
@@ -243,9 +243,18 @@ int CentipedeCallbacks::ExecuteCentipedeSancovBinaryWithShmem(
     ReadFromLocalFile(execute_log_path_, batch_result.log());
     ReadFromLocalFile(failure_description_path_,
                       batch_result.failure_description());
-    // Remove failure_description_ here so that it doesn't stay until another
-    // failed execution.
+    if (std::filesystem::exists(failure_signature_path_)) {
+      ReadFromLocalFile(failure_signature_path_,
+                        batch_result.failure_signature());
+    } else {
+      // TODO(xinhaoyuan): Refactor runner to use dispatcher so this branch can
+      // be removed.
+      batch_result.failure_signature() = batch_result.failure_description();
+    }
+    // Remove the failure description and signature files here so that they do
+    // not stay until another failed execution.
     std::filesystem::remove(failure_description_path_);
+    std::filesystem::remove(failure_signature_path_);
   }
   VLOG(1) << __FUNCTION__ << " took " << (absl::Now() - start_time);
   return retval;

centipede/centipede_callbacks.h

@@ -174,6 +174,8 @@ class CentipedeCallbacks {
       std::filesystem::path(temp_dir_).append("log");
   std::string failure_description_path_ =
       std::filesystem::path(temp_dir_).append("failure_description");
+  std::string failure_signature_path_ =
+      std::filesystem::path(temp_dir_).append("failure_signature");
   const std::string shmem_name1_ = ProcessAndThreadUniqueID("/ctpd-shm1-");
   const std::string shmem_name2_ = ProcessAndThreadUniqueID("/ctpd-shm2-");
 

centipede/centipede_flags.inc

@@ -293,11 +293,10 @@ CENTIPEDE_FLAG(
 CENTIPEDE_FLAG(
     std::string, crashes_to_files, "",
     "When set to a directory path, save the crashing reproducers and "
-    "metadata from the workdir to the given path. Each crash with `ID`"
-    "will be saved with file `ID.data` for the reproducer and "
-    "`ID.metadata` the metadata, which currently contains the failure "
-    "description. If multiple crashes with the same ID exist, only one "
-    "crash will be saved.")
+    "metadata from the workdir to the given path: Each crash with `ID`"
+    "will be saved with file `ID.data` for the reproducer, `ID.desc` the "
+    "description, `ID.sig` the signature. If multiple crashes with the same ID "
+    "exist, only one crash will be saved.")
 CENTIPEDE_FLAG(
     std::string, corpus_from_files, "",
     "Export a corpus from a local directory with one file per input into "

centipede/centipede_interface.cc

@@ -288,9 +288,9 @@ TestShard SetUpTestSharding() {
   return test_shard;
 }
 
-// Prunes non-reproducible and duplicate crashes and returns the crash metadata
-// of the remaining crashes.
-absl::flat_hash_set<std::string> PruneOldCrashesAndGetRemainingCrashMetadata(
+// Prunes non-reproducible and duplicate crashes and returns the crash
+// signatures of the remaining crashes.
+absl::flat_hash_set<std::string> PruneOldCrashesAndGetRemainingCrashSignatures(
     const std::filesystem::path &crashing_dir, const Environment &env,
     CentipedeCallbacksFactory &callbacks_factory) {
   const std::vector<std::string> crashing_input_files =
@@ -299,7 +299,7 @@ absl::flat_hash_set<std::string> PruneOldCrashesAndGetRemainingCrashMetadata(
       ValueOrDie(RemoteListFiles(crashing_dir.c_str(), /*recursively=*/false));
   ScopedCentipedeCallbacks scoped_callbacks(callbacks_factory, env);
   BatchResult batch_result;
-  absl::flat_hash_set<std::string> remaining_crash_metadata;
+  absl::flat_hash_set<std::string> remaining_crash_signatures;
 
   for (const std::string &crashing_input_file : crashing_input_files) {
     ByteArray crashing_input;
@@ -308,21 +308,22 @@ absl::flat_hash_set<std::string> PruneOldCrashesAndGetRemainingCrashMetadata(
         env.binary, {crashing_input}, batch_result);
     const bool is_duplicate =
         is_reproducible && !batch_result.IsSetupFailure() &&
-        !remaining_crash_metadata.insert(batch_result.failure_description())
+        !batch_result.failure_signature().empty() &&
+        !remaining_crash_signatures.insert(batch_result.failure_signature())
              .second;
     if (!is_reproducible || batch_result.IsSetupFailure() || is_duplicate) {
       CHECK_OK(RemotePathDelete(crashing_input_file, /*recursively=*/false));
     } else {
       CHECK_OK(RemotePathTouchExistingFile(crashing_input_file));
     }
   }
-  return remaining_crash_metadata;
+  return remaining_crash_signatures;
 }
 
 // TODO(b/405382531): Add unit tests once the function is unit-testable.
 void DeduplicateAndStoreNewCrashes(
     const std::filesystem::path &crashing_dir, const WorkDir &workdir,
-    size_t total_shards, absl::flat_hash_set<std::string> crash_metadata) {
+    size_t total_shards, absl::flat_hash_set<std::string> crash_signatures) {
   for (size_t shard_idx = 0; shard_idx < total_shards; ++shard_idx) {
     const std::vector<std::string> new_crashing_input_files =
         // The crash reproducer directory may contain subdirectories with
@@ -338,19 +339,21 @@ void DeduplicateAndStoreNewCrashes(
     for (const std::string &crashing_input_file : new_crashing_input_files) {
       const std::string crashing_input_file_name =
           std::filesystem::path(crashing_input_file).filename();
-      const std::string crash_metadata_file =
+      const std::string crash_metadata_path_prefix =
           crash_metadata_dir / crashing_input_file_name;
-      std::string new_crash_metadata;
-      const absl::Status status =
-          RemoteFileGetContents(crash_metadata_file, new_crash_metadata);
+      std::string new_crash_signature;
+      const absl::Status status = RemoteFileGetContents(
+          absl::StrCat(crash_metadata_path_prefix, ".sig"),
+          new_crash_signature);
       if (!status.ok()) {
         LOG(WARNING) << "Ignoring crashing input " << crashing_input_file_name
-                     << " due to failure to read the crash metadata file: "
+                     << " due to failure to read the crash signature: "
                      << status;
         continue;
       }
       const bool is_duplicate =
-          !crash_metadata.insert(new_crash_metadata).second;
+          !new_crash_signature.empty() &&
+          !crash_signatures.insert(new_crash_signature).second;
       if (is_duplicate) continue;
       CHECK_OK(
           RemoteFileRename(crashing_input_file,
@@ -662,11 +665,11 @@ int UpdateCorpusDatabaseForFuzzTests(
 
     // Deduplicate and update the crashing inputs.
     const std::filesystem::path crashing_dir = fuzztest_db_path / "crashing";
-    absl::flat_hash_set<std::string> crash_metadata =
-        PruneOldCrashesAndGetRemainingCrashMetadata(crashing_dir, env,
-                                                    callbacks_factory);
+    absl::flat_hash_set<std::string> crash_signatures =
+        PruneOldCrashesAndGetRemainingCrashSignatures(crashing_dir, env,
+                                                      callbacks_factory);
     DeduplicateAndStoreNewCrashes(crashing_dir, workdir, env.total_shards,
-                                  std::move(crash_metadata));
+                                  std::move(crash_signatures));
   }
 
   return EXIT_SUCCESS;

centipede/centipede_test.cc

@@ -685,6 +685,7 @@ struct Crash {
   std::string binary;
   unsigned char input = 0;
   std::string description;
+  std::string signature;
 };
 
 // A mock for ExtraBinaries test.
@@ -703,6 +704,7 @@ class ExtraBinariesMock : public CentipedeCallbacks {
       for (const Crash &crash : crashes_) {
         if (binary == crash.binary && input[0] == crash.input) {
           batch_result.failure_description() = crash.description;
+          batch_result.failure_signature() = crash.signature;
           res = false;
         }
       }
@@ -766,9 +768,9 @@ TEST(Centipede, ExtraBinaries) {
   env.binary = "b1";
   env.extra_binaries = {"b2", "b3", "b4"};
   env.require_pc_table = false;  // No PC table here.
-  ExtraBinariesMock mock(
-      env, {Crash{"b1", 10, "b1-crash"}, Crash{"b2", 30, "b2-crash"},
-            Crash{"b3", 50, "b3-crash"}});
+  ExtraBinariesMock mock(env, {Crash{"b1", 10, "b1-crash", "b1-sig"},
+                               Crash{"b2", 30, "b2-crash", "b2-sig"},
+                               Crash{"b3", 50, "b3-crash", "b3-sig"}});
   MockFactory factory(mock);
   CentipedeMain(env, factory);
 
@@ -789,11 +791,15 @@ TEST(Centipede, ExtraBinaries) {
   auto crash_metadata_dir_path = WorkDir{env}.CrashMetadataDirPaths().MyShard();
   ASSERT_TRUE(std::filesystem::exists(crash_metadata_dir_path))
       << VV(crash_metadata_dir_path);
-  EXPECT_THAT(crash_metadata_dir_path,
-              HasFilesWithContents(testing::UnorderedElementsAre(
-                  FileAndContents{Hash({10}), "b1-crash"},
-                  FileAndContents{Hash({30}), "b2-crash"},
-                  FileAndContents{Hash({50}), "b3-crash"})));
+  EXPECT_THAT(
+      crash_metadata_dir_path,
+      HasFilesWithContents(testing::UnorderedElementsAre(
+          FileAndContents{absl::StrCat(Hash({10}), ".desc"), "b1-crash"},
+          FileAndContents{absl::StrCat(Hash({10}), ".sig"), "b1-sig"},
+          FileAndContents{absl::StrCat(Hash({30}), ".desc"), "b2-crash"},
+          FileAndContents{absl::StrCat(Hash({30}), ".sig"), "b2-sig"},
+          FileAndContents{absl::StrCat(Hash({50}), ".desc"), "b3-crash"},
+          FileAndContents{absl::StrCat(Hash({50}), ".sig"), "b3-sig"})));
 }
 
 // A mock for UndetectedCrashingInput test.
@@ -1118,6 +1124,47 @@ TEST(Centipede, ReturnsSuccessOnSkippedTest) {
   EXPECT_EQ(mock.execute_count(), 1);
 }
 
+class IgnoredFailureCallbacks : public CentipedeCallbacks {
+ public:
+  using CentipedeCallbacks::CentipedeCallbacks;
+
+  bool Execute(std::string_view binary, const std::vector<ByteArray> &inputs,
+               BatchResult &batch_result) override {
+    ++execute_count_;
+    batch_result.ClearAndResize(inputs.size());
+    batch_result.exit_code() = EXIT_FAILURE;
+    batch_result.failure_description() =
+        "IGNORED FAILURE: failure ignored on purpose";
+    return false;
+  }
+
+  std::vector<ByteArray> Mutate(const std::vector<MutationInputRef> &inputs,
+                                size_t num_mutants) override {
+    return {num_mutants, {0}};
+  }
+
+  int execute_count() const { return execute_count_; }
+
+ private:
+  int execute_count_ = 0;
+};
+
+TEST(Centipede, KeepsRunningAndReturnsSuccessWithIgnoredFailures) {
+  TempDir temp_dir{test_info_->name()};
+  Environment env;
+  env.log_level = 0;  // Disable most of the logging in the test.
+  env.workdir = temp_dir.path();
+  env.batch_size = 7;  // Just some small number.
+  env.num_runs = 11;
+  env.require_pc_table = false;  // No PC table here.
+  IgnoredFailureCallbacks mock(env);
+  MockFactory factory(mock);
+  EXPECT_EQ(CentipedeMain(env, factory), EXIT_SUCCESS);
+  EXPECT_EQ(mock.execute_count(),
+            // 1 batch on seeds, 2 batches for 11 runs.
+            3);
+}
+
 TEST_F(CentipedeWithTemporaryLocalDir, UsesProvidedCustomMutator) {
   Environment env;
   env.binary = GetDataDependencyFilepath(

centipede/runner_result.cc

@@ -124,6 +124,14 @@ bool BatchResult::Read(BlobSequence &blobseq) {
   return true;
 }
 
+bool BatchResult::IsIgnoredFailure() const {
+  constexpr std::string_view kIgnoredFailurePrefix = "IGNORED FAILURE:";
+  return exit_code_ != EXIT_SUCCESS &&
+         std::string_view(failure_description_)
+                 .substr(0, kIgnoredFailurePrefix.size()) ==
+             kIgnoredFailurePrefix;
+}
+
 bool BatchResult::IsSetupFailure() const {
   constexpr std::string_view kSetupFailurePrefix = "SETUP FAILURE:";
   return exit_code_ != EXIT_SUCCESS &&