Changeset 4e49572 in mainline


Ignore:
Timestamp:
2006-03-17T11:41:05Z (19 years ago)
Author:
Ondrej Palkovsky <ondrap@…>
Branches:
lfn, master, serial, ticket/834-toolchain-update, topic/msim-upgrade, topic/simplify-dev-export
Children:
23d22eb
Parents:
5a7d9d1
Message:

Added debugger to AMD64.
Added automatic debugging of AS if it is not rewritten with zero.
Did small changes to IPC infrastructure.

Files:
4 added
12 edited

Legend:

Unmodified
Added
Removed

  • Makefile

    r5a7d9d1 r4e49572  
    6969ifeq ($(CONFIG_DEBUG_SPINLOCK),y)
    7070        DEFS += -DCONFIG_DEBUG_SPINLOCK
     71endif
     72ifeq ($(CONFIG_DEBUG_AS_WATCHPOINT),y)
     73        DEFS += -DCONFIG_DEBUG_AS_WATCHPOINT
    7174endif
    7275ifeq ($(CONFIG_FPU_LAZY),y)
    … …  
    136139        generic/src/smp/ipi.c \
    137140        generic/src/ipc/ipc.c \
    138         generic/src/ipc/sysipc.c
     141        generic/src/ipc/sysipc.c \
     142        generic/src/ipc/ipcrsc.c
    139143
    140144## Test sources

  • arch/amd64/Makefile.inc

    r5a7d9d1 r4e49572  
    104104        arch/$(ARCH)/src/proc/scheduler.c \
    105105        arch/$(ARCH)/src/userspace.c \
    106         arch/$(ARCH)/src/syscall.c
     106        arch/$(ARCH)/src/syscall.c \
     107        arch/$(ARCH)/src/debugger.c
    107108
    108109ifeq ($(CONFIG_SMP),y)

  • arch/amd64/include/asm.h

    r5a7d9d1 r4e49572  
    142142}
    143143
    144 /** Read CR0
    145  *
    146  * Return value in CR0
    147  *
    148  * @return Value read.
    149  */
    150 static inline __u64 read_cr0(void)
    151 {
    152         __u64 v;
    153         __asm__ volatile ("movq %%cr0,%0\n" : "=r" (v));
    154         return v;
    155 }
    156 
    157 /** Read CR2
    158  *
    159  * Return value in CR2
    160  *
    161  * @return Value read.
    162  */
    163 static inline __u64 read_cr2(void)
    164 {
    165         __u64 v;
    166         __asm__ volatile ("movq %%cr2,%0\n" : "=r" (v));
    167         return v;
    168 }
    169 
    170 /** Write CR3
    171  *
    172  * Write value to CR3.
    173  *
    174  * @param v Value to be written.
    175  */
    176 static inline void write_cr3(__u64 v)
    177 {
    178         __asm__ volatile ("movq %0,%%cr3\n" : : "r" (v));
    179 }
    180 
    181 /** Read CR3
    182  *
    183  * Return value in CR3
    184  *
    185  * @return Value read.
    186  */
    187 static inline __u64 read_cr3(void)
    188 {
    189         __u64 v;
    190         __asm__ volatile ("movq %%cr3,%0" : "=r" (v));
    191         return v;
    192 }
    193 
    194144/** Write to MSR */
    195145static inline void write_msr(__u32 msr, __u64 value)
    … …  
    251201}
    252202
     203#define GEN_READ_REG(reg) static inline __native read_ ##reg (void) \
     204    { \
     205        __native res; \
     206        __asm__ volatile ("movq %%" #reg ", %0" : "=r" (res) ); \
     207        return res; \
     208    }
     209
     210#define GEN_WRITE_REG(reg) static inline void write_ ##reg (__native regn) \
     211    { \
     212        __asm__ volatile ("movq %0, %%" #reg : : "r" (regn)); \
     213    }
     214
     215GEN_READ_REG(cr0);
     216GEN_READ_REG(cr2);
     217GEN_READ_REG(cr3);
     218GEN_WRITE_REG(cr3);
     219
     220GEN_READ_REG(dr0);
     221GEN_READ_REG(dr1);
     222GEN_READ_REG(dr2);
     223GEN_READ_REG(dr3);
     224GEN_READ_REG(dr6);
     225GEN_READ_REG(dr7);
     226
     227GEN_WRITE_REG(dr0);
     228GEN_WRITE_REG(dr1);
     229GEN_WRITE_REG(dr2);
     230GEN_WRITE_REG(dr3);
     231GEN_WRITE_REG(dr6);
     232GEN_WRITE_REG(dr7);
     233
     234
    253235extern size_t interrupt_handler_size;
    254236extern void interrupt_handlers(void);

  • arch/amd64/include/cpu.h

    r5a7d9d1 r4e49572  
    3030#define __amd64_CPU_H__
    3131
     32#define RFLAGS_RF       (1 << 16)
    3233
    3334#define EFER_MSR_NUM    0xc0000080

  • arch/amd64/include/interrupt.h

    r5a7d9d1 r4e49572  
    5454#endif
    5555
     56#define VECTOR_DEBUG            1
    5657#define VECTOR_PIC_SPUR         (IVT_IRQBASE+IRQ_PIC_SPUR)
    5758#define VECTOR_CLK              (IVT_IRQBASE+IRQ_CLK)

  • arch/amd64/src/amd64.c

    r5a7d9d1 r4e49572  
    4747#include <interrupt.h>
    4848#include <arch/syscall.h>
     49#include <arch/debugger.h>
    4950
    5051/** Disable I/O on non-privileged levels
    … …  
    130131        if (config.cpu_active == 1) {
    131132                ega_init();     /* video */
     133                /* Enable debugger */
     134                debugger_init();
    132135        }
    133136        /* Setup fast SYSCALL/SYSRET */
    134137        syscall_setup_cpu();
    135 
     138       
    136139}
    137140

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

    r5a7d9d1 r4e49572  
    3333#include <arch/context.h>       /* SP_DELTA */
    3434#include <arch/asm.h>
     35#include <arch/debugger.h>
    3536
    3637void before_thread_runs_arch(void)
    … …  
    4344                  (__u64)&THREAD->kstack);
    4445        swapgs();
     46
     47
     48#ifdef CONFIG_DEBUG_AS_WATCHPOINT
     49        /* Set watchpoint on AS to ensure that nobody sets it to zero */
     50        static int old_slot = -1;
     51        if (old_slot >=0)
     52                breakpoint_del(old_slot);
     53        old_slot = breakpoint_add(&((the_t *) THREAD->kstack)->as,
     54                                  BKPOINT_WRITE | BKPOINT_CHECK_ZERO);
     55#endif
    4556}
    4657

  • generic/include/ipc/ipc.h

    r5a7d9d1 r4e49572  
    177177
    178178extern answerbox_t *ipc_phone_0;
     179extern void ipc_cleanup(task_t *task);
    179180
    180181#endif

  • generic/src/console/cmd.c

    r5a7d9d1 r4e49572  
    303303};
    304304
    305 static int cmd_hello(cmd_arg_t *argv);
    306 static cmd_info_t hello_info = {
    307         .name = "hello",
    308         .description = "Hello Message",
    309         .func = cmd_hello,
    310         .argc = 0
    311 };
    312 
    313305/** Data and methods for 'cpus' command. */
    314306static int cmd_cpus(cmd_arg_t *argv);
    … …  
    353345        &zones_info,
    354346        &zone_info,
    355         &hello_info,
    356347        NULL
    357348};
    … …  
    706697        return 1;
    707698}
    708 
    709 
    710 int cmd_hello(cmd_arg_t *argv)
    711 {
    712         printf("\nHello, World !!!\n");
    713         return 1;
    714 }

  • generic/src/ipc/ipc.c

    r5a7d9d1 r4e49572  
    244244                                          NULL, NULL, 0);
    245245}
     246
     247/** Cleans up all IPC communication of the given task
     248 *
     249 *
     250 */
     251void ipc_cleanup(task_t *task)
     252{
     253        /* Cancel all calls in my dispatch queue */
     254       
     255}

  • generic/src/ipc/sysipc.c

    r5a7d9d1 r4e49572  
    3636#include <ipc/ipc.h>
    3737#include <ipc/sysipc.h>
     38#include <ipc/ipcrsc.h>
    3839
    3940
    … …  
    6364{
    6465        return 1;
    65 }
    66 
    67 /** Find call_t * in call table according to callid
    68  *
    69  * @return NULL on not found, otherwise pointer to call structure
    70  */
    71 static inline call_t * get_call(__native callid)
    72 {
    73         /* TODO: Traverse list of dispatched calls and find one */
    74         /* TODO: locking of call, ripping it from dispatched calls etc.  */
    75         return (call_t *) callid;
    76 }
    77 
    78 /** Return pointer to phone identified by phoneid or NULL if non-existent */
    79 static phone_t * get_phone(__native phoneid)
    80 {
    81         phone_t *phone;
    82 
    83         if (phoneid >= IPC_MAX_PHONES)
    84                 return NULL;
    85 
    86         phone = &TASK->phones[phoneid];
    87         if (!phone->callee)
    88                 return NULL;
    89         return phone;
    90 }
    91 
    92 /** Allocate new phone slot in current TASK structure */
    93 static int phone_alloc(void)
    94 {
    95         int i;
    96 
    97         spinlock_lock(&TASK->lock);
    98        
    99         for (i=0; i < IPC_MAX_PHONES; i++) {
    100                 if (!TASK->phones[i].busy) {
    101                         TASK->phones[i].busy = 1;
    102                         break;
    103                 }
    104         }
    105         spinlock_unlock(&TASK->lock);
    106 
    107         if (i >= IPC_MAX_PHONES)
    108                 return -1;
    109         return i;
    110 }
    111 
    112 /** Disconnect phone */
    113 static void phone_dealloc(int phoneid)
    114 {
    115         spinlock_lock(&TASK->lock);
    116 
    117         ASSERT(TASK->phones[phoneid].busy);
    118 
    119         if (TASK->phones[phoneid].callee)
    120                 ipc_phone_destroy(&TASK->phones[phoneid]);
    121 
    122         TASK->phones[phoneid].busy = 0;
    123         spinlock_unlock(&TASK->lock);
    124 }
    125 
    126 static void phone_connect(int phoneid, answerbox_t *box)
    127 {
    128         phone_t *phone = &TASK->phones[phoneid];
    129        
    130         ipc_phone_connect(phone, box);
    13166}
    13267
    … …  
    213148        phone_t *phone;
    214149
    215         phone = get_phone(phoneid);
    216         if (!phone)
    217                 return ENOENT;
    218 
    219150        if (is_system_method(method))
    220151                return EPERM;
     152
     153        phone = get_phone_and_lock(phoneid);
     154        if (!phone)
     155                return ENOENT;
    221156
    222157        ipc_call_init(&call);
    … …  
    238173        phone_t *phone;
    239174
    240         phone = get_phone(phoneid);
    241         if (!phone)
    242                 return ENOENT;
    243 
    244175        ipc_call_init(&call);
    245176        copy_from_uspace(&call.data, question, sizeof(call.data));
    … …  
    248179                return EPERM;
    249180       
     181        phone = get_phone_and_lock(phoneid);
     182        if (!phone)
     183                return ENOENT;
     184
    250185        ipc_call_sync(phone, &call);
    251186
    … …  
    279214        phone_t *phone;
    280215
    281         phone = get_phone(phoneid);
    282         if (!phone)
    283                 return IPC_CALLRET_FATAL;
    284 
    285216        if (is_system_method(method))
    286217                return IPC_CALLRET_FATAL;
    … …  
    288219        if (check_call_limit())
    289220                return IPC_CALLRET_TEMPORARY;
     221
     222        phone = get_phone_and_lock(phoneid);
     223        if (!phone)
     224                return IPC_CALLRET_FATAL;
    290225
    291226        call = ipc_call_alloc();
    … …  
    308243        phone_t *phone;
    309244
    310         phone = get_phone(phoneid);
    311         if (!phone)
    312                 return IPC_CALLRET_FATAL;
    313 
    314245        if (check_call_limit())
    315246                return IPC_CALLRET_TEMPORARY;
     247
     248        phone = get_phone_and_lock(phoneid);
     249        if (!phone)
     250                return IPC_CALLRET_FATAL;
    316251
    317252        call = ipc_call_alloc();
    … …  
    345280                return ENOENT;
    346281
    347         phone = get_phone(phoneid);
     282        phone = get_phone_and_lock(phoneid);
    348283        if (!phone) {
    349284                IPC_SET_RETVAL(call->data, EFORWARD);
    … …  
    437372        phone_t *phone;
    438373
    439         phone = get_phone(phoneid);
    440         if (!phone)
    441                 return ENOENT;
    442 
    443374        ipc_call_init(&call);
    444375        IPC_SET_METHOD(call.data, IPC_M_CONNECTTOME);
    … …  
    446377        IPC_SET_ARG2(call.data, arg2);
    447378       
     379        phone = get_phone_and_lock(phoneid);
     380        if (!phone)
     381                return ENOENT;
     382
    448383        ipc_call_sync(phone, &call);
    449384
    … …  
    467402        int newphid;
    468403
    469         phone = get_phone(phoneid);
     404        phone = get_phone_and_lock(phoneid);
    470405        if (!phone)
    471406                return ENOENT;

  • kernel.config

    r5a7d9d1 r4e49572  
    7171! [CONFIG_DEBUG=y&CONFIG_SMP=y] CONFIG_DEBUG_SPINLOCK (y/n)
    7272
     73# Watchpoint on rewriting AS with zero
     74! [CONFIG_DEBUG=y&ARCH=amd64] CONFIG_DEBUG_AS_WATCHPOINT (y/n)
     75
    7376## Run-time configuration directives
    7477
Note: See TracChangeset for help on using the changeset viewer.