mirror of https://github.com/Qortal/Brooklyn
You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
378 lines
8.7 KiB
378 lines
8.7 KiB
/* |
|
* Copyright (C) 2001 - 2007 Jeff Dike (jdike@{addtoit,linux.intel}.com) |
|
* Licensed under the GPL |
|
*/ |
|
|
|
#include <linux/mm.h> |
|
#include <linux/sched.h> |
|
#include <linux/slab.h> |
|
#include <linux/syscalls.h> |
|
#include <linux/uaccess.h> |
|
#include <asm/unistd.h> |
|
#include <os.h> |
|
#include <skas.h> |
|
#include <sysdep/tls.h> |
|
|
|
static inline int modify_ldt (int func, void *ptr, unsigned long bytecount) |
|
{ |
|
return syscall(__NR_modify_ldt, func, ptr, bytecount); |
|
} |
|
|
|
static long write_ldt_entry(struct mm_id *mm_idp, int func, |
|
struct user_desc *desc, void **addr, int done) |
|
{ |
|
long res; |
|
void *stub_addr; |
|
res = syscall_stub_data(mm_idp, (unsigned long *)desc, |
|
(sizeof(*desc) + sizeof(long) - 1) & |
|
~(sizeof(long) - 1), |
|
addr, &stub_addr); |
|
if (!res) { |
|
unsigned long args[] = { func, |
|
(unsigned long)stub_addr, |
|
sizeof(*desc), |
|
0, 0, 0 }; |
|
res = run_syscall_stub(mm_idp, __NR_modify_ldt, args, |
|
0, addr, done); |
|
} |
|
|
|
return res; |
|
} |
|
|
|
/* |
|
* In skas mode, we hold our own ldt data in UML. |
|
* Thus, the code implementing sys_modify_ldt_skas |
|
* is very similar to (and mostly stolen from) sys_modify_ldt |
|
* for arch/i386/kernel/ldt.c |
|
* The routines copied and modified in part are: |
|
* - read_ldt |
|
* - read_default_ldt |
|
* - write_ldt |
|
* - sys_modify_ldt_skas |
|
*/ |
|
|
|
static int read_ldt(void __user * ptr, unsigned long bytecount) |
|
{ |
|
int i, err = 0; |
|
unsigned long size; |
|
uml_ldt_t *ldt = ¤t->mm->context.arch.ldt; |
|
|
|
if (!ldt->entry_count) |
|
goto out; |
|
if (bytecount > LDT_ENTRY_SIZE*LDT_ENTRIES) |
|
bytecount = LDT_ENTRY_SIZE*LDT_ENTRIES; |
|
err = bytecount; |
|
|
|
mutex_lock(&ldt->lock); |
|
if (ldt->entry_count <= LDT_DIRECT_ENTRIES) { |
|
size = LDT_ENTRY_SIZE*LDT_DIRECT_ENTRIES; |
|
if (size > bytecount) |
|
size = bytecount; |
|
if (copy_to_user(ptr, ldt->u.entries, size)) |
|
err = -EFAULT; |
|
bytecount -= size; |
|
ptr += size; |
|
} |
|
else { |
|
for (i=0; i<ldt->entry_count/LDT_ENTRIES_PER_PAGE && bytecount; |
|
i++) { |
|
size = PAGE_SIZE; |
|
if (size > bytecount) |
|
size = bytecount; |
|
if (copy_to_user(ptr, ldt->u.pages[i], size)) { |
|
err = -EFAULT; |
|
break; |
|
} |
|
bytecount -= size; |
|
ptr += size; |
|
} |
|
} |
|
mutex_unlock(&ldt->lock); |
|
|
|
if (bytecount == 0 || err == -EFAULT) |
|
goto out; |
|
|
|
if (clear_user(ptr, bytecount)) |
|
err = -EFAULT; |
|
|
|
out: |
|
return err; |
|
} |
|
|
|
static int read_default_ldt(void __user * ptr, unsigned long bytecount) |
|
{ |
|
int err; |
|
|
|
if (bytecount > 5*LDT_ENTRY_SIZE) |
|
bytecount = 5*LDT_ENTRY_SIZE; |
|
|
|
err = bytecount; |
|
/* |
|
* UML doesn't support lcall7 and lcall27. |
|
* So, we don't really have a default ldt, but emulate |
|
* an empty ldt of common host default ldt size. |
|
*/ |
|
if (clear_user(ptr, bytecount)) |
|
err = -EFAULT; |
|
|
|
return err; |
|
} |
|
|
|
static int write_ldt(void __user * ptr, unsigned long bytecount, int func) |
|
{ |
|
uml_ldt_t *ldt = ¤t->mm->context.arch.ldt; |
|
struct mm_id * mm_idp = ¤t->mm->context.id; |
|
int i, err; |
|
struct user_desc ldt_info; |
|
struct ldt_entry entry0, *ldt_p; |
|
void *addr = NULL; |
|
|
|
err = -EINVAL; |
|
if (bytecount != sizeof(ldt_info)) |
|
goto out; |
|
err = -EFAULT; |
|
if (copy_from_user(&ldt_info, ptr, sizeof(ldt_info))) |
|
goto out; |
|
|
|
err = -EINVAL; |
|
if (ldt_info.entry_number >= LDT_ENTRIES) |
|
goto out; |
|
if (ldt_info.contents == 3) { |
|
if (func == 1) |
|
goto out; |
|
if (ldt_info.seg_not_present == 0) |
|
goto out; |
|
} |
|
|
|
mutex_lock(&ldt->lock); |
|
|
|
err = write_ldt_entry(mm_idp, func, &ldt_info, &addr, 1); |
|
if (err) |
|
goto out_unlock; |
|
|
|
if (ldt_info.entry_number >= ldt->entry_count && |
|
ldt_info.entry_number >= LDT_DIRECT_ENTRIES) { |
|
for (i=ldt->entry_count/LDT_ENTRIES_PER_PAGE; |
|
i*LDT_ENTRIES_PER_PAGE <= ldt_info.entry_number; |
|
i++) { |
|
if (i == 0) |
|
memcpy(&entry0, ldt->u.entries, |
|
sizeof(entry0)); |
|
ldt->u.pages[i] = (struct ldt_entry *) |
|
__get_free_page(GFP_KERNEL|__GFP_ZERO); |
|
if (!ldt->u.pages[i]) { |
|
err = -ENOMEM; |
|
/* Undo the change in host */ |
|
memset(&ldt_info, 0, sizeof(ldt_info)); |
|
write_ldt_entry(mm_idp, 1, &ldt_info, &addr, 1); |
|
goto out_unlock; |
|
} |
|
if (i == 0) { |
|
memcpy(ldt->u.pages[0], &entry0, |
|
sizeof(entry0)); |
|
memcpy(ldt->u.pages[0]+1, ldt->u.entries+1, |
|
sizeof(entry0)*(LDT_DIRECT_ENTRIES-1)); |
|
} |
|
ldt->entry_count = (i + 1) * LDT_ENTRIES_PER_PAGE; |
|
} |
|
} |
|
if (ldt->entry_count <= ldt_info.entry_number) |
|
ldt->entry_count = ldt_info.entry_number + 1; |
|
|
|
if (ldt->entry_count <= LDT_DIRECT_ENTRIES) |
|
ldt_p = ldt->u.entries + ldt_info.entry_number; |
|
else |
|
ldt_p = ldt->u.pages[ldt_info.entry_number/LDT_ENTRIES_PER_PAGE] + |
|
ldt_info.entry_number%LDT_ENTRIES_PER_PAGE; |
|
|
|
if (ldt_info.base_addr == 0 && ldt_info.limit == 0 && |
|
(func == 1 || LDT_empty(&ldt_info))) { |
|
ldt_p->a = 0; |
|
ldt_p->b = 0; |
|
} |
|
else{ |
|
if (func == 1) |
|
ldt_info.useable = 0; |
|
ldt_p->a = LDT_entry_a(&ldt_info); |
|
ldt_p->b = LDT_entry_b(&ldt_info); |
|
} |
|
err = 0; |
|
|
|
out_unlock: |
|
mutex_unlock(&ldt->lock); |
|
out: |
|
return err; |
|
} |
|
|
|
static long do_modify_ldt_skas(int func, void __user *ptr, |
|
unsigned long bytecount) |
|
{ |
|
int ret = -ENOSYS; |
|
|
|
switch (func) { |
|
case 0: |
|
ret = read_ldt(ptr, bytecount); |
|
break; |
|
case 1: |
|
case 0x11: |
|
ret = write_ldt(ptr, bytecount, func); |
|
break; |
|
case 2: |
|
ret = read_default_ldt(ptr, bytecount); |
|
break; |
|
} |
|
return ret; |
|
} |
|
|
|
static DEFINE_SPINLOCK(host_ldt_lock); |
|
static short dummy_list[9] = {0, -1}; |
|
static short * host_ldt_entries = NULL; |
|
|
|
static void ldt_get_host_info(void) |
|
{ |
|
long ret; |
|
struct ldt_entry * ldt; |
|
short *tmp; |
|
int i, size, k, order; |
|
|
|
spin_lock(&host_ldt_lock); |
|
|
|
if (host_ldt_entries != NULL) { |
|
spin_unlock(&host_ldt_lock); |
|
return; |
|
} |
|
host_ldt_entries = dummy_list+1; |
|
|
|
spin_unlock(&host_ldt_lock); |
|
|
|
for (i = LDT_PAGES_MAX-1, order=0; i; i>>=1, order++) |
|
; |
|
|
|
ldt = (struct ldt_entry *) |
|
__get_free_pages(GFP_KERNEL|__GFP_ZERO, order); |
|
if (ldt == NULL) { |
|
printk(KERN_ERR "ldt_get_host_info: couldn't allocate buffer " |
|
"for host ldt\n"); |
|
return; |
|
} |
|
|
|
ret = modify_ldt(0, ldt, (1<<order)*PAGE_SIZE); |
|
if (ret < 0) { |
|
printk(KERN_ERR "ldt_get_host_info: couldn't read host ldt\n"); |
|
goto out_free; |
|
} |
|
if (ret == 0) { |
|
/* default_ldt is active, simply write an empty entry 0 */ |
|
host_ldt_entries = dummy_list; |
|
goto out_free; |
|
} |
|
|
|
for (i=0, size=0; i<ret/LDT_ENTRY_SIZE; i++) { |
|
if (ldt[i].a != 0 || ldt[i].b != 0) |
|
size++; |
|
} |
|
|
|
if (size < ARRAY_SIZE(dummy_list)) |
|
host_ldt_entries = dummy_list; |
|
else { |
|
size = (size + 1) * sizeof(dummy_list[0]); |
|
tmp = kmalloc(size, GFP_KERNEL); |
|
if (tmp == NULL) { |
|
printk(KERN_ERR "ldt_get_host_info: couldn't allocate " |
|
"host ldt list\n"); |
|
goto out_free; |
|
} |
|
host_ldt_entries = tmp; |
|
} |
|
|
|
for (i=0, k=0; i<ret/LDT_ENTRY_SIZE; i++) { |
|
if (ldt[i].a != 0 || ldt[i].b != 0) |
|
host_ldt_entries[k++] = i; |
|
} |
|
host_ldt_entries[k] = -1; |
|
|
|
out_free: |
|
free_pages((unsigned long)ldt, order); |
|
} |
|
|
|
long init_new_ldt(struct mm_context *new_mm, struct mm_context *from_mm) |
|
{ |
|
struct user_desc desc; |
|
short * num_p; |
|
int i; |
|
long page, err=0; |
|
void *addr = NULL; |
|
|
|
|
|
mutex_init(&new_mm->arch.ldt.lock); |
|
|
|
if (!from_mm) { |
|
memset(&desc, 0, sizeof(desc)); |
|
/* |
|
* Now we try to retrieve info about the ldt, we |
|
* inherited from the host. All ldt-entries found |
|
* will be reset in the following loop |
|
*/ |
|
ldt_get_host_info(); |
|
for (num_p=host_ldt_entries; *num_p != -1; num_p++) { |
|
desc.entry_number = *num_p; |
|
err = write_ldt_entry(&new_mm->id, 1, &desc, |
|
&addr, *(num_p + 1) == -1); |
|
if (err) |
|
break; |
|
} |
|
new_mm->arch.ldt.entry_count = 0; |
|
|
|
goto out; |
|
} |
|
|
|
/* |
|
* Our local LDT is used to supply the data for |
|
* modify_ldt(READLDT), if PTRACE_LDT isn't available, |
|
* i.e., we have to use the stub for modify_ldt, which |
|
* can't handle the big read buffer of up to 64kB. |
|
*/ |
|
mutex_lock(&from_mm->arch.ldt.lock); |
|
if (from_mm->arch.ldt.entry_count <= LDT_DIRECT_ENTRIES) |
|
memcpy(new_mm->arch.ldt.u.entries, from_mm->arch.ldt.u.entries, |
|
sizeof(new_mm->arch.ldt.u.entries)); |
|
else { |
|
i = from_mm->arch.ldt.entry_count / LDT_ENTRIES_PER_PAGE; |
|
while (i-->0) { |
|
page = __get_free_page(GFP_KERNEL|__GFP_ZERO); |
|
if (!page) { |
|
err = -ENOMEM; |
|
break; |
|
} |
|
new_mm->arch.ldt.u.pages[i] = |
|
(struct ldt_entry *) page; |
|
memcpy(new_mm->arch.ldt.u.pages[i], |
|
from_mm->arch.ldt.u.pages[i], PAGE_SIZE); |
|
} |
|
} |
|
new_mm->arch.ldt.entry_count = from_mm->arch.ldt.entry_count; |
|
mutex_unlock(&from_mm->arch.ldt.lock); |
|
|
|
out: |
|
return err; |
|
} |
|
|
|
|
|
void free_ldt(struct mm_context *mm) |
|
{ |
|
int i; |
|
|
|
if (mm->arch.ldt.entry_count > LDT_DIRECT_ENTRIES) { |
|
i = mm->arch.ldt.entry_count / LDT_ENTRIES_PER_PAGE; |
|
while (i-- > 0) |
|
free_page((long) mm->arch.ldt.u.pages[i]); |
|
} |
|
mm->arch.ldt.entry_count = 0; |
|
} |
|
|
|
SYSCALL_DEFINE3(modify_ldt, int , func , void __user * , ptr , |
|
unsigned long , bytecount) |
|
{ |
|
/* See non-um modify_ldt() for why we do this cast */ |
|
return (unsigned int)do_modify_ldt_skas(func, ptr, bytecount); |
|
}
|
|
|