Fix NativeUnixDirectory direct I/O open on macOS and ARM64 Linux (#1342)

Two platform bugs caused TestNativeUnixDirectory* to fail (5 on macOS, all
on ARM64 Linux):

- macOS EACCES: the write path opened with open(path, O_RDWR|O_CREAT, 0666)
  through a fixed-signature P/Invoke, but C's open() is variadic so the mode
  argument rides the varargs ABI; on macOS (incl. Apple Silicon) the callee
  read garbage and created files without owner-read permission, so the
  subsequent O_RDONLY open failed with EACCES. Now pre-create the file with
  the BCL (applying the normal mode + umask) and open with the two-argument
  open() (no O_CREAT, no varargs). Dropped the broken 3-arg open and the
  O_CREAT/S_RW constants.

- ARM64 Linux ENOTDIR: O_DIRECT was hardcoded to 0x4000, which is correct on
  x86/x86-64 but is O_DIRECTORY on Arm/Arm64 (the two are swapped; O_DIRECT
  there is 0x10000), so open() of a regular file failed with ENOTDIR. Now
  select O_DIRECT by RuntimeInformation.OSArchitecture.

Also tighten the input refill EOF check from n < 0 to n <= 0: upstream used
FileChannel.read() (returns -1 at EOF) but the port wraps libc pread()
(returns 0 at EOF), so read-past-EOF would otherwise silently return zeros.

Verified: TestNativeUnixDirectory* 23/23 pass on macOS arm64, Linux aarch64,
and Linux x86-64 (the latter two in mcr.microsoft.com/dotnet/sdk:10.0 with an
O_DIRECT-capable TMPDIR).

Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com>

Author: paulirwin

src/Lucene.Net.Misc/Store/NativePosixUtil.cs

@@ -66,12 +66,26 @@ public static SafeFileHandle OpenDirect(string filename, bool read)
         {
             EnsureUnix();
 
+            // Upstream's C++ called open(fname, O_RDWR | O_CREAT | DIRECT_FLAG, 0666) for the write path.
+            // We cannot create-with-mode through P/Invoke: open() is variadic (int open(const char*, int, ...))
+            // and the mode argument rides the varargs ABI. On platforms where varargs are not passed in the
+            // same registers as fixed args (notably macOS, including Apple Silicon arm64), a fixed-signature
+            // P/Invoke delivers garbage for mode, producing a file without owner-read permission, so the
+            // subsequent O_RDONLY open of the same file fails with EACCES. To stay correct and ABI-agnostic
+            // we never pass mode: the file is created up front by the BCL (which applies the normal mode and
+            // umask), and we then open it with the plain two-argument open() - no O_CREAT, no varargs.
+            if (!read)
+            {
+                // mirrors O_CREAT: ensure the file exists with a sane mode before opening it
+                using (System.IO.File.Open(filename, System.IO.FileMode.OpenOrCreate, System.IO.FileAccess.ReadWrite)) { }
+            }
+
             int fd;
             if (Constants.MAC_OS_X)
             {
                 fd = read
                     ? NativeMethods.open(filename, NativeMethods.O_RDONLY)
-                    : NativeMethods.open(filename, NativeMethods.O_RDWR | NativeMethods.O_CREAT, NativeMethods.S_RW);
+                    : NativeMethods.open(filename, NativeMethods.O_RDWR);
                 if (fd < 0)
                 {
                     throw NewIOException("open", filename);
@@ -89,7 +103,7 @@ public static SafeFileHandle OpenDirect(string filename, bool read)
             {
                 fd = read
                     ? NativeMethods.open(filename, NativeMethods.O_RDONLY | NativeMethods.O_DIRECT | NativeMethods.O_NOATIME)
-                    : NativeMethods.open(filename, NativeMethods.O_RDWR | NativeMethods.O_CREAT | NativeMethods.O_DIRECT | NativeMethods.O_NOATIME, NativeMethods.S_RW);
+                    : NativeMethods.open(filename, NativeMethods.O_RDWR | NativeMethods.O_DIRECT | NativeMethods.O_NOATIME);
                 if (fd < 0)
                 {
                     throw NewIOException("open", filename);
@@ -194,21 +208,24 @@ private static class NativeMethods
         {
             private const string LIBC = "libc";
 
-            // open() flags. O_CREAT differs between Linux and macOS; O_DIRECT/O_NOATIME are Linux-only.
+            // open() flags. O_DIRECT/O_NOATIME are Linux-only. We never pass O_CREAT/mode: see OpenDirect.
             internal const int O_RDONLY = 0x0;
             internal const int O_RDWR = 0x2;
-            internal static readonly int O_CREAT = Constants.MAC_OS_X ? 0x0200 : 0x40;
-            internal const int O_DIRECT = 0x4000;   // Linux
+
+            // O_DIRECT is architecture-dependent on Linux: most arches (x86/x86-64) use the asm-generic
+            // value 0x4000, but Arm/Arm64 (and a few others) swap it with O_DIRECTORY and use 0x10000.
+            // Using the wrong value silently means "O_DIRECTORY", which makes open() of a regular file
+            // fail with ENOTDIR. O_NOATIME (0x40000) is the same across these arches.
+            internal static readonly int O_DIRECT =
+                RuntimeInformation.OSArchitecture is Architecture.Arm or Architecture.Arm64
+                    ? 0x10000
+                    : 0x4000;
             internal const int O_NOATIME = 0x40000; // Linux
             internal const int F_NOCACHE = 48;      // macOS
-            internal const int S_RW = 0x1B6;        // 0666
 
             [DllImport(LIBC, SetLastError = true, EntryPoint = "open")]
             internal static extern int open([MarshalAs(UnmanagedType.LPStr)] string pathname, int flags);
 
-            [DllImport(LIBC, SetLastError = true, EntryPoint = "open")]
-            internal static extern int open([MarshalAs(UnmanagedType.LPStr)] string pathname, int flags, int mode);
-
             [DllImport(LIBC, SetLastError = true)]
             internal static extern int close(int fd);
 

src/Lucene.Net.Misc/Store/NativeUnixDirectory.cs

@@ -526,7 +526,10 @@ private void Refill()
                 {
                     throw new IOException(ioe.Message + ": " + this, ioe);
                 }
-                if (n < 0)
+                // Upstream used FileChannel.read(), which returns -1 at EOF. Here Pread() wraps libc
+                // pread(), which returns 0 at EOF (a genuine error already threw above), so a refill that
+                // reads nothing means we have stepped entirely past the end of the file.
+                if (n <= 0)
                 {
                     throw EOFException.Create("read past EOF: " + this);
                 }