- 在VisualStudio中部署GDAL库的C++版本(包括SQLite、PROJ等依赖)
- Android开机流程介绍
- STM32CubeMX教程31USB_DEVICE-HID外设_模拟键盘或鼠标
- 深入浅出Java多线程(五):线程间通信
本文细致的剖析了2021 FALL MIT 6.S081 课程的一项实验, Lab 链接 Lab: System calls (mit.edu) .
大家的点赞将会是我继续更新的巨大动力,对文中内容或实验过程中有任何疑问欢迎留言! 。
开始 Lab 前首先要切换 git 分支:
$ git fetch
$ git checkout syscall
$ make clean
在本实验中,您将添加一个系统调用跟踪功能,该功能会在您调试实验时有所帮助。您将创建一个新的 trace 系统调用来跟踪系统调用。它有一个参数,这个参数是一个整数“掩码”(mask),它的比特位与要跟踪的系统调用有对应关系。例如, fork 对应的系统调用号为 5 ( SYS_fork = 5),要跟踪 fork 系统调用,程序应调用 trace(1 << SYS_fork) ,其中 SYS_fork 是 kernel/syscall.h 中的系统调用编号。您应修改 xv6 内核,如果掩码中对应的系统调用的编号置位,则在每个系统调用即将返回时打印一行信息。该信息应该包含 pid 、系统调用的名称和返回值,不需要打印系统调用参数。 trace 系统调用应跟踪调用它的进程及其所有子进程,但不应影响其他进程.
在 Makefile 的 UPROGS 中添加 $U/_trace 。
运行 make qemu ,您会发现编译器无法编译 user/trace.c ,因为系统调用的用户空间存根还不存在。将系统调用的原型添加到 user/user.h ,存根添加到 user/usys.pl,以及将系统调用编号添加到 kernel/syscall.h , Makefile 调用perl脚本user/usys.pl,它生成实际的系统调用存根 user/usys.s ,这个文件中的汇编代码使用RISC-V的 ecall 指令转换到内核。一旦修复了编译问题(*注:如果编译还未通过,尝试先 make clean ,再执行 make qemu *),就运行 trace 32 grep hello README ;但由于您还没有在内核中实现系统调用,执行将失败.
("存根"(stub)通常指的是一个简单的程序或函数,它的目的是在开发过程中替代或模拟某个功能或组件。存根的主要作用是提供一个占位符,使得程序的其余部分能够继续开发和测试,而不受到尚未实现的组件的影响。) 。
在 kernel/sysproc.c 中添加一个 sys_trace() 函数,它将参数保存到 proc 结构体(请参见 kernel/proc.h )里的一个新变量(掩码)中来实现对系统调用的追踪。从用户空间检索系统调用参数的函数在 kernel/syscall.c 中,您可以在 kernel/sysproc.c 中看到它们的使用示例.
修改 fork() (请参阅 kernel/proc.c ),将掩码从父进程复制到子进程.
修改 kernel/syscall.c 中的 syscall() 函数以打印跟踪过程的输出信息。您需要添加一个系统调用名称数组以建立索引.
在开始实验前,有必要搞清 xv6 是如何执行系统调用的,以 sleep 为例,后续的实现过程与这张图紧密相关:
根据提示,首先需要在 kernel/syscall.h 和 kernel/syscall.c 中增加系统调用的编号及声明.
// kernel/syscall.h
// ...
#define SYS_trace 22
// kernel/syscall.c
// ...
extern uint64 sys_trace(void);
extern uint64 sys_sysinfo(void);
static uint64 (*syscalls[])(void) = {
// ...
[SYS_trace] sys_trace,
};
同时,需要在 user/user.h 中添加函数原型 。
// user/user.h
// ...
// system calls
// ...
int trace(int);
// ...
依照实验提示,我们需要在 kernel/proc.h 的 struct proc 结构体中添加一个新的变量 tracenum 来记录被追踪的函数 。
// kernel/proc.h
// ...
// Per-process state
struct proc {
struct spinlock lock;
// p->lock must be held when using these:
enum procstate state; // Process state
void *chan; // If non-zero, sleeping on chan
int killed; // If non-zero, have been killed
int xstate; // Exit status to be returned to parent's wait
int pid; // Process ID
// wait_lock must be held when using this:
struct proc *parent; // Parent process
// these are private to the process, so p->lock need not be held.
uint64 kstack; // Virtual address of kernel stack
uint64 sz; // Size of process memory (bytes)
pagetable_t pagetable; // User page table
struct trapframe *trapframe; // data page for trampoline.S
struct context context; // swtch() here to run process
struct file *ofile[NOFILE]; // Open files
struct inode *cwd; // Current directory
char name[16]; // Process name (debugging)
int tracenum; // Trace mask
};
在实现系统调用函数之前,我们有必要先看一下 user/trace.c , 看看命令行中 trace 命令是如何被使用的.
// user/trace.c
#include "kernel/param.h"
#include "kernel/types.h"
#include "kernel/stat.h"
#include "user/user.h"
int
main(int argc, char *argv[])
{
int i;
char *nargv[MAXARG];
if(argc < 3 || (argv[1][0] < '0' || argv[1][0] > '9')){
fprintf(2, "Usage: %s mask command\n", argv[0]);
exit(1);
}
if (trace(atoi(argv[1])) < 0) {
fprintf(2, "%s: trace failed\n", argv[0]);
exit(1);
}
for(i = 2; i < argc && i < MAXARG; i++){
nargv[i-2] = argv[i];
}
exec(nargv[0], nargv);
exit(0);
}
首先验证参数数量不小于 3 ,因为 trace 命令的使用格式为:
trace [系统调用号] [命令]
并验证传递的系统调用号合法,开始对 argv[1] 传递的系统调用号进行追踪.
需要被 trace 的命令被复制到新的参数参数列表中,并通过 exec 系统调用开始执行,这一过程中, trace 会持续追踪.
使用示例如下:
$ trace 32 grep hello README
3: syscall read -> 1023
3: syscall read -> 966
3: syscall read -> 70
3: syscall read -> 0
这里我们会发现 user/trace.c 使用的参数为 int 型 trace 函数,仅在 user/user.h 有一个函数原型,而没有具体的函数实现,实际上这里与上面补充内容的图片相对应,这一函数实际上会调用 ECALL 指令,指令的参数是代表了 trace 系统调用的数字,之后控制权到了 syscall 函数, syscall 会实际调用 trace 系统调用.
ECALL 指令属于汇编层面,暂且跳过,下面我们来分析 kernel/syscall.c 中 syscall 函数的代码:
// kernel/syscall.c
// ...
void
syscall(void)
{
int num;
struct proc *p = myproc();
num = p->trapframe->a7;
if(num > 0 && num < NELEM(syscalls) && syscalls[num]) {
p->trapframe->a0 = syscalls[num]();
} else {
printf("%d %s: unknown sys call %d\n",
p->pid, p->name, num);
p->trapframe->a0 = -1;
}
}
逐行分析这段代码:
struct proc *p = myproc();
跳转查看 myproc() 的函数定义:
// kernel/proc.c
// ...
// Return the current struct proc *, or zero if none.
struct proc*
myproc(void) {
push_off();
struct cpu *c = mycpu();
struct proc *p = c->proc;
pop_off();
return p;
}
// ...
myproc() 函数会返回当前运行的进程的指针。 struct proc *p = myproc();获取了当前进程的指针并赋值给变量 p 。
num = p->trapframe->a7
从当前进程的 trapframe 结构中获取系统调用号,并将其存储在变量 num 中。在 RISC-V 中,系统调用号存储在寄存器 a7 中.
if(num > 0 && num < NELEM(syscalls) && syscalls[num])
检查系统调用号是否在有效范围内,并且确保与该号相关联的处理函数存在.
p->trapframe->a0 = syscalls[num]();
如果条件满足,执行与系统调用号相关联的处理函数,并将其返回值存储在进程的 trapframe->a0 寄存器中。 a0 寄存器用于存储系统调用的返回值。 syscalls[num]() 能执行对应的系统调用处理函数,是因为 kernel/syscall.c 中定义了一个函数指针数组:
// kernel/syscall.c
// ...
// 函数指针数组
static uint64 (*syscalls[])(void) = {
[SYS_fork] sys_fork,
[SYS_exit] sys_exit,
[SYS_wait] sys_wait,
[SYS_pipe] sys_pipe,
[SYS_read] sys_read,
[SYS_kill] sys_kill,
[SYS_exec] sys_exec,
[SYS_fstat] sys_fstat,
[SYS_chdir] sys_chdir,
[SYS_dup] sys_dup,
[SYS_getpid] sys_getpid,
[SYS_sbrk] sys_sbrk,
[SYS_sleep] sys_sleep,
[SYS_uptime] sys_uptime,
[SYS_open] sys_open,
[SYS_write] sys_write,
[SYS_mknod] sys_mknod,
[SYS_unlink] sys_unlink,
[SYS_link] sys_link,
[SYS_mkdir] sys_mkdir,
[SYS_close] sys_close,
[SYS_trace] sys_trace,
};
syscall 执行结束后,就会执行对应的 sys_trace 函数,我们当前尚未定义这一函数。 提示中提到,我们需要修改 kernel/syscall.c 来打印追踪的信息,而定义在 kernel/sysproc.c 中的 sys_trace 函数只需更新当前进程的 tracenum 即可.
注意到 kernel/sysproc.c 中的函数入参都是 void ,我们需要考虑如何将参数传递给 sys_trace 函数。参考一下 sys_kill 的代码:
// kernel/sysproc.c
// ...
uint64
sys_kill(void)
{
int pid;
if(argint(0, &pid) < 0)
return -1;
return kill(pid);
}
// ...
可以看到有一个 argint 函数似乎完成了对变量 pid 的赋值操作,我们转到 argint 函数的定义:
// Fetch the nth 32-bit system call argument.
int
argint(int n, int *ip)
{
*ip = argraw(n);
return 0;
}
static uint64
argraw(int n)
{
struct proc *p = myproc();
switch (n) {
case 0:
return p->trapframe->a0;
case 1:
return p->trapframe->a1;
case 2:
return p->trapframe->a2;
case 3:
return p->trapframe->a3;
case 4:
return p->trapframe->a4;
case 5:
return p->trapframe->a5;
}
panic("argraw");
return -1;
}
注释表明 argint 函数的功能是取第 n 个 32 位系统调用参数,看这两个函数片段可以得知,系统调用参数是通过当前进程的 trapframe 来传递的。这个参数究竟是什么时候到 a0 中的,需要阅读大量汇编代码,这里暂且略过.
获知这些信息后,我们可以开始实现 sys_trace ,利用 argint 函数取得参数值后,将前面为进程结构体增加的 tracenum 设为该函数值即可:
// kernel/sysproc.c
// ...
uint64
sys_trace(void){
int mask;
// get the trace mask from the p->trapframe->a0
if(argint(0, &mask) < 0)
return -1;
myproc()->tracenum = mask;
return 0;
}
根据提示,我们还需要修改 kernel/proc.c 中的 fork() 函数来将 tracenum 从父进程复制到子进程:
// kernel/proc.c
// Create a new process, copying the parent.
// Sets up child kernel stack to return as if from fork() system call.
int
fork(void)
{
int i, pid;
struct proc *np;
struct proc *p = myproc();
// Allocate process.
if((np = allocproc()) == 0){
return -1;
}
// Copy user memory from parent to child.
if(uvmcopy(p->pagetable, np->pagetable, p->sz) < 0){
freeproc(np);
release(&np->lock);
return -1;
}
np->sz = p->sz;
// copy saved user registers.
*(np->trapframe) = *(p->trapframe);
// Cause fork to return 0 in the child.
np->trapframe->a0 = 0;
// increment reference counts on open file descriptors.
for(i = 0; i < NOFILE; i++)
if(p->ofile[i])
np->ofile[i] = filedup(p->ofile[i]);
np->cwd = idup(p->cwd);
safestrcpy(np->name, p->name, sizeof(p->name));
pid = np->pid;
release(&np->lock);
acquire(&wait_lock);
np->parent = p;
release(&wait_lock);
acquire(&np->lock);
np->state = RUNNABLE;
release(&np->lock);
// 复制 tracenum 到子进程
np->tracenum = p->tracenum;
return pid;
}
根据提示,当前进程每次执行被追踪的系统调用时都应打印相关信息,因此,应将打印信息的代码添加在 kernel/syscall.c 中 syscall 函数中。这里还需要添加一个系统调用名称数组以建立索引。修改后的 syscall 函数如下所示:
// kernel/syscall.c
// ...
void
syscall(void)
{
static char *syscall_names[] = {
[SYS_fork] "fork",
[SYS_exit] "exit",
[SYS_wait] "wait",
[SYS_pipe] "pipe",
[SYS_read] "read",
[SYS_kill] "kill",
[SYS_exec] "exec",
[SYS_fstat] "fstat",
[SYS_chdir] "chdir",
[SYS_dup] "dup",
[SYS_getpid] "getpid",
[SYS_sbrk] "sbrk",
[SYS_sleep] "sleep",
[SYS_uptime] "uptime",
[SYS_open] "open",
[SYS_write] "write",
[SYS_mknod] "mknod",
[SYS_unlink] "unlink",
[SYS_link] "link",
[SYS_mkdir] "mkdir",
[SYS_close] "close",
[SYS_trace] "trace",
[SYS_sysinfo] "sysinfo"
};
int num;
struct proc *p = myproc();
num = p->trapframe->a7;
if(num > 0 && num < NELEM(syscalls) && syscalls[num]) {
p->trapframe->a0 = syscalls[num]();
//在函数返回后,以位运算确认该系统调用是否被追踪
if((1 << num) & p->tracenum) {
printf("%d: syscall %s -> %d\n",
p->pid, syscall_names[num-1], p->trapframe->a0);
}
} else {
printf("%d %s: unknown sys call %d\n",
p->pid, p->name, num);
p->trapframe->a0 = -1;
}
}
这里要解释一下增加的打印信息的判断逻辑,操作系统用一个 32 位掩码来表示要追踪哪个系统调用,即若要追踪系统调用号为 n 的掩码,则将 tracenum 的 n + 1 位置 1 。若当前执行的系统调用正在被追踪,则 1 << num 与 tracenum 相与的结果必然不为 0 ,则 if 条件成立,打印信息.
最后此篇关于深入操作系统内核!细致剖析MIT6.S081课程Lab2:systemcalls-1的文章就讲到这里了,如果你想了解更多关于深入操作系统内核!细致剖析MIT6.S081课程Lab2:systemcalls-1的内容请搜索CFSDN的文章或继续浏览相关文章,希望大家以后支持我的博客! 。
这个问题在这里已经有了答案: Why don't Java's +=, -=, *=, /= compound assignment operators require casting? (11 个
我搜索了很多,但没有一个链接能帮助我解决这个问题。我得到了 ORA-21500: internal error code, arguments: [%s], [%s], [%s], [%s], [%s
我正在做 RegexOne 正则表达式教程,它有一个 question关于编写正则表达式以删除不必要的空格。 教程中提供的解决方案是 We can just skip all the starting
([\s\S]+|\s?) 中 |\s? 的目的或作用是什么?如果没有它,表达式会不会与 ([\s\S]+) 相同? 最佳答案 这不是完全相同的。 ([\s\S]+|\s?) 会匹配空字符串,而 ([
这个正则表达式有一组还是两组? 我正在尝试使用第二组访问 bookTitle 但出现错误: Pattern pattern = Pattern.compile("^\\s*(.*?)\\s+-\\s+
在 C 中给定一个字符串指针 s,下面的迭代会做什么?即它以什么方式遍历字符串? for (++s ; *s; ++s); 最佳答案 for (++s ; *s;++s) 表示 将指针 s 递增到字符
我正在用一个 node.js 应用程序解析一个大列表并有这段代码 sizeCode = dbfr.CN_DESC.split('\s+-\s*|\s*-\s+') 这似乎不起作用,因为它返回了 [ '
我正在编写一个简单的字符串连接程序。 该程序按照我发布的方式运行。但是,我首先使用以下代码编写它来查找字符串的结尾: while (*s++) ; 但是,这个方法并没有奏效。我传递给它的字符串
这个问题已经有答案了: What does (?和aramchand来自Mohandas Karamchand G 因此,在使用这些匹配来分割字符串后,您最终会得到 {"M", "K", "G"} 注
我正在尝试转换 Map到 List使用 lambda。 本质上,我想将键和值与 '=' 连接起来之间。这看起来微不足道,但我找不到如何去做。 例如 Map map = new HashMap<>();
我正在经历 K & R,并且在递增指针时遇到困难。练习 5.3(第 107 页)要求您使用指针编写一个 strcat 函数。 在伪代码中,该函数执行以下操作: 将 2 个字符串作为输入。 找到字符串
在下面的代码中,pS 和 s.pS 在最后一行是否保证相等?也就是说,在语句S s = S();中,是否可以确定不会构造一个临时的S? #include using namespace std; s
演示示例代码: public void ReverseString(char[] s) { for(int i = 0, j = s.Length-1; i < j; i++, j--){
我一直在寻找类似于 .NET examples 中的示例的 PowerShell 脚本.取一个 New-TimeSpan 并显示为 1 天 2 小时 3 分钟 4 秒。排除其零的地方,在需要的地方添加
def func(s): s = s + " is corrected" return s string_list = ["She", "He"] for s in string_li
我是 python 的新手。当我在互联网上搜索 lambda 时。我在 lambda_functions 中找到了这个声明. processFunc = collapse and (lambda s:
我最近开始学习正则表达式,并试图为上面的问题写一个正则表达式。如果限制只放在一个字母上(例如不超过 2 个“b”),这并不困难。 那么答案就是:a* c*(b|ε)a* c*(b|ε)a* c* 但是
当我运行 npm install 时出现以下错误,但我无法修复它。 我试过:npm install -g windows-build-tools 也没有修复这个错误 ERR! configure
有很多有趣的haskell网上可以找到片段。 This post可以在 this (awesome) Stack Overflow question 下找到. The author写道: discou
我知道以下三行代码旨在将字符串提取到$ value中并将其存储在$ header中。但是我不知道$value =~ s/^\s+//;和$value =~ s/\s+$//;之间有什么区别。 $val
我是一名优秀的程序员,十分优秀!