1 ////////////////////////////////////////////////////////////////////
2 // Copyright (C) Alexander Telyatnikov, Ivan Keliukh, Yegor Anchishkin, SKIF Software, 1999-2013. Kiev, Ukraine
4 ////////////////////////////////////////////////////////////////////
6 #ifndef UDF_FORMAT_MEDIA
8 BOOLEAN opt_invalidate_volume
= FALSE
;
9 #endif //UDF_FORMAT_MEDIA
12 #ifndef UDF_FORMAT_MEDIA
13 BOOLEAN open_as_device
= FALSE
;
14 #endif //UDF_FORMAT_MEDIA
17 PSKIN_API SkinAPI
= NULL
;
22 HINSTANCE hInstance
, // handle to current instance
23 HINSTANCE hPrevInstance
, // handle to previous instance
24 int nCmdShow
// show state
29 PSKIN_API (__stdcall
*SkinInit
) (VOID
);
31 hm
= LoadLibraryW(path
);
34 SkinInit
= (PSKIN_API(__stdcall
*)(void))GetProcAddress(hm
, "SkinInit");
40 Skin
->Init(hInstance
, hPrevInstance
, nCmdShow
);
45 #endif //USE_SKIN_MODEL
56 #define _lphUdf ((PUDF_VOL_HANDLE_I)(DeviceObject->lpContext))
59 #define _lphUdf (DeviceObject->cbio)
66 IN ULONG IoControlCode
,
67 IN PDEVICE_OBJECT DeviceObject
,
68 IN PVOID InputBuffer
,
69 IN ULONG InputBufferLength
,
70 OUT PVOID OutputBuffer
,
71 IN ULONG OutputBufferLength
,
72 IN BOOLEAN OverrideVerify
,
73 OUT PVOID Iosb OPTIONAL
77 #if !defined(LIBUDF) && !defined(LIBUDFFMT)
80 ULONG RC
= DeviceIoControl(DeviceObject
->h
,IoControlCode
,
81 InputBuffer
,InputBufferLength
,
82 OutputBuffer
,OutputBufferLength
,
92 ULONG RC
= _lphUdf
->lpIOCtlFunc(_lphUdf
->lpParameter
,IoControlCode
,
93 InputBuffer
,InputBufferLength
,
94 OutputBuffer
,OutputBufferLength
,
101 } // end UDFPhSendIOCTL()
105 UDFPhReadSynchronous(
106 PDEVICE_OBJECT DeviceObject
, // the physical device object
115 #if !defined(LIBUDF) && !defined(LIBUDFFMT)
118 // KdPrint(("UDFPhRead: Length: %x Lba: %lx\n",Length>>0xb,Offset>>0xb));
119 LONG HiOffs
= (ULONG
)(Offset
>> 32);
121 RC
= SetFilePointer(DeviceObject
->h
,(ULONG
)Offset
,&HiOffs
,FILE_BEGIN
);
122 if(RC
== INVALID_SET_FILE_POINTER
) {
123 if(GetLastError() != NO_ERROR
) {
124 KdPrint(("UDFPhReadSynchronous: error %x\n", GetLastError()));
125 return STATUS_END_OF_FILE
;
128 RC
= ReadFile(DeviceObject
->h
,Buffer
,Length
,ReadBytes
,NULL
);
132 return STATUS_END_OF_FILE
;
134 return STATUS_SUCCESS
;
138 return _lphUdf
->lpReadFunc(_lphUdf
->lpParameter
,
144 #endif //defined LIBUDF || defined LIBUDFFMT
146 } // end UDFPhReadSynchronous()
150 UDFPhWriteSynchronous(
151 PDEVICE_OBJECT DeviceObject
, // the physical device object
159 #if !defined(LIBUDF) && !defined(LIBUDFFMT)
161 NTSTATUS RC
= STATUS_SUCCESS
;
162 LONG HiOffs
= (ULONG
)(Offset
>> 32);
163 PVOID Buffer2
= NULL
;
164 PVOID Buffer3
= NULL
;
166 RC
= SetFilePointer(DeviceObject
->h
,(ULONG
)Offset
,&HiOffs
,FILE_BEGIN
);
167 if(RC
== INVALID_SET_FILE_POINTER
) {
168 if(GetLastError() != NO_ERROR
) {
169 KdPrint(("UDFPhWriteSynchronous: error %x\n", GetLastError()));
170 return STATUS_END_OF_FILE
;
174 Buffer2
= ExAllocatePool(NonPagedPool
, Length
+0x10000);
175 Buffer3
= (PVOID
)( ((ULONG
)Buffer2
+ 0xffff) & ~0xffff);
176 RtlCopyMemory(Buffer3
, Buffer
, Length
);
178 RC
= WriteFile(DeviceObject
->h
,Buffer3
,Length
,WrittenBytes
,NULL
);
182 KdPrint(("UDFPhWriteSynchronous: EOF, error %x\n", RC
));
183 RC
= STATUS_END_OF_FILE
;
188 if(Buffer2
) ExFreePool(Buffer2
);
194 return _lphUdf
->lpWriteFunc(_lphUdf
->lpParameter
,
202 } // end UDFPhWriteSynchronous()
206 UDFPhWriteVerifySynchronous(
207 PDEVICE_OBJECT DeviceObject
, // the physical device object
216 PUCHAR v_buff
= NULL
;
219 RC
= UDFPhWriteSynchronous(DeviceObject
, Buffer
, Length
, Offset
, WrittenBytes
, 0);
222 v_buff
= (PUCHAR
)DbgAllocatePool(NonPagedPool
, Length
);
226 RC
= UDFPhSendIOCTL( IOCTL_CDRW_SYNC_CACHE
, DeviceObject
,
227 NULL
,0, NULL
,0, FALSE
, NULL
);
229 RC
= UDFPhReadSynchronous(DeviceObject
, v_buff
, Length
, Offset
, &ReadBytes
, 0);
230 if(!NT_SUCCESS(RC
)) {
235 if(RtlCompareMemory(v_buff
, Buffer
, ReadBytes
) == Length
) {
241 return STATUS_LOST_WRITEBEHIND_DATA
;
242 } // end UDFPhWriteVerifySynchronous()
251 LONG offh
= (ULONG
)(len
>> 32);
252 //( (LONGLONG)LBA >> (32-Vcb->BlockSizeBits) );
254 SetFilePointer((HANDLE
)h
, (ULONG
)(len
/*(LBA << Vcb->BlockSizeBits)*/ ), &offh
, FILE_BEGIN
);
257 SetFilePointer((HANDLE
)h
, 0, &offh
, FILE_BEGIN
);
258 } // end set_image_size()
268 lsz
= SetFilePointer(h
, 0, &hsz
, FILE_END
);
269 return (((int64
)hsz
) << 32) | lsz
;
270 } // end get_file_size()
278 ULONG hsz
= (ULONG
)(sz
>> 32);
279 ULONG lsz
= (ULONG
)sz
;
281 lsz
= SetFilePointer(h
, lsz
, (PLONG
)&hsz
, FILE_BEGIN
);
282 return (((int64
)hsz
) << 32) | lsz
;
283 } // end set_file_pointer()
289 #ifndef UDF_FORMAT_MEDIA
300 ULONG offl
= SetFilePointer((HANDLE
)h
, 0, &offh
, FILE_CURRENT
);
301 // ULONG Lba = (ULONG)((((LONGLONG)offh << 32) + offl) >> Vcb->BlockSizeBits);
303 UDFWriteData(Vcb
, FALSE
, (((LONGLONG
)offh
)<<32)+offl
, len
, FALSE
, buff
, &written
);
305 SetFilePointer((HANDLE
)h
, offl
, &offh
, FILE_BEGIN
);
307 SetFilePointer((HANDLE
)h
, written
, &offh
, FILE_CURRENT
);
311 #endif //UDF_FORMAT_MEDIA
317 #ifdef NT_NATIVE_MODE
325 #ifndef NT_NATIVE_MODE
329 // obtain the token, first check the thread and then the process
330 if (!OpenThreadToken(GetCurrentThread(), TOKEN_ADJUST_PRIVILEGES
| TOKEN_QUERY
, TRUE
, &hToken
)) {
331 if (GetLastError() == ERROR_NO_TOKEN
) {
332 if (!OpenProcessToken(GetCurrentProcess(), TOKEN_ADJUST_PRIVILEGES
| TOKEN_QUERY
, &hToken
)) {
340 // get the luid for the privilege
341 if (!LookupPrivilegeValue(NULL
, pszPrivilege
, &tp
.Privileges
[0].Luid
)) {
346 tp
.PrivilegeCount
= 1;
349 tp
.Privileges
[0].Attributes
= SE_PRIVILEGE_ENABLED
;
351 tp
.Privileges
[0].Attributes
= 0;
353 // enable or disable the privilege
354 if (!AdjustTokenPrivileges(hToken
, FALSE
, &tp
, 0, (PTOKEN_PRIVILEGES
)NULL
, 0)) {
359 if (!CloseHandle(hToken
))
362 #endif //NT_NATIVE_MODE
367 #endif //NT_NATIVE_MODE
375 ULONG
* pLockMode
// OUT
383 RC
= DeviceIoControl(h
,IOCTL_UDF_LOCK_VOLUME_BY_PID
,NULL
,0,NULL
,0,&returned
,NULL
);
385 (*pLockMode
) = IOCTL_UDF_LOCK_VOLUME_BY_PID
;
386 return STATUS_SUCCESS
;
390 RC
= DeviceIoControl(h
,FSCTL_LOCK_VOLUME
,NULL
,0,NULL
,0,&returned
,NULL
);
392 (*pLockMode
) = FSCTL_LOCK_VOLUME
;
393 return STATUS_SUCCESS
;
395 return STATUS_UNSUCCESSFUL
;
402 ULONG
* pLockMode
// IN
408 if((*pLockMode
) == IOCTL_UDF_LOCK_VOLUME_BY_PID
) {
409 return DeviceIoControl(h
,IOCTL_UDF_UNLOCK_VOLUME_BY_PID
,NULL
,0,NULL
,0,&returned
,NULL
);
413 return DeviceIoControl(h
,FSCTL_UNLOCK_VOLUME
,NULL
,0,NULL
,0,&returned
,NULL
);
415 } // MyUnlockVolume()
418 my_retrieve_vol_type(
426 if(wcslen(fn
) == 2 && fn
[1] == ':') {
427 ULONG DevType
= GetDriveTypeW(fn
);
428 KdPrint((" DevType %x\n", DevType
));
431 Vcb
->PhDeviceType
= FILE_DEVICE_CD_ROM
;
434 Vcb
->PhDeviceType
= FILE_DEVICE_DISK
;
438 if(wcslen(fn
) == 2 && fn
[1] == ';') {
439 UserPrint(("Warrning: File name is similar to drive letter.\n"
440 " Don't you type semicolon ';' instead of colon ':' ?\n"));
443 } // end my_retrieve_vol_type()
446 #ifdef NT_NATIVE_MODE
447 #define GetLastError() ((ULONG)(-1))
448 #endif //NT_NATIVE_MODE
450 #define MAX_INVALIDATE_VOLUME_RETRY 8
462 WCHAR deviceNameBuffer
[0x200];
463 WCHAR FSNameBuffer
[0x200];
464 // CCHAR RealDeviceName[0x200];
465 // WCHAR DeviceName[MAX_PATH+1];
469 BOOLEAN CantLock
= FALSE
;
471 #ifdef NT_NATIVE_MODE
472 IO_STATUS_BLOCK ioStatus
;
473 OBJECT_ATTRIBUTES ObjectAttributes
;
474 UNICODE_STRING uniFilename
;
475 #endif //NT_NATIVE_MODE
479 #ifdef UDF_FORMAT_MEDIA
480 PUDFFmtState fms
= Vcb
->fms
;
483 open_as_device
= TRUE
;
487 #ifdef UDF_FORMAT_MEDIA
492 // make several retries to workaround smart applications,
493 // those attempts to work with volume immediately after arrival
495 #ifdef UDF_FORMAT_MEDIA
498 opt_invalidate_volume
? 0 : MAX_INVALIDATE_VOLUME_RETRY
;
500 #ifndef NT_NATIVE_MODE
501 swprintf(deviceNameBuffer
, L
"%ws\\", fn
);
502 KdPrint(("my_open: %S\n", fn
));
503 i
= sizeof(FSNameBuffer
)/sizeof(FSNameBuffer
[0]);
504 if(GetVolumeInformationW(deviceNameBuffer
, NULL
, 0,
505 &returned
, &returned
, &returned
, FSNameBuffer
, i
)) {
506 KdPrint(("my_open: FS: %S\n", FSNameBuffer
));
507 if(!wcscmp(FSNameBuffer
, L
"Unknown")) {
511 KdPrint(("my_open: FS: ???\n"));
513 KdPrint(("my_open: retry %d times\n", retry
));
515 #endif //NT_NATIVE_MODE
519 #ifndef NT_NATIVE_MODE
520 swprintf(deviceNameBuffer
, L
"\\\\.\\%ws", fn
);
521 if(wcslen(fn
) == 2 && fn
[1] == ';') {
522 UserPrint(("Warrning: File name is similar to drive letter.\n"
523 " Don't you type semicolon ';' instead of colon ':' ?\n"));
527 if(h
== ((HANDLE
)-1)) {
528 h
= CreateFileW(deviceNameBuffer
, GENERIC_READ
| GENERIC_WRITE
,
529 ((i
& 1) ? 0 : FILE_SHARE_READ
) | ((i
& 2) ? 0 : FILE_SHARE_WRITE
),
532 FILE_ATTRIBUTE_NORMAL
| FILE_FLAG_NO_BUFFERING
, NULL
);
533 if(h
!= ((HANDLE
)-1)) {
534 KdPrint((" opened i=%x\n", i
));
538 #else //NT_NATIVE_MODE
539 uniFilename
.Length
= swprintf(deviceNameBuffer
, L
"\\??\\%ws", fn
);
540 uniFilename
.Buffer
= deviceNameBuffer
;
541 uniFilename
.Length
*= sizeof(WCHAR
);
542 uniFilename
.MaximumLength
= uniFilename
.Length
+ sizeof(WCHAR
);
546 InitializeObjectAttributes(&ObjectAttributes
, &uniFilename
, OBJ_CASE_INSENSITIVE
, NULL
, NULL
);
547 if(h
== ((HANDLE
)-1)) {
548 RC
= NtCreateFile(&h
,
549 GENERIC_READ
| GENERIC_WRITE
| SYNCHRONIZE
| FILE_READ_ATTRIBUTES
,
553 FILE_ATTRIBUTE_NORMAL
,
554 ((i
& 1) ? 0 : FILE_SHARE_READ
) | ((i
& 2) ? 0 : FILE_SHARE_WRITE
),
556 FILE_SYNCHRONOUS_IO_NONALERT
| FILE_COMPLETE_IF_OPLOCKED
| FILE_WRITE_THROUGH
| FILE_NO_INTERMEDIATE_BUFFERING
,
559 if(!NT_SUCCESS(RC
)) {
560 KdPrint((" opened i2=%x\n", i
));
565 #endif //NT_NATIVE_MODE
566 if(h
!= ((HANDLE
)-1)) {
568 #ifdef UDF_FORMAT_MEDIA
569 if(fms
->opt_flush
|| fms
->opt_probe
) {
572 #endif //UDF_FORMAT_MEDIA
573 my_retrieve_vol_type(Vcb
, fn
);
575 my_retrieve_vol_type(fn
);
577 if(!NT_SUCCESS(MyLockVolume(h
,pLockMode
))) {
579 if(retry
< MAX_INVALIDATE_VOLUME_RETRY
) {
581 if(!Privilege(SE_TCB_NAME
, TRUE
)) {
582 KdPrint(("SE_TCB privilege not held\n"));
584 if(DeviceIoControl(h
,FSCTL_INVALIDATE_VOLUMES
,&h
,sizeof(h
),NULL
,0,&returned
,NULL
) ) {
585 KdPrint((" FSCTL_INVALIDATE_VOLUMES ok, status %x\n", GetLastError()));
590 KdPrint((" FSCTL_INVALIDATE_VOLUMES failed, error %x\n", GetLastError()));
592 if(DeviceIoControl(h
,IOCTL_UDF_INVALIDATE_VOLUMES
,&h
,sizeof(h
),NULL
,0,&returned
,NULL
) ) {
593 KdPrint((" IOCTL_UDF_INVALIDATE_VOLUMES ok, status %x\n", GetLastError()));
597 KdPrint((" IOCTL_UDF_INVALIDATE_VOLUMES, error %x\n", GetLastError()));
600 UserPrint(("can't lock volume, retry\n"));
605 UserPrint(("can't lock volume\n"));
606 #ifndef NT_NATIVE_MODE
607 // In native mode the volume can be not mounted yet !!!
612 #endif //NT_NATIVE_MODE
615 if(!DeviceIoControl(h
,FSCTL_ALLOW_EXTENDED_DASD_IO
,NULL
,0,NULL
,0,&returned
,NULL
)) {
616 KdPrint(("Warning: can't allow extended DASD i/o\n"));
620 KdPrint((" opened, h=%x\n", h
));
625 #ifndef NT_NATIVE_MODE
626 h
= CreateFileW(deviceNameBuffer
, GENERIC_READ
,
630 FILE_ATTRIBUTE_NORMAL
, NULL
);
631 #else //NT_NATIVE_MODE
632 RC
= NtCreateFile(&h
,
633 GENERIC_READ
| SYNCHRONIZE
| FILE_READ_ATTRIBUTES
,
637 FILE_ATTRIBUTE_NORMAL
,
640 FILE_SYNCHRONOUS_IO_NONALERT
| FILE_COMPLETE_IF_OPLOCKED
| FILE_WRITE_THROUGH
,
643 if(!NT_SUCCESS(RC
)) {
646 #endif //NT_NATIVE_MODE
647 if(h
!= ((HANDLE
)-1)) {
649 KdPrint((" opened R/O, h=%x\n", h
));
651 my_retrieve_vol_type(Vcb
, fn
);
653 my_retrieve_vol_type(fn
);
656 UserPrint(("read-only open\n"));
657 if(!NT_SUCCESS(MyLockVolume(h
,pLockMode
))) {
659 if(retry
< MAX_INVALIDATE_VOLUME_RETRY
) {
661 if(!Privilege(SE_TCB_NAME
, TRUE
)) {
662 KdPrint(("SE_TCB privilege not held\n"));
664 if(DeviceIoControl(h
,FSCTL_INVALIDATE_VOLUMES
,&h
,sizeof(h
),NULL
,0,&returned
,NULL
) ) {
668 UserPrint(("can't lock read-only volumem retry"));
673 UserPrint(("can't lock read-only volume"));
674 #ifndef NT_NATIVE_MODE
679 #endif //NT_NATIVE_MODE
681 // write_cdfs = TRUE;
682 // DeviceIoControl(h,FSCTL_DISMOUNT_VOLUME,NULL,0,NULL,0,&returned,NULL);
685 #ifndef NT_NATIVE_MODE
687 #endif //NT_NATIVE_MODE
690 #ifdef UDF_FORMAT_MEDIA
693 open_as_device
= FALSE
;
694 // open as plain file
695 Vcb
->PhDeviceType
= FILE_DEVICE_DISK
;
698 UserPrint(("try image file\n"));
699 #ifndef NT_NATIVE_MODE
700 h
= CreateFileW(fn
, GENERIC_READ
| GENERIC_WRITE
,
704 FILE_ATTRIBUTE_NORMAL
, NULL
);
705 #else //NT_NATIVE_MODE
706 RC
= NtCreateFile(&h
,
707 GENERIC_READ
| SYNCHRONIZE
,
711 FILE_ATTRIBUTE_NORMAL
,
714 FILE_SYNCHRONOUS_IO_NONALERT
| FILE_COMPLETE_IF_OPLOCKED
| FILE_WRITE_THROUGH
,
717 if(!NT_SUCCESS(RC
)) {
720 #endif //NT_NATIVE_MODE
721 if(h
== ((HANDLE
)-1)) {
727 #ifdef UDF_FORMAT_MEDIA
730 MKUDF_CANT_LOCK_VOL
);
736 UserPrint(("error opening device or image file"));
738 #ifdef UDF_FORMAT_MEDIA
741 MKUDF_CANT_OPEN_FILE
);
746 KdPrint((" opened as file, h=%x\n", h
));
763 LONG offh
= (ULONG
)(offset
>>32);
765 offl
= SetFilePointer(fd
, (ULONG
)offset
, &offh
, whence
);
766 if(offl
== -1 && offh
== -1) {
769 return (((uint64
)offh
) << 32) | (uint64
)offl
;
770 } // end udf_lseek64()
775 IN PDEVICE_OBJECT DeviceObject
,
783 RC
= _lphUdf
->lpGetSizeFunc(_lphUdf
->lpParameter
, &sz
, &bs
);
785 (*blocks
) = (ULONG
)(sz
/bs
);
787 return(OS_SUCCESS(RC
));
791 #include "string_lib.cpp"
798 PDEVICE_OBJECT DeviceObject
801 if(DeviceObject
&& DeviceObject
== Vcb
->TargetDeviceObject
) {
802 return Vcb
->PhDeviceType
;
804 return FILE_DEVICE_DISK
;
805 } // end UDFGetDevType()
811 PDEVICE_OBJECT DeviceObject
814 #define lphUdf ((PUDF_VOL_HANDLE_I)(DeviceObject->lpContext))
815 return lphUdf
->bHddDevice
? FILE_DEVICE_DISK
: FILE_DEVICE_CD_ROM
;
817 } // end UDFGetDevType()
821 #endif //_BROWSE_UDF_
825 #ifndef NT_NATIVE_MODE
827 #ifdef PRINT_DBG_CONSOLE
828 CHAR dbg_print_tmp_buff
[2048];
830 BOOLEAN was_enter
= TRUE
;
841 va_start(ap
, DebugMessage
);
844 strcpy(&dbg_print_tmp_buff
[0], JS_DBG_PREFIX
);
845 len
= _vsnprintf(&dbg_print_tmp_buff
[sizeof(JS_DBG_PREFIX
)-1], 2047-sizeof(JS_DBG_PREFIX
), DebugMessage
, ap
);
847 len
= _vsnprintf(&dbg_print_tmp_buff
[0], 2047, DebugMessage
, ap
);
849 dbg_print_tmp_buff
[2047] = 0;
851 (dbg_print_tmp_buff
[len
-1] == '\n' ||
852 dbg_print_tmp_buff
[len
-1] == '\r') ) {
858 OutputDebugString(&dbg_print_tmp_buff
[0]);
862 } // end PrintDbgConsole()
863 #else // PRINT_DBG_CONSOLE
870 } // end ClassDebugPrint()
871 #endif //PRINT_DBG_CONSOLE
875 IN PTIME_FIELDS TimeFields
,
876 IN PLARGE_INTEGER Time
881 st
.wYear
= TimeFields
->Year
;
882 st
.wMonth
= TimeFields
->Month
;
884 st
.wDay
= TimeFields
->Day
;
885 st
.wHour
= TimeFields
->Hour
;
886 st
.wMinute
= TimeFields
->Minute
;
887 st
.wSecond
= TimeFields
->Second
;
888 st
.wMilliseconds
= TimeFields
->Milliseconds
;
890 return SystemTimeToFileTime(&st
, (PFILETIME
)Time
);
891 } // end RtlTimeFieldsToTime()
895 IN PLARGE_INTEGER Time
,
896 IN PTIME_FIELDS TimeFields
902 retval
= FileTimeToSystemTime((PFILETIME
)Time
, &st
);
904 TimeFields
->Year
= st
.wYear
;
905 TimeFields
->Month
= st
.wMonth
;
906 TimeFields
->Weekday
= st
.wDayOfWeek
;
907 TimeFields
->Day
= st
.wDay
;
908 TimeFields
->Hour
= st
.wHour
;
909 TimeFields
->Minute
= st
.wMinute
;
910 TimeFields
->Second
= st
.wSecond
;
911 TimeFields
->Milliseconds
= st
.wMilliseconds
;
916 #endif //NT_NATIVE_MODE
918 #ifdef USE_THREAD_HEAPS
920 HANDLE MemLock
= NULL
;
925 MemLock
= CreateMutex(NULL
, 0, NULL
);
929 ExDeInitThreadPools()
932 CloseHandle(MemLock
);
935 #define MAX_THREADS_WITH_OWN_POOL 128
937 typedef struct _THREAD_POOL_LIST_ITEM
{
940 } THREAD_POOL_LIST_ITEM
, *PTHREAD_POOL_LIST_ITEM
;
942 ULONG LastThreadPool
= -1;
943 THREAD_POOL_LIST_ITEM ThreadPoolList
[MAX_THREADS_WITH_OWN_POOL
];
947 #ifdef KERNEL_MODE_MM_BEHAVIOR
957 ULONG ThreadId
= GetCurrentThreadId();
958 BOOLEAN found
= FALSE
;
960 WaitForSingleObject(MemLock
,-1);
962 for(i
=0; i
<(LastThreadPool
+1); i
++) {
963 if(ThreadPoolList
[i
].ThreadId
== ThreadId
) {
969 ReleaseMutex(MemLock
);
970 return HeapAlloc(ThreadPoolList
[i
].HeapHandle
, HEAP_NO_SERIALIZE
, Size
);
972 for(i
=0; i
<(LastThreadPool
+1); i
++) {
973 if(ThreadPoolList
[i
].ThreadId
== -1) {
977 if(i
>=MAX_THREADS_WITH_OWN_POOL
) {
978 ReleaseMutex(MemLock
);
981 ThreadPoolList
[i
].ThreadId
= ThreadId
;
982 ThreadPoolList
[i
].HeapHandle
= HeapCreate(HEAP_NO_SERIALIZE
, 128*PAGE_SIZE
, 0);
983 if(!ThreadPoolList
[i
].HeapHandle
) {
984 ThreadPoolList
[i
].ThreadId
= -1;
985 ReleaseMutex(MemLock
);
989 if(i
+1 > LastThreadPool
+1)
992 ReleaseMutex(MemLock
);
994 return HeapAlloc(ThreadPoolList
[i
].HeapHandle
, HEAP_NO_SERIALIZE
, Size
);
996 } // end ExAllocatePool()
1000 #ifdef KERNEL_MODE_MM_BEHAVIOR
1008 ULONG ThreadId
= GetCurrentThreadId();
1011 WaitForSingleObject(MemLock
,-1);
1012 for(i
=0; i
<(LastThreadPool
+1); i
++) {
1013 if(ThreadPoolList
[i
].ThreadId
== ThreadId
) {
1017 if(i
+1 > LastThreadPool
+1) {
1023 HeapFree(ThreadPoolList
[i
].HeapHandle
, HEAP_NO_SERIALIZE
, Addr
);
1025 ReleaseMutex(MemLock
);
1027 } // end ExFreePool()
1033 ULONG ThreadId
= GetCurrentThreadId();
1036 WaitForSingleObject(MemLock
,-1);
1037 for(i
=0; i
<(LastThreadPool
+1); i
++) {
1038 if(ThreadPoolList
[i
].ThreadId
== ThreadId
) {
1042 if(i
+1 > LastThreadPool
+1) {
1048 HeapDestroy(ThreadPoolList
[i
].HeapHandle
);
1049 ThreadPoolList
[i
].HeapHandle
= INVALID_HANDLE_VALUE
;
1050 ThreadPoolList
[i
].ThreadId
= -1;
1052 ReleaseMutex(MemLock
);
1055 #endif //USE_THREAD_HEAPS
1057 #if defined(KERNEL_MODE_MM_BEHAVIOR)
1067 if(Size
< PAGE_SIZE
) {
1068 #ifdef USE_THREAD_HEAPS
1069 Addr
= _ExAllocatePool_(MemoryType
, Size
+8);
1071 Addr
= GlobalAlloc(GMEM_DISCARDABLE
, Size
+8);
1075 uAddr
= ((PCHAR
)Addr
)+8;
1077 #ifdef USE_THREAD_HEAPS
1078 Addr
= _ExAllocatePool_(MemoryType
, Size
+PAGE_SIZE
*2);
1080 Addr
= GlobalAlloc(GMEM_DISCARDABLE
, Size
+PAGE_SIZE
*2);
1084 uAddr
= (PVOID
)(((ULONG
)(((PCHAR
)Addr
)+PAGE_SIZE
)) & ~(PAGE_SIZE
-1));
1086 *(((PULONG
)uAddr
)-2) = (ULONG
)Addr
;
1087 *(((PULONG
)uAddr
)-1) = 0xFEDCBA98;
1089 } // end ExAllocatePool()
1099 if(*(((PULONG
)uAddr
)-1) == 0xFEDCBA98) {
1100 Addr
= (PVOID
)(*(((PULONG
)uAddr
)-2));
1101 #ifdef USE_THREAD_HEAPS
1109 } // end ExFreePool()
1110 #endif //defined(KERNEL_MODE_MM_BEHAVIOR) || defined(NT_NATIVE_MODE)
1126 if(!MemPtr
&& !Length
)
1128 if(!MemPtr
|| !Length
)
1131 a
= ((PCHAR
)MemPtr
)[Length
-1];
1133 ((PCHAR
)MemPtr
)[Length
-1] = a
;
1135 for(i
=0; i
<Length
; i
+=PAGE_SIZE
) {
1136 a
= ((PCHAR
)MemPtr
)[i
];
1138 ((PCHAR
)MemPtr
)[i
] = a
;
1141 } _SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER
) {
1145 } // end ProbeMemory()
1147 #ifdef NT_NATIVE_MODE
1148 #include "env_spec_nt.cpp"
1149 #endif //NT_NATIVE_MODE