feat(runtime): improve error messages of runtime fs (#11984)

This commit annotates errors returned from FS Deno APIs to include
paths that were passed to the API calls.

Co-authored-by: Bartek Iwańczuk <biwanczuk@gmail.com>

cli/tests/unit/chmod_test.ts

@@ -82,10 +82,14 @@ unitTest(
 );
 
 unitTest({ permissions: { write: true } }, function chmodSyncFailure() {
-  assertThrows(() => {
   const filename = "/badfile.txt";
+  assertThrows(
+    () => {
       Deno.chmodSync(filename, 0o777);
-  }, Deno.errors.NotFound);
+    },
+    Deno.errors.NotFound,
+    `chmod '${filename}'`,
+  );
 });
 
 unitTest({ permissions: { write: false } }, function chmodSyncPerm() {
@@ -170,10 +174,14 @@ unitTest(
 );
 
 unitTest({ permissions: { write: true } }, async function chmodFailure() {
-  await assertRejects(async () => {
   const filename = "/badfile.txt";
+  await assertRejects(
+    async () => {
       await Deno.chmod(filename, 0o777);
-  }, Deno.errors.NotFound);
+    },
+    Deno.errors.NotFound,
+    `chmod '${filename}'`,
+  );
 });
 
 unitTest({ permissions: { write: false } }, async function chmodPerm() {

cli/tests/unit/chown_test.ts

@@ -48,9 +48,13 @@ unitTest(
     const { uid, gid } = await getUidAndGid();
     const filePath = Deno.makeTempDirSync() + "/chown_test_file.txt";
 
-    assertThrows(() => {
+    assertThrows(
+      () => {
         Deno.chownSync(filePath, uid, gid);
-    }, Deno.errors.NotFound);
+      },
+      Deno.errors.NotFound,
+      `chown '${filePath}'`,
+    );
   },
 );
 
@@ -63,9 +67,13 @@ unitTest(
     const { uid, gid } = await getUidAndGid();
     const filePath = (await Deno.makeTempDir()) + "/chown_test_file.txt";
 
-    await assertRejects(async () => {
+    await assertRejects(
+      async () => {
         await Deno.chown(filePath, uid, gid);
-    }, Deno.errors.NotFound);
+      },
+      Deno.errors.NotFound,
+      `chown '${filePath}'`,
+    );
   },
 );
 

cli/tests/unit/copy_file_test.ts

@@ -72,9 +72,13 @@ unitTest(
     const fromFilename = tempDir + "/from.txt";
     const toFilename = tempDir + "/to.txt";
     // We skip initial writing here, from.txt does not exist
-    assertThrows(() => {
+    assertThrows(
+      () => {
         Deno.copyFileSync(fromFilename, toFilename);
-    }, Deno.errors.NotFound);
+      },
+      Deno.errors.NotFound,
+      `copy '${fromFilename}' -> '${toFilename}'`,
+    );
 
     Deno.removeSync(tempDir, { recursive: true });
   },
@@ -162,9 +166,13 @@ unitTest(
     const fromFilename = tempDir + "/from.txt";
     const toFilename = tempDir + "/to.txt";
     // We skip initial writing here, from.txt does not exist
-    await assertRejects(async () => {
+    await assertRejects(
+      async () => {
         await Deno.copyFile(fromFilename, toFilename);
-    }, Deno.errors.NotFound);
+      },
+      Deno.errors.NotFound,
+      `copy '${fromFilename}' -> '${toFilename}'`,
+    );
 
     Deno.removeSync(tempDir, { recursive: true });
   },

cli/tests/unit/dir_test.ts

@@ -52,8 +52,12 @@ unitTest(
   { permissions: { read: true, write: true } },
   function dirChdirError() {
     const path = Deno.makeTempDirSync() + "test";
-    assertThrows(() => {
+    assertThrows(
+      () => {
         Deno.chdir(path);
-    }, Deno.errors.NotFound);
+      },
+      Deno.errors.NotFound,
+      `chdir '${path}'`,
+    );
   },
 );

cli/tests/unit/files_test.ts

@@ -2,7 +2,13 @@
 
 // deno-lint-ignore-file no-deprecated-deno-api
 
-import { assert, assertEquals, assertRejects, unitTest } from "./test_util.ts";
+import {
+  assert,
+  assertEquals,
+  assertRejects,
+  assertThrows,
+  unitTest,
+} from "./test_util.ts";
 import { copy } from "../../../test_util/std/io/util.ts";
 
 unitTest(function filesStdioFileDescriptors() {
@@ -361,6 +367,32 @@ unitTest(
   },
 );
 
+unitTest(
+  { permissions: { write: true, read: true } },
+  async function openNotFound() {
+    await assertRejects(
+      async () => {
+        await Deno.open("bad_file_name");
+      },
+      Deno.errors.NotFound,
+      `open 'bad_file_name'`,
+    );
+  },
+);
+
+unitTest(
+  { permissions: { write: true, read: true } },
+  function openSyncNotFound() {
+    assertThrows(
+      () => {
+        Deno.openSync("bad_file_name");
+      },
+      Deno.errors.NotFound,
+      `open 'bad_file_name'`,
+    );
+  },
+);
+
 unitTest(
   { permissions: { read: true, write: true } },
   async function createFile() {

cli/tests/unit/link_test.ts

@@ -1,5 +1,11 @@
 // Copyright 2018-2021 the Deno authors. All rights reserved. MIT license.
-import { assert, assertEquals, assertThrows, unitTest } from "./test_util.ts";
+import {
+  assert,
+  assertEquals,
+  assertRejects,
+  assertThrows,
+  unitTest,
+} from "./test_util.ts";
 
 unitTest(
   { permissions: { read: true, write: true } },
@@ -50,9 +56,13 @@ unitTest(
     // newname is already created.
     Deno.writeFileSync(newName, new TextEncoder().encode("newName"));
 
-    assertThrows(() => {
+    assertThrows(
+      () => {
         Deno.linkSync(oldName, newName);
-    }, Deno.errors.AlreadyExists);
+      },
+      Deno.errors.AlreadyExists,
+      `link '${oldName}' -> '${newName}'`,
+    );
   },
 );
 
@@ -63,9 +73,13 @@ unitTest(
     const oldName = testDir + "/oldname";
     const newName = testDir + "/newname";
 
-    assertThrows(() => {
+    assertThrows(
+      () => {
         Deno.linkSync(oldName, newName);
-    }, Deno.errors.NotFound);
+      },
+      Deno.errors.NotFound,
+      `link '${oldName}' -> '${newName}'`,
+    );
   },
 );
 
@@ -125,3 +139,58 @@ unitTest(
     );
   },
 );
+
+unitTest(
+  { permissions: { read: true, write: true } },
+  async function linkExists() {
+    const testDir = Deno.makeTempDirSync();
+    const oldName = testDir + "/oldname";
+    const newName = testDir + "/newname";
+    Deno.writeFileSync(oldName, new TextEncoder().encode("oldName"));
+    // newname is already created.
+    Deno.writeFileSync(newName, new TextEncoder().encode("newName"));
+
+    await assertRejects(
+      async () => {
+        await Deno.link(oldName, newName);
+      },
+      Deno.errors.AlreadyExists,
+      `link '${oldName}' -> '${newName}'`,
+    );
+  },
+);
+
+unitTest(
+  { permissions: { read: true, write: true } },
+  async function linkNotFound() {
+    const testDir = Deno.makeTempDirSync();
+    const oldName = testDir + "/oldname";
+    const newName = testDir + "/newname";
+
+    await assertRejects(
+      async () => {
+        await Deno.link(oldName, newName);
+      },
+      Deno.errors.NotFound,
+      `link '${oldName}' -> '${newName}'`,
+    );
+  },
+);
+
+unitTest(
+  { permissions: { read: false, write: true } },
+  async function linkReadPerm() {
+    await assertRejects(async () => {
+      await Deno.link("oldbaddir", "newbaddir");
+    }, Deno.errors.PermissionDenied);
+  },
+);
+
+unitTest(
+  { permissions: { read: true, write: false } },
+  async function linkWritePerm() {
+    await assertRejects(async () => {
+      await Deno.link("oldbaddir", "newbaddir");
+    }, Deno.errors.PermissionDenied);
+  },
+);

cli/tests/unit/mkdir_test.ts

@@ -59,15 +59,23 @@ unitTest(
 );
 
 unitTest({ permissions: { write: true } }, function mkdirErrSyncIfExists() {
-  assertThrows(() => {
+  assertThrows(
+    () => {
       Deno.mkdirSync(".");
-  }, Deno.errors.AlreadyExists);
+    },
+    Deno.errors.AlreadyExists,
+    `mkdir '.'`,
+  );
 });
 
 unitTest({ permissions: { write: true } }, async function mkdirErrIfExists() {
-  await assertRejects(async () => {
+  await assertRejects(
+    async () => {
       await Deno.mkdir(".");
-  }, Deno.errors.AlreadyExists);
+    },
+    Deno.errors.AlreadyExists,
+    `mkdir '.'`,
+  );
 });
 
 unitTest(

cli/tests/unit/read_dir_test.ts

@@ -40,15 +40,23 @@ unitTest({ permissions: { read: false } }, function readDirSyncPerm() {
 });
 
 unitTest({ permissions: { read: true } }, function readDirSyncNotDir() {
-  assertThrows(() => {
+  assertThrows(
+    () => {
       Deno.readDirSync("cli/tests/testdata/fixture.json");
-  }, Error);
+    },
+    Error,
+    `readdir 'cli/tests/testdata/fixture.json'`,
+  );
 });
 
 unitTest({ permissions: { read: true } }, function readDirSyncNotFound() {
-  assertThrows(() => {
+  assertThrows(
+    () => {
       Deno.readDirSync("bad_dir_name");
-  }, Deno.errors.NotFound);
+    },
+    Deno.errors.NotFound,
+    `readdir 'bad_dir_name'`,
+  );
 });
 
 unitTest({ permissions: { read: true } }, async function readDirSuccess() {
@@ -94,3 +102,13 @@ unitTest(
     }
   },
 );
+
+unitTest({ permissions: { read: true } }, async function readDirNotFound() {
+  await assertRejects(
+    async () => {
+      await Deno.readDir("bad_dir_name")[Symbol.asyncIterator]().next();
+    },
+    Deno.errors.NotFound,
+    `readdir 'bad_dir_name'`,
+  );
+});

cli/tests/unit/read_link_test.ts

@@ -44,9 +44,13 @@ unitTest({ permissions: { read: false } }, function readLinkSyncPerm() {
 });
 
 unitTest({ permissions: { read: true } }, function readLinkSyncNotFound() {
-  assertThrows(() => {
+  assertThrows(
+    () => {
       Deno.readLinkSync("bad_filename");
-  }, Deno.errors.NotFound);
+    },
+    Deno.errors.NotFound,
+    `readlink 'bad_filename'`,
+  );
 });
 
 unitTest(
@@ -84,3 +88,13 @@ unitTest({ permissions: { read: false } }, async function readLinkPerm() {
     await Deno.readLink("/symlink");
   }, Deno.errors.PermissionDenied);
 });
+
+unitTest({ permissions: { read: true } }, async function readLinkNotFound() {
+  await assertRejects(
+    async () => {
+      await Deno.readLink("bad_filename");
+    },
+    Deno.errors.NotFound,
+    `readlink 'bad_filename'`,
+  );
+});

cli/tests/unit/remove_test.ts

@@ -80,15 +80,23 @@ unitTest(
       const subPathInfo = Deno.statSync(subPath);
       assert(subPathInfo.isDirectory); // check exist first
 
-      await assertRejects(async () => {
+      await assertRejects(
+        async () => {
           await Deno[method](path);
-      }, Error);
+        },
+        Error,
+        `remove '${path}'`,
+      );
       // TODO(ry) Is Other really the error we should get here? What would Go do?
 
       // NON-EXISTENT DIRECTORY/FILE
-      await assertRejects(async () => {
+      await assertRejects(
+        async () => {
           await Deno[method]("/baddir");
-      }, Deno.errors.NotFound);
+        },
+        Deno.errors.NotFound,
+        `remove '/baddir'`,
+      );
     }
   },
 );
@@ -210,10 +218,14 @@ unitTest(
 unitTest({ permissions: { write: true } }, async function removeAllFail() {
   for (const method of REMOVE_METHODS) {
     // NON-EXISTENT DIRECTORY/FILE
-    await assertRejects(async () => {
+    await assertRejects(
+      async () => {
         // Non-existent
         await Deno[method]("/baddir", { recursive: true });
-    }, Deno.errors.NotFound);
+      },
+      Deno.errors.NotFound,
+      `remove '/baddir'`,
+    );
   }
 });
 

cli/tests/unit/rename_test.ts

@@ -164,6 +164,13 @@ unitTest(
       Error,
       "Not a directory",
     );
+    assertThrows(
+      () => {
+        Deno.renameSync(olddir, file);
+      },
+      undefined,
+      `rename '${olddir}' -> '${file}'`,
+    );
 
     const fileLink = testDir + "/fileLink";
     const dirLink = testDir + "/dirLink";
@@ -242,6 +249,13 @@ unitTest(
       Deno.errors.PermissionDenied,
       "Access is denied",
     );
+    assertThrows(
+      () => {
+        Deno.renameSync(olddir, emptydir);
+      },
+      undefined,
+      `rename '${olddir}' -> '${emptydir}'`,
+    );
 
     // should succeed on Windows
     Deno.renameSync(olddir, file);

cli/tests/unit/stat_test.ts

@@ -108,9 +108,13 @@ unitTest({ permissions: { read: false } }, function statSyncPerm() {
 });
 
 unitTest({ permissions: { read: true } }, function statSyncNotFound() {
-  assertThrows(() => {
+  assertThrows(
+    () => {
       Deno.statSync("bad_file_name");
-  }, Deno.errors.NotFound);
+    },
+    Deno.errors.NotFound,
+    `stat 'bad_file_name'`,
+  );
 });
 
 unitTest({ permissions: { read: true } }, function lstatSyncSuccess() {
@@ -148,9 +152,13 @@ unitTest({ permissions: { read: false } }, function lstatSyncPerm() {
 });
 
 unitTest({ permissions: { read: true } }, function lstatSyncNotFound() {
-  assertThrows(() => {
+  assertThrows(
+    () => {
       Deno.lstatSync("bad_file_name");
-  }, Deno.errors.NotFound);
+    },
+    Deno.errors.NotFound,
+    `stat 'bad_file_name'`,
+  );
 });
 
 unitTest(
@@ -228,8 +236,10 @@ unitTest({ permissions: { read: false } }, async function statPerm() {
 unitTest({ permissions: { read: true } }, async function statNotFound() {
   await assertRejects(
     async () => {
-      await Deno.stat("bad_file_name"), Deno.errors.NotFound;
+      await Deno.stat("bad_file_name");
     },
+    Deno.errors.NotFound,
+    `stat 'bad_file_name'`,
   );
 });
 
@@ -268,9 +278,13 @@ unitTest({ permissions: { read: false } }, async function lstatPerm() {
 });
 
 unitTest({ permissions: { read: true } }, async function lstatNotFound() {
-  await assertRejects(async () => {
+  await assertRejects(
+    async () => {
       await Deno.lstat("bad_file_name");
-  }, Deno.errors.NotFound);
+    },
+    Deno.errors.NotFound,
+    `stat 'bad_file_name'`,
+  );
 });
 
 unitTest(

cli/tests/unit/symlink_test.ts

@@ -1,6 +1,7 @@
 // Copyright 2018-2021 the Deno authors. All rights reserved. MIT license.
 import {
   assert,
+  assertRejects,
   assertThrows,
   pathToAbsoluteFileUrl,
   unitTest,
@@ -45,6 +46,21 @@ unitTest(function symlinkSyncPerm() {
   }, Deno.errors.PermissionDenied);
 });
 
+unitTest(
+  { permissions: { read: true, write: true } },
+  function symlinkSyncAlreadyExist() {
+    const existingFile = Deno.makeTempFileSync();
+    const existingFile2 = Deno.makeTempFileSync();
+    assertThrows(
+      () => {
+        Deno.symlinkSync(existingFile, existingFile2);
+      },
+      Deno.errors.AlreadyExists,
+      `symlink '${existingFile}' -> '${existingFile2}'`,
+    );
+  },
+);
+
 unitTest(
   { permissions: { read: true, write: true } },
   async function symlinkSuccess() {
@@ -77,3 +93,18 @@ unitTest(
     assert(newNameInfoStat.isDirectory, "NOT DIRECTORY");
   },
 );
+
+unitTest(
+  { permissions: { read: true, write: true } },
+  async function symlinkAlreadyExist() {
+    const existingFile = Deno.makeTempFileSync();
+    const existingFile2 = Deno.makeTempFileSync();
+    await assertRejects(
+      async () => {
+        await Deno.symlink(existingFile, existingFile2);
+      },
+      Deno.errors.AlreadyExists,
+      `symlink '${existingFile}' -> '${existingFile2}'`,
+    );
+  },
+);

cli/tests/unit/truncate_test.ts

@@ -91,3 +91,31 @@ unitTest({ permissions: { write: false } }, async function truncatePerm() {
     await Deno.truncate("/test_truncatePermission.txt");
   }, Deno.errors.PermissionDenied);
 });
+
+unitTest(
+  { permissions: { read: true, write: true } },
+  function truncateSyncNotFound() {
+    const filename = "/badfile.txt";
+    assertThrows(
+      () => {
+        Deno.truncateSync(filename);
+      },
+      Deno.errors.NotFound,
+      `truncate '${filename}'`,
+    );
+  },
+);
+
+unitTest(
+  { permissions: { read: true, write: true } },
+  async function truncateSyncNotFound() {
+    const filename = "/badfile.txt";
+    await assertRejects(
+      async () => {
+        await Deno.truncate(filename);
+      },
+      Deno.errors.NotFound,
+      `truncate '${filename}'`,
+    );
+  },
+);

cli/tests/unit/utime_test.ts

@@ -160,9 +160,13 @@ unitTest(
     const atime = 1000;
     const mtime = 50000;
 
-    assertThrows(() => {
+    assertThrows(
+      () => {
         Deno.utimeSync("/baddir", atime, mtime);
-    }, Deno.errors.NotFound);
+      },
+      Deno.errors.NotFound,
+      "utime '/baddir'",
+    );
   },
 );
 
@@ -271,9 +275,13 @@ unitTest(
     const atime = 1000;
     const mtime = 50000;
 
-    await assertRejects(async () => {
+    await assertRejects(
+      async () => {
         await Deno.utime("/baddir", atime, mtime);
-    }, Deno.errors.NotFound);
+      },
+      Deno.errors.NotFound,
+      "utime '/baddir'",
+    );
   },
 );
 

runtime/errors.rs

@@ -137,7 +137,7 @@ fn get_hyper_error_class(_error: &hyper::Error) -> &'static str {
 }
 
 #[cfg(unix)]
-fn get_nix_error_class(error: &nix::Error) -> &'static str {
+pub fn get_nix_error_class(error: &nix::Error) -> &'static str {
   match error {
     nix::Error::ECHILD => "NotFound",
     nix::Error::EINVAL => "TypeError",

runtime/ops/fs.rs

@@ -23,7 +23,7 @@ use std::cell::RefCell;
 use std::convert::From;
 use std::env::{current_dir, set_current_dir, temp_dir};
 use std::io;
-use std::io::{Seek, SeekFrom};
+use std::io::{Error, Seek, SeekFrom};
 use std::path::{Path, PathBuf};
 use std::rc::Rc;
 use std::time::SystemTime;
@@ -163,7 +163,9 @@ fn op_open_sync(
   _: (),
 ) -> Result<ResourceId, AnyError> {
   let (path, open_options) = open_helper(state, args)?;
-  let std_file = open_options.open(path)?;
+  let std_file = open_options.open(&path).map_err(|err| {
+    Error::new(err.kind(), format!("{}, open '{}'", err, path.display()))
+  })?;
   let tokio_file = tokio::fs::File::from_std(std_file);
   let resource = StdFileResource::fs_file(tokio_file);
   let rid = state.resource_table.add(resource);
@@ -177,8 +179,11 @@ async fn op_open_async(
 ) -> Result<ResourceId, AnyError> {
   let (path, open_options) = open_helper(&mut state.borrow_mut(), args)?;
   let tokio_file = tokio::fs::OpenOptions::from(open_options)
-    .open(path)
+    .open(&path)
-    .await?;
+    .await
+    .map_err(|err| {
+      Error::new(err.kind(), format!("{}, open '{}'", err, path.display()))
+    })?;
   let resource = StdFileResource::fs_file(tokio_file);
   let rid = state.borrow_mut().resource_table.add(resource);
   Ok(rid)
@@ -503,7 +508,9 @@ fn op_chdir(
 ) -> Result<(), AnyError> {
   let d = PathBuf::from(&directory);
   state.borrow_mut::<Permissions>().read.check(&d)?;
-  set_current_dir(&d)?;
+  set_current_dir(&d).map_err(|err| {
+    Error::new(err.kind(), format!("{}, chdir '{}'", err, directory))
+  })?;
   Ok(())
 }
 
@@ -531,7 +538,9 @@ fn op_mkdir_sync(
     use std::os::unix::fs::DirBuilderExt;
     builder.mode(mode);
   }
-  builder.create(path)?;
+  builder.create(&path).map_err(|err| {
+    Error::new(err.kind(), format!("{}, mkdir '{}'", err, path.display()))
+  })?;
   Ok(())
 }
 
@@ -557,7 +566,9 @@ async fn op_mkdir_async(
       use std::os::unix::fs::DirBuilderExt;
       builder.mode(mode);
     }
-    builder.create(path)?;
+    builder.create(&path).map_err(|err| {
+      Error::new(err.kind(), format!("{}, mkdir '{}'", err, path.display()))
+    })?;
     Ok(())
   })
   .await
@@ -578,6 +589,9 @@ fn op_chmod_sync(
 ) -> Result<(), AnyError> {
   let path = Path::new(&args.path).to_path_buf();
   let mode = args.mode & 0o777;
+  let err_mapper = |err: Error| {
+    Error::new(err.kind(), format!("{}, chmod '{}'", err, path.display()))
+  };
 
   state.borrow_mut::<Permissions>().write.check(&path)?;
   debug!("op_chmod_sync {} {:o}", path.display(), mode);
@@ -585,14 +599,14 @@ fn op_chmod_sync(
   {
     use std::os::unix::fs::PermissionsExt;
     let permissions = PermissionsExt::from_mode(mode);
-    std::fs::set_permissions(&path, permissions)?;
+    std::fs::set_permissions(&path, permissions).map_err(err_mapper)?;
     Ok(())
   }
   // TODO Implement chmod for Windows (#4357)
   #[cfg(not(unix))]
   {
     // Still check file/dir exists on Windows
-    let _metadata = std::fs::metadata(&path)?;
+    let _metadata = std::fs::metadata(&path).map_err(err_mapper)?;
     Err(generic_error("Not implemented"))
   }
 }
@@ -612,18 +626,21 @@ async fn op_chmod_async(
 
   tokio::task::spawn_blocking(move || {
     debug!("op_chmod_async {} {:o}", path.display(), mode);
+    let err_mapper = |err: Error| {
+      Error::new(err.kind(), format!("{}, chmod '{}'", err, path.display()))
+    };
     #[cfg(unix)]
     {
       use std::os::unix::fs::PermissionsExt;
       let permissions = PermissionsExt::from_mode(mode);
-      std::fs::set_permissions(&path, permissions)?;
+      std::fs::set_permissions(&path, permissions).map_err(err_mapper)?;
       Ok(())
     }
     // TODO Implement chmod for Windows (#4357)
     #[cfg(not(unix))]
     {
       // Still check file/dir exists on Windows
-      let _metadata = std::fs::metadata(&path)?;
+      let _metadata = std::fs::metadata(&path).map_err(err_mapper)?;
       Err(not_supported())
     }
   })
@@ -654,10 +671,16 @@ fn op_chown_sync(
   );
   #[cfg(unix)]
   {
+    use crate::errors::get_nix_error_class;
     use nix::unistd::{chown, Gid, Uid};
     let nix_uid = args.uid.map(Uid::from_raw);
     let nix_gid = args.gid.map(Gid::from_raw);
-    chown(&path, nix_uid, nix_gid)?;
+    chown(&path, nix_uid, nix_gid).map_err(|err| {
+      custom_error(
+        get_nix_error_class(&err),
+        format!("{}, chown '{}'", err.desc(), path.display()),
+      )
+    })?;
     Ok(())
   }
   // TODO Implement chown for Windows
@@ -688,10 +711,16 @@ async fn op_chown_async(
     );
     #[cfg(unix)]
     {
+      use crate::errors::get_nix_error_class;
       use nix::unistd::{chown, Gid, Uid};
       let nix_uid = args.uid.map(Uid::from_raw);
       let nix_gid = args.gid.map(Gid::from_raw);
-      chown(&path, nix_uid, nix_gid)?;
+      chown(&path, nix_uid, nix_gid).map_err(|err| {
+        custom_error(
+          get_nix_error_class(&err),
+          format!("{}, chown '{}'", err.desc(), path.display()),
+        )
+      })?;
       Ok(())
     }
     // TODO Implement chown for Windows
@@ -722,31 +751,34 @@ fn op_remove_sync(
   #[cfg(not(unix))]
   use std::os::windows::prelude::MetadataExt;
 
-  let metadata = std::fs::symlink_metadata(&path)?;
+  let err_mapper = |err: Error| {
+    Error::new(err.kind(), format!("{}, remove '{}'", err, path.display()))
+  };
+  let metadata = std::fs::symlink_metadata(&path).map_err(err_mapper)?;
 
   debug!("op_remove_sync {} {}", path.display(), recursive);
   let file_type = metadata.file_type();
   if file_type.is_file() {
-    std::fs::remove_file(&path)?;
+    std::fs::remove_file(&path).map_err(err_mapper)?;
   } else if recursive {
-    std::fs::remove_dir_all(&path)?;
+    std::fs::remove_dir_all(&path).map_err(err_mapper)?;
   } else if file_type.is_symlink() {
     #[cfg(unix)]
-    std::fs::remove_file(&path)?;
+    std::fs::remove_file(&path).map_err(err_mapper)?;
     #[cfg(not(unix))]
     {
       use winapi::um::winnt::FILE_ATTRIBUTE_DIRECTORY;
       if metadata.file_attributes() & FILE_ATTRIBUTE_DIRECTORY != 0 {
-        std::fs::remove_dir(&path)?;
+        std::fs::remove_dir(&path).map_err(err_mapper)?;
       } else {
-        std::fs::remove_file(&path)?;
+        std::fs::remove_file(&path).map_err(err_mapper)?;
       }
     }
   } else if file_type.is_dir() {
-    std::fs::remove_dir(&path)?;
+    std::fs::remove_dir(&path).map_err(err_mapper)?;
   } else {
     // pipes, sockets, etc...
-    std::fs::remove_file(&path)?;
+    std::fs::remove_file(&path).map_err(err_mapper)?;
   }
   Ok(())
 }
@@ -767,32 +799,34 @@ async fn op_remove_async(
   tokio::task::spawn_blocking(move || {
     #[cfg(not(unix))]
     use std::os::windows::prelude::MetadataExt;
-
+    let err_mapper = |err: Error| {
-    let metadata = std::fs::symlink_metadata(&path)?;
+      Error::new(err.kind(), format!("{}, remove '{}'", err, path.display()))
+    };
+    let metadata = std::fs::symlink_metadata(&path).map_err(err_mapper)?;
 
     debug!("op_remove_async {} {}", path.display(), recursive);
     let file_type = metadata.file_type();
     if file_type.is_file() {
-      std::fs::remove_file(&path)?;
+      std::fs::remove_file(&path).map_err(err_mapper)?;
     } else if recursive {
-      std::fs::remove_dir_all(&path)?;
+      std::fs::remove_dir_all(&path).map_err(err_mapper)?;
     } else if file_type.is_symlink() {
       #[cfg(unix)]
-      std::fs::remove_file(&path)?;
+      std::fs::remove_file(&path).map_err(err_mapper)?;
       #[cfg(not(unix))]
       {
         use winapi::um::winnt::FILE_ATTRIBUTE_DIRECTORY;
         if metadata.file_attributes() & FILE_ATTRIBUTE_DIRECTORY != 0 {
-          std::fs::remove_dir(&path)?;
+          std::fs::remove_dir(&path).map_err(err_mapper)?;
         } else {
-          std::fs::remove_file(&path)?;
+          std::fs::remove_file(&path).map_err(err_mapper)?;
         }
       }
     } else if file_type.is_dir() {
-      std::fs::remove_dir(&path)?;
+      std::fs::remove_dir(&path).map_err(err_mapper)?;
     } else {
       // pipes, sockets, etc...
-      std::fs::remove_file(&path)?;
+      std::fs::remove_file(&path).map_err(err_mapper)?;
     }
     Ok(())
   })
@@ -824,11 +858,24 @@ fn op_copy_file_sync(
   // See https://github.com/rust-lang/rust/issues/54800
   // Once the issue is resolved, we should remove this workaround.
   if cfg!(unix) && !from.is_file() {
-    return Err(custom_error("NotFound", "File not found"));
+    return Err(custom_error(
+      "NotFound",
+      format!(
+        "File not found, copy '{}' -> '{}'",
+        from.display(),
+        to.display()
+      ),
+    ));
   }
 
+  let err_mapper = |err: Error| {
+    Error::new(
+      err.kind(),
+      format!("{}, copy '{}' -> '{}'", err, from.display(), to.display()),
+    )
+  };
   // returns size of from as u64 (we ignore)
-  std::fs::copy(&from, &to)?;
+  std::fs::copy(&from, &to).map_err(err_mapper)?;
   Ok(())
 }
 
@@ -853,11 +900,24 @@ async fn op_copy_file_async(
     // See https://github.com/rust-lang/rust/issues/54800
     // Once the issue is resolved, we should remove this workaround.
     if cfg!(unix) && !from.is_file() {
-      return Err(custom_error("NotFound", "File not found"));
+      return Err(custom_error(
+        "NotFound",
+        format!(
+          "File not found, copy '{}' -> '{}'",
+          from.display(),
+          to.display()
+        ),
+      ));
     }
 
+    let err_mapper = |err: Error| {
+      Error::new(
+        err.kind(),
+        format!("{}, copy '{}' -> '{}'", err, from.display(), to.display()),
+      )
+    };
     // returns size of from as u64 (we ignore)
-    std::fs::copy(&from, &to)?;
+    std::fs::copy(&from, &to).map_err(err_mapper)?;
     Ok(())
   })
   .await
@@ -956,10 +1016,13 @@ fn op_stat_sync(
   let lstat = args.lstat;
   state.borrow_mut::<Permissions>().read.check(&path)?;
   debug!("op_stat_sync {} {}", path.display(), lstat);
+  let err_mapper = |err: Error| {
+    Error::new(err.kind(), format!("{}, stat '{}'", err, path.display()))
+  };
   let metadata = if lstat {
-    std::fs::symlink_metadata(&path)?
+    std::fs::symlink_metadata(&path).map_err(err_mapper)?
   } else {
-    std::fs::metadata(&path)?
+    std::fs::metadata(&path).map_err(err_mapper)?
   };
   Ok(get_stat(metadata))
 }
@@ -979,10 +1042,13 @@ async fn op_stat_async(
 
   tokio::task::spawn_blocking(move || {
     debug!("op_stat_async {} {}", path.display(), lstat);
+    let err_mapper = |err: Error| {
+      Error::new(err.kind(), format!("{}, stat '{}'", err, path.display()))
+    };
     let metadata = if lstat {
-      std::fs::symlink_metadata(&path)?
+      std::fs::symlink_metadata(&path).map_err(err_mapper)?
     } else {
-      std::fs::metadata(&path)?
+      std::fs::metadata(&path).map_err(err_mapper)?
     };
     Ok(get_stat(metadata))
   })
@@ -1058,7 +1124,11 @@ fn op_read_dir_sync(
   state.borrow_mut::<Permissions>().read.check(&path)?;
 
   debug!("op_read_dir_sync {}", path.display());
-  let entries: Vec<_> = std::fs::read_dir(path)?
+  let err_mapper = |err: Error| {
+    Error::new(err.kind(), format!("{}, readdir '{}'", err, path.display()))
+  };
+  let entries: Vec<_> = std::fs::read_dir(&path)
+    .map_err(err_mapper)?
     .filter_map(|entry| {
       let entry = entry.unwrap();
       // Not all filenames can be encoded as UTF-8. Skip those for now.
@@ -1096,7 +1166,11 @@ async fn op_read_dir_async(
   }
   tokio::task::spawn_blocking(move || {
     debug!("op_read_dir_async {}", path.display());
-    let entries: Vec<_> = std::fs::read_dir(path)?
+    let err_mapper = |err: Error| {
+      Error::new(err.kind(), format!("{}, readdir '{}'", err, path.display()))
+    };
+    let entries: Vec<_> = std::fs::read_dir(&path)
+      .map_err(err_mapper)?
       .filter_map(|entry| {
         let entry = entry.unwrap();
         // Not all filenames can be encoded as UTF-8. Skip those for now.
@@ -1145,7 +1219,18 @@ fn op_rename_sync(
   permissions.write.check(&oldpath)?;
   permissions.write.check(&newpath)?;
   debug!("op_rename_sync {} {}", oldpath.display(), newpath.display());
-  std::fs::rename(&oldpath, &newpath)?;
+  let err_mapper = |err: Error| {
+    Error::new(
+      err.kind(),
+      format!(
+        "{}, rename '{}' -> '{}'",
+        err,
+        oldpath.display(),
+        newpath.display()
+      ),
+    )
+  };
+  std::fs::rename(&oldpath, &newpath).map_err(err_mapper)?;
   Ok(())
 }
 
@@ -1169,7 +1254,18 @@ async fn op_rename_async(
       oldpath.display(),
       newpath.display()
     );
-    std::fs::rename(&oldpath, &newpath)?;
+    let err_mapper = |err: Error| {
+      Error::new(
+        err.kind(),
+        format!(
+          "{}, rename '{}' -> '{}'",
+          err,
+          oldpath.display(),
+          newpath.display()
+        ),
+      )
+    };
+    std::fs::rename(&oldpath, &newpath).map_err(err_mapper)?;
     Ok(())
   })
   .await
@@ -1198,7 +1294,18 @@ fn op_link_sync(
   permissions.write.check(&newpath)?;
 
   debug!("op_link_sync {} {}", oldpath.display(), newpath.display());
-  std::fs::hard_link(&oldpath, &newpath)?;
+  let err_mapper = |err: Error| {
+    Error::new(
+      err.kind(),
+      format!(
+        "{}, link '{}' -> '{}'",
+        err,
+        oldpath.display(),
+        newpath.display()
+      ),
+    )
+  };
+  std::fs::hard_link(&oldpath, &newpath).map_err(err_mapper)?;
   Ok(())
 }
 
@@ -1221,7 +1328,18 @@ async fn op_link_async(
 
   tokio::task::spawn_blocking(move || {
     debug!("op_link_async {} {}", oldpath.display(), newpath.display());
-    std::fs::hard_link(&oldpath, &newpath)?;
+    let err_mapper = |err: Error| {
+      Error::new(
+        err.kind(),
+        format!(
+          "{}, link '{}' -> '{}'",
+          err,
+          oldpath.display(),
+          newpath.display()
+        ),
+      )
+    };
+    std::fs::hard_link(&oldpath, &newpath).map_err(err_mapper)?;
     Ok(())
   })
   .await
@@ -1259,10 +1377,21 @@ fn op_symlink_sync(
     oldpath.display(),
     newpath.display()
   );
+  let err_mapper = |err: Error| {
+    Error::new(
+      err.kind(),
+      format!(
+        "{}, symlink '{}' -> '{}'",
+        err,
+        oldpath.display(),
+        newpath.display()
+      ),
+    )
+  };
   #[cfg(unix)]
   {
     use std::os::unix::fs::symlink;
-    symlink(&oldpath, &newpath)?;
+    symlink(&oldpath, &newpath).map_err(err_mapper)?;
     Ok(())
   }
   #[cfg(not(unix))]
@@ -1271,8 +1400,8 @@ fn op_symlink_sync(
 
     match args.options {
       Some(options) => match options._type.as_ref() {
-        "file" => symlink_file(&oldpath, &newpath)?,
+        "file" => symlink_file(&oldpath, &newpath).map_err(err_mapper)?,
-        "dir" => symlink_dir(&oldpath, &newpath)?,
+        "dir" => symlink_dir(&oldpath, &newpath).map_err(err_mapper)?,
         _ => return Err(type_error("unsupported type")),
       },
       None => {
@@ -1280,9 +1409,9 @@ fn op_symlink_sync(
         match old_meta {
           Ok(metadata) => {
             if metadata.is_file() {
-              symlink_file(&oldpath, &newpath)?
+              symlink_file(&oldpath, &newpath).map_err(err_mapper)?
             } else if metadata.is_dir() {
-              symlink_dir(&oldpath, &newpath)?
+              symlink_dir(&oldpath, &newpath).map_err(err_mapper)?
             }
           }
           Err(_) => return Err(type_error("you must pass a `options` argument for non-existent target path in windows".to_string())),
@@ -1308,10 +1437,21 @@ async fn op_symlink_async(
 
   tokio::task::spawn_blocking(move || {
     debug!("op_symlink_async {} {}", oldpath.display(), newpath.display());
+    let err_mapper = |err: Error| {
+      Error::new(
+        err.kind(),
+        format!(
+          "{}, symlink '{}' -> '{}'",
+          err,
+          oldpath.display(),
+          newpath.display()
+        ),
+      )
+    };
     #[cfg(unix)]
     {
       use std::os::unix::fs::symlink;
-      symlink(&oldpath, &newpath)?;
+      symlink(&oldpath, &newpath).map_err(err_mapper)?;
       Ok(())
     }
     #[cfg(not(unix))]
@@ -1320,8 +1460,8 @@ async fn op_symlink_async(
 
       match args.options {
         Some(options) => match options._type.as_ref() {
-          "file" => symlink_file(&oldpath, &newpath)?,
+          "file" => symlink_file(&oldpath, &newpath).map_err(err_mapper)?,
-          "dir" => symlink_dir(&oldpath, &newpath)?,
+          "dir" => symlink_dir(&oldpath, &newpath).map_err(err_mapper)?,
           _ => return Err(type_error("unsupported type")),
         },
         None => {
@@ -1329,9 +1469,9 @@ async fn op_symlink_async(
           match old_meta {
             Ok(metadata) => {
               if metadata.is_file() {
-                symlink_file(&oldpath, &newpath)?
+                symlink_file(&oldpath, &newpath).map_err(err_mapper)?
               } else if metadata.is_dir() {
-                symlink_dir(&oldpath, &newpath)?
+                symlink_dir(&oldpath, &newpath).map_err(err_mapper)?
               }
             }
             Err(_) => return Err(type_error("you must pass a `options` argument for non-existent target path in windows".to_string())),
@@ -1355,7 +1495,15 @@ fn op_read_link_sync(
   state.borrow_mut::<Permissions>().read.check(&path)?;
 
   debug!("op_read_link_value {}", path.display());
-  let target = std::fs::read_link(&path)?.into_os_string();
+  let err_mapper = |err: Error| {
+    Error::new(
+      err.kind(),
+      format!("{}, readlink '{}'", err, path.display()),
+    )
+  };
+  let target = std::fs::read_link(&path)
+    .map_err(err_mapper)?
+    .into_os_string();
   let targetstr = into_string(target)?;
   Ok(targetstr)
 }
@@ -1372,7 +1520,15 @@ async fn op_read_link_async(
   }
   tokio::task::spawn_blocking(move || {
     debug!("op_read_link_async {}", path.display());
-    let target = std::fs::read_link(&path)?.into_os_string();
+    let err_mapper = |err: Error| {
+      Error::new(
+        err.kind(),
+        format!("{}, readlink '{}'", err, path.display()),
+      )
+    };
+    let target = std::fs::read_link(&path)
+      .map_err(err_mapper)?
+      .into_os_string();
     let targetstr = into_string(target)?;
     Ok(targetstr)
   })
@@ -1444,8 +1600,17 @@ fn op_truncate_sync(
   state.borrow_mut::<Permissions>().write.check(&path)?;
 
   debug!("op_truncate_sync {} {}", path.display(), len);
-  let f = std::fs::OpenOptions::new().write(true).open(&path)?;
+  let err_mapper = |err: Error| {
-  f.set_len(len)?;
+    Error::new(
+      err.kind(),
+      format!("{}, truncate '{}'", err, path.display()),
+    )
+  };
+  let f = std::fs::OpenOptions::new()
+    .write(true)
+    .open(&path)
+    .map_err(err_mapper)?;
+  f.set_len(len).map_err(err_mapper)?;
   Ok(())
 }
 
@@ -1462,8 +1627,17 @@ async fn op_truncate_async(
   }
   tokio::task::spawn_blocking(move || {
     debug!("op_truncate_async {} {}", path.display(), len);
-    let f = std::fs::OpenOptions::new().write(true).open(&path)?;
+    let err_mapper = |err: Error| {
-    f.set_len(len)?;
+      Error::new(
+        err.kind(),
+        format!("{}, truncate '{}'", err, path.display()),
+      )
+    };
+    let f = std::fs::OpenOptions::new()
+      .write(true)
+      .open(&path)
+      .map_err(err_mapper)?;
+    f.set_len(len).map_err(err_mapper)?;
     Ok(())
   })
   .await
@@ -1740,7 +1914,9 @@ fn op_utime_sync(
   let mtime = filetime::FileTime::from_unix_time(args.mtime.0, args.mtime.1);
 
   state.borrow_mut::<Permissions>().write.check(&path)?;
-  filetime::set_file_times(path, atime, mtime)?;
+  filetime::set_file_times(&path, atime, mtime).map_err(|err| {
+    Error::new(err.kind(), format!("{}, utime '{}'", err, path.display()))
+  })?;
   Ok(())
 }
 
@@ -1762,7 +1938,9 @@ async fn op_utime_async(
     .check(&path)?;
 
   tokio::task::spawn_blocking(move || {
-    filetime::set_file_times(path, atime, mtime)?;
+    filetime::set_file_times(&path, atime, mtime).map_err(|err| {
+      Error::new(err.kind(), format!("{}, utime '{}'", err, path.display()))
+    })?;
     Ok(())
   })
   .await