2 * IA32 helper functions
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>
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()
15 #include <linux/kernel.h>
16 #include <linux/init.h>
18 #include <linux/personality.h>
19 #include <linux/sched.h>
21 #include <asm/intrinsics.h>
23 #include <asm/pgtable.h>
24 #include <asm/system.h>
25 #include <asm/processor.h>
26 #include <asm/uaccess.h>
30 extern void die_if_kernel (char *str, struct pt_regs *regs, long err);
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];
38 load_desc (u16 selector)
40 unsigned long *table, limit, index;
44 if (selector & IA32_SEGSEL_TI) {
45 table = (unsigned long *) IA32_LDT_OFFSET;
46 limit = IA32_LDT_ENTRIES;
48 table = cpu_gdt_table[smp_processor_id()];
49 limit = IA32_PAGE_SIZE / sizeof(ia32_boot_gdt[0]);
51 index = selector >> IA32_SEGSEL_INDEX_SHIFT;
54 return IA32_SEG_UNSCRAMBLE(table[index]);
58 ia32_load_segment_descriptors (struct task_struct *task)
60 struct pt_regs *regs = ia64_task_regs(task);
62 /* Setup the segment descriptors */
63 regs->r24 = load_desc(regs->r16 >> 16); /* ESD */
64 regs->r27 = load_desc(regs->r16 >> 0); /* DSD */
65 regs->r28 = load_desc(regs->r16 >> 32); /* FSD */
66 regs->r29 = load_desc(regs->r16 >> 48); /* GSD */
67 regs->ar_csd = load_desc(regs->r17 >> 0); /* CSD */
68 regs->ar_ssd = load_desc(regs->r17 >> 16); /* SSD */
72 ia32_clone_tls (struct task_struct *child, struct pt_regs *childregs)
74 struct desc_struct *desc;
75 struct ia32_user_desc info;
78 if (copy_from_user(&info, (void *)(childregs->r14 & 0xffffffff), sizeof(info)))
83 idx = info.entry_number;
84 if (idx < GDT_ENTRY_TLS_MIN || idx > GDT_ENTRY_TLS_MAX)
87 desc = child->thread.tls_array + idx - GDT_ENTRY_TLS_MIN;
88 desc->a = LDT_entry_a(&info);
89 desc->b = LDT_entry_b(&info);
91 /* XXX: can this be done in a cleaner way ? */
92 load_TLS(&child->thread, smp_processor_id());
93 ia32_load_segment_descriptors(child);
94 load_TLS(¤t->thread, smp_processor_id());
100 ia32_save_state (struct task_struct *t)
102 t->thread.eflag = ia64_getreg(_IA64_REG_AR_EFLAG);
103 t->thread.fsr = ia64_getreg(_IA64_REG_AR_FSR);
104 t->thread.fcr = ia64_getreg(_IA64_REG_AR_FCR);
105 t->thread.fir = ia64_getreg(_IA64_REG_AR_FIR);
106 t->thread.fdr = ia64_getreg(_IA64_REG_AR_FDR);
107 ia64_set_kr(IA64_KR_IO_BASE, t->thread.old_iob);
108 ia64_set_kr(IA64_KR_TSSD, t->thread.old_k1);
112 ia32_load_state (struct task_struct *t)
114 unsigned long eflag, fsr, fcr, fir, fdr, tssd;
115 struct pt_regs *regs = ia64_task_regs(t);
117 eflag = t->thread.eflag;
122 tssd = load_desc(_TSS); /* TSSD */
124 ia64_setreg(_IA64_REG_AR_EFLAG, eflag);
125 ia64_setreg(_IA64_REG_AR_FSR, fsr);
126 ia64_setreg(_IA64_REG_AR_FCR, fcr);
127 ia64_setreg(_IA64_REG_AR_FIR, fir);
128 ia64_setreg(_IA64_REG_AR_FDR, fdr);
129 current->thread.old_iob = ia64_get_kr(IA64_KR_IO_BASE);
130 current->thread.old_k1 = ia64_get_kr(IA64_KR_TSSD);
131 ia64_set_kr(IA64_KR_IO_BASE, IA32_IOBASE);
132 ia64_set_kr(IA64_KR_TSSD, tssd);
134 regs->r17 = (_TSS << 48) | (_LDT << 32) | (__u32) regs->r17;
135 regs->r30 = load_desc(_LDT); /* LDTD */
136 load_TLS(&t->thread, smp_processor_id());
140 * Setup IA32 GDT and TSS
145 int cpu = smp_processor_id();
147 ia32_shared_page[cpu] = alloc_page(GFP_KERNEL);
148 cpu_gdt_table[cpu] = page_address(ia32_shared_page[cpu]);
150 /* Copy from the boot cpu's GDT */
151 memcpy(cpu_gdt_table[cpu], ia32_boot_gdt, PAGE_SIZE);
156 * Setup IA32 GDT and TSS
159 ia32_boot_gdt_init (void)
161 unsigned long ldt_size;
163 ia32_shared_page[0] = alloc_page(GFP_KERNEL);
164 ia32_boot_gdt = page_address(ia32_shared_page[0]);
165 cpu_gdt_table[0] = ia32_boot_gdt;
167 /* CS descriptor in IA-32 (scrambled) format */
168 ia32_boot_gdt[__USER_CS >> 3]
169 = IA32_SEG_DESCRIPTOR(0, (IA32_PAGE_OFFSET-1) >> IA32_PAGE_SHIFT,
170 0xb, 1, 3, 1, 1, 1, 1);
172 /* DS descriptor in IA-32 (scrambled) format */
173 ia32_boot_gdt[__USER_DS >> 3]
174 = IA32_SEG_DESCRIPTOR(0, (IA32_PAGE_OFFSET-1) >> IA32_PAGE_SHIFT,
175 0x3, 1, 3, 1, 1, 1, 1);
177 ldt_size = PAGE_ALIGN(IA32_LDT_ENTRIES*IA32_LDT_ENTRY_SIZE);
178 ia32_boot_gdt[TSS_ENTRY] = IA32_SEG_DESCRIPTOR(IA32_TSS_OFFSET, 235,
179 0xb, 0, 3, 1, 1, 1, 0);
180 ia32_boot_gdt[LDT_ENTRY] = IA32_SEG_DESCRIPTOR(IA32_LDT_OFFSET, ldt_size - 1,
181 0x2, 0, 3, 1, 1, 1, 0);
185 * Handle bad IA32 interrupt via syscall
188 ia32_bad_interrupt (unsigned long int_num, struct pt_regs *regs)
192 die_if_kernel("Bad IA-32 interrupt", regs, int_num);
194 siginfo.si_signo = SIGTRAP;
195 siginfo.si_errno = int_num; /* XXX is it OK to abuse si_errno like this? */
196 siginfo.si_flags = 0;
200 siginfo.si_code = TRAP_BRKPT;
201 force_sig_info(SIGTRAP, &siginfo, current);
207 /* initialize global ia32 state - CR0 and CR4 */
208 ia64_setreg(_IA64_REG_AR_CFLAG, (((ulong) IA32_CR4 << 32) | IA32_CR0));
214 ia32_exec_domain.name = "Linux/x86";
215 ia32_exec_domain.handler = NULL;
216 ia32_exec_domain.pers_low = PER_LINUX32;
217 ia32_exec_domain.pers_high = PER_LINUX32;
218 ia32_exec_domain.signal_map = default_exec_domain.signal_map;
219 ia32_exec_domain.signal_invmap = default_exec_domain.signal_invmap;
220 register_exec_domain(&ia32_exec_domain);
224 __initcall(ia32_init);