~ahs3/+junk/cq-qemu

« back to all changes in this revision

Viewing changes to qemu-common.h

  • Committer: Al Stone
  • Date: 2012-02-09 01:17:20 UTC
  • Revision ID: albert.stone@canonical.com-20120209011720-tztl7ik3qayz80p4
first commit to bzr for qemu

Show diffs side-by-side

added added

removed removed

Lines of Context:
 
1
/* Common header file that is included by all of qemu.  */
 
2
#ifndef QEMU_COMMON_H
 
3
#define QEMU_COMMON_H
 
4
 
 
5
#include "compiler.h"
 
6
#include "config-host.h"
 
7
 
 
8
#if defined(__arm__) || defined(__sparc__) || defined(__mips__) || defined(__hppa__) || defined(__ia64__)
 
9
#define WORDS_ALIGNED
 
10
#endif
 
11
 
 
12
#define TFR(expr) do { if ((expr) != -1) break; } while (errno == EINTR)
 
13
 
 
14
typedef struct QEMUTimer QEMUTimer;
 
15
typedef struct QEMUFile QEMUFile;
 
16
typedef struct DeviceState DeviceState;
 
17
 
 
18
struct Monitor;
 
19
typedef struct Monitor Monitor;
 
20
 
 
21
/* we put basic includes here to avoid repeating them in device drivers */
 
22
#include <stdlib.h>
 
23
#include <stdio.h>
 
24
#include <stdarg.h>
 
25
#include <stdbool.h>
 
26
#include <string.h>
 
27
#include <strings.h>
 
28
#include <inttypes.h>
 
29
#include <limits.h>
 
30
#include <time.h>
 
31
#include <ctype.h>
 
32
#include <errno.h>
 
33
#include <unistd.h>
 
34
#include <fcntl.h>
 
35
#include <sys/stat.h>
 
36
#include <sys/time.h>
 
37
#include <assert.h>
 
38
#include <signal.h>
 
39
#include <glib.h>
 
40
 
 
41
#ifdef _WIN32
 
42
#include "qemu-os-win32.h"
 
43
#endif
 
44
 
 
45
#ifdef CONFIG_POSIX
 
46
#include "qemu-os-posix.h"
 
47
#endif
 
48
 
 
49
#ifndef O_LARGEFILE
 
50
#define O_LARGEFILE 0
 
51
#endif
 
52
#ifndef O_BINARY
 
53
#define O_BINARY 0
 
54
#endif
 
55
#ifndef MAP_ANONYMOUS
 
56
#define MAP_ANONYMOUS MAP_ANON
 
57
#endif
 
58
#ifndef ENOMEDIUM
 
59
#define ENOMEDIUM ENODEV
 
60
#endif
 
61
#if !defined(ENOTSUP)
 
62
#define ENOTSUP 4096
 
63
#endif
 
64
#ifndef TIME_MAX
 
65
#define TIME_MAX LONG_MAX
 
66
#endif
 
67
 
 
68
#ifndef CONFIG_IOVEC
 
69
#define CONFIG_IOVEC
 
70
struct iovec {
 
71
    void *iov_base;
 
72
    size_t iov_len;
 
73
};
 
74
/*
 
75
 * Use the same value as Linux for now.
 
76
 */
 
77
#define IOV_MAX         1024
 
78
#else
 
79
#include <sys/uio.h>
 
80
#endif
 
81
 
 
82
typedef int (*fprintf_function)(FILE *f, const char *fmt, ...)
 
83
    GCC_FMT_ATTR(2, 3);
 
84
 
 
85
#ifdef _WIN32
 
86
#define fsync _commit
 
87
#define lseek _lseeki64
 
88
int qemu_ftruncate64(int, int64_t);
 
89
#define ftruncate qemu_ftruncate64
 
90
 
 
91
static inline char *realpath(const char *path, char *resolved_path)
 
92
{
 
93
    _fullpath(resolved_path, path, _MAX_PATH);
 
94
    return resolved_path;
 
95
}
 
96
#endif
 
97
 
 
98
/* icount */
 
99
void configure_icount(const char *option);
 
