Changes in / [074c9bd:41ce4d9] in mainline


Ignore:
Location:
kernel
Files:
27 edited

Legend:

Unmodified
Added
Removed

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

    r074c9bd r41ce4d9  
    435435GEN_WRITE_REG(dr7)
    436436
     437extern size_t interrupt_handler_size;
     438extern void interrupt_handlers(void);
     439
    437440extern void asm_delay_loop(uint32_t);
    438441extern void asm_fake_loop(uint32_t);
    439442
    440 extern uintptr_t int_0;
    441 extern uintptr_t int_1;
    442 extern uintptr_t int_2;
    443 extern uintptr_t int_3;
    444 extern uintptr_t int_4;
    445 extern uintptr_t int_5;
    446 extern uintptr_t int_6;
    447 extern uintptr_t int_7;
    448 extern uintptr_t int_8;
    449 extern uintptr_t int_9;
    450 extern uintptr_t int_10;
    451 extern uintptr_t int_11;
    452 extern uintptr_t int_12;
    453 extern uintptr_t int_13;
    454 extern uintptr_t int_14;
    455 extern uintptr_t int_15;
    456 extern uintptr_t int_16;
    457 extern uintptr_t int_17;
    458 extern uintptr_t int_18;
    459 extern uintptr_t int_19;
    460 extern uintptr_t int_20;
    461 extern uintptr_t int_21;
    462 extern uintptr_t int_22;
    463 extern uintptr_t int_23;
    464 extern uintptr_t int_24;
    465 extern uintptr_t int_25;
    466 extern uintptr_t int_26;
    467 extern uintptr_t int_27;
    468 extern uintptr_t int_28;
    469 extern uintptr_t int_29;
    470 extern uintptr_t int_30;
    471 extern uintptr_t int_31;
    472 extern uintptr_t int_32;
    473 extern uintptr_t int_33;
    474 extern uintptr_t int_34;
    475 extern uintptr_t int_35;
    476 extern uintptr_t int_36;
    477 extern uintptr_t int_37;
    478 extern uintptr_t int_38;
    479 extern uintptr_t int_39;
    480 extern uintptr_t int_40;
    481 extern uintptr_t int_41;
    482 extern uintptr_t int_42;
    483 extern uintptr_t int_43;
    484 extern uintptr_t int_44;
    485 extern uintptr_t int_45;
    486 extern uintptr_t int_46;
    487 extern uintptr_t int_47;
    488 extern uintptr_t int_48;
    489 extern uintptr_t int_49;
    490 extern uintptr_t int_50;
    491 extern uintptr_t int_51;
    492 extern uintptr_t int_52;
    493 extern uintptr_t int_53;
    494 extern uintptr_t int_54;
    495 extern uintptr_t int_55;
    496 extern uintptr_t int_56;
    497 extern uintptr_t int_57;
    498 extern uintptr_t int_58;
    499 extern uintptr_t int_59;
    500 extern uintptr_t int_60;
    501 extern uintptr_t int_61;
    502 extern uintptr_t int_62;
    503 extern uintptr_t int_63;
    504 
    505443#endif
    506444

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

    r074c9bd r41ce4d9  
    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

    r074c9bd r41ce4d9  
    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

    r074c9bd r41ce4d9  
    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 .macro handler i
    195 .global int_\i
    196 int_\i:
    197 
     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
     206
     207/** Declare interrupt handlers
     208 *
     209 * Declare interrupt handlers for n interrupt
     210 * vectors starting at vector i.
     211 *
     212 * The handlers call exc_dispatch().
     213 *
     214 */
     215.macro handler i n
     216       
    198217        /*
    199218         * Choose between version with error code and version without error
    200          * code.
     219         * code. Both versions have to be of the same size. amd64 assembly is,
     220         * however, a little bit tricky. For instance, subq $0x80, %rsp and
     221         * subq $0x78, %rsp can result in two instructions with different
     222         * op-code lengths.
     223         * Therefore we align the interrupt handlers.
    201224         */
    202225       
    … …  
    206229                         * Version with error word.
    207230                         */
    208                         subq $ISTATE_SOFT_SIZE, %rsp
     231                        subq $IREGISTER_SPACE, %rsp
    209232                .else
    210233                        /*
    211                          * Version without error word.
     234                         * Version without error word,
    212235                         */
    213                         subq $(ISTATE_SOFT_SIZE + 8), %rsp
     236                        subq $(IREGISTER_SPACE + 8), %rsp
    214237                .endif
    215238        .else
    216239                /*
    217                  * Version without error word.
     240                 * Version without error word,
    218241                 */
    219                 subq $(ISTATE_SOFT_SIZE + 8), %rsp
     242                subq $(IREGISTER_SPACE + 8), %rsp
    220243        .endif
    221244       
     245        save_all_gpr
     246        cld
     247       
    222248        /*
    223          * Save the general purpose registers.
    224          */
    225         movq %rax, ISTATE_OFFSET_RAX(%rsp)
    226         movq %rbx, ISTATE_OFFSET_RBX(%rsp)
    227         movq %rcx, ISTATE_OFFSET_RCX(%rsp)
    228         movq %rdx, ISTATE_OFFSET_RDX(%rsp)
    229         movq %rsi, ISTATE_OFFSET_RSI(%rsp)
    230         movq %rdi, ISTATE_OFFSET_RDI(%rsp)
    231         movq %rbp, ISTATE_OFFSET_RBP(%rsp)
    232         movq %r8, ISTATE_OFFSET_R8(%rsp)
    233         movq %r9, ISTATE_OFFSET_R9(%rsp)
    234         movq %r10, ISTATE_OFFSET_R10(%rsp)
    235         movq %r11, ISTATE_OFFSET_R11(%rsp)
    236         movq %r12, ISTATE_OFFSET_R12(%rsp)
    237         movq %r13, ISTATE_OFFSET_R13(%rsp)
    238         movq %r14, ISTATE_OFFSET_R14(%rsp)
    239         movq %r15, ISTATE_OFFSET_R15(%rsp)
    240 
    241         /*
    242          * Imitate a regular stack frame linkage.
    243249         * Stop stack traces here if we came from userspace.
    244250         */
     251        movq %cs, %rax
    245252        xorq %rdx, %rdx
    246         cmpq $(gdtselector(KTEXT_DES)), ISTATE_OFFSET_CS(%rsp)
    247         cmovnzq %rdx, %rbp
    248 
    249         movq %rbp, ISTATE_OFFSET_RBP_FRAME(%rsp)
    250         movq ISTATE_OFFSET_RIP(%rsp), %rax
    251         movq %rax, ISTATE_OFFSET_RIP_FRAME(%rsp)
    252         leaq ISTATE_OFFSET_RBP_FRAME(%rsp), %rbp
    253 
    254         movq $(\i), %rdi   /* pass intnum in the first argument */
    255         movq %rsp, %rsi    /* pass istate address in the second argument */
    256        
    257         cld
    258 
     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       
    259259        /* Call exc_dispatch(i, istate) */
    260260        call exc_dispatch
    261 
    262         /*
    263          * Restore all scratch registers and the preserved registers we have
    264          * clobbered in this handler (i.e. RBP).
    265          */
    266         movq ISTATE_OFFSET_RAX(%rsp), %rax
    267         movq ISTATE_OFFSET_RCX(%rsp), %rcx
    268         movq ISTATE_OFFSET_RDX(%rsp), %rdx
    269         movq ISTATE_OFFSET_RSI(%rsp), %rsi
    270         movq ISTATE_OFFSET_RDI(%rsp), %rdi
    271         movq ISTATE_OFFSET_RBP(%rsp), %rbp
    272         movq ISTATE_OFFSET_R8(%rsp), %r8
    273         movq ISTATE_OFFSET_R9(%rsp), %r9
    274         movq ISTATE_OFFSET_R10(%rsp), %r10
    275         movq ISTATE_OFFSET_R11(%rsp), %r11
     261       
     262        restore_all_gpr
    276263       
    277264        /* $8 = Skip error word */
    278         addq $(ISTATE_SOFT_SIZE + 8), %rsp
     265        addq $(IREGISTER_SPACE + 8), %rsp
    279266        iretq
     267       
     268        .align INTERRUPT_ALIGN
     269        .if (\n - \i) - 1
     270                handler "(\i + 1)", \n
     271        .endif
    280272.endm
    281273
    282 #define LIST_0_63 \
    283         0, 1, 2, 3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20,21,22,23,24,25,26,27,\
    284         28,29,30,31,32,33,34,35,36,37,38,39,40,41,42,43,44,45,46,47,48,49,50,51,52,\
    285         53,54,55,56,57,58,59,60,61,62,63
    286 
     274.align INTERRUPT_ALIGN
    287275interrupt_handlers:
    288 .irp cnt, LIST_0_63
    289         handler \cnt
    290 .endr
     276        h_start:
     277                handler 0 IDT_ITEMS
     278        h_end:
    291279
    292280/** Low-level syscall handler
    … …  
    321309        movq %gs:8, %rsp  /* set this thread's kernel RSP */
    322310       
    323         /*
    324          * Note that the space needed for the imitated istate structure has been
    325          * preallocated for us in thread_create_arch() and set in
    326          * before_thread_runs_arch().
    327          */
    328 
    329         /*
    330          * Save the general purpose registers and push the 7th argument (syscall
    331          * number) onto the stack. Note that the istate structure has a layout
    332          * which supports this.
    333          */
    334         movq %rax, ISTATE_OFFSET_RAX(%rsp)  /* 7th argument, passed on stack */
    335         movq %rbx, ISTATE_OFFSET_RBX(%rsp)  /* observability */
    336         movq %rcx, ISTATE_OFFSET_RCX(%rsp)  /* userspace RIP */
    337         movq %rdx, ISTATE_OFFSET_RDX(%rsp)  /* 3rd argument, observability */
    338         movq %rsi, ISTATE_OFFSET_RSI(%rsp)  /* 2nd argument, observability */
    339         movq %rdi, ISTATE_OFFSET_RDI(%rsp)  /* 1st argument, observability */
    340         movq %rbp, ISTATE_OFFSET_RBP(%rsp)  /* need to preserve userspace RBP */
    341         movq %r8, ISTATE_OFFSET_R8(%rsp)    /* 5th argument, observability */
    342         movq %r9, ISTATE_OFFSET_R9(%rsp)    /* 6th argument, observability */
    343         movq %r10, ISTATE_OFFSET_R10(%rsp)  /* 4th argument, observability */
    344         movq %r11, ISTATE_OFFSET_R11(%rsp)  /* low 32 bits userspace RFLAGS */
    345         movq %r12, ISTATE_OFFSET_R12(%rsp)  /* observability */
    346         movq %r13, ISTATE_OFFSET_R13(%rsp)  /* observability */
    347         movq %r14, ISTATE_OFFSET_R14(%rsp)  /* observability */
    348         movq %r15, ISTATE_OFFSET_R15(%rsp)  /* observability */
    349 
    350         /*
    351          * Save the return address and the userspace stack on locations that
    352          * would normally be taken by them.
    353          */
    354         movq %gs:0, %rax
    355         movq %rax, ISTATE_OFFSET_RSP(%rsp)
    356         movq %rcx, ISTATE_OFFSET_RIP(%rsp)
    357 
    358         /*
    359          * Imitate a regular stack frame linkage.
    360          */
    361         movq $0, ISTATE_OFFSET_RBP_FRAME(%rsp)
    362         movq %rcx, ISTATE_OFFSET_RIP_FRAME(%rsp)
    363         leaq ISTATE_OFFSET_RBP_FRAME(%rsp), %rbp
    364 
    365         /* Switch back to normal %gs */
     311        /* Switch back to remain consistent */
    366312        swapgs
    367313        sti
    368314       
     315        pushq %rcx
     316        pushq %r11
     317        pushq %rbp
     318       
     319        xorq %rbp, %rbp  /* stop the stack traces here */
     320       
    369321        /* Copy the 4th argument where it is expected  */
    370322        movq %r10, %rcx
    371 
    372         /*
    373          * Call syscall_handler() with the 7th argument passed on stack.
    374          */
     323        pushq %rax
     324       
    375325        call syscall_handler
    376326       
     327        addq $8, %rsp
     328       
     329        popq %rbp
     330        popq %r11
     331        popq %rcx
     332       
    377333        cli
    378        
    379         /*
    380          * Restore registers needed for return via the SYSRET instruction and
    381          * the clobbered preserved registers (i.e. RBP).
    382          */
    383         movq ISTATE_OFFSET_RBP(%rsp), %rbp
    384         movq ISTATE_OFFSET_RCX(%rsp), %rcx
    385         movq ISTATE_OFFSET_R11(%rsp), %r11
    386         movq ISTATE_OFFSET_RSP(%rsp), %rsp
    387 
     334        swapgs
     335       
     336        /* Restore the user RSP */
     337        movq %gs:0, %rsp
     338        swapgs
     339       
    388340        sysretq
    389341
    … …  
    532484        ret
    533485
     486.data
     487.global interrupt_handler_size
     488
     489interrupt_handler_size: .quad (h_end - h_start) / IDT_ITEMS

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

    r074c9bd r41ce4d9  
    6565void istate_decode(istate_t *istate)
    6666{
    67         printf("cs =%p\trip=%p\trfl=%p\terr=%p\n",
    68             istate->cs, istate->rip, istate->rflags, istate->error_word);
    69 
    70         if (istate_from_uspace(istate))
    71                 printf("ss =%p\n", istate->ss);
    72        
    73         printf("rax=%p\trbx=%p\trcx=%p\trdx=%p\n",
    74             istate->rax, istate->rbx, istate->rcx, istate->rdx);
    75         printf("rsi=%p\trdi=%p\trbp=%p\trsp=%p\n",
    76             istate->rsi, istate->rdi, istate->rbp,
    77             istate_from_uspace(istate) ? istate->rsp : (uintptr_t)&istate->rsp);
    78         printf("r8 =%p\tr9 =%p\tr10=%p\tr11=%p\n",
    79             istate->r8, istate->r9, istate->r10, istate->r11);
    80         printf("r12=%p\tr13=%p\tr14=%p\tr15=%p\n",
    81             istate->r12, istate->r13, istate->r14, istate->r15);
     67        printf("error_word=%#llx\n", istate->error_word);
     68        printf("cs =%#0.16llx\trflags=%#0.16llx\n", istate->cs,
     69            istate->rflags);
     70        printf("rax=%#0.16llx\trbx=%#0.16llx\trcx=%#0.16llx\n", istate->rax,
     71            istate->rcx, istate->rdx);
     72        printf("rsi=%#0.16llx\trdi=%#0.16llx\tr8 =%#0.16llx\n", istate->rsi,
     73            istate->rdi, istate->r8);
     74        printf("r9 =%#0.16llx\tr10=%#0.16llx\tr11=%#0.16llx\n", istate->r9,
     75            istate->r10, istate->r11);
    8276}
    8377

  • kernel/arch/amd64/src/mm/page.c

    r074c9bd r41ce4d9  
    9090        if (as_page_fault(page, access, istate) == AS_PF_FAULT) {
    9191                fault_if_from_uspace(istate, "Page fault: %#x.", page);
    92                 panic_memtrap(istate, access, page, NULL);
     92                panic_memtrap(istate, access, page, "Page fault.");
    9393        }
    9494}

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

    r074c9bd r41ce4d9  
    175175                d->present = 1;
    176176                d->type = AR_INTERRUPT; /* masking interrupt */
     177
     178                idt_setoffset(d, ((uintptr_t) interrupt_handlers) +
     179                    i * interrupt_handler_size);
    177180        }
    178 
    179         d = &idt[0];
    180         idt_setoffset(d++, (uintptr_t) &int_0);
    181         idt_setoffset(d++, (uintptr_t) &int_1);
    182         idt_setoffset(d++, (uintptr_t) &int_2);
    183         idt_setoffset(d++, (uintptr_t) &int_3);
    184         idt_setoffset(d++, (uintptr_t) &int_4);
    185         idt_setoffset(d++, (uintptr_t) &int_5);
    186         idt_setoffset(d++, (uintptr_t) &int_6);
    187         idt_setoffset(d++, (uintptr_t) &int_7);
    188         idt_setoffset(d++, (uintptr_t) &int_8);
    189         idt_setoffset(d++, (uintptr_t) &int_9);
    190         idt_setoffset(d++, (uintptr_t) &int_10);
    191         idt_setoffset(d++, (uintptr_t) &int_11);
    192         idt_setoffset(d++, (uintptr_t) &int_12);
    193         idt_setoffset(d++, (uintptr_t) &int_13);
    194         idt_setoffset(d++, (uintptr_t) &int_14);
    195         idt_setoffset(d++, (uintptr_t) &int_15);
    196         idt_setoffset(d++, (uintptr_t) &int_16);
    197         idt_setoffset(d++, (uintptr_t) &int_17);
    198         idt_setoffset(d++, (uintptr_t) &int_18);
    199         idt_setoffset(d++, (uintptr_t) &int_19);
    200         idt_setoffset(d++, (uintptr_t) &int_20);
    201         idt_setoffset(d++, (uintptr_t) &int_21);
    202         idt_setoffset(d++, (uintptr_t) &int_22);
    203         idt_setoffset(d++, (uintptr_t) &int_23);
    204         idt_setoffset(d++, (uintptr_t) &int_24);
    205         idt_setoffset(d++, (uintptr_t) &int_25);
    206         idt_setoffset(d++, (uintptr_t) &int_26);
    207         idt_setoffset(d++, (uintptr_t) &int_27);
    208         idt_setoffset(d++, (uintptr_t) &int_28);
    209         idt_setoffset(d++, (uintptr_t) &int_29);
    210         idt_setoffset(d++, (uintptr_t) &int_30);
    211         idt_setoffset(d++, (uintptr_t) &int_31);
    212         idt_setoffset(d++, (uintptr_t) &int_32);
    213         idt_setoffset(d++, (uintptr_t) &int_33);
    214         idt_setoffset(d++, (uintptr_t) &int_34);
    215         idt_setoffset(d++, (uintptr_t) &int_35);
    216         idt_setoffset(d++, (uintptr_t) &int_36);
    217         idt_setoffset(d++, (uintptr_t) &int_37);
    218         idt_setoffset(d++, (uintptr_t) &int_38);
    219         idt_setoffset(d++, (uintptr_t) &int_39);
    220         idt_setoffset(d++, (uintptr_t) &int_40);
    221         idt_setoffset(d++, (uintptr_t) &int_41);
    222         idt_setoffset(d++, (uintptr_t) &int_42);
    223         idt_setoffset(d++, (uintptr_t) &int_43);
    224         idt_setoffset(d++, (uintptr_t) &int_44);
    225         idt_setoffset(d++, (uintptr_t) &int_45);
    226         idt_setoffset(d++, (uintptr_t) &int_46);
    227         idt_setoffset(d++, (uintptr_t) &int_47);
    228         idt_setoffset(d++, (uintptr_t) &int_48);
    229         idt_setoffset(d++, (uintptr_t) &int_49);
    230         idt_setoffset(d++, (uintptr_t) &int_50);
    231         idt_setoffset(d++, (uintptr_t) &int_51);
    232         idt_setoffset(d++, (uintptr_t) &int_52);
    233         idt_setoffset(d++, (uintptr_t) &int_53);
    234         idt_setoffset(d++, (uintptr_t) &int_54);
    235         idt_setoffset(d++, (uintptr_t) &int_55);
    236         idt_setoffset(d++, (uintptr_t) &int_56);
    237         idt_setoffset(d++, (uintptr_t) &int_57);
    238         idt_setoffset(d++, (uintptr_t) &int_58);
    239         idt_setoffset(d++, (uintptr_t) &int_59);
    240         idt_setoffset(d++, (uintptr_t) &int_60);
    241         idt_setoffset(d++, (uintptr_t) &int_61);
    242         idt_setoffset(d++, (uintptr_t) &int_62);
    243         idt_setoffset(d++, (uintptr_t) &int_63);
    244181}
    245182

  • kernel/arch/amd64/src/proc/scheduler.c

    r074c9bd r41ce4d9  
    3838#include <proc/thread.h>
    3939#include <arch.h>
     40#include <arch/context.h>
    4041#include <arch/asm.h>
    4142#include <print.h>
    … …  
    5657{
    5758        CPU->arch.tss->rsp0 =
    58             (uintptr_t) &THREAD->kstack[THREAD_STACK_SIZE];
     59            (uintptr_t) &THREAD->kstack[THREAD_STACK_SIZE - SP_DELTA];
    5960       
    6061        /*

  • kernel/arch/amd64/src/proc/thread.c

    r074c9bd r41ce4d9  
    3434
    3535#include <proc/thread.h>
    36 #include <arch/interrupt.h>
    3736
    3837/** Perform amd64 specific thread initialization.
    … …  
    5049         */
    5150        thread->arch.syscall_rsp[SYSCALL_KSTACK_RSP] =
    52             (uintptr_t) &thread->kstack[PAGE_SIZE - sizeof(istate_t)];
     51            (uintptr_t) &thread->kstack[PAGE_SIZE - sizeof(uint64_t)];
    5352}
    5453

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

    r074c9bd r41ce4d9  
    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/arm32/src/mm/page_fault.c

    r074c9bd r41ce4d9  
    183183        if (ret == AS_PF_FAULT) {
    184184                fault_if_from_uspace(istate, "Page fault: %#x.", badvaddr);
    185                 panic_memtrap(istate, access, badvaddr, NULL);
     185                panic_memtrap(istate, access, badvaddr, "Page fault.");
    186186        }
    187187}
    … …  
    198198
    199199        if (ret == AS_PF_FAULT) {
    200                 fault_if_from_uspace(istate,
    201                     "Page fault - prefetch_abort: %#x.", istate->pc);
    202                 panic_memtrap(istate, PF_ACCESS_EXEC, istate->pc, NULL);
     200                panic_memtrap(istate, PF_ACCESS_EXEC, istate->pc,
     201                    "Page fault - prefetch_abort.");
    203202        }
    204203}

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

    r074c9bd r41ce4d9  
    4343#include <trace.h>
    4444
     45extern uint32_t interrupt_handler_size;
     46
    4547/** Halt CPU
    4648 *
    … …  
    427429extern void asm_delay_loop(uint32_t);
    428430extern void asm_fake_loop(uint32_t);
    429 
    430 extern uintptr_t int_syscall;
    431431
    432432extern uintptr_t int_0;

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

    r074c9bd r41ce4d9  
    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/include/pm.h

    r074c9bd r41ce4d9  
    6767#define AR_CODE       (3 << 3)
    6868#define AR_WRITABLE   (1 << 1)
    69 #define AR_INTERRUPT  (0xe)
    70 #define AR_TRAP       (0xf)
    71 #define AR_TSS        (0x9)
     69#define AR_INTERRUPT  (0x0e)
     70#define AR_TSS        (0x09)
    7271
    7372#define DPL_KERNEL  (PL_KERNEL << 5)

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

    r074c9bd r41ce4d9  
    11/*
    2  * Copyright (c) 2010 Jakub Jermar
     2 * Copyright (c) 2001 Jakub Jermar
    33 * All rights reserved.
    44 *
    … …  
    3131 */
    3232
     33/**
     34 * Mask for interrupts 0 - 31 (bits 0 - 31) where 0 means that int
     35 * has no error word  and 1 means interrupt with error word
     36 *
     37 */
     38#define ERROR_WORD_INTERRUPT_LIST  0x00027d00
     39
    3340#include <arch/pm.h>
    34 #include <arch/cpu.h>
    3541#include <arch/mm/page.h>
    3642
    … …  
    147153        wrmsr
    148154        ret
     155
     156/** Clear nested flag
     157 *
     158 */
     159.macro CLEAR_NT_FLAG
     160        pushfl
     161        andl $0xffffbfff, (%esp)
     162        popfl
     163.endm
    149164
    150165#define ISTATE_OFFSET_EDX         0
    … …  
    175190
    176191/*
     192 * Size of the entire istate structure including the error word and the
     193 * hardware-saved part.
     194 */
     195#define ISTATE_REAL_SIZE  (ISTATE_SOFT_SIZE + 24)
     196
     197/*
    177198 * The SYSENTER syscall mechanism can be used for syscalls with
    178199 * four or fewer arguments. To pass these four arguments, we
    … …  
    185206.global sysenter_handler
    186207sysenter_handler:
    187 
    188         /*
    189          * Note that the space needed for the istate structure has been
    190          * preallocated on the stack by before_thread_runs_arch().
    191          */
     208        sti
     209        subl $(ISTATE_REAL_SIZE), %esp
    192210
    193211        /*
    … …  
    225243         * Switch to kernel selectors.
    226244         */
    227         movw $(gdtselector(KDATA_DES)), %ax
     245        movw $16, %ax
    228246        movw %ax, %ds
    229247        movw %ax, %es
    230248       
    231         /*
    232          * Sanitize EFLAGS.
    233          *
    234          * SYSENTER does not clear the NT flag, which could thus proliferate
    235          * from here to the IRET instruction via a context switch and result
    236          * in crash.
    237          *
    238          * SYSENTER does not clear DF, which the ABI assumes to be cleared.
    239          *
    240          * SYSENTER clears IF, which we would like to be set for syscalls.
    241          *
    242          */
    243         pushl $(EFLAGS_IF)  /* specify EFLAGS bits that we want to set */
    244         popfl               /* set bits from the mask, clear or ignore others */
    245 
     249        cld
    246250        call syscall_handler
    247251       
    … …  
    258262        movl ISTATE_OFFSET_ESP(%esp), %ecx
    259263
     264        addl $(ISTATE_REAL_SIZE), %esp
     265       
    260266        sysexit   /* return to userspace */
    261267
    262 /*
    263  * This is the legacy syscall handler using the interrupt mechanism.
    264  */
    265 .global int_syscall
    266 int_syscall:
    267         subl $(ISTATE_SOFT_SIZE + 4), %esp
    268 
    269         /*
    270          * Push syscall arguments onto the stack
    271          *
    272          * NOTE: The idea behind the order of arguments passed
    273          *       in registers is to use all scratch registers
    274          *       first and preserved registers next. An optimized
    275          *       libc syscall wrapper can make use of this setup.
    276          *       The istate structure is arranged in the way to support
    277          *       this idea.
    278          *
    279          */
    280         movl %eax, ISTATE_OFFSET_EAX(%esp)
    281         movl %ebx, ISTATE_OFFSET_EBX(%esp)
    282         movl %ecx, ISTATE_OFFSET_ECX(%esp)
    283         movl %edx, ISTATE_OFFSET_EDX(%esp)
    284         movl %edi, ISTATE_OFFSET_EDI(%esp)
    285         movl %esi, ISTATE_OFFSET_ESI(%esp)
    286         movl %ebp, ISTATE_OFFSET_EBP(%esp)
    287 
    288         /*
    289          * Save the selector registers.
    290          */
    291         movl %gs, %ecx
    292         movl %fs, %edx
    293 
    294         movl %ecx, ISTATE_OFFSET_GS(%esp)
    295         movl %edx, ISTATE_OFFSET_FS(%esp)
    296 
    297         movl %es, %ecx
    298         movl %ds, %edx
    299                
    300         movl %ecx, ISTATE_OFFSET_ES(%esp)
    301         movl %edx, ISTATE_OFFSET_DS(%esp)
    302 
    303         /*
    304          * Switch to kernel selectors.
    305          */
    306         movl $(gdtselector(KDATA_DES)), %eax
    307         movl %eax, %ds
    308         movl %eax, %es
    309                
    310         movl $0, ISTATE_OFFSET_EBP_FRAME(%esp)
    311         movl ISTATE_OFFSET_EIP(%esp), %eax
    312         movl %eax, ISTATE_OFFSET_EIP_FRAME(%esp)
    313         leal ISTATE_OFFSET_EBP_FRAME(%esp), %ebp
    314                
    315         cld
    316                
    317         /* Call syscall_handler(edx, ecx, ebx, esi, edi, ebp, eax) */
    318         call syscall_handler
    319                        
    320         /*
    321          * Restore the selector registers.
    322          */
    323         movl ISTATE_OFFSET_GS(%esp), %ecx
    324         movl ISTATE_OFFSET_FS(%esp), %edx
    325 
    326         movl %ecx, %gs
    327         movl %edx, %fs
    328 
    329         movl ISTATE_OFFSET_ES(%esp), %ecx
    330         movl ISTATE_OFFSET_DS(%esp), %edx
    331                        
    332         movl %ecx, %es
    333         movl %edx, %ds
    334                        
    335         /*
    336          * Restore the preserved registers the handler cloberred itself
    337          * (i.e. EBP).
    338          */
    339         movl ISTATE_OFFSET_EBP(%esp), %ebp
    340                        
    341         addl $(ISTATE_SOFT_SIZE + 4), %esp
    342         iret
    343                
    344 /**
    345  * Mask for interrupts 0 - 31 (bits 0 - 31) where 0 means that int
    346  * has no error word  and 1 means interrupt with error word
    347  *
    348  */
    349 #define ERROR_WORD_INTERRUPT_LIST  0x00027d00
     268/** Declare interrupt handlers
     269 *
     270 * Declare interrupt handlers for n interrupt
     271 * vectors starting at vector i.
     272 *
     273 */
    350274
    351275.macro handler i
    352276.global int_\i
    353277int_\i:
    354         /*
    355          * This macro distinguishes between two versions of ia32
    356          * exceptions. One version has error word and the other
    357          * does not have it. The latter version fakes the error
    358          * word on the stack so that the handlers and istate_t
    359          * can be the same for both types.
    360          */
    361         .iflt \i - 32
    362                 .if (1 << \i) & ERROR_WORD_INTERRUPT_LIST
    363                         /*
    364                          * Exception with error word.
    365                          */
    366                         subl $ISTATE_SOFT_SIZE, %esp
     278        .ifeq \i - 0x30
     279                /* Syscall handler */
     280                subl $(ISTATE_SOFT_SIZE + 4), %esp
     281
     282                /*
     283                 * Push syscall arguments onto the stack
     284                 *
     285                 * NOTE: The idea behind the order of arguments passed
     286                 *       in registers is to use all scratch registers
     287                 *       first and preserved registers next. An optimized
     288                 *       libc syscall wrapper can make use of this setup.
     289                 *       The istate structure is arranged in the way to support
     290                 *       this idea.
     291                 *
     292                 */
     293                movl %eax, ISTATE_OFFSET_EAX(%esp)
     294                movl %ebx, ISTATE_OFFSET_EBX(%esp)
     295                movl %ecx, ISTATE_OFFSET_ECX(%esp)
     296                movl %edx, ISTATE_OFFSET_EDX(%esp)
     297                movl %edi, ISTATE_OFFSET_EDI(%esp)
     298                movl %esi, ISTATE_OFFSET_ESI(%esp)
     299                movl %ebp, ISTATE_OFFSET_EBP(%esp)
     300
     301                /*
     302                 * Save the selector registers.
     303                 */
     304                movl %gs, %ecx
     305                movl %fs, %edx
     306
     307                movl %ecx, ISTATE_OFFSET_GS(%esp)
     308                movl %edx, ISTATE_OFFSET_FS(%esp)
     309
     310                movl %es, %ecx
     311                movl %ds, %edx
     312               
     313                movl %ecx, ISTATE_OFFSET_ES(%esp)
     314                movl %edx, ISTATE_OFFSET_DS(%esp)
     315
     316                /*
     317                 * Switch to kernel selectors.
     318                 */
     319                movl $16, %eax
     320                movl %eax, %ds
     321                movl %eax, %es
     322               
     323                movl $0, ISTATE_OFFSET_EBP_FRAME(%esp)
     324                movl ISTATE_OFFSET_EIP(%esp), %eax
     325                movl %eax, ISTATE_OFFSET_EIP_FRAME(%esp)
     326                leal ISTATE_OFFSET_EBP_FRAME(%esp), %ebp
     327               
     328                cld
     329                sti
     330               
     331                /* Call syscall_handler(edx, ecx, ebx, esi, edi, ebp, eax) */
     332                call syscall_handler
     333                       
     334                CLEAR_NT_FLAG
     335
     336                /*
     337                 * Restore the selector registers.
     338                 */
     339                movl ISTATE_OFFSET_GS(%esp), %ecx
     340                movl ISTATE_OFFSET_FS(%esp), %edx
     341
     342                movl %ecx, %gs
     343                movl %edx, %fs
     344
     345                movl ISTATE_OFFSET_ES(%esp), %ecx
     346                movl ISTATE_OFFSET_DS(%esp), %edx
     347                       
     348                movl %ecx, %es
     349                movl %edx, %ds
     350                       
     351                /*
     352                 * Restore the preserved registers the handler cloberred itself
     353                 * (i.e. EBP).
     354                 */
     355                movl ISTATE_OFFSET_EBP(%esp), %ebp
     356                       
     357                addl $(ISTATE_SOFT_SIZE + 4), %esp
     358                iret
     359               
     360        .else
     361                /*
     362                 * This macro distinguishes between two versions of ia32
     363                 * exceptions. One version has error word and the other
     364                 * does not have it. The latter version fakes the error
     365                 * word on the stack so that the handlers and istate_t
     366                 * can be the same for both types.
     367                 */
     368                .iflt \i - 32
     369                        .if (1 << \i) & ERROR_WORD_INTERRUPT_LIST
     370                                /*
     371                                 * Exception with error word: do nothing
     372                                 */
     373                        .else
     374                                /*
     375                                 * Exception without error word: fake up one
     376                                 */
     377                                pushl $0
     378                        .endif
    367379                .else
    368380                        /*
    369                          * Exception without error word: fake up one
     381                         * Interrupt: fake up one
    370382                         */
    371                         subl $(ISTATE_SOFT_SIZE + 4), %esp
     383                        pushl $0
    372384                .endif
    373         .else
    374                 /*
    375                  * Interrupt: fake up an error word
    376                  */
    377                 subl $(ISTATE_SOFT_SIZE + 4), %esp
     385               
     386                subl $ISTATE_SOFT_SIZE, %esp
     387               
     388                /*
     389                 * Save the general purpose registers.
     390                 */
     391                movl %eax, ISTATE_OFFSET_EAX(%esp)
     392                movl %ebx, ISTATE_OFFSET_EBX(%esp)
     393                movl %ecx, ISTATE_OFFSET_ECX(%esp)
     394                movl %edx, ISTATE_OFFSET_EDX(%esp)
     395                movl %edi, ISTATE_OFFSET_EDI(%esp)
     396                movl %esi, ISTATE_OFFSET_ESI(%esp)
     397                movl %ebp, ISTATE_OFFSET_EBP(%esp)
     398               
     399                /*
     400                 * Save the selector registers.
     401                 */
     402                movl %gs, %eax
     403                movl %fs, %ebx
     404                movl %es, %ecx
     405                movl %ds, %edx
     406               
     407                movl %eax, ISTATE_OFFSET_GS(%esp)
     408                movl %ebx, ISTATE_OFFSET_FS(%esp)
     409                movl %ecx, ISTATE_OFFSET_ES(%esp)
     410                movl %edx, ISTATE_OFFSET_DS(%esp)
     411               
     412                /*
     413                 * Switch to kernel selectors.
     414                 */
     415                movl $16, %eax
     416                movl %eax, %ds
     417                movl %eax, %es
     418               
     419                /*
     420                 * Imitate a regular stack frame linkage.
     421                 * Stop stack traces here if we came from userspace.
     422                 */
     423                cmpl $8, ISTATE_OFFSET_CS(%esp)
     424                jz 0f
     425                xorl %ebp, %ebp
     426               
     427                0:
     428               
     429                        movl %ebp, ISTATE_OFFSET_EBP_FRAME(%esp)
     430                        movl ISTATE_OFFSET_EIP(%esp), %eax
     431                        movl %eax, ISTATE_OFFSET_EIP_FRAME(%esp)
     432                        leal ISTATE_OFFSET_EBP_FRAME(%esp), %ebp
     433                       
     434                        cld
     435                       
     436                        pushl %esp   /* pass istate address */
     437                        pushl $(\i)  /* pass intnum */
     438                       
     439                        /* Call exc_dispatch(intnum, istate) */
     440                        call exc_dispatch
     441                       
     442                        addl $8, %esp  /* clear arguments from the stack */
     443                       
     444                        CLEAR_NT_FLAG
     445                       
     446                        /*
     447                         * Restore the selector registers.
     448                         */
     449                        movl ISTATE_OFFSET_GS(%esp), %eax
     450                        movl ISTATE_OFFSET_FS(%esp), %ebx
     451                        movl ISTATE_OFFSET_ES(%esp), %ecx
     452                        movl ISTATE_OFFSET_DS(%esp), %edx
     453                       
     454                        movl %eax, %gs
     455                        movl %ebx, %fs
     456                        movl %ecx, %es
     457                        movl %edx, %ds
     458                       
     459                        /*
     460                         * Restore the scratch registers and the preserved
     461                         * registers the handler cloberred itself
     462                         * (i.e. EBX and EBP).
     463                         */
     464                        movl ISTATE_OFFSET_EAX(%esp), %eax
     465                        movl ISTATE_OFFSET_EBX(%esp), %ebx
     466                        movl ISTATE_OFFSET_ECX(%esp), %ecx
     467                        movl ISTATE_OFFSET_EDX(%esp), %edx
     468                        movl ISTATE_OFFSET_EBP(%esp), %ebp
     469                       
     470                        addl $(ISTATE_SOFT_SIZE + 4), %esp
     471                        iret
     472               
    378473        .endif
    379        
    380         /*
    381          * Save the general purpose registers.
    382          */
    383         movl %eax, ISTATE_OFFSET_EAX(%esp)
    384         movl %ebx, ISTATE_OFFSET_EBX(%esp)
    385         movl %ecx, ISTATE_OFFSET_ECX(%esp)
    386         movl %edx, ISTATE_OFFSET_EDX(%esp)
    387         movl %edi, ISTATE_OFFSET_EDI(%esp)
    388         movl %esi, ISTATE_OFFSET_ESI(%esp)
    389         movl %ebp, ISTATE_OFFSET_EBP(%esp)
    390        
    391         /*
    392          * Save the selector registers.
    393          */
    394         movl %gs, %ecx
    395         movl %fs, %edx
    396 
    397         movl %ecx, ISTATE_OFFSET_GS(%esp)
    398         movl %edx, ISTATE_OFFSET_FS(%esp)
    399 
    400         movl %es, %ecx
    401         movl %ds, %edx
    402        
    403         movl %ecx, ISTATE_OFFSET_ES(%esp)
    404         movl %edx, ISTATE_OFFSET_DS(%esp)
    405        
    406         /*
    407          * Switch to kernel selectors.
    408          */
    409         movl $(gdtselector(KDATA_DES)), %eax
    410         movl %eax, %ds
    411         movl %eax, %es
    412        
    413         /*
    414          * Imitate a regular stack frame linkage.
    415          * Stop stack traces here if we came from userspace.
    416          */
    417         xorl %eax, %eax
    418         cmpl $(gdtselector(KTEXT_DES)), ISTATE_OFFSET_CS(%esp)
    419         cmovnzl %eax, %ebp
    420 
    421         movl %ebp, ISTATE_OFFSET_EBP_FRAME(%esp)
    422         movl ISTATE_OFFSET_EIP(%esp), %eax
    423         movl %eax, ISTATE_OFFSET_EIP_FRAME(%esp)
    424         leal ISTATE_OFFSET_EBP_FRAME(%esp), %ebp
    425                
    426         cld
    427                
    428         pushl %esp   /* pass istate address */
    429         pushl $(\i)  /* pass intnum */
    430                
    431         /* Call exc_dispatch(intnum, istate) */
    432         call exc_dispatch
    433                
    434         addl $8, %esp  /* clear arguments from the stack */
    435                
    436         /*
    437          * Restore the selector registers.
    438          */
    439         movl ISTATE_OFFSET_GS(%esp), %ecx
    440         movl ISTATE_OFFSET_FS(%esp), %edx
    441 
    442         movl %ecx, %gs
    443         movl %edx, %fs
    444 
    445         movl ISTATE_OFFSET_ES(%esp), %ecx
    446         movl ISTATE_OFFSET_DS(%esp), %edx
    447                
    448         movl %ecx, %es
    449         movl %edx, %ds
    450                
    451         /*
    452          * Restore the scratch registers and the preserved
    453          * registers the handler cloberred itself
    454          * (i.e. EBP).
    455          */
    456         movl ISTATE_OFFSET_EAX(%esp), %eax
    457         movl ISTATE_OFFSET_ECX(%esp), %ecx
    458         movl ISTATE_OFFSET_EDX(%esp), %edx
    459         movl ISTATE_OFFSET_EBP(%esp), %ebp
    460                
    461         addl $(ISTATE_SOFT_SIZE + 4), %esp
    462         iret
    463474.endm
    464475

  • kernel/arch/ia32/src/interrupt.c

    r074c9bd r41ce4d9  
    6565void istate_decode(istate_t *istate)
    6666{
    67         printf("cs =%p\teip=%p\tefl=%p\terr=%p\n",
    68             istate->cs, istate->eip, istate->eflags, istate->error_word);
    69 
    70         printf("ds =%p\tes =%p\tfs =%p\tgs =%p\n",
    71             istate->ds, istate->es, istate->fs, istate->gs);
     67        printf("error_word=%p\n", istate->error_word);
     68        printf("eflags=%p\n", istate->eflags);
     69
     70        printf("cs =%p\tds =%p\tes =%p\n", istate->cs, istate->ds, istate->es);
     71        printf("fs =%p\tgs =%p", istate->fs, istate->gs);
    7272        if (istate_from_uspace(istate))
    73                 printf("ss =%p\n", istate->ss);
    74 
    75         printf("eax=%p\tebx=%p\tecx=%p\tedx=%p\n",
    76             istate->eax, istate->ebx, istate->ecx, istate->edx);
    77         printf("esi=%p\tedi=%p\tebp=%p\tesp=%p\n",
    78             istate->esi, istate->edi, istate->ebp,
    79             istate_from_uspace(istate) ? istate->esp : (uintptr_t)&istate->esp);
     73                printf("\tss =%p\n", istate->ss);
     74        else
     75                printf("\n");
     76
     77        printf("eax=%p\tebx=%p\tecx=%p\n", istate->eax, istate->ebx,
     78            istate->ecx);
     79        printf("edx=%p\tedi=%p\tesi=%p\n", istate->edx, istate->edi,
     80            istate->esi);
     81        printf("ebp=%p\tesp=%p\teip=%p\n", istate->ebp,
     82            istate_from_uspace(istate) ? istate->esp : (uintptr_t) &istate->esp,
     83            istate->eip);
    8084}
    8185

  • kernel/arch/ia32/src/mm/page.c

    r074c9bd r41ce4d9  
    115115        if (as_page_fault(page, access, istate) == AS_PF_FAULT) {
    116116                fault_if_from_uspace(istate, "Page fault: %#x.", page);
    117                 panic_memtrap(istate, access, page, NULL);
     117                panic_memtrap(istate, access, page, "Page fault.");
    118118        }
    119119}

  • kernel/arch/ia32/src/pm.c

    r074c9bd r41ce4d9  
    130130                d->selector = gdtselector(KTEXT_DES);
    131131
     132                d->access = AR_PRESENT | AR_INTERRUPT;  /* masking interrupt */
     133
    132134                if (i == VECTOR_SYSCALL) {
    133135                        /*
    134                          * The syscall trap gate must be callable from
    135                          * userland. Interrupts will remain enabled.
     136                         * The syscall interrupt gate must be calleable from
     137                         * userland.
    136138                         */
    137                         d->access = AR_PRESENT | AR_TRAP | DPL_USER;
    138                 } else {
    139                         /*
    140                          * Other interrupts use interrupt gates which
    141                          * disable interrupts.
    142                          */
    143                         d->access = AR_PRESENT | AR_INTERRUPT;
     139                        d->access |= DPL_USER;
    144140                }
    145141        }
    … …  
    210206        idt_setoffset(d++, (uintptr_t) &int_62);
    211207        idt_setoffset(d++, (uintptr_t) &int_63);
    212 
    213         idt_setoffset(&idt[VECTOR_SYSCALL], (uintptr_t) &int_syscall);
    214208}
    215209

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

    r074c9bd r41ce4d9  
    3838#include <proc/thread.h>
    3939#include <arch.h>
    40 #include <arch/interrupt.h>
     40#include <arch/context.h>  /* SP_DELTA */
    4141#include <arch/pm.h>
    4242#include <arch/asm.h>
    … …  
    5858void before_thread_runs_arch(void)
    5959{
    60         uintptr_t kstk = (uintptr_t) &THREAD->kstack[THREAD_STACK_SIZE];
     60        uintptr_t kstk = (uintptr_t) &THREAD->kstack[THREAD_STACK_SIZE -
     61            SP_DELTA];
    6162       
    6263        if (CPU->arch.fi.bits.sep) {
    6364                /* Set kernel stack for CP3 -> CPL0 switch via SYSENTER */
    64                 write_msr(IA32_MSR_SYSENTER_ESP, kstk - sizeof(istate_t));
     65                write_msr(IA32_MSR_SYSENTER_ESP, kstk);
    6566        }
    6667       

  • kernel/arch/ia64/src/mm/tlb.c

    r074c9bd r41ce4d9  
    500500                if (as_page_fault(va, PF_ACCESS_EXEC, istate) == AS_PF_FAULT) {
    501501                        fault_if_from_uspace(istate, "Page fault at %p.", va);
    502                         panic_memtrap(istate, PF_ACCESS_EXEC, va, NULL);
     502                        panic_memtrap(istate, PF_ACCESS_EXEC, va,
     503                            "Page fault.");
    503504                }
    504505        }
    … …  
    621622                if (as_page_fault(va, PF_ACCESS_READ, istate) == AS_PF_FAULT) {
    622623                        fault_if_from_uspace(istate, "Page fault at %p.", va);
    623                         panic_memtrap(istate, PF_ACCESS_UNKNOWN, va, NULL);
     624                        panic_memtrap(istate, PF_ACCESS_READ, va,
     625                            "Page fault.");
    624626                }
    625627        }
    … …  
    669671                if (as_page_fault(va, PF_ACCESS_WRITE, istate) == AS_PF_FAULT) {
    670672                        fault_if_from_uspace(istate, "Page fault at %p.", va);
    671                         panic_memtrap(istate, PF_ACCESS_WRITE, va, NULL);
     673                        panic_memtrap(istate, PF_ACCESS_WRITE, va,
     674                            "Page fault.");
    672675                }
    673676        }
    … …  
    705708                if (as_page_fault(va, PF_ACCESS_EXEC, istate) == AS_PF_FAULT) {
    706709                        fault_if_from_uspace(istate, "Page fault at %p.", va);
    707                         panic_memtrap(istate, PF_ACCESS_EXEC, va, NULL);
     710                        panic_memtrap(istate, PF_ACCESS_EXEC, va,
     711                            "Page fault.");
    708712                }
    709713        }
    … …  
    741745                if (as_page_fault(va, PF_ACCESS_READ, istate) == AS_PF_FAULT) {
    742746                        fault_if_from_uspace(istate, "Page fault at %p.", va);
    743                         panic_memtrap(istate, PF_ACCESS_UNKNOWN, va, NULL);
     747                        panic_memtrap(istate, PF_ACCESS_READ, va,
     748                            "Page fault.");
    744749                }
    745750        }
    … …  
    773778        if (as_page_fault(va, PF_ACCESS_WRITE, istate) == AS_PF_FAULT) {
    774779                fault_if_from_uspace(istate, "Page fault at %p.", va);
    775                 panic_memtrap(istate, PF_ACCESS_WRITE, va, NULL);
     780                panic_memtrap(istate, PF_ACCESS_WRITE, va, "Page fault.");
    776781        }
    777782        page_table_unlock(AS, true);
    … …  
    813818                if (as_page_fault(va, PF_ACCESS_READ, istate) == AS_PF_FAULT) {
    814819                        fault_if_from_uspace(istate, "Page fault at %p.", va);
    815                         panic_memtrap(istate, PF_ACCESS_UNKNOWN, va, NULL);
     820                        panic_memtrap(istate, PF_ACCESS_READ, va,
     821                            "Page fault.");
    816822                }
    817823        }

  • kernel/arch/mips32/src/mm/tlb.c

    r074c9bd r41ce4d9  
    324324       
    325325        fault_if_from_uspace(istate, "TLB Refill Exception on %p.", va);
    326         panic_memtrap(istate, PF_ACCESS_UNKNOWN, va, "TLB Refill Exception.");
     326        panic_memtrap(istate, PF_ACCESS_READ, va, "TLB Refill Exception.");
    327327}
    328328
    … …  
    333333       
    334334        fault_if_from_uspace(istate, "TLB Invalid Exception on %p.", va);
    335         panic_memtrap(istate, PF_ACCESS_UNKNOWN, va, "TLB Invalid Exception.");
     335        panic_memtrap(istate, PF_ACCESS_READ, va, "TLB Invalid Exception.");
    336336}
    337337

  • kernel/arch/ppc32/src/mm/tlb.c

    r074c9bd r41ce4d9  
    112112{
    113113        fault_if_from_uspace(istate, "PHT Refill Exception on %p.", badvaddr);
    114         panic_memtrap(istate, PF_ACCESS_UNKNOWN, badvaddr,
     114        panic_memtrap(istate, PF_ACCESS_READ, badvaddr,
    115115            "PHT Refill Exception.");
    116116}

  • kernel/arch/sparc64/src/mm/sun4u/tlb.c

    r074c9bd r41ce4d9  
    259259                        /* NULL access in kernel */
    260260                        do_fast_data_access_mmu_miss_fault(istate, tag,
    261                             "Dereferencing NULL pointer.");
     261                            "Dereferencing NULL pointer");
    262262                } else if (page_8k >= end_of_identity) {
    263263                        /*
    … …  
    442442{
    443443        fault_if_from_uspace(istate, "%s, Address=%p.", str, va);
    444         panic_memtrap(istate, PF_ACCESS_EXEC, va, str);
     444        panic_memtrap(istate, PF_ACCESS_EXEC, va, "%s.", str);
    445445}
    446446
    … …  
    453453        fault_if_from_uspace(istate, "%s, Page=%p (ASID=%d).", str, va,
    454454            tag.context);
    455         panic_memtrap(istate, PF_ACCESS_UNKNOWN, va, str);
     455        panic_memtrap(istate, PF_ACCESS_READ, va, "%s.", str);
    456456}
    457457
    … …  
    464464        fault_if_from_uspace(istate, "%s, Page=%p (ASID=%d).", str, va,
    465465            tag.context);
    466         panic_memtrap(istate, PF_ACCESS_WRITE, va, str);
     466        panic_memtrap(istate, PF_ACCESS_WRITE, va, "%s.", str);
    467467}
    468468

  • kernel/arch/sparc64/src/mm/sun4v/tlb.c

    r074c9bd r41ce4d9  
    359359{
    360360        fault_if_from_uspace(istate, "%s, Address=%p.", str, va);
    361         panic_memtrap(istate, PF_ACCESS_EXEC, va, str);
     361        panic_memtrap(istate, PF_ACCESS_EXEC, va, "%s.", str);
    362362}
    363363
    … …  
    367367        fault_if_from_uspace(istate, "%s, Page=%p (ASID=%d).", str,
    368368            DMISS_ADDRESS(page_and_ctx), DMISS_CONTEXT(page_and_ctx));
    369         panic_memtrap(istate, PF_ACCESS_UNKNOWN, DMISS_ADDRESS(page_and_ctx),
    370             str);
     369        panic_memtrap(istate, PF_ACCESS_READ, DMISS_ADDRESS(page_and_ctx),
     370            "%s.");
    371371}
    372372
    … …  
    377377            DMISS_ADDRESS(page_and_ctx), DMISS_CONTEXT(page_and_ctx));
    378378        panic_memtrap(istate, PF_ACCESS_WRITE, DMISS_ADDRESS(page_and_ctx),
    379             str);
     379            "%s.");
    380380}
    381381

  • kernel/generic/include/mm/as.h

    r074c9bd r41ce4d9  
    171171        PF_ACCESS_READ,
    172172        PF_ACCESS_WRITE,
    173         PF_ACCESS_EXEC,
    174         PF_ACCESS_UNKNOWN
     173        PF_ACCESS_EXEC
    175174} pf_access_t;
    176175

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

    r074c9bd r41ce4d9  
    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

  • kernel/generic/src/debug/panic.c

    r074c9bd r41ce4d9  
    6161        } else if (cat == PANIC_BADTRAP) {
    6262                printf("BAD TRAP %ld.\n", address);
    63                 if (fmt) {
    64                         vprintf(fmt, args);
    65                         printf("\n");
    66                 }
    6763        } else if (cat == PANIC_MEMTRAP) {
    6864                printf("A BAD MEMORY ACCESS WHILE ");
    … …  
    7672                        printf("REFERENCING");
    7773                printf(" ADDRESS %p.\n", address);
    78                 if (fmt) {
    79                         vprintf(fmt, args);
    80                         printf("\n");
    81                 }
    8274        } else {
    8375                printf("THE FOLLOWING REASON:\n");
    8476                vprintf(fmt, args);
    85                 printf("\n");
    8677        }
    8778        va_end(args);
Note: See TracChangeset for help on using the changeset viewer.