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
) &&
162 !(sec
[i
].Characteristics
& IMAGE_SCN_CNT_INITIALIZED_DATA
)) continue;
163 if (!sec
[i
].PointerToRawData
|| !sec
[i
].SizeOfRawData
) continue;
164 if (lseek( fd
, sec
[i
].PointerToRawData
, SEEK_SET
) != sec
[i
].PointerToRawData
) goto error
;
165 toread
= sec
[i
].SizeOfRawData
;
168 long res
= read( fd
, buffer
+ sec
[i
].SizeOfRawData
- toread
, toread
);
169 if (res
<= 0) goto error
;
172 if (write( shared_fd
, buffer
, sec
[i
].SizeOfRawData
) != sec
[i
].SizeOfRawData
) goto error
;
178 release_object( mapping
->shared_file
);
179 mapping
->shared_file
= NULL
;
180 if (buffer
) free( buffer
);
184 /* retrieve the mapping parameters for an executable (PE) image */
185 static int get_image_params( struct mapping
*mapping
)
187 IMAGE_DOS_HEADER dos
;
189 IMAGE_SECTION_HEADER
*sec
= NULL
;
191 int unix_fd
, filepos
, size
;
193 /* load the headers */
195 if (!(fd
= mapping_get_fd( &mapping
->obj
))) return 0;
196 unix_fd
= get_unix_fd( fd
);
197 filepos
= lseek( unix_fd
, 0, SEEK_SET
);
198 if (read( unix_fd
, &dos
, sizeof(dos
) ) != sizeof(dos
)) goto error
;
199 if (dos
.e_magic
!= IMAGE_DOS_SIGNATURE
) goto error
;
200 if (lseek( unix_fd
, dos
.e_lfanew
, SEEK_SET
) == -1) goto error
;
202 if (read( unix_fd
, &nt
.Signature
, sizeof(nt
.Signature
) ) != sizeof(nt
.Signature
)) goto error
;
203 if (nt
.Signature
!= IMAGE_NT_SIGNATURE
) goto error
;
204 if (read( unix_fd
, &nt
.FileHeader
, sizeof(nt
.FileHeader
) ) != sizeof(nt
.FileHeader
)) goto error
;
205 /* zero out Optional header in the case it's not present or partial */
206 memset(&nt
.OptionalHeader
, 0, sizeof(nt
.OptionalHeader
));
207 if (read( unix_fd
, &nt
.OptionalHeader
, nt
.FileHeader
.SizeOfOptionalHeader
) != nt
.FileHeader
.SizeOfOptionalHeader
) goto error
;
209 /* load the section headers */
211 size
= sizeof(*sec
) * nt
.FileHeader
.NumberOfSections
;
212 if (!(sec
= malloc( size
))) goto error
;
213 if (read( unix_fd
, sec
, size
) != size
) goto error
;
215 if (!build_shared_mapping( mapping
, unix_fd
, sec
, nt
.FileHeader
.NumberOfSections
)) goto error
;
217 if (mapping
->shared_file
) /* link it in the list */
219 if ((mapping
->shared_next
= shared_first
)) shared_first
->shared_prev
= mapping
;
220 mapping
->shared_prev
= NULL
;
221 shared_first
= mapping
;
224 mapping
->size_low
= ROUND_SIZE( 0, nt
.OptionalHeader
.SizeOfImage
);
225 mapping
->size_high
= 0;
226 mapping
->base
= (void *)nt
.OptionalHeader
.ImageBase
;
227 mapping
->header_size
= ROUND_SIZE( mapping
->base
, nt
.OptionalHeader
.SizeOfHeaders
);
228 mapping
->protect
= VPROT_IMAGE
;
231 if (mapping
->header_size
> mapping
->size_low
) goto error
;
233 lseek( unix_fd
, filepos
, SEEK_SET
);
235 release_object( fd
);
239 lseek( unix_fd
, filepos
, SEEK_SET
);
240 if (sec
) free( sec
);
241 release_object( fd
);
242 set_error( STATUS_INVALID_FILE_FOR_SECTION
);
246 /* get the size of the unix file associated with the mapping */
247 inline static int get_file_size( struct file
*file
, int *size_high
, int *size_low
)
250 int unix_fd
= get_file_unix_fd( file
);
252 if (fstat( unix_fd
, &st
) == -1) return 0;
253 *size_high
= st
.st_size
>> 32;
254 *size_low
= st
.st_size
& 0xffffffff;
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( sync_namespace
, &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
)
289 if (!get_file_size( mapping
->file
, &size_high
, &size_low
)) goto error
;
293 if (!grow_file( mapping
->file
, size_high
, size_low
)) goto error
;
296 else /* Anonymous mapping (no associated file) */
298 if ((!size_high
&& !size_low
) || (protect
& VPROT_IMAGE
))
300 set_error( STATUS_INVALID_PARAMETER
);
301 mapping
->file
= NULL
;
304 if (!(mapping
->file
= create_temp_file( access
))) goto error
;
305 if (!grow_file( mapping
->file
, size_high
, size_low
)) goto error
;
307 mapping
->size_high
= size_high
;
308 mapping
->size_low
= ROUND_SIZE( 0, size_low
);
309 mapping
->protect
= protect
;
310 return &mapping
->obj
;
313 release_object( mapping
);
317 static void mapping_dump( struct object
*obj
, int verbose
)
319 struct mapping
*mapping
= (struct mapping
*)obj
;
320 assert( obj
->ops
== &mapping_ops
);
321 fprintf( stderr
, "Mapping size=%08x%08x prot=%08x file=%p header_size=%08x base=%p "
322 "shared_file=%p shared_size=%08x ",
323 mapping
->size_high
, mapping
->size_low
, mapping
->protect
, mapping
->file
,
324 mapping
->header_size
, mapping
->base
, mapping
->shared_file
, mapping
->shared_size
);
325 dump_object_name( &mapping
->obj
);
326 fputc( '\n', stderr
);
329 static struct fd
*mapping_get_fd( struct object
*obj
)
331 struct mapping
*mapping
= (struct mapping
*)obj
;
332 return get_obj_fd( (struct object
*)mapping
->file
);
335 static void mapping_destroy( struct object
*obj
)
337 struct mapping
*mapping
= (struct mapping
*)obj
;
338 assert( obj
->ops
== &mapping_ops
);
339 if (mapping
->file
) release_object( mapping
->file
);
340 if (mapping
->shared_file
)
342 release_object( mapping
->shared_file
);
343 if (mapping
->shared_next
) mapping
->shared_next
->shared_prev
= mapping
->shared_prev
;
344 if (mapping
->shared_prev
) mapping
->shared_prev
->shared_next
= mapping
->shared_next
;
345 else shared_first
= mapping
->shared_next
;
349 int get_page_size(void)
351 if (!page_mask
) init_page_size();
352 return page_mask
+ 1;
355 /* create a file mapping */
356 DECL_HANDLER(create_mapping
)
361 if ((obj
= create_mapping( req
->size_high
, req
->size_low
,
362 req
->protect
, req
->file_handle
,
363 get_req_data(), get_req_data_size() )))
365 reply
->handle
= alloc_handle( current
->process
, obj
, req
->access
, req
->inherit
);
366 release_object( obj
);
370 /* open a handle to a mapping */
371 DECL_HANDLER(open_mapping
)
373 reply
->handle
= open_object( sync_namespace
, get_req_data(), get_req_data_size(),
374 &mapping_ops
, req
->access
, req
->inherit
);
377 /* get a mapping information */
378 DECL_HANDLER(get_mapping_info
)
380 struct mapping
*mapping
;
382 if ((mapping
= (struct mapping
*)get_handle_obj( current
->process
, req
->handle
,
385 reply
->size_high
= mapping
->size_high
;
386 reply
->size_low
= mapping
->size_low
;
387 reply
->protect
= mapping
->protect
;
388 reply
->header_size
= mapping
->header_size
;
389 reply
->base
= mapping
->base
;
390 reply
->shared_file
= 0;
391 reply
->shared_size
= mapping
->shared_size
;
392 reply
->drive_type
= get_file_drive_type( mapping
->file
);
393 if (mapping
->shared_file
)
394 reply
->shared_file
= alloc_handle( current
->process
, mapping
->shared_file
,
395 GENERIC_READ
|GENERIC_WRITE
, 0 );
396 release_object( mapping
);