计算机操作系统与安全复习笔记

1 绪论

操作系统目标: 方便性; 有效性; 可扩充性; 开放性.

作用: 用户与计算机硬件系统之间的接口; 计算机资源的管理者; 实现了对计算机资源的抽象; 计算机工作流程的组织者.

多道程序设计: 内存中同时存放若干个作业, 使其共享系统资源且同时运行; 单处理机环境下宏观上并行, 微观上交替执行.

多道批处理系统: 资源利用率高; 系统吞吐量大; 平均周转时间长; 无交互能力.

多道程序协调问题: 处理机争用; 内存分配和保护; I/O 设备分配; 文件组织和管理; 用户与系统接口.

分时系统: 一台主机上连接多个终端同时允许多个用户通过各自终端交互使用并共享资源, 作业提交时直接进入内存并按时间片轮转运行; 多路性, 独立性, 及时性, 交互性.

实时系统: 将时间作为关键参数, 能及时响应外部事件请求在规定时间内完成处理, 并控制所有实时任务协调一致运行.

基本特性: 并发; 共享(互斥共享; 同时访问); 虚拟(CPU; 存储器; 设备); 异步.

主要功能: 处理机管理(进程控制, 同步, 通信, 调度); 存储器管理(内存分配, 保护, 扩充; 地址映射); 设备管理(分配, 处理; 缓冲); 文件管理(存储空间; 目录; 读/写); 提供接口(用户接口; 程序接口); (系统安全; 网络服务; 多媒体存储).

2 CPU 虚拟化

进程: 进程实体的运行过程, 系统进行资源分配和调度的独立单位; 动态性, 并发性, 独立性, 异步性.

挂起: 进程处于静止状态, 暂时不接受调度直到被激活.

PCB(进程控制块): 标识符; 处理机状态(通用寄存器; 指令计数器; 程序状态字; 用户栈指针); 调度信息(状态; 优先级; 事件/阻塞原因); 控制信息(程序和数据地址; 同步和通信; 资源清单; 链接指针).

组织方式: 线性表; 链接队列; 索引表.

内核态: 支撑功能(中断处理; 时钟管理; 原语操作); 资源管理功能(进程管理; 存储器管理; 设备管理).

高级通信: 共享存储器(共享数据结构; 共享存储区); 管道; 消息传递(直接; 间接); C/S(客户机-服务器).

线程: 同一进程中可以切换线程, 仅需保存和设置少量寄存器内容, 系统开销远小于进程切换; 同一或不同进程中线程均可并发执行; 同一进程内线程共享进程拥有的资源和地址空间, 线程间不独立且不拥有系统资源; 多线程支持多处理机并行执行.

TCB(线程控制块): 标识符; 寄存器; 状态; 优先级; 专有存储区; 信号屏蔽; 堆栈指针.

调度层次: 高级/长程/作业(多道批处理); 低级/短程/进程; 中级/内存(即对换).

共同目标: 资源利用率(有效工作时间占比); 公平性(无进程"饥饿"); 平衡性(各资源经常处于忙碌状态); 策略强制执行(安全).

批处理目标: 平均周转时间(作业提交到完成的时间间隔); 系统吞吐量(单位时间内完成的作业数); 处理机利用率.

分时目标: 响应时间(用户请求到处理的时间间隔); 均衡性(响应时间与请求复杂性相适应).

实时目标: 截止时间(开始执行或完成的最迟时间); 可预测性.

FCFS(先来先服务).

SJF(短作业优先): 运行时间短的优先; 必须预知运行时间, 长作业会"饥饿", 人机难以交互, 完全未考虑紧迫程度.

PSA(优先级调度).

HRRN(高响应比调度): 优先权 = = =响应时间 / / /要求服务时间; 短作业优先, 同时避免长作业"饥饿".

进程调度: 就绪进程 → \to → 排队器 → \to → 就绪队列 → \to → 分派器 → \to → 上下文切换器 → \to → 处理机.

非抢占式: 处理机分配给某进程后直至进程完成或发生某事件而阻塞时才会将处理机分配给其他进程.

抢占原则: 优先权; 短进程优先; 时间片轮转.

RR(时间片轮转): 按照 FCFS 策略排序为就绪队列, 从队首开始依次令进程执行一个时间片, 时间片内执行完正常终止, 否则中断并将进程送入队尾.

