Currently, gdb passthroughs of 'bt', 'frame', 'up', 'down', 'info locals' don't work. This is due to gdb not knowing the register values to unwind the stack frames Every gdb passthrough goes through `gdb_interface`. And then, gdb expects `crash_target::fetch_registers` to give it the register values, which is dependent on `machdep->get_cpu_reg` to read the register values for specific architecture. ---------------------------- gdb passthrough (eg. "bt") | | crash -------------------------> | | | gdb_interface | | | | | | ---------------------- | fetch_registers | | | | crash_target<-------------------------+--| gdb | | --------------------------+->| | | Registers (SP,NIP, etc.)| | | | | | | | | ---------------------- | ---------------------------- Implement `machdep->get_cpu_reg` on PPC64, so that crash provides the register values to gdb to unwind stack frames properly With these changes, on powerpc, 'bt' command output in gdb mode, will look like this: gdb> bt #0 0xc0000000002a53e8 in crash_setup_regs (oldregs=<optimized out>, newregs=0xc00000000486f8d8) at ./arch/powerpc/include/asm/kexec.h:69 #1 __crash_kexec (regs=<optimized out>) at kernel/kexec_core.c:974 #2 0xc000000000168918 in panic (fmt=<optimized out>) at kernel/panic.c:358 #3 0xc000000000b735f8 in sysrq_handle_crash (key=<optimized out>) at drivers/tty/sysrq.c:155 #4 0xc000000000b742cc in __handle_sysrq (key=key@entry=99, check_mask=check_mask@entry=false) at drivers/tty/sysrq.c:602 #5 0xc000000000b7506c in write_sysrq_trigger (file=<optimized out>, buf=<optimized out>, count=2, ppos=<optimized out>) at drivers/tty/sysrq.c:1163 #6 0xc00000000069a7bc in pde_write (ppos=<optimized out>, count=<optimized out>, buf=<optimized out>, file=<optimized out>, pde=0xc000000009ed3a80) at fs/proc/inode.c:340 #7 proc_reg_write (file=<optimized out>, buf=<optimized out>, count=<optimized out>, ppos=<optimized out>) at fs/proc/inode.c:352 #8 0xc0000000005b3bbc in vfs_write (file=file@entry=0xc00000009dda7d00, buf=buf@entry=0xebcfc7c6040 <error: Cannot access memory at address 0xebcfc7c6040>, count=count@entry=2, pos=pos@entry=0xc00000000486fda0) at fs/read_write.c:582 instead of earlier output without this patch: gdb> bt #0 <unavailable> in ?? () Backtrace stopped: previous frame identical to this frame (corrupt stack?) Also, 'get_dumpfile_regs' has been introduced to get registers from multiple supported vmcore formats. Correspondingly a flag 'BT_NO_PRINT_REGS' has been introduced to tell helper functions to get registers, to not print registers with every call to backtrace in gdb. Note: This feature to support GDB unwinding doesn't support live debugging Signed-off-by: Aditya Gupta <adityag(a)linux.ibm.com&gt; --- defs.h | 122 +++++++++++++++++++++++++++++++++++++++++++++++++++++++ kernel.c | 33 +++++++++++++++ ppc64.c | 109 +++++++++++++++++++++++++++++++++++++++++++++++-- 3 files changed, 261 insertions(+), 3 deletions(-) diff --git a/defs.h b/defs.h index 5218a94fe4a4..615f3a37935a 100644 --- a/defs.h +++ b/defs.h @@ -6023,6 +6023,7 @@ int load_module_symbols_helper(char *); void unlink_module(struct load_module *); int check_specified_module_tree(char *, char *); int is_system_call(char *, ulong); +void get_dumpfile_regs(struct bt_info*, ulong*, ulong*); void generic_dump_irq(int); void generic_get_irq_affinity(int); void generic_show_interrupts(int, ulong *); @@ -6121,6 +6122,7 @@ ulong cpu_map_addr(const char *type); #define BT_REGS_NOT_FOUND (0x4000000000000ULL) #define BT_OVERFLOW_STACK (0x8000000000000ULL) #define BT_SKIP_IDLE (0x10000000000000ULL) +#define BT_NO_PRINT_REGS (0x20000000000000ULL) #define BT_SYMBOL_OFFSET (BT_SYMBOLIC_ARGS) #define BT_REF_HEXVAL (0x1) @@ -7854,4 +7856,124 @@ enum x86_64_regnum { LAST_REGNUM }; +/* + * Register numbers to make crash_target->fetch_registers() + * ---> machdep->get_cpu_reg() work properly. + * + * These register numbers and names are given according to output of + * `rs6000_register_name`, because that is what was being used by + * crash_target::fetch_registers in case of PPC64 + */ +enum ppc64_regnum { + PPC64_R0_REGNUM = 0, + PPC64_R1_REGNUM, + PPC64_R2_REGNUM, + PPC64_R3_REGNUM, + PPC64_R4_REGNUM, + PPC64_R5_REGNUM, + PPC64_R6_REGNUM, + PPC64_R7_REGNUM, + PPC64_R8_REGNUM, + PPC64_R9_REGNUM, + PPC64_R10_REGNUM, + PPC64_R11_REGNUM, + PPC64_R12_REGNUM, + PPC64_R13_REGNUM, + PPC64_R14_REGNUM, + PPC64_R15_REGNUM, + PPC64_R16_REGNUM, + PPC64_R17_REGNUM, + PPC64_R18_REGNUM, + PPC64_R19_REGNUM, + PPC64_R20_REGNUM, + PPC64_R21_REGNUM, + PPC64_R22_REGNUM, + PPC64_R23_REGNUM, + PPC64_R24_REGNUM, + PPC64_R25_REGNUM, + PPC64_R26_REGNUM, + PPC64_R27_REGNUM, + PPC64_R28_REGNUM, + PPC64_R29_REGNUM, + PPC64_R30_REGNUM, + PPC64_R31_REGNUM, + + PPC64_F0_REGNUM = 32, + PPC64_F1_REGNUM, + PPC64_F2_REGNUM, + PPC64_F3_REGNUM, + PPC64_F4_REGNUM, + PPC64_F5_REGNUM, + PPC64_F6_REGNUM, + PPC64_F7_REGNUM, + PPC64_F8_REGNUM, + PPC64_F9_REGNUM, + PPC64_F10_REGNUM, + PPC64_F11_REGNUM, + PPC64_F12_REGNUM, + PPC64_F13_REGNUM, + PPC64_F14_REGNUM, + PPC64_F15_REGNUM, + PPC64_F16_REGNUM, + PPC64_F17_REGNUM, + PPC64_F18_REGNUM, + PPC64_F19_REGNUM, + PPC64_F20_REGNUM, + PPC64_F21_REGNUM, + PPC64_F22_REGNUM, + PPC64_F23_REGNUM, + PPC64_F24_REGNUM, + PPC64_F25_REGNUM, + PPC64_F26_REGNUM, + PPC64_F27_REGNUM, + PPC64_F28_REGNUM, + PPC64_F29_REGNUM, + PPC64_F30_REGNUM, + PPC64_F31_REGNUM, + + PPC64_PC_REGNUM = 64, + PPC64_MSR_REGNUM = 65, + PPC64_CR_REGNUM = 66, + PPC64_LR_REGNUM = 67, + PPC64_CTR_REGNUM = 68, + PPC64_XER_REGNUM = 69, + PPC64_FPSCR_REGNUM = 70, + + PPC64_VR0_REGNUM = 106, + PPC64_VR1_REGNUM, + PPC64_VR2_REGNUM, + PPC64_VR3_REGNUM, + PPC64_VR4_REGNUM, + PPC64_VR5_REGNUM, + PPC64_VR6_REGNUM, + PPC64_VR7_REGNUM, + PPC64_VR8_REGNUM, + PPC64_VR9_REGNUM, + PPC64_VR10_REGNUM, + PPC64_VR11_REGNUM, + PPC64_VR12_REGNUM, + PPC64_VR13_REGNUM, + PPC64_VR14_REGNUM, + PPC64_VR15_REGNUM, + PPC64_VR16_REGNUM, + PPC64_VR17_REGNUM, + PPC64_VR18_REGNUM, + PPC64_VR19_REGNUM, + PPC64_VR20_REGNUM, + PPC64_VR21_REGNUM, + PPC64_VR22_REGNUM, + PPC64_VR23_REGNUM, + PPC64_VR24_REGNUM, + PPC64_VR25_REGNUM, + PPC64_VR26_REGNUM, + PPC64_VR27_REGNUM, + PPC64_VR28_REGNUM, + PPC64_VR29_REGNUM, + PPC64_VR30_REGNUM, + PPC64_VR31_REGNUM, + + PPC64_VSCR_REGNUM = 138, + PPC64_VRSAVE_REGNU = 139 +}; + #endif /* !GDB_COMMON */ diff --git a/kernel.c b/kernel.c index 6dcf414693e6..52b7ba09f390 100644 --- a/kernel.c +++ b/kernel.c @@ -3533,6 +3533,39 @@ get_lkcd_regs(struct bt_info *bt, ulong *eip, ulong *esp) machdep->get_stack_frame(bt, eip, esp); } +void +get_dumpfile_regs(struct bt_info *bt, ulong *eip, ulong *esp) +{ + bt->flags |= BT_NO_PRINT_REGS; + + if (NETDUMP_DUMPFILE()) + get_netdump_regs(bt, eip, esp); + else if (KDUMP_DUMPFILE()) + get_kdump_regs(bt, eip, esp); + else if (DISKDUMP_DUMPFILE()) + get_diskdump_regs(bt, eip, esp); + else if (KVMDUMP_DUMPFILE()) + get_kvmdump_regs(bt, eip, esp); + else if (LKCD_DUMPFILE()) + get_lkcd_regs(bt, eip, esp); + else if (XENDUMP_DUMPFILE()) + get_xendump_regs(bt, eip, esp); + else if (SADUMP_DUMPFILE()) + get_sadump_regs(bt, eip, esp); + else if (VMSS_DUMPFILE()) + get_vmware_vmss_regs(bt, eip, esp); + else if (REMOTE_PAUSED()) { + if (!is_task_active(bt->task) || !get_remote_regs(bt, eip, esp)) + machdep->get_stack_frame(bt, eip, esp); + } else + machdep->get_stack_frame(bt, eip, esp); + + bt->flags &= ~BT_NO_PRINT_REGS; + + bt->instptr = *eip; + bt->stkptr = *esp; +} + /* * Store the head of the kernel module list for future use. diff --git a/ppc64.c b/ppc64.c index e8930a139e0d..86ac7b7d9b67 100644 --- a/ppc64.c +++ b/ppc64.c @@ -55,6 +55,8 @@ static void ppc64_set_bt_emergency_stack(enum emergency_stack_type type, static char * ppc64_check_eframe(struct ppc64_pt_regs *); static void ppc64_print_eframe(char *, struct ppc64_pt_regs *, struct bt_info *); +static int ppc64_get_cpu_reg(int cpu, int regno, const char *name, int size, + void *value); static void parse_cmdline_args(void); static int ppc64_paca_percpu_offset_init(int); static void ppc64_init_cpu_info(void); @@ -704,6 +706,8 @@ ppc64_init(int when) error(FATAL, "cannot malloc hwirqstack buffer space."); } + machdep->get_cpu_reg = ppc64_get_cpu_reg; + ppc64_init_paca_info(); if (!machdep->hz) { @@ -2501,6 +2505,103 @@ ppc64_print_eframe(char *efrm_str, struct ppc64_pt_regs *regs, ppc64_print_nip_lr(regs, 1); } +static int +ppc64_get_cpu_reg(int cpu, int regno, const char *name, int size, + void *value) +{ + struct bt_info bt_info, bt_setup; + struct task_context *tc; + struct ppc64_pt_regs *pt_regs; + ulong ip, sp; + + if (LIVE()) { + /* doesn't support reading registers in live dump */ + return FALSE; + } + + /* Currently only handling registers available in ppc64_pt_regs: + * + * 0-31: r0-r31 + * 64: pc/nip + * 65: msr + * + * 67: lr + * 68: ctr + */ + switch (regno) { + case PPC64_R0_REGNUM ... PPC64_R31_REGNUM: + + case PPC64_PC_REGNUM: + case PPC64_MSR_REGNUM: + case PPC64_LR_REGNUM: + case PPC64_CTR_REGNUM: + break; + + default: + // return false if we can't get that register + if (CRASHDEBUG(1)) + error(WARNING, "unsupported register, regno=%d\n", regno); + return FALSE; + } + + tc = CURRENT_CONTEXT(); + BZERO(&bt_setup, sizeof(struct bt_info)); + clone_bt_info(&bt_setup, &bt_info, tc); + fill_stackbuf(&bt_info); + + // reusing the get_dumpfile_regs function to get pt regs structure + get_dumpfile_regs(&bt_info, &sp, &ip); + pt_regs = (struct ppc64_pt_regs *)bt_info.machdep; + + if (!pt_regs) { + error(WARNING, "pt_regs not available for cpu %d\n", cpu); + return FALSE; + } + + switch (regno) { + case PPC64_R0_REGNUM ... PPC64_R31_REGNUM: + if (size != sizeof(pt_regs->gpr[regno])) + return FALSE; // size mismatch + + memcpy(value, &pt_regs->gpr[regno], size); + break; + + case PPC64_PC_REGNUM: + if (size != sizeof(pt_regs->nip)) + return FALSE; // size mismatch + + memcpy(value, &pt_regs->nip, size); + break; + + case PPC64_MSR_REGNUM: + if (size != sizeof(pt_regs->msr)) + return FALSE; // size mismatch + + memcpy(value, &pt_regs->msr, size); + break; + + case PPC64_LR_REGNUM: + if (size != sizeof(pt_regs->link)) + return FALSE; // size mismatch + + memcpy(value, &pt_regs->link, size); + break; + + case PPC64_CTR_REGNUM: + if (size != sizeof(pt_regs->ctr)) + return FALSE; // size mismatch + + memcpy(value, &pt_regs->ctr, size); + break; + } + + /* free buffer allocated by fill_stackbuf */ + if (bt_info.stackbuf) + FREEBUF(bt_info.stackbuf); + + return TRUE; +} + /* * For vmcore typically saved with KDump or FADump, get SP and IP values * from the saved ptregs. @@ -2613,9 +2714,11 @@ ppc64_get_dumpfile_stack_frame(struct bt_info *bt_in, ulong *nip, ulong *ksp) pt_regs = (struct ppc64_pt_regs *)bt->machdep; ur_nip = pt_regs->nip; ur_ksp = pt_regs->gpr[1]; - /* Print the collected regs for panic task. */ - ppc64_print_regs(pt_regs); - ppc64_print_nip_lr(pt_regs, 1); + if (!(bt->flags & BT_NO_PRINT_REGS)) { + /* Print the collected regs for panic task. */ + ppc64_print_regs(pt_regs); + ppc64_print_nip_lr(pt_regs, 1); + } } else if ((pc->flags & KDUMP) || ((pc->flags & DISKDUMP) && (*diskdump_flags & KDUMP_CMPRS_LOCAL))) { -- 2.43.0

