【学习总结】用户态与内核态

最新推荐文章于 2022-05-18 17:16:15 发布

王常胜

最新推荐文章于 2022-05-18 17:16:15 发布

阅读量521

点赞数

原文链接：https://www.cnblogs.com/bakari/p/5520860.html

版权

操作系统专栏收录该内容

6 篇文章 0 订阅

订阅专栏

参考链接

Linux探秘之用户态与内核态
 用户态与内核态的切换

一、 Unix/Linux的体系架构

内核从本质上看是一种软件——控制计算机的硬件资源，并提供上层应用程序运行的环境。

如上图所示，从宏观上来看，Linux操作系统的体系架构分为用户态和内核态（或者用户空间和内核）。
用户态即上层应用程序的活动空间，应用程序的执行必须依托于内核提供的资源，包括CPU资源、存储资源、I/O资源等。为了使上层应用能够访问到这些资源，内核必须为上层应用提供访问的接口：即系统调用。

系统调用是操作系统的最小功能单位

系统调用根据不同的应用场景可以进行扩展和裁剪，现在各种版本的Unix实现都提供了不同数量的系统调用，如Linux的不同版本提供了240-260个系统调用，FreeBSD大约提供了320个（reference：UNIX环境高级编程）。我们可以把系统调用看成是一种不能再化简的操作（类似于原子操作，但是不同概念），有人把它比作一个汉字的一个“笔画”，而一个“汉字”就代表一个上层应用，我觉得这个比喻非常贴切。因此，有时候如果要实现一个完整的汉字（给某个变量分配内存空间），就必须调用很多的系统调用。如果从实现者（程序员）的角度来看，这势必会加重程序员的负担，良好的程序设计方法是：重视上层的业务逻辑操作，而尽可能避免底层复杂的实现细节。库函数正是为了将程序员从复杂的细节中解脱出来而提出的一种有效方法。它实现对系统调用的封装，将简单的业务逻辑接口呈现给用户，方便用户调用，从这个角度上看，库函数就像是组成汉字的“偏旁”。这样的一种组成方式极大增强了程序设计的灵活性，对于简单的操作，我们可以直接调用系统调用来访问资源，如“人”，对于复杂操作，我们借助于库函数来实现，如“仁”。显然，这样的库函数依据不同的标准也可以有不同的实现版本，如ISO C 标准库，POSIX标准库等。

Shell是一个特殊的应用程序，俗称命令行，本质上是一个命令解释器，它下通系统调用，上通各种应用，通常充当着一种“胶水”的角色，来连接各个小功能程序，让不同程序能够以一个清晰的接口协同工作，从而增强各个程序的功能。同时，Shell是可编程的，它可以执行符合Shell语法的文本，这样的文本称为Shell脚本，通常短短的几行Shell脚本就可以实现一个非常大的功能，原因就是这些Shell语句通常都对系统调用做了一层封装。为了方便用户和系统交互，一般，一个Shell对应一个终端，终端是一个硬件设备，呈现给用户的是一个图形化窗口。我们可以通过这个窗口输入或者输出文本。这个文本直接传递给shell进行分析解释，然后执行。

总结一下，用户态的应用程序可以通过三种方式来访问内核态的资源：

1.系统调用
2.库函数
3.Shell脚本

下图是对上图的一个细分结构，从这个图上可以更进一步对内核所做的事有一个“全景式”的印象。主要表现为：向下控制硬件资源，向内管理操作系统资源：包括进程的调度和管理、内存的管理、文件系统的管理、设备驱动程序的管理以及网络资源的管理，向上则向应用程序提供系统调用的接口。从整体上来看，整个操作系统分为两层：用户态和内核态，这种分层的架构极大地提高了资源管理的可扩展性和灵活性，而且方便用户对资源的调用和集中式的管理，带来一定的安全性。
细分结构

二、特权级

