CSAPP on RunicDolphin806

Proxy实验

Sun, 28 Dec 2025 00:00:00 +0000

本实验的所有内容均在proxy.c文件中完成。

感谢hankeke303 大佬提供的思路！

Part I：实现顺序的代理服务器

实现顺序的代理服务器实际上就是一个tiny服务器的复刻。

`main`函数

main函数参考书上 P672 的实例：

main函数

现在的代理服务器只支持GET方法。如果客户端请求其他方法（如POST），我们发送给它一个错误信息，并返回到主程序，主程序随后关闭连接并等待下一个连接请求。否则，读并且忽略任何请求报头。

 1int main(int argc, char **argv)
 2{
 3    int listenfd, connfd;
 4    char hostname[MAXLINE], port[MAXLINE];
 5    socklen_t clientlen;
 6    struct sockaddr_storage clientaddr;
 7
 8
 9    // 检查命令输入是否正确
10    if (argc != 2) {
11        fprintf(stderr, "usage: %s <port> \n", argv[0]);
12        exit(1);
13    }
14
15    listenfd = Open_listenfd(argv[1]);
16    // 主循环
17    while (1) {
18        clientlen = sizeof(clientaddr);
19        connfd = Accept(listenfd, (SA *)&clientaddr, &clientlen);
20
21        Getnameinfo((SA *) &clientaddr, clientlen, hostname, MAXLINE, 
22                    port, MAXLINE, 0);
23
24        printf("Accepted connection from (%s, %s)\n", hostname, port);
25    }
26
27    printf("%s", user_agent_hdr);
28    return 0;
29}

解析URL

首先在程序中定义一个URL结构体，存放一个URL的host、端口和路径。

1// URL 结构体
2typedef struct {
3    char host[MAXLINE];
4    char port[MAXLINE];
5    char path[MAXLINE];
6} URL;

对于一个传入的URL字符串，首先忽略掉 http:// 这种协议标识，可以通过查找//字符串来实现。

然后，我们找到第一个/字符，在这个字符后面的就是路径了。如果找不到这个字符，我们就认为访问的是根路径/。随后我们将这个字符设置为\0，方便之后端口的读取。我们通过:字符来定位端口，:后面的就是端口，如果找不到: 那么就认为端口是80，然后我们将这个字符设置为\0。

最后，剩下的字符串就是host了。

 1void parseURL(char *s, URL *url) {
 2    // 忽略"http"，查找 "//" 字符串
 3    char *ptr = strstr(s, "//");
 4
 5    if (ptr != NULL) {
 6        s = ptr+2;
 7    }
 8
 9    // 找到第一个 '/' 字符，其后为路径
10    ptr = strchr(s, '/');
11    if (ptr != NULL) {
12        strcpy(url->path, ptr);
13        *ptr = '\0';    // 在原字符串中截断路径部分
14    }
15
16    // ':' 之后为端口号
17    ptr = strchr(s, ':');
18    if (ptr != NULL) {
19        strcpy(url->port, ptr + 1);
20        *ptr = '\0';
21    }
22    else {
23        // 默认端口为80
24        strcpy(url->port, "80");
25    }
26
27    strcpy(url->host, s);
28}

以http://www.example.com:8080/path/to/file为例：

步骤	操作
查找`//`子字符串	指针指向`www.example.com:8080/path`
查找第一个`/`字符	`ptr`指向`/`，`s`变为`www.example.com:8080`，`url->path`得到`/path/to/file`
查找`:`字符	`ptr`指向`:`，`s`变为`www.example.com`，`url->port`得到`8080`
获取主机名	剩余部分就是主机名，复制到`url->host`，`url->host`得到`www.example.com`

函数说明：

strchr是C语言标准库<string.h>中的一个函数，用于在字符串中查找指定字符的第一次出现位置。如果找到了指定字符，返回该字符在字符串中第一次出现的位置的指针；如果没有找到指定字符，返回NULL。

strcpy是C语言标准库<string.h>中的一个函数，用于将一个字符串复制到另一个字符串中。它会复制源字符串的内容（包括字符串的结束符\0），返回目标字符串的起始地址。

`readClient`函数

readClient函数会从客户端读取请求的全部内容，并生成即将发送到服务端的新请求。

首先，从第一行读取URL扔给parseURL函数提取。

然后，设置默认的Hosts header为URL中的host。接着从接下来读取到的headers中，如果是Hosts那么就更新Hosts，如果是User-Agent、Connection和Proxy-Connection，那么就忽略（因为我们有我们要设定的专属header）。其余的header收集起来，稍后一并作为新请求发过去。

最后，向新请求字符串中写入我们生成的HTTP头和headers。

 1void readClient(rio_t *rio, URL *url, char *data) {
 2    char host[MAXLINE];
 3    char line[MAXLINE];
 4    char other[MAXLINE];
 5    char method[MAXLINE], urlstr[MAXLINE], version[MAXLINE];
 6 
 7    Rio_readlineb(rio, line, MAXLINE);
 8    sscanf(line, "%s %s %s\n", method, urlstr, version);
 9    parseURL(urlstr, url);
10 
11    sprintf(host, "Host: %s\r\n", url->host);
12    while (Rio_readlineb(rio, line, MAXLINE) > 0) {
13        if (strcmp(line, "\r\n") == 0) {
14            break;
15        }
16        if (strncmp(line, "Host", 4) == 0) {
17            strcpy(host, line);
18        }
19        if (strncmp(line, "User-Agent", 10) && strncmp(line, "Connection", 10) 
20            && strncmp(line, "Proxy-Connection", 16)) {
21            strcat(other, line);
22        }
23    }
24    
25    sprintf(data, "%s %s HTTP/1.0\r\n"
26                "%s%s"
27                "Connection: close\r\n"
28                "Proxy-Connection: close\r\n"
29                "%s\r\n", method, url->path, host, user_agent_hdr, other);
30}

`doit`函数

doit函数的功能是处理成功连接的套接字接口。

 1void doit(int connfd) {
 2    rio_t rio;
 3    char line[MAXLINE];
 4    Rio_readinitb(&rio, connfd);
 5    
 6    URL url;
 7    char data[MAXLINE];
 8    readClient(&rio, &url, data);
 9
10    int serverfd = open_clientfd(url.host, url.port);
11    if (serverfd < 0) {
12        printf("Connection failed!\n");
13    }
14    
15    rio_readinitb(&rio, serverfd);
16    Rio_writen(serverfd, data, strlen(data));
17    
18    int len;
19    while ((len = Rio_readlineb(&rio, line, MAXLINE)) > 0) {
20        Rio_writen(connfd, line, len);
21    }
22    
23    Close(serverfd);
24}

Part II：处理多个并发请求

这一部分的任务是实现处理并发请求。

`main`函数

参考书上 P709 的实现。

引入线程的main函数

 1int main(int argc, char **argv)
 2{
 3    int listenfd, connfd;
 4    char hostname[MAXLINE], port[MAXLINE];
 5    socklen_t clientlen;
 6    struct sockaddr_storage clientaddr;
 7
 8    // 引入线程
 9    pthread_t tid;
10
11    // 检查命令输入是否正确
12    if (argc != 2) {
13        fprintf(stderr, "usage: %s <port> \n", argv[0]);
14        exit(1);
15    }
16
17    // 创建线程
18    sbuf_init(&sbuf, SBUFSIZE);
19    for (int i = 0; i < NTHREADS; i++) {
20        Pthread_create(&tid, NULL, thread, NULL);
21    }
22
23    listenfd = Open_listenfd(argv[1]);
24    // 主循环
25    while (1) {
26        clientlen = sizeof(clientaddr);
27        connfd = Accept(listenfd, (SA *)&clientaddr, &clientlen);
28
29        Getnameinfo((SA *) &clientaddr, clientlen, hostname, MAXLINE, 
30                    port, MAXLINE, 0);
31
32        printf("Accepted connection from (%s, %s)\n", hostname, port);
33        // 在循环内部不再是直接执行，而是加入缓冲区
34        sbuf_insert(&sbuf, connfd);
35    }
36    
37    printf("%s", user_agent_hdr);
38    return 0;
39}

同时加入线程执行函数：

1// 线程执行函数
2void *thread(void *vargp) {
3    Pthread_detach(pthread_self());
4    while (1) {
5        int connfd = sbuf_remove(&sbuf);
6        doit(connfd);
7        Close(connfd);
8    }
9}

`SBUF`包

SBUF用于构造生产者-消费者程序，具体实现参考书上 P705-P706 的相关内容。

 1// SBUF 结构体
 2typedef struct {
 3    int *buf;          /* Buffer array */         
 4    int n;             /* Maximum number of slots */
 5    int front;         /* buf[(front+1)%n] is first item */
 6    int rear;          /* buf[rear%n] is last item */
 7    sem_t mutex;       /* Protects accesses to buf */
 8    sem_t slots;       /* Counts available slots */
 9    sem_t items;       /* Counts available items */
10} sbuf_t;
11
12/* Create an empty, bounded, shared FIFO buffer with n slots */
13/* $begin sbuf_init */
14void sbuf_init(sbuf_t *sp, int n)
15{
16    sp->buf = Calloc(n, sizeof(int)); 
17    sp->n = n;                       /* Buffer holds max of n items */
18    sp->front = sp->rear = 0;        /* Empty buffer iff front == rear */
19    Sem_init(&sp->mutex, 0, 1);      /* Binary semaphore for locking */
20    Sem_init(&sp->slots, 0, n);      /* Initially, buf has n empty slots */
21    Sem_init(&sp->items, 0, 0);      /* Initially, buf has zero data items */
22}
23/* $end sbuf_init */
24
25/* Clean up buffer sp */
26/* $begin sbuf_deinit */
27void sbuf_deinit(sbuf_t *sp)
28{
29    Free(sp->buf);
30}
31/* $end sbuf_deinit */
32
33/* Insert item onto the rear of shared buffer sp */
34/* $begin sbuf_insert */
35void sbuf_insert(sbuf_t *sp, int item)
36{
37    P(&sp->slots);                          /* Wait for available slot */
38    P(&sp->mutex);                          /* Lock the buffer */
39    sp->buf[(++sp->rear)%(sp->n)] = item;   /* Insert the item */
40    V(&sp->mutex);                          /* Unlock the buffer */
41    V(&sp->items);                          /* Announce available item */
42}
43/* $end sbuf_insert */
44
45/* Remove and return the first item from buffer sp */
46/* $begin sbuf_remove */
47int sbuf_remove(sbuf_t *sp)
48{
49    int item;
50    P(&sp->items);                          /* Wait for available item */
51    P(&sp->mutex);                          /* Lock the buffer */
52    item = sp->buf[(++sp->front)%(sp->n)];  /* Remove the item */
53    V(&sp->mutex);                          /* Unlock the buffer */
54    V(&sp->slots);                          /* Announce available slot */
55    return item;
56}

Part III：缓存Web对象

第3个任务就是实现缓存一些网页对象。

具体地，当我们的代理访问了一个服务器网页的时候，我们需要将这个网页缓存下来，在之后的请求中就不需要再次从服务器那里请求这个网页了。

但是，缓存的大小不是无限的，这就需要我们在缓存使用满的时候驱逐一部分已经缓存的网页出去。本实验要求我们使用LRU（最近最少使用）的方法，也就是找到上一次访问时间最远的对象替换掉。

`main`函数

 1int main(int argc, char **argv)
 2{
 3    int listenfd, connfd;
 4    char hostname[MAXLINE], port[MAXLINE];
 5    socklen_t clientlen;
 6    struct sockaddr_storage clientaddr;
 7
 8    // 引入线程
 9    pthread_t tid;
10
11    // 检查命令输入是否正确
12    if (argc != 2) {
13        fprintf(stderr, "usage: %s <port> \n", argv[0]);
14        exit(1);
15    }
16
17    // 创建线程
18    sbuf_init(&sbuf, SBUFSIZE);
19    for (int i = 0; i < NTHREADS; i++) {
20        Pthread_create(&tid, NULL, thread, NULL);
21    }
22    // 初始化缓存
23    initCache();
24
25    listenfd = Open_listenfd(argv[1]);
26    // 主循环
27    while (1) {
28        clientlen = sizeof(clientaddr);
29        connfd = Accept(listenfd, (SA *)&clientaddr, &clientlen);
30
31        Getnameinfo((SA *) &clientaddr, clientlen, hostname, MAXLINE, 
32                    port, MAXLINE, 0);
33
34        printf("Accepted connection from (%s, %s)\n", hostname, port);
35        // 在循环内部不再是直接执行，而是加入缓冲区
36        sbuf_insert(&sbuf, connfd);
37    }
38
39    printf("%s", user_agent_hdr);
40    return 0;
41}

读者-写者模型

读者-写者模型实现了多个读者可以同时读取，但是读-写、写-写会互斥。在本实验中采用的是读者优先的策略。

 1// 读者-写者模型
 2void readBegin(Cache *c) {
 3    P(&c->mutex);
 4    if (++c->read_cnt == 1) P(&c->w);
 5    V(&c->mutex);
 6}
 7
 8void readEnd(Cache *c) {
 9    P(&c->mutex);
10    if (--c->read_cnt == 0) V(&c->w);
11    V(&c->mutex);
12}
13
14void writeBegin(Cache *c) {
15    P(&c->w);
16}
17
18void writeEnd(Cache *c) {
19    V(&c->w);
20}

缓存相关

缓存结构

1typedef struct Cache {
2    bool empty;                 // 是否为空
3    URL url;                    // 缓存 URL
4    char data[MAX_OBJECT_SIZE]; // 缓存内容
5    int lru;                    // 上次访问时间
6    int read_cnt;
7    sem_t mutex, w;             // 读者-写者模型相关信号量
8} Cache;

缓存函数

初始化缓存

1// 缓存初始化
2void initCache() {
3    for (int i = 0; i < MAX_CACHE; ++i) {
4        cache[i].empty = 1;
5        Sem_init(&cache[i].mutex, 0, 1);
6        Sem_init(&cache[i].w, 0, 1);
7    }
8}