100
extern int use_icount;
 
101
 
 
102
/* FIXME: Remove NEED_CPU_H.  */
 
103
#ifndef NEED_CPU_H
 
104
 
 
105
#include "osdep.h"
 
106
#include "bswap.h"
 
107
 
 
108
#else
 
109
 
 
110
#include "cpu.h"
 
111
 
 
112
#endif /* !defined(NEED_CPU_H) */
 
113
 
 
114
/* main function, renamed */
 
115
#if defined(CONFIG_COCOA)
 
116
int qemu_main(int argc, char **argv, char **envp);
 
117
#endif
 
118
 
 
119
void qemu_get_timedate(struct tm *tm, int offset);
 
120
int qemu_timedate_diff(struct tm *tm);
 
121
 
 
122
/* cutils.c */
 
123
void pstrcpy(char *buf, int buf_size, const char *str);
 
124
char *pstrcat(char *buf, int buf_size, const char *s);
 
125
int strstart(const char *str, const char *val, const char **ptr);
 
126
int stristart(const char *str, const char *val, const char **ptr);
 
127
int qemu_strnlen(const char *s, int max_len);
 
128
time_t mktimegm(struct tm *tm);
 
129
int qemu_fls(int i);
 
130
int qemu_fdatasync(int fd);
 
131
int fcntl_setfl(int fd, int flag);
 
132
int qemu_parse_fd(const char *param);
 
133
 
 
134
/*
 
135
 * strtosz() suffixes used to specify the default treatment of an
 
136
 * argument passed to strtosz() without an explicit suffix.
 
137
 * These should be defined using upper case characters in the range
 
138
 * A-Z, as strtosz() will use qemu_toupper() on the given argument
 
139
 * prior to comparison.
 
140
 */
 
141
#define STRTOSZ_DEFSUFFIX_TB    'T'
 
142
#define STRTOSZ_DEFSUFFIX_GB    'G'
 
143
#define STRTOSZ_DEFSUFFIX_MB    'M'
 
144
#define STRTOSZ_DEFSUFFIX_KB    'K'
 
145
#define STRTOSZ_DEFSUFFIX_B     'B'
 
146
int64_t strtosz(const char *nptr, char **end);
 
147
int64_t strtosz_suffix(const char *nptr, char **end, const char default_suffix);
 
148
int64_t strtosz_suffix_unit(const char *nptr, char **end,
 
149
                            const char default_suffix, int64_t unit);
 
150
 
 
151
/* path.c */
 
152
void init_paths(const char *prefix);
 
153
const char *path(const char *pathname);
 
154
 
 
155
#define qemu_isalnum(c)         isalnum((unsigned char)(c))
 
156
#define qemu_isalpha(c)         isalpha((unsigned char)(c))
 
157
#define qemu_iscntrl(c)         iscntrl((unsigned char)(c))
 
158
#define qemu_isdigit(c)         isdigit((unsigned char)(c))
 
159
#define qemu_isgraph(c)         isgraph((unsigned char)(c))
 
160
#define qemu_islower(c)         islower((unsigned char)(c))
 
161
#define qemu_isprint(c)         isprint((unsigned char)(c))
 
162
#define qemu_ispunct(c)         ispunct((unsigned char)(c))
 
163
#define qemu_isspace(c)         isspace((unsigned char)(c))
 
164
#define qemu_isupper(c)         isupper((unsigned char)(c))
 
165
#define qemu_isxdigit(c)        isxdigit((unsigned char)(c))
 
166
#define qemu_tolower(c)         tolower((unsigned char)(c))
 
167
#define qemu_toupper(c)         toupper((unsigned char)(c))
 
168
#define qemu_isascii(c)         isascii((unsigned char)(c))
 
169
#define qemu_toascii(c)         toascii((unsigned char)(c))
 
170
 
 
171
void *qemu_oom_check(void *ptr);
 
172
 
 
173
int qemu_open(const char *name, int flags, ...);
 
174
ssize_t qemu_write_full(int fd, const void *buf, size_t count)
 
175
    QEMU_WARN_UNUSED_RESULT;
 
