fs: add fast api to copyFileSync

nodejs · Sep 10, 2023 · 6ff6a52 · 6ff6a52
1 parent 8a748c4
commit 6ff6a52
Show file tree

Hide file tree

Showing 7 changed files with 111 additions and 10 deletions.
diff --git a/benchmark/fs/bench-copyFileSync.js b/benchmark/fs/bench-copyFileSync.js
@@ -0,0 +1,23 @@
+'use strict';
+
+const common = require('../common');
+const fs = require('fs');
+const tmpdir = require('../../test/common/tmpdir');
+
+
+const bench = common.createBenchmark(main, {
+  n: [1e4],
+});
+
+function main({ n }) {
+  tmpdir.refresh();
+  bench.start();
+  for (let i = 0; i < n; i++) {
+    try {
+      fs.copyFileSync(__filename, tmpdir.resolve(`copy-file-bench-${process.pid}`));
+    } catch {
+      // do nothing
+    }
+  }
+  bench.end(n);
+}
diff --git a/lib/fs.js b/lib/fs.js
@@ -2977,16 +2977,7 @@ function copyFile(src, dest, mode, callback) {
  * @returns {void}
  */
 function copyFileSync(src, dest, mode) {
-  src = getValidatedPath(src, 'src');
-  dest = getValidatedPath(dest, 'dest');
-
-  const ctx = { path: src, dest };  // non-prefixed
-
-  src = pathModule._makeLong(src);
-  dest = pathModule._makeLong(dest);
-  mode = getValidMode(mode, 'copyFile');
-  binding.copyFile(src, dest, mode, undefined, ctx);
-  handleErrorFromBinding(ctx);
+  syncFs.copyFile(src, dest, mode);
 }
 
 /**

diff --git a/lib/internal/fs/sync.js b/lib/internal/fs/sync.js
@@ -43,8 +43,24 @@ function access(path, mode) {
   }
 }
 
+function copyFile(src, dest, mode) {
+  src = getValidatedPath(src, 'src');
+  dest = getValidatedPath(dest, 'dest');
+
+  const errno = syncBinding.copyFile(
+    pathModule.toNamespacedPath(src),
+    pathModule.toNamespacedPath(dest),
+    getValidMode(mode, 'copyFile'),
+  );
+
+  if (errno < 0) {
+    handleErrorFromBinding({ errno, syscall: 'copyfile', path: src, dest });
+  }
+}
+
 module.exports = {
   readFileUtf8,
   exists,
   access,
+  copyFile,
 };
diff --git a/src/node_external_reference.h b/src/node_external_reference.h
@@ -25,6 +25,11 @@ using CFunctionCallbackWithStrings =
     bool (*)(v8::Local<v8::Value>,
              const v8::FastOneByteString& input,
              const v8::FastOneByteString& base);
+using CFunctionCallbackWithStringsReturningInt =
+    int32_t (*)(v8::Local<v8::Value>,
+                const v8::FastOneByteString& input,
+                const v8::FastOneByteString& base,
+                int32_t flags);
 using CFunctionWithUint32 = uint32_t (*)(v8::Local<v8::Value>,
                                          const uint32_t input);
 
@@ -42,6 +47,7 @@ class ExternalReferenceRegistry {
   V(CFunctionCallbackWithBool)                                                 \
   V(CFunctionCallbackWithString)                                               \
   V(CFunctionCallbackWithStrings)                                              \
+  V(CFunctionCallbackWithStringsReturningInt)                                  \
   V(CFunctionWithUint32)                                                       \
   V(const v8::CFunctionInfo*)                                                  \
   V(v8::FunctionCallback)                                                      \

diff --git a/src/node_file_sync.cc b/src/node_file_sync.cc
@@ -122,6 +122,54 @@ void BindingData::Deserialize(v8::Local<v8::Context> context,
   CHECK_NOT_NULL(binding);
 }
 
+inline int32_t BindingData::CopyFileInternal(const std::string_view src,
+                                             const std::string_view dest,
+                                             int flags) {
+  uv_fs_t req;
+  auto make = OnScopeLeave([&req]() { uv_fs_req_cleanup(&req); });
+  FS_SYNC_TRACE_BEGIN(copyfile);
+  uv_fs_copyfile(nullptr, &req, src.data(), dest.data(), flags, nullptr);
+  FS_SYNC_TRACE_END(copyfile);
+
+  return int32_t(req.result);
+}
+
+void BindingData::CopyFile(const FunctionCallbackInfo<Value>& args) {
+  Environment* env = Environment::GetCurrent(args);
+  Isolate* isolate = env->isolate();
+
+  const int argc = args.Length();
+  CHECK_GE(argc, 3);
+
+  BufferValue src(isolate, args[0]);
+  CHECK_NOT_NULL(*src);
+  THROW_IF_INSUFFICIENT_PERMISSIONS(
+      env, permission::PermissionScope::kFileSystemRead, src.ToStringView());
+
+  BufferValue dest(isolate, args[1]);
+  CHECK_NOT_NULL(*dest);
+  THROW_IF_INSUFFICIENT_PERMISSIONS(
+      env, permission::PermissionScope::kFileSystemWrite, dest.ToStringView());
+
+  CHECK(args[2]->IsInt32());
+  const int flags = args[2].As<Int32>()->Value();
+
+  return args.GetReturnValue().Set(
+      CopyFileInternal(src.ToStringView(), dest.ToStringView(), flags));
+}
+
+int32_t BindingData::FastCopyFile(Local<Value> receiver,
+                                  const FastOneByteString& src,
+                                  const FastOneByteString& dest,
+                                  int32_t flags) {
+  // TODO(@anonrig): Add "THROW_IF_INSUFFICIENT_PERMISSIONS"
+  return CopyFileInternal(std::string_view(src.data, src.length),
+                          std::string_view(dest.data, dest.length),
+                          flags);
+}
+
+CFunction BindingData::fast_copy_file_(CFunction::Make(FastCopyFile));
+
 void BindingData::Access(const FunctionCallbackInfo<Value>& args) {
   Environment* env = Environment::GetCurrent(args);
   Isolate* isolate = env->isolate();
@@ -264,6 +312,8 @@ void BindingData::CreatePerIsolateProperties(IsolateData* isolate_data,
                                              Local<ObjectTemplate> target) {
   Isolate* isolate = isolate_data->isolate();
   SetMethodNoSideEffect(isolate, target, "access", Access);
+  SetFastMethodNoSideEffect(
+      isolate, target, "copyFile", CopyFile, &fast_copy_file_);
   SetFastMethodNoSideEffect(isolate, target, "exists", Exists, &fast_exists_);
   SetMethodNoSideEffect(isolate, target, "readFileUtf8", ReadFileUtf8);
 }
@@ -279,6 +329,9 @@ void BindingData::CreatePerContextProperties(Local<Object> target,
 void BindingData::RegisterExternalReferences(
     ExternalReferenceRegistry* registry) {
   registry->Register(Access);
+  registry->Register(CopyFile);
+  registry->Register(FastCopyFile);
+  registry->Register(fast_copy_file_.GetTypeInfo());
   registry->Register(Exists);
   registry->Register(FastExists);
   registry->Register(fast_exists_.GetTypeInfo());

diff --git a/src/node_file_sync.h b/src/node_file_sync.h
@@ -31,6 +31,12 @@ class BindingData : public SnapshotableObject {
   SET_SELF_SIZE(BindingData)
   SET_MEMORY_INFO_NAME(BindingData)
 
+  static void CopyFile(const v8::FunctionCallbackInfo<v8::Value>& args);
+  static int32_t FastCopyFile(v8::Local<v8::Value> receiver,
+                              const v8::FastOneByteString& src,
+                              const v8::FastOneByteString& dest,
+                              int32_t flags);
+
   static void Exists(const v8::FunctionCallbackInfo<v8::Value>& args);
   static bool FastExists(v8::Local<v8::Value> receiver,
                          const v8::FastOneByteString& path);
@@ -47,8 +53,12 @@ class BindingData : public SnapshotableObject {
   static void RegisterExternalReferences(ExternalReferenceRegistry* registry);
 
  private:
+  static v8::CFunction fast_copy_file_;
   static v8::CFunction fast_exists_;
 
+  static int CopyFileInternal(const std::string_view src,
+                              const std::string_view dest,
+                              int flags);
   static bool ExistsInternal(const std::string_view path);
 };
 

diff --git a/test.js b/test.js
@@ -0,0 +1,2 @@
+const fs = require('node:fs')
+fs.copyFileSync(__filename, './test.txt')