http://sourceware.org/ml/gdb-cvs/2010-08/msg00101.html ### src/gdb/ChangeLog 2010/08/18 12:24:08 1.12093 ### src/gdb/ChangeLog 2010/08/18 12:25:48 1.12094 ## -2,6 +2,27 @@ PR corefile/8210 + * linux-thread-db.c (add_thread_db_info): Skip glibc/BZ5983 + workaround on core files. + (try_thread_db_load_1): Don't try enabling thread event reporting + on core files. + (thread_db_load): Allow thread_db on core files. + (attach_thread): Don't check thread signals on core files, nor try + really attaching to the thread, nor enabling thread event event + reporting. + (thread_db_detach): Don't try disabing thread event reporting or + removing thread event breakpoints when debugging a core file. + (find_new_threads_callback): Don't try enabling thread event + reporting on core files. + (thread_db_find_new_threads_2): Don't look for a stopped lwp when + debugging a core file. + (thread_db_find_new_threads): Don't update thread + cores (processors) when debugging a core (dump). + +2010-08-18 Pedro Alves + + PR corefile/8210 + * corelow.c (add_to_thread_list): Don't use gdbarch_core_reg_section_encodes_pid. Use bfd_core_file_pid. (get_core_register_section): Don't use --- src/gdb/linux-thread-db.c 2010/07/31 15:34:41 1.76 +++ src/gdb/linux-thread-db.c 2010/08/18 12:25:49 1.77 @@ -189,7 +189,11 @@ info = xcalloc (1, sizeof (*info)); info->pid = ptid_get_pid (inferior_ptid); info->handle = handle; - info->need_stale_parent_threads_check = 1; + + /* The workaround works by reading from /proc/pid/status, so it is + disabled for core files. */ + if (target_has_execution) + info->need_stale_parent_threads_check = 1; info->next = thread_db_list; thread_db_list = info; @@ -737,7 +741,9 @@ if (thread_db_list->next == NULL) push_target (&thread_db_ops); - enable_thread_event_reporting (); + /* Enable event reporting, but not when debugging a core file. */ + if (target_has_execution) + enable_thread_event_reporting (); /* There appears to be a bug in glibc-2.3.6: calls to td_thr_get_info fail with TD_ERR for statically linked executables if td_thr_get_info is @@ -869,13 +875,13 @@ if (info != NULL) return 1; - /* Don't attempt to use thread_db on targets which can not run - (executables not running yet, core files) for now. */ - if (!target_has_execution) + /* Don't attempt to use thread_db on executables not running + yet. */ + if (!target_has_registers) return 0; /* Don't attempt to use thread_db for remote targets. */ - if (!target_can_run (¤t_target)) + if (!(target_can_run (¤t_target) || core_bfd)) return 0; if (thread_db_load_search ()) @@ -1030,13 +1036,15 @@ } } - check_thread_signals (); + if (target_has_execution) + check_thread_signals (); if (ti_p->ti_state == TD_THR_UNKNOWN || ti_p->ti_state == TD_THR_ZOMBIE) return 0; /* A zombie thread -- do not attach. */ /* Under GNU/Linux, we have to attach to each and every thread. */ - if (tp == NULL + if (target_has_execution + && tp == NULL && lin_lwp_attach_lwp (BUILD_LWP (ti_p->ti_lid, GET_PID (ptid))) < 0) return 0; @@ -1061,11 +1069,16 @@ info = get_thread_db_info (GET_PID (ptid)); - /* Enable thread event reporting for this thread. */ - err = info->td_thr_event_enable_p (th_p, 1); - if (err != TD_OK) - error (_("Cannot enable thread event reporting for %s: %s"), - target_pid_to_str (ptid), thread_db_err_str (err)); + /* Enable thread event reporting for this thread, except when + debugging a core file. */ + if (target_has_execution) + { + err = info->td_thr_event_enable_p (th_p, 1); + if (err != TD_OK) + error (_("Cannot enable thread event reporting for %s: %s"), + target_pid_to_str (ptid), thread_db_err_str (err)); + } + return 1; } @@ -1097,14 +1110,17 @@ if (info) { - disable_thread_event_reporting (info); + if (target_has_execution) + { + disable_thread_event_reporting (info); - /* Delete the old thread event breakpoints. Note that unlike - when mourning, we can remove them here because there's still - a live inferior to poke at. In any case, GDB will not try to - insert anything in the inferior when removing a - breakpoint. */ - remove_thread_event_breakpoints (); + /* Delete the old thread event breakpoints. Note that + unlike when mourning, we can remove them here because + there's still a live inferior to poke at. In any case, + GDB will not try to insert anything in the inferior when + removing a breakpoint. */ + remove_thread_event_breakpoints (); + } delete_thread_db_info (GET_PID (inferior_ptid)); } @@ -1317,7 +1333,7 @@ if (ti.ti_state == TD_THR_UNKNOWN || ti.ti_state == TD_THR_ZOMBIE) return 0; /* A zombie -- ignore. */ - if (ti.ti_tid == 0) + if (ti.ti_tid == 0 && target_has_execution) { /* A thread ID of zero means that this is the main thread, but glibc has not yet initialized thread-local storage and the @@ -1417,19 +1433,23 @@ thread_db_find_new_threads_2 (ptid_t ptid, int until_no_new) { td_err_e err; - struct lwp_info *lp; struct thread_db_info *info; int pid = ptid_get_pid (ptid); int i, loop; - /* In linux, we can only read memory through a stopped lwp. */ - ALL_LWPS (lp, ptid) - if (lp->stopped && ptid_get_pid (lp->ptid) == pid) - break; + if (target_has_execution) + { + struct lwp_info *lp; - if (!lp) - /* There is no stopped thread. Bail out. */ - return; + /* In linux, we can only read memory through a stopped lwp. */ + ALL_LWPS (lp, ptid) + if (lp->stopped && ptid_get_pid (lp->ptid) == pid) + break; + + if (!lp) + /* There is no stopped thread. Bail out. */ + return; + } info = get_thread_db_info (GET_PID (ptid)); @@ -1480,8 +1500,9 @@ thread_db_find_new_threads_1 (inferior_ptid); - iterate_over_lwps (minus_one_ptid /* iterate over all */, - update_thread_core, NULL); + if (target_has_execution) + iterate_over_lwps (minus_one_ptid /* iterate over all */, + update_thread_core, NULL); } static char *