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"
32 #define WIN32_NO_STATUS
43 struct object obj
; /* object header */
44 file_pos_t size
; /* mapping size */
45 int protect
; /* protection flags */
46 struct file
*file
; /* file mapped */
47 int header_size
; /* size of headers (for PE image mapping) */
48 void *base
; /* default base addr (for PE image mapping) */
49 struct file
*shared_file
; /* temp file for shared PE mapping */
50 int shared_size
; /* shared mapping total size */
51 struct list shared_entry
; /* entry in global shared PE mappings list */
54 static void mapping_dump( struct object
*obj
, int verbose
);
55 static struct fd
*mapping_get_fd( struct object
*obj
);
56 static unsigned int mapping_map_access( struct object
*obj
, unsigned int access
);
57 static void mapping_destroy( struct object
*obj
);
59 static const struct object_ops mapping_ops
=
61 sizeof(struct mapping
), /* size */
62 mapping_dump
, /* dump */
63 no_add_queue
, /* add_queue */
64 NULL
, /* remove_queue */
67 no_signal
, /* signal */
68 mapping_get_fd
, /* get_fd */
69 mapping_map_access
, /* map_access */
70 no_lookup_name
, /* lookup_name */
71 no_close_handle
, /* close_handle */
72 mapping_destroy
/* destroy */
75 static struct list shared_list
= LIST_INIT(shared_list
);
79 /* These are always the same on an i386, and it will be faster this way */
80 # define page_mask 0xfff
81 # define page_shift 12
82 # define init_page_size() do { /* nothing */ } while(0)
86 static int page_shift
, page_mask
;
88 static void init_page_size(void)
91 # ifdef HAVE_GETPAGESIZE
92 page_size
= getpagesize();
95 page_size
= sysconf(_SC_PAGESIZE
);
97 # error Cannot get the page size on this platform
100 page_mask
= page_size
- 1;
101 /* Make sure we have a power of 2 */
102 assert( !(page_size
& page_mask
) );
104 while ((1 << page_shift
) != page_size
) page_shift
++;
106 #endif /* __i386__ */
108 #define ROUND_SIZE(size) (((size) + page_mask) & ~page_mask)
111 /* find the shared PE mapping for a given mapping */
112 static struct file
*get_shared_file( struct mapping
*mapping
)
116 LIST_FOR_EACH_ENTRY( ptr
, &shared_list
, struct mapping
, shared_entry
)
117 if (is_same_file( ptr
->file
, mapping
->file
))
118 return (struct file
*)grab_object( ptr
->shared_file
);
122 /* return the size of the memory mapping of a given section */
123 static inline unsigned int get_section_map_size( const IMAGE_SECTION_HEADER
*sec
)
125 if (!sec
->Misc
.VirtualSize
) return ROUND_SIZE( sec
->SizeOfRawData
);
126 else return ROUND_SIZE( sec
->Misc
.VirtualSize
);
129 /* return the size of the file mapping of a given section */
130 static inline unsigned int get_section_filemap_size( const IMAGE_SECTION_HEADER
*sec
)
132 if (!sec
->Misc
.VirtualSize
) return sec
->SizeOfRawData
;
133 else return min( sec
->SizeOfRawData
, ROUND_SIZE( sec
->Misc
.VirtualSize
) );
136 /* allocate and fill the temp file for a shared PE image mapping */
137 static int build_shared_mapping( struct mapping
*mapping
, int fd
,
138 IMAGE_SECTION_HEADER
*sec
, unsigned int nb_sec
)
140 unsigned int i
, size
, max_size
, total_size
;
141 off_t shared_pos
, read_pos
, write_pos
;
146 /* compute the total size of the shared mapping */
148 total_size
= max_size
= 0;
149 for (i
= 0; i
< nb_sec
; i
++)
151 if ((sec
[i
].Characteristics
& IMAGE_SCN_MEM_SHARED
) &&
152 (sec
[i
].Characteristics
& IMAGE_SCN_MEM_WRITE
))
154 size
= get_section_filemap_size( &sec
[i
] );
155 if (size
> max_size
) max_size
= size
;
156 total_size
+= get_section_map_size( &sec
[i
] );
159 if (!(mapping
->shared_size
= total_size
)) return 1; /* nothing to do */
161 if ((mapping
->shared_file
= get_shared_file( mapping
))) return 1;
163 /* create a temp file for the mapping */
165 if (!(mapping
->shared_file
= create_temp_file( FILE_GENERIC_READ
|FILE_GENERIC_WRITE
))) return 0;
166 if (!grow_file( mapping
->shared_file
, total_size
)) goto error
;
167 if ((shared_fd
= get_file_unix_fd( mapping
->shared_file
)) == -1) goto error
;
169 if (!(buffer
= malloc( max_size
))) goto error
;
171 /* copy the shared sections data into the temp file */
174 for (i
= 0; i
< nb_sec
; i
++)
176 if (!(sec
[i
].Characteristics
& IMAGE_SCN_MEM_SHARED
)) continue;
177 if (!(sec
[i
].Characteristics
& IMAGE_SCN_MEM_WRITE
)) continue;
178 write_pos
= shared_pos
;
179 shared_pos
+= get_section_map_size( &sec
[i
] );
180 read_pos
= sec
[i
].PointerToRawData
;
181 size
= get_section_filemap_size( &sec
[i
] );
182 if (!read_pos
|| !size
) continue;
186 long res
= pread( fd
, buffer
+ sec
[i
].SizeOfRawData
- toread
, toread
, read_pos
);
187 if (res
<= 0) goto error
;
191 if (pwrite( shared_fd
, buffer
, size
, write_pos
) != size
) goto error
;
197 release_object( mapping
->shared_file
);
198 mapping
->shared_file
= NULL
;
199 if (buffer
) free( buffer
);
203 /* retrieve the mapping parameters for an executable (PE) image */
204 static int get_image_params( struct mapping
*mapping
)
206 IMAGE_DOS_HEADER dos
;
208 IMAGE_SECTION_HEADER
*sec
= NULL
;
211 int unix_fd
, size
, toread
;
213 /* load the headers */
215 if (!(fd
= mapping_get_fd( &mapping
->obj
))) return 0;
216 if ((unix_fd
= get_unix_fd( fd
)) == -1) goto error
;
217 if (pread( unix_fd
, &dos
, sizeof(dos
), 0 ) != sizeof(dos
)) goto error
;
218 if (dos
.e_magic
!= IMAGE_DOS_SIGNATURE
) goto error
;
221 if (pread( unix_fd
, &nt
.Signature
, sizeof(nt
.Signature
), pos
) != sizeof(nt
.Signature
))
223 pos
+= sizeof(nt
.Signature
);
224 if (nt
.Signature
!= IMAGE_NT_SIGNATURE
) goto error
;
225 if (pread( unix_fd
, &nt
.FileHeader
, sizeof(nt
.FileHeader
), pos
) != sizeof(nt
.FileHeader
))
227 pos
+= sizeof(nt
.FileHeader
);
228 /* zero out Optional header in the case it's not present or partial */
229 memset(&nt
.OptionalHeader
, 0, sizeof(nt
.OptionalHeader
));
230 toread
= min( sizeof(nt
.OptionalHeader
), nt
.FileHeader
.SizeOfOptionalHeader
);
231 if (pread( unix_fd
, &nt
.OptionalHeader
, toread
, pos
) != toread
) goto error
;
232 pos
+= nt
.FileHeader
.SizeOfOptionalHeader
;
234 /* load the section headers */
236 size
= sizeof(*sec
) * nt
.FileHeader
.NumberOfSections
;
237 if (!(sec
= malloc( size
))) goto error
;
238 if (pread( unix_fd
, sec
, size
, pos
) != size
) goto error
;
240 if (!build_shared_mapping( mapping
, unix_fd
, sec
, nt
.FileHeader
.NumberOfSections
)) goto error
;
242 if (mapping
->shared_file
) list_add_head( &shared_list
, &mapping
->shared_entry
);
244 mapping
->size
= ROUND_SIZE( nt
.OptionalHeader
.SizeOfImage
);
245 mapping
->base
= (void *)nt
.OptionalHeader
.ImageBase
;
246 mapping
->header_size
= pos
+ size
;
247 mapping
->protect
= VPROT_IMAGE
;
250 if (mapping
->header_size
> mapping
->size
) goto error
;
253 release_object( fd
);
257 if (sec
) free( sec
);
258 release_object( fd
);
259 set_error( STATUS_INVALID_FILE_FOR_SECTION
);
263 /* get the size of the unix file associated with the mapping */
264 inline static int get_file_size( struct file
*file
, file_pos_t
*size
)
267 int unix_fd
= get_file_unix_fd( file
);
269 if (unix_fd
== -1 || fstat( unix_fd
, &st
) == -1) return 0;
274 static struct object
*create_mapping( struct directory
*root
, const struct unicode_str
*name
,
275 unsigned int attr
, file_pos_t size
, int protect
,
276 obj_handle_t handle
)
278 struct mapping
*mapping
;
281 if (!page_mask
) init_page_size();
283 if (!(mapping
= create_named_object_dir( root
, name
, attr
, &mapping_ops
)))
285 if (get_error() == STATUS_OBJECT_NAME_EXISTS
)
286 return &mapping
->obj
; /* Nothing else to do */
288 mapping
->header_size
= 0;
289 mapping
->base
= NULL
;
290 mapping
->shared_file
= NULL
;
291 mapping
->shared_size
= 0;
293 if (protect
& VPROT_READ
) access
|= FILE_READ_DATA
;
294 if (protect
& VPROT_WRITE
) access
|= FILE_WRITE_DATA
;
298 if (!(mapping
->file
= get_file_obj( current
->process
, handle
, access
))) goto error
;
299 if (protect
& VPROT_IMAGE
)
301 if (!get_image_params( mapping
)) goto error
;
302 return &mapping
->obj
;
306 if (!get_file_size( mapping
->file
, &size
)) goto error
;
309 set_error( STATUS_MAPPED_FILE_SIZE_ZERO
);
315 if (!grow_file( mapping
->file
, size
)) goto error
;
318 else /* Anonymous mapping (no associated file) */
320 if (!size
|| (protect
& VPROT_IMAGE
))
322 set_error( STATUS_INVALID_PARAMETER
);
323 mapping
->file
= NULL
;
326 if (!(mapping
->file
= create_temp_file( access
))) goto error
;
327 if (!grow_file( mapping
->file
, size
)) goto error
;
329 mapping
->size
= (size
+ page_mask
) & ~((file_pos_t
)page_mask
);
330 mapping
->protect
= protect
;
331 return &mapping
->obj
;
334 release_object( mapping
);
338 static void mapping_dump( struct object
*obj
, int verbose
)
340 struct mapping
*mapping
= (struct mapping
*)obj
;
341 assert( obj
->ops
== &mapping_ops
);
342 fprintf( stderr
, "Mapping size=%08x%08x prot=%08x file=%p header_size=%08x base=%p "
343 "shared_file=%p shared_size=%08x ",
344 (unsigned int)(mapping
->size
>> 32), (unsigned int)mapping
->size
,
345 mapping
->protect
, mapping
->file
, mapping
->header_size
,
346 mapping
->base
, mapping
->shared_file
, mapping
->shared_size
);
347 dump_object_name( &mapping
->obj
);
348 fputc( '\n', stderr
);
351 static struct fd
*mapping_get_fd( struct object
*obj
)
353 struct mapping
*mapping
= (struct mapping
*)obj
;
354 return get_obj_fd( (struct object
*)mapping
->file
);
357 static unsigned int mapping_map_access( struct object
*obj
, unsigned int access
)
359 if (access
& GENERIC_READ
) access
|= STANDARD_RIGHTS_READ
| SECTION_QUERY
| SECTION_MAP_READ
;
360 if (access
& GENERIC_WRITE
) access
|= STANDARD_RIGHTS_WRITE
| SECTION_MAP_WRITE
;
361 if (access
& GENERIC_EXECUTE
) access
|= STANDARD_RIGHTS_EXECUTE
| SECTION_MAP_EXECUTE
;
362 if (access
& GENERIC_ALL
) access
|= SECTION_ALL_ACCESS
;
363 return access
& ~(GENERIC_READ
| GENERIC_WRITE
| GENERIC_EXECUTE
| GENERIC_ALL
);
366 static void mapping_destroy( struct object
*obj
)
368 struct mapping
*mapping
= (struct mapping
*)obj
;
369 assert( obj
->ops
== &mapping_ops
);
370 if (mapping
->file
) release_object( mapping
->file
);
371 if (mapping
->shared_file
)
373 release_object( mapping
->shared_file
);
374 list_remove( &mapping
->shared_entry
);
378 int get_page_size(void)
380 if (!page_mask
) init_page_size();
381 return page_mask
+ 1;
384 /* create a file mapping */
385 DECL_HANDLER(create_mapping
)
388 struct unicode_str name
;
389 struct directory
*root
= NULL
;
390 file_pos_t size
= ((file_pos_t
)req
->size_high
<< 32) | req
->size_low
;
393 get_req_unicode_str( &name
);
394 if (req
->rootdir
&& !(root
= get_directory_obj( current
->process
, req
->rootdir
, 0 )))
397 if ((obj
= create_mapping( root
, &name
, req
->attributes
, size
, req
->protect
, req
->file_handle
)))
399 reply
->handle
= alloc_handle( current
->process
, obj
, req
->access
, req
->attributes
);
400 release_object( obj
);
403 if (root
) release_object( root
);
406 /* open a handle to a mapping */
407 DECL_HANDLER(open_mapping
)
409 struct unicode_str name
;
410 struct directory
*root
= NULL
;
411 struct mapping
*mapping
;
413 get_req_unicode_str( &name
);
414 if (req
->rootdir
&& !(root
= get_directory_obj( current
->process
, req
->rootdir
, 0 )))
417 if ((mapping
= open_object_dir( root
, &name
, req
->attributes
, &mapping_ops
)))
419 reply
->handle
= alloc_handle( current
->process
, &mapping
->obj
, req
->access
, req
->attributes
);
420 release_object( mapping
);
423 if (root
) release_object( root
);
426 /* get a mapping information */
427 DECL_HANDLER(get_mapping_info
)
429 struct mapping
*mapping
;
431 if ((mapping
= (struct mapping
*)get_handle_obj( current
->process
, req
->handle
,
434 reply
->size_high
= (unsigned int)(mapping
->size
>> 32);
435 reply
->size_low
= (unsigned int)mapping
->size
;
436 reply
->protect
= mapping
->protect
;
437 reply
->header_size
= mapping
->header_size
;
438 reply
->base
= mapping
->base
;
439 reply
->shared_file
= 0;
440 reply
->shared_size
= mapping
->shared_size
;
441 if (mapping
->shared_file
)
442 reply
->shared_file
= alloc_handle( current
->process
, mapping
->shared_file
,
443 GENERIC_READ
|GENERIC_WRITE
, 0 );
444 release_object( mapping
);