Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 1 | /* |
| 2 | * IA32 helper functions |
| 3 | * |
| 4 | * Copyright (C) 1999 Arun Sharma <arun.sharma@intel.com> |
| 5 | * Copyright (C) 2000 Asit K. Mallick <asit.k.mallick@intel.com> |
| 6 | * Copyright (C) 2001-2002 Hewlett-Packard Co |
| 7 | * David Mosberger-Tang <davidm@hpl.hp.com> |
| 8 | * |
| 9 | * 06/16/00 A. Mallick added csd/ssd/tssd for ia32 thread context |
| 10 | * 02/19/01 D. Mosberger dropped tssd; it's not needed |
| 11 | * 09/14/01 D. Mosberger fixed memory management for gdt/tss page |
| 12 | * 09/29/01 D. Mosberger added ia32_load_segment_descriptors() |
| 13 | */ |
| 14 | |
| 15 | #include <linux/kernel.h> |
| 16 | #include <linux/init.h> |
| 17 | #include <linux/mm.h> |
| 18 | #include <linux/personality.h> |
| 19 | #include <linux/sched.h> |
| 20 | |
| 21 | #include <asm/intrinsics.h> |
| 22 | #include <asm/page.h> |
| 23 | #include <asm/pgtable.h> |
| 24 | #include <asm/system.h> |
| 25 | #include <asm/processor.h> |
| 26 | #include <asm/uaccess.h> |
| 27 | |
| 28 | #include "ia32priv.h" |
| 29 | |
| 30 | extern void die_if_kernel (char *str, struct pt_regs *regs, long err); |
| 31 | |
| 32 | struct exec_domain ia32_exec_domain; |
| 33 | struct page *ia32_shared_page[NR_CPUS]; |
| 34 | unsigned long *ia32_boot_gdt; |
| 35 | unsigned long *cpu_gdt_table[NR_CPUS]; |
| 36 | struct page *ia32_gate_page; |
| 37 | |
| 38 | static unsigned long |
| 39 | load_desc (u16 selector) |
| 40 | { |
| 41 | unsigned long *table, limit, index; |
| 42 | |
| 43 | if (!selector) |
| 44 | return 0; |
| 45 | if (selector & IA32_SEGSEL_TI) { |
| 46 | table = (unsigned long *) IA32_LDT_OFFSET; |
| 47 | limit = IA32_LDT_ENTRIES; |
| 48 | } else { |
| 49 | table = cpu_gdt_table[smp_processor_id()]; |
| 50 | limit = IA32_PAGE_SIZE / sizeof(ia32_boot_gdt[0]); |
| 51 | } |
| 52 | index = selector >> IA32_SEGSEL_INDEX_SHIFT; |
| 53 | if (index >= limit) |
| 54 | return 0; |
| 55 | return IA32_SEG_UNSCRAMBLE(table[index]); |
| 56 | } |
| 57 | |
| 58 | void |
| 59 | ia32_load_segment_descriptors (struct task_struct *task) |
| 60 | { |
| 61 | struct pt_regs *regs = ia64_task_regs(task); |
| 62 | |
| 63 | /* Setup the segment descriptors */ |
| 64 | regs->r24 = load_desc(regs->r16 >> 16); /* ESD */ |
| 65 | regs->r27 = load_desc(regs->r16 >> 0); /* DSD */ |
| 66 | regs->r28 = load_desc(regs->r16 >> 32); /* FSD */ |
| 67 | regs->r29 = load_desc(regs->r16 >> 48); /* GSD */ |
| 68 | regs->ar_csd = load_desc(regs->r17 >> 0); /* CSD */ |
| 69 | regs->ar_ssd = load_desc(regs->r17 >> 16); /* SSD */ |
| 70 | } |
| 71 | |
| 72 | int |
| 73 | ia32_clone_tls (struct task_struct *child, struct pt_regs *childregs) |
| 74 | { |
| 75 | struct desc_struct *desc; |
| 76 | struct ia32_user_desc info; |
| 77 | int idx; |
| 78 | |
| 79 | if (copy_from_user(&info, (void __user *)(childregs->r14 & 0xffffffff), sizeof(info))) |
| 80 | return -EFAULT; |
| 81 | if (LDT_empty(&info)) |
| 82 | return -EINVAL; |
| 83 | |
| 84 | idx = info.entry_number; |
| 85 | if (idx < GDT_ENTRY_TLS_MIN || idx > GDT_ENTRY_TLS_MAX) |
| 86 | return -EINVAL; |
| 87 | |
| 88 | desc = child->thread.tls_array + idx - GDT_ENTRY_TLS_MIN; |
| 89 | desc->a = LDT_entry_a(&info); |
| 90 | desc->b = LDT_entry_b(&info); |
| 91 | |
| 92 | /* XXX: can this be done in a cleaner way ? */ |
| 93 | load_TLS(&child->thread, smp_processor_id()); |
| 94 | ia32_load_segment_descriptors(child); |
| 95 | load_TLS(¤t->thread, smp_processor_id()); |
| 96 | |
| 97 | return 0; |
| 98 | } |
| 99 | |
| 100 | void |
| 101 | ia32_save_state (struct task_struct *t) |
| 102 | { |
| 103 | t->thread.eflag = ia64_getreg(_IA64_REG_AR_EFLAG); |
| 104 | t->thread.fsr = ia64_getreg(_IA64_REG_AR_FSR); |
| 105 | t->thread.fcr = ia64_getreg(_IA64_REG_AR_FCR); |
| 106 | t->thread.fir = ia64_getreg(_IA64_REG_AR_FIR); |
| 107 | t->thread.fdr = ia64_getreg(_IA64_REG_AR_FDR); |
| 108 | ia64_set_kr(IA64_KR_IO_BASE, t->thread.old_iob); |
| 109 | ia64_set_kr(IA64_KR_TSSD, t->thread.old_k1); |
| 110 | } |
| 111 | |
| 112 | void |
| 113 | ia32_load_state (struct task_struct *t) |
| 114 | { |
| 115 | unsigned long eflag, fsr, fcr, fir, fdr, tssd; |
| 116 | struct pt_regs *regs = ia64_task_regs(t); |
| 117 | |
| 118 | eflag = t->thread.eflag; |
| 119 | fsr = t->thread.fsr; |
| 120 | fcr = t->thread.fcr; |
| 121 | fir = t->thread.fir; |
| 122 | fdr = t->thread.fdr; |
| 123 | tssd = load_desc(_TSS); /* TSSD */ |
| 124 | |
| 125 | ia64_setreg(_IA64_REG_AR_EFLAG, eflag); |
| 126 | ia64_setreg(_IA64_REG_AR_FSR, fsr); |
| 127 | ia64_setreg(_IA64_REG_AR_FCR, fcr); |
| 128 | ia64_setreg(_IA64_REG_AR_FIR, fir); |
| 129 | ia64_setreg(_IA64_REG_AR_FDR, fdr); |
| 130 | current->thread.old_iob = ia64_get_kr(IA64_KR_IO_BASE); |
| 131 | current->thread.old_k1 = ia64_get_kr(IA64_KR_TSSD); |
| 132 | ia64_set_kr(IA64_KR_IO_BASE, IA32_IOBASE); |
| 133 | ia64_set_kr(IA64_KR_TSSD, tssd); |
| 134 | |
| 135 | regs->r17 = (_TSS << 48) | (_LDT << 32) | (__u32) regs->r17; |
| 136 | regs->r30 = load_desc(_LDT); /* LDTD */ |
| 137 | load_TLS(&t->thread, smp_processor_id()); |
| 138 | } |
| 139 | |
| 140 | /* |
| 141 | * Setup IA32 GDT and TSS |
| 142 | */ |
| 143 | void |
| 144 | ia32_gdt_init (void) |
| 145 | { |
| 146 | int cpu = smp_processor_id(); |
| 147 | |
| 148 | ia32_shared_page[cpu] = alloc_page(GFP_KERNEL); |
| 149 | if (!ia32_shared_page[cpu]) |
| 150 | panic("failed to allocate ia32_shared_page[%d]\n", cpu); |
| 151 | |
| 152 | cpu_gdt_table[cpu] = page_address(ia32_shared_page[cpu]); |
| 153 | |
| 154 | /* Copy from the boot cpu's GDT */ |
| 155 | memcpy(cpu_gdt_table[cpu], ia32_boot_gdt, PAGE_SIZE); |
| 156 | } |
| 157 | |
| 158 | |
| 159 | /* |
| 160 | * Setup IA32 GDT and TSS |
| 161 | */ |
| 162 | static void |
| 163 | ia32_boot_gdt_init (void) |
| 164 | { |
| 165 | unsigned long ldt_size; |
| 166 | |
| 167 | ia32_shared_page[0] = alloc_page(GFP_KERNEL); |
| 168 | if (!ia32_shared_page[0]) |
| 169 | panic("failed to allocate ia32_shared_page[0]\n"); |
| 170 | |
| 171 | ia32_boot_gdt = page_address(ia32_shared_page[0]); |
| 172 | cpu_gdt_table[0] = ia32_boot_gdt; |
| 173 | |
| 174 | /* CS descriptor in IA-32 (scrambled) format */ |
| 175 | ia32_boot_gdt[__USER_CS >> 3] |
| 176 | = IA32_SEG_DESCRIPTOR(0, (IA32_GATE_END-1) >> IA32_PAGE_SHIFT, |
| 177 | 0xb, 1, 3, 1, 1, 1, 1); |
| 178 | |
| 179 | /* DS descriptor in IA-32 (scrambled) format */ |
| 180 | ia32_boot_gdt[__USER_DS >> 3] |
| 181 | = IA32_SEG_DESCRIPTOR(0, (IA32_GATE_END-1) >> IA32_PAGE_SHIFT, |
| 182 | 0x3, 1, 3, 1, 1, 1, 1); |
| 183 | |
| 184 | ldt_size = PAGE_ALIGN(IA32_LDT_ENTRIES*IA32_LDT_ENTRY_SIZE); |
| 185 | ia32_boot_gdt[TSS_ENTRY] = IA32_SEG_DESCRIPTOR(IA32_TSS_OFFSET, 235, |
| 186 | 0xb, 0, 3, 1, 1, 1, 0); |
| 187 | ia32_boot_gdt[LDT_ENTRY] = IA32_SEG_DESCRIPTOR(IA32_LDT_OFFSET, ldt_size - 1, |
| 188 | 0x2, 0, 3, 1, 1, 1, 0); |
| 189 | } |
| 190 | |
| 191 | static void |
| 192 | ia32_gate_page_init(void) |
| 193 | { |
| 194 | unsigned long *sr; |
| 195 | |
| 196 | ia32_gate_page = alloc_page(GFP_KERNEL); |
| 197 | sr = page_address(ia32_gate_page); |
| 198 | /* This is popl %eax ; movl $,%eax ; int $0x80 */ |
| 199 | *sr++ = 0xb858 | (__IA32_NR_sigreturn << 16) | (0x80cdUL << 48); |
| 200 | |
| 201 | /* This is movl $,%eax ; int $0x80 */ |
| 202 | *sr = 0xb8 | (__IA32_NR_rt_sigreturn << 8) | (0x80cdUL << 40); |
| 203 | } |
| 204 | |
| 205 | void |
| 206 | ia32_mem_init(void) |
| 207 | { |
| 208 | ia32_boot_gdt_init(); |
| 209 | ia32_gate_page_init(); |
| 210 | } |
| 211 | |
| 212 | /* |
| 213 | * Handle bad IA32 interrupt via syscall |
| 214 | */ |
| 215 | void |
| 216 | ia32_bad_interrupt (unsigned long int_num, struct pt_regs *regs) |
| 217 | { |
| 218 | siginfo_t siginfo; |
| 219 | |
| 220 | die_if_kernel("Bad IA-32 interrupt", regs, int_num); |
| 221 | |
| 222 | siginfo.si_signo = SIGTRAP; |
| 223 | siginfo.si_errno = int_num; /* XXX is it OK to abuse si_errno like this? */ |
| 224 | siginfo.si_flags = 0; |
| 225 | siginfo.si_isr = 0; |
| 226 | siginfo.si_addr = NULL; |
| 227 | siginfo.si_imm = 0; |
| 228 | siginfo.si_code = TRAP_BRKPT; |
| 229 | force_sig_info(SIGTRAP, &siginfo, current); |
| 230 | } |
| 231 | |
| 232 | void |
| 233 | ia32_cpu_init (void) |
| 234 | { |
| 235 | /* initialize global ia32 state - CR0 and CR4 */ |
| 236 | ia64_setreg(_IA64_REG_AR_CFLAG, (((ulong) IA32_CR4 << 32) | IA32_CR0)); |
| 237 | } |
| 238 | |
| 239 | static int __init |
| 240 | ia32_init (void) |
| 241 | { |
| 242 | ia32_exec_domain.name = "Linux/x86"; |
| 243 | ia32_exec_domain.handler = NULL; |
| 244 | ia32_exec_domain.pers_low = PER_LINUX32; |
| 245 | ia32_exec_domain.pers_high = PER_LINUX32; |
| 246 | ia32_exec_domain.signal_map = default_exec_domain.signal_map; |
| 247 | ia32_exec_domain.signal_invmap = default_exec_domain.signal_invmap; |
| 248 | register_exec_domain(&ia32_exec_domain); |
| 249 | |
| 250 | #if PAGE_SHIFT > IA32_PAGE_SHIFT |
| 251 | { |
| 252 | extern kmem_cache_t *partial_page_cachep; |
| 253 | |
| 254 | partial_page_cachep = kmem_cache_create("partial_page_cache", |
| 255 | sizeof(struct partial_page), 0, 0, |
| 256 | NULL, NULL); |
| 257 | if (!partial_page_cachep) |
| 258 | panic("Cannot create partial page SLAB cache"); |
| 259 | } |
| 260 | #endif |
| 261 | return 0; |
| 262 | } |
| 263 | |
| 264 | __initcall(ia32_init); |