git.cworth.org Git - glaze/blob - glaze-gl.c

   1 /* Copyright © 2013, Intel Corporation
   2  *
   3  * Permission is hereby granted, free of charge, to any person obtaining a copy
   4  * of this software and associated documentation files (the "Software"), to deal
   5  * in the Software without restriction, including without limitation the rights
   6  * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
   7  * copies of the Software, and to permit persons to whom the Software is
   8  * furnished to do so, subject to the following conditions:
   9  *
  10  * The above copyright notice and this permission notice shall be included in
  11  * all copies or substantial portions of the Software.
  12  *
  13  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
  14  * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
  15  * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
  16  * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
  17  * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
  18  * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
  19  * THE SOFTWARE.
  20  */
  21
  22 #define _GNU_SOURCE
  23 #include <dlfcn.h>
  24
  25 #include <stdio.h>
  26 #include <stdlib.h>
  27 #include <string.h>
  28
  29 #include <fcntl.h>
  30
  31 void *libgl_handle;
  32 void *wrapper_handle;
  33
  34 #define STRNCMP_LITERAL(str, literal) strncmp (str, literal, sizeof (literal) - 1)
  35
  36 static void
  37 open_libgl_handle (void)
  38 {
  39         const char *libgl_path;
  40
  41         if (libgl_handle)
  42                 return;
  43
  44         libgl_path = getenv ("GLAZE_LIBGL");
  45
  46         if (libgl_path == NULL) {
  47
  48 #if GLAZE_BITS == 32
  49                 libgl_path = getenv ("GLAZE_LIBGL_32_AUTO");
  50 #elif GLAZE_BITS == 64
  51                 libgl_path = getenv ("GLAZE_LIBGL_64_AUTO");
  52 #endif
  53
  54                 if (libgl_path == NULL) {
  55                         fprintf (stderr,
  56                                  "Error: Failed to detect OpenGL library.\n"
  57                                  "Please set GLAZE_LIBGL to path of real libGL.so\n");
  58                         exit (1);
  59                 }
  60
  61                 setenv ("GLAZE_LIBGL", libgl_path, 1);
  62         }
  63
  64         dlerror();
  65         libgl_handle = dlopen (libgl_path, RTLD_LAZY | RTLD_GLOBAL);
  66         if (libgl_handle == NULL) {
  67                 fprintf (stderr, "glaze_init: Error: Failed to dlopen %s: %s\n",
  68                          libgl_path, dlerror());
  69                 exit (1);
  70         }
  71 }
  72
  73 static void
  74 open_wrapper_handle (void)
  75 {
  76         const char *path;
  77
  78         if (wrapper_handle)
  79                 return;
  80
  81         path = getenv ("GLAZE_WRAPPER");
  82         if (path == NULL) {
  83                 fprintf (stderr, "GLAZE_WRAPPER unset. Please set to path of real libGL.so under glaze.\n");
  84                 exit (1);
  85         }
  86
  87         dlerror ();
  88         wrapper_handle = dlopen (path, RTLD_LAZY);
  89         if (wrapper_handle == NULL) {
  90                 const char *error = dlerror();
  91                 fprintf (stderr, "Error: Failed to dlopen %s: %s\n", path, error);
  92                 exit (1);
  93         }
  94 }
  95
  96 static void
  97 glaze_init (void) __attribute__((constructor));
  98
  99 static void
 100 glaze_init (void)
 101 {
 102         open_libgl_handle ();
 103         open_wrapper_handle ();
 104 }
 105
 106 static void *
 107 resolve (const char *name)
 108 {
 109         static int before_first_gl_call = 1;
 110         void *symbol;
 111
 112         if (before_first_gl_call &&
 113             STRNCMP_LITERAL (name, "gl") == 0 &&
 114             STRNCMP_LITERAL (name, "glX") != 0)
 115         {
 116                 char *callback_name = getenv ("GLAZE_FIRST_GL_CALL_CALLBACK");
 117                 if (callback_name) {
 118                         void (*callback) (void) = dlsym (wrapper_handle,
 119                                                          callback_name);
 120                         if (callback) {
 121                                 (callback) ();
 122                         } else {
 123                                 fprintf (stderr,
 124                                          "Error: Failed to find function %s "
 125                                          "in GLAZE_WRAPPER library.\n",
 126                                          callback_name);
 127                         }
 128                 }
 129                 before_first_gl_call = 0;
 130         }
 131
 132         /* The wrapper gets first choice on all symbols. */
 133         symbol = dlsym (wrapper_handle, name);
 134         if (symbol)
 135                 return symbol;
 136
 137         return dlsym (libgl_handle, name);
 138 }
 139
 140 #define GLAZE_API(name)                                                 \
 141 void * name() __attribute__((ifunc(#name "_resolver")));                \
 142 static void *                                                           \
 143 name ## _resolver (void) { return resolve (#name); }
 144
 145 #include "specs/gl.def"
 146 #include "specs/glx.def"