2017-2018-1 20155206 《信息安全系统设计基础》第十三周学习总结

2017-2018-1 20155206 《信息安全系统设计基础》第十三周学习总结

第八章 异常控制流

平滑：指在存储器中指令都是相邻的。
突变：出现不相邻，通常由诸如跳转、调用、和返回等指令造成。
异常控制流ECF：即这些突变。

关于ECF：
1.ECF是操作系统用来实现I/O、进程和虚拟存器的基本机制
2.应用程序通过使用一个叫做陷阱或者系统调用的ECF形式，向操作系统请求服务
3.ECF是计算机系统中实现并发的基本机制
4.软件异常机制——C++和Java有try，catch，和throw，C中非本地跳转是setjmp和longjmp

第一节 异常

异常是异常控制流的一种形式，由硬件和操作系统实现。简单来说，就是控制流中的突变。

事件：即状态变化，与当前指令的执行可能直接相关，也可能没有关系。
出现异常的处理方式：
1.处理器检测到有异常发生
2.通过异常表，进行间接过程调用，到达异常处理程序
3.完成处理后：①返回给当前指令②返回给下一条指令③终止

1.异常处理

需要知道几个概念：异常号，异常表，异常表基址寄存器。

异常号：系统为每种类型的异常分配的唯一的非负整数。
异常表：系统启动时操作系统就会初始化一张条转变，使得条目k包含异常k的处理程序的地址。
关系：
异常号是到异常表中的索引，异常表的起始地址放在异常表基址寄存器。

异常类似于过程调用，区别在：

1.处理器压入栈的返回地址，是当前指令地址或者下一条指令地址。
2.处理器也把一些额外的处理器状态压到栈里
3.如果控制一个用户程序到内核，所有项目都压到内核栈里。
4.异常处理程序运行在内核模式下，对所有的系统资源都有完全的访问权限。

2.异常的类别

故障指令：执行当前指令导致异常
中断处理程序：硬件中断的异常处理程序。

（1）中断

异步发生
来自处理器外部的I/O设备的信号的结果
返回下一条指令

（2）陷阱

陷阱是有意的异常
是执行一条指令的结果
最重要的用途——系统调用

（3）故障

由错误状况引起，可能能够被故障处理程序修正
结果要么重新执行指令（就是返回当前指令地址），要么终止
典型示例：缺页异常

（4）终止

是不可恢复的致命错误造成的结果
通常是一些硬件错误

3.Linux/IA32系统中的异常

一共有256种不同的异常类型。

（1）Linux/IA32故障和终止

除法错误/浮点异常 异常0 终止程序
一般保护故障/段故障 异常13 终止程序
缺页 异常14 返回当前地址
机器检查 异常18 终止程序
（2）Linux/IA32系统调用

每一个系统调用都有一个唯一的整数号，对应于一个到内核中跳转表的偏移量。

系统调用的实现方法：
在IA32中，系统调用通过一条陷阱指令提供：

int n;//n为异常号
所有的到Linux系统调用的参数都是通过寄存器传递的。惯例如下：

%eax：包含系统调用号
%ebx,%ecx,%edx,%esi,%edi,%ebp：包含最多六个任意参数
%esp：栈指针，不能使用

第二节 进程

进程的经典定义：一个执行中的程序的实例。

系统中的每个程序都是运行在某个进程的上下文中的。

※上下文：由程序正确运行所需的状态组成的。

进程提供给应用程序的关键抽象：

一个独立的逻辑控制流：独占的使用处理器
一个私有的地址空间：独占的使用存储器系统

1.逻辑控制流

（1）含义

一系列的程序计数器PC的值，分别唯一的对应于包含子啊程序的可执行目标文件中的指令，或者是包含在运行时动态链接到程序的共享对象中的指令，这个PC值的序列就叫做逻辑控制流。

（2）

参见图8-12，关键在于：

进程是轮流使用处理器的。每个进程执行它的流的一部分，然后被抢占，然后轮到其他进程。但是进程可以向每个程序提供一种假象，好像它在独占的使用处理器。

