Statistics
| Branch: | Revision:

root / qemu-common.h @ 0bfe3ca5

History | View | Annotate | Download (6.3 kB)

1
/* Common header file that is included by all of qemu.  */
2
#ifndef QEMU_COMMON_H
3
#define QEMU_COMMON_H
4

    
5
#define QEMU_NORETURN __attribute__ ((__noreturn__))
6

    
7
/* Hack around the mess dyngen-exec.h causes: We need QEMU_NORETURN in files that
8
   cannot include the following headers without conflicts. This condition has
9
   to be removed once dyngen is gone. */
10
#ifndef __DYNGEN_EXEC_H__
11

    
12
/* we put basic includes here to avoid repeating them in device drivers */
13
#include <stdlib.h>
14
#include <stdio.h>
15
#include <stdarg.h>
16
#include <string.h>
17
#include <strings.h>
18
#include <inttypes.h>
19
#include <limits.h>
20
#include <time.h>
21
#include <ctype.h>
22
#include <errno.h>
23
#include <unistd.h>
24
#include <fcntl.h>
25
#include <sys/stat.h>
26
#include <assert.h>
27
#include "config-host.h"
28

    
29
#ifndef O_LARGEFILE
30
#define O_LARGEFILE 0
31
#endif
32
#ifndef O_BINARY
33
#define O_BINARY 0
34
#endif
35

    
36
#ifndef ENOMEDIUM
37
#define ENOMEDIUM ENODEV
38
#endif
39

    
40
#ifndef HAVE_IOVEC
41
#define HAVE_IOVEC
42
struct iovec {
43
    void *iov_base;
44
    size_t iov_len;
45
};
46
#else
47
#include <sys/uio.h>
48
#endif
49

    
50
#ifdef _WIN32
51
#define fsync _commit
52
#define lseek _lseeki64
53
#define ENOTSUP 4096
54
extern int qemu_ftruncate64(int, int64_t);
55
#define ftruncate qemu_ftruncate64
56

    
57

    
58
static inline char *realpath(const char *path, char *resolved_path)
59
{
60
    _fullpath(resolved_path, path, _MAX_PATH);
61
    return resolved_path;
62
}
63

    
64
#define PRId64 "I64d"
65
#define PRIx64 "I64x"
66
#define PRIu64 "I64u"
67
#define PRIo64 "I64o"
68
#endif
69

    
70
/* FIXME: Remove NEED_CPU_H.  */
71
#ifndef NEED_CPU_H
72

    
73
#include <setjmp.h>
74
#include "osdep.h"
75
#include "bswap.h"
76

    
77
#else
78

    
79
#include "cpu.h"
80

    
81
#endif /* !defined(NEED_CPU_H) */
82

    
83
/* bottom halves */
84
typedef struct QEMUBH QEMUBH;
85

    
86
typedef void QEMUBHFunc(void *opaque);
87

    
88
QEMUBH *qemu_bh_new(QEMUBHFunc *cb, void *opaque);
89
void qemu_bh_schedule(QEMUBH *bh);
90
/* Bottom halfs that are scheduled from a bottom half handler are instantly
91
 * invoked.  This can create an infinite loop if a bottom half handler
92
 * schedules itself.  qemu_bh_schedule_idle() avoids this infinite loop by
93
 * ensuring that the bottom half isn't executed until the next main loop
94
 * iteration.
95
 */
96
void qemu_bh_schedule_idle(QEMUBH *bh);
97
void qemu_bh_cancel(QEMUBH *bh);
98
void qemu_bh_delete(QEMUBH *bh);
99
int qemu_bh_poll(void);
100

    
101
uint64_t muldiv64(uint64_t a, uint32_t b, uint32_t c);
102

    
103
void qemu_get_timedate(struct tm *tm, int offset);
104
int qemu_timedate_diff(struct tm *tm);
105

    
106
/* cutils.c */
107
void pstrcpy(char *buf, int buf_size, const char *str);
108
char *pstrcat(char *buf, int buf_size, const char *s);
109
int strstart(const char *str, const char *val, const char **ptr);
110
int stristart(const char *str, const char *val, const char **ptr);
111
time_t mktimegm(struct tm *tm);
112
int qemu_fls(int i);
113

    
114
#define qemu_isalnum(c)                isalnum((unsigned char)(c))
115
#define qemu_isalpha(c)                isalpha((unsigned char)(c))
116
#define qemu_iscntrl(c)                iscntrl((unsigned char)(c))
117
#define qemu_isdigit(c)                isdigit((unsigned char)(c))
118
#define qemu_isgraph(c)                isgraph((unsigned char)(c))
119
#define qemu_islower(c)                islower((unsigned char)(c))
120
#define qemu_isprint(c)                isprint((unsigned char)(c))
121
#define qemu_ispunct(c)                ispunct((unsigned char)(c))
122
#define qemu_isspace(c)                isspace((unsigned char)(c))
123
#define qemu_isupper(c)                isupper((unsigned char)(c))
124
#define qemu_isxdigit(c)        isxdigit((unsigned char)(c))
125
#define qemu_tolower(c)                tolower((unsigned char)(c))
126
#define qemu_toupper(c)                toupper((unsigned char)(c))
127
#define qemu_isascii(c)                isascii((unsigned char)(c))
128
#define qemu_toascii(c)                toascii((unsigned char)(c))
129

    
130
void *qemu_malloc(size_t size);
131
void *qemu_realloc(void *ptr, size_t size);
132
void *qemu_mallocz(size_t size);
133
void qemu_free(void *ptr);
134
char *qemu_strdup(const char *str);
135
char *qemu_strndup(const char *str, size_t size);
136

    
137
void *get_mmap_addr(unsigned long size);
138

    
139

    
140
/* Error handling.  */
141

    
142
void QEMU_NORETURN hw_error(const char *fmt, ...)
143
    __attribute__ ((__format__ (__printf__, 1, 2)));
