ipc: remove strace support traces

It is not working and not tested,
and can't be restored with new namespace sandboxing code.

2 files changed, 6 insertions, 154 deletions

diff --git a/ipc/ipc.go b/ipc/ipc.go
index 6424f83cf..eedf166df 100644
--- a/ipc/ipc.go
+++ b/ipc/ipc.go
@@ -42,7 +42,6 @@ const (
 	FlagCollide                        // collide syscalls to provoke data races
 	FlagDedupCover                     // deduplicate coverage in executor
 	FlagDropPrivs                      // impersonate nobody user
-	FlagStrace                         // run executor under strace
 )
 
 func MakeEnv(bin string, timeout time.Duration, flags uint64) (*Env, error) {
@@ -112,12 +111,11 @@ func (env *Env) Close() error {
 
 // Exec starts executor binary to execute program p and returns information about the execution:
 // output: process output
-// strace: strace output if env is created with FlagStrace
 // cov: per-call coverage, len(cov) == len(p.Calls)
 // failed: true if executor has detected a kernel bug
 // hanged: program hanged and was killed
 // err0: failed to start process, or executor has detected a logical error
-func (env *Env) Exec(p *prog.Prog) (output, strace []byte, cov [][]uint32, errnos []int, failed, hanged bool, err0 error) {
+func (env *Env) Exec(p *prog.Prog) (output []byte, cov [][]uint32, errnos []int, failed, hanged bool, err0 error) {
 	if p != nil {
 		// Copy-in serialized program.
 		progData := p.SerializeForExec()
@@ -142,7 +140,7 @@ func (env *Env) Exec(p *prog.Prog) (output, strace []byte, cov [][]uint32, errno
 			return
 		}
 	}
-	output, strace, failed, hanged, err0 = env.cmd.exec()
+	output, failed, hanged, err0 = env.cmd.exec()
 	if err0 != nil {
 		env.cmd.close()
 		env.cmd = nil
@@ -309,24 +307,6 @@ func makeCommand(bin []string, timeout time.Duration, flags uint64, inFile *os.F
 	c.outwp = outwp
 
 	cmd := exec.Command(bin[0], bin[1:]...)
-	/*
-		traceFile := ""
-		if flags&FlagStrace != 0 {
-			f, err := ioutil.TempFile("./", "syzkaller-strace")
-			if err != nil {
-				return nil, fmt.Errorf("failed to create temp file: %v", err)
-			}
-			f.Close()
-			defer os.Remove(f.Name())
-			traceFile, _ = filepath.Abs(f.Name())
-			args := []string{"-s", "8", "-o", traceFile}
-			args = append(args, env.bin...)
-			if env.flags&FlagThreaded != 0 {
-				args = append([]string{"-f"}, args...)
-			}
-			cmd = exec.Command("strace", args...)
-		}
-	*/
 	cmd.ExtraFiles = []*os.File{inFile, outFile, outrp, inwp}
 	cmd.Env = []string{}
 	cmd.Dir = dir
@@ -368,7 +348,7 @@ func (c *command) kill() {
 	syscall.Kill(c.cmd.Process.Pid, syscall.SIGKILL)
 }
 
-func (c *command) exec() (output, strace []byte, failed, hanged bool, err0 error) {
+func (c *command) exec() (output []byte, failed, hanged bool, err0 error) {
 	var tmp [1]byte
 	if _, err := c.outwp.Write(tmp[:]); err != nil {
 		output, _ = ioutil.ReadAll(c.rp)
@@ -419,14 +399,5 @@ func (c *command) exec() (output, strace []byte, failed, hanged bool, err0 error
 			}
 		}
 	}
-	/*
-		if traceFile != "" {
-			strace, err = ioutil.ReadFile(traceFile)
-			if err != nil {
-				err0 = fmt.Errorf("failed to read strace output: %v", err)
-				return
-			}
-		}
-	*/
 	return
 }
diff --git a/ipc/ipc_test.go b/ipc/ipc_test.go
index 77af49e45..af1fa6849 100644
--- a/ipc/ipc_test.go
+++ b/ipc/ipc_test.go
@@ -4,11 +4,8 @@
 package ipc
 
 import (
-	"bufio"
-	"bytes"
 	"math/rand"
 	"os"
-	"strings"
 	"testing"
 	"time"
 
@@ -62,16 +59,13 @@ func TestEmptyProg(t *testing.T) {
 	defer env.Close()
 
 	p := new(prog.Prog)
-	output, strace, cov, _, failed, hanged, err := env.Exec(p)
+	output, cov, _, failed, hanged, err := env.Exec(p)
 	if err != nil {
 		t.Fatalf("failed to run executor: %v", err)
 	}
 	if len(output) != 0 {
 		t.Fatalf("output on empty program")
 	}
-	if len(strace) != 0 {
-		t.Fatalf("strace output when not stracing")
-	}
 	if cov != nil {
 		t.Fatalf("haven't asked for coverage, but got it")
 	}
@@ -80,37 +74,12 @@ func TestEmptyProg(t *testing.T) {
 	}
 }
 
-func TestStrace(t *testing.T) {
-	t.Skip("strace is broken")
-
-	bin := buildExecutor(t)
-	defer os.Remove(bin)
-
-	env, err := MakeEnv(bin, timeout, FlagStrace)
-	if err != nil {
-		t.Fatalf("failed to create env: %v", err)
-	}
-	defer env.Close()
-
-	p := new(prog.Prog)
-	_, strace, _, _, failed, hanged, err := env.Exec(p)
-	if err != nil {
-		t.Fatalf("failed to run executor: %v", err)
-	}
-	if len(strace) == 0 {
-		t.Fatalf("no strace output")
-	}
-	if failed || hanged {
-		t.Fatalf("empty program failed")
-	}
-}
-
 func TestExecute(t *testing.T) {
 	bin := buildExecutor(t)
 	defer os.Remove(bin)
 
 	rs, iters := initTest(t)
-	flags := []uint64{0, FlagStrace, FlagThreaded, FlagStrace | FlagThreaded}
+	flags := []uint64{0, FlagThreaded, FlagThreaded | FlagCollide}
 	for _, flag := range flags {
 		env, err := MakeEnv(bin, timeout, flag)
 		if err != nil {
@@ -120,7 +89,7 @@ func TestExecute(t *testing.T) {
 
 		for i := 0; i < iters/len(flags); i++ {
 			p := prog.Generate(rs, 10, nil)
-			_, _, _, _, _, _, err := env.Exec(p)
+			_, _, _, _, _, err := env.Exec(p)
 			if err != nil {
 				t.Logf("program:\n%s\n", p.Serialize())
 				t.Fatalf("failed to run executor: %v", err)
@@ -128,91 +97,3 @@ func TestExecute(t *testing.T) {
 		}
 	}
 }
-
-func TestCompare(t *testing.T) {
-	t.Skip("flaky")
-
-	bin := buildExecutor(t)
-	defer os.Remove(bin)
-
-	// Sequence of syscalls that statically linked libc produces on startup.
-	rawTracePrefix := []string{"execve", "uname", "brk", "brk", "arch_prctl",
-		"readlink", "brk", "brk", "access"}
-	executorTracePrefix := []string{"execve", "uname", "brk", "brk", "arch_prctl",
-		"set_tid_address", "set_robust_list", "futex", "rt_sigaction", "rt_sigaction",
-		"rt_sigprocmask", "getrlimit", "readlink", "brk", "brk", "access", "mmap", "mmap"}
-	// These calls produce non-deterministic results, ignore them.
-	nondet := []string{"getrusage", "msgget", "msgrcv", "msgsnd", "shmget", "semat", "io_setup", "getpgrp",
-		"getpid", "getpgid", "getppid", "setsid", "ppoll", "keyctl", "ioprio_get",
-		"move_pages", "kcmp"}
-
-	env1, err := MakeEnv(bin, timeout, FlagStrace)
-	if err != nil {
-		t.Fatalf("failed to create env: %v", err)
-	}
-	defer env1.Close()
-
-	rs, iters := initTest(t)
-	for i := 0; i < iters; i++ {
-		p := prog.Generate(rs, 10, nil)
-		_, strace1, _, _, _, _, err := env1.Exec(p)
-		if err != nil {
-			t.Fatalf("failed to run executor: %v", err)
-		}
-
-		src := csource.Write(p, csource.Options{})
-		cprog := buildSource(t, src)
-		defer os.Remove(cprog)
-
-		env2, err := MakeEnv(cprog, timeout, FlagStrace)
-		if err != nil {
-			t.Fatalf("failed to create env: %v", err)
-		}
-		defer env2.Close() // yes, that's defer in a loop
-
-		_, strace2, _, _, _, _, err := env2.Exec(nil)
-		if err != nil {
-			t.Fatalf("failed to run c binary: %v", err)
-		}
-		stripPrefix := func(data []byte, prefix []string) string {
-			prefix0 := prefix
-			buf := new(bytes.Buffer)
-			s := bufio.NewScanner(bytes.NewReader(data))
-			for s.Scan() {
-				if strings.HasPrefix(s.Text(), "--- SIG") {
-					// Signal parameters can contain pid and pc.
-					continue
-				}
-				if len(prefix) == 0 {
-					skip := false
-					for _, c := range nondet {
-						if strings.HasPrefix(s.Text(), c) {
-							skip = true
-							break
-						}
-					}
-					if skip {
-						continue
-					}
-					buf.WriteString(s.Text())
-					buf.Write([]byte{'\n'})
-					continue
-				}
-				if !strings.HasPrefix(s.Text(), prefix[0]) {
-					t.Fatalf("strace output does not start with expected prefix\ngot:\n%s\nexpect prefix: %+v\ncurrent call: %v", data, prefix0, prefix[0])
-				}
-				prefix = prefix[1:]
-			}
-			if err := s.Err(); err != nil {
-				t.Fatalf("failed to scan strace output: %v", err)
-			}
-			return buf.String()
-		}
-		s1 := stripPrefix(strace1, executorTracePrefix)
-		s2 := stripPrefix(strace2, rawTracePrefix)
-		if s1 == "" || s1 != s2 {
-			t.Logf("program:\n%s\n", p.Serialize())
-			t.Fatalf("strace output differs:\n%s\n\n\n%s\n", s1, s2)
-		}
-	}
-}