寻找缓存：枚举每一个缓存，判断是否为空，如果不为空判断URL 是否相等。

 1Cache *getCache(URL *url) {
 2    Cache *ans = NULL;
 3    for (int i = 0; i < MAX_CACHE && ans == NULL; ++i) {
 4        readBegin(&cache[i]);
 5        if (!cache[i].empty && urlEqual(&cache[i].url, url)) {
 6            ans = &cache[i];
 7        }
 8        readEnd(&cache[i]);
 9    }
10    if (ans != NULL) {
11        updateLRU(ans);
12    }
13    return ans;
14}

插入缓存

 1// 插入缓存
 2void insCache(URL *url, char *data) {
 3    Cache *pos = NULL;
 4    for (int i = 0; i < MAX_CACHE && pos == NULL; ++i) {
 5        readBegin(&cache[i]);
 6        if (cache[i].empty) {
 7            pos = &cache[i];
 8        }
 9        readEnd(&cache[i]);
10    }
11    // fprintf(stderr, "insCache: pos = %#p\n", pos);
12    if (pos != NULL) {
13        fillCache(pos, url, data);
14        return;
15    }
16    
17    int minLRU = __INT_MAX__;
18    for (int i = 0; i < MAX_CACHE; ++i) {
19        readBegin(&cache[i]);
20        if (!cache[i].empty && cache[i].lru < minLRU) {
21            minLRU = cache[i].lru;
22            pos = &cache[i];
23        }
24        readEnd(&cache[i]);
25    }
26    fillCache(pos, url, data);
27}

更新 LRU

1// 更新 LRU
2void updateLRU(Cache *c) {
3    static int clock = 0;
4    writeBegin(c);
5    c->lru = ++clock;
6    writeEnd(c);
7}

装载缓存

1// 装载缓存
2void fillCache(Cache *c, URL *url, char *data) {
3    writeBegin(c);
4    c->empty = 0;
5    urlCopy(&c->url, url);
6    strcpy(c->data, data);
7    writeEnd(c);
8    updateLRU(c);
9}

辅助函数，用来判断URL是否相等和复制URL

 1bool urlEqual(const URL *a, const URL *b) {
 2    return strcmp(a->host, b->host) == 0 &&
 3           strcmp(a->port, b->port) == 0 &&
 4           strcmp(a->path, b->path) == 0;
 5}
 6
 7void urlCopy(URL *a, const URL *b) {
 8    strcpy(a->host, b->host);
 9    strcpy(a->port, b->port);
10    strcpy(a->path, b->path);
11}

实验总结

本次的Proxy实验可以看作是对I/O、网络编程和并发编程的一次综合运用。通过实现一个简单却具有重要实际应用价值的网络代理服务器帮助我们回顾了这三部分的基本原理和核心思想。我同时进一步认识到进程（线程）作为计算机系统最成功概念的意义。

在实验过程中，我进一步巩固了LRU算法，同时意识到只要程序涉及到线程的并发运行，就必须考虑到代码的健壮性，这对我今后的学习和实践都具有重要的价值。

运行《深入理解计算机系统》的代码

Mon, 15 Dec 2025 00:00:00 +0000

《深入理解计算机系统》（第三版）一书中提供了很多代码实例，但我一直没有运行过。现在就以第11章 P662 “echo客户端和服务端的示例”为例运行一下。

本次实验均在 WSL2 的 Ubuntu-22.04 系统上进行。

准备头文件

该书中的许多代码都包含了一个名为csapp.h的头文件。Linux系统本身并不包含它，需要自行准备。

下载源代码

点击此处进入本书配套的网站，找到You can download a tarfile字段，点击链接下载压缩文件。

配套网站

配置环境

接下来需要将下载的压缩包中csapp.h和csapp.c文件解压出来，放到系统的/usr/include文件夹中。

先进入csapp.h和csapp.c所在的文件夹，然后执行：

1sudo mv csapp.h /usr/include
2sudo mv csapp.c /usr/include

此时，应该能在/usr/include看到这两个文件。

编译并运行

源代码

echoserveri.c文件：

 1/* 
 2 * echoserveri.c - An iterative echo server 
 3 */ 
 4/* $begin echoserverimain */
 5#include "csapp.h"
 6
 7void echo(int connfd) 
 8{
 9    size_t n; 
10    char buf[MAXLINE]; 
11    rio_t rio;
12
13    Rio_readinitb(&rio, connfd);
14    while((n = Rio_readlineb(&rio, buf, MAXLINE)) != 0) { //line:netp:echo:eof
15        printf("server received %d bytes\n", n);
16        Rio_writen(connfd, buf, n);
17    }
18}
19
20int main(int argc, char **argv) 
21{
22    int listenfd, connfd, port, clientlen;
23    struct sockaddr_in clientaddr;
24    struct hostent *hp;
25    char *haddrp;
26    if (argc != 2) {
27        fprintf(stderr, "usage: %s <port>\n", argv[0]);
28        exit(0);
29    }
30    port = atoi(argv[1]);
31
32    listenfd = Open_listenfd(port);
33    while (1) {
34        clientlen = sizeof(clientaddr);
35        connfd = Accept(listenfd, (SA *)&clientaddr, &clientlen);
36
37        /* determine the domain name and IP address of the client */
38        hp = Gethostbyaddr((const char *)&clientaddr.sin_addr.s_addr, 
39                sizeof(clientaddr.sin_addr.s_addr), AF_INET);
40        haddrp = inet_ntoa(clientaddr.sin_addr);
41        printf("server connected to %s (%s)\n", hp->h_name, haddrp);
42
43        echo(connfd);
44        Close(connfd);
45    }
46    exit(0);
47}
48/* $end echoserverimain */

echoclient.c文件

 1/*
 2 * echoclient.c - An echo client
 3 */
 4/* $begin echoclientmain */
 5#include "csapp.h"
 6
 7int main(int argc, char **argv) 
 8{
 9    int clientfd, port;
10    char *host, buf[MAXLINE];
11    rio_t rio;
12
13    if (argc != 3) {
14        fprintf(stderr, "usage: %s <host> <port>\n", argv[0]);
15        exit(0);
16    }
17    host = argv[1];
18    port = atoi(argv[2]);
19
20    clientfd = Open_clientfd(host, port);
21    Rio_readinitb(&rio, clientfd);
22
23    while (Fgets(buf, MAXLINE, stdin) != NULL) {
24        Rio_writen(clientfd, buf, strlen(buf));
25        Rio_readlineb(&rio, buf, MAXLINE);
26        Fputs(buf, stdout);
27    }
28    Close(clientfd); //line:netp:echoclient:close
29    exit(0);
30}
31/* $end echoclientmain */

生成可执行文件

执行命令

1gcc echoserveri.c -o echoserveri
2gcc echoclient.c -o echoclient

得到可执行文件echoserveri和echoclient。

运行服务端和客户端

新建两个终端，分别运行echoserveri和echoclient文件。

服务端终端：

1# 服务端启动时输入端口号
2./echoserveri <port>

客户端终端：

1# 客户端启动时输入主机名和端口号
2./echoclient <host> <port>
3
4# 之后可以输入内容
5# 观察服务端终端的内容

运行结果

Malloc实验

Sun, 23 Nov 2025 00:00:00 +0000

感谢hankeke303大佬提供的思路！

实验目的

在这个实验中，我们将编写一个用于C程序的动态存储分配器，即实现malloc、free和realloc函数。鼓励以创造性的方式进行探索设计，并实现一个正确、高效和快速的分配器。

以下四个函数是需要实现的函数，它们在mm.h中声明并在mm.c中定义。

函数	简要作用
`mm_init()`	调用`mm_init`执行任何必要的初始化，例如分配初始堆区域。如果在执行初始化时出现问题，则返回值应为`-1`，否则为`0`。
`mm_malloc()`	`mm_malloc`例程返回一个指向至少大小为size字节的分配块有效负载的指针。
`mm_free()`	`mm_free`例程释放`ptr`指向的块。它不返回任何内容。只有当传递的指针（`ptr`）是由先前的`mm_malloc`或`mm_realloc`调用返回的，并且尚未被释放时，此例程才保证可工作。
`mm_realloc()`	`mm_realloc`例程返回一个指向至少大小为`size`字节的分配区域的指针。

测试程序通过计算性能指数 $P$ 来计算分配器的性能，该指数是空间利用率和吞吐量的加权和。
$$ P = wU + (1 − w) \cdot \mathrm{min} \left\{ 1, \ \frac{T}{T_{\mathrm{libc}}} \right\} $$
其中，$U$ 是空间利用率，$T$ 是吞吐量，$T_{\mathrm{libc}}$ 是在默认trace下 libc的malloc吞吐量，$w$ 的默认值为 $0.6$。

性能指标更倾向于空间利用率而不是吞吐量。

宏定义

大致和书上使用的宏定义相同，不过最后有几个和分离适配的链表相关，LIST_PRE和 LIST_NEXT表示这个块上存储上一块和下一块的位置的指针，LIST_HEAD表示第 $i$ 个大小类的头指针，GET_XXX是这三个宏定义的解引用版本。

操作空闲链表的基本常数和宏

 1/* $begin mallocmacros */
 2/* Basic constants and macros */
 3#define WSIZE       4       /* Word and header/footer size (bytes) */ //line:vm:mm:beginconst
 4#define DSIZE       8       /* Double word size (bytes) */
 5#define CHUNKSIZE  (1<<12)  /* Extend heap by this amount (bytes) */  //line:vm:mm:endconst 
 6 
 7#define MAX(x, y) ((x) > (y)? (x) : (y))  
 8 
 9/* Pack a size and allocated bit into a word */
10#define PACK(size, alloc)  ((size) | (alloc)) //line:vm:mm:pack
11 
12/* Read and write a word at address p */
13#define GET(p)       (*(unsigned int *)(p))            //line:vm:mm:get
14#define PUT(p, val)  (*(unsigned int *)(p) = (unsigned int)(val))    //line:vm:mm:put
15 
16/* Read the size and allocated fields from address p */
17#define GET_SIZE(p)  (GET(p) & ~0x7)                   //line:vm:mm:getsize
18#define GET_ALLOC(p) (GET(p) & 0x1)                    //line:vm:mm:getalloc
19
20/* Given block ptr bp, compute address of its header and footer */
21#define HDRP(bp)       ((char *)(bp) - WSIZE)                      //line:vm:mm:hdrp
22#define FTRP(bp)       ((char *)(bp) + GET_SIZE(HDRP(bp)) - DSIZE) //line:vm:mm:ftrp
23 
24/* Given block ptr bp, compute address of next and previous blocks */
25#define NEXT_BLKP(bp)  ((char *)(bp) + GET_SIZE(((char *)(bp) - WSIZE))) //line:vm:mm:nextblkp
26#define PREV_BLKP(bp)  ((char *)(bp) - GET_SIZE(((char *)(bp) - DSIZE))) //line:vm:mm:prevblkp
27 
28/* 分离适配链表相关 */
29#define LIST_PRE(bp) (bp)
30#define LIST_NEXT(bp) ((void *)((char *)bp + WSIZE))
31#define LIST_HEAD(x) ((void *)((char *)(heap) + WSIZE * (x)))
32#define GET_PRE(bp) ((void *)GET(LIST_PRE(bp)))
33#define GET_NEXT(bp) ((void *)GET(LIST_NEXT(bp)))
34#define GET_HEAD(x) ((void *)GET((char *)(heap) + WSIZE * (x)))
35/* $end mallocmacros */

需要注意的是，在这一段进行了如下的修改：

1- #define PUT(p, val)  (*(unsigned int *)(p) = (val))
2+ #define PUT(p, val)  (*(unsigned int *)(p) = (unsigned int)(val))

如果采用书上的方案，编译时将会出现warning: assignment to ‘unsigned int’ from ‘void *’ makes integer from pointer without a cast [-Wint-conversion]。这个警告是因为在 C 语言中，直接将void*指针赋值给unsigned int类型会导致类型不匹配。

如果不更改，编译时将会警告很多次（表现为报错数十行，虽然不影响运行结果）。

这样，我们可以写出一个确定大小类编号的函数：

1int getlist(size_t size) {
2    for (int i = 0; i < 19; ++i) {
3        if (size <= (1 << (i + 4))) {
4            return i;
5        }
6    }
7    return 19;
8}

函数实现

初始化

在书上 P600 提供了一个简易版本：

初始化空闲块

 1int mm_init(void)
 2{
 3    if ((heap = mem_sbrk(24 * WSIZE)) == (void*)-1) {
 4        return -1;
 5    }
 6
 7    // 申请 (20+4)*4 个字节的空间
 8    for (int i = 0; i < 20; ++i) {
 9        PUT(LIST_HEAD(i), NULL);
10    }
11
12    PUT(LIST_HEAD(20), 0);
13    PUT(LIST_HEAD(21), PACK(DSIZE, 1));
14    PUT(LIST_HEAD(22), PACK(DSIZE, 1));
15    PUT(LIST_HEAD(23), PACK(0, 1));
16 
17    // 将堆扩展`CHUNKSIZE`字节，并且创建初始的空闲块
18    if (extend_heap(CHUNKSIZE / WSIZE) == NULL) {
19        return -1;
20    }
21    return 0;
22}

其中，extend_heap函数用来将堆扩展CHUNKSIZE字节，并且创建初始的空闲块。此刻，分配器已初始化了，并且准备好接受来自应用的分配和释放请求。

extend_heap函数

 1void *extend_heap(size_t size) {
 2    size = ((size % 2) ? size + 1 : size) * WSIZE;
 3    void *bp = mem_sbrk(size);
 4    
 5    if (bp == (void *)-1) {
 6        return NULL;
 7    }
 8
 9    PUT(HDRP(bp), PACK(size, 0));
10    PUT(FTRP(bp), PACK(size, 0));
11    PUT(HDRP(NEXT_BLKP(bp)), PACK(0, 1));
12
13    return coalesce(bp);
14}

内存块管理

插入

这里，我们确保了每个大小块中，所有空闲块都是按照大小排序的，头指针指向的为最小的块，越向后大小越大。