熟悉Unix/Linux系统的人都知道，fork的工作实际上是以系统调用的方式完成相应功能的，具体的工作是由sys_fork负责实施。其实无论是不是Unix或者Linux，对于任何操作系统来说，创建一个新的进程都是属于核心功能，因为它要做很多底层细致地工作，消耗系统的物理资源，比如分配物理内存，从父进程拷贝相关信息，拷贝设置页目录页表等等，这些显然不能随便让哪个程序就能去做，于是就自然引出特权级别的概念，显然，最关键性的权力必须由高特权级的程序来执行，这样才可以做到集中管理，减少有限资源的访问和使用冲突。
特权级显然是非常有效的管理和控制程序执行的手段，因此在硬件上对特权级做了很多支持，就Intel x86架构的CPU来说一共有0~3四个特权级，0级最高，3级最低，硬件上在执行每条指令时都会对指令所具有的特权级做相应的检查，相关的概念有CPL、DPL和RPL，这里不再过多阐述。硬件已经提供了一套特权级使用的相关机制，软件自然就是好好利用的问题，这属于操作系统要做的事情，对于Unix/Linux来说，只使用了0级特权级和3级特权级。也就是说在Unix/Linux系统中，一条工作在0级特权级的指令具有了CPU能提供的最高权力，而一条工作在3级特权级的指令具有CPU提供的最低或者说最基本权力。

三、用户态和内核态的切换

因为操作系统的资源是有限的，如果访问资源的操作过多，必然会消耗过多的资源，而且如果不对这些操作加以区分，很可能造成资源访问的冲突。所以，为了减少有限资源的访问和使用冲突，Unix/Linux的设计哲学之一就是：对不同的操作赋予不同的执行等级，就是所谓特权的概念。简单说就是有多大能力做多大的事，与系统相关的一些特别关键的操作必须由最高特权的程序来完成。Intel的X86架构的CPU提供了0到3四个特权级，数字越小，特权越高，Linux操作系统中主要采用了0和3两个特权级，分别对应的就是内核态和用户态。运行于用户态的进程可以执行的操作和访问的资源都会受到极大的限制，而运行在内核态的进程则可以执行任何操作并且在资源的使用上没有限制。很多程序开始时运行于用户态，但在执行的过程中，一些操作需要在内核权限下才能执行，这就涉及到一个从用户态切换到内核态的过程。比如C函数库中的内存分配函数malloc()，它具体是使用sbrk()系统调用来分配内存，当malloc调用sbrk()的时候就涉及一次从用户态到内核态的切换，类似的函数还有printf()，调用的是wirte()系统调用来输出字符串，等等。
状态切换
到底在什么情况下会发生从用户态到内核态的切换，一般存在以下三种情况：

1.当然就是系统调用：原因如上的分析。
2.异常事件：当CPU正在执行运行在用户态的程序时，突然发生某些预先不可知的异常事件，这个时候就会触发从当前用户态执行的进程转向内核态执行相关的异常事件，典型的如缺页异常。
3.外围设备的中断：当外围设备完成用户的请求操作后，会像CPU发出中断信号，此时，CPU就会暂停执行下一条即将要执行的指令，转而去执行中断信号对应的处理程序，如果先前执行的指令是在用户态下，则自然就发生从用户态到内核态的转换。

注意：系统调用的本质其实也是中断，相对于外围设备的硬中断，这种中断称为软中断，这是操作系统为用户特别开放的一种中断，如Linux int 80h中断。所以，从触发方式和效果上来看，这三种切换方式是完全一样的，都相当于是执行了一个中断响应的过程。但是从触发的对象来看，系统调用是进程主动请求切换的，而异常和硬中断则是被动的。

具体切换操作：
从触发方式上看，可以认为存在前述3种不同的类型，但是从最终实际完成由用户态到内核态的切换操作上来说，涉及的关键步骤是完全一致的，没有任何区别，都相当于执行了一个中断响应的过程，因为系统调用实际上最终是中断机制实现的，而异常和中断的处理机制基本上也是一致的，关于它们的具体区别这里不再赘述。关于中断处理机制的细节和步骤这里也不做过多分析，涉及到由用户态切换到内核态的步骤主要包括：

[1] 从当前进程的描述符中提取其内核栈的ss0及esp0信息。
[2] 使用ss0和esp0指向的内核栈将当前进程的cs,eip,eflags,ss,esp信息保存起来，这个过程也完成了由用户栈到内核栈的切换过程，同时保存了被暂停执行的程序的下一条指令。
[3] 将先前由中断向量检索得到的中断处理程序的cs,eip信息装入相应的寄存器，开始执行中断处理程序，这时就转到了内核态的程序执行了。

