2 * Copyright (C) 2001, 2002 Jeff Dike (jdike@karaya.com)
3 * Licensed under the GPL
6 #include "linux/stddef.h"
7 #include "linux/config.h"
8 #include "linux/sched.h"
9 #include "linux/slab.h"
10 #include "linux/types.h"
11 #include "linux/errno.h"
12 #include "asm/uaccess.h"
15 #include "asm/unistd.h"
16 #include "choose-mode.h"
18 #include "mode_kern.h"
20 extern int modify_ldt(int func
, void *ptr
, unsigned long bytecount
);
24 static long do_modify_ldt_tt(int func
, void __user
*ptr
,
25 unsigned long bytecount
)
27 struct user_desc info
;
30 void *p
= NULL
; /* What we pass to host. */
34 case 0x11: /* write_ldt */
35 /* Do this check now to avoid overflows. */
36 if (bytecount
!= sizeof(struct user_desc
)) {
41 if(copy_from_user(&info
, ptr
, sizeof(info
))) {
49 case 2: /* read_ldt */
51 /* The use of info avoids kmalloc on the write case, not on the
53 buf
= kmalloc(bytecount
, GFP_KERNEL
);
65 res
= modify_ldt(func
, p
, bytecount
);
72 /* Modify_ldt was for reading and returned the number of read
74 if(copy_to_user(ptr
, p
, res
))
86 #ifdef CONFIG_MODE_SKAS
89 #include "skas_ptrace.h"
90 #include "asm/mmu_context.h"
92 long write_ldt_entry(struct mm_id
* mm_idp
, int func
, struct user_desc
* desc
,
93 void **addr
, int done
)
98 /* This is a special handling for the case, that the mm to
99 * modify isn't current->active_mm.
100 * If this is called directly by modify_ldt,
101 * (current->active_mm->context.skas.u == mm_idp)
102 * will be true. So no call to switch_mm_skas(mm_idp) is done.
103 * If this is called in case of init_new_ldt or PTRACE_LDT,
104 * mm_idp won't belong to current->active_mm, but child->mm.
105 * So we need to switch child's mm into our userspace, then
108 * Note: I'm unshure: should interrupts be disabled here?
110 if(!current
->active_mm
|| current
->active_mm
== &init_mm
||
111 mm_idp
!= ¤t
->active_mm
->context
.skas
.id
)
112 switch_mm_skas(mm_idp
);
116 struct ptrace_ldt ldt_op
= (struct ptrace_ldt
) {
119 .bytecount
= sizeof(*desc
)};
127 pid
= userspace_pid
[cpu
];
130 res
= ptrace(PTRACE_LDT
, pid
, 0, (unsigned long) &ldt_op
);
139 res
= syscall_stub_data(mm_idp
, (unsigned long *)desc
,
140 (sizeof(*desc
) + sizeof(long) - 1) &
144 unsigned long args
[] = { func
,
145 (unsigned long)stub_addr
,
148 res
= run_syscall_stub(mm_idp
, __NR_modify_ldt
, args
,
154 /* This is the second part of special handling, that makes
155 * PTRACE_LDT possible to implement.
157 if(current
->active_mm
&& current
->active_mm
!= &init_mm
&&
158 mm_idp
!= ¤t
->active_mm
->context
.skas
.id
)
159 switch_mm_skas(¤t
->active_mm
->context
.skas
.id
);
165 static long read_ldt_from_host(void __user
* ptr
, unsigned long bytecount
)
168 struct ptrace_ldt ptrace_ldt
= (struct ptrace_ldt
) {
170 .bytecount
= bytecount
,
171 .ptr
= (void *)kmalloc(bytecount
, GFP_KERNEL
)};
174 if(ptrace_ldt
.ptr
== NULL
)
177 /* This is called from sys_modify_ldt only, so userspace_pid gives
178 * us the right number
182 res
= ptrace(PTRACE_LDT
, userspace_pid
[cpu
], 0,
183 (unsigned long) &ptrace_ldt
);
188 n
= copy_to_user(ptr
, ptrace_ldt
.ptr
, res
);
193 kfree(ptrace_ldt
.ptr
);
199 * In skas mode, we hold our own ldt data in UML.
200 * Thus, the code implementing sys_modify_ldt_skas
201 * is very similar to (and mostly stolen from) sys_modify_ldt
202 * for arch/i386/kernel/ldt.c
203 * The routines copied and modified in part are:
207 * - sys_modify_ldt_skas
210 static int read_ldt(void __user
* ptr
, unsigned long bytecount
)
214 uml_ldt_t
* ldt
= ¤t
->mm
->context
.skas
.ldt
;
216 if(!ldt
->entry_count
)
218 if(bytecount
> LDT_ENTRY_SIZE
*LDT_ENTRIES
)
219 bytecount
= LDT_ENTRY_SIZE
*LDT_ENTRIES
;
223 return read_ldt_from_host(ptr
, bytecount
);
226 down(&ldt
->semaphore
);
227 if(ldt
->entry_count
<= LDT_DIRECT_ENTRIES
){
228 size
= LDT_ENTRY_SIZE
*LDT_DIRECT_ENTRIES
;
231 if(copy_to_user(ptr
, ldt
->u
.entries
, size
))
237 for(i
=0; i
<ldt
->entry_count
/LDT_ENTRIES_PER_PAGE
&& bytecount
;
242 if(copy_to_user(ptr
, ldt
->u
.pages
[i
], size
)){
252 if(bytecount
== 0 || err
== -EFAULT
)
255 if(clear_user(ptr
, bytecount
))
262 static int read_default_ldt(void __user
* ptr
, unsigned long bytecount
)
266 if(bytecount
> 5*LDT_ENTRY_SIZE
)
267 bytecount
= 5*LDT_ENTRY_SIZE
;
270 /* UML doesn't support lcall7 and lcall27.
271 * So, we don't really have a default ldt, but emulate
272 * an empty ldt of common host default ldt size.
274 if(clear_user(ptr
, bytecount
))
280 static int write_ldt(void __user
* ptr
, unsigned long bytecount
, int func
)
282 uml_ldt_t
* ldt
= ¤t
->mm
->context
.skas
.ldt
;
283 struct mm_id
* mm_idp
= ¤t
->mm
->context
.skas
.id
;
285 struct user_desc ldt_info
;
286 struct ldt_entry entry0
, *ldt_p
;
290 if(bytecount
!= sizeof(ldt_info
))
293 if(copy_from_user(&ldt_info
, ptr
, sizeof(ldt_info
)))
297 if(ldt_info
.entry_number
>= LDT_ENTRIES
)
299 if(ldt_info
.contents
== 3){
302 if (ldt_info
.seg_not_present
== 0)
307 down(&ldt
->semaphore
);
309 err
= write_ldt_entry(mm_idp
, func
, &ldt_info
, &addr
, 1);
312 else if(ptrace_ldt
) {
313 /* With PTRACE_LDT available, this is used as a flag only */
314 ldt
->entry_count
= 1;
318 if(ldt_info
.entry_number
>= ldt
->entry_count
&&
319 ldt_info
.entry_number
>= LDT_DIRECT_ENTRIES
){
320 for(i
=ldt
->entry_count
/LDT_ENTRIES_PER_PAGE
;
321 i
*LDT_ENTRIES_PER_PAGE
<= ldt_info
.entry_number
;
324 memcpy(&entry0
, ldt
->u
.entries
,
326 ldt
->u
.pages
[i
] = (struct ldt_entry
*)
327 __get_free_page(GFP_KERNEL
|__GFP_ZERO
);
328 if(!ldt
->u
.pages
[i
]){
330 /* Undo the change in host */
331 memset(&ldt_info
, 0, sizeof(ldt_info
));
332 write_ldt_entry(mm_idp
, 1, &ldt_info
, &addr
, 1);
336 memcpy(ldt
->u
.pages
[0], &entry0
,
338 memcpy(ldt
->u
.pages
[0]+1, ldt
->u
.entries
+1,
339 sizeof(entry0
)*(LDT_DIRECT_ENTRIES
-1));
341 ldt
->entry_count
= (i
+ 1) * LDT_ENTRIES_PER_PAGE
;
344 if(ldt
->entry_count
<= ldt_info
.entry_number
)
345 ldt
->entry_count
= ldt_info
.entry_number
+ 1;
347 if(ldt
->entry_count
<= LDT_DIRECT_ENTRIES
)
348 ldt_p
= ldt
->u
.entries
+ ldt_info
.entry_number
;
350 ldt_p
= ldt
->u
.pages
[ldt_info
.entry_number
/LDT_ENTRIES_PER_PAGE
] +
351 ldt_info
.entry_number
%LDT_ENTRIES_PER_PAGE
;
353 if(ldt_info
.base_addr
== 0 && ldt_info
.limit
== 0 &&
354 (func
== 1 || LDT_empty(&ldt_info
))){
360 ldt_info
.useable
= 0;
361 ldt_p
->a
= LDT_entry_a(&ldt_info
);
362 ldt_p
->b
= LDT_entry_b(&ldt_info
);
372 static long do_modify_ldt_skas(int func
, void __user
*ptr
,
373 unsigned long bytecount
)
379 ret
= read_ldt(ptr
, bytecount
);
383 ret
= write_ldt(ptr
, bytecount
, func
);
386 ret
= read_default_ldt(ptr
, bytecount
);
392 short dummy_list
[9] = {0, -1};
393 short * host_ldt_entries
= NULL
;
395 void ldt_get_host_info(void)
398 struct ldt_entry
* ldt
;
399 int i
, size
, k
, order
;
401 host_ldt_entries
= dummy_list
+1;
403 for(i
= LDT_PAGES_MAX
-1, order
=0; i
; i
>>=1, order
++);
405 ldt
= (struct ldt_entry
*)
406 __get_free_pages(GFP_KERNEL
|__GFP_ZERO
, order
);
408 printk("ldt_get_host_info: couldn't allocate buffer for host ldt\n");
412 ret
= modify_ldt(0, ldt
, (1<<order
)*PAGE_SIZE
);
414 printk("ldt_get_host_info: couldn't read host ldt\n");
418 /* default_ldt is active, simply write an empty entry 0 */
419 host_ldt_entries
= dummy_list
;
423 for(i
=0, size
=0; i
<ret
/LDT_ENTRY_SIZE
; i
++){
424 if(ldt
[i
].a
!= 0 || ldt
[i
].b
!= 0)
428 if(size
< sizeof(dummy_list
)/sizeof(dummy_list
[0])) {
429 host_ldt_entries
= dummy_list
;
432 size
= (size
+ 1) * sizeof(dummy_list
[0]);
433 host_ldt_entries
= (short *)kmalloc(size
, GFP_KERNEL
);
434 if(host_ldt_entries
== NULL
) {
435 printk("ldt_get_host_info: couldn't allocate host ldt list\n");
440 for(i
=0, k
=0; i
<ret
/LDT_ENTRY_SIZE
; i
++){
441 if(ldt
[i
].a
!= 0 || ldt
[i
].b
!= 0) {
442 host_ldt_entries
[k
++] = i
;
445 host_ldt_entries
[k
] = -1;
448 free_pages((unsigned long)ldt
, order
);
451 long init_new_ldt(struct mmu_context_skas
* new_mm
,
452 struct mmu_context_skas
* from_mm
)
454 struct user_desc desc
;
460 memset(&desc
, 0, sizeof(desc
));
463 init_MUTEX(&new_mm
->ldt
.semaphore
);
467 * We have to initialize a clean ldt.
471 * If the new mm was created using proc_mm, host's
472 * default-ldt currently is assigned, which normally
473 * contains the call-gates for lcall7 and lcall27.
474 * To remove these gates, we simply write an empty
475 * entry as number 0 to the host.
477 err
= write_ldt_entry(&new_mm
->id
, 1, &desc
,
482 * Now we try to retrieve info about the ldt, we
483 * inherited from the host. All ldt-entries found
484 * will be reset in the following loop
486 if(host_ldt_entries
== NULL
)
488 for(num_p
=host_ldt_entries
; *num_p
!= -1; num_p
++){
489 desc
.entry_number
= *num_p
;
490 err
= write_ldt_entry(&new_mm
->id
, 1, &desc
,
491 &addr
, *(num_p
+ 1) == -1);
496 new_mm
->ldt
.entry_count
= 0;
498 else if (!ptrace_ldt
) {
499 /* Our local LDT is used to supply the data for
500 * modify_ldt(READLDT), if PTRACE_LDT isn't available,
501 * i.e., we have to use the stub for modify_ldt, which
502 * can't handle the big read buffer of up to 64kB.
504 down(&from_mm
->ldt
.semaphore
);
505 if(from_mm
->ldt
.entry_count
<= LDT_DIRECT_ENTRIES
){
506 memcpy(new_mm
->ldt
.u
.entries
, from_mm
->ldt
.u
.entries
,
507 sizeof(new_mm
->ldt
.u
.entries
));
510 i
= from_mm
->ldt
.entry_count
/ LDT_ENTRIES_PER_PAGE
;
512 page
= __get_free_page(GFP_KERNEL
|__GFP_ZERO
);
517 new_mm
->ldt
.u
.pages
[i
] =
518 (struct ldt_entry
*) page
;
519 memcpy(new_mm
->ldt
.u
.pages
[i
],
520 from_mm
->ldt
.u
.pages
[i
], PAGE_SIZE
);
523 new_mm
->ldt
.entry_count
= from_mm
->ldt
.entry_count
;
524 up(&from_mm
->ldt
.semaphore
);
531 void free_ldt(struct mmu_context_skas
* mm
)
535 if(!ptrace_ldt
&& mm
->ldt
.entry_count
> LDT_DIRECT_ENTRIES
){
536 i
= mm
->ldt
.entry_count
/ LDT_ENTRIES_PER_PAGE
;
538 free_page((long )mm
->ldt
.u
.pages
[i
]);
541 mm
->ldt
.entry_count
= 0;
545 int sys_modify_ldt(int func
, void __user
*ptr
, unsigned long bytecount
)
547 return(CHOOSE_MODE_PROC(do_modify_ldt_tt
, do_modify_ldt_skas
, func
,