MFQ(多级反馈队列): 多个就绪队列优先级从高到低, 从第一个队列的队首开始依次令进程执行一个时间片, 时间片内执行完正常终止, 否则中断并将进程送入最后一个队列的队尾; 仅当当前队列前所有队列均空闲时, 才会执行当前队列.

保证调度: 保证每个进程都能获得相同的处理机时间; 跟踪计算所有进程实际已执行时间和应获得的处理机时间之比, 比值最小的进程一直运行直到超过最接近其的比值为止.

公平分享调度: 考虑不同用户而非单纯进程得到的处理机时间占比.

实时调度基本条件: 提供必要信息(就绪时间, 开始截止时间/完成截止时间, 处理时间, 资源要求, 优先级); 系统处理能力强( ∑ i = 1 m C i P i ≤ N \sum_{i=1}^m\frac{C_i}{P_i}\leq N ∑i=1mPiCi≤N, m m m 个周期性 HRT(硬实时任务), 处理时间为 C i C_i Ci, 周期时间为 P i P_i Pi, 处理机个数为 N N N); 抢占式调度; 快速切换机制(快速中断响应; 快速任务分派).

EDF(最早截止时间优先): 可采用抢占或非抢占.

LLF(最低松弛度优先): 松弛度 = = = 完成截止时间 − - − 处理时间 − - − 当前时间.

优先级倒置(PIP): 高优先级进程因互斥或同步被低优先级延迟或阻塞; 可采用非抢占式调度, 或动态优先级继承(被阻塞的进程继承导致阻塞进程的优先级一直保持到重新就绪).

3 内存虚拟化

装入内存: 绝对装入(单道程序); 可重定位装入(不允许程序运行时在内存中移动位置, 装入时一次性完成地址变换); 动态运行时装入.

链接: 静态链接; 装入时动态链接; 运行时动态链接.

内部碎片: 程序小于固定分区大小时也会占用一个完整的分区空间, 分区内部存在空间浪费.

分区说明表/空闲分区表: 分区号; 分区大小; 分区起址; 状态.

空闲分区链(双向链表): 前向指针; 前状态位; 后向指针; 后状态位; 分区大小.

内存回收: 有相邻的空闲分区时合并, 不分配新表项只修改分区大小或分区起址; 无相邻的空闲分区时单独建立新表项.

顺序搜索: FF(首次适应; 从头开始); NF(循环首次适应; 从上次空闲位置开始); BF(最佳适应; 满足要求的最小空闲分区); WF(最坏适应; 从最大的空闲区中分割).

索引搜索: QF(快速适应; 根据空闲分区大小分类, 每类中所有空闲分区单独设立空闲分区链); BS(伙伴系统; 已分配及空闲分区大小均为 2 k 2^k 2k; 地址为 x x x 的内存块的伙伴块地址为 x + 2 k x+2^k x+2k( x ≡ 0 ( m o d 2 k + 1 ) x\equiv 0({\rm mod}\ 2^{k+1}) x≡0(mod 2k+1)时) 或 x − 2 k x-2^k x−2k( x ≡ 2 k ( m o d 2 k + 1 ) x\equiv 2^k({\rm mod}\ 2^{k+1}) x≡2k(mod 2k+1)时)); Hash(根据所需空闲分区大小计算 Hash 值(Hash 表中位置)从中得到空闲分区链表).

"紧凑"/"拼凑": 外部碎片较多无法装入大作业时, 将内存中所有作业移动使得全部相邻接, 将原本多个分散空闲小区分拼接成一个打分去.

动态重定位: 重定位寄存器存放程序或数据在内存中的起始地址, 访问地址 = = = 相对地址 + + + 重定位地址; "紧凑时"无需修改程序, 只需用新地址修改重定位地址即可.

覆盖(同一作业或进程): 用户空间分为固定区和若干覆盖区, 活跃部分在固定区, 其余部分按调用关系分段; 即将访问的段调入覆盖区, 其他段在外存中, 需要时调入覆盖区并覆盖现有段.

对换(不同作业或进程): 换入, 将准备好竞争处理机的程序从辅存移入主存; 换出, 将处于阻塞状态的程序从主存移到辅存.

页/页面: 进程的逻辑地址空间分成若干大小相等的片; 逻辑地址 A = A= A= 页号 P P P || 偏移量(页内地址) W W W, 页面大小为 L L L 时, P = ⌊ A L ⌋ P=\lfloor\frac{A}{L}\rfloor P=⌊LA⌋, W = A ( m o d L ) W=A({\rm mod}\ L) W=A(mod L).

