Home | History | Annotate | Download | only in ext2fs
      1 /*
      2  * nt_io.c --- This is the Nt I/O interface to the I/O manager.
      3  *
      4  * Implements a one-block write-through cache.
      5  *
      6  * Copyright (C) 1993, 1994, 1995 Theodore Ts'o.
      7  * Copyright (C) 1998 Andrey Shedel (andreys (at) ns.cr.cyco.com)
      8  *
      9  * %Begin-Header%
     10  * This file may be redistributed under the terms of the GNU Library
     11  * General Public License, version 2.
     12  * %End-Header%
     13  */
     14 
     15 #ifdef HAVE_CONFIG_H
     16 #include "config.h"
     17 #endif
     18 
     19 
     20 //
     21 // I need some warnings to disable...
     22 //
     23 
     24 
     25 #pragma warning(disable:4514) // unreferenced inline function has been removed
     26 #pragma warning(push,4)
     27 
     28 #pragma warning(disable:4201) // nonstandard extension used : nameless struct/union)
     29 #pragma warning(disable:4214) // nonstandard extension used : bit field types other than int
     30 #pragma warning(disable:4115) // named type definition in parentheses
     31 
     32 #include <ntddk.h>
     33 #include <ntdddisk.h>
     34 #include <ntstatus.h>
     35 
     36 #pragma warning(pop)
     37 
     38 
     39 //
     40 // Some native APIs.
     41 //
     42 
     43 NTSYSAPI
     44 ULONG
     45 NTAPI
     46 RtlNtStatusToDosError(
     47     IN NTSTATUS Status
     48    );
     49 
     50 NTSYSAPI
     51 NTSTATUS
     52 NTAPI
     53 NtClose(
     54     IN HANDLE Handle
     55    );
     56 
     57 
     58 NTSYSAPI
     59 NTSTATUS
     60 NTAPI
     61 NtOpenFile(
     62     OUT PHANDLE FileHandle,
     63     IN ACCESS_MASK DesiredAccess,
     64     IN POBJECT_ATTRIBUTES ObjectAttributes,
     65     OUT PIO_STATUS_BLOCK IoStatusBlock,
     66     IN ULONG ShareAccess,
     67     IN ULONG OpenOptions
     68     );
     69 
     70 NTSYSAPI
     71 NTSTATUS
     72 NTAPI
     73 NtFlushBuffersFile(
     74     IN HANDLE FileHandle,
     75     OUT PIO_STATUS_BLOCK IoStatusBlock
     76    );
     77 
     78 
     79 NTSYSAPI
     80 NTSTATUS
     81 NTAPI
     82 NtReadFile(
     83     IN HANDLE FileHandle,
     84     IN HANDLE Event OPTIONAL,
     85     IN PIO_APC_ROUTINE ApcRoutine OPTIONAL,
     86     IN PVOID ApcContext OPTIONAL,
     87     OUT PIO_STATUS_BLOCK IoStatusBlock,
     88     OUT PVOID Buffer,
     89     IN ULONG Length,
     90     IN PLARGE_INTEGER ByteOffset OPTIONAL,
     91     IN PULONG Key OPTIONAL
     92     );
     93 
     94 NTSYSAPI
     95 NTSTATUS
     96 NTAPI
     97 NtWriteFile(
     98     IN HANDLE FileHandle,
     99     IN HANDLE Event OPTIONAL,
    100     IN PIO_APC_ROUTINE ApcRoutine OPTIONAL,
    101     IN PVOID ApcContext OPTIONAL,
    102     OUT PIO_STATUS_BLOCK IoStatusBlock,
    103     IN PVOID Buffer,
    104     IN ULONG Length,
    105     IN PLARGE_INTEGER ByteOffset OPTIONAL,
    106     IN PULONG Key OPTIONAL
    107     );
    108 
    109 NTSYSAPI
    110 NTSTATUS
    111 NTAPI
    112 NtDeviceIoControlFile(
    113     IN HANDLE FileHandle,
    114     IN HANDLE Event OPTIONAL,
    115     IN PIO_APC_ROUTINE ApcRoutine OPTIONAL,
    116     IN PVOID ApcContext OPTIONAL,
    117     OUT PIO_STATUS_BLOCK IoStatusBlock,
    118     IN ULONG IoControlCode,
    119     IN PVOID InputBuffer OPTIONAL,
    120     IN ULONG InputBufferLength,
    121     OUT PVOID OutputBuffer OPTIONAL,
    122     IN ULONG OutputBufferLength
    123     );
    124 
    125 NTSYSAPI
    126 NTSTATUS
    127 NTAPI
    128 NtFsControlFile(
    129     IN HANDLE FileHandle,
    130     IN HANDLE Event OPTIONAL,
    131     IN PIO_APC_ROUTINE ApcRoutine OPTIONAL,
    132     IN PVOID ApcContext OPTIONAL,
    133     OUT PIO_STATUS_BLOCK IoStatusBlock,
    134     IN ULONG IoControlCode,
    135     IN PVOID InputBuffer OPTIONAL,
    136     IN ULONG InputBufferLength,
    137     OUT PVOID OutputBuffer OPTIONAL,
    138     IN ULONG OutputBufferLength
    139     );
    140 
    141 
    142 NTSYSAPI
    143 NTSTATUS
    144 NTAPI
    145 NtDelayExecution(
    146     IN BOOLEAN Alertable,
    147     IN PLARGE_INTEGER Interval
    148     );
    149 
    150 
    151 #define FSCTL_LOCK_VOLUME               CTL_CODE(FILE_DEVICE_FILE_SYSTEM, 6, METHOD_BUFFERED, FILE_ANY_ACCESS)
    152 #define FSCTL_UNLOCK_VOLUME             CTL_CODE(FILE_DEVICE_FILE_SYSTEM, 7, METHOD_BUFFERED, FILE_ANY_ACCESS)
    153 #define FSCTL_DISMOUNT_VOLUME           CTL_CODE(FILE_DEVICE_FILE_SYSTEM, 8, METHOD_BUFFERED, FILE_ANY_ACCESS)
    154 #define FSCTL_IS_VOLUME_MOUNTED         CTL_CODE(FILE_DEVICE_FILE_SYSTEM,10, METHOD_BUFFERED, FILE_ANY_ACCESS)
    155 
    156 
    157 //
    158 // useful macros
    159 //
    160 
    161 #define BooleanFlagOn(Flags,SingleFlag) ((BOOLEAN)((((Flags) & (SingleFlag)) != 0)))
    162 
    163 
    164 //
    165 // Include Win32 error codes.
    166 //
    167 
    168 #include <winerror.h>
    169 
    170 //
    171 // standard stuff
    172 //
    173 
    174 #include <assert.h>
    175 #include <stdio.h>
    176 #include <string.h>
    177 #include <stdlib.h>
    178 #include <malloc.h>
    179 
    180 #include <linux/types.h>
    181 #include "ext2_fs.h"
    182 #include <errno.h>
    183 
    184 #include "et/com_err.h"
    185 #include "ext2fs/ext2fs.h"
    186 #include "ext2fs/ext2_err.h"
    187 
    188 
    189 
    190 
    191 //
    192 // For checking structure magic numbers...
    193 //
    194 
    195 
    196 #define EXT2_CHECK_MAGIC(struct, code) \
    197 	  if ((struct)->magic != (code)) return (code)
    198 
    199 #define EXT2_ET_MAGIC_NT_IO_CHANNEL  0x10ed
    200 
    201 
    202 //
    203 // Private data block
    204 //
    205 
    206 typedef struct _NT_PRIVATE_DATA {
    207 	int	   magic;
    208 	HANDLE Handle;
    209 	int	   Flags;
    210 	PCHAR  Buffer;
    211 	__u32  BufferBlockNumber;
    212 	ULONG  BufferSize;
    213 	BOOLEAN OpenedReadonly;
    214 	BOOLEAN Written;
    215 }NT_PRIVATE_DATA, *PNT_PRIVATE_DATA;
    216 
    217 
    218 
    219 //
    220 // Standard interface prototypes
    221 //
    222 
    223 static errcode_t nt_open(const char *name, int flags, io_channel *channel);
    224 static errcode_t nt_close(io_channel channel);
    225 static errcode_t nt_set_blksize(io_channel channel, int blksize);
    226 static errcode_t nt_read_blk(io_channel channel, unsigned long block,
    227 			       int count, void *data);
    228 static errcode_t nt_write_blk(io_channel channel, unsigned long block,
    229 				int count, const void *data);
    230 static errcode_t nt_flush(io_channel channel);
    231 
    232 static struct struct_io_manager struct_nt_manager = {
    233 	.magic		= EXT2_ET_MAGIC_IO_MANAGER,
    234 	.name		= "NT I/O Manager",
    235 	.open		= nt_open,
    236 	.close		= nt_close,
    237 	.set_blksize	= nt_set_blksize,
    238 	.read_blk	= nt_read_blk,
    239 	.write_blk	= nt_write_blk,
    240 	.flush		= nt_flush
    241 };
    242 
    243 //
    244 // function to get API
    245 //
    246 
    247 io_manager nt_io_manager()
    248 {
    249 	return &struct_nt_manager;
    250 }
    251 
    252 
    253 
    254 
    255 
    256 //
    257 // This is a code to convert Win32 errors to unix errno
    258 //
    259 
    260 typedef struct {
    261 	ULONG WinError;
    262 	int errnocode;
    263 }ERROR_ENTRY;
    264 
    265 static ERROR_ENTRY ErrorTable[] = {
    266         {  ERROR_INVALID_FUNCTION,       EINVAL    },
    267         {  ERROR_FILE_NOT_FOUND,         ENOENT    },
    268         {  ERROR_PATH_NOT_FOUND,         ENOENT    },
    269         {  ERROR_TOO_MANY_OPEN_FILES,    EMFILE    },
    270         {  ERROR_ACCESS_DENIED,          EACCES    },
    271         {  ERROR_INVALID_HANDLE,         EBADF     },
    272         {  ERROR_ARENA_TRASHED,          ENOMEM    },
    273         {  ERROR_NOT_ENOUGH_MEMORY,      ENOMEM    },
    274         {  ERROR_INVALID_BLOCK,          ENOMEM    },
    275         {  ERROR_BAD_ENVIRONMENT,        E2BIG     },
    276         {  ERROR_BAD_FORMAT,             ENOEXEC   },
    277         {  ERROR_INVALID_ACCESS,         EINVAL    },
    278         {  ERROR_INVALID_DATA,           EINVAL    },
    279         {  ERROR_INVALID_DRIVE,          ENOENT    },
    280         {  ERROR_CURRENT_DIRECTORY,      EACCES    },
    281         {  ERROR_NOT_SAME_DEVICE,        EXDEV     },
    282         {  ERROR_NO_MORE_FILES,          ENOENT    },
    283         {  ERROR_LOCK_VIOLATION,         EACCES    },
    284         {  ERROR_BAD_NETPATH,            ENOENT    },
    285         {  ERROR_NETWORK_ACCESS_DENIED,  EACCES    },
    286         {  ERROR_BAD_NET_NAME,           ENOENT    },
    287         {  ERROR_FILE_EXISTS,            EEXIST    },
    288         {  ERROR_CANNOT_MAKE,            EACCES    },
    289         {  ERROR_FAIL_I24,               EACCES    },
    290         {  ERROR_INVALID_PARAMETER,      EINVAL    },
    291         {  ERROR_NO_PROC_SLOTS,          EAGAIN    },
    292         {  ERROR_DRIVE_LOCKED,           EACCES    },
    293         {  ERROR_BROKEN_PIPE,            EPIPE     },
    294         {  ERROR_DISK_FULL,              ENOSPC    },
    295         {  ERROR_INVALID_TARGET_HANDLE,  EBADF     },
    296         {  ERROR_INVALID_HANDLE,         EINVAL    },
    297         {  ERROR_WAIT_NO_CHILDREN,       ECHILD    },
    298         {  ERROR_CHILD_NOT_COMPLETE,     ECHILD    },
    299         {  ERROR_DIRECT_ACCESS_HANDLE,   EBADF     },
    300         {  ERROR_NEGATIVE_SEEK,          EINVAL    },
    301         {  ERROR_SEEK_ON_DEVICE,         EACCES    },
    302         {  ERROR_DIR_NOT_EMPTY,          ENOTEMPTY },
    303         {  ERROR_NOT_LOCKED,             EACCES    },
    304         {  ERROR_BAD_PATHNAME,           ENOENT    },
    305         {  ERROR_MAX_THRDS_REACHED,      EAGAIN    },
    306         {  ERROR_LOCK_FAILED,            EACCES    },
    307         {  ERROR_ALREADY_EXISTS,         EEXIST    },
    308         {  ERROR_FILENAME_EXCED_RANGE,   ENOENT    },
    309         {  ERROR_NESTING_NOT_ALLOWED,    EAGAIN    },
    310         {  ERROR_NOT_ENOUGH_QUOTA,       ENOMEM    }
    311 };
    312 
    313 
    314 
    315 
    316 static
    317 unsigned
    318 _MapDosError (
    319     IN ULONG WinError
    320    )
    321 {
    322 	int i;
    323 
    324 	//
    325 	// Lookup
    326 	//
    327 
    328 	for (i = 0; i < (sizeof(ErrorTable)/sizeof(ErrorTable[0])); ++i)
    329 	{
    330 		if (WinError == ErrorTable[i].WinError)
    331 		{
    332 			return ErrorTable[i].errnocode;
    333 		}
    334 	}
    335 
    336 	//
    337 	// not in table. Check ranges
    338 	//
    339 
    340 	if ((WinError >= ERROR_WRITE_PROTECT) &&
    341 		(WinError <= ERROR_SHARING_BUFFER_EXCEEDED))
    342 	{
    343 		return EACCES;
    344 	}
    345 	else if ((WinError >= ERROR_INVALID_STARTING_CODESEG) &&
    346 			 (WinError <= ERROR_INFLOOP_IN_RELOC_CHAIN))
    347 	{
    348 		return ENOEXEC;
    349 	}
    350 	else
    351 	{
    352 		return EINVAL;
    353 	}
    354 }
    355 
    356 
    357 
    358 
    359 
    360 
    361 
    362 //
    363 // Function to map NT status to dos error.
    364 //
    365 
    366 static
    367 __inline
    368 unsigned
    369 _MapNtStatus(
    370     IN NTSTATUS Status
    371    )
    372 {
    373 	return _MapDosError(RtlNtStatusToDosError(Status));
    374 }
    375 
    376 
    377 
    378 
    379 
    380 //
    381 // Helper functions to make things easyer
    382 //
    383 
    384 static
    385 NTSTATUS
    386 _OpenNtName(
    387     IN PCSTR Name,
    388     IN BOOLEAN Readonly,
    389     OUT PHANDLE Handle,
    390     OUT PBOOLEAN OpenedReadonly OPTIONAL
    391    )
    392 {
    393 	UNICODE_STRING UnicodeString;
    394 	ANSI_STRING    AnsiString;
    395 	WCHAR Buffer[512];
    396 	NTSTATUS Status;
    397 	OBJECT_ATTRIBUTES ObjectAttributes;
    398 	IO_STATUS_BLOCK IoStatusBlock;
    399 
    400 	//
    401 	// Make Unicode name from inlut string
    402 	//
    403 
    404 	UnicodeString.Buffer = &Buffer[0];
    405 	UnicodeString.Length = 0;
    406 	UnicodeString.MaximumLength = sizeof(Buffer); // in bytes!!!
    407 
    408 	RtlInitAnsiString(&AnsiString, Name);
    409 
    410 	Status = RtlAnsiStringToUnicodeString(&UnicodeString, &AnsiString, FALSE);
    411 
    412 	if(!NT_SUCCESS(Status))
    413 	{
    414 		return Status; // Unpappable character?
    415 	}
    416 
    417 	//
    418 	// Initialize object
    419 	//
    420 
    421 	InitializeObjectAttributes(&ObjectAttributes,
    422 							   &UnicodeString,
    423 							   OBJ_CASE_INSENSITIVE,
    424 							   NULL,
    425 							   NULL );
    426 
    427 	//
    428 	// Try to open it in initial mode
    429 	//
    430 
    431 	if(ARGUMENT_PRESENT(OpenedReadonly))
    432 	{
    433 		*OpenedReadonly = Readonly;
    434 	}
    435 
    436 
    437 	Status = NtOpenFile(Handle,
    438 						SYNCHRONIZE | FILE_READ_DATA | (Readonly ? 0 : FILE_WRITE_DATA),
    439 						&ObjectAttributes,
    440 						&IoStatusBlock,
    441 						FILE_SHARE_WRITE | FILE_SHARE_READ,
    442 						FILE_SYNCHRONOUS_IO_NONALERT);
    443 
    444 	if(!NT_SUCCESS(Status))
    445 	{
    446 		//
    447 		// Maybe was just mounted? wait 0.5 sec and retry.
    448 		//
    449 
    450 		LARGE_INTEGER Interval;
    451 		Interval.QuadPart = -5000000; // 0.5 sec. from now
    452 
    453 		NtDelayExecution(FALSE, &Interval);
    454 
    455 		Status = NtOpenFile(Handle,
    456 							SYNCHRONIZE | FILE_READ_DATA | (Readonly ? 0 : FILE_WRITE_DATA),
    457 							&ObjectAttributes,
    458 							&IoStatusBlock,
    459 							FILE_SHARE_WRITE | FILE_SHARE_READ,
    460 							FILE_SYNCHRONOUS_IO_NONALERT);
    461 
    462 		//
    463 		// Try to satisfy mode
    464 		//
    465 
    466 		if((STATUS_ACCESS_DENIED == Status) && !Readonly)
    467 		{
    468 			if(ARGUMENT_PRESENT(OpenedReadonly))
    469 			{
    470 				*OpenedReadonly = TRUE;
    471 			}
    472 
    473 			Status = NtOpenFile(Handle,
    474 							SYNCHRONIZE | FILE_READ_DATA,
    475 							&ObjectAttributes,
    476 							&IoStatusBlock,
    477 							FILE_SHARE_WRITE | FILE_SHARE_READ,
    478 							FILE_SYNCHRONOUS_IO_NONALERT);
    479 		}
    480 	}
    481 
    482 
    483 
    484 	//
    485 	// done
    486 	//
    487 
    488 	return Status;
    489 }
    490 
    491 
    492 static
    493 NTSTATUS
    494 _OpenDriveLetter(
    495     IN CHAR Letter,
    496     IN BOOLEAN ReadOnly,
    497     OUT PHANDLE Handle,
    498     OUT PBOOLEAN OpenedReadonly OPTIONAL
    499    )
    500 {
    501 	CHAR Buffer[100];
    502 
    503 	sprintf(Buffer, "\\DosDevices\\%c:", Letter);
    504 
    505 	return _OpenNtName(Buffer, ReadOnly, Handle, OpenedReadonly);
    506 }
    507 
    508 
    509 //
    510 // Flush device
    511 //
    512 
    513 static
    514 __inline
    515 NTSTATUS
    516 _FlushDrive(
    517 		IN HANDLE Handle
    518 		)
    519 {
    520 	IO_STATUS_BLOCK IoStatusBlock;
    521 	return NtFlushBuffersFile(Handle, &IoStatusBlock);
    522 }
    523 
    524 
    525 //
    526 // lock drive
    527 //
    528 
    529 static
    530 __inline
    531 NTSTATUS
    532 _LockDrive(
    533 		IN HANDLE Handle
    534 		)
    535 {
    536 	IO_STATUS_BLOCK IoStatusBlock;
    537 	return NtFsControlFile(Handle, 0, 0, 0, &IoStatusBlock, FSCTL_LOCK_VOLUME, 0, 0, 0, 0);
    538 }
    539 
    540 
    541 //
    542 // unlock drive
    543 //
    544 
    545 static
    546 __inline
    547 NTSTATUS
    548 _UnlockDrive(
    549 	IN HANDLE Handle
    550 	)
    551 {
    552 	IO_STATUS_BLOCK IoStatusBlock;
    553 	return NtFsControlFile(Handle, 0, 0, 0, &IoStatusBlock, FSCTL_UNLOCK_VOLUME, 0, 0, 0, 0);
    554 }
    555 
    556 static
    557 __inline
    558 NTSTATUS
    559 _DismountDrive(
    560 	IN HANDLE Handle
    561 	)
    562 {
    563 	IO_STATUS_BLOCK IoStatusBlock;
    564 	return NtFsControlFile(Handle, 0, 0, 0, &IoStatusBlock, FSCTL_DISMOUNT_VOLUME, 0, 0, 0, 0);
    565 }
    566 
    567 
    568 //
    569 // is mounted
    570 //
    571 
    572 static
    573 __inline
    574 BOOLEAN
    575 _IsMounted(
    576 	IN HANDLE Handle
    577 	)
    578 {
    579 	IO_STATUS_BLOCK IoStatusBlock;
    580 	NTSTATUS Status;
    581 	Status = NtFsControlFile(Handle, 0, 0, 0, &IoStatusBlock, FSCTL_IS_VOLUME_MOUNTED, 0, 0, 0, 0);
    582 	return (BOOLEAN)(STATUS_SUCCESS == Status);
    583 }
    584 
    585 
    586 static
    587 __inline
    588 NTSTATUS
    589 _CloseDisk(
    590 		IN HANDLE Handle
    591 		)
    592 {
    593 	return NtClose(Handle);
    594 }
    595 
    596 
    597 
    598 
    599 //
    600 // Make NT name from any recognized name
    601 //
    602 
    603 static
    604 PCSTR
    605 _NormalizeDeviceName(
    606     IN PCSTR Device,
    607     IN PSTR NormalizedDeviceNameBuffer
    608    )
    609 {
    610 	int PartitionNumber = -1;
    611 	UCHAR DiskNumber;
    612 	PSTR p;
    613 
    614 
    615 	//
    616 	// Do not try to parse NT name
    617 	//
    618 
    619 	if('\\' == *Device)
    620 		return Device;
    621 
    622 
    623 
    624 	//
    625 	// Strip leading '/dev/' if any
    626 	//
    627 
    628 	if(('/' == *(Device)) &&
    629 		('d' == *(Device + 1)) &&
    630 		('e' == *(Device + 2)) &&
    631 		('v' == *(Device + 3)) &&
    632 		('/' == *(Device + 4)))
    633 	{
    634 		Device += 5;
    635 	}
    636 
    637 	if('\0' == *Device)
    638 	{
    639 		return NULL;
    640 	}
    641 
    642 
    643 	//
    644 	// forms: hda[n], fd[n]
    645 	//
    646 
    647 	if('d' != *(Device + 1))
    648 	{
    649 		return NULL;
    650 	}
    651 
    652 	if('h' == *Device)
    653 	{
    654 		if((*(Device + 2) < 'a') || (*(Device + 2) > ('a' + 9)) ||
    655 		   ((*(Device + 3) != '\0') &&
    656 			((*(Device + 4) != '\0') ||
    657 			 ((*(Device + 3) < '0') || (*(Device + 3) > '9'))
    658 			)
    659 		   )
    660 		  )
    661 		{
    662 			return NULL;
    663 		}
    664 
    665 		DiskNumber = (UCHAR)(*(Device + 2) - 'a');
    666 
    667 		if(*(Device + 3) != '\0')
    668 		{
    669 			PartitionNumber = (*(Device + 3) - '0');
    670 		}
    671 
    672 	}
    673 	else if('f' == *Device)
    674 	{
    675 		//
    676 		// 3-d letted should be a digit.
    677 		//
    678 
    679 		if((*(Device + 3) != '\0') ||
    680 		   (*(Device + 2) < '0') || (*(Device + 2) > '9'))
    681 		{
    682 			return NULL;
    683 		}
    684 
    685 		DiskNumber = (UCHAR)(*(Device + 2) - '0');
    686 
    687 	}
    688 	else
    689 	{
    690 		//
    691 		// invalid prefix
    692 		//
    693 
    694 		return NULL;
    695 	}
    696 
    697 
    698 
    699 	//
    700 	// Prefix
    701 	//
    702 
    703 	strcpy(NormalizedDeviceNameBuffer, "\\Device\\");
    704 
    705 	//
    706 	// Media name
    707 	//
    708 
    709 	switch(*Device)
    710 	{
    711 
    712 	case 'f':
    713 		strcat(NormalizedDeviceNameBuffer, "Floppy0");
    714 		break;
    715 
    716 	case 'h':
    717 		strcat(NormalizedDeviceNameBuffer, "Harddisk0");
    718 		break;
    719 	}
    720 
    721 
    722 	p = NormalizedDeviceNameBuffer + strlen(NormalizedDeviceNameBuffer) - 1;
    723 	*p = (CHAR)(*p + DiskNumber);
    724 
    725 
    726 	//
    727 	// Partition nr.
    728 	//
    729 
    730 	if(PartitionNumber >= 0)
    731 	{
    732 		strcat(NormalizedDeviceNameBuffer, "\\Partition0");
    733 
    734 		p = NormalizedDeviceNameBuffer + strlen(NormalizedDeviceNameBuffer) - 1;
    735 		*p = (CHAR)(*p + PartitionNumber);
    736 	}
    737 
    738 
    739 	return NormalizedDeviceNameBuffer;
    740 }
    741 
    742 
    743 
    744 
    745 static
    746 VOID
    747 _GetDeviceSize(
    748     IN HANDLE h,
    749     OUT unsigned __int64 *FsSize
    750    )
    751 {
    752 	PARTITION_INFORMATION pi;
    753 	DISK_GEOMETRY gi;
    754 	NTSTATUS Status;
    755 	IO_STATUS_BLOCK IoStatusBlock;
    756 
    757 	//
    758 	// Zero it
    759 	//
    760 
    761 	*FsSize = 0;
    762 
    763 	//
    764 	// Call driver
    765 	//
    766 
    767 	RtlZeroMemory(&pi, sizeof(PARTITION_INFORMATION));
    768 
    769 	Status = NtDeviceIoControlFile(
    770 		h, NULL, NULL, NULL, &IoStatusBlock, IOCTL_DISK_GET_PARTITION_INFO,
    771 		&pi, sizeof(PARTITION_INFORMATION),
    772 		&pi, sizeof(PARTITION_INFORMATION));
    773 
    774 
    775 	if(NT_SUCCESS(Status))
    776 	{
    777 		*FsSize = pi.PartitionLength.QuadPart;
    778 	}
    779 	else if(STATUS_INVALID_DEVICE_REQUEST == Status)
    780 	{
    781 		//
    782 		// No partitions: get device info.
    783 		//
    784 
    785 		RtlZeroMemory(&gi, sizeof(DISK_GEOMETRY));
    786 
    787 		Status = NtDeviceIoControlFile(
    788 				h, NULL, NULL, NULL, &IoStatusBlock, IOCTL_DISK_GET_DRIVE_GEOMETRY,
    789 				&gi, sizeof(DISK_GEOMETRY),
    790 				&gi, sizeof(DISK_GEOMETRY));
    791 
    792 
    793 		if(NT_SUCCESS(Status))
    794 		{
    795 			*FsSize =
    796 				gi.BytesPerSector *
    797 				gi.SectorsPerTrack *
    798 				gi.TracksPerCylinder *
    799 				gi.Cylinders.QuadPart;
    800 		}
    801 
    802 	}
    803 }
    804 
    805 
    806 
    807 //
    808 // Open device by name.
    809 //
    810 
    811 static
    812 BOOLEAN
    813 _Ext2OpenDevice(
    814     IN PCSTR Name,
    815     IN BOOLEAN ReadOnly,
    816     OUT PHANDLE Handle,
    817     OUT PBOOLEAN OpenedReadonly OPTIONAL,
    818     OUT unsigned *Errno OPTIONAL
    819    )
    820 {
    821 	CHAR NormalizedDeviceName[512];
    822 	NTSTATUS Status;
    823 
    824 	if(NULL == Name)
    825 	{
    826 		//
    827 		// Set not found
    828 		//
    829 
    830 		if(ARGUMENT_PRESENT(Errno))
    831 			*Errno = ENOENT;
    832 
    833 		return FALSE;
    834 	}
    835 
    836 
    837 	if((((*Name) | 0x20) >= 'a') && (((*Name) | 0x20) <= 'z') &&
    838 		(':' == *(Name + 1)) && ('\0' == *(Name + 2)))
    839 	{
    840 		Status = _OpenDriveLetter(*Name, ReadOnly, Handle, OpenedReadonly);
    841 	}
    842 	else
    843 	{
    844 		//
    845 		// Make name
    846 		//
    847 
    848 		Name = _NormalizeDeviceName(Name, NormalizedDeviceName);
    849 
    850 		if(NULL == Name)
    851 		{
    852 			//
    853 			// Set not found
    854 			//
    855 
    856 			if(ARGUMENT_PRESENT(Errno))
    857 				*Errno = ENOENT;
    858 
    859 			return FALSE;
    860 		}
    861 
    862 		//
    863 		// Try to open it
    864 		//
    865 
    866 		Status = _OpenNtName(Name, ReadOnly, Handle, OpenedReadonly);
    867 	}
    868 
    869 
    870 	if(!NT_SUCCESS(Status))
    871 	{
    872 		if(ARGUMENT_PRESENT(Errno))
    873 			*Errno = _MapNtStatus(Status);
    874 
    875 		return FALSE;
    876 	}
    877 
    878 	return TRUE;
    879 }
    880 
    881 
    882 //
    883 // Raw block io. Sets dos errno
    884 //
    885 
    886 static
    887 BOOLEAN
    888 _BlockIo(
    889     IN HANDLE Handle,
    890     IN LARGE_INTEGER Offset,
    891     IN ULONG Bytes,
    892     IN OUT PCHAR Buffer,
    893     IN BOOLEAN Read,
    894     OUT unsigned* Errno
    895    )
    896 {
    897 	IO_STATUS_BLOCK IoStatusBlock;
    898 	NTSTATUS Status;
    899 
    900 	//
    901 	// Should be aligned
    902 	//
    903 
    904 	ASSERT(0 == (Bytes % 512));
    905 	ASSERT(0 == (Offset.LowPart % 512));
    906 
    907 
    908 	//
    909 	// perform io
    910 	//
    911 
    912 	if(Read)
    913 	{
    914 		Status = NtReadFile(Handle, NULL, NULL, NULL,
    915 			&IoStatusBlock, Buffer, Bytes, &Offset, NULL);
    916 	}
    917 	else
    918 	{
    919 		Status = NtWriteFile(Handle, NULL, NULL, NULL,
    920 			&IoStatusBlock, Buffer, Bytes, &Offset, NULL);
    921 	}
    922 
    923 
    924 	//
    925 	// translate error
    926 	//
    927 
    928 	if(NT_SUCCESS(Status))
    929 	{
    930 		*Errno = 0;
    931 		return TRUE;
    932 	}
    933 
    934 	*Errno = _MapNtStatus(Status);
    935 
    936 	return FALSE;
    937 }
    938 
    939 
    940 
    941 __inline
    942 BOOLEAN
    943 _RawWrite(
    944     IN HANDLE Handle,
    945     IN LARGE_INTEGER Offset,
    946     IN ULONG Bytes,
    947     OUT const CHAR* Buffer,
    948     OUT unsigned* Errno
    949    )
    950 {
    951 	return _BlockIo(Handle, Offset, Bytes, (PCHAR)Buffer, FALSE, Errno);
    952 }
    953 
    954 __inline
    955 BOOLEAN
    956 _RawRead(
    957     IN HANDLE Handle,
    958     IN LARGE_INTEGER Offset,
    959     IN ULONG Bytes,
    960     IN PCHAR Buffer,
    961     OUT unsigned* Errno
    962    )
    963 {
    964 	return _BlockIo(Handle, Offset, Bytes, Buffer, TRUE, Errno);
    965 }
    966 
    967 
    968 
    969 __inline
    970 BOOLEAN
    971 _SetPartType(
    972     IN HANDLE Handle,
    973     IN UCHAR Type
    974    )
    975 {
    976 	IO_STATUS_BLOCK IoStatusBlock;
    977 	return STATUS_SUCCESS == NtDeviceIoControlFile(
    978 												   Handle, NULL, NULL, NULL, &IoStatusBlock, IOCTL_DISK_SET_PARTITION_INFO,
    979 												   &Type, sizeof(Type),
    980 												   NULL, 0);
    981 }
    982 
    983 
    984 
    985 //--------------------- interface part
    986 
    987 //
    988 // Interface functions.
    989 // Is_mounted is set to 1 if the device is mounted, 0 otherwise
    990 //
    991 
    992 errcode_t
    993 ext2fs_check_if_mounted(const char *file, int *mount_flags)
    994 {
    995 	HANDLE h;
    996 	BOOLEAN Readonly;
    997 
    998 	*mount_flags = 0;
    999 
   1000 	if(!_Ext2OpenDevice(file, TRUE, &h, &Readonly, NULL))
   1001 	{
   1002 		return 0;
   1003 	}
   1004 
   1005 
   1006 	__try{
   1007 		*mount_flags &= _IsMounted(h) ? EXT2_MF_MOUNTED : 0;
   1008 	}
   1009 	__finally{
   1010 		_CloseDisk(h);
   1011 	}
   1012 
   1013 	return 0;
   1014 }
   1015 
   1016 
   1017 
   1018 //
   1019 // Returns the number of blocks in a partition
   1020 //
   1021 
   1022 static __int64 FsSize = 0;
   1023 static char knowndevice[1024] = "";
   1024 
   1025 
   1026 errcode_t
   1027 ext2fs_get_device_size(const char *file, int blocksize,
   1028 				 blk_t *retblocks)
   1029 {
   1030 	HANDLE h;
   1031 	BOOLEAN Readonly;
   1032 
   1033 	if((0 == FsSize) || (0 != strcmp(knowndevice, file)))
   1034 	{
   1035 
   1036 		if(!_Ext2OpenDevice(file, TRUE, &h, &Readonly, NULL))
   1037 		{
   1038 			return 0;
   1039 		}
   1040 
   1041 
   1042 		__try{
   1043 
   1044 			//
   1045 			// Get size
   1046 			//
   1047 
   1048 			_GetDeviceSize(h, &FsSize);
   1049 			strcpy(knowndevice, file);
   1050 		}
   1051 		__finally{
   1052 			_CloseDisk(h);
   1053 		}
   1054 
   1055 	}
   1056 
   1057 	*retblocks = (blk_t)(unsigned __int64)(FsSize / blocksize);
   1058 	UNREFERENCED_PARAMETER(file);
   1059 	return 0;
   1060 }
   1061 
   1062 
   1063 
   1064 
   1065 
   1066 
   1067 //
   1068 // Table elements
   1069 //
   1070 
   1071 
   1072 static
   1073 errcode_t
   1074 nt_open(const char *name, int flags, io_channel *channel)
   1075 {
   1076 	io_channel      io = NULL;
   1077 	PNT_PRIVATE_DATA NtData = NULL;
   1078 	errcode_t Errno = 0;
   1079 
   1080 	//
   1081 	// Check name
   1082 	//
   1083 
   1084 	if (NULL == name)
   1085 	{
   1086 		return EXT2_ET_BAD_DEVICE_NAME;
   1087 	}
   1088 
   1089 	__try{
   1090 
   1091 		//
   1092 		// Allocate channel handle
   1093 		//
   1094 
   1095 		io = (io_channel) malloc(sizeof(struct struct_io_channel));
   1096 
   1097 		if (NULL == io)
   1098 		{
   1099 			Errno = ENOMEM;
   1100 			__leave;
   1101 		}
   1102 
   1103 		RtlZeroMemory(io, sizeof(struct struct_io_channel));
   1104 		io->magic = EXT2_ET_MAGIC_IO_CHANNEL;
   1105 
   1106 		NtData = (PNT_PRIVATE_DATA)malloc(sizeof(NT_PRIVATE_DATA));
   1107 
   1108 		if (NULL == NtData)
   1109 		{
   1110 			Errno = ENOMEM;
   1111 			__leave;
   1112 		}
   1113 
   1114 
   1115 		io->manager = nt_io_manager();
   1116 		io->name = malloc(strlen(name) + 1);
   1117 		if (NULL == io->name)
   1118 		{
   1119 			Errno = ENOMEM;
   1120 			__leave;
   1121 		}
   1122 
   1123 		strcpy(io->name, name);
   1124 		io->private_data = NtData;
   1125 		io->block_size = 1024;
   1126 		io->read_error = 0;
   1127 		io->write_error = 0;
   1128 		io->refcount = 1;
   1129 
   1130 		//
   1131 		// Initialize data
   1132 		//
   1133 
   1134 		RtlZeroMemory(NtData, sizeof(NT_PRIVATE_DATA));
   1135 
   1136 		NtData->magic = EXT2_ET_MAGIC_NT_IO_CHANNEL;
   1137 		NtData->BufferBlockNumber = 0xffffffff;
   1138 		NtData->BufferSize = 1024;
   1139 		NtData->Buffer = malloc(NtData->BufferSize);
   1140 
   1141 		if (NULL == NtData->Buffer)
   1142 		{
   1143 			Errno = ENOMEM;
   1144 			__leave;
   1145 		}
   1146 
   1147 		//
   1148 		// Open it
   1149 		//
   1150 
   1151 		if(!_Ext2OpenDevice(name, (BOOLEAN)!BooleanFlagOn(flags, EXT2_FLAG_RW), &NtData->Handle, &NtData->OpenedReadonly, &Errno))
   1152 		{
   1153 			__leave;
   1154 		}
   1155 
   1156 
   1157 		//
   1158 		// get size
   1159 		//
   1160 
   1161 		_GetDeviceSize(NtData->Handle, &FsSize);
   1162 		strcpy(knowndevice, name);
   1163 
   1164 
   1165 		//
   1166 		// Lock/dismount
   1167 		//
   1168 
   1169 		if(!NT_SUCCESS(_LockDrive(NtData->Handle)) /*|| !NT_SUCCESS(_DismountDrive(NtData->Handle))*/)
   1170 		{
   1171 			NtData->OpenedReadonly = TRUE;
   1172 		}
   1173 
   1174 		//
   1175 		// Done
   1176 		//
   1177 
   1178 		*channel = io;
   1179 
   1180 
   1181 	}
   1182 	__finally{
   1183 
   1184 		if(0 != Errno)
   1185 		{
   1186 			//
   1187 			// Cleanup
   1188 			//
   1189 
   1190 			if (NULL != io)
   1191 			{
   1192 				free(io->name);
   1193 				free(io);
   1194 			}
   1195 
   1196 			if (NULL != NtData)
   1197 			{
   1198 				if(NULL != NtData->Handle)
   1199 				{
   1200 					_UnlockDrive(NtData->Handle);
   1201 					_CloseDisk(NtData->Handle);
   1202 				}
   1203 
   1204 				free(NtData->Buffer);
   1205 				free(NtData);
   1206 			}
   1207 		}
   1208 	}
   1209 
   1210 	return Errno;
   1211 }
   1212 
   1213 
   1214 //
   1215 // Close api
   1216 //
   1217 
   1218 static
   1219 errcode_t
   1220 nt_close(io_channel channel)
   1221 {
   1222 	PNT_PRIVATE_DATA NtData = NULL;
   1223 
   1224 	if(NULL == channel)
   1225 	{
   1226 		return 0;
   1227 	}
   1228 
   1229 	EXT2_CHECK_MAGIC(channel, EXT2_ET_MAGIC_IO_CHANNEL);
   1230 	NtData = (PNT_PRIVATE_DATA) channel->private_data;
   1231 	EXT2_CHECK_MAGIC(NtData, EXT2_ET_MAGIC_NT_IO_CHANNEL);
   1232 
   1233 	if (--channel->refcount > 0)
   1234 	{
   1235 		return 0;
   1236 	}
   1237 
   1238 	free(channel->name);
   1239 	free(channel);
   1240 
   1241 	if (NULL != NtData)
   1242 	{
   1243 		if(NULL != NtData->Handle)
   1244 		{
   1245 			_DismountDrive(NtData->Handle);
   1246 			_UnlockDrive(NtData->Handle);
   1247 			_CloseDisk(NtData->Handle);
   1248 		}
   1249 
   1250 		free(NtData->Buffer);
   1251 		free(NtData);
   1252 	}
   1253 
   1254 	return 0;
   1255 }
   1256 
   1257 
   1258 
   1259 //
   1260 // set block size
   1261 //
   1262 
   1263 static
   1264 errcode_t
   1265 nt_set_blksize(io_channel channel, int blksize)
   1266 {
   1267 	PNT_PRIVATE_DATA NtData = NULL;
   1268 
   1269 	EXT2_CHECK_MAGIC(channel, EXT2_ET_MAGIC_IO_CHANNEL);
   1270 	NtData = (PNT_PRIVATE_DATA) channel->private_data;
   1271 	EXT2_CHECK_MAGIC(NtData, EXT2_ET_MAGIC_NT_IO_CHANNEL);
   1272 
   1273 	if (channel->block_size != blksize)
   1274 	{
   1275 		channel->block_size = blksize;
   1276 
   1277 		free(NtData->Buffer);
   1278 		NtData->BufferBlockNumber = 0xffffffff;
   1279 		NtData->BufferSize = channel->block_size;
   1280 		ASSERT(0 == (NtData->BufferSize % 512));
   1281 
   1282 		NtData->Buffer = malloc(NtData->BufferSize);
   1283 
   1284 		if (NULL == NtData->Buffer)
   1285 		{
   1286 			return ENOMEM;
   1287 		}
   1288 
   1289 	}
   1290 
   1291 	return 0;
   1292 }
   1293 
   1294 
   1295 //
   1296 // read block
   1297 //
   1298 
   1299 static
   1300 errcode_t
   1301 nt_read_blk(io_channel channel, unsigned long block,
   1302 			       int count, void *buf)
   1303 {
   1304 	PVOID BufferToRead;
   1305 	ULONG SizeToRead;
   1306 	ULONG Size;
   1307 	LARGE_INTEGER Offset;
   1308 	PNT_PRIVATE_DATA NtData = NULL;
   1309 	unsigned Errno = 0;
   1310 
   1311 	EXT2_CHECK_MAGIC(channel, EXT2_ET_MAGIC_IO_CHANNEL);
   1312 	NtData = (PNT_PRIVATE_DATA) channel->private_data;
   1313 	EXT2_CHECK_MAGIC(NtData, EXT2_ET_MAGIC_NT_IO_CHANNEL);
   1314 
   1315 	//
   1316 	// If it's in the cache, use it!
   1317 	//
   1318 
   1319 	if ((1 == count) &&
   1320 		(block == NtData->BufferBlockNumber) &&
   1321 		(NtData->BufferBlockNumber != 0xffffffff))
   1322 	{
   1323 		memcpy(buf, NtData->Buffer, channel->block_size);
   1324 		return 0;
   1325 	}
   1326 
   1327 	Size = (count < 0) ? (ULONG)(-count) : (ULONG)(count * channel->block_size);
   1328 
   1329 	Offset.QuadPart = block * channel->block_size;
   1330 
   1331 	//
   1332 	// If not fit to the block
   1333 	//
   1334 
   1335 	if(Size <= NtData->BufferSize)
   1336 	{
   1337 		//
   1338 		// Update the cache
   1339 		//
   1340 
   1341 		NtData->BufferBlockNumber = block;
   1342 		BufferToRead = NtData->Buffer;
   1343 		SizeToRead = NtData->BufferSize;
   1344 	}
   1345 	else
   1346 	{
   1347 		SizeToRead = Size;
   1348 		BufferToRead = buf;
   1349 		ASSERT(0 == (SizeToRead % channel->block_size));
   1350 	}
   1351 
   1352 	if(!_RawRead(NtData->Handle, Offset, SizeToRead, BufferToRead, &Errno))
   1353 	{
   1354 
   1355 		if (channel->read_error)
   1356 		{
   1357 			return (channel->read_error)(channel, block, count, buf,
   1358 					       Size, 0, Errno);
   1359 		}
   1360 		else
   1361 		{
   1362 			return Errno;
   1363 		}
   1364 	}
   1365 
   1366 
   1367 	if(BufferToRead != buf)
   1368 	{
   1369 		ASSERT(Size <= SizeToRead);
   1370 		memcpy(buf, BufferToRead, Size);
   1371 	}
   1372 
   1373 	return 0;
   1374 }
   1375 
   1376 
   1377 //
   1378 // write block
   1379 //
   1380 
   1381 static
   1382 errcode_t
   1383 nt_write_blk(io_channel channel, unsigned long block,
   1384 				int count, const void *buf)
   1385 {
   1386 	ULONG SizeToWrite;
   1387 	LARGE_INTEGER Offset;
   1388 	PNT_PRIVATE_DATA NtData = NULL;
   1389 	unsigned Errno = 0;
   1390 
   1391 	EXT2_CHECK_MAGIC(channel, EXT2_ET_MAGIC_IO_CHANNEL);
   1392 	NtData = (PNT_PRIVATE_DATA) channel->private_data;
   1393 	EXT2_CHECK_MAGIC(NtData, EXT2_ET_MAGIC_NT_IO_CHANNEL);
   1394 
   1395 	if(NtData->OpenedReadonly)
   1396 	{
   1397 		return EACCES;
   1398 	}
   1399 
   1400 	if (count == 1)
   1401 	{
   1402 		SizeToWrite = channel->block_size;
   1403 	}
   1404 	else
   1405 	{
   1406 		NtData->BufferBlockNumber = 0xffffffff;
   1407 
   1408 		if (count < 0)
   1409 		{
   1410 			SizeToWrite = (ULONG)(-count);
   1411 		}
   1412 		else
   1413 		{
   1414 			SizeToWrite = (ULONG)(count * channel->block_size);
   1415 		}
   1416 	}
   1417 
   1418 
   1419 	ASSERT(0 == (SizeToWrite % 512));
   1420 	Offset.QuadPart = block * channel->block_size;
   1421 
   1422 	if(!_RawWrite(NtData->Handle, Offset, SizeToWrite, buf, &Errno))
   1423 	{
   1424 		if (channel->write_error)
   1425 		{
   1426 			return (channel->write_error)(channel, block, count, buf,
   1427 						SizeToWrite, 0, Errno);
   1428 		}
   1429 		else
   1430 		{
   1431 			return Errno;
   1432 		}
   1433 	}
   1434 
   1435 
   1436 	//
   1437 	// Stash a copy.
   1438 	//
   1439 
   1440 	if(SizeToWrite >= NtData->BufferSize)
   1441 	{
   1442 		NtData->BufferBlockNumber = block;
   1443 		memcpy(NtData->Buffer, buf, NtData->BufferSize);
   1444 	}
   1445 
   1446 	NtData->Written = TRUE;
   1447 
   1448 	return 0;
   1449 
   1450 }
   1451 
   1452 
   1453 
   1454 //
   1455 // Flush data buffers to disk.  Since we are currently using a
   1456 // write-through cache, this is a no-op.
   1457 //
   1458 
   1459 static
   1460 errcode_t
   1461 nt_flush(io_channel channel)
   1462 {
   1463 	PNT_PRIVATE_DATA NtData = NULL;
   1464 
   1465 	EXT2_CHECK_MAGIC(channel, EXT2_ET_MAGIC_IO_CHANNEL);
   1466 	NtData = (PNT_PRIVATE_DATA) channel->private_data;
   1467 	EXT2_CHECK_MAGIC(NtData, EXT2_ET_MAGIC_NT_IO_CHANNEL);
   1468 
   1469 	if(NtData->OpenedReadonly)
   1470 	{
   1471 		return 0; // EACCESS;
   1472 	}
   1473 
   1474 
   1475 	//
   1476 	// Flush file buffers.
   1477 	//
   1478 
   1479 	_FlushDrive(NtData->Handle);
   1480 
   1481 
   1482 	//
   1483 	// Test and correct partition type.
   1484 	//
   1485 
   1486 	if(NtData->Written)
   1487 	{
   1488 		_SetPartType(NtData->Handle, 0x83);
   1489 	}
   1490 
   1491 	return 0;
   1492 }
   1493 
   1494 
   1495