Attachment #264723 for bug #357371

View | Details | Raw Unified | Return to bug 357371
Collapse All | Expand All




static void qxl_reset_surfaces(PCIQXLDevice *d);
static void qxl_ring_set_dirty(PCIQXLDevice *qxl);

/* qemu-kvm locking ... */
void qxl_unlock_iothread(SimpleSpiceDisplay *ssd)
{
    if (cpu_single_env) {
        assert(ssd->env == NULL);
        ssd->env = cpu_single_env;
        cpu_single_env = NULL;
    }
    qemu_mutex_unlock_iothread();
}

void qxl_lock_iothread(SimpleSpiceDisplay *ssd)
{
    qemu_mutex_lock_iothread();
    if (ssd->env) {
        assert(cpu_single_env == NULL);
        cpu_single_env = ssd->env;
        ssd->env = NULL;
    }
}

static inline uint32_t msb_mask(uint32_t val)
{
    uint32_t mask;

    dprint(d, 1, "%s: start%s\n", __FUNCTION__,
           loadvm ? " (loadvm)" : "");

    qxl_unlock_iothread(&d->ssd);
    d->ssd.worker->reset_cursor(d->ssd.worker);
    d->ssd.worker->reset_image_cache(d->ssd.worker);
    qxl_lock_iothread(&d->ssd);
    qxl_reset_surfaces(d);
    qxl_reset_memslots(d);


{
    dprint(d, 1, "%s:\n", __FUNCTION__);
    d->mode = QXL_MODE_UNDEFINED;
    qxl_unlock_iothread(&d->ssd);
    d->ssd.worker->destroy_surfaces(d->ssd.worker);
    qxl_lock_iothread(&d->ssd);
    memset(&d->guest_surfaces.cmds, 0, sizeof(d->guest_surfaces.cmds));
}


    dprint(d, 1, "%s\n", __FUNCTION__);

    d->mode = QXL_MODE_UNDEFINED;
    qxl_unlock_iothread(&d->ssd);
    d->ssd.worker->destroy_primary_surface(d->ssd.worker, 0);
    qxl_lock_iothread(&d->ssd);
}

static void qxl_set_mode(PCIQXLDevice *d, int modenr, int loadvm)

    case QXL_IO_UPDATE_AREA:
    {
        QXLRect update = d->ram->update_area;
        qxl_unlock_iothread(&d->ssd);
        d->ssd.worker->update_area(d->ssd.worker, d->ram->update_surface,
                                   &update, NULL, 0, 0);
        qxl_lock_iothread(&d->ssd);
        break;
    }
    case QXL_IO_NOTIFY_CMD:




    surface.mem        = (intptr_t)ssd->buf;
    surface.group_id   = MEMSLOT_GROUP_HOST;

    qxl_unlock_iothread(ssd);
    ssd->worker->create_primary_surface(ssd->worker, 0, &surface);
    qxl_lock_iothread(ssd);
}

void qemu_spice_destroy_host_primary(SimpleSpiceDisplay *ssd)
{
    dprint(1, "%s:\n", __FUNCTION__);

    qxl_unlock_iothread(ssd);
    ssd->worker->destroy_primary_surface(ssd->worker, 0);
    qxl_lock_iothread(ssd);
}

void qemu_spice_vm_change_state_handler(void *opaque, int running, int reason)

    if (running) {
        ssd->worker->start(ssd->worker);
    } else {
        qxl_unlock_iothread(ssd);
        ssd->worker->stop(ssd->worker);
        qxl_lock_iothread(ssd);
    }
    ssd->running = running;
}