176
void qemu_set_cloexec(int fd);
 
177
 
 
178
#ifndef _WIN32
 
179
int qemu_eventfd(int pipefd[2]);
 
180
int qemu_pipe(int pipefd[2]);
 
181
#endif
 
182
 
 
183
#ifdef _WIN32
 
184
#define qemu_recv(sockfd, buf, len, flags) recv(sockfd, (void *)buf, len, flags)
 
185
#else
 
186
#define qemu_recv(sockfd, buf, len, flags) recv(sockfd, buf, len, flags)
 
187
#endif
 
188
 
 
189
/* Error handling.  */
 
190
 
 
191
void QEMU_NORETURN hw_error(const char *fmt, ...) GCC_FMT_ATTR(1, 2);
 
192
 
 
193
struct ParallelIOArg {
 
194
    void *buffer;
 
195
    int count;
 
196
};
 
197
 
 
198
typedef int (*DMA_transfer_handler) (void *opaque, int nchan, int pos, int size);
 
199
 
 
200
/* A load of opaque types so that device init declarations don't have to
 
201
   pull in all the real definitions.  */
 
202
typedef struct NICInfo NICInfo;
 
203
typedef struct HCIInfo HCIInfo;
 
204
typedef struct AudioState AudioState;
 
205
typedef struct BlockDriverState BlockDriverState;
 
206
typedef struct DriveInfo DriveInfo;
 
207
typedef struct DisplayState DisplayState;
 
208
typedef struct DisplayChangeListener DisplayChangeListener;
 
209
typedef struct DisplaySurface DisplaySurface;
 
210
typedef struct DisplayAllocator DisplayAllocator;
 
211
typedef struct PixelFormat PixelFormat;
 
212
typedef struct TextConsole TextConsole;
 
213
typedef TextConsole QEMUConsole;
 
214
typedef struct CharDriverState CharDriverState;
 
215
typedef struct MACAddr MACAddr;
 
216
typedef struct VLANState VLANState;
 
217
typedef struct VLANClientState VLANClientState;
 
218
typedef struct i2c_bus i2c_bus;
 
219
typedef struct i2c_slave i2c_slave;
 
220
typedef struct SMBusDevice SMBusDevice;
 
221
typedef struct PCIHostState PCIHostState;
 
222
typedef struct PCIExpressHost PCIExpressHost;
 
223
typedef struct PCIBus PCIBus;
 
224
typedef struct PCIDevice PCIDevice;
 
225
typedef struct PCIExpressDevice PCIExpressDevice;
 
226
typedef struct PCIBridge PCIBridge;
 
227
typedef struct PCIEAERMsg PCIEAERMsg;
 
228
typedef struct PCIEAERLog PCIEAERLog;
 
229
typedef struct PCIEAERErr PCIEAERErr;
 
230
typedef struct PCIEPort PCIEPort;
 
231
typedef struct PCIESlot PCIESlot;
 
232
typedef struct SerialState SerialState;
 
233
typedef struct IRQState *qemu_irq;
 
234
typedef struct PCMCIACardState PCMCIACardState;
 
235
typedef struct MouseTransformInfo MouseTransformInfo;
 
236
typedef struct uWireSlave uWireSlave;
 
237
typedef struct I2SCodec I2SCodec;
 
238
typedef struct SSIBus SSIBus;
 
239
typedef struct EventNotifier EventNotifier;
 
240
typedef struct VirtIODevice VirtIODevice;
 
241
typedef struct QEMUSGList QEMUSGList;
 
242
 
 
243
typedef uint64_t pcibus_t;
 
244
 
 
245
void tcg_exec_init(unsigned long tb_size);
 
246
bool tcg_enabled(void);
 
247
 
 
248
void cpu_exec_init_all(void);
 
249
 
 
250
/* CPU save/load.  */
 
251
void cpu_save(QEMUFile *f, void *opaque);
 
252
int cpu_load(QEMUFile *f, void *opaque, int version_id);
 
253
 
 
254
/* Unblock cpu */
 
255
void qemu_cpu_kick(void *env);
 
256
void qemu_cpu_kick_self(void);
 
