arch/ia64/ia32/ia32_support.c

   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/page.h>
  22 #include <asm/pgtable.h>
  23 #include <asm/system.h>
  24 #include <asm/processor.h>
  25 #include <asm/ia32.h>
  26
  27 extern void die_if_kernel (char *str, struct pt_regs *regs, long err);
  28
  29 struct exec_domain ia32_exec_domain;
  30 struct page *ia32_shared_page[(2*IA32_PAGE_SIZE + PAGE_SIZE - 1)/PAGE_SIZE];
  31 unsigned long *ia32_gdt;
  32
  33 static unsigned long
  34 load_desc (u16 selector)
  35 {
  36         unsigned long *table, limit, index;
  37
  38         if (!selector)
  39                 return 0;
  40         if (selector & IA32_SEGSEL_TI) {
  41                 table = (unsigned long *) IA32_LDT_OFFSET;
  42                 limit = IA32_LDT_ENTRIES;
  43         } else {
  44                 table = ia32_gdt;
  45                 limit = IA32_PAGE_SIZE / sizeof(ia32_gdt[0]);
  46         }
  47         index = selector >> IA32_SEGSEL_INDEX_SHIFT;
  48         if (index >= limit)
  49                 return 0;
  50         return IA32_SEG_UNSCRAMBLE(table[index]);
  51 }
  52
  53 void
  54 ia32_load_segment_descriptors (struct task_struct *task)
  55 {
  56         struct pt_regs *regs = ia64_task_regs(task);
  57
  58         /* Setup the segment descriptors */
  59         regs->r24 = load_desc(regs->r16 >> 16);         /* ESD */
  60         regs->r27 = load_desc(regs->r16 >>  0);         /* DSD */
  61         regs->r28 = load_desc(regs->r16 >> 32);         /* FSD */
  62         regs->r29 = load_desc(regs->r16 >> 48);         /* GSD */
  63         task->thread.csd = load_desc(regs->r17 >>  0);  /* CSD */
  64         task->thread.ssd = load_desc(regs->r17 >> 16);  /* SSD */
  65 }
  66
  67 void
  68 ia32_save_state (struct task_struct *t)
  69 {
  70         unsigned long eflag, fsr, fcr, fir, fdr, csd, ssd;
  71
  72         asm ("mov %0=ar.eflag;"
  73              "mov %1=ar.fsr;"
  74              "mov %2=ar.fcr;"
  75              "mov %3=ar.fir;"
  76              "mov %4=ar.fdr;"
  77              "mov %5=ar.csd;"
  78              "mov %6=ar.ssd;"
  79              : "=r"(eflag), "=r"(fsr), "=r"(fcr), "=r"(fir), "=r"(fdr), "=r"(csd), "=r"(ssd));
  80         t->thread.eflag = eflag;
  81         t->thread.fsr = fsr;
  82         t->thread.fcr = fcr;
  83         t->thread.fir = fir;
  84         t->thread.fdr = fdr;
  85         t->thread.csd = csd;
  86         t->thread.ssd = ssd;
  87         ia64_set_kr(IA64_KR_IO_BASE, t->thread.old_iob);
  88         ia64_set_kr(IA64_KR_TSSD, t->thread.old_k1);
  89 }
  90
  91 void
  92 ia32_load_state (struct task_struct *t)
  93 {
  94         unsigned long eflag, fsr, fcr, fir, fdr, csd, ssd, tssd;
  95         struct pt_regs *regs = ia64_task_regs(t);
  96         int nr = get_cpu();     /* LDT and TSS depend on CPU number: */
  97
  98         eflag = t->thread.eflag;
  99         fsr = t->thread.fsr;
 100         fcr = t->thread.fcr;
 101         fir = t->thread.fir;
 102         fdr = t->thread.fdr;
 103         csd = t->thread.csd;
 104         ssd = t->thread.ssd;
 105         tssd = load_desc(_TSS(nr));                                     /* TSSD */
 106
 107         asm volatile ("mov ar.eflag=%0;"
 108                       "mov ar.fsr=%1;"
 109                       "mov ar.fcr=%2;"
 110                       "mov ar.fir=%3;"
 111                       "mov ar.fdr=%4;"
 112                       "mov ar.csd=%5;"
 113                       "mov ar.ssd=%6;"
 114                       :: "r"(eflag), "r"(fsr), "r"(fcr), "r"(fir), "r"(fdr), "r"(csd), "r"(ssd));
 115         current->thread.old_iob = ia64_get_kr(IA64_KR_IO_BASE);
 116         current->thread.old_k1 = ia64_get_kr(IA64_KR_TSSD);
 117         ia64_set_kr(IA64_KR_IO_BASE, IA32_IOBASE);
 118         ia64_set_kr(IA64_KR_TSSD, tssd);
 119
 120         regs->r17 = (_TSS(nr) << 48) | (_LDT(nr) << 32) | (__u32) regs->r17;
 121         regs->r30 = load_desc(_LDT(nr));                                /* LDTD */
 122         put_cpu();
 123 }
 124
 125 /*
 126  * Setup IA32 GDT and TSS
 127  */
 128 void
 129 ia32_gdt_init (void)
 130 {
 131         unsigned long *tss;
 132         unsigned long ldt_size;
 133         int nr;
 134
 135         ia32_shared_page[0] = alloc_page(GFP_KERNEL);
 136         ia32_gdt = page_address(ia32_shared_page[0]);
 137         tss = ia32_gdt + IA32_PAGE_SIZE/sizeof(ia32_gdt[0]);
 138
 139         if (IA32_PAGE_SIZE == PAGE_SIZE) {
 140                 ia32_shared_page[1] = alloc_page(GFP_KERNEL);
 141                 tss = page_address(ia32_shared_page[1]);
 142         }
 143
 144         /* CS descriptor in IA-32 (scrambled) format */
 145         ia32_gdt[__USER_CS >> 3] = IA32_SEG_DESCRIPTOR(0, (IA32_PAGE_OFFSET-1) >> IA32_PAGE_SHIFT,
 146                                                        0xb, 1, 3, 1, 1, 1, 1);
 147
 148         /* DS descriptor in IA-32 (scrambled) format */
 149         ia32_gdt[__USER_DS >> 3] = IA32_SEG_DESCRIPTOR(0, (IA32_PAGE_OFFSET-1) >> IA32_PAGE_SHIFT,
 150                                                        0x3, 1, 3, 1, 1, 1, 1);
 151
 152         /* We never change the TSS and LDT descriptors, so we can share them across all CPUs.  */
 153         ldt_size = PAGE_ALIGN(IA32_LDT_ENTRIES*IA32_LDT_ENTRY_SIZE);
 154         for (nr = 0; nr < NR_CPUS; ++nr) {
 155                 ia32_gdt[_TSS(nr) >> IA32_SEGSEL_INDEX_SHIFT]
 156                         = IA32_SEG_DESCRIPTOR(IA32_TSS_OFFSET, 235,
 157                                               0xb, 0, 3, 1, 1, 1, 0);
 158                 ia32_gdt[_LDT(nr) >> IA32_SEGSEL_INDEX_SHIFT]
 159                         = IA32_SEG_DESCRIPTOR(IA32_LDT_OFFSET, ldt_size - 1,
 160                                               0x2, 0, 3, 1, 1, 1, 0);
 161         }
 162 }
 163
 164 /*
 165  * Handle bad IA32 interrupt via syscall
 166  */
 167 void
 168 ia32_bad_interrupt (unsigned long int_num, struct pt_regs *regs)
 169 {
 170         siginfo_t siginfo;
 171
 172         die_if_kernel("Bad IA-32 interrupt", regs, int_num);
 173
 174         siginfo.si_signo = SIGTRAP;
 175         siginfo.si_errno = int_num;     /* XXX is it OK to abuse si_errno like this? */
 176         siginfo.si_flags = 0;
 177         siginfo.si_isr = 0;
 178         siginfo.si_addr = 0;
 179         siginfo.si_imm = 0;
 180         siginfo.si_code = TRAP_BRKPT;
 181         force_sig_info(SIGTRAP, &siginfo, current);
 182 }
 183
 184 static int __init
 185 ia32_init (void)
 186 {
 187         ia32_exec_domain.name = "Linux/x86";
 188         ia32_exec_domain.handler = NULL;
 189         ia32_exec_domain.pers_low = PER_LINUX32;
 190         ia32_exec_domain.pers_high = PER_LINUX32;
 191         ia32_exec_domain.signal_map = default_exec_domain.signal_map;
 192         ia32_exec_domain.signal_invmap = default_exec_domain.signal_invmap;
 193         register_exec_domain(&ia32_exec_domain);
 194         return 0;
 195 }
 196
 197 __initcall(ia32_init);