Annotation of qemu/qemu-common.h, revision 1.1.1.2

1.1       root        1: /* Common header file that is included by all of qemu.  */
                      2: #ifndef QEMU_COMMON_H
                      3: #define QEMU_COMMON_H
                      4: 
1.1.1.2 ! root        5: #ifdef _WIN32
        !             6: #define WIN32_LEAN_AND_MEAN
        !             7: #define WINVER 0x0501  /* needed for ipv6 bits */
        !             8: #include <windows.h>
        !             9: #endif
        !            10: 
        !            11: #define QEMU_NORETURN __attribute__ ((__noreturn__))
        !            12: 
        !            13: /* Hack around the mess dyngen-exec.h causes: We need QEMU_NORETURN in files that
        !            14:    cannot include the following headers without conflicts. This condition has
        !            15:    to be removed once dyngen is gone. */
        !            16: #ifndef __DYNGEN_EXEC_H__
        !            17: 
1.1       root       18: /* we put basic includes here to avoid repeating them in device drivers */
                     19: #include <stdlib.h>
                     20: #include <stdio.h>
                     21: #include <stdarg.h>
                     22: #include <string.h>
1.1.1.2 ! root       23: #include <strings.h>
1.1       root       24: #include <inttypes.h>
                     25: #include <limits.h>
                     26: #include <time.h>
                     27: #include <ctype.h>
                     28: #include <errno.h>
                     29: #include <unistd.h>
                     30: #include <fcntl.h>
                     31: #include <sys/stat.h>
1.1.1.2 ! root       32: #include "config-host.h"
1.1       root       33: 
                     34: #ifndef O_LARGEFILE
                     35: #define O_LARGEFILE 0
                     36: #endif
                     37: #ifndef O_BINARY
                     38: #define O_BINARY 0
                     39: #endif
                     40: 
                     41: #ifndef ENOMEDIUM
                     42: #define ENOMEDIUM ENODEV
                     43: #endif
                     44: 
1.1.1.2 ! root       45: #ifndef HAVE_IOVEC
        !            46: #define HAVE_IOVEC
        !            47: struct iovec {
        !            48:     void *iov_base;
        !            49:     size_t iov_len;
        !            50: };
        !            51: #else
        !            52: #include <sys/uio.h>
        !            53: #endif
        !            54: 
1.1       root       55: #ifdef _WIN32
                     56: #define fsync _commit
                     57: #define lseek _lseeki64
                     58: #define ENOTSUP 4096
                     59: extern int qemu_ftruncate64(int, int64_t);
                     60: #define ftruncate qemu_ftruncate64
                     61: 
                     62: 
                     63: static inline char *realpath(const char *path, char *resolved_path)
                     64: {
                     65:     _fullpath(resolved_path, path, _MAX_PATH);
                     66:     return resolved_path;
                     67: }
                     68: 
                     69: #define PRId64 "I64d"
                     70: #define PRIx64 "I64x"
                     71: #define PRIu64 "I64u"
                     72: #define PRIo64 "I64o"
                     73: #endif
                     74: 
                     75: /* FIXME: Remove NEED_CPU_H.  */
                     76: #ifndef NEED_CPU_H
                     77: 
                     78: #include <setjmp.h>
                     79: #include "osdep.h"
                     80: #include "bswap.h"
                     81: 
                     82: #else
                     83: 
                     84: #include "cpu.h"
                     85: 
                     86: #endif /* !defined(NEED_CPU_H) */
                     87: 
                     88: /* bottom halves */
                     89: typedef struct QEMUBH QEMUBH;
                     90: 
                     91: typedef void QEMUBHFunc(void *opaque);
                     92: 
                     93: QEMUBH *qemu_bh_new(QEMUBHFunc *cb, void *opaque);
                     94: void qemu_bh_schedule(QEMUBH *bh);
1.1.1.2 ! root       95: /* Bottom halfs that are scheduled from a bottom half handler are instantly
        !            96:  * invoked.  This can create an infinite loop if a bottom half handler
        !            97:  * schedules itself.  qemu_bh_schedule_idle() avoids this infinite loop by
        !            98:  * ensuring that the bottom half isn't executed until the next main loop
        !            99:  * iteration.
        !           100:  */
        !           101: void qemu_bh_schedule_idle(QEMUBH *bh);
1.1       root      102: void qemu_bh_cancel(QEMUBH *bh);
                    103: void qemu_bh_delete(QEMUBH *bh);
                    104: int qemu_bh_poll(void);
                    105: 
                    106: uint64_t muldiv64(uint64_t a, uint32_t b, uint32_t c);
                    107: 
1.1.1.2 ! root      108: void qemu_get_timedate(struct tm *tm, int offset);
        !           109: int qemu_timedate_diff(struct tm *tm);
        !           110: 
1.1       root      111: /* cutils.c */
                    112: void pstrcpy(char *buf, int buf_size, const char *str);
                    113: char *pstrcat(char *buf, int buf_size, const char *s);
                    114: int strstart(const char *str, const char *val, const char **ptr);
                    115: int stristart(const char *str, const char *val, const char **ptr);
                    116: time_t mktimegm(struct tm *tm);
