HookInfo(const char* dl)
{
const char* envHookDebug;
// Load the libcuda.so library with RTLD_GLOBAL so we can hook the function calls
handle = dlopen(dl, RTLD_LAZY | RTLD_GLOBAL);
CU_HOOK_DIE_IF(!handle, "Failed to load libcuda.so, %s\n", dlerror());
realFunctions[CU_HOOK_MEM_ALLOC] = real_dlsym(handle, CUDA_SYMBOL_STRING(cuMemAlloc));
CU_HOOK_DIE_IF(!realFunctions[CU_HOOK_MEM_ALLOC], "Failed to find symbol cuMemAlloc, %s\n", dlerror());
realFunctions[CU_HOOK_MEM_FREE] = real_dlsym(handle, CUDA_SYMBOL_STRING(cuMemFree));
CU_HOOK_DIE_IF(!realFunctions[CU_HOOK_MEM_FREE], "Failed to find symbol cuMemFree, %s\n", dlerror());
realFunctions[CU_HOOK_CTX_GET_CURRENT] = real_dlsym(handle, CUDA_SYMBOL_STRING(cuCtxGetCurrent));
CU_HOOK_DIE_IF(!realFunctions[CU_HOOK_CTX_GET_CURRENT], "Failed to find symbol cuCtxGetCurrent, %s\n", dlerror());
realFunctions[CU_HOOK_CTX_SET_CURRENT] = real_dlsym(handle, CUDA_SYMBOL_STRING(cuCtxSetCurrent));
CU_HOOK_DIE_IF(!realFunctions[CU_HOOK_CTX_SET_CURRENT], "Failed to find symbol cuCtxSetCurrent, %s\n", dlerror());
realFunctions[CU_HOOK_CTX_DESTROY] = real_dlsym(handle, CUDA_SYMBOL_STRING(cuCtxDestroy));
CU_HOOK_DIE_IF(!realFunctions[CU_HOOK_CTX_DESTROY], "Failed to find symbol cuCtxDestroy, %s\n", dlerror());
// Check environment for CU_HOOK_DEBUG to facilitate debugging
envHookDebug = getenv("CU_HOOK_DEBUG");
if (envHookDebug && envHookDebug[0] == '1') {
bDebugEnabled = 1;
fprintf(stderr, "* %6d >> CUDA HOOK Library loaded.\n", getpid());
}
}
__GLXextFuncPtr glXGetProcAddress(const GLubyte * procname){
printf("hooking glxgetprocaddress, %s\n", procname);
if(!glXGetProcAddress_orig)glXGetProcAddress_orig = real_dlsym(RTLD_NEXT, "glXGetProcAddress");
if(string_testEqualN("glShaderSource", (char*)procname, 14)){
if(!glShaderSource_orig)glShaderSource_orig = glXGetProcAddress_orig((GLubyte *)"glShaderSource");
printf("replaced %s\n", procname);
return (__GLXextFuncPtr)glShaderSource;
} else if(string_testEqualN("glUseProgram", (char*)procname, 12)){
if(!glUseProgram_orig)glUseProgram_orig = glXGetProcAddress_orig((GLubyte *)"glUseProgram");
printf("replaced %s\n", procname);
return (__GLXextFuncPtr)glUseProgram;
} else if(string_testEqualN("glXSwapBuffers", (char*)procname, 14)){
if(!glXSwapBuffers_orig)glXSwapBuffers_orig = glXGetProcAddress_orig((GLubyte *)"glXSwapBuffers");
printf("replaced %s\n", procname);
return (__GLXextFuncPtr)glXSwapBuffers;
} else if(string_testEqualN("glXSwapIntervalEXT", (char*)procname, 18)){
if(!glXSwapInterval_orig)glXSwapInterval_orig = glXGetProcAddress_orig((GLubyte *)"glXSwapIntervalEXT");
printf("replaced %s\n", procname);
return (__GLXextFuncPtr)glXSwapInterval;
} else if(string_testEqualN("glXSwapIntervalSGI", (char*)procname, 18) || string_testEqualN("glXSwapIntervalMESA", (char*) procname, 19)){
if(!glXSwapIntervalSGI_orig)glXSwapIntervalSGI_orig = glXGetProcAddress_orig((GLubyte *)"glXSwapIntervalSGI");
printf("replaced %s\n", procname);
return (__GLXextFuncPtr)glXSwapIntervalSGI;
} else if(string_testEqualN("glXChooseFBConfig", (char*)procname, 17)){
if(!glXChooseFBConfig_orig)glXChooseFBConfig_orig = glXGetProcAddress_orig((GLubyte *)"glXChooseFBConfig");
printf("replaced %s\n", procname);
return (__GLXextFuncPtr)glXChooseFBConfig;
} else if(string_testEqualN("glCreateShader", (char*)procname, 14)){
if(!glCreateShader_orig)glCreateShader_orig = glXGetProcAddress_orig((GLubyte *)"glCreateShader");
printf("replaced %s\n", procname);
return (__GLXextFuncPtr)glCreateShader;
}
return glXGetProcAddress_orig(procname);
}
extern void * dlsym(void * handle, const char * symbol){
if(!real_dlsym){
real_dlsym = _dl_sym(RTLD_NEXT, "dlsym", dlsym);
}
void *ret = NULL;
if(symbol && string_testEqual(symbol, "dlsym")) return dlsym;
if(!(ret = real_dlsym(handle, symbol))) return ret;
printf("hooked dlsym, %s\n", symbol);
if(string_testEqualN(symbol, "glXGetProcAddress", 17)){
// printf("--- HOOK GLXGETPROCADDRESS\n");
glXGetProcAddress_orig = real_dlsym(handle, "glXGetProcAddress");
return glXGetProcAddress;
} else if(string_testEqualN(symbol, "glutGetProcAddress", 18)){
// printf("--- HOOK GLXGETPROCADDRESS\n");
glutGetProcAddress_orig = real_dlsym(handle, "glutGetProcAddress");
return glutGetProcAddress;
} else if(string_testEqualN(symbol, "glXSwapBuffers", 14)){
glXSwapBuffers_orig = real_dlsym(handle, "glXSwapBuffers");
// printf("replaced %s\n", symbol);
return (__GLXextFuncPtr)glXSwapBuffers;
} else if(string_testEqualN(symbol, "glXChooseFBConfig", 17)){
glXChooseFBConfig_orig = real_dlsym(handle, "glXChooseFBConfig");
// printf("replaced %s\n", symbol);
return (__GLXextFuncPtr)glXChooseFBConfig;
} else if(string_testEqualN(symbol, "glfwCreateWindow", 16)){
glfwCreateWindow_orig = real_dlsym(handle, "glfwCreateWindow");
// printf("replaced %s\n", symbol);
return glfwCreateWindow;
}
return ret;
}
static
void shim_load_libGL()
{
if(!libGL) {
libGL = dlopen(lib_path("libGL.so"), RTLD_LAZY);
fprintf(stderr, "%s\n", lib_path("libGL.so"));
if(!libGL) {
fputs(dlerror(), stderr);
exit(1);
}
_glXSwapBuffers = (void (*)(Display*, GLXDrawable))real_dlsym(libGL, "glXSwapBuffers");
_glXGetProcAddress = (void (*(*)(const GLubyte *procName))())real_dlsym(libGL, "glXGetProcAddressARB");
const char *error;
if((error = dlerror())) {
fputs(error, stderr);
exit(1);
}
}
}
/*
** Interposed Functions
*/
void* dlsym(void *handle, const char *symbol)
{
// Early out if not a CUDA driver symbol
if (strncmp(symbol, "cu", 2) != 0) {
return (real_dlsym(handle, symbol));
}
if (strcmp(symbol, CUDA_SYMBOL_STRING(cuMemAlloc)) == 0) {
return (void*)(&cuMemAlloc);
}
else if (strcmp(symbol, CUDA_SYMBOL_STRING(cuMemFree)) == 0) {
return (void*)(&cuMemFree);
}
else if (strcmp(symbol, CUDA_SYMBOL_STRING(cuCtxGetCurrent)) == 0) {
return (void*)(&cuCtxGetCurrent);
}
else if (strcmp(symbol, CUDA_SYMBOL_STRING(cuCtxSetCurrent)) == 0) {
return (void*)(&cuCtxSetCurrent);
}
else if (strcmp(symbol, CUDA_SYMBOL_STRING(cuCtxDestroy)) == 0) {
return (void*)(&cuCtxDestroy);
}
return (real_dlsym(handle, symbol));
}
void *dlsym(void *handle, const char *name)
{
if(!real_dlsym) {
fprintf(stderr, "with_smaa: Getting real dlsym...\n");
void *libdl = dlopen(lib_path("libdl.so"), RTLD_NOW);
real_dlsym = __libc_dlsym(libdl, "dlsym");
fprintf(stderr, "with_smaa: real_dlsym=%p\n", real_dlsym);
}
if (!strcmp(name, "dlsym")) {
return (void*) dlsym;
} else if(!strcmp(name, "glXGetProcAddressARB")) {
fprintf(stderr, "with_smaa: dlsym: redirecting glXGetProcAddressARB\n");
return (void*) glXGetProcAddress;
} else if(!strcmp(name, "glXGetProcAddress")) {
fprintf(stderr, "with_smaa: dlsym: redirecting glXGetProcAddress\n");
return (void*) glXGetProcAddress;
} else if(!strcmp(name, "glXSwapBuffers")) {
fprintf(stderr, "with_smaa: dlsym: redirecting glXSwapBuffers\n");
return (void*) glXSwapBuffers;
}
return real_dlsym(handle, name);
}
void * glutGetProcAddress(const char * procname){
if(!glutGetProcAddress_orig)glutGetProcAddress_orig = real_dlsym(RTLD_NEXT, "glutGetProcAddress");
//printf("DOPE %s\n", procname);
return glutGetProcAddress_orig(procname);
}
void init(void){
if(!glShaderSource_orig)glShaderSource_orig = real_dlsym(RTLD_NEXT, "glShaderSource");
if(!glXSwapBuffers_orig)glXSwapBuffers_orig = real_dlsym(RTLD_NEXT, "glXSwapBuffers");
if(!glXSwapInterval_orig)glXSwapInterval_orig = real_dlsym(RTLD_NEXT, "glXSwapIntervalEXT");
if(!glXSwapIntervalSGI_orig)glXSwapIntervalSGI_orig = real_dlsym(RTLD_NEXT, "glXSwapIntervalSGI");
if(!glCreateShader_orig)glCreateShader_orig = real_dlsym(RTLD_NEXT, "glCreateShader");
if(!glActiveTexture_orig)glActiveTexture_orig = real_dlsym(RTLD_NEXT, "glActiveTexture");
if(!glAlphaFunc_orig)glAlphaFunc_orig = real_dlsym(RTLD_NEXT, "glAlphaFunc");
if(!glBindTexture_orig)glBindTexture_orig = real_dlsym(RTLD_NEXT, "glBindTexture");
if(!glBindVertexArray_orig)glBindVertexArray_orig = real_dlsym(RTLD_NEXT, "glBindVertexArray");
if(!glBlendFunc_orig)glBlendFunc_orig = real_dlsym(RTLD_NEXT, "glBlendFunc");
if(!glCullFace_orig)glCullFace_orig = real_dlsym(RTLD_NEXT, "glCullFace");
if(!glColor4fv_orig)glColor4fv_orig = real_dlsym(RTLD_NEXT, "glColor4fv");
if(!glDepthFunc_orig)glDepthFunc_orig = real_dlsym(RTLD_NEXT, "glDepthFunc");
if(!glDepthMask_orig)glDepthMask_orig = real_dlsym(RTLD_NEXT, "glDepthMask");
if(!glUseProgram_orig)glUseProgram_orig = real_dlsym(RTLD_NEXT, "glUseProgram");
if(!glfwCreateWindow_orig)glfwCreateWindow_orig = real_dlsym(RTLD_NEXT, "glfwCreateWindow");
state.color[0] = 1.0; state.color[1] = 1.0; state.color[2] = 1.0; state.color[3] = 1.0;
}
