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

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

Custom device driver changes for driver instance pointer
File size: 25.5 KB
Line 
1/* $Id: hmdevio.cpp,v 1.26 2002-01-12 10:28:17 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 driver = new HMCustomDriver(pfnDriverOpen, pfnDriverClose, pfnDriverIOCtl, pfnDriverRead, pfnDriverWrite, pfnDriverCancelIo, pfnDriverGetOverlappedResult, lpDeviceName, lpDriverData);
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, LPVOID lpDriverData)
392 : HMDeviceDriver(lpDeviceName), hDrvDll(0), lpDriverData(NULL)
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, LPVOID lpDriverData)
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 this->lpDriverData = lpDriverData;
421}
422//******************************************************************************
423//******************************************************************************
424HMCustomDriver::~HMCustomDriver()
425{
426 if(hDrvDll) FreeLibrary(hDrvDll);
427}
428//******************************************************************************
429//******************************************************************************
430DWORD HMCustomDriver::CreateFile (LPCSTR lpFileName,
431 PHMHANDLEDATA pHMHandleData,
432 PVOID lpSecurityAttributes,
433 PHMHANDLEDATA pHMHandleDataTemplate)
434{
435 pHMHandleData->hHMHandle = pfnDriverOpen(lpDriverData, pHMHandleData->dwAccess, pHMHandleData->dwShare, pHMHandleData->dwFlags, (PVOID *)&pHMHandleData->dwUserData);
436 if(pHMHandleData->hHMHandle == INVALID_HANDLE_VALUE_W) {
437 return GetLastError();
438 }
439 return ERROR_SUCCESS_W;
440}
441//******************************************************************************
442//******************************************************************************
443BOOL HMCustomDriver::CloseHandle(PHMHANDLEDATA pHMHandleData)
444{
445 if(pHMHandleData->hHMHandle) {
446 pfnDriverClose(lpDriverData, pHMHandleData->hHMHandle, pHMHandleData->dwFlags, (LPVOID)pHMHandleData->dwUserData);
447 }
448 pHMHandleData->hHMHandle = 0;
449 return TRUE;
450}
451//******************************************************************************
452//******************************************************************************
453BOOL HMCustomDriver::DeviceIoControl(PHMHANDLEDATA pHMHandleData, DWORD dwIoControlCode,
454 LPVOID lpInBuffer, DWORD nInBufferSize,
455 LPVOID lpOutBuffer, DWORD nOutBufferSize,
456 LPDWORD lpBytesReturned, LPOVERLAPPED lpOverlapped)
457{
458 BOOL ret;
459
460 if(pfnDriverIOCtl == NULL) {
461 dprintf(("HMCustomDriver::DeviceIoControl: pfnDriverIOCtl == NULL"));
462 ::SetLastError(ERROR_INVALID_FUNCTION_W);
463 return FALSE;
464 }
465
466 ret = pfnDriverIOCtl(lpDriverData, pHMHandleData->hHMHandle, pHMHandleData->dwFlags, dwIoControlCode, lpInBuffer, nInBufferSize,
467 lpOutBuffer, nOutBufferSize, lpBytesReturned, lpOverlapped, (LPVOID)pHMHandleData->dwUserData);
468 dprintf(("DeviceIoControl %x returned %d", dwIoControlCode, ret));
469 return ret;
470}
471/*****************************************************************************
472 * Name : BOOL HMCustomDriver::ReadFile
473 * Purpose : read data from handle / device
474 * Parameters: PHMHANDLEDATA pHMHandleData,
475 * LPCVOID lpBuffer,
476 * DWORD nNumberOfBytesToRead,
477 * LPDWORD lpNumberOfBytesRead,
478 * LPOVERLAPPED lpOverlapped
479 * LPOVERLAPPED_COMPLETION_ROUTINE lpCompletionRoutine
480 * Variables :
481 * Result : Boolean
482 * Remark :
483 * Status :
484 *
485 * Author : SvL
486 *****************************************************************************/
487
488BOOL HMCustomDriver::ReadFile(PHMHANDLEDATA pHMHandleData,
489 LPCVOID lpBuffer,
490 DWORD nNumberOfBytesToRead,
491 LPDWORD lpNumberOfBytesRead,
492 LPOVERLAPPED lpOverlapped,
493 LPOVERLAPPED_COMPLETION_ROUTINE lpCompletionRoutine)
494{
495 BOOL ret;
496
497 if(pfnDriverRead == NULL) {
498 dprintf(("HMCustomDriver::ReadFile: pfnDriverRead == NULL"));
499 ::SetLastError(ERROR_INVALID_FUNCTION_W);
500 return FALSE;
501 }
502 ret = pfnDriverRead(lpDriverData, pHMHandleData->hHMHandle, pHMHandleData->dwFlags, lpBuffer, nNumberOfBytesToRead,
503 lpNumberOfBytesRead, lpOverlapped, lpCompletionRoutine,
504 (LPVOID)pHMHandleData->dwUserData);
505 dprintf(("pfnDriverRead %x %x %x %x %x %x returned %x", pHMHandleData->hHMHandle, lpBuffer, nNumberOfBytesToRead,
506 lpNumberOfBytesRead, lpOverlapped, lpCompletionRoutine, ret));
507 return ret;
508}
509/*****************************************************************************
510 * Name : BOOL HMCustomDriver::WriteFile
511 * Purpose : write data to handle / device
512 * Parameters: PHMHANDLEDATA pHMHandleData,
513 * LPCVOID lpBuffer,
514 * DWORD nNumberOfBytesToWrite,
515 * LPDWORD lpNumberOfBytesWritten,
516 * LPOVERLAPPED lpOverlapped
517 * LPOVERLAPPED_COMPLETION_ROUTINE lpCompletionRoutine
518 * Variables :
519 * Result : Boolean
520 * Remark :
521 * Status :
522 *
523 * Author : SvL
524 *****************************************************************************/
525
526BOOL HMCustomDriver::WriteFile(PHMHANDLEDATA pHMHandleData,
527 LPCVOID lpBuffer,
528 DWORD nNumberOfBytesToWrite,
529 LPDWORD lpNumberOfBytesWritten,
530 LPOVERLAPPED lpOverlapped,
531 LPOVERLAPPED_COMPLETION_ROUTINE lpCompletionRoutine)
532{
533 BOOL ret;
534
535 if(pfnDriverWrite == NULL) {
536 dprintf(("HMCustomDriver::WriteFile: pfnDriverWrite == NULL"));
537 ::SetLastError(ERROR_INVALID_FUNCTION_W);
538 return FALSE;
539 }
540 ret = pfnDriverWrite(lpDriverData, pHMHandleData->hHMHandle, pHMHandleData->dwFlags, lpBuffer, nNumberOfBytesToWrite,
541 lpNumberOfBytesWritten, lpOverlapped, lpCompletionRoutine,
542 (LPVOID)pHMHandleData->dwUserData);
543 dprintf(("pfnDriverWrite %x %x %x %x %x %x returned %x", pHMHandleData->hHMHandle, lpBuffer, nNumberOfBytesToWrite,
544 lpNumberOfBytesWritten, lpOverlapped, lpCompletionRoutine, ret));
545 return ret;
546}
547/*****************************************************************************
548 * Name : DWORD HMCustomDriver::CancelIo
549 * Purpose : cancel pending IO operation
550 * Variables :
551 * Result :
552 * Remark :
553 * Status :
554 *
555 * Author : SvL
556 *****************************************************************************/
557BOOL HMCustomDriver::CancelIo(PHMHANDLEDATA pHMHandleData)
558{
559 BOOL ret;
560
561 if(pfnDriverCancelIo == NULL) {
562 dprintf(("HMCustomDriver::CancelIo: pfnDriverCancelIo == NULL"));
563 ::SetLastError(ERROR_INVALID_FUNCTION_W);
564 return FALSE;
565 }
566 ret = pfnDriverCancelIo(lpDriverData, pHMHandleData->hHMHandle, pHMHandleData->dwFlags, (LPVOID)pHMHandleData->dwUserData);
567 dprintf(("pfnDriverCancelIo %x returned %x", pHMHandleData->hHMHandle, ret));
568 return ret;
569}
570/*****************************************************************************
571 * Name : DWORD HMCustomDriver::GetOverlappedResult
572 * Purpose : asynchronus I/O
573 * Parameters: PHMHANDLEDATA pHMHandleData
574 * LPOVERLAPPED arg2
575 * LPDWORD arg3
576 * BOOL arg4
577 * Variables :
578 * Result : API returncode
579 * Remark :
580 * Status :
581 *
582 * Author : SvL
583 *****************************************************************************/
584BOOL HMCustomDriver::GetOverlappedResult(PHMHANDLEDATA pHMHandleData,
585 LPOVERLAPPED lpOverlapped,
586 LPDWORD lpcbTransfer,
587 BOOL fWait)
588{
589 dprintf(("KERNEL32-HMCustomDriver: HMCustomDriver::GetOverlappedResult(%08xh,%08xh,%08xh,%08xh)",
590 pHMHandleData->hHMHandle, lpOverlapped, lpcbTransfer, fWait));
591
592 if(!(pHMHandleData->dwFlags & FILE_FLAG_OVERLAPPED_W)) {
593 dprintf(("!WARNING!: GetOverlappedResult called for a handle that wasn't opened with FILE_FLAG_OVERLAPPED"));
594 return TRUE; //NT4, SP6 doesn't fail
595 }
596 if(!lpOverlapped) {
597 ::SetLastError(ERROR_INVALID_PARAMETER);
598 return FALSE;
599 }
600 if(pfnDriverGetOverlappedResult == NULL) {
601 dprintf(("HMCustomDriver::GetOverlappedResult: pfnDriverGetOverlappedResult == NULL"));
602 ::SetLastError(ERROR_INVALID_FUNCTION_W);
603 return FALSE;
604 }
605 return pfnDriverGetOverlappedResult(lpDriverData, pHMHandleData->hHMHandle, pHMHandleData->dwFlags,
606 lpOverlapped, lpcbTransfer, fWait, (LPVOID)pHMHandleData->dwUserData);
607}
608//******************************************************************************
609//******************************************************************************
610BOOL WIN32API QueryPerformanceCounter(LARGE_INTEGER *lpPerformanceCount)
611{
612 QWORD time;
613 APIRET rc;
614
615 rc = DosTmrQueryTime(&time);
616 if(rc) {
617 dprintf(("DosTmrQueryTime returned %d\n", rc));
618 return(FALSE);
619 }
620 lpPerformanceCount->u.LowPart = time.ulLo;
621 lpPerformanceCount->u.HighPart = time.ulHi;
622 return(TRUE);
623}
624//******************************************************************************
625//******************************************************************************
626BOOL WIN32API QueryPerformanceFrequency(LARGE_INTEGER *lpFrequency)
627{
628 APIRET rc;
629 ULONG freq;
630
631 rc = DosTmrQueryFreq(&freq);
632 if(rc) {
633 dprintf(("DosTmrQueryFreq returned %d\n", rc));
634 return(FALSE);
635 }
636 lpFrequency->u.LowPart = freq;
637 lpFrequency->u.HighPart = 0;
638 dprintf2(("QueryPerformanceFrequency returned 0x%X%X\n", lpFrequency->u.HighPart, lpFrequency->u.LowPart));
639 return(TRUE);
640}
641//******************************************************************************
642//******************************************************************************
Note: See TracBrowser for help on using the repository browser.