因此，在插入的时候，我们要在链表中找到合适的位置才能插入。

 1// 链表插入
 2void ins(void *bp) {
 3    // 根据大小选择链表
 4    size_t size = GET_SIZE(HDRP(bp));
 5    int list = getlist(size);
 6    // 若链表为空
 7    if (GET_HEAD(list) == NULL) {
 8        // 直接作为链表第一个元素
 9        PUT(LIST_NEXT(bp), NULL);
10        PUT(LIST_HEAD(list), bp);
11        PUT(LIST_PRE(bp), NULL);
12    } 
13    else {
14        void *p, *q;
15        for (p = GET_HEAD(list), q = NULL; p; q = p, p = GET_NEXT(p)) {
16            if (GET_SIZE(HDRP(p)) >= size) {
17                if (q == NULL) {
18                    PUT(LIST_HEAD(list), bp);
19                }
20                else {
21                    PUT(LIST_NEXT(q), bp);
22                }
23                // 插入链表
24                PUT(LIST_NEXT(bp), p);
25                PUT(LIST_PRE(p), bp);
26                PUT(LIST_PRE(bp), q);
27                return;
28            }
29        }
30
31        // 当前块最大
32        if (q == NULL) {
33            PUT(LIST_HEAD(list), bp);
34        }
35        else {
36            PUT(LIST_NEXT(q), bp);
37        }
38        PUT(LIST_NEXT(bp), p);
39        if (p) {
40            PUT(LIST_PRE(p), bp);
41        }
42        PUT(LIST_PRE(bp), q);
43    }
44}

删除

删除部分就简单了，不需要区分是哪种适配，只需要修改原本的前驱、后继的相关指针即可。

 1// 链表删除
 2void del(void *bp) {
 3    // 根据块大小选择链表
 4    size_t size = GET_SIZE(HDRP(bp));
 5    int list = getlist(size);
 6    // 删除的就是头结点
 7    if (GET_PRE(bp) == NULL) {
 8        PUT(LIST_HEAD(list), GET_NEXT(bp));
 9    }
10    else {
11        // 前驱节点的 next 指向当前节点的后继
12        PUT(LIST_NEXT(GET_PRE(bp)), GET_NEXT(bp));
13    }
14    // 更新后继节点的前驱指针
15    if (GET_NEXT(bp)) {
16        // 后继的前驱指针指向删除结点的前驱
17        PUT(LIST_PRE(GET_NEXT(bp)), GET_PRE(bp));
18    }
19}

合并与切割

合并的过程是将连续的空闲块合成一个。因为我们采用了立即合并的思路，只要有新的空闲块诞生就立刻合并，保证了任意时刻空闲块都是不连续的。

具体的方法是判断新的空闲块的前一个块和后一个块是不是空闲的，将相邻的空闲块在原来的链表中删除，合并在一起，插入新的链表。

 1// 合并空闲块
 2void *coalesce(void *bp) {
 3    // fprintf(stderr, "coalesce %#p begin\n", bp);
 4    size_t pre_alloc = GET_ALLOC(FTRP(PREV_BLKP(bp)));
 5    size_t next_alloc = GET_ALLOC(HDRP(NEXT_BLKP(bp)));
 6    size_t size = GET_SIZE(HDRP(bp));
 7    // fprintf(stderr, "coalesce %#p middle   %d %d %lu\n", bp, prea, nexta, size);
 8    
 9    // 若需要合并，先删除原来的 bp 内存块，重新分配大小后再插入链表中
10
11    // 前后内存块均已分配
12    if (pre_alloc && next_alloc) ;
13    // 前面块已分配，后面块空闲
14    else if (pre_alloc && !next_alloc) {
15        del(NEXT_BLKP(bp));
16        size += GET_SIZE(HDRP(NEXT_BLKP(bp)));
17        PUT(HDRP(bp), PACK(size, 0));
18        PUT(FTRP(bp), PACK(size, 0));
19    } 
20    // 前面块空闲，后面块已分配
21    else if (!pre_alloc && next_alloc) {
22        del(PREV_BLKP(bp));
23        size += GET_SIZE(HDRP(PREV_BLKP(bp)));
24        bp = PREV_BLKP(bp);
25        PUT(HDRP(bp), PACK(size, 0));
26        PUT(FTRP(bp), PACK(size, 0));
27    } 
28    // 前后内存块均空闲
29    else if (!pre_alloc && !next_alloc) {
30        del(NEXT_BLKP(bp));
31        del(PREV_BLKP(bp));
32        size += GET_SIZE(HDRP(PREV_BLKP(bp))) + GET_SIZE(HDRP(NEXT_BLKP(bp)));
33        bp = PREV_BLKP(bp);
34        PUT(HDRP(bp), PACK(size, 0));
35        PUT(FTRP(bp), PACK(size, 0));
36    }
37
38    // 插入更新后的 bp 内存块
39    ins(bp);
40    // fprintf(stderr, "coalesce %#p end\n", bp);
41    return bp;
42}

切割就是在需要使用空闲块的时候，将一个空闲块切割成需要的已分配块，和新的空闲块。因为空闲块的大小至少为4，因此如果空闲块大小和需要分配的大小之差小于4，我们直接将整个空闲块分配掉，否则需要切割出来。

 1// 分割块
 2void place(void *bp, size_t size) {
 3    size_t bsize = GET_SIZE(HDRP(bp));
 4    del(bp);
 5    if (bsize - size >= 4 * WSIZE) {
 6        PUT(HDRP(bp), PACK(size, 1));
 7        PUT(FTRP(bp), PACK(size, 1));
 8        bp = NEXT_BLKP(bp);
 9        PUT(HDRP(bp), PACK(bsize - size, 0));
10        PUT(FTRP(bp), PACK(bsize - size, 0));
11        ins(bp);
12    } 
13    else {
14        PUT(HDRP(bp), PACK(bsize, 1));
15        PUT(FTRP(bp), PACK(bsize, 1));
16    }
17}

寻找空闲块

 1// 寻找空闲块
 2void *find_fit(size_t size) {
 3    for (int list = getlist(size);  list < 20; ++list) {
 4        for (void *bp = GET_HEAD(list); bp; bp = GET_NEXT(bp)) {
 5            // 找到第一个满足条件的块
 6            if (GET_SIZE(HDRP(bp)) >= size) {
 7                return bp;
 8            }
 9        }
10    }
11    return NULL;
12}

核心

动态内存分配的核心函数包括mm_malloc，mm_free和mm_realloc。

分配

mm_malloc函数

 1void *mm_malloc(size_t size)
 2{
 3    // 忽略异常请求
 4    if (size == 0) {
 5        return NULL;
 6    }
 7
 8    // 分配器必须调整请求块的大小，从而为头部和脚部留有空间，
 9    // 满足双字对齐的要求
10
11    if (size <= DSIZE) {
12        size = 2 * DSIZE;
13    }
14    else {
15        size = size + DSIZE;
16    }
17    size = (size + DSIZE - 1) / DSIZE * DSIZE;
18
19    // 寻找空闲块
20    void *bp = find_fit(size);
21    if (bp != NULL) {
22        place(bp, size);
23        return bp;
24    }
25
26    // 未找到空闲块，则分割新的内存空间
27    if ((bp = extend_heap(MAX(size, CHUNKSIZE) / WSIZE)) == NULL) {
28        return NULL;
29    }
30    place(bp, size);
31    return bp;
32}

释放

mm_free函数比较简单，将这个块的头部、脚部标记为空闲块，调用coalesce合并空闲块并插入链表即可。

mm_free函数

 1void mm_free(void *ptr)
 2{
 3    // 忽略异常请求
 4    if (ptr == NULL) {
 5        return;
 6    }
 7    size_t size = GET_SIZE(HDRP(ptr));
 8
 9    // 将这个块的头部、脚部标记为空闲块
10    PUT(HDRP(ptr), PACK(size, 0));
11    PUT(FTRP(ptr), PACK(size, 0));
12
13   // 释放后检查能否合并
14    coalesce(ptr);
15}

再分配

 1void *mm_realloc(void *ptr, size_t size)
 2{
 3    void *oldptr = ptr;
 4    void *newptr;
 5    size_t copySize;
 6    
 7    newptr = mm_malloc(size);
 8    if (newptr == NULL)
 9      return NULL;
10    copySize = GET_SIZE(HDRP(ptr));
11    if (size < copySize)
12      copySize = size;
13    memcpy(newptr, oldptr, copySize);
14    mm_free(oldptr);
15    return newptr;
16}

总结

本次的动态内存分配实验是对链表这种数据结构的一次具体应用，让我体会到链表和指针在执行内存管理任务时的巨大作用，同时我也感受到C语言因具有指针这种特殊数据类型而相较于其他高级语言展现出无可比拟的优势。

在实验中，我多次参考了书本上的案例，但同时也发现其代码存在的不健壮性。这提醒我在编写程序时应学会与时俱进，及时修改可能出现的漏洞和错误，才能保证程序在多种条件下依然能够正常运行。

NEMU-PART III

Tue, 11 Nov 2025 00:00:00 +0000

PA3：存储管理

实现高速缓存

经过实践，高速缓存的一级和二级结构最好同时实现，否则会在分页控制中出现难以预料的bug！

定义高速缓存结构

新建文件/nemu/include/memory/cache.h，填写以下内容：

宏定义缓存块：

 1#ifndef __CACHE_H__
 2#define __CACHE_H__
 3
 4#include "common.h"
 5
 6// 定义高速缓存参数
 7#define CACHE_E_L1 8
 8#define CACHE_E_L2 16
 9#define CACHE_BLOCK 64
10#define CACHE_SIZE_L1 64*1024
11#define CACHE_SIZE_L2 4*1024*1024
12
13...
14
15#endif

缓存块的结构体定义：

 1// 定义一级缓存
 2struct cache_l1 {
 3    bool valid;
 4    int tag;
 5    uint8_t byte[CACHE_BLOCK];
 6} cache_L1[CACHE_SIZE_L1 / CACHE_BLOCK];
 7
 8// 定义二级缓存
 9struct cache_l2 {
10    bool valid;
11    bool dirty;
12    int tag;
13    uint8_t byte[CACHE_BLOCK];
14} cache_L2[CACHE_SIZE_L2 / CACHE_BLOCK];
15
16// 定义高速缓存函数
17void init_cache();
18uint32_t cache_read_L1(hwaddr_t addr);
19uint32_t cache_read_L2(hwaddr_t addr);
20void cache_write_L1(hwaddr_t addr, size_t len, uint32_t data);
21void cache_write_L2(hwaddr_t addr, size_t len, uint32_t data);

高速缓存的读写函数

新建文件/nemu/src/memory/cache.c

缓存的初始化

 1void init_cache(){
 2    int i;
 3    for(i = 0; i < CACHE_SIZE_L1 / CACHE_BLOCK; i++) {
 4        cache_L1[i].valid = false;
 5        cache_L1[i].tag = 0;
 6        memset(cache_L1[i].byte, 0, CACHE_BLOCK);
 7    }
 8    for(i = 0; i < CACHE_SIZE_L2 / CACHE_BLOCK; i++) {
 9        cache_L2[i].dirty = false;
10        cache_L2[i].valid = false;
11        cache_L2[i].tag = 0;
12        memset(cache_L2[i].byte, 0, CACHE_BLOCK);
13    }
14}

读取缓存块中的内容

 1uint32_t cache_read_L1(hwaddr_t addr) {
 2    // 取出地址中set的部分（右移block位并 & 1111111）
 3    // set = 7 byte (set = 2^s = 128)
 4    // offset = 6 byte (block = 2^e = 64)
 5    uint32_t set = (addr >> 6) & 0x7f; 
 6    bool hit = false;
 7    int i;
 8    // 一级缓存中找到相应set
 9    for(i = set * CACHE_E_L1; i < (set + 1) * CACHE_E_L1; i++) { 
10        if(cache_L1[i].tag == (addr >> 13) && cache_L1[i].valid) { // 如果tag和地址相符合并且valid == true
11            hit = true; 
12            return i;
13        }
14    }
15     
16    // 一级缓存中找空内存块
17    for(i = set * CACHE_E_L1; i < (set + 1) * CACHE_E_L1; i++) {
18        // 找到空的地方退出
19        if (!cache_L1[i].valid) {
20            break; 
21        }  
22    }
23    // 到最后仍然没有找到空的地方，执行随机替换算法
24    if(i == (set + 1) * CACHE_E_L1) { 
25        srand(0);
26        i = set * CACHE_E_L1 + rand() % CACHE_E_L1;
27    }
28    cache_L1[i].valid = true;
29    cache_L1[i].tag = addr >> 13;
30    int j = cache_read_L2(addr);;
31    memcpy(cache_L1[i].byte, cache_L2[j].byte, CACHE_BLOCK);
32    
33    return i;
34}
35
36uint32_t cache_read_L2(hwaddr_t addr){
37    uint32_t s = (addr >> 6) & ((1 << 12) - 1);
38    uint32_t block = (addr >> 6) << 6;
39    int i;
40    bool hit = false;
41    for (i = s * CACHE_E_L2; i < (s + 1) * CACHE_E_L2; i++) {
42        if (cache_L2[i].tag == (addr >> 18) && cache_L2[i].valid) {
43            hit = true;
44            break;
45        }
46    }
47    if (!hit) {
48        int j;
49        for (i = s * CACHE_E_L2; i < (s + 1) * CACHE_E_L2; i++) {
50            if (!cache_L2[i].valid)
51                break;
52        }
53        if (i == (s + 1) * CACHE_E_L2) {
54            srand(0);
55            i = s * CACHE_E_L2 + rand() % CACHE_E_L2;
56            if (cache_L2[i].dirty) {
57                uint8_t mask[BURST_LEN * 2];
58                memset(mask, 1, BURST_LEN * 2);
59                for (j = 0; j < CACHE_BLOCK / BURST_LEN; j++) {
60                    call_ddr3_write(block + j * BURST_LEN, cache_L2[i].byte + j * BURST_LEN, mask);
61                }	
62            }
63        }
64        cache_L2[i].valid = true;
65        cache_L2[i].tag = addr >> 18;
66        cache_L2[i].dirty = false;
67        for (j = 0; j < BURST_LEN; j++){
68            call_ddr3_read(block + j * BURST_LEN, cache_L2[i].byte + j * BURST_LEN);
69        }
70    }
71    return i;
72}