Lines 43-48 typedef struct SimpleSpiceDisplay { Link Here

(-)a/ui/spice-display.h (-1 / +6 lines)
43	QXLRect dirty;	43	QXLRect dirty;
44	int notify;	44	int notify;
45	int running;	45	int running;
		46
		47	/* qemu-kvm locking ... */
		48	void *env;
46	} SimpleSpiceDisplay;	49	} SimpleSpiceDisplay;
47		50
48	typedef struct SimpleSpiceUpdate {	51	typedef struct SimpleSpiceUpdate {
Lines 52-57 typedef struct SimpleSpiceUpdate { Link Here
52	uint8_t *bitmap;	55	uint8_t *bitmap;
53	} SimpleSpiceUpdate;	56	} SimpleSpiceUpdate;
54		57
		58	void qxl_unlock_iothread(SimpleSpiceDisplay *ssd);
		59	void qxl_lock_iothread(SimpleSpiceDisplay *ssd);
		60
55	int qemu_spice_rect_is_empty(const QXLRect* r);	61	int qemu_spice_rect_is_empty(const QXLRect* r);
56	void qemu_spice_rect_union(QXLRect dest, const QXLRect r);	62	void qemu_spice_rect_union(QXLRect dest, const QXLRect r);
57		63
58	-

Return to bug 357371

Lines 125-130 static void qxl_reset_memslots(PCIQXLDevice *d); Link Here

(-)a/hw/qxl.c (-8 / +29 lines)
125	static void qxl_reset_surfaces(PCIQXLDevice *d);	125	static void qxl_reset_surfaces(PCIQXLDevice *d);
126	static void qxl_ring_set_dirty(PCIQXLDevice *qxl);	126	static void qxl_ring_set_dirty(PCIQXLDevice *qxl);
127		127
		128	/* qemu-kvm locking ... */
		129	void qxl_unlock_iothread(SimpleSpiceDisplay *ssd)
		130	{
		131	if (cpu_single_env) {
		132	assert(ssd->env == NULL);
		133	ssd->env = cpu_single_env;
		134	cpu_single_env = NULL;
		135	}
		136	qemu_mutex_unlock_iothread();
		137	}
		138
		139	void qxl_lock_iothread(SimpleSpiceDisplay *ssd)
		140	{
		141	qemu_mutex_lock_iothread();
		142	if (ssd->env) {
		143	assert(cpu_single_env == NULL);
		144	cpu_single_env = ssd->env;
		145	ssd->env = NULL;
		146	}
		147	}
		148
128	static inline uint32_t msb_mask(uint32_t val)	149	static inline uint32_t msb_mask(uint32_t val)
129	{	150	{
130	uint32_t mask;	151	uint32_t mask;
Lines 662-671 static void qxl_hard_reset(PCIQXLDevice *d, int loadvm) Link Here
662	dprint(d, 1, "%s: start%s\n", __FUNCTION__,	683	dprint(d, 1, "%s: start%s\n", __FUNCTION__,
663	loadvm ? " (loadvm)" : "");	684	loadvm ? " (loadvm)" : "");
664		685
665	qemu_mutex_unlock_iothread();	686	qxl_unlock_iothread(&d->ssd);
666	d->ssd.worker->reset_cursor(d->ssd.worker);	687	d->ssd.worker->reset_cursor(d->ssd.worker);
667	d->ssd.worker->reset_image_cache(d->ssd.worker);	688	d->ssd.worker->reset_image_cache(d->ssd.worker);
668	qemu_mutex_lock_iothread();	689	qxl_lock_iothread(&d->ssd);
669	qxl_reset_surfaces(d);	690	qxl_reset_surfaces(d);
670	qxl_reset_memslots(d);	691	qxl_reset_memslots(d);
671		692
Lines 795-803 static void qxl_reset_surfaces(PCIQXLDevice *d) Link Here
795	{	816	{
796	dprint(d, 1, "%s:\n", __FUNCTION__);	817	dprint(d, 1, "%s:\n", __FUNCTION__);
797	d->mode = QXL_MODE_UNDEFINED;	818	d->mode = QXL_MODE_UNDEFINED;
798	qemu_mutex_unlock_iothread();	819	qxl_unlock_iothread(&d->ssd);
799	d->ssd.worker->destroy_surfaces(d->ssd.worker);	820	d->ssd.worker->destroy_surfaces(d->ssd.worker);
800	qemu_mutex_lock_iothread();	821	qxl_lock_iothread(&d->ssd);
801	memset(&d->guest_surfaces.cmds, 0, sizeof(d->guest_surfaces.cmds));	822	memset(&d->guest_surfaces.cmds, 0, sizeof(d->guest_surfaces.cmds));
802	}	823	}
803		824
Lines 866-874 static void qxl_destroy_primary(PCIQXLDevice *d) Link Here
866	dprint(d, 1, "%s\n", __FUNCTION__);	887	dprint(d, 1, "%s\n", __FUNCTION__);
867		888
868	d->mode = QXL_MODE_UNDEFINED;	889	d->mode = QXL_MODE_UNDEFINED;
869	qemu_mutex_unlock_iothread();	890	qxl_unlock_iothread(&d->ssd);
870	d->ssd.worker->destroy_primary_surface(d->ssd.worker, 0);	891	d->ssd.worker->destroy_primary_surface(d->ssd.worker, 0);
871	qemu_mutex_lock_iothread();	892	qxl_lock_iothread(&d->ssd);
872	}	893	}
873		894
874	static void qxl_set_mode(PCIQXLDevice *d, int modenr, int loadvm)	895	static void qxl_set_mode(PCIQXLDevice *d, int modenr, int loadvm)
Lines 938-947 static void ioport_write(void *opaque, uint32_t addr, uint32_t val) Link Here
938	case QXL_IO_UPDATE_AREA:	959	case QXL_IO_UPDATE_AREA:
939	{	960	{
940	QXLRect update = d->ram->update_area;	961	QXLRect update = d->ram->update_area;
941	qemu_mutex_unlock_iothread();	962	qxl_unlock_iothread(&d->ssd);
942	d->ssd.worker->update_area(d->ssd.worker, d->ram->update_surface,	963	d->ssd.worker->update_area(d->ssd.worker, d->ram->update_surface,
943	&update, NULL, 0, 0);	964	&update, NULL, 0, 0);
944	qemu_mutex_lock_iothread();	965	qxl_lock_iothread(&d->ssd);
945	break;	966	break;
946	}	967	}
947	case QXL_IO_NOTIFY_CMD:	968	case QXL_IO_NOTIFY_CMD:

Lines 186-203 void qemu_spice_create_host_primary(SimpleSpiceDisplay *ssd) Link Here

(-)a/ui/spice-display.c (-6 / +6 lines)
186	surface.mem = (intptr_t)ssd->buf;	186	surface.mem = (intptr_t)ssd->buf;
187	surface.group_id = MEMSLOT_GROUP_HOST;	187	surface.group_id = MEMSLOT_GROUP_HOST;
188		188
189	qemu_mutex_unlock_iothread();	189	qxl_unlock_iothread(ssd);
190	ssd->worker->create_primary_surface(ssd->worker, 0, &surface);	190	ssd->worker->create_primary_surface(ssd->worker, 0, &surface);
191	qemu_mutex_lock_iothread();	191	qxl_lock_iothread(ssd);
192	}	192	}
193		193
194	void qemu_spice_destroy_host_primary(SimpleSpiceDisplay *ssd)	194	void qemu_spice_destroy_host_primary(SimpleSpiceDisplay *ssd)
195	{	195	{
196	dprint(1, "%s:\n", __FUNCTION__);	196	dprint(1, "%s:\n", __FUNCTION__);
197		197
198	qemu_mutex_unlock_iothread();	198	qxl_unlock_iothread(ssd);
199	ssd->worker->destroy_primary_surface(ssd->worker, 0);	199	ssd->worker->destroy_primary_surface(ssd->worker, 0);
200	qemu_mutex_lock_iothread();	200	qxl_lock_iothread(ssd);
201	}	201	}
202		202
203	void qemu_spice_vm_change_state_handler(void *opaque, int running, int reason)	203	void qemu_spice_vm_change_state_handler(void *opaque, int running, int reason)
Lines 207-215 void qemu_spice_vm_change_state_handler(void *opaque, int running, int reason) Link Here
207	if (running) {	207	if (running) {
208	ssd->worker->start(ssd->worker);	208	ssd->worker->start(ssd->worker);
209	} else {	209	} else {
210	qemu_mutex_unlock_iothread();	210	qxl_unlock_iothread(ssd);
211	ssd->worker->stop(ssd->worker);	211	ssd->worker->stop(ssd->worker);
212	qemu_mutex_lock_iothread();	212	qxl_lock_iothread(ssd);
213	}	213	}
214	ssd->running = running;	214	ssd->running = running;
215	}	215	}