wrap: Add wrapping library

2 files changed, 1538 insertions, 0 deletions

diff --git a/src/pprint.c b/src/pprint.c
new file mode 100644
index 0000000..2424735
--- /dev/null
+++ b/src/pprint.c
@@ -0,0 +1,401 @@
+#include <assert.h>
+#include <stdbool.h>
+
+#define DPRI(value) printf("%s: 0x%x\n", #value, (unsigned int)(value))
+
+#define PPRINT(fp, data, type) pprint_##type(fp, data)
+
+#define PPRINT_CASE(name) \
+    case name: \
+        return #name
+
+#define UNUSED(x) (void)x
+
+static const char *pprint_PVRSRV_ERROR(FILE *fp, PVRSRV_ERROR data) {
+    UNUSED(fp);
+    switch(data) {
+        PPRINT_CASE(PVRSRV_OK);
+        PPRINT_CASE(PVRSRV_ERROR_OUT_OF_MEMORY);
+        PPRINT_CASE(PVRSRV_ERROR_TOO_FEW_BUFFERS);
+        PPRINT_CASE(PVRSRV_ERROR_INVALID_PARAMS);
+        PPRINT_CASE(PVRSRV_ERROR_INIT_FAILURE);
+        PPRINT_CASE(PVRSRV_ERROR_CANT_REGISTER_CALLBACK);
+        PPRINT_CASE(PVRSRV_ERROR_INVALID_DEVICE);
+
+        PPRINT_CASE(PVRSRV_ERROR_NOT_OWNER);
+        PPRINT_CASE(PVRSRV_ERROR_BAD_MAPPING);
+        PPRINT_CASE(PVRSRV_ERROR_TIMEOUT);
+        PPRINT_CASE(PVRSRV_ERROR_FLIP_CHAIN_EXISTS);
+        PPRINT_CASE(PVRSRV_ERROR_INVALID_SWAPINTERVAL);
+        PPRINT_CASE(PVRSRV_ERROR_SCENE_INVALID);
+        PPRINT_CASE(PVRSRV_ERROR_STREAM_ERROR);
+        PPRINT_CASE(PVRSRV_ERROR_FAILED_DEPENDENCIES);
+        PPRINT_CASE(PVRSRV_ERROR_CMD_NOT_PROCESSED);
+        PPRINT_CASE(PVRSRV_ERROR_CMD_TOO_BIG);
+        PPRINT_CASE(PVRSRV_ERROR_DEVICE_REGISTER_FAILED);
+        PPRINT_CASE(PVRSRV_ERROR_TOOMANYBUFFERS);
+        PPRINT_CASE(PVRSRV_ERROR_NOT_SUPPORTED);
+        PPRINT_CASE(PVRSRV_ERROR_PROCESSING_BLOCKED);
+
+        PPRINT_CASE(PVRSRV_ERROR_CANNOT_FLUSH_QUEUE);
+        PPRINT_CASE(PVRSRV_ERROR_CANNOT_GET_QUEUE_SPACE);
+        PPRINT_CASE(PVRSRV_ERROR_CANNOT_GET_RENDERDETAILS);
+        PPRINT_CASE(PVRSRV_ERROR_RETRY);
+
+        PPRINT_CASE(PVRSRV_ERROR_DDK_VERSION_MISMATCH);
+        PPRINT_CASE(PVRSRV_ERROR_BUILD_MISMATCH);
+        PPRINT_CASE(PVRSRV_ERROR_CORE_REVISION_MISMATCH);
+
+        PPRINT_CASE(PVRSRV_ERROR_UPLOAD_TOO_BIG);
+
+        PPRINT_CASE(PVRSRV_ERROR_INVALID_FLAGS);
+        PPRINT_CASE(PVRSRV_ERROR_FAILED_TO_REGISTER_PROCESS);
+
+        PPRINT_CASE(PVRSRV_ERROR_UNABLE_TO_LOAD_LIBRARY);
+        PPRINT_CASE(PVRSRV_ERROR_UNABLE_GET_FUNC_ADDR);
+        PPRINT_CASE(PVRSRV_ERROR_UNLOAD_LIBRARY_FAILED);
+
+        PPRINT_CASE(PVRSRV_ERROR_BRIDGE_CALL_FAILED);
+        PPRINT_CASE(PVRSRV_ERROR_IOCTL_CALL_FAILED);
+
+        PPRINT_CASE(PVRSRV_ERROR_MMU_CONTEXT_NOT_FOUND);
+        PPRINT_CASE(PVRSRV_ERROR_BUFFER_DEVICE_NOT_FOUND);
+        PPRINT_CASE(PVRSRV_ERROR_BUFFER_DEVICE_ALREADY_PRESENT);
+
+        PPRINT_CASE(PVRSRV_ERROR_PCI_DEVICE_NOT_FOUND);
+        PPRINT_CASE(PVRSRV_ERROR_PCI_CALL_FAILED);
+        PPRINT_CASE(PVRSRV_ERROR_PCI_REGION_TOO_SMALL);
+        PPRINT_CASE(PVRSRV_ERROR_PCI_REGION_UNAVAILABLE);
+        PPRINT_CASE(PVRSRV_ERROR_BAD_REGION_SIZE_MISMATCH);
+
+        PPRINT_CASE(PVRSRV_ERROR_REGISTER_BASE_NOT_SET);
+
+        PPRINT_CASE(PVRSRV_ERROR_BM_BAD_SHAREMEM_HANDLE);
+
+        PPRINT_CASE(PVRSRV_ERROR_FAILED_TO_ALLOC_USER_MEM);
+        PPRINT_CASE(PVRSRV_ERROR_FAILED_TO_ALLOC_VP_MEMORY);
+        PPRINT_CASE(PVRSRV_ERROR_FAILED_TO_MAP_SHARED_PBDESC);
+        PPRINT_CASE(PVRSRV_ERROR_FAILED_TO_GET_PHYS_ADDR);
+
+        PPRINT_CASE(PVRSRV_ERROR_FAILED_TO_ALLOC_VIRT_MEMORY);
+        PPRINT_CASE(PVRSRV_ERROR_FAILED_TO_COPY_VIRT_MEMORY);
+
+        PPRINT_CASE(PVRSRV_ERROR_FAILED_TO_ALLOC_PAGES);
+        PPRINT_CASE(PVRSRV_ERROR_FAILED_TO_FREE_PAGES);
+        PPRINT_CASE(PVRSRV_ERROR_FAILED_TO_COPY_PAGES);
+        PPRINT_CASE(PVRSRV_ERROR_UNABLE_TO_LOCK_PAGES);
+        PPRINT_CASE(PVRSRV_ERROR_UNABLE_TO_UNLOCK_PAGES);
+        PPRINT_CASE(PVRSRV_ERROR_STILL_MAPPED);
+        PPRINT_CASE(PVRSRV_ERROR_MAPPING_NOT_FOUND);
+        PPRINT_CASE(PVRSRV_ERROR_PHYS_ADDRESS_EXCEEDS_32BIT);
+        PPRINT_CASE(PVRSRV_ERROR_FAILED_TO_MAP_PAGE_TABLE);
+
+        PPRINT_CASE(PVRSRV_ERROR_INVALID_SEGMENT_BLOCK);
+        PPRINT_CASE(PVRSRV_ERROR_INVALID_SGXDEVDATA);
+        PPRINT_CASE(PVRSRV_ERROR_INVALID_DEVINFO);
+        PPRINT_CASE(PVRSRV_ERROR_INVALID_MEMINFO);
+        PPRINT_CASE(PVRSRV_ERROR_INVALID_MISCINFO);
+        PPRINT_CASE(PVRSRV_ERROR_UNKNOWN_IOCTL);
+        PPRINT_CASE(PVRSRV_ERROR_INVALID_CONTEXT);
+        PPRINT_CASE(PVRSRV_ERROR_UNABLE_TO_DESTROY_CONTEXT);
+        PPRINT_CASE(PVRSRV_ERROR_INVALID_HEAP);
+        PPRINT_CASE(PVRSRV_ERROR_INVALID_KERNELINFO);
+        PPRINT_CASE(PVRSRV_ERROR_UNKNOWN_POWER_STATE);
+        PPRINT_CASE(PVRSRV_ERROR_INVALID_HANDLE_TYPE);
+        PPRINT_CASE(PVRSRV_ERROR_INVALID_WRAP_TYPE);
+        PPRINT_CASE(PVRSRV_ERROR_INVALID_PHYS_ADDR);
+        PPRINT_CASE(PVRSRV_ERROR_INVALID_CPU_ADDR);
+        PPRINT_CASE(PVRSRV_ERROR_INVALID_HEAPINFO);
+        PPRINT_CASE(PVRSRV_ERROR_INVALID_PERPROC);
+        PPRINT_CASE(PVRSRV_ERROR_FAILED_TO_RETRIEVE_HEAPINFO);
+        PPRINT_CASE(PVRSRV_ERROR_INVALID_MAP_REQUEST);
+        PPRINT_CASE(PVRSRV_ERROR_INVALID_UNMAP_REQUEST);
+        PPRINT_CASE(PVRSRV_ERROR_UNABLE_TO_FIND_MAPPING_HEAP);
+        PPRINT_CASE(PVRSRV_ERROR_MAPPING_STILL_IN_USE);
+
+        PPRINT_CASE(PVRSRV_ERROR_EXCEEDED_HW_LIMITS);
+        PPRINT_CASE(PVRSRV_ERROR_NO_STAGING_BUFFER_ALLOCATED);
+
+        PPRINT_CASE(PVRSRV_ERROR_UNABLE_TO_CREATE_PERPROC_AREA);
+        PPRINT_CASE(PVRSRV_ERROR_UNABLE_TO_CREATE_EVENT);
+        PPRINT_CASE(PVRSRV_ERROR_UNABLE_TO_ENABLE_EVENT);
+        PPRINT_CASE(PVRSRV_ERROR_UNABLE_TO_REGISTER_EVENT);
+        PPRINT_CASE(PVRSRV_ERROR_UNABLE_TO_DESTROY_EVENT);
+        PPRINT_CASE(PVRSRV_ERROR_UNABLE_TO_CREATE_THREAD);
+        PPRINT_CASE(PVRSRV_ERROR_UNABLE_TO_CLOSE_THREAD);
+        PPRINT_CASE(PVRSRV_ERROR_THREAD_READ_ERROR);
+        PPRINT_CASE(PVRSRV_ERROR_UNABLE_TO_REGISTER_ISR_HANDLER);
+        PPRINT_CASE(PVRSRV_ERROR_UNABLE_TO_INSTALL_ISR);
+        PPRINT_CASE(PVRSRV_ERROR_UNABLE_TO_UNINSTALL_ISR);
+        PPRINT_CASE(PVRSRV_ERROR_ISR_ALREADY_INSTALLED);
+        PPRINT_CASE(PVRSRV_ERROR_ISR_NOT_INSTALLED);
+        PPRINT_CASE(PVRSRV_ERROR_UNABLE_TO_INITIALISE_INTERRUPT);
+        PPRINT_CASE(PVRSRV_ERROR_UNABLE_TO_RETRIEVE_INFO);
+        PPRINT_CASE(PVRSRV_ERROR_UNABLE_TO_DO_BACKWARDS_BLIT);
+        PPRINT_CASE(PVRSRV_ERROR_UNABLE_TO_CLOSE_SERVICES);
+        PPRINT_CASE(PVRSRV_ERROR_UNABLE_TO_REGISTER_CONTEXT);
+        PPRINT_CASE(PVRSRV_ERROR_UNABLE_TO_REGISTER_RESOURCE);
+        PPRINT_CASE(PVRSRV_ERROR_UNABLE_TO_CLOSE_HANDLE);
+
+        PPRINT_CASE(PVRSRV_ERROR_INVALID_CCB_COMMAND);
+
+        PPRINT_CASE(PVRSRV_ERROR_UNABLE_TO_LOCK_RESOURCE);
+        PPRINT_CASE(PVRSRV_ERROR_INVALID_LOCK_ID);
+        PPRINT_CASE(PVRSRV_ERROR_RESOURCE_NOT_LOCKED);
+
+        PPRINT_CASE(PVRSRV_ERROR_FLIP_FAILED);
+        PPRINT_CASE(PVRSRV_ERROR_UNBLANK_DISPLAY_FAILED);
+
+        PPRINT_CASE(PVRSRV_ERROR_TIMEOUT_POLLING_FOR_VALUE);
+
+        PPRINT_CASE(PVRSRV_ERROR_CREATE_RENDER_CONTEXT_FAILED);
+        PPRINT_CASE(PVRSRV_ERROR_UNKNOWN_PRIMARY_FRAG);
+        PPRINT_CASE(PVRSRV_ERROR_UNEXPECTED_SECONDARY_FRAG);
+        PPRINT_CASE(PVRSRV_ERROR_UNEXPECTED_PRIMARY_FRAG);
+
+        PPRINT_CASE(PVRSRV_ERROR_UNABLE_TO_INSERT_FENCE_ID);
+
+        PPRINT_CASE(PVRSRV_ERROR_BLIT_SETUP_FAILED);
+
+        PPRINT_CASE(PVRSRV_ERROR_PDUMP_NOT_AVAILABLE);
+        PPRINT_CASE(PVRSRV_ERROR_PDUMP_BUFFER_FULL);
+        PPRINT_CASE(PVRSRV_ERROR_PDUMP_BUF_OVERFLOW);
+        PPRINT_CASE(PVRSRV_ERROR_PDUMP_NOT_ACTIVE);
+        PPRINT_CASE(PVRSRV_ERROR_INCOMPLETE_LINE_OVERLAPS_PAGES);
+
+        PPRINT_CASE(PVRSRV_ERROR_MUTEX_DESTROY_FAILED);
+        PPRINT_CASE(PVRSRV_ERROR_MUTEX_INTERRUPTIBLE_ERROR);
+
+        PPRINT_CASE(PVRSRV_ERROR_INSUFFICIENT_SCRIPT_SPACE);
+        PPRINT_CASE(PVRSRV_ERROR_INSUFFICIENT_SPACE_FOR_COMMAND);
+
+        PPRINT_CASE(PVRSRV_ERROR_PROCESS_NOT_INITIALISED);
+        PPRINT_CASE(PVRSRV_ERROR_PROCESS_NOT_FOUND);
+        PPRINT_CASE(PVRSRV_ERROR_SRV_CONNECT_FAILED);
+        PPRINT_CASE(PVRSRV_ERROR_SRV_DISCONNECT_FAILED);
+        PPRINT_CASE(PVRSRV_ERROR_DEINT_PHASE_FAILED);
+        PPRINT_CASE(PVRSRV_ERROR_INIT2_PHASE_FAILED);
+
+        PPRINT_CASE(PVRSRV_ERROR_UNABLE_TO_FIND_RESOURCE);
+
+        PPRINT_CASE(PVRSRV_ERROR_NO_DC_DEVICES_FOUND);
+        PPRINT_CASE(PVRSRV_ERROR_UNABLE_TO_OPEN_DC_DEVICE);
+        PPRINT_CASE(PVRSRV_ERROR_UNABLE_TO_REMOVE_DEVICE);
+        PPRINT_CASE(PVRSRV_ERROR_NO_DEVICEDATA_FOUND);
+        PPRINT_CASE(PVRSRV_ERROR_NO_DEVICENODE_FOUND);
+        PPRINT_CASE(PVRSRV_ERROR_NO_CLIENTNODE_FOUND);
+        PPRINT_CASE(PVRSRV_ERROR_FAILED_TO_PROCESS_QUEUE);
+
+        PPRINT_CASE(PVRSRV_ERROR_UNABLE_TO_INIT_TASK);
+        PPRINT_CASE(PVRSRV_ERROR_UNABLE_TO_SCHEDULE_TASK);
+        PPRINT_CASE(PVRSRV_ERROR_UNABLE_TO_KILL_TASK);
+
+        PPRINT_CASE(PVRSRV_ERROR_UNABLE_TO_ENABLE_TIMER);
+        PPRINT_CASE(PVRSRV_ERROR_UNABLE_TO_DISABLE_TIMER);
+        PPRINT_CASE(PVRSRV_ERROR_UNABLE_TO_REMOVE_TIMER);
+
+        PPRINT_CASE(PVRSRV_ERROR_UNKNOWN_PIXEL_FORMAT);
+        PPRINT_CASE(PVRSRV_ERROR_UNKNOWN_SCRIPT_OPERATION);
+
+        PPRINT_CASE(PVRSRV_ERROR_HANDLE_INDEX_OUT_OF_RANGE);
+        PPRINT_CASE(PVRSRV_ERROR_HANDLE_NOT_ALLOCATED);
+        PPRINT_CASE(PVRSRV_ERROR_HANDLE_TYPE_MISMATCH);
+        PPRINT_CASE(PVRSRV_ERROR_UNABLE_TO_ADD_HANDLE);
+        PPRINT_CASE(PVRSRV_ERROR_HANDLE_NOT_SHAREABLE);
+        PPRINT_CASE(PVRSRV_ERROR_HANDLE_NOT_FOUND);
+        PPRINT_CASE(PVRSRV_ERROR_INVALID_SUBHANDLE);
+        PPRINT_CASE(PVRSRV_ERROR_HANDLE_BATCH_IN_USE);
+        PPRINT_CASE(PVRSRV_ERROR_HANDLE_BATCH_COMMIT_FAILURE);
+
+        PPRINT_CASE(PVRSRV_ERROR_UNABLE_TO_CREATE_HASH_TABLE);
+        PPRINT_CASE(PVRSRV_ERROR_INSERT_HASH_TABLE_DATA_FAILED);
+
+        PPRINT_CASE(PVRSRV_ERROR_UNSUPPORTED_BACKING_STORE);
+        PPRINT_CASE(PVRSRV_ERROR_UNABLE_TO_DESTROY_BM_HEAP);
+
+        PPRINT_CASE(PVRSRV_ERROR_UNKNOWN_INIT_SERVER_STATE);
+
+        PPRINT_CASE(PVRSRV_ERROR_NO_FREE_DEVICEIDS_AVALIABLE);
+        PPRINT_CASE(PVRSRV_ERROR_INVALID_DEVICEID);
+        PPRINT_CASE(PVRSRV_ERROR_DEVICEID_NOT_FOUND);
+
+        PPRINT_CASE(PVRSRV_ERROR_MEMORY_TEST_FAILED);
+        PPRINT_CASE(PVRSRV_ERROR_CPUPADDR_TEST_FAILED);
+        PPRINT_CASE(PVRSRV_ERROR_COPY_TEST_FAILED);
+
+        PPRINT_CASE(PVRSRV_ERROR_SEMAPHORE_NOT_INITIALISED);
+
+        PPRINT_CASE(PVRSRV_ERROR_UNABLE_TO_RELEASE_CLOCK);
+        PPRINT_CASE(PVRSRV_ERROR_CLOCK_REQUEST_FAILED);
+        PPRINT_CASE(PVRSRV_ERROR_DISABLE_CLOCK_FAILURE);
+        PPRINT_CASE(PVRSRV_ERROR_UNABLE_TO_SET_CLOCK_RATE);
+        PPRINT_CASE(PVRSRV_ERROR_UNABLE_TO_ROUND_CLOCK_RATE);
+        PPRINT_CASE(PVRSRV_ERROR_UNABLE_TO_ENABLE_CLOCK);
+        PPRINT_CASE(PVRSRV_ERROR_UNABLE_TO_GET_CLOCK);
+        PPRINT_CASE(PVRSRV_ERROR_UNABLE_TO_GET_PARENT_CLOCK);
+        PPRINT_CASE(PVRSRV_ERROR_UNABLE_TO_GET_SYSTEM_CLOCK);
+
+        PPRINT_CASE(PVRSRV_ERROR_UNKNOWN_SGL_ERROR);
+
+        PPRINT_CASE(PVRSRV_ERROR_SYSTEM_POWER_CHANGE_FAILURE);
+        PPRINT_CASE(PVRSRV_ERROR_DEVICE_POWER_CHANGE_FAILURE);
+
+        PPRINT_CASE(PVRSRV_ERROR_BAD_SYNC_STATE);
+
+        PPRINT_CASE(PVRSRV_ERROR_CACHEOP_FAILED);
+
+        PPRINT_CASE(PVRSRV_ERROR_CACHE_INVALIDATE_FAILED);
+
+        PPRINT_CASE(PVRSRV_ERROR_FORCE_I32);
+         default:
+            printf("Got value %d\n", data);
+            assert(false && "Reached end of case\n");
+            return NULL;
+    }
+}
+
+static const char *pprint_PVRSRV_DEVICE_TYPE(FILE *fp, PVRSRV_DEVICE_TYPE data) {
+    UNUSED(fp);
+    switch(data) {
+        PPRINT_CASE(PVRSRV_DEVICE_TYPE_UNKNOWN);
+        PPRINT_CASE(PVRSRV_DEVICE_TYPE_MBX1);
+        PPRINT_CASE(PVRSRV_DEVICE_TYPE_MBX1_LITE);
+        PPRINT_CASE(PVRSRV_DEVICE_TYPE_M24VA);
+        PPRINT_CASE(PVRSRV_DEVICE_TYPE_MVDA2);
+        PPRINT_CASE(PVRSRV_DEVICE_TYPE_MVED1);
+        PPRINT_CASE(PVRSRV_DEVICE_TYPE_MSVDX);
+        PPRINT_CASE(PVRSRV_DEVICE_TYPE_SGX);
+        PPRINT_CASE(PVRSRV_DEVICE_TYPE_VGX);
+        PPRINT_CASE(PVRSRV_DEVICE_TYPE_EXT);
+        PPRINT_CASE(PVRSRV_DEVICE_TYPE_FORCE_I32);
+        default:
+            assert(false && "Reached end of case\n");
+            return NULL;
+    }
+}
+
+static const char *pprint_PVRSRV_DEVICE_CLASS(FILE *fp, PVRSRV_DEVICE_CLASS data) {
+    UNUSED(fp);
+    switch(data) {
+        PPRINT_CASE(PVRSRV_DEVICE_CLASS_3D);
+        PPRINT_CASE(PVRSRV_DEVICE_CLASS_DISPLAY);
+        PPRINT_CASE(PVRSRV_DEVICE_CLASS_BUFFER);
+        PPRINT_CASE(PVRSRV_DEVICE_CLASS_VIDEO);
+        PPRINT_CASE(PVRSRV_DEVICE_CLASS_FORCE_I32);
+        default:
+            assert(false && "Reached end of case\n");
+            return NULL;
+    }
+}
+
+static const char *pprint_SGX_MISC_INFO_REQUEST(FILE *fp, SGX_MISC_INFO_REQUEST data) {
+    UNUSED(fp);
+    switch(data) {
+        PPRINT_CASE(SGX_MISC_INFO_REQUEST_CLOCKSPEED);
+        PPRINT_CASE(SGX_MISC_INFO_REQUEST_CLOCKSPEED_SLCSIZE);
+        PPRINT_CASE(SGX_MISC_INFO_REQUEST_SGXREV);
+        PPRINT_CASE(SGX_MISC_INFO_REQUEST_DRIVER_SGXREV);
+        PPRINT_CASE(SGX_MISC_INFO_REQUEST_SET_HWPERF_STATUS);
+        PPRINT_CASE(SGX_MISC_INFO_DUMP_DEBUG_INFO);
+        PPRINT_CASE(SGX_MISC_INFO_DUMP_DEBUG_INFO_FORCE_REGS);
+        PPRINT_CASE(SGX_MISC_INFO_PANIC);
+        PPRINT_CASE(SGX_MISC_INFO_REQUEST_SPM);
+        PPRINT_CASE(SGX_MISC_INFO_REQUEST_ACTIVEPOWER);
+        PPRINT_CASE(SGX_MISC_INFO_REQUEST_LOCKUPS);
+        PPRINT_CASE(SGX_MISC_INFO_REQUEST_FORCE_I16);
+        default:
+            assert(false && "Reached end of case\n");
+            return NULL;
+    }
+}
+
+#if 0
+static void pprint_PVRSRV_BRIDGE_PACKAGE(FILE *fp, PVRSRV_BRIDGE_PACKAGE *data) {
+    fprintf(fp, "{\n.ui32BridgeID = 0x%x,\n,.ui32Size = 0x%x,\n.pvParamIn = %p,\n.ui32InBufferSize = 0x%x,\n.pvParamOut = %p,\n.ui32OutBufferSize = 0x%x,\n.hKernelServices = %p,\n}",
+                data->ui32BridgeID, data->ui32Size, data->pvParamIn, data->ui32InBufferSize, data->pvParamOut, data->ui32OutBufferSize, data->hKernelServices);
+}
+#endif
+
+static void pprint_PVRSRV_BRIDGE_IN_CONNECT_SERVICES(FILE *fp, PVRSRV_BRIDGE_IN_CONNECT_SERVICES *data) {
+    fprintf(fp, "{\n.ui32BridgeFlags = 0x%x,\n.ui32Flags = 0x%x,\n}", data->ui32BridgeFlags, data->ui32Flags);
+}
+
+static void pprint_PVRSRV_BRIDGE_IN_ACQUIRE_DEVICEINFO(FILE *fp, PVRSRV_BRIDGE_IN_ACQUIRE_DEVICEINFO *data) {
+    fprintf(fp, "{\n.ui32BridgeFlags = 0x%x,\n.uiDevIndex = 0x%x,\n.eDeviceType = %s,\n}",
+                data->ui32BridgeFlags, data->uiDevIndex, PPRINT(fp, data->eDeviceType, PVRSRV_DEVICE_TYPE));
+}
+
+static void pprint_PVRSRV_BRIDGE_IN_SGXGETMISCINFO(FILE *fp, PVRSRV_BRIDGE_IN_SGXGETMISCINFO *data) {
+    fprintf(fp, "{\n.ui32BridgeFlags = 0x%x,\n.hDevCookie = %p,\n.psMiscInfo = {\n\t.eRequest = %s\n},\n}",
+                 data->ui32BridgeFlags, data->hDevCookie, PPRINT(fp, data->psMiscInfo->eRequest, SGX_MISC_INFO_REQUEST));
+}
+
+static void pprint_PVRSRV_BRIDGE_IN_CREATE_DEVMEMCONTEXT(FILE *fp, PVRSRV_BRIDGE_IN_CREATE_DEVMEMCONTEXT *data) {
+    fprintf(fp, "{\n.ui32BridgeFlags = 0x%x,\n.hDevCookie = %p,\n}\n}",
+                 data->ui32BridgeFlags, data->hDevCookie);
+}
+static void pprint_PVRSRV_BRIDGE_IN_GETCLIENTINFO(FILE *fp, PVRSRV_BRIDGE_IN_GETCLIENTINFO *data) {
+    fprintf(fp, "{\n.ui32BridgeFlags = 0x%x,\n.hDevCookie = %p,\n}",
+                 data->ui32BridgeFlags, data->hDevCookie);
+}
+
+static void pprint_PVRSRV_BRIDGE_OUT_CONNECT_SERVICES(FILE *fp, PVRSRV_BRIDGE_OUT_CONNECT_SERVICES *data) {
+    fprintf(fp, "{\n.eError = %s,\n.hKernelServices = %p,\n}",
+                PPRINT(fp, data->eError, PVRSRV_ERROR), data->hKernelServices);
+}
+
+static void pprint_PVRSRV_BRIDGE_OUT_ENUMDEVICE(FILE *fp, PVRSRV_BRIDGE_OUT_ENUMDEVICE *data) {
+    fprintf(fp, "{\n.eError = %s,\n.ui32NumDevices = %d,\n.asDeviceIdentifier = {\n",
+                PPRINT(fp, data->eError, PVRSRV_ERROR), data->ui32NumDevices);
+    for(uint32_t i = 0; i < data->ui32NumDevices; i++) {
+        PVRSRV_DEVICE_IDENTIFIER *di = &data->asDeviceIdentifier[i];
+        fprintf(fp, "{\n.eDeviceType = %s,\n.eDeviceClass = %s,\n.ui32DeviceIndex = %d,\n.pszPDumpDevName = %s,\n.pszPDumpRegName = %s\n},",
+                     PPRINT(fp, di->eDeviceType, PVRSRV_DEVICE_TYPE),
+                     PPRINT(fp, di->eDeviceClass, PVRSRV_DEVICE_CLASS),
+                     di->ui32DeviceIndex,
+                     di->pszPDumpDevName,
+                     di->pszPDumpRegName);
+    }
+    fprintf(fp,"\n}");
+}
+
+static void pprint_PVRSRV_BRIDGE_OUT_ACQUIRE_DEVICEINFO(FILE *fp, PVRSRV_BRIDGE_OUT_ACQUIRE_DEVICEINFO *data) {
+    fprintf(fp, "{\n.eError = %s,\n.hDevCookie = %p,\n}",
+                PPRINT(fp, data->eError, PVRSRV_ERROR), data->hDevCookie);
+}
+
+#if 0
+static void pprint_PVRSRV_SGX_MISCINFO_FEATURES(FILE *fp, PVRSRV_SGX_MISCINFO_FEATURES *data) {
+    fprintf(fp, "{\n.ui32CoreRev = 0x%x,\n.ui32CoreID = 0x%x,\n.ui32DDKVersion = 0%x,\n.ui32DDBBuild = 0x%x\n.ui32CoreIdSW = 0x%x,\n.uiCoreRevSW = 0x%x,\n.ui32BuildOptions = 0x%x,\n}",
+                data->ui32CoreRev, data->ui32CoreID, data->ui32DDKVersion, data->ui32DDKBuild, data->ui32CoreIdSW,
+                data->ui32CoreRevSW, data->ui32BuildOptions);
+}
+#endif
+
+#if 0
+static void pprint_PVRSRV_HEAP_INFO(FILE *fp, PVRSRV_HEAP_INFO *data) {
+    fprintf(fp, "{\n.ui32HeapID = 0x%x,\n.hDevMemHeap = %p,\n.sDevVAddrBase = 0x%x,\n.ui32HeapByteSize = 0x%x,\n.ui32Attribs = 0x%x,\n.ui32XTileStride = 0x%x\n}",
+                data->ui32HeapID, data->hDevMemHeap, data->sDevVAddrBase.uiAddr, data->ui32HeapByteSize,
+                data->ui32Attribs, data->ui32XTileStride);
+}
+#endif
+
+#if 0
+static void pprint_PVRSRV_BRIDGE_OUT_CREATE_DEVMEMCONTEXT(FILE *fp, PVRSRV_BRIDGE_OUT_CREATE_DEVMEMCONTEXT *data) {
+    fprintf(fp, "{\n.eError = %s,\n.hDevMemContext = %p,\n.ui32ClientHeapCount = %d,\n.sHeapInfo = {\n",
+                PPRINT(fp, data->eError, PVRSRV_ERROR), data->hDevMemContext, data->ui32ClientHeapCount);
+    for(uint32_t i = 0; i < data->ui32ClientHeapCount; i++) {
+        PPRINT(fp, &data->sHeapInfo[i], PVRSRV_HEAP_INFO);
+        fprintf(fp, ",\n");
+    }
+    fprintf(fp, "}");
+}
+#endif
+
+static void pprint_drmVersion(FILE *fp, drmVersion *drm) {
+    fprintf(fp, "{\n.version_major = %d,\n.version_minor = %d,\n.version_patchlevel = %d\n.name_len = %d,\n.name = \"%s\",\n.date_len = %d,\n.date = \"%s\",\n.desc_len = %d,\n.desc = \"%s\"\n}",
+                (int)drm->version_major, (int)drm->version_minor, (int)drm->version_patchlevel,
+                (int)drm->name_len, drm->name,
+                (int)drm->date_len, drm->date,
+                (int)drm->desc_len, drm->desc);
+}
diff --git a/src/wrap.c b/src/wrap.c
new file mode 100644
index 0000000..7b0263c
--- /dev/null
+++ b/src/wrap.c
@@ -0,0 +1,1137 @@
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <stdarg.h>
+#include <stdbool.h>
+#include <assert.h>
+#include <unistd.h>
+//#include <fcntl.h>
+#include <dlfcn.h>
+
+#include <sys/stat.h>
+#include <sys/mman.h>
+#include <sys/syscall.h>
+
+#include <asm-generic/ioctl.h>
+
+#include <xf86drm.h>
+
+#define DRM_PVR_RESERVED1 (DRM_COMMAND_BASE + 0)
+#define DRM_PVR_RESERVED2 (DRM_COMMAND_BASE + 1)
+#define DRM_PVR_RESERVED3 (DRM_COMMAND_BASE + 2)
+#define DRM_PVR_RESERVED4 (DRM_COMMAND_BASE + 3)
+#define DRM_PVR_RESERVED5 (DRM_COMMAND_BASE + 4)
+#define DRM_PVR_RESERVED6 (DRM_COMMAND_BASE + 5)
+
+/* PVR includes */
+#define SUPPORT_MEMINFO_IDS
+#define SUPPORT_DRI_DRM_EXT
+#include <config_kernel.h>
+#include <sgxfeaturedefs.h>
+#include <pvr_bridge.h>
+#include <sgx_bridge.h>
+#include <pvr_drm_shared.h>
+#include <sgxconfig.h>
+#include <sgx_mkif_km.h>
+#include <sgx_options.h>
+#include <sgxapi_km.h>
+
+#define DRM_IOCTL_PVR_SRVKM DRM_IOWR(PVR_DRM_SRVKM_CMD, PVRSRV_BRIDGE_PACKAGE)
+#include "pvr_ioctl.h"
+
+#include "pprint.c"
+
+#define MAX_FDS 128
+#define PROLOG(func) \
+    static typeof(func) *orig_##func = NULL; \
+    if(!orig_##func) \
+        orig_##func = dlsym(RTLD_NEXT, #func);
+
+#define DRM_COMMAND_BASE 0x40
+
+typedef struct __attribute__((__packed__)) Register {
+        unsigned int addr;
+        unsigned int val;
+} Register;
+
+//XXX: this is probably wrong
+typedef struct __attribute__((__packed__))  CCBEntry
+{
+        uint32_t length;
+        uint32_t unk0;
+        uint32_t unk1; // Indirect points to 0x67 PDSPixelCodeData with 0xdcxxxx0
+        uint32_t unk2;
+        uint32_t unk3; // Indirect points to 0x67 PDSPixelCodeData with 0xdcxxxx0 offset by 4
+        uint32_t unk4;
+        uint32_t unk5;
+        uint32_t unk6;
+        uint32_t frame_number;
+        IMG_DEV_VIRTADDR dev_addr_0;
+        uint32_t unk7;
+        uint32_t unk8;
+        uint32_t unk9;
+        uint32_t unk10;
+        uint32_t unk11;
+        uint32_t unk12;
+        uint32_t unk13;
+        IMG_DEV_VIRTADDR dev_addr_1;
+        uint32_t unk14;
+        IMG_DEV_VIRTADDR dev_addr_2;
+        IMG_DEV_VIRTADDR dev_addr_3;
+        IMG_DEV_VIRTADDR dev_addr_4;
+        IMG_DEV_VIRTADDR dev_addr_5;
+        IMG_DEV_VIRTADDR dev_addr_6;
+        uint32_t num_regs;
+        SGXMKIF_CMDTA_SHARED shared_data;
+        uint32_t unk15;
+        uint32_t unk16;
+        uint32_t unk17;
+        uint32_t unk18;
+        uint32_t unk19;
+        uint32_t unk20;
+        uint32_t vdm_command_stream;
+        uint32_t unk21;
+        IMG_DEV_VIRTADDR dev_addr_ta_0; // points to 0x95 TAData buffer, size is 0xc00 and all zeros
+        IMG_DEV_VIRTADDR dev_addr_ta_1; // points to 0x8d TAData buffer, size is 0x400 and not all zeros
+        uint32_t unk24;
+        uint32_t unk25;
+        uint32_t unk26;
+        uint32_t unk27;
+        uint32_t unk28;
+        IMG_DEV_VIRTADDR dev_addr_per3d_0; // points to 0x12 PerContext3DParameters, size is 0x3dd000 and all zeros
+        uint32_t unk30;
+        //this is probably variable length
+        Register r[1];
+} CCBEntry;
+
+#define DEBUG_SYSCALL(msg) write(-1, (msg), sizeof(msg))
+
+int ioctl(int fd, int request, ...);
+
+enum pvr_heap {
+    PVR_HEAP_VERTEX_SHADER,
+    PVR_HEAP_PIXEL_SHADER,
+    PVR_HEAP_PDS_VERTEX_CODE_DATA,
+    PVR_HEAP_PDS_PIXEL_CODE_DATA,
+    PVR_HEAP_GENERAL,
+    PVR_HEAP_SYNC_INFO,
+    PVR_HEAP_KERNEL_DATA,
+    PVR_HEAP_TA_DATA,
+    PVR_HEAP_SHARED_3DPARAMETERS,
+    PVR_HEAP_PERCONTEXT_3DPARAMETERS,
+};
+
+static const char *pvr_heap_names[] = {
+    [PVR_HEAP_VERTEX_SHADER] = "VertexShader",
+    [PVR_HEAP_PIXEL_SHADER] = "PixelShader",
+    [PVR_HEAP_PDS_VERTEX_CODE_DATA] = "PDSVertexCodeData",
+    [PVR_HEAP_PDS_PIXEL_CODE_DATA] = "PDSPixelCodeData",
+    [PVR_HEAP_GENERAL] = "General",
+    [PVR_HEAP_SYNC_INFO] = "SyncInfo",
+    [PVR_HEAP_KERNEL_DATA] = "KernelData",
+    [PVR_HEAP_TA_DATA] = "TAData",
+    [PVR_HEAP_SHARED_3DPARAMETERS] = "Shared3DParameters",
+    [PVR_HEAP_PERCONTEXT_3DPARAMETERS] = "PerContext3DParameters",
+};
+
+enum mem_type {
+    MEM_TYPE_NORMAL,
+    MEM_TYPE_DISP,
+    MEM_TYPE_MAP,
+};
+
+#define MAX_BUFFERS_TO_TRACK 256
+
+static struct mem_entry {
+    bool in_use;
+    bool has_mmap[2];
+    enum mem_type type;
+    void *data[2];
+    int prot[2];
+    PVRSRV_CLIENT_MEM_INFO mem_info;
+    PVRSRV_BRIDGE_OUT_MHANDLE_TO_MMAP_DATA mmap_data[2];
+} mem_trackings[MAX_BUFFERS_TO_TRACK], *last_mem_entry = NULL;
+
+static struct fd_info {
+    bool open;
+    bool is_pvr;
+} fds[MAX_FDS];
+
+#if 0
+static FILE *log_file;
+static void open_log_file() {
+    if(log_file == NULL) {
+        log_file = fopen("log.bin", "wb");
+        assert(log_file);
+    }
+}
+#endif
+
+#define INRANGE(val, min, len) ((val) >= (min) && (val) < ((min)+(len)))
+static enum pvr_heap get_heap(IMG_DEV_VIRTADDR vaddr) {
+    //printf("GENERAL HEAP 0x%x-0x%x", SGX_GENERAL_HEAP_BASE, SGX_GENERAL_HEAP_BASE+SGX_GENERAL_HEAP_SIZE);
+    if(INRANGE(vaddr.uiAddr, SGX_VERTEXSHADER_HEAP_BASE, SGX_VERTEXSHADER_HEAP_SIZE)) {
+        return PVR_HEAP_VERTEX_SHADER;
+    } else if(INRANGE(vaddr.uiAddr, SGX_PIXELSHADER_HEAP_BASE, SGX_PIXELSHADER_HEAP_SIZE)) {
+        return PVR_HEAP_PIXEL_SHADER;
+    } else if(INRANGE(vaddr.uiAddr, SGX_PDSVERTEX_CODEDATA_HEAP_BASE, SGX_PDSVERTEX_CODEDATA_HEAP_SIZE)) {
+        return PVR_HEAP_PDS_VERTEX_CODE_DATA;
+    } else if(INRANGE(vaddr.uiAddr, SGX_PDSPIXEL_CODEDATA_HEAP_BASE, SGX_PDSPIXEL_CODEDATA_HEAP_SIZE)) {
+        return PVR_HEAP_PDS_PIXEL_CODE_DATA;
+    } else if(INRANGE(vaddr.uiAddr, SGX_GENERAL_HEAP_BASE, SGX_GENERAL_HEAP_SIZE)) {
+        return PVR_HEAP_GENERAL;
+    } else if(INRANGE(vaddr.uiAddr, SGX_SYNCINFO_HEAP_BASE, SGX_SYNCINFO_HEAP_SIZE)) {
+        return PVR_HEAP_SYNC_INFO;
+    } else if(INRANGE(vaddr.uiAddr, SGX_KERNEL_DATA_HEAP_BASE, SGX_KERNEL_DATA_HEAP_SIZE)) {
+        return PVR_HEAP_KERNEL_DATA;
+    } else if(INRANGE(vaddr.uiAddr, SGX_TADATA_HEAP_BASE, SGX_TADATA_HEAP_SIZE)) {
+        return PVR_HEAP_TA_DATA;
+    } else if(INRANGE(vaddr.uiAddr, SGX_SHARED_3DPARAMETERS_HEAP_BASE, SGX_SHARED_3DPARAMETERS_HEAP_SIZE)) {
+        return PVR_HEAP_SHARED_3DPARAMETERS;
+    } else if(INRANGE(vaddr.uiAddr, SGX_PERCONTEXT_3DPARAMETERS_HEAP_BASE, SGX_PERCONTEXT_3DPARAMETERS_HEAP_SIZE)) {
+        return PVR_HEAP_PERCONTEXT_3DPARAMETERS;
+    }else {
+        printf("Unhandled addr 0x%X\n", vaddr.uiAddr);
+        assert(false);
+    }
+}
+
+#if 0
+static bool bincmp32(uint8_t *ptr, uint32_t value) {
+    uint8_t *bytes = (uint8_t*)&value;
+
+    return /*ptr[0] == bytes[0] &&*/ ptr[1] == bytes[1] && ptr[2] == bytes[2] && ptr[3] == bytes[3];
+}
+#endif
+
+static void clear_mem(struct mem_entry *mem) {
+    enum pvr_heap heap = get_heap(mem->mem_info.sDevVAddr);
+    bool valid_heap = heap == PVR_HEAP_VERTEX_SHADER
+                      || heap == PVR_HEAP_PIXEL_SHADER
+                      || heap == PVR_HEAP_PDS_VERTEX_CODE_DATA
+                      || heap == PVR_HEAP_PDS_PIXEL_CODE_DATA
+                      || heap == PVR_HEAP_GENERAL
+                      //|| heap == PVR_HEAP_KERNEL_DATA
+                      || heap == PVR_HEAP_PERCONTEXT_3DPARAMETERS
+                      || heap == PVR_HEAP_SYNC_INFO;
+    IMG_HANDLE handle = mem->mem_info.hKernelMemInfo;
+    bool is_special_heap = (uintptr_t)handle == 0x14;
+    if(mem->type == MEM_TYPE_NORMAL && (valid_heap || is_special_heap)) {
+        for (int i = 0; i < 2; i++)
+            if (mem->data[i])
+                memset(mem->data[i], 0x00, mem->mem_info.uAllocSize);
+    }
+
+/* TODO, it might be help to track all writes to the command buffer
+ * in order to do this we would need to handle SEGV to figure out
+ * what is being written to memory and then recover from it.
+ * One thing to note is that 0x14 (which appears to be the memory for
+ * the CCB in my test app) gets written to by memcpy. so in theory
+ * we might be able to just hook into memcpy and see if the addr
+ * is part of CCB.
+ */
+#if 0
+    if(is_special_heap) {
+        mprotect(mem->data, mem->mem_info.uAllocSize, PROT_READ);
+    }
+#endif
+}
+
+static struct mem_entry *add_mmap_pointer(void* data, int prot, size_t length, uintptr_t pgoffset) {
+    int track_arr_size = sizeof(mem_trackings)/sizeof(mem_trackings[0]);
+    for(int i = 0; i < track_arr_size; i++) {
+        struct mem_entry *mem = &mem_trackings[i];
+
+        for (int j = 0; j < 2; j++) {
+            if (mem->in_use && mem->has_mmap[j]) {
+                if (mem->mmap_data[j].uiMMapOffset == pgoffset && mem->mmap_data[j].uiRealByteSize == length) {
+                    mem->data[j] = data;
+                    mem->prot[j] = prot;
+                    return mem;
+                }
+            }
+        }
+    }
+
+    printf("Failed to find matching tracking entry\n");
+    assert(false);
+}
+
+static void track_buffer(PVRSRV_CLIENT_MEM_INFO *mem_info, enum mem_type type) {
+    int track_arr_size = sizeof(mem_trackings)/sizeof(mem_trackings[0]);
+    for(int i = 0; i < track_arr_size; i++) {
+        struct mem_entry *mem = &mem_trackings[i];
+        if(!mem->in_use) {
+            mem->mem_info = *mem_info;
+            mem->in_use = true;
+            mem->type = type;
+
+            printf("Allocated %x bytes of memory at %p : %x (%s)\n",
+                   mem_info->uAllocSize, mem_info->pvLinAddr, mem_info->sDevVAddr.uiAddr,
+                   pvr_heap_names[get_heap(mem_info->sDevVAddr)]);
+            if(type == MEM_TYPE_DISP) {
+                /* Override handle for tracking system */
+                /* TODO this might not be the best approach, modify it causes problems with
+                 * disp class memory */
+                mem->mem_info.hKernelMemInfo = mem->mem_info.hMappingInfo;
+            }
+            printf("TRACKING %p\n", mem->mem_info.hMappingInfo);
+            printf(" Next is %p\n", mem->mem_info.psNext);
+            return;
+        }
+    }
+
+    printf("Ran out of slot to track memory\n");
+    assert(false);
+}
+
+static void add_mmap_data(int fd, IMG_HANDLE handle, PVRSRV_BRIDGE_OUT_MHANDLE_TO_MMAP_DATA *mmap_data) {
+    int track_arr_size = sizeof(mem_trackings)/sizeof(mem_trackings[0]);
+    for(int i = 0; i < track_arr_size; i++) {
+        struct mem_entry *mem = &mem_trackings[i];
+        bool primary_handle_valid = mem->mem_info.hKernelMemInfo == handle;
+        /* TODO assume next handle is just incremented of out handle
+         * We do this because psNext doesn't seem to be a virt addr but we need to track the handle
+         * Because this handle will be used mmap_info iotctl
+         * this assumption may be wrong */
+        bool secondary_handle_valid = mem->mem_info.psNext && (mem->mem_info.hKernelMemInfo+1 == handle);
+        if(mem->in_use && !mem->has_mmap[0] && primary_handle_valid) {
+            mem->mmap_data[0] = *mmap_data;
+            mem->has_mmap[0] = true;
+            last_mem_entry = mem;
+            return;
+        } else if(mem->in_use && !mem->has_mmap[1] && secondary_handle_valid) {
+            mem->mmap_data[1] = *mmap_data;
+            mem->has_mmap[1] = true;
+            last_mem_entry = mem;
+            return;
+        }
+    }
+
+    printf("Could not find mem with handle %p\n", handle);
+    assert(false);
+}
+
+#if 0
+static void add_mmap_addr(IMG_HANDLE handle, void *data) {
+    int track_arr_size = sizeof(mem_trackings)/sizeof(mem_trackings[0]);
+    for(int i = 0; i < track_arr_size; i++) {
+        struct mem_entry *mem = &mem_trackings[i];
+        if(mem->in_use && mem->mem_info.hKernelMemInfo == handle) {
+            mem->data = data;
+            return;
+        }
+    }
+
+    printf("Could not find mem with handle %p\n", handle);
+    assert(false);
+}
+#endif
+
+static char str_buf[4096];
+
+static void dump_buffer(struct mem_entry *mem, int buf_index, const char *name) {
+    FILE *fp = fopen(name, "wb");
+    if(!fp) {
+        printf("Failed to open buffer file %s", name);
+        assert(false);
+    }
+    fwrite(mem->data[buf_index], 1, mem->mem_info.uAllocSize, fp);
+    fclose(fp);
+}
+
+static void dump_tracked_buffers() {
+    struct stat st = {0};
+    if(stat("buffers", &st) == -1) {
+        mkdir("buffers", 0700);
+    }
+    int track_arr_size = sizeof(mem_trackings)/sizeof(mem_trackings[0]);
+    for(int i = 0; i < track_arr_size; i++) {
+        struct mem_entry *mem = &mem_trackings[i];
+        for (int j = 0; j < 2; j++) {
+            if(mem->in_use && mem->data[j]) {
+                sprintf(str_buf, "buffers/0x%x_%s.bin", (uintptr_t)mem->mem_info.hKernelMemInfo + j,
+                        pvr_heap_names[get_heap(mem->mem_info.sDevVAddr)]);
+                dump_buffer(mem, j, str_buf);
+            }
+        }
+    }
+}
+
+static struct mem_entry *get_buffer(IMG_HANDLE mem_handle) {
+    int track_arr_size = sizeof(mem_trackings)/sizeof(mem_trackings[0]);
+    for(int i = 0; i < track_arr_size; i++) {
+        struct mem_entry *mem = &mem_trackings[i];
+        //for (int j = 0; j < 2; j++) {
+            if (mem->in_use && (mem->mem_info.hKernelMemInfo) == mem_handle) {
+                return mem;
+            }
+        //}
+    }
+    return NULL;
+}
+
+static void create_buffer(int fd, PVRSRV_BRIDGE_PACKAGE *in_bridge, IMG_HANDLE cookie, int heap, int size, int attrib, int align)
+{
+    PROLOG(ioctl);
+    PVRSRV_BRIDGE_IN_ALLOCDEVICEMEM in_alloc = {
+        //.ui32BridgeFlags = 0xffffffff,
+        .hDevCookie = cookie,
+        .hDevMemHeap = (void*)heap,
+        .ui32Attribs = attrib,
+        .uSize = size,
+        .uAlignment = align,
+    };
+
+    PVRSRV_BRIDGE_OUT_ALLOCDEVICEMEM out_alloc = {0};
+
+    PVRSRV_BRIDGE_PACKAGE alloc = {
+        .ui32BridgeID = PVRSRV_BRIDGE_ALLOC_DEVICEMEM,
+        .ui32Size = sizeof(alloc),
+        .pvParamIn = &in_alloc,
+        .ui32InBufferSize = sizeof(in_alloc),
+        .pvParamOut = &out_alloc,
+        .ui32OutBufferSize = sizeof(out_alloc),
+        .hKernelServices = in_bridge->hKernelServices
+    };
+
+    long ret = orig_ioctl(fd, DRM_IOCTL_PVR_SRVKM, &alloc);
+
+    if (ret != 0 || out_alloc.eError != PVRSRV_OK) {
+        printf("Failed to alloc patch buffer\n");
+    } else {
+        printf("Created alloc buffer\n");
+    }
+}
+
+#if 0
+static IMG_HANDLE new_magic_handle = NULL;
+static PVRSRV_CLIENT_MEM_INFO new_magic_mem;
+static IMG_HANDLE create_patchable_buffer(int fd, PVRSRV_BRIDGE_PACKAGE *in_bridge, IMG_HANDLE cookie) {
+    PROLOG(ioctl);
+    PROLOG(syscall);
+    PVRSRV_BRIDGE_IN_ALLOCDEVICEMEM in_alloc = {
+        //.ui32BridgeFlags = 0xffffffff,
+        .hDevCookie = cookie,
+        .hDevMemHeap = (void*)0x9,
+        .ui32Attribs = 0x9,
+        .uSize = 524288,
+        .uAlignment = 64,
+    };
+
+    PVRSRV_BRIDGE_OUT_ALLOCDEVICEMEM out_alloc = {0};
+
+    PVRSRV_BRIDGE_PACKAGE alloc = {
+        .ui32BridgeID = PVRSRV_BRIDGE_ALLOC_DEVICEMEM,
+        .ui32Size = sizeof(alloc),
+        .pvParamIn = &in_alloc,
+        .ui32InBufferSize = sizeof(in_alloc),
+        .pvParamOut = &out_alloc,
+        .ui32OutBufferSize = sizeof(out_alloc),
+        .hKernelServices = in_bridge->hKernelServices
+    };
+
+    long ret = orig_ioctl(fd, DRM_IOCTL_PVR_SRVKM, &alloc);
+
+    if (ret != 0 || out_alloc.eError != PVRSRV_OK) {
+        printf("Failed to alloc patch buffer\n");
+    } else {
+        printf("Created alloc buffer\n");
+    }
+
+    PVRSRV_BRIDGE_IN_MHANDLE_TO_MMAP_DATA in_to_mmap = {
+        //.ui32BridgeFlags = 0xffffffff,
+        .hMHandle = out_alloc.sClientMemInfo.hKernelMemInfo,
+    };
+
+    PVRSRV_BRIDGE_OUT_MHANDLE_TO_MMAP_DATA out_to_mmap = {0};
+
+    PVRSRV_BRIDGE_PACKAGE to_mmap = {
+        .ui32BridgeID = PVRSRV_BRIDGE_MHANDLE_TO_MMAP_DATA,
+        .ui32Size = sizeof(to_mmap),
+        .pvParamIn = &in_to_mmap,
+        .ui32InBufferSize = sizeof(in_to_mmap),
+        .pvParamOut = &out_to_mmap,
+        .ui32OutBufferSize = sizeof(out_to_mmap),
+        .hKernelServices = in_bridge->hKernelServices
+    };
+
+    ret = orig_ioctl(fd, DRM_IOCTL_PVR_SRVKM, &to_mmap);
+
+    if (ret != 0 || out_alloc.eError != PVRSRV_OK) {
+        printf("Failed to mmap data patch buffer\n");
+    } else {
+        printf("Got mmap data\n");
+    }
+
+
+    ret = orig_syscall(SYS_mmap2, 0, out_to_mmap.uiRealByteSize, 3, 1, fd, out_to_mmap.uiMMapOffset);
+
+    if (ret == (long)MAP_FAILED) {
+        printf("Failed to mmap patch buffer\n");
+    } else {
+        printf("Mapped patch buffer\n");
+    }
+    uint8_t *addr = (uint8_t*)ret;
+    new_magic_mem = out_alloc.sClientMemInfo;
+
+#if 1
+    FILE *fp = fopen("./buffers_red/0x73_PDSPixelCodeData.bin", "rb");
+    fread(addr, 1, 524288, fp);
+    fclose(fp);
+#endif
+
+#if 1
+    for (size_t i = 0; i < 524288; i += 4) {
+        uint32_t *data = (uint32_t*)(((uint8_t*)addr) + i);
+        if ((*data & 0xffffff00) == 0x0dc13000) {
+            //printf("Memory %p is patched at 0x%x\n", mem->mem_info.hKernelMemInfo, i);
+            *data = ((uint32_t)new_magic_mem.sDevVAddr.uiAddr) | (*data & 0xff);
+            //cacheflush(mem->data, mem->mem_info.uAllocSize, DCACHE);
+        }
+
+    }
+#endif
+
+    munmap(addr, out_to_mmap.uiRealByteSize);
+
+    printf("Created patchable buffer %d %d\n", out_alloc.eError, out_to_mmap.eError);
+
+
+    return out_alloc.sClientMemInfo.hKernelMemInfo;
+}
+#endif
+
+static void patch_buffers() {
+    int track_arr_size = sizeof(mem_trackings)/sizeof(mem_trackings[0]);
+    for(int i = 0; i < track_arr_size; i++) {
+        //struct mem_entry *mem = &mem_trackings[i];
+
+#if 0
+        if (mem->in_use && mem->mem_info.hKernelMemInfo == 0x6f) {
+            uint32_t *data = mem->data[0] + 0x1c;
+            *data = 0xdeadbeef;
+        }
+#endif
+#if 0
+        if (mem->in_use && mem->mem_info.hKernelMemInfo == 0x73) {
+            //memset(mem->data[0], 0x00, mem->mem_info.uAllocSize);
+            uint32_t *magic_ptr = mem->data[0] + 0xc0;
+            //*magic_ptr = 0x0;
+            //*magic_ptr = new_magic_mem.sDevVAddr.uiAddr | 0xa0;
+            *magic_ptr = 0xdeadbeef;
+        }
+#endif
+#if 0
+        if(mem->in_use && mem->mem_info.hKernelMemInfo == 0x73) {
+            float *clear_color = ((uint8_t*)mem->data) + 0xac;
+            clear_color[0] = 1.0f;
+            clear_color[1] = 0.5f;
+        }
+#endif
+#if 0
+        else if(mem->in_use && mem->mem_info.hKernelMemInfo == 0x14) {
+            uint32_t *cmds = ((uint8_t*)mem->data) + 0x00;
+            cmds[0]= 0xDEADBEEF;
+        }
+#endif
+#if 0
+        if(mem->in_use && mem->data[0] && mem->mem_info.hKernelMemInfo == 0x71) {
+            printf("Patched buffer\n");
+            uint8_t *data = ((uint8_t*)mem->data[0]) + 0x142;
+            uint32_t important_bits = (new_magic_mem.sDevVAddr.uiAddr & 0x00FFF000) >> 12;
+            uint8_t *ptr_bits = &important_bits;
+            data[2] = ptr_bits[1];
+            data[3] = ptr_bits[0];
+            uint32_t *data32 = (uint32_t*)data;
+            printf("Patched data is 0x%x real addr is 0x%x\n", *data32, new_magic_mem.sDevVAddr.uiAddr);
+        }
+#endif
+#if 0
+        int count = 0;
+        if(mem->in_use && mem->data && (mem->prot & PROT_WRITE) && !mem->disp_mem/*mem->mem_info.hKernelMemInfo == 0x25*/) {
+            //if (mem->mem_info.hKernelMemInfo == 0x73)
+            //    continue;
+            for (size_t i = 0; i < mem->mem_info.uAllocSize; i += 4) {
+                uint32_t *data = ((uint8_t*)mem->data) + i;
+                if ((*data & 0xffffff00) == 0x0dc13000) {
+                    //if (count == 0)
+                    {
+                        printf("Memory %p is patched at 0x%x\n", mem->mem_info.hKernelMemInfo, i);
+                        *data = ((uint32_t)new_magic_mem.sDevVAddr.uiAddr) | (*data & 0xff);
+                    }
+                    //count += 1;
+                }
+            }
+        }
+#endif
+
+#if 0
+        for (int j = 0; j < 2; j++) {
+            if(mem->in_use && !mem->disp_mem && mem->data[j]) {
+                for (size_t k = 0; k < mem->mem_info.uAllocSize; k += 2) {
+                    uint16_t *data = ((uint8_t*)mem->data[j]) + k;
+                    if ((*data) == 0x0130) {
+                        printf("Memory %p is patched at 0x%x\n", mem->mem_info.hKernelMemInfo+j, k);
+                        *data = (new_magic_mem.sDevVAddr.uiAddr - SGX_PDSPIXEL_CODEDATA_HEAP_BASE) >> 8;
+                    }
+
+                }
+            }
+        }
+#endif
+    }
+}
+
+static void check_fd(int fd, const char *pathname) {
+    assert(fd < MAX_FDS && "fd is larger than MAX_FDS");
+    fds[fd].open = true;
+    if(strcmp("/dev/dri/renderD128", pathname) == 0) {
+        //printf("FD %d is pvr\n", fd);
+        fds[fd].is_pvr = true;
+    }
+}
+
+static bool is_pvr(int fd) {
+    assert(fd < MAX_FDS && "fd is larger than MAX_FDS");
+    assert(fds[fd].open && "fd is not open");
+    return fds[fd].is_pvr;
+}
+
+static void pvrsrv_ioctl_post(int fd, PVRSRV_BRIDGE_PACKAGE *bridge_package, int ret) {
+    int ioctl_nr = _IOC_NR(bridge_package->ui32BridgeID);
+    switch(ioctl_nr) {
+        case _IOC_NR(PVRSRV_BRIDGE_CONNECT_SERVICES):
+            PPRINT(stdout, bridge_package->pvParamOut, PVRSRV_BRIDGE_OUT_CONNECT_SERVICES);
+            break;
+        case _IOC_NR(PVRSRV_BRIDGE_ENUM_DEVICES):
+            PPRINT(stdout, bridge_package->pvParamOut, PVRSRV_BRIDGE_OUT_ENUMDEVICE);
+            break;
+        case _IOC_NR(PVRSRV_BRIDGE_ACQUIRE_DEVICEINFO):
+            PPRINT(stdout, bridge_package->pvParamOut, PVRSRV_BRIDGE_OUT_ACQUIRE_DEVICEINFO);
+            break;
+        case _IOC_NR(PVRSRV_BRIDGE_SGX_REGISTER_HW_RENDER_CONTEXT):
+            /* TODO figure out if we can find cmd submits from this */
+            {
+                PVRSRV_BRIDGE_OUT_SGX_REGISTER_HW_RENDER_CONTEXT *data = bridge_package->pvParamOut;
+                printf("HW Render Context handle %p\n", data->hHWRenderContext);
+                printf("HW Render Context %p\n", data);
+                break;
+            }
+        case _IOC_NR(PVRSRV_BRIDGE_ALLOC_DEVICEMEM):
+            {
+                PVRSRV_BRIDGE_OUT_ALLOCDEVICEMEM *mem_data = bridge_package->pvParamOut;
+                PVRSRV_CLIENT_MEM_INFO *mem = &mem_data->sClientMemInfo;
+                track_buffer(mem, MEM_TYPE_NORMAL);
+                printf("Alloc %p\n", mem->hKernelMemInfo);
+            }
+            break;
+        case _IOC_NR(PVRSRV_BRIDGE_MHANDLE_TO_MMAP_DATA):
+            {
+                PVRSRV_BRIDGE_IN_MHANDLE_TO_MMAP_DATA *in_data = bridge_package->pvParamIn;
+                PVRSRV_BRIDGE_OUT_MHANDLE_TO_MMAP_DATA *out_data = bridge_package->pvParamOut;
+                add_mmap_data(fd, in_data->hMHandle, out_data);
+                printf("MHANDLE to MMAP data %p\n", in_data->hMHandle);
+            }
+            break;
+        case _IOC_NR(PVRSRV_BRIDGE_MAP_DEVICECLASS_MEMORY):
+            {
+                PVRSRV_BRIDGE_OUT_MAP_DEVICECLASS_MEMORY *out_data = bridge_package->pvParamOut;
+                track_buffer(&out_data->sClientMemInfo, MEM_TYPE_DISP);
+                printf("Disp class %p\n", out_data->sClientMemInfo.hMappingInfo);
+            }
+            break;
+        case _IOC_NR(PVRSRV_BRIDGE_MAP_DEV_MEMORY):
+            {
+                PVRSRV_BRIDGE_IN_MAP_DEV_MEMORY *in = bridge_package->pvParamIn;
+                PVRSRV_BRIDGE_OUT_MAP_DEV_MEMORY *out_data = bridge_package->pvParamOut;
+                track_buffer(&out_data->sDstClientMemInfo, MEM_TYPE_MAP);
+                printf("Map dev mem %p\n", out_data->sDstClientMemInfo.hKernelMemInfo);
+                printf("Mapping %p %p\n", in->hKernelMemInfo, in->hDstDevMemHeap);
+            }
+            break;
+        case _IOC_NR(PVRSRV_BRIDGE_CREATE_DEVMEMCONTEXT):
+            {
+                PVRSRV_BRIDGE_OUT_CREATE_DEVMEMCONTEXT *out = bridge_package->pvParamOut;
+                printf("Devmem context %p\n", out);
+                //PPRINT(stdout, bridge_package->pvParamIn, PVRSRV_BRIDGE_IN_CREATE_DEVMEMCONTEXT);
+                //fwrite(bridge_package->pvParamIn, 1, sizeof(PVRSRV_BRIDGE_IN_CREATE_DEVMEMCONTEXT), log_file);
+            }
+            break;
+
+        case _IOC_NR(PVRSRV_BRIDGE_GET_MISC_INFO):
+            {
+                PVRSRV_BRIDGE_IN_GET_MISC_INFO *in = bridge_package->pvParamIn;
+                printf("Getting misc info %u\n", in->sMiscInfo.ui32StateRequest);
+            }
+            break;
+        case _IOC_NR(PVRSRV_BRIDGE_SGX_GETMISCINFO):
+            {
+                PVRSRV_BRIDGE_IN_SGXGETMISCINFO *in = bridge_package->pvParamIn;
+                printf("Getting SGX misc info %u\n", in->psMiscInfo->eRequest);
+            }
+            break;
+        case _IOC_NR(PVRSRV_BRIDGE_SGX_DOKICK):
+            /* This is the command to kick off command execution */
+            {
+                PVRSRV_BRIDGE_IN_DOKICK *ccb = bridge_package->pvParamIn;
+
+                printf("CCB offset 0x%x\n", ccb->sCCBKick.ui32CCBOffset);
+                printf("Cookie %p\n", ccb->hDevCookie);
+                printf("Dev Mem Context %p\n", ccb->sCCBKick.hDevMemContext);
+                printf("Kernel mem handle %p\n", ccb->sCCBKick.hCCBKernelMemInfo);
+                struct mem_entry *cmd_buf = get_buffer(ccb->sCCBKick.hCCBKernelMemInfo);
+                printf("Dumping %p as ccb buffer\n", cmd_buf->mem_info.hKernelMemInfo);
+                dump_buffer(cmd_buf, 0, "./cmd.bin");
+                SGXMKIF_CMDTA_SHARED *ccb_data = (cmd_buf->data[0] + ccb->sCCBKick.ui32CCBOffset);
+                printf("CCB data %p, %d\n", ccb_data, sizeof(SGXMKIF_CMDTA_SHARED));
+            }
+            break;
+    }
+}
+
+static bool pvrsrv_ioctl(int fd, PVRSRV_BRIDGE_PACKAGE *bridge_package) {
+    int ioctl_nr = _IOC_NR(bridge_package->ui32BridgeID);
+    printf(">>> pvr_ioctl(%s)\n", pvrsrv_ioctl_names[ioctl_nr]);
+    switch(ioctl_nr) {
+        case _IOC_NR(PVRSRV_BRIDGE_MHANDLE_TO_MMAP_DATA):
+            /* TODO track memory */
+            break;
+        case _IOC_NR(PVRSRV_BRIDGE_ALLOC_DEVICEMEM):
+            {
+                PVRSRV_BRIDGE_IN_ALLOCDEVICEMEM *mem_data = bridge_package->pvParamIn;
+                static int current_alloc = 0;
+#if 0
+                if (mem_data->hDevMemHeap == 0x3 && mem_data->uSize == 262144) {
+                    create_buffer(fd, bridge_package, mem_data->hDevCookie, 0x3, 262144, 9, 4);
+                    printf("Created buffer to offset\n");
+                }
+#endif
+#if 1
+                /* Before buffer is allocated, allocate an identical buffer so addresses will be offset */
+                create_buffer(fd, bridge_package, mem_data->hDevCookie, (uintptr_t)mem_data->hDevMemHeap,
+                        mem_data->uSize, mem_data->ui32Attribs, mem_data->uAlignment);
+
+#endif
+
+#if 0
+                if (current_alloc == 74) {
+                    printf("Dupped this buffer!\n");
+                    create_buffer(fd, bridge_package, mem_data->hDevCookie, mem_data->hDevMemHeap,
+                        mem_data->uSize, mem_data->ui32Attribs, mem_data->uAlignment);
+                }
+#endif
+
+                printf("Alloc #%d %p\n", current_alloc, mem_data);
+                current_alloc++;
+            }
+            break;
+        case _IOC_NR(PVRSRV_BRIDGE_SGX_REGISTER_HW_RENDER_CONTEXT):
+            /* TODO figure out if we can find cmd submits from this */
+            {
+                PVRSRV_BRIDGE_IN_SGX_REGISTER_HW_RENDER_CONTEXT *data = bridge_package->pvParamIn;
+                printf("HW Render Context %p\n", data);
+#if 0
+                for (IMG_UINT32 i = 0; i < data->ui32HWRenderContextSize; i += sizeof(IMG_UINT32)) {
+                    IMG_UINT32 *t = (IMG_UINT32*)&data->pHWRenderContextCpuVAddr[i];
+                    printf("\tvalue is 0x%x\n", *t);
+                }
+#endif
+                break;
+            }
+        case _IOC_NR(PVRSRV_BRIDGE_SGX_REGISTER_HW_TRANSFER_CONTEXT):
+            /* TODO figure out if we can find cmd submits from this */
+            break;
+        case _IOC_NR(PVRSRV_BRIDGE_MAP_DEVICECLASS_MEMORY):
+            /* TODO figure out if we need to track this memory */
+            break;
+        case _IOC_NR(PVRSRV_BRIDGE_RELEASE_MMAP_DATA):
+            /* TODO track memory */
+            break;
+        case _IOC_NR(PVRSRV_BRIDGE_UNMAP_DEVICECLASS_MEMORY):
+            /* TODO track memory */
+            break;
+        case _IOC_NR(PVRSRV_BRIDGE_MAP_DEV_MEMORY):
+            /* TODO track memory */
+            break;
+        case _IOC_NR(PVRSRV_BRIDGE_UNMAP_DEV_MEMORY):
+            /* TODO track memory */
+            break;
+        case _IOC_NR(PVRSRV_BRIDGE_FREE_DEVICEMEM):
+            /* TODO track memory */
+            break;
+        case _IOC_NR(PVRSRV_BRIDGE_SGX_DOKICK):
+            /* This is the command to kick off command execution */
+            {
+                int num_buffers = 0;
+                int track_arr_size = sizeof(mem_trackings)/sizeof(mem_trackings[0]);
+                for(int i = 0; i < track_arr_size; i++) {
+                    struct mem_entry *mem = &mem_trackings[i];
+                    if(mem->in_use) {
+                        num_buffers += 1;
+                    }
+                }
+                PVRSRV_BRIDGE_IN_DOKICK *ccb = bridge_package->pvParamIn;
+                printf("Tracking %d buffers\n", num_buffers);
+                //new_magic_handle = create_patchable_buffer(fd, bridge_package, ccb->hDevCookie);
+                dump_tracked_buffers();
+                patch_buffers();
+
+                printf("CCB offset 0x%x\n", ccb->sCCBKick.ui32CCBOffset);
+                printf("Cookie %p\n", ccb->hDevCookie);
+                printf("Dev Mem Context %p\n", ccb->sCCBKick.hDevMemContext);
+                printf("Kernel mem handle %p\n", ccb->sCCBKick.hCCBKernelMemInfo);
+                //SGXMKIF_CMDTA_SHARED *ccb_data = get_buffer(ccb->sCCBKick.hCCBKernelMemInfo);
+                //printf("CCB data %p\n", ccb_data);
+                CCBEntry *entry = get_buffer(ccb->sCCBKick.hCCBKernelMemInfo)->data[0];
+#if 0
+                //CCBEntry dump = *entry;
+                //printf("Entry is %p 0x%x\n", &dump, entry->vdm_command_stream);
+                //entry->dev_addr_5.uiAddr = 0;
+                //entry->unk0 = 0; // Totally hangs GPU
+                entry->unk1 = 0;
+                entry->unk2 = 0;
+                entry->unk3 = 0;
+                //entry->unk4 = 0; // Totally hangs GPU
+                entry->unk5 = 0;
+                entry->unk6 = 0;
+                entry->unk7 = 0;
+                entry->unk8 = 0;
+                entry->unk9 = 0;
+                entry->unk10 = 0;
+                entry->unk11 = 0;
+                entry->unk12 = 0;
+                entry->unk13 = 0;
+                entry->unk14 = 0;
+                entry->unk15 = 0;
+                //entry->unk16 = 0; // Setting this to zero causes PVRSRV_BRIDGE_EVENT_OBJECT_WAIT when we read fb
+                //entry->unk17 = 0; // Same as 16, for both dmesg  shows GPU hand recovery
+                //entry->unk18 = 0; // Same as 16
+                //entry->unk19 = 0; // Same as 16
+                //entry->unk20 = 0; // Same as 16
+                entry->unk21 = 0;
+                //entry->unk22 = 0; // Totally hangs GPU, found MMU context for page fault 0x00000000
+                //entry->unk23 = 0; // Hangs GPU, Found MMU context for page fault 0x00000000
+                //entry->unk24 = 0; // Hangs GPU, Found MMU context for page fault 0x00000000
+                entry->unk25 = 0;
+                entry->unk26 = 0;
+                entry->unk27 = 0;
+                entry->unk28 = 0;
+                //entry->unk29 = 0; // Hangs GPU, Found MMU context for page fault 0x00000000
+                entry->unk30 = 0;
+#endif
+                uint32_t lst[] = {
+                    entry->unk0,
+                    entry->unk4,
+                    entry->unk16,
+                    entry->unk17,
+                    entry->unk18,
+                    entry->unk19,
+                    entry->unk20,
+                    entry->unk24,
+
+                };
+                printf("CCB entry is:\n");
+                for(int i = 0; i < sizeof(lst)/sizeof(lst[0]); i++) {
+                    printf("\t0x%x\n", lst[i]);
+                }
+                printf("Num Regs is %d\n", entry->num_regs);
+                DPRI(entry->length);
+                DPRI(entry->unk0);
+                DPRI(entry->unk1);
+                DPRI(entry->unk2);
+                DPRI(entry->unk3);
+                DPRI(entry->unk4);
+                DPRI(entry->unk5);
+                DPRI(entry->unk6);
+                DPRI(entry->frame_number);
+                DPRI(entry->dev_addr_0.uiAddr);
+                DPRI(entry->unk7);
+                DPRI(entry->unk8);
+                DPRI(entry->unk9);
+                DPRI(entry->unk10);
+                DPRI(entry->unk11);
+                DPRI(entry->unk12);
+                DPRI(entry->unk13);
+                DPRI(entry->dev_addr_1.uiAddr);
+                DPRI(entry->unk14);
+                DPRI(entry->dev_addr_2.uiAddr);
+                DPRI(entry->dev_addr_3.uiAddr);
+                DPRI(entry->dev_addr_4.uiAddr);
+                DPRI(entry->dev_addr_5.uiAddr);
+                DPRI(entry->dev_addr_6.uiAddr);
+                DPRI(entry->num_regs);
+                //DPRI(entry->shared_data.uiAddr);
+                DPRI(entry->unk15);
+                DPRI(entry->unk16);
+                DPRI(entry->unk17);
+                DPRI(entry->unk18);
+                DPRI(entry->unk19);
+                DPRI(entry->unk20);
+                DPRI(entry->vdm_command_stream);
+                DPRI(entry->unk21);
+                DPRI(entry->dev_addr_ta_0.uiAddr); // points to 0x95 TAData buffer, size is 0xc00 and all zeros
+                DPRI(entry->dev_addr_ta_1.uiAddr); // points to 0x8d TAData buffer, size is 0x400 and not all zeros
+                DPRI(entry->unk24);
+                DPRI(entry->unk25);
+                DPRI(entry->unk26);
+                DPRI(entry->unk27);
+                DPRI(entry->unk28);
+                DPRI(entry->dev_addr_per3d_0.uiAddr); // points to 0x12 PerContext3DParameters, size is 0x3dd000 and all zeros
+                DPRI(entry->unk30);
+
+
+            }
+            break;
+        case _IOC_NR(PVRSRV_BRIDGE_SGX_SET_RENDER_CONTEXT_PRIORITY):
+        case _IOC_NR(PVRSRV_BRIDGE_SGX_SET_TRANSFER_CONTEXT_PRIORITY):
+            /* TODO figure out if this is important */
+            break;
+        case _IOC_NR(PVRSRV_BRIDGE_EVENT_OBJECT_WAIT):
+        case _IOC_NR(PVRSRV_BRIDGE_SYNC_OPS_FLUSH_TO_TOKEN):
+        case _IOC_NR(PVRSRV_BRIDGE_SYNC_OPS_TAKE_TOKEN):
+        case _IOC_NR(PVRSRV_BRIDGE_OPEN_DISPCLASS_DEVICE):
+        case _IOC_NR(PVRSRV_BRIDGE_GET_DISPCLASS_INFO):
+        case _IOC_NR(PVRSRV_BRIDGE_CLOSE_DISPCLASS_DEVICE):
+        case _IOC_NR(PVRSRV_BRIDGE_ENUM_DISPCLASS_FORMATS):
+        case _IOC_NR(PVRSRV_BRIDGE_ENUM_DISPCLASS_DIMS):
+        case _IOC_NR(PVRSRV_BRIDGE_GET_DISPCLASS_SYSBUFFER):
+        case _IOC_NR(PVRSRV_BRIDGE_ENUM_CLASS):
+        case _IOC_NR(PVRSRV_BRIDGE_SGX_GETINTERNALDEVINFO):
+            break;
+        case _IOC_NR(PVRSRV_BRIDGE_CONNECT_SERVICES):
+            PPRINT(stdout, bridge_package->pvParamIn, PVRSRV_BRIDGE_IN_CONNECT_SERVICES);
+            //fwrite(bridge_package->pvParamIn, 1, sizeof(PVRSRV_BRIDGE_IN_CONNECT_SERVICES), log_file);
+            break;
+        case _IOC_NR(PVRSRV_BRIDGE_ENUM_DEVICES):
+            break;
+        case _IOC_NR(PVRSRV_BRIDGE_ACQUIRE_DEVICEINFO):
+            PPRINT(stdout, bridge_package->pvParamIn, PVRSRV_BRIDGE_IN_ACQUIRE_DEVICEINFO);
+            //fwrite(bridge_package->pvParamIn, 1, sizeof(PVRSRV_BRIDGE_IN_ACQUIRE_DEVICEINFO), log_file);
+            break;
+        case _IOC_NR(PVRSRV_BRIDGE_SGX_GETMISCINFO):
+            PPRINT(stdout, bridge_package->pvParamIn, PVRSRV_BRIDGE_IN_SGXGETMISCINFO);
+            //fwrite(bridge_package->pvParamIn, 1, sizeof(PVRSRV_BRIDGE_IN_SGXGETMISCINFO), log_file);
+            break;
+        case _IOC_NR(PVRSRV_BRIDGE_DISCONNECT_SERVICES):
+            break;
+        case _IOC_NR(PVRSRV_BRIDGE_CREATE_DEVMEMCONTEXT):
+            PPRINT(stdout, bridge_package->pvParamIn, PVRSRV_BRIDGE_IN_CREATE_DEVMEMCONTEXT);
+            //fwrite(bridge_package->pvParamIn, 1, sizeof(PVRSRV_BRIDGE_IN_CREATE_DEVMEMCONTEXT), log_file);
+            break;
+        case _IOC_NR(PVRSRV_BRIDGE_SGX_GETCLIENTINFO):
+            PPRINT(stdout, bridge_package->pvParamIn, PVRSRV_BRIDGE_IN_GETCLIENTINFO);
+            //fwrite(bridge_package->pvParamIn, 1, sizeof(PVRSRV_BRIDGE_IN_GETCLIENTINFO), log_file);
+            break;
+        case _IOC_NR(PVRSRV_BRIDGE_GET_MISC_INFO):
+        case _IOC_NR(PVRSRV_BRIDGE_EVENT_OBJECT_OPEN):
+        case _IOC_NR(PVRSRV_BRIDGE_GET_DEVMEM_HEAPINFO):
+        case _IOC_NR(PVRSRV_BRIDGE_SGX_UNREGISTER_HW_RENDER_CONTEXT):
+        case _IOC_NR(PVRSRV_BRIDGE_EVENT_OBJECT_CLOSE):
+        case _IOC_NR(PVRSRV_BRIDGE_SGX_RELEASECLIENTINFO):
+        case _IOC_NR(PVRSRV_BRIDGE_DESTROY_DEVMEMCONTEXT):
+            /* TODO figure out if these ioctl need to be handled */
+            break;
+        default:
+            printf("Unimplemented pvrsrv ioctl %d, may be %s\n", ioctl_nr, pvrsrv_ioctl_names[ioctl_nr]);
+            assert(false);
+            break;
+    }
+    return false;
+}
+
+static bool pvr_ioctl_pre(int fd, int request, void *ptr) {
+    //fwrite(&request, 1, sizeof(request), log_file);
+    int ioctl_nr = _IOC_NR(request);
+    switch(ioctl_nr) {
+        case _IOC_NR(DRM_IOCTL_VERSION):
+            printf(">>> ioctl(DRM_IOCTL_VERSION)\n");
+	    //PPRINT(stdout, ptr, drmVersion);
+            break;
+        case _IOC_NR(DRM_IOCTL_GET_MAGIC):
+            printf(">>> ioctl(DRM_IOCTL_GET_MAGIC)\n");
+            break;
+        case _IOC_NR(DRM_IOCTL_GET_UNIQUE):
+            printf(">>> ioctl(DRM_IOCTL_GET_UNIQUE)\n");
+            break;
+        case _IOC_NR(DRM_IOCTL_SET_VERSION):
+            printf(">>> ioctl(DRM_IOCTL_SET_VERSION)\n");
+            {
+                struct drm_set_version *data = ptr;
+                printf("\t%d %d %d %d\n", data->drm_di_major,
+                                        data->drm_di_minor,
+                                        data->drm_dd_major,
+                                        data->drm_dd_minor);
+            }
+            break;
+        case PVR_DRM_SRVKM_CMD:
+            //fwrite(ptr, 1, sizeof(PVRSRV_BRIDGE_PACKAGE), log_file);
+            //PPRINT(stdout, ptr, PVRSRV_BRIDGE_PACKAGE);
+            return pvrsrv_ioctl(fd, ptr);
+            break;
+        case PVR_DRM_IS_MASTER_CMD:
+            printf(">>> ioctl(PVR_DRM_IS_MASTER_CMD)\n");
+            /* From KMD source code this seems to always return 0 */
+            break;
+        default:
+            printf("Unimplemented ioctl 0x%x\n", ioctl_nr);
+            assert(false);
+            break;
+    }
+    return false;
+}
+
+static void pvr_ioctl_post(int fd, int request, void *ptr, int ret) {
+    int ioctl_nr = _IOC_NR(request);
+    switch(ioctl_nr) {
+        case _IOC_NR(DRM_IOCTL_VERSION):
+            //printf(">>> ioctl(DRM_IOCTL_VERSION)\n");
+	    PPRINT(stdout, ptr, drmVersion);
+            break;
+        case PVR_DRM_SRVKM_CMD:
+            pvrsrv_ioctl_post(fd, ptr, ret);
+            break;
+    }
+}
+
+int ioctl(int fd, int request, ...) {
+    PROLOG(ioctl);
+    //open_log_file();
+    int ioc_size = _IOC_SIZE(request);
+    bool pvr = is_pvr(fd);
+
+    //printf("Size is %d\n", ioc_size);
+    void *ptr = NULL;
+    if(ioc_size) {
+        va_list args;
+        va_start(args, request);
+        ptr = va_arg(args, void *);
+        va_end(args);
+    }
+
+    bool skip = false;
+    if(pvr) {
+        skip = pvr_ioctl_pre(fd, request, ptr);
+    }
+
+    int ret = 0;
+    if(!skip)
+        ret = orig_ioctl(fd, request, ptr);
+
+    if(pvr) {
+        pvr_ioctl_post(fd, request, ptr, ret);
+    }
+
+    return ret;
+}
+
+int close(int fd) {
+    PROLOG(close);
+    /* Mark file as closed */
+    memset(&fds[fd], 0, sizeof(fds[fd]));
+    return orig_close(fd);
+}
+
+int open64(const char *pathname, int flags, ...) {
+    printf("Called open64 on %s (%d)\n", pathname, flags);
+    PROLOG(open64);
+    int fd = orig_open64(pathname, flags);
+    check_fd(fd, pathname);
+    return fd;
+}
+
+int open(const char *pathname, int flags, mode_t mode) {
+    //printf("Called open on %s (%d)\n", pathname, flags);
+    PROLOG(open);
+    int fd = orig_open(pathname, flags, mode);
+    check_fd(fd, pathname);
+    return fd;
+}
+
+int openat(int dirfd, const char *pathname, int flags, ...) {
+    assert(false && "openat not implemented");
+    printf("Called openat on %s (%d) (%d)\n", pathname, dirfd, flags);
+    PROLOG(openat);
+    return orig_openat(dirfd, pathname, flags);
+}
+
+long syscall(long number, ...) {
+    PROLOG(syscall);
+    if(number == SYS_mmap2) {
+        va_list args;
+        va_start(args, number);
+        unsigned long addr = va_arg(args, unsigned long);
+        unsigned long length = va_arg(args, unsigned long);
+        unsigned long prot = va_arg(args, unsigned long);
+        unsigned long flags = va_arg(args, unsigned long);
+        unsigned long fd = va_arg(args, unsigned long);
+        unsigned long pgoffset = va_arg(args, unsigned long);
+        long ret = orig_syscall(number, addr, length, prot, flags, fd, pgoffset);
+	if (is_pvr(fd)) {
+            printf("mmap2 called with 0x%lx\n", ret);
+            last_mem_entry = add_mmap_pointer((void*)ret, prot, length, pgoffset);
+            clear_mem(last_mem_entry);
+	}
+        return ret;
+    } else {
+        printf("Unhandled syscall 0x%lx\n", number);
+    }
+
+    assert(false);
+    return 0;
+}
+
+
+
+#if 0
+void * memcpy ( void * destination, const void * source, size_t num ) {
+    PROLOG(memcpy);
+
+    for(size_t i = 0; i < num; i += 1) {
+        uint32_t *data = ((uint8_t*)source) + i;
+        //if ((*data & 0xffffff00) == 0x0dc13000) {
+        if (bincmp32(data, 0x0dc13000)) {
+            printf("Found pointer at %p\n", data);
+        }
+    }
+
+    return orig_memcpy(destination, source, num);
+}
+#endif
+
+#if 0
+drmVersionPtr drmGetVersion(int fd) {
+    PROLOG(drmGetVersion);
+    printf(">>> drmGetVersion(%d)\n", fd);
+    return orig_drmGetVersion(fd);
+}
+
+int drmSetInterfaceVersion(int fd, drmSetVersion *version) {
+    PROLOG(drmSetInterfaceVersion);
+    printf(">>> drmSetInterfaceVersion(%d, ...)", fd);
+    return orig_drmSetInterfaceVersion(fd);
+}
+#endif
+
+#if 0
+/* We need to hijack this function to get memory mappings since the pvr driver
+ * calls `mmap2` through `syscall` meaning we can't hijack it with LD_PRELOAD
+ * This function does not get every memory mapping though
+ */
+int PVRSRVAllocDeviceMem(void* data, void* handle, uint32_t attribs, uint32_t size, uint32_t align, PVRSRV_CLIENT_MEM_INFO** info) {
+    PROLOG(PVRSRVAllocDeviceMem);
+    int ret = orig_PVRSRVAllocDeviceMem(data, handle, attribs, size, align, info);
+
+    printf("allocated %x bytes of memory at %p : %x (%s)\n", size, (*info)->pvLinAddr, (*info)->sDevVAddr.uiAddr,
+    pvr_heap_names[get_heap((*info)->sDevVAddr)]);
+    printf("Heap handle %p\n", handle);
+
+    /* Clear memory so comparing dumps will be more consistent */
+    memset((*info)->pvLinAddr, 0, size);
+
+    /* Track userspace pointer here since this avoids the double mmap issue */
+    add_mmap_addr((*info)->hKernelMemInfo, (*info)->pvLinAddr);
+
+    return ret;
+}
+#endif