source: trunk/src/kernel32/hmdevio.cpp@ 7630

Last change on this file since 7630 was 7630, checked in by sandervl, 24 years ago

CancelIo & GetOverlappedResult added for custom drivers
File size: 24.8 KB
Line 
1/* $Id: hmdevio.cpp,v 1.23 2001-12-14 10:22:38 sandervl Exp $ */
2
3/*
4 * Win32 Device IOCTL API functions for OS/2
5 *
6 * Copyright 1998 Sander van Leeuwen
7 *
8 *
9 * Project Odin Software License can be found in LICENSE.TXT
10 *
11 */
12#define INCL_DOSPROFILE
13#define INCL_DOSDEVICES
14#define INCL_DOSDEVIOCTL
15#define INCL_GPI
16#define INCL_DOSFILEMGR /* File Manager values */
17#define INCL_DOSERRORS /* DOS Error values */
18#define INCL_DOSPROCESS /* DOS Process values */
19#define INCL_DOSMISC /* DOS Miscellanous values */
20#include <os2wrap.h> //Odin32 OS/2 api wrappers
21#include <string.h>
22#include <stdio.h>
23
24#include <win32type.h>
25#include <win32api.h>
26#include <misc.h>
27#include <win\winioctl.h>
28#include "hmdevio.h"
29#include "cio.h"
30#include "map.h"
31#include "exceptutil.h"
32#include "oslibdos.h"
33
34#define DBG_LOCALLOG DBG_hmdevio
35#include "dbglocal.h"
36
37static BOOL fX86Init = FALSE;
38//SvL: Used in iccio.asm (how can you put these in the .asm data segment without messing things up?)
39ULONG ioentry = 0;
40USHORT gdt = 0;
41char devname[] = "/dev/fastio$";
42
43static BOOL GpdDevIOCtl(HANDLE hDevice, DWORD dwIoControlCode, LPVOID lpInBuffer, DWORD nInBufferSize, LPVOID lpOutBuffer, DWORD nOutBufferSize, LPDWORD lpBytesReturned, LPOVERLAPPED lpOverlapped);
44static BOOL MAPMEMIOCtl(HANDLE hDevice, DWORD dwIoControlCode, LPVOID lpInBuffer, DWORD nInBufferSize, LPVOID lpOutBuffer, DWORD nOutBufferSize, LPDWORD lpBytesReturned, LPOVERLAPPED lpOverlapped);
45static BOOL FXMEMMAPIOCtl(HANDLE hDevice, DWORD dwIoControlCode, LPVOID lpInBuffer, DWORD nInBufferSize, LPVOID lpOutBuffer, DWORD nOutBufferSize, LPDWORD lpBytesReturned, LPOVERLAPPED lpOverlapped);
46static BOOL VPCIOCtl(HANDLE hDevice, DWORD dwIoControlCode, LPVOID lpInBuffer, DWORD nInBufferSize, LPVOID lpOutBuffer, DWORD nOutBufferSize, LPDWORD lpBytesReturned, LPOVERLAPPED lpOverlapped);
47
48static WIN32DRV knownDriver[] =
49 {{"\\\\.\\GpdDev", "", TRUE, 666, GpdDevIOCtl},
50 { "\\\\.\\MAPMEM", "PMAP$", FALSE, 0, MAPMEMIOCtl},
51 { "FXMEMMAP.VXD", "PMAP$", FALSE, 0, FXMEMMAPIOCtl},
52 };
53
54static int nrKnownDrivers = sizeof(knownDriver)/sizeof(WIN32DRV);
55BOOL fVirtualPC = FALSE;
56
57//******************************************************************************
58//******************************************************************************
59void RegisterDevices()
60{
61 HMDeviceDriver *driver;
62 DWORD rc;
63
64 for(int i=0;i<nrKnownDrivers;i++)
65 {
66 driver = new HMDeviceDriver(knownDriver[i].szWin32Name,
67 knownDriver[i].szOS2Name,
68 knownDriver[i].fCreateFile,
69 knownDriver[i].devIOCtl);
70
71 rc = HMDeviceRegister(knownDriver[i].szWin32Name, driver);
72 if (rc != NO_ERROR) /* check for errors */
73 dprintf(("KERNEL32:RegisterDevices: registering %s failed with %u.\n",
74 knownDriver[i].szWin32Name, rc));
75 }
76
77 //check registry for Odin driver plugin dlls
78 HKEY hkDrivers, hkDrvDll;
79
80 rc = RegOpenKeyExA(HKEY_LOCAL_MACHINE,
81 "System\\CurrentControlSet\\Services",
82 0, KEY_READ, &hkDrivers);
83
84 if(rc == 0) {
85 char szDllName[CCHMAXPATH];
86 char szKeyName[CCHMAXPATH];
87 char szDrvName[CCHMAXPATH];
88 DWORD dwType, dwSize;
89 int iSubKey = 0;
90
91 while(rc == 0) {
92 rc = RegEnumKeyA(hkDrivers, iSubKey++, szKeyName, sizeof(szKeyName));
93 if(rc) break;
94
95 rc = RegOpenKeyExA(hkDrivers, szKeyName,
96 0, KEY_READ, &hkDrvDll);
97 if(rc == 0) {
98 dwSize = sizeof(szDllName);
99 rc = RegQueryValueExA(hkDrvDll,
100 "DllName",
101 NULL,
102 &dwType,
103 (LPBYTE)szDllName,
104 &dwSize);
105
106 RegCloseKey(hkDrvDll);
107 if(rc == 0 && dwType == REG_SZ)
108 {
109 HINSTANCE hDrvDll = LoadLibraryA(szDllName);
110 if(hDrvDll)
111 {
112 sprintf(szDrvName, "\\\\.\\%s", szKeyName);
113 driver = new HMCustomDriver(hDrvDll, szDrvName);
114
115 rc = HMDeviceRegister(szDrvName, driver);
116 if (rc != NO_ERROR) /* check for errors */
117 dprintf(("KERNEL32:RegisterDevices: registering %s failed with %u.\n", szDrvName, rc));
118
119 // @@@PH
120 // there should be an symbolic link:
121 // "\\.\drvname$" -> "drvname$"
122 }
123 }
124 rc = 0;
125 }
126 }
127 RegCloseKey(hkDrivers);
128 }
129
130 return;
131}
132//******************************************************************************
133//******************************************************************************
134BOOL WIN32API RegisterCustomDriver(PFNDRVOPEN pfnDriverOpen, PFNDRVCLOSE pfnDriverClose,
135 PFNDRVIOCTL pfnDriverIOCtl, PFNDRVREAD pfnDriverRead,
136 PFNDRVWRITE pfnDriverWrite, PFNDRVCANCELIO pfnDriverCancelIo,
137 PFNDRVGETOVERLAPPEDRESULT pfnDriverGetOverlappedResult,
138 LPCSTR lpDeviceName)
139{
140 HMDeviceDriver *driver;
141 DWORD rc;
142
143 driver = new HMCustomDriver(pfnDriverOpen, pfnDriverClose, pfnDriverIOCtl, pfnDriverRead, pfnDriverWrite, pfnDriverCancelIo, pfnDriverGetOverlappedResult, lpDeviceName);
144 if(driver == NULL) {
145 DebugInt3();
146 return FALSE;
147 }
148 rc = HMDeviceRegister((LPSTR)lpDeviceName, driver);
149 if (rc != NO_ERROR) { /* check for errors */
150 dprintf(("KERNEL32:RegisterDevices: registering %s failed with %u.\n", lpDeviceName, rc));
151 return FALSE;
152 }
153 return TRUE;
154}
155//******************************************************************************
156//******************************************************************************
157HMDeviceDriver::HMDeviceDriver(LPCSTR lpDeviceName, LPSTR lpOS2DevName, BOOL fCreate,
158 WINIOCTL pDevIOCtl)
159 : HMDeviceKernelObjectClass(lpDeviceName)
160{
161 this->fCreateFile = fCreateFile;
162 this->szOS2Name = lpOS2DevName;
163 this->devIOCtl = pDevIOCtl;
164}
165//******************************************************************************
166//******************************************************************************
167HMDeviceDriver::HMDeviceDriver(LPCSTR lpDeviceName)
168 : HMDeviceKernelObjectClass(lpDeviceName)
169{
170}
171//******************************************************************************
172//******************************************************************************
173DWORD HMDeviceDriver::CreateFile (LPCSTR lpFileName,
174 PHMHANDLEDATA pHMHandleData,
175 PVOID lpSecurityAttributes,
176 PHMHANDLEDATA pHMHandleDataTemplate)
177{
178 APIRET rc;
179 HFILE hfFileHandle = 0L; /* Handle for file being manipulated */
180 ULONG ulAction = 0; /* Action taken by DosOpen */
181 ULONG sharetype = 0;
182
183 if(pHMHandleData->dwAccess & (GENERIC_READ | GENERIC_WRITE))
184 sharetype |= OPEN_ACCESS_READWRITE;
185 else
186 if(pHMHandleData->dwAccess & GENERIC_WRITE)
187 sharetype |= OPEN_ACCESS_WRITEONLY;
188
189 if(pHMHandleData->dwShare == 0)
190 sharetype |= OPEN_SHARE_DENYREADWRITE;
191 else
192 if(pHMHandleData->dwShare & (FILE_SHARE_READ | FILE_SHARE_WRITE))
193 sharetype |= OPEN_SHARE_DENYNONE;
194 else
195 if(pHMHandleData->dwShare & FILE_SHARE_WRITE)
196 sharetype |= OPEN_SHARE_DENYREAD;
197 else
198 if(pHMHandleData->dwShare & FILE_SHARE_READ)
199 sharetype |= OPEN_SHARE_DENYWRITE;
200
201 if(szOS2Name[0] == 0) {
202 pHMHandleData->hHMHandle = 0;
203 return (NO_ERROR);
204 }
205
206tryopen:
207 rc = DosOpen( szOS2Name, /* File path name */
208 &hfFileHandle, /* File handle */
209 &ulAction, /* Action taken */
210 0,
211 FILE_NORMAL,
212 FILE_OPEN,
213 sharetype,
214 0L); /* No extended attribute */
215
216 if(rc == ERROR_TOO_MANY_OPEN_FILES) {
217 ULONG CurMaxFH;
218 LONG ReqCount = 32;
219
220 rc = DosSetRelMaxFH(&ReqCount, &CurMaxFH);
221 if(rc) {
222 dprintf(("DosSetRelMaxFH returned %d", rc));
223 return error2WinError(rc);
224 }
225 dprintf(("DosOpen failed -> increased nr open files to %d", CurMaxFH));
226 goto tryopen;
227 }
228
229 dprintf(("DosOpen %s returned %d\n", szOS2Name, rc));
230
231 if(rc == NO_ERROR)
232 {
233 pHMHandleData->hHMHandle = hfFileHandle;
234 return (NO_ERROR);
235 }
236 else
237 return(error2WinError(rc));
238}
239//******************************************************************************
240//******************************************************************************
241BOOL HMDeviceDriver::CloseHandle(PHMHANDLEDATA pHMHandleData)
242{
243 DWORD rc = 0;
244
245 if(pHMHandleData->hHMHandle) {
246 rc = DosClose(pHMHandleData->hHMHandle);
247 }
248 pHMHandleData->hHMHandle = 0;
249 return rc;
250}
251//******************************************************************************
252//******************************************************************************
253BOOL HMDeviceDriver::DeviceIoControl(PHMHANDLEDATA pHMHandleData, DWORD dwIoControlCode,
254 LPVOID lpInBuffer, DWORD nInBufferSize,
255 LPVOID lpOutBuffer, DWORD nOutBufferSize,
256 LPDWORD lpBytesReturned, LPOVERLAPPED lpOverlapped)
257{
258 return devIOCtl(pHMHandleData->hHMHandle, dwIoControlCode, lpInBuffer, nInBufferSize,
259 lpOutBuffer, nOutBufferSize, lpBytesReturned, lpOverlapped);
260}
261//******************************************************************************
262//******************************************************************************
263static BOOL GpdDevIOCtl(HANDLE hDevice, DWORD dwIoControlCode, LPVOID lpInBuffer, DWORD nInBufferSize, LPVOID lpOutBuffer, DWORD nOutBufferSize, LPDWORD lpBytesReturned, LPOVERLAPPED lpOverlapped)
264{
265 ULONG port, val = 0;
266
267 if(fX86Init == FALSE) {
268 if(io_init() == 0)
269 fX86Init = TRUE;
270 else return(FALSE);
271 }
272
273 *lpBytesReturned = 0;
274
275 port = ((GENPORT_WRITE_INPUT *)lpInBuffer)->PortNumber;
276
277 switch((dwIoControlCode >> 2) & 0xFFF) {
278 case IOCTL_GPD_READ_PORT_UCHAR:
279 if(nOutBufferSize < sizeof(char))
280 return(FALSE);
281
282 val = c_inb(port);
283 *(char *)lpOutBuffer = val;
284 *lpBytesReturned = sizeof(char);
285 break;
286 case IOCTL_GPD_READ_PORT_USHORT:
287 if(nOutBufferSize < sizeof(USHORT))
288 return(FALSE);
289
290 val = c_inw(port);
291 *(USHORT *)lpOutBuffer = val;
292 *lpBytesReturned = sizeof(USHORT);
293 break;
294 case IOCTL_GPD_READ_PORT_ULONG:
295 if(nOutBufferSize < sizeof(ULONG))
296 return(FALSE);
297
298 val = c_inl(port);
299 *(ULONG *)lpOutBuffer = val;
300 *lpBytesReturned = sizeof(ULONG);
301 break;
302 case IOCTL_GPD_WRITE_PORT_UCHAR:
303 val = ((GENPORT_WRITE_INPUT *)lpInBuffer)->CharData;
304 c_outb(port, val);
305 break;
306 case IOCTL_GPD_WRITE_PORT_USHORT:
307 val = ((GENPORT_WRITE_INPUT *)lpInBuffer)->ShortData;
308 c_outw(port, val);
309 break;
310 case IOCTL_GPD_WRITE_PORT_ULONG:
311 val = ((GENPORT_WRITE_INPUT *)lpInBuffer)->LongData;
312 c_outl(port, val);
313 break;
314 default:
315 dprintf(("GpdDevIOCtl unknown func %X\n", (dwIoControlCode >> 2) & 0xFFF));
316 return(FALSE);
317 }
318
319 return(TRUE);
320}
321//******************************************************************************
322//******************************************************************************
323static BOOL MAPMEMIOCtl(HANDLE hDevice, DWORD dwIoControlCode, LPVOID lpInBuffer, DWORD nInBufferSize, LPVOID lpOutBuffer, DWORD nOutBufferSize, LPDWORD lpBytesReturned, LPOVERLAPPED lpOverlapped)
324{
325 PHYSICAL_MEMORY_INFO *meminfo = (PHYSICAL_MEMORY_INFO *)lpInBuffer;
326 struct map_ioctl memmap;
327
328 *lpBytesReturned = 0;
329
330 switch((dwIoControlCode >> 2) & 0xFFF) {
331 case IOCTL_MAPMEM_MAP_USER_PHYSICAL_MEMORY:
332 if(nInBufferSize != sizeof(PHYSICAL_MEMORY_INFO))
333 return(FALSE);
334
335 memmap.a.phys = meminfo->BusAddress.u.LowPart;
336 memmap.size = meminfo->Length;
337 dprintf(("DeviceIoControl map phys address %X length %X\n", memmap.a.phys, memmap.size));
338 if(mpioctl((HFILE)hDevice, IOCTL_MAP, &memmap) == -1) {
339 dprintf(("mpioctl failed!\n"));
340 return(FALSE);
341 }
342
343 dprintf(("DeviceIoControl map virt address = %X\n", memmap.a.user));
344 *(ULONG *)lpOutBuffer = (ULONG)memmap.a.user;
345 break;
346 case IOCTL_MAPMEM_UNMAP_USER_PHYSICAL_MEMORY:
347 dprintf(("Unmap mapping %X\n", *(ULONG *)lpInBuffer));
348 memmap.a.phys = *(ULONG *)lpInBuffer;
349 memmap.size = 0;
350 if(mpioctl((HFILE)hDevice, IOCTL_MAP, &memmap) == -1)
351 return(FALSE);
352 break;
353 default:
354 dprintf(("MAPMEMIOCtl unknown func %X\n", (dwIoControlCode >> 2) & 0xFFF));
355 return(FALSE);
356 }
357
358 return(TRUE);
359}
360//******************************************************************************
361//******************************************************************************
362static BOOL FXMEMMAPIOCtl(HANDLE hDevice, DWORD dwIoControlCode, LPVOID lpInBuffer, DWORD nInBufferSize, LPVOID lpOutBuffer, DWORD nOutBufferSize, LPDWORD lpBytesReturned, LPOVERLAPPED lpOverlapped)
363{
364 struct map_ioctl memmap;
365 MAPDEVREQUEST *vxdmem = (MAPDEVREQUEST *)lpInBuffer;
366
367 switch(dwIoControlCode) {
368 case 1:
369 break;
370 case 2:
371 memmap.a.phys = (DWORD)vxdmem->mdr_PhysicalAddress;
372 memmap.size = vxdmem->mdr_SizeInBytes;
373 dprintf(("DeviceIoControl map phys address %X length %X\n", memmap.a.phys, memmap.size));
374 if(mpioctl((HFILE)hDevice, IOCTL_MAP, &memmap) == -1) {
375 dprintf(("mpioctl failed!\n"));
376 return(FALSE);
377 }
378
379 dprintf(("DeviceIoControl map virt address = %X\n", memmap.a.user));
380 vxdmem->mdr_LinearAddress = (PVOID)memmap.a.user;
381 break;
382 default:
383 dprintf(("FXMEMMAPIOCtl unknown func %X\n", (dwIoControlCode >> 2) & 0xFFF));
384 return(FALSE);
385 }
386
387 return(TRUE);
388}
389//******************************************************************************
390//******************************************************************************
391HMCustomDriver::HMCustomDriver(HINSTANCE hInstance, LPCSTR lpDeviceName)
392 : HMDeviceDriver(lpDeviceName), hDrvDll(0)
393{
394 hDrvDll = hInstance ;
395 pfnDriverOpen = (PFNDRVOPEN) GetProcAddress(hDrvDll, "DrvOpen");
396 pfnDriverClose = (PFNDRVCLOSE)GetProcAddress(hDrvDll, "DrvClose");
397 pfnDriverRead = (PFNDRVREAD) GetProcAddress(hDrvDll, "DrvRead");
398 pfnDriverWrite = (PFNDRVWRITE)GetProcAddress(hDrvDll, "DrvWrite");
399 pfnDriverIOCtl = (PFNDRVIOCTL)GetProcAddress(hDrvDll, "DrvIOCtl");
400}
401//******************************************************************************
402//******************************************************************************
403HMCustomDriver::HMCustomDriver(PFNDRVOPEN pfnDriverOpen, PFNDRVCLOSE pfnDriverClose,
404 PFNDRVIOCTL pfnDriverIOCtl, PFNDRVREAD pfnDriverRead,
405 PFNDRVWRITE pfnDriverWrite, PFNDRVCANCELIO pfnDriverCancelIo,
406 PFNDRVGETOVERLAPPEDRESULT pfnDriverGetOverlappedResult,
407 LPCSTR lpDeviceName)
408 : HMDeviceDriver(lpDeviceName), hDrvDll(0)
409{
410 if(!pfnDriverOpen || !pfnDriverClose) {
411 DebugInt3();
412 }
413 this->pfnDriverOpen = pfnDriverOpen;
414 this->pfnDriverClose = pfnDriverClose;
415 this->pfnDriverIOCtl = pfnDriverIOCtl;
416 this->pfnDriverRead = pfnDriverRead;
417 this->pfnDriverWrite = pfnDriverWrite;
418 this->pfnDriverCancelIo = pfnDriverCancelIo;
419 this->pfnDriverGetOverlappedResult = pfnDriverGetOverlappedResult;
420}
421//******************************************************************************
422//******************************************************************************
423HMCustomDriver::~HMCustomDriver()
424{
425 if(hDrvDll) FreeLibrary(hDrvDll);
426}
427//******************************************************************************
428//******************************************************************************
429DWORD HMCustomDriver::CreateFile (LPCSTR lpFileName,
430 PHMHANDLEDATA pHMHandleData,
431 PVOID lpSecurityAttributes,
432 PHMHANDLEDATA pHMHandleDataTemplate)
433{
434 pHMHandleData->hHMHandle = pfnDriverOpen(pHMHandleData->dwAccess, pHMHandleData->dwShare);
435 if(pHMHandleData->hHMHandle == INVALID_HANDLE_VALUE_W) {
436 return GetLastError();
437 }
438 return ERROR_SUCCESS_W;
439}
440//******************************************************************************
441//******************************************************************************
442BOOL HMCustomDriver::CloseHandle(PHMHANDLEDATA pHMHandleData)
443{
444 if(pHMHandleData->hHMHandle) {
445 pfnDriverClose(pHMHandleData->hHMHandle);
446 }
447 pHMHandleData->hHMHandle = 0;
448 return TRUE;
449}
450//******************************************************************************
451//******************************************************************************
452BOOL HMCustomDriver::DeviceIoControl(PHMHANDLEDATA pHMHandleData, DWORD dwIoControlCode,
453 LPVOID lpInBuffer, DWORD nInBufferSize,
454 LPVOID lpOutBuffer, DWORD nOutBufferSize,
455 LPDWORD lpBytesReturned, LPOVERLAPPED lpOverlapped)
456{
457 BOOL ret;
458
459 if(pfnDriverIOCtl == NULL) {
460 dprintf(("HMCustomDriver::DeviceIoControl: pfnDriverIOCtl == NULL"));
461 ::SetLastError(ERROR_INVALID_FUNCTION_W);
462 return FALSE;
463 }
464
465 ret = pfnDriverIOCtl(pHMHandleData->hHMHandle, dwIoControlCode, lpInBuffer, nInBufferSize,
466 lpOutBuffer, nOutBufferSize, lpBytesReturned, lpOverlapped);
467 dprintf(("DeviceIoControl %x returned %d", dwIoControlCode, ret));
468 return ret;
469}
470/*****************************************************************************
471 * Name : BOOL HMCustomDriver::ReadFile
472 * Purpose : read data from handle / device
473 * Parameters: PHMHANDLEDATA pHMHandleData,
474 * LPCVOID lpBuffer,
475 * DWORD nNumberOfBytesToRead,
476 * LPDWORD lpNumberOfBytesRead,
477 * LPOVERLAPPED lpOverlapped
478 * LPOVERLAPPED_COMPLETION_ROUTINE lpCompletionRoutine
479 * Variables :
480 * Result : Boolean
481 * Remark :
482 * Status :
483 *
484 * Author : SvL
485 *****************************************************************************/
486
487BOOL HMCustomDriver::ReadFile(PHMHANDLEDATA pHMHandleData,
488 LPCVOID lpBuffer,
489 DWORD nNumberOfBytesToRead,
490 LPDWORD lpNumberOfBytesRead,
491 LPOVERLAPPED lpOverlapped,
492 LPOVERLAPPED_COMPLETION_ROUTINE lpCompletionRoutine)
493{
494 BOOL ret;
495
496 if(pfnDriverRead == NULL) {
497 dprintf(("HMCustomDriver::ReadFile: pfnDriverRead == NULL"));
498 ::SetLastError(ERROR_INVALID_FUNCTION_W);
499 return FALSE;
500 }
501 ret = pfnDriverRead(pHMHandleData->hHMHandle, lpBuffer, nNumberOfBytesToRead,
502 lpNumberOfBytesRead, lpOverlapped, lpCompletionRoutine);
503 dprintf(("pfnDriverRead %x %x %x %x %x %x returned %x", pHMHandleData->hHMHandle, lpBuffer, nNumberOfBytesToRead,
504 lpNumberOfBytesRead, lpOverlapped, lpCompletionRoutine, ret));
505 return ret;
506}
507/*****************************************************************************
508 * Name : BOOL HMCustomDriver::WriteFile
509 * Purpose : write data to handle / device
510 * Parameters: PHMHANDLEDATA pHMHandleData,
511 * LPCVOID lpBuffer,
512 * DWORD nNumberOfBytesToWrite,
513 * LPDWORD lpNumberOfBytesWritten,
514 * LPOVERLAPPED lpOverlapped
515 * LPOVERLAPPED_COMPLETION_ROUTINE lpCompletionRoutine
516 * Variables :
517 * Result : Boolean
518 * Remark :
519 * Status :
520 *
521 * Author : SvL
522 *****************************************************************************/
523
524BOOL HMCustomDriver::WriteFile(PHMHANDLEDATA pHMHandleData,
525 LPCVOID lpBuffer,
526 DWORD nNumberOfBytesToWrite,
527 LPDWORD lpNumberOfBytesWritten,
528 LPOVERLAPPED lpOverlapped,
529 LPOVERLAPPED_COMPLETION_ROUTINE lpCompletionRoutine)
530{
531 BOOL ret;
532
533 if(pfnDriverWrite == NULL) {
534 dprintf(("HMCustomDriver::WriteFile: pfnDriverWrite == NULL"));
535 ::SetLastError(ERROR_INVALID_FUNCTION_W);
536 return FALSE;
537 }
538 ret = pfnDriverWrite(pHMHandleData->hHMHandle, lpBuffer, nNumberOfBytesToWrite,
539 lpNumberOfBytesWritten, lpOverlapped, lpCompletionRoutine);
540 dprintf(("pfnDriverWrite %x %x %x %x %x %x returned %x", pHMHandleData->hHMHandle, lpBuffer, nNumberOfBytesToWrite,
541 lpNumberOfBytesWritten, lpOverlapped, lpCompletionRoutine, ret));
542 return ret;
543}
544/*****************************************************************************
545 * Name : DWORD HMCustomDriver::CancelIo
546 * Purpose : cancel pending IO operation
547 * Variables :
548 * Result :
549 * Remark :
550 * Status :
551 *
552 * Author : SvL
553 *****************************************************************************/
554BOOL HMCustomDriver::CancelIo(PHMHANDLEDATA pHMHandleData)
555{
556 BOOL ret;
557
558 if(pfnDriverCancelIo == NULL) {
559 dprintf(("HMCustomDriver::CancelIo: pfnDriverCancelIo == NULL"));
560 ::SetLastError(ERROR_INVALID_FUNCTION_W);
561 return FALSE;
562 }
563 ret = pfnDriverCancelIo(pHMHandleData->hHMHandle);
564 dprintf(("pfnDriverCancelIo %x returned %x", pHMHandleData->hHMHandle, ret));
565 return ret;
566}
567/*****************************************************************************
568 * Name : DWORD HMCustomDriver::GetOverlappedResult
569 * Purpose : asynchronus I/O
570 * Parameters: PHMHANDLEDATA pHMHandleData
571 * LPOVERLAPPED arg2
572 * LPDWORD arg3
573 * BOOL arg4
574 * Variables :
575 * Result : API returncode
576 * Remark :
577 * Status :
578 *
579 * Author : SvL
580 *****************************************************************************/
581BOOL HMCustomDriver::GetOverlappedResult(PHMHANDLEDATA pHMHandleData,
582 LPOVERLAPPED lpOverlapped,
583 LPDWORD lpcbTransfer,
584 BOOL fWait)
585{
586 dprintf(("KERNEL32-HMCustomDriver: HMCustomDriver::GetOverlappedResult(%08xh,%08xh,%08xh,%08xh)",
587 pHMHandleData->hHMHandle, lpOverlapped, lpcbTransfer, fWait));
588
589 if(!(pHMHandleData->dwFlags & FILE_FLAG_OVERLAPPED_W)) {
590 dprintf(("!WARNING!: GetOverlappedResult called for a handle that wasn't opened with FILE_FLAG_OVERLAPPED"));
591 return TRUE; //NT4, SP6 doesn't fail
592 }
593 if(!lpOverlapped) {
594 ::SetLastError(ERROR_INVALID_PARAMETER);
595 return FALSE;
596 }
597 if(pfnDriverGetOverlappedResult == NULL) {
598 dprintf(("HMCustomDriver::GetOverlappedResult: pfnDriverGetOverlappedResult == NULL"));
599 ::SetLastError(ERROR_INVALID_FUNCTION_W);
600 return FALSE;
601 }
602 return pfnDriverGetOverlappedResult(pHMHandleData->hHMHandle, lpOverlapped, lpcbTransfer, fWait);
603}
604//******************************************************************************
605//******************************************************************************
606BOOL WIN32API QueryPerformanceCounter(LARGE_INTEGER *lpPerformanceCount)
607{
608 QWORD time;
609 APIRET rc;
610
611 rc = DosTmrQueryTime(&time);
612 if(rc) {
613 dprintf(("DosTmrQueryTime returned %d\n", rc));
614 return(FALSE);
615 }
616 lpPerformanceCount->u.LowPart = time.ulLo;
617 lpPerformanceCount->u.HighPart = time.ulHi;
618 return(TRUE);
619}
620//******************************************************************************
621//******************************************************************************
622BOOL WIN32API QueryPerformanceFrequency(LARGE_INTEGER *lpFrequency)
623{
624 APIRET rc;
625 ULONG freq;
626
627 rc = DosTmrQueryFreq(&freq);
628 if(rc) {
629 dprintf(("DosTmrQueryFreq returned %d\n", rc));
630 return(FALSE);
631 }
632 lpFrequency->u.LowPart = freq;
633 lpFrequency->u.HighPart = 0;
634 dprintf2(("QueryPerformanceFrequency returned 0x%X%X\n", lpFrequency->u.HighPart, lpFrequency->u.LowPart));
635 return(TRUE);
636}
637//******************************************************************************
638//******************************************************************************
Note: See TracBrowser for help on using the repository browser.