source: trunk/src/kernel32/hmdisk.cpp@ 6036

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

IOCTL_SCSI_PASS_THROUGH_DIRECT implemented
File size: 20.7 KB
Line 
1/* $Id: hmdisk.cpp,v 1.9 2001-06-17 13:58:32 sandervl Exp $ */
2
3/*
4 * Win32 Disk API functions for OS/2
5 *
6 * Copyright 2000 Sander van Leeuwen
7 *
8 *
9 * Project Odin Software License can be found in LICENSE.TXT
10 *
11 */
12#include <os2win.h>
13#include <string.h>
14
15#include <misc.h>
16#include "hmdisk.h"
17#include "mmap.h"
18#include "oslibdos.h"
19#include <win\winioctl.h>
20#include <win\ntddscsi.h>
21#include <win\wnaspi32.h>
22#include <win\aspi.h>
23
24#define DBG_LOCALLOG DBG_hmdisk
25#include "dbglocal.h"
26
27static HINSTANCE hInstAspi = 0;
28static DWORD (WIN32API *GetASPI32SupportInfo)() = NULL;
29static DWORD (CDECL *SendASPI32Command)(LPSRB lpSRB) = NULL;
30
31HMDeviceDiskClass::HMDeviceDiskClass(LPCSTR lpDeviceName) : HMDeviceKernelObjectClass(lpDeviceName)
32{
33 HMDeviceRegisterEx("\\\\.\\PHYSICALDRIVE", this, NULL);
34}
35
36/*****************************************************************************
37 * Name : HMDeviceDiskClass::FindDevice
38 * Purpose : Checks if lpDeviceName belongs to this device class
39 * Parameters: LPCSTR lpClassDevName
40 * LPCSTR lpDeviceName
41 * int namelength
42 * Variables :
43 * Result : checks if name is for a drive of physical disk
44 * Remark :
45 * Status :
46 *
47 * Author : SvL
48 *****************************************************************************/
49BOOL HMDeviceDiskClass::FindDevice(LPCSTR lpClassDevName, LPCSTR lpDeviceName, int namelength)
50{
51 //\\.\x: -> length 6
52 //\\.\PHYSICALDRIVEn -> length 18
53 if(namelength != 6 && namelength != 18) {
54 return FALSE;
55 }
56
57 //SvL: \\.\x: -> drive x (i.e. \\.\C:)
58 // \\.\PHYSICALDRIVEn -> drive n (n>=0)
59 if((strncmp(lpDeviceName, "\\\\.\\", 4) == 0) &&
60 namelength == 6 && lpDeviceName[5] == ':')
61 {
62 return TRUE;
63 }
64 if((strncmp(lpDeviceName, "\\\\.\\PHYSICALDRIVE", 17) == 0) && namelength == 18) {
65 return TRUE;
66 }
67 return FALSE;
68}
69//******************************************************************************
70//TODO: PHYSICALDRIVEn!!
71//******************************************************************************
72DWORD HMDeviceDiskClass::CreateFile (LPCSTR lpFileName,
73 PHMHANDLEDATA pHMHandleData,
74 PVOID lpSecurityAttributes,
75 PHMHANDLEDATA pHMHandleDataTemplate)
76{
77 HFILE hFile;
78 HFILE hTemplate;
79
80 dprintf2(("KERNEL32: HMDeviceDiskClass::CreateFile %s(%s,%08x,%08x,%08x)\n",
81 lpHMDeviceName,
82 lpFileName,
83 pHMHandleData,
84 lpSecurityAttributes,
85 pHMHandleDataTemplate));
86
87 //TODO: check in NT if CREATE_ALWAYS is allowed!!
88 if(pHMHandleData->dwCreation != OPEN_EXISTING) {
89 dprintf(("Invalid creation flags %x!!", pHMHandleData->dwCreation));
90 return ERROR_INVALID_PARAMETER;
91 }
92 if(strncmp(lpFileName, // "support" for local unc names
93 "\\\\.\\",
94 4) == 0)
95 {
96 lpFileName+=4;
97 }
98
99 //Disable error popus. NT allows an app to open a cdrom/dvd drive without a disk inside
100 //OS/2 fails in that case with error ERROR_NOT_READY
101 OSLibDosDisableHardError(TRUE);
102 hFile = OSLibDosCreateFile((LPSTR)lpFileName,
103 pHMHandleData->dwAccess,
104 pHMHandleData->dwShare,
105 (LPSECURITY_ATTRIBUTES)lpSecurityAttributes,
106 pHMHandleData->dwCreation,
107 pHMHandleData->dwFlags,
108 hTemplate);
109 OSLibDosDisableHardError(FALSE);
110
111 if (hFile != INVALID_HANDLE_ERROR || GetLastError() == ERROR_NOT_READY)
112 {
113 if(hFile == INVALID_HANDLE_ERROR) {
114 SetLastError(NO_ERROR);
115 pHMHandleData->hHMHandle = 0; //handle lookup fails if this is set to -1
116 }
117 else pHMHandleData->hHMHandle = hFile;
118
119 pHMHandleData->dwUserData = *lpFileName; //save drive letter
120 if(pHMHandleData->dwUserData >= 'a') {
121 pHMHandleData->dwUserData = pHMHandleData->dwUserData - ((int)'a' - (int)'A');
122 }
123
124 if(GetDriveTypeA(lpFileName) == DRIVE_CDROM && hInstAspi == NULL) {
125 hInstAspi = LoadLibraryA("WNASPI32.DLL");
126 if(hInstAspi == NULL) {
127 return ERROR_INVALID_PARAMETER;
128 }
129 *(FARPROC *)&GetASPI32SupportInfo = GetProcAddress(hInstAspi, "GetASPI32SupportInfo");
130 *(FARPROC *)&SendASPI32Command = GetProcAddress(hInstAspi, "SendASPI32Command");
131 }
132 return (NO_ERROR);
133 }
134 else {
135 dprintf(("CreateFile failed; error %d", GetLastError()));
136 return(GetLastError());
137 }
138}
139//******************************************************************************
140//******************************************************************************
141BOOL HMDeviceDiskClass::CloseHandle(PHMHANDLEDATA pHMHandleData)
142{
143 if(pHMHandleData->hHMHandle) {
144 return OSLibDosClose(pHMHandleData->hHMHandle);
145 }
146 return TRUE;
147}
148//******************************************************************************
149//******************************************************************************
150BOOL HMDeviceDiskClass::DeviceIoControl(PHMHANDLEDATA pHMHandleData, DWORD dwIoControlCode,
151 LPVOID lpInBuffer, DWORD nInBufferSize,
152 LPVOID lpOutBuffer, DWORD nOutBufferSize,
153 LPDWORD lpBytesReturned, LPOVERLAPPED lpOverlapped)
154{
155#ifdef DEBUG
156 char *msg = NULL;
157
158 switch(dwIoControlCode)
159 {
160 case FSCTL_DELETE_REPARSE_POINT:
161 msg = "FSCTL_DELETE_REPARSE_POINT";
162 break;
163 case FSCTL_DISMOUNT_VOLUME:
164 msg = "FSCTL_DISMOUNT_VOLUME";
165 break;
166 case FSCTL_GET_COMPRESSION:
167 msg = "FSCTL_GET_COMPRESSION";
168 break;
169 case FSCTL_GET_REPARSE_POINT:
170 msg = "FSCTL_GET_REPARSE_POINT";
171 break;
172 case FSCTL_LOCK_VOLUME:
173 msg = "FSCTL_LOCK_VOLUME";
174 break;
175 case FSCTL_QUERY_ALLOCATED_RANGES:
176 msg = "FSCTL_QUERY_ALLOCATED_RANGES";
177 break;
178 case FSCTL_SET_COMPRESSION:
179 msg = "FSCTL_SET_COMPRESSION";
180 break;
181 case FSCTL_SET_REPARSE_POINT:
182 msg = "FSCTL_SET_REPARSE_POINT";
183 break;
184 case FSCTL_SET_SPARSE:
185 msg = "FSCTL_SET_SPARSE";
186 break;
187 case FSCTL_SET_ZERO_DATA:
188 msg = "FSCTL_SET_ZERO_DATA";
189 break;
190 case FSCTL_UNLOCK_VOLUME:
191 msg = "FSCTL_UNLOCK_VOLUME";
192 break;
193 case IOCTL_DISK_CHECK_VERIFY:
194 msg = "IOCTL_DISK_CHECK_VERIFY";
195 break;
196 case IOCTL_DISK_EJECT_MEDIA:
197 msg = "IOCTL_DISK_EJECT_MEDIA";
198 break;
199 case IOCTL_DISK_FORMAT_TRACKS:
200 msg = "IOCTL_DISK_FORMAT_TRACKS";
201 break;
202 case IOCTL_DISK_GET_DRIVE_GEOMETRY:
203 msg = "IOCTL_DISK_GET_DRIVE_GEOMETRY";
204 break;
205 case IOCTL_DISK_GET_DRIVE_LAYOUT:
206 msg = "IOCTL_DISK_GET_DRIVE_LAYOUT";
207 break;
208 case IOCTL_DISK_GET_MEDIA_TYPES:
209 msg = "IOCTL_DISK_GET_MEDIA_TYPES";
210 break;
211 case IOCTL_DISK_GET_PARTITION_INFO:
212 msg = "IOCTL_DISK_GET_PARTITION_INFO";
213 break;
214 case IOCTL_DISK_LOAD_MEDIA:
215 msg = "IOCTL_DISK_LOAD_MEDIA";
216 break;
217 case IOCTL_DISK_MEDIA_REMOVAL:
218 msg = "IOCTL_DISK_MEDIA_REMOVAL";
219 break;
220 case IOCTL_DISK_PERFORMANCE:
221 msg = "IOCTL_DISK_PERFORMANCE";
222 break;
223 case IOCTL_DISK_REASSIGN_BLOCKS:
224 msg = "IOCTL_DISK_REASSIGN_BLOCKS";
225 break;
226 case IOCTL_DISK_SET_DRIVE_LAYOUT:
227 msg = "IOCTL_DISK_SET_DRIVE_LAYOUT";
228 break;
229 case IOCTL_DISK_SET_PARTITION_INFO:
230 msg = "IOCTL_DISK_SET_PARTITION_INFO";
231 break;
232 case IOCTL_DISK_VERIFY:
233 msg = "IOCTL_DISK_VERIFY";
234 break;
235 case IOCTL_SERIAL_LSRMST_INSERT:
236 msg = "IOCTL_SERIAL_LSRMST_INSERT";
237 break;
238 case IOCTL_STORAGE_CHECK_VERIFY:
239 msg = "IOCTL_STORAGE_CHECK_VERIFY";
240 break;
241 case IOCTL_STORAGE_EJECT_MEDIA:
242 msg = "IOCTL_STORAGE_EJECT_MEDIA";
243 break;
244 case IOCTL_STORAGE_GET_MEDIA_TYPES:
245 msg = "IOCTL_STORAGE_GET_MEDIA_TYPES";
246 break;
247 case IOCTL_STORAGE_LOAD_MEDIA:
248 msg = "IOCTL_STORAGE_LOAD_MEDIA";
249 break;
250 case IOCTL_STORAGE_MEDIA_REMOVAL:
251 msg = "IOCTL_STORAGE_MEDIA_REMOVAL";
252 break;
253 case IOCTL_SCSI_PASS_THROUGH:
254 msg = "IOCTL_SCSI_PASS_THROUGH";
255 break;
256 case IOCTL_SCSI_MINIPORT:
257 msg = "IOCTL_SCSI_MINIPORT";
258 break;
259 case IOCTL_SCSI_GET_INQUIRY_DATA:
260 msg = "IOCTL_SCSI_GET_INQUIRY_DATA";
261 break;
262 case IOCTL_SCSI_GET_CAPABILITIES:
263 msg = "IOCTL_SCSI_GET_CAPABILITIES";
264 break;
265 case IOCTL_SCSI_PASS_THROUGH_DIRECT:
266 msg = "IOCTL_SCSI_PASS_THROUGH_DIRECT";
267 break;
268 case IOCTL_SCSI_GET_ADDRESS:
269 msg = "IOCTL_SCSI_GET_ADDRESS";
270 break;
271 case IOCTL_SCSI_RESCAN_BUS:
272 msg = "IOCTL_SCSI_RESCAN_BUS";
273 break;
274 case IOCTL_SCSI_GET_DUMP_POINTERS:
275 msg = "IOCTL_SCSI_GET_DUMP_POINTERS";
276 break;
277 case IOCTL_SCSI_FREE_DUMP_POINTERS:
278 msg = "IOCTL_SCSI_FREE_DUMP_POINTERS";
279 break;
280 case IOCTL_IDE_PASS_THROUGH:
281 msg = "IOCTL_IDE_PASS_THROUGH";
282 break;
283 }
284 if(msg) {
285 dprintf(("HMDeviceDiskClass::DeviceIoControl %s", msg));
286 }
287#endif
288
289 switch(dwIoControlCode)
290 {
291 case FSCTL_DELETE_REPARSE_POINT:
292 case FSCTL_DISMOUNT_VOLUME:
293 case FSCTL_GET_COMPRESSION:
294 case FSCTL_GET_REPARSE_POINT:
295 case FSCTL_LOCK_VOLUME:
296 case FSCTL_QUERY_ALLOCATED_RANGES:
297 case FSCTL_SET_COMPRESSION:
298 case FSCTL_SET_REPARSE_POINT:
299 case FSCTL_SET_SPARSE:
300 case FSCTL_SET_ZERO_DATA:
301 case FSCTL_UNLOCK_VOLUME:
302 break;
303
304 case IOCTL_DISK_CHECK_VERIFY:
305 case IOCTL_DISK_EJECT_MEDIA:
306 case IOCTL_DISK_FORMAT_TRACKS:
307 case IOCTL_DISK_GET_DRIVE_LAYOUT:
308 break;
309
310 case IOCTL_DISK_GET_DRIVE_GEOMETRY:
311 case IOCTL_DISK_GET_MEDIA_TYPES:
312 {
313 PDISK_GEOMETRY pGeom = (PDISK_GEOMETRY)lpOutBuffer;
314 if(nOutBufferSize < sizeof(DISK_GEOMETRY) || !pGeom) {
315 SetLastError(ERROR_INSUFFICIENT_BUFFER);
316 return FALSE;
317 }
318 if(lpBytesReturned) {
319 *lpBytesReturned = 0;
320 }
321 if(OSLibDosGetDiskGeometry(pHMHandleData->dwUserData, pGeom) == FALSE) {
322 return FALSE;
323 }
324 if(lpBytesReturned) {
325 *lpBytesReturned = sizeof(DISK_GEOMETRY);
326 }
327 SetLastError(ERROR_SUCCESS);
328 return TRUE;
329 }
330
331 case IOCTL_DISK_GET_PARTITION_INFO:
332 case IOCTL_DISK_LOAD_MEDIA:
333 case IOCTL_DISK_MEDIA_REMOVAL:
334 case IOCTL_DISK_PERFORMANCE:
335 case IOCTL_DISK_REASSIGN_BLOCKS:
336 case IOCTL_DISK_SET_DRIVE_LAYOUT:
337 case IOCTL_DISK_SET_PARTITION_INFO:
338 case IOCTL_DISK_VERIFY:
339 case IOCTL_SERIAL_LSRMST_INSERT:
340 break;
341
342 case IOCTL_STORAGE_CHECK_VERIFY:
343 if(lpBytesReturned) {
344 lpBytesReturned = 0;
345 }
346 //TODO: check if disk has been inserted or removed
347 if(pHMHandleData->hHMHandle == 0) {
348 SetLastError(ERROR_NOT_READY);
349 return FALSE;
350 }
351 SetLastError(NO_ERROR);
352 return TRUE;
353
354 case IOCTL_STORAGE_EJECT_MEDIA:
355 case IOCTL_STORAGE_GET_MEDIA_TYPES:
356 case IOCTL_STORAGE_LOAD_MEDIA:
357 case IOCTL_STORAGE_MEDIA_REMOVAL:
358 break;
359 case IOCTL_SCSI_PASS_THROUGH:
360 case IOCTL_SCSI_MINIPORT:
361 case IOCTL_SCSI_GET_INQUIRY_DATA:
362 case IOCTL_SCSI_GET_CAPABILITIES:
363 break;
364
365 case IOCTL_SCSI_PASS_THROUGH_DIRECT:
366 {
367 PSCSI_PASS_THROUGH_DIRECT pPacket = (PSCSI_PASS_THROUGH_DIRECT)lpOutBuffer;
368 SRB_ExecSCSICmd *psrb;
369
370 if(nOutBufferSize < sizeof(SCSI_PASS_THROUGH_DIRECT) ||
371 !pPacket || pPacket->Length < sizeof(SCSI_PASS_THROUGH_DIRECT))
372 {
373 SetLastError(ERROR_INSUFFICIENT_BUFFER);
374 return FALSE;
375 }
376 if(lpBytesReturned) {
377 *lpBytesReturned = 0;
378 }
379 psrb = (SRB_ExecSCSICmd *)alloca(sizeof(SRB_ExecSCSICmd)+pPacket->SenseInfoLength);
380 if(psrb == NULL) {
381 dprintf(("not enough memory!!"));
382 SetLastError(ERROR_NOT_ENOUGH_MEMORY);
383 return FALSE;
384 }
385 memset(psrb, 0, sizeof(*psrb));
386 psrb->SRB_Cmd = SC_EXEC_SCSI_CMD;
387 psrb->SRB_Status = pPacket->ScsiStatus;
388 psrb->SRB_HaId = pPacket->PathId;
389 psrb->SRB_Target = pPacket->TargetId;
390 psrb->SRB_Lun = pPacket->Lun;
391 psrb->SRB_BufLen = pPacket->DataTransferLength;
392 psrb->SRB_SenseLen = pPacket->SenseInfoLength;
393 psrb->SRB_CDBLen = pPacket->CdbLength;
394 switch(pPacket->DataIn) {
395 case SCSI_IOCTL_DATA_OUT:
396 psrb->SRB_Flags = 0x2 << 3;
397 break;
398 case SCSI_IOCTL_DATA_IN:
399 psrb->SRB_Flags = 0x1 << 3;
400 break;
401 case SCSI_IOCTL_DATA_UNSPECIFIED:
402 psrb->SRB_Flags = 0x3 << 3;
403 break;
404 }
405 if(pPacket->CdbLength > 16) {
406 SetLastError(ERROR_INVALID_PARAMETER);
407 return FALSE;
408 }
409 psrb->SRB_BufPointer = (BYTE *)pPacket->DataBuffer;
410 memcpy(&psrb->CDBByte[0], &pPacket->Cdb[0], 16);
411 if(psrb->SRB_SenseLen) {
412 memcpy(&psrb->SenseArea[0], (char *)pPacket + pPacket->SenseInfoOffset, psrb->SRB_SenseLen);
413 }
414 //TODO: pPacket->TimeOutValue ignored
415 int rc = SendASPI32Command((LPSRB)psrb);
416 if(rc != SS_COMP) {
417 dprintf(("SendASPI32Command failed with error %d", rc));
418 if(rc == SS_ERR) {
419 SetLastError(ERROR_ADAP_HDW_ERR); //returned by NT4, SP6
420 }
421 else SetLastError(ERROR_GEN_FAILURE);
422 return FALSE;
423 }
424 pPacket->ScsiStatus = rc;
425 if(lpBytesReturned) {
426 *lpBytesReturned = 0;
427 }
428 pPacket->DataTransferLength = psrb->SRB_BufLen;
429 if(psrb->SRB_SenseLen) {
430 memcpy((char *)pPacket + pPacket->SenseInfoOffset, &psrb->SenseArea[0], psrb->SRB_SenseLen);
431 }
432 SetLastError(ERROR_SUCCESS);
433 return TRUE;
434 }
435 case IOCTL_SCSI_GET_ADDRESS:
436 {
437 DWORD numAdapters, rc;
438 SRB srb;
439 int i, j, k;
440
441 if(!lpOutBuffer || nOutBufferSize < 8) {
442 SetLastError(ERROR_INSUFFICIENT_BUFFER); //todo: right error?
443 return(FALSE);
444 }
445 SCSI_ADDRESS *addr = (SCSI_ADDRESS *)lpOutBuffer;
446 addr->Length = sizeof(SCSI_ADDRESS);
447 addr->PortNumber = 0;
448 addr->PathId = 0;
449 numAdapters = GetASPI32SupportInfo();
450 if(LOBYTE(numAdapters) == 0) goto failure;
451
452 memset(&srb, 0, sizeof(srb));
453 srb.common.SRB_Cmd = SC_HA_INQUIRY;
454 rc = SendASPI32Command(&srb);
455
456 char drivename[3];
457 drivename[0] = (char)pHMHandleData->dwUserData;
458 drivename[1] = ':';
459 drivename[2] = 0;
460
461 for(i=0;i<LOBYTE(numAdapters);i++) {
462 for(j=0;j<8;j++) {
463 for(k=0;k<16;k++) {
464 memset(&srb, 0, sizeof(srb));
465 srb.common.SRB_Cmd = SC_GET_DEV_TYPE;
466 srb.devtype.SRB_HaId = i;
467 srb.devtype.SRB_Target = j;
468 srb.devtype.SRB_Lun = k;
469 rc = SendASPI32Command(&srb);
470 if(rc == SS_COMP) {
471 if(srb.devtype.SRB_DeviceType == SS_DEVTYPE_CDROM &&
472 GetDriveTypeA(drivename) == DRIVE_CDROM)
473 {
474 goto done;
475 }
476 }
477 }
478 }
479 }
480done:
481 if(rc == SS_COMP) {
482 addr->TargetId = j;
483 addr->Lun = k;
484 SetLastError(ERROR_SUCCESS);
485 }
486 else SetLastError(ERROR_FILE_NOT_FOUND); //todo
487 return TRUE;
488failure:
489 SetLastError(ERROR_INVALID_PARAMETER); //todo
490 return FALSE;
491 }
492
493 case IOCTL_SCSI_RESCAN_BUS:
494 case IOCTL_SCSI_GET_DUMP_POINTERS:
495 case IOCTL_SCSI_FREE_DUMP_POINTERS:
496 case IOCTL_IDE_PASS_THROUGH:
497 break;
498
499 }
500 dprintf(("HMDeviceDiskClass::DeviceIoControl: unimplemented dwIoControlCode=%08lx\n", dwIoControlCode));
501 SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
502 return FALSE;
503}
504/*****************************************************************************
505 * Name : BOOL HMDeviceDiskClass::ReadFile
506 * Purpose : read data from handle / device
507 * Parameters: PHMHANDLEDATA pHMHandleData,
508 * LPCVOID lpBuffer,
509 * DWORD nNumberOfBytesToRead,
510 * LPDWORD lpNumberOfBytesRead,
511 * LPOVERLAPPED lpOverlapped
512 * Variables :
513 * Result : Boolean
514 * Remark :
515 * Status :
516 *
517 * Author : Patrick Haller [Wed, 1998/02/11 20:44]
518 *****************************************************************************/
519
520BOOL HMDeviceDiskClass::ReadFile(PHMHANDLEDATA pHMHandleData,
521 LPCVOID lpBuffer,
522 DWORD nNumberOfBytesToRead,
523 LPDWORD lpNumberOfBytesRead,
524 LPOVERLAPPED lpOverlapped)
525{
526 LPVOID lpRealBuf;
527 Win32MemMap *map;
528 DWORD offset, bytesread;
529 BOOL bRC;
530
531 dprintf2(("KERNEL32: HMDeviceDiskClass::ReadFile %s(%08x,%08x,%08x,%08x,%08x) - stub?\n",
532 lpHMDeviceName,
533 pHMHandleData,
534 lpBuffer,
535 nNumberOfBytesToRead,
536 lpNumberOfBytesRead,
537 lpOverlapped));
538
539 //SvL: It's legal for this pointer to be NULL
540 if(lpNumberOfBytesRead)
541 *lpNumberOfBytesRead = 0;
542 else
543 lpNumberOfBytesRead = &bytesread;
544
545 if((pHMHandleData->dwFlags & FILE_FLAG_OVERLAPPED) && !lpOverlapped) {
546 dprintf(("FILE_FLAG_OVERLAPPED flag set, but lpOverlapped NULL!!"));
547 SetLastError(ERROR_INVALID_PARAMETER);
548 return FALSE;
549 }
550 if(!(pHMHandleData->dwFlags & FILE_FLAG_OVERLAPPED) && lpOverlapped) {
551 dprintf(("Warning: lpOverlapped != NULL & !FILE_FLAG_OVERLAPPED; sync operation"));
552 }
553
554 //SvL: DosRead doesn't like writing to memory addresses returned by
555 // DosAliasMem -> search for original memory mapped pointer and use
556 // that one + commit pages if not already present
557 map = Win32MemMapView::findMapByView((ULONG)lpBuffer, &offset, MEMMAP_ACCESS_WRITE);
558 if(map) {
559 lpRealBuf = (LPVOID)((ULONG)map->getMappingAddr() + offset);
560 DWORD nrpages = nNumberOfBytesToRead/4096;
561 if(offset & 0xfff)
562 nrpages++;
563 if(nNumberOfBytesToRead & 0xfff)
564 nrpages++;
565
566 map->commitPage(offset & ~0xfff, TRUE, nrpages);
567 }
568 else lpRealBuf = (LPVOID)lpBuffer;
569
570 if(pHMHandleData->dwFlags & FILE_FLAG_OVERLAPPED) {
571 dprintf(("ERROR: Overlapped IO not yet implememented!!"));
572 }
573// else {
574 bRC = OSLibDosRead(pHMHandleData->hHMHandle,
575 (PVOID)lpRealBuf,
576 nNumberOfBytesToRead,
577 lpNumberOfBytesRead);
578// }
579
580 if(bRC == 0) {
581 dprintf(("KERNEL32: HMDeviceDiskClass::ReadFile returned %08xh %x", bRC, GetLastError()));
582 dprintf(("%x -> %d", lpBuffer, IsBadWritePtr((LPVOID)lpBuffer, nNumberOfBytesToRead)));
583 }
584
585 return bRC;
586}
587/*****************************************************************************
588 * Name : DWORD HMDeviceDiskClass::SetFilePointer
589 * Purpose : set file pointer
590 * Parameters: PHMHANDLEDATA pHMHandleData
591 * LONG lDistanceToMove
592 * PLONG lpDistanceToMoveHigh
593 * DWORD dwMoveMethod
594 * Variables :
595 * Result : API returncode
596 * Remark :
597 * Status :
598 *
599 * Author : Patrick Haller [Wed, 1999/06/17 20:44]
600 *****************************************************************************/
601
602DWORD HMDeviceDiskClass::SetFilePointer(PHMHANDLEDATA pHMHandleData,
603 LONG lDistanceToMove,
604 PLONG lpDistanceToMoveHigh,
605 DWORD dwMoveMethod)
606{
607 DWORD ret;
608
609 dprintf2(("KERNEL32: HMDeviceDiskClass::SetFilePointer %s(%08xh,%08xh,%08xh,%08xh)\n",
610 lpHMDeviceName,
611 pHMHandleData,
612 lDistanceToMove,
613 lpDistanceToMoveHigh,
614 dwMoveMethod));
615
616 ret = OSLibDosSetFilePointer(pHMHandleData->hHMHandle,
617 lDistanceToMove,
618 (DWORD *)lpDistanceToMoveHigh,
619 dwMoveMethod);
620
621 if(ret == -1) {
622 dprintf(("SetFilePointer failed (error = %d)", GetLastError()));
623 }
624 return ret;
625}
626//******************************************************************************
627//******************************************************************************
Note: See TracBrowser for help on using the repository browser.