Currently, both crash context and gdb's current thread context were pretty independent, and could be different, for example, crash commands might be working on thread 6 (CPU 5), but GDB passthroughs will be working on thread 2 (CPU 1). This was not a problem earlier since interaction of crash and gdb was not depending on current context for most part. But for gdb passthroughs to work correctly, gdb needs register values from crash, which depend on current context in crash. Synchronise 'thread' command in gdb with 'set -c' command in crash. 1. crash -> gdb synchronisation: Everytime crash's context changes, a helper is called to switch to the thread on that CPU in gdb. The function has been implemented in crash_target.c, since gdb functions are accessible inside 'crash_target.c', and the thread ID to CPU ID mapping is also done by the crash_target, during initially registering the threads with gdb. With this implementation, GDB's default thread initially also changes to the crashing thread, so a switch to crashing thread manually isn't required anymore 2. gdb -> crash synchronisation: gdb has been patched to call 'set_cpu' whenever user switches to any thread. Signed-off-by: Aditya Gupta <adityag(a)linux.ibm.com&gt; --- crash_target.c | 24 ++++++++++++++++++++++++ defs.h | 3 +++ gdb-10.2.patch | 30 ++++++++++++++++++++++++++++++ kernel.c | 8 +++++++- task.c | 4 +++- 5 files changed, 67 insertions(+), 2 deletions(-) diff --git a/crash_target.c b/crash_target.c index 455480679741..a9d7eea8a80e 100644 --- a/crash_target.c +++ b/crash_target.c @@ -29,6 +29,8 @@ extern "C" int gdb_readmem_callback(unsigned long, void *, int, int); extern "C" int crash_get_nr_cpus(void); extern "C" int crash_get_cpu_reg (int cpu, int regno, const char *regname, int regsize, void *val); +extern "C" int gdb_change_cpu_context (unsigned int cpu); +extern "C" int set_cpu (int cpu); /* The crash target. */ @@ -133,3 +135,25 @@ crash_target_init (void) /* Now, set up the frame cache. */ reinit_frame_cache (); } + +/* + * Change gdb's thread context to the thread on given CPU + **/ +extern "C" int +gdb_change_cpu_context(unsigned int cpu) +{ + ptid_t ptid = ptid_t(CRASH_INFERIOR_PID, 0, cpu); + inferior *inf = current_inferior (); + thread_info *tp = find_thread_ptid (inf, ptid); + + if (tp == nullptr) + return FALSE; + + /* Making sure that crash's context is same */ + set_cpu(cpu); + + /* Switch to the thread */ + switch_to_thread(tp); + return TRUE; +} + diff --git a/defs.h b/defs.h index 615f3a37935a..7f7a12753658 100644 --- a/defs.h +++ b/defs.h @@ -7976,4 +7976,7 @@ enum ppc64_regnum { PPC64_VRSAVE_REGNU = 139 }; +/* crash_target.c */ +extern int gdb_change_cpu_context (unsigned int cpu); + #endif /* !GDB_COMMON */ diff --git a/gdb-10.2.patch b/gdb-10.2.patch index 2f7d585105aa..4698079ca343 100644 --- a/gdb-10.2.patch +++ b/gdb-10.2.patch @@ -10,6 +10,7 @@ tar xvzmf gdb-10.2.tar.gz \ gdb-10.2/gdb/symtab.c \ + gdb-10.2/gdb/thread.c \ gdb-10.2/gdb/printcmd.c \ gdb-10.2/gdb/symfile.c \ gdb-10.2/gdb/Makefile.in \ @@ -3237,3 +3238,32 @@ exit 0 for (compunit_symtab *cust : objfile->compunits ()) { +--- gdb-10.2/gdb/thread.c.orig ++++ gdb-10.2/gdb/thread.c +@@ -58,6 +58,11 @@ static int highest_thread_num; + /* The current/selected thread. */ + static thread_info *current_thread_; + ++#ifdef CRASH_MERGE ++/* Function to set cpu, defined by crash-utility */ ++extern "C" void set_cpu (int); ++#endif ++ + /* RAII type used to increase / decrease the refcount of each thread + in a given list of threads. */ + +@@ -1896,7 +1901,13 @@ thread_command (const char *tidstr, int from_tty) + { + ptid_t previous_ptid = inferior_ptid; + +- thread_select (tidstr, parse_thread_id (tidstr, NULL)); ++ struct thread_info* thread_id = parse_thread_id (tidstr, NULL); ++ ++#ifdef CRASH_MERGE ++ set_cpu(thread_id->ptid.tid()); ++#endif ++ ++ thread_select (tidstr, thread_id); + + /* Print if the thread has not changed, otherwise an event will + be sent. */ diff --git a/kernel.c b/kernel.c index 52b7ba09f390..a8d60507dd95 100644 --- a/kernel.c +++ b/kernel.c @@ -6504,7 +6504,13 @@ set_cpu(int cpu) if (hide_offline_cpu(cpu)) error(FATAL, "invalid cpu number: cpu %d is OFFLINE\n", cpu); - if ((task = get_active_task(cpu))) + task = get_active_task(cpu); + + /* Check if context is already set to given cpu */ + if (task == CURRENT_TASK()) + return; + + if (task) set_context(task, NO_PID); else error(FATAL, "cannot determine active task on cpu %ld\n", cpu); diff --git a/task.c b/task.c index ebdb5be3786f..3a190cafbacb 100644 --- a/task.c +++ b/task.c @@ -5301,7 +5301,9 @@ set_context(ulong task, ulong pid) if (found) { CURRENT_CONTEXT() = tc; - return TRUE; + + /* change the selected thread in gdb, according to current context */ + return gdb_change_cpu_context(tc->processor); } else { if (task) error(INFO, "cannot set context for task: %lx\n", task); -- 2.43.0

