.NET on Raspberry Pi cannot write to writable network file

[sba923]

Description

(This is derived from PowerShell/PowerShell#15339, full details can be found there)

Context is: PowerShell 7.1.3 running on Raspberry Pi 2B+ with a network mount off an Ubuntu 20.04.2 LTS box running Samba Version 4.11.6-Ubuntu

PS /home/pi> lsb_release -a
No LSB modules are available.
Distributor ID: Raspbian
Description:    Raspbian GNU/Linux 10 (buster)
Release:        10
Codename:       buster
PS /home/pi> cat /etc/os-release
PRETTY_NAME="Raspbian GNU/Linux 10 (buster)"
NAME="Raspbian GNU/Linux"
VERSION_ID="10"
VERSION="10 (buster)"
VERSION_CODENAME=buster
ID=raspbian
ID_LIKE=debian
HOME_URL="http://www.raspbian.org/"
SUPPORT_URL="http://www.raspbian.org/RaspbianForums"
BUG_REPORT_URL="http://www.raspbian.org/RaspbianBugs"
PS /home/pi> $PSVersionTable

Name                           Value
----                           -----
PSVersion                      7.1.3
PSEdition                      Core
GitCommitId                    7.1.3
OS                             Linux 5.10.17-v7+ #1403 SMP Mon Feb 22 11:29:51 GMT 2021
Platform                       Unix
PSCompatibleVersions           {1.0, 2.0, 3.0, 4.0…}
PSRemotingProtocolVersion      2.3
SerializationVersion           1.1.0.1
WSManStackVersion              3.0

pi@jeedom:~ $ resolveip pnjnas
IP address of pnjnas is 192.168.1.3
pi@jeedom:~ $ mount | fgrep 192.168.1.3
//192.168.1.3/pi on /pnjnas/pi type cifs (rw,nosuid,nodev,noexec,relatime,vers=2.0,cache=strict,username=pi,uid=0,noforceuid,gid=0,noforcegid,addr=192.168.1.3,file_mode=0777,dir_mode=0777,soft,nounix,serverino,mapposix,rsize=65536,wsize=65536,bsize=1048576,echo_interval=60,actimeo=1,_netdev)
//192.168.1.3/Qdownload on /pnjnas/Qdownload type cifs (rw,nosuid,nodev,noexec,relatime,vers=2.0,cache=strict,username=pi,uid=0,noforceuid,gid=0,noforcegid,addr=192.168.1.3,file_mode=0777,dir_mode=0777,soft,nounix,serverino,mapposix,rsize=65536,wsize=65536,bsize=1048576,echo_interval=60,actimeo=1,_netdev)
//192.168.1.3/public on /pnjnas/public type cifs (rw,nosuid,nodev,noexec,relatime,vers=2.0,cache=strict,username=pi,uid=0,noforceuid,gid=0,noforcegid,addr=192.168.1.3,file_mode=0777,dir_mode=0777,soft,nounix,serverino,mapposix,rsize=65536,wsize=65536,bsize=1048576,echo_interval=60,actimeo=1,_netdev)
//192.168.1.3/sto on /pnjnas/sto type cifs (rw,nosuid,nodev,noexec,relatime,vers=2.0,cache=strict,username=sto,uid=0,noforceuid,gid=0,noforcegid,addr=192.168.1.3,file_mode=0777,dir_mode=0777,soft,nounix,serverino,mapposix,rsize=65536,wsize=65536,bsize=1048576,echo_interval=60,actimeo=1,_netdev)
pi@jeedom:~ $ ls -l /pnjnas/sto/disks/Health/foo.txt
-rwxrwxrwx 1 root root 4 May  2 21:09 /pnjnas/sto/disks/Health/foo.txt
pi@jeedom:~ $ ls -ld /pnjnas/sto/disks/Health
drwxrwxrwx 2 root root 0 May  2 21:06 /pnjnas/sto/disks/Health
pi@jeedom:~ $ echo "foo" >/pnjnas/sto/disks/Health/foo.txt
# no error since file is writable
pi@jeedom:~ $ ls -l /pnjnas/sto/disks/Health/foo.txt
-rwxrwxrwx 1 root root 4 May  3 14:16 /pnjnas/sto/disks/Health/foo.txt
pi@jeedom:~ $ cat /pnjnas/sto/disks/Health/foo.txt
foo

Writing to that same file via .NET APIs (invoked via PowerShell) doesn't work:

$fs = [IO.File]::Open("/pnjnas/sto/disks/Health/foo.txt", "Create",  "Write", "Read")
$sw = [IO.StreamWriter]::new($fs)
$sw.WriteLine("foo")
$sw.Dispose()

This fails as follows:

MethodInvocationException: /pnjnas/sto/PowerShell/test/Test-WritingToSambaShare.ps1:4
Line |
   4 |  $sw.Dispose()
     |  ~~~~~~~~~~~~~
     | Exception calling "Dispose" with "0" argument(s): "Access to the path '/pnjnas/sto/disks/Health/foo.txt' is denied."

Tagging subscribers to this area: @carlossanlop
See info in area-owners.md if you want to be subscribed.

Issue Details

---

Description

(This is derived from PowerShell/PowerShell#15339, full details can be found there)

Context is: PowerShell 7.1.3 running on Raspberry Pi 2B+ with a network mount off an Ubuntu 20.04.2 LTS box running Samba Version 4.11.6-Ubuntu

PS /home/pi> lsb_release -a
No LSB modules are available.
Distributor ID: Raspbian
Description:    Raspbian GNU/Linux 10 (buster)
Release:        10
Codename:       buster
PS /home/pi> cat /etc/os-release
PRETTY_NAME="Raspbian GNU/Linux 10 (buster)"
NAME="Raspbian GNU/Linux"
VERSION_ID="10"
VERSION="10 (buster)"
VERSION_CODENAME=buster
ID=raspbian
ID_LIKE=debian
HOME_URL="http://www.raspbian.org/"
SUPPORT_URL="http://www.raspbian.org/RaspbianForums"
BUG_REPORT_URL="http://www.raspbian.org/RaspbianBugs"
PS /home/pi> $PSVersionTable

Name                           Value
----                           -----
PSVersion                      7.1.3
PSEdition                      Core
GitCommitId                    7.1.3
OS                             Linux 5.10.17-v7+ #1403 SMP Mon Feb 22 11:29:51 GMT 2021
Platform                       Unix
PSCompatibleVersions           {1.0, 2.0, 3.0, 4.0…}
PSRemotingProtocolVersion      2.3
SerializationVersion           1.1.0.1
WSManStackVersion              3.0

pi@jeedom:~ $ resolveip pnjnas
IP address of pnjnas is 192.168.1.3
pi@jeedom:~ $ mount | fgrep 192.168.1.3
//192.168.1.3/pi on /pnjnas/pi type cifs (rw,nosuid,nodev,noexec,relatime,vers=2.0,cache=strict,username=pi,uid=0,noforceuid,gid=0,noforcegid,addr=192.168.1.3,file_mode=0777,dir_mode=0777,soft,nounix,serverino,mapposix,rsize=65536,wsize=65536,bsize=1048576,echo_interval=60,actimeo=1,_netdev)
//192.168.1.3/Qdownload on /pnjnas/Qdownload type cifs (rw,nosuid,nodev,noexec,relatime,vers=2.0,cache=strict,username=pi,uid=0,noforceuid,gid=0,noforcegid,addr=192.168.1.3,file_mode=0777,dir_mode=0777,soft,nounix,serverino,mapposix,rsize=65536,wsize=65536,bsize=1048576,echo_interval=60,actimeo=1,_netdev)
//192.168.1.3/public on /pnjnas/public type cifs (rw,nosuid,nodev,noexec,relatime,vers=2.0,cache=strict,username=pi,uid=0,noforceuid,gid=0,noforcegid,addr=192.168.1.3,file_mode=0777,dir_mode=0777,soft,nounix,serverino,mapposix,rsize=65536,wsize=65536,bsize=1048576,echo_interval=60,actimeo=1,_netdev)
//192.168.1.3/sto on /pnjnas/sto type cifs (rw,nosuid,nodev,noexec,relatime,vers=2.0,cache=strict,username=sto,uid=0,noforceuid,gid=0,noforcegid,addr=192.168.1.3,file_mode=0777,dir_mode=0777,soft,nounix,serverino,mapposix,rsize=65536,wsize=65536,bsize=1048576,echo_interval=60,actimeo=1,_netdev)
pi@jeedom:~ $ ls -l /pnjnas/sto/disks/Health/foo.txt
-rwxrwxrwx 1 root root 4 May  2 21:09 /pnjnas/sto/disks/Health/foo.txt
pi@jeedom:~ $ ls -ld /pnjnas/sto/disks/Health
drwxrwxrwx 2 root root 0 May  2 21:06 /pnjnas/sto/disks/Health
pi@jeedom:~ $ echo "foo" >/pnjnas/sto/disks/Health/foo.txt
# no error since file is writable
pi@jeedom:~ $ ls -l /pnjnas/sto/disks/Health/foo.txt
-rwxrwxrwx 1 root root 4 May  3 14:16 /pnjnas/sto/disks/Health/foo.txt
pi@jeedom:~ $ cat /pnjnas/sto/disks/Health/foo.txt
foo

Writing to that same file via .NET APIs (invoked via PowerShell) doesn't work:

$fs = [IO.File]::Open("/pnjnas/sto/disks/Health/foo.txt", "Create",  "Write", "Read")
$sw = [IO.StreamWriter]::new($fs)
$sw.WriteLine("foo")
$sw.Dispose()

This fails as follows:

MethodInvocationException: /pnjnas/sto/PowerShell/test/Test-WritingToSambaShare.ps1:4
Line |
   4 |  $sw.Dispose()
     |  ~~~~~~~~~~~~~
     | Exception calling "Dispose" with "0" argument(s): "Access to the path '/pnjnas/sto/disks/Health/foo.txt' is denied."

Author:	sba923
Assignees:	-
Labels:	area-System.IO, untriaged
Milestone:	-

[adamsitnik]

@sba923 I currently don't have an access to a remote Samba file share and I can't properly test a fix that I've been working on. Is there any chance that you could run the following app with a path to a writeable folder as an argument and share the output with me?

The app creates a file and tries to acquire few different type of locks before writing to it.

The easiest way would be to install dotnet SDK, create new folder, run dotnet new console and replace the contents of the .csproj file with:

<Project Sdk="Microsoft.NET.Sdk">
    <PropertyGroup>
        <OutputType>Exe</OutputType>
        <TargetFramework>net5.0</TargetFramework>
        <AllowUnsafeBlocks>true</AllowUnsafeBlocks>
    </PropertyGroup>
    <ItemGroup>
      <PackageReference Include="Tmds.LibC" Version="0.5.0" />
    </ItemGroup>
</Project>

And the .cs file with:

using System;
using System.IO;
using System.Runtime.InteropServices;
using System.Text;
using Microsoft.Win32.SafeHandles;
using Tmds.Linux;
using static Tmds.Linux.LibC;

namespace FileSystemRepro
{
    class Program
    {
        static void Main(string[] args)
        {
            string directoryPath = args[0];
            string fileName = Guid.NewGuid().ToString();
            string filePath = Path.Combine(directoryPath, fileName);

            try
            {
                CreateNoLocks(filePath);
                File.Delete(filePath);

                CreateFLock(filePath, LockOperations.LOCK_EX);
                File.Delete(filePath);
                
                CreateFLock(filePath, LockOperations.LOCK_SH);
                File.Delete(filePath);
                
                CreateFcntl(filePath, LockOperations.LOCK_EX);
                File.Delete(filePath);
                
                CreateFcntl(filePath, LockOperations.LOCK_SH);
                File.Delete(filePath);
            }
            finally
            {
                if (File.Exists(filePath))
                {
                    File.Delete(filePath);
                }
            }
        }

        private static void CreateNoLocks(string filePath)
        {
            using (SafeFileHandle sfh = CreateNewFile(filePath))
            using (FileStream fs = new FileStream(sfh, FileAccess.ReadWrite, bufferSize: 1, isAsync: false))
            {
                WriteAndReadSimple(fs);
            }
        }
        
        private static void CreateFLock(string filePath, LockOperations lockOperations)
        {
            using (SafeFileHandle sfh = CreateNewFile(filePath))
            using (FileStream fs = new FileStream(sfh, FileAccess.ReadWrite, bufferSize: 1, isAsync: false))
            {
                Console.WriteLine($"Using {lockOperations} flock to lock the file");
                int lockResult = flock(sfh.DangerousGetHandle().ToInt32(), lockOperations);
                if (lockResult == -1)
                {
                    int errorCode = errno;
                    Console.WriteLine($"Locking {filePath} failed with error code {errorCode} and message: {GetErrorMessage(errorCode)}");
                }

                try
                {
                    WriteAndReadSimple(fs);
                }
                finally
                {
                    flock(sfh.DangerousGetHandle().ToInt32(), LockOperations.LOCK_UN);
                }
            }
        }
        
        private static unsafe void CreateFcntl(string filePath, LockOperations lockOperations)
        {
            using (SafeFileHandle sfh = CreateNewFile(filePath))
            using (FileStream fs = new FileStream(sfh, FileAccess.ReadWrite, bufferSize: 1, isAsync: false))
            {
                Console.WriteLine($"Using {lockOperations} fcntl to lock the file");
                flock flock = default;
                flock.l_whence = (short)SEEK_SET;
                flock.l_start = 0;
                flock.l_len = 0; // lock entire file
                flock.l_type = (short) lockOperations;
                
                int lockResult = fcntl(sfh.DangerousGetHandle().ToInt32(), F_SETLK, &flock);
                if (lockResult == -1)
                {
                    int errorCode = errno;
                    Console.WriteLine($"Locking {filePath} failed with error code {errorCode} and message: {GetErrorMessage(errorCode)}");
                }

                try
                {
                    WriteAndReadSimple(fs);
                }
                finally
                {
                    flock.l_type = (short) LockOperations.LOCK_UN;
                    fcntl(sfh.DangerousGetHandle().ToInt32(), F_SETLK, &flock);
                }
            }
        }

        private static void WriteAndReadSimple(FileStream fs)
        {
            Console.WriteLine($"Length: {fs.Length}, position: {fs.Position}");
            fs.WriteByte(123);
            Console.WriteLine($"After writing one byte: length: {fs.Length}, position: {fs.Position}");
            fs.Position -= 1;
            int read = fs.ReadByte();
            if (read != 123)
            {
                Console.WriteLine($"Invalid content {read}");
            }
        }

        private static unsafe SafeFileHandle CreateNewFile(string filePath)
        {
            byte[] utf8Path = Encoding.UTF8.GetBytes(filePath);
            fixed (byte* pinnedPath = utf8Path)
            {
                int createNewFileFlags = O_CREAT | O_RDWR | O_EXCL;
                mode_t openPermissions =  S_IRUSR | S_IWUSR | S_IRGRP | S_IWGRP | S_IROTH | S_IWOTH; // read and write for all
                int result = open(pinnedPath, createNewFileFlags, openPermissions);
                
                if (result == -1)
                {
                    int errorCode = errno;
                    throw new Exception($"Creating {filePath} failed with error code {errorCode} and message: {GetErrorMessage(errorCode)}");
                }

                return new SafeFileHandle(new IntPtr(result), true);
            }
        }
        
        private static unsafe string GetErrorMessage(int errno)
        {
            int bufferLength = 1024;
            byte* buffer = stackalloc byte[bufferLength];

            int rv = strerror_r(errno, buffer, bufferLength);

            return rv == 0 ? Marshal.PtrToStringAnsi((IntPtr)buffer) : $"errno {errno}";
        }

        private enum LockOperations : int
        {
            LOCK_SH = 1,    /* shared lock */
            LOCK_EX = 2,    /* exclusive lock */
            LOCK_NB = 4,    /* don't block when locking*/
            LOCK_UN = 8,    /* unlock */
        }
        
        [DllImport("libc", SetLastError = true, ExactSpelling = true)]
        private static extern int flock(int fd, LockOperations operation);
    }
}

After that you should be able to run it using the following command:

dotnet run -- $pathToFolder

[sba923]

Sure. Here what it gets me:

pi@jeedom:~/src/locktest $ dotnet run -- /pnjnas/sto/tmp/locktest
Length: 0, position: 0
After writing one byte: length: 1, position: 1
Using LOCK_EX flock to lock the file
Length: 0, position: 0
After writing one byte: length: 1, position: 1
Using LOCK_SH flock to lock the file
Length: 0, position: 0
After writing one byte: length: 1, position: 1
Unhandled exception. System.UnauthorizedAccessException: Access to the path is denied.
 ---> System.IO.IOException: Permission denied
   --- End of inner exception stack trace ---
   at System.IO.FileStream.WriteNative(ReadOnlySpan`1 source)
   at System.IO.FileStream.FlushWriteBuffer()
   at System.IO.FileStream.Seek(Int64 offset, SeekOrigin origin)
   at System.IO.FileStream.set_Position(Int64 value)
   at FileSystemRepro.Program.WriteAndReadSimple(FileStream fs) in /home/pi/src/locktest/Program.cs:line 114
   at FileSystemRepro.Program.CreateFLock(String filePath, LockOperations lockOperations) in /home/pi/src/locktest/Program.cs:line 69
   at FileSystemRepro.Program.Main(String[] args) in /home/pi/src/locktest/Program.cs:line 27
pi@jeedom:~/src/locktest $ ls -lart /pnjnas/sto/tmp/locktest
total 0
drwxrwxrwx 2 root root 0 Jul  6 09:22 ..
-rwxrwxrwx 1 root root 0 Jul  6 09:25 85e620be-6bcf-4e27-b021-9fce5a4c0cfd
drwxrwxrwx 2 root root 0 Jul  6 09:25 .

[adamsitnik]

@sba923 thank you very much! I've sent a PR with a fix: #55195

[sba923]

Great. This probably means that the fix to the original issue will be available (only) when a PowerShell release is published that consumes the fixed .NET.

[adamsitnik]

This probably means that the fix to the original issue will be available (only) when a PowerShell release is published that consumes the fixed .NET.

@sba923 Yes, however I have one more idea: releasing the lock after a failed write which I hope could be backported to older .NET Core releases. Could you please run the following app and share the output?

using System;
using System.IO;
using System.Runtime.InteropServices;
using System.Text;
using Microsoft.Win32.SafeHandles;
using Tmds.Linux;
using static Tmds.Linux.LibC;

namespace ReleaseLock
{
    class Program
    {
        static void Main(string[] args)
        {
            string directoryPath = args[0];
            string fileName = Guid.NewGuid().ToString();
            string filePath = Path.Combine(directoryPath, fileName);
            
            try
            {
                CreateFLock(filePath, LockOperations.LOCK_EX);
                File.Delete(filePath);
                
                CreateFLock(filePath, LockOperations.LOCK_SH);
            }
            finally
            {
                if (File.Exists(filePath)) File.Delete(filePath);
            }
        }

        private static void CreateFLock(string filePath, LockOperations lockOperations)
        {
            using (SafeFileHandle sfh = CreateNewFile(filePath))
            {
                Console.WriteLine($"Using {lockOperations} flock to lock the file");
                int lockResult = flock(sfh.DangerousGetHandle().ToInt32(), lockOperations);
                if (lockResult == -1)
                {
                    int errorCode = errno;
                    Console.WriteLine($"Locking {filePath} failed with error code {errorCode} and message: {GetErrorMessage(errorCode)}");
                }

                try
                {
                    WriteAndReadSimple(sfh);
                }
                finally
                {
                    flock(sfh.DangerousGetHandle().ToInt32(), LockOperations.LOCK_UN);
                }
            }
        }

        private static unsafe void WriteAndReadSimple(SafeFileHandle sfh)
        {
            byte* buffer = stackalloc byte[1];
            buffer[0] = 123;

            ssize_t writeResult = write(sfh.DangerousGetHandle().ToInt32(), buffer, 1);
            if (writeResult == -1)
            {
                int errorCode = errno;
                Console.WriteLine($"writing failed with error code {errorCode} and message: {GetErrorMessage(errorCode)}");
                
                int unlockResult = flock(sfh.DangerousGetHandle().ToInt32(), LockOperations.LOCK_UN);
                Console.WriteLine($"Releasing the lock returned {unlockResult}");
                
                writeResult = write(sfh.DangerousGetHandle().ToInt32(), buffer, 1);
                if (writeResult == -1)
                {
                    Console.WriteLine($"writing after unlock failed with error code {errorCode} and message: {GetErrorMessage(errorCode)}");
                }
            }
            
            buffer[0] = 0;
            ssize_t readResult = pread(sfh.DangerousGetHandle().ToInt32(), buffer, count: 1, offset:0);
            if (readResult == -1)
            {
                int errorCode = errno;
                Console.WriteLine($"reading failed with error code {errorCode} and message: {GetErrorMessage(errorCode)}");
            }
            else if (buffer[0] != 123)
            {
                Console.WriteLine($"Invalid content {buffer[0]}, readResult = {readResult}");
            }
        }

        private static unsafe SafeFileHandle CreateNewFile(string filePath)
        {
            byte[] utf8Path = Encoding.UTF8.GetBytes(filePath);
            fixed (byte* pinnedPath = utf8Path)
            {
                int createNewFileFlags = O_CREAT | O_RDWR | O_EXCL;
                mode_t openPermissions =  S_IRUSR | S_IWUSR | S_IRGRP | S_IWGRP | S_IROTH | S_IWOTH; // read and write for all
                int result = open(pinnedPath, createNewFileFlags, openPermissions);
                
                if (result == -1)
                {
                    int errorCode = errno;
                    throw new Exception($"Creating {filePath} failed with error code {errorCode} and message: {GetErrorMessage(errorCode)}");
                }

                return new SafeFileHandle(new IntPtr(result), true);
            }
        }
        
        private static unsafe string GetErrorMessage(int errno)
        {
            int bufferLength = 1024;
            byte* buffer = stackalloc byte[bufferLength];

            int rv = strerror_r(errno, buffer, bufferLength);

            return rv == 0 ? Marshal.PtrToStringAnsi((IntPtr)buffer) : $"errno {errno}";
        }

        private enum LockOperations
        {
            LOCK_SH = 1,    /* shared lock */
            LOCK_EX = 2,    /* exclusive lock */
            LOCK_NB = 4,    /* don't block when locking*/
            LOCK_UN = 8,    /* unlock */
        }
        
        [DllImport("libc", SetLastError = true, ExactSpelling = true)]
        private static extern int flock(int fd, LockOperations operation);
    }
}

[sba923]

Here's what I get this time:

pi@jeedom:~/src/locktest $ dotnet run -- /pnjnas/sto/tmp/locktest/
Using LOCK_EX flock to lock the file
Using LOCK_SH flock to lock the file
writing failed with error code 13 and message: Permission denied
Releasing the lock returned 0
pi@jeedom:~/src/locktest $ ls -lart /pnjnas/sto/tmp/locktest
total 0
drwxrwxrwx 2 root root 0 Jul  6 09:22 ..
drwxrwxrwx 2 root root 0 Jul  6 16:22 .

[adamsitnik]

@sba923 please excuse me to bother you again. It turned out that unlocking the file would work fine for CIFS (which returns a nice error when the write fails) but not for NFS which reports a successful write which actually does not write anything to disk and because of that I can't use the "unlock on failure" approach.

My current best idea is to use fstatfs() sys-call and just don't lock the files for NFS, CIFS and SMB (#55256). But I need to verify that the file system can be recgonized in your scenario. Could you please run the following app and share the results?

Once again big thanks for all the help.

using System;
using System.IO;
using System.Runtime.InteropServices;
using System.Text;
using Microsoft.Win32.SafeHandles;
using Tmds.Linux;
using static Tmds.Linux.LibC;

namespace GetFileSystemType
{
    class Program
    {
        static unsafe void Main(string[] args)
        {
            string directoryPath = args[0];
            string fileName = Guid.NewGuid().ToString();
            string filePath = Path.Combine(directoryPath, fileName);
            
            try
            {
                using (SafeFileHandle sfh = CreateNewFile(filePath))
                {
                    statfs statfs = default;
                    int statfsResult = IntPtr.Size == 4
                        ? fstatfs(sfh.DangerousGetHandle().ToInt32(), &statfs)
                        : fstatfs64(sfh.DangerousGetHandle().ToInt32(), &statfs);

                    if (statfsResult == -1)
                    {
                        int errorCode = errno;
                        Console.WriteLine($"fstatfs failed with error code {errorCode} and message: {GetErrorMessage(errorCode)}");
                    }
                    else
                    {
                        Console.WriteLine($"file system type is {statfs.f_type.ToString("X")}");
                    }
                }
            }
            finally
            {
                if (File.Exists(filePath)) File.Delete(filePath);
            }
        }

        private static unsafe SafeFileHandle CreateNewFile(string filePath)
        {
            byte[] utf8Path = Encoding.UTF8.GetBytes(filePath);
            fixed (byte* pinnedPath = utf8Path)
            {
                int createNewFileFlags = O_CREAT | O_RDWR | O_EXCL;
                mode_t openPermissions =  S_IRUSR | S_IWUSR | S_IRGRP | S_IWGRP | S_IROTH | S_IWOTH; // read and write for all
                int result = open(pinnedPath, createNewFileFlags, openPermissions);
                
                if (result == -1)
                {
                    int errorCode = errno;
                    throw new Exception($"Creating {filePath} failed with error code {errorCode} and message: {GetErrorMessage(errorCode)}");
                }

                return new SafeFileHandle(new IntPtr(result), true);
            }
        }
        
        private static unsafe string GetErrorMessage(int errno)
        {
            int bufferLength = 1024;
            byte* buffer = stackalloc byte[bufferLength];

            int rv = strerror_r(errno, buffer, bufferLength);

            return rv == 0 ? Marshal.PtrToStringAnsi((IntPtr)buffer) : $"errno {errno}";
        }
        
        [DllImport("libc", SetLastError = true, ExactSpelling = true)]
        private static extern unsafe int fstatfs64(int fd, statfs* operation);
        
        [DllImport("libc", SetLastError = true, ExactSpelling = true)]
        private static extern unsafe int fstatfs(int fd, statfs* operation);
        
        [StructLayout(LayoutKind.Sequential)]
        internal unsafe struct statfs {
            internal nint f_type; /* type of file system (see below) */
            internal nint f_bsize; /* optimal transfer block size */
            internal fsblkcnt_t f_blocks; /* total data blocks in file system */
            internal fsblkcnt_t f_bfree; /* free blocks in fs */
            internal fsblkcnt_t f_bavail; /* free blocks available to unprivileged user */
            internal fsfilcnt_t f_files; /* total file nodes in file system */
            internal fsfilcnt_t f_ffree; /* free file nodes in fs */
            internal nint f_fsid; /* file system id */
            internal nint f_namelen; /* maximum length of filenames */
            internal nint f_frsize; /* fragment size (since Linux 2.6) */
            internal nint f_spare;
        };
    }
}