]> git.proxmox.com Git - mirror_qemu.git/blame - qemu-common.h
vfio-pci: Don't use kvm_irqchip_in_kernel
[mirror_qemu.git] / qemu-common.h
CommitLineData
9fb26641 1
04509ad9
EH
2/* Common header file that is included by all of QEMU.
3 *
4 * This file is supposed to be included only by .c files. No header file should
5 * depend on qemu-common.h, as this would easily lead to circular header
6 * dependencies.
7 *
8 * If a header file uses a definition from qemu-common.h, that definition
9 * must be moved to a separate header file, and the header that uses it
10 * must include that header.
11 */
faf07963
PB
12#ifndef QEMU_COMMON_H
13#define QEMU_COMMON_H
14
5c026320 15#include "compiler.h"
beb6f0de 16#include "config-host.h"
394e1bb7 17#include "qemu-types.h"
beb6f0de 18
332ae28d
PB
19#if defined(__arm__) || defined(__sparc__) || defined(__mips__) || defined(__hppa__) || defined(__ia64__)
20#define WORDS_ALIGNED
21#endif
22
082b5557 23#define TFR(expr) do { if ((expr) != -1) break; } while (errno == EINTR)
24ebf5f3 24
faf07963
PB
25/* we put basic includes here to avoid repeating them in device drivers */
26#include <stdlib.h>
27#include <stdio.h>
28#include <stdarg.h>
11165820 29#include <stdbool.h>
faf07963 30#include <string.h>
c8906845 31#include <strings.h>
faf07963
PB
32#include <inttypes.h>
33#include <limits.h>
34#include <time.h>
35#include <ctype.h>
36#include <errno.h>
37#include <unistd.h>
38#include <fcntl.h>
39#include <sys/stat.h>
dcfd0865 40#include <sys/time.h>
55616505 41#include <assert.h>
86f69a92 42#include <signal.h>
14015304 43#include <glib.h>
faf07963 44
082b5557
BS
45#ifdef _WIN32
46#include "qemu-os-win32.h"
47#endif
48
49#ifdef CONFIG_POSIX
50#include "qemu-os-posix.h"
51#endif
52
faf07963
PB
53#ifndef O_LARGEFILE
54#define O_LARGEFILE 0
55#endif
56#ifndef O_BINARY
57#define O_BINARY 0
58#endif
0e74e66b
JQ
59#ifndef MAP_ANONYMOUS
60#define MAP_ANONYMOUS MAP_ANON
61#endif
faf07963
PB
62#ifndef ENOMEDIUM
63#define ENOMEDIUM ENODEV
64#endif
4c955388 65#if !defined(ENOTSUP)
2880bc32
JQ
66#define ENOTSUP 4096
67#endif
2084a8e3
PB
68#if !defined(ECANCELED)
69#define ECANCELED 4097
70#endif
3c9405a0
GH
71#ifndef TIME_MAX
72#define TIME_MAX LONG_MAX
73#endif
faf07963 74
c0fd260e
SW
75/* HOST_LONG_BITS is the size of a native pointer in bits. */
76#if UINTPTR_MAX == UINT32_MAX
77# define HOST_LONG_BITS 32
78#elif UINTPTR_MAX == UINT64_MAX
79# define HOST_LONG_BITS 64
80#else
81# error Unknown pointer size
82#endif
83
6114fdb0
JQ
84#ifndef CONFIG_IOVEC
85#define CONFIG_IOVEC
bf9298b9
AL
86struct iovec {
87 void *iov_base;
88 size_t iov_len;
89};
e2a305fb
CH
90/*
91 * Use the same value as Linux for now.
92 */
93#define IOV_MAX 1024
331dadde
BS
94#else
95#include <sys/uio.h>
bf9298b9
AL
96#endif
97
f868445a
SW
98typedef int (*fprintf_function)(FILE *f, const char *fmt, ...)
99 GCC_FMT_ATTR(2, 3);
100
faf07963 101#ifdef _WIN32
faf07963 102#define fsync _commit
371c6489
SW
103#if !defined(lseek)
104# define lseek _lseeki64
105#endif
64b85a8f 106int qemu_ftruncate64(int, int64_t);
371c6489
SW
107#if !defined(ftruncate)
108# define ftruncate qemu_ftruncate64
109#endif
faf07963 110
faf07963
PB
111static inline char *realpath(const char *path, char *resolved_path)
112{
113 _fullpath(resolved_path, path, _MAX_PATH);
114 return resolved_path;
115}
faf07963
PB
116#endif
117
946fb27c
PB
118/* icount */
119void configure_icount(const char *option);
120extern int use_icount;
121
faf07963
PB
122/* FIXME: Remove NEED_CPU_H. */
123#ifndef NEED_CPU_H
124
faf07963
PB
125#include "osdep.h"
126#include "bswap.h"
127
128#else
129
130#include "cpu.h"
131
132#endif /* !defined(NEED_CPU_H) */
133
3bbbee18
AF
134/* main function, renamed */
135#if defined(CONFIG_COCOA)
136int qemu_main(int argc, char **argv, char **envp);
137#endif
138
f6503059
AZ
139void qemu_get_timedate(struct tm *tm, int offset);
140int qemu_timedate_diff(struct tm *tm);
141
c8057f95
PM
142/**
143 * is_help_option:
144 * @s: string to test
145 *
146 * Check whether @s is one of the standard strings which indicate
147 * that the user is asking for a list of the valid values for a
148 * command option like -cpu or -M. The current accepted strings
149 * are 'help' and '?'. '?' is deprecated (it is a shell wildcard
150 * which makes it annoying to use in a reliable way) but provided
151 * for backwards compatibility.
152 *
153 * Returns: true if @s is a request for a list.
154 */
155static inline bool is_help_option(const char *s)
156{
157 return !strcmp(s, "?") || !strcmp(s, "help");
158}
159
faf07963
PB
160/* cutils.c */
161void pstrcpy(char *buf, int buf_size, const char *str);
2a025ae4 162void strpadcpy(char *buf, int buf_size, const char *str, char pad);
faf07963
PB
163char *pstrcat(char *buf, int buf_size, const char *s);
164int strstart(const char *str, const char *val, const char **ptr);
165int stristart(const char *str, const char *val, const char **ptr);
d43277c5 166int qemu_strnlen(const char *s, int max_len);
faf07963 167time_t mktimegm(struct tm *tm);
ad46db9a 168int qemu_fls(int i);
6f1953c4 169int qemu_fdatasync(int fd);
db1a4972 170int fcntl_setfl(int fd, int flag);
443916d1 171int qemu_parse_fd(const char *param);
d8427002 172
d7142456
JS
173/*
174 * strtosz() suffixes used to specify the default treatment of an
175 * argument passed to strtosz() without an explicit suffix.
176 * These should be defined using upper case characters in the range
177 * A-Z, as strtosz() will use qemu_toupper() on the given argument
178 * prior to comparison.
179 */
d8427002
JS
180#define STRTOSZ_DEFSUFFIX_TB 'T'
181#define STRTOSZ_DEFSUFFIX_GB 'G'
182#define STRTOSZ_DEFSUFFIX_MB 'M'
183#define STRTOSZ_DEFSUFFIX_KB 'K'
184#define STRTOSZ_DEFSUFFIX_B 'B'
70b4f4bb
JS
185int64_t strtosz(const char *nptr, char **end);
186int64_t strtosz_suffix(const char *nptr, char **end, const char default_suffix);
a732e1ba
JR
187int64_t strtosz_suffix_unit(const char *nptr, char **end,
188 const char default_suffix, int64_t unit);
faf07963 189
37022086
BS
190/* path.c */
191void init_paths(const char *prefix);
192const char *path(const char *pathname);
193
cd390083
BS
194#define qemu_isalnum(c) isalnum((unsigned char)(c))
195#define qemu_isalpha(c) isalpha((unsigned char)(c))
196#define qemu_iscntrl(c) iscntrl((unsigned char)(c))
197#define qemu_isdigit(c) isdigit((unsigned char)(c))
198#define qemu_isgraph(c) isgraph((unsigned char)(c))
199#define qemu_islower(c) islower((unsigned char)(c))
200#define qemu_isprint(c) isprint((unsigned char)(c))
201#define qemu_ispunct(c) ispunct((unsigned char)(c))
202#define qemu_isspace(c) isspace((unsigned char)(c))
203#define qemu_isupper(c) isupper((unsigned char)(c))
204#define qemu_isxdigit(c) isxdigit((unsigned char)(c))
205#define qemu_tolower(c) tolower((unsigned char)(c))
206#define qemu_toupper(c) toupper((unsigned char)(c))
207#define qemu_isascii(c) isascii((unsigned char)(c))
208#define qemu_toascii(c) toascii((unsigned char)(c))
209
b152aa84 210void *qemu_oom_check(void *ptr);
ca10f867 211
7c7c0629
JQ
212ssize_t qemu_write_full(int fd, const void *buf, size_t count)
213 QEMU_WARN_UNUSED_RESULT;
993295fe
PB
214ssize_t qemu_send_full(int fd, const void *buf, size_t count, int flags)
215 QEMU_WARN_UNUSED_RESULT;
8c5135f9 216ssize_t qemu_recv_full(int fd, void *buf, size_t count, int flags)
993295fe 217 QEMU_WARN_UNUSED_RESULT;
40ff6d7e
KW
218
219#ifndef _WIN32
220int qemu_pipe(int pipefd[2]);
221#endif
222
00aa0040 223#ifdef _WIN32
58455eb9
SW
224/* MinGW needs type casts for the 'buf' and 'optval' arguments. */
225#define qemu_getsockopt(sockfd, level, optname, optval, optlen) \
226 getsockopt(sockfd, level, optname, (void *)optval, optlen)
227#define qemu_setsockopt(sockfd, level, optname, optval, optlen) \
228 setsockopt(sockfd, level, optname, (const void *)optval, optlen)
00aa0040 229#define qemu_recv(sockfd, buf, len, flags) recv(sockfd, (void *)buf, len, flags)
73062dfe
SW
230#define qemu_sendto(sockfd, buf, len, flags, destaddr, addrlen) \
231 sendto(sockfd, (const void *)buf, len, flags, destaddr, addrlen)
00aa0040 232#else
58455eb9
SW
233#define qemu_getsockopt(sockfd, level, optname, optval, optlen) \
234 getsockopt(sockfd, level, optname, optval, optlen)
235#define qemu_setsockopt(sockfd, level, optname, optval, optlen) \
236 setsockopt(sockfd, level, optname, optval, optlen)
00aa0040 237#define qemu_recv(sockfd, buf, len, flags) recv(sockfd, buf, len, flags)
73062dfe
SW
238#define qemu_sendto(sockfd, buf, len, flags, destaddr, addrlen) \
239 sendto(sockfd, buf, len, flags, destaddr, addrlen)
00aa0040
BS
240#endif
241
87ecb68b
PB
242/* Error handling. */
243
e5924d89 244void QEMU_NORETURN hw_error(const char *fmt, ...) GCC_FMT_ATTR(1, 2);
87ecb68b 245
87ecb68b
PB
246struct ParallelIOArg {
247 void *buffer;
248 int count;
249};
250
251typedef int (*DMA_transfer_handler) (void *opaque, int nchan, int pos, int size);
252
186993ee
MT
253typedef uint64_t pcibus_t;
254
4e4fa398
JK
255typedef enum LostTickPolicy {
256 LOST_TICK_DISCARD,
257 LOST_TICK_DELAY,
258 LOST_TICK_MERGE,
259 LOST_TICK_SLEW,
1ce05125 260 LOST_TICK_MAX
4e4fa398
JK
261} LostTickPolicy;
262
679042f0
AP
263typedef struct PCIHostDeviceAddress {
264 unsigned int domain;
265 unsigned int bus;
266 unsigned int slot;
267 unsigned int function;
268} PCIHostDeviceAddress;
269
d5ab9713
JK
270void tcg_exec_init(unsigned long tb_size);
271bool tcg_enabled(void);
272
273void cpu_exec_init_all(void);
d2053c3c 274
b3c7724c
PB
275/* CPU save/load. */
276void cpu_save(QEMUFile *f, void *opaque);
277int cpu_load(QEMUFile *f, void *opaque, int version_id);
278
8edac960 279/* Unblock cpu */
46d62fac 280void qemu_cpu_kick_self(void);
8edac960 281
e82bcec2
MT
282/* work queue */
283struct qemu_work_item {
284 struct qemu_work_item *next;
285 void (*func)(void *data);
286 void *data;
287 int done;
288};
289
0bf46a40
AL
290#ifdef CONFIG_USER_ONLY
291#define qemu_init_vcpu(env) do { } while (0)
292#else
293void qemu_init_vcpu(void *env);
294#endif
295
8c5135f9
PB
296
297/**
2fc8ae1d
MT
298 * Sends a (part of) iovec down a socket, yielding when the socket is full, or
299 * Receives data into a (part of) iovec from a socket,
300 * yielding when there is no data in the socket.
301 * The same interface as qemu_sendv_recvv(), with added yielding.
302 * XXX should mark these as coroutine_fn
8c5135f9 303 */
2fc8ae1d
MT
304ssize_t qemu_co_sendv_recvv(int sockfd, struct iovec *iov, unsigned iov_cnt,
305 size_t offset, size_t bytes, bool do_send);
306#define qemu_co_recvv(sockfd, iov, iov_cnt, offset, bytes) \
307 qemu_co_sendv_recvv(sockfd, iov, iov_cnt, offset, bytes, false)
308#define qemu_co_sendv(sockfd, iov, iov_cnt, offset, bytes) \
309 qemu_co_sendv_recvv(sockfd, iov, iov_cnt, offset, bytes, true)
8c5135f9
PB
310
311/**
2fc8ae1d 312 * The same as above, but with just a single buffer
8c5135f9 313 */
2fc8ae1d
MT
314ssize_t qemu_co_send_recv(int sockfd, void *buf, size_t bytes, bool do_send);
315#define qemu_co_recv(sockfd, buf, bytes) \
316 qemu_co_send_recv(sockfd, buf, bytes, false)
317#define qemu_co_send(sockfd, buf, bytes) \
318 qemu_co_send_recv(sockfd, buf, bytes, true)
8c5135f9 319
44e3ee8a
AL
320typedef struct QEMUIOVector {
321 struct iovec *iov;
322 int niov;
323 int nalloc;
249aa745 324 size_t size;
44e3ee8a
AL
325} QEMUIOVector;
326
327void qemu_iovec_init(QEMUIOVector *qiov, int alloc_hint);
522584a5 328void qemu_iovec_init_external(QEMUIOVector *qiov, struct iovec *iov, int niov);
44e3ee8a 329void qemu_iovec_add(QEMUIOVector *qiov, void *base, size_t len);
1b093c48
MT
330void qemu_iovec_concat(QEMUIOVector *dst,
331 QEMUIOVector *src, size_t soffset, size_t sbytes);
44e3ee8a 332void qemu_iovec_destroy(QEMUIOVector *qiov);
be959463 333void qemu_iovec_reset(QEMUIOVector *qiov);
d5e6b161
MT
334size_t qemu_iovec_to_buf(QEMUIOVector *qiov, size_t offset,
335 void *buf, size_t bytes);
03396148
MT
336size_t qemu_iovec_from_buf(QEMUIOVector *qiov, size_t offset,
337 const void *buf, size_t bytes);
3d9b4925
MT
338size_t qemu_iovec_memset(QEMUIOVector *qiov, size_t offset,
339 int fillc, size_t bytes);
44e3ee8a 340
1a6d39fd
SH
341bool buffer_is_zero(const void *buf, size_t len);
342
6b837bc4
JS
343void qemu_progress_init(int enabled, float min_skip);
344void qemu_progress_end(void);
3bfe4dbf 345void qemu_progress_print(float delta, int max);
31459f46 346const char *qemu_get_vm_name(void);
6b837bc4 347
082b5557
BS
348#define QEMU_FILE_TYPE_BIOS 0
349#define QEMU_FILE_TYPE_KEYMAP 1
350char *qemu_find_file(int type, const char *name);
351
352/* OS specific functions */
353void os_setup_early_signal_handling(void);
354char *os_find_datadir(const char *argv0);
355void os_parse_cmd_args(int index, const char *optarg);
356void os_pidfile_error(void);
357
abd0c6bd
PB
358/* Convert a byte between binary and BCD. */
359static inline uint8_t to_bcd(uint8_t val)
360{
361 return ((val / 10) << 4) | (val % 10);
362}
363
364static inline uint8_t from_bcd(uint8_t val)
365{
366 return ((val >> 4) * 10) + (val & 0x0f);
367}
368
338b922e 369/* compute with 96 bit intermediate result: (a*b)/c */
370static inline uint64_t muldiv64(uint64_t a, uint32_t b, uint32_t c)
371{
372 union {
373 uint64_t ll;
374 struct {
375#ifdef HOST_WORDS_BIGENDIAN
376 uint32_t high, low;
377#else
378 uint32_t low, high;
379#endif
380 } l;
381 } u, res;
382 uint64_t rl, rh;
383
384 u.ll = a;
385 rl = (uint64_t)u.l.low * (uint64_t)b;
386 rh = (uint64_t)u.l.high * (uint64_t)b;
387 rh += (rl >> 32);
388 res.l.high = rh / c;
389 res.l.low = (((rh % c) << 32) + (rl & 0xffffffff)) / c;
390 return res.ll;
391}
392
3951690a
SH
393/* Round number down to multiple */
394#define QEMU_ALIGN_DOWN(n, m) ((n) / (m) * (m))
395
396/* Round number up to multiple */
397#define QEMU_ALIGN_UP(n, m) QEMU_ALIGN_DOWN((n) + (m) - 1, (m))
398
9fb26641
OW
399static inline bool is_power_of_2(uint64_t value)
400{
401 if (!value) {
402 return 0;
403 }
404
405 return !(value & (value - 1));
406}
407
408/* round down to the nearest power of 2*/
409int64_t pow2floor(int64_t value);
410
0bfe3ca5
AL
411#include "module.h"
412
e6546bb9
OW
413/*
414 * Implementation of ULEB128 (http://en.wikipedia.org/wiki/LEB128)
415 * Input is limited to 14-bit numbers
416 */
417
418int uleb128_encode_small(uint8_t *out, uint32_t n);
419int uleb128_decode_small(const uint8_t *in, uint32_t *n);
420
faf07963 421#endif