Annotation of qemu/qemu-char.h, revision 1.1.1.10

1.1       root        1: #ifndef QEMU_CHAR_H
                      2: #define QEMU_CHAR_H
                      3: 
1.1.1.4   root        4: #include "qemu-common.h"
1.1.1.5   root        5: #include "qemu-queue.h"
                      6: #include "qemu-option.h"
                      7: #include "qemu-config.h"
                      8: #include "qobject.h"
1.1.1.7   root        9: #include "qstring.h"
1.1.1.9   root       10: #include "main-loop.h"
1.1.1.4   root       11: 
1.1       root       12: /* character device */
                     13: 
1.1.1.4   root       14: #define CHR_EVENT_BREAK   0 /* serial break char */
                     15: #define CHR_EVENT_FOCUS   1 /* focus to this terminal (modal input needed) */
1.1.1.5   root       16: #define CHR_EVENT_OPENED  2 /* new connection established */
1.1.1.4   root       17: #define CHR_EVENT_MUX_IN  3 /* mux-focus was set to this terminal */
                     18: #define CHR_EVENT_MUX_OUT 4 /* mux-focus will move on */
1.1.1.5   root       19: #define CHR_EVENT_CLOSED  5 /* connection closed */
1.1       root       20: 
                     21: 
                     22: #define CHR_IOCTL_SERIAL_SET_PARAMS   1
                     23: typedef struct {
                     24:     int speed;
                     25:     int parity;
                     26:     int data_bits;
                     27:     int stop_bits;
                     28: } QEMUSerialSetParams;
                     29: 
                     30: #define CHR_IOCTL_SERIAL_SET_BREAK    2
                     31: 
                     32: #define CHR_IOCTL_PP_READ_DATA        3
                     33: #define CHR_IOCTL_PP_WRITE_DATA       4
                     34: #define CHR_IOCTL_PP_READ_CONTROL     5
                     35: #define CHR_IOCTL_PP_WRITE_CONTROL    6
                     36: #define CHR_IOCTL_PP_READ_STATUS      7
                     37: #define CHR_IOCTL_PP_EPP_READ_ADDR    8
                     38: #define CHR_IOCTL_PP_EPP_READ         9
                     39: #define CHR_IOCTL_PP_EPP_WRITE_ADDR  10
                     40: #define CHR_IOCTL_PP_EPP_WRITE       11
1.1.1.2   root       41: #define CHR_IOCTL_PP_DATA_DIR        12
                     42: 
                     43: #define CHR_IOCTL_SERIAL_SET_TIOCM   13
                     44: #define CHR_IOCTL_SERIAL_GET_TIOCM   14
                     45: 
                     46: #define CHR_TIOCM_CTS  0x020
                     47: #define CHR_TIOCM_CAR  0x040
                     48: #define CHR_TIOCM_DSR  0x100
                     49: #define CHR_TIOCM_RI   0x080
                     50: #define CHR_TIOCM_DTR  0x002
                     51: #define CHR_TIOCM_RTS  0x004
1.1       root       52: 
                     53: typedef void IOEventHandler(void *opaque, int event);
                     54: 
                     55: struct CharDriverState {
1.1.1.2   root       56:     void (*init)(struct CharDriverState *s);
1.1       root       57:     int (*chr_write)(struct CharDriverState *s, const uint8_t *buf, int len);
                     58:     void (*chr_update_read_handler)(struct CharDriverState *s);
                     59:     int (*chr_ioctl)(struct CharDriverState *s, int cmd, void *arg);
1.1.1.4   root       60:     int (*get_msgfd)(struct CharDriverState *s);
1.1.1.8   root       61:     int (*chr_add_client)(struct CharDriverState *chr, int fd);
1.1       root       62:     IOEventHandler *chr_event;
1.1.1.6   root       63:     IOCanReadHandler *chr_can_read;
1.1       root       64:     IOReadHandler *chr_read;
                     65:     void *handler_opaque;
                     66:     void (*chr_close)(struct CharDriverState *chr);
                     67:     void (*chr_accept_input)(struct CharDriverState *chr);
1.1.1.7   root       68:     void (*chr_set_echo)(struct CharDriverState *chr, bool echo);
1.1.1.8   root       69:     void (*chr_guest_open)(struct CharDriverState *chr);
                     70:     void (*chr_guest_close)(struct CharDriverState *chr);
1.1       root       71:     void *opaque;
                     72:     QEMUBH *bh;
1.1.1.2   root       73:     char *label;
                     74:     char *filename;
1.1.1.6   root       75:     int opened;
1.1.1.8   root       76:     int avail_connections;
1.1.1.5   root       77:     QTAILQ_ENTRY(CharDriverState) next;
1.1       root       78: };
                     79: 