Hi Kazu, On Thu, Feb 08, 2024 at 08:40:26AM +0000, HAGIO KAZUHITO(萩尾 一仁) wrote: Nice idea, true, 'get_active_task' can be used instead of me depending on CURRENT_CONTEXT. But, seems everytime 'get_cpu_reg' will be called, 'get_active_task' will have to go through all tasks to get the active task. Can I add this if condition in 'get_active_task' to optimise it: --- a/task.c +++ b/task.c @@ -6308,6 +6308,11 @@ get_active_task(int cpu) if (DUMPFILE() && (task = tt->panic_threads[cpu])) return task; + /* return current task if already set to required active task */ + tc = CURRENT_CONTEXT(); + if ((tc->processor == cpu) && is_task_active(tc->task)) + return tc->task; + tc = FIRST_CONTEXT(); for (i = 0; i < RUNNING_TASKS(); i++, tc++) { if ((tc->processor == cpu) && is_task_active(tc->task)) Yes, I think it's better to not remove the set_cpu()s done in gdb_refresh_regcache(), so that there are no issues due to the gdb and crash contexts not being in sync. Sure, i will. Thanks, Aditya Gupta > > Thanks, > Kazu > > > > > Synchronise 'thread' command in gdb with 'set -c' command in crash. > > 1. crash -> gdb synchronisation: > > Everytime crash's context changes, a helper is called to switch to > > the thread on that CPU in gdb. The function has been implemented in > > crash_target.c, since gdb functions are accessible inside > > 'crash_target.c', and the thread ID to CPU ID mapping is also done > > by the crash_target, during initially registering the threads with > > gdb. With this implementation, GDB's default thread initially also > > changes to the crashing thread, so a switch to crashing thread > > manually isn't required anymore > > > > 2. gdb -> crash synchronisation: > > gdb has been patched to call 'set_cpu' whenever user switches to any > > thread. > > > > Signed-off-by: Aditya Gupta <adityag(a)linux.ibm.com&gt; > > --- > > crash_target.c | 24 ++++++++++++++++++++++++ > > defs.h | 3 +++ > > gdb-10.2.patch | 30 ++++++++++++++++++++++++++++++ > > kernel.c | 8 +++++++- > > task.c | 4 +++- > > 5 files changed, 67 insertions(+), 2 deletions(-) > > > > diff --git a/crash_target.c b/crash_target.c > > index 455480679741..a9d7eea8a80e 100644 > > --- a/crash_target.c > > +++ b/crash_target.c > > @@ -29,6 +29,8 @@ extern "C" int gdb_readmem_callback(unsigned long, void *, int, int); > > extern "C" int crash_get_nr_cpus(void); > > extern "C" int crash_get_cpu_reg (int cpu, int regno, const char *regname, > > int regsize, void *val); > > +extern "C" int gdb_change_cpu_context (unsigned int cpu); > > +extern "C" int set_cpu (int cpu); > > > > > > /* The crash target. */ > > @@ -133,3 +135,25 @@ crash_target_init (void) > > /* Now, set up the frame cache. */ > > reinit_frame_cache (); > > } > > + > > +/* > > + * Change gdb's thread context to the thread on given CPU > > + **/ > > +extern "C" int > > +gdb_change_cpu_context(unsigned int cpu) > > +{ > > + ptid_t ptid = ptid_t(CRASH_INFERIOR_PID, 0, cpu); > > + inferior *inf = current_inferior (); > > + thread_info *tp = find_thread_ptid (inf, ptid); > > + > > + if (tp == nullptr) > > + return FALSE; > > + > > + /* Making sure that crash's context is same */ > > + set_cpu(cpu); > > + > > + /* Switch to the thread */ > > + switch_to_thread(tp); > > + return TRUE; > > +} > > + > > diff --git a/defs.h b/defs.h > > index 615f3a37935a..7f7a12753658 100644 > > --- a/defs.h > > +++ b/defs.h > > @@ -7976,4 +7976,7 @@ enum ppc64_regnum { > > PPC64_VRSAVE_REGNU = 139 > > }; > > > > +/* crash_target.c */ > > +extern int gdb_change_cpu_context (unsigned int cpu); > > + > > #endif /* !GDB_COMMON */ > > diff --git a/gdb-10.2.patch b/gdb-10.2.patch > > index 2f7d585105aa..4698079ca343 100644 > > --- a/gdb-10.2.patch > > +++ b/gdb-10.2.patch > > @@ -10,6 +10,7 @@ > > > > tar xvzmf gdb-10.2.tar.gz \ > > gdb-10.2/gdb/symtab.c \ > > + gdb-10.2/gdb/thread.c \ > > gdb-10.2/gdb/printcmd.c \ > > gdb-10.2/gdb/symfile.c \ > > gdb-10.2/gdb/Makefile.in \ > > @@ -3237,3 +3238,32 @@ exit 0 > > > > for (compunit_symtab *cust : objfile->compunits ()) > > { > > +--- gdb-10.2/gdb/thread.c.orig > > ++++ gdb-10.2/gdb/thread.c > > +@@ -58,6 +58,11 @@ static int highest_thread_num; > > + /* The current/selected thread. */ > > + static thread_info *current_thread_; > > + > > ++#ifdef CRASH_MERGE > > ++/* Function to set cpu, defined by crash-utility */ > > ++extern "C" void set_cpu (int); > > ++#endif > > ++ > > + /* RAII type used to increase / decrease the refcount of each thread > > + in a given list of threads. */ > > + > > +@@ -1896,7 +1901,13 @@ thread_command (const char *tidstr, int from_tty) > > + { > > + ptid_t previous_ptid = inferior_ptid; > > + > > +- thread_select (tidstr, parse_thread_id (tidstr, NULL)); > > ++ struct thread_info* thread_id = parse_thread_id (tidstr, NULL); > > ++ > > ++#ifdef CRASH_MERGE > > ++ set_cpu(thread_id->ptid.tid()); > > ++#endif > > ++ > > ++ thread_select (tidstr, thread_id); > > + > > + /* Print if the thread has not changed, otherwise an event will > > + be sent. */ > > diff --git a/kernel.c b/kernel.c > > index 52b7ba09f390..a8d60507dd95 100644 > > --- a/kernel.c > > +++ b/kernel.c > > @@ -6504,7 +6504,13 @@ set_cpu(int cpu) > > if (hide_offline_cpu(cpu)) > > error(FATAL, "invalid cpu number: cpu %d is OFFLINE\n", cpu); > > > > - if ((task = get_active_task(cpu))) > > + task = get_active_task(cpu); > > + > > + /* Check if context is already set to given cpu */ > > + if (task == CURRENT_TASK()) > > + return; > > + > > + if (task) > > set_context(task, NO_PID); > > else > > error(FATAL, "cannot determine active task on cpu %ld\n", cpu); > > diff --git a/task.c b/task.c > > index ebdb5be3786f..3a190cafbacb 100644 > > --- a/task.c > > +++ b/task.c > > @@ -5301,7 +5301,9 @@ set_context(ulong task, ulong pid) > > > > if (found) { > > CURRENT_CONTEXT() = tc; > > - return TRUE; > > + > > + /* change the selected thread in gdb, according to current context */ > > + return gdb_change_cpu_context(tc->processor); > > } else { > > if (task) > > error(INFO, "cannot set context for task: %lx\n", task);