块/物理块/页框: 内存空间分成与页面相同大小的若干个存储块; 物理地址 = = = 块号 || 偏移量(块内地址).

页表: 记录页号到块号的映射.

两次访存: 第一次访问内存得到物理地址; 第二次根据物理地址访问对应内存单元.

TLB(快表/联想寄存器): 具有并行查询能力的特殊高速缓存寄存器, 为提高地址变换速度.

两级页表: 逻辑地址 = = = 外层页号 || 外层页地址 || 页内地址.

多级页表: 建立索引而无需浪费主存空间存储无用页表项, 顶级页表至多只有 1 1 1 个页面; 地址空间依旧为一维.

反置页表: 为一个物理块设置一个页表项, 按照物理块编号排序, 内容为页号和所隶属进程的标识符.

引入分段原因: 方便编程, 信息共享, 信息保护, 动态增长, 动态链接.

段表: 逻辑地址 = = = 段号 || 段内地址; 段号, 段长, 基址; 段号超过段表长度或段内地址超过段长, 均产生越界中断信号; 地址空间为二维.

段页式: 逻辑地址 = = = 段号 || 段内页号 || 页内地址; 每个段由若干页面组成; 需要三次访存; 地址空间为二维.

局部性原理: 时间局部性, 某个存储单元被访问过不久后可能会再次被访问; 空间局部性, 某个存储单元附近的存储单元可能将被访问.

虚拟存储器: 具有请求调入功能和置换功能, 能从逻辑上对内存扩充; 多次性(多次装入内存), 对换性, 虚拟性(逻辑上扩充内存).

请求页表: 页号 || 块号 || 状态位 P P P(已分配/空闲) || 访问字段 A A A(一段时间内被访问次数/最近多久未被访问) || 修改位/脏位 M M M || 外存地址.

缺页中断: 指令执行期间可能产生多次缺页中断, 属于内部中断.

请求段表: 段号/段名 || 段长 || 段基址 || 存取方式(仅执行/仅读/可读写) || 访问字段 A A A || 修改位/脏位 M M M || 存在位 P P P(本段是否已调入内存) || 增补位(本段运行过程中是否动态增长) || 外存起址(起始盘块号).

分段保护: 越界检查, 段号超过段表长度或段内地址超过段长时越界中断; 存取控制检查, 不符合段要求的存取方式时中断; 环境保护机构, 低编号环具有高优先权(OS 内核处于 0 号环), 仅可调用相同或高优先权服务, 仅可访问相同或低优先权数据.

内存分配: 固定分配局部置换(物理块数固定不变, 缺页时在已分配的页面中置换); 可变分配全局置换(物理块数可变, 缺页时分配保留的空闲物理块, 无空闲时在全部进程的物理块中置换); 可变分配局部置换(物理块数可变, 缺页时在已分配的页面中置换).

物理块分配: 平均分配; 按比例分配(页面数占比); 考虑优先权分配.

调入时机: 预调页(一次性调入若干相邻页, 但未必被适用); 请求调页(仅在缺页时调入).

调入过程: 发出缺页中断 → \to → 所缺页调入内存 → \to → 修改页表.

影响页面对换效率的因素: 页面置换算法; 写回磁盘的频率; 读入内存的频率.

PBA(页面缓冲算法): 显著降低页面对换频率, 可采用简单的置换策略; 空闲页面链表(空闲物理块队列; 换出时挂在队尾), 修改页面链表(修改物理块队列; 换出时挂在队尾).

缺页率: f = F A f=\frac{F}{A} f=AF, F F F 为调页次数, A A A 为页面访问总次数; 页面越大, 分配物理块数目越多, 程序局部性越好, 缺页率越低.

最佳置换: 换出以后永不使用或在未来最长时间内不再访问的页面; 理论缺页率最低.

FIFO(先进先出).

LRU(最近最久未使用): 访问字段记录页面自上次被访问以来经历的时间; 换出访问字段值最大的页面.

LFU(最近最少使用): 在一定间隔内访问时访问位记为 "1", 否则记为 "0"; 换出 FIFO 下访问位值为 "0" 的页面.

Clock/NRU(最近未使用): 某页被访问时访问位记位 "1"; 缺页时将 FIFO 下访问位值为 "1" 的页面修改为 "0", 直到第一个访问位值为 "0" 的页面换出.