（3）逻辑流示例

异常处理程序、进程、信号处理程序、线程、Java进程

2.并发流

（1）含义

一个逻辑流的执行在时间上与另一个流重叠。【与是否在同一处理器无关】

这两个流并发的运行。

（2）几个概念

并发：多个流并发的执行
多任务：一个进程和其他进程轮流运行（也叫时间分片）
时间片：一个进程执行它的控制流的一部分的每一时间段
（3）并行

两个流并发的运行在不同的处理机核或者计算机上。

并行流并行的运行，并行的执行。

3.私有地址空间

进程为程序提供的假象，好像它独占的使用系统地址空间。一般而言，和这个空间中某个地址相关联的那个存储器字节是不能被其他进程读写的。

4.用户模式和内核模式

简单的说，用户模式和内核模式的区别就在于用户的权限上，权限指的是对系统资源使用的权限。

具体的区别是有无模式位，有的话就是内核模式，可以执行指令集中的所有指令，访问系统中任何存储器位置；没有就是用户模式。

进程从用户模式变为内核模式的唯一方法是通过异常——中断，故障，或者陷入系统调用。

Linux的聪明机制——/proc文件系统，将许多内核数据结构的内容输出为一个用户程序可以读的文本文件的层次结构。

但我在虚拟机中输入告诉我权限不够？

这个通过最后一节得知，是我输入方法不对，应该输入的是cat打印指令，再接后面的目录，如下图：

5.上下文切换

操作系统内核使用上下文切换这种较高层形式的异常控制流来实现多任务。上下文切换机制建立在较底层异常机制之上。

（1）上下文：内核重新启动一个被抢占的进程所需的状态。

由一些对象的值组成：

通用目的寄存器
浮点寄存器
程序计数器
用户栈
状态寄存器
内核栈
内核数据结构：页表、进程表、文件表
（2）调度和调度器

操作系统讲过。

（3）上下文切换机制

1.保存当前进程的上下文

2.恢复某个先前被抢占的进程被保存的上下文

3.将控制传递给这个新恢复的进程。

（4）可能发生上下文切换的原因：

内核代表用户执行系统调用时
中断
第三节 系统调用错误处理

这一节主要是附录A的内容的重复解释，在上周已经学习过。

简单总结就是，系统会使用错误处理包装函数，系统级函数是小写，他们的包装函数名大写，包装函数调用基本函数，有任何问题就终止，如果没有问题和基本函数是一样的。

需要注意的就是，检查错误的思想

第四节 进程控制

一、获取进程ID

每个进程都有一个唯一的正数进程ID(PID)。

`#include <sys/types.h>

include <unistd.h>`

pid_t getpid(void); 返回调用进程的PID
pid_t getppid(void); 返回父进程的PID（创建调用进程的进程）

二、创建和终止进程

1.进程总是处于下面三种状态之一

运行
停止：被挂起且不会被调度
终止：永远停止。原因：

1.收到信号，默认行为为终止进程
2.从主程序返回
3.调用exit函数
2.创建进程

父进程通过调用fork函数来创建一个新的运行子进程。fork函数定义如下：
`#include <sys/types.h>

include <unistd.h>`

pid_t fork(void)

fork函数只被调用一次，但是会返回两次：父进程返回子进程的PID，子进程返回0.如果失败返回-1.

`/* $begin fork */

include "csapp.h"

int main()
{
pid_t pid;
int x = 1;

pid = Fork(); //line:ecf:forkreturn
if (pid == 0) {  /* Child */
printf("child : x=%d\n", ++x); //line:ecf:childprint
exit(0);
}

/* Parent */
printf("parent: x=%d\n", --x); //line:ecf:parentprint
exit(0);

}
/* $end fork */`

调用一次，返回两次
并发执行，内核能够以任何方式交替执行它们的逻辑控制流中的指令
相同和不同：

相同：用户栈、本地变量值、堆、全局变量值、代码
不同：私有地址空间
共享文件：子进程继承了父进程所有的打开文件。参考10.6节笔记。

