Changeset 39cea6a in mainline for arch/ia32


Ignore:
Timestamp:
2006-04-13T17:38:03Z (20 years ago)
Author:
Jakub Jermar <jakub@…>
Branches:
lfn, master, serial, ticket/834-toolchain-update, topic/msim-upgrade, topic/simplify-dev-export
Children:
e185136
Parents:
897ad60
Message:

Cleanup pm.c and pm.h code on ia32 and amd64.
Add before_task_runs() and before_task_runs_arch() for each architecture.
Add ia32 and amd64 code to ensure I/O Permission Bitmap update.

Location:
arch/ia32
Files:
5 edited

Legend:

Unmodified
Added
Removed

  • arch/ia32/include/asm.h

    r897ad60 r39cea6a  
    257257 * @param gdtr_reg Address of memory from where to load GDTR.
    258258 */
    259 static inline void gdtr_load(struct ptr_16_32 *gdtr_reg)
     259static inline void gdtr_load(ptr_16_32_t *gdtr_reg)
    260260{
    261261        __asm__ volatile ("lgdt %0\n" : : "m" (*gdtr_reg));
    … …  
    266266 * @param gdtr_reg Address of memory to where to load GDTR.
    267267 */
    268 static inline void gdtr_store(struct ptr_16_32 *gdtr_reg)
     268static inline void gdtr_store(ptr_16_32_t *gdtr_reg)
    269269{
    270270        __asm__ volatile ("sgdt %0\n" : : "m" (*gdtr_reg));
    … …  
    275275 * @param idtr_reg Address of memory from where to load IDTR.
    276276 */
    277 static inline void idtr_load(struct ptr_16_32 *idtr_reg)
     277static inline void idtr_load(ptr_16_32_t *idtr_reg)
    278278{
    279279        __asm__ volatile ("lidt %0\n" : : "m" (*idtr_reg));

  • arch/ia32/include/pm.h

    r897ad60 r39cea6a  
    5656#define DPL_USER        (PL_USER<<5)
    5757
    58 #define IO_MAP_BASE     (104)
     58#define TSS_BASIC_SIZE  104
    5959
    6060#ifndef __ASM__
    … …  
    6868        __u32 base;
    6969} __attribute__ ((packed));
     70typedef struct ptr_16_32 ptr_16_32_t;
    7071
    7172struct descriptor {
    … …  
    8182        unsigned base_24_31: 8;
    8283} __attribute__ ((packed));
     84typedef struct descriptor  descriptor_t;
    8385
    8486struct idescriptor {
    … …  
    8991        unsigned offset_16_31: 16;
    9092} __attribute__ ((packed));
    91 
     93typedef struct idescriptor idescriptor_t;
    9294
    9395struct tss {
    … …  
    132134        __u8 iomap[0x10000+1];  /* 64K + 1 terminating byte */
    133135} __attribute__ ((packed));
     136typedef struct tss tss_t;
    134137
    135 extern struct ptr_16_32 gdtr;
    136 extern struct ptr_16_32 bootstrap_gdtr;
    137 extern struct ptr_16_32 protected_ap_gdtr;
     138extern ptr_16_32_t gdtr;
     139extern ptr_16_32_t bootstrap_gdtr;
     140extern ptr_16_32_t protected_ap_gdtr;
    138141extern struct tss *tss_p;
    139142
    140 extern struct descriptor gdt[];
     143extern descriptor_t gdt[];
    141144
    142145extern void pm_init(void);
    143146
    144 extern void gdt_setbase(struct descriptor *d, __address base);
    145 extern void gdt_setlimit(struct descriptor *d, __u32 limit);
     147extern void gdt_setbase(descriptor_t *d, __address base);
     148extern void gdt_setlimit(descriptor_t *d, __u32 limit);
    146149
    147150extern void idt_init(void);
    148 extern void idt_setoffset(struct idescriptor *d, __address offset);
     151extern void idt_setoffset(idescriptor_t *d, __address offset);
    149152
    150 extern void tss_initialize(struct tss *t);
     153extern void tss_initialize(tss_t *t);
    151154extern void set_tls_desc(__address tls);
    152155

  • arch/ia32/src/cpu/cpu.c

    r897ad60 r39cea6a  
    8888}
    8989
    90 
    91 
    92 
    9390void cpu_arch_init(void)
    9491{
    95         __u32 help=0;
     92        cpuid_feature_info fi;
     93        cpuid_extended_feature_info efi;
     94        cpu_info_t info;
     95        __u32 help = 0;
    9696       
    9797        CPU->arch.tss = tss_p;
    98         CPU->fpu_owner=NULL;
     98        CPU->arch.tss->iomap_base = &CPU->arch.tss->iomap[0] - ((__u8 *) CPU->arch.tss);
    9999
    100         cpuid_feature_info fi;
    101         cpuid_extended_feature_info efi;
     100        CPU->fpu_owner = NULL;
    102101
    103         cpu_info_t info;
    104102        cpuid(1, &info);
    105103
    106         fi.word=info.cpuid_edx;
    107         efi.word=info.cpuid_ecx;
     104        fi.word = info.cpuid_edx;
     105        efi.word = info.cpuid_ecx;
    108106       
    109         if(fi.bits.fxsr)        fpu_fxsr();
    110         else fpu_fsr();
     107        if (fi.bits.fxsr)
     108                fpu_fxsr();
     109        else
     110                fpu_fsr();     
    111111       
    112         if(fi.bits.sse) asm volatile (
    113                 "mov %%cr4,%0;\n"
    114                 "or %1,%0;\n"
    115                 "mov %0,%%cr4;\n"
    116                 :"+r"(help)
    117                 :"i"(CR4_OSFXSR_MASK|(1<<10))
    118         );
    119        
     112        if (fi.bits.sse) {
     113                asm volatile (
     114                        "mov %%cr4,%0\n"
     115                        "or %1,%0\n"
     116                        "mov %0,%%cr4\n"
     117                        : "+r" (help)
     118                        : "i" (CR4_OSFXSR_MASK|(1<<10))
     119                );
     120        }
    120121}
    121 
    122122
    123123void cpu_identify(void)

  • arch/ia32/src/pm.c

    r897ad60 r39cea6a  
    5353 * structure in it's base.
    5454 */
    55 struct descriptor gdt[GDT_ITEMS] = {
     55descriptor_t gdt[GDT_ITEMS] = {
    5656        /* NULL descriptor */
    5757        { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 },
    … …  
    6969};
    7070
    71 static struct idescriptor idt[IDT_ITEMS];
    72 
    73 static struct tss tss;
    74 
    75 struct tss *tss_p = NULL;
     71static idescriptor_t idt[IDT_ITEMS];
     72
     73static tss_t tss;
     74
     75tss_t *tss_p = NULL;
    7676
    7777/* gdtr is changed by kmp before next CPU is initialized */
    78 struct ptr_16_32 bootstrap_gdtr = { .limit = sizeof(gdt), .base = KA2PA((__address) gdt) };
    79 struct ptr_16_32 gdtr = { .limit = sizeof(gdt), .base = (__address) gdt };
    80 
    81 void gdt_setbase(struct descriptor *d, __address base)
     78ptr_16_32_t bootstrap_gdtr = { .limit = sizeof(gdt), .base = KA2PA((__address) gdt) };
     79ptr_16_32_t gdtr = { .limit = sizeof(gdt), .base = (__address) gdt };
     80
     81void gdt_setbase(descriptor_t *d, __address base)
    8282{
    8383        d->base_0_15 = base & 0xffff;
    … …  
    8686}
    8787
    88 void gdt_setlimit(struct descriptor *d, __u32 limit)
     88void gdt_setlimit(descriptor_t *d, __u32 limit)
    8989{
    9090        d->limit_0_15 = limit & 0xffff;
    … …  
    9292}
    9393
    94 void idt_setoffset(struct idescriptor *d, __address offset)
     94void idt_setoffset(idescriptor_t *d, __address offset)
    9595{
    9696        /*
    … …  
    101101}
    102102
    103 void tss_initialize(struct tss *t)
     103void tss_initialize(tss_t *t)
    104104{
    105105        memsetb((__address) t, sizeof(struct tss), 0);
    … …  
    111111void idt_init(void)
    112112{
    113         struct idescriptor *d;
     113        idescriptor_t *d;
    114114        int i;
    115115
    … …  
    142142static void clean_IOPL_NT_flags(void)
    143143{
    144         asm
    145         (
    146                 "pushfl;"
    147                 "pop %%eax;"
    148                 "and $0xffff8fff,%%eax;"
    149                 "push %%eax;"
    150                 "popfl;"
    151                 :
    152                 :
    153                 :"%eax"
     144        __asm__ volatile (
     145                "pushfl\n"
     146                "pop %%eax\n"
     147                "and $0xffff8fff, %%eax\n"
     148                "push %%eax\n"
     149                "popfl\n"
     150                : : : "eax"
    154151        );
    155152}
    … …  
    158155static void clean_AM_flag(void)
    159156{
    160         asm
    161         (
    162                 "mov %%cr0,%%eax;"
    163                 "and $0xFFFBFFFF,%%eax;"
    164                 "mov %%eax,%%cr0;"
    165                 :
    166                 :
    167                 :"%eax"
     157        __asm__ volatile (
     158                "mov %%cr0, %%eax\n"
     159                "and $0xfffbffff, %%eax\n"
     160                "mov %%eax, %%cr0\n"
     161                : : : "eax"
    168162        );
    169163}
    … …  
    171165void pm_init(void)
    172166{
    173         struct descriptor *gdt_p = (struct descriptor *) gdtr.base;
    174         struct ptr_16_32 idtr;
     167        descriptor_t *gdt_p = (descriptor_t *) gdtr.base;
     168        ptr_16_32_t idtr;
    175169
    176170        /*
    … …  
    196190        }
    197191        else {
    198                 tss_p = (struct tss *) malloc(sizeof(struct tss),FRAME_ATOMIC);
     192                tss_p = (tss_t *) malloc(sizeof(tss_t), FRAME_ATOMIC);
    199193                if (!tss_p)
    200194                        panic("could not allocate TSS\n");
    … …  
    208202       
    209203        gdt_setbase(&gdt_p[TSS_DES], (__address) tss_p);
    210         gdt_setlimit(&gdt_p[TSS_DES], sizeof(struct tss) - 1);
     204        gdt_setlimit(&gdt_p[TSS_DES], sizeof(tss_t) - 1);
    211205
    212206        /*
    … …  
    222216void set_tls_desc(__address tls)
    223217{
    224         struct ptr_16_32 cpugdtr;
    225         struct descriptor *gdt_p = (struct descriptor *) cpugdtr.base;
     218        ptr_16_32_t cpugdtr;
     219        descriptor_t *gdt_p = (descriptor_t *) cpugdtr.base;
    226220
    227221        gdtr_store(&cpugdtr);

  • arch/ia32/src/proc/scheduler.c

    r897ad60 r39cea6a  
    2929#include <proc/scheduler.h>
    3030#include <cpu.h>
     31#include <proc/task.h>
    3132#include <proc/thread.h>
    3233#include <arch.h>
    … …  
    3435#include <arch/debugger.h>
    3536#include <arch/pm.h>
     37#include <arch/asm.h>
    3638
     39/** Perform ia32 specific tasks needed before the new task is run. */
     40void before_task_runs_arch(void)
     41{
     42}
     43
     44/** Perform ia32 specific tasks needed before the new thread is scheduled.
     45 *
     46 * THREAD is locked and interrupts are disabled.
     47 */
    3748void before_thread_runs_arch(void)
    3849{
     50        size_t iomap_size;
     51        ptr_16_32_t cpugdtr;
     52        descriptor_t *gdt_p;
     53
    3954        CPU->arch.tss->esp0 = (__address) &THREAD->kstack[THREAD_STACK_SIZE-SP_DELTA];
    4055        CPU->arch.tss->ss0 = selector(KDATA_DES);
    … …  
    4257        /* Set up TLS in GS register */
    4358        set_tls_desc(THREAD->arch.tls);
     59
     60        /*
     61         * Switch the I/O Permission Bitmap, if necessary.
     62         *
     63         * First, copy the I/O Permission Bitmap.
     64         * This needs to be changed so that the
     65         * copying is avoided if the same task
     66         * was already running and the iomap did
     67         * not change.
     68         */
     69        spinlock_lock(&TASK->lock);
     70        iomap_size = TASK->arch.iomap_size;
     71        if (iomap_size) {
     72                ASSERT(TASK->arch.iomap);
     73                memcpy(CPU->arch.tss->iomap, TASK->arch.iomap, iomap_size);
     74                CPU->arch.tss->iomap[iomap_size] = 0xff;        /* terminating byte */
     75        }
     76        spinlock_unlock(&TASK->lock);   
     77
     78        /* Second, adjust TSS segment limit. */
     79        gdtr_store(&cpugdtr);
     80        gdt_p = (descriptor_t *) cpugdtr.base;
     81        gdt_setlimit(&gdt_p[TSS_DES], TSS_BASIC_SIZE + iomap_size - 1);
     82        gdtr_load(&cpugdtr);
    4483
    4584#ifdef CONFIG_DEBUG_AS_WATCHPOINT
Note: See TracChangeset for help on using the changeset viewer.