改进型 Clock: 换出已修改页面代价较大; 访问位 A = 1 A=1 A=1 表示最近被访问, 修改位 M = 1 M=1 M=1 表示最近被修改; (1) 当前位置开始扫描寻找 A = 0 A=0 A=0 且 M = 0 M=0 M=0 的第一类页面, 失败时继续 (2); (2) 重新扫描寻找 A = 0 A=0 A=0 且 M = 1 M=1 M=1 的第二类页面, 并将途中所有页面 A A A 置为 "0", 失败时重复 (1).

访存情况	访问有效时间(EAT)
被访问页在内存中, 对应页表项在快表中	λ + t \lambda+t λ+t, λ \lambda λ 为查找快表时间, t t t 为访问实际物理地址时间
被访问页在内存中, 对应页表项不在快表中	2 ( λ + t ) 2(\lambda+t) 2(λ+t)
被访问页不在内存中	ϕ + 2 ( λ + t ) \phi+2(\lambda+t) ϕ+2(λ+t), ϕ \phi ϕ 为缺页中断处理时间
无快表	2 t 2t 2t
仅考虑命中率	α ( λ + t ) + 2 ( 1 − α ) ( t + λ ) \alpha(\lambda+t)+2(1-\alpha)(t+\lambda) α(λ+t)+2(1−α)(t+λ), α \alpha α 为命中率
仅考虑缺页率	t + f ( ϕ + t ) + ( 1 − f ) t t+f(\phi+t)+(1-f)t t+f(ϕ+t)+(1−f)t, f f f 为缺页率
考虑命中率及缺页率	λ + α t + ( 1 − α ) [ t + f ( ϕ + λ + t ) + ( 1 − f ) ( λ + t ) ] \lambda+\alpha t+(1-\alpha)[t+f(\phi+\lambda+t)+(1-f)(\lambda+t)] λ+αt+(1−α)[t+f(ϕ+λ+t)+(1−f)(λ+t)]

4 并发

并发: 微观上快速交替执行, 宏观上并行.

同步: 并发执行的多个进程间按照一定规则或时序共享系统资源, 使程序执行具有可再现性.

临界资源: 一次仅允许一个进程使用的资源.

临界区: 进程中访问临界资源的代码段.

同步规则: 空闲让进, 忙则等待, 有限等待, 让权等待(不"忙等": 不能进入临界区时立即释放虚拟机).

硬件实现: 关中断; Test-and-Set/TS/TSL 或 Swap/Exchange/XCHG 指令("忙等").

// 整型信号量: 存在"忙等"
// P 操作: 请求资源
void wait(semaphore S){
    while(S<=0);
    S--
}
// V 操作: 释放资源
void signal(semaphore S){
    S++;
}

// 记录型信号量: 让权等待
typedef struct {
    int value; // 正时表示剩余资源数量, 负时表示等待进程数
    struct process_control_block *list; // 进程等待队列
} semaphore;
// P 操作
void wait(semaphore *S){
    S->value--;
    if(S->wait<0) block(S->list); // 没有资源时当前进程加入到等待队列
}
// V 操作
void signal(semaphore *S){
    S->value++;
    if(S->value<=0) wakeup(S->list); // 等待队列还有进程时唤醒队列中的进程
}

// AND 型信号量: 进程需要多个不同临界资源
// P 操作
void Swait(semaphore S1, ..., semaphore Sn){
    while(1){
        if(S1>=1 && ... && Sn>=1){
            S1--, ..., Sn--;
            break;
        } else /* 进程加入第一个没有剩余资源关联的等待队列中 */
    }
}
// V 操作
void Ssignal(semaphore S1, ..., semaphore Sn){
    while(1){
        S1++, ..., Sn++;
        wakeup(S1); ... ; wakeup(Sn); // 所有资源关联的等待队列还有进程时唤醒队列中的进程
    }
}

// 信号量集: 每类临界资源有多个
// S 资源剩余数, t 资源分配下限(S >= t 时才分配), d 进程对资源需求量(S -= d)
void Swait(semaphore S1, semaphore t1, semaphore d1, ...);
void Ssignal(semaphore S1, semaphore d1, ...);

Swait(S, d, d); // 一类资源但有多个
Swait(S, 1, 1); // S > 1 时退化为记录型, S = 1 时退化为整型
Swait(S, 1, 0); // 可控开关: S >= 1 时允许多个进程进入某特定区; S = 0 后阻止所有进程进入

