Revision cd245a19

b/osdep.c
50 50
#endif
51 51

  
52 52
#include "qemu-common.h"
53
#include "trace.h"
53 54
#include "sysemu.h"
54 55
#include "qemu_socket.h"
55 56

  
......
71 72
#if defined(_WIN32)
72 73
void *qemu_memalign(size_t alignment, size_t size)
73 74
{
75
    void *ptr;
76

  
74 77
    if (!size) {
75 78
        abort();
76 79
    }
77
    return oom_check(VirtualAlloc(NULL, size, MEM_COMMIT, PAGE_READWRITE));
80
    ptr = oom_check(VirtualAlloc(NULL, size, MEM_COMMIT, PAGE_READWRITE));
81
    trace_qemu_memalign(alignment, size, ptr);
82
    return ptr;
78 83
}
79 84

  
80 85
void *qemu_vmalloc(size_t size)
81 86
{
87
    void *ptr;
88

  
82 89
    /* FIXME: this is not exactly optimal solution since VirtualAlloc
83 90
       has 64Kb granularity, but at least it guarantees us that the
84 91
       memory is page aligned. */
85 92
    if (!size) {
86 93
        abort();
87 94
    }
88
    return oom_check(VirtualAlloc(NULL, size, MEM_COMMIT, PAGE_READWRITE));
95
    ptr = oom_check(VirtualAlloc(NULL, size, MEM_COMMIT, PAGE_READWRITE));
96
    trace_qemu_vmalloc(size, ptr);
97
    return ptr;
89 98
}
90 99

  
91 100
void qemu_vfree(void *ptr)
92 101
{
102
    trace_qemu_vfree(ptr);
93 103
    VirtualFree(ptr, 0, MEM_RELEASE);
94 104
}
95 105

  
......
97 107

  
98 108
void *qemu_memalign(size_t alignment, size_t size)
99 109
{
110
    void *ptr;
100 111
#if defined(_POSIX_C_SOURCE) && !defined(__sun__)
101 112
    int ret;
102
    void *ptr;
103 113
    ret = posix_memalign(&ptr, alignment, size);
104 114
    if (ret != 0) {
105 115
        fprintf(stderr, "Failed to allocate %zu B: %s\n",
106 116
                size, strerror(ret));
107 117
        abort();
108 118
    }
109
    return ptr;
110 119
#elif defined(CONFIG_BSD)
111
    return oom_check(valloc(size));
120
    ptr = oom_check(valloc(size));
112 121
#else
113
    return oom_check(memalign(alignment, size));
122
    ptr = oom_check(memalign(alignment, size));
114 123
#endif
124
    trace_qemu_memalign(alignment, size, ptr);
125
    return ptr;
115 126
}
116 127

  
117 128
/* alloc shared memory pages */
......
122 133

  
123 134
void qemu_vfree(void *ptr)
124 135
{
136
    trace_qemu_vfree(ptr);
125 137
    free(ptr);
126 138
}
127 139

  
b/qemu-malloc.c
22 22
 * THE SOFTWARE.
23 23
 */
24 24
#include "qemu-common.h"
25
#include "trace.h"
25 26
#include <stdlib.h>
26 27

  
27 28
static void *oom_check(void *ptr)
......
34 35

  
35 36
void qemu_free(void *ptr)
36 37
{
38
    trace_qemu_free(ptr);
37 39
    free(ptr);
38 40
}
39 41

  
......
48 50

  
49 51
void *qemu_malloc(size_t size)
50 52
{
53
    void *ptr;
51 54
    if (!size && !allow_zero_malloc()) {
52 55
        abort();
53 56
    }
54
    return oom_check(malloc(size ? size : 1));
57
    ptr = oom_check(malloc(size ? size : 1));
58
    trace_qemu_malloc(size, ptr);
59
    return ptr;
55 60
}
56 61

  
57 62
void *qemu_realloc(void *ptr, size_t size)
58 63
{
64
    void *newptr;
59 65
    if (!size && !allow_zero_malloc()) {
60 66
        abort();
61 67
    }
62
    return oom_check(realloc(ptr, size ? size : 1));
68
    newptr = oom_check(realloc(ptr, size ? size : 1));
69
    trace_qemu_realloc(ptr, size, newptr);
70
    return newptr;
63 71
}
64 72

  
65 73
void *qemu_mallocz(size_t size)
b/trace-events
27 27
# system may not have the necessary headers included.
28 28
#
29 29
# The <format-string> should be a sprintf()-compatible format string.
30

  
31
# qemu-malloc.c
32
disable qemu_malloc(size_t size, void *ptr) "size %zu ptr %p"
33
disable qemu_realloc(void *ptr, size_t size, void *newptr) "ptr %p size %zu newptr %p"
34
disable qemu_free(void *ptr) "ptr %p"
35

  
36
# osdep.c
37
disable qemu_memalign(size_t alignment, size_t size, void *ptr) "alignment %zu size %zu ptr %p"
38
disable qemu_valloc(size_t size, void *ptr) "size %zu ptr %p"
39
disable qemu_vfree(void *ptr) "ptr %p"

Also available in: Unified diff