root / qemu-char.h @ a0595d9e
History | View | Annotate | Download (7.3 kB)
1 |
#ifndef QEMU_CHAR_H
|
---|---|
2 |
#define QEMU_CHAR_H
|
3 |
|
4 |
#include "qemu-common.h" |
5 |
#include "qemu-queue.h" |
6 |
#include "qemu-option.h" |
7 |
#include "qemu-config.h" |
8 |
#include "qobject.h" |
9 |
#include "qstring.h" |
10 |
#include "main-loop.h" |
11 |
|
12 |
/* character device */
|
13 |
|
14 |
#define CHR_EVENT_BREAK 0 /* serial break char */ |
15 |
#define CHR_EVENT_FOCUS 1 /* focus to this terminal (modal input needed) */ |
16 |
#define CHR_EVENT_OPENED 2 /* new connection established */ |
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 */ |
19 |
#define CHR_EVENT_CLOSED 5 /* connection closed */ |
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 |
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 |
52 |
|
53 |
typedef void IOEventHandler(void *opaque, int event); |
54 |
|
55 |
struct CharDriverState {
|
56 |
void (*init)(struct CharDriverState *s); |
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); |
60 |
int (*get_msgfd)(struct CharDriverState *s); |
61 |
int (*chr_add_client)(struct CharDriverState *chr, int fd); |
62 |
IOEventHandler *chr_event; |
63 |
IOCanReadHandler *chr_can_read; |
64 |
IOReadHandler *chr_read; |
65 |
void *handler_opaque;
|
66 |
void (*chr_close)(struct CharDriverState *chr); |
67 |
void (*chr_accept_input)(struct CharDriverState *chr); |
68 |
void (*chr_set_echo)(struct CharDriverState *chr, bool echo); |
69 |
void (*chr_guest_open)(struct CharDriverState *chr); |
70 |
void (*chr_guest_close)(struct CharDriverState *chr); |
71 |
void *opaque;
|
72 |
QEMUBH *bh; |
73 |
char *label;
|
74 |
char *filename;
|
75 |
int opened;
|
76 |
int avail_connections;
|
77 |
QTAILQ_ENTRY(CharDriverState) next; |
78 |
}; |
79 |
|
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, |
91 |
void (*init)(struct CharDriverState *s)); |
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, ...) |
150 |
GCC_FMT_ATTR(2, 3); |
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 |
|
225 |
void qemu_chr_add_handlers(CharDriverState *s,
|
226 |
IOCanReadHandler *fd_can_read, |
227 |
IOReadHandler *fd_read, |
228 |
IOEventHandler *fd_event, |
229 |
void *opaque);
|
230 |
|
231 |
void qemu_chr_generic_open(CharDriverState *s);
|
232 |
void qemu_chr_accept_input(CharDriverState *s);
|
233 |
int qemu_chr_add_client(CharDriverState *s, int fd); |
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); |
237 |
|
238 |
QemuOpts *qemu_chr_parse_compat(const char *label, const char *filename); |
239 |
|
240 |
/* add an eventfd to the qemu devices that are polled */
|
241 |
CharDriverState *qemu_chr_open_eventfd(int eventfd);
|
242 |
|
243 |
extern int term_escape_char; |
244 |
|
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 |
|
251 |
CharDriverState *qemu_char_get_next_serial(void);
|
252 |
|
253 |
#endif
|