| /* |
| * 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); |
| } |