1 /*
2 * $Id: text_mmap.c,v 4.15 2006/11/27 01:52:23 bkorb Exp $
3 *
4 * Time-stamp: "2006-09-10 14:50:04 bkorb"
5 */
6
7 #ifndef MAP_ANONYMOUS
8 # ifdef MAP_ANON
9 # define MAP_ANONYMOUS MAP_ANON
10 # endif
11 #endif
12
13 /*
14 * Some weird systems require that a specifically invalid FD number
15 * get passed in as an argument value. Which value is that? Well,
16 * as everybody knows, if open(2) fails, it returns -1, so that must
17 * be the value. :)
18 */
19 #define AO_INVALID_FD -1
20
21 #define FILE_WRITABLE(_prt,_flg) \
22 ( (_prt & PROT_WRITE) \
23 && ((_flg & (MAP_SHARED|MAP_PRIVATE)) == MAP_SHARED))
24 #define MAP_FAILED_PTR ((void*)MAP_FAILED)
25
26 /*=export_func text_mmap
27 * private:
28 *
29 * what: map a text file with terminating NUL
30 *
31 * arg: char const*, pzFile, name of the file to map
32 * arg: int, prot, mmap protections (see mmap(2))
33 * arg: int, flags, mmap flags (see mmap(2))
34 * arg: tmap_info_t*, mapinfo, returned info about the mapping
35 *
36 * ret-type: void*
37 * ret-desc: The mmaped data address
38 *
39 * doc:
40 *
41 * This routine will mmap a file into memory ensuring that there is at least
42 * one @file{NUL} character following the file data. It will return the
43 * address where the file contents have been mapped into memory. If there is a
44 * problem, then it will return @code{MAP_FAILED} and set @file{errno}
45 * appropriately.
46 *
47 * The named file does not exist, @code{stat(2)} will set @file{errno} as it
48 * will. If the file is not a regular file, @file{errno} will be
49 * @code{EINVAL}. At that point, @code{open(2)} is attempted with the access
50 * bits set appropriately for the requested @code{mmap(2)} protections and flag
51 * bits. On failure, @file{errno} will be set according to the documentation
52 * for @code{open(2)}. If @code{mmap(2)} fails, @file{errno} will be set as
53 * that routine sets it. If @code{text_mmap} works to this point, a valid
54 * address will be returned, but there may still be ``issues''.
55 *
56 * If the file size is not an even multiple of the system page size, then
57 * @code{text_map} will return at this point and @file{errno} will be zero.
58 * Otherwise, an anonymous map is attempted. If not available, then an attempt
59 * is made to @code{mmap(2)} @file{/dev/zero}. If any of these fail, the
60 * address of the file's data is returned, bug @code{no} @file{NUL} characters
61 * are mapped after the end of the data.
62 *
63 * see: mmap(2), open(2), stat(2)
64 *
65 * err: Any error code issued by mmap(2), open(2), stat(2) is possible.
66 * Additionally, if the specified file is not a regular file, then
67 * errno will be set to @code{EINVAL}.
68 *
69 * example:
70 * #include <mylib.h>
71 * tmap_info_t mi;
72 * int no_nul;
73 * void* data = text_mmap( "file", PROT_WRITE, MAP_PRIVATE, &mi );
74 * if (data == MAP_FAILED) return;
75 * no_nul = (mi.txt_size == mi.txt_full_size);
76 * << use the data >>
77 * text_munmap( &mi );
78 =*/
79 void*
text_mmap(char const * pzFile,int prot,int flags,tmap_info_t * pMI)80 text_mmap( char const* pzFile, int prot, int flags, tmap_info_t* pMI )
81 {
82 memset( pMI, 0, sizeof(*pMI) );
83 #ifdef HAVE_MMAP
84 pMI->txt_zero_fd = -1;
85 #endif
86 pMI->txt_fd = -1;
87
88 /*
89 * Make sure we can stat the regular file. Save the file size.
90 */
91 {
92 struct stat sb;
93 if (stat( pzFile, &sb ) != 0) {
94 pMI->txt_errno = errno;
95 return MAP_FAILED_PTR;
96 }
97
98 if (! S_ISREG( sb.st_mode )) {
99 pMI->txt_errno = errno = EINVAL;
100 return MAP_FAILED_PTR;
101 }
102
103 pMI->txt_size = sb.st_size;
104 }
105
106 /*
107 * Map mmap flags and protections into open flags and do the open.
108 */
109 {
110 int o_flag;
111 /*
112 * See if we will be updating the file. If we can alter the memory
113 * and if we share the data and we are *not* copy-on-writing the data,
114 * then our updates will show in the file, so we must open with
115 * write access.
116 */
117 if (FILE_WRITABLE(prot,flags))
118 o_flag = O_RDWR;
119 else
120 o_flag = O_RDONLY;
121
122 /*
123 * If you're not sharing the file and you are writing to it,
124 * then don't let anyone else have access to the file.
125 */
126 if (((flags & MAP_SHARED) == 0) && (prot & PROT_WRITE))
127 o_flag |= O_EXCL;
128
129 pMI->txt_fd = open( pzFile, o_flag );
130 }
131
132 if (pMI->txt_fd == AO_INVALID_FD) {
133 pMI->txt_errno = errno;
134 return MAP_FAILED_PTR;
135 }
136
137 #ifdef HAVE_MMAP /* * * * * WITH MMAP * * * * * */
138 /*
139 * do the mmap. If we fail, then preserve errno, close the file and
140 * return the failure.
141 */
142 pMI->txt_data =
143 mmap(NULL, pMI->txt_size+1, prot, flags, pMI->txt_fd, (size_t)0);
144 if (pMI->txt_data == MAP_FAILED_PTR) {
145 pMI->txt_errno = errno;
146 goto fail_return;
147 }
148
149 /*
150 * Most likely, everything will turn out fine now. The only difficult
151 * part at this point is coping with files with sizes that are a multiple
152 * of the page size. Handling that is what this whole thing is about.
153 */
154 pMI->txt_zero_fd = -1;
155 pMI->txt_errno = 0;
156
157 {
158 void* pNuls;
159 #ifdef _SC_PAGESIZE
160 size_t pgsz = sysconf(_SC_PAGESIZE);
161 #else
162 size_t pgsz = getpagesize();
163 #endif
164 /*
165 * Compute the pagesize rounded mapped memory size.
166 * IF this is not the same as the file size, then there are NUL's
167 * at the end of the file mapping and all is okay.
168 */
169 pMI->txt_full_size = (pMI->txt_size + (pgsz - 1)) & ~(pgsz - 1);
170 if (pMI->txt_size != pMI->txt_full_size)
171 return pMI->txt_data;
172
173 /*
174 * Still here? We have to remap the trailing inaccessible page
175 * either anonymously or to /dev/zero.
176 */
177 pMI->txt_full_size += pgsz;
178 #if defined(MAP_ANONYMOUS)
179 pNuls = mmap(
180 (void*)(((char*)pMI->txt_data) + pMI->txt_size),
181 pgsz, PROT_READ|PROT_WRITE,
182 MAP_ANONYMOUS|MAP_FIXED|MAP_PRIVATE, AO_INVALID_FD, (size_t)0);
183
184 if (pNuls != MAP_FAILED_PTR)
185 return pMI->txt_data;
186
187 pMI->txt_errno = errno;
188
189 #elif defined(HAVE_DEV_ZERO)
190 pMI->txt_zero_fd = open( "/dev/zero", O_RDONLY );
191
192 if (pMI->txt_zero_fd == AO_INVALID_FD) {
193 pMI->txt_errno = errno;
194
195 } else {
196 pNuls = mmap(
197 (void*)(((char*)pMI->txt_data) + pMI->txt_size), pgsz,
198 PROT_READ|PROT_WRITE, MAP_PRIVATE|MAP_FIXED,
199 pMI->txt_zero_fd, 0 );
200
201 if (pNuls != MAP_FAILED_PTR)
202 return pMI->txt_data;
203
204 pMI->txt_errno = errno;
205 close( pMI->txt_zero_fd );
206 pMI->txt_zero_fd = -1;
207 }
208 #endif
209
210 pMI->txt_full_size = pMI->txt_size;
211 }
212
213 {
214 void* p = AGALOC( pMI->txt_size+1, "file text" );
215 memcpy( p, pMI->txt_data, pMI->txt_size );
216 ((char*)p)[pMI->txt_size] = NUL;
217 munmap(pMI->txt_data, pMI->txt_size );
218 pMI->txt_data = p;
219 }
220 pMI->txt_alloc = 1;
221 return pMI->txt_data;
222
223 #else /* * * * * * no HAVE_MMAP * * * * * */
224
225 pMI->txt_data = AGALOC( pMI->txt_size+1, "file text" );
226 if (pMI->txt_data == NULL) {
227 pMI->txt_errno = ENOMEM;
228 goto fail_return;
229 }
230
231 {
232 size_t sz = pMI->txt_size;
233 char* pz = pMI->txt_data;
234
235 while (sz > 0) {
236 ssize_t rdct = read( pMI->txt_fd, pz, sz );
237 if (rdct <= 0) {
238 pMI->txt_errno = errno;
239 fprintf( stderr, zFSErrReadFile,
240 errno, strerror( errno ), pzFile );
241 free( pMI->txt_data );
242 goto fail_return;
243 }
244
245 pz += rdct;
246 sz -= rdct;
247 }
248
249 *pz = NUL;
250 }
251
252 /*
253 * We never need a dummy page mapped in
254 */
255 pMI->txt_zero_fd = -1;
256 pMI->txt_errno = 0;
257
258 return pMI->txt_data;
259
260 #endif /* * * * * * no HAVE_MMAP * * * * * */
261
262 fail_return:
263 if (pMI->txt_fd >= 0) {
264 close( pMI->txt_fd );
265 pMI->txt_fd = -1;
266 }
267 errno = pMI->txt_errno;
268 pMI->txt_data = MAP_FAILED_PTR;
269 return pMI->txt_data;
270 }
271
272
273 /*=export_func text_munmap
274 * private:
275 *
276 * what: unmap the data mapped in by text_mmap
277 *
278 * arg: tmap_info_t*, mapinfo, info about the mapping
279 *
280 * ret-type: int
281 * ret-desc: -1 or 0. @file{errno} will have the error code.
282 *
283 * doc:
284 *
285 * This routine will unmap the data mapped in with @code{text_mmap} and close
286 * the associated file descriptors opened by that function.
287 *
288 * see: munmap(2), close(2)
289 *
290 * err: Any error code issued by munmap(2) or close(2) is possible.
291 =*/
292 int
text_munmap(tmap_info_t * pMI)293 text_munmap( tmap_info_t* pMI )
294 {
295 #ifdef HAVE_MMAP
296 int res = 0;
297 if (pMI->txt_alloc) {
298 /*
299 * IF the user has write permission and the text is not mapped private,
300 * then write back any changes. Hopefully, nobody else has modified
301 * the file in the mean time.
302 */
303 if ( ((pMI->txt_prot & PROT_WRITE) != 0)
304 && ((pMI->txt_flags & MAP_PRIVATE) == 0)) {
305
306 if (lseek(pMI->txt_fd, (size_t)0, SEEK_SET) != 0)
307 goto error_return;
308
309 res = (write( pMI->txt_fd, pMI->txt_data, pMI->txt_size ) < 0)
310 ? errno : 0;
311 }
312
313 AGFREE( pMI->txt_data );
314 errno = res;
315 } else {
316 res = munmap( pMI->txt_data, pMI->txt_full_size );
317 }
318 if (res != 0)
319 goto error_return;
320
321 res = close( pMI->txt_fd );
322 if (res != 0)
323 goto error_return;
324
325 pMI->txt_fd = -1;
326 errno = 0;
327 if (pMI->txt_zero_fd != -1) {
328 res = close( pMI->txt_zero_fd );
329 pMI->txt_zero_fd = -1;
330 }
331
332 error_return:
333 pMI->txt_errno = errno;
334 return res;
335 #else /* HAVE_MMAP */
336
337 errno = 0;
338 /*
339 * IF the memory is writable *AND* it is not private (copy-on-write)
340 * *AND* the memory is "sharable" (seen by other processes)
341 * THEN rewrite the data.
342 */
343 if ( FILE_WRITABLE(pMI->txt_prot, pMI->txt_flags)
344 && (lseek( pMI->txt_fd, 0, SEEK_SET ) >= 0) ) {
345 write( pMI->txt_fd, pMI->txt_data, pMI->txt_size );
346 }
347
348 close( pMI->txt_fd );
349 pMI->txt_fd = -1;
350 pMI->txt_errno = errno;
351 free( pMI->txt_data );
352
353 return pMI->txt_errno;
354 #endif /* HAVE_MMAP */
355 }
356
357 /*
358 * Local Variables:
359 * mode: C
360 * c-file-style: "stroustrup"
361 * indent-tabs-mode: nil
362 * End:
363 * end of autoopts/text_mmap.c */
364