2 * Copyright (C) 1992 Krishna Balasubramanian and Linus Torvalds
3 * Copyright (C) 1999 Ingo Molnar <mingo@redhat.com>
4 * Copyright (C) 2002 Andi Kleen
6 * This handles calls from both 32bit and 64bit mode.
9 #include <linux/errno.h>
10 #include <linux/sched.h>
11 #include <linux/string.h>
13 #include <linux/smp.h>
14 #include <linux/vmalloc.h>
16 #include <asm/uaccess.h>
17 #include <asm/system.h>
20 #include <asm/mmu_context.h>
23 static void flush_ldt(void *null
)
25 if (current
->active_mm
)
26 load_LDT(¤t
->active_mm
->context
);
30 static int alloc_ldt(mm_context_t
*pc
, int mincount
, int reload
)
32 void *oldldt
, *newldt
;
35 if (mincount
<= pc
->size
)
38 mincount
= (mincount
+ 511) & (~511);
39 if (mincount
* LDT_ENTRY_SIZE
> PAGE_SIZE
)
40 newldt
= vmalloc(mincount
* LDT_ENTRY_SIZE
);
42 newldt
= (void *)__get_free_page(GFP_KERNEL
);
48 memcpy(newldt
, pc
->ldt
, oldsize
* LDT_ENTRY_SIZE
);
50 memset(newldt
+ oldsize
* LDT_ENTRY_SIZE
, 0,
51 (mincount
- oldsize
) * LDT_ENTRY_SIZE
);
54 /* CHECKME: Do we really need this ? */
68 mask
= cpumask_of_cpu(smp_processor_id());
69 if (!cpus_equal(current
->mm
->cpu_vm_mask
, mask
))
70 smp_call_function(flush_ldt
, NULL
, 1, 1);
77 if (oldsize
* LDT_ENTRY_SIZE
> PAGE_SIZE
)
80 put_page(virt_to_page(oldldt
));
85 static inline int copy_ldt(mm_context_t
*new, mm_context_t
*old
)
87 int err
= alloc_ldt(new, old
->size
, 0);
91 memcpy(new->ldt
, old
->ldt
, old
->size
* LDT_ENTRY_SIZE
);
96 * we do not have to muck with descriptors here, that is
97 * done in switch_mm() as needed.
99 int init_new_context(struct task_struct
*tsk
, struct mm_struct
*mm
)
101 struct mm_struct
*old_mm
;
104 mutex_init(&mm
->context
.lock
);
105 mm
->context
.size
= 0;
106 old_mm
= current
->mm
;
107 if (old_mm
&& old_mm
->context
.size
> 0) {
108 mutex_lock(&old_mm
->context
.lock
);
109 retval
= copy_ldt(&mm
->context
, &old_mm
->context
);
110 mutex_unlock(&old_mm
->context
.lock
);
116 * No need to lock the MM as we are the last user
118 * 64bit: Don't touch the LDT register - we're already in the next thread.
120 void destroy_context(struct mm_struct
*mm
)
122 if (mm
->context
.size
) {
124 /* CHECKME: Can this ever happen ? */
125 if (mm
== current
->active_mm
)
128 if (mm
->context
.size
* LDT_ENTRY_SIZE
> PAGE_SIZE
)
129 vfree(mm
->context
.ldt
);
131 put_page(virt_to_page(mm
->context
.ldt
));
132 mm
->context
.size
= 0;
136 static int read_ldt(void __user
*ptr
, unsigned long bytecount
)
140 struct mm_struct
*mm
= current
->mm
;
142 if (!mm
->context
.size
)
144 if (bytecount
> LDT_ENTRY_SIZE
* LDT_ENTRIES
)
145 bytecount
= LDT_ENTRY_SIZE
* LDT_ENTRIES
;
147 mutex_lock(&mm
->context
.lock
);
148 size
= mm
->context
.size
* LDT_ENTRY_SIZE
;
149 if (size
> bytecount
)
153 if (copy_to_user(ptr
, mm
->context
.ldt
, size
))
155 mutex_unlock(&mm
->context
.lock
);
158 if (size
!= bytecount
) {
159 /* zero-fill the rest */
160 if (clear_user(ptr
+ size
, bytecount
- size
) != 0) {
170 static int read_default_ldt(void __user
*ptr
, unsigned long bytecount
)
172 /* CHECKME: Can we use _one_ random number ? */
174 unsigned long size
= 5 * sizeof(struct desc_struct
);
176 unsigned long size
= 128;
178 if (bytecount
> size
)
180 if (clear_user(ptr
, bytecount
))
185 static int write_ldt(void __user
*ptr
, unsigned long bytecount
, int oldmode
)
187 struct mm_struct
*mm
= current
->mm
;
188 struct desc_struct ldt
;
190 struct user_desc ldt_info
;
193 if (bytecount
!= sizeof(ldt_info
))
196 if (copy_from_user(&ldt_info
, ptr
, sizeof(ldt_info
)))
200 if (ldt_info
.entry_number
>= LDT_ENTRIES
)
202 if (ldt_info
.contents
== 3) {
205 if (ldt_info
.seg_not_present
== 0)
209 mutex_lock(&mm
->context
.lock
);
210 if (ldt_info
.entry_number
>= mm
->context
.size
) {
211 error
= alloc_ldt(¤t
->mm
->context
,
212 ldt_info
.entry_number
+ 1, 1);
217 /* Allow LDTs to be cleared by the user. */
218 if (ldt_info
.base_addr
== 0 && ldt_info
.limit
== 0) {
219 if (oldmode
|| LDT_empty(&ldt_info
)) {
220 memset(&ldt
, 0, sizeof(ldt
));
225 fill_ldt(&ldt
, &ldt_info
);
229 /* Install the new entry ... */
231 write_ldt_entry(mm
->context
.ldt
, ldt_info
.entry_number
, &ldt
);
235 mutex_unlock(&mm
->context
.lock
);
240 asmlinkage
int sys_modify_ldt(int func
, void __user
*ptr
,
241 unsigned long bytecount
)
247 ret
= read_ldt(ptr
, bytecount
);
250 ret
= write_ldt(ptr
, bytecount
, 1);
253 ret
= read_default_ldt(ptr
, bytecount
);
256 ret
= write_ldt(ptr
, bytecount
, 0);
This page took 0.043601 seconds and 5 git commands to generate.