]> git.cworth.org Git - glaze/blob - glaze-gl.c
Add a glaze_execute function to libglaze
[glaze] / 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"