Hi Kazu, On Fri, Feb 09, 2024 at 05:17:33AM +0000, HAGIO KAZUHITO(萩尾 一仁) wrote: True, i missed that. Atleast on ppc, most dumpfiles should have tt->panic_threads, that should be enough optimisation. I will post a V8 with the 'get_active_task' instead of depending on CURRENT_CONTEXT. Thanks, Aditya Gupta > Thanks, > Kazu > > > > > --- a/task.c > > +++ b/task.c > > @@ -6308,6 +6308,11 @@ get_active_task(int cpu) > > if (DUMPFILE() && (task = tt->panic_threads[cpu])) > > return task; > > > > + /* return current task if already set to required active task */ > > + tc = CURRENT_CONTEXT(); > > + if ((tc->processor == cpu) && is_task_active(tc->task)) > > + return tc->task; > > + > > tc = FIRST_CONTEXT(); > > for (i = 0; i < RUNNING_TASKS(); i++, tc++) { > > if ((tc->processor == cpu) && is_task_active(tc->task)) > > > >> > >> The synchronization between crash and gdb is nice for usability, though. > > > > Yes, I think it's better to not remove the set_cpu()s done in > > gdb_refresh_regcache(), so that there are no issues due to the gdb and > > crash contexts not being in sync. > > > >> > >> (it's very helpful if you would rebase the patch set to the latest, when > >> you update this.) > > > > Sure, i will. > > > > Thanks, > > Aditya Gupta > > > >> > >> Thanks, > >> Kazu > >> > >>> > >>> Synchronise 'thread' command in gdb with 'set -c' command in crash. > >>> 1. crash -> gdb synchronisation: > >>> Everytime crash's context changes, a helper is called to switch to > >>> the thread on that CPU in gdb. The function has been implemented in > >>> crash_target.c, since gdb functions are accessible inside > >>> 'crash_target.c', and the thread ID to CPU ID mapping is also done > >>> by the crash_target, during initially registering the threads with > >>> gdb. With this implementation, GDB's default thread initially also > >>> changes to the crashing thread, so a switch to crashing thread > >>> manually isn't required anymore > >>> > >>> 2. gdb -> crash synchronisation: > >>> gdb has been patched to call 'set_cpu' whenever user switches to any > >>> thread. > >>> > >>> Signed-off-by: Aditya Gupta <adityag(a)linux.ibm.com&gt; > >>> --- > >>> crash_target.c | 24 ++++++++++++++++++++++++ > >>> defs.h | 3 +++ > >>> gdb-10.2.patch | 30 ++++++++++++++++++++++++++++++ > >>> kernel.c | 8 +++++++- > >>> task.c | 4 +++- > >>> 5 files changed, 67 insertions(+), 2 deletions(-) > >>> > >>> diff --git a/crash_target.c b/crash_target.c > >>> index 455480679741..a9d7eea8a80e 100644 > >>> --- a/crash_target.c > >>> +++ b/crash_target.c > >>> @@ -29,6 +29,8 @@ extern "C" int gdb_readmem_callback(unsigned long, void *, int, int); > >>> extern "C" int crash_get_nr_cpus(void); > >>> extern "C" int crash_get_cpu_reg (int cpu, int regno, const char *regname, > >>> int regsize, void *val); > >>> +extern "C" int gdb_change_cpu_context (unsigned int cpu); > >>> +extern "C" int set_cpu (int cpu); > >>> > >>> > >>> /* The crash target. */ > >>> @@ -133,3 +135,25 @@ crash_target_init (void) > >>> /* Now, set up the frame cache. */ > >>> reinit_frame_cache (); > >>> } > >>> + > >>> +/* > >>> + * Change gdb's thread context to the thread on given CPU > >>> + **/ > >>> +extern "C" int > >>> +gdb_change_cpu_context(unsigned int cpu) > >>> +{ > >>> + ptid_t ptid = ptid_t(CRASH_INFERIOR_PID, 0, cpu); > >>> + inferior *inf = current_inferior (); > >>> + thread_info *tp = find_thread_ptid (inf, ptid); > >>> + > >>> + if (tp == nullptr) > >>> + return FALSE; > >>> + > >>> + /* Making sure that crash's context is same */ > >>> + set_cpu(cpu); > >>> + > >>> + /* Switch to the thread */ > >>> + switch_to_thread(tp); > >>> + return TRUE; > >>> +} > >>> + > >>> diff --git a/defs.h b/defs.h > >>> index 615f3a37935a..7f7a12753658 100644 > >>> --- a/defs.h > >>> +++ b/defs.h > >>> @@ -7976,4 +7976,7 @@ enum ppc64_regnum { > >>> PPC64_VRSAVE_REGNU = 139 > >>> }; > >>> > >>> +/* crash_target.c */ > >>> +extern int gdb_change_cpu_context (unsigned int cpu); > >>> + > >>> #endif /* !GDB_COMMON */ > >>> diff --git a/gdb-10.2.patch b/gdb-10.2.patch > >>> index 2f7d585105aa..4698079ca343 100644 > >>> --- a/gdb-10.2.patch > >>> +++ b/gdb-10.2.patch > >>> @@ -10,6 +10,7 @@ > >>> > >>> tar xvzmf gdb-10.2.tar.gz \ > >>> gdb-10.2/gdb/symtab.c \ > >>> + gdb-10.2/gdb/thread.c \ > >>> gdb-10.2/gdb/printcmd.c \ > >>> gdb-10.2/gdb/symfile.c \ > >>> gdb-10.2/gdb/Makefile.in \ > >>> @@ -3237,3 +3238,32 @@ exit 0 > >>> > >>> for (compunit_symtab *cust : objfile->compunits ()) > >>> { > >>> +--- gdb-10.2/gdb/thread.c.orig > >>> ++++ gdb-10.2/gdb/thread.c > >>> +@@ -58,6 +58,11 @@ static int highest_thread_num; > >>> + /* The current/selected thread. */ > >>> + static thread_info *current_thread_; > >>> + > >>> ++#ifdef CRASH_MERGE > >>> ++/* Function to set cpu, defined by crash-utility */ > >>> ++extern "C" void set_cpu (int); > >>> ++#endif > >>> ++ > >>> + /* RAII type used to increase / decrease the refcount of each thread > >>> + in a given list of threads. */ > >>> + > >>> +@@ -1896,7 +1901,13 @@ thread_command (const char *tidstr, int from_tty) > >>> + { > >>> + ptid_t previous_ptid = inferior_ptid; > >>> + > >>> +- thread_select (tidstr, parse_thread_id (tidstr, NULL)); > >>> ++ struct thread_info* thread_id = parse_thread_id (tidstr, NULL); > >>> ++ > >>> ++#ifdef CRASH_MERGE > >>> ++ set_cpu(thread_id->ptid.tid()); > >>> ++#endif > >>> ++ > >>> ++ thread_select (tidstr, thread_id); > >>> + > >>> + /* Print if the thread has not changed, otherwise an event will > >>> + be sent. */ > >>> diff --git a/kernel.c b/kernel.c > >>> index 52b7ba09f390..a8d60507dd95 100644 > >>> --- a/kernel.c > >>> +++ b/kernel.c > >>> @@ -6504,7 +6504,13 @@ set_cpu(int cpu) > >>> if (hide_offline_cpu(cpu)) > >>> error(FATAL, "invalid cpu number: cpu %d is OFFLINE\n", cpu); > >>> > >>> - if ((task = get_active_task(cpu))) > >>> + task = get_active_task(cpu); > >>> + > >>> + /* Check if context is already set to given cpu */ > >>> + if (task == CURRENT_TASK()) > >>> + return; > >>> + > >>> + if (task) > >>> set_context(task, NO_PID); > >>> else > >>> error(FATAL, "cannot determine active task on cpu %ld\n", cpu); > >>> diff --git a/task.c b/task.c > >>> index ebdb5be3786f..3a190cafbacb 100644 > >>> --- a/task.c > >>> +++ b/task.c > >>> @@ -5301,7 +5301,9 @@ set_context(ulong task, ulong pid) > >>> > >>> if (found) { > >>> CURRENT_CONTEXT() = tc; > >>> - return TRUE; > >>> + > >>> + /* change the selected thread in gdb, according to current context */ > >>> + return gdb_change_cpu_context(tc->processor); > >>> } else { > >>> if (task) > >>> error(INFO, "cannot set context for task: %lx\n", task);