调用fork函数n次，产生2的n次方个进程。

3.终止进程

用exitinclude <stdlib.h>

void exit(int status); exit函数以status函数。

三、回收子进程

进程终止后还要被父进程回收，否则处于僵死状态。

如果父进程没有来得及回收，内核会安排init进程来回收他们。init进程的PID为1.

一个进程可以通过调用waitpid函数来等待它的子进程终止或停止。waitpid函数的定义如下：
`#include <sys/types.h>

include <sys/wait.h>

pid_t waitpid(pid_t pid, int *status, int options);`

成功返回子进程PID,如果WNOHANG,返回0，其他错误返回-1.

第五节 信号

Lunix信号：更高层的软件形式的异常允许进程中断其他进程。

信号术语

传递一个信号到目的进程的两个步骤：发送信号和接收信号。

发送信号的原因：

1.内核检测到一个系统事件
2.一个进程调用了kill函数，显式的要求内核发送一个信号给目的进程。
一个进程可以发送信号给它自己。

接收信号：

1.忽略
2.终止
3.执行信号处理程序，捕获信号
待处理信号：

只发出没有被接收的信号
任何时刻，一种类型至多只会有一个待处理信号，多的会被直接丢弃
一个进程可以选择性的阻塞接受某种信号，被阻塞仍可以被发送，但是不会被接收
一个待处理信号最多只能被接收一次。
pending：待处理信号集合
blocked：被阻塞信号集合。

课后作业及实现

进程A和B是互相并发的，就像B和C一样，因为它们各自的执行是重叠的，也就是一个进程在另一个进程结束前开始。进程A和C不是并发的，因为它们的执行没有重叠;A在C开始之前就结束了。

A.这里的关键点是子进程执行了两个prin七f语句。在fork返回之后，它执行了第8行的prin七fe然后它从if语句中出来，执行了第9行的printf语句。下面是子进程产生的输出:printfl:x=2 printf2: x=1
B.父进程只执行了第9行的printf:printf2: x=0

父进程打印b，然后是c。子进程打印a，然后是c。意识到你不能对父进程和子进程是如何交错执行的做任何假设是非常重要的。因此，任何满足b}c和a -- c的拓扑排序都是可能的输出序列。有四个这样的序列:acbc, bcac, abcc和bacco

A.每次我们运行这个程序，就会产生6个输出行。 B.输出行的顺序根据系统不同而不同，取决于内核如何交替执行父子进程的指令。一般而言，满足下图的任意拓扑排序都是合法的顺序:
比如unix>Hello01Bye2Bye当我们在系统上运行这个程序时，会得到下面的输出:

unix> ./waitprob1

Hello

0

1

Bye

2

Bye

在这种情况下，父进程首先运行，在第6行打印''Hello''，在第8行打印“0”。对wait的调用会阻塞，因为子进程还没有终止，所以内核执行一个上下文切换，并将控制传递给子进程，子进程在第8行打印''1''，在第15行打印''Bye''，然后在第16行终止，退出状态为2。在子进程终止后，父进程继续，在第12行打印子进程的退出状态，在第15行打印''Bye''。

只要休眠进程收到一个未被忽略的信号，sleep函数就会提前返回。但是，因为收到一个SIGINT信号的默认行为就是终止进程(见图8-25 )，我们必须设置一个SIGINT处理程序来允许sleep函数返回。处理程序简单地捕获SIGNAL，并将控制返回给sleep函数，该函数会立即返回。

这个程序打印字符串“213"，这是卡内基梅隆大学CS:APP课程的缩写名。父进程开始时打印''2''，然后创建子进程，子进程会陷入一个无限循环。然后父进程向子进程发送一个信号，并等待它终止。子进程捕获这个信号(中断这个无限循环)，对计数器值(从初始值2)减一，打印''1"，然后终止。在父进程回收子进程之后，它对计数器值(从初始值2)加一，打印，''3''，并且终止。