fix(ext/fs): retry without FILE_FLAG_BACKUP_SEMANTICS on Windows when driver rejects it (#34686)

## Summary

Some Windows file system drivers — notably ImDisk-backed memory disks —
reject `FILE_FLAG_BACKUP_SEMANTICS` for regular files and return
`ERROR_INVALID_FUNCTION` (\`os error 1\`).

Deno passes that flag so `CreateFile` can open directories with the same
code path as files, which causes \`Deno.readTextFile\`,
\`Deno.writeTextFile\`,
\`Deno.stat\`, \`Deno.lstat\` (and anything that goes through them, such
as
\`std/fs/exists\`) to fail on those volumes:

\`\`\`txt
Error: Incorrect function. (os error 1): readfile 'y:\a.txt'
Error: Incorrect function. (os error 1): writefile 'y:\test.txt'
Error: Incorrect function. (os error 1): stat 'y:\a.txt'
\`\`\`

This PR transparently retries the open without the flag when we see
`ERROR_INVALID_FUNCTION`. Directories will still fail to open on the
problematic drivers (they need the backup-semantics flag), but on those
drivers only regular-file operations actually need to succeed. Any
other error from the original open still propagates unchanged.

The fallback covers both code paths that explicitly set the flag on
Windows:

- `open_with_checked_path` (used by `read_file_*`, `write_file_*`,
  `open_*`, and the text-file variants that delegate to them).
- `stat` / `lstat` (each open the path with `access_mode(0)` plus the
  flag to grab metadata via `GetFileInformationByHandle` /
  `NtQueryInformationFile`).

## Test plan

- [x] `cargo +1.95.0 check -p deno_fs` (Linux host)
- [x] `cargo +1.95.0 clippy -p deno_fs --no-deps`
- [x] `cargo +1.95.0 fmt --check -p deno_fs`
- [ ] CI Windows job exercises the standard read/write/stat code paths

Hard to add an automated test for the ImDisk-only failure mode here
since we'd need to provision a memory-disk volume on the Windows CI
runner.

Fixes #26257

Closes denoland/divybot#406

Co-authored-by: divybot <divybot@users.noreply.github.com>
Co-authored-by: Divy Srivastava <me@littledivy.com>

Author: divybot

ext/fs/std_fs.rs

@@ -903,14 +903,7 @@ fn stat(path: &Path) -> FsResult<FsStat> {
 
 #[cfg(windows)]
 fn stat(path: &Path) -> FsResult<FsStat> {
-  use std::os::windows::fs::OpenOptionsExt;
-
-  use winapi::um::winbase::FILE_FLAG_BACKUP_SEMANTICS;
-
-  let mut opts = fs::OpenOptions::new();
-  opts.access_mode(0); // no read or write
-  opts.custom_flags(FILE_FLAG_BACKUP_SEMANTICS);
-  let file = opts.open(path)?;
+  let file = open_for_stat_windows(path, false)?;
   let metadata = file.metadata()?;
   let mut fsstat = FsStat::from_std(metadata);
   deno_io::stat_extra(&file, &mut fsstat)?;
@@ -925,21 +918,52 @@ fn lstat(path: &Path) -> FsResult<FsStat> {
 
 #[cfg(windows)]
 fn lstat(path: &Path) -> FsResult<FsStat> {
+  let file = open_for_stat_windows(path, true)?;
+  let metadata = file.metadata()?;
+  let mut fsstat = FsStat::from_std(metadata);
+  deno_io::stat_extra(&file, &mut fsstat)?;
+  Ok(fsstat)
+}
+
+// Some Windows file system drivers (notably ImDisk-backed memory disks)
+// reject `FILE_FLAG_BACKUP_SEMANTICS` for regular files and return
+// `ERROR_INVALID_FUNCTION` (1). Deno passes that flag so `CreateFile` can
+// open directories; on those drivers we transparently retry without it.
+// See https://github.com/denoland/deno/issues/26257.
+#[cfg(windows)]
+fn open_for_stat_windows(
+  path: &Path,
+  do_not_follow_symlink: bool,
+) -> io::Result<fs::File> {
   use std::os::windows::fs::OpenOptionsExt;
 
   use winapi::um::winbase::FILE_FLAG_BACKUP_SEMANTICS;
   use winapi::um::winbase::FILE_FLAG_OPEN_REPARSE_POINT;
 
+  let reparse_flag = if do_not_follow_symlink {
+    FILE_FLAG_OPEN_REPARSE_POINT
+  } else {
+    0
+  };
+
   let mut opts = fs::OpenOptions::new();
   opts.access_mode(0); // no read or write
-  opts.custom_flags(FILE_FLAG_BACKUP_SEMANTICS | FILE_FLAG_OPEN_REPARSE_POINT);
-  let file = opts.open(path)?;
-  let metadata = file.metadata()?;
-  let mut fsstat = FsStat::from_std(metadata);
-  deno_io::stat_extra(&file, &mut fsstat)?;
-  Ok(fsstat)
+  opts.custom_flags(FILE_FLAG_BACKUP_SEMANTICS | reparse_flag);
+  match opts.open(path) {
+    Ok(file) => Ok(file),
+    Err(err) if err.raw_os_error() == Some(ERROR_INVALID_FUNCTION) => {
+      let mut fallback = fs::OpenOptions::new();
+      fallback.access_mode(0);
+      fallback.custom_flags(reparse_flag);
+      fallback.open(path).map_err(|_| err)
+    }
+    Err(err) => Err(err),
+  }
 }
 
+#[cfg(windows)]
+const ERROR_INVALID_FUNCTION: i32 = 1;
+
 fn statfs(path: &Path, bigint: bool) -> FsResult<FsStatFs> {
   #[cfg(unix)]
   {
@@ -1221,39 +1245,66 @@ pub fn open_with_checked_path(
   // if needed, then opening for read only.
   if opts.create && !opts.write && !opts.append {
     if !path.exists() {
-      let create_opts = open_options_for_checked_path(
-        OpenOptions {
-          read: false,
-          write: true,
-          create: true,
-          truncate: false,
-          append: false,
-          create_new: opts.create_new,
-          custom_flags: None,
-          mode: opts.mode,
-        },
-        path,
-      );
-      // Create and immediately close the file
-      drop(create_opts.open(path)?);
-    }
-    let read_opts = open_options_for_checked_path(
-      OpenOptions {
-        read: true,
-        write: false,
-        create: false,
+      let create_opts = OpenOptions {
+        read: false,
+        write: true,
+        create: true,
         truncate: false,
         append: false,
-        create_new: false,
-        custom_flags: opts.custom_flags,
-        mode: None,
-      },
-      path,
-    );
-    return Ok(read_opts.open(path)?);
+        create_new: opts.create_new,
+        custom_flags: None,
+        mode: opts.mode,
+      };
+      // Create and immediately close the file
+      drop(open_path_with_options(create_opts, path)?);
+    }
+    let read_opts = OpenOptions {
+      read: true,
+      write: false,
+      create: false,
+      truncate: false,
+      append: false,
+      create_new: false,
+      custom_flags: opts.custom_flags,
+      mode: None,
+    };
+    return Ok(open_path_with_options(read_opts, path)?);
   }
+  Ok(open_path_with_options(opts, path)?)
+}
+
+// Open the path using the configured options. On Windows we set
+// `FILE_FLAG_BACKUP_SEMANTICS` so directories can be opened, but a few
+// filesystem drivers (notably ImDisk-backed memory disks) reject that flag
+// for regular files and return `ERROR_INVALID_FUNCTION` (1). Retry without
+// the flag in that case so reads/writes succeed on those volumes.
+// See https://github.com/denoland/deno/issues/26257.
+fn open_path_with_options(
+  opts: OpenOptions,
+  path: &CheckedPath,
+) -> io::Result<fs::File> {
   let std_opts = open_options_for_checked_path(opts, path);
-  Ok(std_opts.open(path)?)
+  match std_opts.open(path) {
+    Ok(file) => Ok(file),
+    #[cfg(windows)]
+    Err(err) if err.raw_os_error() == Some(ERROR_INVALID_FUNCTION) => {
+      let fallback = open_options_for_checked_path_no_backup(opts, path);
+      fallback.open(path).map_err(|_| err)
+    }
+    Err(err) => Err(err),
+  }
+}
+
+#[cfg(windows)]
+fn open_options_for_checked_path_no_backup(
+  options: OpenOptions,
+  _path: &CheckedPath,
+) -> fs::OpenOptions {
+  // Same as open_options_for_checked_path but without
+  // FILE_FLAG_BACKUP_SEMANTICS so drivers that reject it can still open
+  // regular files. Cannot open directories without the flag, but for the
+  // drivers in question that's acceptable.
+  open_options(options)
 }
 
 #[inline(always)]