← Back to branch summary

~vcs-imports/qemu/git

« back to all changes in this revision

Viewing changes to bsd-user/mmap.c

  • Committer: pbrook
  • Date: 2007-03-06 23:52:01 UTC
  • Revision ID: git-v1:1c7b3754f68382941a1921e578ead25d97d116fb
Simple u-boot image loading support.


git-svn-id: svn://svn.savannah.nongnu.org/qemu/trunk@2472 c046a42c-6fe2-441c-8c8c-71466251a162

Show diffs side-by-side

added added

removed removed

Lines of Context:
bsd-user/mmap.c
1
 
/*
2
 
 *  mmap support for qemu
3
 
 *
4
 
 *  Copyright (c) 2003 - 2008 Fabrice Bellard
5
 
 *
6
 
 *  This program is free software; you can redistribute it and/or modify
7
 
 *  it under the terms of the GNU General Public License as published by
8
 
 *  the Free Software Foundation; either version 2 of the License, or
9
 
 *  (at your option) any later version.
10
 
 *
11
 
 *  This program 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
14
 
 *  GNU General Public License for more details.
15
 
 *
16
 
 *  You should have received a copy of the GNU General Public License
17
 
 *  along with this program; if not, write to the Free Software
18
 
 *  Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
19
 
 */
20
 
#include <stdlib.h>
21
 
#include <stdio.h>
22
 
#include <stdarg.h>
23
 
#include <string.h>
24
 
#include <unistd.h>
25
 
#include <errno.h>
26
 
#include <sys/mman.h>
27
 
 
28
 
#include "qemu.h"
29
 
#include "qemu-common.h"
30
 
 
31
 
//#define DEBUG_MMAP
32
 
 
33
 
#if defined(USE_NPTL)
34
 
pthread_mutex_t mmap_mutex;
35
 
static int __thread mmap_lock_count;
36
 
 
37
 
void mmap_lock(void)
38
 
{
39
 
    if (mmap_lock_count++ == 0) {
40
 
        pthread_mutex_lock(&mmap_mutex);
41
 
    }
42
 
}
43
 
 
44
 
void mmap_unlock(void)
45
 
{
46
 
    if (--mmap_lock_count == 0) {
47
 
        pthread_mutex_unlock(&mmap_mutex);
48
 
    }
49
 
}
50
 
 
51
 
/* Grab lock to make sure things are in a consistent state after fork().  */
52
 
void mmap_fork_start(void)
53
 
{
54
 
    if (mmap_lock_count)
55
 
        abort();
56
 
    pthread_mutex_lock(&mmap_mutex);
57
 
}
58
 
 
59
 
void mmap_fork_end(int child)
60
 
{
61
 
    if (child)
62
 
        pthread_mutex_init(&mmap_mutex, NULL);
63
 
    else
64
 
        pthread_mutex_unlock(&mmap_mutex);
65
 
}
66
 
#else
67
 
/* We aren't threadsafe to start with, so no need to worry about locking.  */
68
 
void mmap_lock(void)
69
 
{
70
 
}
71
 
 
72
 
void mmap_unlock(void)
73
 
{
74
 
}
75
 
#endif
76
 
 
77
 
void *qemu_vmalloc(size_t size)
78
 
{
79
 
    void *p;
80
 
    unsigned long addr;
81
 
    mmap_lock();
82
 
    /* Use map and mark the pages as used.  */
83
 
    p = mmap(NULL, size, PROT_READ | PROT_WRITE,
84
 
             MAP_PRIVATE | MAP_ANON, -1, 0);
85
 
 
86
 
    addr = (unsigned long)p;
87
 
    if (addr == (target_ulong) addr) {
88
 
        /* Allocated region overlaps guest address space.
89
 
           This may recurse.  */
90
 
        page_set_flags(addr & TARGET_PAGE_MASK, TARGET_PAGE_ALIGN(addr + size),
91
 
                       PAGE_RESERVED);
92
 
    }
93
 
 
94
 
    mmap_unlock();
95
 
    return p;
96
 
}
97
 
 
98
 
void *qemu_malloc(size_t size)
99
 
{
100
 
    char * p;
101
 
    size += 16;
102
 
    p = qemu_vmalloc(size);
103
 
    *(size_t *)p = size;
104
 
    return p + 16;
105
 
}
106
 
 
107
 
/* We use map, which is always zero initialized.  */
108
 
void * qemu_mallocz(size_t size)
109
 
{
110
 
    return qemu_malloc(size);
111
 
}
112
 
 
113
 
void qemu_free(void *ptr)
114
 
