The Android Open Source Project | 8b23a6c | 2009-03-03 19:30:32 -0800 | [diff] [blame] | 1 | /* Common header file that is included by all of qemu. */ |
| 2 | #ifndef QEMU_COMMON_H |
| 3 | #define QEMU_COMMON_H |
| 4 | |
David Turner | 6a9ef17 | 2010-09-09 22:54:36 +0200 | [diff] [blame] | 5 | #include "config-host.h" |
| 6 | |
David 'Digit' Turner | 5d8f37a | 2009-09-14 14:32:27 -0700 | [diff] [blame] | 7 | #define QEMU_NORETURN __attribute__ ((__noreturn__)) |
David Turner | 6a9ef17 | 2010-09-09 22:54:36 +0200 | [diff] [blame] | 8 | #ifdef CONFIG_GCC_ATTRIBUTE_WARN_UNUSED_RESULT |
| 9 | #define QEMU_WARN_UNUSED_RESULT __attribute__((warn_unused_result)) |
| 10 | #else |
| 11 | #define QEMU_WARN_UNUSED_RESULT |
| 12 | #endif |
| 13 | |
| 14 | #define QEMU_BUILD_BUG_ON(x) typedef char __build_bug_on__##__LINE__[(x)?-1:1]; |
| 15 | |
| 16 | typedef struct QEMUTimer QEMUTimer; |
| 17 | typedef struct QEMUFile QEMUFile; |
| 18 | typedef struct QEMUBH QEMUBH; |
| 19 | typedef struct DeviceState DeviceState; |
David 'Digit' Turner | 5d8f37a | 2009-09-14 14:32:27 -0700 | [diff] [blame] | 20 | |
David 'Digit' Turner | 45c3be0 | 2011-05-09 14:52:14 +0200 | [diff] [blame] | 21 | struct Monitor; |
| 22 | typedef struct Monitor Monitor; |
David 'Digit' Turner | 5d8f37a | 2009-09-14 14:32:27 -0700 | [diff] [blame] | 23 | |
The Android Open Source Project | 8b23a6c | 2009-03-03 19:30:32 -0800 | [diff] [blame] | 24 | /* we put basic includes here to avoid repeating them in device drivers */ |
| 25 | #include <stdlib.h> |
| 26 | #include <stdio.h> |
The Android Open Source Project | 8b23a6c | 2009-03-03 19:30:32 -0800 | [diff] [blame] | 27 | #include <stdarg.h> |
David Turner | 6a9ef17 | 2010-09-09 22:54:36 +0200 | [diff] [blame] | 28 | #include <stdbool.h> |
The Android Open Source Project | 8b23a6c | 2009-03-03 19:30:32 -0800 | [diff] [blame] | 29 | #include <string.h> |
David 'Digit' Turner | 5d8f37a | 2009-09-14 14:32:27 -0700 | [diff] [blame] | 30 | #include <strings.h> |
The Android Open Source Project | 8b23a6c | 2009-03-03 19:30:32 -0800 | [diff] [blame] | 31 | #include <inttypes.h> |
| 32 | #include <limits.h> |
| 33 | #include <time.h> |
| 34 | #include <ctype.h> |
| 35 | #include <errno.h> |
| 36 | #include <unistd.h> |
| 37 | #include <fcntl.h> |
| 38 | #include <sys/stat.h> |
David 'Digit' Turner | 45c3be0 | 2011-05-09 14:52:14 +0200 | [diff] [blame] | 39 | #include <sys/time.h> |
David 'Digit' Turner | 5d8f37a | 2009-09-14 14:32:27 -0700 | [diff] [blame] | 40 | #include <assert.h> |
The Android Open Source Project | 8b23a6c | 2009-03-03 19:30:32 -0800 | [diff] [blame] | 41 | |
David 'Digit' Turner | 45c3be0 | 2011-05-09 14:52:14 +0200 | [diff] [blame] | 42 | #ifdef _WIN32 |
| 43 | #include "qemu-os-win32.h" |
| 44 | #endif |
| 45 | |
| 46 | #ifdef CONFIG_POSIX |
| 47 | #include "qemu-os-posix.h" |
| 48 | #endif |
| 49 | |
The Android Open Source Project | 8b23a6c | 2009-03-03 19:30:32 -0800 | [diff] [blame] | 50 | #ifndef O_LARGEFILE |
| 51 | #define O_LARGEFILE 0 |
| 52 | #endif |
| 53 | #ifndef O_BINARY |
| 54 | #define O_BINARY 0 |
| 55 | #endif |
David Turner | d065994 | 2010-09-10 10:42:32 +0200 | [diff] [blame] | 56 | #ifndef MAP_ANONYMOUS |
| 57 | #define MAP_ANONYMOUS MAP_ANON |
| 58 | #endif |
The Android Open Source Project | 8b23a6c | 2009-03-03 19:30:32 -0800 | [diff] [blame] | 59 | #ifndef ENOMEDIUM |
| 60 | #define ENOMEDIUM ENODEV |
| 61 | #endif |
David Turner | d065994 | 2010-09-10 10:42:32 +0200 | [diff] [blame] | 62 | #if !defined(ENOTSUP) |
| 63 | #define ENOTSUP 4096 |
| 64 | #endif |
David 'Digit' Turner | 45c3be0 | 2011-05-09 14:52:14 +0200 | [diff] [blame] | 65 | #ifndef TIME_MAX |
| 66 | #define TIME_MAX LONG_MAX |
| 67 | #endif |
The Android Open Source Project | 8b23a6c | 2009-03-03 19:30:32 -0800 | [diff] [blame] | 68 | |
David 'Digit' Turner | 3d66dc7 | 2010-01-27 18:18:41 -0800 | [diff] [blame] | 69 | #ifndef CONFIG_IOVEC |
| 70 | #define CONFIG_IOVEC |
David 'Digit' Turner | 5d8f37a | 2009-09-14 14:32:27 -0700 | [diff] [blame] | 71 | struct iovec { |
| 72 | void *iov_base; |
| 73 | size_t iov_len; |
| 74 | }; |
David Turner | d065994 | 2010-09-10 10:42:32 +0200 | [diff] [blame] | 75 | /* |
| 76 | * Use the same value as Linux for now. |
| 77 | */ |
| 78 | #define IOV_MAX 1024 |
David 'Digit' Turner | 5d8f37a | 2009-09-14 14:32:27 -0700 | [diff] [blame] | 79 | #else |
| 80 | #include <sys/uio.h> |
| 81 | #endif |
| 82 | |
David 'Digit' Turner | 45c3be0 | 2011-05-09 14:52:14 +0200 | [diff] [blame] | 83 | #if defined __GNUC__ |
| 84 | # if (__GNUC__ < 4) || \ |
| 85 | defined(__GNUC_MINOR__) && (__GNUC__ == 4) && (__GNUC_MINOR__ < 4) |
| 86 | /* gcc versions before 4.4.x don't support gnu_printf, so use printf. */ |
| 87 | # define GCC_ATTR __attribute__((__unused__, format(printf, 1, 2))) |
| 88 | # define GCC_FMT_ATTR(n, m) __attribute__((format(printf, n, m))) |
| 89 | # else |
| 90 | /* Use gnu_printf when supported (qemu uses standard format strings). */ |
| 91 | # define GCC_ATTR __attribute__((__unused__, format(gnu_printf, 1, 2))) |
| 92 | # define GCC_FMT_ATTR(n, m) __attribute__((format(gnu_printf, n, m))) |
| 93 | # endif |
| 94 | #else |
| 95 | #define GCC_ATTR /**/ |
| 96 | #define GCC_FMT_ATTR(n, m) |
| 97 | #endif |
| 98 | |
| 99 | typedef int (*fprintf_function)(FILE *f, const char *fmt, ...) |
| 100 | GCC_FMT_ATTR(2, 3); |
| 101 | |
The Android Open Source Project | 8b23a6c | 2009-03-03 19:30:32 -0800 | [diff] [blame] | 102 | #ifdef _WIN32 |
The Android Open Source Project | 8b23a6c | 2009-03-03 19:30:32 -0800 | [diff] [blame] | 103 | #define fsync _commit |
| 104 | #define lseek _lseeki64 |
David 'Digit' Turner | 45c3be0 | 2011-05-09 14:52:14 +0200 | [diff] [blame] | 105 | int qemu_ftruncate64(int, int64_t); |
The Android Open Source Project | 8b23a6c | 2009-03-03 19:30:32 -0800 | [diff] [blame] | 106 | #define ftruncate qemu_ftruncate64 |
| 107 | |
The Android Open Source Project | 8b23a6c | 2009-03-03 19:30:32 -0800 | [diff] [blame] | 108 | static inline char *realpath(const char *path, char *resolved_path) |
| 109 | { |
| 110 | _fullpath(resolved_path, path, _MAX_PATH); |
| 111 | return resolved_path; |
| 112 | } |
| 113 | |
| 114 | #define PRId64 "I64d" |
| 115 | #define PRIx64 "I64x" |
| 116 | #define PRIu64 "I64u" |
| 117 | #define PRIo64 "I64o" |
| 118 | #endif |
| 119 | |
| 120 | /* FIXME: Remove NEED_CPU_H. */ |
| 121 | #ifndef NEED_CPU_H |
| 122 | |
The Android Open Source Project | 8b23a6c | 2009-03-03 19:30:32 -0800 | [diff] [blame] | 123 | #include <setjmp.h> |
| 124 | #include "osdep.h" |
| 125 | #include "bswap.h" |
| 126 | |
| 127 | #else |
| 128 | |
| 129 | #include "cpu.h" |
| 130 | |
| 131 | #endif /* !defined(NEED_CPU_H) */ |
| 132 | |
| 133 | /* bottom halves */ |
The Android Open Source Project | 8b23a6c | 2009-03-03 19:30:32 -0800 | [diff] [blame] | 134 | typedef void QEMUBHFunc(void *opaque); |
| 135 | |
David Turner | d065994 | 2010-09-10 10:42:32 +0200 | [diff] [blame] | 136 | void async_context_push(void); |
| 137 | void async_context_pop(void); |
| 138 | int get_async_context_id(void); |
| 139 | |
The Android Open Source Project | 8b23a6c | 2009-03-03 19:30:32 -0800 | [diff] [blame] | 140 | QEMUBH *qemu_bh_new(QEMUBHFunc *cb, void *opaque); |
| 141 | void qemu_bh_schedule(QEMUBH *bh); |
David 'Digit' Turner | 5d8f37a | 2009-09-14 14:32:27 -0700 | [diff] [blame] | 142 | /* Bottom halfs that are scheduled from a bottom half handler are instantly |
| 143 | * invoked. This can create an infinite loop if a bottom half handler |
| 144 | * schedules itself. qemu_bh_schedule_idle() avoids this infinite loop by |
| 145 | * ensuring that the bottom half isn't executed until the next main loop |
| 146 | * iteration. |
| 147 | */ |
| 148 | void qemu_bh_schedule_idle(QEMUBH *bh); |
The Android Open Source Project | 8b23a6c | 2009-03-03 19:30:32 -0800 | [diff] [blame] | 149 | void qemu_bh_cancel(QEMUBH *bh); |
| 150 | void qemu_bh_delete(QEMUBH *bh); |
| 151 | int qemu_bh_poll(void); |
David Turner | d065994 | 2010-09-10 10:42:32 +0200 | [diff] [blame] | 152 | void qemu_bh_update_timeout(int *timeout); |
The Android Open Source Project | 8b23a6c | 2009-03-03 19:30:32 -0800 | [diff] [blame] | 153 | |
The Android Open Source Project | 8b23a6c | 2009-03-03 19:30:32 -0800 | [diff] [blame] | 154 | void qemu_get_timedate(struct tm *tm, int offset); |
| 155 | int qemu_timedate_diff(struct tm *tm); |
| 156 | |
| 157 | /* cutils.c */ |
| 158 | void pstrcpy(char *buf, int buf_size, const char *str); |
| 159 | char *pstrcat(char *buf, int buf_size, const char *s); |
| 160 | int strstart(const char *str, const char *val, const char **ptr); |
| 161 | int stristart(const char *str, const char *val, const char **ptr); |
David 'Digit' Turner | fd3b1a0 | 2010-05-10 23:47:54 -0700 | [diff] [blame] | 162 | int qemu_strnlen(const char *s, int max_len); |
The Android Open Source Project | 8b23a6c | 2009-03-03 19:30:32 -0800 | [diff] [blame] | 163 | time_t mktimegm(struct tm *tm); |
David 'Digit' Turner | 5d8f37a | 2009-09-14 14:32:27 -0700 | [diff] [blame] | 164 | int qemu_fls(int i); |
David 'Digit' Turner | fd3b1a0 | 2010-05-10 23:47:54 -0700 | [diff] [blame] | 165 | int qemu_fdatasync(int fd); |
David Turner | 6a9ef17 | 2010-09-09 22:54:36 +0200 | [diff] [blame] | 166 | int fcntl_setfl(int fd, int flag); |
David 'Digit' Turner | 5d8f37a | 2009-09-14 14:32:27 -0700 | [diff] [blame] | 167 | |
David 'Digit' Turner | 45c3be0 | 2011-05-09 14:52:14 +0200 | [diff] [blame] | 168 | /* |
| 169 | * strtosz() suffixes used to specify the default treatment of an |
| 170 | * argument passed to strtosz() without an explicit suffix. |
| 171 | * These should be defined using upper case characters in the range |
| 172 | * A-Z, as strtosz() will use qemu_toupper() on the given argument |
| 173 | * prior to comparison. |
| 174 | */ |
| 175 | #define STRTOSZ_DEFSUFFIX_TB 'T' |
| 176 | #define STRTOSZ_DEFSUFFIX_GB 'G' |
| 177 | #define STRTOSZ_DEFSUFFIX_MB 'M' |
| 178 | #define STRTOSZ_DEFSUFFIX_KB 'K' |
| 179 | #define STRTOSZ_DEFSUFFIX_B 'B' |
| 180 | int64_t strtosz(const char *nptr, char **end); |
| 181 | int64_t strtosz_suffix(const char *nptr, char **end, const char default_suffix); |
| 182 | |
David Turner | b919805 | 2010-09-10 11:50:34 +0200 | [diff] [blame] | 183 | /* path.c */ |
| 184 | void init_paths(const char *prefix); |
| 185 | const char *path(const char *pathname); |
| 186 | |
David 'Digit' Turner | 5d8f37a | 2009-09-14 14:32:27 -0700 | [diff] [blame] | 187 | #define qemu_isalnum(c) isalnum((unsigned char)(c)) |
| 188 | #define qemu_isalpha(c) isalpha((unsigned char)(c)) |
| 189 | #define qemu_iscntrl(c) iscntrl((unsigned char)(c)) |
| 190 | #define qemu_isdigit(c) isdigit((unsigned char)(c)) |
| 191 | #define qemu_isgraph(c) isgraph((unsigned char)(c)) |
| 192 | #define qemu_islower(c) islower((unsigned char)(c)) |
| 193 | #define qemu_isprint(c) isprint((unsigned char)(c)) |
| 194 | #define qemu_ispunct(c) ispunct((unsigned char)(c)) |
| 195 | #define qemu_isspace(c) isspace((unsigned char)(c)) |
| 196 | #define qemu_isupper(c) isupper((unsigned char)(c)) |
| 197 | #define qemu_isxdigit(c) isxdigit((unsigned char)(c)) |
| 198 | #define qemu_tolower(c) tolower((unsigned char)(c)) |
| 199 | #define qemu_toupper(c) toupper((unsigned char)(c)) |
| 200 | #define qemu_isascii(c) isascii((unsigned char)(c)) |
| 201 | #define qemu_toascii(c) toascii((unsigned char)(c)) |
The Android Open Source Project | 8b23a6c | 2009-03-03 19:30:32 -0800 | [diff] [blame] | 202 | |
David 'Digit' Turner | 45c3be0 | 2011-05-09 14:52:14 +0200 | [diff] [blame] | 203 | #ifdef _WIN32 |
| 204 | /* ffs() in oslib-win32.c for WIN32, strings.h for the rest of the world */ |
| 205 | int ffs(int i); |
| 206 | #endif |
| 207 | |
| 208 | void *qemu_oom_check(void *ptr); |
The Android Open Source Project | 8b23a6c | 2009-03-03 19:30:32 -0800 | [diff] [blame] | 209 | void *qemu_malloc(size_t size); |
| 210 | void *qemu_realloc(void *ptr, size_t size); |
| 211 | void *qemu_mallocz(size_t size); |
| 212 | void qemu_free(void *ptr); |
| 213 | char *qemu_strdup(const char *str); |
David 'Digit' Turner | 5d8f37a | 2009-09-14 14:32:27 -0700 | [diff] [blame] | 214 | char *qemu_strndup(const char *str, size_t size); |
The Android Open Source Project | 8b23a6c | 2009-03-03 19:30:32 -0800 | [diff] [blame] | 215 | |
David Turner | d065994 | 2010-09-10 10:42:32 +0200 | [diff] [blame] | 216 | void qemu_mutex_lock_iothread(void); |
| 217 | void qemu_mutex_unlock_iothread(void); |
| 218 | |
| 219 | int qemu_open(const char *name, int flags, ...); |
| 220 | ssize_t qemu_write_full(int fd, const void *buf, size_t count) |
| 221 | QEMU_WARN_UNUSED_RESULT; |
| 222 | void qemu_set_cloexec(int fd); |
| 223 | |
| 224 | #ifndef _WIN32 |
David 'Digit' Turner | 8354d2d | 2011-05-11 00:19:06 +0200 | [diff] [blame] | 225 | int qemu_add_child_watch(pid_t pid); |
David Turner | d065994 | 2010-09-10 10:42:32 +0200 | [diff] [blame] | 226 | int qemu_eventfd(int pipefd[2]); |
| 227 | int qemu_pipe(int pipefd[2]); |
| 228 | #endif |
| 229 | |
The Android Open Source Project | 8b23a6c | 2009-03-03 19:30:32 -0800 | [diff] [blame] | 230 | void *get_mmap_addr(unsigned long size); |
| 231 | |
| 232 | |
| 233 | /* Error handling. */ |
| 234 | |
David 'Digit' Turner | 45c3be0 | 2011-05-09 14:52:14 +0200 | [diff] [blame] | 235 | void QEMU_NORETURN hw_error(const char *fmt, ...) GCC_FMT_ATTR(1, 2); |
The Android Open Source Project | 8b23a6c | 2009-03-03 19:30:32 -0800 | [diff] [blame] | 236 | |
| 237 | /* IO callbacks. */ |
| 238 | typedef void IOReadHandler(void *opaque, const uint8_t *buf, int size); |
David Turner | 4143d8f | 2010-09-10 11:05:02 +0200 | [diff] [blame] | 239 | typedef int IOCanReadHandler(void *opaque); |
The Android Open Source Project | 8b23a6c | 2009-03-03 19:30:32 -0800 | [diff] [blame] | 240 | typedef void IOHandler(void *opaque); |
| 241 | |
David 'Digit' Turner | 8354d2d | 2011-05-11 00:19:06 +0200 | [diff] [blame] | 242 | void qemu_iohandler_fill(int *pnfds, fd_set *readfds, fd_set *writefds, fd_set *xfds); |
| 243 | void qemu_iohandler_poll(fd_set *readfds, fd_set *writefds, fd_set *xfds, int rc); |
| 244 | |
The Android Open Source Project | 8b23a6c | 2009-03-03 19:30:32 -0800 | [diff] [blame] | 245 | struct ParallelIOArg { |
| 246 | void *buffer; |
| 247 | int count; |
| 248 | }; |
| 249 | |
| 250 | typedef int (*DMA_transfer_handler) (void *opaque, int nchan, int pos, int size); |
| 251 | |
| 252 | /* A load of opaque types so that device init declarations don't have to |
| 253 | pull in all the real definitions. */ |
| 254 | typedef struct NICInfo NICInfo; |
David 'Digit' Turner | 5d8f37a | 2009-09-14 14:32:27 -0700 | [diff] [blame] | 255 | typedef struct HCIInfo HCIInfo; |
The Android Open Source Project | 8b23a6c | 2009-03-03 19:30:32 -0800 | [diff] [blame] | 256 | typedef struct AudioState AudioState; |
| 257 | typedef struct BlockDriverState BlockDriverState; |
David Turner | d065994 | 2010-09-10 10:42:32 +0200 | [diff] [blame] | 258 | typedef struct DriveInfo DriveInfo; |
The Android Open Source Project | 8b23a6c | 2009-03-03 19:30:32 -0800 | [diff] [blame] | 259 | typedef struct DisplayState DisplayState; |
David 'Digit' Turner | 5d8f37a | 2009-09-14 14:32:27 -0700 | [diff] [blame] | 260 | typedef struct DisplayChangeListener DisplayChangeListener; |
| 261 | typedef struct DisplaySurface DisplaySurface; |
| 262 | typedef struct DisplayAllocator DisplayAllocator; |
| 263 | typedef struct PixelFormat PixelFormat; |
The Android Open Source Project | 8b23a6c | 2009-03-03 19:30:32 -0800 | [diff] [blame] | 264 | typedef struct TextConsole TextConsole; |
| 265 | typedef TextConsole QEMUConsole; |
| 266 | typedef struct CharDriverState CharDriverState; |
David Turner | d065994 | 2010-09-10 10:42:32 +0200 | [diff] [blame] | 267 | typedef struct MACAddr MACAddr; |
The Android Open Source Project | 8b23a6c | 2009-03-03 19:30:32 -0800 | [diff] [blame] | 268 | typedef struct VLANState VLANState; |
David Turner | d065994 | 2010-09-10 10:42:32 +0200 | [diff] [blame] | 269 | typedef struct VLANClientState VLANClientState; |
The Android Open Source Project | 8b23a6c | 2009-03-03 19:30:32 -0800 | [diff] [blame] | 270 | typedef struct i2c_bus i2c_bus; |
| 271 | typedef struct i2c_slave i2c_slave; |
| 272 | typedef struct SMBusDevice SMBusDevice; |
David Turner | d065994 | 2010-09-10 10:42:32 +0200 | [diff] [blame] | 273 | typedef struct PCIHostState PCIHostState; |
| 274 | typedef struct PCIExpressHost PCIExpressHost; |
The Android Open Source Project | 8b23a6c | 2009-03-03 19:30:32 -0800 | [diff] [blame] | 275 | typedef struct PCIBus PCIBus; |
| 276 | typedef struct PCIDevice PCIDevice; |
| 277 | typedef struct SerialState SerialState; |
| 278 | typedef struct IRQState *qemu_irq; |
David 'Digit' Turner | 5d8f37a | 2009-09-14 14:32:27 -0700 | [diff] [blame] | 279 | typedef struct PCMCIACardState PCMCIACardState; |
| 280 | typedef struct MouseTransformInfo MouseTransformInfo; |
| 281 | typedef struct uWireSlave uWireSlave; |
| 282 | typedef struct I2SCodec I2SCodec; |
David 'Digit' Turner | 5d8f37a | 2009-09-14 14:32:27 -0700 | [diff] [blame] | 283 | typedef struct SSIBus SSIBus; |
David Turner | d065994 | 2010-09-10 10:42:32 +0200 | [diff] [blame] | 284 | typedef struct EventNotifier EventNotifier; |
| 285 | typedef struct VirtIODevice VirtIODevice; |
| 286 | |
| 287 | typedef uint64_t pcibus_t; |
| 288 | |
| 289 | typedef enum { |
| 290 | IF_NONE, |
| 291 | IF_IDE, IF_SCSI, IF_FLOPPY, IF_PFLASH, IF_MTD, IF_SD, IF_VIRTIO, IF_XEN, |
| 292 | IF_COUNT |
| 293 | } BlockInterfaceType; |
| 294 | |
| 295 | void cpu_exec_init_all(unsigned long tb_size); |
The Android Open Source Project | 8b23a6c | 2009-03-03 19:30:32 -0800 | [diff] [blame] | 296 | |
| 297 | /* CPU save/load. */ |
| 298 | void cpu_save(QEMUFile *f, void *opaque); |
| 299 | int cpu_load(QEMUFile *f, void *opaque, int version_id); |
| 300 | |
David 'Digit' Turner | 5d8f37a | 2009-09-14 14:32:27 -0700 | [diff] [blame] | 301 | /* Force QEMU to stop what it's doing and service IO */ |
| 302 | void qemu_service_io(void); |
| 303 | |
| 304 | /* Force QEMU to process pending events */ |
| 305 | void qemu_notify_event(void); |
| 306 | |
| 307 | /* Unblock cpu */ |
| 308 | void qemu_cpu_kick(void *env); |
| 309 | int qemu_cpu_self(void *env); |
| 310 | |
David Turner | d065994 | 2010-09-10 10:42:32 +0200 | [diff] [blame] | 311 | /* work queue */ |
| 312 | struct qemu_work_item { |
| 313 | struct qemu_work_item *next; |
| 314 | void (*func)(void *data); |
| 315 | void *data; |
| 316 | int done; |
| 317 | }; |
| 318 | |
David 'Digit' Turner | 5d8f37a | 2009-09-14 14:32:27 -0700 | [diff] [blame] | 319 | #ifdef CONFIG_USER_ONLY |
| 320 | #define qemu_init_vcpu(env) do { } while (0) |
| 321 | #else |
| 322 | void qemu_init_vcpu(void *env); |
| 323 | #endif |
| 324 | |
| 325 | typedef struct QEMUIOVector { |
| 326 | struct iovec *iov; |
| 327 | int niov; |
| 328 | int nalloc; |
| 329 | size_t size; |
| 330 | } QEMUIOVector; |
| 331 | |
| 332 | void qemu_iovec_init(QEMUIOVector *qiov, int alloc_hint); |
| 333 | void qemu_iovec_init_external(QEMUIOVector *qiov, struct iovec *iov, int niov); |
| 334 | void qemu_iovec_add(QEMUIOVector *qiov, void *base, size_t len); |
David 'Digit' Turner | 795bb19 | 2011-05-09 15:20:22 +0200 | [diff] [blame] | 335 | void qemu_iovec_copy(QEMUIOVector *dst, QEMUIOVector *src, uint64_t skip, |
| 336 | size_t size); |
David Turner | d065994 | 2010-09-10 10:42:32 +0200 | [diff] [blame] | 337 | void qemu_iovec_concat(QEMUIOVector *dst, QEMUIOVector *src, size_t size); |
David 'Digit' Turner | 5d8f37a | 2009-09-14 14:32:27 -0700 | [diff] [blame] | 338 | void qemu_iovec_destroy(QEMUIOVector *qiov); |
| 339 | void qemu_iovec_reset(QEMUIOVector *qiov); |
| 340 | void qemu_iovec_to_buffer(QEMUIOVector *qiov, void *buf); |
| 341 | void qemu_iovec_from_buffer(QEMUIOVector *qiov, const void *buf, size_t count); |
David 'Digit' Turner | 795bb19 | 2011-05-09 15:20:22 +0200 | [diff] [blame] | 342 | void qemu_iovec_memset(QEMUIOVector *qiov, int c, size_t count); |
| 343 | void qemu_iovec_memset_skip(QEMUIOVector *qiov, int c, size_t count, |
| 344 | size_t skip); |
David 'Digit' Turner | 5d8f37a | 2009-09-14 14:32:27 -0700 | [diff] [blame] | 345 | |
David Turner | d065994 | 2010-09-10 10:42:32 +0200 | [diff] [blame] | 346 | /* Convert a byte between binary and BCD. */ |
| 347 | static inline uint8_t to_bcd(uint8_t val) |
| 348 | { |
| 349 | return ((val / 10) << 4) | (val % 10); |
| 350 | } |
| 351 | |
| 352 | static inline uint8_t from_bcd(uint8_t val) |
| 353 | { |
| 354 | return ((val >> 4) * 10) + (val & 0x0f); |
| 355 | } |
| 356 | |
David 'Digit' Turner | 795bb19 | 2011-05-09 15:20:22 +0200 | [diff] [blame] | 357 | /* compute with 96 bit intermediate result: (a*b)/c */ |
| 358 | static inline uint64_t muldiv64(uint64_t a, uint32_t b, uint32_t c) |
| 359 | { |
| 360 | union { |
| 361 | uint64_t ll; |
| 362 | struct { |
| 363 | #ifdef HOST_WORDS_BIGENDIAN |
| 364 | uint32_t high, low; |
| 365 | #else |
| 366 | uint32_t low, high; |
| 367 | #endif |
| 368 | } l; |
| 369 | } u, res; |
| 370 | uint64_t rl, rh; |
| 371 | |
| 372 | u.ll = a; |
| 373 | rl = (uint64_t)u.l.low * (uint64_t)b; |
| 374 | rh = (uint64_t)u.l.high * (uint64_t)b; |
| 375 | rh += (rl >> 32); |
| 376 | res.l.high = rh / c; |
| 377 | res.l.low = (((rh % c) << 32) + (rl & 0xffffffff)) / c; |
| 378 | return res.ll; |
| 379 | } |
| 380 | |
David 'Digit' Turner | 5d8f37a | 2009-09-14 14:32:27 -0700 | [diff] [blame] | 381 | #include "module.h" |
| 382 | |
David 'Digit' Turner | f59442f | 2010-10-08 16:22:10 +0200 | [diff] [blame] | 383 | typedef enum DisplayType |
| 384 | { |
| 385 | DT_DEFAULT, |
| 386 | DT_CURSES, |
| 387 | DT_SDL, |
| 388 | DT_VNC, |
| 389 | DT_NOGRAPHIC, |
| 390 | } DisplayType; |
| 391 | |
The Android Open Source Project | 8b23a6c | 2009-03-03 19:30:32 -0800 | [diff] [blame] | 392 | #endif |