m5cn9itjr
/
AFL
1
0
Fork 0
Code Issues Pull Requests 2 Packages Projects Releases 1 Wiki Activity

Renamed the report

Browse Source
main
BagPipeOuO 4 months ago
parent 94e115ecbd
commit 9ba3397419
3 changed files with 172 additions and 136 deletions
Show Stats Download Patch File Download Diff File

18
.vscode/c_cpp_properties.json vendored
Unescape View File

@ -0,0 +1,18 @@
{
"configurations": [
{
"name": "windows-gcc-x86",
"includePath": [
"${workspaceFolder}/**"
],
"compilerPath": "C:/Program Files/MinGW/bin/gcc.exe",
"cStandard": "${default}",
"cppStandard": "${default}",
"intelliSenseMode": "windows-gcc-x86",
"compilerArgs": [
""
]
}
],
"version": 4
}

0
docs/2024秋软件工程课程报告一：AFL泛读报告.docx → docs/2024秋软件工程课程报告：AFL泛读、标注和维护报告文档.docx
Unescape View File

290
src/afl-showmap.c
Unescape View File

@ -54,31 +54,31 @@
#include <sys/types.h>
#include <sys/resource.h>
static s32 child_pid; /* PID of the tested program */
static s32 child_pid; /* 被测试程序的进程 PID */
static u8* trace_bits; /* SHM with instrumentation bitmap */
static u8* trace_bits; /* 用于存储插桩信息的共享内存 */
static u8 *out_file, /* Trace output file */
*doc_path, /* Path to docs */
*target_path, /* Path to target binary */
*at_file; /* Substitution string for @@ */
static u8 *out_file, /* 输出文件路径 */
*doc_path, /* 文档目录路径 */
*target_path, /* 被测目标程序的路径 */
*at_file; /* `@@` 的替换字符串，用于输入文件 */
static u32 exec_tmout; /* Exec timeout (ms) */
static u32 exec_tmout; /* 测试程序的执行超时时间 (毫秒) */
static u64 mem_limit = MEM_LIMIT; /* Memory limit (MB) */
static u64 mem_limit = MEM_LIMIT; /* 测试程序的内存限制 (MB) */
static s32 shm_id; /* ID of the SHM region */
static s32 shm_id; /* 共享内存 (SHM) 的标识符 */
static u8 quiet_mode, /* Hide non-essential messages? */
edges_only, /* Ignore hit counts? */
cmin_mode, /* Generate output in afl-cmin mode? */
binary_mode, /* Write output as a binary map */
keep_cores; /* Allow coredumps? */
static u8 quiet_mode, /* 是否隐藏非必要的信息 */
edges_only, /* 是否只关心边覆盖率 */
cmin_mode, /* 是否以 `afl-cmin` 模式生成输出 */
binary_mode, /* 是否以二进制方式输出插桩信息 */
keep_cores; /* A是否允许生成 core dump 文件 */
static volatile u8
stop_soon, /* Ctrl-C pressed? */
child_timed_out, /* Child timed out? */
child_crashed; /* Child crashed? */
stop_soon, /* 是否按下了 Ctrl-C (中止标志) */
child_timed_out, /* 子进程是否超时 */
child_crashed; /* 子进程是否崩溃 */
/* Classify tuple counts. Instead of mapping to individual bits, as in
afl-fuzz.c, we map to more user-friendly numbers between 1 and 8. */
@ -95,7 +95,7 @@ static const u8 count_class_human[256] = {
[32 ... 127] = 7,
[128 ... 255] = 8
};
}; // 映射插桩命中计数到 1-8 的更具可读性的区间。0 代表未命中；1-3 被保留为原值；其余区间依次分段映射，便于统计分析。
static const u8 count_class_binary[256] = {
@ -109,23 +109,24 @@ static const u8 count_class_binary[256] = {
[32 ... 127] = 64,
[128 ... 255] = 128
};
}; // 将插桩计数按指数方式映射到二进制值，便于程序进一步处理。
static void classify_counts(u8* mem, const u8* map) {
static void classify_counts(u8* mem, const u8* map) {//对插桩命中计数 (mem) 进行分类处理，基于全局变量 edges_only 的值选择分类模式。
//u8* mem：插桩数据的内存指针。const u8* map：分类映射表
u32 i = MAP_SIZE;
if (edges_only) {
while (i--) {
if (*mem) *mem = 1;
if (*mem) *mem = 1;// 只关心边的覆盖情况，命中计数直接归一
mem++;
}
} else {
while (i--) {
*mem = map[*mem];
*mem = map[*mem];// 使用提供的映射表对命中计数进行分类
mem++;
}
@ -134,95 +135,101 @@ static void classify_counts(u8* mem, const u8* map) {
}
/* Get rid of shared memory (atexit handler). */
/* 删除共享内存 (atexit 处理程序). */
static void remove_shm(void) {
static void remove_shm(void) {//释放分配的共享内存。
shmctl(shm_id, IPC_RMID, NULL);
shmctl(shm_id, IPC_RMID, NULL); //使用 shmctl 函数删除共享内存区域
//IPC_RMID 标志用于标记共享内存为 "移除"，在无其他进程访问后会自动释放。
//通过 atexit 注册，在程序退出时自动调用，确保清理资源。
}
/* Configure shared memory. */
/* 配置共享内存 */
static void setup_shm(void) {
static void setup_shm(void) {// 创建共享内存，分配给 trace_bits 用于记录插桩数据。通过 atexit 注册清理函数，确保资源的释放。
u8* shm_str;
/* 创建一个私有的共享内存区域，大小为 MAP_SIZE */
shm_id = shmget(IPC_PRIVATE, MAP_SIZE, IPC_CREAT | IPC_EXCL | 0600);
if (shm_id < 0) PFATAL("shmget() failed");
if (shm_id < 0) PFATAL("shmget() failed");/* 创建失败时输出错误并退出 */
atexit(remove_shm);
atexit(remove_shm);/* 注册 atexit 处理程序以在程序退出时删除共享内存 */
/* 将共享内存 ID 转换为字符串并设置环境变量 */
shm_str = alloc_printf("%d", shm_id);
setenv(SHM_ENV_VAR, shm_str, 1);
ck_free(shm_str);
ck_free(shm_str);/* 释放临时字符串内存 */
/* 将共享内存附加到当前进程的地址空间 */
trace_bits = shmat(shm_id, NULL, 0);
if (trace_bits == (void *)-1) PFATAL("shmat() failed");
if (trace_bits == (void *)-1) PFATAL("shmat() failed"); /* 附加失败时退出 */
}
/* Write results. */
/* 写入测试结果 */
static u32 write_results(void) {
static u32 write_results(void) { //将插桩结果输出到文件，支持二进制和文本模式。
s32 fd;
u32 i, ret = 0;
s32 fd; /* 文件描述符 */
u32 i, ret = 0; /* 计数器和返回值 */
u8 cco = !!getenv("AFL_CMIN_CRASHES_ONLY"),
caa = !!getenv("AFL_CMIN_ALLOW_ANY");
u8 cco = !!getenv("AFL_CMIN_CRASHES_ONLY"), /* 仅输出崩溃路径？ */
caa = !!getenv("AFL_CMIN_ALLOW_ANY"); /* 是否允许所有路径？ */
if (!strncmp(out_file, "/dev/", 5)) {
/* 根据输出文件路径的类型处理 */
if (!strncmp(out_file, "/dev/", 5)) { /* 如果是设备文件路径 */
fd = open(out_file, O_WRONLY, 0600);
if (fd < 0) PFATAL("Unable to open '%s'", out_file);
} else if (!strcmp(out_file, "-")) {
} else if (!strcmp(out_file, "-")) { /* 如果是标准输出 */
fd = dup(1);
fd = dup(1); /* 复制标准输出描述符 */
if (fd < 0) PFATAL("Unable to open stdout");
} else {
} else { /* 普通文件路径 */
unlink(out_file); /* Ignore errors */
unlink(out_file); /* 删除已有的同名文件 (忽略错误) */
fd = open(out_file, O_WRONLY | O_CREAT | O_EXCL, 0600);
if (fd < 0) PFATAL("Unable to create '%s'", out_file);
}
/* 如果以二进制模式输出结果 */
if (binary_mode) {
for (i = 0; i < MAP_SIZE; i++)
if (trace_bits[i]) ret++;
if (trace_bits[i]) ret++;/* 统计非零插桩计数 */
ck_write(fd, trace_bits, MAP_SIZE, out_file);
ck_write(fd, trace_bits, MAP_SIZE, out_file);/* 将插桩数据写入文件 */
close(fd);
} else {
} else { /* 文本模式输出 */
FILE* f = fdopen(fd, "w");
if (!f) PFATAL("fdopen() failed");
/* 遍历插桩数据，按文本格式输出 */
for (i = 0; i < MAP_SIZE; i++) {
if (!trace_bits[i]) continue;
if (!trace_bits[i]) continue;/* 跳过空条目 */
ret++;
if (cmin_mode) {
if (cmin_mode) {/* afl-cmin 模式 */
if (child_timed_out) break;
if (!caa && child_crashed != cco) break;
if (child_timed_out) break; /* 如果子进程超时，停止输出 */
if (!caa && child_crashed != cco) break;/* 根据环境变量条件过滤 */
fprintf(f, "%u%u\n", trace_bits[i], i);
} else fprintf(f, "%06u:%u\n", i, trace_bits[i]);
} else fprintf(f, "%06u:%u\n", i, trace_bits[i]);/* 标准格式 */
}
@ -235,42 +242,42 @@ static u32 write_results(void) {
}
/* Handle timeout signal. */
/* 处理超时信号 */
static void handle_timeout(int sig) {
child_timed_out = 1;
if (child_pid > 0) kill(child_pid, SIGKILL);
child_timed_out = 1; /* 设置子进程超时标志 */
if (child_pid > 0) kill(child_pid, SIGKILL); /* 强制杀死子进程 */
}
/* Execute target application. */
/* 执行目标程序 */
static void run_target(char** argv) {
static struct itimerval it;
static struct itimerval it;/* 定时器结构 */
int status = 0;
if (!quiet_mode)
SAYF("-- Program output begins --\n" cRST);
SAYF("-- Program output begins --\n" cRST);/* 输出调试信息 */
MEM_BARRIER();
MEM_BARRIER(); /* 防止编译器重排内存操作 */
child_pid = fork();
child_pid = fork();/* 创建子进程 */
if (child_pid < 0) PFATAL("fork() failed");
if (child_pid < 0) PFATAL("fork() failed");/* 如果 fork 失败，退出程序 */
if (!child_pid) {
if (!child_pid) { /* 子进程逻辑 */
struct rlimit r;
if (quiet_mode) {
if (quiet_mode) { /* 如果静默模式开启，将子进程输出重定向到 `/dev/null` */
s32 fd = open("/dev/null", O_RDWR);
if (fd < 0 || dup2(fd, 1) < 0 || dup2(fd, 2) < 0) {
*(u32*)trace_bits = EXEC_FAIL_SIG;
*(u32*)trace_bits = EXEC_FAIL_SIG; /* 设置错误标志 */
PFATAL("Descriptor initialization failed");
}
@ -278,35 +285,35 @@ static void run_target(char** argv) {
}
if (mem_limit) {
if (mem_limit) {/* 设置子进程内存限制 */
r.rlim_max = r.rlim_cur = ((rlim_t)mem_limit) << 20;
#ifdef RLIMIT_AS
setrlimit(RLIMIT_AS, &r); /* Ignore errors */
setrlimit(RLIMIT_AS, &r); /* 设置内存限制 (按地址空间限制)，忽略错误 */
#else
setrlimit(RLIMIT_DATA, &r); /* Ignore errors */
setrlimit(RLIMIT_DATA, &r); /* 设置内存限制 (按数据段大小限制)，忽略错误 */
#endif /* ^RLIMIT_AS */
}
// 根据平台使用适当的资源限制类型 (RLIMIT_AS 或 RLIMIT_DATA) 限制子进程的内存使用。
if (!keep_cores) r.rlim_max = r.rlim_cur = 0; /* 禁止 core dump */
// 控制是否允许子进程生成 core dump 文件。
else r.rlim_max = r.rlim_cur = RLIM_INFINITY; /* 允许无限 core dump */
if (!keep_cores) r.rlim_max = r.rlim_cur = 0;
else r.rlim_max = r.rlim_cur = RLIM_INFINITY;
setrlimit(RLIMIT_CORE, &r); /* 设置 core dump 限制，忽略错误 */
setrlimit(RLIMIT_CORE, &r); /* Ignore errors */
if (!getenv("LD_BIND_LAZY")) setenv("LD_BIND_NOW", "1", 0); // 强制目标程序加载动态库时立即绑定符号，避免延迟加载可能引发的问题。
if (!getenv("LD_BIND_LAZY")) setenv("LD_BIND_NOW", "1", 0);
setsid(); /* 创建一个新会话，隔离子进程 */
setsid();
execv(target_path, argv);/* 替换当前进程镜像为目标程序 */
execv(target_path, argv);
*(u32*)trace_bits = EXEC_FAIL_SIG;
exit(0);
*(u32*)trace_bits = EXEC_FAIL_SIG; /* 如果 execv 返回，则标记执行失败 */
exit(0);/* 终止子进程 */
}
@ -320,9 +327,9 @@ static void run_target(char** argv) {
}
setitimer(ITIMER_REAL, &it, NULL);
setitimer(ITIMER_REAL, &it, NULL);/* 配置超时定时器 */
if (waitpid(child_pid, &status, 0) <= 0) FATAL("waitpid() failed");
if (waitpid(child_pid, &status, 0) <= 0) FATAL("waitpid() failed"); /* 等待子进程结束 */
child_pid = 0;
it.it_value.tv_sec = 0;
@ -338,7 +345,7 @@ static void run_target(char** argv) {
classify_counts(trace_bits, binary_mode ?
count_class_binary : count_class_human);
/* 将 trace_bits 中的插桩命中数据分类为二进制或人类可读格式 */
if (!quiet_mode)
SAYF(cRST "-- Program output ends --\n");
@ -362,11 +369,11 @@ static void run_target(char** argv) {
/* Handle Ctrl-C and the like. */
static void handle_stop_sig(int sig) {
static void handle_stop_sig(int sig) {//捕获停止信号 (SIGHUP, SIGINT, SIGTERM) 并设置全局停止标志。终止子进程以确保程序退出。
stop_soon = 1;
stop_soon = 1;/* 设置标志，通知主程序停止 */
if (child_pid > 0) kill(child_pid, SIGKILL);
if (child_pid > 0) kill(child_pid, SIGKILL);/* 强制杀死子进程 */
}
@ -374,7 +381,7 @@ static void handle_stop_sig(int sig) {
/* Do basic preparations - persistent fds, filenames, etc. */
static void set_up_environment(void) {
// 设置环境变量，配置 AddressSanitizer (ASAN) 和 MemorySanitizer (MSAN) 行为：禁用内存泄漏检测 (detect_leaks=0)。禁用符号化输出 (symbolize=0)。配置错误退出行为 (abort_on_error=1)。
setenv("ASAN_OPTIONS", "abort_on_error=1:"
"detect_leaks=0:"
"symbolize=0:"
@ -385,7 +392,7 @@ static void set_up_environment(void) {
"abort_on_error=1:"
"allocator_may_return_null=1:"
"msan_track_origins=0", 0);
// 如果存在 AFL_PRELOAD 环境变量，将其设置为动态库预加载路径。
if (getenv("AFL_PRELOAD")) {
setenv("LD_PRELOAD", getenv("AFL_PRELOAD"), 1);
setenv("DYLD_INSERT_LIBRARIES", getenv("AFL_PRELOAD"), 1);
@ -407,15 +414,15 @@ static void setup_signal_handlers(void) {
sigemptyset(&sa.sa_mask);
/* Various ways of saying "stop". */
sa.sa_handler = handle_stop_sig;
// 为停止信号 (SIGHUP, SIGINT, SIGTERM) 注册处理函数 handle_stop_sig。
sa.sa_handler = handle_stop_sig; /* 设置停止信号的处理函数 */
sigaction(SIGHUP, &sa, NULL);
sigaction(SIGINT, &sa, NULL);
sigaction(SIGTERM, &sa, NULL);
/* Exec timeout notifications. */
sa.sa_handler = handle_timeout;
sa.sa_handler = handle_timeout;/* 设置超时信号的处理函数 */
sigaction(SIGALRM, &sa, NULL);
}
@ -425,14 +432,15 @@ static void setup_signal_handlers(void) {
static void detect_file_args(char** argv) {
// 获取当前工作目录，用于构造绝对路径。
u32 i = 0;
u8* cwd = getcwd(NULL, 0);
u8* cwd = getcwd(NULL, 0);/* 获取当前工作目录 */
if (!cwd) PFATAL("getcwd() failed");
while (argv[i]) {
u8* aa_loc = strstr(argv[i], "@@");
u8* aa_loc = strstr(argv[i], "@@");/* 查找命令行参数中的 @@ */
if (aa_loc) {
@ -442,13 +450,13 @@ static void detect_file_args(char** argv) {
/* Be sure that we're always using fully-qualified paths. */
if (at_file[0] == '/') aa_subst = at_file;
else aa_subst = alloc_printf("%s/%s", cwd, at_file);
if (at_file[0] == '/') aa_subst = at_file;/* 如果是绝对路径，直接使用 */
else aa_subst = alloc_printf("%s/%s", cwd, at_file);/* 构造绝对路径 */
/* Construct a replacement argv value. */
*aa_loc = 0;
n_arg = alloc_printf("%s%s%s", argv[i], aa_subst, aa_loc + 2);
n_arg = alloc_printf("%s%s%s", argv[i], aa_subst, aa_loc + 2);/* 替换 @@ */
argv[i] = n_arg;
*aa_loc = '@';
@ -466,7 +474,7 @@ static void detect_file_args(char** argv) {
/* Show banner. */
// 打印工具的名称和版本信息。
static void show_banner(void) {
SAYF(cCYA "afl-showmap " cBRI VERSION cRST " by <lcamtuf@google.com>\n");
@ -478,7 +486,7 @@ static void show_banner(void) {
static void usage(u8* argv0) {
show_banner();
// 显示工具的用法说明，包括参数和选项说明。
SAYF("\n%s [ options ] -- /path/to/target_app [ ... ]\n\n"
"Required parameters:\n\n"
@ -492,7 +500,7 @@ static void usage(u8* argv0) {
" -Q - use binary-only instrumentation (QEMU mode)\n\n"
"Other settings:\n\n"
// 描述可用的执行控制选项，包括超时时间和内存限制。
" -q - sink program's output and don't show messages\n"
" -e - show edge coverage only, ignore hit counts\n"
" -c - allow core dumps\n"
@ -509,16 +517,16 @@ static void usage(u8* argv0) {
/* Find binary. */
// 找到目标程序的可执行文件路径 (target_path)。
static void find_binary(u8* fname) {
// fname：目标程序的文件名。如果 fname 包含斜杠（表明是路径）或没有设置 PATH 环境变量，则直接检查 fname 是否是一个可执行文件。否则，遍历 PATH 环境变量中定义的路径，尝试找到 fname。
u8* env_path = 0;
struct stat st;
if (strchr(fname, '/') || !(env_path = getenv("PATH"))) {
// 如果 fname 是路径（包含斜杠），直接检查其合法性。
target_path = ck_strdup(fname);
// 如果 PATH 环境变量未设置，同样直接检查 fname。
if (stat(target_path, &st) || !S_ISREG(st.st_mode) ||
!(st.st_mode & 0111) || st.st_size < 4)
FATAL("Program '%s' not found or not executable", fname);
@ -538,14 +546,14 @@ static void find_binary(u8* fname) {
} else cur_elem = ck_strdup(env_path);
env_path = delim;
// 按冒号分隔符解析 PATH 环境变量，依次检查每个路径是否包含目标文件。
if (cur_elem[0])
target_path = alloc_printf("%s/%s", cur_elem, fname);
else
target_path = ck_strdup(fname);
ck_free(cur_elem);
// 将文件名与路径组合成完整路径。检查文件是否存在、是否是普通文件、是否可执行且文件大小合理。如果找到符合条件的文件路径，则退出循环。
if (!stat(target_path, &st) && S_ISREG(st.st_mode) &&
(st.st_mode & 0111) && st.st_size >= 4) break;
@ -553,7 +561,7 @@ static void find_binary(u8* fname) {
target_path = 0;
}
// 如果遍历完所有路径后仍未找到目标文件，则程序退出。
if (!target_path) FATAL("Program '%s' not found or not executable", fname);
}
@ -562,23 +570,25 @@ static void find_binary(u8* fname) {
/* Fix up argv for QEMU. */
// 为在 QEMU 模式下执行目标程序，调整参数列表 argv。
static char** get_qemu_argv(u8* own_loc, char** argv, int argc) {
// own_loc：当前程序的路径，用于寻找 afl-qemu-trace。argv：原始参数列表。argc：参数个数。
char** new_argv = ck_alloc(sizeof(char*) * (argc + 4));
u8 *tmp, *cp, *rsl, *own_copy;
/* Workaround for a QEMU stability glitch. */
/* 设置 QEMU 的环境变量 QEMU_LOG，禁用链式日志。 */
setenv("QEMU_LOG", "nochain", 1);
memcpy(new_argv + 3, argv + 1, sizeof(char*) * argc);
// 为新参数列表分配空间。
// 将原始参数 argv 复制到新参数列表的合适位置。
// 添加必要的 QEMU 参数 -- 和 target_path。
new_argv[2] = target_path;
new_argv[1] = "--";
/* Now we need to actually find qemu for argv[0]. */
// 检查 AFL_PATH 环境变量是否指向 afl-qemu-trace，并验证其是否可执行。
tmp = getenv("AFL_PATH");
if (tmp) {
@ -592,7 +602,7 @@ static char** get_qemu_argv(u8* own_loc, char** argv, int argc) {
return new_argv;
}
// 使用当前程序的路径 own_loc 尝试找到 afl-qemu-trace。
own_copy = ck_strdup(own_loc);
rsl = strrchr(own_copy, '/');
@ -611,14 +621,14 @@ static char** get_qemu_argv(u8* own_loc, char** argv, int argc) {
}
} else ck_free(own_copy);
// 检查预定义路径 BIN_PATH 下是否存在 afl-qemu-trace。
if (!access(BIN_PATH "/afl-qemu-trace", X_OK)) {
target_path = new_argv[0] = BIN_PATH "/afl-qemu-trace";
return new_argv;
}
// 如果未找到 afl-qemu-trace，程序退出并报错。
FATAL("Unable to find 'afl-qemu-trace'.");
}
@ -627,24 +637,31 @@ static char** get_qemu_argv(u8* own_loc, char** argv, int argc) {
/* Main entry point */
int main(int argc, char** argv) {
//opt：用于存储当前解析的命令行选项。
//mem_limit_given：标志是否设置了内存限制选项。
//timeout_given：标志是否设置了超时选项。
//qemu_mode：标志是否启用了 QEMU 模式。
//tcnt：存储记录的插桩数据元组计数。
//use_argv：用于执行目标程序的参数列表。
s32 opt;
u8 mem_limit_given = 0, timeout_given = 0, qemu_mode = 0;
u32 tcnt;
char** use_argv;
// 检查 DOC_PATH 是否存在，如果不存在则回退到默认路径 "docs"。
doc_path = access(DOC_PATH, F_OK) ? "docs" : DOC_PATH;
// 使用 getopt 解析命令行选项，支持的选项包括：
while ((opt = getopt(argc,argv,"+o:m:t:A:eqZQbcV")) > 0)
switch (opt) {
// -o：指定输出文件。
case 'o':
if (out_file) FATAL("Multiple -o options not supported");
out_file = optarg;
break;
// -m：设置内存限制。
case 'm': {
u8 suffix = 'M';
@ -681,7 +698,7 @@ int main(int argc, char** argv) {
}
break;
// -t：设置超时时间。
case 't':
if (timeout_given) FATAL("Multiple -t options not supported");
@ -696,19 +713,19 @@ int main(int argc, char** argv) {
}
break;
// -e：只关注边覆盖率。
case 'e':
if (edges_only) FATAL("Multiple -e options not supported");
edges_only = 1;
break;
// -q：静默模式，不显示多余信息。
case 'q':
if (quiet_mode) FATAL("Multiple -q options not supported");
quiet_mode = 1;
break;
// -Z：启用 afl-cmin 模式，内部使用，设置 cmin_mode 和 quiet_mode。
case 'Z':
/* This is an undocumented option to write data in the syntax expected
@ -717,13 +734,13 @@ int main(int argc, char** argv) {
cmin_mode = 1;
quiet_mode = 1;
break;
// -A：设置 @@ 替换文件路径。
case 'A':
/* Another afl-cmin specific feature. */
at_file = optarg;
break;
// -Q：启用 QEMU 模式，如果未指定内存限制，使用默认值 MEM_LIMIT_QEMU。
case 'Q':
if (qemu_mode) FATAL("Multiple -Q options not supported");
@ -731,7 +748,7 @@ int main(int argc, char** argv) {
qemu_mode = 1;
break;
// -b：启用二进制输出模式，设置全局变量 binary_mode = 1。
case 'b':
/* Secret undocumented mode. Writes output in raw binary format
@ -739,13 +756,13 @@ int main(int argc, char** argv) {
binary_mode = 1;
break;
// -c：允许生成核心转储文件，设置全局变量 keep_cores = 1。
case 'c':
if (keep_cores) FATAL("Multiple -c options not supported");
keep_cores = 1;
break;
// -V：显示版本号并退出程序。
case 'V':
show_banner();
@ -757,39 +774,40 @@ int main(int argc, char** argv) {
}
if (optind == argc || !out_file) usage(argv[0]);
if (optind == argc || !out_file) usage(argv[0]); //如果未指定目标程序路径或输出文件，则显示用法说明并退出。
setup_shm();
setup_signal_handlers();
setup_shm();// 调用 setup_shm 函数，配置用于插桩数据存储的共享内存。
setup_signal_handlers();// 注册信号处理函数，处理程序停止（SIGINT、SIGTERM）或超时（SIGALRM）等事件。
set_up_environment();
set_up_environment();// 配置环境变量，例如 ASAN_OPTIONS 和 MSAN_OPTIONS。
find_binary(argv[optind]);
find_binary(argv[optind]);//使用 find_binary 函数查找目标程序的可执行文件路径，并存储到全局变量 target_path。
if (!quiet_mode) {
if (!quiet_mode) {// 如果未启用静默模式，显示工具信息和目标程序路径。
show_banner();
ACTF("Executing '%s'...\n", target_path);
}
detect_file_args(argv + optind);
detect_file_args(argv + optind); //检测命令行参数中的 @@ 并将其替换为指定的文件路径。
if (qemu_mode)
if (qemu_mode) //如果启用了 QEMU 模式，调用 get_qemu_argv 函数为 QEMU 准备参数列表。
use_argv = get_qemu_argv(argv[0], argv + optind, argc - optind);
else
else // 否则直接使用原始参数。
use_argv = argv + optind;
run_target(use_argv);
tcnt = write_results();
tcnt = write_results(); // 调用 write_results 函数，将插桩数据写入指定的输出文件。
if (!quiet_mode) {
if (!tcnt) FATAL("No instrumentation detected" cRST);
OKF("Captured %u tuples in '%s'." cRST, tcnt, out_file);
if (!tcnt) FATAL("No instrumentation detected" cRST); //如果没有捕获插桩数据，显示错误并退出。
OKF("Captured %u tuples in '%s'." cRST, tcnt, out_file); // 否则显示捕获的元组数量和输出文件路径。
}
exit(child_crashed * 2 + child_timed_out);
// 根据子进程状态退出.如果子进程崩溃：返回 2。如果子进程超时：返回 1。正常退出：返回 0。
}

Write Preview
Loading…
Cancel
Save