{
115
 
    /* FIXME: We should unmark the reserved pages here.  However this gets
116
 
       complicated when one target page spans multiple host pages, so we
117
 
       don't bother.  */
118
 
    size_t *p;
119
 
    p = (size_t *)((char *)ptr - 16);
120
 
    munmap(p, *p);
121
 
}
122
 
 
123
 
/* NOTE: all the constants are the HOST ones, but addresses are target. */
124
 
int target_mprotect(abi_ulong start, abi_ulong len, int prot)
125
 
{
126
 
    abi_ulong end, host_start, host_end, addr;
127
 
    int prot1, ret;
128
 
 
129
 
#ifdef DEBUG_MMAP
130
 
    printf("mprotect: start=0x" TARGET_FMT_lx
131
 
           " len=0x" TARGET_FMT_lx " prot=%c%c%c\n", start, len,
132
 
           prot & PROT_READ ? 'r' : '-',
133
 
           prot & PROT_WRITE ? 'w' : '-',
134
 
           prot & PROT_EXEC ? 'x' : '-');
135
 
#endif
136
 
 
137
 
    if ((start & ~TARGET_PAGE_MASK) != 0)
138
 
        return -EINVAL;
139
 
    len = TARGET_PAGE_ALIGN(len);
140
 
    end = start + len;
141
 
    if (end < start)
142
 
        return -EINVAL;
143
 
    prot &= PROT_READ | PROT_WRITE | PROT_EXEC;
144
 
    if (len == 0)
145
 
        return 0;
146
 
 
147
 
    mmap_lock();
148
 
    host_start = start & qemu_host_page_mask;
149
 
    host_end = HOST_PAGE_ALIGN(end);
150
 
    if (start > host_start) {
151
 
        /* handle host page containing start */
152
 
        prot1 = prot;
153
 
        for(addr = host_start; addr < start; addr += TARGET_PAGE_SIZE) {
154
 
            prot1 |= page_get_flags(addr);
155
 
        }
156
 
        if (host_end == host_start + qemu_host_page_size) {
157
 
            for(addr = end; addr < host_end; addr += TARGET_PAGE_SIZE) {
158
 
                prot1 |= page_get_flags(addr);
159
 
            }
160
 
            end = host_end;
161
 
        }
162
 
        ret = mprotect(g2h(host_start), qemu_host_page_size, prot1 & PAGE_BITS);
163
 
        if (ret != 0)
164
 
            goto error;
165
 
        host_start += qemu_host_page_size;
166
 
    }
167
 
    if (end < host_end) {
168
 
        prot1 = prot;
169
 
        for(addr = end; addr < host_end; addr += TARGET_PAGE_SIZE) {
170
 
            prot1 |= page_get_flags(addr);
171
 
        }
172
 
        ret = mprotect(g2h(host_end - qemu_host_page_size), qemu_host_page_size,
173
 
                       prot1 & PAGE_BITS);
174
 
        if (ret != 0)
175
 
            goto error;
176
 
        host_end -= qemu_host_page_size;
177
 
    }
178
 
 
179
 
    /* handle the pages in the middle */
180
 
    if (host_start < host_end) {
181
 
        ret = mprotect(g2h(host_start), host_end - host_start, prot);
182
 
        if (ret != 0)
183
 
            goto error;
184
 
    }
185
 
    page_set_flags(start, start + len, prot | PAGE_VALID);
186
 
    mmap_unlock();
187
 
    return 0;
188
 
error:
189
 
    mmap_unlock();
190
 
    return ret;
191
 
}
192
 
 
193
 
/* map an incomplete host page */
194
 
static int mmap_frag(abi_ulong real_start,
195
 
                     abi_ulong start, abi_ulong end,
196
 
                     int prot, int flags, int fd, abi_ulong offset)
197
 