数据写入缓存块

 1void cache_write_L1(hwaddr_t addr, size_t len, uint32_t data) {
 2    uint32_t set = (addr >> 6) & 0x7f;
 3    uint32_t offset = addr & (CACHE_BLOCK - 1); 
 4    int i;
 5    bool hit = false;
 6    for (i = set * CACHE_E_L1; i < (set + 1) * CACHE_E_L1; i++) {
 7        if (cache_L1[i].tag == (addr >> 13) && cache_L1[i].valid) {
 8            hit = true;
 9            break;
10        }
11    }
12    // 写直通
13    if (hit) { 
14        memcpy(cache_L1[i].byte + offset, &data, len);
15    }
16    cache_write_L2(addr, len, data);
17}
18
19void cache_write_L2(swaddr_t addr, size_t len, uint32_t data) {
20    uint32_t set = (addr >> 6) & ((1 << 12) - 1); 
21    uint32_t offset = addr & 0x3f;	
22    int i;
23    bool hit = false;
24    for (i = set * CACHE_E_L2; i < (set + 1) * CACHE_E_L2; i++) {
25        if (cache_L2[i].tag == (addr >> 13) && cache_L2[i].valid) {
26            hit = true;
27            break;
28        }
29    }
30    if (!hit){
31        i = cache_read_L2(addr);
32    }
33    cache_L2[i].dirty = true;
34    memcpy(cache_L2[i].byte + offset, &data, len);
35}

修改内存读写逻辑

在/nemu/src/memory/memory.c中，修改hwaddr_read和hwaddr_write两个函数：

 1uint32_t hwaddr_read(hwaddr_t addr, size_t len) {
 2    uint32_t offset = addr & (CACHE_BLOCK - 1);
 3    uint32_t block = cache_read_L1(addr);
 4    uint8_t temp[4];
 5    memset(temp, 0, sizeof(temp));
 6    if (offset + len >= CACHE_BLOCK) {
 7        uint32_t second_block = cache_read_L1(addr + len);
 8        memcpy(temp, cache[block].byte + offset, CACHE_BLOCK - offset);
 9        memcpy(temp + CACHE_BLOCK - offset, cache[second_block].byte, len - (CACHE_BLOCK - offset));
10    } else {
11        memcpy(temp, cache[block].byte + offset, len);
12    }
13    int zero = 0;
14    uint32_t result = unalign_rw(temp + zero, 4) & (~0u >> ((4 - len) << 3));
15    return result;
16}
17
18void hwaddr_write(hwaddr_t addr, size_t len, uint32_t data) {
19    cache_write_L1(addr, len, data);
20}

实现分段机制

修改kernel

首先需要在kernel中加入切换到保护模式的代码：在kernel/include/common.h中定义宏IA32_SEG，然后重新编译kernel。

1- //#define IA32_SEG
2+ #define IA32_SEG

这一步必须完成！如果你是CV大佬，很容易漏掉这个步骤！

定义段寄存器

在CPU_state结构中添加GDTR，CR0和各种段寄存器，包括CS, DS, ES, SS, 其具体结构参考i386手册。

在libcommon/x86-inc目录下的头文件中定义了一些和x86相关的宏和结构体，你可以在NEMU中包含这些头文件来使用它们。

 1// 段寄存器
 2enum {R_ES, R_CS, R_SS, R_DS};
 3
 4// 定义段寄存器结构体
 5typedef struct {
 6    uint16_t selector;
 7    uint16_t attribute;
 8    uint32_t limit;
 9    uint32_t base;
10} Segment_Reg;
11
12...
13
14typedef struct {
15    ...
16
17    // GDTR寄存器
18    struct GDTR {
19        uint32_t base;
20        uint16_t limit;
21    } gdtr;
22
23    // CR0和CR3寄存器由 /lib-common/x86-inc/cpu.h 定义
24    CR0 cr0;
25    CR3 cr3;
26
27    // 设置段寄存器
28    union {
29        struct {
30            Segment_Reg sreg[4];	
31        };
32        struct {
33            Segment_Reg es, cs, ss, ds;
34        };
35    };
36
37} CPU_state;

完善指令集

添加lgdt指令。
添加opcode为0F 20和0F 22的mov指令，使得我们可以设置/读出CR0。
添加opcode为8E的mov指令，使得我们可以设置段寄存器。
为了设置CS寄存器, 你需要实现ljmp指令

实现段寄存器的捆绑规则

在Operand结构体中添加成员sreg，位置：/nemu/include/cpu/decode/operand.h

 1typedef struct {
 2    uint32_t type;
 3    size_t size;
 4    union {
 5        uint32_t reg;
 6-       swaddr_t addr;
 7+		struct {
 8+			swaddr_t addr;
 9+			uint8_t sreg;
10+		};
11        uint32_t imm;
12        int32_t simm;
13    };
14    uint32_t val;
15    char str[OP_STR_SIZE];
16} Operand;

修改所有调用swaddr_read()和swaddr_write()的代码，为它们添加段寄存器的参数。具体要求如下：

指令	实现要求
`opcode`为`A0`, `A1`, `A2`, `A3` 的`mov`指令	使用`DS`寄存器
一些堆栈操作指令	隐式使用`SS`寄存器
`instr_fetch()`	总是使用`CS`寄存器
`monitor`中，`x`和`p`命令读出内存时	使用`DS`寄存器
`bt`命令打印栈帧链	使用`SS`寄存器
字符串操作指令使用的段寄存器	请查阅 i386 手册

修改内存读写函数

设置CR0后，如果发现CR0的PE位为 1，则进入IA-32保护模式，从此所有虚拟地址的访问（包括swaddr_read()和 swaddr_write()）都需要经过段级地址转换。

为了实现段级地址转换，需要对/nemu/src/memory/memory.c中的swaddr_read()和swaddr_write()函数作少量修改：

1uint32_t swaddr_read(swaddr_t addr, size_t len) {
2#ifdef DEBUG
3    assert(len == 1 || len == 2 || len == 4);
4#endif
5    lnaddr_t lnaddr = seg_translate(addr, len, current_sreg);
6    return lnaddr_read(lnaddr, len);
7}
8
9// swaddr_write()函数采取类似操作

其中sreg记录了当前段级地址转换所用到的段寄存器的编码。关于段寄存器的编码，请查阅i386手册。

然后实现seg_translate()函数。再次提醒，在 NEMU 中，只有进入保护模式之后才会进行段级地址转换。

1lnaddr_t seg_translate(swaddr_t addr, size_t len, uint8_t sreg_id) {
2    if (cpu.cr0.protect_enable == 0) {
3        return addr;
4    }
5    else {
6        return cpu.sreg[sreg_id].base + addr;
7    }
8}

实现分页机制

思考题

GDT能有多大

段选择符的结构中，INDEX有13位，故GDT最大能容纳2^13个段描述符

为什么是线性地址？

不可以。虚拟地址需要经GDT中的段表翻译才能得出地址，而如果GDTR中存放虚拟地址则找不到GDT在哪里了。

如何提高寻找段描述符的效率

可以按照高速缓存的思想，建立类似cache 和 TLB 的结构来提高寻找效率。

段式存储管理的缺点

分段管理要求分配一大段连续的存储空间，难以实现并且容易造成大量的外部碎片出现。

页式存储管理的优点

没有外部碎片，并且不再需要大段连续的存储空间，提高了内存的利用率。

一些问题

Q：为什么页表表项中的基地址信息只有20位而不是32位

A：分页基地址有20位是8086的传统，在8086的分段机制中，每个段的基地址由seg_reg（即段寄存器的值）«4得到，而段寄存器是16位的，左移4位得到20位的基地址。

Q：表项和CR3中的基地址都是物理地址，这是必须的吗？能否采用虚拟地址或者线性地址？

A：是必须的，如果cr3中的基地址是虚拟地址，则无从寻找页表翻译成物理地址，进入鸡生蛋蛋生鸡的死循环。至于其他表项的虚拟地址与线性地址问题同理。

Q：为什么不采用一级页表？采用一级页表会有什么缺点？

A：多级页表可以有效地节约内存空间，如果仅采用一级页表，将可能导致较大的页表长期驻留在内存中。

空指针是“空”的吗？

空指针只是未分配或者未指向内存任何位置的指针，并不是“NULL”的。

在扁平模式下如何进行保护

对于数据有不同的访问权限，未达到需要的权限时不能进行写操作

地址映射
分页机制

因为这里定义的ｘ生成的地址是虚拟地址，超过了物理地址的界限，报错0xc014a000 outside of the physical memory。而kvm.c中的虚拟地址都经过了va_to_pa的转换，在物理地址范围之内。

进行反汇编后，其地址如下：

c01003d6: e8 65 09 00 00 call c0100d40

该call指令的opcode为e8，实现的是跳转到：该条指令的下一条指令的首地址+偏移量的位置。由于未进行寻址，故不需要进行虚实地址转化。

分页的环境下，在没有初始化页表时，0～128M的虚拟地址到物理地址的映射相当于一个简易的页表，使得高位的地址可以通过该虚拟地址（即经过va_to_pa）访问到物理地址，从而进行初始化页表的操作。

init_mm()函数执行退出时。该函数将nemu映射到了高位地址并且将之前的PDE全部置为无效，此时返回main.c时，栈中保存的返回地址需要经过虚实转换，可由于页面被置为了无效，所以报错。查看汇编代码，直接调用此函数时，nemu运行在物理地址上，由于在init_mm中将之前的PDE都置为无效，所以在loader()函数寻址时页面无效，导致报错。

Shell实验

Sun, 19 Oct 2025 00:00:00 +0000

感谢之一Yo大佬提供的思路！

实验目的

更加熟悉进程控制和信号的概念。你将通过编写一个简单的Unix shell程序来实现这一目标，实现对作业的控制。

Shell介绍

详细介绍（太长不看）

Shell是一个交互式命令行解释器，代表用户运行程序。Shell重复地打印提示符，等待stdin上输入的命令行，然后根据命令行的内容执行一些操作。

命令行是一系列由空白分隔的ASCII文本单词。命令行中的第一个单词要么是内置命令的名称，要么是可执行文件的路径名。其余的单词是命令行参数。如果第一个单词是内置命令，Shell立即在当前进程中执行该命令。否则，该单词被假定为可执行程序的路径名。在这种情况下，Shell创建一个子进程，然后在子进程的上下文中加载并运行程序。作为解释单个命令行的结果创建的子进程总称为作业。一般来说，一个作业可以由通过Unix管道连接的多个子进程组成。

如果命令行以一个 “&” 结尾，那么作业在后台运行，这意味着Shell在打印提示并等待下一个命令行之前不等待作业终止。否则，作业在前台运行，这意味着Shell等待作业终止后才等待下一个命令行。因此，在任何时候，最多只能有一个作业在前台运行。但是，任意数量的作业可以在后台运行。

本篇博客将会详细介绍 CSAPP 的 ShellLab 完成过程，实现一个简易（lou）的 shell。tsh 拥有以下功能：

可以执行外部程序
支持四个内建命令，名称和功能为：

名称	功能
`quit`	退出终端
`jobs`	列出所有后台作业
`bg <job>`	继续在后台运行一个处于停止状态的后台作业，`<job>` 可以是 `PID` 或者 `%JID` 形式
`fg <job>`	将一个处于运行或者停止状态的后台作业转移到前台继续运行
按下 `Ctrl` + `C`	终止前台作业
按下 `Ctrl` + `Z`	停止前台作业

实验材料中已经写好了一些函数，只要求我们实现下列核心函数：

名称	功能
`eval`	解析并执行指令
`builtin_cmd`	识别并执行内建指令
`do_bgfg`	执行 `fg` 和 `bg` 指令
`waitfg`	阻塞终端直至前台任务完成
`sigchld_handler`	捕获 `SIGCHLD` 信号
`sigint_handler`	捕获 `SIGINT` 信号
`sigtstp_handler`	捕获 `SIGTSTP` 信号

函数实现

`eval`函数

在《深入理解计算机系统》第525页给出了eval函数的核心代码：

eval函数

但是在 Shell 实验中，还应当满足以下要求：

父进程在fork子进程之前必须使用sigprocmask阻塞SIGCHLD信号，然后在通过调用addjob将子进程添加到作业列表后，再次使用sigprocmask解除对这些信号的阻塞。
由于子进程继承了其父进程的阻塞向量，子进程必须确保在执行新程序之前解除对SIGCHLD信号的阻塞。父进程需要以这种方式阻塞SIGCHLD信号，以避免在父进程调用addjob之前，子进程被sigchld_handler收回（因此从作业列表中删除）的竞争条件。
在fork之后但在execve之前，子进程应调用setpgid(0, 0)，将子进程放入一个新的进程组，其组ID与子进程的PID相同。这确保在前台进程组中只有一个进程，即shell。

setpgid函数将进程pid的进程组改为pgid。如果pid是 0, 那么就使用当前进程的PID。如果pgid是 0，那么就用pid指定的进程的PID作为进程组 ID。