四、用户态切换到内核态的变化

研究x86体系下Linux系统中用户态到内核态切换条件，及切换过程中内核栈和任务状态段TSS在中断机制/任务切换中的作用及相关寄存器的变化。

1.用户态到内核态的切换途径

系统调用
中断
异常

对应代码，在3.3内核中，可以在/arch/x86/kernel/entry_32.S文件中查看。

2. 内核栈

内核栈：Linux中每个进程有两个栈，分别用于用户态和内核态的进程执行，其中的内核栈就是用于内核态的堆栈，它和进程的task_struct结构，更具体的是thread_info结构一起放在两个连续的页框大小的空间内。
在内核源代码中使用C语言定义了一个联合结构方便地表示一个进程的thread_info和内核栈：

//此结构在3.3内核版本中的定义在include/linux/sched.h文件的第2106行
2106	union thread_union {
2107		struct thread_info thread_info;
2108		unsigned long stack[THREAD_SIZE/sizeof(long)];
2109	};

thread_info结构定义如下：

//此结构在3.3内核 /arch/x86/include/asm/thread_info.h文件第26行
26	struct thread_info {
27		struct task_struct	*task;		/* main task structure */
28		struct exec_domain	*exec_domain;	/* execution domain */
29		__u32			flags;		/* low level flags */
30		__u32			status;		/* thread synchronous flags */
31		__u32			cpu;		/* current CPU */
32		int			preempt_count;	/* 0=> preemptable, 
33								<0 =>BUG */	
34		mm_segment_t		addr_limit;
35		struct restart_block	restart_block;
36		void __user		*sysenter_return;
37 #ifdef	CONFIG_X86_32
38		unsigned long		previous_esp;	/* ESP of the previous stack in
39							     case of nested (IRQ) stacks
40							*/
41		__u8			supervisor_stack[0];
42 #endif
43		unsigned int 		sig_on_uaccess_eror:1;
44		unsigned int 		uaccess_err:1;	/* uaccess failed */
45	};

它们的结构图大致如下：

esp寄存器是CPU栈指针，存放内核栈栈顶地址。在X86体系中，栈开始于末端，并朝内存区开始的方向增长。从用户态刚切换到内核态时，进程的内核栈总是空的，此时esp指向这个栈的顶端。
　　在X86中调用int指令型系统调用后会把用户栈的%esp的值及相关寄存器压入内核栈中，系统调用通过iret指令返回，在返回之前会从内核栈弹出用户栈的%esp和寄存器的状态，然后进行恢复。所以在进入内核态之前要保存进程的上下文，中断结束后恢复进程上下文，那靠的就是内核栈。
　　这里有个细节问题，就是要想在内核栈保存用户态的esp,eip等寄存器的值，首先得知道内核栈的栈指针，那在进入内核态之前，通过什么才能获得内核栈的栈指针呢？答案是：TSS

3. TSS( 任务状态段)

X86体系结构中包括了一个特殊的段类型：任务状态段（TSS），用它来存放硬件上下文。TSS反映了CPU上的当前进程的特权级。
linux为每一个cpu提供一个tss段，并且在tr寄存器中保存该段。
在从用户态切换到内核态时，可以通过获取TSS段中的esp0来获取当前进程的内核栈栈顶指针，从而可以保存用户态的cs,esp,eip等上下文。

注：linux中之所以为每一个cpu提供一个tss段，而不是为每个进程提供一个tss段，主要原因是tr寄存器永远指向它，在任务切换的适合不必切换tr寄存器，从而减小开销。

下面我们看下在X86体系中Linux内核对TSS的具体实现：
内核代码中TSS结构的定义：

//3.3内核中：/arch/x86/include/asm/processor.h文件的第248行处
248	struct tss_struct {
249		/*
250		* The hardware state;
251		*/
252		struct x86_hw_tss	x86_tss;
253
254		/*
255		* The extra 1 is there bacause the CPU will access an
256		* additional byte beyond the end of the IO permission
257		* bitmap. The extra byte must be all 1 bits, and must
258		* be within the limit.
259		*/
260		unsigned long		io_bitmap[IO_BITMAO_LONGS +1];
261
262		/*
263		* .. and then another 0x100 bytes for the emergency kernel stack:
264		*/
265		unsigned long		stack[64];
266
267	} ____cacheline_aligned;