{
198
 
    abi_ulong real_end, addr;
199
 
    void *host_start;
200
 
    int prot1, prot_new;
201
 
 
202
 
    real_end = real_start + qemu_host_page_size;
203
 
    host_start = g2h(real_start);
204
 
 
205
 
    /* get the protection of the target pages outside the mapping */
206
 
    prot1 = 0;
207
 
    for(addr = real_start; addr < real_end; addr++) {
208
 
        if (addr < start || addr >= end)
209
 
            prot1 |= page_get_flags(addr);
210
 
    }
211
 
 
212
 
    if (prot1 == 0) {
213
 
        /* no page was there, so we allocate one */
214
 
        void *p = mmap(host_start, qemu_host_page_size, prot,
215
 
                       flags | MAP_ANON, -1, 0);
216
 
        if (p == MAP_FAILED)
217
 
            return -1;
218
 
        prot1 = prot;
219
 
    }
220
 
    prot1 &= PAGE_BITS;
221
 
 
222
 
    prot_new = prot | prot1;
223
 
    if (!(flags & MAP_ANON)) {
224
 
        /* msync() won't work here, so we return an error if write is
225
 
           possible while it is a shared mapping */
226
 
        if ((flags & MAP_FLAGMASK) == MAP_SHARED &&
227
 
            (prot & PROT_WRITE))
228
 
            return -EINVAL;
229
 
 
230
 
        /* adjust protection to be able to read */
231
 
        if (!(prot1 & PROT_WRITE))
232
 
            mprotect(host_start, qemu_host_page_size, prot1 | PROT_WRITE);
233
 
 
234
 
        /* read the corresponding file data */
235
 
        pread(fd, g2h(start), end - start, offset);
236
 
 
237
 
        /* put final protection */
238
 
        if (prot_new != (prot1 | PROT_WRITE))
239
 
            mprotect(host_start, qemu_host_page_size, prot_new);
240
 
    } else {
241
 
        /* just update the protection */
242
 
        if (prot_new != prot1) {
243
 
            mprotect(host_start, qemu_host_page_size, prot_new);
244
 
        }
245
 
    }
246
 
    return 0;
247
 
}
248
 
 
249
 
#if defined(__CYGWIN__)
250
 
/* Cygwin doesn't have a whole lot of address space.  */
251
 
static abi_ulong mmap_next_start = 0x18000000;
252
 
#else
253
 
static abi_ulong mmap_next_start = 0x40000000;
254
 
#endif
255
 
 
256
 
unsigned long last_brk;
257
 
 
258
 
/* find a free memory area of size 'size'. The search starts at
259
 
   'start'. If 'start' == 0, then a default start address is used.
260
 
   Return -1 if error.
261
 
*/
262
 
/* page_init() marks pages used by the host as reserved to be sure not
263
 
   to use them. */
264
 
static abi_ulong mmap_find_vma(abi_ulong start, abi_ulong size)
265
 
{
266
 
    abi_ulong addr, addr1, addr_start;
267
 
    int prot;
268
 
    unsigned long new_brk;
269
 
 
270
 
    new_brk = (unsigned long)sbrk(0);
271
 
    if (last_brk && last_brk < new_brk && last_brk == (target_ulong)last_brk) {
272
 
        /* This is a hack to catch the host allocating memory with brk().
273
 
           If it uses mmap then we loose.
274
 
           FIXME: We really want to avoid the host allocating memory in
275
 
           the first place, and maybe leave some slack to avoid switching
276
 
           to mmap.  */
277
 
        page_set_flags(last_brk & TARGET_PAGE_MASK,
278
 
                       TARGET_PAGE_ALIGN(new_brk),
279
 
                       PAGE_RESERVED);
280
 
    }
281
 
    last_brk = new_brk;
282
 
 
283
 
    size = HOST_PAGE_ALIGN(size);
284
 
    start = start & qemu_host_page_mask;
285
 
    addr = start;
286
 
    if (addr == 0)
287
 
        addr = mmap_next_start;
288
 
    addr_start = addr;
289
 
    for(;;) {
290
 
        prot = 0;
291
 
        for(addr1 = addr; addr1 < (addr + size); addr1 += TARGET_PAGE_SIZE) {
292
 
            prot |= page_get_flags(addr1);
293
 
        }
294
 
        if (prot == 0)
295
 
            break;
296
 
        addr += qemu_host_page_size;
297
 
        /* we found nothing */
298
 
        if (addr == addr_start)
299
 
            return (abi_ulong)-1;
300
 
    }
301
 
    if (start == 0)
302
 
        mmap_next_start = addr + size;
303
 
    return addr;
304
 
}
305
 
 
306
 
/* NOTE: all the constants are the HOST ones */
307
 
abi_long target_mmap(abi_ulong start, abi_ulong len, int prot,
308
 
                     int flags, int fd, abi_ulong offset)
309
 
