diff --git a/src/cargo/core/compiler/mod.rs b/src/cargo/core/compiler/mod.rs
index ab43e99795a..1c1a1ebedd8 100644
--- a/src/cargo/core/compiler/mod.rs
+++ b/src/cargo/core/compiler/mod.rs
@@ -670,6 +670,22 @@ fn prepare_rustc(cx: &Context<'_, '_>, unit: &Unit) -> CargoResult<ProcessBuilde
     if unit.target.is_test() || unit.target.is_bench() {
         let tmp = cx.files().layout(unit.kind).prepare_tmp()?;
         base.env("CARGO_TARGET_TMPDIR", tmp.display().to_string());
+
+        if cx.bcx.config.nightly_features_allowed {
+            // Use a relative path and limit to integration tests and benchmarks in hopes
+            // that it conveys to the user that the meaning of this value is a bit fuzzy
+            // (very different meaning in the original repo vs once published).
+            let cargo_workspace_dir = if is_primary && is_workspace {
+                pathdiff::diff_paths(cx.bcx.ws.root(), unit.pkg.root())
+                    .expect("both paths are absolute")
+                    .display()
+                    .to_string()
+            } else {
+                // path from unit.pkg.root() to unit.pkg.root()
+                ".".to_string()
+            };
+            base.env("CARGO_WORKSPACE_DIR", cargo_workspace_dir);
+        }
     }
 
     base.inherit_jobserver(&cx.jobserver);
diff --git a/src/doc/src/reference/environment-variables.md b/src/doc/src/reference/environment-variables.md
index 3f05526138b..846c425a639 100644
--- a/src/doc/src/reference/environment-variables.md
+++ b/src/doc/src/reference/environment-variables.md
@@ -265,6 +265,11 @@ corresponding environment variable is set to the empty string, `""`.
   where integration tests or benchmarks are free to put any data needed by
   the tests/benches. Cargo initially creates this directory but doesn't
   manage its content in any way, this is the responsibility of the test code.
+* `CARGO_WORKSPACE_DIR` --- Only set when building [integration test] or benchmark code.
+  This is a path to the workspace directory of the package being built. When there is
+  no associated workspace, which includes all registry packages, this will be a path to
+  the directory that contains the manifest of the package.
+  Currently, it is implemented as a relative path.
 
 [Cargo target]: cargo-targets.md
 [binaries]: cargo-targets.md#binaries
diff --git a/tests/testsuite/build.rs b/tests/testsuite/build.rs
index 23840ad9a60..17aded7ae1c 100644
--- a/tests/testsuite/build.rs
+++ b/tests/testsuite/build.rs
@@ -1477,7 +1477,7 @@ fn cargo_default_env_metadata_env_var() {
 }
 
 #[cargo_test]
-fn crate_env_vars() {
+fn crate_env_vars_without_workspace() {
     let p = project()
         .file(
             "Cargo.toml",
@@ -1545,6 +1545,9 @@ fn crate_env_vars() {
 
                     // Verify CARGO_TARGET_TMPDIR isn't set for bins
                     assert!(option_env!("CARGO_TARGET_TMPDIR").is_none());
+
+                    // Verify CARGO_WORKSPACE_DIR isn't set for bins
+                    assert!(option_env!("CARGO_WORKSPACE_DIR").is_none());
                 }
             "#,
         )
@@ -1588,6 +1591,10 @@ fn crate_env_vars() {
                     // Check that CARGO_TARGET_TMPDIR isn't set for unit tests
                     assert!(option_env!("CARGO_TARGET_TMPDIR").is_none());
                     env::var("CARGO_TARGET_TMPDIR").unwrap_err();
+
+                    // Check that CARGO_WORKSPACE_DIR isn't set for unit tests
+                    assert!(option_env!("CARGO_WORKSPACE_DIR").is_none());
+                    env::var("CARGO_WORKSPACE_DIR").unwrap_err();
                 }
             "#,
         )
@@ -1605,6 +1612,9 @@ fn crate_env_vars() {
 
                     // Verify CARGO_TARGET_TMPDIR isn't set for examples
                     assert!(option_env!("CARGO_TARGET_TMPDIR").is_none());
+
+                    // Verify CARGO_WORKSPACE_DIR isn't set for examples
+                    assert!(option_env!("CARGO_WORKSPACE_DIR").is_none());
                 }
             "#,
         )
@@ -1614,6 +1624,9 @@ fn crate_env_vars() {
                 #[test]
                 fn env() {
                     foo::check_tmpdir(option_env!("CARGO_TARGET_TMPDIR"));
+
+                    // Verify CARGO_WORKSPACE_DIR isn't set for integration tests without masquerade_as_nightly_cargo()
+                    assert!(option_env!("CARGO_WORKSPACE_DIR").is_none());
                 }
             "#,
         );
