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