{
310
 
    abi_ulong ret, end, real_start, real_end, retaddr, host_offset, host_len;
311
 
    unsigned long host_start;
312
 
 
313
 
    mmap_lock();
314
 
#ifdef DEBUG_MMAP
315
 
    {
316
 
        printf("mmap: start=0x" TARGET_FMT_lx
317
 
               " len=0x" TARGET_FMT_lx " prot=%c%c%c flags=",
318
 
               start, len,
319
 
               prot & PROT_READ ? 'r' : '-',
320
 
               prot & PROT_WRITE ? 'w' : '-',
321
 
               prot & PROT_EXEC ? 'x' : '-');
322
 
        if (flags & MAP_FIXED)
323
 
            printf("MAP_FIXED ");
324
 
        if (flags & MAP_ANON)
325
 
            printf("MAP_ANON ");
326
 
        switch(flags & MAP_FLAGMASK) {
327
 
        case MAP_PRIVATE:
328
 
            printf("MAP_PRIVATE ");
329
 
            break;
330
 
        case MAP_SHARED:
331
 
            printf("MAP_SHARED ");
332
 
            break;
333
 
        default:
334
 
            printf("[MAP_FLAGMASK=0x%x] ", flags & MAP_FLAGMASK);
335
 
            break;
336
 
        }
337
 
        printf("fd=%d offset=" TARGET_FMT_lx "\n", fd, offset);
338
 
    }
339
 
#endif
340
 
 
341
 
    if (offset & ~TARGET_PAGE_MASK) {
342
 
        errno = EINVAL;
343
 
        goto fail;
344
 
    }
345
 
 
346
 
    len = TARGET_PAGE_ALIGN(len);
347
 
    if (len == 0)
348
 
        goto the_end;
349
 
    real_start = start & qemu_host_page_mask;
350
 
 
351
 
    if (!(flags & MAP_FIXED)) {
352
 
        abi_ulong mmap_start;
353
 
        void *p;
354
 
        host_offset = offset & qemu_host_page_mask;
355
 
        host_len = len + offset - host_offset;
356
 
        host_len = HOST_PAGE_ALIGN(host_len);
357
 
        mmap_start = mmap_find_vma(real_start, host_len);
358
 
        if (mmap_start == (abi_ulong)-1) {
359
 
            errno = ENOMEM;
360
 
            goto fail;
361
 
        }
362
 
        /* Note: we prefer to control the mapping address. It is
363
 
           especially important if qemu_host_page_size >
364
 
           qemu_real_host_page_size */
365
 
        p = mmap(g2h(mmap_start),
366
 
                 host_len, prot, flags | MAP_FIXED, fd, host_offset);
367
 
        if (p == MAP_FAILED)
368
 
            goto fail;
369
 
        /* update start so that it points to the file position at 'offset' */
370
 
        host_start = (unsigned long)p;
371
 
        if (!(flags & MAP_ANON))
372
 
            host_start += offset - host_offset;
373
 
        start = h2g(host_start);
374
 
    } else {
375
 
        int flg;
376
 
        target_ulong addr;
377
 
 
378
 
        if (start & ~TARGET_PAGE_MASK) {
379
 
            errno = EINVAL;
380
 
            goto fail;
381
 
        }
382
 
        end = start + len;
383
 
        real_end = HOST_PAGE_ALIGN(end);
384
 
 
385
 
        for(addr = real_start; addr < real_end; addr += TARGET_PAGE_SIZE) {
386
 
            flg = page_get_flags(addr);
387
 
            if (flg & PAGE_RESERVED) {
388
 
                errno = ENXIO;
389
 
                goto fail;
390
 
            }
391
 
        }
392
 
 
393
 
        /* worst case: we cannot map the file because the offset is not
394
 
           aligned, so we read it */
395
 
        if (!(flags & MAP_ANON) &&
396
 
            (offset & ~qemu_host_page_mask) != (start & ~qemu_host_page_mask)) {
397
 
            /* msync() won't work here, so we return an error if write is
398
 
               possible while it is a shared mapping */
399
 
            if ((flags & MAP_FLAGMASK) == MAP_SHARED &&
400
 
                (prot & PROT_WRITE)) {
401
 
                errno = EINVAL;
402
 
                goto fail;
403
 
            }
404
 
            retaddr = target_mmap(start, len, prot | PROT_WRITE,
405
 
                                  MAP_FIXED | MAP_PRIVATE | MAP_ANON,
406
 
                                  -1, 0);
407
 
            if (retaddr == -1)
408
 
                goto fail;
409
 
            pread(fd, g2h(start), len, offset);
410
 
            if (!(prot & PROT_WRITE)) {
411
 
                ret = target_mprotect(start, len, prot);
412
 
                if (ret != 0) {
413
 
                    start = ret;
414
 
                    goto the_end;
415
 
                }
416
 
            }
417
 
            goto the_end;
418
 
        }
419
 
 
420
 
        /* handle the start of the mapping */
421
 
        if (start > real_start) {
422
 
            if (real_end == real_start + qemu_host_page_size) {
423
 
                /* one single host page */
424
 
                ret = mmap_frag(real_start, start, end,
425
 
                                prot, flags, fd, offset);
426
 
                if (ret == -1)
427
 
                    goto fail;
428
 
                goto the_end1;
429
 
            }
430
 
            ret = mmap_frag(real_start, start, real_start + qemu_host_page_size,
431
 
                            prot, flags, fd, offset);
432
 
            if (ret == -1)
433
 
                goto fail;
434
 
            real_start += qemu_host_page_size;
435
 
        }
436
 
        /* handle the end of the mapping */
437
 
        if (end < real_end) {
438
 
            ret = mmap_frag(real_end - qemu_host_page_size,
439
 
                            real_end - qemu_host_page_size, real_end,
440
 
                            prot, flags, fd,
441
 
                            offset + real_end - qemu_host_page_size - start);
442
 
            if (ret == -1)
443
 
                goto fail;
444
 
            real_end -= qemu_host_page_size;
445
 
        }
446
 
 
447
 
        /* map the middle (easier) */
448
 
        if (real_start < real_end) {
449
 
            void *p;
450
 
            unsigned long offset1;
451
 
            if (flags & MAP_ANON)
452
 
                offset1 = 0;
453
 
            else
454
 
                offset1 = offset + real_start - start;
455
 
            p = mmap(g2h(real_start), real_end - real_start,
456
 
                     prot, flags, fd, offset1);
457
 
            if (p == MAP_FAILED)
458
 
                goto fail;
459
 
        }
460
 
    }
461
 
 the_end1:
462
 
    page_set_flags(start, start + len, prot | PAGE_VALID);
463
 
 the_end:
464
 
#ifdef DEBUG_MMAP
465
 
    printf("ret=0x" TARGET_FMT_lx "\n", start);
466
 
    page_dump(stdout);
467
 
    printf("\n");
468
 
#endif
469
 
    mmap_unlock();
470
 
    return start;
471
 
fail:
472
 
    mmap_unlock();
473
 
    return -1;
474
 
}
475
 
 
476
 
