func main() {
    ...
    manager, err := rpctype.NewRPCClient(*flagManager, timeouts.Scale) // 初始化RPC (远程过程调用协议), 后面就通过 manager RPC 远程调用 /syz-manager/rpc.go 中的函数
    ...
    if err := manager.Call("Manager.Connect", a, r); err != nil { // RPC -> Connect() 连接
		log.Fatalf("failed to connect to manager: %v ", err)
	}
    if err := manager.Call("Manager.Check", r.CheckResult, nil); err != nil { // [1] RPC远程调用 -> syz-manager/rpc.go:Check() -> machineChecked() -> loadCorpus() 将 db 中所有的语料库加载到 mgr.candidates
			log.Fatalf("Manager.Check call failed: %v", err)
		}
    ...
    for needCandidates, more := true, true; more; needCandidates = false {
		more = fuzzer.poll(needCandidates, nil) // [2] 更新 fuzzer.corpus 语料库以及 fuzzer.workQueue 队列 !!!
		// This loop lead to "no output" in qemu emulation, tell manager we are not dead.
		log.Logf(0, "fetching corpus: %v, signal %v/%v (executing program)",
			len(fuzzer.corpus), len(fuzzer.corpusSignal), len(fuzzer.maxSignal))
	}
    ...
    fuzzer.choiceTable = target.BuildChoiceTable(fuzzer.corpus, calls) // [3] 生成 prios[X][Y] 优先级, 预测在包含系统调用X的程序中添加系统调用Y是否能得到新的覆盖 !!!
    ...
    log.Logf(0, "starting %v fuzzer processes", *flagProcs)
	for pid := 0; pid < *flagProcs; pid++ { // flagProcs —— 表示每个VM中的并行测试进程数 (来自config文件中的procs参数)
		proc, err := newProc(fuzzer, pid)
		if err != nil {
			log.Fatalf("failed to create proc: %v", err)
		}
		fuzzer.procs = append(fuzzer.procs, proc)
		go proc.loop() // [4] fuzz的核心函数，如果有剩余的Procs，就开启新的线程执行此函数。 生成新的程序和变异都在这里进行。 !!!
	}

	fuzzer.pollLoop() // [5] 循环等待，如果程序需要新的语料库，就调用poll()生成新的数据。 !!!
}

func (fuzzer *Fuzzer) poll(needCandidates bool, stats map[string]uint64) bool {
	a := &rpctype.PollArgs{
		Name:           fuzzer.name,
		NeedCandidates: needCandidates,
		MaxSignal:      fuzzer.grabNewSignal().Serialize(),
		Stats:          stats,
	}
	r := &rpctype.PollRes{}
	if err := fuzzer.manager.Call("Manager.Poll", a, r); err != nil { // [1] RPC远程调用 -> syz-manager/rpc.go:Poll() -> candidateBatch() 取得 mgr.candidates 并存入 r.Candidates
		log.Fatalf("Manager.Poll call failed: %v", err)
	}
	maxSignal := r.MaxSignal.Deserialize() // 获得最大的信号量
	log.Logf(1, "poll: candidates=%v inputs=%v signal=%v",
		len(r.Candidates), len(r.NewInputs), maxSignal.Len())
	fuzzer.addMaxSignal(maxSignal)    // 调用了 fuzzer.maxSignal.Merge(sign) 实现此功能: 对已经存在的sign比较优先级，对没有的sign直接添加
	for _, inp := range r.NewInputs { // 更新 corpusSignal 和 maxSignal
		fuzzer.addInputFromAnotherFuzzer(inp) // [2] -> addInputToCorpus() 更新 fuzzer.corpus
	}
	for _, candidate := range r.Candidates {
		fuzzer.addCandidateInput(candidate) // [3] 从 r.Candidates 提取出程序, 并加入到 fuzzer.workQueue
	}
	if needCandidates && len(r.Candidates) == 0 && atomic.LoadUint32(&fuzzer.triagedCandidates) == 0 {
		atomic.StoreUint32(&fuzzer.triagedCandidates, 1) // 如果需要Candidates，并且Candidates长度为0，并且triagedCandidates==0，就把triagedCandidates置为1
	}
	return len(r.NewInputs) != 0 || len(r.Candidates) != 0 || maxSignal.Len() != 0 // NewInputs、Candidates、maxSignal有一个不为空，就返回true
}

