struct queue_entry {
u8* fname; 
u32 len; 
 
u8 cal_failed, 
    trim_done, 
    was_fuzzed, 
    passed_det, 
    has_new_cov, 
    var_behavior, 
    favored, 
    fs_redundant; 
 
u32 bitmap_size, 
    fuzz_level, 
    exec_cksum; 
 
u64 exec_us, 
    handicap, 
    n_fuzz, 
    depth; 
 
u8* trace_mini; 
u32 tc_ref; 
 
struct queue_entry *next, 
                   *next_100; 
};

struct extra_data {
  u8* data; 
  u32 len; 
  u32 hit_cnt; 
};

enum {
 FAULT_NONE,
 FAULT_TMOUT,
 FAULT_CRASH,
 FAULT_ERROR,
 FAULT_NOINST,
 FAULT_NOBITS };

if (pipe(st_pipe) || pipe(ctl_pipe)) PFATAL("pipe() failed");

forksrv_pid = fork();

if (forksrv_pid < 0) PFATAL("fork() failed");

if (!forksrv_pid) {
  struct rlimit r;
  
  if (dup2(use_stdin ? prog_in_fd : dev_null_fd, 0) < 0 ||
      dup2(dev_null_fd, 1) < 0 ||
      dup2(dev_null_fd, 2) < 0) {
    *(u32*)trace_bits = EXEC_FAIL_SIG;
    PFATAL("dup2() failed");
  }
  close(dev_null_fd);
  close(prog_in_fd);
 
  setsid();
  ....

 execv(target_path, argv);

*(u32*)trace_bits = EXEC_FAIL_SIG;
    exit(0);
}
....

if (rlen == 4) {
    OKF("All right - fork server is up.");
    return;}

or (i = 0; i < MAP_SIZE; i++)
   
 if (top_rated[i] && (temp_v[i >> 3] & (1 << (i & 7))))
 {
   u32 j = MAP_SIZE >> 3;

   while (j--)
     if (top_rated[i]->trace_mini[j])
       temp_v[j] &= ~top_rated[i]->trace_mini[j];
   top_rated[i]->favored = 1;
   queued_favored++;
   if (top_rated[i]->fuzz_level == 0 || !top_rated[i]->was_fuzzed) pending_favored++;
 }

tuple t0,t1,t2,t3,t4；seed s0,s1,s2 初始化temp_v=[1,1,1,1,1]
s1可覆盖t2,t3 | s2覆盖t0,t1,t4，并且top_rated[0]=s2，top_rated[2]=s1
开始后判断temp_v[0]=1，说明t0没有被访问
top_rated[0]存在(s2) -> 判断s2可以覆盖的范围 -> trace_mini=[1,1,0,0,1]
更新temp_v=[0,0,1,1,0]
标记s2为favored
继续判断temp_v[1]=0，说明t1此时已经被访问过了，跳过
继续判断temp_v[2]=1，说明t2没有被访问
top_rated[2]存在(s1) -> 判断s1可以覆盖的范围 -> trace_mini=[0,0,1,1,0]
更新temp_v=[0,0,0,0,0]
标记s1为favored
此时所有tuple都被覆盖，favored为s1,s2

static u8 trim_case(char** argv, struct queue_entry* q, u8* in_buf) {
....
static u8 clean_trace[MAP_SIZE];
u8 needs_write = 0

while (remove_len >= MAX(len_p2 / TRIM_END_STEPS, TRIM_MIN_BYTES)) {
      
    while (remove_pos < q->len) {
      
         write_with_gap(in_buf, q->len, remove_pos, trim_avail);
        
         fault = run_target(argv, exec_tmout);
     
         cksum = hash32(trace_bits, MAP_SIZE, HASH_CONST);
     
         if (cksum == q->exec_cksum) {
          memmove(in_buf + remove_pos, in_buf + remove_pos + trim_avail, move_tail);
       
           if (!needs_write) {
         memcpy(clean_trace, trace_bits, MAP_SIZE);}
     } else remove_pos += remove_len;
   }
   remove_len >>= 1; 
}
}

#define EFF_APOS(_p) ((_p) >> EFF_MAP_SCALE2)
#define EFF_REM(_x) ((_x) & ((1 << EFF_MAP_SCALE2) - 1))
#define EFF_ALEN(_l) (EFF_APOS(_l) + !!EFF_REM(_l))
#define EFF_SPAN_ALEN(_p, _l) (EFF_APOS((_p) + (_l) - 1) - EFF_APOS(_p) + 1)

for (j = 0; j < extras_cnt; j++) {
   if ((extras_cnt > MAX_DET_EXTRAS && UR(extras_cnt) >= MAX_DET_EXTRAS) ||
       extras[j].len > len - i ||
       !memcmp(extras[j].data, out_buf + i, extras[j].len) ||
       !memchr(eff_map + EFF_APOS(i), 1, EFF_SPAN_ALEN(i, extras[j].len))) {
     stage_max--;
     continue;
   }

进入循环后第一部还是 cull_queue() 对queue进行筛选
判断queue_cur是否为空，如果是，则表示已经完成对队列的遍历，初始化相关参数，重新开始遍历队列
fuzz_one() 函数会对queue_cur所对应文件进行fuzz，包括(跳过-calibrate_case-修剪测试用例-对用例评分-确定性变异或直接havoc&ssplice)
判断是否结束，更新queue_cur和current_entry
当队列中的所有文件都经过变异测试了，则完成一次”cycle done”。整个队列又会从第一个文件开始，再次继续进行变异