例如，如果进程 15213 是调用进程，那么setpgid(0, 0)会创建一个新的进程组，其进程组 ID 是 15213，并且把进程 15213 加人到这个新的进程组中。

 1void eval(char *cmdline) 
 2{
 3    char* argv[MAXARGS];    // 命令参数
 4    char buf[MAXLINE];      // 保存命令行
 5    int bg;                 // 判断 job 运行在 bg 还是 fg
 6    pid_t pid;
 7
 8    sigset_t mask_all, mask_one, prev_mask;
 9    sigfillset(&mask_all);
10    sigemptyset(&mask_one);
11    sigaddset(&mask_one, SIGCHLD);
12
13    strcpy(buf, cmdline);
14    bg = parseline(cmdline, argv);
15
16    // 忽略空指令
17    if (argv[0] == NULL)
18        return;
19
20    if (!builtin_cmd(argv)) {
21        // 创建子进程前阻塞SIGCHLD信号
22        sigprocmask(SIG_BLOCK, &mask_one, &prev_mask);
23        if ((pid = Fork()) == 0) {
24            // 子进程必须确保在执行新程序之前解除对SIGCHLD信号的阻塞
25            sigprocmask(SIG_SETMASK, &prev_mask, NULL);
26            // 将子进程放入一个新的进程组
27            setpgid(0, 0);
28            if (execve(argv[0], argv, environ) < 0) {
29                printf("%s: Command not found.\n", argv[0]);
30                exit(0);
31            }
32        }
33
34        /*
35          父进程需要阻塞SIGCHLD信号，以避免在父进程调用addjob之前，
36          子进程被sigchld_handler收回
37        */
38        sigprocmask(SIG_BLOCK, &mask_one, NULL);
39        // 将子进程添加到作业列表
40        addjob(jobs, pid, bg ? BG : FG, cmdline);
41        
42
43        if (!bg) {
44            waitfg(pid);
45        } else {
46            printf("[%d] (%d) %s", pid2jid(pid), pid, cmdline);
47        }
48
49        // 再次使用sigprocmask解除对这些信号的阻塞
50        sigprocmask(SIG_SETMASK, &prev_mask, NULL);
51    }
52    
53    return;
54}

其中Fork()函数定义可以在《深入理解计算机系统》第512页找到：

Fork函数

`builtin_cmd`函数

在《深入理解计算机系统》第525页同样给出了builtin_cmd函数的核心代码：

builtin_cmd函数

Shell 程序要实现的builtin_cmd比这个要多一些分支语句，主要用来判断quit、jobs、bg和fg命令。

 1int builtin_cmd(char **argv) 
 2{
 3    // 识别和解释内置命令：quit、fg、bg和jobs
 4    // 指令 tsh > quit 
 5    if(!strcmp(argv[0], "quit")) {
 6        exit(0);
 7    }
 8    // 指令 tsh > fg 和 tsh > bg
 9    else if(!strcmp(argv[0], "fg") || !strcmp(argv[0], "bg")) {
10        do_bgfg(argv);
11        return 1;
12    }
13    // 指令 tsh > jobs
14    else if(!strcmp(argv[0], "jobs")) {
15        listjobs(jobs);
16        return 1;
17    }
18    else if(!strcmp(argv[0], "&")) {
19        return 1;
20    }
21    
22    return 0;     /* not a builtin command */
23}

`waitfg`函数

阻塞终端直至前台任务完成意味着主程序需要显式地等待某个信号处理程序运行，一种合适的解决方法是使用sigsuspend函数。

 1void waitfg(pid_t pid)
 2{
 3   // 等待前台作业完成
 4    sigset_t mask;
 5    sigemptyset(&mask);
 6
 7    // sigsuspend函数提高执行效率
 8    while(fgpid(jobs)) {
 9        sigsuspend(&mask);
10    }
11    return;
12}

还有一种思路是使用sleep函数。
1while(!pid) {
2    sleep(1);
3}
当这段代码正确执行时，它太慢了。如果在while之后pause之前收到信号，程序必须等相当长的一段时间才会再次检查循环的终止条件。使用像 nanosleep这样更髙精度的休眠函数也是不可接受的，因为没有很好的方法来确定休眠的间隔。间隔太小，循环会太浪费；间隔太大，程序又会太慢。

`do_bgfg`函数

在builtin_cmd中最重要的就是do_bgfg函数，负责作业的状态转换。

首先获取任务的PID，若为空则报错；否则发送SIGCONT信号给进程组中的每一个进程。

为了做到将SIGCONT信号发送给进程组中的每一个进程，需要将kill函数的pid参数取负值，不然就只发给指定的进程了。具体可参见kill函数在《深入理解计算机系统》第530页的定义：

kill函数的定义位于《深入理解计算机系统》第530页：

kill函数

 1void do_bgfg(char **argv) 
 2{
 3    char* cmd = argv[0];
 4    char* id = argv[1];
 5    struct job_t* job;
 6
 7    if (id == NULL) {
 8        printf("%s command requires PID or %%jobid argument\n", cmd);
 9        return;
10    }
11
12    // 根据 jid/pid 获取作业
13    if (id[0] == '%') {
14        if ((job = getjobjid(jobs, atoi(id + 1))) == NULL) {
15            printf("%s: No such job\n", id);
16            return;
17        }
18    } 
19    else if (atoi(id) > 0) {
20        if ((job = getjobpid(jobs, atoi(id))) == NULL) {
21            printf("(%d): No such process\n", atoi(id));
22            return;
23        }
24    } 
25    else {
26        printf("%s: argument must be a PID or %%jobid\n", cmd);
27        return;
28    }
29
30    // 状态转移
31    if (!strcmp(cmd, "fg")) {
32        job->state = FG;
33        kill(-job->pid, SIGCONT);
34        waitfg(job->pid);
35    } 
36    else if (!strcmp(cmd, "bg")) {
37        job->state = BG;
38        kill(-job->pid, SIGCONT);
39        printf("[%d] (%d) %s", job->jid, job->pid, job->cmdline);
40    }
41    return;
42}

信号处理

sigchld_handler函数

 1void sigchld_handler(int sig) 
 2{
 3    int old_errno = errno;
 4    pid_t pid;
 5    int status;
 6    sigset_t mask_all, prev_mask;
 7    sigfillset(&mask_all);
 8
 9    while ((pid = waitpid(-1, &status, WNOHANG | WUNTRACED)) > 0) {
10        // 终止作业
11        if (WIFEXITED(status) || WIFSIGNALED(status)) {
12            sigprocmask(SIG_BLOCK, &mask_all, &prev_mask);
13
14            // ctrl-c 终止
15            if (WIFSIGNALED(status)) {
16                printf("Job [%d] (%d) terminated by signal 2\n", pid2jid(pid), pid);
17            }
18
19            deletejob(jobs, pid);
20            sigprocmask(SIG_SETMASK, &prev_mask, NULL);
21        }
22        // 停止作业
23        else if (WIFSTOPPED(status)) {
24            sigprocmask(SIG_BLOCK, &mask_all, &prev_mask);
25
26            struct job_t* job = getjobpid(jobs, pid);
27            job->state = ST;
28            printf("Job [%d] (%d) stopped by signal 20\n", job->jid, job->pid);
29
30            sigprocmask(SIG_SETMASK, &prev_mask, NULL);
31        }
32    }
33
34    errno = old_errno;
35    return;
36}

处理Ctrl + C

 1void sigint_handler(int sig) 
 2{
 3    // 获取SIGINT（ctrl-c）信号
 4    int olderrno = errno;
 5
 6    // 获取当前正在前台的任务的PID
 7    pid_t pid = fgpid(jobs);
 8    // 判断任务是否存在
 9    if(pid > 0) {
10        // -pid表示进程组 |pid| 的所有进程
11        kill(-pid, SIGKILL);
12    }
13    errno = olderrno;
14    return;
15}

处理Ctrl + Z
同理可得：

 1void sigtstp_handler(int sig) 
 2{
 3     // 获取SIGTSTP（ctrl-z）信号
 4    int olderrno = errno;
 5
 6    pid_t pid = fgpid(jobs);
 7    if(pid > 0) {
 8        kill(-pid, SIGTSTP);
 9    }
10    errno = olderrno;
11    return;
12}

总结

通过这次实验，我加深了对进程控制和信号处理的理解，同时对于并发现象有了更直观的认识。即使是一个简易的Shell程序，也需要考虑任务的排队、信号阻塞等问题，要在心中有整体设计观念。同时在完成实验的过程中我大量参考了书本内容，也提醒我在今后的学习和实验中要注重书本的工具作用。

另外，在评测平台测试时，第一次测试时由于在Command not found后多加了一个句点而导致判错。这启示我在编程时应当小心谨慎，认真阅读要求，并且仔细检查，方能提高正确率和效率。

NEMU-PART II

Wed, 17 Sep 2025 00:00:00 +0000

PA2：指令系统

实验目的：

掌握i386（IA-32）指令格式。
掌握NEMU平台的指令周期。

运行用户程序

任务：编写几条指令的helper函数, 使得第一个简单的C程序可以在NEMU中运行起来。

流程：

make run运行NEMU。
按c执行程序。
查看报错信息，观察出现未知指令的内存地址和对应操作码。
编写对应的指令文件xxx-template.h，xxx.h，xxx.c。
在all-instr.h中添加对应的头文件。
在exec.c中对应位置添加操作名称。

添加call指令

查找call指令对应的Opcode等信息，可知操作码为e8。

call指令

编写call-template.h

 1#include "cpu/exec/template-start.h"
 2
 3#define instr call
 4
 5// call + 相对偏移量（视为一个立即数）
 6make_helper(concat(call_i_, SUFFIX)) {
 7    // 解码偏移量（立即数）
 8    int len = concat(decode_i_, SUFFIX)(cpu.eip + 1); 
 9    // 压栈操作 (push)
10    reg_l(R_ESP) -= DATA_BYTE; 
11    // eip寄存器的下一位地址写入esp (mov)
12    MEM_W(reg_l(R_ESP), cpu.eip + len + 1); 
13    // 加上立即数偏移量，实现跳转
14    cpu.eip += (DATA_TYPE_S)op_src->val; 
15    // 更新eip寄存器
16    print_asm("call: 0x%x", cpu.eip + len + 1); 
17    return len + 1;
18}
19
20// call + 寄存器
21make_helper(concat(call_rm_, SUFFIX)) {
22    // 解码寄存器/内存
23    int len = concat(decode_rm_, SUFFIX)(eip + 1);
24    reg_l(R_ESP) -= DATA_BYTE;
25    MEM_W(reg_l(R_ESP), cpu.eip + len + 1);
26    cpu.eip = (DATA_TYPE_S)op_src->val - len - 1;
27    print_asm("call: %s", op_src->str);
28    return len + 1;
29}
30
31#include "cpu/exec/template-end.h"

call指令示意

编写call.c

 1#include "cpu/exec/helper.h"
 2
 3#define DATA_BYTE 1
 4#include "call-template.h"
 5#undef DATA_BYTE
 6
 7#define DATA_BYTE 2
 8#include "call-template.h"
 9#undef DATA_BYTE
10
11#define DATA_BYTE 4
12#include "call-template.h"
13#undef DATA_BYTE
14
15make_helper_v(call_i)
16make_helper_v(call_rm)

编写call.h

1#ifndef __CALL_H__
2#define __CALL_H__
3
4make_helper(call_i_v);
5make_helper(call_rm_v);
6
7#endif

在nemu/src/cpu/exec/all-instr.h中包含call.h，并在nemu/src/cpu/exec/exec.c中的opcode_table中填写相应的helper函数。

添加test指令

test指令

test指令其实相当于进行AND按位与操作，但是test是不会改变操作数的，只会改变EFLAGS寄存器中的标志位。

标志位	名称	功能
CF	进位标志	如果运算的结果最高位产生了进位或借位，其值为1，否则为0。
PF	奇偶标志	计算运算结果里1的奇偶性，偶数为1，否则为0。
ZF	零标志	相关指令结束后判断是否为0，结果为0，其值为1，否则为0。
SF	符号标志	相关指令结束后判断正负，结果为负，其值为1，否则为0。
I	中断使能标志	表示能否响应外部中断，若能响应外部中断，其值为1，否则为0。
DF	方向标志	当DF为1，ESI、EDI自动递减，否则自动递增。
OF	溢出标志	反映有符号数运算结果是否溢出，如果溢出，其值为1，否则为0。

编写test-template.h

 1#include "cpu/exec/template-start.h"
 2
 3#define instr test
 4
 5static void do_execute() {
 6    // 两个操作数进行与运算
 7    DATA_TYPE result = op_dest->val & op_src->val;
 8
 9    cpu.eflags.CF = 0;
10    cpu.eflags.OF = 0;
11
12    // 在/nemu/src/cpu/eflags.c中定义的函数
13    // 可根据结果自动修改eflags寄存器的值
14    update_eflags_pf_zf_sf((DATA_TYPE_S)result);
15    print_asm_template1();
16}
17make_instr_helper(i2a)
18make_instr_helper(i2rm)
19make_instr_helper(r2rm)
20
21#include "cpu/exec/template-end.h"

程序中经常使用一些缩写，并已成为约定俗成的惯例。

例如，为了方便理解，通常把to用2代替。因此i2rm表示立即数传到寄存器/内存中，r2rm表示寄存器传到寄存器/内存中。

i18n与此类似，是internationalization的缩写，表示“国际化”。

编写test.c

 1#include "cpu/exec/helper.h"
 2
 3#define DATA_BYTE 1
 4#include "test-template.h"
 5#undef DATA_BYTE
 6
 7#define DATA_BYTE 2
 8#include "test-template.h"
 9#undef DATA_BYTE
10
11#define DATA_BYTE 4
12#include "test-template.h"
13#undef DATA_BYTE
14
15make_helper_v(test_i2a)
16make_helper_v(test_i2rm)
17make_helper_v(test_r2rm)

编写test.h

 1#ifndef _TEST_H_
 2#define _TEST_H_
 3
 4make_helper(test_i2a_b);
 5make_helper(test_i2rm_b);
 6make_helper(test_r2rm_b);
 7
 8make_helper(test_i2a_v);
 9make_helper(test_i2rm_v);
10make_helper(test_r2rm_v);
11
12#endif

添加je指令

je指令

添加je指令有两种方法，一种是参考普通指令的执行方式，用static void do_execute创建函数并使用make_instr_helper()；另一种是直接定义一个新的make_jcc_helper()宏。这里采用后者，因为这样所有条件跳转如jne，jg，jge等都可以用make_jcc_helper()的宏实现。

 1#include "cpu/exec/template-start.h"
 2 
 3// 条件跳转指令译码过程复杂，make_instr_helper无法使用，需要重新定义
 4#define make_jcc_helper(cc) \
 5    make_helper(concat4(j, cc, _, SUFFIX)) { \
 6        int len = concat(decode_si_, SUFFIX)(eip + 1); \
 7        print_asm(str(concat(j,cc)) " %x",cpu.eip+op_src->val+1+len+(DATA_BYTE == 4)); \
 8        if (concat(check_cc_, cc)()) { \
 9            cpu.eip += op_src->val; \
10        } \
11        return len + 1; \
12    }
13
14#include "cpu/exec/template-end.h"