@@ -1629,6 +1642,9 @@ fn crate_env_vars() {
                 #[bench]
                 fn env(_: &mut Bencher) {
                     foo::check_tmpdir(option_env!("CARGO_TARGET_TMPDIR"));
+
+                    // Verify CARGO_WORKSPACE_DIR isn't set for benches without masquerade_as_nightly_cargo()
+                    assert!(option_env!("CARGO_WORKSPACE_DIR").is_none());
                 }
             "#,
         )
@@ -1657,6 +1673,376 @@ fn crate_env_vars() {
     }
 }
 
+#[cargo_test]
+fn nightly_cargo_workspace_dir_env_var_with_workspace() {
+    Package::new("bar", "0.1.0")
+        .file("src/lib.rs", "#[test] fn bar() {}")
+        .file(
+            "tests/bar_env.rs",
+            r#"
+            use std::path::Path;
+
+            #[test]
+            fn env() {
+                assert!(Path::new(option_env!("CARGO_WORKSPACE_DIR").unwrap()).join(file!()).exists());
+                assert_eq!(std::fs::canonicalize(option_env!("CARGO_WORKSPACE_DIR").unwrap()).unwrap().display().to_string(), option_env!("CARGO_MANIFEST_DIR").unwrap());
+            }
+        "#,
+        )
+        .publish();
+
+    let p = project()
+        .file(
+            "Cargo.toml",
+            r#"
+            [workspace]
+            members = ["foo"]
+            "#,
+        )
+        .file(
+            "foo/Cargo.toml",
+            r#"
+            [package]
+            name = "foo"
+            version = "0.0.1"
+            authors = []
+
+            [dependencies]
+            bar = "0.1.0"
+
+            [dependencies.baz_member]
+            path = "../baz/baz_member"
+
+            [[bin]]
+            name = "foo-bar"
+            path = "src/main.rs"
+            "#,
+        )
+        .file(
+            "foo/src/main.rs",
+            r#"
+                fn main() {
+                    // Verify CARGO_WORKSPACE_DIR isn't set for bins
+                    assert!(option_env!("CARGO_WORKSPACE_DIR").is_none());
+                }
+            "#,
+        )
+        .file(
+            "foo/src/lib.rs",
+            r#"
+                use std::env;
+
+                #[test]
+                fn env() {
+                    // Check that CARGO_WORKSPACE_DIR isn't set for unit tests
+                    assert!(option_env!("CARGO_WORKSPACE_DIR").is_none());
+                    env::var("CARGO_WORKSPACE_DIR").unwrap_err();
+                }
+            "#,
+        )
+        .file(
+            "foo/examples/ex-env-vars.rs",
+            r#"
+                fn main() {
+                    // Verify CARGO_WORKSPACE_DIR isn't set for examples
+                    assert!(option_env!("CARGO_WORKSPACE_DIR").is_none());
+                }
+            "#,
+        )
+        .file(
+            "foo/tests/env.rs",
+            r#"
+                use std::path::Path;
+
+                #[test]
+                fn env() {
+                    assert!(Path::new(option_env!("CARGO_WORKSPACE_DIR").unwrap()).join(file!()).exists());
+                }
+            "#,
+        )
+        .file(
+            "baz/Cargo.toml",
+            r#"
+            [workspace]
+            members = ["baz_member"]
+            "#,
+        )
+        .file(
+            "baz/baz_member/Cargo.toml",
+            r#"
+            [package]
+            name = "baz_member"
+            version = "0.1.0"
+            authors = []
+            "#,
+        )
+        .file("baz/baz_member/src/lib.rs", "#[test] fn baz_member() {}")
+        .file(
+            "baz/baz_member/tests/env.rs",
+            r#"
+            use std::path::Path;
+
+            #[test]
+            fn env() {
+                // is_primary = true
+                // is_workspace = true
+                // cargo_workspace_dir = "../.."
+                // cx.bcx.ws.root() = "/Users/yerke/dev/rust/cargo/target/tmp/cit/t0/foo"
+                // unit.pkg.root() = "/Users/yerke/dev/rust/cargo/target/tmp/cit/t0/foo/baz/baz_member"
+                // option_env!("CARGO_WORKSPACE_DIR").unwrap() = "../.."
+                // file!() = "baz/baz_member/tests/env.rs"
+                // std::env::current_dir().unwrap() = "/Users/yerke/dev/rust/cargo/target/tmp/cit/t0/foo/baz/baz_member"
+                // option_env!("CARGO_MANIFEST_DIR").unwrap() = "/Users/yerke/dev/rust/cargo/target/tmp/cit/t0/foo/baz/baz_member"
+                dbg!(option_env!("CARGO_WORKSPACE_DIR").unwrap());
+                dbg!(file!());
+                dbg!(std::env::current_dir().unwrap());
+                dbg!(option_env!("CARGO_MANIFEST_DIR").unwrap());
+                assert!(Path::new(option_env!("CARGO_WORKSPACE_DIR").unwrap()).join(file!()).exists());
+                // thread 'env' panicked at 'assertion failed: `(left == right)`
+                //   left: `"/Users/yerke/dev/rust/cargo/target/tmp/cit/t0/foo"`,
+                //  right: `"/Users/yerke/dev/rust/cargo/target/tmp/cit/t0/foo/baz/baz_member"`', baz/baz_member/tests/env.rs:16:17
+                assert_eq!(std::fs::canonicalize(option_env!("CARGO_WORKSPACE_DIR").unwrap()).unwrap().display().to_string(), option_env!("CARGO_MANIFEST_DIR").unwrap());
+            }
+        "#,
+        )
+        .file(
+            "foo/baz/Cargo.toml",
+            r#"
+                [package]
+
+                name = "baz"
+                version = "0.0.0"
+                authors = []
+
+                [lib]
+                name = "baz"
+                crate_type = ["dylib", "rlib"]
+            "#,
+        )
+        .file("foo/baz/src/lib.rs", "");
+    let p = if is_nightly() {
+        p.file(
+            "foo/benches/env.rs",
+            r#"
+                #![feature(test)]
+                extern crate test;
+                use std::path::Path;
+                use test::Bencher;
+
+                #[bench]
+                fn env(_: &mut Bencher) {
+                    assert!(Path::new(option_env!("CARGO_WORKSPACE_DIR").unwrap()).join(file!()).exists());
+                }
+            "#,
+        )
+        .build()
+    } else {
+        p.build()
+    };
+
+    println!("build");
+    p.cargo("build -v").run();
+
+    println!("bin");
+    p.process(&p.bin("foo-bar")).run();
+
+    println!("example");
+    p.cargo("run --example ex-env-vars -v").run();
+
+    println!("test");
+    // fails because it's running tests in baz/baz_member/src/lib.rs
+    // p.cargo("test -v").masquerade_as_nightly_cargo(&[]).run();
+
+    println!("bench");
+    p.cargo("bench -v").masquerade_as_nightly_cargo(&[]).run();
+
+    // published crate without workspace
+    p.cargo("test -p bar")
+        .masquerade_as_nightly_cargo(&[])
+        .with_stdout_contains("running 1 test\ntest bar ... ok")
+        .run();
+
+    // path dependency crate with workspace
+    // this test fails
+    // p.cargo("test -p baz_member")
+    //     .masquerade_as_nightly_cargo(&[])
+    //     .run();
+}
+
+#[cargo_test]
+fn nightly_cargo_workspace_dir_env_var_without_workspace() {
+    Package::new("bar", "0.1.0")
+        .file("src/lib.rs", "#[test] fn bar() {}")
+        .file(
+            "tests/bar_env.rs",
+            r#"
+            use std::path::Path;
+
+            #[test]
+            fn env() {
+                assert!(Path::new(option_env!("CARGO_WORKSPACE_DIR").unwrap()).join(file!()).exists());
+                assert_eq!(std::fs::canonicalize(option_env!("CARGO_WORKSPACE_DIR").unwrap()).unwrap().display().to_string(), option_env!("CARGO_MANIFEST_DIR").unwrap());
+            }
+        "#,
+        )
+        .publish();
+
+    let p = project()
+        .file(
+            "Cargo.toml",
+            r#"
+            [package]
+            name = "foo"
+            version = "0.0.1"
+            authors = []
+
+            [dependencies]
+            bar = "0.1.0"
+
+            [dependencies.baz_member]
+            path = "baz/baz_member"
+
+            [[bin]]
+            name = "foo-bar"
+            path = "src/main.rs"
+            "#,
+        )
+        .file(
+            "src/main.rs",
+            r#"
+                extern crate foo;
+
+                fn main() {
+                    // Verify CARGO_WORKSPACE_DIR isn't set for bins
+                    assert!(option_env!("CARGO_WORKSPACE_DIR").is_none());
+                }
+            "#,
+        )
+        .file(
+            "src/lib.rs",
+            r#"
+                use std::env;
+                #[test]
+                fn env() {
+                    // Check that CARGO_WORKSPACE_DIR isn't set for unit tests
+                    assert!(option_env!("CARGO_WORKSPACE_DIR").is_none());
+                    env::var("CARGO_WORKSPACE_DIR").unwrap_err();
+                }
+            "#,
+        )
+        .file(
+            "examples/ex-env-vars.rs",
+            r#"
+                fn main() {
+                    // Verify CARGO_WORKSPACE_DIR isn't set for examples
+                    assert!(option_env!("CARGO_WORKSPACE_DIR").is_none());
+                }
+            "#,
+        )
+        .file(
+            "tests/env.rs",
+            r#"
+                use std::path::Path;
+
+                #[test]
+                fn env() {
+                    assert!(Path::new(option_env!("CARGO_WORKSPACE_DIR").unwrap()).join(file!()).exists());
+                }
+            "#,
+        )
+        // path dependency
+        .file(
+            "baz/Cargo.toml",
+            r#"
+            [workspace]
+            members = ["baz_member"]
+            "#,
+        )
+        .file(
+            "baz/baz_member/Cargo.toml",
+            r#"
+            [package]
+            name = "baz_member"
+            version = "0.1.0"
+            authors = []
+            "#,
+        )
+        .file("baz/baz_member/src/lib.rs", "#[test] fn baz_member() {}")
+        .file(
+            "baz/baz_member/tests/env.rs",
+            r#"
+            use std::path::Path;
+
+            #[test]
+            fn env() {
+                // is_primary = true
+                // is_workspace = false
+                // cargo_workspace_dir = "."
+                // cx.bcx.ws.root() = "/Users/yerke/dev/rust/cargo/target/tmp/cit/t0/foo"
+                // unit.pkg.root() = "/Users/yerke/dev/rust/cargo/target/tmp/cit/t0/foo/baz/baz_member"
+                // option_env!("CARGO_WORKSPACE_DIR").unwrap() = "."
+                // file!() = "baz/baz_member/tests/env.rs"
+                // std::env::current_dir().unwrap() = "/Users/yerke/dev/rust/cargo/target/tmp/cit/t0/foo/baz/baz_member"
+                // option_env!("CARGO_MANIFEST_DIR").unwrap() = "/Users/yerke/dev/rust/cargo/target/tmp/cit/t0/foo/baz/baz_member"
+                // thread 'env' panicked at 'assertion failed: Path::new(option_env!(\"CARGO_WORKSPACE_DIR\").unwrap()).join(file!()).exists()', baz/baz_member/tests/env.rs:15:17
+                // since it's trying to access "/Users/yerke/dev/rust/cargo/target/tmp/cit/t0/foo/baz/baz_member/baz/baz_member/tests/env.rs"
+                dbg!(option_env!("CARGO_WORKSPACE_DIR").unwrap());
+                dbg!(file!());
+                dbg!(std::env::current_dir().unwrap());
+                dbg!(option_env!("CARGO_MANIFEST_DIR").unwrap());
+                assert!(Path::new(option_env!("CARGO_WORKSPACE_DIR").unwrap()).join(file!()).exists());
+                assert_eq!(std::fs::canonicalize(option_env!("CARGO_WORKSPACE_DIR").unwrap()).unwrap().display().to_string(), option_env!("CARGO_MANIFEST_DIR").unwrap());
+            }
+        "#,
+        );
+
+    let p = if is_nightly() {
+        p.file(
+            "benches/env.rs",
+            r#"
+                #![feature(test)]
+                extern crate test;
+                use std::path::Path;
+                use test::Bencher;
+
+                #[bench]
+                fn env(_: &mut Bencher) {
+                    assert!(Path::new(option_env!("CARGO_WORKSPACE_DIR").unwrap()).join(file!()).exists());
+                }
+            "#,
+        )
+            .build()
+    } else {
+        p.build()
+    };
+
+    println!("build");
+    p.cargo("build -v").run();
+
+    println!("bin");
+    p.process(&p.bin("foo-bar")).run();
+
+    println!("example");
+    p.cargo("run --example ex-env-vars -v").run();
+
+    println!("test");
+    p.cargo("test -v").masquerade_as_nightly_cargo(&[]).run();
+
+    // published crate without workspace
+    p.cargo("test -p bar")
+        .masquerade_as_nightly_cargo(&[])
+        .with_stdout_contains("running 1 test\ntest bar ... ok")
+        .run();
+
+    println!("bench");
+    p.cargo("bench -v").masquerade_as_nightly_cargo(&[]).run();
+
+    // This test fails
+    // p.cargo("test -p baz_member")
+    //     .masquerade_as_nightly_cargo(&[])
+    //     .run();
+}
+
 #[cargo_test]
 fn crate_authors_env_vars() {
     let p = project()