// 进程互斥
semaphore mutex = 1;  // 互斥
void Pi(){
    while(1){
        wait(mutex);
        /* 临界代码 */
        signal(mutex);
    }
}

// 生产者-消费者问题
semaphore mutex = 1 // 缓冲区互斥访问
semaphore empty = N // 空闲缓冲区数量
semaphore full = 0 // 产品数量
// 生产进程一直向缓冲区输入直至缓冲区满
void producer(){
    while(1){
        /* 生产一个产品 */
        wait(empty);
        wait(mutex);
        /* 该产品放入缓冲区 */
        signal(mutex);
        signal(full);
    }
}
// 消费进程一直从缓冲区输出直至缓冲区空
void consumer(){
    while(1){
        wait(full);
        wait(mutex);
        /* 从缓冲区取走一个产品 */
        signal(mutex);
        signal(empty);
    }
}

// 读者-写者问题
semaphore wmutex = 1; // 共享文件互斥访问
semaphore rmutex = 1; // readcount 互斥访问
semaphore readcount = 0; // 访问共享文件的读进程数量
// 多个读进程可同时读共享对象
void reader(){
    while(1){
        wait(rmutex);
        if(readcount == 0) wait(wmutex); // 第一个读进程读前加锁
        readcount++;
        signal(rmutex);
        /* 读文件 */
        wait(rmutex);
        readcount--;
        if(readcount == 0) signal(wmutex); // 最后一个读进程读后解锁
        signal(rmutex);
    }
}
// 读进程均和写进程互斥
void writer(){
    while(1){
        wait(wmutex);
        /* 写文件 */
        signal(wmutex);
    }
}

// 哲学家进餐问题
// 5 个哲学家中间有 5 只筷子, 仅当哲学家同时拿起左右 2 只筷子时才可以进餐
semaphore chopstick[5] = {1, 1, 1, 1, 1};
// 直接拿左拿右时会出现死锁
void Phi(int i){
    wait(chopsitck[i]);
    wait(chopstick[(i + 1) % 5]);
    /* 吃饭 */
    signal(chopsitck[i]);
    signal(chopstick[(i + 1) % 5]);
}
// 最多只允许 4 个哲学家同时进餐
// 仅当哲学家可以同时拿起左右 2 只筷子时才可以拿筷子(任意时刻至多有 1 个哲学家尝试拿筷子)
semaphore mutex = 1;
void Phi(int i){
    wait(mutex);
    wait(chopsitck[i]);
    wait(chopstick[(i + 1) % 5]);
    signal(mutex);
    /* 吃饭 */
    signal(chopsitck[i]);
    signal(chopstick[(i + 1) % 5]);
}
// 奇数号哲学家先拿左边筷子再拿右边筷子, 偶数号相反

死锁: 一组进程中每个进程都在等待仅由该组中其他进程才能引发的事件.

产生原因: 竞争不可抢占性资源; 竞争可消耗资源; 进程推进顺序不当.

必要条件: 互斥条件; 请求和保持条件(新请求的资源被占用时, 请求阻塞但不释放已占用资源); 不可抢占条件(已占用资源只能在进程使用完后自行释放); 循环等待条件(存在进程-资源循环链).

处理方法: 预防(设置限制以破除必要条件); 避免(不设限但资源分配时检查); 检测 解除.

安全状态: 系统能按照某种进程推行顺序(安全序列)为每个进程分配所需资源, 直至满足每个进程对资源的最大需求, 使每个进程均可顺利完成.

死锁避免(银行家算法): 系统始终处于安全状态即不会产生死锁.

资源分配图: 圆圈表示进程, 方框表示资源, 请求边由进程指向资源, 分配边由资源指向进程.

死锁定理: 资源分配图不可完全简化时存在死锁.

解除方法: 资源剥夺; 终止/撤销进程; 进程回退.

数据结构
Available[m] 每类资源数量
Max[n][m] 每个进程所需的每类资源最大数量
Allocation[n][m] 当前每个进程已获得的每类资源数量
Need[n][m] 当前每个进程还需获得的每类资源数量
关系: Need[i][j] = Max[i][j] - Allocation[i][j]

银行家算法
RequestPi[m] 当前进程 Pi 资源请求每类资源数量
① 请求资源数不得超过宣布的最大值 RequestPi[j] <= Need[i][j] 
② 请求资源数不得超过剩余资源数 RequestPi[j] <= Available[j]
③ 尝试分配资源并执行安全性检查
Available[j] = Available[j] - RequestPi[j]
Allocation[i][j] = Allocation[i][j] - RequestPi[j]
Need[i][j] = Need[i][j] - RequestPi[j]

安全性检查
Work[m] = Available[m] 可提供给进程继续运行所需的各类资源数目
Finish[n] 是否有足够资源分配给进程使之运行完成
① 进程集合中找到一个进程满足 Finish[i] = false, Need[i][j] <= Work[j]; 否则转到 ③
② 该进程获得资源后可顺利运行完成, 并释放获取的资源, 并转到 ①
Work[j] = Work[j] + Allocation[i][j]
Finish[i] = true;
③ 所有进程 Finish[i] = true 时处于安全状态; 否则不安全

5 I/O

I/O 系统基本功能: 隐藏物理设备细节; 设备无关性/独立性; 提高处理机和设备利用率; 控制设备; 确保设备共享正确性; 错误处理.

层次结构: 用户层软件(产生 I/O 请求; 格式化 I/O; SPOOLing) ⇆ \leftrightarrows ⇆ (I/O 系统结构) 设备独立性软件(映射; 保护; 分块; 缓冲; 分配) ⇆ \leftrightarrows ⇆ 设备驱动程序(设置寄存器; 状态检查) ⇆ \leftrightarrows ⇆ 中断处理程序 ⇆ \leftrightarrows ⇆ (RW/HW 接口, 软件/硬件接口, 通道) 设备控制器 ⇆ \leftrightarrows ⇆(通路) 设备.

系统接口: 块设备接口; 流设备接口(字符); 网络通信接口.

设备: 存储, I/O; 输入, 输出, 交互; 低速, 中速, 高速; 块, 字符.

控制器基本功能: 接收和识别命令; 数据交换; 识别和报告设备状态; 地址识别; 数据缓冲区; 差错控制.

控制器组成: 与处理机接口(数据线, 地址线, 控制线); I/O 逻辑; 与设备接口(数据, 状态信息, 控制信息).

通道: 专门负责 I/O 的处理机; 指令类型单一, 与 CPU 共享内存.

通道类型(信息交换方式): 字节多路(轮转扫描, 不适合高速设备); 数组选择(仅有一个分配型子通道, 设备独占, 利用率低); 数组多路(多个非分配型子通道分时并行).

"瓶颈" 问题: 通道价格昂贵, 设置数量少而成为 I/O 瓶颈致使系统整体吞吐量下降; 增加设备到主机间通路而无需增加通道.

中断处理程序: 响应中断信号 → \to → 保存现场 → \to → 转入设备处理程序 → \to → 中断处理 → \to → 恢复现场并退出中断.

驱动程序功能/过程: 抽象要求转换为具体要求 → \to → 校验服务请求 → \to → 检查设备状态 → \to → 传递必要参数 → \to → 启动设备.

驱动程序特点: 设备无关软件和控制器间通信转换; 不同类型设备配置不同; 与设备采用的控制方式紧密相关; 基本部分固化在 ROM(只读存储器)中; 应允许可重入.

控制方式: 程序查询(等待设备就绪定期询问); 中断(设备就绪时发出中断请求; 以字为单位传输数据); DMA(直接存储器访问; 以块为单位传输数据).

DMA: DMA请求 → \to →预处理 → \to →数据传送 → \to →后处理.

预处理: 主存起始地址 → \to →AR(主存地址计数器), I/O 设备地址 → \to →DAR(设备地址计数器), 传送长度 → \to →WC(传送长度计数器), 启动 I/O 设备.

数据传送: I/O 设备向数据缓冲器写入数据直至将要溢出.

后处理: 将要溢出时发起中断请求, CPU 或主存读取数据.

传送方式: 停止 CPU 访存; DMA 和 CPU 交替访存; 周期挪用/窃取(CPU 正在访存时等待存取周期结束; 同时请求访存时 DMA 优先).

I/O 重定向: 用于 I/O 操作的设备可以更换而不必改变应用程序.

设备无关性/独立性: 应用程序独立于具体使用的物理设备.

设备无关软件: 设备驱动程序的统一接口; 缓冲管理; 差错控制; 对独立设备的分配与回收; 独立于设备的逻辑数据块.

SDT(系统设备表): 类型, 标识符, 指向 DCT 指针, 驱动程序入口地址.

DCT(设备控制表): 类型, 标识符, 状态, 指向 COCT 指针, 重复执行次数/时间, 设备队列队首指针.

COCT(控制器控制表): 标识符, 状态, 指向 CHCT 指针, 控制器队列队首指针, 控制器队列队尾指针.

CHCT(通道控制表): 标识符, 状态, 指向 COCT 指针, 通道队列队首指针, 通道队列队尾指针.

设备分配考虑因素: 设备固有属性; 分配算法; 安全性.

独占设备分配程序: 分配设备 → \to → 分配控制器 → \to → 分配通道.

LUT(逻辑设备表): 实现逻辑设备名到物理设备名映射; 逻辑设备名, 物理设备名, 驱动程序入口地址.

假脱机技术(SPOOLing): 利用多道程序技术模拟脱机 I/O 系统, 以缓和主机高速性和设备低速性间的矛盾, 实现主机和设备的并行.

构成: 输入井和输出井(磁盘上开辟两个区域模拟脱机输入和脱机输出); 输入缓冲区和输出缓冲区(内存中开辟两个区域缓和主机和设备速度间的矛盾); 预输入进程和输出进程(模拟脱机输入和脱机输出时的外围控制机); 井管理程序(控制作业和磁盘井之间的信息交换).

特点: 提高 I/O 速度; 独占设备改为共享设备; 实现虚拟设备.

守护进程: 独占设备改为共享设备时, 配置一个守护进程和假脱机文件队列; 守护进程是允许使用该独占设备的唯一进程, 使用设备时将文件放入假脱机文件队列并唤醒守护进程, 守护进程执行完后继续睡眠.

缓冲区引入原因: 缓和主机和设备速度间矛盾; 减少对 CPU 中断频率, 放宽对 CPU 中断响应时间的限制; 解决数据粒度不匹配问题; 提高主机和设备间并行性.

单缓冲区: 处理每块数据用时 max ⁡ { C , T } + M \max\{C,T\}+M max{C,T}+M, 磁盘将该块数据输入缓冲区时间为 T T T, 缓冲区中数据传送到用户区时间为 M M M, CPU 处理数据时间为 C C C.

双缓冲区/缓冲区对换: 数据输入第一缓冲区, 装满后转向第二缓冲区, 此时第一缓冲区数据传送到用户区并由 CPU 处理; 处理每块数据用时 max ⁡ { C + M , T } \max\{C+M,T\} max{C+M,T}.

环行缓冲区: 多个大小相同的缓冲区组成环形队列; 队尾指针指向下一个空的缓冲区, 队首指针指向计算进程下一个可用的已装满的缓冲区; 队尾指针追上队首指针时, 所有可用缓冲区均装满, 阻塞输入进程; 队首指针追上队尾指针时, 已处理完所有缓冲区数据, 阻塞计算进程.

缓冲池: 管理多个缓冲区, 缓冲首部用于标识和管理, 缓冲体用于存放数据; 空白缓冲队列, 输入队列, 输出队列; 收容输入, 提取输入, 收容输出, 提取输出.

磁盘组成: 盘面 > > >磁道(间隔) > > >扇区(间隔)控制信息 + + +数据 > > >字段(间距); 存储数据前需将磁盘低级格式化; 高级格式化以设置引导块, 空闲存储管理, 根目录, 文件系统.

访问时间: 寻道时间 T s T_s Ts(磁头移动到指定磁道) + + + 旋转延迟时间(指定扇区移动到磁头下) T τ + T_{\tau}+ Tτ+ 传输时间 T t T_t Tt.

早期调度: FCFS(先来先服务); SSTF(最短寻道时间优先).

扫描调度: SCAN(扫描/电梯; 磁头移动方向且距离最近优先, 移动方向无数据时切换方向); CSCAN(循环扫描; 单向移动且距离最近优先); NStepSCAN(请求队列分成 N N N 个子队列, 每个子队列使用 FCFS, 新请求放入其他队列, 避免磁臂"粘着"); FSCAN(请求队列分为当前队列和扫描期间新请求的待处理队列, 子队列使用 SCAN).

提高磁盘 I/O 速度途径: 高速缓存; 提前读, 延迟写, 优化物理块分布, 使用虚拟盘; RAID(廉价磁盘冗余阵列).