144

    
145
/* IO callbacks.  */
146
typedef void IOReadHandler(void *opaque, const uint8_t *buf, int size);
147
typedef int IOCanRWHandler(void *opaque);
148
typedef void IOHandler(void *opaque);
149

    
150
struct ParallelIOArg {
151
    void *buffer;
152
    int count;
153
};
154

    
155
typedef int (*DMA_transfer_handler) (void *opaque, int nchan, int pos, int size);
156

    
157
/* A load of opaque types so that device init declarations don't have to
158
   pull in all the real definitions.  */
159
typedef struct NICInfo NICInfo;
160
typedef struct HCIInfo HCIInfo;
161
typedef struct AudioState AudioState;
162
typedef struct BlockDriverState BlockDriverState;
163
typedef struct DisplayState DisplayState;
164
typedef struct DisplayChangeListener DisplayChangeListener;
165
typedef struct DisplaySurface DisplaySurface;
166
typedef struct DisplayAllocator DisplayAllocator;
167
typedef struct PixelFormat PixelFormat;
168
typedef struct TextConsole TextConsole;
169
typedef TextConsole QEMUConsole;
170
typedef struct CharDriverState CharDriverState;
171
typedef struct VLANState VLANState;
172
typedef struct QEMUFile QEMUFile;
173
typedef struct i2c_bus i2c_bus;
174
typedef struct i2c_slave i2c_slave;
175
typedef struct SMBusDevice SMBusDevice;
176
typedef struct QEMUTimer QEMUTimer;
177
typedef struct PCIBus PCIBus;
178
typedef struct PCIDevice PCIDevice;
179
typedef struct SerialState SerialState;
180
typedef struct IRQState *qemu_irq;
181
typedef struct PCMCIACardState PCMCIACardState;
182
typedef struct MouseTransformInfo MouseTransformInfo;
183
typedef struct uWireSlave uWireSlave;
184
typedef struct I2SCodec I2SCodec;
185

    
186
/* CPU save/load.  */
187
void cpu_save(QEMUFile *f, void *opaque);
188
int cpu_load(QEMUFile *f, void *opaque, int version_id);
189

    
190
/* Force QEMU to stop what it's doing and service IO */
191
void qemu_service_io(void);
192

    
193
/* Force QEMU to process pending events */
194
void qemu_notify_event(void);
195

    
196
/* Unblock cpu */
197
void qemu_cpu_kick(void *env);
198
int qemu_cpu_self(void *env);
199

    
200
#ifdef CONFIG_USER_ONLY
201
#define qemu_init_vcpu(env) do { } while (0)
202
#else
203
void qemu_init_vcpu(void *env);
204
#endif
205

    
206
typedef struct QEMUIOVector {
207
    struct iovec *iov;
208
    int niov;
209
    int nalloc;
210
    size_t size;
211
} QEMUIOVector;
212

    
213
void qemu_iovec_init(QEMUIOVector *qiov, int alloc_hint);
214
void qemu_iovec_init_external(QEMUIOVector *qiov, struct iovec *iov, int niov);
215
void qemu_iovec_add(QEMUIOVector *qiov, void *base, size_t len);
216
void qemu_iovec_destroy(QEMUIOVector *qiov);
217
void qemu_iovec_reset(QEMUIOVector *qiov);
218
void qemu_iovec_to_buffer(QEMUIOVector *qiov, void *buf);
219
void qemu_iovec_from_buffer(QEMUIOVector *qiov, const void *buf, size_t count);
220

    
221
struct Monitor;
222
typedef struct Monitor Monitor;
223

    
224
#include "module.h"
225

    
226
#endif /* dyngen-exec.h hack */
227

    
228
#endif