include/sysemu/char.h

   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-file.h"
   8 #include "block/aio.h"
   9 #include "qapi/qmp/qobject.h"
  10 #include "qapi/qmp/qstring.h"
  11 #include "qemu/main-loop.h"
  12
  13 /* character device */
  14
  15 #define CHR_EVENT_BREAK   0 /* serial break char */
  16 #define CHR_EVENT_FOCUS   1 /* focus to this terminal (modal input needed) */
  17 #define CHR_EVENT_OPENED  2 /* new connection established */
  18 #define CHR_EVENT_MUX_IN  3 /* mux-focus was set to this terminal */
  19 #define CHR_EVENT_MUX_OUT 4 /* mux-focus will move on */
  20 #define CHR_EVENT_CLOSED  5 /* connection closed */
  21
  22
  23 #define CHR_IOCTL_SERIAL_SET_PARAMS   1
  24 typedef struct {
  25     int speed;
  26     int parity;
  27     int data_bits;
  28     int stop_bits;
  29 } QEMUSerialSetParams;
  30
  31 #define CHR_IOCTL_SERIAL_SET_BREAK    2
  32
  33 #define CHR_IOCTL_PP_READ_DATA        3
  34 #define CHR_IOCTL_PP_WRITE_DATA       4
  35 #define CHR_IOCTL_PP_READ_CONTROL     5
  36 #define CHR_IOCTL_PP_WRITE_CONTROL    6
  37 #define CHR_IOCTL_PP_READ_STATUS      7
  38 #define CHR_IOCTL_PP_EPP_READ_ADDR    8
  39 #define CHR_IOCTL_PP_EPP_READ         9
  40 #define CHR_IOCTL_PP_EPP_WRITE_ADDR  10
  41 #define CHR_IOCTL_PP_EPP_WRITE       11
  42 #define CHR_IOCTL_PP_DATA_DIR        12
  43
  44 struct ParallelIOArg {
  45     void *buffer;
  46     int count;
  47 };
  48
  49 #define CHR_IOCTL_SERIAL_SET_TIOCM   13
  50 #define CHR_IOCTL_SERIAL_GET_TIOCM   14
  51
  52 #define CHR_TIOCM_CTS   0x020
  53 #define CHR_TIOCM_CAR   0x040
  54 #define CHR_TIOCM_DSR   0x100
  55 #define CHR_TIOCM_RI    0x080
  56 #define CHR_TIOCM_DTR   0x002
  57 #define CHR_TIOCM_RTS   0x004
  58
  59 typedef void IOEventHandler(void *opaque, int event);
  60
  61 struct CharDriverState {
  62     QemuMutex chr_write_lock;
  63     void (*init)(struct CharDriverState *s);
  64     int (*chr_write)(struct CharDriverState *s, const uint8_t *buf, int len);
  65     int (*chr_sync_read)(struct CharDriverState *s,
  66                          const uint8_t *buf, int len);
  67     GSource *(*chr_add_watch)(struct CharDriverState *s, GIOCondition cond);
  68     void (*chr_update_read_handler)(struct CharDriverState *s,
  69                                     GMainContext *context);
  70     int (*chr_ioctl)(struct CharDriverState *s, int cmd, void *arg);
  71     int (*get_msgfds)(struct CharDriverState *s, int* fds, int num);
  72     int (*set_msgfds)(struct CharDriverState *s, int *fds, int num);
  73     int (*chr_add_client)(struct CharDriverState *chr, int fd);
  74     int (*chr_wait_connected)(struct CharDriverState *chr, Error **errp);
  75     IOEventHandler *chr_event;
  76     IOCanReadHandler *chr_can_read;
  77     IOReadHandler *chr_read;
  78     void *handler_opaque;
  79     void (*chr_close)(struct CharDriverState *chr);
  80     void (*chr_disconnect)(struct CharDriverState *chr);
  81     void (*chr_accept_input)(struct CharDriverState *chr);
  82     void (*chr_set_echo)(struct CharDriverState *chr, bool echo);
  83     void (*chr_set_fe_open)(struct CharDriverState *chr, int fe_open);
  84     void (*chr_fe_event)(struct CharDriverState *chr, int event);
  85     void *opaque;
  86     char *label;
  87     char *filename;
  88     int logfd;
  89     int be_open;
  90     int fe_open;
  91     int explicit_fe_open;
  92     int explicit_be_open;
  93     int avail_connections;
  94     int is_mux;
  95     guint fd_in_tag;
  96     QemuOpts *opts;
  97     bool replay;
  98     QTAILQ_ENTRY(CharDriverState) next;
  99 };
 100
 101 /**
 102  * qemu_chr_alloc:
 103  * @backend: the common backend config
 104  * @errp: pointer to a NULL-initialized error object
 105  *
 106  * Allocate and initialize a new CharDriverState.
 107  *
 108  * Returns: a newly allocated CharDriverState, or NULL on error.
 109  */
 110 CharDriverState *qemu_chr_alloc(ChardevCommon *backend, Error **errp);
 111
 112 /**
 113  * @qemu_chr_new_from_opts:
 114  *
 115  * Create a new character backend from a QemuOpts list.
 116  *
 117  * @opts see qemu-config.c for a list of valid options
 118  * @init not sure..
 119  *
 120  * Returns: a new character backend
 121  */
 122 CharDriverState *qemu_chr_new_from_opts(QemuOpts *opts,
 123                                     void (*init)(struct CharDriverState *s),
 124                                     Error **errp);
 125
 126 /**
 127  * @qemu_chr_parse_common:
 128  *
 129  * Parse the common options available to all character backends.
 130  *
 131  * @opts the options that still need parsing
 132  * @backend a new backend
 133  */
 134 void qemu_chr_parse_common(QemuOpts *opts, ChardevCommon *backend);
 135
 136 /**
 137  * @qemu_chr_new:
 138  *
 139  * Create a new character backend from a URI.
 140  *
 141  * @label the name of the backend
 142  * @filename the URI
 143  * @init not sure..
 144  *
 145  * Returns: a new character backend
 146  */
 147 CharDriverState *qemu_chr_new(const char *label, const char *filename,
 148                               void (*init)(struct CharDriverState *s));
 149 /**
 150  * @qemu_chr_disconnect:
 151  *
 152  * Close a fd accpeted by character backend.
 153  */
 154 void qemu_chr_disconnect(CharDriverState *chr);
 155
 156 /**
 157  * @qemu_chr_cleanup:
 158  *
 159  * Delete all chardevs (when leaving qemu)
 160  */
 161 void qemu_chr_cleanup(void);
 162
 163 /**
 164  * @qemu_chr_wait_connected:
 165  *
 166  * Wait for characted backend to be connected.
 167  */
 168 int qemu_chr_wait_connected(CharDriverState *chr, Error **errp);
 169
 170 /**
 171  * @qemu_chr_new_noreplay:
 172  *
 173  * Create a new character backend from a URI.
 174  * Character device communications are not written
 175  * into the replay log.
 176  *
 177  * @label the name of the backend
 178  * @filename the URI
 179  * @init not sure..
 180  *
 181  * Returns: a new character backend
 182  */
 183 CharDriverState *qemu_chr_new_noreplay(const char *label, const char *filename,
 184                                        void (*init)(struct CharDriverState *s));
 185
 186 /**
 187  * @qemu_chr_delete:
 188  *
 189  * Destroy a character backend and remove it from the list of
 190  * identified character backends.
 191  */
 192 void qemu_chr_delete(CharDriverState *chr);
 193
 194 /**
 195  * @qemu_chr_free:
 196  *
 197  * Destroy a character backend.
 198  */
 199 void qemu_chr_free(CharDriverState *chr);
 200
 201 /**
 202  * @qemu_chr_fe_set_echo:
 203  *
 204  * Ask the backend to override its normal echo setting.  This only really
 205  * applies to the stdio backend and is used by the QMP server such that you
 206  * can see what you type if you try to type QMP commands.
 207  *
 208  * @echo true to enable echo, false to disable echo
 209  */
 210 void qemu_chr_fe_set_echo(struct CharDriverState *chr, bool echo);
 211
 212 /**
 213  * @qemu_chr_fe_set_open:
 214  *
 215  * Set character frontend open status.  This is an indication that the
 216  * front end is ready (or not) to begin doing I/O.
 217  */
 218 void qemu_chr_fe_set_open(struct CharDriverState *chr, int fe_open);
 219
 220 /**
 221  * @qemu_chr_fe_event:
 222  *
 223  * Send an event from the front end to the back end.
 224  *
 225  * @event the event to send
 226  */
 227 void qemu_chr_fe_event(CharDriverState *s, int event);
 228
 229 /**
 230  * @qemu_chr_fe_printf:
 231  *
 232  * Write to a character backend using a printf style interface.
 233  * This function is thread-safe.
 234  *
 235  * @fmt see #printf
 236  */
 237 void qemu_chr_fe_printf(CharDriverState *s, const char *fmt, ...)
 238     GCC_FMT_ATTR(2, 3);
 239
 240 /**
 241  * @qemu_chr_fe_add_watch:
 242  *
 243  * If the backend is connected, create and add a #GSource that fires
 244  * when the given condition (typically G_IO_OUT|G_IO_HUP or G_IO_HUP)
 245  * is active; return the #GSource's tag.  If it is disconnected,
 246  * return 0.
 247  *
 248  * @cond the condition to poll for
 249  * @func the function to call when the condition happens
 250  * @user_data the opaque pointer to pass to @func
 251  */
 252 guint qemu_chr_fe_add_watch(CharDriverState *s, GIOCondition cond,
 253                             GIOFunc func, void *user_data);
 254
 255 /**
 256  * @qemu_chr_fe_write:
 257  *
 258  * Write data to a character backend from the front end.  This function
 259  * will send data from the front end to the back end.  This function
 260  * is thread-safe.
 261  *
 262  * @buf the data
 263  * @len the number of bytes to send
 264  *
 265  * Returns: the number of bytes consumed
 266  */
 267 int qemu_chr_fe_write(CharDriverState *s, const uint8_t *buf, int len);
 268
 269 /**
 270  * @qemu_chr_fe_write_all:
 271  *
 272  * Write data to a character backend from the front end.  This function will
 273  * send data from the front end to the back end.  Unlike @qemu_chr_fe_write,
 274  * this function will block if the back end cannot consume all of the data
 275  * attempted to be written.  This function is thread-safe.
 276  *
 277  * @buf the data
 278  * @len the number of bytes to send
 279  *
 280  * Returns: the number of bytes consumed
 281  */
 282 int qemu_chr_fe_write_all(CharDriverState *s, const uint8_t *buf, int len);
 283
 284 /**
 285  * @qemu_chr_fe_read_all:
 286  *
 287  * Read data to a buffer from the back end.
 288  *
 289  * @buf the data buffer
 290  * @len the number of bytes to read
 291  *
 292  * Returns: the number of bytes read
 293  */
 294 int qemu_chr_fe_read_all(CharDriverState *s, uint8_t *buf, int len);
 295
 296 /**
 297  * @qemu_chr_fe_ioctl:
 298  *
 299  * Issue a device specific ioctl to a backend.  This function is thread-safe.
 300  *
 301  * @cmd see CHR_IOCTL_*
 302  * @arg the data associated with @cmd
 303  *
 304  * Returns: if @cmd is not supported by the backend, -ENOTSUP, otherwise the
 305  *          return value depends on the semantics of @cmd
 306  */
 307 int qemu_chr_fe_ioctl(CharDriverState *s, int cmd, void *arg);
 308
 309 /**
 310  * @qemu_chr_fe_get_msgfd:
 311  *
 312  * For backends capable of fd passing, return the latest file descriptor passed
 313  * by a client.
 314  *
 315  * Returns: -1 if fd passing isn't supported or there is no pending file
 316  *          descriptor.  If a file descriptor is returned, subsequent calls to
 317  *          this function will return -1 until a client sends a new file
 318  *          descriptor.
 319  */
 320 int qemu_chr_fe_get_msgfd(CharDriverState *s);
 321
 322 /**
 323  * @qemu_chr_fe_get_msgfds:
 324  *
 325  * For backends capable of fd passing, return the number of file received
 326  * descriptors and fills the fds array up to num elements
 327  *
 328  * Returns: -1 if fd passing isn't supported or there are no pending file
 329  *          descriptors.  If file descriptors are returned, subsequent calls to
 330  *          this function will return -1 until a client sends a new set of file
 331  *          descriptors.
 332  */
 333 int qemu_chr_fe_get_msgfds(CharDriverState *s, int *fds, int num);
 334
 335 /**
 336  * @qemu_chr_fe_set_msgfds:
 337  *
 338  * For backends capable of fd passing, set an array of fds to be passed with
 339  * the next send operation.
 340  * A subsequent call to this function before calling a write function will
 341  * result in overwriting the fd array with the new value without being send.
 342  * Upon writing the message the fd array is freed.
 343  *
 344  * Returns: -1 if fd passing isn't supported.
 345  */
 346 int qemu_chr_fe_set_msgfds(CharDriverState *s, int *fds, int num);
 347
 348 /**
 349  * @qemu_chr_fe_claim:
 350  *
 351  * Claim a backend before using it, should be called before calling
 352  * qemu_chr_add_handlers().
 353  *
 354  * Returns: -1 if the backend is already in use by another frontend, 0 on
 355  *          success.
 356  */
 357 int qemu_chr_fe_claim(CharDriverState *s);
 358
 359 /**
 360  * @qemu_chr_fe_claim_no_fail:
 361  *
 362  * Like qemu_chr_fe_claim, but will exit qemu with an error when the
 363  * backend is already in use.
 364  */
 365 void qemu_chr_fe_claim_no_fail(CharDriverState *s);
 366
 367 /**
 368  * @qemu_chr_fe_claim:
 369  *
 370  * Release a backend for use by another frontend.
 371  *
 372  * Returns: -1 if the backend is already in use by another frontend, 0 on
 373  *          success.
 374  */
 375 void qemu_chr_fe_release(CharDriverState *s);
 376
 377 /**
 378  * @qemu_chr_be_can_write:
 379  *
 380  * Determine how much data the front end can currently accept.  This function
 381  * returns the number of bytes the front end can accept.  If it returns 0, the
 382  * front end cannot receive data at the moment.  The function must be polled
 383  * to determine when data can be received.
 384  *
 385  * Returns: the number of bytes the front end can receive via @qemu_chr_be_write
 386  */
 387 int qemu_chr_be_can_write(CharDriverState *s);
 388
 389 /**
 390  * @qemu_chr_be_write:
 391  *
 392  * Write data from the back end to the front end.  Before issuing this call,
 393  * the caller should call @qemu_chr_be_can_write to determine how much data
 394  * the front end can currently accept.
 395  *
 396  * @buf a buffer to receive data from the front end
 397  * @len the number of bytes to receive from the front end
 398  */
 399 void qemu_chr_be_write(CharDriverState *s, uint8_t *buf, int len);
 400
 401 /**
 402  * @qemu_chr_be_write_impl:
 403  *
 404  * Implementation of back end writing. Used by replay module.
 405  *
 406  * @buf a buffer to receive data from the front end
 407  * @len the number of bytes to receive from the front end
 408  */
 409 void qemu_chr_be_write_impl(CharDriverState *s, uint8_t *buf, int len);
 410
 411 /**
 412  * @qemu_chr_be_event:
 413  *
 414  * Send an event from the back end to the front end.
 415  *
 416  * @event the event to send
 417  */
 418 void qemu_chr_be_event(CharDriverState *s, int event);
 419
 420 void qemu_chr_add_handlers(CharDriverState *s,
 421                            IOCanReadHandler *fd_can_read,
 422                            IOReadHandler *fd_read,
 423                            IOEventHandler *fd_event,
 424                            void *opaque);
 425
 426 /* This API can make handler run in the context what you pass to. */
 427 void qemu_chr_add_handlers_full(CharDriverState *s,
 428                                 IOCanReadHandler *fd_can_read,
 429                                 IOReadHandler *fd_read,
 430                                 IOEventHandler *fd_event,
 431                                 void *opaque,
 432                                 GMainContext *context);
 433
 434 void qemu_chr_be_generic_open(CharDriverState *s);
 435 void qemu_chr_accept_input(CharDriverState *s);
 436 int qemu_chr_add_client(CharDriverState *s, int fd);
 437 CharDriverState *qemu_chr_find(const char *name);
 438 bool chr_is_ringbuf(const CharDriverState *chr);
 439
 440 QemuOpts *qemu_chr_parse_compat(const char *label, const char *filename);
 441
 442 void register_char_driver(const char *name, ChardevBackendKind kind,
 443         void (*parse)(QemuOpts *opts, ChardevBackend *backend, Error **errp),
 444         CharDriverState *(*create)(const char *id, ChardevBackend *backend,
 445                                    ChardevReturn *ret, Error **errp));
 446
 447 extern int term_escape_char;
 448
 449
 450 /* console.c */
 451 typedef CharDriverState *(VcHandler)(ChardevVC *vc, Error **errp);
 452 void register_vc_handler(VcHandler *handler);
 453
 454 #endif