From: Natalia Saiapova Introduce a new structure to manage different options of the scheduler locking. The options can coexist together and be set individually. In the next patch gdb: refine commands to control scheduler locking. we introduce the commands to control these options. In this patch we do not introduce new commands and keep the previous API. New scheduler locking options are: replay continue -- control continuing commands during replay mode. replay step -- control stepping commands during replay mode. continue -- control continuing commands during normal execution. step -- control stepping commands during normal execution. Internally they hold a bool value, when true the locking is enabled. Mapping to the old settings Old Settings | New settings ----------------------------------- off | all are false | replay | continue = false, step = false, | replay continue = true, replay step = true | step | continue = false, step = true, | replay continue = false, replay step = true | on | all are true --- gdb/infrun.c | 147 ++++++++++++++++++++++++++++++++++++++++++++++----- 1 file changed, 134 insertions(+), 13 deletions(-) diff --git a/gdb/infrun.c b/gdb/infrun.c index ba360570d48..f449b222fc3 100644 --- a/gdb/infrun.c +++ b/gdb/infrun.c @@ -106,8 +106,12 @@ static bool start_step_over (void); static bool step_over_info_valid_p (void); -static bool schedlock_applies (struct thread_info *tp); -static bool schedlock_applies (bool step, bool record_will_replay); +struct schedlock_options; +static bool schedlock_applies (thread_info *tp); +static bool schedlock_applies (bool step, + bool record_will_replay, + thread_info *tp = nullptr); +static bool schedlock_applies_to_opts (const schedlock_options &, bool step); /* Asynchronous signal handler registered as event loop source for when we have pending events ready to be passed to the core. */ @@ -2321,7 +2325,69 @@ infrun_thread_ptid_changed (process_stratum_target *target, inferior_ptid = new_ptid; } - +/* A structure to hold scheduler locking settings for + a mode, replay or normal. */ +struct schedlock_options +{ + struct option { + const std::string name; + bool value; + + option () = delete; + option (std::string name, bool value) + : name (std::move (name)), value (value) + {} + + /* Forbid accidential copying. */ + option (const option &) = delete; + option operator= (const option &) = delete; + option (option &&) = default; + option &operator= (option &&) = default; + + operator bool () const { return value; } + const char *c_str () const { return value ? "on" : "off"; } + /* Set new value. Return true, if the value has changed. */ + bool set (bool new_value); + }; + + schedlock_options () = delete; + schedlock_options (option cont, option step) + : cont (std::move (cont)), step (std::move (step)) + {} + + /* Forbid accidential copying. */ + schedlock_options (const schedlock_options &) = delete; + schedlock_options operator= (const schedlock_options &) = delete; + schedlock_options (schedlock_options &&) = default; + schedlock_options &operator= (schedlock_options &&) = default; + + /* If true, the scheduler is locked during continuing. */ + option cont; + /* If true, the scheduler is locked during stepping. */ + option step; +}; + +bool +schedlock_options::option::set (bool new_value) +{ + if (value != new_value) + { + value = new_value; + return true; + } + + return false; +} + +struct schedlock +{ + schedlock (schedlock_options opt, schedlock_options replay_opt) + : normal (std::move (opt)), replay (std::move (replay_opt)) + {} + + schedlock_options normal; + schedlock_options replay; +}; static const char schedlock_off[] = "off"; static const char schedlock_on[] = "on"; @@ -2334,7 +2400,42 @@ static const char *const scheduler_enums[] = { schedlock_replay, nullptr }; + static const char *scheduler_mode = schedlock_replay; + +schedlock schedlock { + { + {"cont", false}, + {"step", false} + }, + { + {"replay cont", true}, + {"replay step", true} + } +}; + +/* A helper function to set scheduler locking shortcuts: + set scheduler-locking on: all options are on. + set scheduler-locking off: all options are off. + set scheduler-locking replay: only replay options are on. + set scheduler-locking step: only "step" and "replay step" are on. */ + +static void +set_schedlock_shortcut_option (const char *shortcut) +{ + bool is_on = (shortcut == schedlock_on); + bool is_step = (shortcut == schedlock_step); + bool is_replay = (shortcut == schedlock_replay); + bool is_off = (shortcut == schedlock_off); + /* Check that we got a valid shortcut option. */ + gdb_assert (is_on || is_step || is_replay || is_off); + + schedlock.normal.cont.set (is_on); + schedlock.normal.step.set (is_on || is_step); + schedlock.replay.cont.set (is_on || is_replay); + schedlock.replay.step.set (is_on || is_replay || is_step); +} + static void show_scheduler_mode (struct ui_file *file, int from_tty, struct cmd_list_element *c, const char *value) @@ -2351,9 +2452,13 @@ set_schedlock_func (const char *args, int from_tty, struct cmd_list_element *c) if (!target_can_lock_scheduler ()) { scheduler_mode = schedlock_off; + /* Set scheduler locking off. */ + set_schedlock_shortcut_option (schedlock_off); error (_("Target '%s' cannot support this command."), target_shortname ()); } + + set_schedlock_shortcut_option (scheduler_mode); } /* True if execution commands resume all threads of all processes by @@ -2384,6 +2489,10 @@ ptid_t user_visible_resume_ptid (int step) { ptid_t resume_ptid; + thread_info *tp = nullptr; + + if (inferior_ptid != null_ptid) + tp = inferior_thread (); if (non_stop) { @@ -2393,14 +2502,14 @@ user_visible_resume_ptid (int step) } else if (schedlock_applies (step, target_record_will_replay (inferior_ptid, - execution_direction))) + execution_direction), + tp)) { /* User-settable 'scheduler' mode requires solo thread resume. */ resume_ptid = inferior_ptid; } - else if (inferior_ptid != null_ptid - && inferior_thread ()->control.in_cond_eval) + else if (tp != nullptr && tp->control.in_cond_eval) { /* The inferior thread is evaluating a BP condition. Other threads might be stopped or running and we do not want to change their @@ -3111,8 +3220,9 @@ clear_proceed_status (int step) This is a convenience feature to not require the user to explicitly stop replaying the other threads. We're assuming that the user's intent is to resume tracing the recorded process. */ - if (!non_stop && scheduler_mode == schedlock_replay - && !target_record_will_replay (inferior_ptid, execution_direction)) + if (!non_stop && schedlock_applies_to_opts (schedlock.replay, step) + && !target_record_will_replay (inferior_ptid, + execution_direction)) target_record_stop_replaying (); if (!non_stop && inferior_ptid != null_ptid) @@ -3186,6 +3296,17 @@ thread_still_needs_step_over (struct thread_info *tp) return what; } +/* Return true if OPTS lock the scheduler. + STEP indicates whether a thread is about to step. + Note, this does not take into the account the mode (replay or + normal execution). */ + +static bool +schedlock_applies_to_opts (const schedlock_options &opts, bool step) +{ + return ((opts.cont && !step) || (opts.step && step)); +} + /* Returns true if scheduler locking applies to TP. */ static bool @@ -3199,7 +3320,7 @@ schedlock_applies (thread_info *tp) record_will_replay = target_record_will_replay (tp->ptid, execution_direction); } - return schedlock_applies (step, record_will_replay); + return schedlock_applies (step, record_will_replay, tp); } /* Returns true if scheduler locking applies. STEP indicates whether @@ -3207,11 +3328,11 @@ schedlock_applies (thread_info *tp) indicates whether we're about to replay. */ static bool -schedlock_applies (bool step, bool record_will_replay) +schedlock_applies (bool step, bool record_will_replay, thread_info *tp) { - return (scheduler_mode == schedlock_on - || (scheduler_mode == schedlock_step && step) - || (scheduler_mode == schedlock_replay && record_will_replay)); + schedlock_options &opts + = record_will_replay ? schedlock.replay : schedlock.normal; + return schedlock_applies_to_opts (opts, step); } /* When FORCE_P is false, set process_stratum_target::COMMIT_RESUMED_STATE -- 2.34.1