在include/cpu/eflags.h中定义比较函数：

1static inline bool check_cc_e() {
2    return cpu.eflags.ZF == 1;
3}

这样在调用make_je_helper时就会使用check_cc_e函数判断是否更新eflags寄存器的值。

添加其他指令

push指令

push指令

操作流程：
① esp寄存器值减4，表示栈顶指针下移一个地址的长度。
② 将读入的数据写入地址中，表示数据入栈。

cmp指令

cmp指令

操作流程：
① 记录源操作数-目标操作数的值。
② 用所得的值更新eflags寄存器。

pop指令

pop指令

操作流程：
① 向译码出的对象操作数中写入栈顶数据。
② 栈顶指针加4，回到push前的状态。

ret指令

ret指令

操作流程：
① 使eip跳转到esp中存放的地址处。
② 栈顶指针加4。

实现更多指令

jbe指令

在jcc-template.h指令中添加be字段，并在eflags.h中补充check_cc_be函数。

leave指令

leave指令

操作流程：
① 使esp指向ebp（栈底）所指的位置。
② ebp指向esp所存的地址。
③ 栈顶指针加4。

add指令

实现浮点数定点化

什么是定点化

我们约定最高位为符号位，接下来的15位表示整数部分，低16位表示小数部分，即约定小数点在第15和第16位之间（从第0位开始）。从这个约定可以看到，FLOAT类型其实是实数的一种定点表示。

更通俗的解释是：定点化数的小数点位置是固定的；或者说，定点化数的小数位数是确定的。

定点数

由这个定义，可以得出以下结论：

对于一个实数a，它的FLOAT类型表示A = a * 2^16 = a << 16。

定点数的运算

在lib-common/FLOAT.h中定义定点数与整型的基本运算：

 1static inline int F2int(FLOAT a) {
 2	// 将定点数转换为整型
 3	return (a >> 16);
 4}
 5
 6static inline FLOAT int2F(int a) {
 7	// 将整型转换为定点数
 8	return (a << 16);
 9}
10
11static inline FLOAT F_mul_int(FLOAT a, int b) {
12	// 定点数与整型相乘
13	return a * b;
14}
15
16static inline FLOAT F_div_int(FLOAT a, int b) {
17	// 定点数与整型相除
18	return a / b;
19}

在lib-common/FLOAT/FLOAT.c中定义浮点数到定点数的转化和定点数的运算：

定义浮点数结构

1// 接收IEEE编码的浮点数
2typedef union {
3	struct {
4		uint32_t m : 23;	// 尾数位
5		uint32_t e : 8;		// 指数位
6		uint32_t s : 1;		// 符号位
7	};
8	uint32_t val;
9} Float;

将浮点数转化为定点数

回忆浮点数的计算公式：对于一段32位长的浮点数编码，它对应的浮点数值为：$V = (-1)^s \times M \times 2^E$

其中 $E = 1 - bias$，$M = 1 + f$

 1FLOAT f2F(float a) {
 2	/* You should figure out how to convert `a' into FLOAT without
 3	 * introducing x87 floating point instructions. Else you can
 4	 * not run this code in NEMU before implementing x87 floating
 5	 * point instructions, which is contrary to our expectation.
 6	 *
 7	 * Hint: The bit representation of `a' is already on the
 8	 * stack. How do you retrieve it to another variable without
 9	 * performing arithmetic operations on it directly?
10	 */
11
12	Float f;
13	void *temp = &a;
14	f.val = *(uint32_t *) temp;     // 联合体val接收IEEE编码
15
16	uint32_t m = f.m | (1 << 23);	// 为尾数位添加1
17	// 计算偏移量
18	int shift = (int)f.e - (127+23-16);
19	
20	// 对m执行偏移操作
21	if(shift > 0) {
22		m <<= shift;
23	}
24	else {
25		m >>= (-shift);
26	}
27
28	return (__sign(f.val) ? -m : m);
29}

浮点数转定点数

实现定点数的运算
运行integral和quadratic-eq，补充缺失指令

为简易调试器增加变量支持

在nemu/src/monitor/debug/elf.c文件中：

 1//sym是我们需要匹配的符号名称，success指针用于设置是否匹配成功
 2uint32_t look_up_symtab(char *sym){
 3    int i;
 4    //遍历符号表逐个匹配符号
 5    for(i=0;i < nr_symtab_entry;i++){
 6        //逐个提取符号信息中的符号类别
 7        uint8_t type = ELF32_ST_TYPE(symtab[i].st_info);
 8        //当遇到类别为FUNC或者OBJECT时候匹配符号名
 9        if((type == STT_FUNC || type == STT_OBJECT) && strcmp(strtab + symtab[i].st_name, sym) == 0){
10        //匹配成功后返回符号的地址
11        return symtab[i].st_value;
12        }
13    }
14    printf("No sym found");
15    return 0;
16}

实现kernel加载

kernel/src/elf/elf.c

 1...
 2	/* TODO: fix the magic number with the correct one */
 3    //修改为elf文件的魔数
 4	const uint32_t elf_magic = 0x464c457f;
 5	uint32_t *p_magic = (void *)buf;
 6	nemu_assert(*p_magic == elf_magic);
 7 
 8	/* Load each program segment */
 9    //初始化ph指向program header开头，buf指向elf文件的开头，e_phoff为program header偏移量
