OpenE2K
/
qemu-e2k
13
4
Fork 0
Code Issues 4 Pull Requests Projects 2 Releases Activity

Xen 2017/12/14 

-----BEGIN PGP SIGNATURE-----
 Version: GnuPG v1
 
 iQIcBAABAgAGBQJaMxayAAoJEIlPj0hw4a6Qkn8P/2Zqb7DX6mXhJgKrIcDSwchb
 txNxIFjpWddAzx2G4bAVF8xWmveBrC8Z5rnIrctcxW8m/ejiL5j946minp0VD5dc
 K97189NNUtd6aYMgDd0y/vxMTo47TYLqBwEjLaR4YxOg4t9HOqN2hPfO0TZ8d83o
 qkH/A1Y7EncipqS3nDmh1eqJfLaVuk5DJxLUpIpLTN55Ni+DWqkPwFbzCznOXgRn
 gzChSzjnsVE/y12YnNBDJIV5ZXt0hSNWvNsQzH5NgSfXfybmlKAjqKCpPRmZ7zzJ
 XgKF+pjShCeptiTjYGfrwMTMGrhzjLcp3WljpXWAavy6en5H3pGj2R8LuPR82jyy
 EL3IFTnGHT4Ax8ZiX4954igB/rdynbx8QAqQwnRUR2lBZXP3ZoUH2F0HL5I5Fy5U
 P4AZJ5MpcAELw44YAI2NFU+QutKR5bJbndFknUi5Vuj9sIvR1pQtnPDjzmKIQ0Wb
 LhrUXL9BPhuSI+YBxBMCSNRNJtWwLTEXJ3Fi9L7tn3KYP86g9q9YFv1Ronh/oxfs
 GsNxuj65KIrGhw42apTwjf4bMF1zjJhJAhbr4kctD5zt26rp8IoQSAjB0W0Fh6E3
 seZA03HNJqRUybUxueDb5gx/8knK9uvQhOxSbm23Pnld860R2HB/02to84eI5uPZ
 yu0Khgyo/yhg0gTCZeRo
 =FtCu
 -----END PGP SIGNATURE-----

Merge remote-tracking branch 'remotes/sstabellini/tags/xen-20171214-tag' into staging

Xen 2017/12/14

# gpg: Signature made Fri 15 Dec 2017 00:26:26 GMT
# gpg:                using RSA key 0x894F8F4870E1AE90
# gpg: Good signature from "Stefano Stabellini <stefano.stabellini@eu.citrix.com>"
# gpg:                 aka "Stefano Stabellini <sstabellini@kernel.org>"
# Primary key fingerprint: D04E 33AB A51F 67BA 07D3  0AEA 894F 8F48 70E1 AE90

* remotes/sstabellini/tags/xen-20171214-tag:
  xen/pt: Set is_express to avoid out-of-bounds write
  xenfb: activate input handlers for raw pointer devices
  xenfb: Add [feature|request]-raw-pointer
  xenfb: Use Input Handlers directly
  ui: generate qcode to linux mappings
  xen-disk: use an IOThread per instance

Signed-off-by: Peter Maydell <peter.maydell@linaro.org>
This commit is contained in:
Peter Maydell 2017-12-15 09:52:07 +00:00
parent 0ef0583d5a 2e63eb2bec
commit 1c3b51a796
7 changed files with 218 additions and 148 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

1
Makefile
View File

@ -229,6 +229,7 @@ KEYCODEMAP_FILES = \
ui/input-keymap-linux-to-qcode.c \
ui/input-keymap-qcode-to-qnum.c \
ui/input-keymap-qnum-to-qcode.c \
ui/input-keymap-qcode-to-linux.c \
$(NULL)
GENERATED_FILES += $(KEYCODEMAP_FILES)

7
hw/block/trace-events
View File