其中主要的内容是：
硬件状态结构 : x86_hw_tss
IO权位图 :　　　　io_bitmap
备用内核栈：　　 stack

其中硬件状态结构：其中在32位X86系统中x86_hw_tss的具体定义如下：

// /arch/x86/include/asm/processor.h文件中第190行处
190 #ifdef CONFIG_X86_32
191 /* This is the TSS defined by the hardware. */
192 struct x86_hw_tss {
193		unsigned short		back_link, __bln;
194		unsigned long		sp0;		//当前进程的内核栈顶指针
195		unsigned short   	ss0, __ss0h;	//当前进程的内核栈段描述符
196		unsigned long		sp1;
197		/* ss1 caches MSR_IA32_SYSENTER_CS: */
198		unsigned short		ss1, __ss1h;
199		unsigned long		sp2;
200		unsigned short   	ss2,__ss2h;
201		unsigned long		__cr3;
202		unsigned long		ip;
203		unsigned long		flags;
204		unsigned long		ax;
205		unsigned long		cx;
206		unsigned long		dx;
207		unsigned long		bx;
208		unsigned long		sp;		//当前进程用户态栈顶指针
209		unsigned long		bp;
210		unsigned long   	si;
211		unsigned long		di;
212		unsigned short		es, __esh;
213		unsigned short		cs, __csh;
214		unsigned short		ss, __ssh;
215		unsigned short		ds, __dsh;
216		unsigned short		fs, __fsh;
217		unsigned short		gs, __gsh;
218		unsigned short		ldt, __ldth;
219		unsigned short		trace;
220		unsigned short		io_bitmap_base;
221
222 	} __attribute__((packed));

linux的tss段中只使用esp0和iomap等字段，并且不用它的其他字段来保存寄存器，在一个用户进程被中断进入内核态的时候，从tss中的硬件状态结构中取出esp0（即内核栈栈顶指针），然后切到esp0，其它的寄存器则保存在esp0指的内核栈上而不保存在tss中。

每个CPU定义一个TSS段的具体实现代码：

//3.3内核中/arch/x86/kernel/init_task.c第35行
35	* per-CPU TSS segments. Threads are completely 'sosf' on Linux,
36	* no more per-task TSS's. The TSS size is kept cacheline-aligned
37	* so they are allowed to end up in the .data..cacheline_aligned
38	* section. Since TSS's are completely CPU-local, we want them
39	* on exact cacheline boundaries, to eliminate cacheline ping-pong.
40 	*/

41	DEFINE_PER_CPU_SHARED_ALIGNED(struct tss_struct, init_tss) = INIT_TSS;

INIT_TSS 的定义如下：

//3.3内核中 /arch/x86/include/asm/processor.h文件的第879行
879 #define INIT_TSS {
880	.x86_tss = {
881		.sp0 = sizeof(init_stack) + (long)&init_stack,
882		.ss0 = __KERNEL_DS,
883		.ss1 = __KERNEK_CS,
884		.io_bitmap_base = INVALID_IO_BITMAP_OFFSET,
885		 },
886	.io_bitmap = { [0 ... IO_BITMAP_LONGS] =~0 },
887	}

其中init_stack是宏定义，指向内核栈：

61 #define init_stack 		(init_thread_union.stack)

这里可以看到分别把内核栈栈顶指针、内核代码段、内核数据段赋值给TSS中的相应项。从而进程从用户态切换到内核态时，可以从TSS段中获取内核栈栈顶指针，进而保存进程上下文到内核栈中。

4. 总结

在进程从用户态到内核态切换过程中，Linux主要做的事：

读取tr寄存器，访问TSS段
从TSS段中的sp0获取进程内核栈的栈顶指针
由控制单元在内核栈中保存当前eflags,cs,ss,eip,esp寄存器的值。
由SAVE_ALL保存其寄存器的值到内核栈
把内核代码选择符写入CS寄存器，内核栈指针写入ESP寄存器，把内核入口点的线性地址写入EIP寄存器
此时，CPU已经切换到内核态，根据EIP中的值开始执行内核入口点的第一条指令