pxcloud/spice
6
0
Fork 0
mirror of https://gitlab.uni-freiburg.de/opensourcevdi/spice synced 2026-08-09 11:50:55 +00:00
Code Issues Actions Packages Projects Releases Wiki Activity

memslot: prefix memslot functions with memslot_

Browse Source 
Signed-off-by: Frediano Ziglio <fziglio@redhat.com>
Acked-by: Fabiano Fidêncio <fidencio@redhat.com>
This commit is contained in:
Frediano Ziglio 2015-12-01 16:33:07 +00:00
parent 768dfa2139
commit 7280460b78
5 changed files with 141 additions and 141 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

34
server/red_memslots.c
View File

@ -49,8 +49,8 @@ static void print_memslots(RedMemSlotInfo *info)
}
/* return 1 if validation successfull, 0 otherwise */
int validate_virt(RedMemSlotInfo *info, unsigned long virt, int slot_id,
uint32_t add_size, uint32_t group_id)
int memslot_validate_virt(RedMemSlotInfo *info, unsigned long virt, int slot_id,
uint32_t add_size, uint32_t group_id)
{
MemSlot *slot;
@ -76,8 +76,8 @@ int validate_virt(RedMemSlotInfo *info, unsigned long virt, int slot_id,
* return virtual address if successful, which may be 0.
* returns 0 and sets error to 1 if an error condition occurs.
*/
unsigned long get_virt(RedMemSlotInfo *info, QXLPHYSICAL addr, uint32_t add_size,
int group_id, int *error)
unsigned long memslot_get_virt(RedMemSlotInfo *info, QXLPHYSICAL addr, uint32_t add_size,
int group_id, int *error)
{
int slot_id;
int generation;
@ -92,7 +92,7 @@ unsigned long get_virt(RedMemSlotInfo *info, QXLPHYSICAL addr, uint32_t add_size
return 0;
}
slot_id = get_memslot_id(info, addr);
slot_id = memslot_get_id(info, addr);
if (slot_id > info->num_memslots) {
print_memslots(info);
spice_critical("slot_id %d too big, addr=%" PRIx64, slot_id, addr);
@ -102,7 +102,7 @@ unsigned long get_virt(RedMemSlotInfo *info, QXLPHYSICAL addr, uint32_t add_size
slot = &info->mem_slots[group_id][slot_id];
generation = get_generation(info, addr);
generation = memslot_get_generation(info, addr);
if (generation != slot->generation) {
print_memslots(info);
spice_critical("address generation is not valid, group_id %d, slot_id %d, gen %d, slot_gen %d\n",
@ -114,7 +114,7 @@ unsigned long get_virt(RedMemSlotInfo *info, QXLPHYSICAL addr, uint32_t add_size
h_virt = __get_clean_virt(info, addr);
h_virt += slot->address_delta;
if (!validate_virt(info, h_virt, slot_id, add_size, group_id)) {
if (!memslot_validate_virt(info, h_virt, slot_id, add_size, group_id)) {
*error = 1;
return 0;
}
@ -122,11 +122,11 @@ unsigned long get_virt(RedMemSlotInfo *info, QXLPHYSICAL addr, uint32_t add_size
return h_virt;
}
void red_memslot_info_init(RedMemSlotInfo *info,
uint32_t num_groups, uint32_t num_slots,
uint8_t generation_bits,
uint8_t id_bits,
uint8_t internal_groupslot_id)
void memslot_info_init(RedMemSlotInfo *info,
uint32_t num_groups, uint32_t num_slots,
uint8_t generation_bits,
uint8_t id_bits,
uint8_t internal_groupslot_id)
{
uint32_t i;
@ -153,9 +153,9 @@ void red_memslot_info_init(RedMemSlotInfo *info,
(info->mem_slot_bits + info->generation_bits));
}
void red_memslot_info_add_slot(RedMemSlotInfo *info, uint32_t slot_group_id, uint32_t slot_id,
uint64_t addr_delta, unsigned long virt_start, unsigned long virt_end,
uint32_t generation)
void memslot_info_add_slot(RedMemSlotInfo *info, uint32_t slot_group_id, uint32_t slot_id,
uint64_t addr_delta, unsigned long virt_start, unsigned long virt_end,
uint32_t generation)
{
spice_assert(info->num_memslots_groups > slot_group_id);
spice_assert(info->num_memslots > slot_id);
@ -166,7 +166,7 @@ void red_memslot_info_add_slot(RedMemSlotInfo *info, uint32_t slot_group_id, uin
info->mem_slots[slot_group_id][slot_id].generation = generation;
}
void red_memslot_info_del_slot(RedMemSlotInfo *info, uint32_t slot_group_id, uint32_t slot_id)
void memslot_info_del_slot(RedMemSlotInfo *info, uint32_t slot_group_id, uint32_t slot_id)
{
spice_assert(info->num_memslots_groups > slot_group_id);
spice_assert(info->num_memslots > slot_id);
@ -175,7 +175,7 @@ void red_memslot_info_del_slot(RedMemSlotInfo *info, uint32_t slot_group_id, uin
info->mem_slots[slot_group_id][slot_id].virt_end_addr = 0;
}
void red_memslot_info_reset(RedMemSlotInfo *info)
void memslot_info_reset(RedMemSlotInfo *info)
{
uint32_t i;
for (i = 0; i < info->num_memslots_groups; ++i) {

30
server/red_memslots.h
View File

@ -43,30 +43,30 @@ typedef struct RedMemSlotInfo {
unsigned long memslot_clean_virt_mask;
} RedMemSlotInfo;
static inline int get_memslot_id(RedMemSlotInfo *info, uint64_t addr)
static inline int memslot_get_id(RedMemSlotInfo *info, uint64_t addr)
{
return addr >> info->memslot_id_shift;
}
static inline int get_generation(RedMemSlotInfo *info, uint64_t addr)
static inline int memslot_get_generation(RedMemSlotInfo *info, uint64_t addr)
{
return (addr >> info->memslot_gen_shift) & info->memslot_gen_mask;
}
int validate_virt(RedMemSlotInfo *info, unsigned long virt, int slot_id,
uint32_t add_size, uint32_t group_id);
unsigned long get_virt(RedMemSlotInfo *info, QXLPHYSICAL addr, uint32_t add_size,
int memslot_validate_virt(RedMemSlotInfo *info, unsigned long virt, int slot_id,
uint32_t add_size, uint32_t group_id);
unsigned long memslot_get_virt(RedMemSlotInfo *info, QXLPHYSICAL addr, uint32_t add_size,
int group_id, int *error);
void red_memslot_info_init(RedMemSlotInfo *info,
uint32_t num_groups, uint32_t num_slots,
uint8_t generation_bits,
uint8_t id_bits,
uint8_t internal_groupslot_id);
void red_memslot_info_add_slot(RedMemSlotInfo *info, uint32_t slot_group_id, uint32_t slot_id,
uint64_t addr_delta, unsigned long virt_start, unsigned long virt_end,
uint32_t generation);
void red_memslot_info_del_slot(RedMemSlotInfo *info, uint32_t slot_group_id, uint32_t slot_id);
void red_memslot_info_reset(RedMemSlotInfo *info);
void memslot_info_init(RedMemSlotInfo *info,
uint32_t num_groups, uint32_t num_slots,
uint8_t generation_bits,
uint8_t id_bits,
uint8_t internal_groupslot_id);
void memslot_info_add_slot(RedMemSlotInfo *info, uint32_t slot_group_id, uint32_t slot_id,
uint64_t addr_delta, unsigned long virt_start, unsigned long virt_end,
uint32_t generation);
void memslot_info_del_slot(RedMemSlotInfo *info, uint32_t slot_group_id, uint32_t slot_id);
void memslot_info_reset(RedMemSlotInfo *info);
#endif

70
server/red_parse_qxl.c
View File

@ -52,7 +52,7 @@ static void hexdump_qxl(RedMemSlotInfo *slots, int group_id,
uint8_t *hex;
int i;
hex = (uint8_t*)get_virt(slots, addr, bytes, group_id);
hex = (uint8_t*)memslot_get_virt(slots, addr, bytes, group_id);
for (i = 0; i < bytes; i++) {
if (0 == i % 16) {
fprintf(stderr, "%lx: ", addr+i);
@ -118,7 +118,7 @@ static size_t red_get_data_chunks_ptr(RedMemSlotInfo *slots, int group_id,
data_size += red->data_size;
red->data = qxl->data;
red->prev_chunk = red->next_chunk = NULL;
if (!validate_virt(slots, (intptr_t)red->data, memslot_id, red->data_size, group_id)) {
if (!memslot_validate_virt(slots, (intptr_t)red->data, memslot_id, red->data_size, group_id)) {
red->data = NULL;
return 0;
}
@ -132,9 +132,9 @@ static size_t red_get_data_chunks_ptr(RedMemSlotInfo *slots, int group_id,
goto error;
}
memslot_id = get_memslot_id(slots, next_chunk);
qxl = (QXLDataChunk *)get_virt(slots, next_chunk, sizeof(*qxl),
group_id, &error);
memslot_id = memslot_get_id(slots, next_chunk);
qxl = (QXLDataChunk *)memslot_get_virt(slots, next_chunk, sizeof(*qxl),
group_id, &error);
if (error)
goto error;
@ -161,7 +161,7 @@ static size_t red_get_data_chunks_ptr(RedMemSlotInfo *slots, int group_id,
spice_warning("too much data inside chunks, avoiding DoS\n");
goto error;
}
if (!validate_virt(slots, (intptr_t)red->data, memslot_id, red->data_size, group_id))
if (!memslot_validate_virt(slots, (intptr_t)red->data, memslot_id, red->data_size, group_id))
goto error;
}
@ -185,9 +185,9 @@ static size_t red_get_data_chunks(RedMemSlotInfo *slots, int group_id,
{
QXLDataChunk *qxl;
int error;
int memslot_id = get_memslot_id(slots, addr);
int memslot_id = memslot_get_id(slots, addr);
qxl = (QXLDataChunk *)get_virt(slots, addr, sizeof(*qxl), group_id, &error);
qxl = (QXLDataChunk *)memslot_get_virt(slots, addr, sizeof(*qxl), group_id, &error);
if (error) {
return 0;
}
@ -242,12 +242,12 @@ static SpicePath *red_get_path(RedMemSlotInfo *slots, int group_id,
uint32_t count;
int error;
qxl = (QXLPath *)get_virt(slots, addr, sizeof(*qxl), group_id, &error);
qxl = (QXLPath *)memslot_get_virt(slots, addr, sizeof(*qxl), group_id, &error);
if (error) {
return NULL;
}
size = red_get_data_chunks_ptr(slots, group_id,
get_memslot_id(slots, addr),
memslot_get_id(slots, addr),
&chunks, &qxl->chunk);
data = red_linearize_chunk(&chunks, size, &free_data);
red_put_data_chunks(&chunks);
@ -321,12 +321,12 @@ static SpiceClipRects *red_get_clip_rects(RedMemSlotInfo *slots, int group_id,
int error;
uint32_t num_rects;
qxl = (QXLClipRects *)get_virt(slots, addr, sizeof(*qxl), group_id, &error);
qxl = (QXLClipRects *)memslot_get_virt(slots, addr, sizeof(*qxl), group_id, &error);
if (error) {
return NULL;
}
size = red_get_data_chunks_ptr(slots, group_id,
get_memslot_id(slots, addr),
memslot_get_id(slots, addr),
&chunks, &qxl->chunk);
data = red_linearize_chunk(&chunks, size, &free_data);
red_put_data_chunks(&chunks);
@ -355,7 +355,7 @@ static SpiceChunks *red_get_image_data_flat(RedMemSlotInfo *slots, int group_id,
data = spice_chunks_new(1);
data->data_size = size;
data->chunk[0].data = (void*)get_virt(slots, addr, size, group_id, &error);
data->chunk[0].data = (void*)memslot_get_virt(slots, addr, size, group_id, &error);
if (error) {
return 0;
}
@ -445,7 +445,7 @@ static SpiceImage *red_get_image(RedMemSlotInfo *slots, int group_id,
return NULL;
}
qxl = (QXLImage *)get_virt(slots, addr, sizeof(*qxl), group_id, &error);
qxl = (QXLImage *)memslot_get_virt(slots, addr, sizeof(*qxl), group_id, &error);
if (error) {
return NULL;
}
@ -488,15 +488,15 @@ static SpiceImage *red_get_image(RedMemSlotInfo *slots, int group_id,
if (palette) {
QXLPalette *qp;
int i, num_ents;
qp = (QXLPalette *)get_virt(slots, palette,
sizeof(*qp), group_id, &error);
qp = (QXLPalette *)memslot_get_virt(slots, palette,
sizeof(*qp), group_id, &error);
if (error) {
goto error;
}
num_ents = qp->num_ents;
if (!validate_virt(slots, (intptr_t)qp->ents,
get_memslot_id(slots, palette),
num_ents * sizeof(qp->ents[0]), group_id)) {
if (!memslot_validate_virt(slots, (intptr_t)qp->ents,
memslot_get_id(slots, palette),
num_ents * sizeof(qp->ents[0]), group_id)) {
goto error;
}
rp = spice_malloc_n_m(num_ents, sizeof(rp->ents[0]), sizeof(*rp));
@ -544,7 +544,7 @@ static SpiceImage *red_get_image(RedMemSlotInfo *slots, int group_id,
case SPICE_IMAGE_TYPE_QUIC:
red->u.quic.data_size = qxl->quic.data_size;
size = red_get_data_chunks_ptr(slots, group_id,
get_memslot_id(slots, addr),
memslot_get_id(slots, addr),
&chunks, (QXLDataChunk *)qxl->quic.data);
spice_assert(size == red->u.quic.data_size);
if (size != red->u.quic.data_size) {
@ -741,7 +741,7 @@ static bool get_transform(RedMemSlotInfo *slots,
if (qxl_transform == 0)
return FALSE;
t = (uint32_t *)get_virt(slots, qxl_transform, sizeof(*dst_transform), group_id, &error);
t = (uint32_t *)memslot_get_virt(slots, qxl_transform, sizeof(*dst_transform), group_id, &error);
if (!t || error)
return FALSE;
@ -816,8 +816,8 @@ static int red_get_stroke_ptr(RedMemSlotInfo *slots, int group_id,
red->attr.style = spice_malloc_n(style_nseg, sizeof(SPICE_FIXED28_4));
red->attr.style_nseg = style_nseg;
spice_assert(qxl->attr.style);
buf = (uint8_t *)get_virt(slots, qxl->attr.style,
style_nseg * sizeof(QXLFIXED), group_id, &error);
buf = (uint8_t *)memslot_get_virt(slots, qxl->attr.style,
style_nseg * sizeof(QXLFIXED), group_id, &error);
if (error) {
return error;
}
@ -858,12 +858,12 @@ static SpiceString *red_get_string(RedMemSlotInfo *slots, int group_id,
int error;
uint16_t qxl_flags, qxl_length;
qxl = (QXLString *)get_virt(slots, addr, sizeof(*qxl), group_id, &error);
qxl = (QXLString *)memslot_get_virt(slots, addr, sizeof(*qxl), group_id, &error);
if (error) {
return NULL;
}
chunk_size = red_get_data_chunks_ptr(slots, group_id,
get_memslot_id(slots, addr),
memslot_get_id(slots, addr),
&chunks, &qxl->chunk);
if (!chunk_size) {
/* XXX could be a zero sized string.. */
@ -1013,7 +1013,7 @@ static int red_get_native_drawable(RedMemSlotInfo *slots, int group_id,
int i;
int error = 0;
qxl = (QXLDrawable *)get_virt(slots, addr, sizeof(*qxl), group_id, &error);
qxl = (QXLDrawable *)memslot_get_virt(slots, addr, sizeof(*qxl), group_id, &error);
if (error) {
return error;
}
@ -1096,7 +1096,7 @@ static int red_get_compat_drawable(RedMemSlotInfo *slots, int group_id,
QXLCompatDrawable *qxl;
int error;
qxl = (QXLCompatDrawable *)get_virt(slots, addr, sizeof(*qxl), group_id, &error);
qxl = (QXLCompatDrawable *)memslot_get_virt(slots, addr, sizeof(*qxl), group_id, &error);
if (error) {
return error;
}
@ -1244,7 +1244,7 @@ int red_get_update_cmd(RedMemSlotInfo *slots, int group_id,
QXLUpdateCmd *qxl;
int error;
qxl = (QXLUpdateCmd *)get_virt(slots, addr, sizeof(*qxl), group_id, &error);
qxl = (QXLUpdateCmd *)memslot_get_virt(slots, addr, sizeof(*qxl), group_id, &error);
if (error) {
return 1;
}
@ -1273,7 +1273,7 @@ int red_get_message(RedMemSlotInfo *slots, int group_id,
* luckily this is for debug logging only,
* so we can just ignore it by default.
*/
qxl = (QXLMessage *)get_virt(slots, addr, sizeof(*qxl), group_id, &error);
qxl = (QXLMessage *)memslot_get_virt(slots, addr, sizeof(*qxl), group_id, &error);
if (error) {
return 1;
}
@ -1312,8 +1312,8 @@ int red_get_surface_cmd(RedMemSlotInfo *slots, int group_id,
int error;
unsigned int bpp;
qxl = (QXLSurfaceCmd *)get_virt(slots, addr, sizeof(*qxl), group_id,
&error);
qxl = (QXLSurfaceCmd *)memslot_get_virt(slots, addr, sizeof(*qxl), group_id,
&error);
if (error) {
return 1;
}
@ -1350,7 +1350,7 @@ int red_get_surface_cmd(RedMemSlotInfo *slots, int group_id,
return 1;
}
red->u.surface_create.data =
(uint8_t*)get_virt(slots, qxl->u.surface_create.data, size, group_id, &error);
(uint8_t*)memslot_get_virt(slots, qxl->u.surface_create.data, size, group_id, &error);
if (error) {
return 1;
}
@ -1374,7 +1374,7 @@ static int red_get_cursor(RedMemSlotInfo *slots, int group_id,
bool free_data;
int error;
qxl = (QXLCursor *)get_virt(slots, addr, sizeof(*qxl), group_id, &error);
qxl = (QXLCursor *)memslot_get_virt(slots, addr, sizeof(*qxl), group_id, &error);
if (error) {
return 1;
}
@ -1389,7 +1389,7 @@ static int red_get_cursor(RedMemSlotInfo *slots, int group_id,
red->flags = 0;
red->data_size = qxl->data_size;
size = red_get_data_chunks_ptr(slots, group_id,
get_memslot_id(slots, addr),
memslot_get_id(slots, addr),
&chunks, &qxl->chunk);
red->data_size = MIN(red->data_size, size);
data = red_linearize_chunk(&chunks, size, &free_data);
@ -1414,7 +1414,7 @@ int red_get_cursor_cmd(RedMemSlotInfo *slots, int group_id,
QXLCursorCmd *qxl;
int error;
qxl = (QXLCursorCmd *)get_virt(slots, addr, sizeof(*qxl), group_id, &error);
qxl = (QXLCursorCmd *)memslot_get_virt(slots, addr, sizeof(*qxl), group_id, &error);
if (error) {
return error;
}

102
server/red_record_qxl.c
View File

@ -35,8 +35,8 @@ static void hexdump_qxl(RedMemSlotInfo *slots, int group_id,
int i;
int error;
hex = (uint8_t*)get_virt(slots, addr, bytes, group_id,
&error);
hex = (uint8_t*)memslot_get_virt(slots, addr, bytes, group_id,
&error);
for (i = 0; i < bytes; i++) {
if (0 == i % 16) {
fprintf(stderr, "%lx: ", addr+i);
@ -139,21 +139,21 @@ static size_t red_record_data_chunks_ptr(FILE *fd, const char *prefix,
while (cur->next_chunk) {
cur =
(QXLDataChunk*)get_virt(slots, cur->next_chunk, sizeof(*cur), group_id,
&error);
(QXLDataChunk*)memslot_get_virt(slots, cur->next_chunk, sizeof(*cur), group_id,
&error);
data_size += cur->data_size;
count_chunks++;
}
fprintf(fd, "data_chunks %d %ld\n", count_chunks, data_size);
validate_virt(slots, (intptr_t)qxl->data, memslot_id, qxl->data_size, group_id);
memslot_validate_virt(slots, (intptr_t)qxl->data, memslot_id, qxl->data_size, group_id);
write_binary(fd, prefix, qxl->data_size, qxl->data);
while (qxl->next_chunk) {
memslot_id = get_memslot_id(slots, qxl->next_chunk);
qxl = (QXLDataChunk*)get_virt(slots, qxl->next_chunk, sizeof(*qxl), group_id,
&error);
memslot_id = memslot_get_id(slots, qxl->next_chunk);
qxl = (QXLDataChunk*)memslot_get_virt(slots, qxl->next_chunk, sizeof(*qxl), group_id,
&error);
validate_virt(slots, (intptr_t)qxl->data, memslot_id, qxl->data_size, group_id);
memslot_validate_virt(slots, (intptr_t)qxl->data, memslot_id, qxl->data_size, group_id);
write_binary(fd, prefix, qxl->data_size, qxl->data);
}
@ -165,11 +165,11 @@ static size_t red_record_data_chunks(FILE *fd, const char *prefix,
QXLPHYSICAL addr)
{
QXLDataChunk *qxl;
int memslot_id = get_memslot_id(slots, addr);
int memslot_id = memslot_get_id(slots, addr);
int error;
qxl = (QXLDataChunk*)get_virt(slots, addr, sizeof(*qxl), group_id,
&error);
qxl = (QXLDataChunk*)memslot_get_virt(slots, addr, sizeof(*qxl), group_id,
&error);
return red_record_data_chunks_ptr(fd, prefix, slots, group_id, memslot_id, qxl);
}
@ -195,10 +195,10 @@ static void red_record_path(FILE *fd, RedMemSlotInfo *slots, int group_id,
QXLPath *qxl;
int error;
qxl = (QXLPath *)get_virt(slots, addr, sizeof(*qxl), group_id,
&error);
qxl = (QXLPath *)memslot_get_virt(slots, addr, sizeof(*qxl), group_id,
&error);
red_record_data_chunks_ptr(fd, "path", slots, group_id,
get_memslot_id(slots, addr),
memslot_get_id(slots, addr),
&qxl->chunk);
}
@ -208,11 +208,11 @@ static void red_record_clip_rects(FILE *fd, RedMemSlotInfo *slots, int group_id,
QXLClipRects *qxl;
int error;
qxl = (QXLClipRects *)get_virt(slots, addr, sizeof(*qxl), group_id,
&error);
qxl = (QXLClipRects *)memslot_get_virt(slots, addr, sizeof(*qxl), group_id,
&error);
fprintf(fd, "num_rects %d\n", qxl->num_rects);
red_record_data_chunks_ptr(fd, "clip_rects", slots, group_id,
get_memslot_id(slots, addr),
memslot_get_id(slots, addr),
&qxl->chunk);
}
@ -223,8 +223,8 @@ static void red_record_virt_data_flat(FILE *fd, const char *prefix,
int error;
write_binary(fd, prefix,
size, (uint8_t*)get_virt(slots, addr, size, group_id,
&error));
size, (uint8_t*)memslot_get_virt(slots, addr, size, group_id,
&error));
}
static void red_record_image_data_flat(FILE *fd, RedMemSlotInfo *slots, int group_id,
@ -253,8 +253,8 @@ static void red_record_image(FILE *fd, RedMemSlotInfo *slots, int group_id,
return;
}
qxl = (QXLImage *)get_virt(slots, addr, sizeof(*qxl), group_id,
&error);
qxl = (QXLImage *)memslot_get_virt(slots, addr, sizeof(*qxl), group_id,
&error);
fprintf(fd, "descriptor.id %ld\n", qxl->descriptor.id);
fprintf(fd, "descriptor.type %d\n", qxl->descriptor.type);
fprintf(fd, "descriptor.flags %d\n", qxl->descriptor.flags);
@ -273,12 +273,12 @@ static void red_record_image(FILE *fd, RedMemSlotInfo *slots, int group_id,
if (qxl->bitmap.palette) {
QXLPalette *qp;
int i, num_ents;
qp = (QXLPalette *)get_virt(slots, qxl->bitmap.palette,
sizeof(*qp), group_id, &error);
qp = (QXLPalette *)memslot_get_virt(slots, qxl->bitmap.palette,
sizeof(*qp), group_id, &error);
num_ents = qp->num_ents;
fprintf(fd, "qp.num_ents %d\n", qp->num_ents);
validate_virt(slots, (intptr_t)qp->ents,
get_memslot_id(slots, qxl->bitmap.palette),
memslot_validate_virt(slots, (intptr_t)qp->ents,
memslot_get_id(slots, qxl->bitmap.palette),
num_ents * sizeof(qp->ents[0]), group_id);
fprintf(fd, "unique %ld\n", qp->unique);
for (i = 0; i < num_ents; i++) {
@ -302,7 +302,7 @@ static void red_record_image(FILE *fd, RedMemSlotInfo *slots, int group_id,
case SPICE_IMAGE_TYPE_QUIC:
fprintf(fd, "quic.data_size %d\n", qxl->quic.data_size);
size = red_record_data_chunks_ptr(fd, "quic.data", slots, group_id,
get_memslot_id(slots, addr),
memslot_get_id(slots, addr),
(QXLDataChunk *)qxl->quic.data);
spice_assert(size == qxl->quic.data_size);
break;
@ -426,9 +426,9 @@ static void red_record_stroke_ptr(FILE *fd, RedMemSlotInfo *slots, int group_id,
fprintf(fd, "attr.style_nseg %d\n", qxl->attr.style_nseg);
spice_assert(qxl->attr.style);
buf = (uint8_t *)get_virt(slots, qxl->attr.style,
style_nseg * sizeof(QXLFIXED), group_id,
&error);
buf = (uint8_t *)memslot_get_virt(slots, qxl->attr.style,
style_nseg * sizeof(QXLFIXED), group_id,
&error);
write_binary(fd, "style", style_nseg * sizeof(QXLFIXED), buf);
}
red_record_brush_ptr(fd, slots, group_id, &qxl->brush, flags);
@ -443,14 +443,14 @@ static void red_record_string(FILE *fd, RedMemSlotInfo *slots, int group_id,
size_t chunk_size;
int error;
qxl = (QXLString *)get_virt(slots, addr, sizeof(*qxl), group_id,
&error);
qxl = (QXLString *)memslot_get_virt(slots, addr, sizeof(*qxl), group_id,
&error);
fprintf(fd, "data_size %d\n", qxl->data_size);
fprintf(fd, "length %d\n", qxl->length);
fprintf(fd, "flags %d\n", qxl->flags);
chunk_size = red_record_data_chunks_ptr(fd, "string", slots, group_id,
get_memslot_id(slots, addr),
&qxl->chunk);
memslot_get_id(slots, addr),
&qxl->chunk);
spice_assert(chunk_size == qxl->data_size);
}
@ -521,8 +521,8 @@ static void red_record_native_drawable(FILE *fd, RedMemSlotInfo *slots, int grou
int i;
int error;
qxl = (QXLDrawable *)get_virt(slots, addr, sizeof(*qxl), group_id,
&error);
qxl = (QXLDrawable *)memslot_get_virt(slots, addr, sizeof(*qxl), group_id,
&error);
red_record_rect_ptr(fd, "bbox", &qxl->bbox);
red_record_clip_ptr(fd, slots, group_id, &qxl->clip);
@ -597,8 +597,8 @@ static void red_record_compat_drawable(FILE *fd, RedMemSlotInfo *slots, int grou
QXLCompatDrawable *qxl;
int error;
qxl = (QXLCompatDrawable *)get_virt(slots, addr, sizeof(*qxl), group_id,
&error);
qxl = (QXLCompatDrawable *)memslot_get_virt(slots, addr, sizeof(*qxl), group_id,
&error);
red_record_rect_ptr(fd, "bbox", &qxl->bbox);
red_record_clip_ptr(fd, slots, group_id, &qxl->clip);
@ -676,8 +676,8 @@ static void red_record_update_cmd(FILE *fd, RedMemSlotInfo *slots, int group_id,
QXLUpdateCmd *qxl;
int error;
qxl = (QXLUpdateCmd *)get_virt(slots, addr, sizeof(*qxl), group_id,
&error);
qxl = (QXLUpdateCmd *)memslot_get_virt(slots, addr, sizeof(*qxl), group_id,
&error);
fprintf(fd, "update\n");
red_record_rect_ptr(fd, "area", &qxl->area);
@ -697,8 +697,8 @@ static void red_record_message(FILE *fd, RedMemSlotInfo *slots, int group_id,
* luckily this is for debug logging only,
* so we can just ignore it by default.
*/
qxl = (QXLMessage *)get_virt(slots, addr, sizeof(*qxl), group_id,
&error);
qxl = (QXLMessage *)memslot_get_virt(slots, addr, sizeof(*qxl), group_id,
&error);
write_binary(fd, "message", strlen((char*)qxl->data), (uint8_t*)qxl->data);
}
@ -709,8 +709,8 @@ static void red_record_surface_cmd(FILE *fd, RedMemSlotInfo *slots, int group_id
size_t size;
int error;
qxl = (QXLSurfaceCmd *)get_virt(slots, addr, sizeof(*qxl), group_id,
&error);
qxl = (QXLSurfaceCmd *)memslot_get_virt(slots, addr, sizeof(*qxl), group_id,
&error);
fprintf(fd, "surface_cmd\n");
fprintf(fd, "surface_id %d\n", qxl->surface_id);
@ -726,8 +726,8 @@ static void red_record_surface_cmd(FILE *fd, RedMemSlotInfo *slots, int group_id
size = qxl->u.surface_create.height * abs(qxl->u.surface_create.stride);
if ((qxl->flags & QXL_SURF_FLAG_KEEP_DATA) != 0) {
write_binary(fd, "data", size,
(uint8_t*)get_virt(slots, qxl->u.surface_create.data, size, group_id,
&error));
(uint8_t*)memslot_get_virt(slots, qxl->u.surface_create.data, size, group_id,
&error));
}
break;
}
@ -739,8 +739,8 @@ static void red_record_cursor(FILE *fd, RedMemSlotInfo *slots, int group_id,
QXLCursor *qxl;
int error;
qxl = (QXLCursor *)get_virt(slots, addr, sizeof(*qxl), group_id,
&error);
qxl = (QXLCursor *)memslot_get_virt(slots, addr, sizeof(*qxl), group_id,
&error);
fprintf(fd, "header.unique %ld\n", qxl->header.unique);
fprintf(fd, "header.type %d\n", qxl->header.type);
@ -751,7 +751,7 @@ static void red_record_cursor(FILE *fd, RedMemSlotInfo *slots, int group_id,
fprintf(fd, "data_size %d\n", qxl->data_size);
red_record_data_chunks_ptr(fd, "cursor", slots, group_id,
get_memslot_id(slots, addr),
memslot_get_id(slots, addr),
&qxl->chunk);
}
@ -761,8 +761,8 @@ void red_record_cursor_cmd(FILE *fd, RedMemSlotInfo *slots, int group_id,
QXLCursorCmd *qxl;
int error;
qxl = (QXLCursorCmd *)get_virt(slots, addr, sizeof(*qxl), group_id,
&error);
qxl = (QXLCursorCmd *)memslot_get_virt(slots, addr, sizeof(*qxl), group_id,
&error);
fprintf(fd, "cursor_cmd\n");
fprintf(fd, "type %d\n", qxl->type);

46
server/red_worker.c
View File

@ -787,7 +787,7 @@ static void handle_dev_del_memslot(void *opaque, void *payload)
uint32_t slot_id = msg->slot_id;
uint32_t slot_group_id = msg->slot_group_id;
red_memslot_info_del_slot(&worker->mem_slots, slot_group_id, slot_id);
memslot_info_del_slot(&worker->mem_slots, slot_group_id, slot_id);
}
static void handle_dev_destroy_surface_wait(void *opaque, void *payload)
@ -860,9 +860,9 @@ static void dev_create_primary_surface(RedWorker *worker, uint32_t surface_id,
spice_warn_if(((uint64_t)abs(surface.stride) * (uint64_t)surface.height) !=
abs(surface.stride) * surface.height);
line_0 = (uint8_t*)get_virt(&worker->mem_slots, surface.mem,
surface.height * abs(surface.stride),
surface.group_id, &error);
line_0 = (uint8_t*)memslot_get_virt(&worker->mem_slots, surface.mem,
surface.height * abs(surface.stride),
surface.group_id, &error);
if (error) {
return;
}
@ -1139,9 +1139,9 @@ static void handle_dev_monitors_config_async(void *opaque, void *payload)
int error;
uint16_t count, max_allowed;
QXLMonitorsConfig *dev_monitors_config =
(QXLMonitorsConfig*)get_virt(&worker->mem_slots, msg->monitors_config,
qxl_monitors_config_size(1),
msg->group_id, &error);
(QXLMonitorsConfig*)memslot_get_virt(&worker->mem_slots, msg->monitors_config,
qxl_monitors_config_size(1),
msg->group_id, &error);
if (error) {
/* TODO: raise guest bug (requires added QXL interface) */
@ -1163,9 +1163,9 @@ static void handle_dev_monitors_config_async(void *opaque, void *payload)
}
/* get pointer again to check virtual size */
dev_monitors_config =
(QXLMonitorsConfig*)get_virt(&worker->mem_slots, msg->monitors_config,
qxl_monitors_config_size(count),
msg->group_id, &error);
(QXLMonitorsConfig*)memslot_get_virt(&worker->mem_slots, msg->monitors_config,
qxl_monitors_config_size(count),
msg->group_id, &error);
if (error) {
/* TODO: raise guest bug (requires added QXL interface) */
return;
@ -1267,9 +1267,9 @@ static void handle_dev_set_mouse_mode(void *opaque, void *payload)
static void dev_add_memslot(RedWorker *worker, QXLDevMemSlot mem_slot)
{
red_memslot_info_add_slot(&worker->mem_slots, mem_slot.slot_group_id, mem_slot.slot_id,
mem_slot.addr_delta, mem_slot.virt_start, mem_slot.virt_end,
mem_slot.generation);
memslot_info_add_slot(&worker->mem_slots, mem_slot.slot_group_id, mem_slot.slot_id,
mem_slot.addr_delta, mem_slot.virt_start, mem_slot.virt_end,
mem_slot.generation);
}
static void handle_dev_add_memslot(void *opaque, void *payload)
@ -1278,9 +1278,9 @@ static void handle_dev_add_memslot(void *opaque, void *payload)
RedWorkerMessageAddMemslot *msg = payload;
QXLDevMemSlot mem_slot = msg->mem_slot;
red_memslot_info_add_slot(&worker->mem_slots, mem_slot.slot_group_id, mem_slot.slot_id,
mem_slot.addr_delta, mem_slot.virt_start, mem_slot.virt_end,
mem_slot.generation);
memslot_info_add_slot(&worker->mem_slots, mem_slot.slot_group_id, mem_slot.slot_id,
mem_slot.addr_delta, mem_slot.virt_start, mem_slot.virt_end,
mem_slot.generation);
}
static void handle_dev_add_memslot_async(void *opaque, void *payload)
@ -1295,7 +1295,7 @@ static void handle_dev_reset_memslots(void *opaque, void *payload)
{
RedWorker *worker = opaque;
red_memslot_info_reset(&worker->mem_slots);
memslot_info_reset(&worker->mem_slots);
}
static void handle_dev_driver_unload(void *opaque, void *payload)
@ -1607,12 +1607,12 @@ RedWorker* red_worker_new(QXLInstance *qxl, RedDispatcher *red_dispatcher)
worker->watches[0].watch_func = handle_dev_input;
worker->watches[0].watch_func_opaque = worker;
red_memslot_info_init(&worker->mem_slots,
init_info.num_memslots_groups,
init_info.num_memslots,
init_info.memslot_gen_bits,
init_info.memslot_id_bits,
init_info.internal_groupslot_id);
memslot_info_init(&worker->mem_slots,
init_info.num_memslots_groups,
init_info.num_memslots,
init_info.memslot_gen_bits,
init_info.memslot_id_bits,
init_info.internal_groupslot_id);
spice_warn_if(init_info.n_surfaces > NUM_SURFACES);