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"
41 struct object obj
; /* object header */
42 file_pos_t size
; /* mapping size */
43 int protect
; /* protection flags */
44 struct file
*file
; /* file mapped */
45 int header_size
; /* size of headers (for PE image mapping) */
46 void *base
; /* default base addr (for PE image mapping) */
47 struct file
*shared_file
; /* temp file for shared PE mapping */
48 int shared_size
; /* shared mapping total size */
49 struct mapping
*shared_next
; /* next in shared PE mapping list */
50 struct mapping
*shared_prev
; /* prev in shared PE mapping list */
53 static void mapping_dump( struct object
*obj
, int verbose
);
54 static struct fd
*mapping_get_fd( struct object
*obj
);
55 static void mapping_destroy( struct object
*obj
);
57 static const struct object_ops mapping_ops
=
59 sizeof(struct mapping
), /* size */
60 mapping_dump
, /* dump */
61 no_add_queue
, /* add_queue */
62 NULL
, /* remove_queue */
65 no_signal
, /* signal */
66 mapping_get_fd
, /* get_fd */
67 no_close_handle
, /* close_handle */
68 mapping_destroy
/* destroy */
71 static struct mapping
*shared_first
;
75 /* These are always the same on an i386, and it will be faster this way */
76 # define page_mask 0xfff
77 # define page_shift 12
78 # define init_page_size() do { /* nothing */ } while(0)
82 static int page_shift
, page_mask
;
84 static void init_page_size(void)
87 # ifdef HAVE_GETPAGESIZE
88 page_size
= getpagesize();
91 page_size
= sysconf(_SC_PAGESIZE
);
93 # error Cannot get the page size on this platform
96 page_mask
= page_size
- 1;
97 /* Make sure we have a power of 2 */
98 assert( !(page_size
& page_mask
) );
100 while ((1 << page_shift
) != page_size
) page_shift
++;
102 #endif /* __i386__ */
104 #define ROUND_SIZE_MASK(addr,size,mask) \
105 (((int)(size) + ((int)(addr) & (mask)) + (mask)) & ~(mask))
107 #define ROUND_SIZE(size) (((size) + page_mask) & ~page_mask)
110 /* find the shared PE mapping for a given mapping */
111 static struct file
*get_shared_file( struct mapping
*mapping
)
115 for (ptr
= shared_first
; ptr
; ptr
= ptr
->shared_next
)
116 if (is_same_file( ptr
->file
, mapping
->file
))
117 return (struct file
*)grab_object( ptr
->shared_file
);
121 /* allocate and fill the temp file for a shared PE image mapping */
122 static int build_shared_mapping( struct mapping
*mapping
, int fd
,
123 IMAGE_SECTION_HEADER
*sec
, unsigned int nb_sec
)
125 unsigned int i
, max_size
, total_size
;
126 off_t shared_pos
, read_pos
, write_pos
;
131 /* compute the total size of the shared mapping */
133 total_size
= max_size
= 0;
134 for (i
= 0; i
< nb_sec
; i
++)
136 if ((sec
[i
].Characteristics
& IMAGE_SCN_MEM_SHARED
) &&
137 (sec
[i
].Characteristics
& IMAGE_SCN_MEM_WRITE
))
139 unsigned int size
= ROUND_SIZE( sec
[i
].Misc
.VirtualSize
);
140 if (size
> max_size
) max_size
= size
;
144 if (!(mapping
->shared_size
= total_size
)) return 1; /* nothing to do */
146 if ((mapping
->shared_file
= get_shared_file( mapping
))) return 1;
148 /* create a temp file for the mapping */
150 if (!(mapping
->shared_file
= create_temp_file( GENERIC_READ
|GENERIC_WRITE
))) return 0;
151 if (!grow_file( mapping
->shared_file
, total_size
)) goto error
;
152 if ((shared_fd
= get_file_unix_fd( mapping
->shared_file
)) == -1) goto error
;
154 if (!(buffer
= malloc( max_size
))) goto error
;
156 /* copy the shared sections data into the temp file */
159 for (i
= 0; i
< nb_sec
; i
++)
161 if (!(sec
[i
].Characteristics
& IMAGE_SCN_MEM_SHARED
)) continue;
162 if (!(sec
[i
].Characteristics
& IMAGE_SCN_MEM_WRITE
)) continue;
163 write_pos
= shared_pos
;
164 shared_pos
+= ROUND_SIZE( sec
[i
].Misc
.VirtualSize
);
165 if ((sec
[i
].Characteristics
& IMAGE_SCN_CNT_UNINITIALIZED_DATA
) &&
166 !(sec
[i
].Characteristics
& IMAGE_SCN_CNT_INITIALIZED_DATA
)) continue;
167 if (!sec
[i
].PointerToRawData
|| !sec
[i
].SizeOfRawData
) continue;
168 read_pos
= sec
[i
].PointerToRawData
;
169 toread
= sec
[i
].SizeOfRawData
;
172 long res
= pread( fd
, buffer
+ sec
[i
].SizeOfRawData
- toread
, toread
, read_pos
);
173 if (res
<= 0) goto error
;
177 if (pwrite( shared_fd
, buffer
, sec
[i
].SizeOfRawData
, write_pos
) != sec
[i
].SizeOfRawData
)
184 release_object( mapping
->shared_file
);
185 mapping
->shared_file
= NULL
;
186 if (buffer
) free( buffer
);
190 /* retrieve the mapping parameters for an executable (PE) image */
191 static int get_image_params( struct mapping
*mapping
)
193 IMAGE_DOS_HEADER dos
;
195 IMAGE_SECTION_HEADER
*sec
= NULL
;
200 /* load the headers */
202 if (!(fd
= mapping_get_fd( &mapping
->obj
))) return 0;
203 unix_fd
= get_unix_fd( fd
);
204 if (pread( unix_fd
, &dos
, sizeof(dos
), 0 ) != sizeof(dos
)) goto error
;
205 if (dos
.e_magic
!= IMAGE_DOS_SIGNATURE
) goto error
;
208 if (pread( unix_fd
, &nt
.Signature
, sizeof(nt
.Signature
), pos
) != sizeof(nt
.Signature
))
210 pos
+= sizeof(nt
.Signature
);
211 if (nt
.Signature
!= IMAGE_NT_SIGNATURE
) goto error
;
212 if (pread( unix_fd
, &nt
.FileHeader
, sizeof(nt
.FileHeader
), pos
) != sizeof(nt
.FileHeader
))
214 pos
+= sizeof(nt
.FileHeader
);
215 /* zero out Optional header in the case it's not present or partial */
216 memset(&nt
.OptionalHeader
, 0, sizeof(nt
.OptionalHeader
));
217 if (pread( unix_fd
, &nt
.OptionalHeader
, nt
.FileHeader
.SizeOfOptionalHeader
,
218 pos
) != nt
.FileHeader
.SizeOfOptionalHeader
) goto error
;
219 pos
+= nt
.FileHeader
.SizeOfOptionalHeader
;
221 /* load the section headers */
223 size
= sizeof(*sec
) * nt
.FileHeader
.NumberOfSections
;
224 if (!(sec
= malloc( size
))) goto error
;
225 if (pread( unix_fd
, sec
, size
, pos
) != size
) goto error
;
227 if (!build_shared_mapping( mapping
, unix_fd
, sec
, nt
.FileHeader
.NumberOfSections
)) goto error
;
229 if (mapping
->shared_file
) /* link it in the list */
231 if ((mapping
->shared_next
= shared_first
)) shared_first
->shared_prev
= mapping
;
232 mapping
->shared_prev
= NULL
;
233 shared_first
= mapping
;
236 mapping
->size
= ROUND_SIZE( nt
.OptionalHeader
.SizeOfImage
);
237 mapping
->base
= (void *)nt
.OptionalHeader
.ImageBase
;
238 mapping
->header_size
= ROUND_SIZE_MASK( mapping
->base
, nt
.OptionalHeader
.SizeOfHeaders
,
239 nt
.OptionalHeader
.SectionAlignment
- 1 );
240 mapping
->protect
= VPROT_IMAGE
;
243 if (mapping
->header_size
> mapping
->size
) goto error
;
246 release_object( fd
);
250 if (sec
) free( sec
);
251 release_object( fd
);
252 set_error( STATUS_INVALID_FILE_FOR_SECTION
);
256 /* get the size of the unix file associated with the mapping */
257 inline static int get_file_size( struct file
*file
, file_pos_t
*size
)
260 int unix_fd
= get_file_unix_fd( file
);
262 if (fstat( unix_fd
, &st
) == -1) return 0;
267 static struct object
*create_mapping( file_pos_t size
, int protect
, obj_handle_t handle
,
268 const WCHAR
*name
, size_t len
)
270 struct mapping
*mapping
;
273 if (!page_mask
) init_page_size();
275 if (!(mapping
= create_named_object( sync_namespace
, &mapping_ops
, name
, len
)))
277 if (get_error() == STATUS_OBJECT_NAME_COLLISION
)
278 return &mapping
->obj
; /* Nothing else to do */
280 mapping
->header_size
= 0;
281 mapping
->base
= NULL
;
282 mapping
->shared_file
= NULL
;
283 mapping
->shared_size
= 0;
285 if (protect
& VPROT_READ
) access
|= GENERIC_READ
;
286 if (protect
& VPROT_WRITE
) access
|= GENERIC_WRITE
;
290 if (!(mapping
->file
= get_file_obj( current
->process
, handle
, access
))) goto error
;
291 if (protect
& VPROT_IMAGE
)
293 if (!get_image_params( mapping
)) goto error
;
294 return &mapping
->obj
;
298 if (!get_file_size( mapping
->file
, &size
)) goto error
;
301 set_error( STATUS_FILE_INVALID
);
307 if (!grow_file( mapping
->file
, size
)) goto error
;
310 else /* Anonymous mapping (no associated file) */
312 if (!size
|| (protect
& VPROT_IMAGE
))
314 set_error( STATUS_INVALID_PARAMETER
);
315 mapping
->file
= NULL
;
318 if (!(mapping
->file
= create_temp_file( access
))) goto error
;
319 if (!grow_file( mapping
->file
, size
)) goto error
;
321 mapping
->size
= (size
+ page_mask
) & ~((file_pos_t
)page_mask
);
322 mapping
->protect
= protect
;
323 return &mapping
->obj
;
326 release_object( mapping
);
330 static void mapping_dump( struct object
*obj
, int verbose
)
332 struct mapping
*mapping
= (struct mapping
*)obj
;
333 assert( obj
->ops
== &mapping_ops
);
334 fprintf( stderr
, "Mapping size=%08x%08x prot=%08x file=%p header_size=%08x base=%p "
335 "shared_file=%p shared_size=%08x ",
336 (unsigned int)(mapping
->size
>> 32), (unsigned int)mapping
->size
,
337 mapping
->protect
, mapping
->file
, mapping
->header_size
,
338 mapping
->base
, mapping
->shared_file
, mapping
->shared_size
);
339 dump_object_name( &mapping
->obj
);
340 fputc( '\n', stderr
);
343 static struct fd
*mapping_get_fd( struct object
*obj
)
345 struct mapping
*mapping
= (struct mapping
*)obj
;
346 return get_obj_fd( (struct object
*)mapping
->file
);
349 static void mapping_destroy( struct object
*obj
)
351 struct mapping
*mapping
= (struct mapping
*)obj
;
352 assert( obj
->ops
== &mapping_ops
);
353 if (mapping
->file
) release_object( mapping
->file
);
354 if (mapping
->shared_file
)
356 release_object( mapping
->shared_file
);
357 if (mapping
->shared_next
) mapping
->shared_next
->shared_prev
= mapping
->shared_prev
;
358 if (mapping
->shared_prev
) mapping
->shared_prev
->shared_next
= mapping
->shared_next
;
359 else shared_first
= mapping
->shared_next
;
363 int get_page_size(void)
365 if (!page_mask
) init_page_size();
366 return page_mask
+ 1;
369 /* create a file mapping */
370 DECL_HANDLER(create_mapping
)
373 file_pos_t size
= ((file_pos_t
)req
->size_high
<< 32) | req
->size_low
;
376 if ((obj
= create_mapping( size
, req
->protect
, req
->file_handle
,
377 get_req_data(), get_req_data_size() )))
379 reply
->handle
= alloc_handle( current
->process
, obj
, req
->access
, req
->inherit
);
380 release_object( obj
);
384 /* open a handle to a mapping */
385 DECL_HANDLER(open_mapping
)
387 reply
->handle
= open_object( sync_namespace
, get_req_data(), get_req_data_size(),
388 &mapping_ops
, req
->access
, req
->inherit
);
391 /* get a mapping information */
392 DECL_HANDLER(get_mapping_info
)
394 struct mapping
*mapping
;
396 if ((mapping
= (struct mapping
*)get_handle_obj( current
->process
, req
->handle
,
399 reply
->size_high
= (unsigned int)(mapping
->size
>> 32);
400 reply
->size_low
= (unsigned int)mapping
->size
;
401 reply
->protect
= mapping
->protect
;
402 reply
->header_size
= mapping
->header_size
;
403 reply
->base
= mapping
->base
;
404 reply
->shared_file
= 0;
405 reply
->shared_size
= mapping
->shared_size
;
406 if (mapping
->shared_file
)
407 reply
->shared_file
= alloc_handle( current
->process
, mapping
->shared_file
,
408 GENERIC_READ
|GENERIC_WRITE
, 0 );
409 release_object( mapping
);