2 * Server-side file mapping management
4 * Copyright (C) 1999 Alexandre Julliard
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.
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.
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
22 #include "wine/port.h"
38 struct object obj
; /* object header */
39 int size_high
; /* mapping size */
40 int size_low
; /* mapping size */
41 int protect
; /* protection flags */
42 struct file
*file
; /* file mapped */
43 int header_size
; /* size of headers (for PE image mapping) */
44 void *base
; /* default base addr (for PE image mapping) */
45 struct file
*shared_file
; /* temp file for shared PE mapping */
46 int shared_size
; /* shared mapping total size */
47 struct mapping
*shared_next
; /* next in shared PE mapping list */
48 struct mapping
*shared_prev
; /* prev in shared PE mapping list */
51 static int mapping_get_fd( struct object
*obj
);
52 static int mapping_get_info( struct object
*obj
, struct get_file_info_reply
*reply
, int *flags
);
53 static void mapping_dump( struct object
*obj
, int verbose
);
54 static void mapping_destroy( struct object
*obj
);
56 static const struct object_ops mapping_ops
=
58 sizeof(struct mapping
), /* size */
59 mapping_dump
, /* dump */
60 no_add_queue
, /* add_queue */
61 NULL
, /* remove_queue */
64 NULL
, /* get_poll_events */
65 NULL
, /* poll_event */
66 mapping_get_fd
, /* get_fd */
68 mapping_get_info
, /* get_file_info */
69 NULL
, /* queue_async */
70 mapping_destroy
/* destroy */
73 static struct mapping
*shared_first
;
77 /* These are always the same on an i386, and it will be faster this way */
78 # define page_mask 0xfff
79 # define page_shift 12
80 # define init_page_size() do { /* nothing */ } while(0)
84 static int page_shift
, page_mask
;
86 static void init_page_size(void)
89 # ifdef HAVE_GETPAGESIZE
90 page_size
= getpagesize();
93 page_size
= sysconf(_SC_PAGESIZE
);
95 # error Cannot get the page size on this platform
98 page_mask
= page_size
- 1;
99 /* Make sure we have a power of 2 */
100 assert( !(page_size
& page_mask
) );
102 while ((1 << page_shift
) != page_size
) page_shift
++;
104 #endif /* __i386__ */
106 #define ROUND_ADDR(addr) \
107 ((int)(addr) & ~page_mask)
109 #define ROUND_SIZE(addr,size) \
110 (((int)(size) + ((int)(addr) & page_mask) + page_mask) & ~page_mask)
112 /* get the fd to use for mmaping a file */
113 inline static int get_mmap_fd( struct file
*file
)
116 if (!(obj
= (struct object
*)file
))
118 set_error( STATUS_INVALID_HANDLE
);
121 return obj
->ops
->get_fd( obj
);
124 /* find the shared PE mapping for a given mapping */
125 static struct file
*get_shared_file( struct mapping
*mapping
)
129 for (ptr
= shared_first
; ptr
; ptr
= ptr
->shared_next
)
130 if (is_same_file( ptr
->file
, mapping
->file
))
131 return (struct file
*)grab_object( ptr
->shared_file
);
135 /* allocate and fill the temp file for a shared PE image mapping */
136 static int build_shared_mapping( struct mapping
*mapping
, int fd
,
137 IMAGE_SECTION_HEADER
*sec
, int nb_sec
)
139 int i
, max_size
, total_size
, pos
;
144 /* compute the total size of the shared mapping */
146 total_size
= max_size
= 0;
147 for (i
= 0; i
< nb_sec
; i
++)
149 if ((sec
[i
].Characteristics
& IMAGE_SCN_MEM_SHARED
) &&
150 (sec
[i
].Characteristics
& IMAGE_SCN_MEM_WRITE
))
152 int size
= ROUND_SIZE( 0, sec
[i
].Misc
.VirtualSize
);
153 if (size
> max_size
) max_size
= size
;
157 if (!(mapping
->shared_size
= total_size
)) return 1; /* nothing to do */
159 if ((mapping
->shared_file
= get_shared_file( mapping
))) return 1;
161 /* create a temp file for the mapping */
163 if (!(mapping
->shared_file
= create_temp_file( GENERIC_READ
|GENERIC_WRITE
))) return 0;
164 if (!grow_file( mapping
->shared_file
, 0, total_size
)) goto error
;
165 if ((shared_fd
= get_mmap_fd( mapping
->shared_file
)) == -1) goto error
;
167 if (!(buffer
= malloc( max_size
))) goto error
;
169 /* copy the shared sections data into the temp file */
171 for (i
= pos
= 0; i
< nb_sec
; i
++)
173 if (!(sec
[i
].Characteristics
& IMAGE_SCN_MEM_SHARED
)) continue;
174 if (!(sec
[i
].Characteristics
& IMAGE_SCN_MEM_WRITE
)) continue;
175 if (lseek( shared_fd
, pos
, SEEK_SET
) != pos
) goto error
;
176 pos
+= ROUND_SIZE( 0, sec
[i
].Misc
.VirtualSize
);
177 if (sec
[i
].Characteristics
& IMAGE_SCN_CNT_UNINITIALIZED_DATA
) continue;
178 if (!sec
[i
].PointerToRawData
|| !sec
[i
].SizeOfRawData
) continue;
179 if (lseek( fd
, sec
[i
].PointerToRawData
, SEEK_SET
) != sec
[i
].PointerToRawData
) goto error
;
180 toread
= sec
[i
].SizeOfRawData
;
183 long res
= read( fd
, buffer
+ sec
[i
].SizeOfRawData
- toread
, toread
);
184 if (res
<= 0) goto error
;
187 if (write( shared_fd
, buffer
, sec
[i
].SizeOfRawData
) != sec
[i
].SizeOfRawData
) goto error
;
193 release_object( mapping
->shared_file
);
194 mapping
->shared_file
= NULL
;
195 if (buffer
) free( buffer
);
199 /* retrieve the mapping parameters for an executable (PE) image */
200 static int get_image_params( struct mapping
*mapping
)
202 IMAGE_DOS_HEADER dos
;
204 IMAGE_SECTION_HEADER
*sec
= NULL
;
205 int fd
, filepos
, size
;
207 /* load the headers */
209 if ((fd
= get_mmap_fd( mapping
->file
)) == -1) return 0;
210 filepos
= lseek( fd
, 0, SEEK_SET
);
211 if (read( fd
, &dos
, sizeof(dos
) ) != sizeof(dos
)) goto error
;
212 if (dos
.e_magic
!= IMAGE_DOS_SIGNATURE
) goto error
;
213 if (lseek( fd
, dos
.e_lfanew
, SEEK_SET
) == -1) goto error
;
215 if (read( fd
, &nt
.Signature
, sizeof(nt
.Signature
) ) != sizeof(nt
.Signature
)) goto error
;
216 if (nt
.Signature
!= IMAGE_NT_SIGNATURE
) goto error
;
217 if (read( fd
, &nt
.FileHeader
, sizeof(nt
.FileHeader
) ) != sizeof(nt
.FileHeader
)) goto error
;
218 /* zero out Optional header in the case it's not present or partial */
219 memset(&nt
.OptionalHeader
, 0, sizeof(nt
.OptionalHeader
));
220 if (read( fd
, &nt
.OptionalHeader
, nt
.FileHeader
.SizeOfOptionalHeader
) != nt
.FileHeader
.SizeOfOptionalHeader
) goto error
;
222 /* load the section headers */
224 size
= sizeof(*sec
) * nt
.FileHeader
.NumberOfSections
;
225 if (!(sec
= malloc( size
))) goto error
;
226 if (read( fd
, sec
, size
) != size
) goto error
;
228 if (!build_shared_mapping( mapping
, fd
, sec
, nt
.FileHeader
.NumberOfSections
)) goto error
;
230 if (mapping
->shared_file
) /* link it in the list */
232 if ((mapping
->shared_next
= shared_first
)) shared_first
->shared_prev
= mapping
;
233 mapping
->shared_prev
= NULL
;
234 shared_first
= mapping
;
237 mapping
->size_low
= ROUND_SIZE( 0, nt
.OptionalHeader
.SizeOfImage
);
238 mapping
->size_high
= 0;
239 mapping
->base
= (void *)nt
.OptionalHeader
.ImageBase
;
240 mapping
->header_size
= ROUND_SIZE( mapping
->base
, nt
.OptionalHeader
.SizeOfHeaders
);
241 mapping
->protect
= VPROT_IMAGE
;
244 if (mapping
->header_size
> mapping
->size_low
) goto error
;
246 lseek( fd
, filepos
, SEEK_SET
);
251 lseek( fd
, filepos
, SEEK_SET
);
252 if (sec
) free( sec
);
253 set_error( STATUS_INVALID_FILE_FOR_SECTION
);
258 static struct object
*create_mapping( int size_high
, int size_low
, int protect
,
259 obj_handle_t handle
, const WCHAR
*name
, size_t len
)
261 struct mapping
*mapping
;
264 if (!page_mask
) init_page_size();
266 if (!(mapping
= create_named_object( &mapping_ops
, name
, len
)))
268 if (get_error() == STATUS_OBJECT_NAME_COLLISION
)
269 return &mapping
->obj
; /* Nothing else to do */
271 mapping
->header_size
= 0;
272 mapping
->base
= NULL
;
273 mapping
->shared_file
= NULL
;
274 mapping
->shared_size
= 0;
276 if (protect
& VPROT_READ
) access
|= GENERIC_READ
;
277 if (protect
& VPROT_WRITE
) access
|= GENERIC_WRITE
;
281 if (!(mapping
->file
= get_file_obj( current
->process
, handle
, access
))) goto error
;
282 if (protect
& VPROT_IMAGE
)
284 if (!get_image_params( mapping
)) goto error
;
285 return &mapping
->obj
;
287 if (!size_high
&& !size_low
)
290 struct get_file_info_reply reply
;
291 struct object
*obj
= (struct object
*)mapping
->file
;
292 obj
->ops
->get_file_info( obj
, &reply
, &flags
);
293 size_high
= reply
.size_high
;
294 size_low
= ROUND_SIZE( 0, reply
.size_low
);
296 else if (!grow_file( mapping
->file
, size_high
, size_low
)) goto error
;
298 else /* Anonymous mapping (no associated file) */
300 if ((!size_high
&& !size_low
) || (protect
& VPROT_IMAGE
))
302 set_error( STATUS_INVALID_PARAMETER
);
303 mapping
->file
= NULL
;
306 if (!(mapping
->file
= create_temp_file( access
))) goto error
;
307 if (!grow_file( mapping
->file
, size_high
, size_low
)) goto error
;
309 mapping
->size_high
= size_high
;
310 mapping
->size_low
= ROUND_SIZE( 0, size_low
);
311 mapping
->protect
= protect
;
312 return &mapping
->obj
;
315 release_object( mapping
);
319 static void mapping_dump( struct object
*obj
, int verbose
)
321 struct mapping
*mapping
= (struct mapping
*)obj
;
322 assert( obj
->ops
== &mapping_ops
);
323 fprintf( stderr
, "Mapping size=%08x%08x prot=%08x file=%p header_size=%08x base=%p "
324 "shared_file=%p shared_size=%08x ",
325 mapping
->size_high
, mapping
->size_low
, mapping
->protect
, mapping
->file
,
326 mapping
->header_size
, mapping
->base
, mapping
->shared_file
, mapping
->shared_size
);
327 dump_object_name( &mapping
->obj
);
328 fputc( '\n', stderr
);
331 static int mapping_get_fd( struct object
*obj
)
333 struct mapping
*mapping
= (struct mapping
*)obj
;
334 assert( obj
->ops
== &mapping_ops
);
335 return get_mmap_fd( mapping
->file
);
338 static int mapping_get_info( struct object
*obj
, struct get_file_info_reply
*reply
, int *flags
)
340 struct mapping
*mapping
= (struct mapping
*)obj
;
341 struct object
*file
= (struct object
*)mapping
->file
;
343 assert( obj
->ops
== &mapping_ops
);
345 return file
->ops
->get_file_info( file
, reply
, flags
);
348 static void mapping_destroy( struct object
*obj
)
350 struct mapping
*mapping
= (struct mapping
*)obj
;
351 assert( obj
->ops
== &mapping_ops
);
352 if (mapping
->file
) release_object( mapping
->file
);
353 if (mapping
->shared_file
)
355 release_object( mapping
->shared_file
);
356 if (mapping
->shared_next
) mapping
->shared_next
->shared_prev
= mapping
->shared_prev
;
357 if (mapping
->shared_prev
) mapping
->shared_prev
->shared_next
= mapping
->shared_next
;
358 else shared_first
= mapping
->shared_next
;
362 int get_page_size(void)
364 if (!page_mask
) init_page_size();
365 return page_mask
+ 1;
368 /* create a file mapping */
369 DECL_HANDLER(create_mapping
)
374 if ((obj
= create_mapping( req
->size_high
, req
->size_low
,
375 req
->protect
, req
->file_handle
,
376 get_req_data(), get_req_data_size() )))
378 int access
= FILE_MAP_ALL_ACCESS
;
379 if (!(req
->protect
& VPROT_WRITE
)) access
&= ~FILE_MAP_WRITE
;
380 reply
->handle
= alloc_handle( current
->process
, obj
, access
, req
->inherit
);
381 release_object( obj
);
385 /* open a handle to a mapping */
386 DECL_HANDLER(open_mapping
)
388 reply
->handle
= open_object( get_req_data(), get_req_data_size(),
389 &mapping_ops
, req
->access
, req
->inherit
);
392 /* get a mapping information */
393 DECL_HANDLER(get_mapping_info
)
395 struct mapping
*mapping
;
397 if ((mapping
= (struct mapping
*)get_handle_obj( current
->process
, req
->handle
,
400 reply
->size_high
= mapping
->size_high
;
401 reply
->size_low
= mapping
->size_low
;
402 reply
->protect
= mapping
->protect
;
403 reply
->header_size
= mapping
->header_size
;
404 reply
->base
= mapping
->base
;
405 reply
->shared_file
= 0;
406 reply
->shared_size
= mapping
->shared_size
;
407 reply
->drive_type
= get_file_drive_type( mapping
->file
);
408 if (mapping
->shared_file
)
409 reply
->shared_file
= alloc_handle( current
->process
, mapping
->shared_file
,
410 GENERIC_READ
|GENERIC_WRITE
, 0 );
411 release_object( mapping
);