func (target *Target) BuildChoiceTable(corpus []*Prog, enabled map[*Syscall]bool) *ChoiceTable {
	...
    var enabledCalls []*Syscall // [1] 把可用syscall的数组 enabled 赋值到 enabledCalls, 并按ID大小进行排序
	for c := range enabled {
		enabledCalls = append(enabledCalls, c)
	}
    ...
    prios := target.CalculatePriorities(corpus)  // [2] 根据 剩下的 corpus 计算 prios[X][Y] 优先级 !!!!!
	run := make([][]int32, len(target.Syscalls)) // [3] 基于上一步计算的 prios 和启用的 syscall, 计算出表 run。对系统调用 i/j来说, run[i][j] 的值是之前 run[i][x] (x<j) 的和加上 prios[i][j], 所以对run[x]来说是从小到大排好序的。
	for i := range run {
		if !enabled[target.Syscalls[i]] {
			continue
		}
		run[i] = make([]int32, len(target.Syscalls))
		var sum int32
		for j := range run[i] {
			if enabled[target.Syscalls[j]] {
				sum += prios[i][j]
			}
			run[i][j] = sum
		}
	}
	return &ChoiceTable{target, run, enabledCalls} // 返回&ChoiceTable
}

func (target *Target) calcStaticPriorities() [][]int32 {
	uses := target.calcResourceUsage() // [1] 创建hash表, key是string类型, 表示某种资源; value 也是hash表, 对应 (id, value), 系统调用id和value权重。 !!!
	// 资源是通过遍历函数参数得到的, 比如可以是 Vma, Ptr, Buffer 等等。每种类型的权重是不同的, 比如Vma是5，Ptr是10。 !!!
	// noteUsage() 同一种资源同一个系统调用，只会记录最大的值
	prios := make([][]int32, len(target.Syscalls))
	for i := range prios {
		prios[i] = make([]int32, len(target.Syscalls))
	}
	for _, weights := range uses { // [2] 对uses的weights进行双重遍历，跳过自身（在[4]单独处理），设置prios的值
		for _, w0 := range weights {
			for _, w1 := range weights {
				if w0.call == w1.call {
					// Self-priority is assigned below.
					continue
				}
				prios[w0.call][w1.call] += w0.inout*w1.in*3/2 + w0.inout*w1.inout // 设置prios的值, 优先级的值是基于参数方向的，c0产生资源、c1来使用会有更高的优先级
			}
		}
	}
	normalizePrio(prios) // [3] 对prios进行规范化处理，使优先级的值落在区间[prioLow,prioHigh]内。默认10-1000
	for c0, pp := range prios { // [4] 把prios[c0][c0]这种自己调用自己的情况赋予一个较高的优先级，但也不能太高 (prioHigh * 9 / 10)。
		pp[c0] = prioHigh * 9 / 10
	}
	return prios
}

func (target *Target) calcDynamicPrio(corpus []*Prog) [][]int32 {
	prios := make([][]int32, len(target.Syscalls))
	for i := range prios {
		prios[i] = make([]int32, len(target.Syscalls))
	}
	for _, p := range corpus { // [1] 如果语料库中一对系统调用一起出现在程序中，则计数加 1
		for idx0, c0 := range p.Calls {
			for _, c1 := range p.Calls[idx0+1:] {
				prios[c0.Meta.ID][c1.Meta.ID]++
			}
		}
	}
	normalizePrio(prios) // [2] 规范化
	return prios
}

