fs: improve error performance of fchownSync

benchmark/fs/bench-fchownSync.js

@@ -0,0 +1,67 @@
+'use strict';
+
+const common = require('../common');
+const fs = require('fs');
+const tmpdir = require('../../test/common/tmpdir');
+tmpdir.refresh();
+
+// Windows does not have `getuid` or `getgid`.
+if (process.platform === 'win32') {
+  return;
+}
+
+const bench = common.createBenchmark(main, {
+  type: ['existing', 'non-existing'],
+  n: [1e3],
+});
+
+function main({ n, type }) {
+  const uid = process.getuid();
+  const gid = process.getgid();
+  let files;
+
+  switch (type) {
+    case 'existing':
+      files = [];
+
+      // Populate tmpdir with mock files
+      for (let i = 0; i < n; i++) {
+        const path = tmpdir.resolve(`fchmodsync-bench-file-${i}`);
+        fs.writeFileSync(path, 'bench');
+        files.push(path);
+      }
+      break;
+    case 'non-existing':
+      files = new Array(n).fill(tmpdir.resolve(`.non-existing-file-${Date.now()}`));
+      break;
+    default:
+      new Error('Invalid type');
+  }
+
+  const fds = files.map((x) => {
+    // Try to open, if not return likely invalid fd (1 << 30)
+    try {
+      return fs.openSync(x, 'r');
+    } catch {
+      return 1 << 30;
+    }
+  });
+
+  bench.start();
+  for (let i = 0; i < n; i++) {
+    try {
+      fs.fchownSync(fds[i], uid, gid);
+    } catch {
+      // do nothing
+    }
+  }
+  bench.end(n);
+
+  for (const x of fds) {
+    try {
+      fs.closeSync(x);
+    } catch {
+      // do nothing
+    }
+  }
+}

lib/fs.js

@@ -2059,10 +2059,7 @@
   fd = getValidatedFd(fd);
   validateInteger(uid, 'uid', -1, kMaxUserId);
   validateInteger(gid, 'gid', -1, kMaxUserId);
-
-  const ctx = {};
-  binding.fchown(fd, uid, gid, undefined, ctx);
-  handleErrorFromBinding(ctx);
+  return syncFs.fchown(fd, uid, gid);
 }
 
 /**

src/node_file.cc

@@ -2626,6 +2626,32 @@ static void FChown(const FunctionCallbackInfo<Value>& args) {
 }
 
 
+static void FChownSync(const FunctionCallbackInfo<Value>& args) {
+  Environment* env = Environment::GetCurrent(args);
+
+  const int argc = args.Length();
+  CHECK_GE(argc, 3);
+
+  CHECK(args[0]->IsInt32());
+  const uv_file fd = static_cast<uv_file>(args[0].As<Int32>()->Value());
+
+  CHECK(args[1]->IsInt32());
+  const uv_uid_t uid = static_cast<uv_uid_t>(args[1].As<Int32>()->Value());
+
+  CHECK(args[2]->IsInt32());
+  const uv_gid_t gid = static_cast<uv_gid_t>(args[2].As<Int32>()->Value());
+
+  uv_fs_t req;
+  auto cleanup = OnScopeLeave([&req]() { uv_fs_req_cleanup(&req); });
+  FS_SYNC_TRACE_BEGIN(fchown);
+  int err = uv_fs_fchown(nullptr, &req, fd, uid, gid, nullptr);
+  FS_SYNC_TRACE_END(fchown);
+  if (err < 0) {
+    return env->ThrowUVException(err, "fchown");
+  }
+}
+
+
 static void LChown(const FunctionCallbackInfo<Value>& args) {
   Environment* env = Environment::GetCurrent(args);
 
@@ -3224,6 +3250,7 @@ static void CreatePerIsolateProperties(IsolateData* isolate_data,
   SetMethod(isolate, target, "rmdir", RMDir);
   SetMethod(isolate, target, "mkdir", MKDir);
   SetMethod(isolate, target, "readdir", ReadDir);
+  SetMethod(isolate, target, "fchownSync", FChownSync);
   SetMethod(isolate, target, "internalModuleReadJSON", InternalModuleReadJSON);
   SetMethod(isolate, target, "internalModuleStat", InternalModuleStat);
   SetMethod(isolate, target, "stat", Stat);
@@ -3364,6 +3391,7 @@ void RegisterExternalReferences(ExternalReferenceRegistry* registry) {
 
   registry->Register(Chown);
   registry->Register(FChown);
+  registry->Register(FChownSync);
   registry->Register(LChown);
 
   registry->Register(UTimes);

typings/internalBinding/fs.d.ts

@@ -65,6 +65,7 @@ declare namespace InternalFSBinding {
   function chown(path: string, uid: number, gid: number, req: FSReqCallback): void;
   function chown(path: string, uid: number, gid: number, req: undefined, ctx: FSSyncContext): void;
   function chown(path: string, uid: number, gid: number, usePromises: typeof kUsePromises): Promise<void>;
+  function fchownSync(path: number, uid: number, gid: number): void;
 
   function close(fd: number, req: FSReqCallback): void;
   function close(fd: number, req: undefined, ctx: FSSyncContext): void;
@@ -240,6 +241,7 @@ export interface FsBinding {
   copyFile: typeof InternalFSBinding.copyFile;
   fchmod: typeof InternalFSBinding.fchmod;
   fchown: typeof InternalFSBinding.fchown;
+  fchownSync: typeof InternalFSBinding.fchownSync;
   fdatasync: typeof InternalFSBinding.fdatasync;
   fstat: typeof InternalFSBinding.fstat;
   fsync: typeof InternalFSBinding.fsync;