当前课程知识点:操作系统 >  第三讲 启动、中断、异常和系统调用 >  3.3 中断、异常和系统调用比较 >  3.3 中断、异常和系统调用比较

返回《操作系统》慕课在线视频课程列表

3.3 中断、异常和系统调用比较在线视频

3.3 中断、异常和系统调用比较

下一节:3.4 系统调用

返回《操作系统》慕课在线视频列表

3.3 中断、异常和系统调用比较课程教案、知识点、字幕

好 接下来我们介绍中断异常和系统调用

那在这里呢 我们会说中断异常和系统调用

它到底是用来干什么 解决什么问题

然后这几个的应用场景

或者说他们之间有些什么样的区别和联系

它在用处的时候 它们之间会有一些差异

但是也有很多会共同的东西

再一个就是说我们需要来说明

中断异常和系统调用它的实现机制

首先我们说在上前边的内容里头已经说过

操作系统 计算机系统启来了之后

它会加载操作系统的内核

然后就把控制权转给操作系统内核了

在这前面这一段呢 是可以信任的

但是在操作系统内核之上呢

实际上我们还有很多的应用程序

这些应用程序我们没有办法

对它做到完全的信任

而这应用程序要使用操作系统内核提供的服务

那这时候怎么办呢

实际上我们就需要解决一个操作系统内核

和外界打交道的问题

那我们说操作系统内核是可以信赖的

我可以在里做对计算机系统里的任何内容的控制

可以执行它的特权指令 这种信任呢

并不是它跟外界完全的隔离

它还需要为上边的应用程序提供服务

也就是说我可以信任的内核

它必须对外界提供某种访问的接口

或者打交道的通道 然后再一个呢

我们除了会是跟应用程序打交道之外

我们在程序或者计算机系统

在运行过程当中会有各种各样的问题

比如说我在外设

你在跟他做交互的时候你敲键盘

我并不能确认 你会在什么时间

准确的一个什么时间点去敲键盘

你敲了键盘之后 可能我的系统正在干别的事

这时候我没办法给你做出响应

那这样的话就会让你感觉

这个计算机系统很不好用

所以为了能够让计算机系统

能够对外界做出适当的反映

我们需要提出中断机制

也就是说当外设与系统有交互的时候

我需要怎么来处理

还有一种情况呢

是说我的应用程序在执行过程当中

比如说我做除法 除了一个零

那这时候是要出问题呢

而是否会除零呢

我只有执行到那一步的时候我才知道

好 等到这个时候你再知道的话

那我已经没办法往下做了

所以总会有一些意外情况

我在事先写程序的时候我是没办法预料到的

对于这种意外的情况

我们怎么来处理 所以在我们这里呢

通常的做法是说应用程序提供你所需要的功能

那里头的异常呢 这种意外的情况呢

把它控制权转给操作系统

由操作系统来处理它

这是我们这里说到的应用程序执行当中意外

有异常来做处理 那还有一种情况呢

是说我们要解决用户程序如何来解决系统的服务

就好象说我们提供给银行对外提供服务

银行为了保证安全 所以它有很多的防护

这个防护又和对外提供服务这是有矛盾的

为了方便用户来使用银行的服务

你必须提供灵活的访问接口

但是这种灵活的接口 又不能影响到银行的安全

操作系统内核也是一样的

我们需要来通过系统调用来提供一个接口

让应用程序既方便的使用内核提供的服务

又不至于用户的行为对我内核的安全产生影响

那也就是说使用服务呢 我们有很多种方式

那在这里头呢 用内核提供服务

和我们通常写程序的时候用函数库

来提供服务有啥区别 那这是我们在这里呢

你在选择用系统调用 还是用函数库的时候

需要做出的判断

好 有了刚才这些问题我们来看

用下边这个图来看一下

内核和外界之间打交道的地方

这是我们内核 然后我们在里呢

提供了相应的一些内核服务 这些内核服务

首先会是说跟外界的硬件打交道

比如说我敲了键盘 那我在敲下一个键的时候

可能里头会有一个缓冲区

缓冲区的大小是有限制的

那存多了 前边的内容就会丢

好 那我在这里呢 有数据之后

我就必须告诉操作系统

那你在这里面及时把我的数据读走

否则的话

后边来的数据就会丢了 那这时候呢

有一条通道 那这就是我们这里的中断

好中断 通知内核 内核通过驱动

来与你的设备进行数据的交互

比如说键盘我是读进去 磁盘的话

即是会有读有写 然后还有一种情况是说

应用程序在执行的过程当中

好 正常执行 那跟内核没关系

好 执行到某一个位置的时候

比如说某条指令做除法 除了个零

或者说一条存储访问指令

访问到某一个存储单元

但这个存储单元是不允许你访问的

就好比说储户你想说银行里有你的钱

你就想直接去开银行的保险柜

把你的钱取出来 那这是不行的

对于这种情况呢

我们在这里跟操作系统是类似的

它会提供一个异常机制

那我们把这些情况都认为

是你代码执行过程当中的出错

有些错误呢 实际上是我们事先有预计的

好 那这时候呢 把空闲交到内核

内核可能做出的处理呢

要么说我把你遇到的问题解决掉

比如说你访问到的某一个存储单元

原来的存储单元不存在

好 那我把原来的存储单元的内容放到内存里头

OK 对于虚拟存储来讲

这时候你就可以执行了

而另外一些问题 比如说像是除零之类的

那你这时候除零 我就没有办法继续下去

这时候我就会把应用程序

所占这些资源还给操作系统

那这是我们异常 那最主要的一类呢

是正常情况下的使用

应用程序会使用到函数库

那这时候跟内核不打交道

但是内核 应用程序或者函数库

会间接的通过系统调用接口

使用到操作系统内核的服务

比如说我要读写文件

那我应用程序不能直接访问磁盘设备

它怎么办呢 发出操作系统

提供了一个磁盘读写的一个系统调用接口

好 那应用程序通过调用这个

读写接口所提供的这个函数

好 那这时候进到内核里头来

内核把相应的数据读出来

还给应用程序 那这个流程就结束了

所以从这我们可以看到

操作系统内核和外界打交道基本上就是中断

异常和系统调用这三个接口

这是我们在这里说到这三条

从这三条我们就可以看到

中断 异常和系统调用他们之间

到底有什么样的定义

系统调用是应用程序

主动向操作系统发出的服务请求

而异常呢 是非法指令或者其他原因

导致的指令执行失败之后的处理请求

那这种处理请求呢 可能会是说我终止程序

也可能会是说解决你遇到的问题

然后重新执行这条指令 而中断呢

是硬件设备对操作系统提出的处理请求

比如说我缓冲区里有数据

需要内核把它读走

或者说我缓冲区里的数据已经全部用完

需要内核补充新的数据

那这里我们说到的中断异常和系统调用

那这三者之间的区别到底怎么来描述呢

我们可以从这样几条来区别

第一个是它的源头 那在这呢

我们标出了系统调用的触发条件

中断的起头和异常的起头

这三个分别对应着我们这里的来源不同

外设 应用程序 实际上这个异常

在这个图里描述是适宜性的

我在执行内核代码的时候

也可能由于代码的执行出现问题

这时候呢 也可能是内部出现的

然后第二个呢 是他们的响应方式不一样

那这三个箭头分别对应着系统 调用

中断和异常的响应方式 那系统调用呢

通常情况下我们会是同步的或者异步的

也就是说应用程序发出系统调用请求

然后它就在那等着了

一直到你算完内核服务完成之后给它结果

那也可能是异步的

说我们在这里系统调用发出了之后

你内核在处理时候

处理的过程当中

我就切换过去干别的事情过去了

然后等到其他条件准备之后

你这才会回来 而中断的它是异步的

也就是说你上边应用程序

该怎么做处理怎么做处理

我不会感知到中断的存在

那中断只是在应用程序暂停执行

处理完中断所需要的服务之后

继续恢复你应用程序的执行

就跟没有这件事情一样

而异常是跟你的这个当前指令有关的

这个是同步的 也就是说必须处理完

当前这条异常所产生的指令所导致的问题

我才可以继续下去 那当然他们之间的处理呢

会都在内核里头来做

但他们的处理也会有一些区别

中断会持续的进行

而系统调用它会是用户提出之后会处理

等待然后再继续 而异常呢

是会处理当前所出现的问题

那具体说起来 中断的处理

那这个中断实际上我们把它理解为

系统调用异常和中断这三种情况的总称

对于硬件上的处理呢

这主要是在硬件中那个地方

在CPU做初始化的时候

它其中就有一项工作 要对中断使能

也就是说在许可外界打扰CPU的执行之前

CPU是不会对外界的任何中断请求发出响应的

那只有我CPU把相应的准备工作做完

外界来一个请求之后 我知道怎么处理了

我才会允许这种处理

如果我不知道怎么处理的话

你给我一个请求 我也不知道怎么办

所以在这 在初始化的时候

它有一个中断使能 使能之后

我才能够进行中断的处理

第二个是说这个事件产生了

产生了之后通常是一个电平的上升沿

或者说是一个高电平

那CPU会记录下这件事情

也就是说我有一个中断标志

表示出现了一个中断

然后这时候我需要知道中断

到底是由什么设备产生的

需要知道中断源的编号

这一部分工作是由硬件来做的

好 硬件做完这一部分工作之后

剩下的事情就是由内核的软件来做

那在这里头呢

也就是说这几个进来都到了这个中断向量表

中断向量表如果是中断

那它直接绕到这边的中断服务例程

驱动程序里来做出响应

如果是异常 它直接转到异常服务例程来做处理

如果说是系统调用 由于系统调用的量很大

那我们在这儿 系统调用之后

系统调用它之后总共占用一个中断编号

然后它自己的不同的系统调用的功能呢

是用系统调用表来表示的

好 在这呢 根据你系统调用表里的

功能的选择不同

我去选择不同的系统调用实现

那么在这个过程里头呢

我为了不影响程序的正常执行

我前边有一个保护现场和恢复现场

而在这里头呢 要做系统调用的交互

我还需要知道系统调用产生之前

我准备的上下文的信息 比如说你到底让我干啥

那这一部分工作呢 是会和你的编译有关系

然后中间这一部分到底如何实现

那这个是由操作系统来做的

然后如果是中断的话

那么你在执行的过程当中

需要清除这个中断标志

这个也是由你的中断服务例程来完成的

好 我们说中断可以满足应用程序

外部设备 或者程序执行异常的服务请求

那这时候可能会出现一种情况

我正在处理一个请求的时候

有来了一个请求这时候我怎么办

那我们说在操作系统的里头呢

它是硬件的中断 它是允许被打断的

也就是说我正在处理一个中断的时候

可以允许你再出现其他的中断

如果两个中断源不同 那这时候呢

我可以通过优先级的高低

让一个往后推一段

或者说让一个暂停下来

那使得我可以同时在做

交替在做处理 然后在中断服务例程里头

并不是说我任何一个时刻都可以做任何一个处理

它会在一定的时间里呢

禁止中断请求 比如说我电源有问题

那可能其他的问题就变得不重要了

这时候我在做电源的处理的时候

我就会禁止掉其他中断

然后中断服务请求会一直保持到CPU做出响应

然后对于异常呢 我也可以被打断

你比如说我在程序执行当中出现了异常

这时候正在做异常的处理

比如说我在这里头虚拟存储里头

它访问到的存储单元的数据不存在

我正在从硬盘上倒数据进来

倒的过程当中 它会用到磁盘I/O

这时候也会再有磁盘设备的中断

这时候是允许它可以做嵌套的

然后对于异常服务的嵌套呢

这是我们说到的 异常服务和缺页

这两个在异常服务里头还会再出现异常

也就是说我执行中断

执行异常处理例程里头

有一段存储访问它是缺页的

那这时候两个异常也是可以嵌套到一起

操作系统课程列表:

第零讲 在线教学环境准备

-0.1 Piazza讨论区

--piazza访问和使用

--html

-0.2 在线实验平台

--实验平台使用帮助

--平台使用帮助

--Gitlab使用帮助

--IBM内部账号初始化

-0.2在线实验平台

--Raw HTML

第一讲 操作系统概述

-1.1 课程概述

--视频

-第一讲 操作系统概述--练习

-1.2 教学安排

--视频

-1.3 什么是操作系统

--Video

-1.4 为什么学习操作系统,如何学习操作系统

--Video

-1.5 操作系统实例

--视频

-1.6 操作系统的演变

--视频

-1.7 操作系统结构

--视频

第二讲 实验零 操作系统实验环境准备

-2.1 前言和国内外现状

--2.1 前言和国内外现状

-2.2 OS实验目标

--2.2 OS实验目标

-2.3 8个OS实验概述

--2.3 8个OS实验概述

-2.4 实验环境搭建

--2.4 实验环境搭建

-2.5 x86-32硬件介绍

--2.5 x86-32硬件介绍

-2.6 ucore部分编程技巧

--2.6 ucore部分编程技巧

-2.7 演示实验操作过程

--2.7 演示实验操作过程

--Q6

--Q7

--Q10

第三讲 启动、中断、异常和系统调用

-3.1 BIOS

--3.1 BIOS

-3.2 系统启动流程

--3.2 系统启动流程

-3.3 中断、异常和系统调用比较

--3.3 中断、异常和系统调用比较

-第三讲 启动、中断、异常和系统调用--3.3 中断、异常和系统调用比较

-3.4 系统调用

--3.4 系统调用

-第三讲 启动、中断、异常和系统调用--3.4 系统调用

-3.5 系统调用示例

--3.5 系统调用示例

-3.6 ucore+系统调用代码

--3.6 ucore+系统调用代码

第四讲 实验一 bootloader启动ucore os

-4.1 启动顺序

--4.1 启动顺序

-4.2 C函数调用的实现

--4.2 C函数调用的实现

-4.3 GCC内联汇编

--4.3 GCC内联汇编

-4.4 x86中断处理过程

--4.4 x86中断处理过程

-4.5 练习一

--4.5 练习一

-4.6 练习二

--4.6 练习二

-4.7 练习三

--4.7 练习三

-4.8 练习四 练习五

--4.8 练习四练习五

-4.9 练习六

--4.9 练习六

第五讲 物理内存管理: 连续内存分配

-5.1 计算机体系结构和内存层次

--5.1 计算机体系结构和内存层次

-5.2 地址空间和地址生成

--5.2 地址空间和地址生成

-5.3 连续内存分配

--5.3 连续内存分配

-5.4 碎片整理

--5.4 碎片整理

-5.5 伙伴系统

--5.5 伙伴系统

-第五讲 物理内存管理: 连续内存分配--5.6 练习

第六讲 物理内存管理: 非连续内存分配

-6.1 非连续内存分配的需求背景

--6.1 非连续内存分配的需求背景

-6.2 段式存储管理

-- 6.2 段式存储管理

-6.3 页式存储管理

--6.3 页式存储管理

-6.4 页表概述

--6.4 页表概述

-6.5 快表和多级页表

--6.5 快表和多级页表

-6.6 反置页表

--6.6 反置页表

-6.7 段页式存储管理

--6.7 段页式存储管理

-第六讲 物理内存管理: 非连续内存分配--6.8 练习

第七讲 实验二 物理内存管理

-7.1 了解x86保护模式中的特权级

--7.1 了解x86保护模式中的特权级

-第七讲 实验二 物理内存管理--7.1 了解x86保护模式中的特权级

-7.2 了解特权级切换过程

--7.2 了解特权级切换过程

-第七讲 实验二 物理内存管理--7.2 了解特权级切换过程

-7.3 了解段/页表

--7.3 了解段/页表

-第七讲 实验二 物理内存管理--7.3 了解段/页表

-7.4 了解UCORE建立段/页表

--7.4 了解ucore建立段/页表

-第七讲 实验二 物理内存管理--7.4 了解UCORE建立段/页表

-7.5 演示lab2实验环节

--7.5 演示lab2实验环节

第八讲 虚拟存储概念

-8.1 虚拟存储的需求背景

--8.1 虚拟存储的需求背景

-8.2 覆盖和交换

--8.2 覆盖和交换

-8.3 局部性原理

--8.3 局部性原理

-8.4 虚拟存储概念

--8.4 虚拟存储概念

-8.5 虚拟页式存储

--8.5 虚拟页式存储

-8.6 缺页异常

--8.6 缺页异常

第九讲 页面置换算法

-9.1 页面置换算法的概念

--9.1 页面置换算法的概念

-9.2 最优算法、先进先出算法和最近最久未使用算法

--9.2 最优算法、先进先出算法和最近最久未使用算法

-第九讲 页面置换算法--9.2 最优算法、先进先出算法和最近最久未使用算法

-9.3 时钟置换算法和最不常用算法

--9.3 时钟置换算法和最不常用算法

-第九讲 页面置换算法--9.3 时钟置换算法和最不常用算法

-9.4 Belady现象和局部置换算法比较

--9.4 Belady现象和局部置换算法比较

-第九讲 页面置换算法--9.4 Belady现象和局部置换算法比较

-9.5 工作集置换算法

--9.5 工作集置换算法

-第九讲 页面置换算法--9.5 工作集置换算法

-9.6 缺页率置换算法

--9.6 缺页率置换算法

-第九讲 页面置换算法--9.6 缺页率置换算法

-9.7 抖动和负载控制

--9.7 抖动和负载控制

第十讲 实验三 虚拟内存管理

-10.1 实验目标:虚存管理

--10.1 实验目标:虚存管理

-第十讲 实验三 虚拟内存管理--10.1 实验目标:虚存管理

-10.2 回顾历史和了解当下

-- 10.2 回顾历史和了解当下

-第十讲 实验三 虚拟内存管理--10.2 回顾历史和了解当下

-10.3 处理流程、关键数据结构和功能

--10.3 处理流程、关键数据结构和功能

-第十讲 实验三 虚拟内存管理--10.3 处理流程、关键数据结构和功能

-10.4 页访问异常

--10.4 页访问异常

-第十讲 实验三 虚拟内存管理--10.4 页访问异常

-10.5 页换入换出机制

--10.5 页换入换出机制

-第十讲 实验三 虚拟内存管理--10.5 页换入换出机制

第十一讲 进程和线程

-11.1 进程的概念

--11.1 进程的概念

-第十一讲 进程和线程--11.1 进程的概念

-11.2 进程控制块

--11.2 进程控制块

-第十一讲 进程和线程--11.2 进程控制块

-11.3 进程状态

--11.3 进程状态

-第十一讲 进程和线程--11.3 进程状态

-11.4 三状态进程模型

--11.4 三状态进程模型

-11.5 挂起进程模型

--11.5 挂起进程模型

-第十一讲 进程和线程--11.5 挂起进程模型

-11.6 线程的概念

--11.6 线程的概念

-第十一讲 进程和线程--11.6 线程的概念

-11.7 用户线程

--11.7 用户线程

-第十一讲 进程和线程--11.7 用户线程

-11.8 内核线程

--11.8 内核线程

-第十一讲 进程和线程--11.8 内核线程

第十二讲 进程控制

-12.1 进程切换

--12.1 进程切换

-第十二讲 进程控制--12.1 进程切换

-12.2 进程创建

--12.2 进程创建

-第十二讲 进程控制--12.2 进程创建

-12.3 进程加载

--12.3 进程加载

-第十二讲 进程控制--12.3 进程加载

-12.4 进程等待与退出

--12.4 进程等待与退出

-第十二讲 进程控制--12.4 进程等待与退出

第十三讲 实验四 内核线程管理

-13.1 总体介绍

--13.1 总体介绍

-13.2 关键数据结构

--13.2 关键数据结构

-13.3 执行流程

--13.3 执行流程

-13.4 实际操作

--13.4 实际操作

第十四讲 实验五 用户进程管理

-14.1 总体介绍

--14.1 总体介绍

-14.2 进程的内存布局

--14.2 进程的内存布局

-14.3 执行ELF格式的二进制代码-do_execve的实现

--14.3 执行ELF格式的二进制代码-do_execve的实现

-14.4 执行ELF格式的二进制代码-load_icode的实现

--14.4 执行ELF格式的二进制代码-load_icode的实现

-14.5 进程复制

--14.5 进程复制

-14.6 内存管理的copy-on-write机制

--14.6 内存管理的copy-on-write机制

第十五讲 处理机调度

-15.1 处理机调度概念

--15.1 处理机调度概念

-第十五讲 处理机调度--15.1 处理机调度概念

-15.2 调度准则

--15.2 调度准则

-15.3 先来先服务、短进程优先和最高响应比优先调度算法

--15.3 先来先服务、短进程优先和最高响应比优先调度算法

-第十五讲 处理机调度--15.3 先来先服务、短进程优先和最高响应比优先调度算法

-15.4 时间片轮转、多级反馈队列、公平共享调度算法和ucore调度框架

--15.4 时间片轮转、多级反馈队列、公平共享调度算法和ucore调度框架

-第十五讲 处理机调度--15.4 时间片轮转、多级反馈队列、公平共享调度算法和uc

-15.5 实时调度和多处理器调度

--15.5 实时调度和多处理器调度

-第十五讲 处理机调度--15.5 实时调度和多处理器调度

-15.6 优先级反置

--15.6 优先级反置

-第十五讲 处理机调度--15.6 优先级反置

第十六讲 实验六 调度器

-16.1 总体介绍和调度过程

--16.1 总体介绍和调度过程

-16.2 调度算法支撑框架

--16.2 调度算法支撑框架

-16.3 时间片轮转调度算法

--16.3 时间片轮转调度算法

-16.4 Stride调度算法

--16.4 Stride调度算法

第十七讲 同步互斥

-17.1 背景

--17.1 背景

-17.2 现实生活中的同步问题

--17.2 现实生活中的同步问题

-第十七讲 同步互斥--17.2 现实生活中的同步问题

-17.3 临界区和禁用硬件中断同步方法

--17.3 临界区和禁用硬件中断同步方法

-第十七讲 同步互斥--17.3 临界区和禁用硬件中断同步方法

-17.4 基于软件的同步方法

--17.4 基于软件的同步方法

-第十七讲 同步互斥--17.4 基于软件的同步方法

-17.5 高级抽象的同步方法

--17.5 高级抽象的同步方法

-第十七讲 同步互斥--17.5 高级抽象的同步方法

第十八讲 信号量与管程

-18.1 信号量

--18.1 信号量

-第十八讲 信号量与管程--18.1 信号量

-18.2 信号量使用

--18.2 信号量使用

-第十八讲 信号量与管程--18.2 信号量使用

-18.3 管程

--18.3 管程

-第十八讲 信号量与管程--18.3 管程

-18.4 哲学家就餐问题

--18.4 哲学家就餐问题

-18.5 读者-写者问题

--18.5 读者-写者问题

第十九讲 实验七 同步互斥

-19.1 总体介绍

--19.1 总体介绍

-19.2 底层支撑

--19.2 底层支撑

-第十九讲 实验七 同步互斥--19.2 底层支撑

-19.3 信号量设计实现

--19.3 信号量设计实现

-第十九讲 实验七 同步互斥--19.3 信号量设计实现

-19.4 管程和条件变量设计实现

--19.4 管程和条件变量设计实现

-第十九讲 实验七 同步互斥--19.4 管程和条件变量设计实现

-19.5 哲学家就餐问题

--19.5 哲学家就餐问题

第二十讲 死锁和进程通信

-20.1 死锁概念

--20.1 死锁概念

-第二十讲 死锁和进程通信--20.1 死锁概念

-20.2 死锁处理方法

--20.2 死锁处理方法

-第二十讲 死锁和进程通信--20.2 死锁处理方法

-20.3 银行家算法

--20.3 银行家算法

-第二十讲 死锁和进程通信--20.3 银行家算法

-20.4 死锁检测

--20.4 死锁检测

-第二十讲 死锁和进程通信--20.4 死锁检测

-20.5 进程通信概念

--20.5 进程通信概念

-第二十讲 死锁和进程通信--20.5 进程通信概念

-20.6 信号和管道

--20.6 信号和管道

-第二十讲 死锁和进程通信--20.6 信号和管道

-20.7 消息队列和共享内存

--20.7 消息队列和共享内存

-第二十讲 死锁和进程通信--20.7 消息队列和共享内存

第二十一讲 文件系统

-21.1 文件系统和文件

--21.1 文件系统和文件

-第二十一讲 文件系统--21.1 文件系统和文件

-21.2 文件描述符

--21.2 文件描述符

-第二十一讲 文件系统--21.2 文件描述符

-21.3 目录、文件别名和文件系统种类

--21.3 目录、文件别名和文件系统种类

-第二十一讲 文件系统--21.3 目录、文件别名和文件系统种类

-21.4 虚拟文件系统

--21.4 虚拟文件系统

-第二十一讲 文件系统--21.4 虚拟文件系统

-21.5 文件缓存和打开文件

--21.5 文件缓存和打开文件

-第二十一讲 文件系统--21.5 文件缓存和打开文件

-21.6 文件分配

--21.6 文件分配

-第二十一讲 文件系统--21.6 文件分配

-21.7 空闲空间管理和冗余磁盘阵列RAID

--21.7 空闲空间管理和冗余磁盘阵列RAID

-第二十一讲 文件系统--21.7 空闲空间管理和冗余磁盘阵列RAID

第二十二讲 实验八 文件系统

-22.1 总体介绍

--22.1 总体介绍

-第二十二讲 实验八 文件系统--22.1 总体介绍

-22.2 ucore 文件系统架构

--22.2 ucore 文件系统架构

-第二十二讲 实验八 文件系统--22.2 ucore 文件系统架构

-22.3 Simple File System分析

--22.3 Simple File System分析

-第二十二讲 实验八 文件系统--22.3 Simple File System分析

-22.4 Virtual File System分析

--22.4 Virtual File System分析

-第二十二讲 实验八 文件系统--22.4 Virtual File System分

-22.5 I/O设备接口分析

--22.5 I/O设备接口分析

-第二十二讲 实验八 文件系统--22.5 I/O设备接口分析

-22.6 执行流程分析

--22.6 执行流程分析

第二十三讲 I/O子系统

-23.1 I/O特点

--视频

-第二十三讲 I/O子系统--23.1 I/O特点

-23.2 I/O结构

--816C80A0F5E3B8809C33DC5901307461

-第二十三讲 I/O子系统--23.2 I/O结构

-23.3 I/O数据传输

--C58221E14388B9DB9C33DC5901307461

-第二十三讲 I/O子系统--23.3 I/O数据传输

-23.4 磁盘调度

--567A3F1FCBFB3F4C9C33DC5901307461

-第二十三讲 I/O子系统--23.4 磁盘调度

-23.5 磁盘缓存

--C327536B80D25CE79C33DC5901307461

-第二十三讲 I/O子系统--23.5 磁盘缓存

html

-html

--html

3.3 中断、异常和系统调用比较笔记与讨论

也许你还感兴趣的课程:

© 柠檬大学-慕课导航 课程版权归原始院校所有,
本网站仅通过互联网进行慕课课程索引,不提供在线课程学习和视频,请同学们点击报名到课程提供网站进行学习。