|
|
# 参考答案 | 对答案，是再次学习的一个机会
|
|
|
|
|
|
你好，我是编辑宇新。
|
|
|
|
|
|
春节将至，先给你拜个早年：愿你2022年工期变长，需求变少，技术水平更加硬核。
|
|
|
|
|
|
距离我们专栏更新结束已经过去了不少时间，给坚持学习的你点个赞。学习操作系统是一个长期投资，需要持之以恒，才能见效。无论你是二刷、三刷的朋友，还是刚买课的新同学，都建议你充分利用留言区，给自己的学习加个增益buff。这种学习讨论的氛围，也会激励你持续学习。
|
|
|
|
|
|
今天这期加餐，我们整理了课程里的思考题答案，一次性发布出来，供你对照参考，查漏补缺。
|
|
|
|
|
|
建议你一定要先自己学习理解，动脑思考、动手训练，有余力还可以看看其他小伙伴的解题思路，之后再来对答案。
|
|
|
|
|
|
### [第1节课](https://time.geekbang.org/column/article/369457)
|
|
|
|
|
|
Q：为了实现C语言中函数的调用和返回功能，CPU实现了函数调用和返回指令，即上图汇编代码中的“call”，“ret”指令，请你思考一下：call和ret指令在逻辑上执行的操作是怎样的呢？
|
|
|
|
|
|
A：一般函数调用的情况下call和ret指令在逻辑上执行的操作如下：
|
|
|
|
|
|
1.将call指令的下一条指令的地址压入栈中；
|
|
|
2.将call指令数据中的地址送入IP寄存器中（指令指针寄存器），该地址就是被调用函数的地址；
|
|
|
3.由于IP寄存器地址设置成为被调用函数的地址，CPU自然跳转到被调用函数处开始执行指令；
|
|
|
4.在被调用函数的最后都有一条ret指令，当CPU执行到ret指令时，就从栈中弹出一个数据到IP寄存器，而这个数据通常是先前执行call指令的下一条指令的地址，即实现了函数返回功能。
|
|
|
|
|
|
### [第2节课](https://time.geekbang.org/column/article/369502)
|
|
|
|
|
|
Q：以上printf函数定义，其中有个形式参数很奇怪，请你思考下：为什么是“…”形式参数，这个形式参数有什么作用？
|
|
|
|
|
|
A：在C语言中经常使用printf(“%s :%d”,“number is :”,20);printf(“%x :%d”,0x10,20);printf(“%x,%x :%d”,0xba,0xff,20);可以看出，这些printf函数参数个数都不同，因为C语言的特性支持变参函数。而“…”表示支持0个和多个参数，C语言是通过调用者传递参数的，刚好支持这种变参函数。
|
|
|
|
|
|
### [第3节课](https://time.geekbang.org/column/article/372609)
|
|
|
|
|
|
Q：其实我们的内核架构不是我们首创的，它是属于微内核、宏内核之外的第三种架构，请问这是什么架构？
|
|
|
|
|
|
A：我们的内核架构是混合内核架构，是介于微、宏架构之间的一种架构，这种架构保证了宏架构的高性能又兼顾了微架构的可移植、可扩展性。
|
|
|
|
|
|
### [第4节课](https://time.geekbang.org/column/article/374474)
|
|
|
|
|
|
Q：Windows NT内核属于哪种架构类型？
|
|
|
|
|
|
A：Windows NT内核架构其实既不属于传统的宏内核架构，也不是新的微内核架构，说NT是微内核架构是错误的，NT这种内核架构其实是宏内核的变种——混合内核。
|
|
|
|
|
|
### [第5节课](https://time.geekbang.org/column/article/375278)
|
|
|
|
|
|
Q：请问实模式下能寻址多大的内存空间？
|
|
|
|
|
|
A：由于实模式下访问内存的地址是这样产生的：16位段寄存器左移4位，加一个16位通用寄存器，最后形成了20位地址，所以只能访问1MB大的内存空间。
|
|
|
|
|
|
### [第6节课](https://time.geekbang.org/column/article/376064)
|
|
|
|
|
|
Q：分页模式下，操作系统是如何对应用程序的地址空间进行隔离的？
|
|
|
|
|
|
A：操作系统会给每个应用程序都配置独立的一套页表数据。应用程序运行时，就让CR3寄存器指向该应用程序的页表数据。运行下一个应用程序时，则会执行同样的操作。
|
|
|
|
|
|
### [第7节课](https://time.geekbang.org/column/article/376711)
|
|
|
|
|
|
Q：请你思考一下，如何写出让CPU跑得更快的代码？由于Cache比内存快几个数量级，所以这个问题也可以转换成：如何写出提高Cache命中率的代码？
|
|
|
|
|
|
A：第一，定义变量时，尽量让其地址与Cache行大小对齐。
|
|
|
|
|
|
```plain
|
|
|
int a __attribute__((aligned (64)));
|
|
|
int b __attribute__((aligned (64)));
|
|
|
|
|
|
```
|
|
|
|
|
|
第二，操作数据时的顺序，尽量和数据在内存中布局顺序保持一致。
|
|
|
|
|
|
```plain
|
|
|
int arr[M][M];
|
|
|
for(int i = 0; i < M; i++) {
|
|
|
for(int k = 0; k < M; k++) {
|
|
|
arr[i][k] = 0;
|
|
|
}
|
|
|
}
|
|
|
//而非这样
|
|
|
for(int i = 0; i < M; i++) {
|
|
|
for(int k = 0; k < M; k++) {
|
|
|
arr[k][i] = 0;
|
|
|
}
|
|
|
}
|
|
|
|
|
|
```
|
|
|
|
|
|
第三，尽量少用全局变量。
|
|
|
|
|
|
### [第8节课](https://time.geekbang.org/column/article/377913)
|
|
|
|
|
|
Q：请用代码展示一下自旋锁或者信号量，可能的使用形式是什么样的？
|
|
|
|
|
|
A：最常规的形式是在设计共享数据结构时，在其中包含自旋锁或者信号量。
|
|
|
|
|
|
如下所示：
|
|
|
|
|
|
```c++
|
|
|
typedef struct s_DATA
|
|
|
{
|
|
|
spinlock_t d_lock;
|
|
|
sem_t d_sem;
|
|
|
int a;
|
|
|
int b;
|
|
|
long state;
|
|
|
}data_t;
|
|
|
data_t da;
|
|
|
do_da_write(data_t* d)
|
|
|
{
|
|
|
x86_spin_lock(&d->d_lock);
|
|
|
d->a = 0;
|
|
|
d->b = 1;
|
|
|
d->state = 2;
|
|
|
x86_spin_unlock(&d->d_lock);
|
|
|
}
|
|
|
do_da_sem_write(data_t* d)
|
|
|
{
|
|
|
krlsem_down(&d->d_sem);
|
|
|
d->a = 20;
|
|
|
d->b = 10;
|
|
|
d->state = 4;
|
|
|
krlsem_up(&d->d_sem);
|
|
|
}
|
|
|
do_da_write(&da);
|
|
|
do_da_sem_write(&da);
|
|
|
|
|
|
```
|
|
|
|
|
|
### [第9节课](https://time.geekbang.org/column/article/378870)
|
|
|
|
|
|
Q：请试着回答：上述Linux的读写锁，支持多少个进程并发读取共享数据？这样的读写锁有什么不足？
|
|
|
|
|
|
A：第一个问题，根据上述描述，读写锁本质上就是一个计数器。锁变量的初始值为0x01000000，即表示最多可以有0x01000000个进程同时获取读锁。
|
|
|
|
|
|
第二个问题，读写锁的不足是，如果一直有很多读取数据的进程占有读锁，因而可能导致修改数据的进程饥饿的情况。操作系统会加以控制，让修改数据的进程优先得锁。
|
|
|
|
|
|
### [第10节课](https://time.geekbang.org/column/article/379291)
|
|
|
|
|
|
Q：请问，我们为什么要把虚拟硬盘格式化成ext4文件系统格式呢？
|
|
|
|
|
|
A：有两点原因。第一，GRUB在加载系统映像文件时，能够识别ext4文件系统格式；二，我们在Linux下生成系统映像文件时，要复制到虚拟硬盘中去，所以这个文件系统格式必须被Linux所识别，那么选ext4就最合适。
|
|
|
|
|
|
### [第11节课](https://time.geekbang.org/column/article/380507)
|
|
|
|
|
|
Q：请问GRUB头中为什么需要\_entry标号和\_start标号的地址？
|
|
|
|
|
|
A：这是GRUB规定的。GRUB正是通过\_entry标号和\_start标号的地址，控制内核文件被加载到什么内存地址，又应该从什么内存地址开始运行。
|
|
|
|
|
|
### [第12节课](https://time.geekbang.org/column/article/381157)
|
|
|
|
|
|
Q：请你想一下，init\_bstartparm()函数中的init\_mem820()函数，这个函数到底干了什么？
|
|
|
|
|
|
A：init\_mem820()函数是把e820map\_t结构数组复制到内核文件之后的内存空间，并且重新填写了机器信息结构。
|
|
|
|
|
|
它的代码如下：
|
|
|
|
|
|
```plain
|
|
|
void init_meme820(machbstart_t *mbsp)
|
|
|
{
|
|
|
//源e820map_t结构数组地址
|
|
|
e820map_t *semp = (e820map_t *)((u32_t)(mbsp->mb_e820padr));
|
|
|
//e820map_t结构数组元素个数
|
|
|
u64_t senr = mbsp->mb_e820nr;
|
|
|
//获取下一段空闲内存空间的首地址，即e820map_t结构数组的新地址
|
|
|
e820map_t *demp = (e820map_t *)((u32_t)(mbsp->mb_nextwtpadr));
|
|
|
//检查地址空间冲突
|
|
|
if (1 > move_krlimg(mbsp, (u64_t)((u32_t)demp), (senr * (sizeof(e820map_t)))))
|
|
|
{
|
|
|
kerror("move_krlimg err");
|
|
|
}
|
|
|
//复制
|
|
|
m2mcopy(semp, demp, (sint_t)(senr * (sizeof(e820map_t))));
|
|
|
//并重新填写了对应的机器信息结构字段
|
|
|
mbsp->mb_e820padr = (u64_t)((u32_t)(demp));
|
|
|
mbsp->mb_e820sz = senr * (sizeof(e820map_t));
|
|
|
mbsp->mb_nextwtpadr = P4K_ALIGN((u32_t)(demp) + (u32_t)(senr * (sizeof(e820map_t))));
|
|
|
mbsp->mb_kalldendpadr = mbsp->mb_e820padr + mbsp->mb_e820sz;
|
|
|
return;
|
|
|
}
|
|
|
|
|
|
```
|
|
|
|
|
|
### [第13节课](https://time.geekbang.org/column/article/381810)
|
|
|
|
|
|
Q：请你画出Cosmos硬件抽象层的函数调用关系图。
|
|
|
|
|
|
A：Cosmos硬件抽象层的函数调用关系图如下。
|
|
|
|
|
|
|
|
|
|
|
|
### [第14节课](https://time.geekbang.org/column/article/382733)
|
|
|
|
|
|
Q：为什么要用C代码mkpiggy程序生成piggy.S文件，并包含vmlinux.bin.gz文件呢？
|
|
|
|
|
|
A：因为mkpiggy程序在读取vmlinux.bin.gz文件，知道了其长度等信息，它就会把这些信息保存在piggy.S文件相关的字段中。在解压vmlinux.bin.gz文件时，解压的代码需要用到这些信息。
|
|
|
|
|
|
### [第15节课](https://time.geekbang.org/column/article/383611)
|
|
|
|
|
|
Q：你能指出上文中Linux初始化流程里，主要函数都被链接到哪些对应的二进制文件中了？
|
|
|
|
|
|
A：它们的链接结构如下。
|
|
|
|
|
|
1.\_start、main函数链接在setup.elf文件中，而setup.elf文件生成了setup.bin。
|
|
|
|
|
|
2.startup\_32、startup\_64、extract\_kernel链接在linux/arch/x86/boot/compressed目录下的vmlinux文件中，而这个文件生成了vmlinux.bin。
|
|
|
|
|
|
3.Linux内核的startup\_64、x86\_64\_start\_kernel、start\_kernel、arch\_call\_rest\_init、rest\_init、kernel\_init、try\_to\_run\_init\_process、run\_init\_process函数链接在顶层linux目录下的vmlinux中。这是一个elf格式的文件，由objcoopy去除符号信息后用压缩工具压缩，包含到piggy.S中，从而形成了piggy.o，最终和其它文件一起生成了vmlinux.bin。
|
|
|
|
|
|
### [第16节课](https://time.geekbang.org/column/article/384366?)
|
|
|
|
|
|
Q：我们为什么要以 2 的（0～52）次方为页面数来组织页面呢？
|
|
|
|
|
|
A：以2的（0～52）次方为页面数来组织页面，是为了每组连续的页面能对半分割。对半分割是为了保证连续的页面空间最大化，同时保证在下一次释放时，能最大可能地合并一个整体，这么做的目的只有一个：在满足最小、最大页面请求时，保证内存碎片的最小化。
|
|
|
|
|
|
### [第17节课](https://time.geekbang.org/column/article/384772)
|
|
|
|
|
|
Q：请问在 4GB 的物理内存的情况下，msadsc\_t 结构实例变量本身占用多大的内存空间？
|
|
|
|
|
|
A：4GB有1M个页面，那就对应1M个msadsc\_t结构，每个msadsc\_t结构为40个字节，所以占用40MB的内存空间。
|
|
|
|
|
|
### [第18节课](https://time.geekbang.org/column/article/385628)
|
|
|
|
|
|
Q：在内存页面分配过程中，是怎样尽可能保证内存页面连续的呢？
|
|
|
|
|
|
A：因为分配内存页面一开始就是连续的，然后在分配时始终以2的幂次分隔，所以能保证内存页面的最大连续性。
|
|
|
|
|
|
### [第19节课](https://time.geekbang.org/column/article/386400)
|
|
|
|
|
|
Q：为什么我们在分配内存对象大小时，要按照Cache行大小的倍数分配呢？
|
|
|
|
|
|
A：因为这使得我们分配的内存对象的地址空间是和Cache行对齐的，那么这个内存对象中的数据就极有可能被Cache命中，从而大大提升程序的性能。
|
|
|
|
|
|
### [第20节课](https://time.geekbang.org/column/article/387258)
|
|
|
|
|
|
Q：请问内核虚拟地址空间为什么有一个 0xFFFF800000000000～0xFFFF800400000000 的线性映射区呢？
|
|
|
|
|
|
A：内核的线性映射区0xFFFF800000000000～0xFFFF800400000000，会映射到物理地址空间的0~～0x400000000。因为内核本身运行在虚拟地址空间，本身使用虚拟地址，但是它又必须访问物理内存，所以有了这个线性映射区，就可以把这个区域的物理地址转换成虚拟地址，也可以直接把虚拟地址转换成物理地址。
|
|
|
|
|
|
另外，因为它们之间就是一个常数：0xFFFF800000000000。所以，内核就可以很方便地操作自身数据结构和设备寄存器。这个设备寄存器是物理地址，内核很方便就能转换为虚拟地址，然后通过这个虚拟地址访问设备寄存器。
|
|
|
|
|
|
### [第21节课](https://time.geekbang.org/column/article/388167)
|
|
|
|
|
|
Q：请问，x86 CPU 的缺页异常，是第几号异常？缺页的地址保存在哪个寄存器中？
|
|
|
|
|
|
A：x86 CPU的缺页异常，是14号异常。缺页的地址保存在x86 CPU的CR2寄存器中。
|
|
|
|
|
|
### [第22节课](https://time.geekbang.org/column/article/389123)
|
|
|
|
|
|
Q：在默认配置下，Linux伙伴系统能分配多大的连续物理内存？
|
|
|
|
|
|
A：Linux伙伴系统能分配多大的连续物理内存，取决于MAX\_ORDER。MAX\_ORDER的值默认为11，因为是free\_area数组的下标，所以要MAX\_ORDER-1 = 10, 结果就是2 << 10 = 1024，而1024个连续的页面（一个页面4KB）是4MB，即Linux伙伴系统能分配多大的连续物理内存是4MB。
|
|
|
|
|
|
### [第23节课](https://time.geekbang.org/column/article/389880)
|
|
|
|
|
|
Q：Linux的SLAB，使用kmalloc函数能分配多大的内存对象呢？
|
|
|
|
|
|
A：kmalloc函数能分配32MB的内存对象。
|
|
|
|
|
|
### [第24节课](https://time.geekbang.org/column/article/390674)
|
|
|
|
|
|
Q：各个进程是如何共享同一份内核代码和数据的？
|
|
|
|
|
|
A：只需要将每个进程的上半部分虚拟地址空间（0xFFFF800000000000~0xFFFFFFFFFFFFFFFF）的MMU页表设为相同的映射关系就行了，这样每个进程都可以共享内核的代码的数据，但是又不能读取和修改这部分地址空间中的数据，因为权限不够。
|
|
|
|
|
|
### [第25节课](https://time.geekbang.org/column/article/391222)
|
|
|
|
|
|
Q：请问当调度器函数调度到一个新建进程时，为何要进入 retnfrom\_first\_sched 函数呢？
|
|
|
|
|
|
A：因为新建的进程内核中只有CPU默认的寄存器状态，没有从内核其它任何位置调用进入krlschedul函数。因此没有调用krlschedul函数的调用路径，所以无从返回，只能通过retnfrom\_first\_sched函数，强制初始化CPU寄存器状态，从而让进程开始运行。
|
|
|
|
|
|
### [第26节课](https://time.geekbang.org/column/article/392198)
|
|
|
|
|
|
Q：我们让进程进入等待状态后，进程会立马停止运行吗？
|
|
|
|
|
|
A：进程不会立马停止运行，因为在调用krlsched\_wait函数后，进程的上下文并没有切换。需要在krlsched\_wait函数的外层，通过调用krlschedul函数进行进程调度，才能让该进程停止运行，进入等待状态。
|
|
|
|
|
|
### [第27节课](https://time.geekbang.org/column/article/393350)
|
|
|
|
|
|
Q：想一想，Linux 进程的优先级和 Linux 调度类的优先级是一回事儿吗？
|
|
|
|
|
|
A：不是一回事儿。一个调度类管理着同一类的多个进程，而进程的优先级是该调度类下的各个进程间的优先级。
|
|
|
|
|
|
### [第28节课](https://time.geekbang.org/column/article/394084)
|
|
|
|
|
|
Q：请你写出一个用来访问设备的接口函数，或者想一下访问一个设备需要什么参数。
|
|
|
|
|
|
A：比如打开一个设备的接口函数，如下所示：
|
|
|
|
|
|
```plain
|
|
|
int open(devid_t *devid, uint_t flgs);
|
|
|
|
|
|
```
|
|
|
|
|
|
必须至少要有设备的devid参数。里面要包含设备的类型和设备号，这样才能找到一个具体的设备。
|
|
|
|
|
|
### [第29节课](https://time.geekbang.org/column/article/394875)
|
|
|
|
|
|
Q：请你写出帮驱动程序开发者自动分配设备ID接口函数。
|
|
|
|
|
|
A：很明显，这需要驱动程序提供一个设备类型，然后到设备表中搜索该设备类型还没有占用的设备ID，最后返回这个设备ID。代码如下所示：
|
|
|
|
|
|
```plain
|
|
|
drvstus_t krlnew_devid(devid_t *devid)
|
|
|
{
|
|
|
device_t *findevp;
|
|
|
drvstus_t rets = DFCERRSTUS;
|
|
|
cpuflg_t cpufg;
|
|
|
list_h_t *lstp;
|
|
|
devtable_t *dtbp = &osdevtable;//获取设备表
|
|
|
uint_t devmty = devid->dev_mtype;
|
|
|
uint_t devidnr = 0;
|
|
|
if (devmty >= DEVICE_MAX)
|
|
|
{
|
|
|
return DFCERRSTUS;
|
|
|
}
|
|
|
|
|
|
krlspinlock_cli(&dtbp->devt_lock, &cpufg);
|
|
|
if (devmty != dtbp->devt_devclsl[devmty].dtl_type)
|
|
|
{
|
|
|
rets = DFCERRSTUS;
|
|
|
goto return_step;
|
|
|
}
|
|
|
//检查这个设备类型链表是不是为空
|
|
|
if (list_is_empty(&dtbp->devt_devclsl[devmty].dtl_list) == TRUE)
|
|
|
{
|
|
|
rets = DFCOKSTUS;
|
|
|
devid->dev_nr = 0;
|
|
|
goto return_step;
|
|
|
}
|
|
|
//扫描该设备类型链表下的所有设备
|
|
|
list_for_each(lstp, &dtbp->devt_devclsl[devmty].dtl_list)
|
|
|
{
|
|
|
findevp = list_entry(lstp, device_t, dev_intbllst);
|
|
|
if (findevp->dev_id.dev_nr > devidnr)
|
|
|
{
|
|
|
//获取最大的设备号
|
|
|
devidnr = findevp->dev_id.dev_nr;
|
|
|
}
|
|
|
}
|
|
|
//新的设备号等于最大设备号加一
|
|
|
devid->dev_nr = devidnr++;
|
|
|
rets = DFCOKSTUS;
|
|
|
return_step:
|
|
|
krlspinunlock_sti(&dtbp->devt_lock, &cpufg);
|
|
|
return rets;
|
|
|
}
|
|
|
|
|
|
|
|
|
```
|
|
|
|
|
|
### [第30节课](https://time.geekbang.org/column/article/395772)
|
|
|
|
|
|
Q：请你想一想，为什么没有 systick 设备这样周期性的产生中断，进程就有可能霸占 CPU 呢？
|
|
|
|
|
|
A：如果一个应用程序，它不调用任何系统接口，也不退出系统，就在主函数中执行一个死循环，这样这个进程一旦运行，内核将再也没有办法从应用手中夺回CPU，其代码如下：
|
|
|
|
|
|
```plain
|
|
|
void main()
|
|
|
{
|
|
|
for(;;);
|
|
|
return;
|
|
|
}
|
|
|
|
|
|
```
|
|
|
|
|
|
### [第31节课](https://time.geekbang.org/column/article/396896)
|
|
|
|
|
|
Q：为什么无论是我们加载miscdrv.ko内核模块，还是运行App测试，都要在前面加上sudo呢？
|
|
|
|
|
|
A：Linux系统的安全是基于用户类型的，并且是多用户的系统，所以有些影响系统的操作，必须要root用户才能完成。比如你加载一个内核模块，这个内核模块是不是友好的？会不会干坏事？这需要管理员root用户评估；应用程序访问设备，同样是系统特权操作，也需要root用户，而sudo命令就是暂时让应用以root用户运行。
|
|
|
|
|
|
### [第32节课](https://time.geekbang.org/column/article/397594)
|
|
|
|
|
|
Q：请问，我们文件系统的储存单位为什么要自定义一个逻辑储存块？
|
|
|
|
|
|
A：有两点考量：一是储存设备都按块为单位储存；二是为了文件系统代码的可移植性和可扩展性。因为储存设备的储存块大小各不相同，有512B、1KB、2KB、4KB，我们自己定义一个逻辑储存块，就能很好地适应不同的储存设备。
|
|
|
|
|
|
### [第33节课](https://time.geekbang.org/column/article/39869)
|
|
|
|
|
|
Q：请问，建立文件系统的超级块、位图、根目录的三大函数的调用顺序可以随意调换吗，原因是什么？
|
|
|
|
|
|
A：不能随意调换，因为建立位图要依赖于超级块，而建立根目录时需要依赖于位图，所以必须是先调用建立超级块的函数，然后调用建立位图的函数，最后调用建立根目录的函数。
|
|
|
|
|
|
### [第34节课](https://time.geekbang.org/column/article/399700)
|
|
|
|
|
|
Q：请你想一想，我们这个简单的、小的，却五脏俱全的文件系统有哪些限制？
|
|
|
|
|
|
A：我们这个文件系统有如下限制：
|
|
|
|
|
|
1. 不能创建目录，所有文件都在根目录“/”下，即文件路径名都是这样的形式：“/file”、“/file1”、“/file2”等；
|
|
|
2. 每个文件最多只能分配一个储存块（4KB大小）；
|
|
|
3. 暂不支持文件随机读写，一旦发生读写操作，我们的文件系统会把一个文件的全部数据都返回给请求者，或者更新该文件的全部数据。
|
|
|
|
|
|
### [第35节课](https://time.geekbang.org/column/article/400424)
|
|
|
|
|
|
Q：请说一说 super\_block，dentry，inode 这三个数据结构 ，一定要在储存设备上对应存在吗？
|
|
|
|
|
|
A：不一定要在储存设备上对应存在，具体的文件系统可以有自己的实现，但是在运行时刻必须要能转换成内存中对应的super\_block，dentry，inode这三大数据结构。转换方法由具体文件系统实现。
|
|
|
|
|
|
### [第36节课](https://time.geekbang.org/column/article/401467)
|
|
|
|
|
|
Q：我们这节课从宏观的角度分析了网络数据的运转，但是在内核中网络数据包怎么运转的呢？请你简单描述这个过程。
|
|
|
|
|
|
A：内核网络数据包处理流程如下：
|
|
|
|
|
|
1. 网卡驱动初始化
|
|
|
2. 中断注册
|
|
|
3. 重要结构体初始化
|
|
|
4. 网络收发包
|
|
|
|
|
|
### [第37节课](https://time.geekbang.org/column/article/402840)
|
|
|
|
|
|
Q：我们已经了解到了操作系统内核和网络协议栈的关系，可是网络协议栈真的一定只能放在内核态实现么？
|
|
|
|
|
|
A：我们发现传统的收发方式有一些弊端，比如：内核态用户态切换会引入Cache Miss、流水线失效、硬中断、锁、额外的拷贝等等额外开销。这些开销在C10K的并发规模可能无法体现出来，可是一旦到了C10M的规模，这些开销就不容小视了，于是DPDK这种用户态网络栈就应运而生了。
|
|
|
|
|
|
### [第38节课](https://time.geekbang.org/column/article/404013)
|
|
|
|
|
|
Q：请思考一下，我们目前的互联网架构属于中心化架构还是去中心化架构呢？你觉得未来的发展趋势又是如何？
|
|
|
|
|
|
A：早期的传统互联网架构下，我们如果要配置交换机，一般都是直接用配置线连接交换机，然后命令行配置的，但出现什么问题可能就要跑到机房了。而且那个年代，中小型运营商也比较多，且分布式技术不够成熟。所以，诞生了如OSPF、BGP、ISIS之类的分布式、自组织的动态路由协议。
|
|
|
|
|
|
而随着分布式技术成熟，以及电信、互联网巨头逐渐聚集，我们现在逐渐演进到了以Google B4为代表的中心化架构的SDN上了，这也就是为什么万维网之父Tim Berners-Lee爵士会表示对今天的中心化Web 非常不满，却还是搞出了开源的去中心化平台 Solid项目的原因。
|
|
|
|
|
|
至于未来，个人认为随着以大数据、区块链为代表的去中心化架构逐渐成熟，也许互联网的基础架构会回归去中心化。当然为了实现这个目标，就需要我们大家一起努力了。
|
|
|
|
|
|
### [第39节课](https://time.geekbang.org/column/article/404724)
|
|
|
|
|
|
Q：套接字也是一种进程间通信机制，它和其他通信机制有什么不同？
|
|
|
|
|
|
A：它可用于不同机器间的进程通信。
|
|
|
|
|
|
### [第40节课](https://time.geekbang.org/column/article/405781)
|
|
|
|
|
|
Q：我们了解的 TCP 三次握手，发生在 socket 的哪几个函数中呢？
|
|
|
|
|
|
A：第一次握手：客户端调用connect时，触发了连接请求，向服务器发送了SYN J包，这时connect进入阻塞状态；
|
|
|
|
|
|
第二次握手：服务器监听到连接请求，即收到SYN J包，就会调用accept函数接收请求，向客户端发送SYN K ，接着ACK J+1，这时accept进入阻塞状态；
|
|
|
|
|
|
第三次握手：客户端收到服务器的SYN K ，ACK J+1之后，这时connect返回，并对SYN K进行确认；服务器收到ACK K+1时，accept返回。至此三次握手完毕，连接建立。
|
|
|
|
|
|
### [第41节课](https://time.geekbang.org/column/article/406633)
|
|
|
|
|
|
Q：请问 int 指令后面的常数能不能大于255，为什么？
|
|
|
|
|
|
A：int 指令后面的常数不能大于255，因为int指令会经过中断门，后面的常数就是中断门的索引，而我们中断门最多256（0～255）个，所以不能大于255。
|
|
|
|
|
|
### [第42节课](https://time.geekbang.org/column/article/407343)
|
|
|
|
|
|
Q：请说说syscall指令和int指令的区别是什么？
|
|
|
|
|
|
A：syscall指令不需要经过中断门，执行syscall指令后的进入内核的入口地址，是内核在初始化时写入到特殊寄存器。这个寄存器应用程序不能访问，处理器在硬件层还对syscall指令执行逻辑做了一定的优化，而int要经过中断门进入到内核，做权限检查又还要读取内存，这会导致性能下降。
|
|
|
|
|
|
### [第43节课](https://time.geekbang.org/column/article/408124)
|
|
|
|
|
|
Q：有了KVM作为虚拟化的基石之后，如果让你从零开始，设计一款像各大云厂商IAAS平台一样的虚拟化平台，还需要考虑哪些问题呢？
|
|
|
|
|
|
A：如果只是在一台物理机上开启多个虚拟机，KVM确实已经做的很棒了，但是如果我们扩展到多个机架、多个机房，问题就变得更加复杂了。
|
|
|
|
|
|
我们除了要考虑之前讲过的网络问题，还需要考虑分布式环境下的计算、存储、消息传输、状态同步、动态迁移、扩缩容、镜像、身份认证、编排与调度、UI管理面板等很多问题。
|
|
|
|
|
|
当然，业界也有一些开源解决方案，比如大名鼎鼎的OpenStack，不过笔者觉得OpenStack由于设计实现得比较早，所以存在集群规模有限，部署、维护、二次开发复杂度高，历史包袱重等问题。和多位架构师沟通交流之后，我们正在尝试重新设计并实现一套更现代化的、轻量级的、IAAS云平台，感兴趣的同学可以加入课程群多多交流。课程交流群点[这里](https://jinshuju.net/f/I4XbfK)，按加群提示操作后加入。
|
|
|
|
|
|
### [第44节课](https://time.geekbang.org/column/article/408927)
|
|
|
|
|
|
Q：在我们启动容器后，一旦容器退出，容器可写层的所有内容都会被删除。那么，如果用户需要持久化容器里的部分数据该怎么办呢？
|
|
|
|
|
|
A：可以通过实现volume（数据卷），在容器文件系统里创建挂载点，把宿主机文件目录挂载到容器挂载点，启动过程中读取数据卷。
|
|
|
|
|
|
### [第45节课](https://time.geekbang.org/column/article/409790)
|
|
|
|
|
|
Q：除了 ARM 指令集，如果想开发一款 CPU，我们还有更好的 RISC 指令集可选么？
|
|
|
|
|
|
A：RISC-V是2010年加州大学柏克莱分校创建的开源指令集架构。由于这个指令集是完全开放，允许任何人用于任何目的而设计，还不需要付高昂的专利费，所以开源之后IBM、高通、恩智浦、甲骨文、华为、阿里等知名公司也纷纷加入基金会，并且投入大量资源来进行研发与优化。由此可见，RISC-V是一个非常有潜力的项目，我们也会在后续课程结束后，发起Cosmos配套的开源芯片研发项目，感兴趣的同学可以加入课程群一起多多交流。
|
|
|
|
|
|
### [第45节课](https://time.geekbang.org/column/article/410396)
|
|
|
|
|
|
Q：请问，ARMv8有多少特权级？每个特权级有什么作用？
|
|
|
|
|
|
A：ARMv8，有4个特权级，E0～E3, E0运行APP，E1运行OS， E2运行虚拟机监控软件，E3运行安全监视软件。
|
|
|
|
|
|
到这里，思考题答案公布完毕，同学们学习加油呀！
|
|
|
|