qemu-char.h 7.3 KB

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