int target_munmap(abi_ulong start, abi_ulong len)
477
 
{
478
 
    abi_ulong end, real_start, real_end, addr;
479
 
    int prot, ret;
480
 
 
481
 
#ifdef DEBUG_MMAP
482
 
    printf("munmap: start=0x%lx len=0x%lx\n", start, len);
483
 
#endif
484
 
    if (start & ~TARGET_PAGE_MASK)
485
 
        return -EINVAL;
486
 
    len = TARGET_PAGE_ALIGN(len);
487
 
    if (len == 0)
488
 
        return -EINVAL;
489
 
    mmap_lock();
490
 
    end = start + len;
491
 
    real_start = start & qemu_host_page_mask;
492
 
    real_end = HOST_PAGE_ALIGN(end);
493
 
 
494
 
    if (start > real_start) {
495
 
        /* handle host page containing start */
496
 
        prot = 0;
497
 
        for(addr = real_start; addr < start; addr += TARGET_PAGE_SIZE) {
498
 
            prot |= page_get_flags(addr);
499
 
        }
500
 
        if (real_end == real_start + qemu_host_page_size) {
501
 
            for(addr = end; addr < real_end; addr += TARGET_PAGE_SIZE) {
502
 
                prot |= page_get_flags(addr);
503
 
            }
504
 
            end = real_end;
505
 
        }
506
 
        if (prot != 0)
507
 
            real_start += qemu_host_page_size;
508
 
    }
509
 
    if (end < real_end) {
510
 
        prot = 0;
511
 
        for(addr = end; addr < real_end; addr += TARGET_PAGE_SIZE) {
512
 
            prot |= page_get_flags(addr);
513
 
        }
514
 
        if (prot != 0)
515
 
            real_end -= qemu_host_page_size;
516
 
    }
517
 
 
518
 
    ret = 0;
519
 
    /* unmap what we can */
520
 
    if (real_start < real_end) {
521
 
        ret = munmap(g2h(real_start), real_end - real_start);
522
 
    }
523
 
 
524
 
    if (ret == 0)
525
 
        page_set_flags(start, start + len, 0);
526
 
    mmap_unlock();
527
 
    return ret;
528
 
}
529
 
 
530
 
int target_msync(abi_ulong start, abi_ulong len, int flags)
531
 
{
532
 
    abi_ulong end;
533
 
 
534
 
    if (start & ~TARGET_PAGE_MASK)
535
 
        return -EINVAL;
536
 
    len = TARGET_PAGE_ALIGN(len);
537
 
    end = start + len;
538
 
    if (end < start)
539
 
        return -EINVAL;
540
 
    if (end == start)
541
 
        return 0;
542
 
 
543
 
    start &= qemu_host_page_mask;
544
 
    return msync(g2h(start), end - start, flags);
545
 
}