Context Navigation

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

Visit:

Last change on this file since 6049 was 6049, checked in by sandervl, 24 years ago
semaphore rewrite (not activated)
File size: 20.9 KB

Line
1	/* $Id: hmdisk.cpp,v 1.10 2001-06-19 10:50:24 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
27	static HINSTANCE hInstAspi = 0;
28	static DWORD (WIN32API *GetASPI32SupportInfo)() = NULL;
29	static DWORD (CDECL *SendASPI32Command)(LPSRB lpSRB) = NULL;
30
31	HMDeviceDiskClass::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	*****************************************************************************/
49	BOOL 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	//******************************************************************************
72	DWORD 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	//******************************************************************************
141	BOOL HMDeviceDiskClass::CloseHandle(PHMHANDLEDATA pHMHandleData)
142	{
143	if(pHMHandleData->hHMHandle) {
144	return OSLibDosClose(pHMHandleData->hHMHandle);
145	}
146	return TRUE;
147	}
148	//******************************************************************************
149	//******************************************************************************
150	BOOL 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(hInstAspi == NULL) {
371	SetLastError(ERROR_ACCESS_DENIED);
372	return FALSE;
373	}
374
375	if(nOutBufferSize < sizeof(SCSI_PASS_THROUGH_DIRECT) \|\|
376	!pPacket \|\| pPacket->Length < sizeof(SCSI_PASS_THROUGH_DIRECT))
377	{
378	SetLastError(ERROR_INSUFFICIENT_BUFFER);
379	return FALSE;
380	}
381	if(lpBytesReturned) {
382	*lpBytesReturned = 0;
383	}
384	psrb = (SRB_ExecSCSICmd *)alloca(sizeof(SRB_ExecSCSICmd)+pPacket->SenseInfoLength);
385	if(psrb == NULL) {
386	dprintf(("not enough memory!!"));
387	SetLastError(ERROR_NOT_ENOUGH_MEMORY);
388	return FALSE;
389	}
390	memset(psrb, 0, sizeof(*psrb));
391	psrb->SRB_Cmd = SC_EXEC_SCSI_CMD;
392	psrb->SRB_Status = pPacket->ScsiStatus;
393	psrb->SRB_HaId = pPacket->PathId;
394	psrb->SRB_Target = pPacket->TargetId;
395	psrb->SRB_Lun = pPacket->Lun;
396	psrb->SRB_BufLen = pPacket->DataTransferLength;
397	psrb->SRB_SenseLen = pPacket->SenseInfoLength;
398	psrb->SRB_CDBLen = pPacket->CdbLength;
399	switch(pPacket->DataIn) {
400	case SCSI_IOCTL_DATA_OUT:
401	psrb->SRB_Flags = 0x2 << 3;
402	break;
403	case SCSI_IOCTL_DATA_IN:
404	psrb->SRB_Flags = 0x1 << 3;
405	break;
406	case SCSI_IOCTL_DATA_UNSPECIFIED:
407	psrb->SRB_Flags = 0x3 << 3;
408	break;
409	}
410	if(pPacket->CdbLength > 16) {
411	SetLastError(ERROR_INVALID_PARAMETER);
412	return FALSE;
413	}
414	psrb->SRB_BufPointer = (BYTE *)pPacket->DataBuffer;
415	memcpy(&psrb->CDBByte[0], &pPacket->Cdb[0], 16);
416	if(psrb->SRB_SenseLen) {
417	memcpy(&psrb->SenseArea[0], (char *)pPacket + pPacket->SenseInfoOffset, psrb->SRB_SenseLen);
418	}
419	//TODO: pPacket->TimeOutValue ignored
420	int rc = SendASPI32Command((LPSRB)psrb);
421	if(rc != SS_COMP) {
422	dprintf(("SendASPI32Command failed with error %d", rc));
423	if(rc == SS_ERR) {
424	SetLastError(ERROR_ADAP_HDW_ERR); //returned by NT4, SP6
425	}
426	else SetLastError(ERROR_GEN_FAILURE);
427	return FALSE;
428	}
429	pPacket->ScsiStatus = rc;
430	if(lpBytesReturned) {
431	*lpBytesReturned = 0;
432	}
433	pPacket->DataTransferLength = psrb->SRB_BufLen;
434	if(psrb->SRB_SenseLen) {
435	memcpy((char *)pPacket + pPacket->SenseInfoOffset, &psrb->SenseArea[0], psrb->SRB_SenseLen);
436	}
437	SetLastError(ERROR_SUCCESS);
438	return TRUE;
439	}
440	case IOCTL_SCSI_GET_ADDRESS:
441	{
442	DWORD numAdapters, rc;
443	SRB srb;
444	int i, j, k;
445
446	if(!lpOutBuffer \|\| nOutBufferSize < 8) {
447	SetLastError(ERROR_INSUFFICIENT_BUFFER); //todo: right error?
448	return(FALSE);
449	}
450	SCSI_ADDRESS addr = (SCSI_ADDRESS )lpOutBuffer;
451	addr->Length = sizeof(SCSI_ADDRESS);
452	addr->PortNumber = 0;
453	addr->PathId = 0;
454	numAdapters = GetASPI32SupportInfo();
455	if(LOBYTE(numAdapters) == 0) goto failure;
456
457	memset(&srb, 0, sizeof(srb));
458	srb.common.SRB_Cmd = SC_HA_INQUIRY;
459	rc = SendASPI32Command(&srb);
460
461	char drivename[3];
462	drivename[0] = (char)pHMHandleData->dwUserData;
463	drivename[1] = ':';
464	drivename[2] = 0;
465
466	for(i=0;i<LOBYTE(numAdapters);i++) {
467	for(j=0;j<8;j++) {
468	for(k=0;k<16;k++) {
469	memset(&srb, 0, sizeof(srb));
470	srb.common.SRB_Cmd = SC_GET_DEV_TYPE;
471	srb.devtype.SRB_HaId = i;
472	srb.devtype.SRB_Target = j;
473	srb.devtype.SRB_Lun = k;
474	rc = SendASPI32Command(&srb);
475	if(rc == SS_COMP) {
476	if(srb.devtype.SRB_DeviceType == SS_DEVTYPE_CDROM &&
477	GetDriveTypeA(drivename) == DRIVE_CDROM)
478	{
479	goto done;
480	}
481	}
482	}
483	}
484	}
485	done:
486	if(rc == SS_COMP) {
487	addr->TargetId = j;
488	addr->Lun = k;
489	SetLastError(ERROR_SUCCESS);
490	}
491	else SetLastError(ERROR_FILE_NOT_FOUND); //todo
492	return TRUE;
493	failure:
494	SetLastError(ERROR_INVALID_PARAMETER); //todo
495	return FALSE;
496	}
497
498	case IOCTL_SCSI_RESCAN_BUS:
499	case IOCTL_SCSI_GET_DUMP_POINTERS:
500	case IOCTL_SCSI_FREE_DUMP_POINTERS:
501	case IOCTL_IDE_PASS_THROUGH:
502	break;
503
504	}
505	dprintf(("HMDeviceDiskClass::DeviceIoControl: unimplemented dwIoControlCode=%08lx\n", dwIoControlCode));
506	SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
507	return FALSE;
508	}
509	/*****************************************************************************
510	* Name : BOOL HMDeviceDiskClass::ReadFile
511	* Purpose : read data from handle / device
512	* Parameters: PHMHANDLEDATA pHMHandleData,
513	* LPCVOID lpBuffer,
514	* DWORD nNumberOfBytesToRead,
515	* LPDWORD lpNumberOfBytesRead,
516	* LPOVERLAPPED lpOverlapped
517	* Variables :
518	* Result : Boolean
519	* Remark :
520	* Status :
521	*
522	* Author : Patrick Haller [Wed, 1998/02/11 20:44]
523	*****************************************************************************/
524
525	BOOL HMDeviceDiskClass::ReadFile(PHMHANDLEDATA pHMHandleData,
526	LPCVOID lpBuffer,
527	DWORD nNumberOfBytesToRead,
528	LPDWORD lpNumberOfBytesRead,
529	LPOVERLAPPED lpOverlapped)
530	{
531	LPVOID lpRealBuf;
532	Win32MemMap *map;
533	DWORD offset, bytesread;
534	BOOL bRC;
535
536	dprintf2(("KERNEL32: HMDeviceDiskClass::ReadFile %s(%08x,%08x,%08x,%08x,%08x) - stub?\n",
537	lpHMDeviceName,
538	pHMHandleData,
539	lpBuffer,
540	nNumberOfBytesToRead,
541	lpNumberOfBytesRead,
542	lpOverlapped));
543
544	//SvL: It's legal for this pointer to be NULL
545	if(lpNumberOfBytesRead)
546	*lpNumberOfBytesRead = 0;
547	else
548	lpNumberOfBytesRead = &bytesread;
549
550	if((pHMHandleData->dwFlags & FILE_FLAG_OVERLAPPED) && !lpOverlapped) {
551	dprintf(("FILE_FLAG_OVERLAPPED flag set, but lpOverlapped NULL!!"));
552	SetLastError(ERROR_INVALID_PARAMETER);
553	return FALSE;
554	}
555	if(!(pHMHandleData->dwFlags & FILE_FLAG_OVERLAPPED) && lpOverlapped) {
556	dprintf(("Warning: lpOverlapped != NULL & !FILE_FLAG_OVERLAPPED; sync operation"));
557	}
558
559	//SvL: DosRead doesn't like writing to memory addresses returned by
560	// DosAliasMem -> search for original memory mapped pointer and use
561	// that one + commit pages if not already present
562	map = Win32MemMapView::findMapByView((ULONG)lpBuffer, &offset, MEMMAP_ACCESS_WRITE);
563	if(map) {
564	lpRealBuf = (LPVOID)((ULONG)map->getMappingAddr() + offset);
565	DWORD nrpages = nNumberOfBytesToRead/4096;
566	if(offset & 0xfff)
567	nrpages++;
568	if(nNumberOfBytesToRead & 0xfff)
569	nrpages++;
570
571	map->commitPage(offset & ~0xfff, TRUE, nrpages);
572	}
573	else lpRealBuf = (LPVOID)lpBuffer;
574
575	if(pHMHandleData->dwFlags & FILE_FLAG_OVERLAPPED) {
576	dprintf(("ERROR: Overlapped IO not yet implememented!!"));
577	}
578	// else {
579	bRC = OSLibDosRead(pHMHandleData->hHMHandle,
580	(PVOID)lpRealBuf,
581	nNumberOfBytesToRead,
582	lpNumberOfBytesRead);
583	// }
584
585	if(bRC == 0) {
586	dprintf(("KERNEL32: HMDeviceDiskClass::ReadFile returned %08xh %x", bRC, GetLastError()));
587	dprintf(("%x -> %d", lpBuffer, IsBadWritePtr((LPVOID)lpBuffer, nNumberOfBytesToRead)));
588	}
589
590	return bRC;
591	}
592	/*****************************************************************************
593	* Name : DWORD HMDeviceDiskClass::SetFilePointer
594	* Purpose : set file pointer
595	* Parameters: PHMHANDLEDATA pHMHandleData
596	* LONG lDistanceToMove
597	* PLONG lpDistanceToMoveHigh
598	* DWORD dwMoveMethod
599	* Variables :
600	* Result : API returncode
601	* Remark :
602	* Status :
603	*
604	* Author : Patrick Haller [Wed, 1999/06/17 20:44]
605	*****************************************************************************/
606
607	DWORD HMDeviceDiskClass::SetFilePointer(PHMHANDLEDATA pHMHandleData,
608	LONG lDistanceToMove,
609	PLONG lpDistanceToMoveHigh,
610	DWORD dwMoveMethod)
611	{
612	DWORD ret;
613
614	dprintf2(("KERNEL32: HMDeviceDiskClass::SetFilePointer %s(%08xh,%08xh,%08xh,%08xh)\n",
615	lpHMDeviceName,
616	pHMHandleData,
617	lDistanceToMove,
618	lpDistanceToMoveHigh,
619	dwMoveMethod));
620
621	ret = OSLibDosSetFilePointer(pHMHandleData->hHMHandle,
622	lDistanceToMove,
623	(DWORD *)lpDistanceToMoveHigh,
624	dwMoveMethod);
625
626	if(ret == -1) {
627	dprintf(("SetFilePointer failed (error = %d)", GetLastError()));
628	}
629	return ret;
630	}
631	//******************************************************************************
632	//******************************************************************************

Note: See TracBrowser for help on using the repository browser.

Download in other formats: