public static unsafe bool TryReadFileHeader(FileHeader* header, string path)
{
var fd = Syscall.open(path, OpenFlags.O_RDONLY, FilePermissions.S_IRUSR);
try
{
if (fd == -1)
{
var lastError = Marshal.GetLastWin32Error();
if (((Errno) lastError) == Errno.EACCES)
return false;
ThrowLastError(lastError);
}
int remaining = sizeof(FileHeader);
var ptr = ((byte*)header);
while (remaining > 0)
{
var read = Syscall.read(fd, ptr, (ulong)remaining);
if (read == -1)
ThrowLastError(Marshal.GetLastWin32Error());
if (read == 0)
return false;// truncated file?
remaining -= (int)read;
ptr += read;
}
return true;
}
finally
{
if (fd != -1)
Syscall.close(fd);
}
}
public static unsafe void WriteFileHeader(FileHeader* header, string path)
{
var fd = Syscall.open(path, OpenFlags.O_WRONLY | OpenFlags.O_CREAT,
FilePermissions.ALLPERMS);
try
{
if (fd == -1)
ThrowLastError(Marshal.GetLastWin32Error());
int remaining = sizeof(FileHeader);
var ptr = ((byte*)header);
while (remaining > 0)
{
var written = Syscall.write(fd, ptr, (ulong)remaining);
if (written == -1)
ThrowLastError(Marshal.GetLastWin32Error());
remaining -= (int) written;
ptr += written;
}
Syscall.fsync(fd);
}
finally
{
if (fd != -1)
Syscall.close(fd);
}
}
public static unsafe void WriteFileHeader(FileHeader* header, string path)
{
using (var fs = new FileStream(path, FileMode.Create, FileAccess.ReadWrite, FileShare.Read))
{
var ptr = (byte*)header;
int remaining = sizeof(FileHeader);
while (remaining > 0)
{
int read;
if (Win32NativeFileMethods.WriteFile(fs.SafeFileHandle, ptr, remaining, out read, null) == false)
throw new Win32Exception();
ptr += read;
remaining -= read;
}
Win32NativeFileMethods.FlushFileBuffers(fs.SafeFileHandle);
}
}
public static unsafe bool TryReadFileHeader(FileHeader* header, string path)
{
using (var fs = new FileStream(path, FileMode.Open, FileAccess.Read, FileShare.ReadWrite))
{
if (fs.Length != sizeof(FileHeader))
return false; // wrong file size
var ptr = (byte*)header;
int remaining = sizeof(FileHeader);
while (remaining > 0)
{
int read;
if (Win32NativeFileMethods.ReadFile(fs.SafeFileHandle, ptr, remaining, out read, null) == false)
throw new Win32Exception();
if (read == 0)
return false; // we should be reading _something_ here, if we can't, then it is an error and we assume corruption
ptr += read;
remaining -= read;
}
return true;
}
}
public unsafe abstract void WriteHeader(string filename, FileHeader* header);
public override unsafe void WriteHeader(string filename, FileHeader* header)
{
if (Disposed)
throw new ObjectDisposedException("PureMemoryStorageEnvironmentOptions");
IntPtr ptr;
if (_headers.TryGetValue(filename, out ptr) == false)
{
ptr = Marshal.AllocHGlobal(sizeof(FileHeader));
_headers[filename] = ptr;
}
MemoryUtils.Copy((byte*)ptr, (byte*)header, sizeof(FileHeader));
}
public unsafe abstract bool ReadHeader(string filename, FileHeader* header);
public override unsafe void WriteHeader(string filename, FileHeader* header)
{
var path = Path.Combine(_basePath, filename);
if (RunningOnPosix)
PosixHelper.WriteFileHeader(header, path);
else
Win32Helper.WriteFileHeader(header, path);
}
public unsafe override bool ReadHeader(string filename, FileHeader* header)
{
if(Disposed)
throw new ObjectDisposedException("PureMemoryStorageEnvironmentOptions");
IntPtr ptr;
if (_headers.TryGetValue(filename, out ptr) == false)
{
return false;
}
*header = *((FileHeader*)ptr);
return true;
}
public unsafe override bool ReadHeader(string filename, FileHeader* header)
{
var path = Path.Combine(_basePath, filename);
if (File.Exists(path) == false)
{
return false;
}
if (RunningOnPosix)
return PosixHelper.TryReadFileHeader(header, path);
return Win32Helper.TryReadFileHeader(header, path);
}
public override unsafe void WriteHeader(string filename, FileHeader* header)
{
IntPtr ptr;
if (_headers.TryGetValue(filename, out ptr) == false)
{
ptr = Marshal.AllocHGlobal(sizeof(FileHeader));
_headers[filename] = ptr;
}
NativeMethods.memcpy((byte*)ptr, (byte*)header, sizeof(FileHeader));
}
public unsafe override bool ReadHeader(string filename, FileHeader* header)
{
IntPtr ptr;
if (_headers.TryGetValue(filename, out ptr) == false)
{
return false;
}
*header = *((FileHeader*)ptr);
return true;
}
public override unsafe void WriteHeader(string filename, FileHeader* header)
{
var path = Path.Combine(_basePath, filename);
using (var fs = new FileStream(path, FileMode.Create, FileAccess.ReadWrite, FileShare.Read))
{
var ptr = (byte*)header;
int remaining = sizeof(FileHeader);
while (remaining > 0)
{
int read;
if (NativeFileMethods.WriteFile(fs.SafeFileHandle, ptr, remaining, out read, null) == false)
throw new Win32Exception();
ptr += read;
remaining -= read;
}
NativeFileMethods.FlushFileBuffers(fs.SafeFileHandle);
}
}
public unsafe override bool ReadHeader(string filename, FileHeader* header)
{
var path = Path.Combine(_basePath, filename);
if (File.Exists(path) == false)
{
return false;
}
using (var fs = new FileStream(path, FileMode.Open, FileAccess.Read, FileShare.ReadWrite))
{
if (fs.Length != sizeof (FileHeader))
return false; // wrong file size
var ptr = (byte*)header;
int remaining = sizeof(FileHeader);
while (remaining > 0)
{
int read;
if (NativeFileMethods.ReadFile(fs.SafeFileHandle, ptr, remaining, out read, null) == false)
throw new Win32Exception();
if (read == 0)
return false; // we should be reading _something_ here, if we can't, then it is an error and we assume corruption
ptr += read;
remaining -= read;
}
return true;
}
}