1.1.1.2 ! root      117: int qemu_fls(int i);
        !           118: 
        !           119: #define qemu_isalnum(c)                isalnum((unsigned char)(c))
        !           120: #define qemu_isalpha(c)                isalpha((unsigned char)(c))
        !           121: #define qemu_iscntrl(c)                iscntrl((unsigned char)(c))
        !           122: #define qemu_isdigit(c)                isdigit((unsigned char)(c))
        !           123: #define qemu_isgraph(c)                isgraph((unsigned char)(c))
        !           124: #define qemu_islower(c)                islower((unsigned char)(c))
        !           125: #define qemu_isprint(c)                isprint((unsigned char)(c))
        !           126: #define qemu_ispunct(c)                ispunct((unsigned char)(c))
        !           127: #define qemu_isspace(c)                isspace((unsigned char)(c))
        !           128: #define qemu_isupper(c)                isupper((unsigned char)(c))
        !           129: #define qemu_isxdigit(c)       isxdigit((unsigned char)(c))
        !           130: #define qemu_tolower(c)                tolower((unsigned char)(c))
        !           131: #define qemu_toupper(c)                toupper((unsigned char)(c))
        !           132: #define qemu_isascii(c)                isascii((unsigned char)(c))
        !           133: #define qemu_toascii(c)                toascii((unsigned char)(c))
        !           134: 
        !           135: void *qemu_malloc(size_t size);
        !           136: void *qemu_realloc(void *ptr, size_t size);
        !           137: void *qemu_mallocz(size_t size);
        !           138: void qemu_free(void *ptr);
        !           139: char *qemu_strdup(const char *str);
        !           140: char *qemu_strndup(const char *str, size_t size);
        !           141: 
        !           142: void *get_mmap_addr(unsigned long size);
        !           143: 
1.1       root      144: 
                    145: /* Error handling.  */
                    146: 
1.1.1.2 ! root      147: void QEMU_NORETURN hw_error(const char *fmt, ...)
        !           148:     __attribute__ ((__format__ (__printf__, 1, 2)));
1.1       root      149: 
                    150: /* IO callbacks.  */
                    151: typedef void IOReadHandler(void *opaque, const uint8_t *buf, int size);
                    152: typedef int IOCanRWHandler(void *opaque);
                    153: typedef void IOHandler(void *opaque);
                    154: 
                    155: struct ParallelIOArg {
                    156:     void *buffer;
                    157:     int count;
                    158: };
                    159: 
                    160: typedef int (*DMA_transfer_handler) (void *opaque, int nchan, int pos, int size);
                    161: 
                    162: /* A load of opaque types so that device init declarations don't have to
                    163:    pull in all the real definitions.  */
                    164: typedef struct NICInfo NICInfo;
1.1.1.2 ! root      165: typedef struct HCIInfo HCIInfo;
1.1       root      166: typedef struct AudioState AudioState;
                    167: typedef struct BlockDriverState BlockDriverState;
                    168: typedef struct DisplayState DisplayState;
1.1.1.2 ! root      169: typedef struct DisplayChangeListener DisplayChangeListener;
        !           170: typedef struct DisplaySurface DisplaySurface;
        !           171: typedef struct PixelFormat PixelFormat;
1.1       root      172: typedef struct TextConsole TextConsole;
1.1.1.2 ! root      173: typedef TextConsole QEMUConsole;
1.1       root      174: typedef struct CharDriverState CharDriverState;
                    175: typedef struct VLANState VLANState;
                    176: typedef struct QEMUFile QEMUFile;
                    177: typedef struct i2c_bus i2c_bus;
                    178: typedef struct i2c_slave i2c_slave;
                    179: typedef struct SMBusDevice SMBusDevice;
                    180: typedef struct QEMUTimer QEMUTimer;
                    181: typedef struct PCIBus PCIBus;
                    182: typedef struct PCIDevice PCIDevice;
                    183: typedef struct SerialState SerialState;
                    184: typedef struct IRQState *qemu_irq;
                    185: struct pcmcia_card_s;
                    186: 
1.1.1.2 ! root      187: /* CPU save/load.  */
        !           188: void cpu_save(QEMUFile *f, void *opaque);
        !           189: int cpu_load(QEMUFile *f, void *opaque, int version_id);
        !           190: 
        !           191: /* Force QEMU to stop what it's doing and service IO */
        !           192: void qemu_service_io(void);
        !           193: 
        !           194: typedef struct QEMUIOVector {
        !           195:     struct iovec *iov;
        !           196:     int niov;
        !           197:     int nalloc;
        !           198:     size_t size;
        !           199: } QEMUIOVector;
        !           200: 
        !           201: void qemu_iovec_init(QEMUIOVector *qiov, int alloc_hint);
        !           202: void qemu_iovec_add(QEMUIOVector *qiov, void *base, size_t len);
        !           203: void qemu_iovec_destroy(QEMUIOVector *qiov);
        !           204: void qemu_iovec_reset(QEMUIOVector *qiov);
        !           205: void qemu_iovec_to_buffer(QEMUIOVector *qiov, void *buf);
        !           206: void qemu_iovec_from_buffer(QEMUIOVector *qiov, const void *buf, size_t count);
        !           207: 
        !           208: #endif /* dyngen-exec.h hack */
        !           209: 
1.1       root      210: #endif

unix.superglobalmegacorp.com