Date: Tue, 15 Jun 2004 04:07:34 GMT From: Marcel Moolenaar <marcel@FreeBSD.org> To: Perforce Change Reviews <perforce@freebsd.org> Subject: PERFORCE change 54988 for review Message-ID: <200406150407.i5F47YZL020602@repoman.freebsd.org>
next in thread | raw e-mail | index | archive | help
http://perforce.freebsd.org/chv.cgi?CH=54988 Change 54988 by marcel@marcel_nfs on 2004/06/15 04:07:19 First round of getting alpha and sparc64 from trapframe to PCB. This also fixes softwate single stepping in DDB (used by alpha). Affected files ... .. //depot/projects/gdb/sys/alpha/alpha/db_disasm.c#2 edit .. //depot/projects/gdb/sys/alpha/alpha/db_interface.c#7 edit .. //depot/projects/gdb/sys/alpha/alpha/db_trace.c#3 edit .. //depot/projects/gdb/sys/alpha/include/db_machdep.h#3 edit .. //depot/projects/gdb/sys/ddb/db_run.c#3 edit .. //depot/projects/gdb/sys/sparc64/include/db_machdep.h#2 edit .. //depot/projects/gdb/sys/sparc64/include/kdb.h#3 edit .. //depot/projects/gdb/sys/sparc64/sparc64/db_trace.c#3 edit .. //depot/projects/gdb/sys/sparc64/sparc64/trap.c#7 edit Differences ... ==== //depot/projects/gdb/sys/alpha/alpha/db_disasm.c#2 (text+ko) ==== @@ -813,26 +813,9 @@ * (optional) alternate format. Return address of start of * next instruction. */ -int alpha_print_instruction(db_addr_t, alpha_instruction, boolean_t); -db_addr_t -db_disasm(loc, altfmt) - db_addr_t loc; - boolean_t altfmt; -{ - alpha_instruction inst; - - inst.bits = db_get_value(loc, 4, 0); - - loc += alpha_print_instruction(loc, inst, altfmt); - return (loc); -} - -int -alpha_print_instruction(iadr, i, showregs) - db_addr_t iadr; - alpha_instruction i; - boolean_t showregs; +static int +alpha_print_instr(db_addr_t iadr, alpha_instruction i, boolean_t showregs) { const char *opcode; int ireg; @@ -1038,7 +1021,7 @@ if (i.mem_format.opcode == op_ldah) signed_immediate <<= 16; db_printf(" <0x%lx>", signed_immediate + - db_register_value(DDB_REGS, i.mem_format.rs)); + db_register_value(i.mem_format.rs)); } break; case op_br: @@ -1084,10 +1067,23 @@ db_printf(","); db_printf("%s=0x%lx", name_of_register[regnum[ireg]], - db_register_value(DDB_REGS, regnum[ireg])); + db_register_value(regnum[ireg])); } db_printf(">"); } db_printf("\n"); return (sizeof(alpha_instruction)); } + +db_addr_t +db_disasm(loc, altfmt) + db_addr_t loc; + boolean_t altfmt; +{ + alpha_instruction inst; + + inst.bits = db_get_value(loc, 4, 0); + + loc += alpha_print_instr(loc, inst, altfmt); + return (loc); +} ==== //depot/projects/gdb/sys/alpha/alpha/db_interface.c#7 (text+ko) ==== @@ -72,45 +72,60 @@ #include <ddb/db_sym.h> #include <ddb/db_variables.h> +static db_varfcn_t db_frame; + struct db_variable db_regs[] = { - { "v0", &ddb_regs.tf_regs[FRAME_V0], FCN_NULL }, - { "t0", &ddb_regs.tf_regs[FRAME_T0], FCN_NULL }, - { "t1", &ddb_regs.tf_regs[FRAME_T1], FCN_NULL }, - { "t2", &ddb_regs.tf_regs[FRAME_T2], FCN_NULL }, - { "t3", &ddb_regs.tf_regs[FRAME_T3], FCN_NULL }, - { "t4", &ddb_regs.tf_regs[FRAME_T4], FCN_NULL }, - { "t5", &ddb_regs.tf_regs[FRAME_T5], FCN_NULL }, - { "t6", &ddb_regs.tf_regs[FRAME_T6], FCN_NULL }, - { "t7", &ddb_regs.tf_regs[FRAME_T7], FCN_NULL }, - { "s0", &ddb_regs.tf_regs[FRAME_S0], FCN_NULL }, - { "s1", &ddb_regs.tf_regs[FRAME_S1], FCN_NULL }, - { "s2", &ddb_regs.tf_regs[FRAME_S2], FCN_NULL }, - { "s3", &ddb_regs.tf_regs[FRAME_S3], FCN_NULL }, - { "s4", &ddb_regs.tf_regs[FRAME_S4], FCN_NULL }, - { "s5", &ddb_regs.tf_regs[FRAME_S5], FCN_NULL }, - { "s6", &ddb_regs.tf_regs[FRAME_S6], FCN_NULL }, - { "a0", &ddb_regs.tf_regs[FRAME_A0], FCN_NULL }, - { "a1", &ddb_regs.tf_regs[FRAME_A1], FCN_NULL }, - { "a2", &ddb_regs.tf_regs[FRAME_A2], FCN_NULL }, - { "a3", &ddb_regs.tf_regs[FRAME_A3], FCN_NULL }, - { "a4", &ddb_regs.tf_regs[FRAME_A4], FCN_NULL }, - { "a5", &ddb_regs.tf_regs[FRAME_A5], FCN_NULL }, - { "t8", &ddb_regs.tf_regs[FRAME_T8], FCN_NULL }, - { "t9", &ddb_regs.tf_regs[FRAME_T9], FCN_NULL }, - { "t10", &ddb_regs.tf_regs[FRAME_T10], FCN_NULL }, - { "t11", &ddb_regs.tf_regs[FRAME_T11], FCN_NULL }, - { "ra", &ddb_regs.tf_regs[FRAME_RA], FCN_NULL }, - { "t12", &ddb_regs.tf_regs[FRAME_T12], FCN_NULL }, - { "at", &ddb_regs.tf_regs[FRAME_AT], FCN_NULL }, - { "gp", &ddb_regs.tf_regs[FRAME_GP], FCN_NULL }, - { "sp", &ddb_regs.tf_regs[FRAME_SP], FCN_NULL }, - { "pc", &ddb_regs.tf_regs[FRAME_PC], FCN_NULL }, - { "ps", &ddb_regs.tf_regs[FRAME_PS], FCN_NULL }, - { "ai", &ddb_regs.tf_regs[FRAME_T11], FCN_NULL }, - { "pv", &ddb_regs.tf_regs[FRAME_T12], FCN_NULL }, + { "v0", (db_expr_t *)FRAME_V0, db_frame }, + { "t0", (db_expr_t *)FRAME_T0, db_frame }, + { "t1", (db_expr_t *)FRAME_T1, db_frame }, + { "t2", (db_expr_t *)FRAME_T2, db_frame }, + { "t3", (db_expr_t *)FRAME_T3, db_frame }, + { "t4", (db_expr_t *)FRAME_T4, db_frame }, + { "t5", (db_expr_t *)FRAME_T5, db_frame }, + { "t6", (db_expr_t *)FRAME_T6, db_frame }, + { "t7", (db_expr_t *)FRAME_T7, db_frame }, + { "s0", (db_expr_t *)FRAME_S0, db_frame }, + { "s1", (db_expr_t *)FRAME_S1, db_frame }, + { "s2", (db_expr_t *)FRAME_S2, db_frame }, + { "s3", (db_expr_t *)FRAME_S3, db_frame }, + { "s4", (db_expr_t *)FRAME_S4, db_frame }, + { "s5", (db_expr_t *)FRAME_S5, db_frame }, + { "s6", (db_expr_t *)FRAME_S6, db_frame }, + { "a0", (db_expr_t *)FRAME_A0, db_frame }, + { "a1", (db_expr_t *)FRAME_A1, db_frame }, + { "a2", (db_expr_t *)FRAME_A2, db_frame }, + { "a3", (db_expr_t *)FRAME_A3, db_frame }, + { "a4", (db_expr_t *)FRAME_A4, db_frame }, + { "a5", (db_expr_t *)FRAME_A5, db_frame }, + { "t8", (db_expr_t *)FRAME_T8, db_frame }, + { "t9", (db_expr_t *)FRAME_T9, db_frame }, + { "t10", (db_expr_t *)FRAME_T10, db_frame }, + { "t11", (db_expr_t *)FRAME_T11, db_frame }, + { "ra", (db_expr_t *)FRAME_RA, db_frame }, + { "t12", (db_expr_t *)FRAME_T12, db_frame }, + { "at", (db_expr_t *)FRAME_AT, db_frame }, + { "gp", (db_expr_t *)FRAME_GP, db_frame }, + { "sp", (db_expr_t *)FRAME_SP, db_frame }, + { "pc", (db_expr_t *)FRAME_PC, db_frame }, + { "ps", (db_expr_t *)FRAME_PS, db_frame }, + { "ai", (db_expr_t *)FRAME_T11, db_frame }, + { "pv", (db_expr_t *)FRAME_T12, db_frame }, }; struct db_variable *db_eregs = db_regs + sizeof(db_regs)/sizeof(db_regs[0]); +static int +db_frame(struct db_variable *vp, db_expr_t *valuep, int op) +{ + + if (kdb_frame == NULL) + return (0); + if (op == DB_VAR_GET) + *valuep = kdb_frame->tf_regs[(uintptr_t)vp->valuep]; + else + kdb_frame->tf_regs[(uintptr_t)vp->valuep] = *valuep; + return (1); +} + /* * Read bytes from kernel address space for debugger. */ @@ -216,9 +231,7 @@ }; u_long -db_register_value(regs, regno) - db_regs_t *regs; - int regno; +db_register_value(int regno) { if (regno > 31 || regno < 0) { @@ -229,7 +242,7 @@ if (regno == 31) return (0); - return (regs->tf_regs[reg_to_frame[regno]]); + return (kdb_frame->tf_regs[reg_to_frame[regno]]); } /* @@ -385,10 +398,7 @@ } db_addr_t -db_branch_taken(ins, pc, regs) - int ins; - db_addr_t pc; - db_regs_t *regs; +db_branch_taken(int ins, db_addr_t pc) { alpha_instruction insn; db_addr_t newpc; @@ -399,7 +409,7 @@ * Jump format: target PC is (contents of instruction's "RB") & ~3. */ case op_j: - newpc = db_register_value(regs, insn.jump_format.rs) & ~3; + newpc = db_register_value(insn.jump_format.rs) & ~3; break; /* ==== //depot/projects/gdb/sys/alpha/alpha/db_trace.c#3 (text+ko) ==== @@ -204,10 +204,10 @@ } static int -db_backtrace(struct thread *td, struct trapframe *tf, db_addr_t frame, - db_addr_t pc, int count) +db_backtrace(struct thread *td, db_addr_t frame, db_addr_t pc, int count) { struct prologue_info pi; + struct trapframe *tf; const char *symname; c_db_sym_t sym; db_expr_t diff; @@ -219,6 +219,7 @@ count = 1024; last_ipl = ~0L; + tf = NULL; while (count--) { sym = db_search_symbol(pc, DB_STGY_ANY, &diff); if (sym == DB_SYM_NULL) @@ -326,7 +327,6 @@ db_stack_trace_cmd(db_expr_t addr, boolean_t have_addr, db_expr_t count, char *modif) { - struct trapframe *tf; struct thread *td; td = (have_addr) ? kdb_thr_lookup(addr) : kdb_thread; @@ -334,9 +334,7 @@ db_printf("Thread %d not found\n", (int)addr); return; } - tf = td->td_last_frame; - db_backtrace(td, tf, (db_addr_t)(tf + 1), tf->tf_regs[FRAME_PC], - count); + db_trace_thread(td, count); } void @@ -349,17 +347,17 @@ " lda %1,1f \n" "1:\n" : "=r" (sp), "=r" (pc)); - db_backtrace(curthread, NULL, sp, pc, -1); + db_backtrace(curthread, sp, pc, -1); } int db_trace_thread(struct thread *thr, int count) { - struct trapframe *tf; + struct pcb *ctx; - tf = thr->td_last_frame; - return (db_backtrace(thr, tf, (db_addr_t)(tf + 1), - tf->tf_regs[FRAME_PC], count)); + ctx = kdb_thr_ctx(thr); + return (db_backtrace(thr, ctx->pcb_hw.apcb_ksp, ctx->pcb_context[7], + count)); } int ==== //depot/projects/gdb/sys/alpha/include/db_machdep.h#3 (text+ko) ==== @@ -31,55 +31,41 @@ #ifndef _ALPHA_DB_MACHDEP_H_ #define _ALPHA_DB_MACHDEP_H_ -/* - * Machine-dependent defines for new kernel debugger. - */ -#ifndef KLD_MODULE -#include "opt_ddb.h" -#endif - #include <sys/param.h> #include <vm/vm.h> #include <machine/frame.h> -#define DB_NO_AOUT +#define DB_NO_AOUT typedef vm_offset_t db_addr_t; /* address - unsigned */ typedef long db_expr_t; /* expression - signed */ -typedef struct trapframe db_regs_t; -#ifdef DDB -extern db_regs_t ddb_regs; /* register state */ -#endif -#define DDB_REGS (&ddb_regs) +#define PC_REGS() ((db_addr_t)kdb_thrctx->pcb_context[7]) -#define PC_REGS(regs) ((db_addr_t)(regs)->tf_regs[FRAME_PC]) - #define BKPT_INST 0x00000080 /* breakpoint instruction */ #define BKPT_SIZE (4) /* size of breakpoint inst */ #define BKPT_SET(inst) (BKPT_INST) -#define FIXUP_PC_AFTER_BREAK \ - (ddb_regs.tf_regs[FRAME_PC] -= BKPT_SIZE); +#define FIXUP_PC_AFTER_BREAK (kdb_frame->tf_regs[FRAME_PC] -= BKPT_SIZE); #define SOFTWARE_SSTEP 1 /* no hardware support */ -#define IS_BREAKPOINT_TRAP(type, code) ((type) == ALPHA_KENTRY_IF && \ - (code) == ALPHA_IF_CODE_BPT) + +#define IS_BREAKPOINT_TRAP(type, code) \ + ((type) == ALPHA_KENTRY_IF && (code) == ALPHA_IF_CODE_BPT) #define IS_WATCHPOINT_TRAP(type, code) 0 /* * Functions needed for software single-stepping. */ +boolean_t db_inst_trap_return(int inst); +boolean_t db_inst_return(int inst); +boolean_t db_inst_call(int inst); +boolean_t db_inst_branch(int inst); +boolean_t db_inst_load(int inst); +boolean_t db_inst_store(int inst); +boolean_t db_inst_unconditional_flow_transfer(int inst); +db_addr_t db_branch_taken(int inst, db_addr_t pc); -boolean_t db_inst_trap_return(int inst); -boolean_t db_inst_return(int inst); -boolean_t db_inst_call(int inst); -boolean_t db_inst_branch(int inst); -boolean_t db_inst_load(int inst); -boolean_t db_inst_store(int inst); -boolean_t db_inst_unconditional_flow_transfer(int inst); -db_addr_t db_branch_taken(int inst, db_addr_t pc, db_regs_t *regs); - #define inst_trap_return(ins) db_inst_trap_return(ins) #define inst_return(ins) db_inst_return(ins) #define inst_call(ins) db_inst_call(ins) @@ -88,13 +74,12 @@ #define inst_store(ins) db_inst_store(ins) #define inst_unconditional_flow_transfer(ins) \ db_inst_unconditional_flow_transfer(ins) -#define branch_taken(ins, pc, regs) \ - db_branch_taken((ins), (pc), (regs)) +#define branch_taken(ins, pc) db_branch_taken(ins, pc) /* No delay slots on Alpha. */ #define next_instr_address(v, b) ((db_addr_t) ((b) ? (v) : ((v) + 4))) -u_long db_register_value(db_regs_t *, int); +u_long db_register_value(int); /* * Pretty arbitrary ==== //depot/projects/gdb/sys/ddb/db_run.c#3 (text+ko) ==== @@ -65,10 +65,10 @@ int db_store_count; #ifndef db_set_single_step -extern void db_set_single_step(db_regs_t *regs); +void db_set_single_step(void); #endif #ifndef db_clear_single_step -extern void db_clear_single_step(db_regs_t *regs); +void db_clear_single_step(void); #endif boolean_t @@ -249,11 +249,10 @@ db_breakpoint_t db_taken_bkpt = 0; void -db_set_single_step(regs) - register db_regs_t *regs; +db_set_single_step(void) { - db_addr_t pc = PC_REGS(regs), brpc; - unsigned inst; + db_addr_t pc = PC_REGS(), brpc; + unsigned inst; /* * User was stopped at pc, e.g. the instruction @@ -261,28 +260,27 @@ */ inst = db_get_value(pc, sizeof(int), FALSE); if (inst_branch(inst) || inst_call(inst)) { - brpc = branch_taken(inst, pc, regs); - if (brpc != pc) { /* self-branches are hopeless */ - db_taken_bkpt = db_set_temp_breakpoint(brpc); - } - pc = next_instr_address(pc,1); + brpc = branch_taken(inst, pc); + if (brpc != pc) { /* self-branches are hopeless */ + db_taken_bkpt = db_set_temp_breakpoint(brpc); + } + pc = next_instr_address(pc, 1); } - pc = next_instr_address(pc,0); + pc = next_instr_address(pc, 0); db_not_taken_bkpt = db_set_temp_breakpoint(pc); } void -db_clear_single_step(regs) - db_regs_t *regs; +db_clear_single_step(void) { if (db_not_taken_bkpt != 0) { - db_delete_temp_breakpoint(db_not_taken_bkpt); - db_not_taken_bkpt = 0; + db_delete_temp_breakpoint(db_not_taken_bkpt); + db_not_taken_bkpt = 0; } if (db_taken_bkpt != 0) { - db_delete_temp_breakpoint(db_taken_bkpt); - db_taken_bkpt = 0; + db_delete_temp_breakpoint(db_taken_bkpt); + db_taken_bkpt = 0; } } ==== //depot/projects/gdb/sys/sparc64/include/db_machdep.h#2 (text+ko) ==== @@ -38,23 +38,19 @@ typedef vm_offset_t db_addr_t; typedef long db_expr_t; -typedef struct trapframe db_regs_t; -extern db_regs_t ddb_regs; -#define DDB_REGS (&ddb_regs) +#define PC_REGS() ((db_addr_t)kdb_thrctx->pcb_pc) -#define PC_REGS(regs) ((db_addr_t)(regs)->tf_tpc) - #define BKPT_INST (0x91d03001) #define BKPT_SIZE (4) #define BKPT_SET(inst) (BKPT_INST) #define BKPT_SKIP do { \ - ddb_regs.tf_tpc = ddb_regs.tf_tnpc + 4; \ - ddb_regs.tf_tnpc += 8; \ + kdb_frame->tf_tpc = kdb_frame->tf_tnpc + 4; \ + kdb_frame->tf_tnpc += 8; \ } while (0) -#define db_clear_single_step(regs) -#define db_set_single_step(regs) +#define db_clear_single_step kdb_cpu_clear_singlestep +#define db_set_single_step kdb_cpu_set_singlestep #define IS_BREAKPOINT_TRAP(type, code) (type == T_BREAKPOINT) #define IS_WATCHPOINT_TRAP(type, code) (0) ==== //depot/projects/gdb/sys/sparc64/include/kdb.h#3 (text+ko) ==== @@ -29,7 +29,7 @@ #ifndef _MACHINE_KDB_H_ #define _MACHINE_KDB_H_ -#include <machine/frame.h> +#include <machine/cpufunc.h> static __inline void kdb_cpu_clear_singlestep(void) ==== //depot/projects/gdb/sys/sparc64/sparc64/db_trace.c#3 (text+ko) ==== @@ -51,29 +51,47 @@ #define INKERNEL(va) \ ((va) >= VM_MIN_KERNEL_ADDRESS && (va) <= VM_MAX_KERNEL_ADDRESS) +static db_varfcn_t db_frame; + +#define DB_OFFSET(x) (db_expr_t *)offsetof(struct trapframe, x) struct db_variable db_regs[] = { - { "g0", &ddb_regs.tf_global[0], FCN_NULL }, - { "g1", &ddb_regs.tf_global[1], FCN_NULL }, - { "g2", &ddb_regs.tf_global[2], FCN_NULL }, - { "g3", &ddb_regs.tf_global[3], FCN_NULL }, - { "g4", &ddb_regs.tf_global[4], FCN_NULL }, - { "g5", &ddb_regs.tf_global[5], FCN_NULL }, - { "g6", &ddb_regs.tf_global[6], FCN_NULL }, - { "g7", &ddb_regs.tf_global[7], FCN_NULL }, - { "i0", &ddb_regs.tf_out[0], FCN_NULL }, - { "i1", &ddb_regs.tf_out[1], FCN_NULL }, - { "i2", &ddb_regs.tf_out[2], FCN_NULL }, - { "i3", &ddb_regs.tf_out[3], FCN_NULL }, - { "i4", &ddb_regs.tf_out[4], FCN_NULL }, - { "i5", &ddb_regs.tf_out[5], FCN_NULL }, - { "i6", &ddb_regs.tf_out[6], FCN_NULL }, - { "i7", &ddb_regs.tf_out[7], FCN_NULL }, - { "tnpc", &ddb_regs.tf_tnpc, FCN_NULL }, - { "tpc", &ddb_regs.tf_tpc, FCN_NULL }, - { "tstate", &ddb_regs.tf_tstate, FCN_NULL }, + { "g0", DB_OFFSET(tf_global[0]), db_frame }, + { "g1", DB_OFFSET(tf_global[1]), db_frame }, + { "g2", DB_OFFSET(tf_global[2]), db_frame }, + { "g3", DB_OFFSET(tf_global[3]), db_frame }, + { "g4", DB_OFFSET(tf_global[4]), db_frame }, + { "g5", DB_OFFSET(tf_global[5]), db_frame }, + { "g6", DB_OFFSET(tf_global[6]), db_frame }, + { "g7", DB_OFFSET(tf_global[7]), db_frame }, + { "i0", DB_OFFSET(tf_out[0]), db_frame }, + { "i1", DB_OFFSET(tf_out[1]), db_frame }, + { "i2", DB_OFFSET(tf_out[2]), db_frame }, + { "i3", DB_OFFSET(tf_out[3]), db_frame }, + { "i4", DB_OFFSET(tf_out[4]), db_frame }, + { "i5", DB_OFFSET(tf_out[5]), db_frame }, + { "i6", DB_OFFSET(tf_out[6]), db_frame }, + { "i7", DB_OFFSET(tf_out[7]), db_frame }, + { "tnpc", DB_OFFSET(tf_tnpc), db_frame }, + { "tpc", DB_OFFSET(tf_tpc), db_frame }, + { "tstate", DB_OFFSET(tf_tstate), db_frame }, }; struct db_variable *db_eregs = db_regs + sizeof(db_regs)/sizeof(db_regs[0]); +static int +db_frame(struct db_variable *vp, db_expr_t *valuep, int op) +{ + uint64_t *reg; + + if (kdb_frame == NULL) + return (0); + reg = (uint64_t*)((uintptr_t)kdb_frame + (uintptr_t)vp->valuep); + if (op == DB_VAR_GET) + *valuep = *reg; + else + *reg = *valuep; + return (1); +} + /* * User stack trace (debugging aid). */ @@ -200,9 +218,9 @@ } static int -db_backtrace(struct thread *td, struct trapframe *tf, struct frame *fp, - int count) +db_backtrace(struct thread *td, struct frame *fp, int count) { + struct trapframe *tf; const char *name; c_db_sym_t sym; db_expr_t offset; @@ -215,9 +233,6 @@ if (count == -1) count = 1024; - if (fp == NULL && tf != NULL) - fp = (struct frame *)(tf->tf_out[6] + SPOFF); - trap = 0; user = 0; npc = 0; @@ -267,7 +282,7 @@ db_printf("Thread %d not found\n", (int)addr); return; } - db_backtrace(td, td->td_last_frame, NULL, count); + db_trace_thread(td, count); } void @@ -276,12 +291,14 @@ db_expr_t addr; addr = (db_expr_t)__builtin_frame_address(1); - db_backtrace(curthread, NULL, (struct frame *)(addr + SPOFF), -1); + db_backtrace(curthread, (struct frame *)(addr + SPOFF), -1); } int db_trace_thread(struct thread *td, int count) { + struct pcb *ctx; - return (db_backtrace(td, td->td_last_frame, NULL, count)); + ctx = kdb_thr_ctx(td); + return (db_backtrace(td, (struct frame*)(ctx->pcb_sp + SPOFF), count)); } ==== //depot/projects/gdb/sys/sparc64/sparc64/trap.c#7 (text+ko) ==== @@ -250,7 +250,6 @@ p = td->td_proc; sticks = td->td_sticks; td->td_frame = tf; - td->td_last_frame = tf; if (td->td_ucred != p->p_ucred) cred_update_thread(td); @@ -305,8 +304,6 @@ } #endif - td->td_last_frame = tf; - switch (tf->tf_type & ~T_KERNEL) { #ifdef KDB case T_BREAKPOINT: @@ -526,7 +523,6 @@ sticks = td->td_sticks; td->td_frame = tf; - td->td_last_frame = tf; if (td->td_ucred != p->p_ucred) cred_update_thread(td); if (p->p_flag & P_SA)
Want to link to this message? Use this URL: <https://mail-archive.FreeBSD.org/cgi/mid.cgi?200406150407.i5F47YZL020602>