1.1.1.9   root       80: /**
                     81:  * @qemu_chr_new_from_opts:
                     82:  *
                     83:  * Create a new character backend from a QemuOpts list.
                     84:  *
                     85:  * @opts see qemu-config.c for a list of valid options
                     86:  * @init not sure..
                     87:  *
                     88:  * Returns: a new character backend
                     89:  */
                     90: CharDriverState *qemu_chr_new_from_opts(QemuOpts *opts,
1.1.1.5   root       91:                                     void (*init)(struct CharDriverState *s));
1.1.1.9   root       92: 
                     93: /**
                     94:  * @qemu_chr_new:
                     95:  *
                     96:  * Create a new character backend from a URI.
                     97:  *
                     98:  * @label the name of the backend
                     99:  * @filename the URI
                    100:  * @init not sure..
                    101:  *
                    102:  * Returns: a new character backend
                    103:  */
                    104: CharDriverState *qemu_chr_new(const char *label, const char *filename,
                    105:                               void (*init)(struct CharDriverState *s));
                    106: 
                    107: /**
                    108:  * @qemu_chr_delete:
                    109:  *
                    110:  * Destroy a character backend.
                    111:  */
                    112: void qemu_chr_delete(CharDriverState *chr);
                    113: 
                    114: /**
                    115:  * @qemu_chr_fe_set_echo:
                    116:  *
                    117:  * Ask the backend to override its normal echo setting.  This only really
                    118:  * applies to the stdio backend and is used by the QMP server such that you
                    119:  * can see what you type if you try to type QMP commands.
                    120:  *
                    121:  * @echo true to enable echo, false to disable echo
                    122:  */
                    123: void qemu_chr_fe_set_echo(struct CharDriverState *chr, bool echo);
                    124: 
                    125: /**
                    126:  * @qemu_chr_fe_open:
                    127:  *
                    128:  * Open a character backend.  This function call is an indication that the
                    129:  * front end is ready to begin doing I/O.
                    130:  */
                    131: void qemu_chr_fe_open(struct CharDriverState *chr);
                    132: 
                    133: /**
                    134:  * @qemu_chr_fe_close:
                    135:  *
                    136:  * Close a character backend.  This function call indicates that the front end
                    137:  * no longer is able to process I/O.  To process I/O again, the front end will
                    138:  * call @qemu_chr_fe_open.
                    139:  */
                    140: void qemu_chr_fe_close(struct CharDriverState *chr);
                    141: 
                    142: /**
                    143:  * @qemu_chr_fe_printf:
                    144:  *
                    145:  * Write to a character backend using a printf style interface.
                    146:  *
                    147:  * @fmt see #printf
                    148:  */
                    149: void qemu_chr_fe_printf(CharDriverState *s, const char *fmt, ...)
