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 #include <gelf.h>
  31
  32 void *libgl_handle;
  33 void *wrapper_handle;
  34
  35 /* Is the given elf program 32 or 64 bit?
  36  *
  37  * Note: This function returns -1 if 'filename' cannot
  38  * be opened as a valid ELF file.
  39  */
  40 static int
  41 elf_bits (const char *filename)
  42 {
  43         Elf *elf;
  44         GElf_Ehdr ehdr;
  45         int fd, class;
  46
  47         fd = open (filename, O_RDONLY, 0);
  48         if (fd < 0)
  49                 return -1;
  50
  51         if (elf_version (EV_CURRENT ) == EV_NONE)
  52                 return -1;
  53
  54         elf = elf_begin (fd, ELF_C_READ, NULL);
  55         if (elf == NULL)
  56                 return -1;
  57
  58         if (elf_kind (elf) != ELF_K_ELF)
  59                 return -1;
  60
  61         if (gelf_getehdr (elf, &ehdr) == NULL)
  62                 return -1;
  63
  64         class = gelf_getclass (elf);
  65
  66         switch (class) {
  67         case ELFCLASS32:
  68                 return 32;
  69         case ELFCLASS64:
  70                 return 64;
  71         default:
  72                 return -1;
  73         }
  74 }
  75
  76 static void
  77 open_libgl_handle (void)
  78 {
  79         const char *libgl_path;
  80
  81         if (libgl_handle)
  82                 return;
  83
  84         libgl_path = getenv ("GLAZE_LIBGL");
  85
  86         if (libgl_path == NULL) {
  87                 Dl_info info;
  88                 int bits;
  89
  90                 if (dladdr (open_libgl_handle, &info) == 0) {
  91                         fprintf (stderr, "Internal error: Failed to lookup filename of glaze library with dladdr.\n");
  92                         exit (1);
  93                 }
  94
  95                 bits = elf_bits (info.dli_fname);
  96
  97                 if (bits == 32)
  98                         libgl_path = getenv ("GLAZE_LIBGL_32_AUTO");
  99                 if (bits == 64)
 100                         libgl_path = getenv ("GLAZE_LIBGL_64_AUTO");
 101
 102                 if (libgl_path == NULL) {
 103                         fprintf (stderr,
 104                                  "Error: Failed to detect OpenGL library.\n"
 105                                  "Please set GLAZE_LIBGL to path of real libGL.so\n");
 106                         exit (1);
 107                 }
 108
 109                 setenv ("GLAZE_LIBGL", libgl_path, 1);
 110         }
 111
 112         dlerror();
 113         libgl_handle = dlopen (libgl_path, RTLD_LAZY | RTLD_GLOBAL);
 114         if (libgl_handle == NULL) {
 115                 fprintf (stderr, "glaze_init: Error: Failed to dlopen %s: %s\n",
 116                          libgl_path, dlerror());
 117                 exit (1);
 118         }
 119 }
 120
 121 static void
 122 open_wrapper_handle (void)
 123 {
 124         const char *path;
 125
 126         if (wrapper_handle)
 127                 return;
 128
 129         path = getenv ("GLAZE_WRAPPER");
 130         if (path == NULL) {
 131                 fprintf (stderr, "GLAZE_WRAPPER unset. Please set to path of real libGL.so under glaze.\n");
 132                 exit (1);
 133         }
 134
 135         dlerror ();
 136         wrapper_handle = dlopen (path, RTLD_LAZY);
 137         if (wrapper_handle == NULL) {
 138                 const char *error = dlerror();
 139                 fprintf (stderr, "Error: Failed to dlopen %s: %s\n", path, error);
 140                 exit (1);
 141         }
 142 }
 143
 144 static void
 145 glaze_init (void) __attribute__((constructor));
 146
 147 static void
 148 glaze_init (void)
 149 {
 150         open_libgl_handle ();
 151         open_wrapper_handle ();
 152 }
 153
 154 static void *
 155 resolve (const char *name)
 156 {
 157         void *symbol;
 158
 159         /* The wrapper gets first choice on all symbols. */
 160         symbol = dlsym (wrapper_handle, name);
 161         if (symbol)
 162                 return symbol;
 163
 164         return dlsym (libgl_handle, name);
 165 }
 166
 167 #define GLAZE_API(name)                                                 \
 168 void * name() __attribute__((ifunc(#name "_resolver")));                \
 169 static void *                                                           \
 170 name ## _resolver (void) { return resolve (#name); }
 171
 172 #include "specs/gl.def"
 173 #include "specs/glx.def"