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"
39 struct object obj
; /* object header */
40 int size_high
; /* mapping size */
41 int size_low
; /* mapping size */
42 int protect
; /* protection flags */
43 struct file
*file
; /* file mapped */
44 int header_size
; /* size of headers (for PE image mapping) */
45 void *base
; /* default base addr (for PE image mapping) */
46 struct file
*shared_file
; /* temp file for shared PE mapping */
47 int shared_size
; /* shared mapping total size */
48 struct mapping
*shared_next
; /* next in shared PE mapping list */
49 struct mapping
*shared_prev
; /* prev in shared PE mapping list */
52 static void mapping_dump( struct object
*obj
, int verbose
);
53 static struct fd
*mapping_get_fd( struct object
*obj
);
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 mapping_get_fd
, /* get_fd */
65 mapping_destroy
/* destroy */
68 static struct mapping
*shared_first
;
72 /* These are always the same on an i386, and it will be faster this way */
73 # define page_mask 0xfff
74 # define page_shift 12
75 # define init_page_size() do { /* nothing */ } while(0)
79 static int page_shift
, page_mask
;
81 static void init_page_size(void)
84 # ifdef HAVE_GETPAGESIZE
85 page_size
= getpagesize();
88 page_size
= sysconf(_SC_PAGESIZE
);
90 # error Cannot get the page size on this platform
93 page_mask
= page_size
- 1;
94 /* Make sure we have a power of 2 */
95 assert( !(page_size
& page_mask
) );
97 while ((1 << page_shift
) != page_size
) page_shift
++;
101 #define ROUND_ADDR(addr) \
102 ((int)(addr) & ~page_mask)
104 #define ROUND_SIZE(addr,size) \
105 (((int)(size) + ((int)(addr) & page_mask) + page_mask) & ~page_mask)
108 /* find the shared PE mapping for a given mapping */
109 static struct file
*get_shared_file( struct mapping
*mapping
)
113 for (ptr
= shared_first
; ptr
; ptr
= ptr
->shared_next
)
114 if (is_same_file( ptr
->file
, mapping
->file
))
115 return (struct file
*)grab_object( ptr
->shared_file
);
119 /* allocate and fill the temp file for a shared PE image mapping */
120 static int build_shared_mapping( struct mapping
*mapping
, int fd
,
121 IMAGE_SECTION_HEADER
*sec
, int nb_sec
)
123 int i
, max_size
, total_size
, pos
;
128 /* compute the total size of the shared mapping */
130 total_size
= max_size
= 0;
131 for (i
= 0; i
< nb_sec
; i
++)
133 if ((sec
[i
].Characteristics
& IMAGE_SCN_MEM_SHARED
) &&
134 (sec
[i
].Characteristics
& IMAGE_SCN_MEM_WRITE
))
136 int size
= ROUND_SIZE( 0, sec
[i
].Misc
.VirtualSize
);
137 if (size
> max_size
) max_size
= size
;
141 if (!(mapping
->shared_size
= total_size
)) return 1; /* nothing to do */
143 if ((mapping
->shared_file
= get_shared_file( mapping
))) return 1;
145 /* create a temp file for the mapping */
147 if (!(mapping
->shared_file
= create_temp_file( GENERIC_READ
|GENERIC_WRITE
))) return 0;
148 if (!grow_file( mapping
->shared_file
, 0, total_size
)) goto error
;
149 if ((shared_fd
= get_file_unix_fd( mapping
->shared_file
)) == -1) goto error
;
151 if (!(buffer
= malloc( max_size
))) goto error
;
153 /* copy the shared sections data into the temp file */
155 for (i
= pos
= 0; i
< nb_sec
; i
++)
157 if (!(sec
[i
].Characteristics
& IMAGE_SCN_MEM_SHARED
)) continue;
158 if (!(sec
[i
].Characteristics
& IMAGE_SCN_MEM_WRITE
)) continue;
159 if (lseek( shared_fd
, pos
, SEEK_SET
) != pos
) goto error
;
160 pos
+= ROUND_SIZE( 0, sec
[i
].Misc
.VirtualSize
);
161 if (sec
[i
].Characteristics
& IMAGE_SCN_CNT_UNINITIALIZED_DATA
) continue;
162 if (!sec
[i
].PointerToRawData
|| !sec
[i
].SizeOfRawData
) continue;
163 if (lseek( fd
, sec
[i
].PointerToRawData
, SEEK_SET
) != sec
[i
].PointerToRawData
) goto error
;
164 toread
= sec
[i
].SizeOfRawData
;
167 long res
= read( fd
, buffer
+ sec
[i
].SizeOfRawData
- toread
, toread
);
168 if (res
<= 0) goto error
;
171 if (write( shared_fd
, buffer
, sec
[i
].SizeOfRawData
) != sec
[i
].SizeOfRawData
) goto error
;
177 release_object( mapping
->shared_file
);
178 mapping
->shared_file
= NULL
;
179 if (buffer
) free( buffer
);
183 /* retrieve the mapping parameters for an executable (PE) image */
184 static int get_image_params( struct mapping
*mapping
)
186 IMAGE_DOS_HEADER dos
;
188 IMAGE_SECTION_HEADER
*sec
= NULL
;
190 int unix_fd
, filepos
, size
;
192 /* load the headers */
194 if (!(fd
= mapping_get_fd( &mapping
->obj
))) return 0;
195 unix_fd
= get_unix_fd( fd
);
196 filepos
= lseek( unix_fd
, 0, SEEK_SET
);
197 if (read( unix_fd
, &dos
, sizeof(dos
) ) != sizeof(dos
)) goto error
;
198 if (dos
.e_magic
!= IMAGE_DOS_SIGNATURE
) goto error
;
199 if (lseek( unix_fd
, dos
.e_lfanew
, SEEK_SET
) == -1) goto error
;
201 if (read( unix_fd
, &nt
.Signature
, sizeof(nt
.Signature
) ) != sizeof(nt
.Signature
)) goto error
;
202 if (nt
.Signature
!= IMAGE_NT_SIGNATURE
) goto error
;
203 if (read( unix_fd
, &nt
.FileHeader
, sizeof(nt
.FileHeader
) ) != sizeof(nt
.FileHeader
)) goto error
;
204 /* zero out Optional header in the case it's not present or partial */
205 memset(&nt
.OptionalHeader
, 0, sizeof(nt
.OptionalHeader
));
206 if (read( unix_fd
, &nt
.OptionalHeader
, nt
.FileHeader
.SizeOfOptionalHeader
) != nt
.FileHeader
.SizeOfOptionalHeader
) goto error
;
208 /* load the section headers */
210 size
= sizeof(*sec
) * nt
.FileHeader
.NumberOfSections
;
211 if (!(sec
= malloc( size
))) goto error
;
212 if (read( unix_fd
, sec
, size
) != size
) goto error
;
214 if (!build_shared_mapping( mapping
, unix_fd
, sec
, nt
.FileHeader
.NumberOfSections
)) goto error
;
216 if (mapping
->shared_file
) /* link it in the list */
218 if ((mapping
->shared_next
= shared_first
)) shared_first
->shared_prev
= mapping
;
219 mapping
->shared_prev
= NULL
;
220 shared_first
= mapping
;
223 mapping
->size_low
= ROUND_SIZE( 0, nt
.OptionalHeader
.SizeOfImage
);
224 mapping
->size_high
= 0;
225 mapping
->base
= (void *)nt
.OptionalHeader
.ImageBase
;
226 mapping
->header_size
= ROUND_SIZE( mapping
->base
, nt
.OptionalHeader
.SizeOfHeaders
);
227 mapping
->protect
= VPROT_IMAGE
;
230 if (mapping
->header_size
> mapping
->size_low
) goto error
;
232 lseek( unix_fd
, filepos
, SEEK_SET
);
234 release_object( fd
);
238 lseek( unix_fd
, filepos
, SEEK_SET
);
239 if (sec
) free( sec
);
240 release_object( fd
);
241 set_error( STATUS_INVALID_FILE_FOR_SECTION
);
245 /* get the size of the unix file associated with the mapping */
246 inline static int get_file_size( struct file
*file
, int *size_high
, int *size_low
)
249 int unix_fd
= get_file_unix_fd( file
);
251 if (fstat( unix_fd
, &st
) == -1) return 0;
252 *size_high
= st
.st_size
>> 32;
253 *size_low
= st
.st_size
& 0xffffffff;
257 static struct object
*create_mapping( int size_high
, int size_low
, int protect
,
258 obj_handle_t handle
, const WCHAR
*name
, size_t len
)
260 struct mapping
*mapping
;
263 if (!page_mask
) init_page_size();
265 if (!(mapping
= create_named_object( sync_namespace
, &mapping_ops
, name
, len
)))
267 if (get_error() == STATUS_OBJECT_NAME_COLLISION
)
268 return &mapping
->obj
; /* Nothing else to do */
270 mapping
->header_size
= 0;
271 mapping
->base
= NULL
;
272 mapping
->shared_file
= NULL
;
273 mapping
->shared_size
= 0;
275 if (protect
& VPROT_READ
) access
|= GENERIC_READ
;
276 if (protect
& VPROT_WRITE
) access
|= GENERIC_WRITE
;
280 if (!(mapping
->file
= get_file_obj( current
->process
, handle
, access
))) goto error
;
281 if (protect
& VPROT_IMAGE
)
283 if (!get_image_params( mapping
)) goto error
;
284 return &mapping
->obj
;
286 if (!size_high
&& !size_low
)
288 if (!get_file_size( mapping
->file
, &size_high
, &size_low
)) goto error
;
292 if (!grow_file( mapping
->file
, size_high
, size_low
)) goto error
;
295 else /* Anonymous mapping (no associated file) */
297 if ((!size_high
&& !size_low
) || (protect
& VPROT_IMAGE
))
299 set_error( STATUS_INVALID_PARAMETER
);
300 mapping
->file
= NULL
;
303 if (!(mapping
->file
= create_temp_file( access
))) goto error
;
304 if (!grow_file( mapping
->file
, size_high
, size_low
)) goto error
;
306 mapping
->size_high
= size_high
;
307 mapping
->size_low
= ROUND_SIZE( 0, size_low
);
308 mapping
->protect
= protect
;
309 return &mapping
->obj
;
312 release_object( mapping
);
316 static void mapping_dump( struct object
*obj
, int verbose
)
318 struct mapping
*mapping
= (struct mapping
*)obj
;
319 assert( obj
->ops
== &mapping_ops
);
320 fprintf( stderr
, "Mapping size=%08x%08x prot=%08x file=%p header_size=%08x base=%p "
321 "shared_file=%p shared_size=%08x ",
322 mapping
->size_high
, mapping
->size_low
, mapping
->protect
, mapping
->file
,
323 mapping
->header_size
, mapping
->base
, mapping
->shared_file
, mapping
->shared_size
);
324 dump_object_name( &mapping
->obj
);
325 fputc( '\n', stderr
);
328 static struct fd
*mapping_get_fd( struct object
*obj
)
330 struct mapping
*mapping
= (struct mapping
*)obj
;
331 return get_obj_fd( (struct object
*)mapping
->file
);
334 static void mapping_destroy( struct object
*obj
)
336 struct mapping
*mapping
= (struct mapping
*)obj
;
337 assert( obj
->ops
== &mapping_ops
);
338 if (mapping
->file
) release_object( mapping
->file
);
339 if (mapping
->shared_file
)
341 release_object( mapping
->shared_file
);
342 if (mapping
->shared_next
) mapping
->shared_next
->shared_prev
= mapping
->shared_prev
;
343 if (mapping
->shared_prev
) mapping
->shared_prev
->shared_next
= mapping
->shared_next
;
344 else shared_first
= mapping
->shared_next
;
348 int get_page_size(void)
350 if (!page_mask
) init_page_size();
351 return page_mask
+ 1;
354 /* create a file mapping */
355 DECL_HANDLER(create_mapping
)
360 if ((obj
= create_mapping( req
->size_high
, req
->size_low
,
361 req
->protect
, req
->file_handle
,
362 get_req_data(), get_req_data_size() )))
364 reply
->handle
= alloc_handle( current
->process
, obj
, req
->access
, req
->inherit
);
365 release_object( obj
);
369 /* open a handle to a mapping */
370 DECL_HANDLER(open_mapping
)
372 reply
->handle
= open_object( sync_namespace
, get_req_data(), get_req_data_size(),
373 &mapping_ops
, req
->access
, req
->inherit
);
376 /* get a mapping information */
377 DECL_HANDLER(get_mapping_info
)
379 struct mapping
*mapping
;
381 if ((mapping
= (struct mapping
*)get_handle_obj( current
->process
, req
->handle
,
384 reply
->size_high
= mapping
->size_high
;
385 reply
->size_low
= mapping
->size_low
;
386 reply
->protect
= mapping
->protect
;
387 reply
->header_size
= mapping
->header_size
;
388 reply
->base
= mapping
->base
;
389 reply
->shared_file
= 0;
390 reply
->shared_size
= mapping
->shared_size
;
391 reply
->drive_type
= get_file_drive_type( mapping
->file
);
392 if (mapping
->shared_file
)
393 reply
->shared_file
= alloc_handle( current
->process
, mapping
->shared_file
,
394 GENERIC_READ
|GENERIC_WRITE
, 0 );
395 release_object( mapping
);