func (proc *Proc) loop() {
	generatePeriod := 100
	if proc.fuzzer.config.Flags&ipc.FlagSignal == 0 {
		// If we don't have real coverage signal, generate programs more frequently
		// because fallback signal is weak.
		generatePeriod = 2 // 在下面的循环中, 当 (i % generatePeriod == 0) 时调用 Generate() 来生成新的prog, 所以generatePeriod的值越小, 生成的频率越高
	}
	for i := 0; ; i++ {
		item := proc.fuzzer.workQueue.dequeue() // [1] 遍历 fuzzer.workQueue 队列, 取到item中, 对三种不同类型的item，分别调用不同的函数进行处理
		if item != nil {
			switch item := item.(type) {
			case *WorkTriage: // WorkTriage: 第一次执行时，检查是否产生了新的覆盖，有新覆盖的话则 Minimize 并添加到语料库中。
				proc.triageInput(item) // [2] !!!
			case *WorkCandidate: // WorkCandidate: 来自hub的程序，所以现在不知道它是否对当前的fuzzer有效。proc处理它们的方式跟本地生成或变异出的程序相同。
				proc.execute(proc.execOpts, item.p, item.flags, StatCandidate) // [3] !!! 依次调用 proc.execute->proc.executeRaw->proc.env.Exec->env.cmd.exec 将数据传给executor执行, 若产生新的 syscall，则加入到 fuzzer.workQueue 队列
			case *WorkSmash: // WorkSmash: 刚加入到语料库中的程序。hint变异: 先调用execute()执行原始程序, 收集比较操作数; 调用 MutateWithHints(), 用比较操作数来替换参数，进行变异，执行变异的程序，检查是否有新覆盖
				proc.smashInput(item) // [4] !!!
			default:
				log.Fatalf("unknown work type: %#v", item)
			}
			continue
		}

		ct := proc.fuzzer.choiceTable                                 // ct用来存储 prios[X][Y] 优先级
		fuzzerSnapshot := proc.fuzzer.snapshot()                      // 保存快照
		if len(fuzzerSnapshot.corpus) == 0 || i%generatePeriod == 0 { // 如果 corpus 的长度为0或者到了i%generatePeriod == 0的计数
			// Generate a new prog.
			p := proc.fuzzer.target.Generate(proc.rnd, prog.RecommendedCalls, ct) // [5] 如果 corpus 为空, 则调用 Generate() 随机生成新的程序 (加入新的syscall) !!!
			log.Logf(1, "#%v: generated", proc.pid)
			proc.executeAndCollide(proc.execOpts, p, ProgNormal, StatGenerate)
		} else {
			// Mutate an existing prog.
			p := fuzzerSnapshot.chooseProgram(proc.rnd).Clone()
			p.Mutate(proc.rnd, prog.RecommendedCalls, ct, fuzzerSnapshot.corpus) // [6] 调用Mutate()进行变异 (对现有的syscall进行变异) !!!
			log.Logf(1, "#%v: mutated", proc.pid)
			proc.executeAndCollide(proc.execOpts, p, ProgNormal, StatFuzz)
		}
	}
}

func (proc *Proc) execute(execOpts *ipc.ExecOpts, p *prog.Prog, flags ProgTypes, stat Stat) *ipc.ProgInfo {
	info := proc.executeRaw(execOpts, p, stat) // [1] 执行 item.p 程序获得执行信息 info !!!
	if info == nil {
		return nil
	}
	calls, extra := proc.fuzzer.checkNewSignal(p, info) // [2] 检查有没有生成新的call
	for _, callIndex := range calls {
		proc.enqueueCallTriage(p, flags, callIndex, info.Calls[callIndex]) // [3] 把新的call加入到 fuzzer.workQueue 队列中
	}
	if extra {
		proc.enqueueCallTriage(p, flags, -1, info.Extra)
	}
	return info
}

func (proc *Proc) smashInput(item *WorkSmash) {
	if proc.fuzzer.faultInjectionEnabled && item.call != -1 {
		proc.failCall(item.p, item.call) // [1] 在测试过程中注入错误, 再调用executeRaw()执行
	}
	if proc.fuzzer.comparisonTracingEnabled && item.call != -1 {
		proc.executeHintSeed(item.p, item.call) // [2] hint变异: 先调用execute()执行原始程序, 收集比较操作数; 调用 MutateWithHints(), 用比较操作数来替换参数，进行变异，执行变异的程序，检查是否有新覆盖。 !!!
	}
	fuzzerSnapshot := proc.fuzzer.snapshot() // [3] 保存一个快照
	for i := 0; i < 100; i++ {               // [4] 循环100次，调用 Mutate() 进行变异，再调用 execute() 执行变异后的程序
		p := item.p.Clone()
		p.Mutate(proc.rnd, prog.RecommendedCalls, proc.fuzzer.choiceTable, fuzzerSnapshot.corpus) // [5] !!!
		log.Logf(1, "#%v: smash mutated", proc.pid)
		proc.executeAndCollide(proc.execOpts, p, ProgNormal, StatSmash) // [6] !!!
	}
}

