?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Moved some more definitions out of undocshell.h into the exported
[wine/multimedia.git] / dlls / ntdll / virtual.c
blob737585d653bfdf5ad43d931b15522c10b2dad333
1 /*
2 * Win32 virtual memory functions
3 *
4 * Copyright 1997, 2002 Alexandre Julliard
5 *
6 * This library is free software; you can redistribute it and/or
7 * modify it under the terms of the GNU Lesser General Public
8 * License as published by the Free Software Foundation; either
9 * version 2.1 of the License, or (at your option) any later version.
10 *
11 * This library is distributed in the hope that it will be useful,
12 * but WITHOUT ANY WARRANTY; without even the implied warranty of
13 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
14 * Lesser General Public License for more details.
15 *
16 * You should have received a copy of the GNU Lesser General Public
17 * License along with this library; if not, write to the Free Software
18 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
19 */
20
21 #include "config.h"
22 #include "wine/port.h"
23
24 #include <assert.h>
25 #include <errno.h>
26 #ifdef HAVE_SYS_ERRNO_H
27 #include <sys/errno.h>
28 #endif
29 #include <fcntl.h>
30 #ifdef HAVE_UNISTD_H
31 # include <unistd.h>
32 #endif
33 #include <stdlib.h>
34 #include <stdio.h>
35 #include <string.h>
36 #include <sys/types.h>
37 #ifdef HAVE_SYS_MMAN_H
38 #include <sys/mman.h>
39 #endif
40
41 #define NONAMELESSUNION
42 #define NONAMELESSSTRUCT
43 #include "ntstatus.h"
44 #include "thread.h"
45 #include "winternl.h"
46 #include "wine/library.h"
47 #include "wine/server.h"
48 #include "wine/debug.h"
49 #include "ntdll_misc.h"
50
51 WINE_DEFAULT_DEBUG_CHANNEL(virtual);
52 WINE_DECLARE_DEBUG_CHANNEL(module);
53
54 #ifndef MS_SYNC
55 #define MS_SYNC 0
56 #endif
57
58 /* File view */
59 typedef struct _FV
60 {
61 struct _FV *next; /* Next view */
62 struct _FV *prev; /* Prev view */
63 void *base; /* Base address */
64 UINT size; /* Size in bytes */
65 UINT flags; /* Allocation flags */
66 HANDLE mapping; /* Handle to the file mapping */
67 HANDLERPROC handlerProc; /* Fault handler */
68 LPVOID handlerArg; /* Fault handler argument */
69 BYTE protect; /* Protection for all pages at allocation time */
70 BYTE prot[1]; /* Protection byte for each page */
71 } FILE_VIEW;
72
73 /* Per-view flags */
74 #define VFLAG_SYSTEM 0x01
75 #define VFLAG_VALLOC 0x02 /* allocated by VirtualAlloc */
76
77 /* Conversion from VPROT_* to Win32 flags */
78 static const BYTE VIRTUAL_Win32Flags[16] =
79 {
80 PAGE_NOACCESS, /* 0 */
81 PAGE_READONLY, /* READ */
82 PAGE_READWRITE, /* WRITE */
83 PAGE_READWRITE, /* READ | WRITE */
84 PAGE_EXECUTE, /* EXEC */
85 PAGE_EXECUTE_READ, /* READ | EXEC */
86 PAGE_EXECUTE_READWRITE, /* WRITE | EXEC */
87 PAGE_EXECUTE_READWRITE, /* READ | WRITE | EXEC */
88 PAGE_WRITECOPY, /* WRITECOPY */
89 PAGE_WRITECOPY, /* READ | WRITECOPY */
90 PAGE_WRITECOPY, /* WRITE | WRITECOPY */
91 PAGE_WRITECOPY, /* READ | WRITE | WRITECOPY */
92 PAGE_EXECUTE_WRITECOPY, /* EXEC | WRITECOPY */
93 PAGE_EXECUTE_WRITECOPY, /* READ | EXEC | WRITECOPY */
94 PAGE_EXECUTE_WRITECOPY, /* WRITE | EXEC | WRITECOPY */
95 PAGE_EXECUTE_WRITECOPY /* READ | WRITE | EXEC | WRITECOPY */
96 };
97
98
99 static FILE_VIEW *VIRTUAL_FirstView;
100
101 static CRITICAL_SECTION csVirtual;
102 static CRITICAL_SECTION_DEBUG critsect_debug =
103 {
104 0, 0, &csVirtual,
105 { &critsect_debug.ProcessLocksList, &critsect_debug.ProcessLocksList },
106 0, 0, { 0, (DWORD)(__FILE__ ": csVirtual") }
107 };
108 static CRITICAL_SECTION csVirtual = { &critsect_debug, -1, 0, 0, 0, 0 };
109
110 #ifdef __i386__
111 /* These are always the same on an i386, and it will be faster this way */
112 # define page_mask 0xfff
113 # define page_shift 12
114 # define page_size 0x1000
115 /* Note: ADDRESS_SPACE_LIMIT is a Windows limit, you cannot change it.
116 * If you are on Solaris you need to find a way to avoid having the system
117 * allocate things above 0xc000000. Don't touch that define.
118 */
119 # define ADDRESS_SPACE_LIMIT ((void *)0xc0000000) /* top of the user address space */
120 #else
121 static UINT page_shift;
122 static UINT page_mask;
123 static UINT page_size;
124 # define ADDRESS_SPACE_LIMIT 0 /* no limit needed on other platforms */
125 #endif /* __i386__ */
126 #define granularity_mask 0xffff /* Allocation granularity (usually 64k) */
127
128 #define ROUND_ADDR(addr,mask) \
129 ((void *)((UINT_PTR)(addr) & ~(mask)))
130
131 #define ROUND_SIZE(addr,size) \
132 (((UINT)(size) + ((UINT_PTR)(addr) & page_mask) + page_mask) & ~page_mask)
133
134 #define VIRTUAL_DEBUG_DUMP_VIEW(view) \
135 if (!TRACE_ON(virtual)); else VIRTUAL_DumpView(view)
136
137 static LPVOID VIRTUAL_mmap( int fd, LPVOID start, DWORD size, DWORD offset_low,
138 DWORD offset_high, int prot, int flags, BOOL *removable );
139
140
141 /***********************************************************************
142 * VIRTUAL_GetProtStr
143 */
144 static const char *VIRTUAL_GetProtStr( BYTE prot )
145 {
146 static char buffer[6];
147 buffer[0] = (prot & VPROT_COMMITTED) ? 'c' : '-';
148 buffer[1] = (prot & VPROT_GUARD) ? 'g' : '-';
149 buffer[2] = (prot & VPROT_READ) ? 'r' : '-';
150 buffer[3] = (prot & VPROT_WRITE) ?
151 ((prot & VPROT_WRITECOPY) ? 'w' : 'W') : '-';
152 buffer[4] = (prot & VPROT_EXEC) ? 'x' : '-';
153 buffer[5] = 0;
154 return buffer;
155 }
156
157
158 /***********************************************************************
159 * VIRTUAL_DumpView
160 */
161 static void VIRTUAL_DumpView( FILE_VIEW *view )
162 {
163 UINT i, count;
164 char *addr = view->base;
165 BYTE prot = view->prot[0];
166
167 DPRINTF( "View: %p - %p", addr, addr + view->size - 1 );
168 if (view->flags & VFLAG_SYSTEM)
169 DPRINTF( " (system)\n" );
170 else if (view->flags & VFLAG_VALLOC)
171 DPRINTF( " (valloc)\n" );
172 else if (view->mapping)
173 DPRINTF( " %p\n", view->mapping );
174 else
175 DPRINTF( " (anonymous)\n");
176
177 for (count = i = 1; i < view->size >> page_shift; i++, count++)
178 {
179 if (view->prot[i] == prot) continue;
180 DPRINTF( " %p - %p %s\n",
181 addr, addr + (count << page_shift) - 1, VIRTUAL_GetProtStr(prot) );
182 addr += (count << page_shift);
183 prot = view->prot[i];
184 count = 0;
185 }
186 if (count)
187 DPRINTF( " %p - %p %s\n",
188 addr, addr + (count << page_shift) - 1, VIRTUAL_GetProtStr(prot) );
189 }
190
191
192 /***********************************************************************
193 * VIRTUAL_Dump
194 */
195 void VIRTUAL_Dump(void)
196 {
197 FILE_VIEW *view;
198 DPRINTF( "\nDump of all virtual memory views:\n\n" );
199 RtlEnterCriticalSection(&csVirtual);
200 view = VIRTUAL_FirstView;
201 while (view)
202 {
203 VIRTUAL_DumpView( view );
204 view = view->next;
205 }
206 RtlLeaveCriticalSection(&csVirtual);
207 }
208
209
210 /***********************************************************************
211 * VIRTUAL_FindView
212 *
213 * Find the view containing a given address.
214 *
215 * RETURNS
216 * View: Success
217 * NULL: Failure
218 */
219 static FILE_VIEW *VIRTUAL_FindView( const void *addr ) /* [in] Address */
220 {
221 FILE_VIEW *view;
222
223 RtlEnterCriticalSection(&csVirtual);
224 view = VIRTUAL_FirstView;
225 while (view)
226 {
227 if (view->base > addr)
228 {
229 view = NULL;
230 break;
231 }
232 if ((char*)view->base + view->size > (char*)addr) break;
233 view = view->next;
234 }
235 RtlLeaveCriticalSection(&csVirtual);
236 return view;
237 }
238
239
240 /***********************************************************************
241 * VIRTUAL_DeleteView
242 * Deletes a view.
243 *
244 * RETURNS
245 * None
246 */
247 static void VIRTUAL_DeleteView( FILE_VIEW *view ) /* [in] View */
248 {
249 RtlEnterCriticalSection(&csVirtual);
250 if (!(view->flags & VFLAG_SYSTEM))
251 munmap( (void *)view->base, view->size );
252 if (view->next) view->next->prev = view->prev;
253 if (view->prev) view->prev->next = view->next;
254 else VIRTUAL_FirstView = view->next;
255 RtlLeaveCriticalSection(&csVirtual);
256 if (view->mapping) NtClose( view->mapping );
257 free( view );
258 }
259
260
261 /***********************************************************************
262 * VIRTUAL_CreateView
263 *
264 * Create a new view and add it in the linked list.
265 */
266 static FILE_VIEW *VIRTUAL_CreateView( void *base, UINT size, UINT flags,
267 BYTE vprot, HANDLE mapping )
268 {
269 FILE_VIEW *view, *prev;
270
271 /* Create the view structure */
272
273 assert( !((unsigned int)base & page_mask) );
274 assert( !(size & page_mask) );
275 size >>= page_shift;
276 if (!(view = (FILE_VIEW *)malloc( sizeof(*view) + size - 1 ))) return NULL;
277 view->base = base;
278 view->size = size << page_shift;
279 view->flags = flags;
280 view->mapping = mapping;
281 view->protect = vprot;
282 view->handlerProc = NULL;
283 memset( view->prot, vprot, size );
284
285 /* Duplicate the mapping handle */
286
287 if (view->mapping &&
288 NtDuplicateObject( GetCurrentProcess(), view->mapping,
289 GetCurrentProcess(), &view->mapping,
290 0, 0, DUPLICATE_SAME_ACCESS ))
291 {
292 free( view );
293 return NULL;
294 }
295
296 /* Insert it in the linked list */
297
298 RtlEnterCriticalSection(&csVirtual);
299 if (!VIRTUAL_FirstView || (VIRTUAL_FirstView->base > base))
300 {
301 view->next = VIRTUAL_FirstView;
302 view->prev = NULL;
303 if (view->next) view->next->prev = view;
304 VIRTUAL_FirstView = view;
305 }
306 else
307 {
308 prev = VIRTUAL_FirstView;
309 while (prev->next && (prev->next->base < base)) prev = prev->next;
310 view->next = prev->next;
311 view->prev = prev;
312 if (view->next) view->next->prev = view;
313 prev->next = view;
314
315 /* Check for overlapping views. This can happen if the previous view
316 * was a system view that got unmapped behind our back. In that case
317 * we recover by simply deleting it. */
318 if ((char *)prev->base + prev->size > (char *)base)
319 {
320 TRACE( "overlapping prev view %p-%p for %p-%p\n",
321 prev->base, (char *)prev->base + prev->size,
322 base, (char *)base + view->size );
323 assert( view->prev->flags & VFLAG_SYSTEM );
324 VIRTUAL_DeleteView( view->prev );
325 }
326 }
327 /* check for overlap with next too */
328 if (view->next && (char *)base + view->size > (char *)view->next->base)
329 {
330 TRACE( "overlapping next view %p-%p for %p-%p\n",
331 view->next->base, (char *)view->next->base + view->next->size,
332 base, (char *)base + view->size );
333 assert( view->next->flags & VFLAG_SYSTEM );
334 VIRTUAL_DeleteView( view->next );
335 }
336 RtlLeaveCriticalSection(&csVirtual);
337 VIRTUAL_DEBUG_DUMP_VIEW( view );
338 return view;
339 }
340
341
342 /***********************************************************************
343 * VIRTUAL_GetUnixProt
344 *
345 * Convert page protections to protection for mmap/mprotect.
346 */
347 static int VIRTUAL_GetUnixProt( BYTE vprot )
348 {
349 int prot = 0;
350 if ((vprot & VPROT_COMMITTED) && !(vprot & VPROT_GUARD))
351 {
352 if (vprot & VPROT_READ) prot |= PROT_READ;
353 if (vprot & VPROT_WRITE) prot |= PROT_WRITE;
354 if (vprot & VPROT_WRITECOPY) prot |= PROT_WRITE;
355 if (vprot & VPROT_EXEC) prot |= PROT_EXEC;
356 }
357 return prot;
358 }
359
360
361 /***********************************************************************
362 * VIRTUAL_GetWin32Prot
363 *
364 * Convert page protections to Win32 flags.
365 *
366 * RETURNS
367 * None
368 */
369 static void VIRTUAL_GetWin32Prot(
370 BYTE vprot, /* [in] Page protection flags */
371 DWORD *protect, /* [out] Location to store Win32 protection flags */
372 DWORD *state ) /* [out] Location to store mem state flag */
373 {
374 if (protect) {
375 *protect = VIRTUAL_Win32Flags[vprot & 0x0f];
376 /* if (vprot & VPROT_GUARD) *protect |= PAGE_GUARD;*/
377 if (vprot & VPROT_NOCACHE) *protect |= PAGE_NOCACHE;
378
379 if (vprot & VPROT_GUARD) *protect = PAGE_NOACCESS;
380 }
381
382 if (state) *state = (vprot & VPROT_COMMITTED) ? MEM_COMMIT : MEM_RESERVE;
383 }
384
385
386 /***********************************************************************
387 * VIRTUAL_GetProt
388 *
389 * Build page protections from Win32 flags.
390 *
391 * RETURNS
392 * Value of page protection flags
393 */
394 static BYTE VIRTUAL_GetProt( DWORD protect ) /* [in] Win32 protection flags */
395 {
396 BYTE vprot;
397
398 switch(protect & 0xff)
399 {
400 case PAGE_READONLY:
401 vprot = VPROT_READ;
402 break;
403 case PAGE_READWRITE:
404 vprot = VPROT_READ | VPROT_WRITE;
405 break;
406 case PAGE_WRITECOPY:
407 /* MSDN CreateFileMapping() states that if PAGE_WRITECOPY is given,
408 * that the hFile must have been opened with GENERIC_READ and
409 * GENERIC_WRITE access. This is WRONG as tests show that you
410 * only need GENERIC_READ access (at least for Win9x,
411 * FIXME: what about NT?). Thus, we don't put VPROT_WRITE in
412 * PAGE_WRITECOPY and PAGE_EXECUTE_WRITECOPY.
413 */
414 vprot = VPROT_READ | VPROT_WRITECOPY;
415 break;
416 case PAGE_EXECUTE:
417 vprot = VPROT_EXEC;
418 break;
419 case PAGE_EXECUTE_READ:
420 vprot = VPROT_EXEC | VPROT_READ;
421 break;
422 case PAGE_EXECUTE_READWRITE:
423 vprot = VPROT_EXEC | VPROT_READ | VPROT_WRITE;
424 break;
425 case PAGE_EXECUTE_WRITECOPY:
426 /* See comment for PAGE_WRITECOPY above */
427 vprot = VPROT_EXEC | VPROT_READ | VPROT_WRITECOPY;
428 break;
429 case PAGE_NOACCESS:
430 default:
431 vprot = 0;
432 break;
433 }
434 if (protect & PAGE_GUARD) vprot |= VPROT_GUARD;
435 if (protect & PAGE_NOCACHE) vprot |= VPROT_NOCACHE;
436 return vprot;
437 }
438
439
440 /***********************************************************************
441 * VIRTUAL_SetProt
442 *
443 * Change the protection of a range of pages.
444 *
445 * RETURNS
446 * TRUE: Success
447 * FALSE: Failure
448 */
449 static BOOL VIRTUAL_SetProt( FILE_VIEW *view, /* [in] Pointer to view */
450 void *base, /* [in] Starting address */
451 UINT size, /* [in] Size in bytes */
452 BYTE vprot ) /* [in] Protections to use */
453 {
454 TRACE("%p-%p %s\n",
455 base, (char *)base + size - 1, VIRTUAL_GetProtStr( vprot ) );
456
457 if (mprotect( base, size, VIRTUAL_GetUnixProt(vprot) ))
458 return FALSE; /* FIXME: last error */
459
460 memset( view->prot + (((char *)base - (char *)view->base) >> page_shift),
461 vprot, size >> page_shift );
462 VIRTUAL_DEBUG_DUMP_VIEW( view );
463 return TRUE;
464 }
465
466
467 /***********************************************************************
468 * anon_mmap_aligned
469 *
470 * Create an anonymous mapping aligned to the allocation granularity.
471 */
472 static NTSTATUS anon_mmap_aligned( void **addr, unsigned int size, int prot, int flags )
473 {
474 void *ptr, *base = *addr;
475 unsigned int view_size = size + (base ? 0 : granularity_mask + 1);
476
477 if ((ptr = wine_anon_mmap( base, view_size, prot, flags )) == (void *)-1)
478 {
479 if (errno == ENOMEM) return STATUS_NO_MEMORY;
480 return STATUS_INVALID_PARAMETER;
481 }
482
483 if (!base)
484 {
485 /* Release the extra memory while keeping the range
486 * starting on the granularity boundary. */
487 if ((unsigned int)ptr & granularity_mask)
488 {
489 unsigned int extra = granularity_mask + 1 - ((unsigned int)ptr & granularity_mask);
490 munmap( ptr, extra );
491 ptr = (char *)ptr + extra;
492 view_size -= extra;
493 }
494 if (view_size > size)
495 munmap( (char *)ptr + size, view_size - size );
496 }
497 else if (ptr != base)
498 {
499 /* We couldn't get the address we wanted */
500 munmap( ptr, view_size );
501 return STATUS_CONFLICTING_ADDRESSES;
502 }
503 *addr = ptr;
504 return STATUS_SUCCESS;
505 }
506
507
508 /***********************************************************************
509 * do_relocations
510 *
511 * Apply the relocations to a mapped PE image
512 */
513 static int do_relocations( char *base, const IMAGE_DATA_DIRECTORY *dir,
514 int delta, DWORD total_size )
515 {
516 IMAGE_BASE_RELOCATION *rel;
517
518 TRACE_(module)( "relocating from %p-%p to %p-%p\n",
519 base - delta, base - delta + total_size, base, base + total_size );
520
521 for (rel = (IMAGE_BASE_RELOCATION *)(base + dir->VirtualAddress);
522 ((char *)rel < base + dir->VirtualAddress + dir->Size) && rel->SizeOfBlock;
523 rel = (IMAGE_BASE_RELOCATION*)((char*)rel + rel->SizeOfBlock) )
524 {
525 char *page = base + rel->VirtualAddress;
526 WORD *TypeOffset = (WORD *)(rel + 1);
527 int i, count = (rel->SizeOfBlock - sizeof(*rel)) / sizeof(*TypeOffset);
528
529 if (!count) continue;
530
531 /* sanity checks */
532 if ((char *)rel + rel->SizeOfBlock > base + dir->VirtualAddress + dir->Size ||
533 page > base + total_size)
534 {
535 ERR_(module)("invalid relocation %p,%lx,%ld at %p,%lx,%lx\n",
536 rel, rel->VirtualAddress, rel->SizeOfBlock,
537 base, dir->VirtualAddress, dir->Size );
538 return 0;
539 }
540
541 TRACE_(module)("%ld relocations for page %lx\n", rel->SizeOfBlock, rel->VirtualAddress);
542
543 /* patching in reverse order */
544 for (i = 0 ; i < count; i++)
545 {
546 int offset = TypeOffset[i] & 0xFFF;
547 int type = TypeOffset[i] >> 12;
548 switch(type)
549 {
550 case IMAGE_REL_BASED_ABSOLUTE:
551 break;
552 case IMAGE_REL_BASED_HIGH:
553 *(short*)(page+offset) += HIWORD(delta);
554 break;
555 case IMAGE_REL_BASED_LOW:
556 *(short*)(page+offset) += LOWORD(delta);
557 break;
558 case IMAGE_REL_BASED_HIGHLOW:
559 *(int*)(page+offset) += delta;
560 /* FIXME: if this is an exported address, fire up enhanced logic */
561 break;
562 default:
563 FIXME_(module)("Unknown/unsupported fixup type %d.\n", type);
564 break;
565 }
566 }
567 }
568 return 1;
569 }
570
571
572 /***********************************************************************
573 * map_image
574 *
575 * Map an executable (PE format) image into memory.
576 */
577 static NTSTATUS map_image( HANDLE hmapping, int fd, char *base, DWORD total_size,
578 DWORD header_size, int shared_fd, BOOL removable, PVOID *addr_ptr )
579 {
580 IMAGE_DOS_HEADER *dos;
581 IMAGE_NT_HEADERS *nt;
582 IMAGE_SECTION_HEADER *sec;
583 IMAGE_DATA_DIRECTORY *imports;
584 NTSTATUS status = STATUS_INVALID_IMAGE_FORMAT; /* generic error (FIXME) */
585 int i, pos;
586 FILE_VIEW *view;
587 char *ptr;
588
589 /* zero-map the whole range */
590
591 if (base < (char *)0x110000 || /* make sure the DOS area remains free */
592 (ptr = wine_anon_mmap( base, total_size,
593 PROT_READ | PROT_WRITE | PROT_EXEC, 0 )) == (char *)-1)
594 {
595 ptr = wine_anon_mmap( NULL, total_size,
596 PROT_READ | PROT_WRITE | PROT_EXEC, 0 );
597 if (ptr == (char *)-1)
598 {
599 ERR_(module)("Not enough memory for module (%ld bytes)\n", total_size);
600 goto error;
601 }
602 }
603 TRACE_(module)( "mapped PE file at %p-%p\n", ptr, ptr + total_size );
604
605 /* map the header */
606
607 if (VIRTUAL_mmap( fd, ptr, header_size, 0, 0, PROT_READ,
608 MAP_PRIVATE | MAP_FIXED, &removable ) == (char *)-1) goto error;
609 dos = (IMAGE_DOS_HEADER *)ptr;
610 nt = (IMAGE_NT_HEADERS *)(ptr + dos->e_lfanew);
611 if ((char *)(nt + 1) > ptr + header_size) goto error;
612
613 sec = (IMAGE_SECTION_HEADER*)((char*)&nt->OptionalHeader+nt->FileHeader.SizeOfOptionalHeader);
614 if ((char *)(sec + nt->FileHeader.NumberOfSections) > ptr + header_size) goto error;
615
616 imports = nt->OptionalHeader.DataDirectory + IMAGE_DIRECTORY_ENTRY_IMPORT;
617 if (!imports->Size || !imports->VirtualAddress) imports = NULL;
618
619 /* check the architecture */
620
621 if (nt->FileHeader.Machine != IMAGE_FILE_MACHINE_I386)
622 {
623 MESSAGE("Trying to load PE image for unsupported architecture (");
624 switch (nt->FileHeader.Machine)
625 {
626 case IMAGE_FILE_MACHINE_UNKNOWN: MESSAGE("Unknown"); break;
627 case IMAGE_FILE_MACHINE_I860: MESSAGE("I860"); break;
628 case IMAGE_FILE_MACHINE_R3000: MESSAGE("R3000"); break;
629 case IMAGE_FILE_MACHINE_R4000: MESSAGE("R4000"); break;
630 case IMAGE_FILE_MACHINE_R10000: MESSAGE("R10000"); break;
631 case IMAGE_FILE_MACHINE_ALPHA: MESSAGE("Alpha"); break;
632 case IMAGE_FILE_MACHINE_POWERPC: MESSAGE("PowerPC"); break;
633 default: MESSAGE("Unknown-%04x", nt->FileHeader.Machine); break;
634 }
635 MESSAGE(")\n");
636 goto error;
637 }
638
639 /* map all the sections */
640
641 for (i = pos = 0; i < nt->FileHeader.NumberOfSections; i++, sec++)
642 {
643 DWORD size;
644
645 /* a few sanity checks */
646 size = sec->VirtualAddress + ROUND_SIZE( sec->VirtualAddress, sec->Misc.VirtualSize );
647 if (sec->VirtualAddress > total_size || size > total_size || size < sec->VirtualAddress)
648 {
649 ERR_(module)( "Section %.8s too large (%lx+%lx/%lx)\n",
650 sec->Name, sec->VirtualAddress, sec->Misc.VirtualSize, total_size );
651 goto error;
652 }
653
654 if ((sec->Characteristics & IMAGE_SCN_MEM_SHARED) &&
655 (sec->Characteristics & IMAGE_SCN_MEM_WRITE))
656 {
657 size = ROUND_SIZE( 0, sec->Misc.VirtualSize );
658 TRACE_(module)( "mapping shared section %.8s at %p off %lx (%x) size %lx (%lx) flags %lx\n",
659 sec->Name, ptr + sec->VirtualAddress,
660 sec->PointerToRawData, pos, sec->SizeOfRawData,
661 size, sec->Characteristics );
662 if (VIRTUAL_mmap( shared_fd, ptr + sec->VirtualAddress, size,
663 pos, 0, PROT_READ|PROT_WRITE|PROT_EXEC,
664 MAP_SHARED|MAP_FIXED, NULL ) == (void *)-1)
665 {
666 ERR_(module)( "Could not map shared section %.8s\n", sec->Name );
667 goto error;
668 }
669
670 /* check if the import directory falls inside this section */
671 if (imports && imports->VirtualAddress >= sec->VirtualAddress &&
672 imports->VirtualAddress < sec->VirtualAddress + size)
673 {
674 UINT_PTR base = imports->VirtualAddress & ~page_mask;
675 UINT_PTR end = base + ROUND_SIZE( imports->VirtualAddress, imports->Size );
676 if (end > sec->VirtualAddress + size) end = sec->VirtualAddress + size;
677 if (end > base) VIRTUAL_mmap( shared_fd, ptr + base, end - base,
678 pos + (base - sec->VirtualAddress), 0,
679 PROT_READ|PROT_WRITE|PROT_EXEC,
680 MAP_PRIVATE|MAP_FIXED, NULL );
681 }
682 pos += size;
683 continue;
684 }
685
686 TRACE_(module)( "mapping section %.8s at %p off %lx size %lx flags %lx\n",
687 sec->Name, ptr + sec->VirtualAddress,
688 sec->PointerToRawData, sec->SizeOfRawData,
689 sec->Characteristics );
690
691 if ((sec->Characteristics & IMAGE_SCN_CNT_UNINITIALIZED_DATA) &&
692 !(sec->Characteristics & IMAGE_SCN_CNT_INITIALIZED_DATA)) continue;
693 if (!sec->PointerToRawData || !sec->SizeOfRawData) continue;
694
695 /* Note: if the section is not aligned properly VIRTUAL_mmap will magically
696 * fall back to read(), so we don't need to check anything here.
697 */
698 if (VIRTUAL_mmap( fd, ptr + sec->VirtualAddress, sec->SizeOfRawData,
699 sec->PointerToRawData, 0, PROT_READ|PROT_WRITE|PROT_EXEC,
700 MAP_PRIVATE | MAP_FIXED, &removable ) == (void *)-1)
701 {
702 ERR_(module)( "Could not map section %.8s, file probably truncated\n", sec->Name );
703 goto error;
704 }
705
706 if ((sec->SizeOfRawData < sec->Misc.VirtualSize) && (sec->SizeOfRawData & page_mask))
707 {
708 DWORD end = ROUND_SIZE( 0, sec->SizeOfRawData );
709 if (end > sec->Misc.VirtualSize) end = sec->Misc.VirtualSize;
710 TRACE_(module)("clearing %p - %p\n",
711 ptr + sec->VirtualAddress + sec->SizeOfRawData,
712 ptr + sec->VirtualAddress + end );
713 memset( ptr + sec->VirtualAddress + sec->SizeOfRawData, 0,
714 end - sec->SizeOfRawData );
715 }
716 }
717
718
719 /* perform base relocation, if necessary */
720
721 if (ptr != base)
722 {
723 const IMAGE_DATA_DIRECTORY *relocs;
724
725 relocs = &nt->OptionalHeader.DataDirectory[IMAGE_DIRECTORY_ENTRY_BASERELOC];
726 if (!relocs->VirtualAddress || !relocs->Size)
727 {
728 if (nt->OptionalHeader.ImageBase == 0x400000)
729 ERR("Standard load address for a Win32 program (0x00400000) not available - security-patched kernel ?\n");
730 else
731 ERR( "FATAL: Need to relocate module from addr %lx, but there are no relocation records\n",
732 nt->OptionalHeader.ImageBase );
733 goto error;
734 }
735
736 /* FIXME: If we need to relocate a system DLL (base > 2GB) we should
737 * really make sure that the *new* base address is also > 2GB.
738 * Some DLLs really check the MSB of the module handle :-/
739 */
740 if ((nt->OptionalHeader.ImageBase & 0x80000000) && !((DWORD)base & 0x80000000))
741 ERR( "Forced to relocate system DLL (base > 2GB). This is not good.\n" );
742
743 if (!do_relocations( ptr, relocs, ptr - base, total_size ))
744 {
745 goto error;
746 }
747 }
748
749 if (removable) hmapping = 0; /* don't keep handle open on removable media */
750 if (!(view = VIRTUAL_CreateView( ptr, total_size, 0,
751 VPROT_COMMITTED | VPROT_READ | VPROT_WRITE |
752 VPROT_EXEC | VPROT_WRITECOPY | VPROT_IMAGE, hmapping )))
753 {
754 status = STATUS_NO_MEMORY;
755 goto error;
756 }
757
758 /* set the image protections */
759
760 VIRTUAL_SetProt( view, ptr, header_size, VPROT_COMMITTED | VPROT_READ );
761 sec = (IMAGE_SECTION_HEADER*)((char *)&nt->OptionalHeader+nt->FileHeader.SizeOfOptionalHeader);
762 for (i = 0; i < nt->FileHeader.NumberOfSections; i++, sec++)
763 {
764 DWORD size = ROUND_SIZE( sec->VirtualAddress, sec->Misc.VirtualSize );
765 BYTE vprot = VPROT_COMMITTED;
766 if (sec->Characteristics & IMAGE_SCN_MEM_READ) vprot |= VPROT_READ;
767 if (sec->Characteristics & IMAGE_SCN_MEM_WRITE) vprot |= VPROT_WRITE|VPROT_WRITECOPY;
768 if (sec->Characteristics & IMAGE_SCN_MEM_EXECUTE) vprot |= VPROT_EXEC;
769
770 /* make sure the import directory is writable */
771 if (imports && imports->VirtualAddress >= sec->VirtualAddress &&
772 imports->VirtualAddress < sec->VirtualAddress + size)
773 vprot |= VPROT_READ|VPROT_WRITE|VPROT_WRITECOPY;
774
775 VIRTUAL_SetProt( view, ptr + sec->VirtualAddress, size, vprot );
776 }
777
778 *addr_ptr = ptr;
779 return STATUS_SUCCESS;
780
781 error:
782 if (ptr != (char *)-1) munmap( ptr, total_size );
783 return status;
784 }
785
786
787 /***********************************************************************
788 * is_current_process
789 *
790 * Check whether a process handle is for the current process.
791 */
792 static BOOL is_current_process( HANDLE handle )
793 {
794 BOOL ret = FALSE;
795
796 if (handle == GetCurrentProcess()) return TRUE;
797 SERVER_START_REQ( get_process_info )
798 {
799 req->handle = handle;
800 if (!wine_server_call( req ))
801 ret = ((DWORD)reply->pid == GetCurrentProcessId());
802 }
803 SERVER_END_REQ;
804 return ret;
805 }
806
807
808 /***********************************************************************
809 * virtual_init
810 */
811 void virtual_init(void)
812 {
813 #ifndef page_mask
814 page_size = getpagesize();
815 page_mask = page_size - 1;
816 /* Make sure we have a power of 2 */
817 assert( !(page_size & page_mask) );
818 page_shift = 0;
819 while ((1 << page_shift) != page_size) page_shift++;
820 #endif /* page_mask */
821 }
822
823
824 /***********************************************************************
825 * VIRTUAL_SetFaultHandler
826 */
827 BOOL VIRTUAL_SetFaultHandler( LPCVOID addr, HANDLERPROC proc, LPVOID arg )
828 {
829 FILE_VIEW *view;
830
831 if (!(view = VIRTUAL_FindView( addr ))) return FALSE;
832 view->handlerProc = proc;
833 view->handlerArg = arg;
834 return TRUE;
835 }
836
837 /***********************************************************************
838 * VIRTUAL_HandleFault
839 */
840 DWORD VIRTUAL_HandleFault( LPCVOID addr )
841 {
842 FILE_VIEW *view = VIRTUAL_FindView( addr );
843 DWORD ret = EXCEPTION_ACCESS_VIOLATION;
844
845 if (view)
846 {
847 if (view->handlerProc)
848 {
849 if (view->handlerProc(view->handlerArg, addr)) ret = 0; /* handled */
850 }
851 else
852 {
853 BYTE vprot = view->prot[((char *)addr - (char *)view->base) >> page_shift];
854 void *page = (void *)((UINT_PTR)addr & ~page_mask);
855 char *stack = NtCurrentTeb()->Tib.StackLimit;
856 if (vprot & VPROT_GUARD)
857 {
858 VIRTUAL_SetProt( view, page, page_mask + 1, vprot & ~VPROT_GUARD );
859 ret = STATUS_GUARD_PAGE_VIOLATION;
860 }
861 /* is it inside the stack guard page? */
862 if (((char *)addr >= stack) && ((char *)addr < stack + (page_mask+1)))
863 ret = STATUS_STACK_OVERFLOW;
864 }
865 }
866 return ret;
867 }
868
869
870
871 /***********************************************************************
872 * unaligned_mmap
873 *
874 * Linux kernels before 2.4.x can support non page-aligned offsets, as
875 * long as the offset is aligned to the filesystem block size. This is
876 * a big performance gain so we want to take advantage of it.
877 *
878 * However, when we use 64-bit file support this doesn't work because
879 * glibc rejects unaligned offsets. Also glibc 2.1.3 mmap64 is broken
880 * in that it rounds unaligned offsets down to a page boundary. For
881 * these reasons we do a direct system call here.
882 */
883 static void *unaligned_mmap( void *addr, size_t length, unsigned int prot,
884 unsigned int flags, int fd, unsigned int offset_low,
885 unsigned int offset_high )
886 {
887 #if defined(linux) && defined(__i386__) && defined(__GNUC__)
888 if (!offset_high && (offset_low & page_mask))
889 {
890 int ret;
891
892 struct
893 {
894 void *addr;
895 unsigned int length;
896 unsigned int prot;
897 unsigned int flags;
898 unsigned int fd;
899 unsigned int offset;
900 } args;
901
902 args.addr = addr;
903 args.length = length;
904 args.prot = prot;
905 args.flags = flags;
906 args.fd = fd;
907 args.offset = offset_low;
908
909 __asm__ __volatile__("push %%ebx\n\t"
910 "movl %2,%%ebx\n\t"
911 "int $0x80\n\t"
912 "popl %%ebx"
913 : "=a" (ret)
914 : "0" (90), /* SYS_mmap */
915 "g" (&args)
916 : "memory" );
917 if (ret < 0 && ret > -4096)
918 {
919 errno = -ret;
920 ret = -1;
921 }
922 return (void *)ret;
923 }
924 #endif
925 return mmap( addr, length, prot, flags, fd, ((off_t)offset_high << 32) | offset_low );
926 }
927
928
929 /***********************************************************************
930 * VIRTUAL_mmap
931 *
932 * Wrapper for mmap() that handles anonymous mappings portably,
933 * and falls back to read if mmap of a file fails.
934 */
935 static LPVOID VIRTUAL_mmap( int fd, LPVOID start, DWORD size,
936 DWORD offset_low, DWORD offset_high,
937 int prot, int flags, BOOL *removable )
938 {
939 LPVOID ret;
940 off_t offset;
941 BOOL is_shared_write = FALSE;
942
943 if (fd == -1) return wine_anon_mmap( start, size, prot, flags );
944
945 if (prot & PROT_WRITE)
946 {
947 #ifdef MAP_SHARED
948 if (flags & MAP_SHARED) is_shared_write = TRUE;
949 #endif
950 #ifdef MAP_PRIVATE
951 if (!(flags & MAP_PRIVATE)) is_shared_write = TRUE;
952 #endif
953 }
954
955 if (removable && *removable)
956 {
957 /* if on removable media, try using read instead of mmap */
958 if (!is_shared_write) goto fake_mmap;
959 *removable = FALSE;
960 }
961
962 if ((ret = unaligned_mmap( start, size, prot, flags, fd,
963 offset_low, offset_high )) != (LPVOID)-1) return ret;
964
965 /* mmap() failed; if this is because the file offset is not */
966 /* page-aligned (EINVAL), or because the underlying filesystem */
967 /* does not support mmap() (ENOEXEC,ENODEV), we do it by hand. */
968
969 if ((errno != ENOEXEC) && (errno != EINVAL) && (errno != ENODEV)) return ret;
970 if (is_shared_write) return ret; /* we cannot fake shared write mappings */
971
972 fake_mmap:
973 /* Reserve the memory with an anonymous mmap */
974 ret = wine_anon_mmap( start, size, PROT_READ | PROT_WRITE, flags );
975 if (ret == (LPVOID)-1) return ret;
976 /* Now read in the file */
977 offset = ((off_t)offset_high << 32) | offset_low;
978 pread( fd, ret, size, offset );
979 mprotect( ret, size, prot ); /* Set the right protection */
980 return ret;
981 }
982
983
984 /***********************************************************************
985 * NtAllocateVirtualMemory (NTDLL.@)
986 * ZwAllocateVirtualMemory (NTDLL.@)
987 */
988 NTSTATUS WINAPI NtAllocateVirtualMemory( HANDLE process, PVOID *ret, PVOID addr,
989 ULONG *size_ptr, ULONG type, ULONG protect )
990 {
991 FILE_VIEW *view;
992 void *base;
993 BYTE vprot;
994 DWORD size = *size_ptr;
995
996 if (!is_current_process( process ))
997 {
998 ERR("Unsupported on other process\n");
999 return STATUS_ACCESS_DENIED;
1000 }
1001
1002 TRACE("%p %08lx %lx %08lx\n", addr, size, type, protect );
1003
1004 if (!size) return STATUS_INVALID_PARAMETER;
1005
1006 /* Round parameters to a page boundary */
1007
1008 if (size > 0x7fc00000) return STATUS_WORKING_SET_LIMIT_RANGE; /* 2Gb - 4Mb */
1009
1010 if (addr)
1011 {
1012 if (type & MEM_RESERVE) /* Round down to 64k boundary */
1013 base = ROUND_ADDR( addr, granularity_mask );
1014 else
1015 base = ROUND_ADDR( addr, page_mask );
1016 size = (((UINT_PTR)addr + size + page_mask) & ~page_mask) - (UINT_PTR)base;
1017
1018 /* disallow low 64k, wrap-around and kernel space */
1019 if (((char *)base <= (char *)granularity_mask) ||
1020 ((char *)base + size < (char *)base) ||
1021 (ADDRESS_SPACE_LIMIT && ((char *)base + size > (char *)ADDRESS_SPACE_LIMIT)))
1022 return STATUS_INVALID_PARAMETER;
1023 }
1024 else
1025 {
1026 base = NULL;
1027 size = (size + page_mask) & ~page_mask;
1028 }
1029
1030 if (type & MEM_TOP_DOWN) {
1031 /* FIXME: MEM_TOP_DOWN allocates the largest possible address.
1032 * Is there _ANY_ way to do it with UNIX mmap()?
1033 */
1034 WARN("MEM_TOP_DOWN ignored\n");
1035 type &= ~MEM_TOP_DOWN;
1036 }
1037
1038 /* Compute the alloc type flags */
1039
1040 if (type & MEM_SYSTEM)
1041 {
1042 vprot = VIRTUAL_GetProt( protect ) | VPROT_COMMITTED;
1043 if (type & MEM_IMAGE) vprot |= VPROT_IMAGE;
1044 }
1045 else
1046 {
1047 if (!(type & (MEM_COMMIT | MEM_RESERVE)) || (type & ~(MEM_COMMIT | MEM_RESERVE)))
1048 {
1049 WARN("called with wrong alloc type flags (%08lx) !\n", type);
1050 return STATUS_INVALID_PARAMETER;
1051 }
1052 if (type & MEM_COMMIT)
1053 vprot = VIRTUAL_GetProt( protect ) | VPROT_COMMITTED;
1054 else
1055 vprot = 0;
1056 }
1057
1058 /* Reserve the memory */
1059
1060 if (type & MEM_SYSTEM)
1061 {
1062 if (!(view = VIRTUAL_CreateView( base, size, VFLAG_VALLOC | VFLAG_SYSTEM, vprot, 0 )))
1063 return STATUS_NO_MEMORY;
1064 }
1065 else if ((type & MEM_RESERVE) || !base)
1066 {
1067 NTSTATUS res = anon_mmap_aligned( &base, size, VIRTUAL_GetUnixProt( vprot ), 0 );
1068 if (res) return res;
1069
1070 if (!(view = VIRTUAL_CreateView( base, size, VFLAG_VALLOC, vprot, 0 )))
1071 {
1072 munmap( base, size );
1073 return STATUS_NO_MEMORY;
1074 }
1075 }
1076 else
1077 {
1078 /* Commit the pages */
1079
1080 if (!(view = VIRTUAL_FindView( base )) ||
1081 ((char *)base + size > (char *)view->base + view->size)) return STATUS_NOT_MAPPED_VIEW;
1082
1083 if (!VIRTUAL_SetProt( view, base, size, vprot )) return STATUS_ACCESS_DENIED;
1084 }
1085
1086 *ret = base;
1087 *size_ptr = size;
1088 return STATUS_SUCCESS;
1089 }
1090
1091
1092 /***********************************************************************
1093 * NtFreeVirtualMemory (NTDLL.@)
1094 * ZwFreeVirtualMemory (NTDLL.@)
1095 */
1096 NTSTATUS WINAPI NtFreeVirtualMemory( HANDLE process, PVOID *addr_ptr, ULONG *size_ptr, ULONG type )
1097 {
1098 FILE_VIEW *view;
1099 char *base;
1100 LPVOID addr = *addr_ptr;
1101 DWORD size = *size_ptr;
1102
1103 if (!is_current_process( process ))
1104 {
1105 ERR("Unsupported on other process\n");
1106 return STATUS_ACCESS_DENIED;
1107 }
1108
1109 TRACE("%p %08lx %lx\n", addr, size, type );
1110
1111 /* Fix the parameters */
1112
1113 size = ROUND_SIZE( addr, size );
1114 base = ROUND_ADDR( addr, page_mask );
1115
1116 if (!(view = VIRTUAL_FindView( base )) ||
1117 (base + size > (char *)view->base + view->size) ||
1118 !(view->flags & VFLAG_VALLOC))
1119 return STATUS_INVALID_PARAMETER;
1120
1121 /* Check the type */
1122
1123 if (type & MEM_SYSTEM)
1124 {
1125 /* return the values that the caller should use to unmap the area */
1126 *addr_ptr = view->base;
1127 *size_ptr = view->size;
1128 view->flags |= VFLAG_SYSTEM;
1129 VIRTUAL_DeleteView( view );
1130 return STATUS_SUCCESS;
1131 }
1132
1133 if ((type != MEM_DECOMMIT) && (type != MEM_RELEASE))
1134 {
1135 WARN("called with wrong free type flags (%08lx) !\n", type);
1136 return STATUS_INVALID_PARAMETER;
1137 }
1138
1139 /* Free the pages */
1140
1141 if (type == MEM_RELEASE)
1142 {
1143 if (size || (base != view->base)) return STATUS_INVALID_PARAMETER;
1144 VIRTUAL_DeleteView( view );
1145 }
1146 else
1147 {
1148 /* Decommit the pages by remapping zero-pages instead */
1149
1150 if (wine_anon_mmap( (LPVOID)base, size, VIRTUAL_GetUnixProt(0), MAP_FIXED ) != (LPVOID)base)
1151 ERR( "Could not remap pages, expect trouble\n" );
1152 if (!VIRTUAL_SetProt( view, base, size, 0 )) return STATUS_ACCESS_DENIED; /* FIXME */
1153 }
1154
1155 *addr_ptr = base;
1156 *size_ptr = size;
1157 return STATUS_SUCCESS;
1158 }
1159
1160
1161 /***********************************************************************
1162 * NtProtectVirtualMemory (NTDLL.@)
1163 * ZwProtectVirtualMemory (NTDLL.@)
1164 */
1165 NTSTATUS WINAPI NtProtectVirtualMemory( HANDLE process, PVOID *addr_ptr, ULONG *size_ptr,
1166 ULONG new_prot, ULONG *old_prot )
1167 {
1168 FILE_VIEW *view;
1169 char *base;
1170 UINT i;
1171 BYTE vprot, *p;
1172 DWORD prot, size = *size_ptr;
1173 LPVOID addr = *addr_ptr;
1174
1175 if (!is_current_process( process ))
1176 {
1177 ERR("Unsupported on other process\n");
1178 return STATUS_ACCESS_DENIED;
1179 }
1180
1181 TRACE("%p %08lx %08lx\n", addr, size, new_prot );
1182
1183 /* Fix the parameters */
1184
1185 size = ROUND_SIZE( addr, size );
1186 base = ROUND_ADDR( addr, page_mask );
1187
1188 if (!(view = VIRTUAL_FindView( base )) ||
1189 (base + size > (char *)view->base + view->size))
1190 return STATUS_INVALID_PARAMETER;
1191
1192 /* Make sure all the pages are committed */
1193
1194 p = view->prot + ((base - (char *)view->base) >> page_shift);
1195 VIRTUAL_GetWin32Prot( *p, &prot, NULL );
1196 for (i = size >> page_shift; i; i--, p++)
1197 {
1198 if (!(*p & VPROT_COMMITTED)) return STATUS_NOT_COMMITTED;
1199 }
1200
1201 if (old_prot) *old_prot = prot;
1202 vprot = VIRTUAL_GetProt( new_prot ) | VPROT_COMMITTED;
1203 if (!VIRTUAL_SetProt( view, base, size, vprot )) return STATUS_ACCESS_DENIED;
1204
1205 *addr_ptr = base;
1206 *size_ptr = size;
1207 return STATUS_SUCCESS;
1208 }
1209
1210
1211 /***********************************************************************
1212 * NtQueryVirtualMemory (NTDLL.@)
1213 * ZwQueryVirtualMemory (NTDLL.@)
1214 */
1215 NTSTATUS WINAPI NtQueryVirtualMemory( HANDLE process, LPCVOID addr,
1216 MEMORY_INFORMATION_CLASS info_class, PVOID buffer,
1217 ULONG len, ULONG *res_len )
1218 {
1219 FILE_VIEW *view;
1220 char *base, *alloc_base = 0;
1221 UINT size = 0;
1222 MEMORY_BASIC_INFORMATION *info = buffer;
1223
1224 if (info_class != MemoryBasicInformation) return STATUS_INVALID_INFO_CLASS;
1225 if (ADDRESS_SPACE_LIMIT && addr >= ADDRESS_SPACE_LIMIT)
1226 return STATUS_WORKING_SET_LIMIT_RANGE; /* FIXME */
1227
1228 if (!is_current_process( process ))
1229 {
1230 ERR("Unsupported on other process\n");
1231 return STATUS_ACCESS_DENIED;
1232 }
1233
1234 base = ROUND_ADDR( addr, page_mask );
1235
1236 /* Find the view containing the address */
1237
1238 RtlEnterCriticalSection(&csVirtual);
1239 view = VIRTUAL_FirstView;
1240 for (;;)
1241 {
1242 if (!view)
1243 {
1244 size = (char *)ADDRESS_SPACE_LIMIT - alloc_base;
1245 break;
1246 }
1247 if ((char *)view->base > base)
1248 {
1249 size = (char *)view->base - alloc_base;
1250 view = NULL;
1251 break;
1252 }
1253 if ((char *)view->base + view->size > base)
1254 {
1255 alloc_base = view->base;
1256 size = view->size;
1257 break;
1258 }
1259 alloc_base = (char *)view->base + view->size;
1260 view = view->next;
1261 }
1262 RtlLeaveCriticalSection(&csVirtual);
1263
1264 /* Fill the info structure */
1265
1266 if (!view)
1267 {
1268 info->State = MEM_FREE;
1269 info->Protect = 0;
1270 info->AllocationProtect = 0;
1271 info->Type = 0;
1272 }
1273 else
1274 {
1275 BYTE vprot = view->prot[(base - alloc_base) >> page_shift];
1276 VIRTUAL_GetWin32Prot( vprot, &info->Protect, &info->State );
1277 for (size = base - alloc_base; size < view->size; size += page_mask+1)
1278 if (view->prot[size >> page_shift] != vprot) break;
1279 VIRTUAL_GetWin32Prot( view->protect, &info->AllocationProtect, NULL );
1280 if (view->protect & VPROT_IMAGE) info->Type = MEM_IMAGE;
1281 else if (view->flags & VFLAG_VALLOC) info->Type = MEM_PRIVATE;
1282 else info->Type = MEM_MAPPED;
1283 }
1284
1285 info->BaseAddress = (LPVOID)base;
1286 info->AllocationBase = (LPVOID)alloc_base;
1287 info->RegionSize = size - (base - alloc_base);
1288 if (res_len) *res_len = sizeof(*info);
1289 return STATUS_SUCCESS;
1290 }
1291
1292
1293 /***********************************************************************
1294 * NtLockVirtualMemory (NTDLL.@)
1295 * ZwLockVirtualMemory (NTDLL.@)
1296 */
1297 NTSTATUS WINAPI NtLockVirtualMemory( HANDLE process, PVOID *addr, ULONG *size, ULONG unknown )
1298 {
1299 if (!is_current_process( process ))
1300 {
1301 ERR("Unsupported on other process\n");
1302 return STATUS_ACCESS_DENIED;
1303 }
1304 return STATUS_SUCCESS;
1305 }
1306
1307
1308 /***********************************************************************
1309 * NtUnlockVirtualMemory (NTDLL.@)
1310 * ZwUnlockVirtualMemory (NTDLL.@)
1311 */
1312 NTSTATUS WINAPI NtUnlockVirtualMemory( HANDLE process, PVOID *addr, ULONG *size, ULONG unknown )
1313 {
1314 if (!is_current_process( process ))
1315 {
1316 ERR("Unsupported on other process\n");
1317 return STATUS_ACCESS_DENIED;
1318 }
1319 return STATUS_SUCCESS;
1320 }
1321
1322
1323 /***********************************************************************
1324 * NtCreateSection (NTDLL.@)
1325 * ZwCreateSection (NTDLL.@)
1326 */
1327 NTSTATUS WINAPI NtCreateSection( HANDLE *handle, ACCESS_MASK access, const OBJECT_ATTRIBUTES *attr,
1328 const LARGE_INTEGER *size, ULONG protect,
1329 ULONG sec_flags, HANDLE file )
1330 {
1331 NTSTATUS ret;
1332 BYTE vprot;
1333 DWORD len = attr->ObjectName ? attr->ObjectName->Length : 0;
1334
1335 /* Check parameters */
1336
1337 if (len > MAX_PATH*sizeof(WCHAR)) return STATUS_NAME_TOO_LONG;
1338
1339 vprot = VIRTUAL_GetProt( protect );
1340 if (sec_flags & SEC_RESERVE)
1341 {
1342 if (file) return STATUS_INVALID_PARAMETER;
1343 }
1344 else vprot |= VPROT_COMMITTED;
1345 if (sec_flags & SEC_NOCACHE) vprot |= VPROT_NOCACHE;
1346 if (sec_flags & SEC_IMAGE) vprot |= VPROT_IMAGE;
1347
1348 /* Create the server object */
1349
1350 SERVER_START_REQ( create_mapping )
1351 {
1352 req->file_handle = file;
1353 req->size_high = size ? size->u.HighPart : 0;
1354 req->size_low = size ? size->u.LowPart : 0;
1355 req->protect = vprot;
1356 req->access = access;
1357 req->inherit = (attr->Attributes & OBJ_INHERIT) != 0;
1358 if (len) wine_server_add_data( req, attr->ObjectName->Buffer, len );
1359 ret = wine_server_call( req );
1360 *handle = reply->handle;
1361 }
1362 SERVER_END_REQ;
1363 return ret;
1364 }
1365
1366
1367 /***********************************************************************
1368 * NtOpenSection (NTDLL.@)
1369 * ZwOpenSection (NTDLL.@)
1370 */
1371 NTSTATUS WINAPI NtOpenSection( HANDLE *handle, ACCESS_MASK access, const OBJECT_ATTRIBUTES *attr )
1372 {
1373 NTSTATUS ret;
1374 DWORD len = attr->ObjectName->Length;
1375
1376 if (len > MAX_PATH*sizeof(WCHAR)) return STATUS_NAME_TOO_LONG;
1377
1378 SERVER_START_REQ( open_mapping )
1379 {
1380 req->access = access;
1381 req->inherit = (attr->Attributes & OBJ_INHERIT) != 0;
1382 wine_server_add_data( req, attr->ObjectName->Buffer, len );
1383 if (!(ret = wine_server_call( req ))) *handle = reply->handle;
1384 }
1385 SERVER_END_REQ;
1386 return ret;
1387 }
1388
1389
1390 /***********************************************************************
1391 * NtMapViewOfSection (NTDLL.@)
1392 * ZwMapViewOfSection (NTDLL.@)
1393 */
1394 NTSTATUS WINAPI NtMapViewOfSection( HANDLE handle, HANDLE process, PVOID *addr_ptr, ULONG zero_bits,
1395 ULONG commit_size, const LARGE_INTEGER *offset, ULONG *size_ptr,
1396 SECTION_INHERIT inherit, ULONG alloc_type, ULONG protect )
1397 {
1398 FILE_VIEW *view;
1399 NTSTATUS res;
1400 UINT size = 0;
1401 int flags = MAP_PRIVATE;
1402 int unix_handle = -1;
1403 int prot;
1404 void *base, *ptr = (void *)-1, *ret;
1405 DWORD size_low, size_high, header_size, shared_size;
1406 HANDLE shared_file;
1407 BOOL removable;
1408
1409 if (!is_current_process( process ))
1410 {
1411 ERR("Unsupported on other process\n");
1412 return STATUS_ACCESS_DENIED;
1413 }
1414
1415 TRACE("handle=%p addr=%p off=%lx%08lx size=%x access=%lx\n",
1416 handle, *addr_ptr, offset->u.HighPart, offset->u.LowPart, size, protect );
1417
1418 /* Check parameters */
1419
1420 if ((offset->u.LowPart & granularity_mask) ||
1421 (*addr_ptr && ((UINT_PTR)*addr_ptr & granularity_mask)))
1422 return STATUS_INVALID_PARAMETER;
1423
1424 SERVER_START_REQ( get_mapping_info )
1425 {
1426 req->handle = handle;
1427 res = wine_server_call( req );
1428 prot = reply->protect;
1429 base = reply->base;
1430 size_low = reply->size_low;
1431 size_high = reply->size_high;
1432 header_size = reply->header_size;
1433 shared_file = reply->shared_file;
1434 shared_size = reply->shared_size;
1435 removable = reply->removable;
1436 }
1437 SERVER_END_REQ;
1438 if (res) return res;
1439
1440 if ((res = wine_server_handle_to_fd( handle, 0, &unix_handle, NULL, NULL ))) return res;
1441
1442 if (prot & VPROT_IMAGE)
1443 {
1444 if (shared_file)
1445 {
1446 int shared_fd;
1447
1448 if ((res = wine_server_handle_to_fd( shared_file, GENERIC_READ, &shared_fd,
1449 NULL, NULL ))) goto error;
1450 res = map_image( handle, unix_handle, base, size_low, header_size,
1451 shared_fd, removable, addr_ptr );
1452 wine_server_release_fd( shared_file, shared_fd );
1453 NtClose( shared_file );
1454 }
1455 else
1456 {
1457 res = map_image( handle, unix_handle, base, size_low, header_size,
1458 -1, removable, addr_ptr );
1459 }
1460 wine_server_release_fd( handle, unix_handle );
1461 if (!res) *size_ptr = size_low;
1462 return res;
1463 }
1464
1465 if (size_high)
1466 ERR("Sizes larger than 4Gb not supported\n");
1467
1468 if ((offset->u.LowPart >= size_low) ||
1469 (*size_ptr > size_low - offset->u.LowPart))
1470 {
1471 res = STATUS_INVALID_PARAMETER;
1472 goto error;
1473 }
1474 if (*size_ptr) size = ROUND_SIZE( offset->u.LowPart, *size_ptr );
1475 else size = size_low - offset->u.LowPart;
1476
1477 switch(protect)
1478 {
1479 case PAGE_NOACCESS:
1480 break;
1481 case PAGE_READWRITE:
1482 case PAGE_EXECUTE_READWRITE:
1483 if (!(prot & VPROT_WRITE))
1484 {
1485 res = STATUS_INVALID_PARAMETER;
1486 goto error;
1487 }
1488 flags = MAP_SHARED;
1489 /* fall through */
1490 case PAGE_READONLY:
1491 case PAGE_WRITECOPY:
1492 case PAGE_EXECUTE:
1493 case PAGE_EXECUTE_READ:
1494 case PAGE_EXECUTE_WRITECOPY:
1495 if (prot & VPROT_READ) break;
1496 /* fall through */
1497 default:
1498 res = STATUS_INVALID_PARAMETER;
1499 goto error;
1500 }
1501
1502 /* FIXME: If a mapping is created with SEC_RESERVE and a process,
1503 * which has a view of this mapping commits some pages, they will
1504 * appear commited in all other processes, which have the same
1505 * view created. Since we don`t support this yet, we create the
1506 * whole mapping commited.
1507 */
1508 prot |= VPROT_COMMITTED;
1509
1510 /* Reserve a properly aligned area */
1511
1512 if ((res = anon_mmap_aligned( addr_ptr, size, PROT_NONE, 0 ))) goto error;
1513 ptr = *addr_ptr;
1514
1515 /* Map the file */
1516
1517 TRACE("handle=%p size=%x offset=%lx\n", handle, size, offset->u.LowPart );
1518
1519 ret = VIRTUAL_mmap( unix_handle, ptr, size, offset->u.LowPart, offset->u.HighPart,
1520 VIRTUAL_GetUnixProt( prot ), flags | MAP_FIXED, &removable );
1521 if (ret != ptr)
1522 {
1523 ERR( "VIRTUAL_mmap %p %x %lx%08lx failed\n",
1524 ptr, size, offset->u.HighPart, offset->u.LowPart );
1525 res = STATUS_NO_MEMORY; /* FIXME */
1526 goto error;
1527 }
1528 if (removable) handle = 0; /* don't keep handle open on removable media */
1529
1530 if (!(view = VIRTUAL_CreateView( ptr, size, 0, prot, handle )))
1531 {
1532 res = STATUS_NO_MEMORY;
1533 goto error;
1534 }
1535 wine_server_release_fd( handle, unix_handle );
1536 *size_ptr = size;
1537 return STATUS_SUCCESS;
1538
1539 error:
1540 wine_server_release_fd( handle, unix_handle );
1541 if (ptr != (void *)-1) munmap( ptr, size );
1542 return res;
1543 }
1544
1545
1546 /***********************************************************************
1547 * NtUnmapViewOfSection (NTDLL.@)
1548 * ZwUnmapViewOfSection (NTDLL.@)
1549 */
1550 NTSTATUS WINAPI NtUnmapViewOfSection( HANDLE process, PVOID addr )
1551 {
1552 FILE_VIEW *view;
1553 void *base = ROUND_ADDR( addr, page_mask );
1554
1555 if (!is_current_process( process ))
1556 {
1557 ERR("Unsupported on other process\n");
1558 return STATUS_ACCESS_DENIED;
1559 }
1560 if (!(view = VIRTUAL_FindView( base )) || (base != view->base)) return STATUS_INVALID_PARAMETER;
1561 VIRTUAL_DeleteView( view );
1562 return STATUS_SUCCESS;
1563 }
1564
1565
1566 /***********************************************************************
1567 * NtFlushVirtualMemory (NTDLL.@)
1568 * ZwFlushVirtualMemory (NTDLL.@)
1569 */
1570 NTSTATUS WINAPI NtFlushVirtualMemory( HANDLE process, LPCVOID *addr_ptr,
1571 ULONG *size_ptr, ULONG unknown )
1572 {
1573 FILE_VIEW *view;
1574 void *addr = ROUND_ADDR( *addr_ptr, page_mask );
1575
1576 if (!is_current_process( process ))
1577 {
1578 ERR("Unsupported on other process\n");
1579 return STATUS_ACCESS_DENIED;
1580 }
1581 if (!(view = VIRTUAL_FindView( addr ))) return STATUS_INVALID_PARAMETER;
1582 if (!*size_ptr) *size_ptr = view->size;
1583 *addr_ptr = addr;
1584 if (!msync( addr, *size_ptr, MS_SYNC )) return STATUS_SUCCESS;
1585 return STATUS_NOT_MAPPED_DATA;
1586 }
1587
1588
1589 /***********************************************************************
1590 * NtReadVirtualMemory (NTDLL.@)
1591 * ZwReadVirtualMemory (NTDLL.@)
1592 */
1593 NTSTATUS WINAPI NtReadVirtualMemory( HANDLE process, const void *addr, void *buffer,
1594 SIZE_T size, SIZE_T *bytes_read )
1595 {
1596 NTSTATUS status;
1597
1598 SERVER_START_REQ( read_process_memory )
1599 {
1600 req->handle = process;
1601 req->addr = (void *)addr;
1602 wine_server_set_reply( req, buffer, size );
1603 if ((status = wine_server_call( req ))) size = 0;
1604 }
1605 SERVER_END_REQ;
1606 if (bytes_read) *bytes_read = size;
1607 return status;
1608 }
1609
1610
1611 /***********************************************************************
1612 * NtWriteVirtualMemory (NTDLL.@)
1613 * ZwWriteVirtualMemory (NTDLL.@)
1614 */
1615 NTSTATUS WINAPI NtWriteVirtualMemory( HANDLE process, void *addr, const void *buffer,
1616 SIZE_T size, SIZE_T *bytes_written )
1617 {
1618 static const unsigned int zero;
1619 unsigned int first_offset, last_offset, first_mask, last_mask;
1620 NTSTATUS status;
1621
1622 if (!size) return STATUS_INVALID_PARAMETER;
1623
1624 /* compute the mask for the first int */
1625 first_mask = ~0;
1626 first_offset = (unsigned int)addr % sizeof(int);
1627 memset( &first_mask, 0, first_offset );
1628
1629 /* compute the mask for the last int */
1630 last_offset = (size + first_offset) % sizeof(int);
1631 last_mask = 0;
1632 memset( &last_mask, 0xff, last_offset ? last_offset : sizeof(int) );
1633
1634 SERVER_START_REQ( write_process_memory )
1635 {
1636 req->handle = process;
1637 req->addr = (char *)addr - first_offset;
1638 req->first_mask = first_mask;
1639 req->last_mask = last_mask;
1640 if (first_offset) wine_server_add_data( req, &zero, first_offset );
1641 wine_server_add_data( req, buffer, size );
1642 if (last_offset) wine_server_add_data( req, &zero, sizeof(int) - last_offset );
1643
1644 if ((status = wine_server_call( req ))) size = 0;
1645 }
1646 SERVER_END_REQ;
1647 if (bytes_written) *bytes_written = size;
1648 return status;
1649 }
Maarten's multimedia branch