← Back to branch summary

~vcs-imports/qemu/git

« back to all changes in this revision

Viewing changes to osdep.c

  • Committer: blueswir1
  • Date: 2007-11-25 08:48:16 UTC
  • Revision ID: git-v1:b76482e76560345c00e7d6c89199ced204a926d2
 Fix buffer mux handling for unconnected serial ports


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

Show diffs side-by-side

added added

removed removed

Lines of Context:
osdep.c
37
37
#include "sysemu.h"
38
38
 
39
39
#ifdef _WIN32
40
 
#define WIN32_LEAN_AND_MEAN
41
40
#include <windows.h>
42
41
#elif defined(_BSD)
43
42
#include <stdlib.h>
45
44
#include <malloc.h>
46
45
#endif
47
46
 
48
 
#include "qemu_socket.h"
 
47
void *get_mmap_addr(unsigned long size)
 
48
{
 
49
    return NULL;
 
50
}
 
51
 
 
52
void qemu_free(void *ptr)
 
53
{
 
54
    free(ptr);
 
55
}
 
56
 
 
57
void *qemu_malloc(size_t size)
 
58
{
 
59
    return malloc(size);
 
60
}
49
61
 
50
62
#if defined(_WIN32)
51
 
void *qemu_memalign(size_t alignment, size_t size)
52
 
{
53
 
    return VirtualAlloc(NULL, size, MEM_COMMIT, PAGE_READWRITE);
54
 
}
55
63
 
56
64
void *qemu_vmalloc(size_t size)
57
65
{
70
78
 
71
79
#if defined(USE_KQEMU)
72
80
 
73
 
#ifdef __OpenBSD__
74
 
#include <sys/param.h>
75
 
#include <sys/types.h>
76
 
#include <sys/mount.h>
77
 
#else
78
81
#include <sys/vfs.h>
79
 
#endif
80
 
 
81
82
#include <sys/mman.h>
82
83
#include <fcntl.h>
83
84
 
85
86
{
86
87
    static int phys_ram_fd = -1;
87
88
    static int phys_ram_size = 0;
88
 
    void *ptr;
89
 
 
90
 
#ifdef __OpenBSD__ /* no need (?) for a dummy file on OpenBSD */
91
 
    int map_anon = MAP_ANON;
92
 
#else
93
 
    int map_anon = 0;
94
89
    const char *tmpdir;
95
90
    char phys_ram_file[1024];
 
91
    void *ptr;
96
92
#ifdef HOST_SOLARIS
97
93
    struct statvfs stfs;
98
94
#else
112
108
            int64_t free_space;
113
109
            int ram_mb;
114
110
 
 
111
            extern int ram_size;
115
112
            free_space = (int64_t)stfs.f_bavail * stfs.f_bsize;
116
113
            if ((ram_size + 8192 * 1024) >= free_space) {
117
114
                ram_mb = (ram_size / (1024 * 1024));
120
117
                        tmpdir, ram_mb);
121
118
                if (strcmp(tmpdir, "/dev/shm") == 0) {
122
119
                    fprintf(stderr, "To have more space available provided you have enough RAM and swap, do as root:\n"
123
 
                            "mount -o remount,size=%dm /dev/shm\n",
 
120
                            "umount /dev/shm\n"
 
121
                            "mount -t tmpfs -o size=%dm none /dev/shm\n",
124
122
                            ram_mb + 16);
125
123
                } else {
126
124
                    fprintf(stderr,
154
152
    }
155
153
    size = (size + 4095) & ~4095;
156
154
    ftruncate(phys_ram_fd, phys_ram_size + size);
157
 
#endif /* !__OpenBSD__ */
158
155
    ptr = mmap(NULL,
159
156
               size,
160
 
               PROT_WRITE | PROT_READ, map_anon | MAP_SHARED,
 
157
               PROT_WRITE | PROT_READ, MAP_SHARED,
161
158
               phys_ram_fd, phys_ram_size);
162
159
    if (ptr == MAP_FAILED) {
163
160
        fprintf(stderr, "Could not map physical memory\n");
174
171
 
175
172
#endif
176
173
 
177
 
void *qemu_memalign(size_t alignment, size_t size)
178
 
{
179
 
#if defined(_POSIX_C_SOURCE)
180
 
    int ret;
181
 
    void *ptr;
182
 
    ret = posix_memalign(&ptr, alignment, size);
183
 
    if (ret != 0)
184
 
        return NULL;
185
 
    return ptr;
186
 
#elif defined(_BSD)
187
 
    return valloc(size);
188
 
#else
189
 
    return memalign(alignment, size);
190
 
#endif
191
 
}
192
 
 
193
174
/* alloc shared memory pages */
194
175
void *qemu_vmalloc(size_t size)
195
176
{
215
196
 
216
197
#endif
217
198
 
 
199
void *qemu_mallocz(size_t size)
 
200
{
 
201
    void *ptr;
 
202
    ptr = qemu_malloc(size);
 
203
    if (!ptr)
 
204
        return NULL;
 
205
    memset(ptr, 0, size);
 
206
    return ptr;
 
207
}
 
208
 
 
209
char *qemu_strdup(const char *str)
 
210
{
 
211
    char *ptr;
 
212
    ptr = qemu_malloc(strlen(str) + 1);
 
213
    if (!ptr)
 
214
        return NULL;
 
215
    strcpy(ptr, str);
 
216
    return ptr;
 
217
}
 
218
 
218
219
int qemu_create_pidfile(const char *filename)
219
220
{
220
221
    char buffer[128];
285
286
  return 0;
286
287
}
287
288
#endif /* _WIN32 */
288
 
 
289
 
 
290
 
#ifdef _WIN32
291
 
void socket_set_nonblock(int fd)
292
 
{
293
 
    unsigned long opt = 1;
294
 
    ioctlsocket(fd, FIONBIO, &opt);
295
 
}
296
 
 
297
 
int inet_aton(const char *cp, struct in_addr *ia)
298
 
{
299
 
    uint32_t addr = inet_addr(cp);
300
 
    if (addr == 0xffffffff)
301
 
        return 0;
302
 
    ia->s_addr = addr;
303
 
    return 1;
304
 
}
305
 
#else
306
 
void socket_set_nonblock(int fd)
307
 
{
308
 
    int f;
309
 
    f = fcntl(fd, F_GETFL);
310
 
    fcntl(fd, F_SETFL, f | O_NONBLOCK);
311
 
}
312
 
#endif