1495 lines
25 KiB
C
1495 lines
25 KiB
C
/*
|
|
* nt_io.c --- This is the Nt I/O interface to the I/O manager.
|
|
*
|
|
* Implements a one-block write-through cache.
|
|
*
|
|
* Copyright (C) 1993, 1994, 1995 Theodore Ts'o.
|
|
* Copyright (C) 1998 Andrey Shedel (andreys@ns.cr.cyco.com)
|
|
*
|
|
* %Begin-Header%
|
|
* This file may be redistributed under the terms of the GNU Library
|
|
* General Public License, version 2.
|
|
* %End-Header%
|
|
*/
|
|
|
|
#ifdef HAVE_CONFIG_H
|
|
#include "config.h"
|
|
#endif
|
|
|
|
|
|
//
|
|
// I need some warnings to disable...
|
|
//
|
|
|
|
|
|
#pragma warning(disable:4514) // unreferenced inline function has been removed
|
|
#pragma warning(push,4)
|
|
|
|
#pragma warning(disable:4201) // nonstandard extension used : nameless struct/union)
|
|
#pragma warning(disable:4214) // nonstandard extension used : bit field types other than int
|
|
#pragma warning(disable:4115) // named type definition in parentheses
|
|
|
|
#include <ntddk.h>
|
|
#include <ntdddisk.h>
|
|
#include <ntstatus.h>
|
|
|
|
#pragma warning(pop)
|
|
|
|
|
|
//
|
|
// Some native APIs.
|
|
//
|
|
|
|
NTSYSAPI
|
|
ULONG
|
|
NTAPI
|
|
RtlNtStatusToDosError(
|
|
IN NTSTATUS Status
|
|
);
|
|
|
|
NTSYSAPI
|
|
NTSTATUS
|
|
NTAPI
|
|
NtClose(
|
|
IN HANDLE Handle
|
|
);
|
|
|
|
|
|
NTSYSAPI
|
|
NTSTATUS
|
|
NTAPI
|
|
NtOpenFile(
|
|
OUT PHANDLE FileHandle,
|
|
IN ACCESS_MASK DesiredAccess,
|
|
IN POBJECT_ATTRIBUTES ObjectAttributes,
|
|
OUT PIO_STATUS_BLOCK IoStatusBlock,
|
|
IN ULONG ShareAccess,
|
|
IN ULONG OpenOptions
|
|
);
|
|
|
|
NTSYSAPI
|
|
NTSTATUS
|
|
NTAPI
|
|
NtFlushBuffersFile(
|
|
IN HANDLE FileHandle,
|
|
OUT PIO_STATUS_BLOCK IoStatusBlock
|
|
);
|
|
|
|
|
|
NTSYSAPI
|
|
NTSTATUS
|
|
NTAPI
|
|
NtReadFile(
|
|
IN HANDLE FileHandle,
|
|
IN HANDLE Event OPTIONAL,
|
|
IN PIO_APC_ROUTINE ApcRoutine OPTIONAL,
|
|
IN PVOID ApcContext OPTIONAL,
|
|
OUT PIO_STATUS_BLOCK IoStatusBlock,
|
|
OUT PVOID Buffer,
|
|
IN ULONG Length,
|
|
IN PLARGE_INTEGER ByteOffset OPTIONAL,
|
|
IN PULONG Key OPTIONAL
|
|
);
|
|
|
|
NTSYSAPI
|
|
NTSTATUS
|
|
NTAPI
|
|
NtWriteFile(
|
|
IN HANDLE FileHandle,
|
|
IN HANDLE Event OPTIONAL,
|
|
IN PIO_APC_ROUTINE ApcRoutine OPTIONAL,
|
|
IN PVOID ApcContext OPTIONAL,
|
|
OUT PIO_STATUS_BLOCK IoStatusBlock,
|
|
IN PVOID Buffer,
|
|
IN ULONG Length,
|
|
IN PLARGE_INTEGER ByteOffset OPTIONAL,
|
|
IN PULONG Key OPTIONAL
|
|
);
|
|
|
|
NTSYSAPI
|
|
NTSTATUS
|
|
NTAPI
|
|
NtDeviceIoControlFile(
|
|
IN HANDLE FileHandle,
|
|
IN HANDLE Event OPTIONAL,
|
|
IN PIO_APC_ROUTINE ApcRoutine OPTIONAL,
|
|
IN PVOID ApcContext OPTIONAL,
|
|
OUT PIO_STATUS_BLOCK IoStatusBlock,
|
|
IN ULONG IoControlCode,
|
|
IN PVOID InputBuffer OPTIONAL,
|
|
IN ULONG InputBufferLength,
|
|
OUT PVOID OutputBuffer OPTIONAL,
|
|
IN ULONG OutputBufferLength
|
|
);
|
|
|
|
NTSYSAPI
|
|
NTSTATUS
|
|
NTAPI
|
|
NtFsControlFile(
|
|
IN HANDLE FileHandle,
|
|
IN HANDLE Event OPTIONAL,
|
|
IN PIO_APC_ROUTINE ApcRoutine OPTIONAL,
|
|
IN PVOID ApcContext OPTIONAL,
|
|
OUT PIO_STATUS_BLOCK IoStatusBlock,
|
|
IN ULONG IoControlCode,
|
|
IN PVOID InputBuffer OPTIONAL,
|
|
IN ULONG InputBufferLength,
|
|
OUT PVOID OutputBuffer OPTIONAL,
|
|
IN ULONG OutputBufferLength
|
|
);
|
|
|
|
|
|
NTSYSAPI
|
|
NTSTATUS
|
|
NTAPI
|
|
NtDelayExecution(
|
|
IN BOOLEAN Alertable,
|
|
IN PLARGE_INTEGER Interval
|
|
);
|
|
|
|
|
|
#define FSCTL_LOCK_VOLUME CTL_CODE(FILE_DEVICE_FILE_SYSTEM, 6, METHOD_BUFFERED, FILE_ANY_ACCESS)
|
|
#define FSCTL_UNLOCK_VOLUME CTL_CODE(FILE_DEVICE_FILE_SYSTEM, 7, METHOD_BUFFERED, FILE_ANY_ACCESS)
|
|
#define FSCTL_DISMOUNT_VOLUME CTL_CODE(FILE_DEVICE_FILE_SYSTEM, 8, METHOD_BUFFERED, FILE_ANY_ACCESS)
|
|
#define FSCTL_IS_VOLUME_MOUNTED CTL_CODE(FILE_DEVICE_FILE_SYSTEM,10, METHOD_BUFFERED, FILE_ANY_ACCESS)
|
|
|
|
|
|
//
|
|
// useful macros
|
|
//
|
|
|
|
#define BooleanFlagOn(Flags,SingleFlag) ((BOOLEAN)((((Flags) & (SingleFlag)) != 0)))
|
|
|
|
|
|
//
|
|
// Include Win32 error codes.
|
|
//
|
|
|
|
#include <winerror.h>
|
|
|
|
//
|
|
// standard stuff
|
|
//
|
|
|
|
#include <assert.h>
|
|
#include <stdio.h>
|
|
#include <string.h>
|
|
#include <stdlib.h>
|
|
#include <malloc.h>
|
|
|
|
#include <linux/types.h>
|
|
#include "ext2_fs.h"
|
|
#include <errno.h>
|
|
|
|
#include "et/com_err.h"
|
|
#include "ext2fs/ext2fs.h"
|
|
#include "ext2fs/ext2_err.h"
|
|
|
|
|
|
|
|
|
|
//
|
|
// For checking structure magic numbers...
|
|
//
|
|
|
|
|
|
#define EXT2_CHECK_MAGIC(struct, code) \
|
|
if ((struct)->magic != (code)) return (code)
|
|
|
|
#define EXT2_ET_MAGIC_NT_IO_CHANNEL 0x10ed
|
|
|
|
|
|
//
|
|
// Private data block
|
|
//
|
|
|
|
typedef struct _NT_PRIVATE_DATA {
|
|
int magic;
|
|
HANDLE Handle;
|
|
int Flags;
|
|
PCHAR Buffer;
|
|
__u32 BufferBlockNumber;
|
|
ULONG BufferSize;
|
|
BOOLEAN OpenedReadonly;
|
|
BOOLEAN Written;
|
|
}NT_PRIVATE_DATA, *PNT_PRIVATE_DATA;
|
|
|
|
|
|
|
|
//
|
|
// Standard interface prototypes
|
|
//
|
|
|
|
static errcode_t nt_open(const char *name, int flags, io_channel *channel);
|
|
static errcode_t nt_close(io_channel channel);
|
|
static errcode_t nt_set_blksize(io_channel channel, int blksize);
|
|
static errcode_t nt_read_blk(io_channel channel, unsigned long block,
|
|
int count, void *data);
|
|
static errcode_t nt_write_blk(io_channel channel, unsigned long block,
|
|
int count, const void *data);
|
|
static errcode_t nt_flush(io_channel channel);
|
|
|
|
static struct struct_io_manager struct_nt_manager = {
|
|
.magic = EXT2_ET_MAGIC_IO_MANAGER,
|
|
.name = "NT I/O Manager",
|
|
.open = nt_open,
|
|
.close = nt_close,
|
|
.set_blksize = nt_set_blksize,
|
|
.read_blk = nt_read_blk,
|
|
.write_blk = nt_write_blk,
|
|
.flush = nt_flush
|
|
};
|
|
|
|
//
|
|
// function to get API
|
|
//
|
|
|
|
io_manager nt_io_manager()
|
|
{
|
|
return &struct_nt_manager;
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
//
|
|
// This is a code to convert Win32 errors to unix errno
|
|
//
|
|
|
|
typedef struct {
|
|
ULONG WinError;
|
|
int errnocode;
|
|
}ERROR_ENTRY;
|
|
|
|
static ERROR_ENTRY ErrorTable[] = {
|
|
{ ERROR_INVALID_FUNCTION, EINVAL },
|
|
{ ERROR_FILE_NOT_FOUND, ENOENT },
|
|
{ ERROR_PATH_NOT_FOUND, ENOENT },
|
|
{ ERROR_TOO_MANY_OPEN_FILES, EMFILE },
|
|
{ ERROR_ACCESS_DENIED, EACCES },
|
|
{ ERROR_INVALID_HANDLE, EBADF },
|
|
{ ERROR_ARENA_TRASHED, ENOMEM },
|
|
{ ERROR_NOT_ENOUGH_MEMORY, ENOMEM },
|
|
{ ERROR_INVALID_BLOCK, ENOMEM },
|
|
{ ERROR_BAD_ENVIRONMENT, E2BIG },
|
|
{ ERROR_BAD_FORMAT, ENOEXEC },
|
|
{ ERROR_INVALID_ACCESS, EINVAL },
|
|
{ ERROR_INVALID_DATA, EINVAL },
|
|
{ ERROR_INVALID_DRIVE, ENOENT },
|
|
{ ERROR_CURRENT_DIRECTORY, EACCES },
|
|
{ ERROR_NOT_SAME_DEVICE, EXDEV },
|
|
{ ERROR_NO_MORE_FILES, ENOENT },
|
|
{ ERROR_LOCK_VIOLATION, EACCES },
|
|
{ ERROR_BAD_NETPATH, ENOENT },
|
|
{ ERROR_NETWORK_ACCESS_DENIED, EACCES },
|
|
{ ERROR_BAD_NET_NAME, ENOENT },
|
|
{ ERROR_FILE_EXISTS, EEXIST },
|
|
{ ERROR_CANNOT_MAKE, EACCES },
|
|
{ ERROR_FAIL_I24, EACCES },
|
|
{ ERROR_INVALID_PARAMETER, EINVAL },
|
|
{ ERROR_NO_PROC_SLOTS, EAGAIN },
|
|
{ ERROR_DRIVE_LOCKED, EACCES },
|
|
{ ERROR_BROKEN_PIPE, EPIPE },
|
|
{ ERROR_DISK_FULL, ENOSPC },
|
|
{ ERROR_INVALID_TARGET_HANDLE, EBADF },
|
|
{ ERROR_INVALID_HANDLE, EINVAL },
|
|
{ ERROR_WAIT_NO_CHILDREN, ECHILD },
|
|
{ ERROR_CHILD_NOT_COMPLETE, ECHILD },
|
|
{ ERROR_DIRECT_ACCESS_HANDLE, EBADF },
|
|
{ ERROR_NEGATIVE_SEEK, EINVAL },
|
|
{ ERROR_SEEK_ON_DEVICE, EACCES },
|
|
{ ERROR_DIR_NOT_EMPTY, ENOTEMPTY },
|
|
{ ERROR_NOT_LOCKED, EACCES },
|
|
{ ERROR_BAD_PATHNAME, ENOENT },
|
|
{ ERROR_MAX_THRDS_REACHED, EAGAIN },
|
|
{ ERROR_LOCK_FAILED, EACCES },
|
|
{ ERROR_ALREADY_EXISTS, EEXIST },
|
|
{ ERROR_FILENAME_EXCED_RANGE, ENOENT },
|
|
{ ERROR_NESTING_NOT_ALLOWED, EAGAIN },
|
|
{ ERROR_NOT_ENOUGH_QUOTA, ENOMEM }
|
|
};
|
|
|
|
|
|
|
|
|
|
static
|
|
unsigned
|
|
_MapDosError (
|
|
IN ULONG WinError
|
|
)
|
|
{
|
|
int i;
|
|
|
|
//
|
|
// Lookup
|
|
//
|
|
|
|
for (i = 0; i < (sizeof(ErrorTable)/sizeof(ErrorTable[0])); ++i)
|
|
{
|
|
if (WinError == ErrorTable[i].WinError)
|
|
{
|
|
return ErrorTable[i].errnocode;
|
|
}
|
|
}
|
|
|
|
//
|
|
// not in table. Check ranges
|
|
//
|
|
|
|
if ((WinError >= ERROR_WRITE_PROTECT) &&
|
|
(WinError <= ERROR_SHARING_BUFFER_EXCEEDED))
|
|
{
|
|
return EACCES;
|
|
}
|
|
else if ((WinError >= ERROR_INVALID_STARTING_CODESEG) &&
|
|
(WinError <= ERROR_INFLOOP_IN_RELOC_CHAIN))
|
|
{
|
|
return ENOEXEC;
|
|
}
|
|
else
|
|
{
|
|
return EINVAL;
|
|
}
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
//
|
|
// Function to map NT status to dos error.
|
|
//
|
|
|
|
static
|
|
__inline
|
|
unsigned
|
|
_MapNtStatus(
|
|
IN NTSTATUS Status
|
|
)
|
|
{
|
|
return _MapDosError(RtlNtStatusToDosError(Status));
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
//
|
|
// Helper functions to make things easier
|
|
//
|
|
|
|
static
|
|
NTSTATUS
|
|
_OpenNtName(
|
|
IN PCSTR Name,
|
|
IN BOOLEAN Readonly,
|
|
OUT PHANDLE Handle,
|
|
OUT PBOOLEAN OpenedReadonly OPTIONAL
|
|
)
|
|
{
|
|
UNICODE_STRING UnicodeString;
|
|
ANSI_STRING AnsiString;
|
|
WCHAR Buffer[512];
|
|
NTSTATUS Status;
|
|
OBJECT_ATTRIBUTES ObjectAttributes;
|
|
IO_STATUS_BLOCK IoStatusBlock;
|
|
|
|
//
|
|
// Make Unicode name from input string
|
|
//
|
|
|
|
UnicodeString.Buffer = &Buffer[0];
|
|
UnicodeString.Length = 0;
|
|
UnicodeString.MaximumLength = sizeof(Buffer); // in bytes!!!
|
|
|
|
RtlInitAnsiString(&AnsiString, Name);
|
|
|
|
Status = RtlAnsiStringToUnicodeString(&UnicodeString, &AnsiString, FALSE);
|
|
|
|
if(!NT_SUCCESS(Status))
|
|
{
|
|
return Status; // Unmappable character?
|
|
}
|
|
|
|
//
|
|
// Initialize object
|
|
//
|
|
|
|
InitializeObjectAttributes(&ObjectAttributes,
|
|
&UnicodeString,
|
|
OBJ_CASE_INSENSITIVE,
|
|
NULL,
|
|
NULL );
|
|
|
|
//
|
|
// Try to open it in initial mode
|
|
//
|
|
|
|
if(ARGUMENT_PRESENT(OpenedReadonly))
|
|
{
|
|
*OpenedReadonly = Readonly;
|
|
}
|
|
|
|
|
|
Status = NtOpenFile(Handle,
|
|
SYNCHRONIZE | FILE_READ_DATA | (Readonly ? 0 : FILE_WRITE_DATA),
|
|
&ObjectAttributes,
|
|
&IoStatusBlock,
|
|
FILE_SHARE_WRITE | FILE_SHARE_READ,
|
|
FILE_SYNCHRONOUS_IO_NONALERT);
|
|
|
|
if(!NT_SUCCESS(Status))
|
|
{
|
|
//
|
|
// Maybe was just mounted? wait 0.5 sec and retry.
|
|
//
|
|
|
|
LARGE_INTEGER Interval;
|
|
Interval.QuadPart = -5000000; // 0.5 sec. from now
|
|
|
|
NtDelayExecution(FALSE, &Interval);
|
|
|
|
Status = NtOpenFile(Handle,
|
|
SYNCHRONIZE | FILE_READ_DATA | (Readonly ? 0 : FILE_WRITE_DATA),
|
|
&ObjectAttributes,
|
|
&IoStatusBlock,
|
|
FILE_SHARE_WRITE | FILE_SHARE_READ,
|
|
FILE_SYNCHRONOUS_IO_NONALERT);
|
|
|
|
//
|
|
// Try to satisfy mode
|
|
//
|
|
|
|
if((STATUS_ACCESS_DENIED == Status) && !Readonly)
|
|
{
|
|
if(ARGUMENT_PRESENT(OpenedReadonly))
|
|
{
|
|
*OpenedReadonly = TRUE;
|
|
}
|
|
|
|
Status = NtOpenFile(Handle,
|
|
SYNCHRONIZE | FILE_READ_DATA,
|
|
&ObjectAttributes,
|
|
&IoStatusBlock,
|
|
FILE_SHARE_WRITE | FILE_SHARE_READ,
|
|
FILE_SYNCHRONOUS_IO_NONALERT);
|
|
}
|
|
}
|
|
|
|
|
|
|
|
//
|
|
// done
|
|
//
|
|
|
|
return Status;
|
|
}
|
|
|
|
|
|
static
|
|
NTSTATUS
|
|
_OpenDriveLetter(
|
|
IN CHAR Letter,
|
|
IN BOOLEAN ReadOnly,
|
|
OUT PHANDLE Handle,
|
|
OUT PBOOLEAN OpenedReadonly OPTIONAL
|
|
)
|
|
{
|
|
CHAR Buffer[100];
|
|
|
|
sprintf(Buffer, "\\DosDevices\\%c:", Letter);
|
|
|
|
return _OpenNtName(Buffer, ReadOnly, Handle, OpenedReadonly);
|
|
}
|
|
|
|
|
|
//
|
|
// Flush device
|
|
//
|
|
|
|
static
|
|
__inline
|
|
NTSTATUS
|
|
_FlushDrive(
|
|
IN HANDLE Handle
|
|
)
|
|
{
|
|
IO_STATUS_BLOCK IoStatusBlock;
|
|
return NtFlushBuffersFile(Handle, &IoStatusBlock);
|
|
}
|
|
|
|
|
|
//
|
|
// lock drive
|
|
//
|
|
|
|
static
|
|
__inline
|
|
NTSTATUS
|
|
_LockDrive(
|
|
IN HANDLE Handle
|
|
)
|
|
{
|
|
IO_STATUS_BLOCK IoStatusBlock;
|
|
return NtFsControlFile(Handle, 0, 0, 0, &IoStatusBlock, FSCTL_LOCK_VOLUME, 0, 0, 0, 0);
|
|
}
|
|
|
|
|
|
//
|
|
// unlock drive
|
|
//
|
|
|
|
static
|
|
__inline
|
|
NTSTATUS
|
|
_UnlockDrive(
|
|
IN HANDLE Handle
|
|
)
|
|
{
|
|
IO_STATUS_BLOCK IoStatusBlock;
|
|
return NtFsControlFile(Handle, 0, 0, 0, &IoStatusBlock, FSCTL_UNLOCK_VOLUME, 0, 0, 0, 0);
|
|
}
|
|
|
|
static
|
|
__inline
|
|
NTSTATUS
|
|
_DismountDrive(
|
|
IN HANDLE Handle
|
|
)
|
|
{
|
|
IO_STATUS_BLOCK IoStatusBlock;
|
|
return NtFsControlFile(Handle, 0, 0, 0, &IoStatusBlock, FSCTL_DISMOUNT_VOLUME, 0, 0, 0, 0);
|
|
}
|
|
|
|
|
|
//
|
|
// is mounted
|
|
//
|
|
|
|
static
|
|
__inline
|
|
BOOLEAN
|
|
_IsMounted(
|
|
IN HANDLE Handle
|
|
)
|
|
{
|
|
IO_STATUS_BLOCK IoStatusBlock;
|
|
NTSTATUS Status;
|
|
Status = NtFsControlFile(Handle, 0, 0, 0, &IoStatusBlock, FSCTL_IS_VOLUME_MOUNTED, 0, 0, 0, 0);
|
|
return (BOOLEAN)(STATUS_SUCCESS == Status);
|
|
}
|
|
|
|
|
|
static
|
|
__inline
|
|
NTSTATUS
|
|
_CloseDisk(
|
|
IN HANDLE Handle
|
|
)
|
|
{
|
|
return NtClose(Handle);
|
|
}
|
|
|
|
|
|
|
|
|
|
//
|
|
// Make NT name from any recognized name
|
|
//
|
|
|
|
static
|
|
PCSTR
|
|
_NormalizeDeviceName(
|
|
IN PCSTR Device,
|
|
IN PSTR NormalizedDeviceNameBuffer
|
|
)
|
|
{
|
|
int PartitionNumber = -1;
|
|
UCHAR DiskNumber;
|
|
PSTR p;
|
|
|
|
|
|
//
|
|
// Do not try to parse NT name
|
|
//
|
|
|
|
if('\\' == *Device)
|
|
return Device;
|
|
|
|
|
|
|
|
//
|
|
// Strip leading '/dev/' if any
|
|
//
|
|
|
|
if(('/' == *(Device)) &&
|
|
('d' == *(Device + 1)) &&
|
|
('e' == *(Device + 2)) &&
|
|
('v' == *(Device + 3)) &&
|
|
('/' == *(Device + 4)))
|
|
{
|
|
Device += 5;
|
|
}
|
|
|
|
if('\0' == *Device)
|
|
{
|
|
return NULL;
|
|
}
|
|
|
|
|
|
//
|
|
// forms: hda[n], fd[n]
|
|
//
|
|
|
|
if('d' != *(Device + 1))
|
|
{
|
|
return NULL;
|
|
}
|
|
|
|
if('h' == *Device)
|
|
{
|
|
if((*(Device + 2) < 'a') || (*(Device + 2) > ('a' + 9)) ||
|
|
((*(Device + 3) != '\0') &&
|
|
((*(Device + 4) != '\0') ||
|
|
((*(Device + 3) < '0') || (*(Device + 3) > '9'))
|
|
)
|
|
)
|
|
)
|
|
{
|
|
return NULL;
|
|
}
|
|
|
|
DiskNumber = (UCHAR)(*(Device + 2) - 'a');
|
|
|
|
if(*(Device + 3) != '\0')
|
|
{
|
|
PartitionNumber = (*(Device + 3) - '0');
|
|
}
|
|
|
|
}
|
|
else if('f' == *Device)
|
|
{
|
|
//
|
|
// 3-d letter should be a digit.
|
|
//
|
|
|
|
if((*(Device + 3) != '\0') ||
|
|
(*(Device + 2) < '0') || (*(Device + 2) > '9'))
|
|
{
|
|
return NULL;
|
|
}
|
|
|
|
DiskNumber = (UCHAR)(*(Device + 2) - '0');
|
|
|
|
}
|
|
else
|
|
{
|
|
//
|
|
// invalid prefix
|
|
//
|
|
|
|
return NULL;
|
|
}
|
|
|
|
|
|
|
|
//
|
|
// Prefix
|
|
//
|
|
|
|
strcpy(NormalizedDeviceNameBuffer, "\\Device\\");
|
|
|
|
//
|
|
// Media name
|
|
//
|
|
|
|
switch(*Device)
|
|
{
|
|
|
|
case 'f':
|
|
strcat(NormalizedDeviceNameBuffer, "Floppy0");
|
|
break;
|
|
|
|
case 'h':
|
|
strcat(NormalizedDeviceNameBuffer, "Harddisk0");
|
|
break;
|
|
}
|
|
|
|
|
|
p = NormalizedDeviceNameBuffer + strlen(NormalizedDeviceNameBuffer) - 1;
|
|
*p = (CHAR)(*p + DiskNumber);
|
|
|
|
|
|
//
|
|
// Partition nr.
|
|
//
|
|
|
|
if(PartitionNumber >= 0)
|
|
{
|
|
strcat(NormalizedDeviceNameBuffer, "\\Partition0");
|
|
|
|
p = NormalizedDeviceNameBuffer + strlen(NormalizedDeviceNameBuffer) - 1;
|
|
*p = (CHAR)(*p + PartitionNumber);
|
|
}
|
|
|
|
|
|
return NormalizedDeviceNameBuffer;
|
|
}
|
|
|
|
|
|
|
|
|
|
static
|
|
VOID
|
|
_GetDeviceSize(
|
|
IN HANDLE h,
|
|
OUT unsigned __int64 *FsSize
|
|
)
|
|
{
|
|
PARTITION_INFORMATION pi;
|
|
DISK_GEOMETRY gi;
|
|
NTSTATUS Status;
|
|
IO_STATUS_BLOCK IoStatusBlock;
|
|
|
|
//
|
|
// Zero it
|
|
//
|
|
|
|
*FsSize = 0;
|
|
|
|
//
|
|
// Call driver
|
|
//
|
|
|
|
RtlZeroMemory(&pi, sizeof(PARTITION_INFORMATION));
|
|
|
|
Status = NtDeviceIoControlFile(
|
|
h, NULL, NULL, NULL, &IoStatusBlock, IOCTL_DISK_GET_PARTITION_INFO,
|
|
&pi, sizeof(PARTITION_INFORMATION),
|
|
&pi, sizeof(PARTITION_INFORMATION));
|
|
|
|
|
|
if(NT_SUCCESS(Status))
|
|
{
|
|
*FsSize = pi.PartitionLength.QuadPart;
|
|
}
|
|
else if(STATUS_INVALID_DEVICE_REQUEST == Status)
|
|
{
|
|
//
|
|
// No partitions: get device info.
|
|
//
|
|
|
|
RtlZeroMemory(&gi, sizeof(DISK_GEOMETRY));
|
|
|
|
Status = NtDeviceIoControlFile(
|
|
h, NULL, NULL, NULL, &IoStatusBlock, IOCTL_DISK_GET_DRIVE_GEOMETRY,
|
|
&gi, sizeof(DISK_GEOMETRY),
|
|
&gi, sizeof(DISK_GEOMETRY));
|
|
|
|
|
|
if(NT_SUCCESS(Status))
|
|
{
|
|
*FsSize =
|
|
gi.BytesPerSector *
|
|
gi.SectorsPerTrack *
|
|
gi.TracksPerCylinder *
|
|
gi.Cylinders.QuadPart;
|
|
}
|
|
|
|
}
|
|
}
|
|
|
|
|
|
|
|
//
|
|
// Open device by name.
|
|
//
|
|
|
|
static
|
|
BOOLEAN
|
|
_Ext2OpenDevice(
|
|
IN PCSTR Name,
|
|
IN BOOLEAN ReadOnly,
|
|
OUT PHANDLE Handle,
|
|
OUT PBOOLEAN OpenedReadonly OPTIONAL,
|
|
OUT unsigned *Errno OPTIONAL
|
|
)
|
|
{
|
|
CHAR NormalizedDeviceName[512];
|
|
NTSTATUS Status;
|
|
|
|
if(NULL == Name)
|
|
{
|
|
//
|
|
// Set not found
|
|
//
|
|
|
|
if(ARGUMENT_PRESENT(Errno))
|
|
*Errno = ENOENT;
|
|
|
|
return FALSE;
|
|
}
|
|
|
|
|
|
if((((*Name) | 0x20) >= 'a') && (((*Name) | 0x20) <= 'z') &&
|
|
(':' == *(Name + 1)) && ('\0' == *(Name + 2)))
|
|
{
|
|
Status = _OpenDriveLetter(*Name, ReadOnly, Handle, OpenedReadonly);
|
|
}
|
|
else
|
|
{
|
|
//
|
|
// Make name
|
|
//
|
|
|
|
Name = _NormalizeDeviceName(Name, NormalizedDeviceName);
|
|
|
|
if(NULL == Name)
|
|
{
|
|
//
|
|
// Set not found
|
|
//
|
|
|
|
if(ARGUMENT_PRESENT(Errno))
|
|
*Errno = ENOENT;
|
|
|
|
return FALSE;
|
|
}
|
|
|
|
//
|
|
// Try to open it
|
|
//
|
|
|
|
Status = _OpenNtName(Name, ReadOnly, Handle, OpenedReadonly);
|
|
}
|
|
|
|
|
|
if(!NT_SUCCESS(Status))
|
|
{
|
|
if(ARGUMENT_PRESENT(Errno))
|
|
*Errno = _MapNtStatus(Status);
|
|
|
|
return FALSE;
|
|
}
|
|
|
|
return TRUE;
|
|
}
|
|
|
|
|
|
//
|
|
// Raw block io. Sets dos errno
|
|
//
|
|
|
|
static
|
|
BOOLEAN
|
|
_BlockIo(
|
|
IN HANDLE Handle,
|
|
IN LARGE_INTEGER Offset,
|
|
IN ULONG Bytes,
|
|
IN OUT PCHAR Buffer,
|
|
IN BOOLEAN Read,
|
|
OUT unsigned* Errno
|
|
)
|
|
{
|
|
IO_STATUS_BLOCK IoStatusBlock;
|
|
NTSTATUS Status;
|
|
|
|
//
|
|
// Should be aligned
|
|
//
|
|
|
|
ASSERT(0 == (Bytes % 512));
|
|
ASSERT(0 == (Offset.LowPart % 512));
|
|
|
|
|
|
//
|
|
// perform io
|
|
//
|
|
|
|
if(Read)
|
|
{
|
|
Status = NtReadFile(Handle, NULL, NULL, NULL,
|
|
&IoStatusBlock, Buffer, Bytes, &Offset, NULL);
|
|
}
|
|
else
|
|
{
|
|
Status = NtWriteFile(Handle, NULL, NULL, NULL,
|
|
&IoStatusBlock, Buffer, Bytes, &Offset, NULL);
|
|
}
|
|
|
|
|
|
//
|
|
// translate error
|
|
//
|
|
|
|
if(NT_SUCCESS(Status))
|
|
{
|
|
*Errno = 0;
|
|
return TRUE;
|
|
}
|
|
|
|
*Errno = _MapNtStatus(Status);
|
|
|
|
return FALSE;
|
|
}
|
|
|
|
|
|
|
|
__inline
|
|
BOOLEAN
|
|
_RawWrite(
|
|
IN HANDLE Handle,
|
|
IN LARGE_INTEGER Offset,
|
|
IN ULONG Bytes,
|
|
OUT const CHAR* Buffer,
|
|
OUT unsigned* Errno
|
|
)
|
|
{
|
|
return _BlockIo(Handle, Offset, Bytes, (PCHAR)Buffer, FALSE, Errno);
|
|
}
|
|
|
|
__inline
|
|
BOOLEAN
|
|
_RawRead(
|
|
IN HANDLE Handle,
|
|
IN LARGE_INTEGER Offset,
|
|
IN ULONG Bytes,
|
|
IN PCHAR Buffer,
|
|
OUT unsigned* Errno
|
|
)
|
|
{
|
|
return _BlockIo(Handle, Offset, Bytes, Buffer, TRUE, Errno);
|
|
}
|
|
|
|
|
|
|
|
__inline
|
|
BOOLEAN
|
|
_SetPartType(
|
|
IN HANDLE Handle,
|
|
IN UCHAR Type
|
|
)
|
|
{
|
|
IO_STATUS_BLOCK IoStatusBlock;
|
|
return STATUS_SUCCESS == NtDeviceIoControlFile(
|
|
Handle, NULL, NULL, NULL, &IoStatusBlock, IOCTL_DISK_SET_PARTITION_INFO,
|
|
&Type, sizeof(Type),
|
|
NULL, 0);
|
|
}
|
|
|
|
|
|
|
|
//--------------------- interface part
|
|
|
|
//
|
|
// Interface functions.
|
|
// Is_mounted is set to 1 if the device is mounted, 0 otherwise
|
|
//
|
|
|
|
errcode_t
|
|
ext2fs_check_if_mounted(const char *file, int *mount_flags)
|
|
{
|
|
HANDLE h;
|
|
BOOLEAN Readonly;
|
|
|
|
*mount_flags = 0;
|
|
|
|
if(!_Ext2OpenDevice(file, TRUE, &h, &Readonly, NULL))
|
|
{
|
|
return 0;
|
|
}
|
|
|
|
|
|
__try{
|
|
*mount_flags &= _IsMounted(h) ? EXT2_MF_MOUNTED : 0;
|
|
}
|
|
__finally{
|
|
_CloseDisk(h);
|
|
}
|
|
|
|
return 0;
|
|
}
|
|
|
|
|
|
|
|
//
|
|
// Returns the number of blocks in a partition
|
|
//
|
|
|
|
static __int64 FsSize = 0;
|
|
static char knowndevice[1024] = "";
|
|
|
|
|
|
errcode_t
|
|
ext2fs_get_device_size(const char *file, int blocksize,
|
|
blk_t *retblocks)
|
|
{
|
|
HANDLE h;
|
|
BOOLEAN Readonly;
|
|
|
|
if((0 == FsSize) || (0 != strcmp(knowndevice, file)))
|
|
{
|
|
|
|
if(!_Ext2OpenDevice(file, TRUE, &h, &Readonly, NULL))
|
|
{
|
|
return 0;
|
|
}
|
|
|
|
|
|
__try{
|
|
|
|
//
|
|
// Get size
|
|
//
|
|
|
|
_GetDeviceSize(h, &FsSize);
|
|
strcpy(knowndevice, file);
|
|
}
|
|
__finally{
|
|
_CloseDisk(h);
|
|
}
|
|
|
|
}
|
|
|
|
*retblocks = (blk_t)(unsigned __int64)(FsSize / blocksize);
|
|
UNREFERENCED_PARAMETER(file);
|
|
return 0;
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
|
|
//
|
|
// Table elements
|
|
//
|
|
|
|
|
|
static
|
|
errcode_t
|
|
nt_open(const char *name, int flags, io_channel *channel)
|
|
{
|
|
io_channel io = NULL;
|
|
PNT_PRIVATE_DATA NtData = NULL;
|
|
errcode_t Errno = 0;
|
|
|
|
//
|
|
// Check name
|
|
//
|
|
|
|
if (NULL == name)
|
|
{
|
|
return EXT2_ET_BAD_DEVICE_NAME;
|
|
}
|
|
|
|
__try{
|
|
|
|
//
|
|
// Allocate channel handle
|
|
//
|
|
|
|
io = (io_channel) malloc(sizeof(struct struct_io_channel));
|
|
|
|
if (NULL == io)
|
|
{
|
|
Errno = ENOMEM;
|
|
__leave;
|
|
}
|
|
|
|
RtlZeroMemory(io, sizeof(struct struct_io_channel));
|
|
io->magic = EXT2_ET_MAGIC_IO_CHANNEL;
|
|
|
|
NtData = (PNT_PRIVATE_DATA)malloc(sizeof(NT_PRIVATE_DATA));
|
|
|
|
if (NULL == NtData)
|
|
{
|
|
Errno = ENOMEM;
|
|
__leave;
|
|
}
|
|
|
|
|
|
io->manager = nt_io_manager();
|
|
io->name = malloc(strlen(name) + 1);
|
|
if (NULL == io->name)
|
|
{
|
|
Errno = ENOMEM;
|
|
__leave;
|
|
}
|
|
|
|
strcpy(io->name, name);
|
|
io->private_data = NtData;
|
|
io->block_size = 1024;
|
|
io->read_error = 0;
|
|
io->write_error = 0;
|
|
io->refcount = 1;
|
|
|
|
//
|
|
// Initialize data
|
|
//
|
|
|
|
RtlZeroMemory(NtData, sizeof(NT_PRIVATE_DATA));
|
|
|
|
NtData->magic = EXT2_ET_MAGIC_NT_IO_CHANNEL;
|
|
NtData->BufferBlockNumber = 0xffffffff;
|
|
NtData->BufferSize = 1024;
|
|
NtData->Buffer = malloc(NtData->BufferSize);
|
|
|
|
if (NULL == NtData->Buffer)
|
|
{
|
|
Errno = ENOMEM;
|
|
__leave;
|
|
}
|
|
|
|
//
|
|
// Open it
|
|
//
|
|
|
|
if(!_Ext2OpenDevice(name, (BOOLEAN)!BooleanFlagOn(flags, EXT2_FLAG_RW), &NtData->Handle, &NtData->OpenedReadonly, &Errno))
|
|
{
|
|
__leave;
|
|
}
|
|
|
|
|
|
//
|
|
// get size
|
|
//
|
|
|
|
_GetDeviceSize(NtData->Handle, &FsSize);
|
|
strcpy(knowndevice, name);
|
|
|
|
|
|
//
|
|
// Lock/dismount
|
|
//
|
|
|
|
if(!NT_SUCCESS(_LockDrive(NtData->Handle)) /*|| !NT_SUCCESS(_DismountDrive(NtData->Handle))*/)
|
|
{
|
|
NtData->OpenedReadonly = TRUE;
|
|
}
|
|
|
|
//
|
|
// Done
|
|
//
|
|
|
|
*channel = io;
|
|
|
|
|
|
}
|
|
__finally{
|
|
|
|
if(0 != Errno)
|
|
{
|
|
//
|
|
// Cleanup
|
|
//
|
|
|
|
if (NULL != io)
|
|
{
|
|
free(io->name);
|
|
free(io);
|
|
}
|
|
|
|
if (NULL != NtData)
|
|
{
|
|
if(NULL != NtData->Handle)
|
|
{
|
|
_UnlockDrive(NtData->Handle);
|
|
_CloseDisk(NtData->Handle);
|
|
}
|
|
|
|
free(NtData->Buffer);
|
|
free(NtData);
|
|
}
|
|
}
|
|
}
|
|
|
|
return Errno;
|
|
}
|
|
|
|
|
|
//
|
|
// Close api
|
|
//
|
|
|
|
static
|
|
errcode_t
|
|
nt_close(io_channel channel)
|
|
{
|
|
PNT_PRIVATE_DATA NtData = NULL;
|
|
|
|
if(NULL == channel)
|
|
{
|
|
return 0;
|
|
}
|
|
|
|
EXT2_CHECK_MAGIC(channel, EXT2_ET_MAGIC_IO_CHANNEL);
|
|
NtData = (PNT_PRIVATE_DATA) channel->private_data;
|
|
EXT2_CHECK_MAGIC(NtData, EXT2_ET_MAGIC_NT_IO_CHANNEL);
|
|
|
|
if (--channel->refcount > 0)
|
|
{
|
|
return 0;
|
|
}
|
|
|
|
free(channel->name);
|
|
free(channel);
|
|
|
|
if (NULL != NtData)
|
|
{
|
|
if(NULL != NtData->Handle)
|
|
{
|
|
_DismountDrive(NtData->Handle);
|
|
_UnlockDrive(NtData->Handle);
|
|
_CloseDisk(NtData->Handle);
|
|
}
|
|
|
|
free(NtData->Buffer);
|
|
free(NtData);
|
|
}
|
|
|
|
return 0;
|
|
}
|
|
|
|
|
|
|
|
//
|
|
// set block size
|
|
//
|
|
|
|
static
|
|
errcode_t
|
|
nt_set_blksize(io_channel channel, int blksize)
|
|
{
|
|
PNT_PRIVATE_DATA NtData = NULL;
|
|
|
|
EXT2_CHECK_MAGIC(channel, EXT2_ET_MAGIC_IO_CHANNEL);
|
|
NtData = (PNT_PRIVATE_DATA) channel->private_data;
|
|
EXT2_CHECK_MAGIC(NtData, EXT2_ET_MAGIC_NT_IO_CHANNEL);
|
|
|
|
if (channel->block_size != blksize)
|
|
{
|
|
channel->block_size = blksize;
|
|
|
|
free(NtData->Buffer);
|
|
NtData->BufferBlockNumber = 0xffffffff;
|
|
NtData->BufferSize = channel->block_size;
|
|
ASSERT(0 == (NtData->BufferSize % 512));
|
|
|
|
NtData->Buffer = malloc(NtData->BufferSize);
|
|
|
|
if (NULL == NtData->Buffer)
|
|
{
|
|
return ENOMEM;
|
|
}
|
|
|
|
}
|
|
|
|
return 0;
|
|
}
|
|
|
|
|
|
//
|
|
// read block
|
|
//
|
|
|
|
static
|
|
errcode_t
|
|
nt_read_blk(io_channel channel, unsigned long block,
|
|
int count, void *buf)
|
|
{
|
|
PVOID BufferToRead;
|
|
ULONG SizeToRead;
|
|
ULONG Size;
|
|
LARGE_INTEGER Offset;
|
|
PNT_PRIVATE_DATA NtData = NULL;
|
|
unsigned Errno = 0;
|
|
|
|
EXT2_CHECK_MAGIC(channel, EXT2_ET_MAGIC_IO_CHANNEL);
|
|
NtData = (PNT_PRIVATE_DATA) channel->private_data;
|
|
EXT2_CHECK_MAGIC(NtData, EXT2_ET_MAGIC_NT_IO_CHANNEL);
|
|
|
|
//
|
|
// If it's in the cache, use it!
|
|
//
|
|
|
|
if ((1 == count) &&
|
|
(block == NtData->BufferBlockNumber) &&
|
|
(NtData->BufferBlockNumber != 0xffffffff))
|
|
{
|
|
memcpy(buf, NtData->Buffer, channel->block_size);
|
|
return 0;
|
|
}
|
|
|
|
Size = (count < 0) ? (ULONG)(-count) : (ULONG)(count * channel->block_size);
|
|
|
|
Offset.QuadPart = block * channel->block_size;
|
|
|
|
//
|
|
// If not fit to the block
|
|
//
|
|
|
|
if(Size <= NtData->BufferSize)
|
|
{
|
|
//
|
|
// Update the cache
|
|
//
|
|
|
|
NtData->BufferBlockNumber = block;
|
|
BufferToRead = NtData->Buffer;
|
|
SizeToRead = NtData->BufferSize;
|
|
}
|
|
else
|
|
{
|
|
SizeToRead = Size;
|
|
BufferToRead = buf;
|
|
ASSERT(0 == (SizeToRead % channel->block_size));
|
|
}
|
|
|
|
if(!_RawRead(NtData->Handle, Offset, SizeToRead, BufferToRead, &Errno))
|
|
{
|
|
|
|
if (channel->read_error)
|
|
{
|
|
return (channel->read_error)(channel, block, count, buf,
|
|
Size, 0, Errno);
|
|
}
|
|
else
|
|
{
|
|
return Errno;
|
|
}
|
|
}
|
|
|
|
|
|
if(BufferToRead != buf)
|
|
{
|
|
ASSERT(Size <= SizeToRead);
|
|
memcpy(buf, BufferToRead, Size);
|
|
}
|
|
|
|
return 0;
|
|
}
|
|
|
|
|
|
//
|
|
// write block
|
|
//
|
|
|
|
static
|
|
errcode_t
|
|
nt_write_blk(io_channel channel, unsigned long block,
|
|
int count, const void *buf)
|
|
{
|
|
ULONG SizeToWrite;
|
|
LARGE_INTEGER Offset;
|
|
PNT_PRIVATE_DATA NtData = NULL;
|
|
unsigned Errno = 0;
|
|
|
|
EXT2_CHECK_MAGIC(channel, EXT2_ET_MAGIC_IO_CHANNEL);
|
|
NtData = (PNT_PRIVATE_DATA) channel->private_data;
|
|
EXT2_CHECK_MAGIC(NtData, EXT2_ET_MAGIC_NT_IO_CHANNEL);
|
|
|
|
if(NtData->OpenedReadonly)
|
|
{
|
|
return EACCES;
|
|
}
|
|
|
|
if (count == 1)
|
|
{
|
|
SizeToWrite = channel->block_size;
|
|
}
|
|
else
|
|
{
|
|
NtData->BufferBlockNumber = 0xffffffff;
|
|
|
|
if (count < 0)
|
|
{
|
|
SizeToWrite = (ULONG)(-count);
|
|
}
|
|
else
|
|
{
|
|
SizeToWrite = (ULONG)(count * channel->block_size);
|
|
}
|
|
}
|
|
|
|
|
|
ASSERT(0 == (SizeToWrite % 512));
|
|
Offset.QuadPart = block * channel->block_size;
|
|
|
|
if(!_RawWrite(NtData->Handle, Offset, SizeToWrite, buf, &Errno))
|
|
{
|
|
if (channel->write_error)
|
|
{
|
|
return (channel->write_error)(channel, block, count, buf,
|
|
SizeToWrite, 0, Errno);
|
|
}
|
|
else
|
|
{
|
|
return Errno;
|
|
}
|
|
}
|
|
|
|
|
|
//
|
|
// Stash a copy.
|
|
//
|
|
|
|
if(SizeToWrite >= NtData->BufferSize)
|
|
{
|
|
NtData->BufferBlockNumber = block;
|
|
memcpy(NtData->Buffer, buf, NtData->BufferSize);
|
|
}
|
|
|
|
NtData->Written = TRUE;
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
//
|
|
// Flush data buffers to disk. Since we are currently using a
|
|
// write-through cache, this is a no-op.
|
|
//
|
|
|
|
static
|
|
errcode_t
|
|
nt_flush(io_channel channel)
|
|
{
|
|
PNT_PRIVATE_DATA NtData = NULL;
|
|
|
|
EXT2_CHECK_MAGIC(channel, EXT2_ET_MAGIC_IO_CHANNEL);
|
|
NtData = (PNT_PRIVATE_DATA) channel->private_data;
|
|
EXT2_CHECK_MAGIC(NtData, EXT2_ET_MAGIC_NT_IO_CHANNEL);
|
|
|
|
if(NtData->OpenedReadonly)
|
|
{
|
|
return 0; // EACCESS;
|
|
}
|
|
|
|
|
|
//
|
|
// Flush file buffers.
|
|
//
|
|
|
|
_FlushDrive(NtData->Handle);
|
|
|
|
|
|
//
|
|
// Test and correct partition type.
|
|
//
|
|
|
|
if(NtData->Written)
|
|
{
|
|
_SetPartType(NtData->Handle, 0x83);
|
|
}
|
|
|
|
return 0;
|
|
}
|
|
|
|
|