2 * LDT manipulation functions
4 * Copyright 1993 Robert J. Amstadt
5 * Copyright 1995 Alexandre Julliard
18 #include <sys/syscall.h>
22 unsigned int entry_number
;
23 unsigned long base_addr
;
25 unsigned int seg_32bit
: 1;
26 unsigned int contents
: 2;
27 unsigned int read_exec_only
: 1;
28 unsigned int limit_in_pages
: 1;
29 unsigned int seg_not_present
: 1;
32 static __inline__
int modify_ldt( int func
, struct modify_ldt_s
*ptr
,
37 __asm__
__volatile__( "pushl %%ebx\n\t"
42 : "0" (SYS_modify_ldt
),
47 __asm__
__volatile__("int $0x80"
49 : "0" (SYS_modify_ldt
),
54 if (res
>= 0) return res
;
61 #if defined(__svr4__) || defined(_SCO_DS)
62 #include <sys/sysi86.h>
68 #if defined(__NetBSD__) || defined(__FreeBSD__) || defined(__OpenBSD__)
69 #include <machine/segments.h>
71 extern int i386_get_ldt(int, union descriptor
*, int);
72 extern int i386_set_ldt(int, union descriptor
*, int);
73 #endif /* __NetBSD__ || __FreeBSD__ || __OpenBSD__ */
78 ldt_copy_entry ldt_copy
[LDT_SIZE
];
79 unsigned char ldt_flags_copy
[LDT_SIZE
];
82 /***********************************************************************
85 * Convert the raw bytes of the descriptor to an ldt_entry structure.
87 void LDT_BytesToEntry( const unsigned long *buffer
, ldt_entry
*content
)
89 content
->base
= (*buffer
>> 16) & 0x0000ffff;
90 content
->limit
= *buffer
& 0x0000ffff;
92 content
->base
|= (*buffer
& 0xff000000) | ((*buffer
<< 16) & 0x00ff0000);
93 content
->limit
|= (*buffer
& 0x000f0000);
94 content
->type
= (*buffer
>> 10) & 3;
95 content
->seg_32bit
= (*buffer
& 0x00400000) != 0;
96 content
->read_only
= (*buffer
& 0x00000200) == 0;
97 content
->limit_in_pages
= (*buffer
& 0x00800000) != 0;
101 /***********************************************************************
104 * Convert an ldt_entry structure to the raw bytes of the descriptor.
106 void LDT_EntryToBytes( unsigned long *buffer
, const ldt_entry
*content
)
108 *buffer
++ = ((content
->base
& 0x0000ffff) << 16) |
109 (content
->limit
& 0x0ffff);
110 *buffer
= (content
->base
& 0xff000000) |
111 ((content
->base
& 0x00ff0000)>>16) |
112 (content
->limit
& 0xf0000) |
113 (content
->type
<< 10) |
114 ((content
->read_only
== 0) << 9) |
115 ((content
->seg_32bit
!= 0) << 22) |
116 ((content
->limit_in_pages
!= 0) << 23) |
121 /***********************************************************************
124 * Retrieve an LDT entry.
126 int LDT_GetEntry( int entry
, ldt_entry
*content
)
130 content
->base
= ldt_copy
[entry
].base
;
131 content
->limit
= ldt_copy
[entry
].limit
;
132 content
->type
= (ldt_flags_copy
[entry
] & LDT_FLAGS_TYPE
);
133 content
->seg_32bit
= (ldt_flags_copy
[entry
] & LDT_FLAGS_32BIT
) != 0;
134 content
->read_only
= (ldt_flags_copy
[entry
] & LDT_FLAGS_READONLY
) !=0;
135 content
->limit_in_pages
= (ldt_flags_copy
[entry
] & LDT_FLAGS_BIG
) !=0;
136 if (content
->limit_in_pages
) content
->limit
>>= 12;
141 /***********************************************************************
146 int LDT_SetEntry( int entry
, const ldt_entry
*content
)
151 "LDT_SetEntry: entry=%04x base=%08lx limit=%05lx %s %d-bit flags=%c%c%c\n",
152 entry
, content
->base
, content
->limit
,
153 content
->limit_in_pages
? "pages" : "bytes",
154 content
->seg_32bit
? 32 : 16,
155 content
->read_only
&& (content
->type
& SEGMENT_CODE
) ? '-' : 'r',
156 content
->read_only
|| (content
->type
& SEGMENT_CODE
) ? '-' : 'w',
157 (content
->type
& SEGMENT_CODE
) ? 'x' : '-' );
159 /* Entry 0 must not be modified; its base and limit are always 0 */
160 if (!entry
) return 0;
166 struct modify_ldt_s ldt_info
;
168 ldt_info
.entry_number
= entry
;
169 ldt_info
.base_addr
= content
->base
;
170 ldt_info
.limit
= content
->limit
;
171 ldt_info
.seg_32bit
= content
->seg_32bit
!= 0;
172 ldt_info
.contents
= content
->type
;
173 ldt_info
.read_exec_only
= content
->read_only
!= 0;
174 ldt_info
.limit_in_pages
= content
->limit_in_pages
!= 0;
175 ldt_info
.seg_not_present
= 0;
176 /* Make sure the info will be accepted by the kernel */
177 /* This is ugly, but what can I do? */
178 if (content
->type
== SEGMENT_STACK
)
184 if (ldt_info
.base_addr
>= 0xc0000000)
186 fprintf( stderr
, "LDT_SetEntry: invalid base addr %08lx\n",
187 ldt_info
.base_addr
);
190 if (content
->limit_in_pages
)
192 if ((ldt_info
.limit
<< 12) + 0xfff >
193 0xc0000000 - ldt_info
.base_addr
)
194 ldt_info
.limit
= (0xc0000000 - 0xfff - ldt_info
.base_addr
) >> 12;
198 if (ldt_info
.limit
> 0xc0000000 - ldt_info
.base_addr
)
199 ldt_info
.limit
= 0xc0000000 - ldt_info
.base_addr
;
202 if ((ret
= modify_ldt(1, &ldt_info
, sizeof(ldt_info
))) < 0)
203 perror( "modify_ldt" );
207 #if defined(__NetBSD__) || defined(__FreeBSD__) || defined(__OpenBSD__)
211 LDT_EntryToBytes( d
, content
);
212 ret
= i386_set_ldt(entry
, (union descriptor
*)d
, 1);
215 perror("i386_set_ldt");
217 "Did you reconfigure the kernel with \"options USER_LDT\"?\n");
221 #endif /* __NetBSD__ || __FreeBSD__ || __OpenBSD__ */
223 #if defined(__svr4__) || defined(_SCO_DS)
227 ldt_mod
.sel
= ENTRY_TO_SELECTOR(entry
) | 4;
228 ldt_mod
.bo
= content
->base
;
229 ldt_mod
.ls
= content
->limit
;
230 i
= ((content
->limit
& 0xf0000) |
231 (content
->type
<< 10) |
232 (((content
->read_only
!= 0) ^ 1) << 9) |
233 ((content
->seg_32bit
!= 0) << 22) |
234 ((content
->limit_in_pages
!= 0)<< 23) |
238 ldt_mod
.acc1
= (i
& 0xff00) >> 8;
239 ldt_mod
.acc2
= (i
& 0xf00000) >> 20;
241 if (content
->base
== 0)
246 if ((ret
= sysi86(SI86DSCR
, &ldt_mod
)) == -1) perror("sysi86");
250 #endif /* __i386__ */
252 if (ret
< 0) return ret
;
253 ldt_copy
[entry
].base
= content
->base
;
254 if (!content
->limit_in_pages
) ldt_copy
[entry
].limit
= content
->limit
;
255 else ldt_copy
[entry
].limit
= (content
->limit
<< 12) | 0x0fff;
256 ldt_flags_copy
[entry
] = (content
->type
& LDT_FLAGS_TYPE
) |
257 (content
->read_only
? LDT_FLAGS_READONLY
: 0) |
258 (content
->seg_32bit
? LDT_FLAGS_32BIT
: 0) |
259 (content
->limit_in_pages
? LDT_FLAGS_BIG
: 0) |
260 (ldt_flags_copy
[entry
] & LDT_FLAGS_ALLOCATED
);
265 /***********************************************************************
268 * Print the content of the LDT on stdout.
270 void LDT_Print( int start
, int length
)
275 if (length
== -1) length
= LDT_SIZE
- start
;
276 for (i
= start
; i
< start
+ length
; i
++)
278 if (!ldt_copy
[i
].base
&& !ldt_copy
[i
].limit
) continue; /* Free entry */
279 if ((ldt_flags_copy
[i
] & LDT_FLAGS_TYPE
) == SEGMENT_CODE
)
281 flags
[0] = (ldt_flags_copy
[i
] & LDT_FLAGS_EXECONLY
) ? '-' : 'r';
288 flags
[1] = (ldt_flags_copy
[i
] & LDT_FLAGS_READONLY
) ? '-' : 'w';
291 fprintf(stderr
,"%04x: sel=%04x base=%08lx limit=%08lx %d-bit %c%c%c\n",
292 i
, ENTRY_TO_SELECTOR(i
),
293 ldt_copy
[i
].base
, ldt_copy
[i
].limit
,
294 ldt_flags_copy
[i
] & LDT_FLAGS_32BIT
? 32 : 16,
295 flags
[0], flags
[1], flags
[2] );