0f482d1a0901c788884b85b77f29bbbc935dc16d
[mono.git] / mono / utils / mono-mmap-windows.c
1 /**
2  * \file
3  * Windows support for mapping code into the process address space
4  *
5  * Author:
6  *   Mono Team (mono-list@lists.ximian.com)
7  *
8  * Copyright 2001-2008 Novell, Inc.
9  * Licensed under the MIT license. See LICENSE file in the project root for full license information.
10  */
11
12 #include <config.h>
13 #include <glib.h>
14
15 #if defined(HOST_WIN32)
16 #include <windows.h>
17 #include "mono/utils/mono-mmap-windows-internals.h"
18 #include <mono/utils/mono-counters.h>
19 #include <io.h>
20
21 static void *malloced_shared_area = NULL;
22
23 int
24 mono_pagesize (void)
25 {
26         SYSTEM_INFO info;
27         static int saved_pagesize = 0;
28         if (saved_pagesize)
29                 return saved_pagesize;
30         GetSystemInfo (&info);
31         saved_pagesize = info.dwPageSize;
32         return saved_pagesize;
33 }
34
35 int
36 mono_valloc_granule (void)
37 {
38         SYSTEM_INFO info;
39         static int saved_valloc_granule = 0;
40         if (saved_valloc_granule)
41                 return saved_valloc_granule;
42         GetSystemInfo (&info);
43         saved_valloc_granule = info.dwAllocationGranularity;
44         return saved_valloc_granule;
45 }
46
47 int
48 mono_mmap_win_prot_from_flags (int flags)
49 {
50         int prot = flags & (MONO_MMAP_READ|MONO_MMAP_WRITE|MONO_MMAP_EXEC);
51         switch (prot) {
52         case 0: prot = PAGE_NOACCESS; break;
53         case MONO_MMAP_READ: prot = PAGE_READONLY; break;
54         case MONO_MMAP_READ|MONO_MMAP_EXEC: prot = PAGE_EXECUTE_READ; break;
55         case MONO_MMAP_READ|MONO_MMAP_WRITE: prot = PAGE_READWRITE; break;
56         case MONO_MMAP_READ|MONO_MMAP_WRITE|MONO_MMAP_EXEC: prot = PAGE_EXECUTE_READWRITE; break;
57         case MONO_MMAP_WRITE: prot = PAGE_READWRITE; break;
58         case MONO_MMAP_WRITE|MONO_MMAP_EXEC: prot = PAGE_EXECUTE_READWRITE; break;
59         case MONO_MMAP_EXEC: prot = PAGE_EXECUTE; break;
60         default:
61                 g_assert_not_reached ();
62         }
63         return prot;
64 }
65
66 void*
67 mono_valloc (void *addr, size_t length, int flags, MonoMemAccountType type)
68 {
69         void *ptr;
70         int mflags = MEM_RESERVE|MEM_COMMIT;
71         int prot = mono_mmap_win_prot_from_flags (flags);
72         /* translate the flags */
73
74         ptr = VirtualAlloc (addr, length, mflags, prot);
75
76         account_mem (type, (ssize_t)length);
77
78         return ptr;
79 }
80
81 void*
82 mono_valloc_aligned (size_t length, size_t alignment, int flags, MonoMemAccountType type)
83 {
84         int prot = mono_mmap_win_prot_from_flags (flags);
85         char *mem = VirtualAlloc (NULL, length + alignment, MEM_RESERVE, prot);
86         char *aligned;
87
88         if (!mem)
89                 return NULL;
90
91         aligned = aligned_address (mem, length, alignment);
92
93         aligned = VirtualAlloc (aligned, length, MEM_COMMIT, prot);
94         g_assert (aligned);
95
96         account_mem (type, (ssize_t)length);
97
98         return aligned;
99 }
100
101 int
102 mono_vfree (void *addr, size_t length, MonoMemAccountType type)
103 {
104         MEMORY_BASIC_INFORMATION mbi;
105         SIZE_T query_result = VirtualQuery (addr, &mbi, sizeof (mbi));
106         BOOL res;
107
108         g_assert (query_result);
109
110         res = VirtualFree (mbi.AllocationBase, 0, MEM_RELEASE);
111
112         g_assert (res);
113
114         account_mem (type, -(ssize_t)length);
115
116         return 0;
117 }
118
119 #if G_HAVE_API_SUPPORT(HAVE_CLASSIC_WINAPI_SUPPORT)
120 void*
121 mono_file_map (size_t length, int flags, int fd, guint64 offset, void **ret_handle)
122 {
123         void *ptr;
124         int mflags = 0;
125         HANDLE file, mapping;
126         int prot = mono_mmap_win_prot_from_flags (flags);
127         /* translate the flags */
128         /*if (flags & MONO_MMAP_PRIVATE)
129                 mflags |= MAP_PRIVATE;
130         if (flags & MONO_MMAP_SHARED)
131                 mflags |= MAP_SHARED;
132         if (flags & MONO_MMAP_ANON)
133                 mflags |= MAP_ANONYMOUS;
134         if (flags & MONO_MMAP_FIXED)
135                 mflags |= MAP_FIXED;
136         if (flags & MONO_MMAP_32BIT)
137                 mflags |= MAP_32BIT;*/
138
139         mflags = FILE_MAP_READ;
140         if (flags & MONO_MMAP_WRITE)
141                 mflags = FILE_MAP_COPY;
142
143         file = (HANDLE) _get_osfhandle (fd);
144
145         mapping = CreateFileMapping (file, NULL, prot, 0, 0, NULL);
146
147         if (mapping == NULL)
148                 return NULL;
149
150         ptr = MapViewOfFile (mapping, mflags, 0, offset, length);
151
152         if (ptr == NULL) {
153                 CloseHandle (mapping);
154                 return NULL;
155         }
156         *ret_handle = (void*)mapping;
157         return ptr;
158 }
159
160 int
161 mono_file_unmap (void *addr, void *handle)
162 {
163         UnmapViewOfFile (addr);
164         CloseHandle ((HANDLE)handle);
165         return 0;
166 }
167 #endif /* G_HAVE_API_SUPPORT(HAVE_CLASSIC_WINAPI_SUPPORT) */
168
169 int
170 mono_mprotect (void *addr, size_t length, int flags)
171 {
172         DWORD oldprot;
173         int prot = mono_mmap_win_prot_from_flags (flags);
174
175         if (flags & MONO_MMAP_DISCARD) {
176                 VirtualFree (addr, length, MEM_DECOMMIT);
177                 VirtualAlloc (addr, length, MEM_COMMIT, prot);
178                 return 0;
179         }
180         return VirtualProtect (addr, length, prot, &oldprot) == 0;
181 }
182
183 void*
184 mono_shared_area (void)
185 {
186         if (!malloced_shared_area)
187                 malloced_shared_area = malloc_shared_area (0);
188         /* get the pid here */
189         return malloced_shared_area;
190 }
191
192 void
193 mono_shared_area_remove (void)
194 {
195         if (malloced_shared_area)
196                 g_free (malloced_shared_area);
197         malloced_shared_area = NULL;
198 }
199
200 void*
201 mono_shared_area_for_pid (void *pid)
202 {
203         return NULL;
204 }
205
206 void
207 mono_shared_area_unload (void *area)
208 {
209 }
210
211 int
212 mono_shared_area_instances (void **array, int count)
213 {
214         return 0;
215 }
216
217 #endif