@ -10,3 +10,10 @@ virtio_blk_submit_multireq(void *vdev, void *mrb, int start, int num_reqs, uint6
# hw/block/hd-geometry.c
hd_geometry_lchs_guess(void *blk, int cyls, int heads, int secs) "blk %p LCHS %d %d %d"
hd_geometry_guess(void *blk, uint32_t cyls, uint32_t heads, uint32_t secs, int trans) "blk %p CHS %u %u %u trans %d"
# hw/block/xen_disk.c
xen_disk_alloc(char *name) "%s"
xen_disk_init(char *name) "%s"
xen_disk_connect(char *name) "%s"
xen_disk_disconnect(char *name) "%s"
xen_disk_free(char *name) "%s"

53
hw/block/xen_disk.c
View File

@ -27,10 +27,12 @@
#include "hw/xen/xen_backend.h"
#include "xen_blkif.h"
#include "sysemu/blockdev.h"
#include "sysemu/iothread.h"
#include "sysemu/block-backend.h"
#include "qapi/error.h"
#include "qapi/qmp/qdict.h"
#include "qapi/qmp/qstring.h"
#include "trace.h"
/* ------------------------------------------------------------- */
@ -125,6 +127,9 @@ struct XenBlkDev {
DriveInfo *dinfo;
BlockBackend *blk;
QEMUBH *bh;
IOThread *iothread;
AioContext *ctx;
};
/* ------------------------------------------------------------- */
@ -596,9 +601,12 @@ static int ioreq_runio_qemu_aio(struct ioreq *ioreq);
static void qemu_aio_complete(void *opaque, int ret)
{
struct ioreq *ioreq = opaque;
struct XenBlkDev *blkdev = ioreq->blkdev;
aio_context_acquire(blkdev->ctx);
if (ret != 0) {
xen_pv_printf(&ioreq->blkdev->xendev, 0, "%s I/O error\n",
xen_pv_printf(&blkdev->xendev, 0, "%s I/O error\n",
ioreq->req.operation == BLKIF_OP_READ ? "read" : "write");
ioreq->aio_errors++;
}
@ -607,10 +615,10 @@ static void qemu_aio_complete(void *opaque, int ret)
if (ioreq->presync) {
ioreq->presync = 0;
ioreq_runio_qemu_aio(ioreq);
return;
goto done;
}
if (ioreq->aio_inflight > 0) {
return;
goto done;
}
if (xen_feature_grant_copy) {
@ -647,16 +655,19 @@ static void qemu_aio_complete(void *opaque, int ret)
}
case BLKIF_OP_READ:
if (ioreq->status == BLKIF_RSP_OKAY) {
block_acct_done(blk_get_stats(ioreq->blkdev->blk), &ioreq->acct);
block_acct_done(blk_get_stats(blkdev->blk), &ioreq->acct);
} else {
block_acct_failed(blk_get_stats(ioreq->blkdev->blk), &ioreq->acct);
block_acct_failed(blk_get_stats(blkdev->blk), &ioreq->acct);
}
break;
case BLKIF_OP_DISCARD:
default:
break;
}
qemu_bh_schedule(ioreq->blkdev->bh);
qemu_bh_schedule(blkdev->bh);
done:
aio_context_release(blkdev->ctx);
}
static bool blk_split_discard(struct ioreq *ioreq, blkif_sector_t sector_number,
@ -913,17 +924,29 @@ static void blk_handle_requests(struct XenBlkDev *blkdev)
static void blk_bh(void *opaque)
{
struct XenBlkDev *blkdev = opaque;
aio_context_acquire(blkdev->ctx);
blk_handle_requests(blkdev);
aio_context_release(blkdev->ctx);
}
static void blk_alloc(struct XenDevice *xendev)
{
struct XenBlkDev *blkdev = container_of(xendev, struct XenBlkDev, xendev);
Error *err = NULL;
trace_xen_disk_alloc(xendev->name);
QLIST_INIT(&blkdev->inflight);
QLIST_INIT(&blkdev->finished);
QLIST_INIT(&blkdev->freelist);
blkdev->bh = qemu_bh_new(blk_bh, blkdev);
blkdev->iothread = iothread_create(xendev->name, &err);
assert(!err);
blkdev->ctx = iothread_get_aio_context(blkdev->iothread);
blkdev->bh = aio_bh_new(blkdev->ctx, blk_bh, blkdev);
if (xen_mode != XEN_EMULATE) {
batch_maps = 1;
}
@ -950,6 +973,8 @@ static int blk_init(struct XenDevice *xendev)
int info = 0;
char *directiosafe = NULL;
trace_xen_disk_init(xendev->name);
/* read xenstore entries */
if (blkdev->params == NULL) {
char *h = NULL;
@ -1062,6 +1087,8 @@ static int blk_connect(struct XenDevice *xendev)
unsigned int i;
uint32_t *domids;
trace_xen_disk_connect(xendev->name);
/* read-only ? */
if (blkdev->directiosafe) {
qflags = BDRV_O_NOCACHE | BDRV_O_NATIVE_AIO;
@ -1287,6 +1314,8 @@ static int blk_connect(struct XenDevice *xendev)
blkdev->persistent_gnt_count = 0;
}
blk_set_aio_context(blkdev->blk, blkdev->ctx);
xen_be_bind_evtchn(&blkdev->xendev);
xen_pv_printf(&blkdev->xendev, 1, "ok: proto %s, nr-ring-ref %u, "
@ -1300,13 +1329,20 @@ static void blk_disconnect(struct XenDevice *xendev)
{
struct XenBlkDev *blkdev = container_of(xendev, struct XenBlkDev, xendev);
trace_xen_disk_disconnect(xendev->name);
aio_context_acquire(blkdev->ctx);
if (blkdev->blk) {
blk_set_aio_context(blkdev->blk, qemu_get_aio_context());
blk_detach_dev(blkdev->blk, blkdev);
blk_unref(blkdev->blk);
blkdev->blk = NULL;
}
xen_pv_unbind_evtchn(&blkdev->xendev);
aio_context_release(blkdev->ctx);
if (blkdev->sring) {
xengnttab_unmap(blkdev->xendev.gnttabdev, blkdev->sring,
blkdev->nr_ring_ref);
@ -1345,6 +1381,8 @@ static int blk_free(struct XenDevice *xendev)
struct XenBlkDev *blkdev = container_of(xendev, struct XenBlkDev, xendev);
struct ioreq *ioreq;
trace_xen_disk_free(xendev->name);
blk_disconnect(xendev);
while (!QLIST_EMPTY(&blkdev->freelist)) {
@ -1360,6 +1398,7 @@ static int blk_free(struct XenDevice *xendev)
g_free(blkdev->dev);
g_free(blkdev->devtype);
qemu_bh_delete(blkdev->bh);
iothread_destroy(blkdev->iothread);
return 0;
}

300
hw/display/xenfb.c
View File

@ -27,6 +27,7 @@
#include "qemu/osdep.h"
#include "hw/hw.h"
#include "ui/input.h"
#include "ui/console.h"
#include "hw/xen/xen_backend.h"
@ -51,9 +52,11 @@ struct common {
struct XenInput {
struct common c;
int abs_pointer_wanted; /* Whether guest supports absolute pointer */
int button_state; /* Last seen pointer button state */
int extended;
QEMUPutMouseEntry *qmouse;
int raw_pointer_wanted; /* Whether guest supports raw (unscaled) pointer */
QemuInputHandlerState *qkbd;
QemuInputHandlerState *qmou;
int axis[INPUT_AXIS__MAX];
int wheel;
};
#define UP_QUEUE 8
@ -119,79 +122,6 @@ static void common_unbind(struct common *c)
}
/* -------------------------------------------------------------------- */
#if 0
/*
* These two tables are not needed any more, but left in here
* intentionally as documentation, to show how scancode2linux[]
* was generated.
*
* Tables to map from scancode to Linux input layer keycode.
* Scancodes are hardware-specific. These maps assumes a
* standard AT or PS/2 keyboard which is what QEMU feeds us.
*/
const unsigned char atkbd_set2_keycode[512] = {
0, 67, 65, 63, 61, 59, 60, 88, 0, 68, 66, 64, 62, 15, 41,117,
0, 56, 42, 93, 29, 16, 2, 0, 0, 0, 44, 31, 30, 17, 3, 0,
0, 46, 45, 32, 18, 5, 4, 95, 0, 57, 47, 33, 20, 19, 6,183,
0, 49, 48, 35, 34, 21, 7,184, 0, 0, 50, 36, 22, 8, 9,185,
0, 51, 37, 23, 24, 11, 10, 0, 0, 52, 53, 38, 39, 25, 12, 0,
0, 89, 40, 0, 26, 13, 0, 0, 58, 54, 28, 27, 0, 43, 0, 85,
0, 86, 91, 90, 92, 0, 14, 94, 0, 79,124, 75, 71,121, 0, 0,
82, 83, 80, 76, 77, 72, 1, 69, 87, 78, 81, 74, 55, 73, 70, 99,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
217,100,255, 0, 97,165, 0, 0,156, 0, 0, 0, 0, 0, 0,125,
173,114, 0,113, 0, 0, 0,126,128, 0, 0,140, 0, 0, 0,127,
159, 0,115, 0,164, 0, 0,116,158, 0,150,166, 0, 0, 0,142,
157, 0, 0, 0, 0, 0, 0, 0,155, 0, 98, 0, 0,163, 0, 0,
226, 0, 0, 0, 0, 0, 0, 0, 0,255, 96, 0, 0, 0,143, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0,107, 0,105,102, 0, 0,112,
110,111,108,112,106,103, 0,119, 0,118,109, 0, 99,104,119, 0,
};
const unsigned char atkbd_unxlate_table[128] = {
0,118, 22, 30, 38, 37, 46, 54, 61, 62, 70, 69, 78, 85,102, 13,
21, 29, 36, 45, 44, 53, 60, 67, 68, 77, 84, 91, 90, 20, 28, 27,
35, 43, 52, 51, 59, 66, 75, 76, 82, 14, 18, 93, 26, 34, 33, 42,
50, 49, 58, 65, 73, 74, 89,124, 17, 41, 88, 5, 6, 4, 12, 3,
11, 2, 10, 1, 9,119,126,108,117,125,123,107,115,116,121,105,
114,122,112,113,127, 96, 97,120, 7, 15, 23, 31, 39, 47, 55, 63,
71, 79, 86, 94, 8, 16, 24, 32, 40, 48, 56, 64, 72, 80, 87,111,
19, 25, 57, 81, 83, 92, 95, 98, 99,100,101,103,104,106,109,110
};
#endif
/*
* for (i = 0; i < 128; i++) {
* scancode2linux[i] = atkbd_set2_keycode[atkbd_unxlate_table[i]];
* scancode2linux[i | 0x80] = atkbd_set2_keycode[atkbd_unxlate_table[i] | 0x80];
* }
*/
static const unsigned char scancode2linux[512] = {
0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15,
16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31,
32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47,
48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63,
64, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79,
80, 81, 82, 83, 99, 0, 86, 87, 88,117, 0, 0, 95,183,184,185,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
93, 0, 0, 89, 0, 0, 85, 91, 90, 92, 0, 94, 0,124,121, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
165, 0, 0, 0, 0, 0, 0, 0, 0,163, 0, 0, 96, 97, 0, 0,
113,140,164, 0,166, 0, 0, 0, 0, 0,255, 0, 0, 0,114, 0,
115, 0,150, 0, 0, 98,255, 99,100, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0,119,119,102,103,104, 0,105,112,106,118,107,
108,109,110,111, 0, 0, 0, 0, 0, 0, 0,125,126,127,116,142,
0, 0, 0,143, 0,217,156,173,128,159,158,157,155,226, 0,112,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
};
/* Send an event to the keyboard frontend driver */
static int xenfb_kbd_event(struct XenInput *xenfb,
union xenkbd_in_event *event)
@ -262,36 +192,28 @@ static int xenfb_send_position(struct XenInput *xenfb,
/*
* Send a key event from the client to the guest OS
* QEMU gives us a raw scancode from an AT / PS/2 style keyboard.
* QEMU gives us a QCode.
* We have to turn this into a Linux Input layer keycode.
*
* Extra complexity from the fact that with extended scancodes
* (like those produced by arrow keys) this method gets called
* twice, but we only want to send a single event. So we have to
* track the '0xe0' scancode state & collapse the extended keys
* as needed.
*
* Wish we could just send scancodes straight to the guest which
* already has code for dealing with this...
*/
static void xenfb_key_event(void *opaque, int scancode)
static void xenfb_key_event(DeviceState *dev, QemuConsole *src,
InputEvent *evt)
{
struct XenInput *xenfb = opaque;
int down = 1;
struct XenInput *xenfb = (struct XenInput *)dev;
InputKeyEvent *key = evt->u.key.data;
int qcode = qemu_input_key_value_to_qcode(key->key);
int lnx;
if (scancode == 0xe0) {
xenfb->extended = 1;
return;
} else if (scancode & 0x80) {
scancode &= 0x7f;
down = 0;
if (qcode < qemu_input_map_qcode_to_linux_len) {
lnx = qemu_input_map_qcode_to_linux[qcode];
if (lnx) {
trace_xenfb_key_event(xenfb, lnx, key->down);
xenfb_send_key(xenfb, key->down, lnx);
}
}
if (xenfb->extended) {
scancode |= 0x80;
xenfb->extended = 0;
}
trace_xenfb_key_event(opaque, scancode2linux[scancode], down);
xenfb_send_key(xenfb, down, scancode2linux[scancode]);
}
/*
@ -303,48 +225,126 @@ static void xenfb_key_event(void *opaque, int scancode)
* given any button up/down events, so have to track changes in
* the button state.
*/
static void xenfb_mouse_event(void *opaque,
int dx, int dy, int dz, int button_state)
static void xenfb_mouse_event(DeviceState *dev, QemuConsole *src,
InputEvent *evt)
{
struct XenInput *xenfb = opaque;
QemuConsole *con = qemu_console_lookup_by_index(0);
struct XenInput *xenfb = (struct XenInput *)dev;
InputBtnEvent *btn;
InputMoveEvent *move;
QemuConsole *con;
DisplaySurface *surface;
int dw, dh, i;
int scale;
if (!con) {
xen_pv_printf(&xenfb->c.xendev, 0, "No QEMU console available");
return;
switch (evt->type) {
case INPUT_EVENT_KIND_BTN:
btn = evt->u.btn.data;
switch (btn->button) {
case INPUT_BUTTON_LEFT:
xenfb_send_key(xenfb, btn->down, BTN_LEFT);
break;
case INPUT_BUTTON_RIGHT:
xenfb_send_key(xenfb, btn->down, BTN_LEFT + 1);
break;
case INPUT_BUTTON_MIDDLE:
xenfb_send_key(xenfb, btn->down, BTN_LEFT + 2);
break;
case INPUT_BUTTON_WHEEL_UP:
if (btn->down) {
xenfb->wheel--;
}
break;
case INPUT_BUTTON_WHEEL_DOWN:
if (btn->down) {
xenfb->wheel++;
}
break;
default:
break;
}
break;
case INPUT_EVENT_KIND_ABS:
move = evt->u.abs.data;
if (xenfb->raw_pointer_wanted) {
xenfb->axis[move->axis] = move->value;
} else {
con = qemu_console_lookup_by_index(0);
if (!con) {
xen_pv_printf(&xenfb->c.xendev, 0, "No QEMU console available");
return;
}
surface = qemu_console_surface(con);
switch (move->axis) {
case INPUT_AXIS_X:
scale = surface_width(surface) - 1;
break;
case INPUT_AXIS_Y:
scale = surface_height(surface) - 1;
break;
default:
scale = 0x8000;
break;
}
xenfb->axis[move->axis] = move->value * scale / 0x7fff;
}
break;
case INPUT_EVENT_KIND_REL:
move = evt->u.rel.data;
xenfb->axis[move->axis] += move->value;
break;
default:
break;
}
surface = qemu_console_surface(con);
dw = surface_width(surface);
dh = surface_height(surface);
trace_xenfb_mouse_event(opaque, dx, dy, dz, button_state,
xenfb->abs_pointer_wanted);
if (xenfb->abs_pointer_wanted)
xenfb_send_position(xenfb,
dx * (dw - 1) / 0x7fff,
dy * (dh - 1) / 0x7fff,
dz);
else
xenfb_send_motion(xenfb, dx, dy, dz);
for (i = 0 ; i < 8 ; i++) {
int lastDown = xenfb->button_state & (1 << i);
int down = button_state & (1 << i);
if (down == lastDown)
continue;
if (xenfb_send_key(xenfb, down, BTN_LEFT+i) < 0)
return;
}
xenfb->button_state = button_state;
}
static void xenfb_mouse_sync(DeviceState *dev)
{
struct XenInput *xenfb = (struct XenInput *)dev;
trace_xenfb_mouse_event(xenfb, xenfb->axis[INPUT_AXIS_X],
xenfb->axis[INPUT_AXIS_Y],
xenfb->wheel, 0,
xenfb->abs_pointer_wanted);
if (xenfb->abs_pointer_wanted) {
xenfb_send_position(xenfb, xenfb->axis[INPUT_AXIS_X],
xenfb->axis[INPUT_AXIS_Y],
xenfb->wheel);
} else {
xenfb_send_motion(xenfb, xenfb->axis[INPUT_AXIS_X],
xenfb->axis[INPUT_AXIS_Y],
xenfb->wheel);
xenfb->axis[INPUT_AXIS_X] = 0;
xenfb->axis[INPUT_AXIS_Y] = 0;
}
xenfb->wheel = 0;
}
static QemuInputHandler xenfb_keyboard = {
.name = "Xen PV Keyboard",
.mask = INPUT_EVENT_MASK_KEY,
.event = xenfb_key_event,
};
static QemuInputHandler xenfb_abs_mouse = {
.name = "Xen PV Mouse",
.mask = INPUT_EVENT_MASK_BTN | INPUT_EVENT_MASK_ABS,
.event = xenfb_mouse_event,
.sync = xenfb_mouse_sync,
};
static QemuInputHandler xenfb_rel_mouse = {
.name = "Xen PV Mouse",
.mask = INPUT_EVENT_MASK_BTN | INPUT_EVENT_MASK_REL,
.event = xenfb_mouse_event,
.sync = xenfb_mouse_sync,
};
static int input_init(struct XenDevice *xendev)
{
xenstore_write_be_int(xendev, "feature-abs-pointer", 1);
xenstore_write_be_int(xendev, "feature-raw-pointer", 1);
return 0;
}
@ -357,7 +357,6 @@ static int input_initialise(struct XenDevice *xendev)
if (rc != 0)
return rc;
qemu_add_kbd_event_handler(xenfb_key_event, in);
return 0;
}
@ -369,25 +368,44 @@ static void input_connected(struct XenDevice *xendev)
&in->abs_pointer_wanted) == -1) {
in->abs_pointer_wanted = 0;
}
if (xenstore_read_fe_int(xendev, "request-raw-pointer",
&in->raw_pointer_wanted) == -1) {
in->raw_pointer_wanted = 0;
}
if (in->raw_pointer_wanted && in->abs_pointer_wanted == 0) {
xen_pv_printf(xendev, 0, "raw pointer set without abs pointer");
}
if (in->qmouse) {
qemu_remove_mouse_event_handler(in->qmouse);
if (in->qkbd) {
qemu_input_handler_unregister(in->qkbd);
}
if (in->qmou) {
qemu_input_handler_unregister(in->qmou);
}
trace_xenfb_input_connected(xendev, in->abs_pointer_wanted);
in->qmouse = qemu_add_mouse_event_handler(xenfb_mouse_event, in,
in->abs_pointer_wanted,
"Xen PVFB Mouse");
in->qkbd = qemu_input_handler_register((DeviceState *)in, &xenfb_keyboard);
in->qmou = qemu_input_handler_register((DeviceState *)in,
in->abs_pointer_wanted ? &xenfb_abs_mouse : &xenfb_rel_mouse);
if (in->raw_pointer_wanted) {
qemu_input_handler_activate(in->qkbd);
qemu_input_handler_activate(in->qmou);
}
}
static void input_disconnect(struct XenDevice *xendev)
{
struct XenInput *in = container_of(xendev, struct XenInput, c.xendev);
if (in->qmouse) {
qemu_remove_mouse_event_handler(in->qmouse);
in->qmouse = NULL;
if (in->qkbd) {
qemu_input_handler_unregister(in->qkbd);
in->qkbd = NULL;
}
if (in->qmou) {
qemu_input_handler_unregister(in->qmou);
in->qmou = NULL;
}
qemu_add_kbd_event_handler(NULL, NULL);
common_unbind(&in->c);
}

1
hw/xen/xen_pt.c
View File

@ -946,6 +946,7 @@ static void xen_pci_passthrough_class_init(ObjectClass *klass, void *data)
k->exit = xen_pt_unregister_device;
k->config_read = xen_pt_pci_read_config;
k->config_write = xen_pt_pci_write_config;
k->is_express = 1; /* We might be */
set_bit(DEVICE_CATEGORY_MISC, dc->categories);
dc->desc = "Assign an host PCI device with Xen";
dc->props = xen_pci_passthrough_properties;

3
include/ui/input.h
View File

@ -77,4 +77,7 @@ extern const guint16 qemu_input_map_qcode_to_qnum[];
extern const guint qemu_input_map_qnum_to_qcode_len;
extern const guint16 qemu_input_map_qnum_to_qcode[];
extern const guint qemu_input_map_qcode_to_linux_len;
extern const guint16 qemu_input_map_qcode_to_linux[];
#endif /* INPUT_H */

1
ui/input-keymap.c
View File

@ -8,6 +8,7 @@
#include "ui/input-keymap-linux-to-qcode.c"
#include "ui/input-keymap-qcode-to-qnum.c"
#include "ui/input-keymap-qnum-to-qcode.c"
#include "ui/input-keymap-qcode-to-linux.c"
int qemu_input_linux_to_qcode(unsigned int lnx)
{