| /branches/tracing/kernel/arch/amd64/include/types.h |
|---|
| 35,10 → 35,6 |
| #ifndef KERN_amd64_TYPES_H_ |
| #define KERN_amd64_TYPES_H_ |
| #define NULL 0 |
| #define false 0 |
| #define true 1 |
| typedef signed char int8_t; |
| typedef signed short int16_t; |
| typedef signed int int32_t; |
| 61,14 → 57,31 |
| typedef uint64_t unative_t; |
| typedef int64_t native_t; |
| typedef uint8_t bool; |
| typedef uint64_t thread_id_t; |
| typedef uint64_t task_id_t; |
| typedef uint32_t context_id_t; |
| /**< Formats for uintptr_t, size_t, count_t and index_t */ |
| #define PRIp "llx" |
| #define PRIs "llu" |
| #define PRIc "llu" |
| #define PRIi "llu" |
| typedef int32_t inr_t; |
| typedef int32_t devno_t; |
| /**< Formats for (u)int8_t, (u)int16_t, (u)int32_t, (u)int64_t and (u)native_t */ |
| #define PRId8 "d" |
| #define PRId16 "d" |
| #define PRId32 "d" |
| #define PRId64 "lld" |
| #define PRIdn "lld" |
| #define PRIu8 "u" |
| #define PRIu16 "u" |
| #define PRIu32 "u" |
| #define PRIu64 "llu" |
| #define PRIun "llu" |
| #define PRIx8 "x" |
| #define PRIx16 "x" |
| #define PRIx32 "x" |
| #define PRIx64 "llx" |
| #define PRIxn "llx" |
| /** Page Table Entry. */ |
| typedef struct { |
| unsigned present : 1; |
| /branches/tracing/kernel/arch/amd64/include/memstr.h |
|---|
| 35,110 → 35,13 |
| #ifndef KERN_amd64_MEMSTR_H_ |
| #define KERN_amd64_MEMSTR_H_ |
| /** Copy memory |
| * |
| * Copy a given number of bytes (3rd argument) |
| * from the memory location defined by 2nd argument |
| * to the memory location defined by 1st argument. |
| * The memory areas cannot overlap. |
| * |
| * @param dst Destination |
| * @param src Source |
| * @param cnt Number of bytes |
| * @return Destination |
| */ |
| static inline void * memcpy(void * dst, const void * src, size_t cnt) |
| { |
| unative_t d0, d1, d2; |
| #define memcpy(dst, src, cnt) __builtin_memcpy((dst), (src), (cnt)) |
| asm volatile( |
| "rep movsq\n\t" |
| "movq %4, %%rcx\n\t" |
| "andq $7, %%rcx\n\t" |
| "jz 1f\n\t" |
| "rep movsb\n\t" |
| "1:\n" |
| : "=&c" (d0), "=&D" (d1), "=&S" (d2) |
| : "0" ((unative_t)(cnt / 8)), "g" ((unative_t)cnt), "1" ((unative_t) dst), "2" ((unative_t) src) |
| : "memory"); |
| extern void memsetw(void *dst, size_t cnt, uint16_t x); |
| extern void memsetb(void *dst, size_t cnt, uint8_t x); |
| return dst; |
| } |
| extern int memcmp(const void *a, const void *b, size_t cnt); |
| /** Compare memory regions for equality |
| * |
| * Compare a given number of bytes (3rd argument) |
| * at memory locations defined by 1st and 2nd argument |
| * for equality. If bytes are equal function returns 0. |
| * |
| * @param src Region 1 |
| * @param dst Region 2 |
| * @param cnt Number of bytes |
| * @return Zero if bytes are equal, non-zero otherwise |
| */ |
| static inline int memcmp(const void * src, const void * dst, size_t cnt) |
| { |
| unative_t d0, d1, d2; |
| unative_t ret; |
| asm ( |
| "repe cmpsb\n\t" |
| "je 1f\n\t" |
| "movq %3, %0\n\t" |
| "addq $1, %0\n\t" |
| "1:\n" |
| : "=a" (ret), "=&S" (d0), "=&D" (d1), "=&c" (d2) |
| : "0" (0), "1" (src), "2" (dst), "3" ((unative_t)cnt) |
| ); |
| return ret; |
| } |
| /** Fill memory with words |
| * Fill a given number of words (2nd argument) |
| * at memory defined by 1st argument with the |
| * word value defined by 3rd argument. |
| * |
| * @param dst Destination |
| * @param cnt Number of words |
| * @param x Value to fill |
| */ |
| static inline void memsetw(uintptr_t dst, size_t cnt, uint16_t x) |
| { |
| unative_t d0, d1; |
| asm volatile ( |
| "rep stosw\n\t" |
| : "=&D" (d0), "=&c" (d1), "=&a" (x) |
| : "0" (dst), "1" ((unative_t)cnt), "2" (x) |
| : "memory" |
| ); |
| } |
| /** Fill memory with bytes |
| * Fill a given number of bytes (2nd argument) |
| * at memory defined by 1st argument with the |
| * word value defined by 3rd argument. |
| * |
| * @param dst Destination |
| * @param cnt Number of bytes |
| * @param x Value to fill |
| */ |
| static inline void memsetb(uintptr_t dst, size_t cnt, uint8_t x) |
| { |
| unative_t d0, d1; |
| asm volatile ( |
| "rep stosb\n\t" |
| : "=&D" (d0), "=&c" (d1), "=&a" (x) |
| : "0" (dst), "1" ((unative_t)cnt), "2" (x) |
| : "memory" |
| ); |
| } |
| #endif |
| /** @} |
| /branches/tracing/kernel/arch/amd64/include/atomic.h |
|---|
| 41,17 → 41,17 |
| static inline void atomic_inc(atomic_t *val) { |
| #ifdef CONFIG_SMP |
| asm volatile ("lock incq %0\n" : "=m" (val->count)); |
| asm volatile ("lock incq %0\n" : "+m" (val->count)); |
| #else |
| asm volatile ("incq %0\n" : "=m" (val->count)); |
| asm volatile ("incq %0\n" : "+m" (val->count)); |
| #endif /* CONFIG_SMP */ |
| } |
| static inline void atomic_dec(atomic_t *val) { |
| #ifdef CONFIG_SMP |
| asm volatile ("lock decq %0\n" : "=m" (val->count)); |
| asm volatile ("lock decq %0\n" : "+m" (val->count)); |
| #else |
| asm volatile ("decq %0\n" : "=m" (val->count)); |
| asm volatile ("decq %0\n" : "+m" (val->count)); |
| #endif /* CONFIG_SMP */ |
| } |
| 61,7 → 61,7 |
| asm volatile ( |
| "lock xaddq %1, %0\n" |
| : "=m" (val->count), "+r" (r) |
| : "+m" (val->count), "+r" (r) |
| ); |
| return r; |
| 73,14 → 73,14 |
| asm volatile ( |
| "lock xaddq %1, %0\n" |
| : "=m" (val->count), "+r" (r) |
| : "+m" (val->count), "+r" (r) |
| ); |
| return r; |
| } |
| #define atomic_preinc(val) (atomic_postinc(val)+1) |
| #define atomic_predec(val) (atomic_postdec(val)-1) |
| #define atomic_preinc(val) (atomic_postinc(val) + 1) |
| #define atomic_predec(val) (atomic_postdec(val) - 1) |
| static inline uint64_t test_and_set(atomic_t *val) { |
| uint64_t v; |
| 88,7 → 88,7 |
| asm volatile ( |
| "movq $1, %0\n" |
| "xchgq %0, %1\n" |
| : "=r" (v),"=m" (val->count) |
| : "=r" (v), "+m" (val->count) |
| ); |
| return v; |
| 102,20 → 102,20 |
| preemption_disable(); |
| asm volatile ( |
| "0:;" |
| "0:\n" |
| #ifdef CONFIG_HT |
| "pause;" |
| "pause\n" |
| #endif |
| "mov %0, %1;" |
| "testq %1, %1;" |
| "jnz 0b;" /* Lightweight looping on locked spinlock */ |
| "mov %0, %1\n" |
| "testq %1, %1\n" |
| "jnz 0b\n" /* Lightweight looping on locked spinlock */ |
| "incq %1;" /* now use the atomic operation */ |
| "xchgq %0, %1;" |
| "testq %1, %1;" |
| "jnz 0b;" |
| : "=m"(val->count),"=r"(tmp) |
| ); |
| "incq %1\n" /* now use the atomic operation */ |
| "xchgq %0, %1\n" |
| "testq %1, %1\n" |
| "jnz 0b\n" |
| : "+m" (val->count), "=r"(tmp) |
| ); |
| /* |
| * Prevent critical section code from bleeding out this way up. |
| */ |
| /branches/tracing/kernel/arch/amd64/Makefile.inc |
|---|
| 35,6 → 35,7 |
| TARGET = amd64-linux-gnu |
| TOOLCHAIN_DIR = /usr/local/amd64 |
| FPU_NO_CFLAGS = -mno-sse -mno-sse2 |
| CMN1 = -m64 -mcmodel=kernel -mno-red-zone -fno-unwind-tables |
| GCC_CFLAGS += $(CMN1) |
| ICC_CFLAGS += $(CMN1) |
| /branches/tracing/kernel/arch/amd64/src/pm.c |
|---|
| 155,7 → 155,7 |
| void tss_initialize(tss_t *t) |
| { |
| memsetb((uintptr_t) t, sizeof(tss_t), 0); |
| memsetb(t, sizeof(tss_t), 0); |
| } |
| /* |
| 239,7 → 239,7 |
| preemption_disable(); |
| ipl_t ipl = interrupts_disable(); |
| memsetb((uintptr_t) idt, sizeof(idt), 0); |
| memsetb(idt, sizeof(idt), 0); |
| idtr_load(&idtr); |
| interrupts_restore(ipl); |
| /branches/tracing/kernel/arch/amd64/src/asm_utils.S |
|---|
| 65,6 → 65,8 |
| .global get_cycle |
| .global read_efer_flag |
| .global set_efer_flag |
| .global memsetb |
| .global memsetw |
| .global memcpy |
| .global memcpy_from_uspace |
| .global memcpy_to_uspace |
| 71,6 → 73,14 |
| .global memcpy_from_uspace_failover_address |
| .global memcpy_to_uspace_failover_address |
| # Wrapper for generic memsetb |
| memsetb: |
| jmp _memsetb |
| # Wrapper for generic memsetw |
| memsetw: |
| jmp _memsetw |
| #define MEMCPY_DST %rdi |
| #define MEMCPY_SRC %rsi |
| #define MEMCPY_SIZE %rdx |
| /branches/tracing/kernel/arch/amd64/src/proc/thread.c |
|---|
| 46,7 → 46,7 |
| * Kernel RSP can be precalculated at thread creation time. |
| */ |
| t->arch.syscall_rsp[SYSCALL_KSTACK_RSP] = |
| (uintptr_t)&t->kstack[PAGE_SIZE - sizeof(uint64_t)]; |
| (uintptr_t) &t->kstack[PAGE_SIZE - sizeof(uint64_t)]; |
| } |
| /** @} |
| /branches/tracing/kernel/arch/amd64/src/debugger.c |
|---|
| 106,25 → 106,33 |
| { |
| unsigned int i; |
| char *symbol; |
| #ifdef __32_BITS__ |
| printf("# Count Address In symbol\n"); |
| printf("-- ----- ---------- ---------\n"); |
| #endif |
| #ifdef __64_BITS__ |
| printf("# Count Address In symbol\n"); |
| printf("-- ----- ------------------ ---------\n"); |
| #endif |
| if (sizeof(void *) == 4) { |
| printf("# Count Address In symbol\n"); |
| printf("-- ----- ---------- ---------\n"); |
| } else { |
| printf("# Count Address In symbol\n"); |
| printf("-- ----- ------------------ ---------\n"); |
| } |
| for (i = 0; i < BKPOINTS_MAX; i++) |
| if (breakpoints[i].address) { |
| symbol = get_symtab_entry(breakpoints[i].address); |
| if (sizeof(void *) == 4) |
| printf("%-2u %-5d %#10zx %s\n", i, breakpoints[i].counter, |
| breakpoints[i].address, symbol); |
| else |
| printf("%-2u %-5d %#18zx %s\n", i, breakpoints[i].counter, |
| breakpoints[i].address, symbol); |
| #ifdef __32_BITS__ |
| printf("%-2u %-5d %#10zx %s\n", i, |
| breakpoints[i].counter, breakpoints[i].address, |
| symbol); |
| #endif |
| #ifdef __64_BITS__ |
| printf("%-2u %-5d %#18zx %s\n", i, |
| breakpoints[i].counter, breakpoints[i].address, |
| symbol); |
| #endif |
| } |
| return 1; |
| } |
| 162,19 → 170,23 |
| if ((flags & BKPOINT_INSTR)) { |
| ; |
| } else { |
| if (sizeof(int) == 4) |
| dr7 |= ((unative_t) 0x3) << (18 + 4*curidx); |
| else /* 8 */ |
| dr7 |= ((unative_t) 0x2) << (18 + 4*curidx); |
| #ifdef __32_BITS__ |
| dr7 |= ((unative_t) 0x3) << (18 + 4 * curidx); |
| #endif |
| #ifdef __64_BITS__ |
| dr7 |= ((unative_t) 0x2) << (18 + 4 * curidx); |
| #endif |
| if ((flags & BKPOINT_WRITE)) |
| dr7 |= ((unative_t) 0x1) << (16 + 4*curidx); |
| dr7 |= ((unative_t) 0x1) << (16 + 4 * curidx); |
| else if ((flags & BKPOINT_READ_WRITE)) |
| dr7 |= ((unative_t) 0x3) << (16 + 4*curidx); |
| dr7 |= ((unative_t) 0x3) << (16 + 4 * curidx); |
| } |
| /* Enable global breakpoint */ |
| dr7 |= 0x2 << (curidx*2); |
| dr7 |= 0x2 << (curidx * 2); |
| write_dr7(dr7); |
| 246,15 → 258,15 |
| if ((breakpoints[slot].flags & BKPOINT_CHECK_ZERO)) { |
| if (*((unative_t *) breakpoints[slot].address) != 0) |
| return; |
| printf("**** Found ZERO on address %lx (slot %d) ****\n", |
| breakpoints[slot].address, slot); |
| printf("*** Found ZERO on address %lx (slot %d) ***\n", |
| breakpoints[slot].address, slot); |
| } else { |
| printf("Data watchpoint - new data: %lx\n", |
| *((unative_t *) breakpoints[slot].address)); |
| *((unative_t *) breakpoints[slot].address)); |
| } |
| } |
| printf("Reached breakpoint %d:%lx(%s)\n", slot, getip(istate), |
| get_symtab_entry(getip(istate))); |
| get_symtab_entry(getip(istate))); |
| printf("***Type 'exit' to exit kconsole.\n"); |
| atomic_set(&haltstate,1); |
| kconsole((void *) "debug"); |
| 359,7 → 371,9 |
| } |
| #ifdef CONFIG_SMP |
| static void debug_ipi(int n __attribute__((unused)), istate_t *istate __attribute__((unused))) |
| static void |
| debug_ipi(int n __attribute__((unused)), |
| istate_t *istate __attribute__((unused))) |
| { |
| int i; |
| 375,7 → 389,7 |
| { |
| int i; |
| for (i=0; i<BKPOINTS_MAX; i++) |
| for (i = 0; i < BKPOINTS_MAX; i++) |
| breakpoints[i].address = NULL; |
| cmd_initialize(&bkpts_info); |
| 396,11 → 410,9 |
| panic("could not register command %s\n", addwatchp_info.name); |
| #endif |
| exc_register(VECTOR_DEBUG, "debugger", |
| debug_exception); |
| exc_register(VECTOR_DEBUG, "debugger", debug_exception); |
| #ifdef CONFIG_SMP |
| exc_register(VECTOR_DEBUG_IPI, "debugger_smp", |
| debug_ipi); |
| exc_register(VECTOR_DEBUG_IPI, "debugger_smp", debug_ipi); |
| #endif |
| } |