func (proc *Proc) executeHintSeed(p *prog.Prog, call int) {
	log.Logf(1, "#%v: collecting comparisons", proc.pid)
	// First execute the original program to dump comparisons from KCOV.
	info := proc.execute(proc.execOptsComps, p, ProgNormal, StatSeed) // [1] 先执行原始程序, 通过KCOV收集syscall中的比较操作数
	if info == nil {
		return
	}
	// 再对初始程序的每一个可以匹配成功的系统调用参数和比较操作数进行变异。执行每一次变异后的程序, 检查是否出现新的覆盖。
	// 参数2 info.Calls[call].Comps —— 每个syscall的比较操作数, 数据类型 map[uint64]map[uint64]bool
	// 参数3 传入的是一个func，用来执行程序，后面将使用到的几个函数也会把func作为参数
	p.MutateWithHints(call, info.Calls[call].Comps, func(p *prog.Prog) { // [2] !!!
		log.Logf(1, "#%v: executing comparison hint", proc.pid)
		proc.execute(proc.execOpts, p, ProgNormal, StatHint)
	})
}

    // Example: for comparisons {(op1, op2), (op1, op3), (op1, op4), (op2, op1)}
    // this map will store the following:
    // m = {
    //        op1: {map[op2]: true, map[op3]: true, map[op4]: true},
    //        op2: {map[op1]: true}
    // }

// (1) 
// 源码：
// Models the following code:
// void f(u64 qw) {
//      u8 b = (u8) qw
//      u16 w = (u16) qw
//      u32 dw = (u32) qw
//      if (b == 0xab) {...}
//      if (w == 0xcdcd) {...}
//      if (dw == 0xefefefef) {...}
//      if (qw == 0x0101010101010101) {...}
//  }; f(0x1234567890abcdef);
// CompMap
CompMap{
    0xef:               uint64Set{0xab: true},
    0xcdef:             uint64Set{0xcdcd: true},
    0x90abcdef:         uint64Set{0xefefefef: true},
    0x1234567890abcdef: uint64Set{0x0101010101010101: true},
},
// results:
uint64Set{
    0x1234567890abcdab: true,
    0x1234567890abcdcd: true,
    0x12345678efefefef: true,
    0x0101010101010101: true,
},

// (2)
// 源码:
// void f(i32 dw) {
//      i64 qw = (i32) dw;
//      if (qw == -2) {...};
// }; f(-1);
// CompMap:
CompMap{0xffffffffffffffff: uint64Set{0xfffffffffffffffe: true}},
// results:
uint64Set{0xfffffffe: true},

// 随机生成一个有ncalls个syscall的随机的程序。参数ct是一个可用的syscalls的集合，如果值为nil就表示所有的syscall都可用
func (target *Target) Generate(rs rand.Source, ncalls int, ct *ChoiceTable) *Prog {
	p := &Prog{ // 初始化
		Target: target,
	}
	r := newRand(target, rs)
	s := newState(target, ct, nil) // ct (含run表) 存到了 s.ct
	for len(p.Calls) < ncalls {
		calls := r.generateCall(s, p, len(p.Calls)) // [1] 根据基准 syscall 和run表随机选择一个syscall，并生成具体的系统调用和相应参数。 依次调用generateParticularCall()->generateArgs()->generateArg()->generateArgImpl()->generate()。 根据参数的数据类型调用相应的 generate() 函数 !!!
		for _, c := range calls {
			s.analyze(c) // [2] 对 syscall 进行分析，对相应的类型做相应的处理
			p.Calls = append(p.Calls, c)
		}
	}
	for len(p.Calls) > ncalls {
		p.RemoveCall(ncalls - 1) // [3] 超过 syscall 个数, 则移除多出的
	}
	p.sanitizeFix() // [4] 进行合法检测
	p.debugValidate()
	return p
}

