Home | History | Annotate | Download | only in qemu
      1 /* Common header file that is included by all of qemu.  */
      2 #ifndef QEMU_COMMON_H
      3 #define QEMU_COMMON_H
      4 
      5 #include "config-host.h"
      6 
      7 #define QEMU_NORETURN __attribute__ ((__noreturn__))
      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;
     20 
     21 struct Monitor;
     22 typedef struct Monitor Monitor;
     23 
     24 /* we put basic includes here to avoid repeating them in device drivers */
     25 #include <stdlib.h>
     26 #include <stdio.h>
     27 #include <stdarg.h>
     28 #include <stdbool.h>
     29 #include <string.h>
     30 #include <strings.h>
     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>
     39 #include <sys/time.h>
     40 #include <assert.h>
     41 
     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 
     50 #ifndef O_LARGEFILE
     51 #define O_LARGEFILE 0
     52 #endif
     53 #ifndef O_BINARY
     54 #define O_BINARY 0
     55 #endif
     56 #ifndef MAP_ANONYMOUS
     57 #define MAP_ANONYMOUS MAP_ANON
     58 #endif
     59 #ifndef ENOMEDIUM
     60 #define ENOMEDIUM ENODEV
     61 #endif
     62 #if !defined(ENOTSUP)
     63 #define ENOTSUP 4096
     64 #endif
     65 #ifndef TIME_MAX
     66 #define TIME_MAX LONG_MAX
     67 #endif
     68 
     69 #ifndef CONFIG_IOVEC
     70 #define CONFIG_IOVEC
     71 struct iovec {
     72     void *iov_base;
     73     size_t iov_len;
     74 };
     75 /*
     76  * Use the same value as Linux for now.
     77  */
     78 #define IOV_MAX		1024
     79 #else
     80 #include <sys/uio.h>
     81 #endif
     82 
     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 
    102 #ifdef _WIN32
    103 #define fsync _commit
    104 #define lseek _lseeki64
    105 int qemu_ftruncate64(int, int64_t);
    106 #define ftruncate qemu_ftruncate64
    107 
    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 
    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 */
    134 typedef void QEMUBHFunc(void *opaque);
    135 
    136 void async_context_push(void);
    137 void async_context_pop(void);
    138 int get_async_context_id(void);
    139 
    140 QEMUBH *qemu_bh_new(QEMUBHFunc *cb, void *opaque);
    141 void qemu_bh_schedule(QEMUBH *bh);
    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);
    149 void qemu_bh_cancel(QEMUBH *bh);
    150 void qemu_bh_delete(QEMUBH *bh);
    151 int qemu_bh_poll(void);
    152 void qemu_bh_update_timeout(int *timeout);
    153 
    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);
    162 int qemu_strnlen(const char *s, int max_len);
    163 time_t mktimegm(struct tm *tm);
    164 int qemu_fls(int i);
    165 int qemu_fdatasync(int fd);
    166 int fcntl_setfl(int fd, int flag);
    167 
    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 
    183 /* path.c */
    184 void init_paths(const char *prefix);
    185 const char *path(const char *pathname);
    186 
    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))
    202 
    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);
    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);
    214 char *qemu_strndup(const char *str, size_t size);
    215 
    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
    225 int qemu_add_child_watch(pid_t pid);
    226 int qemu_eventfd(int pipefd[2]);
    227 int qemu_pipe(int pipefd[2]);
    228 #endif
    229 
    230 void *get_mmap_addr(unsigned long size);
    231 
    232 
    233 /* Error handling.  */
    234 
    235 void QEMU_NORETURN hw_error(const char *fmt, ...) GCC_FMT_ATTR(1, 2);
    236 
    237 /* IO callbacks.  */
    238 typedef void IOReadHandler(void *opaque, const uint8_t *buf, int size);
    239 typedef int IOCanReadHandler(void *opaque);
    240 typedef void IOHandler(void *opaque);
    241 
    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 
    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;
    255 typedef struct HCIInfo HCIInfo;
    256 typedef struct AudioState AudioState;
    257 typedef struct BlockDriverState BlockDriverState;
    258 typedef struct DriveInfo DriveInfo;
    259 typedef struct DisplayState DisplayState;
    260 typedef struct DisplayChangeListener DisplayChangeListener;
    261 typedef struct DisplaySurface DisplaySurface;
    262 typedef struct DisplayAllocator DisplayAllocator;
    263 typedef struct PixelFormat PixelFormat;
    264 typedef struct TextConsole TextConsole;
    265 typedef TextConsole QEMUConsole;
    266 typedef struct CharDriverState CharDriverState;
    267 typedef struct MACAddr MACAddr;
    268 typedef struct VLANState VLANState;
    269 typedef struct VLANClientState VLANClientState;
    270 typedef struct i2c_bus i2c_bus;
    271 typedef struct i2c_slave i2c_slave;
    272 typedef struct SMBusDevice SMBusDevice;
    273 typedef struct PCIHostState PCIHostState;
    274 typedef struct PCIExpressHost PCIExpressHost;
    275 typedef struct PCIBus PCIBus;
    276 typedef struct PCIDevice PCIDevice;
    277 typedef struct SerialState SerialState;
    278 typedef struct IRQState *qemu_irq;
    279 typedef struct PCMCIACardState PCMCIACardState;
    280 typedef struct MouseTransformInfo MouseTransformInfo;
    281 typedef struct uWireSlave uWireSlave;
    282 typedef struct I2SCodec I2SCodec;
    283 typedef struct SSIBus SSIBus;
    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);
    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 
    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 
    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 
    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);
    335 void qemu_iovec_copy(QEMUIOVector *dst, QEMUIOVector *src, uint64_t skip,
    336     size_t size);
    337 void qemu_iovec_concat(QEMUIOVector *dst, QEMUIOVector *src, size_t size);
    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);
    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);
    345 
    346 /* OS specific functions */
    347 void os_setup_early_signal_handling(void);
    348 char *os_find_datadir(const char *argv0);
    349 void os_parse_cmd_args(int index, const char *optarg);
    350 void os_pidfile_error(void);
    351 
    352 /* Convert a byte between binary and BCD.  */
    353 static inline uint8_t to_bcd(uint8_t val)
    354 {
    355     return ((val / 10) << 4) | (val % 10);
    356 }
    357 
    358 static inline uint8_t from_bcd(uint8_t val)
    359 {
    360     return ((val >> 4) * 10) + (val & 0x0f);
    361 }
    362 
    363 /* compute with 96 bit intermediate result: (a*b)/c */
    364 static inline uint64_t muldiv64(uint64_t a, uint32_t b, uint32_t c)
    365 {
    366     union {
    367         uint64_t ll;
    368         struct {
    369 #ifdef HOST_WORDS_BIGENDIAN
    370             uint32_t high, low;
    371 #else
    372             uint32_t low, high;
    373 #endif
    374         } l;
    375     } u, res;
    376     uint64_t rl, rh;
    377 
    378     u.ll = a;
    379     rl = (uint64_t)u.l.low * (uint64_t)b;
    380     rh = (uint64_t)u.l.high * (uint64_t)b;
    381     rh += (rl >> 32);
    382     res.l.high = rh / c;
    383     res.l.low = (((rh % c) << 32) + (rl & 0xffffffff)) / c;
    384     return res.ll;
    385 }
    386 
    387 #include "module.h"
    388 
    389 typedef enum DisplayType
    390 {
    391     DT_DEFAULT,
    392     DT_CURSES,
    393     DT_SDL,
    394     DT_VNC,
    395     DT_NOGRAPHIC,
    396 } DisplayType;
    397 
    398 #endif
    399