Added created_task member to ReplayResult

This member reflects that a new task was created so that a debugger/debugger-frontend can reliably tell whether or not a new task or task group has been created via clone/v/fork syscalls.

Because waiting for exit syscalls in the replay trace is not enough, since the exit replay frame can come long after the spawned task has already started replaying its steps.

This member of ReplayResult is passed down to the appropriate place where we create a new task, it does mean we have to change a  few function signatures unfortunately.

Author: theIDinside

src/ReplaySession.cc

@@ -668,7 +668,8 @@ static void emulate_syscall_entry(ReplayTask* t, const TraceFrame& frame,
  * occurred.
  */
 Completion ReplaySession::enter_syscall(ReplayTask* t,
-                                        const StepConstraints& constraints) {
+                                        const StepConstraints& constraints,
+                                        std::optional<pid_t>& task_created) {
   if (t->regs().matches(trace_frame.regs()) &&
       t->tick_count() == trace_frame.ticks()) {
     // We already entered the syscall via an ENTERING_SYSCALL_PTRACE
@@ -737,7 +738,7 @@ Completion ReplaySession::enter_syscall(ReplayTask* t,
   }
 
   if (current_trace_frame().event().Syscall().state == ENTERING_SYSCALL) {
-    rep_after_enter_syscall(t);
+    rep_after_enter_syscall(t, task_created);
   }
   return COMPLETE;
 }
@@ -1708,7 +1709,8 @@ Completion ReplaySession::advance_to_ticks_target(
  * more work.
  */
 Completion ReplaySession::try_one_trace_step(
-    ReplayTask* t, const StepConstraints& constraints) {
+    ReplayTask* t, const StepConstraints& constraints,
+    std::optional<pid_t>& task_created) {
   if (constraints.ticks_target > 0 && !trace_frame.event().has_ticks_slop() &&
       current_trace_frame().ticks() > constraints.ticks_target) {
     // Instead of doing this step, just advance to the ticks_target, since
@@ -1723,7 +1725,7 @@ Completion ReplaySession::try_one_trace_step(
     case TSTEP_RETIRE:
       return COMPLETE;
     case TSTEP_ENTER_SYSCALL:
-      return enter_syscall(t, constraints);
+      return enter_syscall(t, constraints, task_created);
     case TSTEP_EXIT_SYSCALL:
       return exit_syscall(t);
     case TSTEP_DETERMINISTIC_SIGNAL:
@@ -2056,7 +2058,7 @@ ReplayResult ReplaySession::replay_step(const StepConstraints& constraints) {
   result.break_status.task_context = TaskContext(t);
 
   /* Advance towards fulfilling |current_step|. */
-  Completion complete = try_one_trace_step(t, constraints);
+  Completion complete = try_one_trace_step(t, constraints, result.created_task);
   if (detected_transient_error_) {
     result.status = REPLAY_TRANSIENT_ERROR;
     return result;

src/ReplaySession.h

@@ -126,6 +126,10 @@ struct ReplayResult {
   // one iteration to go. did_fast_forward may be false in this case if the
   // instruction executes exactly twice.
   bool incomplete_fast_forward;
+
+  // If this replay step creates a new task, we need to be able to report it
+  // reliably to a frontend consuming rr.
+  std::optional<pid_t> created_task{ std::nullopt };
 };
 
 /**
@@ -392,10 +396,12 @@ class ReplaySession final : public Session {
   void advance_to_next_trace_frame();
   Completion emulate_signal_delivery(ReplayTask* oldtask);
   Completion try_one_trace_step(ReplayTask* t,
-                                const StepConstraints& step_constraints);
+                                const StepConstraints& step_constraints,
+                                std::optional<pid_t>& task_created);
   Completion cont_syscall_boundary(ReplayTask* t,
                                    const StepConstraints& constraints);
-  Completion enter_syscall(ReplayTask* t, const StepConstraints& constraints);
+  Completion enter_syscall(ReplayTask* t, const StepConstraints& constraints,
+                           std::optional<pid_t>& task_created);
   Completion exit_syscall(ReplayTask* t);
   Completion exit_task(ReplayTask* t);
   bool handle_unrecorded_cpuid_fault(ReplayTask* t,

src/replay_syscall.cc

@@ -150,7 +150,8 @@ static bool syscall_shares_vm(Registers r)
   }
 }
 
-template <typename Arch> static void prepare_clone(ReplayTask* t) {
+template <typename Arch>
+static void prepare_clone(ReplayTask* t, std::optional<pid_t>& task_created) {
   const TraceFrame& trace_frame = t->current_trace_frame();
 
   // We're being called with the syscall entry event, so we can't inspect the result
@@ -267,6 +268,7 @@ template <typename Arch> static void prepare_clone(ReplayTask* t) {
       t->session().clone(t, clone_flags_to_task_flags(flags), params.stack,
                          params.tls, params.ctid, new_tid, rec_tid));
   new_task->own_namespace_rec_tid = tte.own_ns_tid();
+  task_created = new_tid;
 
   if (Arch::clone == t->regs().original_syscallno()) {
     /* FIXME: what if registers are non-null and contain an
@@ -968,7 +970,8 @@ static void process_init_buffers(ReplayTask* t, ReplayTraceStep* step) {
 static int non_negative_syscall(int sys) { return sys < 0 ? INT32_MAX : sys; }
 
 template <typename Arch>
-static void rep_after_enter_syscall_arch(ReplayTask* t) {
+static void rep_after_enter_syscall_arch(ReplayTask* t,
+                                         std::optional<pid_t>& task_created) {
   switch (non_negative_syscall(t->regs().original_syscallno())) {
     case Arch::write:
     case Arch::writev: {
@@ -981,7 +984,7 @@ static void rep_after_enter_syscall_arch(ReplayTask* t) {
     case Arch::fork:
       // Create the new task now. It needs to exist before clone/fork/vfork
       // returns so that a ptracer can touch it during PTRACE_EVENT handling.
-      prepare_clone<Arch>(t);
+      prepare_clone<Arch>(t, task_created);
       break;
 
     case Arch::ptrace: {
@@ -1036,8 +1039,9 @@ static void rep_after_enter_syscall_arch(ReplayTask* t) {
   t->apply_all_data_records_from_trace();
 }
 
-void rep_after_enter_syscall(ReplayTask* t) {
-  RR_ARCH_FUNCTION(rep_after_enter_syscall_arch, t->arch(), t)
+void rep_after_enter_syscall(ReplayTask* t,
+                             std::optional<pid_t>& task_created) {
+  RR_ARCH_FUNCTION(rep_after_enter_syscall_arch, t->arch(), t, task_created)
 }
 
 void rep_prepare_run_to_syscall(ReplayTask* t, ReplayTraceStep* step) {

src/replay_syscall.h

@@ -19,7 +19,7 @@ void rep_prepare_run_to_syscall(ReplayTask* t, ReplayTraceStep* step);
 /**
  * Call this when |t| has just entered a syscall.
  */
-void rep_after_enter_syscall(ReplayTask* t);
+void rep_after_enter_syscall(ReplayTask* t, std::optional<pid_t>& task_created);
 
 /**
  * Process pending syscall. Call this when |t| is about to exit a syscall.