Merge pull request #253 from fitzgen/0.10.0-release

0.10.0 release

Author: fitzgen

CHANGELOG.md

@@ -28,6 +28,30 @@ Released YYYY-MM-DD.
 
 --------------------------------------------------------------------------------
 
+## 0.10.0
+
+Released 2021-03-10.
+
+### Added
+
+* Added the `cargo fuzz coverage` subcommand to generate coverage data for a
+  fuzz target. Learn more in [the Coverage chapter of the Rust Fuzzing
+  Book!](https://rust-fuzz.github.io/book/cargo-fuzz/coverage.html)
+
+--------------------------------------------------------------------------------
+
+## 0.9.2
+
+--------------------------------------------------------------------------------
+
+## 0.9.1
+
+--------------------------------------------------------------------------------
+
+## 0.9.0
+
+--------------------------------------------------------------------------------
+
 ## 0.8.0
 
 Released 2020-06-25.

Cargo.lock

@@ -1,6 +1,6 @@
 [package]
 name = "cargo-fuzz"
-version = "0.9.2"
+version = "0.10.0"
 authors = ["The rust-fuzz Project Developers"]
 license = "MIT OR Apache-2.0"
 description = "A `cargo` subcommand for using `libFuzzer`! Easy to use! No need to recompile LLVM!"

Cargo.toml

@@ -65,59 +65,6 @@ You can also always find the full command-line options that are available with
 $ cargo fuzz --help
 ```
 
-## Code coverage
-
-### Prerequisites
-Install the LLVM-coverage tools as described in the [Unstable book](https://doc.rust-lang.org/beta/unstable-book/compiler-flags/source-based-code-coverage.html#installing-llvm-coverage-tools).
-
-We recommend using at least LLVM 11 and a recent nightly version of the Rust toolchain.
-This code was tested with `1.51.0-nightly (2021-02-10)`.
-
-### Generate code-coverage data
-
-After you fuzzed your program, use the `coverage` command to generate precise
-[source-based code coverage](https://blog.rust-lang.org/inside-rust/2020/11/12/source-based-code-coverage.html)
-information:
-```
-$ cargo fuzz coverage <target> [corpus dirs] [-- <args>]
-```
-This command
-
-- compiles your project using the `-Zinstrument-coverage` Rust compiler flag,
-- runs the program _without fuzzing_ on the provided corpus (if no corpus directory is provided it uses `fuzz/corpus/<target>` by default),
-- for each input file in the corpus, generates raw coverage data in the `fuzz/coverage/<target>/raw` subdirectory,
-- merges the raw files into a `coverage.profdata` file located in the `fuzz/coverage/<target>` subdirectory.
-
-Use the generated `coverage.profdata` file to generate coverage reports and visualize code-coverage information
-as described in the [Unstable book](https://doc.rust-lang.org/beta/unstable-book/compiler-flags/source-based-code-coverage.html#creating-coverage-reports).
-
-### Example
-
-Suppose we have a `compiler` fuzz target for which we want to visualize code coverage.
-
-1. Run the fuzzer on the `compiler` target:
-
-   ```
-   $ cargo fuzz run compiler
-   ```
-
-2. Produce code-coverage information:
-
-   ```
-   $ cargo fuzz coverage compiler
-   ```
-
-2. Visualize the coverage data in HTML:
-
-   ```
-   $ cargo cov -- show target/.../compiler \
-       --format=html \
-       -instr-profile=fuzz/coverage/compiler/coverage.profdata \
-       > index.html
-   ```
-   
-   There are many visualization and coverage-report options available (see `llvm-cov show --help`).
-
 ## Trophy case
 
 [The trophy case](https://github.com/rust-fuzz/trophy-case) has a list of bugs

README.md

@@ -588,10 +588,10 @@ impl FuzzProject {
 
     /// Produce coverage information for a given corpus
     pub fn exec_coverage(self, coverage: &options::Coverage) -> Result<()> {
-        // Build project with source-based coverage generation enabled
+        // Build project with source-based coverage generation enabled.
         self.exec_build(&coverage.build, Some(&coverage.target))?;
 
-        // Retrieve corpus directories
+        // Retrieve corpus directories.
         let corpora = if coverage.corpus.is_empty() {
             vec![self.corpus_for(&coverage.target)?]
         } else {
@@ -602,7 +602,7 @@ impl FuzzProject {
                 .collect()
         };
 
-        // Collect the (non-directory) readable input files from the corpora
+        // Collect the (non-directory) readable input files from the corpora.
         let files_and_dirs = corpora.iter().flat_map(fs::read_dir).flatten().flatten();
         let mut readable_input_files = files_and_dirs
             .filter(|file| match file.file_type() {
@@ -621,16 +621,21 @@ impl FuzzProject {
 
         let (coverage_out_raw_dir, coverage_out_file) = self.coverage_for(&coverage.target)?;
 
-        // Generating individual coverage data for all files in corpora
+        // Generating individual coverage data for all files in corpora.
         for input_file in readable_input_files {
             let (mut cmd, file_name) =
                 self.create_coverage_cmd(coverage, &coverage_out_raw_dir, &input_file.path())?;
             eprintln!("Generating coverage data for {:?}", file_name);
             let status = cmd
                 .status()
-                .with_context(|| format!("failed to run command: {:?}", cmd))?;
+                .with_context(|| format!("Failed to run command: {:?}", cmd))?;
             if !status.success() {
-                bail!("failed to generate coverage data: {}", status);
+                Err(anyhow!(
+                    "Command exited with failure status {}: {:?}",
+                    status,
+                    cmd
+                ))
+                .context("Failed to generage coverage data")?;
             }
         }
 
@@ -677,10 +682,24 @@ impl FuzzProject {
             merge_cmd.arg(raw_file?.path());
         }
         merge_cmd.arg("-o").arg(profdata_out_path);
+
         eprintln!("Merging raw coverage data...");
-        merge_cmd
-            .output()
-            .with_context(|| "Merging raw coverage files failed.")?;
+        let status = merge_cmd
+            .status()
+            .with_context(|| format!("Failed to run command: {:?}", merge_cmd))
+            .with_context(|| "Merging raw coverage files failed.\n\
+                              \n\
+                              Do you have LLVM coverage tools installed?\n\
+                              https://doc.rust-lang.org/beta/unstable-book/compiler-flags/source-based-code-coverage.html#installing-llvm-coverage-tools")?;
+        if !status.success() {
+            Err(anyhow!(
+                "Command exited with failure status {}: {:?}",
+                status,
+                merge_cmd
+            ))
+            .context("Merging raw coverage files failed")?;
+        }
+
         if profdata_out_path.exists() {
             eprintln!("Coverage data merged and saved in {:?}.", profdata_out_path);
             Ok(())