From 3d6e7e7d0c6aed10a859034486191e0b3b69d786 Mon Sep 17 00:00:00 2001 From: Jeff Dike Date: Thu, 27 May 2010 15:22:50 -0400 Subject: qemu: Update the static recipe to 0.12.0 Signed-off-by: Jeff Dike --- meta/packages/qemu/qemu-0.12.0/fix-dirent.patch | 12 + meta/packages/qemu/qemu-0.12.0/fix-nogl.patch | 68 + meta/packages/qemu/qemu-0.12.0/no-strip.patch | 26 + .../qemu/qemu-0.12.0/qemu-git-qemugl-host.patch | 34376 +++++++++++++++++++ .../qemugl-allow-glxcontext-release.patch | 63 + .../qemu-0.12.0/workaround_bad_futex_headers.patch | 24 + .../qemu/qemu-0.9.1/02_snapshot_use_tmpdir.patch | 23 - .../04_do_not_print_rtc_freq_if_ok.patch | 26 - .../05_non-fatal_if_linux_hd_missing.patch | 17 - .../qemu/qemu-0.9.1/06_exit_segfault.patch | 45 - meta/packages/qemu/qemu-0.9.1/10_signal_jobs.patch | 26 - .../qemu/qemu-0.9.1/11_signal_sigaction.patch | 21 - .../qemu/qemu-0.9.1/22_net_tuntap_stall.patch | 18 - meta/packages/qemu/qemu-0.9.1/31_syscalls.patch | 48 - .../qemu/qemu-0.9.1/32_syscall_sysctl.patch | 55 - .../qemu/qemu-0.9.1/33_syscall_ppc_clone.patch | 22 - .../qemu/qemu-0.9.1/39_syscall_fadvise64.patch | 21 - .../qemu/qemu-0.9.1/41_arm_fpa_sigfpe.patch | 104 - .../qemu/qemu-0.9.1/52_ne2000_return.patch | 17 - .../qemu/qemu-0.9.1/61_safe_64bit_int.patch | 27 - meta/packages/qemu/qemu-0.9.1/63_sparc_build.patch | 18 - .../qemu/qemu-0.9.1/64_ppc_asm_constraints.patch | 18 - meta/packages/qemu/qemu-0.9.1/65_kfreebsd.patch | 35 - meta/packages/qemu/qemu-0.9.1/66_tls_ld.patch | 55 - .../qemu/qemu-0.9.1/91-oh-sdl-cursor.patch | 18 - .../qemu-0.9.1/configure_symlinkpath_fix.patch | 28 - meta/packages/qemu/qemu-0.9.1/fix_segfault.patch | 37 - meta/packages/qemu/qemu-0.9.1/no-strip.patch | 22 - .../qemu/qemu-0.9.1/qemu-0.9.0-nptl-update.patch | 219 - .../packages/qemu/qemu-0.9.1/qemu-0.9.0-nptl.patch | 929 - .../qemu-0.9.1/qemu-amd64-32b-mapping-0.9.0.patch | 37 - meta/packages/qemu/qemu-0.9.1/series | 27 - .../qemu-0.9.1/workaround_bad_futex_headers.patch | 25 - meta/packages/qemu/qemu-0.9.1/writev_fix.patch | 17 - meta/packages/qemu/qemu_0.12.0.bb | 51 + meta/packages/qemu/qemu_0.9.1.bb | 48 - 36 files changed, 34620 insertions(+), 2003 deletions(-) create mode 100644 meta/packages/qemu/qemu-0.12.0/fix-dirent.patch create mode 100644 meta/packages/qemu/qemu-0.12.0/fix-nogl.patch create mode 100644 meta/packages/qemu/qemu-0.12.0/no-strip.patch create mode 100644 meta/packages/qemu/qemu-0.12.0/qemu-git-qemugl-host.patch create mode 100644 meta/packages/qemu/qemu-0.12.0/qemugl-allow-glxcontext-release.patch create mode 100644 meta/packages/qemu/qemu-0.12.0/workaround_bad_futex_headers.patch delete mode 100644 meta/packages/qemu/qemu-0.9.1/02_snapshot_use_tmpdir.patch delete mode 100644 meta/packages/qemu/qemu-0.9.1/04_do_not_print_rtc_freq_if_ok.patch delete mode 100644 meta/packages/qemu/qemu-0.9.1/05_non-fatal_if_linux_hd_missing.patch delete mode 100644 meta/packages/qemu/qemu-0.9.1/06_exit_segfault.patch delete mode 100644 meta/packages/qemu/qemu-0.9.1/10_signal_jobs.patch delete mode 100644 meta/packages/qemu/qemu-0.9.1/11_signal_sigaction.patch delete mode 100644 meta/packages/qemu/qemu-0.9.1/22_net_tuntap_stall.patch delete mode 100644 meta/packages/qemu/qemu-0.9.1/31_syscalls.patch delete mode 100644 meta/packages/qemu/qemu-0.9.1/32_syscall_sysctl.patch delete mode 100644 meta/packages/qemu/qemu-0.9.1/33_syscall_ppc_clone.patch delete mode 100644 meta/packages/qemu/qemu-0.9.1/39_syscall_fadvise64.patch delete mode 100644 meta/packages/qemu/qemu-0.9.1/41_arm_fpa_sigfpe.patch delete mode 100644 meta/packages/qemu/qemu-0.9.1/52_ne2000_return.patch delete mode 100644 meta/packages/qemu/qemu-0.9.1/61_safe_64bit_int.patch delete mode 100644 meta/packages/qemu/qemu-0.9.1/63_sparc_build.patch delete mode 100644 meta/packages/qemu/qemu-0.9.1/64_ppc_asm_constraints.patch delete mode 100644 meta/packages/qemu/qemu-0.9.1/65_kfreebsd.patch delete mode 100644 meta/packages/qemu/qemu-0.9.1/66_tls_ld.patch delete mode 100644 meta/packages/qemu/qemu-0.9.1/91-oh-sdl-cursor.patch delete mode 100644 meta/packages/qemu/qemu-0.9.1/configure_symlinkpath_fix.patch delete mode 100644 meta/packages/qemu/qemu-0.9.1/fix_segfault.patch delete mode 100644 meta/packages/qemu/qemu-0.9.1/no-strip.patch delete mode 100644 meta/packages/qemu/qemu-0.9.1/qemu-0.9.0-nptl-update.patch delete mode 100644 meta/packages/qemu/qemu-0.9.1/qemu-0.9.0-nptl.patch delete mode 100644 meta/packages/qemu/qemu-0.9.1/qemu-amd64-32b-mapping-0.9.0.patch delete mode 100644 meta/packages/qemu/qemu-0.9.1/series delete mode 100644 meta/packages/qemu/qemu-0.9.1/workaround_bad_futex_headers.patch delete mode 100644 meta/packages/qemu/qemu-0.9.1/writev_fix.patch create mode 100644 meta/packages/qemu/qemu_0.12.0.bb delete mode 100644 meta/packages/qemu/qemu_0.9.1.bb diff --git a/meta/packages/qemu/qemu-0.12.0/fix-dirent.patch b/meta/packages/qemu/qemu-0.12.0/fix-dirent.patch new file mode 100644 index 0000000000..8bbfa0e88e --- /dev/null +++ b/meta/packages/qemu/qemu-0.12.0/fix-dirent.patch @@ -0,0 +1,12 @@ +Index: qemu/linux-user/syscall.c +=================================================================== +--- qemu.orig/linux-user/syscall.c 2010-05-11 13:16:22.421783949 -0400 ++++ qemu/linux-user/syscall.c 2010-05-11 13:16:31.759805849 -0400 +@@ -26,6 +26,7 @@ + #include + #include + #include ++#include + #include + #include + #include diff --git a/meta/packages/qemu/qemu-0.12.0/fix-nogl.patch b/meta/packages/qemu/qemu-0.12.0/fix-nogl.patch new file mode 100644 index 0000000000..68efab3a1f --- /dev/null +++ b/meta/packages/qemu/qemu-0.12.0/fix-nogl.patch @@ -0,0 +1,68 @@ +Index: qemu/Makefile.target +=================================================================== +--- qemu.orig/Makefile.target 2010-05-11 16:53:34.545811866 -0400 ++++ qemu/Makefile.target 2010-05-11 16:53:37.743809704 -0400 +@@ -47,6 +47,9 @@ libobj-$(CONFIG_NOSOFTFLOAT) += fpu/soft + libobj-y += op_helper.o helper.o + libobj-$(CONFIG_NEED_MMU) += mmu.o + libobj-$(TARGET_I386) += helper_opengl.o opengl_exec.o ++libobj-$(TARGET_X86_64) += helper_opengl.o opengl_exec.o ++libobj-$(TARGET_ARM) += dummygl.o ++libobj-$(TARGET_MIPS) += dummygl.o + libobj-$(TARGET_ARM) += neon_helper.o iwmmxt_helper.o + libobj-$(TARGET_ALPHA) += alpha_palcode.o + +Index: qemu/target-arm/dummygl.c +=================================================================== +--- /dev/null 1970-01-01 00:00:00.000000000 +0000 ++++ qemu/target-arm/dummygl.c 2010-05-11 16:53:37.743809704 -0400 +@@ -0,0 +1,22 @@ ++#include ++#include ++#include ++#include ++#include ++#include ++ ++void opengl_exec_set_parent_window(Display* _dpy, Window _parent_window) ++{ ++ ++} ++ ++void opengl_process_enable(void) ++{ ++ ++} ++ ++ ++void mem_opengl(uint64_t ptr) ++{ ++ ++} +Index: qemu/target-mips/dummygl.c +=================================================================== +--- /dev/null 1970-01-01 00:00:00.000000000 +0000 ++++ qemu/target-mips/dummygl.c 2010-05-11 16:53:37.744811919 -0400 +@@ -0,0 +1,22 @@ ++#include ++#include ++#include ++#include ++#include ++#include ++ ++void opengl_exec_set_parent_window(Display* _dpy, Window _parent_window) ++{ ++ ++} ++ ++void opengl_process_enable(void) ++{ ++ ++} ++ ++ ++void mem_opengl(uint64_t ptr) ++{ ++ ++} diff --git a/meta/packages/qemu/qemu-0.12.0/no-strip.patch b/meta/packages/qemu/qemu-0.12.0/no-strip.patch new file mode 100644 index 0000000000..8a95a688b3 --- /dev/null +++ b/meta/packages/qemu/qemu-0.12.0/no-strip.patch @@ -0,0 +1,26 @@ +Index: qemu/Makefile +=================================================================== +--- qemu.orig/Makefile 2010-05-11 17:17:06.416912704 -0400 ++++ qemu/Makefile 2010-05-11 17:17:17.051812402 -0400 +@@ -300,7 +300,7 @@ endif + install: all $(if $(BUILD_DOCS),install-doc) + $(INSTALL_DIR) "$(DESTDIR)$(bindir)" + ifneq ($(TOOLS),) +- $(INSTALL_PROG) $(STRIP_OPT) $(TOOLS) "$(DESTDIR)$(bindir)" ++ $(INSTALL_PROG) $(TOOLS) "$(DESTDIR)$(bindir)" + endif + ifneq ($(BLOBS),) + $(INSTALL_DIR) "$(DESTDIR)$(datadir)" +Index: qemu/Makefile.target +=================================================================== +--- qemu.orig/Makefile.target 2010-05-11 17:17:12.188784092 -0400 ++++ qemu/Makefile.target 2010-05-11 17:17:17.052808122 -0400 +@@ -351,7 +351,7 @@ clean: + + install: all + ifneq ($(PROGS),) +- $(INSTALL) -m 755 $(STRIP_OPT) $(PROGS) "$(DESTDIR)$(bindir)" ++ $(INSTALL) -m 755 $(PROGS) "$(DESTDIR)$(bindir)" + endif + + # Include automatically generated dependency files diff --git a/meta/packages/qemu/qemu-0.12.0/qemu-git-qemugl-host.patch b/meta/packages/qemu/qemu-0.12.0/qemu-git-qemugl-host.patch new file mode 100644 index 0000000000..7ec491daed --- /dev/null +++ b/meta/packages/qemu/qemu-0.12.0/qemu-git-qemugl-host.patch @@ -0,0 +1,34376 @@ +Index: qemu/Makefile.target +=================================================================== +--- qemu.orig/Makefile.target 2010-05-11 18:05:22.955784896 -0400 ++++ qemu/Makefile.target 2010-05-14 13:34:07.721301429 -0400 +@@ -46,6 +46,7 @@ libobj-$(CONFIG_SOFTFLOAT) += fpu/softfl + libobj-$(CONFIG_NOSOFTFLOAT) += fpu/softfloat-native.o + libobj-y += op_helper.o helper.o + libobj-$(CONFIG_NEED_MMU) += mmu.o ++libobj-$(TARGET_I386) += helper_opengl.o opengl_exec.o + libobj-$(TARGET_ARM) += neon_helper.o iwmmxt_helper.o + libobj-$(TARGET_ALPHA) += alpha_palcode.o + +@@ -82,6 +83,21 @@ op_helper.o cpu-exec.o: QEMU_CFLAGS += $ + # cpu_signal_handler() in cpu-exec.c. + signal.o: QEMU_CFLAGS += $(HELPER_CFLAGS) + ++parse_gl_h: parse_gl_h.c ++ $(HOST_CC) -g -o $@ $< ++server_stub.c: parse_gl_h ++ ./parse_gl_h ++gl_func.h: parse_gl_h ++ ./parse_gl_h ++GL_CFLAGS := -Wall -g -O2 -fno-strict-aliasing ++opengl_func.h: gl_func.h ++helper_opengl.o: helper_opengl.c opengl_func.h server_stub.c ++ $(CC) $(GL_CFLAGS) $(DEFINES) -c -o $@ $< -I.. -I. -I../fpu -I../target-i386 -DNEED_CPU_H ++gl_beginend.h: ../target-i386/beginend_funcs.sh ++ $< > $@ ++opengl_exec.o : opengl_exec.c server_stub.c gl_func.h opengl_func.h gl_beginend.h ++ $(CC) $(GL_CFLAGS) $(DEFINES) -c -o $@ $< -I. -I../target-i386 ++ + ######################################################### + # Linux user emulator target + +@@ -196,6 +212,10 @@ obj-i386-y += usb-uhci.o vmmouse.o vmpor + obj-i386-y += device-hotplug.o pci-hotplug.o smbios.o wdt_ib700.o + obj-i386-y += ne2000-isa.o + ++ifeq ($(TARGET_BASE_ARCH), i386) ++QEMU_CFLAGS += -DTARGET_OPENGL_OK ++endif ++ + # shared objects + obj-ppc-y = ppc.o ide/core.o ide/qdev.o ide/isa.o ide/pci.o ide/macio.o + obj-ppc-y += ide/cmd646.o +@@ -303,6 +323,8 @@ vl.o: qemu-options.h + + monitor.o: qemu-monitor.h + ++LIBS += -lGL -lGLU ++ + ARLIBS=../libqemu_common.a libqemu.a $(HWLIB) + + endif # CONFIG_SOFTMMU +Index: qemu/hw/pixel_ops.h +=================================================================== +--- qemu.orig/hw/pixel_ops.h 2010-05-11 18:05:22.959804376 -0400 ++++ qemu/hw/pixel_ops.h 2010-05-12 12:10:40.092908994 -0400 +@@ -4,6 +4,12 @@ static inline unsigned int rgb_to_pixel8 + return ((r >> 5) << 5) | ((g >> 5) << 2) | (b >> 6); + } + ++static inline unsigned int rgb_to_pixel8bgr(unsigned int r, unsigned int g, ++ unsigned int b) ++{ ++ return ((b >> 5) << 5) | ((g >> 5) << 2) | (r >> 6); ++} ++ + static inline unsigned int rgb_to_pixel15(unsigned int r, unsigned int g, + unsigned int b) + { +Index: qemu/hw/vmware_vga.c +=================================================================== +--- qemu.orig/hw/vmware_vga.c 2010-05-11 18:05:22.959804376 -0400 ++++ qemu/hw/vmware_vga.c 2010-05-12 12:10:40.124785891 -0400 +@@ -489,6 +489,8 @@ static inline void vmsvga_cursor_define( + + #define CMD(f) le32_to_cpu(s->cmd->f) + ++static uint32_t last_cmd; ++ + static inline int vmsvga_fifo_empty(struct vmsvga_state_s *s) + { + if (!s->config || !s->enable) +@@ -498,11 +500,18 @@ static inline int vmsvga_fifo_empty(stru + + static inline uint32_t vmsvga_fifo_read_raw(struct vmsvga_state_s *s) + { +- uint32_t cmd = s->fifo[CMD(stop) >> 2]; +- s->cmd->stop = cpu_to_le32(CMD(stop) + 4); +- if (CMD(stop) >= CMD(max)) ++ int offset = CMD(stop); ++ ++ if (unlikely(s->cmd->next_cmd == s->cmd->stop)) { ++ fprintf(stderr, "%s: FIFO empty during CMD %i\n", ++ __FUNCTION__, last_cmd); ++ return 0x00000000; ++ } ++ ++ s->cmd->stop = cpu_to_le32(offset + 4); ++ if (offset + 4 >= CMD(max)) + s->cmd->stop = s->cmd->min; +- return cmd; ++ return s->fifo[offset >> 2]; + } + + static inline uint32_t vmsvga_fifo_read(struct vmsvga_state_s *s) +@@ -512,12 +521,12 @@ static inline uint32_t vmsvga_fifo_read( + + static void vmsvga_fifo_run(struct vmsvga_state_s *s) + { +- uint32_t cmd, colour; ++ uint32_t colour; + int args = 0; + int x, y, dx, dy, width, height; + struct vmsvga_cursor_definition_s cursor; + while (!vmsvga_fifo_empty(s)) +- switch (cmd = vmsvga_fifo_read(s)) { ++ switch (last_cmd = vmsvga_fifo_read(s)) { + case SVGA_CMD_UPDATE: + case SVGA_CMD_UPDATE_VERBOSE: + x = vmsvga_fifo_read(s); +@@ -617,7 +626,7 @@ static void vmsvga_fifo_run(struct vmsvg + while (args --) + vmsvga_fifo_read(s); + printf("%s: Unknown command 0x%02x in SVGA command FIFO\n", +- __FUNCTION__, cmd); ++ __FUNCTION__, last_cmd); + break; + } + +@@ -1136,6 +1145,12 @@ static void vmsvga_init(struct vmsvga_st + + vga_init_vbe(&s->vga); + ++#ifdef EMBED_STDVGA ++ s->vga.map_addr = VBE_DISPI_LFB_PHYSICAL_ADDRESS; ++ s->vga.map_end = VBE_DISPI_LFB_PHYSICAL_ADDRESS + vga_ram_size; ++ vga_dirty_log_start(s); ++#endif ++ + rom_add_vga(VGABIOS_FILENAME); + + vmsvga_reset(s); +Index: qemu/qemu-char.c +=================================================================== +--- qemu.orig/qemu-char.c 2010-05-11 18:05:22.955784896 -0400 ++++ qemu/qemu-char.c 2010-05-12 17:20:54.280909040 -0400 +@@ -2232,6 +2232,69 @@ static CharDriverState *qemu_chr_open_so + return NULL; + } + ++#define TARGET_OPENGL_OK ++#if defined(TARGET_OPENGL_OK) ++static uint8_t buffer[32]; ++static int buffer_len; ++static int hexdigit[128] = { ++ ['0'] = 0x0, ++ ['1'] = 0x1, ++ ['2'] = 0x2, ++ ['3'] = 0x3, ++ ['4'] = 0x4, ++ ['5'] = 0x5, ++ ['6'] = 0x6, ++ ['7'] = 0x7, ++ ['8'] = 0x8, ++ ['9'] = 0x9, ++ ['a'] = 0xa, ++ ['b'] = 0xb, ++ ['c'] = 0xc, ++ ['d'] = 0xd, ++ ['e'] = 0xe, ++ ['f'] = 0xf, ++}; ++ ++static int opengl_chr_write(CharDriverState *chr, const uint8_t *buf, int len) ++{ ++ uint64_t ptr = 0; ++ int i; ++ ++ if (memchr(buf, 'x', len)) ++ opengl_process_enable(); ++ return len; ++ memcpy(buffer + buffer_len, buf, len); ++ buffer_len += len; ++ ++ if (buffer_len >= 16) { ++ for (i = 0; i < 16; i ++) ++ ptr = (ptr << 4) + hexdigit[buffer[i]]; ++ ++ buffer_len -= 16; ++ if (buffer_len) ++ memcpy(buffer, buffer + 16, buffer_len); ++ ++ mem_opengl(ptr); ++ } ++ ++ return len; ++} ++ ++CharDriverState *qemu_chr_open_opengl(void) ++{ ++ CharDriverState *chr = qemu_mallocz(sizeof(CharDriverState)); ++ ++ chr->opaque = chr; ++ chr->chr_write = opengl_chr_write; ++ ++ qemu_chr_generic_open(chr); ++ ++ return chr; ++} ++#else ++#define qemu_chr_open_opengl() 0 ++#endif ++ + QemuOpts *qemu_chr_parse_compat(const char *label, const char *filename) + { + char host[65], port[33], width[8], height[8]; +@@ -2352,6 +2415,10 @@ QemuOpts *qemu_chr_parse_compat(const ch + qemu_opt_set(opts, "path", filename); + return opts; + } ++ if (!strcmp(filename, "opengl")){ ++ qemu_opt_set(opts, "backend", "opengl"); ++ return opts; ++ } + + fail: + fprintf(stderr, "%s: fail on \"%s\"\n", __FUNCTION__, filename); +@@ -2368,6 +2435,7 @@ static const struct { + { .name = "udp", .open = qemu_chr_open_udp }, + { .name = "msmouse", .open = qemu_chr_open_msmouse }, + { .name = "vc", .open = text_console_init }, ++ { .name = "opengl", .open = qemu_chr_open_opengl }, + #ifdef _WIN32 + { .name = "file", .open = qemu_chr_open_win_file_out }, + { .name = "pipe", .open = qemu_chr_open_win_pipe }, +Index: qemu/sdl.c +=================================================================== +--- qemu.orig/sdl.c 2010-05-11 18:05:22.959804376 -0400 ++++ qemu/sdl.c 2010-05-12 12:10:40.128783931 -0400 +@@ -58,6 +58,8 @@ static uint8_t allocator; + static SDL_PixelFormat host_format; + static int scaling_active = 0; + ++extern void opengl_exec_set_parent_window(Display* _dpy, Window _parent_window); ++ + static void sdl_update(DisplayState *ds, int x, int y, int w, int h) + { + // printf("updating x=%d y=%d w=%d h=%d\n", x, y, w, h); +@@ -119,12 +121,22 @@ static void do_sdl_resize(int new_width, + + static void sdl_resize(DisplayState *ds) + { +- if (!allocator) { ++ SDL_SysWMinfo info; ++ static Display *dpy; ++ ++ if (!allocator) { + if (!scaling_active) + do_sdl_resize(ds_get_width(ds), ds_get_height(ds), 0); + else if (real_screen->format->BitsPerPixel != ds_get_bits_per_pixel(ds)) + do_sdl_resize(real_screen->w, real_screen->h, ds_get_bits_per_pixel(ds)); + sdl_setdata(ds); ++ ++ SDL_GetWMInfo(&info); ++ if (info.subsystem == SDL_SYSWM_X11 && info.info.x11.display && ++ (!dpy || dpy == info.info.x11.display)) { ++ dpy = info.info.x11.display; ++ opengl_exec_set_parent_window(dpy, info.info.x11.window); ++ } + } else { + if (guest_screen != NULL) { + SDL_FreeSurface(guest_screen); +@@ -453,7 +465,7 @@ static void sdl_show_cursor(void) + + if (!kbd_mouse_is_absolute()) { + SDL_ShowCursor(1); +- if (guest_cursor && ++ if (guest_cursor && !force_pointer && + (gui_grab || kbd_mouse_is_absolute() || absolute_enabled)) + SDL_SetCursor(guest_sprite); + else +@@ -464,7 +476,8 @@ static void sdl_show_cursor(void) + static void sdl_grab_start(void) + { + if (guest_cursor) { +- SDL_SetCursor(guest_sprite); ++ if (!force_pointer) ++ SDL_SetCursor(guest_sprite); + if (!kbd_mouse_is_absolute() && !absolute_enabled) + SDL_WarpMouse(guest_x, guest_y); + } else +@@ -505,8 +518,8 @@ static void sdl_send_mouse_event(int dx, + absolute_enabled = 1; + } + +- dx = x * 0x7FFF / (width - 1); +- dy = y * 0x7FFF / (height - 1); ++ dx = x * 0x7FFF / (width - 1); ++ dy = y * 0x7FFF / (height - 1); + } else if (absolute_enabled) { + sdl_show_cursor(); + absolute_enabled = 0; +@@ -760,7 +773,8 @@ static void sdl_mouse_warp(int x, int y, + if (!guest_cursor) + sdl_show_cursor(); + if (gui_grab || kbd_mouse_is_absolute() || absolute_enabled) { +- SDL_SetCursor(guest_sprite); ++ if (!force_pointer) ++ SDL_SetCursor(guest_sprite); + if (!kbd_mouse_is_absolute() && !absolute_enabled) + SDL_WarpMouse(x, y); + } +@@ -814,7 +828,7 @@ static void sdl_mouse_define(int width, + } + guest_sprite = SDL_CreateCursor(sprite, mask, width, height, hot_x, hot_y); + +- if (guest_cursor && ++ if (guest_cursor && !force_pointer && + (gui_grab || kbd_mouse_is_absolute() || absolute_enabled)) + SDL_SetCursor(guest_sprite); + } +@@ -831,6 +845,7 @@ void sdl_display_init(DisplayState *ds, + int flags; + uint8_t data = 0; + DisplayAllocator *da; ++ SDL_SysWMinfo info; + const SDL_VideoInfo *vi; + + #if defined(__APPLE__) +@@ -855,6 +870,12 @@ void sdl_display_init(DisplayState *ds, + vi = SDL_GetVideoInfo(); + host_format = *(vi->vfmt); + ++ SDL_GetWMInfo(&info); ++ if (info.subsystem == SDL_SYSWM_X11 && info.info.x11.display) ++ opengl_exec_set_parent_window(info.info.x11.display, ++ RootWindow(info.info.x11.display, ++ DefaultScreen(info.info.x11.display))); ++ + dcl = qemu_mallocz(sizeof(DisplayChangeListener)); + dcl->dpy_update = sdl_update; + dcl->dpy_resize = sdl_resize; +@@ -890,4 +911,9 @@ void sdl_display_init(DisplayState *ds, + gui_fullscreen_initial_grab = 1; + sdl_grab_start(); + } ++ ++ SDL_GetWMInfo(&info); ++ if (info.subsystem == SDL_SYSWM_X11 && info.info.x11.display) ++ opengl_exec_set_parent_window(info.info.x11.display, ++ info.info.x11.window); + } +Index: qemu/slirp/udp.c +=================================================================== +--- qemu.orig/slirp/udp.c 2010-05-11 18:05:22.955784896 -0400 ++++ qemu/slirp/udp.c 2010-05-12 12:10:40.129784123 -0400 +@@ -40,6 +40,7 @@ + + #include + #include "ip_icmp.h" ++#include "bswap.h" + + static u_int8_t udp_tos(struct socket *so); + +@@ -125,6 +126,11 @@ udp_input(register struct mbuf *m, int i + goto bad; + } + ++ if (ntohs(uh->uh_dport) == 9999 && m->m_len - iphlen == 16) { ++ mem_opengl(le64_to_cpup((uint64_t *) (m->m_data + iphlen + 8))); ++ goto bad; ++ } ++ + if (slirp->restricted) { + goto bad; + } +Index: qemu/sysemu.h +=================================================================== +--- qemu.orig/sysemu.h 2010-05-11 18:05:22.959804376 -0400 ++++ qemu/sysemu.h 2010-05-12 12:10:40.129784123 -0400 +@@ -141,6 +141,7 @@ extern int semihosting_enabled; + extern int old_param; + extern int boot_menu; + extern QEMUClock *rtc_clock; ++extern int force_pointer; + + #define MAX_NODES 64 + extern int nb_numa_nodes; +Index: qemu/target-i386/beginend_funcs.sh +=================================================================== +--- /dev/null 1970-01-01 00:00:00.000000000 +0000 ++++ qemu/target-i386/beginend_funcs.sh 2010-05-12 12:10:40.129784123 -0400 +@@ -0,0 +1,23 @@ ++#! /bin/sh ++# Copyright 2008 (C) Intel Corporation ++# ++# echo names of functions that are legal between a glBegin and glEnd pair. ++echo -e MAGIC_MACRO\(glVertex{2,3,4}{s,i,f,d}{,v}\)\\n ++echo -e MAGIC_MACRO\(glTexCoord{1,2,3,4}{s,i,f,d}{,v}\)\\n ++echo -e MAGIC_MACRO\(glMultiTexCoord{1,2,3,4}{s,i,f,d}{,v}\)\\n ++echo -e MAGIC_MACRO\(glNormal3{b,s,i,f,d}{,v}\)\\n ++echo -e MAGIC_MACRO\(glFogCoord{f,d}{,v}\)\\n ++echo -e MAGIC_MACRO\(glColor{3,4}{b,s,i,f,d,ub,us,ui}{,v}\)\\n ++echo -e MAGIC_MACRO\(glSecondaryColor3{b,s,i,f,d,ub,us,ui}{,v}\)\\n ++echo -e MAGIC_MACRO\(glIndex{s,i,f,d,ub}{,v}\)\\n ++echo -e MAGIC_MACRO\(glVertexAttrib{1,2,3,4}{s,f,d}{,v}\)\\n ++echo -e MAGIC_MACRO\(glVertexAttrib4{b,i,ub,us,ui}v\)\\n ++echo -e MAGIC_MACRO\(glVertexAttrib4Nub\)\\n ++echo -e MAGIC_MACRO\(glVertexAttrib4N{b,s,i,ub,us,ui}v\)\\n ++echo -e MAGIC_MACRO\(glArrayElement\)\\n ++echo -e MAGIC_MACRO\(glEvalCoord{1,2}{f,d}{,v}\)\\n ++echo -e MAGIC_MACRO\(glEvalPoint{1,2}\)\\n ++echo -e MAGIC_MACRO\(glMaterial{i,f}{,v}\)\\n ++echo -e MAGIC_MACRO\(glCallList\)\\n ++echo -e MAGIC_MACRO\(glCallLists\)\\n ++echo -e MAGIC_MACRO\(glEdgeFlag{,v}\)\\n +Index: qemu/target-i386/ghash.c +=================================================================== +--- /dev/null 1970-01-01 00:00:00.000000000 +0000 ++++ qemu/target-i386/ghash.c 2010-05-12 12:10:40.130781590 -0400 +@@ -0,0 +1,347 @@ ++/* This is a modified and simplified version of original ghash.c */ ++ ++/* GLIB - Library of useful routines for C programming ++ * Copyright (C) 1995-1997 Peter Mattis, Spencer Kimball and Josh MacDonald ++ * ++ * This library is free software; you can redistribute it and/or ++ * modify it under the terms of the GNU Lesser General Public ++ * License as published by the Free Software Foundation; either ++ * version 2 of the License, or (at your option) any later version. ++ * ++ * This library is distributed in the hope that it will be useful, ++ * but WITHOUT ANY WARRANTY; without even the implied warranty of ++ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU ++ * Lesser General Public License for more details. ++ * ++ * You should have received a copy of the GNU Lesser General Public ++ * License along with this library; if not, write to the ++ * Free Software Foundation, Inc., 59 Temple Place - Suite 330, ++ * Boston, MA 02111-1307, USA. ++ */ ++ ++/* ++ * Modified by the GLib Team and others 1997-2000. See the AUTHORS ++ * file for a list of people on the GLib Team. See the ChangeLog ++ * files for a list of changes. These files are distributed with ++ * GLib at ftp://ftp.gtk.org/pub/gtk/. ++ */ ++ ++ ++#include ++ ++#include "ghash.h" ++ ++#define HASH_TABLE_MIN_SIZE 11 ++#define HASH_TABLE_MAX_SIZE 13845163 ++ ++#define CLAMP(x, low, high) (((x) > (high)) ? (high) : (((x) < (low)) ? (low) : (x))) ++ ++ ++typedef struct _SimpleHashNode SimpleHashNode; ++ ++struct _SimpleHashNode ++{ ++ int key; ++ void* value; ++ SimpleHashNode *next; ++}; ++ ++struct _SimpleHashTable ++{ ++ int size; ++ int nnodes; ++ SimpleHashNode **nodes; ++ SimpleDestroyNotify value_destroy_func; ++}; ++ ++static const unsigned int simple_primes[] = ++{ ++ 11, ++ 19, ++ 37, ++ 73, ++ 109, ++ 163, ++ 251, ++ 367, ++ 557, ++ 823, ++ 1237, ++ 1861, ++ 2777, ++ 4177, ++ 6247, ++ 9371, ++ 14057, ++ 21089, ++ 31627, ++ 47431, ++ 71143, ++ 106721, ++ 160073, ++ 240101, ++ 360163, ++ 540217, ++ 810343, ++ 1215497, ++ 1823231, ++ 2734867, ++ 4102283, ++ 6153409, ++ 9230113, ++ 13845163, ++}; ++ ++static const unsigned int simple_nprimes = sizeof (simple_primes) / sizeof (simple_primes[0]); ++ ++unsigned int simple_spaced_primes_closest (unsigned int num) ++{ ++ int i; ++ ++ for (i = 0; i < simple_nprimes; i++) ++ if (simple_primes[i] > num) ++ return simple_primes[i]; ++ ++ return simple_primes[simple_nprimes - 1]; ++} ++ ++#define HASH_TABLE_RESIZE(hash_table) \ ++ do { \ ++ if ((hash_table->size >= 3 * hash_table->nnodes && \ ++ hash_table->size > HASH_TABLE_MIN_SIZE) || \ ++ (3 * hash_table->size <= hash_table->nnodes && \ ++ hash_table->size < HASH_TABLE_MAX_SIZE)) \ ++ simple_hash_table_resize (hash_table); \ ++ } while(0) ++ ++static void simple_hash_table_resize (SimpleHashTable *hash_table); ++static SimpleHashNode** simple_hash_table_lookup_node (SimpleHashTable *hash_table, ++ int key); ++static SimpleHashNode* simple_hash_node_new (int key, ++ void* value); ++static void simple_hash_nodes_destroy (SimpleHashNode *hash_node, ++ SimpleDestroyNotify value_destroy_func); ++ ++ ++#define alloc0(type, n) (type*)calloc(n, sizeof(type)) ++ ++SimpleHashTable* ++simple_hash_table_new (SimpleDestroyNotify value_destroy_func) ++{ ++ SimpleHashTable *hash_table; ++ ++ hash_table = alloc0(SimpleHashTable, 1); ++ hash_table->size = HASH_TABLE_MIN_SIZE; ++ hash_table->nnodes = 0; ++ hash_table->value_destroy_func = value_destroy_func; ++ hash_table->nodes = alloc0 (SimpleHashNode*, hash_table->size); ++ ++ return hash_table; ++} ++ ++SimpleHashTable* simple_hash_table_clone(SimpleHashTable *hash_table, ++ SimpleCloneValue clone_value_func) ++{ ++ SimpleHashTable *hash_table_new; ++ SimpleHashNode *new_node; ++ SimpleHashNode *node; ++ int i; ++ ++ hash_table_new = alloc0 (SimpleHashTable, 1); ++ hash_table_new->size = hash_table->size; ++ hash_table_new->nnodes = hash_table->nnodes; ++ hash_table_new->value_destroy_func = hash_table->value_destroy_func; ++ hash_table_new->nodes = alloc0 (SimpleHashNode*, hash_table_new->size); ++ for (i = 0; i < hash_table->size; i++) ++ { ++ node = hash_table->nodes[i]; ++ while(node) ++ { ++ SimpleHashNode *next = hash_table_new->nodes[i]; ++ new_node = simple_hash_node_new(node->key, ++ (clone_value_func)? clone_value_func(node->value) : node->value); ++ new_node->next = next; ++ hash_table_new->nodes[i] = new_node; ++ node = node->next; ++ } ++ } ++ return hash_table_new; ++} ++ ++void ++simple_hash_table_destroy (SimpleHashTable *hash_table) ++{ ++ int i; ++ ++ for (i = 0; i < hash_table->size; i++) ++ { ++ simple_hash_nodes_destroy (hash_table->nodes[i], ++ hash_table->value_destroy_func); ++ hash_table->nodes[i] = NULL; ++ } ++ free (hash_table->nodes); ++ free (hash_table); ++} ++ ++static inline SimpleHashNode** ++simple_hash_table_lookup_node (SimpleHashTable *hash_table, ++ int key) ++{ ++ SimpleHashNode **node; ++ ++ node = &hash_table->nodes[(unsigned int)key % hash_table->size]; ++ while (*node && (*node)->key != key) ++ node = &(*node)->next; ++ ++ return node; ++} ++ ++void* ++simple_hash_table_lookup (SimpleHashTable *hash_table, int key) ++{ ++ SimpleHashNode *node; ++ ++ node = *simple_hash_table_lookup_node (hash_table, key); ++ ++ return node ? node->value : NULL; ++} ++ ++void** ++simple_hash_table_lookup_pointer (SimpleHashTable *hash_table, int key) ++{ ++ SimpleHashNode *node; ++ ++ node = *simple_hash_table_lookup_node (hash_table, key); ++ ++ return node ? &node->value : NULL; ++} ++ ++ ++void ++simple_hash_table_insert (SimpleHashTable *hash_table, ++ int key, ++ void* value) ++{ ++ SimpleHashNode **node; ++ ++ node = simple_hash_table_lookup_node (hash_table, key); ++ ++ if (*node) ++ { ++ /* do not reset node->key in this place, keeping ++ * the old key is the intended behaviour. ++ * simple_hash_table_replace() can be used instead. ++ */ ++ if (hash_table->value_destroy_func) ++ hash_table->value_destroy_func ((*node)->value); ++ ++ (*node)->value = value; ++ } ++ else ++ { ++ *node = simple_hash_node_new (key, value); ++ hash_table->nnodes++; ++ HASH_TABLE_RESIZE (hash_table); ++ } ++} ++int ++simple_hash_table_remove (SimpleHashTable *hash_table, ++ int key) ++{ ++ SimpleHashNode **node, *dest; ++ ++ node = simple_hash_table_lookup_node (hash_table, key); ++ if (*node) ++ { ++ dest = *node; ++ (*node) = dest->next; ++ if (hash_table->value_destroy_func) ++ hash_table->value_destroy_func (dest->value); ++ free (dest); ++ hash_table->nnodes--; ++ ++ HASH_TABLE_RESIZE (hash_table); ++ ++ return 1; ++ } ++ ++ return 0; ++} ++ ++ ++void ++simple_hash_table_foreach (SimpleHashTable *hash_table, ++ SimpleHFunc func, ++ void* user_data) ++{ ++ SimpleHashNode *node; ++ int i; ++ ++ for (i = 0; i < hash_table->size; i++) ++ for (node = hash_table->nodes[i]; node; node = node->next) ++ (* func) (node->key, node->value, user_data); ++} ++ ++unsigned int ++simple_hash_table_size (SimpleHashTable *hash_table) ++{ ++ return hash_table->nnodes; ++} ++ ++static void ++simple_hash_table_resize (SimpleHashTable *hash_table) ++{ ++ SimpleHashNode **new_nodes; ++ SimpleHashNode *node; ++ SimpleHashNode *next; ++ unsigned int hash_val; ++ int new_size; ++ int i; ++ ++ new_size = simple_spaced_primes_closest (hash_table->nnodes); ++ new_size = CLAMP (new_size, HASH_TABLE_MIN_SIZE, HASH_TABLE_MAX_SIZE); ++ ++ new_nodes = alloc0 (SimpleHashNode*, new_size); ++ ++ for (i = 0; i < hash_table->size; i++) ++ for (node = hash_table->nodes[i]; node; node = next) ++ { ++ next = node->next; ++ ++ hash_val = (unsigned int)(node->key) % new_size; ++ ++ node->next = new_nodes[hash_val]; ++ new_nodes[hash_val] = node; ++ } ++ ++ free (hash_table->nodes); ++ hash_table->nodes = new_nodes; ++ hash_table->size = new_size; ++} ++ ++static SimpleHashNode* ++simple_hash_node_new (int key, ++ void* value) ++{ ++ SimpleHashNode *hash_node = alloc0 (SimpleHashNode, 1); ++ ++ hash_node->key = key; ++ hash_node->value = value; ++ hash_node->next = NULL; ++ ++ return hash_node; ++} ++ ++static void ++simple_hash_nodes_destroy (SimpleHashNode *hash_node, ++ SimpleDestroyNotify value_destroy_func) ++{ ++ while (hash_node) ++ { ++ SimpleHashNode *next = hash_node->next; ++ if (value_destroy_func) ++ value_destroy_func (hash_node->value); ++ free (hash_node); ++ hash_node = next; ++ } ++} +Index: qemu/target-i386/ghash.h +=================================================================== +--- /dev/null 1970-01-01 00:00:00.000000000 +0000 ++++ qemu/target-i386/ghash.h 2010-05-12 12:10:40.130781590 -0400 +@@ -0,0 +1,59 @@ ++/* This is a modified and simplified version of original ghash.h */ ++ ++ ++/* GLIB - Library of useful routines for C programming ++ * Copyright (C) 1995-1997 Peter Mattis, Spencer Kimball and Josh MacDonald ++ * ++ * This library is free software; you can redistribute it and/or ++ * modify it under the terms of the GNU Lesser General Public ++ * License as published by the Free Software Foundation; either ++ * version 2 of the License, or (at your option) any later version. ++ * ++ * This library is distributed in the hope that it will be useful, ++ * but WITHOUT ANY WARRANTY; without even the implied warranty of ++ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU ++ * Lesser General Public License for more details. ++ * ++ * You should have received a copy of the GNU Lesser General Public ++ * License along with this library; if not, write to the ++ * Free Software Foundation, Inc., 59 Temple Place - Suite 330, ++ * Boston, MA 02111-1307, USA. ++ */ ++ ++/* ++ * Modified by the GLib Team and others 1997-2000. See the AUTHORS ++ * file for a list of people on the GLib Team. See the ChangeLog ++ * files for a list of changes. These files are distributed with ++ * GLib at ftp://ftp.gtk.org/pub/gtk/. ++ */ ++ ++#ifndef __SIMPLE_HASH_H__ ++#define __SIMPLE_HASH_H__ ++ ++typedef struct _SimpleHashTable SimpleHashTable; ++ ++typedef void (*SimpleDestroyNotify)(void*); ++typedef void (*SimpleHFunc)(int key, void* value, void* user_data); ++typedef void* (*SimpleCloneValue)(void* value); ++ ++/* Hash tables ++ */ ++SimpleHashTable* simple_hash_table_new (SimpleDestroyNotify value_destroy_func); ++SimpleHashTable* simple_hash_table_clone(SimpleHashTable *hash_table, ++ SimpleCloneValue clone_value_func); ++void simple_hash_table_destroy (SimpleHashTable *hash_table); ++void simple_hash_table_insert (SimpleHashTable *hash_table, ++ int key, ++ void* value); ++int simple_hash_table_remove (SimpleHashTable *hash_table, ++ int key); ++void* simple_hash_table_lookup (SimpleHashTable *hash_table, ++ int key); ++void** simple_hash_table_lookup_pointer (SimpleHashTable *hash_table, int key); ++void simple_hash_table_foreach (SimpleHashTable *hash_table, ++ SimpleHFunc func, ++ void* user_data); ++unsigned int simple_hash_table_size (SimpleHashTable *hash_table); ++ ++#endif /* __SIMPLE_HASH_H__ */ ++ +Index: qemu/target-i386/gl_func_perso.h +=================================================================== +--- /dev/null 1970-01-01 00:00:00.000000000 +0000 ++++ qemu/target-i386/gl_func_perso.h 2010-05-12 12:10:40.130781590 -0400 +@@ -0,0 +1,135 @@ ++/* ++ * Hand-implemented GL/GLX API ++ * ++ * Copyright (c) 2006,2007 Even Rouault ++ * ++ * Permission is hereby granted, free of charge, to any person obtaining a copy ++ * of this software and associated documentation files (the "Software"), to deal ++ * in the Software without restriction, including without limitation the rights ++ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell ++ * copies of the Software, and to permit persons to whom the Software is ++ * furnished to do so, subject to the following conditions: ++ * ++ * The above copyright notice and this permission notice shall be included in ++ * all copies or substantial portions of the Software. ++ * ++ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR ++ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, ++ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL ++ * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER ++ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, ++ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN ++ * THE SOFTWARE. ++ */ ++ ++MAGIC_MACRO(_init32), ++MAGIC_MACRO(_init64), ++MAGIC_MACRO(_synchronize), ++MAGIC_MACRO(_serialized_calls), ++MAGIC_MACRO(_exit_process), ++MAGIC_MACRO(_moveResizeWindow), ++MAGIC_MACRO(_changeWindowState), ++MAGIC_MACRO(_send_cursor), ++ ++/* When you add a glX call here, you HAVE TO update IS_GLX_CALL */ ++MAGIC_MACRO(glXChooseVisual), ++MAGIC_MACRO(glXQueryExtensionsString), ++MAGIC_MACRO(glXQueryServerString), ++MAGIC_MACRO(glXCreateContext), ++MAGIC_MACRO(glXCopyContext), ++MAGIC_MACRO(glXDestroyContext), ++MAGIC_MACRO(glXGetClientString), ++MAGIC_MACRO(glXQueryVersion), ++MAGIC_MACRO(glXMakeCurrent), ++MAGIC_MACRO(glXGetConfig), ++MAGIC_MACRO(glXGetConfig_extended), ++MAGIC_MACRO(glXWaitGL), ++MAGIC_MACRO(glXWaitX), ++MAGIC_MACRO(glXGetFBConfigAttrib_extended), ++MAGIC_MACRO(glXChooseFBConfig), ++MAGIC_MACRO(glXChooseFBConfigSGIX), ++MAGIC_MACRO(glXGetFBConfigs), ++MAGIC_MACRO(glXCreatePbuffer), ++MAGIC_MACRO(glXCreateGLXPbufferSGIX), ++MAGIC_MACRO(glXDestroyPbuffer), ++MAGIC_MACRO(glXDestroyGLXPbufferSGIX), ++MAGIC_MACRO(glXCreateNewContext), ++MAGIC_MACRO(glXCreateContextWithConfigSGIX), ++MAGIC_MACRO(glXGetVisualFromFBConfig), ++MAGIC_MACRO(glXGetFBConfigAttrib), ++MAGIC_MACRO(glXGetFBConfigAttribSGIX), ++MAGIC_MACRO(glXQueryContext), ++MAGIC_MACRO(glXQueryDrawable), ++MAGIC_MACRO(glXQueryGLXPbufferSGIX), ++MAGIC_MACRO(glXUseXFont), ++MAGIC_MACRO(glXIsDirect), ++MAGIC_MACRO(glXGetProcAddress_fake), ++MAGIC_MACRO(glXGetProcAddress_global_fake), ++MAGIC_MACRO(glXSwapBuffers), ++MAGIC_MACRO(glXQueryExtension), ++MAGIC_MACRO(glXGetScreenDriver), ++MAGIC_MACRO(glXGetDriverConfig), ++MAGIC_MACRO(glXSwapIntervalSGI), ++MAGIC_MACRO(glXBindTexImageATI), ++MAGIC_MACRO(glXReleaseTexImageATI), ++MAGIC_MACRO(glXBindTexImageARB), ++MAGIC_MACRO(glXReleaseTexImageARB), ++ ++MAGIC_MACRO(glGetString), ++ ++MAGIC_MACRO(glShaderSourceARB_fake), ++MAGIC_MACRO(glShaderSource_fake), ++MAGIC_MACRO(glVertexPointer_fake), ++MAGIC_MACRO(glNormalPointer_fake), ++MAGIC_MACRO(glColorPointer_fake), ++MAGIC_MACRO(glSecondaryColorPointer_fake), ++MAGIC_MACRO(glIndexPointer_fake), ++MAGIC_MACRO(glTexCoordPointer_fake), ++MAGIC_MACRO(glEdgeFlagPointer_fake), ++MAGIC_MACRO(glVertexAttribPointerARB_fake), ++MAGIC_MACRO(glVertexAttribPointerNV_fake), ++MAGIC_MACRO(glWeightPointerARB_fake), ++MAGIC_MACRO(glMatrixIndexPointerARB_fake), ++MAGIC_MACRO(glFogCoordPointer_fake), ++MAGIC_MACRO(glVariantPointerEXT_fake), ++MAGIC_MACRO(glInterleavedArrays_fake), ++MAGIC_MACRO(glElementPointerATI_fake), ++MAGIC_MACRO(glTuxRacerDrawElements_fake), ++MAGIC_MACRO(glVertexAndNormalPointer_fake), ++MAGIC_MACRO(glTexCoordPointer01_fake), ++MAGIC_MACRO(glTexCoordPointer012_fake), ++MAGIC_MACRO(glVertexNormalPointerInterlaced_fake), ++MAGIC_MACRO(glVertexNormalColorPointerInterlaced_fake), ++MAGIC_MACRO(glVertexColorTexCoord0PointerInterlaced_fake), ++MAGIC_MACRO(glVertexNormalTexCoord0PointerInterlaced_fake), ++MAGIC_MACRO(glVertexNormalTexCoord01PointerInterlaced_fake), ++MAGIC_MACRO(glVertexNormalTexCoord012PointerInterlaced_fake), ++MAGIC_MACRO(glVertexNormalColorTexCoord0PointerInterlaced_fake), ++MAGIC_MACRO(glVertexNormalColorTexCoord01PointerInterlaced_fake), ++MAGIC_MACRO(glVertexNormalColorTexCoord012PointerInterlaced_fake), ++MAGIC_MACRO(glGenTextures_fake), ++MAGIC_MACRO(glGenBuffersARB_fake), ++MAGIC_MACRO(glGenLists_fake), ++MAGIC_MACRO(_glDrawElements_buffer), ++MAGIC_MACRO(_glDrawRangeElements_buffer), ++MAGIC_MACRO(_glMultiDrawElements_buffer), ++MAGIC_MACRO(_glVertexPointer_buffer), ++MAGIC_MACRO(_glNormalPointer_buffer), ++MAGIC_MACRO(_glColorPointer_buffer), ++MAGIC_MACRO(_glSecondaryColorPointer_buffer), ++MAGIC_MACRO(_glIndexPointer_buffer), ++MAGIC_MACRO(_glTexCoordPointer_buffer), ++MAGIC_MACRO(_glEdgeFlagPointer_buffer), ++MAGIC_MACRO(_glVertexAttribPointerARB_buffer), ++MAGIC_MACRO(_glWeightPointerARB_buffer), ++MAGIC_MACRO(_glMatrixIndexPointerARB_buffer), ++MAGIC_MACRO(_glFogCoordPointer_buffer), ++MAGIC_MACRO(_glVariantPointerEXT_buffer), ++MAGIC_MACRO(_glGetError_fake), ++MAGIC_MACRO(_glReadPixels_pbo), ++MAGIC_MACRO(_glDrawPixels_pbo), ++MAGIC_MACRO(_glMapBufferARB_fake), ++MAGIC_MACRO(_glSelectBuffer_fake), ++MAGIC_MACRO(_glGetSelectBuffer_fake), ++MAGIC_MACRO(_glFeedbackBuffer_fake), ++MAGIC_MACRO(_glGetFeedbackBuffer_fake), +Index: qemu/target-i386/helper.c +=================================================================== +--- qemu.orig/target-i386/helper.c 2010-05-11 18:05:22.955784896 -0400 ++++ qemu/target-i386/helper.c 2010-05-12 12:10:40.131781711 -0400 +@@ -1433,7 +1433,7 @@ target_phys_addr_t cpu_get_phys_page_deb + } + + page_offset = (addr & TARGET_PAGE_MASK) & (page_size - 1); +- paddr = (pte & TARGET_PAGE_MASK) + page_offset; ++ paddr = (pte & PHYS_ADDR_MASK) + page_offset; + return paddr; + } + +Index: qemu/target-i386/helper.h +=================================================================== +--- qemu.orig/target-i386/helper.h 2010-05-11 18:05:22.956804503 -0400 ++++ qemu/target-i386/helper.h 2010-05-12 12:10:40.131781711 -0400 +@@ -217,4 +217,6 @@ DEF_HELPER_2(rclq, tl, tl, tl) + DEF_HELPER_2(rcrq, tl, tl, tl) + #endif + ++DEF_HELPER_0(opengl, void) ++ + #include "def-helper.h" +Index: qemu/target-i386/helper_opengl.c +=================================================================== +--- /dev/null 1970-01-01 00:00:00.000000000 +0000 ++++ qemu/target-i386/helper_opengl.c 2010-05-12 12:10:40.132781622 -0400 +@@ -0,0 +1,1207 @@ ++/* ++ * Host-side implementation of GL/GLX API ++ * ++ * Copyright (c) 2006,2007 Even Rouault ++ * ++ * Permission is hereby granted, free of charge, to any person obtaining a copy ++ * of this software and associated documentation files (the "Software"), to deal ++ * in the Software without restriction, including without limitation the rights ++ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell ++ * copies of the Software, and to permit persons to whom the Software is ++ * furnished to do so, subject to the following conditions: ++ * ++ * The above copyright notice and this permission notice shall be included in ++ * all copies or substantial portions of the Software. ++ * ++ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR ++ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, ++ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL ++ * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER ++ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, ++ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN ++ * THE SOFTWARE. ++ */ ++#define _XOPEN_SOURCE 600 ++#include ++#include ++#include ++ ++#include ++#include ++ ++#include "exec.h" ++ ++#if defined(CONFIG_USER_ONLY) ++void helper_opengl(void) ++{ ++ /* TODO */ ++} ++#else ++ ++#include "opengl_func.h" ++ ++#define ENABLE_GL_LOG ++ ++extern FILE *stderr; ++ ++extern void init_process_tab(void); ++extern int do_function_call(int func_number, arg_t *args, char *ret_string); ++ ++extern void sdl_set_opengl_window(int x, int y, int width, int height); ++ ++static int last_process_id = 0; ++static int must_save = 0; ++ ++static int allow_kernel = 0; ++ ++static inline void *get_phys_mem_addr(const CPUState *env, target_ulong addr) ++{ ++ int is_user, index; ++ ++ index = (addr >> TARGET_PAGE_BITS) & (CPU_TLB_SIZE - 1); ++ is_user = ((env->hflags & HF_CPL_MASK) == 3); ++ /* A sanity check for the int0x99 case */ ++ if (unlikely(is_user == 0 && !allow_kernel)) { ++ fprintf(stderr, "not in userland !!!\n"); ++ return NULL; ++ } ++ if (__builtin_expect ++ (env->tlb_table[is_user][index].addr_code != ++ (addr & TARGET_PAGE_MASK), 0)) { ++ target_ulong ret = cpu_get_phys_page_debug((CPUState *) env, addr); ++ ++ if (ret == -1) { ++ fprintf(stderr, ++ "cpu_get_phys_page_debug(env, " TARGET_FMT_lx ") == " ++ TARGET_FMT_lx "\n", addr, ret); ++ fprintf(stderr, ++ "not in phys mem " TARGET_FMT_lx "(" TARGET_FMT_lx " " ++ TARGET_FMT_lx ")\n", addr, ++ env->tlb_table[is_user][index].addr_code, ++ addr & TARGET_PAGE_MASK); ++ fprintf(stderr, "cpu_x86_handle_mmu_fault = %d\n", ++ cpu_x86_handle_mmu_fault((CPUState *) env, addr, 0, 1, 1)); ++ return NULL; ++ } else { ++ if (ret + TARGET_PAGE_SIZE <= last_ram_offset) { ++ return qemu_get_ram_ptr(ret + ++ (((target_ulong) addr) & (TARGET_PAGE_SIZE - 1))); ++ } else { ++ fprintf(stderr, ++ "cpu_get_phys_page_debug(env, " TARGET_FMT_lx ") == " ++ TARGET_FMT_lx "\n", addr, ret); ++ fprintf(stderr, ++ "ret=" TARGET_FMT_lx " last_ram_offset= " TARGET_FMT_lx ++ "\n", ret, (target_ulong) last_ram_offset); ++ return NULL; ++ } ++ } ++ } else ++ return (void *) (addr + env->tlb_table[is_user][index].addend); ++} ++ ++#ifndef MIN ++#define MIN(a, b) (((a) < (b)) ? (a) : (b)) ++#endif ++ ++enum { ++ NOT_MAPPED, ++ MAPPED_CONTIGUOUS, ++ MAPPED_NOT_CONTIGUOUS ++}; ++ ++#define TARGET_ADDR_LOW_ALIGN(x) ((target_ulong)(x) & ~(TARGET_PAGE_SIZE - 1)) ++ ++/* Return NOT_MAPPED if a page is not mapped into target physical memory */ ++/* MAPPED_CONTIGUOUS if all pages are mapped into target physical memory and contiguous */ ++/* MAPPED_NOT_CONTIGUOUS if all pages are mapped into target physical memory but not contiguous */ ++static int get_target_mem_state(const CPUState *env, ++ target_ulong target_addr, int len) ++{ ++ target_ulong aligned_target_addr = TARGET_ADDR_LOW_ALIGN(target_addr); ++ int to_end_page = ++ (long) aligned_target_addr + TARGET_PAGE_SIZE - (long) target_addr; ++ int ret = MAPPED_CONTIGUOUS; ++ ++ if (aligned_target_addr != target_addr) { ++ void *phys_addr = get_phys_mem_addr(env, aligned_target_addr); ++ void *last_phys_addr = phys_addr; ++ ++ if (phys_addr == 0) { ++ return NOT_MAPPED; ++ } ++ if (len > to_end_page) { ++ len -= to_end_page; ++ aligned_target_addr += TARGET_PAGE_SIZE; ++ int i; ++ ++ for (i = 0; i < len; i += TARGET_PAGE_SIZE) { ++ void *phys_addr = ++ get_phys_mem_addr(env, aligned_target_addr + i); ++ if (phys_addr == 0) { ++ return NOT_MAPPED; ++ } ++ if (phys_addr != last_phys_addr + TARGET_PAGE_SIZE) ++ ret = MAPPED_NOT_CONTIGUOUS; ++ last_phys_addr = phys_addr; ++ } ++ } ++ } else { ++ void *last_phys_addr = NULL; ++ int i; ++ ++ for (i = 0; i < len; i += TARGET_PAGE_SIZE) { ++ void *phys_addr = get_phys_mem_addr(env, target_addr + i); ++ ++ if (phys_addr == 0) { ++ return NOT_MAPPED; ++ } ++ if (i != 0 && phys_addr != last_phys_addr + TARGET_PAGE_SIZE) ++ ret = MAPPED_NOT_CONTIGUOUS; ++ last_phys_addr = phys_addr; ++ } ++ } ++ return ret; ++} ++ ++/* copy len bytes from host memory at addr host_addr to target memory at logical addr target_addr */ ++/* Returns 1 if successfull, 0 if some target pages are not mapped into target physical memory */ ++static int memcpy_host_to_target(const CPUState *env, ++ target_ulong target_addr, ++ const void *host_addr, int len) ++{ ++ int i; ++ target_ulong aligned_target_addr = TARGET_ADDR_LOW_ALIGN(target_addr); ++ int to_end_page = ++ (long) aligned_target_addr + TARGET_PAGE_SIZE - (long) target_addr; ++ int ret = get_target_mem_state(env, target_addr, len); ++ ++ if (ret == NOT_MAPPED) { ++ return 0; ++ } ++ ++ if (ret == MAPPED_CONTIGUOUS) { ++ void *phys_addr = get_phys_mem_addr(env, target_addr); ++ ++ memcpy(phys_addr, host_addr, len); ++ } else { ++ if (aligned_target_addr != target_addr) { ++ void *phys_addr = get_phys_mem_addr(env, target_addr); ++ ++ memcpy(phys_addr, host_addr, MIN(len, to_end_page)); ++ if (len <= to_end_page) { ++ return 1; ++ } ++ len -= to_end_page; ++ host_addr += to_end_page; ++ target_addr = aligned_target_addr + TARGET_PAGE_SIZE; ++ } ++ for (i = 0; i < len; i += TARGET_PAGE_SIZE) { ++ void *phys_addr = get_phys_mem_addr(env, target_addr + i); ++ ++ memcpy(phys_addr, host_addr + i, ++ (i + TARGET_PAGE_SIZE <= ++ len) ? TARGET_PAGE_SIZE : len & (TARGET_PAGE_SIZE - 1)); ++ } ++ } ++ ++ return 1; ++} ++ ++static int memcpy_target_to_host(const CPUState *env, void *host_addr, ++ target_ulong target_addr, int len) ++{ ++ int i; ++ target_ulong aligned_target_addr = TARGET_ADDR_LOW_ALIGN(target_addr); ++ int to_end_page = ++ (long) aligned_target_addr + TARGET_PAGE_SIZE - (long) target_addr; ++ int ret = get_target_mem_state(env, target_addr, len); ++ ++ if (ret == NOT_MAPPED) { ++ return 0; ++ } ++ ++ if (ret == MAPPED_CONTIGUOUS) { ++ void *phys_addr = get_phys_mem_addr(env, target_addr); ++ ++ memcpy(host_addr, phys_addr, len); ++ } else { ++ if (aligned_target_addr != target_addr) { ++ void *phys_addr = get_phys_mem_addr(env, target_addr); ++ ++ memcpy(host_addr, phys_addr, MIN(len, to_end_page)); ++ if (len <= to_end_page) ++ return 1; ++ ++ len -= to_end_page; ++ host_addr += to_end_page; ++ target_addr = aligned_target_addr + TARGET_PAGE_SIZE; ++ } ++ for (i = 0; i < len; i += TARGET_PAGE_SIZE) { ++ void *phys_addr = get_phys_mem_addr(env, target_addr + i); ++ ++ memcpy(host_addr + i, phys_addr, ++ (i + TARGET_PAGE_SIZE <= ++ len) ? TARGET_PAGE_SIZE : len & (TARGET_PAGE_SIZE - 1)); ++ } ++ } ++ ++ return 1; ++} ++ ++static int memcpy_target_to_host_1_1(const CPUState *env, void *host_addr, ++ target_ulong target_addr, int nb_args) ++{ ++ return memcpy_target_to_host(env, host_addr, target_addr, nb_args * 8); ++} ++ ++static int wordsize = 0; ++static int (*argcpy_target_to_host) (const CPUState *env, void *host_addr, ++ target_ulong target_addr, int nb_args) = ++ memcpy_target_to_host_1_1; ++ ++void do_disconnect_current(void); ++void do_context_switch(Display *dpy, pid_t pid, int call); ++ ++static void disconnect_current(void) ++{ ++ last_process_id = 0; ++ ++ return do_disconnect_current(); ++} ++ ++static int memcpy_target32_to_host(const CPUState *env, void *host_addr, ++ target_ulong target_addr, int nb_args) ++{ ++ int ret; ++ uint32_t args_temp[nb_args], *src = args_temp; ++ arg_t *dest = host_addr; ++ ++ ret = memcpy_target_to_host(env, args_temp, target_addr, nb_args * 4); ++ if (!ret) ++ return ret; ++ ++ while (nb_args) { ++ /* TODO: endianness */ ++ *dest = 0; ++ *(uint32_t *) (dest++) = *src++; ++ nb_args--; ++ } ++ ++ return ret; ++} ++ ++static int memcpy_target64_to_host(const CPUState *env, void *host_addr, ++ target_ulong target_addr, int nb_args) ++{ ++ int ret; ++ uint64_t args_temp[nb_args], *src = args_temp; ++ arg_t *dest = host_addr; ++ ++ ret = memcpy_target_to_host(env, args_temp, target_addr, nb_args * 8); ++ if (!ret) ++ return ret; ++ ++ while (nb_args) { ++ /* TODO: endianness */ ++ *dest = 0; ++ *(uint64_t *) (dest++) = *src++; ++ nb_args--; ++ } ++ ++ return ret; ++} ++ ++static int host_offset = 0; ++static void reset_host_offset() ++{ ++ host_offset = 0; ++} ++ ++/* Return a host pointer with the content of [target_addr, target_addr + len bytes[ */ ++/* Do not free or modify */ ++static const void *get_host_read_pointer(const CPUState *env, ++ const target_ulong target_addr, int len) ++{ ++ int ret = get_target_mem_state(env, target_addr, len); ++ ++ if (ret == NOT_MAPPED) { ++ return NULL; ++ } else if (ret == MAPPED_CONTIGUOUS) { ++ return get_phys_mem_addr(env, target_addr); ++ } else { ++ static int host_mem_size = 0; ++ static void *host_mem = NULL; ++ static void *ret; ++ ++ if (host_mem_size < host_offset + len) { ++ host_mem_size = 2 * host_mem_size + host_offset + len; ++ host_mem = realloc(host_mem, host_mem_size); ++ } ++ ret = host_mem + host_offset; ++ assert(memcpy_target_to_host(env, ret, target_addr, len)); ++ host_offset += len; ++ return ret; ++ } ++} ++ ++int doing_opengl = 0; ++static int last_func_number = -1; ++static size_t(*my_strlen) (const char *) = NULL; ++ ++#ifdef ENABLE_GL_LOG ++static FILE *f = NULL; ++static int logger_pid = 0; ++ ++#define write_gl_debug_init() do { if (f == NULL) f = fopen("/tmp/debug_gl.bin", "wb"); } while(0) ++ ++void write_gl_debug_cmd_int(int my_int) ++{ ++ write_gl_debug_init(); ++ fwrite(&my_int, sizeof(int), 1, f); ++ fflush(f); ++} ++ ++void write_gl_debug_cmd_short(short my_int) ++{ ++ write_gl_debug_init(); ++ fwrite(&my_int, sizeof(short), 1, f); ++ fflush(f); ++} ++ ++static void inline write_gl_debug_cmd_buffer_with_size(int size, void *buffer) ++{ ++ write_gl_debug_init(); ++ fwrite(&size, sizeof(int), 1, f); ++ if (size) ++ fwrite(buffer, size, 1, f); ++} ++ ++static void inline write_gl_debug_cmd_buffer_without_size( ++ int size, void *buffer) ++{ ++ write_gl_debug_init(); ++ if (size) ++ fwrite(buffer, size, 1, f); ++} ++ ++void write_gl_debug_end(void) ++{ ++ write_gl_debug_init(); ++ fclose(f); ++ f = NULL; ++ logger_pid = 0; ++ must_save = 0; ++} ++ ++static inline int is_logging(int pid) ++{ ++ return must_save && pid == logger_pid; ++} ++#endif ++ ++#include ++#include ++ ++static void (*anticrash_handler) (void *) = NULL; ++static void (*show_stack_from_signal_handler) (int, int, int) = NULL; ++ ++void my_anticrash_sigsegv_handler(int signum, siginfo_t *info, void *ptr) ++{ ++ static int counter = 0; ++ ++ counter++; ++ ++ printf("oops\n"); ++ ++ /* if (show_stack_from_signal_handler && counter == 1) { struct ucontext* ++ * ctxt = (struct ucontext*)ptr; show_stack_from_signal_handler(10, ++ * ctxt->uc_mcontext.gregs[REG_EBP], ctxt->uc_mcontext.gregs[REG_ESP]); } */ ++ anticrash_handler(ptr); ++ ++ counter--; ++} ++ ++static int decode_call_int(CPUState *env, int func_number, int pid, ++ target_ulong target_ret_string, ++ target_ulong in_args, target_ulong in_args_size) ++{ ++ Signature *signature = (Signature *) tab_opengl_calls[func_number]; ++ int ret_type = signature->ret_type; ++ /* int has_out_parameters = signature->has_out_parameters; */ ++ int nb_args = signature->nb_args; ++ int *args_type = signature->args_type; ++ int i; ++ int ret; ++ int *args_size = NULL; ++ target_ulong saved_out_ptr[50]; ++ static char *ret_string = NULL; ++ static arg_t args[50]; ++ static Display *dpy = NULL; ++ ++ if (dpy == NULL) { ++ void *handle = dlopen("libanticrash.so", RTLD_LAZY); ++ ++ if (handle) { ++ anticrash_handler = dlsym(handle, "anticrash_handler"); ++ if (anticrash_handler) { ++ fprintf(stderr, "anticrash handler enabled\n"); ++ struct sigaction sigsegv_action; ++ struct sigaction old_sigsegv_action; ++ ++ sigsegv_action.sa_sigaction = my_anticrash_sigsegv_handler; ++ sigemptyset(&(sigsegv_action.sa_mask)); ++ sigsegv_action.sa_flags = SA_SIGINFO | SA_NODEFER; ++ sigaction(SIGSEGV, &sigsegv_action, &old_sigsegv_action); ++ } ++ } ++ handle = dlopen("libgetstack.so", RTLD_LAZY); ++ if (handle) { ++ show_stack_from_signal_handler = ++ dlsym(handle, "show_stack_from_signal_handler"); ++ } ++ ++ dpy = XOpenDisplay(NULL); ++ init_process_tab(); ++ ret_string = malloc(32768); ++ my_strlen = strlen; ++ } ++ ++ if (unlikely(last_func_number == _exit_process_func && ++ func_number == _exit_process_func)) { ++ last_func_number = -1; ++ return 0; ++ } ++ ++ if (last_process_id != pid) { ++ do_context_switch(dpy, pid, func_number); ++ last_process_id = pid; ++ } ++ ++ if (unlikely(func_number == _exit_process_func)) ++ last_process_id = 0; ++ ++ if (!wordsize) { ++ if (func_number == _init32_func || func_number == _init64_func) { ++ if (func_number == _init32_func) { ++ wordsize = 32; ++ argcpy_target_to_host = memcpy_target32_to_host; ++ } else { ++ wordsize = 64; ++ argcpy_target_to_host = memcpy_target64_to_host; ++ } ++ } else ++ fprintf(stderr, "commands submitted before initialisation done\n"); ++ } ++ ++ reset_host_offset(); ++ ++ if (nb_args) { ++ ++ if (argcpy_target_to_host(env, args, in_args, nb_args) == 0) { ++ fprintf(stderr, "call %s pid=%d\n", ++ tab_opengl_calls_name[func_number], pid); ++ fprintf(stderr, "cannot get call parameters\n"); ++ disconnect_current(); ++ return 0; ++ } ++ ++ args_size = ++ (int *) get_host_read_pointer(env, in_args_size, ++ sizeof(int) * nb_args); ++ if (args_size == NULL) { ++ fprintf(stderr, "call %s pid=%d\n", ++ tab_opengl_calls_name[func_number], pid); ++ fprintf(stderr, "cannot get call parameters size\n"); ++ disconnect_current(); ++ return 0; ++ } ++ } ++ ++ if (func_number == _serialized_calls_func) { ++ int command_buffer_size = args_size[0]; ++ const void *command_buffer = ++ get_host_read_pointer(env, args[0], command_buffer_size); ++ int commmand_buffer_offset = 0; ++ ++ args_size = NULL; ++#ifdef ENABLE_GL_LOG ++ if (is_logging(pid)) ++ write_gl_debug_cmd_short(_serialized_calls_func); ++#endif ++ ++ while (commmand_buffer_offset < command_buffer_size) { ++ func_number = ++ *(short *) (command_buffer + commmand_buffer_offset); ++ if (!(func_number >= 0 && func_number < GL_N_CALLS)) { ++ fprintf(stderr, ++ "func_number >= 0 && func_number < GL_N_CALLS failed at " ++ "commmand_buffer_offset=%d (command_buffer_size=%d)\n", ++ commmand_buffer_offset, command_buffer_size); ++ return 0; ++ } ++ commmand_buffer_offset += sizeof(short); ++#ifdef ENABLE_GL_LOG ++ if (is_logging(pid)) ++ write_gl_debug_cmd_short(func_number); ++#endif ++ ++ signature = (Signature *) tab_opengl_calls[func_number]; ++ ret_type = signature->ret_type; ++ assert(ret_type == TYPE_NONE); ++ nb_args = signature->nb_args; ++ args_type = signature->args_type; ++ ++ for (i = 0; i < nb_args; i++) { ++ switch (args_type[i]) { ++ case TYPE_UNSIGNED_INT: ++ case TYPE_INT: ++ case TYPE_UNSIGNED_CHAR: ++ case TYPE_CHAR: ++ case TYPE_UNSIGNED_SHORT: ++ case TYPE_SHORT: ++ case TYPE_FLOAT: ++ { ++ args[i] = ++ *(int *) (command_buffer + ++ commmand_buffer_offset); ++#ifdef ENABLE_GL_LOG ++ if (is_logging(pid)) ++ write_gl_debug_cmd_int(args[i]); ++#endif ++ commmand_buffer_offset += sizeof(int); ++ break; ++ } ++ ++ case TYPE_NULL_TERMINATED_STRING: ++ CASE_IN_UNKNOWN_SIZE_POINTERS: ++ { ++ int arg_size = ++ *(int *) (command_buffer + ++ commmand_buffer_offset); ++ commmand_buffer_offset += sizeof(int); ++ ++ if (arg_size == 0) { ++ args[i] = 0; ++ } else { ++ args[i] = ++ (long) (command_buffer + ++ commmand_buffer_offset); ++ } ++ ++ if (args[i] == 0) { ++ if (!IS_NULL_POINTER_OK_FOR_FUNC(func_number)) { ++ fprintf(stderr, "call %s arg %d pid=%d\n", ++ tab_opengl_calls_name[func_number], i, ++ pid); ++ disconnect_current(); ++ return 0; ++ } ++ } else { ++ if (arg_size == 0) { ++ fprintf(stderr, "call %s arg %d pid=%d\n", ++ tab_opengl_calls_name[func_number], i, ++ pid); ++ fprintf(stderr, "args_size[i] == 0 !!\n"); ++ disconnect_current(); ++ return 0; ++ } ++ } ++#ifdef ENABLE_GL_LOG ++ if (is_logging(pid)) ++ write_gl_debug_cmd_buffer_with_size(arg_size, ++ (void *) ++ args[i]); ++#endif ++ commmand_buffer_offset += arg_size; ++ ++ break; ++ } ++ ++ CASE_IN_LENGTH_DEPENDING_ON_PREVIOUS_ARGS: ++ { ++ int arg_s