func (p *Prog) Mutate(rs rand.Source, ncalls int, ct *ChoiceTable, corpus []*Prog) {
	r := newRand(p.Target, rs)
	if ncalls < len(p.Calls) {
		ncalls = len(p.Calls)
	}
	ctx := &mutator{
		p:      p,
		r:      r,
		ncalls: ncalls,
		ct:     ct,
		corpus: corpus,
	}
	for stop, ok := false, false; !stop; stop = ok && len(p.Calls) != 0 && r.oneOf(3) { // 随机选择以下几种变异类型，都设置了一定的概率
		switch {
		case r.oneOf(5):
			// Not all calls have anything squashable,
			// so this has lower priority in reality.
			ok = ctx.squashAny() // [1] 对参数进行压缩，因为能够压缩参数的情况比较少，所以可能性最低;
		case r.nOutOf(1, 100):
			ok = ctx.splice() // [2] 拼接，随机选择一个语料库外的程序p0，选一个随机数i，插入到程序 ctx.p 的第i条指令后面;
		case r.nOutOf(20, 31):
			ok = ctx.insertCall() // [3] 在随机位置插入一个新的 syscall;
		case r.nOutOf(10, 11):
			ok = ctx.mutateArg() // [4] 对一个随机 syscall的参数进行变异。先判断参数的类型，对不同类型的参数使用不同的变异策略; !!!
		default:
			ok = ctx.removeCall() // [5] 随机移除一个 syscall
		}
	}
	p.sanitizeFix()
	p.debugValidate()
	if got := len(p.Calls); got < 1 || got > ncalls {
		panic(fmt.Sprintf("bad number of calls after mutation: %v, want [1, %v]", got, ncalls))
	}
}

// 原始程序
foo$any0(&(0x7f0000000000)=
	{0x11,
	0x11223344,
	0x2233,
	0x1122334455667788,
	{0x1, 0x7, 0x1, 0x1, 0x1bc, 0x4},
	[{@res32=0x0, @i8=0x44, "aabb"}, {@res64=0x1, @i32=0x11223344, "1122334455667788"}]
	})
// squashed 后
foo$any0(&(0x7f0000000000)=
	ANY=[@ANYBLOB="1100000044332211223300000000000088776655443322117d00bc11",
	@ANYRES32=0x0,
	@ANYBLOB="0000000044aabb00",
	@ANYRES64=0x1,
	@ANYBLOB="44332211112233445566778800000000"])

		// Change filename.
		{`
mutate5(&(0x7f0000001000)="2e2f66696c653000", 0x22c0)
mutate5(&(0x7f0000001000)="2e2f66696c653000", 0x22c0)
`, `
mutate5(&(0x7f0000001000)="2e2f66696c653000", 0x22c0)
mutate5(&(0x7f0000001000)="2e2f66696c653100", 0x22c0)
`},
		// Extend an array.
		{`
mutate3(&(0x7f0000000000)=[0x1, 0x1], 0x2)
`, `
mutate3(&(0x7f0000000000)=[0x1, 0x1, 0x1], 0x3)
`},
		// Mutate size from it's natural value.
		{`
mutate7(&(0x7f0000000000)='123', 0x3)
`, `
mutate7(&(0x7f0000000000)='123', 0x2)
`},
		// Mutate proc to the special value.
		{`
mutate8(0x2)
`, `
mutate8(0xffffffffffffffff)
`},
		// Remove calls and update args.   (mutator的)removeCall函数调用(Prog的)removeCall函数随机移除一个系统调用
		{`
r0 = mutate5(&(0x7f0000000000)="2e2f66696c653000", 0x0)
mutate0()
mutate6(r0, &(0x7f0000000000)="00", 0x1)
mutate1()
`, `
mutate0()
mutate6(0xffffffffffffffff, &(0x7f0000000000)="00", 0x1)
mutate1()
`},