Remove vlc-config
[vlc.git] / libs / loader / ldt_keeper.c
1 /*
2  * $Id$
3  *
4  * Copyright 1993 Robert J. Amstadt
5  * Copyright 1995 Alexandre Julliard
6  *
7  * Originally distributed under LPGL 2.1 (or later) by the Wine project.
8  *
9  * Modified for use with MPlayer, detailed CVS changelog at
10  * http://www.mplayerhq.hu/cgi-bin/cvsweb.cgi/main/
11  *
12  * File now distributed as part of VLC media player with no modifications.
13  *
14  * This program is free software; you can redistribute it and/or modify
15  * it under the terms of the GNU General Public License as published by
16  * the Free Software Foundation; either version 2 of the License, or
17  * (at your option) any later version.
18  *
19  * This program is distributed in the hope that it will be useful,
20  * but WITHOUT ANY WARRANTY; without even the implied warranty of
21  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
22  * GNU General Public License for more details.
23  *
24  * You should have received a copy of the GNU General Public License
25  * along with this program; if not, write to the Free Software
26  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston MA 02110-1301, USA.
27  */
28
29 /**
30  * !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
31  * This file MUST be in main library because LDT must
32  * be modified before program creates first thread
33  * - avifile includes this file from C++ code
34  * and initializes it at the start of player!
35  * it might sound like a hack and it really is - but
36  * as aviplay is deconding video with more than just one
37  * thread currently it's necessary to do it this way
38  * this might change in the future
39  */
40
41 /* applied some modification to make make our xine friend more happy */
42
43 #include "ldt_keeper.h"
44
45 #include <string.h>
46 #include <stdlib.h>
47 #include <errno.h>
48 #include <fcntl.h>
49 #include <sys/mman.h>
50 #include <sys/types.h>
51 #include <stdio.h>
52 #include <unistd.h>
53 #ifdef __linux__
54 #include <asm/unistd.h>
55 #include <asm/ldt.h>
56 // 2.5.xx+ calls this user_desc:
57 #include <linux/version.h>
58 #if LINUX_VERSION_CODE >= KERNEL_VERSION(2,5,47)
59 #define modify_ldt_ldt_s user_desc
60 #endif
61 /* prototype it here, so we won't depend on kernel headers */
62 #ifdef  __cplusplus
63 extern "C" {
64 #endif
65 /// declare modify_ldt with the _syscall3 macro for older glibcs
66 #if defined(__GLIBC__) &&  (__GLIBC__ < 2 || (__GLIBC__ == 2 && __GLIBC_MINOR__ == 0))
67 _syscall3( int, modify_ldt, int, func, void *, ptr, unsigned long, bytecount );
68 #else
69 int modify_ldt(int func, void *ptr, unsigned long bytecount);
70 #endif
71 #ifdef  __cplusplus
72 }
73 #endif
74 #else
75 #if defined(__NetBSD__) || defined(__FreeBSD__) || defined(__OpenBSD__) || defined(__DragonFly__)
76 #include <machine/segments.h>
77 #include <machine/sysarch.h>
78 #endif
79
80 #ifdef __svr4__
81 #include <sys/segment.h>
82 #include <sys/sysi86.h>
83
84 /* solaris x86: add missing prototype for sysi86() */
85 #ifdef  __cplusplus
86 extern "C" {
87 #endif
88 int sysi86(int, void*);
89 #ifdef  __cplusplus
90 }
91 #endif
92
93 #ifndef NUMSYSLDTS             /* SunOS 2.5.1 does not define NUMSYSLDTS */
94 #define NUMSYSLDTS     6       /* Let's hope the SunOS 5.8 value is OK */
95 #endif
96
97 #define       TEB_SEL_IDX     NUMSYSLDTS
98 #endif
99
100 #define LDT_ENTRIES     8192
101 #define LDT_ENTRY_SIZE  8
102 #pragma pack(4)
103 struct modify_ldt_ldt_s {
104         unsigned int  entry_number;
105         unsigned long base_addr;
106         unsigned int  limit;
107         unsigned int  seg_32bit:1;
108         unsigned int  contents:2;
109         unsigned int  read_exec_only:1;
110         unsigned int  limit_in_pages:1;
111         unsigned int  seg_not_present:1;
112         unsigned int  useable:1;
113 };
114
115 #define MODIFY_LDT_CONTENTS_DATA        0
116 #define MODIFY_LDT_CONTENTS_STACK       1
117 #define MODIFY_LDT_CONTENTS_CODE        2
118 #endif
119
120
121 /* user level (privilege level: 3) ldt (1<<2) segment selector */
122 #define       LDT_SEL(idx) ((idx) << 3 | 1 << 2 | 3)
123
124 /* i got this value from wine sources, it's the first free LDT entry */
125 #if defined(__FreeBSD__) && defined(LDT_AUTO_ALLOC)
126 #define       TEB_SEL_IDX     LDT_AUTO_ALLOC
127 #endif
128
129 #ifndef       TEB_SEL_IDX
130 #define       TEB_SEL_IDX     17
131 #endif
132
133 static unsigned int fs_ldt = TEB_SEL_IDX;
134
135
136 /**
137  * here is a small logical problem with Restore for multithreaded programs -
138  * in C++ we use static class for this...
139  */
140
141 #ifdef __cplusplus
142 extern "C"
143 #endif
144 void Setup_FS_Segment(void)
145 {
146     unsigned int ldt_desc = LDT_SEL(fs_ldt);
147
148     __asm__ __volatile__(
149         "movl %0,%%eax; movw %%ax, %%fs" : : "r" (ldt_desc)
150         :"eax"
151     );
152 }
153
154 /* we don't need this - use modify_ldt instead */
155 #if 0
156 #ifdef __linux__
157 /* XXX: why is this routine from libc redefined here? */
158 /* NOTE: the redefined version ignores the count param, count is hardcoded as 16 */
159 static int LDT_Modify( int func, struct modify_ldt_ldt_s *ptr,
160                        unsigned long count )
161 {
162     int res;
163 #ifdef __PIC__
164     __asm__ __volatile__( "pushl %%ebx\n\t"
165                           "movl %2,%%ebx\n\t"
166                           "int $0x80\n\t"
167                           "popl %%ebx"
168                           : "=a" (res)
169                           : "0" (__NR_modify_ldt),
170                           "r" (func),
171                           "c" (ptr),
172                           "d"(16)//sizeof(*ptr) from kernel point of view
173                           :"esi"     );
174 #else
175     __asm__ __volatile__("int $0x80"
176                          : "=a" (res)
177                          : "0" (__NR_modify_ldt),
178                          "b" (func),
179                          "c" (ptr),
180                          "d"(16)
181                          :"esi");
182 #endif  /* __PIC__ */
183     if (res >= 0) return res;
184     errno = -res;
185     return -1;
186 }
187 #endif
188 #endif
189
190 #if defined(__NetBSD__) || defined(__FreeBSD__) || defined(__OpenBSD__) || defined(__DragonFly__)
191 static void LDT_EntryToBytes( unsigned long *buffer, const struct modify_ldt_ldt_s *content )
192 {
193     *buffer++ = ((content->base_addr & 0x0000ffff) << 16) |
194         (content->limit & 0x0ffff);
195     *buffer = (content->base_addr & 0xff000000) |
196         ((content->base_addr & 0x00ff0000)>>16) |
197         (content->limit & 0xf0000) |
198         (content->contents << 10) |
199         ((content->read_exec_only == 0) << 9) |
200         ((content->seg_32bit != 0) << 22) |
201         ((content->limit_in_pages != 0) << 23) |
202         0xf000;
203 }
204 #endif
205
206 void* fs_seg=0;
207
208 ldt_fs_t* Setup_LDT_Keeper(void)
209 {
210     struct modify_ldt_ldt_s array;
211     int ret;
212     ldt_fs_t* ldt_fs = (ldt_fs_t*) malloc(sizeof(ldt_fs_t));
213
214     if (!ldt_fs)
215         return NULL;
216
217     ldt_fs->fd = open("/dev/zero", O_RDWR);
218     if(ldt_fs->fd<0){
219         perror( "Cannot open /dev/zero for READ+WRITE. Check permissions! error: ");
220         free(ldt_fs);
221         return NULL;
222     }
223     fs_seg=
224     ldt_fs->fs_seg = mmap(NULL, getpagesize(), PROT_READ | PROT_WRITE, MAP_PRIVATE,
225                           ldt_fs->fd, 0);
226     if (ldt_fs->fs_seg == (void*)-1)
227     {
228         perror("ERROR: Couldn't allocate memory for fs segment");
229         close(ldt_fs->fd);
230         free(ldt_fs);
231         return NULL;
232     }
233     *(void**)((char*)ldt_fs->fs_seg+0x18) = ldt_fs->fs_seg;
234     memset(&array, 0, sizeof(array));
235     array.base_addr=(int)ldt_fs->fs_seg;
236     array.entry_number=TEB_SEL_IDX;
237     array.limit=array.base_addr+getpagesize()-1;
238     array.seg_32bit=1;
239     array.read_exec_only=0;
240     array.seg_not_present=0;
241     array.contents=MODIFY_LDT_CONTENTS_DATA;
242     array.limit_in_pages=0;
243 #ifdef __linux__
244     //ret=LDT_Modify(0x1, &array, sizeof(struct modify_ldt_ldt_s));
245     ret=modify_ldt(0x1, &array, sizeof(struct modify_ldt_ldt_s));
246     if(ret<0)
247     {
248         perror("install_fs");
249         printf("Couldn't install fs segment, expect segfault\n");
250     }
251 #endif /*linux*/
252
253 #if defined(__NetBSD__) || defined(__FreeBSD__) || defined(__OpenBSD__) || defined(__DragonFly__)
254     {
255         unsigned long d[2];
256
257         LDT_EntryToBytes( d, &array );
258 #if defined(__FreeBSD__) && defined(LDT_AUTO_ALLOC)
259         ret = i386_set_ldt(LDT_AUTO_ALLOC, (union descriptor *)d, 1);
260         array.entry_number = ret;
261         fs_ldt = ret;
262 #else
263         ret = i386_set_ldt(array.entry_number, (union descriptor *)d, 1);
264 #endif
265         if (ret < 0)
266         {
267             perror("install_fs");
268             printf("Couldn't install fs segment, expect segfault\n");
269             printf("Did you reconfigure the kernel with \"options USER_LDT\"?\n");
270         }
271     }
272 #endif  /* __NetBSD__ || __FreeBSD__ || __OpenBSD__ || __DragonFly__ */
273
274 #if defined(__svr4__)
275     {
276         struct ssd ssd;
277         ssd.sel = LDT_SEL(TEB_SEL_IDX);
278         ssd.bo = array.base_addr;
279         ssd.ls = array.limit - array.base_addr;
280         ssd.acc1 = ((array.read_exec_only == 0) << 1) |
281             (array.contents << 2) |
282             0xf0;   /* P(resent) | DPL3 | S */
283         ssd.acc2 = 0x4;   /* byte limit, 32-bit segment */
284         if (sysi86(SI86DSCR, &ssd) < 0) {
285             perror("sysi86(SI86DSCR)");
286             printf("Couldn't install fs segment, expect segfault\n");
287         }
288     }
289 #endif
290
291     Setup_FS_Segment();
292
293     ldt_fs->prev_struct = (char*)malloc(sizeof(char) * 8);
294     *(void**)array.base_addr = ldt_fs->prev_struct;
295
296     return ldt_fs;
297 }
298
299 void Restore_LDT_Keeper(ldt_fs_t* ldt_fs)
300 {
301     if (ldt_fs == NULL || ldt_fs->fs_seg == NULL)
302         return;
303     free(ldt_fs->prev_struct);
304     munmap((char*)ldt_fs->fs_seg, getpagesize());
305     ldt_fs->fs_seg = 0;
306     close(ldt_fs->fd);
307     free(ldt_fs);
308 }