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