Currently the output is like this ppc64le: crash> info threads Id Target Id Frame 1 CPU 0 <unavailable> in ?? () 2 CPU 1 0xc000000000025d00 in ppc_panic_event (this=<optimized out>, event=<optimized out>, ptr=0x0) at arch/powerpc/kernel/setup-common.c:712 3 CPU 2 0xc000000000025d00 in ppc_panic_event (this=<optimized out>, event=<optimized out>, ptr=0x0) at arch/powerpc/kernel/setup-common.c:712 4 CPU 3 0xc000000000025d00 in ppc_panic_event (this=<optimized out>, event=<optimized out>, ptr=0x0) at arch/powerpc/kernel/setup-common.c:712 * 5 CPU 4 0xc000000000025d00 in ppc_panic_event (this=<optimized out>, event=<optimized out>, ptr=0x0) at arch/powerpc/kernel/setup-common.c:712 6 CPU 5 0xc000000000025d00 in ppc_panic_event (this=<optimized out>, event=<optimized out>, ptr=0x0) at arch/powerpc/kernel/setup-common.c:712 7 CPU 6 0xc000000000025d00 in ppc_panic_event (this=<optimized out>, event=<optimized out>, ptr=0x0) at arch/powerpc/kernel/setup-common.c:712 8 CPU 7 0xc000000000025d00 in ppc_panic_event (this=<optimized out>, event=<optimized out>, ptr=0x0) at arch/powerpc/kernel/setup-common.c:712 There are two issues here: 1. CPU 0 always shows '<unavailable>' frame: This is due to 'thread 0' being initialised in 'crash_target_init', but it's very early in crash init, so it could not get any registers from the vmcore. And, since GDB caches registers (whether it is there or now), it keeps thinking that registers for this thread are unavailable, so all future usage of thread 0 also shows unavailable registers & frame Fix this by refreshing the register cache of all threads in 'gdb_refresh_regcache', at task_init 2. All other CPUs show the same frame: For each thread, GDB depends on crash to give it registers, ie. crash_target::fetch_registers, but this in turn depends on crash's current context GDB internally switches it's thread context internally to each thread one by one, while printing the thread's frame, similarly switch crash's context when the thread context is changed, so that it matches the thread context in gdb (such as, CPU 3 in crash for thread 2(CPU 3) in gdb). Also, since we are switching context multiple times, add an argument to 'set_cpu' to not print the context everytime With these fixed, it will show all threads, as well as correct registers and frame. It might still show similar frame for many threads, due to all of them being on same NMI exception crash path, but if checked with 'info registers', they will have different registers. Signed-off-by: Aditya Gupta <adityag(a)linux.ibm.com&gt; --- crash_target.c | 37 ++++++++++++++++++++++++++++++++-- defs.h | 5 +++-- gdb-10.2.patch | 54 ++++++++++++++++++++++++++++++++++++++++++++++++++ kernel.c | 8 +++++--- task.c | 30 ++++++++++++++++++++-------- tools.c | 10 +++++----- 6 files changed, 124 insertions(+), 20 deletions(-) diff --git a/crash_target.c b/crash_target.c index a9d7eea8a80e..d06383f594aa 100644 --- a/crash_target.c +++ b/crash_target.c @@ -30,7 +30,8 @@ extern "C" int crash_get_nr_cpus(void); extern "C" int crash_get_cpu_reg (int cpu, int regno, const char *regname, int regsize, void *val); extern "C" int gdb_change_cpu_context (unsigned int cpu); -extern "C" int set_cpu (int cpu); +extern "C" void gdb_refresh_regcache(unsigned int cpu); +extern "C" int set_cpu(int cpu, int print_context); /* The crash target. */ @@ -150,10 +151,42 @@ gdb_change_cpu_context(unsigned int cpu) return FALSE; /* Making sure that crash's context is same */ - set_cpu(cpu); + set_cpu(cpu, FALSE); /* Switch to the thread */ switch_to_thread(tp); + + /* Fetch/Refresh thread's registers */ + gdb_refresh_regcache(cpu); + return TRUE; } +/* Refresh regcache of gdb thread on given CPU + * + * When gdb threads were initially added by 'crash_target_init', crash was not + * yet initialised, and hence crash_target::fetch_registers didn't give any + * registers to gdb. + * + * This is meant to be called after tasks in crash have been initialised, and + * possible machdep->get_cpu_reg is also set so architecture can give registers + */ +extern "C" void +gdb_refresh_regcache(unsigned int cpu) +{ + int saved_cpu = inferior_thread()->ptid.tid(); + ptid_t ptid = ptid_t(CRASH_INFERIOR_PID, 0, cpu); + inferior *inf = current_inferior(); + thread_info *tp = find_thread_ptid (inf, ptid); + + if (tp == NULL) { + warning("gdb thread for cpu %d not found\n", cpu); + return; + } + + /* temporarily switch to the cpu so we get correct registers */ + set_cpu(cpu, FALSE); + target_fetch_registers(get_thread_regcache(tp), -1); + + set_cpu(saved_cpu, FALSE); +} diff --git a/defs.h b/defs.h index 7f7a12753658..ba4a6a606f66 100644 --- a/defs.h +++ b/defs.h @@ -5940,7 +5940,7 @@ extern char *help_map[]; * task.c */ void task_init(void); -int set_context(ulong, ulong); +int set_context(ulong, ulong, uint); void show_context(struct task_context *); ulong pid_to_task(ulong); ulong task_to_pid(ulong); @@ -6044,7 +6044,7 @@ void parse_kernel_version(char *); #define SHOW_LOG_AUDIT (0x8) #define SHOW_LOG_CTIME (0x10) #define SHOW_LOG_SAFE (0x20) -void set_cpu(int); +void set_cpu(int cpu, int print_context); void clear_machdep_cache(void); struct stack_hook *gather_text_list(struct bt_info *); int get_cpus_online(void); @@ -7978,5 +7978,6 @@ enum ppc64_regnum { /* crash_target.c */ extern int gdb_change_cpu_context (unsigned int cpu); +extern void gdb_refresh_regcache (unsigned int cpu); #endif /* !GDB_COMMON */ diff --git a/gdb-10.2.patch b/gdb-10.2.patch index 2b8b3a41f2bd..b15a46de0b13 100644 --- a/gdb-10.2.patch +++ b/gdb-10.2.patch @@ -3320,3 +3320,57 @@ exit 0 } /* +--- gdb-10.2/gdb/thread.c.orig ++++ gdb-10.2/gdb/thread.c +@@ -60,7 +60,7 @@ static thread_info *current_thread_; + + #ifdef CRASH_MERGE + /* Function to set cpu, defined by crash-utility */ +-extern "C" void set_cpu (int); ++extern "C" void set_cpu(int cpu, int print_context); + #endif + + /* RAII type used to increase / decrease the refcount of each thread +@@ -1098,6 +1098,9 @@ print_thread_info_1 (struct ui_out *uiout, const char *requested_threads, + uiout->table_body (); + } + ++#ifdef CRASH_MERGE ++ int current_cpu = current_thread ? current_thread->ptid.tid() : 0; ++#endif + for (inferior *inf : all_inferiors ()) + for (thread_info *tp : inf->threads ()) + { +@@ -1113,6 +1116,11 @@ print_thread_info_1 (struct ui_out *uiout, const char *requested_threads, + + ui_out_emit_tuple tuple_emitter (uiout, NULL); + ++ /* Switch to the thread's CPU in crash */ ++#ifdef CRASH_MERGE ++ set_cpu(tp->ptid.tid(), FALSE); ++#endif ++ + if (!uiout->is_mi_like_p ()) + { + if (tp == current_thread) +@@ -1185,6 +1193,11 @@ print_thread_info_1 (struct ui_out *uiout, const char *requested_threads, + /* This end scope restores the current thread and the frame + selected before the "info threads" command, and it finishes the + ui-out list or table. */ ++ ++#ifdef CRASH_MERGE ++ /* Restore crash's context */ ++ set_cpu(current_cpu, FALSE); ++#endif + } + + if (pid == -1 && requested_threads == NULL) +@@ -1904,7 +1917,7 @@ thread_command (const char *tidstr, int from_tty) + struct thread_info* thread_id = parse_thread_id (tidstr, NULL); + + #ifdef CRASH_MERGE +- set_cpu(thread_id->ptid.tid()); ++ set_cpu(thread_id->ptid.tid(), FALSE); + #endif + + thread_select (tidstr, thread_id); diff --git a/kernel.c b/kernel.c index a8d60507dd95..505cffde1cf8 100644 --- a/kernel.c +++ b/kernel.c @@ -6491,9 +6491,10 @@ no_cpu_flags: /* * Set the context to the active task on a given cpu -- dumpfiles only. + * Optionally show the context if print_context is TRUE */ void -set_cpu(int cpu) +set_cpu(int cpu, int print_context) { ulong task; @@ -6511,11 +6512,12 @@ set_cpu(int cpu) return; if (task) - set_context(task, NO_PID); + set_context(task, NO_PID, TRUE); else error(FATAL, "cannot determine active task on cpu %ld\n", cpu); - show_context(CURRENT_CONTEXT()); + if (print_context) + show_context(CURRENT_CONTEXT()); } diff --git a/task.c b/task.c index 3a190cafbacb..a405b05a47d1 100644 --- a/task.c +++ b/task.c @@ -672,7 +672,7 @@ task_init(void) if (ACTIVE()) { active_pid = REMOTE() ? pc->server_pid : LOCAL_ACTIVE() ? pc->program_pid : 1; - set_context(NO_TASK, active_pid); + set_context(NO_TASK, active_pid, FALSE); tt->this_task = pid_to_task(active_pid); } else { @@ -684,7 +684,7 @@ task_init(void) else if (ELF_NOTES_VALID() && DISKDUMP_DUMPFILE()) map_cpus_to_prstatus_kdump_cmprs(); please_wait("determining panic task"); - set_context(get_panic_context(), NO_PID); + set_context(get_panic_context(), NO_PID, TRUE); please_wait_done(); } @@ -706,6 +706,17 @@ task_init(void) kt->boot_date.tv_nsec = 0; } + /* + * Refresh CPU 0's thread's regcache + * + * This is required since, it's registers were initialised in + * crash_target_init when crash was not initialised yet and hence could + * not pass registers to gdb when gdb requests via + * crash_target::fetch_registers, so CPU 0's registers are shown as + * <unavailable> in gdb mode + * */ + gdb_refresh_regcache(0); + tt->flags |= TASK_INIT_DONE; } @@ -2985,9 +2996,9 @@ refresh_context(ulong curtask, ulong curpid) struct task_context *tc; if (task_exists(curtask) && pid_exists(curpid)) { - set_context(curtask, NO_PID); + set_context(curtask, NO_PID, FALSE); } else { - set_context(tt->this_task, NO_PID); + set_context(tt->this_task, NO_PID, FALSE); complain = TRUE; if (STREQ(args[0], "set") && (argcnt == 2) && @@ -3053,7 +3064,7 @@ sort_context_array(void) curtask = CURRENT_TASK(); qsort((void *)tt->context_array, (size_t)tt->running_tasks, sizeof(struct task_context), sort_by_pid); - set_context(curtask, NO_PID); + set_context(curtask, NO_PID, FALSE); sort_context_by_task(); } @@ -3100,7 +3111,7 @@ sort_context_array_by_last_run(void) curtask = CURRENT_TASK(); qsort((void *)tt->context_array, (size_t)tt->running_tasks, sizeof(struct task_context), sort_by_last_run); - set_context(curtask, NO_PID); + set_context(curtask, NO_PID, FALSE); sort_context_by_task(); } @@ -5281,7 +5292,7 @@ comm_exists(char *s) * that pid is selected. */ int -set_context(ulong task, ulong pid) +set_context(ulong task, ulong pid, uint update_gdb_thread) { int i; struct task_context *tc; @@ -5303,7 +5314,10 @@ set_context(ulong task, ulong pid) CURRENT_CONTEXT() = tc; /* change the selected thread in gdb, according to current context */ - return gdb_change_cpu_context(tc->processor); + if (update_gdb_thread) + return gdb_change_cpu_context(tc->processor); + else + return TRUE; } else { if (task) error(INFO, "cannot set context for task: %lx\n", task); diff --git a/tools.c b/tools.c index 0f2db108838a..9b149fb27fcb 100644 --- a/tools.c +++ b/tools.c @@ -1860,7 +1860,7 @@ cmd_set(void) break; } cpu = dtoi(optarg, FAULT_ON_ERROR, NULL); - set_cpu(cpu); + set_cpu(cpu, TRUE); return; case 'p': @@ -1871,7 +1871,7 @@ cmd_set(void) return; if (ACTIVE()) { - set_context(tt->this_task, NO_PID); + set_context(tt->this_task, NO_PID, FALSE); show_context(CURRENT_CONTEXT()); return; } @@ -1880,7 +1880,7 @@ cmd_set(void) error(INFO, "no panic task found!\n"); return; } - set_context(tt->panic_task, NO_PID); + set_context(tt->panic_task, NO_PID, FALSE); show_context(CURRENT_CONTEXT()); return; @@ -2559,14 +2559,14 @@ cmd_set(void) case STR_PID: pid = value; task = NO_TASK; - if (set_context(task, pid)) + if (set_context(task, pid, FALSE)) show_context(CURRENT_CONTEXT()); break; case STR_TASK: task = value; pid = NO_PID; - if (set_context(task, pid)) + if (set_context(task, pid, FALSE)) show_context(CURRENT_CONTEXT()); break; -- 2.43.0

Hi Kazu, On Thu, Feb 08, 2024 at 08:41:12AM +0000, HAGIO KAZUHITO(萩尾 一仁) wrote: Yes, it makes sense. I will change it to TRUE. Thanks, Aditya Gupta > > Thanks, > Kazu > > > show_context(CURRENT_CONTEXT()); > > return; > > > > @@ -2559,14 +2559,14 @@ cmd_set(void) > > case STR_PID: > > pid = value; > > task = NO_TASK; > > - if (set_context(task, pid)) > > + if (set_context(task, pid, FALSE)) > > show_context(CURRENT_CONTEXT()); > > break; > > > > case STR_TASK: > > task = value; > > pid = NO_PID; > > - if (set_context(task, pid)) > > + if (set_context(task, pid, FALSE)) > > show_context(CURRENT_CONTEXT()); > > break; > >