2007-11-17 18:14:51 +01:00
|
|
|
#ifndef QEMU_CHAR_H
|
|
|
|
#define QEMU_CHAR_H
|
|
|
|
|
2009-03-06 00:01:23 +01:00
|
|
|
#include "qemu-common.h"
|
2009-09-12 09:36:22 +02:00
|
|
|
#include "qemu-queue.h"
|
2009-09-10 10:58:35 +02:00
|
|
|
#include "qemu-option.h"
|
|
|
|
#include "qemu-config.h"
|
2009-12-10 20:16:08 +01:00
|
|
|
#include "qobject.h"
|
2010-10-22 20:09:05 +02:00
|
|
|
#include "qstring.h"
|
2011-09-12 16:44:30 +02:00
|
|
|
#include "main-loop.h"
|
2009-03-06 00:01:23 +01:00
|
|
|
|
2007-11-17 18:14:51 +01:00
|
|
|
/* character device */
|
|
|
|
|
2009-03-06 00:01:47 +01:00
|
|
|
#define CHR_EVENT_BREAK 0 /* serial break char */
|
|
|
|
#define CHR_EVENT_FOCUS 1 /* focus to this terminal (modal input needed) */
|
2009-10-07 15:01:16 +02:00
|
|
|
#define CHR_EVENT_OPENED 2 /* new connection established */
|
2009-03-06 00:01:47 +01:00
|
|
|
#define CHR_EVENT_MUX_IN 3 /* mux-focus was set to this terminal */
|
|
|
|
#define CHR_EVENT_MUX_OUT 4 /* mux-focus will move on */
|
2009-08-11 17:57:48 +02:00
|
|
|
#define CHR_EVENT_CLOSED 5 /* connection closed */
|
2007-11-17 18:14:51 +01:00
|
|
|
|
|
|
|
|
|
|
|
#define CHR_IOCTL_SERIAL_SET_PARAMS 1
|
|
|
|
typedef struct {
|
|
|
|
int speed;
|
|
|
|
int parity;
|
|
|
|
int data_bits;
|
|
|
|
int stop_bits;
|
|
|
|
} QEMUSerialSetParams;
|
|
|
|
|
|
|
|
#define CHR_IOCTL_SERIAL_SET_BREAK 2
|
|
|
|
|
|
|
|
#define CHR_IOCTL_PP_READ_DATA 3
|
|
|
|
#define CHR_IOCTL_PP_WRITE_DATA 4
|
|
|
|
#define CHR_IOCTL_PP_READ_CONTROL 5
|
|
|
|
#define CHR_IOCTL_PP_WRITE_CONTROL 6
|
|
|
|
#define CHR_IOCTL_PP_READ_STATUS 7
|
|
|
|
#define CHR_IOCTL_PP_EPP_READ_ADDR 8
|
|
|
|
#define CHR_IOCTL_PP_EPP_READ 9
|
|
|
|
#define CHR_IOCTL_PP_EPP_WRITE_ADDR 10
|
|
|
|
#define CHR_IOCTL_PP_EPP_WRITE 11
|
2008-08-22 10:57:09 +02:00
|
|
|
#define CHR_IOCTL_PP_DATA_DIR 12
|
2007-11-17 18:14:51 +01:00
|
|
|
|
2008-08-22 23:25:00 +02:00
|
|
|
#define CHR_IOCTL_SERIAL_SET_TIOCM 13
|
|
|
|
#define CHR_IOCTL_SERIAL_GET_TIOCM 14
|
2008-08-11 16:17:04 +02:00
|
|
|
|
|
|
|
#define CHR_TIOCM_CTS 0x020
|
|
|
|
#define CHR_TIOCM_CAR 0x040
|
|
|
|
#define CHR_TIOCM_DSR 0x100
|
|
|
|
#define CHR_TIOCM_RI 0x080
|
|
|
|
#define CHR_TIOCM_DTR 0x002
|
|
|
|
#define CHR_TIOCM_RTS 0x004
|
|
|
|
|
2007-11-17 18:14:51 +01:00
|
|
|
typedef void IOEventHandler(void *opaque, int event);
|
|
|
|
|
|
|
|
struct CharDriverState {
|
2009-01-18 15:08:04 +01:00
|
|
|
void (*init)(struct CharDriverState *s);
|
2007-11-17 18:14:51 +01:00
|
|
|
int (*chr_write)(struct CharDriverState *s, const uint8_t *buf, int len);
|
|
|
|
void (*chr_update_read_handler)(struct CharDriverState *s);
|
|
|
|
int (*chr_ioctl)(struct CharDriverState *s, int cmd, void *arg);
|
2009-07-22 10:11:39 +02:00
|
|
|
int (*get_msgfd)(struct CharDriverState *s);
|
Introduce a 'client_add' monitor command accepting an open FD
Allow client connections for VNC and socket based character
devices to be passed in over the monitor using SCM_RIGHTS.
One intended usage scenario is to start QEMU with VNC on a
UNIX domain socket. An unprivileged user which cannot access
the UNIX domain socket, can then connect to QEMU's VNC server
by passing an open FD to libvirt, which passes it onto QEMU.
{ "execute": "get_fd", "arguments": { "fdname": "myclient" } }
{ "return": {} }
{ "execute": "add_client", "arguments": { "protocol": "vnc",
"fdname": "myclient",
"skipauth": true } }
{ "return": {} }
In this case 'protocol' can be 'vnc' or 'spice', or the name
of a character device (eg from -chardev id=XXXX)
The 'skipauth' parameter can be used to skip any configured
VNC authentication scheme, which is useful if the mgmt layer
talking to the monitor has already authenticated the client
in another way.
* console.h: Define 'vnc_display_add_client' method
* monitor.c: Implement 'client_add' command
* qemu-char.c, qemu-char.h: Add 'qemu_char_add_client' method
* qerror.c, qerror.h: Add QERR_ADD_CLIENT_FAILED
* qmp-commands.hx: Declare 'client_add' command
* ui/vnc.c: Implement 'vnc_display_add_client' method
Signed-off-by: Anthony Liguori <aliguori@us.ibm.com>
2011-06-23 14:31:42 +02:00
|
|
|
int (*chr_add_client)(struct CharDriverState *chr, int fd);
|
2007-11-17 18:14:51 +01:00
|
|
|
IOEventHandler *chr_event;
|
2010-03-11 17:55:39 +01:00
|
|
|
IOCanReadHandler *chr_can_read;
|
2007-11-17 18:14:51 +01:00
|
|
|
IOReadHandler *chr_read;
|
|
|
|
void *handler_opaque;
|
|
|
|
void (*chr_close)(struct CharDriverState *chr);
|
2007-11-25 01:55:06 +01:00
|
|
|
void (*chr_accept_input)(struct CharDriverState *chr);
|
2010-12-23 13:42:48 +01:00
|
|
|
void (*chr_set_echo)(struct CharDriverState *chr, bool echo);
|
2011-03-24 11:12:02 +01:00
|
|
|
void (*chr_guest_open)(struct CharDriverState *chr);
|
|
|
|
void (*chr_guest_close)(struct CharDriverState *chr);
|
2007-11-17 18:14:51 +01:00
|
|
|
void *opaque;
|
2012-10-12 09:52:49 +02:00
|
|
|
QEMUTimer *open_timer;
|
2008-10-31 18:31:29 +01:00
|
|
|
char *label;
|
|
|
|
char *filename;
|
2010-04-01 18:42:39 +02:00
|
|
|
int opened;
|
2011-04-26 12:19:26 +02:00
|
|
|
int avail_connections;
|
2009-09-12 09:36:22 +02:00
|
|
|
QTAILQ_ENTRY(CharDriverState) next;
|
2007-11-17 18:14:51 +01:00
|
|
|
};
|
|
|
|
|
2011-08-15 18:17:41 +02:00
|
|
|
/**
|
|
|
|
* @qemu_chr_new_from_opts:
|
|
|
|
*
|
|
|
|
* Create a new character backend from a QemuOpts list.
|
|
|
|
*
|
|
|
|
* @opts see qemu-config.c for a list of valid options
|
|
|
|
* @init not sure..
|
|
|
|
*
|
|
|
|
* Returns: a new character backend
|
|
|
|
*/
|
2011-08-15 18:17:37 +02:00
|
|
|
CharDriverState *qemu_chr_new_from_opts(QemuOpts *opts,
|
2009-09-10 10:58:35 +02:00
|
|
|
void (*init)(struct CharDriverState *s));
|
2011-08-15 18:17:41 +02:00
|
|
|
|
|
|
|
/**
|
|
|
|
* @qemu_chr_new:
|
|
|
|
*
|
|
|
|
* Create a new character backend from a URI.
|
|
|
|
*
|
|
|
|
* @label the name of the backend
|
|
|
|
* @filename the URI
|
|
|
|
* @init not sure..
|
|
|
|
*
|
|
|
|
* Returns: a new character backend
|
|
|
|
*/
|
|
|
|
CharDriverState *qemu_chr_new(const char *label, const char *filename,
|
|
|
|
void (*init)(struct CharDriverState *s));
|
|
|
|
|
|
|
|
/**
|
|
|
|
* @qemu_chr_delete:
|
|
|
|
*
|
|
|
|
* Destroy a character backend.
|
|
|
|
*/
|
|
|
|
void qemu_chr_delete(CharDriverState *chr);
|
|
|
|
|
|
|
|
/**
|
|
|
|
* @qemu_chr_fe_set_echo:
|
|
|
|
*
|
|
|
|
* Ask the backend to override its normal echo setting. This only really
|
|
|
|
* applies to the stdio backend and is used by the QMP server such that you
|
|
|
|
* can see what you type if you try to type QMP commands.
|
|
|
|
*
|
|
|
|
* @echo true to enable echo, false to disable echo
|
|
|
|
*/
|
2011-08-15 18:17:35 +02:00
|
|
|
void qemu_chr_fe_set_echo(struct CharDriverState *chr, bool echo);
|
2011-08-15 18:17:41 +02:00
|
|
|
|
|
|
|
/**
|
|
|
|
* @qemu_chr_fe_open:
|
|
|
|
*
|
|
|
|
* Open a character backend. This function call is an indication that the
|
|
|
|
* front end is ready to begin doing I/O.
|
|
|
|
*/
|
2011-08-15 18:17:32 +02:00
|
|
|
void qemu_chr_fe_open(struct CharDriverState *chr);
|
2011-08-15 18:17:41 +02:00
|
|
|
|
|
|
|
/**
|
|
|
|
* @qemu_chr_fe_close:
|
|
|
|
*
|
|
|
|
* Close a character backend. This function call indicates that the front end
|
|
|
|
* no longer is able to process I/O. To process I/O again, the front end will
|
|
|
|
* call @qemu_chr_fe_open.
|
|
|
|
*/
|
2011-08-15 18:17:33 +02:00
|
|
|
void qemu_chr_fe_close(struct CharDriverState *chr);
|
2011-08-15 18:17:41 +02:00
|
|
|
|
|
|
|
/**
|
|
|
|
* @qemu_chr_fe_printf:
|
|
|
|
*
|
|
|
|
* Write to a character backend using a printf style interface.
|
|
|
|
*
|
|
|
|
* @fmt see #printf
|
|
|
|
*/
|
2011-08-15 18:17:29 +02:00
|
|
|
void qemu_chr_fe_printf(CharDriverState *s, const char *fmt, ...)
|
2010-09-23 21:28:05 +02:00
|
|
|
GCC_FMT_ATTR(2, 3);
|
2011-08-15 18:17:41 +02:00
|
|
|
|
|
|
|
/**
|
|
|
|
* @qemu_chr_fe_write:
|
|
|
|
*
|
|
|
|
* Write data to a character backend from the front end. This function will
|
|
|
|
* send data from the front end to the back end.
|
|
|
|
*
|
|
|
|
* @buf the data
|
|
|
|
* @len the number of bytes to send
|
|
|
|
*
|
|
|
|
* Returns: the number of bytes consumed
|
|
|
|
*/
|
2011-08-15 18:17:28 +02:00
|
|
|
int qemu_chr_fe_write(CharDriverState *s, const uint8_t *buf, int len);
|
2011-08-15 18:17:41 +02:00
|
|
|
|
|
|
|
/**
|
|
|
|
* @qemu_chr_fe_ioctl:
|
|
|
|
*
|
|
|
|
* Issue a device specific ioctl to a backend.
|
|
|
|
*
|
|
|
|
* @cmd see CHR_IOCTL_*
|
|
|
|
* @arg the data associated with @cmd
|
|
|
|
*
|
|
|
|
* Returns: if @cmd is not supported by the backend, -ENOTSUP, otherwise the
|
|
|
|
* return value depends on the semantics of @cmd
|
|
|
|
*/
|
|
|
|
int qemu_chr_fe_ioctl(CharDriverState *s, int cmd, void *arg);
|
|
|
|
|
|
|
|
/**
|
|
|
|
* @qemu_chr_fe_get_msgfd:
|
|
|
|
*
|
|
|
|
* For backends capable of fd passing, return the latest file descriptor passed
|
|
|
|
* by a client.
|
|
|
|
*
|
|
|
|
* Returns: -1 if fd passing isn't supported or there is no pending file
|
|
|
|
* descriptor. If a file descriptor is returned, subsequent calls to
|
|
|
|
* this function will return -1 until a client sends a new file
|
|
|
|
* descriptor.
|
|
|
|
*/
|
|
|
|
int qemu_chr_fe_get_msgfd(CharDriverState *s);
|
|
|
|
|
|
|
|
/**
|
|
|
|
* @qemu_chr_be_can_write:
|
|
|
|
*
|
|
|
|
* Determine how much data the front end can currently accept. This function
|
|
|
|
* returns the number of bytes the front end can accept. If it returns 0, the
|
|
|
|
* front end cannot receive data at the moment. The function must be polled
|
|
|
|
* to determine when data can be received.
|
|
|
|
*
|
|
|
|
* Returns: the number of bytes the front end can receive via @qemu_chr_be_write
|
|
|
|
*/
|
|
|
|
int qemu_chr_be_can_write(CharDriverState *s);
|
|
|
|
|
|
|
|
/**
|
|
|
|
* @qemu_chr_be_write:
|
|
|
|
*
|
|
|
|
* Write data from the back end to the front end. Before issuing this call,
|
|
|
|
* the caller should call @qemu_chr_be_can_write to determine how much data
|
|
|
|
* the front end can currently accept.
|
|
|
|
*
|
|
|
|
* @buf a buffer to receive data from the front end
|
|
|
|
* @len the number of bytes to receive from the front end
|
|
|
|
*/
|
|
|
|
void qemu_chr_be_write(CharDriverState *s, uint8_t *buf, int len);
|
|
|
|
|
2011-11-19 10:22:43 +01:00
|
|
|
|
|
|
|
/**
|
|
|
|
* @qemu_chr_be_event:
|
|
|
|
*
|
|
|
|
* Send an event from the back end to the front end.
|
|
|
|
*
|
|
|
|
* @event the event to send
|
|
|
|
*/
|
|
|
|
void qemu_chr_be_event(CharDriverState *s, int event);
|
|
|
|
|
2007-11-17 18:14:51 +01:00
|
|
|
void qemu_chr_add_handlers(CharDriverState *s,
|
2010-03-11 17:55:39 +01:00
|
|
|
IOCanReadHandler *fd_can_read,
|
2007-11-17 18:14:51 +01:00
|
|
|
IOReadHandler *fd_read,
|
|
|
|
IOEventHandler *fd_event,
|
|
|
|
void *opaque);
|
2011-08-15 18:17:41 +02:00
|
|
|
|
2009-11-03 15:29:56 +01:00
|
|
|
void qemu_chr_generic_open(CharDriverState *s);
|
2007-11-25 01:55:06 +01:00
|
|
|
void qemu_chr_accept_input(CharDriverState *s);
|
Introduce a 'client_add' monitor command accepting an open FD
Allow client connections for VNC and socket based character
devices to be passed in over the monitor using SCM_RIGHTS.
One intended usage scenario is to start QEMU with VNC on a
UNIX domain socket. An unprivileged user which cannot access
the UNIX domain socket, can then connect to QEMU's VNC server
by passing an open FD to libvirt, which passes it onto QEMU.
{ "execute": "get_fd", "arguments": { "fdname": "myclient" } }
{ "return": {} }
{ "execute": "add_client", "arguments": { "protocol": "vnc",
"fdname": "myclient",
"skipauth": true } }
{ "return": {} }
In this case 'protocol' can be 'vnc' or 'spice', or the name
of a character device (eg from -chardev id=XXXX)
The 'skipauth' parameter can be used to skip any configured
VNC authentication scheme, which is useful if the mgmt layer
talking to the monitor has already authenticated the client
in another way.
* console.h: Define 'vnc_display_add_client' method
* monitor.c: Implement 'client_add' command
* qemu-char.c, qemu-char.h: Add 'qemu_char_add_client' method
* qerror.c, qerror.h: Add QERR_ADD_CLIENT_FAILED
* qmp-commands.hx: Declare 'client_add' command
* ui/vnc.c: Implement 'vnc_display_add_client' method
Signed-off-by: Anthony Liguori <aliguori@us.ibm.com>
2011-06-23 14:31:42 +02:00
|
|
|
int qemu_chr_add_client(CharDriverState *s, int fd);
|
2009-12-10 20:16:08 +01:00
|
|
|
void qemu_chr_info_print(Monitor *mon, const QObject *ret_data);
|
|
|
|
void qemu_chr_info(Monitor *mon, QObject **ret_data);
|
2009-09-10 10:58:52 +02:00
|
|
|
CharDriverState *qemu_chr_find(const char *name);
|
2007-11-17 18:14:51 +01:00
|
|
|
|
2011-08-15 18:17:41 +02:00
|
|
|
QemuOpts *qemu_chr_parse_compat(const char *label, const char *filename);
|
|
|
|
|
RESEND: Inter-VM shared memory PCI device
resend for bug fix related to removal of irqfd
Support an inter-vm shared memory device that maps a shared-memory object as a
PCI device in the guest. This patch also supports interrupts between guest by
communicating over a unix domain socket. This patch applies to the qemu-kvm
repository.
-device ivshmem,size=<size in format accepted by -m>[,shm=<shm name>]
Interrupts are supported between multiple VMs by using a shared memory server
by using a chardev socket.
-device ivshmem,size=<size in format accepted by -m>[,shm=<shm name>]
[,chardev=<id>][,msi=on][,ioeventfd=on][,vectors=n][,role=peer|master]
-chardev socket,path=<path>,id=<id>
The shared memory server, sample programs and init scripts are in a git repo here:
www.gitorious.org/nahanni
Signed-off-by: Cam Macdonell <cam@cs.ualberta.ca>
Signed-off-by: Anthony Liguori <aliguori@us.ibm.com>
2010-07-27 18:54:13 +02:00
|
|
|
/* add an eventfd to the qemu devices that are polled */
|
|
|
|
CharDriverState *qemu_chr_open_eventfd(int eventfd);
|
|
|
|
|
2008-10-31 19:44:40 +01:00
|
|
|
extern int term_escape_char;
|
|
|
|
|
2010-10-22 20:09:05 +02:00
|
|
|
/* memory chardev */
|
|
|
|
void qemu_chr_init_mem(CharDriverState *chr);
|
|
|
|
void qemu_chr_close_mem(CharDriverState *chr);
|
|
|
|
QString *qemu_chr_mem_to_qs(CharDriverState *chr);
|
|
|
|
size_t qemu_chr_mem_osize(const CharDriverState *chr);
|
|
|
|
|
2011-12-22 22:29:25 +01:00
|
|
|
CharDriverState *qemu_char_get_next_serial(void);
|
|
|
|
|
2007-11-17 18:14:51 +01:00
|
|
|
#endif
|