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

Last change on this file since 8325 was 8325, checked in by sandervl, 23 years ago

export RegisterCustomDriver
File size: 25.6 KB
Line 
1/* $Id: hmdevio.cpp,v 1.27 2002-04-29 16:28:37 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, NULL);
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, LPVOID lpDriverData)
139{
140 HMDeviceDriver *driver;
141 DWORD rc;
142
143 dprintf(("RegisterCustomDriver %s", lpDeviceName));
144 driver = new HMCustomDriver(pfnDriverOpen, pfnDriverClose, pfnDriverIOCtl, pfnDriverRead, pfnDriverWrite, pfnDriverCancelIo, pfnDriverGetOverlappedResult, lpDeviceName, lpDriverData);
145 if(driver == NULL) {
146 DebugInt3();
147 return FALSE;
148 }
149 rc = HMDeviceRegister((LPSTR)lpDeviceName, driver);
150 if (rc != NO_ERROR) { /* check for errors */
151 dprintf(("KERNEL32:RegisterDevices: registering %s failed with %u.\n", lpDeviceName, rc));
152 return FALSE;
153 }
154 return TRUE;
155}
156//******************************************************************************
157//******************************************************************************
158HMDeviceDriver::HMDeviceDriver(LPCSTR lpDeviceName, LPSTR lpOS2DevName, BOOL fCreate,
159 WINIOCTL pDevIOCtl)
160 : HMDeviceKernelObjectClass(lpDeviceName)
161{
162 this->fCreateFile = fCreateFile;
163 this->szOS2Name = lpOS2DevName;
164 this->devIOCtl = pDevIOCtl;
165}
166//******************************************************************************
167//******************************************************************************
168HMDeviceDriver::HMDeviceDriver(LPCSTR lpDeviceName)
169 : HMDeviceKernelObjectClass(lpDeviceName)
170{
171}
172//******************************************************************************
173//******************************************************************************
174DWORD HMDeviceDriver::CreateFile (LPCSTR lpFileName,
175 PHMHANDLEDATA pHMHandleData,
176 PVOID lpSecurityAttributes,
177 PHMHANDLEDATA pHMHandleDataTemplate)
178{
179 APIRET rc;
180 HFILE hfFileHandle = 0L; /* Handle for file being manipulated */
181 ULONG ulAction = 0; /* Action taken by DosOpen */
182 ULONG sharetype = 0;
183
184 if(pHMHandleData->dwAccess & (GENERIC_READ | GENERIC_WRITE))
185 sharetype |= OPEN_ACCESS_READWRITE;
186 else
187 if(pHMHandleData->dwAccess & GENERIC_WRITE)
188 sharetype |= OPEN_ACCESS_WRITEONLY;
189
190 if(pHMHandleData->dwShare == 0)
191 sharetype |= OPEN_SHARE_DENYREADWRITE;
192 else
193 if(pHMHandleData->dwShare & (FILE_SHARE_READ | FILE_SHARE_WRITE))
194 sharetype |= OPEN_SHARE_DENYNONE;
195 else
196 if(pHMHandleData->dwShare & FILE_SHARE_WRITE)
197 sharetype |= OPEN_SHARE_DENYREAD;
198 else
199 if(pHMHandleData->dwShare & FILE_SHARE_READ)
200 sharetype |= OPEN_SHARE_DENYWRITE;
201
202 if(szOS2Name[0] == 0) {
203 pHMHandleData->hHMHandle = 0;
204 return (NO_ERROR);
205 }
206
207tryopen:
208 rc = DosOpen( szOS2Name, /* File path name */
209 &hfFileHandle, /* File handle */
210 &ulAction, /* Action taken */
211 0,
212 FILE_NORMAL,
213 FILE_OPEN,
214 sharetype,
215 0L); /* No extended attribute */
216
217 if(rc == ERROR_TOO_MANY_OPEN_FILES) {
218 ULONG CurMaxFH;
219 LONG ReqCount = 32;
220
221 rc = DosSetRelMaxFH(&ReqCount, &CurMaxFH);
222 if(rc) {
223 dprintf(("DosSetRelMaxFH returned %d", rc));
224 return error2WinError(rc);
225 }
226 dprintf(("DosOpen failed -> increased nr open files to %d", CurMaxFH));
227 goto tryopen;
228 }
229
230 dprintf(("DosOpen %s returned %d\n", szOS2Name, rc));
231
232 if(rc == NO_ERROR)
233 {
234 pHMHandleData->hHMHandle = hfFileHandle;
235 return (NO_ERROR);
236 }
237 else
238 return(error2WinError(rc));
239}
240//******************************************************************************
241//******************************************************************************
242BOOL HMDeviceDriver::CloseHandle(PHMHANDLEDATA pHMHandleData)
243{
244 DWORD rc = 0;
245
246 if(pHMHandleData->hHMHandle) {
247 rc = DosClose(pHMHandleData->hHMHandle);
248 }
249 pHMHandleData->hHMHandle = 0;
250 return rc;
251}
252//******************************************************************************
253//******************************************************************************
254BOOL HMDeviceDriver::DeviceIoControl(PHMHANDLEDATA pHMHandleData, DWORD dwIoControlCode,
255 LPVOID lpInBuffer, DWORD nInBufferSize,
256 LPVOID lpOutBuffer, DWORD nOutBufferSize,
257 LPDWORD lpBytesReturned, LPOVERLAPPED lpOverlapped)
258{
259 return devIOCtl(pHMHandleData->hHMHandle, dwIoControlCode, lpInBuffer, nInBufferSize,
260 lpOutBuffer, nOutBufferSize, lpBytesReturned, lpOverlapped);
261}
262//******************************************************************************
263//******************************************************************************
264static BOOL GpdDevIOCtl(HANDLE hDevice, DWORD dwIoControlCode, LPVOID lpInBuffer, DWORD nInBufferSize, LPVOID lpOutBuffer, DWORD nOutBufferSize, LPDWORD lpBytesReturned, LPOVERLAPPED lpOverlapped)
265{
266 ULONG port, val = 0;
267
268 if(fX86Init == FALSE) {
269 if(io_init() == 0)
270 fX86Init = TRUE;
271 else return(FALSE);
272 }
273
274 *lpBytesReturned = 0;
275
276 port = ((GENPORT_WRITE_INPUT *)lpInBuffer)->PortNumber;
277
278 switch((dwIoControlCode >> 2) & 0xFFF) {
279 case IOCTL_GPD_READ_PORT_UCHAR:
280 if(nOutBufferSize < sizeof(char))
281 return(FALSE);
282
283 val = c_inb(port);
284 *(char *)lpOutBuffer = val;
285 *lpBytesReturned = sizeof(char);
286 break;
287 case IOCTL_GPD_READ_PORT_USHORT:
288 if(nOutBufferSize < sizeof(USHORT))
289 return(FALSE);
290
291 val = c_inw(port);
292 *(USHORT *)lpOutBuffer = val;
293 *lpBytesReturned = sizeof(USHORT);
294 break;
295 case IOCTL_GPD_READ_PORT_ULONG:
296 if(nOutBufferSize < sizeof(ULONG))
297 return(FALSE);
298
299 val = c_inl(port);
300 *(ULONG *)lpOutBuffer = val;
301 *lpBytesReturned = sizeof(ULONG);
302 break;
303 case IOCTL_GPD_WRITE_PORT_UCHAR:
304 val = ((GENPORT_WRITE_INPUT *)lpInBuffer)->CharData;
305 c_outb(port, val);
306 break;
307 case IOCTL_GPD_WRITE_PORT_USHORT:
308 val = ((GENPORT_WRITE_INPUT *)lpInBuffer)->ShortData;
309 c_outw(port, val);
310 break;
311 case IOCTL_GPD_WRITE_PORT_ULONG:
312 val = ((GENPORT_WRITE_INPUT *)lpInBuffer)->LongData;
313 c_outl(port, val);
314 break;
315 default:
316 dprintf(("GpdDevIOCtl unknown func %X\n", (dwIoControlCode >> 2) & 0xFFF));
317 return(FALSE);
318 }
319
320 return(TRUE);
321}
322//******************************************************************************
323//******************************************************************************
324static BOOL MAPMEMIOCtl(HANDLE hDevice, DWORD dwIoControlCode, LPVOID lpInBuffer, DWORD nInBufferSize, LPVOID lpOutBuffer, DWORD nOutBufferSize, LPDWORD lpBytesReturned, LPOVERLAPPED lpOverlapped)
325{
326 PHYSICAL_MEMORY_INFO *meminfo = (PHYSICAL_MEMORY_INFO *)lpInBuffer;
327 struct map_ioctl memmap;
328
329 *lpBytesReturned = 0;
330
331 switch((dwIoControlCode >> 2) & 0xFFF) {
332 case IOCTL_MAPMEM_MAP_USER_PHYSICAL_MEMORY:
333 if(nInBufferSize != sizeof(PHYSICAL_MEMORY_INFO))
334 return(FALSE);
335
336 memmap.a.phys = meminfo->BusAddress.u.LowPart;
337 memmap.size = meminfo->Length;
338 dprintf(("DeviceIoControl map phys address %X length %X\n", memmap.a.phys, memmap.size));
339 if(mpioctl((HFILE)hDevice, IOCTL_MAP, &memmap) == -1) {
340 dprintf(("mpioctl failed!\n"));
341 return(FALSE);
342 }
343
344 dprintf(("DeviceIoControl map virt address = %X\n", memmap.a.user));
345 *(ULONG *)lpOutBuffer = (ULONG)memmap.a.user;
346 break;
347 case IOCTL_MAPMEM_UNMAP_USER_PHYSICAL_MEMORY:
348 dprintf(("Unmap mapping %X\n", *(ULONG *)lpInBuffer));
349 memmap.a.phys = *(ULONG *)lpInBuffer;
350 memmap.size = 0;
351 if(mpioctl((HFILE)hDevice, IOCTL_MAP, &memmap) == -1)
352 return(FALSE);
353 break;
354 default:
355 dprintf(("MAPMEMIOCtl unknown func %X\n", (dwIoControlCode >> 2) & 0xFFF));
356 return(FALSE);
357 }
358
359 return(TRUE);
360}
361//******************************************************************************
362//******************************************************************************
363static BOOL FXMEMMAPIOCtl(HANDLE hDevice, DWORD dwIoControlCode, LPVOID lpInBuffer, DWORD nInBufferSize, LPVOID lpOutBuffer, DWORD nOutBufferSize, LPDWORD lpBytesReturned, LPOVERLAPPED lpOverlapped)
364{
365 struct map_ioctl memmap;
366 MAPDEVREQUEST *vxdmem = (MAPDEVREQUEST *)lpInBuffer;
367
368 switch(dwIoControlCode) {
369 case 1:
370 break;
371 case 2:
372 memmap.a.phys = (DWORD)vxdmem->mdr_PhysicalAddress;
373 memmap.size = vxdmem->mdr_SizeInBytes;
374 dprintf(("DeviceIoControl map phys address %X length %X\n", memmap.a.phys, memmap.size));
375 if(mpioctl((HFILE)hDevice, IOCTL_MAP, &memmap) == -1) {
376 dprintf(("mpioctl failed!\n"));
377 return(FALSE);
378 }
379
380 dprintf(("DeviceIoControl map virt address = %X\n", memmap.a.user));
381 vxdmem->mdr_LinearAddress = (PVOID)memmap.a.user;
382 break;
383 default:
384 dprintf(("FXMEMMAPIOCtl unknown func %X\n", (dwIoControlCode >> 2) & 0xFFF));
385 return(FALSE);
386 }
387
388 return(TRUE);
389}
390//******************************************************************************
391//******************************************************************************
392HMCustomDriver::HMCustomDriver(HINSTANCE hInstance, LPCSTR lpDeviceName, LPVOID lpDriverData)
393 : HMDeviceDriver(lpDeviceName), hDrvDll(0), lpDriverData(NULL)
394{
395 hDrvDll = hInstance ;
396 pfnDriverOpen = (PFNDRVOPEN) GetProcAddress(hDrvDll, "DrvOpen");
397 pfnDriverClose = (PFNDRVCLOSE)GetProcAddress(hDrvDll, "DrvClose");
398 pfnDriverRead = (PFNDRVREAD) GetProcAddress(hDrvDll, "DrvRead");
399 pfnDriverWrite = (PFNDRVWRITE)GetProcAddress(hDrvDll, "DrvWrite");
400 pfnDriverIOCtl = (PFNDRVIOCTL)GetProcAddress(hDrvDll, "DrvIOCtl");
401}
402//******************************************************************************
403//******************************************************************************
404HMCustomDriver::HMCustomDriver(PFNDRVOPEN pfnDriverOpen, PFNDRVCLOSE pfnDriverClose,
405 PFNDRVIOCTL pfnDriverIOCtl, PFNDRVREAD pfnDriverRead,
406 PFNDRVWRITE pfnDriverWrite, PFNDRVCANCELIO pfnDriverCancelIo,
407 PFNDRVGETOVERLAPPEDRESULT pfnDriverGetOverlappedResult,
408 LPCSTR lpDeviceName, LPVOID lpDriverData)
409 : HMDeviceDriver(lpDeviceName), hDrvDll(0)
410{
411 if(!pfnDriverOpen || !pfnDriverClose) {
412 DebugInt3();
413 }
414 this->pfnDriverOpen = pfnDriverOpen;
415 this->pfnDriverClose = pfnDriverClose;
416 this->pfnDriverIOCtl = pfnDriverIOCtl;
417 this->pfnDriverRead = pfnDriverRead;
418 this->pfnDriverWrite = pfnDriverWrite;
419 this->pfnDriverCancelIo = pfnDriverCancelIo;
420 this->pfnDriverGetOverlappedResult = pfnDriverGetOverlappedResult;
421 this->lpDriverData = lpDriverData;
422}
423//******************************************************************************
424//******************************************************************************
425HMCustomDriver::~HMCustomDriver()
426{
427 if(hDrvDll) FreeLibrary(hDrvDll);
428}
429//******************************************************************************
430//******************************************************************************
431DWORD HMCustomDriver::CreateFile (LPCSTR lpFileName,
432 PHMHANDLEDATA pHMHandleData,
433 PVOID lpSecurityAttributes,
434 PHMHANDLEDATA pHMHandleDataTemplate)
435{
436 pHMHandleData->hHMHandle = pfnDriverOpen(lpDriverData, pHMHandleData->dwAccess, pHMHandleData->dwShare, pHMHandleData->dwFlags, (PVOID *)&pHMHandleData->dwUserData);
437 if(pHMHandleData->hHMHandle == INVALID_HANDLE_VALUE_W) {
438 return GetLastError();
439 }
440 return ERROR_SUCCESS_W;
441}
442//******************************************************************************
443//******************************************************************************
444BOOL HMCustomDriver::CloseHandle(PHMHANDLEDATA pHMHandleData)
445{
446 if(pHMHandleData->hHMHandle) {
447 pfnDriverClose(lpDriverData, pHMHandleData->hHMHandle, pHMHandleData->dwFlags, (LPVOID)pHMHandleData->dwUserData);
448 }
449 pHMHandleData->hHMHandle = 0;
450 return TRUE;
451}
452//******************************************************************************
453//******************************************************************************
454BOOL HMCustomDriver::DeviceIoControl(PHMHANDLEDATA pHMHandleData, DWORD dwIoControlCode,
455 LPVOID lpInBuffer, DWORD nInBufferSize,
456 LPVOID lpOutBuffer, DWORD nOutBufferSize,
457 LPDWORD lpBytesReturned, LPOVERLAPPED lpOverlapped)
458{
459 BOOL ret;
460
461 if(pfnDriverIOCtl == NULL) {
462 dprintf(("HMCustomDriver::DeviceIoControl: pfnDriverIOCtl == NULL"));
463 ::SetLastError(ERROR_INVALID_FUNCTION_W);
464 return FALSE;
465 }
466
467 ret = pfnDriverIOCtl(lpDriverData, pHMHandleData->hHMHandle, pHMHandleData->dwFlags, dwIoControlCode, lpInBuffer, nInBufferSize,
468 lpOutBuffer, nOutBufferSize, lpBytesReturned, lpOverlapped, (LPVOID)pHMHandleData->dwUserData);
469 dprintf(("DeviceIoControl %x returned %d", dwIoControlCode, ret));
470 return ret;
471}
472/*****************************************************************************
473 * Name : BOOL HMCustomDriver::ReadFile
474 * Purpose : read data from handle / device
475 * Parameters: PHMHANDLEDATA pHMHandleData,
476 * LPCVOID lpBuffer,
477 * DWORD nNumberOfBytesToRead,
478 * LPDWORD lpNumberOfBytesRead,
479 * LPOVERLAPPED lpOverlapped
480 * LPOVERLAPPED_COMPLETION_ROUTINE lpCompletionRoutine
481 * Variables :
482 * Result : Boolean
483 * Remark :
484 * Status :
485 *
486 * Author : SvL
487 *****************************************************************************/
488
489BOOL HMCustomDriver::ReadFile(PHMHANDLEDATA pHMHandleData,
490 LPCVOID lpBuffer,
491 DWORD nNumberOfBytesToRead,
492 LPDWORD lpNumberOfBytesRead,
493 LPOVERLAPPED lpOverlapped,
494 LPOVERLAPPED_COMPLETION_ROUTINE lpCompletionRoutine)
495{
496 BOOL ret;
497
498 if(pfnDriverRead == NULL) {
499 dprintf(("HMCustomDriver::ReadFile: pfnDriverRead == NULL"));
500 ::SetLastError(ERROR_INVALID_FUNCTION_W);
501 return FALSE;
502 }
503 ret = pfnDriverRead(lpDriverData, pHMHandleData->hHMHandle, pHMHandleData->dwFlags, lpBuffer, nNumberOfBytesToRead,
504 lpNumberOfBytesRead, lpOverlapped, lpCompletionRoutine,
505 (LPVOID)pHMHandleData->dwUserData);
506 dprintf(("pfnDriverRead %x %x %x %x %x %x returned %x", pHMHandleData->hHMHandle, lpBuffer, nNumberOfBytesToRead,
507 lpNumberOfBytesRead, lpOverlapped, lpCompletionRoutine, ret));
508 return ret;
509}
510/*****************************************************************************
511 * Name : BOOL HMCustomDriver::WriteFile
512 * Purpose : write data to handle / device
513 * Parameters: PHMHANDLEDATA pHMHandleData,
514 * LPCVOID lpBuffer,
515 * DWORD nNumberOfBytesToWrite,
516 * LPDWORD lpNumberOfBytesWritten,
517 * LPOVERLAPPED lpOverlapped
518 * LPOVERLAPPED_COMPLETION_ROUTINE lpCompletionRoutine
519 * Variables :
520 * Result : Boolean
521 * Remark :
522 * Status :
523 *
524 * Author : SvL
525 *****************************************************************************/
526
527BOOL HMCustomDriver::WriteFile(PHMHANDLEDATA pHMHandleData,
528 LPCVOID lpBuffer,
529 DWORD nNumberOfBytesToWrite,
530 LPDWORD lpNumberOfBytesWritten,
531 LPOVERLAPPED lpOverlapped,
532 LPOVERLAPPED_COMPLETION_ROUTINE lpCompletionRoutine)
533{
534 BOOL ret;
535
536 if(pfnDriverWrite == NULL) {
537 dprintf(("HMCustomDriver::WriteFile: pfnDriverWrite == NULL"));
538 ::SetLastError(ERROR_INVALID_FUNCTION_W);
539 return FALSE;
540 }
541 ret = pfnDriverWrite(lpDriverData, pHMHandleData->hHMHandle, pHMHandleData->dwFlags, lpBuffer, nNumberOfBytesToWrite,
542 lpNumberOfBytesWritten, lpOverlapped, lpCompletionRoutine,
543 (LPVOID)pHMHandleData->dwUserData);
544 dprintf(("pfnDriverWrite %x %x %x %x %x %x returned %x", pHMHandleData->hHMHandle, lpBuffer, nNumberOfBytesToWrite,
545 lpNumberOfBytesWritten, lpOverlapped, lpCompletionRoutine, ret));
546 return ret;
547}
548/*****************************************************************************
549 * Name : DWORD HMCustomDriver::CancelIo
550 * Purpose : cancel pending IO operation
551 * Variables :
552 * Result :
553 * Remark :
554 * Status :
555 *
556 * Author : SvL
557 *****************************************************************************/
558BOOL HMCustomDriver::CancelIo(PHMHANDLEDATA pHMHandleData)
559{
560 BOOL ret;
561
562 if(pfnDriverCancelIo == NULL) {
563 dprintf(("HMCustomDriver::CancelIo: pfnDriverCancelIo == NULL"));
564 ::SetLastError(ERROR_INVALID_FUNCTION_W);
565 return FALSE;
566 }
567 ret = pfnDriverCancelIo(lpDriverData, pHMHandleData->hHMHandle, pHMHandleData->dwFlags, (LPVOID)pHMHandleData->dwUserData);
568 dprintf(("pfnDriverCancelIo %x returned %x", pHMHandleData->hHMHandle, ret));
569 return ret;
570}
571/*****************************************************************************
572 * Name : DWORD HMCustomDriver::GetOverlappedResult
573 * Purpose : asynchronus I/O
574 * Parameters: PHMHANDLEDATA pHMHandleData
575 * LPOVERLAPPED arg2
576 * LPDWORD arg3
577 * BOOL arg4
578 * Variables :
579 * Result : API returncode
580 * Remark :
581 * Status :
582 *
583 * Author : SvL
584 *****************************************************************************/
585BOOL HMCustomDriver::GetOverlappedResult(PHMHANDLEDATA pHMHandleData,
586 LPOVERLAPPED lpOverlapped,
587 LPDWORD lpcbTransfer,
588 BOOL fWait)
589{
590 dprintf(("KERNEL32-HMCustomDriver: HMCustomDriver::GetOverlappedResult(%08xh,%08xh,%08xh,%08xh)",
591 pHMHandleData->hHMHandle, lpOverlapped, lpcbTransfer, fWait));
592
593 if(!(pHMHandleData->dwFlags & FILE_FLAG_OVERLAPPED_W)) {
594 dprintf(("!WARNING!: GetOverlappedResult called for a handle that wasn't opened with FILE_FLAG_OVERLAPPED"));
595 return TRUE; //NT4, SP6 doesn't fail
596 }
597 if(!lpOverlapped) {
598 ::SetLastError(ERROR_INVALID_PARAMETER);
599 return FALSE;
600 }
601 if(pfnDriverGetOverlappedResult == NULL) {
602 dprintf(("HMCustomDriver::GetOverlappedResult: pfnDriverGetOverlappedResult == NULL"));
603 ::SetLastError(ERROR_INVALID_FUNCTION_W);
604 return FALSE;
605 }
606 return pfnDriverGetOverlappedResult(lpDriverData, pHMHandleData->hHMHandle, pHMHandleData->dwFlags,
607 lpOverlapped, lpcbTransfer, fWait, (LPVOID)pHMHandleData->dwUserData);
608}
609//******************************************************************************
610//******************************************************************************
611BOOL WIN32API QueryPerformanceCounter(LARGE_INTEGER *lpPerformanceCount)
612{
613 QWORD time;
614 APIRET rc;
615
616 rc = DosTmrQueryTime(&time);
617 if(rc) {
618 dprintf(("DosTmrQueryTime returned %d\n", rc));
619 return(FALSE);
620 }
621 lpPerformanceCount->u.LowPart = time.ulLo;
622 lpPerformanceCount->u.HighPart = time.ulHi;
623 return(TRUE);
624}
625//******************************************************************************
626//******************************************************************************
627BOOL WIN32API QueryPerformanceFrequency(LARGE_INTEGER *lpFrequency)
628{
629 APIRET rc;
630 ULONG freq;
631
632 rc = DosTmrQueryFreq(&freq);
633 if(rc) {
634 dprintf(("DosTmrQueryFreq returned %d\n", rc));
635 return(FALSE);
636 }
637 lpFrequency->u.LowPart = freq;
638 lpFrequency->u.HighPart = 0;
639 dprintf2(("QueryPerformanceFrequency returned 0x%X%X\n", lpFrequency->u.HighPart, lpFrequency->u.LowPart));
640 return(TRUE);
641}
642//******************************************************************************
643//******************************************************************************
Note: See TracBrowser for help on using the repository browser.