257
int qemu_cpu_is_self(void *env);
 
258
bool all_cpu_threads_idle(void);
 
259
 
 
260
/* work queue */
 
261
struct qemu_work_item {
 
262
    struct qemu_work_item *next;
 
263
    void (*func)(void *data);
 
264
    void *data;
 
265
    int done;
 
266
};
 
267
 
 
268
#ifdef CONFIG_USER_ONLY
 
269
#define qemu_init_vcpu(env) do { } while (0)
 
270
#else
 
271
void qemu_init_vcpu(void *env);
 
272
#endif
 
273
 
 
274
typedef struct QEMUIOVector {
 
275
    struct iovec *iov;
 
276
    int niov;
 
277
    int nalloc;
 
278
    size_t size;
 
279
} QEMUIOVector;
 
280
 
 
281
void qemu_iovec_init(QEMUIOVector *qiov, int alloc_hint);
 
282
void qemu_iovec_init_external(QEMUIOVector *qiov, struct iovec *iov, int niov);
 
283
void qemu_iovec_add(QEMUIOVector *qiov, void *base, size_t len);
 
284
void qemu_iovec_copy(QEMUIOVector *dst, QEMUIOVector *src, uint64_t skip,
 
285
    size_t size);
 
286
void qemu_iovec_concat(QEMUIOVector *dst, QEMUIOVector *src, size_t size);
 
287
void qemu_iovec_destroy(QEMUIOVector *qiov);
 
288
void qemu_iovec_reset(QEMUIOVector *qiov);
 
289
void qemu_iovec_to_buffer(QEMUIOVector *qiov, void *buf);
 
290
void qemu_iovec_from_buffer(QEMUIOVector *qiov, const void *buf, size_t count);
 
291
void qemu_iovec_memset(QEMUIOVector *qiov, int c, size_t count);
 
292
void qemu_iovec_memset_skip(QEMUIOVector *qiov, int c, size_t count,
 
293
                            size_t skip);
 
294
 
 
295
void qemu_progress_init(int enabled, float min_skip);
 
296
void qemu_progress_end(void);
 
297
void qemu_progress_print(float delta, int max);
 
298
 
 
299
#define QEMU_FILE_TYPE_BIOS   0
 
300
#define QEMU_FILE_TYPE_KEYMAP 1
 
301
char *qemu_find_file(int type, const char *name);
 
302
 
 
303
/* OS specific functions */
 
304
void os_setup_early_signal_handling(void);
 
305
char *os_find_datadir(const char *argv0);
 
306
void os_parse_cmd_args(int index, const char *optarg);
 
307
void os_pidfile_error(void);
 
308
 
 
309
/* Convert a byte between binary and BCD.  */
 
310
static inline uint8_t to_bcd(uint8_t val)
 
311
{
 
312
    return ((val / 10) << 4) | (val % 10);
 
313
}
 
314
 
 
315
static inline uint8_t from_bcd(uint8_t val)
 
316
{
 
317
    return ((val >> 4) * 10) + (val & 0x0f);
 
318
}
 
319
 
 
320
/* compute with 96 bit intermediate result: (a*b)/c */
 
321
static inline uint64_t muldiv64(uint64_t a, uint32_t b, uint32_t c)
 
322
{
 
323
    union {
 
324
        uint64_t ll;
 
325
        struct {
 
326
#ifdef HOST_WORDS_BIGENDIAN
 
327
            uint32_t high, low;
 
328
#else
 
329
            uint32_t low, high;
 
330
#endif
 
331
        } l;
 
332
    } u, res;
 
333
    uint64_t rl, rh;
 
334
 
 
335
    u.ll = a;
 
336
    rl = (uint64_t)u.l.low * (uint64_t)b;
 
337
    rh = (uint64_t)u.l.high * (uint64_t)b;
 
338
    rh += (rl >> 32);
 
339
    res.l.high = rh / c;
 
340
    res.l.low = (((rh % c) << 32) + (rl & 0xffffffff)) / c;
 
341
    return res.ll;
 
342
}
 
343
 
 
344
#include "module.h"
 
345
 
 
346
#endif