Discard prepared-syscall state when a syscall is interrupted by tracee seccomp trap

Author: rocallahan

src/RecordSession.cc

@@ -276,6 +276,9 @@ static void handle_seccomp_trap(RecordTask* t,
     // PTRACE_SYSCALL to enter the syscall during handle_desched_event. Cancel
     // that event now since the seccomp SIGSYS aborts it completely.
     ASSERT(t, t->ev().Syscall().number == syscallno);
+    // Make sure any prepared syscall state is discarded and any temporary
+    // effects (e.g. redirecting pointers to scratch) undone.
+    rec_abort_prepared_syscall(t);
     if (t->ev().type() == EV_SYSCALL_INTERRUPTION) {
       // The event could be a syscall-interruption if it was pushed by
       // `handle_desched_event`. In that case, it has not been recorded yet.

src/record_syscall.cc

@@ -417,6 +417,11 @@ struct TaskSyscallState {
    * original destinations, update registers, etc.
    */
   void process_syscall_results();
+  /**
+   * Called when a syscall has been completely aborted to undo any changes we
+   * made.
+   */
+  void abort_syscall_results();
 
   /**
    * Upon successful syscall completion, each RestoreAndRecordScratch record
@@ -800,6 +805,34 @@ void TaskSyscallState::process_syscall_results() {
   }
 }
 
+void TaskSyscallState::abort_syscall_results() {
+  ASSERT(t, preparation_done);
+
+  if (scratch_enabled) {
+    Registers r = t->regs();
+    // restore modified in-memory pointers and registers
+    for (size_t i = 0; i < param_list.size(); ++i) {
+      auto& param = param_list[i];
+      if (param.ptr_in_reg) {
+        r.set_arg(param.ptr_in_reg, param.dest.as_int());
+      }
+      if (!param.ptr_in_memory.is_null()) {
+        set_remote_ptr(t, param.ptr_in_memory, param.dest);
+      }
+    }
+    t->set_regs(r);
+  } else {
+    for (auto& param : param_list) {
+      if (param.mutator) {
+        size_t size = param.num_bytes.incoming_size;
+        ASSERT(t, saved_data.size() >= size);
+        t->write_bytes_helper(param.dest, size, saved_data.data());
+        saved_data.erase(saved_data.begin(), saved_data.begin() + size);
+      }
+    }
+  }
+}
+
 template <typename Arch>
 static void prepare_recvmsg(RecordTask* t, TaskSyscallState& syscall_state,
                             remote_ptr<typename Arch::msghdr> msgp,
@@ -4148,6 +4181,14 @@ Switchable rec_prepare_syscall(RecordTask* t) {
   return syscall_state.done_preparing(s);
 }
 
+void rec_abort_prepared_syscall(RecordTask* t) {
+  auto syscall_state = syscall_state_property.get(*t);
+  if (syscall_state) {
+    syscall_state->abort_syscall_results();
+    syscall_state_property.remove(*t);
+  }
+}
+
 template <typename Arch>
 static void rec_prepare_restart_syscall_arch(RecordTask* t,
                                              TaskSyscallState& syscall_state) {

src/record_syscall.h

@@ -15,6 +15,12 @@ class RecordTask;
  */
 Switchable rec_prepare_syscall(RecordTask* t);
 
+/**
+ * Any prepared syscall is not going to happen (because it was aborted by
+ * tracee seccomp filter). Cancel any preparation work.
+ */
+void rec_abort_prepared_syscall(RecordTask* t);
+
 /**
  * Prepare |t| for its current syscall event to be interrupted and
  * possibly restarted.

src/test/seccomp_desched.c

@@ -6,7 +6,13 @@ static int pipe_fds[2];
 
 static void handler(__attribute__((unused)) int sig,
                     __attribute__((unused)) siginfo_t* si,
-                    __attribute__((unused)) void* p) {}
+                    __attribute__((unused)) void* p) {
+  /* Make a non-buffered syscall to check that it gets recorded OK */
+  struct statfs fs;
+  memset(&fs, 0, sizeof(fs));
+  test_assert(0 == statfs("/", &fs));
+  test_assert(fs.f_bsize > 0);
+}
 
 static void install_filter(void) {
   prctl(PR_SET_NO_NEW_PRIVS, 1, 0, 0, 0);