func (mgr *Manager) saveRepro(crash *Crash, res *repro.Result) {
sig := hash.Hash([]byte(crash.desc))
dir := filepath.Join(mgr.crashdir, sig.String())
if res == nil {
for i := 0; i < maxReproAttempts; i++ {
name := filepath.Join(dir, fmt.Sprintf("repro%v", i))
if _, err := os.Stat(name); err != nil {
ioutil.WriteFile(name, nil, 0660)
break
}
}
return
}
opts := fmt.Sprintf("# %+v\n", res.Opts)
prog := res.Prog.Serialize()
ioutil.WriteFile(filepath.Join(dir, "repro.prog"), append([]byte(opts), prog...), 0660)
if len(mgr.cfg.Tag) > 0 {
ioutil.WriteFile(filepath.Join(dir, "repro.tag"), []byte(mgr.cfg.Tag), 0660)
}
if len(crash.text) > 0 {
ioutil.WriteFile(filepath.Join(dir, "repro.report"), []byte(crash.text), 0660)
}
if res.CRepro {
cprog, err := csource.Write(res.Prog, res.Opts)
if err == nil {
formatted, err := csource.Format(cprog)
if err == nil {
cprog = formatted
}
ioutil.WriteFile(filepath.Join(dir, "repro.cprog"), cprog, 0660)
} else {
Logf(0, "failed to write C source: %v", err)
}
}
}
func main() {
flag.Parse()
if len(flag.Args()) != 1 {
fmt.Fprintf(os.Stderr, "usage: prog2c [-threaded [-collide]] prog_file\n")
os.Exit(1)
}
data, err := ioutil.ReadFile(flag.Args()[0])
if err != nil {
fmt.Fprintf(os.Stderr, "failed to read prog file: %v\n", err)
os.Exit(1)
}
p, err := prog.Deserialize(data)
if err != nil {
fmt.Fprintf(os.Stderr, "failed to deserialize the program: %v\n", err)
os.Exit(1)
}
opts := csource.Options{
Threaded: *flagThreaded,
Collide: *flagCollide,
}
src := csource.Write(p, opts)
if formatted, err := csource.Format(src); err != nil {
fmt.Fprintf(os.Stderr, "%v\n", err)
} else {
src = formatted
}
os.Stdout.Write(src)
}
func main() {
os.Args = append(append([]string{}, os.Args[0], "-v=10"), os.Args[1:]...)
flag.Parse()
cfg, _, err := config.Parse(*flagConfig)
if err != nil {
Fatalf("%v", err)
}
if *flagCount > 0 {
cfg.Count = *flagCount
}
if cfg.Count > 4 {
cfg.Count = 4
}
if len(flag.Args()) != 1 {
Fatalf("usage: syz-repro -config=config.file execution.log")
}
data, err := ioutil.ReadFile(flag.Args()[0])
if err != nil {
Fatalf("failed to open log file: %v", err)
}
vmIndexes := make([]int, cfg.Count)
for i := range vmIndexes {
vmIndexes[i] = i
}
go func() {
c := make(chan os.Signal, 2)
signal.Notify(c, syscall.SIGINT)
<-c
close(vm.Shutdown)
Logf(-1, "shutting down...")
<-c
Fatalf("terminating")
}()
res, err := repro.Run(data, cfg, vmIndexes)
if err != nil {
Logf(0, "reproduction failed: %v", err)
}
if res == nil {
return
}
fmt.Printf("opts: %+v crepro: %v\n\n", res.Opts, res.CRepro)
fmt.Printf("%s\n", res.Prog.Serialize())
if res.CRepro {
src, err := csource.Write(res.Prog, res.Opts)
if err != nil {
Fatalf("failed to generate C repro: %v", err)
}
if formatted, err := csource.Format(src); err == nil {
src = formatted
}
fmt.Printf("%s\n", src)
}
}
func main() {
flag.Parse()
if *flagProg == "" {
flag.PrintDefaults()
os.Exit(1)
}
data, err := ioutil.ReadFile(*flagProg)
if err != nil {
fmt.Fprintf(os.Stderr, "failed to read prog file: %v\n", err)
os.Exit(1)
}
p, err := prog.Deserialize(data)
if err != nil {
fmt.Fprintf(os.Stderr, "failed to deserialize the program: %v\n", err)
os.Exit(1)
}
opts := csource.Options{
Threaded: *flagThreaded,
Collide: *flagCollide,
Repeat: *flagRepeat,
Procs: *flagProcs,
Sandbox: *flagSandbox,
Repro: false,
}
src, err := csource.Write(p, opts)
if err != nil {
fmt.Fprintf(os.Stderr, "failed to generate C spurce: %v\n", err)
os.Exit(1)
}
if formatted, err := csource.Format(src); err != nil {
fmt.Fprintf(os.Stderr, "%v\n", err)
} else {
src = formatted
}
os.Stdout.Write(src)
}
func repro(cfg *config.Config, entries []*prog.LogEntry, crashStart int) {
// Cut programs that were executed after crash.
for i, ent := range entries {
if ent.Start > crashStart {
entries = entries[:i]
break
}
}
// Extract last program on every proc.
procs := make(map[int]int)
for i, ent := range entries {
procs[ent.Proc] = i
}
var indices []int
for _, idx := range procs {
indices = append(indices, idx)
}
sort.Ints(indices)
var suspected []*prog.LogEntry
for i := len(indices) - 1; i >= 0; i-- {
suspected = append(suspected, entries[indices[i]])
}
// Execute the suspected programs.
Logf(0, "the suspected programs are:")
for _, ent := range suspected {
Logf(0, "on proc %v:\n%s\n", ent.Proc, ent.P.Serialize())
}
var p *prog.Prog
multiplier := 1
for ; p == nil && multiplier <= 100; multiplier *= 10 {
for _, ent := range suspected {
if testProg(cfg, ent.P, multiplier, true, true) {
p = ent.P
break
}
}
}
if p == nil {
Logf(0, "no program crashed")
return
}
Logf(0, "minimizing program")
p, _ = prog.Minimize(p, -1, func(p1 *prog.Prog, callIndex int) bool {
return testProg(cfg, p1, multiplier, true, true)
})
opts := csource.Options{
Threaded: true,
Collide: true,
}
if testProg(cfg, p, multiplier, true, false) {
opts.Collide = false
if testProg(cfg, p, multiplier, false, false) {
opts.Threaded = false
}
}
src := csource.Write(p, opts)
src, _ = csource.Format(src)
Logf(0, "C source:\n%s\n", src)
srcf, err := fileutil.WriteTempFile(src)
if err != nil {
Fatalf("%v", err)
}
bin, err := csource.Build(srcf)
if err != nil {
Fatalf("%v", err)
}
defer os.Remove(bin)
testBin(cfg, bin)
}