1.1.1.7   root      150:     GCC_FMT_ATTR(2, 3);
1.1.1.9   root      151: 
                    152: /**
                    153:  * @qemu_chr_fe_write:
                    154:  *
                    155:  * Write data to a character backend from the front end.  This function will
                    156:  * send data from the front end to the back end.
                    157:  *
                    158:  * @buf the data
                    159:  * @len the number of bytes to send
                    160:  *
                    161:  * Returns: the number of bytes consumed
                    162:  */
                    163: int qemu_chr_fe_write(CharDriverState *s, const uint8_t *buf, int len);
                    164: 
                    165: /**
                    166:  * @qemu_chr_fe_ioctl:
                    167:  *
                    168:  * Issue a device specific ioctl to a backend.
                    169:  *
                    170:  * @cmd see CHR_IOCTL_*
                    171:  * @arg the data associated with @cmd
                    172:  *
                    173:  * Returns: if @cmd is not supported by the backend, -ENOTSUP, otherwise the
                    174:  *          return value depends on the semantics of @cmd
                    175:  */
                    176: int qemu_chr_fe_ioctl(CharDriverState *s, int cmd, void *arg);
                    177: 
                    178: /**
                    179:  * @qemu_chr_fe_get_msgfd:
                    180:  *
                    181:  * For backends capable of fd passing, return the latest file descriptor passed
                    182:  * by a client.
                    183:  *
                    184:  * Returns: -1 if fd passing isn't supported or there is no pending file
                    185:  *          descriptor.  If a file descriptor is returned, subsequent calls to
                    186:  *          this function will return -1 until a client sends a new file
                    187:  *          descriptor.
                    188:  */
                    189: int qemu_chr_fe_get_msgfd(CharDriverState *s);
                    190: 
                    191: /**
                    192:  * @qemu_chr_be_can_write:
                    193:  *
                    194:  * Determine how much data the front end can currently accept.  This function
                    195:  * returns the number of bytes the front end can accept.  If it returns 0, the
                    196:  * front end cannot receive data at the moment.  The function must be polled
                    197:  * to determine when data can be received.
                    198:  *
                    199:  * Returns: the number of bytes the front end can receive via @qemu_chr_be_write
                    200:  */
                    201: int qemu_chr_be_can_write(CharDriverState *s);
                    202: 
                    203: /**
                    204:  * @qemu_chr_be_write:
                    205:  *
                    206:  * Write data from the back end to the front end.  Before issuing this call,
                    207:  * the caller should call @qemu_chr_be_can_write to determine how much data
                    208:  * the front end can currently accept.
                    209:  *
                    210:  * @buf a buffer to receive data from the front end
                    211:  * @len the number of bytes to receive from the front end
                    212:  */
                    213: void qemu_chr_be_write(CharDriverState *s, uint8_t *buf, int len);
                    214: 
                    215: 
                    216: /**
                    217:  * @qemu_chr_be_event:
                    218:  *
                    219:  * Send an event from the back end to the front end.
                    220:  *
                    221:  * @event the event to send
                    222:  */
                    223: void qemu_chr_be_event(CharDriverState *s, int event);
                    224: 
1.1       root      225: void qemu_chr_add_handlers(CharDriverState *s,
1.1.1.6   root      226:                            IOCanReadHandler *fd_can_read,
1.1       root      227:                            IOReadHandler *fd_read,
                    228:                            IOEventHandler *fd_event,
                    229:                            void *opaque);
1.1.1.9   root      230: 
1.1.1.5   root      231: void qemu_chr_generic_open(CharDriverState *s);
1.1       root      232: void qemu_chr_accept_input(CharDriverState *s);
1.1.1.8   root      233: int qemu_chr_add_client(CharDriverState *s, int fd);
1.1.1.5   root      234: void qemu_chr_info_print(Monitor *mon, const QObject *ret_data);
                    235: void qemu_chr_info(Monitor *mon, QObject **ret_data);
                    236: CharDriverState *qemu_chr_find(const char *name);
1.1.1.2   root      237: 
1.1.1.9   root      238: QemuOpts *qemu_chr_parse_compat(const char *label, const char *filename);
                    239: 
1.1.1.6   root      240: /* add an eventfd to the qemu devices that are polled */
                    241: CharDriverState *qemu_chr_open_eventfd(int eventfd);
                    242: 
1.1.1.2   root      243: extern int term_escape_char;
1.1       root      244: 
1.1.1.7   root      245: /* memory chardev */
                    246: void qemu_chr_init_mem(CharDriverState *chr);
                    247: void qemu_chr_close_mem(CharDriverState *chr);
                    248: QString *qemu_chr_mem_to_qs(CharDriverState *chr);
                    249: size_t qemu_chr_mem_osize(const CharDriverState *chr);
                    250: 
1.1.1.10! root      251: CharDriverState *qemu_char_get_next_serial(void);
        !           252: 
1.1       root      253: #endif

unix.superglobalmegacorp.com