spice: add worker wrapper functions.
[qemu.git] / qemu-common.h
blob1e3c66511eeb464ef1d0b94fb562fb16674f5bb3
1 /* Common header file that is included by all of qemu. */
2 #ifndef QEMU_COMMON_H
3 #define QEMU_COMMON_H
5 #include "compiler.h"
6 #include "config-host.h"
8 #if defined(__arm__) || defined(__sparc__) || defined(__mips__) || defined(__hppa__) || defined(__ia64__)
9 #define WORDS_ALIGNED
10 #endif
12 #define TFR(expr) do { if ((expr) != -1) break; } while (errno == EINTR)
14 typedef struct QEMUTimer QEMUTimer;
15 typedef struct QEMUFile QEMUFile;
16 typedef struct QEMUBH QEMUBH;
17 typedef struct DeviceState DeviceState;
19 struct Monitor;
20 typedef struct Monitor Monitor;
22 /* we put basic includes here to avoid repeating them in device drivers */
23 #include <stdlib.h>
24 #include <stdio.h>
25 #include <stdarg.h>
26 #include <stdbool.h>
27 #include <string.h>
28 #include <strings.h>
29 #include <inttypes.h>
30 #include <limits.h>
31 #include <time.h>
32 #include <ctype.h>
33 #include <errno.h>
34 #include <unistd.h>
35 #include <fcntl.h>
36 #include <sys/stat.h>
37 #include <sys/time.h>
38 #include <assert.h>
39 #include <signal.h>
41 #ifdef _WIN32
42 #include "qemu-os-win32.h"
43 #endif
45 #ifdef CONFIG_POSIX
46 #include "qemu-os-posix.h"
47 #endif
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
68 #ifndef CONFIG_IOVEC
69 #define CONFIG_IOVEC
70 struct iovec {
71 void *iov_base;
72 size_t iov_len;
75 * Use the same value as Linux for now.
77 #define IOV_MAX 1024
78 #else
79 #include <sys/uio.h>
80 #endif
82 typedef int (*fprintf_function)(FILE *f, const char *fmt, ...)
83 GCC_FMT_ATTR(2, 3);
85 #ifdef _WIN32
86 #define fsync _commit
87 #define lseek _lseeki64
88 int qemu_ftruncate64(int, int64_t);
89 #define ftruncate qemu_ftruncate64
91 static inline char *realpath(const char *path, char *resolved_path)
93 _fullpath(resolved_path, path, _MAX_PATH);
94 return resolved_path;
96 #endif
98 /* FIXME: Remove NEED_CPU_H. */
99 #ifndef NEED_CPU_H
101 #include "osdep.h"
102 #include "bswap.h"
104 #else
106 #include "cpu.h"
108 #endif /* !defined(NEED_CPU_H) */
110 /* main function, renamed */
111 #if defined(CONFIG_COCOA)
112 int qemu_main(int argc, char **argv, char **envp);
113 #endif
115 /* bottom halves */
116 typedef void QEMUBHFunc(void *opaque);
118 void async_context_push(void);
119 void async_context_pop(void);
120 int get_async_context_id(void);
122 QEMUBH *qemu_bh_new(QEMUBHFunc *cb, void *opaque);
123 void qemu_bh_schedule(QEMUBH *bh);
124 /* Bottom halfs that are scheduled from a bottom half handler are instantly
125 * invoked. This can create an infinite loop if a bottom half handler
126 * schedules itself. qemu_bh_schedule_idle() avoids this infinite loop by
127 * ensuring that the bottom half isn't executed until the next main loop
128 * iteration.
130 void qemu_bh_schedule_idle(QEMUBH *bh);
131 void qemu_bh_cancel(QEMUBH *bh);
132 void qemu_bh_delete(QEMUBH *bh);
133 int qemu_bh_poll(void);
134 void qemu_bh_update_timeout(int *timeout);
136 void qemu_get_timedate(struct tm *tm, int offset);
137 int qemu_timedate_diff(struct tm *tm);
139 /* cutils.c */
140 void pstrcpy(char *buf, int buf_size, const char *str);
141 char *pstrcat(char *buf, int buf_size, const char *s);
142 int strstart(const char *str, const char *val, const char **ptr);
143 int stristart(const char *str, const char *val, const char **ptr);
144 int qemu_strnlen(const char *s, int max_len);
145 time_t mktimegm(struct tm *tm);
146 int qemu_fls(int i);
147 int qemu_fdatasync(int fd);
148 int fcntl_setfl(int fd, int flag);
151 * strtosz() suffixes used to specify the default treatment of an
152 * argument passed to strtosz() without an explicit suffix.
153 * These should be defined using upper case characters in the range
154 * A-Z, as strtosz() will use qemu_toupper() on the given argument
155 * prior to comparison.
157 #define STRTOSZ_DEFSUFFIX_TB 'T'
158 #define STRTOSZ_DEFSUFFIX_GB 'G'
159 #define STRTOSZ_DEFSUFFIX_MB 'M'
160 #define STRTOSZ_DEFSUFFIX_KB 'K'
161 #define STRTOSZ_DEFSUFFIX_B 'B'
162 int64_t strtosz(const char *nptr, char **end);
163 int64_t strtosz_suffix(const char *nptr, char **end, const char default_suffix);
165 /* path.c */
166 void init_paths(const char *prefix);
167 const char *path(const char *pathname);
169 #define qemu_isalnum(c) isalnum((unsigned char)(c))
170 #define qemu_isalpha(c) isalpha((unsigned char)(c))
171 #define qemu_iscntrl(c) iscntrl((unsigned char)(c))
172 #define qemu_isdigit(c) isdigit((unsigned char)(c))
173 #define qemu_isgraph(c) isgraph((unsigned char)(c))
174 #define qemu_islower(c) islower((unsigned char)(c))
175 #define qemu_isprint(c) isprint((unsigned char)(c))
176 #define qemu_ispunct(c) ispunct((unsigned char)(c))
177 #define qemu_isspace(c) isspace((unsigned char)(c))
178 #define qemu_isupper(c) isupper((unsigned char)(c))
179 #define qemu_isxdigit(c) isxdigit((unsigned char)(c))
180 #define qemu_tolower(c) tolower((unsigned char)(c))
181 #define qemu_toupper(c) toupper((unsigned char)(c))
182 #define qemu_isascii(c) isascii((unsigned char)(c))
183 #define qemu_toascii(c) toascii((unsigned char)(c))
185 void *qemu_oom_check(void *ptr);
186 void *qemu_malloc(size_t size);
187 void *qemu_realloc(void *ptr, size_t size);
188 void *qemu_mallocz(size_t size);
189 void qemu_free(void *ptr);
190 char *qemu_strdup(const char *str);
191 char *qemu_strndup(const char *str, size_t size);
193 void qemu_mutex_lock_iothread(void);
194 void qemu_mutex_unlock_iothread(void);
196 int qemu_open(const char *name, int flags, ...);
197 ssize_t qemu_write_full(int fd, const void *buf, size_t count)
198 QEMU_WARN_UNUSED_RESULT;
199 void qemu_set_cloexec(int fd);
201 #ifndef _WIN32
202 int qemu_add_child_watch(pid_t pid);
203 int qemu_eventfd(int pipefd[2]);
204 int qemu_pipe(int pipefd[2]);
205 #endif
207 #ifdef _WIN32
208 #define qemu_recv(sockfd, buf, len, flags) recv(sockfd, (void *)buf, len, flags)
209 #else
210 #define qemu_recv(sockfd, buf, len, flags) recv(sockfd, buf, len, flags)
211 #endif
213 /* Error handling. */
215 void QEMU_NORETURN hw_error(const char *fmt, ...) GCC_FMT_ATTR(1, 2);
217 /* IO callbacks. */
218 typedef void IOReadHandler(void *opaque, const uint8_t *buf, int size);
219 typedef int IOCanReadHandler(void *opaque);
220 typedef void IOHandler(void *opaque);
222 void qemu_iohandler_fill(int *pnfds, fd_set *readfds, fd_set *writefds, fd_set *xfds);
223 void qemu_iohandler_poll(fd_set *readfds, fd_set *writefds, fd_set *xfds, int rc);
225 struct ParallelIOArg {
226 void *buffer;
227 int count;
230 typedef int (*DMA_transfer_handler) (void *opaque, int nchan, int pos, int size);
232 /* A load of opaque types so that device init declarations don't have to
233 pull in all the real definitions. */
234 typedef struct NICInfo NICInfo;
235 typedef struct HCIInfo HCIInfo;
236 typedef struct AudioState AudioState;
237 typedef struct BlockDriverState BlockDriverState;
238 typedef struct DriveInfo DriveInfo;
239 typedef struct DisplayState DisplayState;
240 typedef struct DisplayChangeListener DisplayChangeListener;
241 typedef struct DisplaySurface DisplaySurface;
242 typedef struct DisplayAllocator DisplayAllocator;
243 typedef struct PixelFormat PixelFormat;
244 typedef struct TextConsole TextConsole;
245 typedef TextConsole QEMUConsole;
246 typedef struct CharDriverState CharDriverState;
247 typedef struct MACAddr MACAddr;
248 typedef struct VLANState VLANState;
249 typedef struct VLANClientState VLANClientState;
250 typedef struct i2c_bus i2c_bus;
251 typedef struct i2c_slave i2c_slave;
252 typedef struct SMBusDevice SMBusDevice;
253 typedef struct PCIHostState PCIHostState;
254 typedef struct PCIExpressHost PCIExpressHost;
255 typedef struct PCIBus PCIBus;
256 typedef struct PCIDevice PCIDevice;
257 typedef struct PCIExpressDevice PCIExpressDevice;
258 typedef struct PCIBridge PCIBridge;
259 typedef struct PCIEAERMsg PCIEAERMsg;
260 typedef struct PCIEAERLog PCIEAERLog;
261 typedef struct PCIEAERErr PCIEAERErr;
262 typedef struct PCIEPort PCIEPort;
263 typedef struct PCIESlot PCIESlot;
264 typedef struct SerialState SerialState;
265 typedef struct IRQState *qemu_irq;
266 typedef struct PCMCIACardState PCMCIACardState;
267 typedef struct MouseTransformInfo MouseTransformInfo;
268 typedef struct uWireSlave uWireSlave;
269 typedef struct I2SCodec I2SCodec;
270 typedef struct SSIBus SSIBus;
271 typedef struct EventNotifier EventNotifier;
272 typedef struct VirtIODevice VirtIODevice;
274 typedef uint64_t pcibus_t;
276 void cpu_exec_init_all(unsigned long tb_size);
278 /* CPU save/load. */
279 void cpu_save(QEMUFile *f, void *opaque);
280 int cpu_load(QEMUFile *f, void *opaque, int version_id);
282 /* Force QEMU to stop what it's doing and service IO */
283 void qemu_service_io(void);
285 /* Force QEMU to process pending events */
286 void qemu_notify_event(void);
288 /* Unblock cpu */
289 void qemu_cpu_kick(void *env);
290 void qemu_cpu_kick_self(void);
291 int qemu_cpu_is_self(void *env);
292 bool all_cpu_threads_idle(void);
294 /* work queue */
295 struct qemu_work_item {
296 struct qemu_work_item *next;
297 void (*func)(void *data);
298 void *data;
299 int done;
302 #ifdef CONFIG_USER_ONLY
303 #define qemu_init_vcpu(env) do { } while (0)
304 #else
305 void qemu_init_vcpu(void *env);
306 #endif
308 typedef struct QEMUIOVector {
309 struct iovec *iov;
310 int niov;
311 int nalloc;
312 size_t size;
313 } QEMUIOVector;
315 void qemu_iovec_init(QEMUIOVector *qiov, int alloc_hint);
316 void qemu_iovec_init_external(QEMUIOVector *qiov, struct iovec *iov, int niov);
317 void qemu_iovec_add(QEMUIOVector *qiov, void *base, size_t len);
318 void qemu_iovec_copy(QEMUIOVector *dst, QEMUIOVector *src, uint64_t skip,
319 size_t size);
320 void qemu_iovec_concat(QEMUIOVector *dst, QEMUIOVector *src, size_t size);
321 void qemu_iovec_destroy(QEMUIOVector *qiov);
322 void qemu_iovec_reset(QEMUIOVector *qiov);
323 void qemu_iovec_to_buffer(QEMUIOVector *qiov, void *buf);
324 void qemu_iovec_from_buffer(QEMUIOVector *qiov, const void *buf, size_t count);
325 void qemu_iovec_memset(QEMUIOVector *qiov, int c, size_t count);
326 void qemu_iovec_memset_skip(QEMUIOVector *qiov, int c, size_t count,
327 size_t skip);
329 void qemu_progress_init(int enabled, float min_skip);
330 void qemu_progress_end(void);
331 void qemu_progress_print(float delta, int max);
333 #define QEMU_FILE_TYPE_BIOS 0
334 #define QEMU_FILE_TYPE_KEYMAP 1
335 char *qemu_find_file(int type, const char *name);
337 /* OS specific functions */
338 void os_setup_early_signal_handling(void);
339 char *os_find_datadir(const char *argv0);
340 void os_parse_cmd_args(int index, const char *optarg);
341 void os_pidfile_error(void);
343 /* Convert a byte between binary and BCD. */
344 static inline uint8_t to_bcd(uint8_t val)
346 return ((val / 10) << 4) | (val % 10);
349 static inline uint8_t from_bcd(uint8_t val)
351 return ((val >> 4) * 10) + (val & 0x0f);
354 /* compute with 96 bit intermediate result: (a*b)/c */
355 static inline uint64_t muldiv64(uint64_t a, uint32_t b, uint32_t c)
357 union {
358 uint64_t ll;
359 struct {
360 #ifdef HOST_WORDS_BIGENDIAN
361 uint32_t high, low;
362 #else
363 uint32_t low, high;
364 #endif
365 } l;
366 } u, res;
367 uint64_t rl, rh;
369 u.ll = a;
370 rl = (uint64_t)u.l.low * (uint64_t)b;
371 rh = (uint64_t)u.l.high * (uint64_t)b;
372 rh += (rl >> 32);
373 res.l.high = rh / c;
374 res.l.low = (((rh % c) << 32) + (rl & 0xffffffff)) / c;
375 return res.ll;
378 #include "module.h"
380 #endif