10    ph = (void *)buf + elf->e_phoff;
11    //eph指向program header的末尾，e_phnum为program header中segment的数量
12    //遍历program header表，加载需要加载的segment
13	for(Elf32_Phdr *eph = ph + elf->e_phnum;ph < eph;ph++) {
14		/* Scan the program header table, load each segment into memory */
15		if(ph->p_type == PT_LOAD) {
16            uint32_t addr = ph->p_vaddr; //存储segment加载到的目标地址
17			/* TODO: read the content of the segment from the ELF file 
18			 * to the memory region [VirtAddr, VirtAddr + FileSiz)
19			 */
20            //利用函数从当前segment中读取filesiz大小的数据到目标地址
21         ramdisk_read((void *)addr, ELF_OFFSET_IN_DISK + ph->p_offset,ph->p_filesz);
22			
23			/* TODO: zero the memory region 
24			 * [VirtAddr + FileSiz, VirtAddr + MemSiz)
25			 */
26         //通过函数将未初始化的数据置0
27         memset((void *)addr + ph->p_filesz,0,ph->p_memsz - ph->p_filesz);
28...

进入PA3 →

NEMU-PART II Pre

Tue, 16 Sep 2025 00:00:00 +0000

磨刀不误砍柴工！！！

实验目的：

掌握i386（IA-32）指令格式。
掌握NEMU平台的指令周期。

切换用户程序

修改工程目录下的Makefile文件，更换NEMU的用户程序：

1- USERPROG := obj/testcase/mov
2+ USERPROG := obj/testcase/mov-c

同理，将mov-c更换为testcase/src目录下的其他文件，例如add、bubble-sort等，即可执行对应的用户程序。

了解NEMU的指令集

X86系列处理器采用变长指令字结构，各种指令长度随指令功能而异。

要实现一条指令，首先你需要知道这条指令的格式和功能。格式决定如何解释，功能决定如何执行。这些信息都在 instruction set page（i386 手册第17 章）。

i386 手册中的汇编语言格式都是 Intel 格式，而 objdump（反汇编）的默认格式是 AT&T 格式，两者的源操作数和目的操作数位置不一样，千万不要把它们混淆了！

指令格式

x86指令的一般格式如下：

x86指令的一般格式

Opcode（操作码）必定出现，其余组成部分可能不出现。Opcode决定是否出现ModR/M；SIB、Displacement、Immediate由ModR/M决定。
对于某些组成部分，其长度并不是固定的。
给定一条具体指令的二进制形式，其组成部分的划分是有办法确定的，不会产生歧义

例如对于以下指令：

指令示例

它的划分如下：

示例指令划分

ModR/M部分为什么解析出了disp32[--][--]？

ModR/M内部这一个字节的组成，分为了三个部分，具体每个部分的编码都对应着右边表内的含义，以ModR/M内的编码为基准进行查表就能够解析出对应的含义。

例如例子中的ModR/M部分编码是84（十六进制），对应二进制就是10000100，对应回格式中的部分就是Mod部分为10，R/M部分为100，二者在右边表中可以对应出一行，这一行的对应指令就是disp32[--][--]。disp32代表偏移量（displacement）为32位的，两个[--][--]就代表我们需要解析SIB中的编码部分才能得到偏移量的具体数值。

阅读Opcode Table

以mov指令的第一种形式为例：

mov指令

列数	具体含义
Description	将一个8位寄存器中的数据传送到8位的寄存器或者内存中，其中`r/m`表示“寄存器或内存”。
Opcode	88表示这条指令的`opcode`的首字节是`0x88`，`/r`表示后面跟一个`ModR/M`字节，并且 `ModR/M`字节中的`reg/opcode`域解释成通用寄存器的编码。
Instruction	`r8`表示8位寄存器；`r/m8`表示8位寄存器或内存，具体由`mod`字段决定。

通用寄存器编码

接下来的两种形式也就不难看懂了：但这两种形式的Opcode都是一样的，难道不会出现歧义吗？

x86是通过指令一般格式中的 operand-size prefix来区分上面这两种形式的。

Operand-size prefix的编码是0x66，作用是指示当前指令需要改变操作数的长度。在 IA-32 中，通常如果这个前缀没有出现，操作数长度默认是 32 位；当这个前缀出现的时候，操作数长度就改变成16位。

换句话说，如果把一个开头为89 ...的比特串解释成指令，它就应该被解释成MOV r/m32, r32的形式；如果比特串的开头是66 89...，它就应该被解释成MOV r/m16, r16。

C语言宏定义

在C语言中，可以使用命令#define来定义宏。宏不负责检查语法的正确性。

1// 常规的宏
2#define PI 3.1415926
3// 带参数的宏
4#define putchar(x) putc(x, stdout)
5
6// 使用宏进行连接
7#define concat(x, y)   x ## y

例如：

1#define make_helper(name) int name(swaddr_t eip)

这个宏定义就代表了以下的两行代码是同一个代码，我们使用的时候看到的是上面部分函数，但是程序执行的时候实际上是在执行下面的函数（实际上就是同一个函数）：

1make_helper(exec)
2int exec(swaddr_t eip)

在C语言中，宏必须定义在一行中。

若需通过换行提高代码可读性，可使用\附在每行末尾。

NEMU的指令周期

取指

核心流程

 1void cpu_exec(volatile uint32_t n) {
 2    ...
 3
 4    for(; n>0; n--) {
 5        int instr_len = exec(cpu.eip);  // 执行当前%eip所指向的指令
 6        cpu.eip += instr_len;           // %eip指向下一条指令
 7    }
 8
 9    ...
10}

函数exec：

1make_helper(exec) {     //等价于 int exec(swaddr_t eip)
2    ops_decoded.opcode = instr_fetch(eip, 1);       // 表示读取一个字节的操作码
3    return opcode_table[ops_decoded.opcode](eip);   // 返回一个函数 
4}

其中，函数instr_fetch()负责取指：

1static inline uint32_t instr_fetch(swaddr_t addr, size_t len) {
2    return swaddr_read(addr, len);
3}

instr_fetch()从eip处提取Opcode，存储到ops_decoded.opcode中。

译码

所有指令的规则如下：

内容	规则
指令	指令名称，具体由i386手册确定
形式	`i2r`，将立即数移动到寄存器 `i2rm`，将立即数移动到寄存器或内存 `r2rm`，将寄存器移动到寄存器或内存
操作数后缀	`b`表示操作数长度为8，`v`表示无法确定操作数长度，可能是16或32

通过opcode_table，根据提取到的Opcode找到对应的指令处理函数（如mov_i2r_v）。

执行

对于同一指令的不同形式，它们的执行阶段是相同的。如mov_i2rm和mov_rm2r，它们的执行阶段都是将源操作数存储到目标操作数中。
对于不同指令的同一种形式，它们的译码阶段是相同的。如mov_i2rm和sub_rm2r，它们的译码阶段都是识别出一个立即数和一个rm操作数。
对于同一条指令同一种形式的不同长度，它们的译码阶段和执行阶段都非常类似。如mov_i2rm_b，mov_i2rm_w和mov_i2rm_l。它们都是识别出一个立即数和一个rm操作数，然后把立即数存入rm操作数。

访存

访存指令

写回

指令执行完后，eip指向下一条指令。

编写指令的流程

编写指令模板文件xxx-template.h
① 在文件头尾分别包含cpu/exec/template-start.h和cpu/exec/template-end.h。
② 定义宏instr为指令名称。
③ 定义函数static void do_execute()，实现该指令的通用执行过程。
④ 定义helper函数
（1）若指令的译码方式在nemu/include/cpu/decode/decode.h中已经存在，那么可以考虑使用宏 make_instr_helper()来构造helper函数（大部分 helper 函数都可以通过这种方式构造）。
（2）否则可以考虑添加相应的译码函数或者不使用make_instr_helper(), 而是直接使用make_helper()来定义helper函数，在函数体中直接进行译码，并调用do_execute()（可以参考nemu/src/cpu/exec/data-mov/xchg-template.h中的xchg_a2r指令类型。
编写指令实例化文件xxx.c
① 包含cpu/exec-helper.h。
② 通过分别将宏DATA_BYTE定义成 1, 2, 4, 分别对指令模板文件xxx-template.h进行实例化。
③ 若一个helper函数只会在某些操作数长度中用到，可以在xxx-template.h中通过条件编译的功能来指定（可以参考nemu/src/cpu/exec/data-mov/xchg-template.h中的xchg_a2r指令类型）。
④ 必要时通过宏make_helper_v()定义相应的重载函数，根据指令的操作数长度前缀确定调用哪一个helper函数。
编写指令头文件xxx.h，声明helper函数的原型。
在nemu/src/cpu/exec/all-instr.h中包含xxx.h。
在nemu/src/cpu/exec/exec.c中的opcode_table中填写相应的helper函数

编写指令的流程

进入PA2 →

NEMU-PART I

Mon, 08 Sep 2025 00:00:00 +0000

你说得对，但是NEMU是一个基于X86-64处理器模拟的IA-32操作系统。NEMU运行在一个被称作Docker的容器，在这里，被容器选中的人将被授予gcc，导引C语言之力。你将扮演一位名为Debug的神秘用户，编写众多C语言程序，在调试中找出FAIL的原因，同时逐步发掘Hit Bad Trap的真相。

目标：制作一个32位的操作系统

什么是NEMU

在X86-64处理器的机器上模拟一个32位操作系统（一个用来执行其它程序的程序！），它包括4个连贯的实验内容：

阶段	任务
PA1	简易调试器
PA2	指令系统
PA3	存储管理
PA4	中断与I/O

认识NEMU

NEMU的结构

调试器操作指令集

在nemu/src/monitor/debug/ui.c中定义了调试器的结构：

 1static struct {
 2    char *name;
 3    char *description;
 4    // 函数指针，可指向*name，*description
 5    int (*handler) (char *);     
 6} cmd_table [] = {
 7    { "help", "Display informations about all supported commands", cmd_help },
 8    { "c", "Continue the execution of the program", cmd_c },
 9    { "q", "Exit NEMU", cmd_q },
10
11    /* TODO: Add more commands */
12    /* 接下来若想定义新的操作，格式为
13    { "name", "description", function},
14    */
15};

几个有用的函数

函数	作用
`Log()`	`printf()`的升级版，专门用来输出调试信息，同时还会输出使用`Log()`所在的源文件，行号和函数，当输出的调试信息过多的时候，可以很方便地定位到代码中的相关位置
`Assert()`	`assert()`的升级版，当测试条件为假时，在`assertion fail`之前可以输出一些信息
`panic()`	用于输出信息并结束程序，相当于无条件的`assertion fail`
`swaddr_read()` / `swaddr_write()`	访问模拟的内存
`strtok()`	一个简单的字符串分割工具，用于解析命令
`sscanf()`	可以从字符串中读入格式化的内容, 使用它有时候可以很方便地实现字符串的解析

PA1：简易调试器

机器永远是对的！

未经过测试的每行代码永远是错误的！

RTFM！（阅读手册！）

实现正确的寄存器结构体

寄存器

在/nemu/include/cpu/reg.h中，原寄存器结构体定义为：

 1typedef struct {
 2    struct {
 3        uint32_t _32;
 4        uint16_t _16;
 5        uint8_t _8[2];
 6    } gpr[8];
 7
 8    /* Do NOT change the order of the GPRs' definitions. */
 9    uint32_t eax, ecx, edx, ebx, esp, ebp, esi, edi;
10    ... 
11} CPU_state;

使用结构体，每一个寄存器均独立存在，而X86系统的寄存器是共享的，例如 %eax 的后16位即为 %ax。因此应使用联合体的形式定义寄存器，这样对 %ax 操作时也会相应地改变 %eax 的值。

 1typedef struct {
 2    union {
 3        union {
 4            uint32_t _32;
 5            uint16_t _16;
 6            uint8_t _8[2];
 7        } gpr[8];
 8
 9        /* Do NOT change the order of the GPRs' definitions. */
10        struct {
11            uint32_t eax, ecx, edx, ebx, esp, ebp, esi, edi;
12        };	
13    };
14    ...
15} CPU_state;

实现调试器的功能

回顾nemu/src/monitor/debug/ui.c中对调试器的定义，需增加新的操作指令。

指令名	示例	功能
`si`	`si 10`	单步执行
`info`	`info r`	打印寄存器状态
	`info w`	打印监视点状态
`x`	`x N EXPR`	扫描内存
`p`	`p EXPR`	表达式求值
`w`	`w EXPR`	设置监视点
`d`	`d N`	删除监视点

 1static struct {
 2    char *name;
 3    char *description;
 4    int (*handler) (char *);
 5} cmd_table [] = {
 6    ...
 7    // 定义单步执行操作，关键字为 si，以此类推
 8    { "si", "Single step execution", cmd_si },
 9    { "info", "Show register or monitor's infomation", cmd_info },
10    { "x", "Scan Memory", cmd_x },
11    ...
12};

单步执行

在nemu/src/monitor/debug/ui.c中定义新的操作函数：

 1static int cmd_si(char *args) {
 2    char *arg = strtok(NULL, " ");  // 获取第二个字符
 3    int step = 0;   // 待操作步数
 4    int i = 0;
 5   
 6    if (arg == NULL) {
 7        cpu_exec(1);
 8    }
 9    else {
10        sscanf(arg, "%d", &step);  // 将arg转换为整型数
11        if (step <= 0) {
12            printf("Illegal input!");
13        }
14        else {
15            for(; i<step; i++) {
16                cpu_exec(1);
17            }
18        }
19    }
20    return 0;
21}

报错请查看：

使用循环时，循环变量的初始化应在循环结构之前，否则会报错：

1nemu/src/monitor/debug/ui.c:55: error: 'for' loop initial declarations are only allowed in C99 mode
2nemu/src/monitor/debug/ui.c:55: note: use option -std=c99 or -std=gnu99 to compile your code

读取函数应使用 sscanf。

打印寄存器状态

同理，定义操作函数cmd_info

 1static int cmd_info(char *args) {
 2    char *arg = strtok(NULL, " ");  // 获取第二个字符
 3    int i = 0;
 4
 5    if (*arg == 'r') {    // 参数为'r'时打印寄存器的值
 6        for(; i<8; i++) {
 7            // 打印eax, ecx, edx, ebx, esp, ebp, esi, edi 8个寄存器
 8            printf("%s\t\t", regsl[i]);     // 打印寄存器名称
 9            // 先打印16进制值，再打印10进制值（仿GDB）
10            // "\t" 为制表符，让输出更美观
11            printf("0x%08x\t\t%d\n", cpu.gpr[i]._32, cpu.gpr[i]._32);
12        }
13        // 打印%eip 寄存器
14        printf("eip\t\t0x%08x\t\t%d\n", cpu.eip, cpu.eip);  
15    }
16    else {
17        printf("Illegal input!\n");
18    }
19
20    return 0;
21}

扫描内存

 1static int cmd_x(char *args) {
 2    char *arg_1 = strtok(NULL, " ");    // 获取第1个参数 N
 3    char *arg_2 = strtok(NULL, " ");    // 获取第2个参数 EXPR
 4    int i = 0;
 5    int j = 0;
 6
 7    int N;
 8    swaddr_t address;	
 9
10    sscanf(arg_1, "%d", &N);
11    sscanf(arg_2, "%x", &address);	// 获取起始内存地址
12    
13    for(; i<N; i++) {
14        // 每行打印4个值
15        if (j%4 == 0) {
16            printf("0x%x:", address);
17        }
18
19        // 每4字节打印一个值
20        printf("0x%08x ", swaddr_read(address, 4));
21        address += 4;
22        j++;
23
24        // 4个值后换行
25        if (j%4 == 0) {
26            printf("\n");
27        }
28    }
29
30    printf("\n");
31    return 0;
32}

表达式求值

阶段1：词法分析

定义token

在/nemu/src/monitor/debug/expr.c中，观察token结构体，它包含两个数据type和str：

1typedef struct token {
2    int type;       // 记录token的类型
3    char str[32];   // 记录token的具体数据
4} Token;

容易发现，当token为+, -, &等单运算符时，只需要记录它的type即可，因为它们的type唯一标识了各自的具体数据。

在/nemu/src/monitor/debug/expr.c的列举类中，定义token的类型。

 1enum {
 2    NOTYPE = 256,
 3    NUM = 1,        // 10进制数
 4    REGISTER = 2,   // 寄存器
 5    HEX = 3,        // 16进制数
 6    EQ = 4,         // 相等
 7    NOTEQ = 5,      // 不相等
 8    OR = 6,         // 或运算
 9    AND = 7,        // 与运算
10    POINT,          // 指针
11    NEG
12
13    /* TODO: Add more token types */
14
15};

定义了枚举类后，相应的字段和数字就确定了唯一对应的关系。例如，type = NUM和type = 1均表示10进制整数。

定义正则表达式

在/nemu/src/monitor/debug/expr.c中，定义正则表达式：

 1static struct rule {
 2    char *regex;
 3    int token_type;
 4} rules[] = {
 5
 6    /* TODO: Add more rules.
 7     * Pay attention to the precedence level of different rules.
 8     */
 9
10    {" +",	NOTYPE},                // spaces 空格
11
12    {"\\+", '+'},                   // plus 运算符
13    {"\\-", '-'},
14    {"\\*", '*'},
15    {"\\/", '/'},
16
17    {"\\$[a-z]+", REGISTER},        // 数据
18    {"0x[0-9a-fA-F]+", HEX},
19    {"[0-9]+", NUM},
20
21    {"==", EQ},                     // equal
22    {"!=", NOTEQ},
23
24    {"&&", AND},                    // 逻辑运算符
25    {"\\|\\|", OR},
26    {"!", '!'},
27
28    {"\\(", '('},                   // 括号
29    {"\\)", ')'},
30};

正则表达式的作用是识别当前表达式的具体内容。例如，对于表达式4 + 3 * ( 2 - 1 )，正则表达式的识别结果应为：

识别token

识别token

在/nemu/src/monitor/debug/expr.c中的make_token函数可以帮助我们实现这一工作。

 1static bool make_token(char *e) {
 2    ...
 3    while(e[position] != '\0') {
 4        ...
 5        for(i = 0; i < NR_REGEX; i ++) {
 6            ...
 7            // 清空token值，防止每次运算相互干扰
 8            int j = 0;
 9            for(; j < 32; j++) {
10                tokens[nr_token].str[j] = '\0';
11            }
12            
13            // tokens.type的赋值函数
14            switch(rules[i].token_type) {
15                case 256: 
16                    break;
17
18                // 输入10进制数、寄存器、16进制数
19                case NUM:
20                    tokens[nr_token].type = NUM;
21                    strncpy(tokens[nr_token].str, &e[position - substr_len], substr_len);
22                    nr_token++;
23                    break;
24
25                // REGISTER，HEX，EQ，NOTEQ，AND，OR与之类似
26
27                ...
28                
29                // 输入单运算符
30                case '+':
31                    tokens[nr_token].type = '+';
32                    nr_token++;
33                    break;
34
35                // -, *, /, !, (, ) 与之类似
36
37                ...
38
39                default: 
40                    assert(0);
41            }
42            break;
43        }
44    }
45}

以其中一个为例：

1case NUM:
2    // token的类型为NUM
3    tokens[nr_token].type = NUM;
4    // 将sub_strlen长度的值存储到tokens.str
5    strncpy(tokens[nr_token].str, &e[position - substr_len], substr_len);
6    // 开始读取下一个token
7    nr_token++;
8    // 跳出switch循环
9    break;

阶段2：表达式求值

判断表达式括号匹配

 1bool check_parentheses(int p, int q) {
 2    int a = 0;          // 记录表达式token下标
 3    int i = 0, j = 0;   // 分别记录左、右括号总数
 4
 5    // 检查表达式首尾是否为括号
 6    if(tokens[p].type == '(' || tokens[q].type == ')') {
 7        for(a = p; a<=q; a++) {
 8            if(tokens[a].type == '(') {
 9                i++;
10            }
11            if(tokens[a].type == ')') {
12                j++;
13            }
14            if(a != q && i == j) {
15                // 排除例如 (a+b)) 这种情况
16                return false;
17            }
18        }
19
20        if(i == j) {
21            // 左右括号数量相等，正确
22            return true;
23        } 
24        else {
25            // 数量不等，错误
26            return false;
27        }
28    }
29
30    return false;
31}

寻找主操作符

dominant operator（主操作符）是表达式中最后参与运算的运算符，根据运算符优先级可知：

非运算符的token不是dominant operator。
出现在一对括号中的token不是dominant operator。注意到这里不会出现有括号包围整个表达式的情况，因为这种情况已经在check_parentheses()相应的if块中被处理了。
dominant operator的优先级在表达式中是最低的。这是因为dominant operator是最后一步才进行的运算符。
当有多个运算符的优先级都是最低时，根据结合性，最后被结合的运算符才是dominant operator。一个例子是1 + 2 + 3，它的dominant operator应该是右边的+。

找到主操作符后，表达式的运算可归结为主操作符两侧数的运算。这也就意味着该问题满足了分治的基本条件：一个问题可分解为若干个与原问题结构相同的子问题。

参阅此处：分治法

 1int dominant_operator(int p, int q) {
 2    int step = 0;
 3    int op = -1;
 4    int i = 0;  	// 记录token下标
 5    int pri = 0; 	// 记录当前操作符优先级
 6
 7    for(i = p; i <= q; i++) {
 8        if(tokens[i].type == '(') {
 9            step ++;
10        }
11        else if(tokens[i].type == ')') {
12            step --;
13        }
14
15        if(step == 0) {
16            if(tokens[i].type == OR) {
17                if(pri < 51) {
18                    op = i;
19                    pri = 51;
20                }
21            }
22            else if(tokens[i].type == AND) {
23                if(pri < 50) {
24                    op = i;
25                    pri = 50;
26                }
27            }
28            else if(tokens[i].type == EQ || tokens[i].type == NOTEQ) {
29                if(pri < 49) {
30                    op = i;
31                    pri = 49;
32                }
33            }
34            else if(tokens[i].type == '+' || tokens[i].type == '-') {
35                if(pri < 48) {
36                    op = i;
37                    pri = 48;
38                }
39            }
40            else if(tokens[i].type == '*' || tokens[i].type == '/') {
41                if(pri < 46) {
42                    op = i;
43                    pri = 46;
44                }
45            }	
46        }
47        else if(step < 0) {
48            return -2;
49        }
50    }
51    return op;
52}

递归计算表达式的值

这里运用的就是分治算法。

  1uint32_t eval(int p, int q) {
  2    int result = 0;
  3    int op = 0;
  4    int val1, val2;
  5
  6    // 表达式左侧超过右侧，错误
  7    if (p > q) {
  8        assert(0);
  9    }
 10
 11    // 表达式左侧等于右侧，说明为单个数字
 12    else if (p == q) {
 13        // 处理10进制数
 14        if (tokens[p].type == NUM) {
 15            sscanf(tokens[p].str, "%d", &result);
 16            return result;
 17        } 
 18
 19        // 处理16进制数
 20        else if (tokens[p].type == HEX) {
 21            int i = 2;
 22            while(tokens[p].str[i] != 0) {
 23                result *= 16;
 24                if (tokens[p].str[i] <= '9') {
 25                    // 16进制为0-9
 26                    result += tokens[p].str[i] - '0'; 	
 27                }
 28                else {
 29                    // 16进制为a-f
 30                    result += tokens[p].str[i] - 'a' + 10;	
 31                }
 32                i++;
 33            }
 34            return result;
 35        } 
 36
 37        // 处理寄存器
 38        else if (tokens[p].type == REGISTER) {
 39            if (!strcmp(tokens[p].str, "$eax")) {
 40                return cpu.eax;
 41            } 
 42
 43            // 剩下的寄存器使用相同的处理办法
 44            
 45            ...
 46
 47            else {
 48                return 0;
 49            }
 50        } 
 51        else {
 52            assert(0);
 53        }
 54    }
 55
 56    // 表达式两侧不等，但是括号匹配，去掉括号
 57    else if (check_parentheses(p, q) == true) {
 58         return eval(p + 1, q - 1);
 59    }
 60
 61    // 正常表达式
 62    else {
 63        // 寻找主操作符
 64        op = dominant_operator(p, q);
 65
 66        if (op == -2) {
 67            assert(0);
 68        } 
 69
 70        // 处理一元运算符
 71        else if (op == -1) {
 72            // 处理逻辑非运算，如 !1
 73            if (tokens[p].type == '!') {
 74                sscanf(tokens[q].str, "%d", &result);
 75                return !result;
 76            }
 77
 78            // 之后将在此处实现负数运算和指针解引用
 79
 80        }
 81
 82        // 计算主操作数两侧表达式值
 83        
 84        val1 = eval(p, op - 1);     // 计算主操作数左侧表达式
 85        val2 = eval(op + 1, q);     // 计算主操作数右侧表达式
 86
 87        switch (tokens[op].type) {
 88            case '+' : 
 89                return val1 + val2;	
 90
 91            // -, *, / , OR, AND, EQ, NOTEQ运算以此类推 
 92             
 93            ...
 94
 95            default : 
 96                assert(0);
 97        }
 98    }
 99    return 0;
100}

举例：

分治法求表达式的值

expr函数

 1uint32_t expr(char *e, bool *success) {
 2    if(!make_token(e)) {
 3        *success = false;
 4        return 0;
 5    }
 6
 7    /* TODO: Insert codes to evaluate the expression. */
 8
 9    int i;
10    for (i = 0; i < nr_token; i++){
11        if (tokens[i].type == '*' && (i == 0 || (tokens[i - 1].type != NUM && tokens[i - 1].type != HEX && tokens[i - 1].type != ')'))){
12            tokens[i].type = POINT;
13        }
14        if (tokens[i].type == '-' && (i == 0 || (tokens[i - 1].type != NUM && tokens[i - 1].type != HEX && tokens[i - 1].type != ')'))){
15            tokens[i].type = NEG;
16        }
17    }
18    return eval(0, nr_token - 1);
19
20    // panic("please implement me");
21    return 0;
22}

最终实现

在/nemu/src/monitor/debug/ui.c中写入cmd_p函数：

1static int cmd_p(char *args) {
2    bool *success = false;
3    int result = 0;
4    result = expr(args, success);
5    if(!success) {
6        printf("%d\n", result); 
7    }
8    return 0;
9}

表达式求值功能正式实现。

选做任务：实现负数运算和指针解引用

在eval函数中加入以下内容：

 1uint32_t eval(int p, int q) {
 2
 3    ...
 4
 5    // 正常表达式
 6    else {
 7       // 处理一元运算符
 8        else if (op == -1) {
 9
10            ...
11
12            // 处理带负数的表达式，如 1+ -1
13            if (tokens[p].type == NEG) {
14                sscanf(tokens[q].str, "%d", &result);
15                return -result;
16            }
17
18            // 实现指针解引用
19            else if (tokens[p].type == POINT) {
20                if (!strcmp(tokens[p + 2].str, "$eax")){
21                    result = swaddr_read(cpu.eax, 4);
22                    return result;
23                }
24
25                // 其余寄存器采用类似操作
26
27                ...
28            }
29        } 
30    }  
31}

监视点

新建监视点

在nemu/src/monitor/debug/watchpoint.c中，定义函数new_wp()：

 1// 从free_链表中返回一个空闲监视点
 2WP* new_wp() {
 3    WP *temp;
 4    temp = free_;           // free_链表的头节点作为返回值
 5    free_ = free_->next;    // free_链表的下一个节点成为头节点
 6    temp->next = NULL;      // 空闲监视点为head链表的尾节点
 7
 8    // 若head链表为空，返回的节点成为头节点
 9    if(head == NULL) {
10        head = temp;
11    }
12    // head链表不为空，寻找其尾节点
13    else {
14        WP *p;
15        p = head;
16        // 将返回的节点插入head链表的尾部
17        while (p->next != NULL) {
18            p = p->next;
19        }
20        p->next = temp;
21    }
22    return temp;
23}

示意图如下：

监视点链表

释放监视点

同理，在nemu/src/monitor/debug/watchpoint.c中定义：

 1// 释放监视点至free_链表
 2void free_wp(WP *wp) {
 3    if(wp == NULL) {
 4        assert(0);   // 返回节点为空
 5    } 
 6    else if (wp == head) {
 7        head = head->next;
 8    }
 9    else {
10        WP* temp = head;
11        // 找到head链表待删除节点的前一个节点
12        while(temp != NULL && temp->next != wp) {
13            temp = temp->next;
14        }
15        // 取消待删除节点与其后节点的连接
16        temp->next = wp->next;
17    }
18
19    // 待删除节点成为free链表的头节点
20    wp->next = free_;
21    free_ = wp;
22
23    // 清空待删除节点的内容
24    wp->result = 0;
25    wp->expr[0] = '\0';
26}

释放监视点实际上就是新建监视点的逆操作，换言之，就是将head链表待删除的节点变成free链表的头节点。

判断监视点是否触发

在nemu/src/monitor/debug/watchpoint.c中定义：

 1// 判断监视点是否触发
 2bool checkWP() {
 3    bool check = false;	 // 最终返回值
 4
 5    bool *success = false;  
 6    WP *temp = head;    // 从head链表的头节点开始遍历
 7    int expr_temp;
 8
 9    while(temp != NULL) {
10        expr_temp = expr(temp->expr, success);
11        if (expr_temp != temp->result){
12            check = true;
13            printf ("Hint watchpoint %d at address 0x%08x\n", temp->NO, cpu.eip);
14            temp = temp->next;
15            continue;
16            // 检测到监视点对应的值发生变化
17        }
18        temp->result = expr_temp;
19        temp = temp->next;
20    }	
21    return check;
22}

在/nemu/src/monitor/cpu-exec.c中加入以下内容：

1/* TODO: check watchpoints here. */
2
3// 链接外部函数
4extern bool checkWP();
5bool change = checkWP();
6if (change) {
7    nemu_state = STOP;
8}

打印监视点和删除监视点

 1// 打印所有监视点
 2void printf_wp(){
 3    WP *temp = head;
 4    if (temp == NULL){
 5        printf("No watchpoints\n");
 6    }
 7    while (temp != NULL){
 8        printf("Watch point %d: %s\n", temp->NO, temp->expr);
 9        temp = temp->next;
10    }
11}
12
13// 删除监视点
14WP* delete_wp(int p, bool *key){
15    WP *temp = head;
16    while (temp != NULL && temp->NO != p){
17        temp = temp->next;
18    }
19    if (temp == NULL){
20        *key = false;
21    }
22    return temp;
23}

加入调试器指令

最后在/nemu/src/monitor/debug/ui.c中加入指令函数：

 1// 打印监视器的值
 2static int cmd_info(char *args) {
 3	char *arg = strtok(NULL, " ");  // 获取第二个字符
 4
 5	...
 6
 7	else if(*arg == 'w') {
 8		extern void printf_wp();
 9		printf_wp();
10	}
11
12	...
13
14	return 0;
15}
16
17// 设置监视点
18static int cmd_w(char *args) {
19
20    extern WP* new_wp();
21    WP* temp = new_wp();
22
23    bool *success = false;
24    int result = 0;
25    result = expr(args, success);
26
27    if(!success) {
28        // 若表达式合法，将对应的值赋给temp这个新监视点
29        temp->result = result;
30        strcpy(temp->expr, args);
31    }
32
33    return 0;
34}
35
36// 删除监视点
37static int cmd_d(char *args) {
38    int p = 0;
39    bool key = true;
40    sscanf(args, "%d", &p);
41
42    // 记得链接外部函数
43    extern WP* delete_wp();
44    extern void free_wp();
45    WP *q = delete_wp(p, &key);
46
47    if (key){
48        printf("Delete watchpoint %d: %s\n", q->NO, q->expr);
49        free_wp(q);
50        return 0;
51    } 
52    else {
53        printf("No found watchpoint %d\n", p);
54        return 0;
55    }
56
57    return 0;
58}

思考题

思考题1：opcode_table到底是一个什么类型的数组？

解答

opcode_table数组是一个函数指针数组。

思考题2（1）：在cmd_c()函数中, 调用cpu_exec()的时候传入了参数-1 , 你知道为什么吗?

解答

-1是无符号类型最大的数字，所以函数里的for循环可以执行所有指令。

思考题2（2）：框架代码中定义wp_pool等变量的时候使用了关键字static，static在此处的含义是什么? 为什么要在此处使用它?

解答

static在此处的含义是静态全局变量，该变量只能被本文件中的函数调用，并且是全局变量，而不能被同一程序其他文件中的函数调用，使用static是为了避免它被误修改。

思考题3-1：EFLAGS寄存器中的CF位是什么意思?

解答

i386手册里P34页中和参阅附录c提到，CF是进位标志。

EFLAGS寄存器

思考题3-2：ModR/M字节是什么?

解答

P241-243页。ModR/M 由 Mod，Reg/Opcode，R/M 三个部分组成。 Mod 是前两位，提供寄存器寻址和内存寻址， Reg/Opcode为3-5位，如果是Reg表示使用哪个寄存器，Opcode表示对group属性的Opcode进行补充； R/M为6-8位，与mod结合起来会得到8个寄存器和24个内存寻址。

ModR/M

思考题3-3：mov指令的具体格式是怎么样的?

解答

P345页，格式是DEST ← SRC。

mov指令

思考题3-4：完成 PA1 的内容之后, nemu目录下的所有.c和.h和文件总共有多少行代码? 你是使用什么命令得到这个结果的？和框架代码相比, 你在PA1中编写了多少行代码？你可以把这条命令写入Makefile中, 随着实验进度的推进, 你可以很方便地统计工程的代码行数, 例如敲入 make count就会自动运行统计代码行数的命令。再来个难一点的, 除去空行之外, nemu目录下的所有.c和.h文件总共有多少行代码？

解答

通过find . -name "*[.h/.c]" | xargs wc -l命令，得到4376行。和框架代码4197行相比, 我在 PA1中编写了606行代码。

通过find . -name "*[.h/.c]" | xargs grep "^." | wc -l命令计算去除空行的所有.c .h文件得到了3900行代码。

make count指令如下：

make count

@find nemu/ -name “.c” -o -name “.h” | xargs cat | grep -v ^$$ | wc -l

思考题3-5：打开工程目录下的Makefile文件, 你会在CFLAGS变量中看到 gcc 的一些编译选项。请解释 gcc 中的-Wall和-Werror有什么作用? 为什么要使用-Wall和-Werror？

解答

-Wall使GCC编译后显示所有的警告信息。-Werror会将将所有的警告当成错误进行处理，并且取消编译操作。使用-Wall和-Werror就是为了找出可能存在的错误，尽可能地避免程序运行出错，优化程序。

至此，PA1全部完成

CSAPP on RunicDolphin806

Proxy实验

Part I：实现顺序的代理服务器

main函数

main函数

解析URL

readClient函数

doit函数

Part II：处理多个并发请求

main函数

引入线程的main函数

SBUF包

Part III：缓存Web对象

main函数

读者-写者模型

缓存相关

缓存结构

缓存函数

实验总结

运行《深入理解计算机系统》的代码

准备头文件

下载源代码

配套网站

配置环境

编译并运行

源代码

生成可执行文件

运行服务端和客户端

运行结果

Malloc实验

实验目的

宏定义

操作空闲链表的基本常数和宏

函数实现

初始化

初始化空闲块

extend_heap函数

内存块管理

插入

删除

合并与切割

寻找空闲块

核心

分配

mm_malloc函数

释放

mm_free函数

再分配

总结

NEMU-PART III

实现高速缓存

定义高速缓存结构

高速缓存的读写函数

修改内存读写逻辑

实现分段机制

修改kernel

定义段寄存器

完善指令集

实现段寄存器的捆绑规则

修改内存读写函数

实现分页机制

思考题

Shell实验

实验目的

Shell介绍

函数实现

eval函数

eval函数

Fork函数

builtin_cmd函数

builtin_cmd函数

waitfg函数

do_bgfg函数

kill函数

信号处理

总结

NEMU-PART II

运行用户程序

添加call指令

call指令

`main`函数

`readClient`函数

`doit`函数

`main`函数

`SBUF`包

`main`函数

`eval`函数

`builtin_cmd`函数

`waitfg`函数

`do_bgfg`函数