Changes in / [6b1a85c:5f83634] in mainline


Ignore:
Location:
kernel
Files:
7 edited

Legend:

Unmodified
Added
Removed

  • kernel/arch/amd64/include/cpu.h

    r6b1a85c r5f83634  
    4545#define RFLAGS_DF       (1 << 10)
    4646#define RFLAGS_OF       (1 << 11)
    47 #define RFLAGS_NT       (1 << 14)
    4847#define RFLAGS_RF       (1 << 16)
    4948

  • kernel/arch/amd64/include/interrupt.h

    r6b1a85c r5f83634  
    7474typedef struct istate {
    7575        uint64_t rax;
    76         uint64_t rbx;
    7776        uint64_t rcx;
    7877        uint64_t rdx;
    7978        uint64_t rsi;
    8079        uint64_t rdi;
    81         uint64_t rbp;
    8280        uint64_t r8;
    8381        uint64_t r9;
    8482        uint64_t r10;
    8583        uint64_t r11;
    86         uint64_t r12;
    87         uint64_t r13;
    88         uint64_t r14;
    89         uint64_t r15;
    90         uint64_t alignment;     /* align rbp_frame on multiple of 16 */
    91         uint64_t rbp_frame;     /* imitation of frame pointer linkage */
    92         uint64_t rip_frame;     /* imitation of return address linkage */
    93         uint64_t error_word;    /* real or fake error word */
     84        uint64_t rbp;
     85        uint64_t error_word;
    9486        uint64_t rip;
    9587        uint64_t cs;
    9688        uint64_t rflags;
    97         uint64_t rsp;           /* only if istate_t is from uspace */
    98         uint64_t ss;            /* only if istate_t is from uspace */
     89        uint64_t stack[];  /* Additional data on stack */
    9990} istate_t;
    10091

  • kernel/arch/amd64/src/asm.S

    r6b1a85c r5f83634  
    2626 * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
    2727 */
     28
     29#define IREGISTER_SPACE  80
     30
     31#define IOFFSET_RAX  0x00
     32#define IOFFSET_RCX  0x08
     33#define IOFFSET_RDX  0x10
     34#define IOFFSET_RSI  0x18
     35#define IOFFSET_RDI  0x20
     36#define IOFFSET_R8   0x28
     37#define IOFFSET_R9   0x30
     38#define IOFFSET_R10  0x38
     39#define IOFFSET_R11  0x40
     40#define IOFFSET_RBP  0x48
     41
     42/**
     43 * Mask for interrupts 0 - 31 (bits 0 - 31) where 0 means that int
     44 * has no error word  and 1 means interrupt with error word
     45 *
     46 */
     47#define ERROR_WORD_INTERRUPT_LIST  0x00027D00
    2848
    2949#include <arch/pm.h>
    … …  
    154174        ret
    155175
    156 #define ISTATE_OFFSET_RAX               0
    157 #define ISTATE_OFFSET_RBX               8
    158 #define ISTATE_OFFSET_RCX               16
    159 #define ISTATE_OFFSET_RDX               24
    160 #define ISTATE_OFFSET_RSI               32
    161 #define ISTATE_OFFSET_RDI               40
    162 #define ISTATE_OFFSET_RBP               48
    163 #define ISTATE_OFFSET_R8                56
    164 #define ISTATE_OFFSET_R9                64
    165 #define ISTATE_OFFSET_R10               72
    166 #define ISTATE_OFFSET_R11               80
    167 #define ISTATE_OFFSET_R12               88     
    168 #define ISTATE_OFFSET_R13               96
    169 #define ISTATE_OFFSET_R14               104
    170 #define ISTATE_OFFSET_R15               112
    171 #define ISTATE_OFFSET_ALIGNMENT         120
    172 #define ISTATE_OFFSET_RBP_FRAME         128
    173 #define ISTATE_OFFSET_RIP_FRAME         136
    174 #define ISTATE_OFFSET_ERROR_WORD        144
    175 #define ISTATE_OFFSET_RIP               152
    176 #define ISTATE_OFFSET_CS                160
    177 #define ISTATE_OFFSET_RFLAGS            168
    178 #define ISTATE_OFFSET_RSP               176
    179 #define ISTATE_OFFSET_SS                184
    180 
    181 /*
    182  * Size of the istate structure without the hardware-saved part and without the
    183  * error word.
    184  */
    185 #define ISTATE_SOFT_SIZE        144
    186 
    187 /**
    188  * Mask for interrupts 0 - 31 (bits 0 - 31) where 0 means that int
    189  * has no error word  and 1 means interrupt with error word
    190  *
    191  */
    192 #define ERROR_WORD_INTERRUPT_LIST  0x00027D00
    193 
    194 #define INTERRUPT_ALIGN         256
     176/** Push all volatile general purpose registers on stack
     177 *
     178 */
     179.macro save_all_gpr
     180        movq %rax, IOFFSET_RAX(%rsp)
     181        movq %rcx, IOFFSET_RCX(%rsp)
     182        movq %rdx, IOFFSET_RDX(%rsp)
     183        movq %rsi, IOFFSET_RSI(%rsp)
     184        movq %rdi, IOFFSET_RDI(%rsp)
     185        movq %r8, IOFFSET_R8(%rsp)
     186        movq %r9, IOFFSET_R9(%rsp)
     187        movq %r10, IOFFSET_R10(%rsp)
     188        movq %r11, IOFFSET_R11(%rsp)
     189        movq %rbp, IOFFSET_RBP(%rsp)
     190.endm
     191
     192.macro restore_all_gpr
     193        movq IOFFSET_RAX(%rsp), %rax
     194        movq IOFFSET_RCX(%rsp), %rcx
     195        movq IOFFSET_RDX(%rsp), %rdx
     196        movq IOFFSET_RSI(%rsp), %rsi
     197        movq IOFFSET_RDI(%rsp), %rdi
     198        movq IOFFSET_R8(%rsp), %r8
     199        movq IOFFSET_R9(%rsp), %r9
     200        movq IOFFSET_R10(%rsp), %r10
     201        movq IOFFSET_R11(%rsp), %r11
     202        movq IOFFSET_RBP(%rsp), %rbp
     203.endm
     204
     205#define INTERRUPT_ALIGN  128
    195206
    196207/** Declare interrupt handlers
    … …  
    218229                         * Version with error word.
    219230                         */
    220                         subq $ISTATE_SOFT_SIZE, %rsp
     231                        subq $IREGISTER_SPACE, %rsp
    221232                .else
    222233                        /*
    223                          * Version without error word.
     234                         * Version without error word,
    224235                         */
    225                         subq $(ISTATE_SOFT_SIZE + 8), %rsp
     236                        subq $(IREGISTER_SPACE + 8), %rsp
    226237                .endif
    227238        .else
    228239                /*
    229                  * Version without error word.
     240                 * Version without error word,
    230241                 */
    231                 subq $(ISTATE_SOFT_SIZE + 8), %rsp
     242                subq $(IREGISTER_SPACE + 8), %rsp
    232243        .endif
    233244       
     245        save_all_gpr
     246        cld
     247       
    234248        /*
    235          * Save the general purpose registers.
    236          */
    237         movq %rax, ISTATE_OFFSET_RAX(%rsp)
    238         movq %rbx, ISTATE_OFFSET_RBX(%rsp)
    239         movq %rcx, ISTATE_OFFSET_RCX(%rsp)
    240         movq %rdx, ISTATE_OFFSET_RDX(%rsp)
    241         movq %rsi, ISTATE_OFFSET_RSI(%rsp)
    242         movq %rdi, ISTATE_OFFSET_RDI(%rsp)
    243         movq %rbp, ISTATE_OFFSET_RBP(%rsp)
    244         movq %r8, ISTATE_OFFSET_R8(%rsp)
    245         movq %r9, ISTATE_OFFSET_R9(%rsp)
    246         movq %r10, ISTATE_OFFSET_R10(%rsp)
    247         movq %r11, ISTATE_OFFSET_R11(%rsp)
    248         movq %r12, ISTATE_OFFSET_R12(%rsp)
    249         movq %r13, ISTATE_OFFSET_R13(%rsp)
    250         movq %r14, ISTATE_OFFSET_R14(%rsp)
    251         movq %r15, ISTATE_OFFSET_R15(%rsp)
    252 
    253         /*
    254          * Imitate a regular stack frame linkage.
    255249         * Stop stack traces here if we came from userspace.
    256250         */
     251        movq %cs, %rax
    257252        xorq %rdx, %rdx
    258         cmpq $(gdtselector(KTEXT_DES)), ISTATE_OFFSET_CS(%rsp)
    259         cmovnzq %rdx, %rbp
    260 
    261         movq %rbp, ISTATE_OFFSET_RBP_FRAME(%rsp)
    262         movq ISTATE_OFFSET_RIP(%rsp), %rax
    263         movq %rax, ISTATE_OFFSET_RIP_FRAME(%rsp)
    264         leaq ISTATE_OFFSET_RBP_FRAME(%rsp), %rbp
    265 
    266         movq $(\i), %rdi   /* pass intnum in the first argument */
    267         movq %rsp, %rsi    /* pass istate address in the second argument */
    268        
    269         cld
    270 
     253        cmpq %rax, IREGISTER_SPACE+16(%rsp)
     254        cmovneq %rdx, %rbp
     255
     256        movq $(\i), %rdi   /* %rdi - first argument */
     257        movq %rsp, %rsi    /* %rsi - pointer to istate */
     258       
    271259        /* Call exc_dispatch(i, istate) */
    272260        call exc_dispatch
    273 
    274         /*
    275          * Restore all scratch registers and the preserved registers we have
    276          * clobbered in this handler (i.e. RBP).
    277          */
    278         movq ISTATE_OFFSET_RAX(%rsp), %rax
    279         movq ISTATE_OFFSET_RCX(%rsp), %rcx
    280         movq ISTATE_OFFSET_RDX(%rsp), %rdx
    281         movq ISTATE_OFFSET_RSI(%rsp), %rsi
    282         movq ISTATE_OFFSET_RDI(%rsp), %rdi
    283         movq ISTATE_OFFSET_RBP(%rsp), %rbp
    284         movq ISTATE_OFFSET_R8(%rsp), %r8
    285         movq ISTATE_OFFSET_R9(%rsp), %r9
    286         movq ISTATE_OFFSET_R10(%rsp), %r10
    287         movq ISTATE_OFFSET_R11(%rsp), %r11
     261       
     262        restore_all_gpr
    288263       
    289264        /* $8 = Skip error word */
    290         addq $(ISTATE_SOFT_SIZE + 8), %rsp
     265        addq $(IREGISTER_SPACE + 8), %rsp
    291266        iretq
    292267       

  • kernel/arch/amd64/src/syscall.c

    r6b1a85c r5f83634  
    6666         * - clear DF so that the string instructions operate in
    6767         *   the right direction
    68          * - clear NT to prevent a #GP should the flag proliferate to an IRET
    6968         */
    70         write_msr(AMD_MSR_SFMASK, RFLAGS_IF | RFLAGS_DF | RFLAGS_NT);
     69        write_msr(AMD_MSR_SFMASK, RFLAGS_IF | RFLAGS_DF);
    7170}
    7271

  • kernel/arch/ia32/include/cpu.h

    r6b1a85c r5f83634  
    3737
    3838#define EFLAGS_IF       (1 << 9)
    39 #define EFLAGS_DF       (1 << 10)
    40 #define EFLAGS_NT       (1 << 14)
    4139#define EFLAGS_RF       (1 << 16)
    4240

  • kernel/arch/ia32/src/asm.S

    r6b1a85c r5f83634  
    11/*
    2  * Copyright (c) 2010 Jakub Jermar
     2 * Copyright (c) 2001 Jakub Jermar
    33 * All rights reserved.
    44 *
    … …  
    3232
    3333#include <arch/pm.h>
    34 #include <arch/cpu.h>
    3534#include <arch/mm/page.h>
    3635
    … …  
    191190.global sysenter_handler
    192191sysenter_handler:
     192        sti
    193193        subl $(ISTATE_REAL_SIZE), %esp
    194194
    … …  
    227227         * Switch to kernel selectors.
    228228         */
    229         movw $(gdtselector(KDATA_DES)), %ax
     229        movw $16, %ax
    230230        movw %ax, %ds
    231231        movw %ax, %es
    232232       
    233         /*
    234          * Sanitize EFLAGS.
    235          *
    236          * SYSENTER does not clear the NT flag, which could thus proliferate
    237          * from here to the IRET instruction via a context switch and result
    238          * in crash.
    239          *
    240          * SYSENTER does not clear DF, which the ABI assumes to be cleared.
    241          *
    242          * SYSENTER clears IF, which we would like to be set for syscalls.
    243          *
    244          */
    245         pushl $(EFLAGS_IF)  /* specify EFLAGS bits that we want to set */
    246         popfl               /* set bits from the mask, clear or ignore others */
    247 
     233        cld
    248234        call syscall_handler
    249235       
    … …  
    308294         * Switch to kernel selectors.
    309295         */
    310         movl $(gdtselector(KDATA_DES)), %eax
     296        movl $16, %eax
    311297        movl %eax, %ds
    312298        movl %eax, %es
    … …  
    372358                .if (1 << \i) & ERROR_WORD_INTERRUPT_LIST
    373359                        /*
    374                          * Exception with error word.
     360                         * Exception with error word: do nothing
    375361                         */
    376                         subl $ISTATE_SOFT_SIZE, %esp
    377362                .else
    378363                        /*
    379364                         * Exception without error word: fake up one
    380365                         */
    381                         subl $(ISTATE_SOFT_SIZE + 4), %esp
     366                        pushl $0
    382367                .endif
    383368        .else
    384369                /*
    385                  * Interrupt: fake up an error word
     370                 * Interrupt: fake up one
    386371                 */
    387                 subl $(ISTATE_SOFT_SIZE + 4), %esp
     372                pushl $0
    388373        .endif
     374       
     375        subl $ISTATE_SOFT_SIZE, %esp
    389376       
    390377        /*
    … …  
    417404         * Switch to kernel selectors.
    418405         */
    419         movl $(gdtselector(KDATA_DES)), %eax
     406        movl $16, %eax
    420407        movl %eax, %ds
    421408        movl %eax, %es
    … …  
    426413         */
    427414        xorl %eax, %eax
    428         cmpl $(gdtselector(KTEXT_DES)), ISTATE_OFFSET_CS(%esp)
    429         cmovnzl %eax, %ebp
     415        cmpl $8, ISTATE_OFFSET_CS(%esp)
     416        cmovl %eax, %ebp
    430417
    431418        movl %ebp, ISTATE_OFFSET_EBP_FRAME(%esp)

  • kernel/generic/src/console/kconsole.c

    r6b1a85c r5f83634  
    210210        link_t *pos = NULL;
    211211        const char *hint;
    212         char *output = malloc(MAX_CMDLINE, 0);
     212        char output[MAX_CMDLINE];
    213213       
    214214        output[0] = 0;
    … …  
    235235                str_cpy(input, size, output);
    236236       
    237         free(output);
    238237        return found;
    239238}
    … …  
    246245        wchar_t *current = history[history_pos];
    247246        current[0] = 0;
    248         char *tmp = malloc(STR_BOUNDS(MAX_CMDLINE), 0);
    249247       
    250248        while (true) {
    … …  
    291289                                beg++;
    292290                       
     291                        char tmp[STR_BOUNDS(MAX_CMDLINE)];
    293292                        wstr_to_str(tmp, position - beg + 1, current + beg);
    294293                       
    … …  
    416415        }
    417416       
    418         free(tmp);
    419417        return current;
    420418}
    … …  
    632630                                        cmd->argv[i].vartype = ARG_TYPE_STRING;
    633631                                } else {
    634                                         printf("Wrong syntax.\n");
     632                                        printf("Wrong synxtax.\n");
    635633                                        error = true;
    636634                                }
    … …  
    690688                printf("Type \"exit\" to leave the console.\n");
    691689       
    692         char *cmdline = malloc(STR_BOUNDS(MAX_CMDLINE), 0);
    693690        while (true) {
    694691                wchar_t *tmp = clever_readline((char *) prompt, stdin);
    … …  
    697694                        continue;
    698695               
     696                char cmdline[STR_BOUNDS(MAX_CMDLINE)];
    699697                wstr_to_str(cmdline, STR_BOUNDS(MAX_CMDLINE), tmp);
    700698               
    … …  
    708706                (void) cmd_info->func(cmd_info->argv);
    709707        }
    710         free(cmdline);
    711708}
    712709
Note: See TracChangeset for help on using the changeset viewer.