操作系统实验指导书新编版详解与实战技巧分享

引言

操作系统是计算机科学的核心课程之一，它不仅理论深奥，而且实践性极强。通过实验，学生可以将抽象的理论知识转化为具体的系统行为，从而深入理解进程管理、内存管理、文件系统等核心概念。本文将基于《操作系统实验指导书新编版》的核心内容，结合当前主流的实验环境（如Linux内核、xv6教学系统等），详细解析实验要点，并分享实战技巧，帮助读者高效完成实验并提升系统编程能力。

一、实验环境搭建与配置

1.1 选择实验平台

现代操作系统实验通常基于以下两种平台：

• Linux内核实验：适用于深入理解现代操作系统设计，如进程调度、内存管理等。
• xv6教学系统：一个简化的Unix-like教学系统，适合初学者理解操作系统核心机制。

推荐配置：

• 虚拟机环境：使用VirtualBox或VMware安装Ubuntu 22.04 LTS（推荐）。
• Docker容器：对于轻量级实验，可使用Docker快速部署实验环境。
• WSL2：Windows用户可通过WSL2运行Linux内核实验。

1.2 环境配置步骤（以Ubuntu为例）

# 1. 更新系统
sudo apt update && sudo apt upgrade -y

# 2. 安装必要工具
sudo apt install build-essential git vim gcc make gdb -y

# 3. 安装内核开发工具
sudo apt install linux-headers-$(uname -r) -y

# 4. 安装QEMU（用于模拟运行）
sudo apt install qemu-system-x86 -y

# 5. 克隆xv6实验代码（示例）
git clone https://github.com/mit-pdos/xv6-riscv.git
cd xv6-riscv
make qemu

1.3 常见问题解决

• 权限问题：确保用户有sudo权限，或使用sudo执行关键命令。
• 依赖缺失：根据错误提示安装缺失的包，如libelf-dev、flex、bison等。
• 编译错误：检查内核版本兼容性，确保使用与实验指导书匹配的版本。

二、核心实验详解

2.1 进程管理实验

实验目标：理解进程创建、调度和通信机制。

实验步骤：

1. 进程创建：使用fork()系统调用创建子进程。
2. 进程调度：修改Linux内核的调度策略（如CFS）。
3. 进程通信：实现管道（pipe）或消息队列。

代码示例：进程创建与通信

#include <stdio.h>
#include <unistd.h>
#include <sys/wait.h>

int main() {
    pid_t pid;
    int fd[2];
    
    // 创建管道
    if (pipe(fd) == -1) {
        perror("pipe");
        return 1;
    }
    
    pid = fork();
    
    if (pid == -1) {
        perror("fork");
        return 1;
    }
    
    if (pid == 0) { // 子进程
        close(fd[0]); // 关闭读端
        write(fd[1], "Hello from child!", 18);
        close(fd[1]);
        exit(0);
    } else { // 父进程
        close(fd[1]); // 关闭写端
        char buffer[100];
        read(fd[0], buffer, sizeof(buffer));
        printf("Parent received: %s\n", buffer);
        close(fd[0]);
        wait(NULL); // 等待子进程结束
    }
    
    return 0;
}

实战技巧：

• 使用strace跟踪系统调用：strace ./your_program。
• 调试时使用gdb，设置断点观察进程状态变化。
• 注意fork()返回值的三种情况：-1（错误）、0（子进程）、>0（父进程）。

2.2 内存管理实验

实验目标：理解虚拟内存、分页机制和页面置换算法。

实验步骤：

1. 模拟分页：实现一个简单的分页系统。
2. 页面置换：实现LRU（最近最少使用）算法。
3. 内存分配：修改内核的kmalloc或用户空间的malloc。

代码示例：LRU页面置换算法模拟

class LRUCache:
    def __init__(self, capacity):
        self.capacity = capacity
        self.cache = {}
        self.order = []  # 记录访问顺序
    
    def get(self, key):
        if key in self.cache:
            # 更新访问顺序
            self.order.remove(key)
            self.order.append(key)
            return self.cache[key]
        return -1
    
    def put(self, key, value):
        if key in self.cache:
            self.order.remove(key)
        elif len(self.cache) >= self.capacity:
            # 移除最久未使用的页面
            lru_key = self.order.pop(0)
            del self.cache[lru_key]
        
        self.cache[key] = value
        self.order.append(key)

# 测试
lru = LRUCache(3)
lru.put(1, 10)
lru.put(2, 20)
lru.put(3, 30)
print(lru.get(1))  # 输出10，访问后1变为最近使用
lru.put(4, 40)     # 移除最久未使用的2
print(lru.get(2))  # 输出-1（已移除）

实战技巧：

• 使用/proc/meminfo和free -h监控内存使用。
• 在Linux内核中，通过/proc/<pid>/maps查看进程内存映射。
• 实验时注意区分物理地址和虚拟地址，使用mmap进行内存映射。

2.3 文件系统实验

实验目标：理解文件系统的结构、目录管理和磁盘I/O。

实验步骤：

1. 实现简单文件系统：基于FAT或Ext2结构。
2. 目录操作：实现ls、mkdir、rm等命令。
3. 磁盘缓存：模拟Buffer Cache机制。

代码示例：简单的文件系统模拟（Python）

import os
import json

class SimpleFileSystem:
    def __init__(self, disk_path):
        self.disk_path = disk_path
        if not os.path.exists(disk_path):
            self.format_disk()
    
    def format_disk(self):
        # 初始化超级块、inode表、数据块
        self.metadata = {
            "superblock": {"total_blocks": 1024, "block_size": 512},
            "inodes": {},
            "free_blocks": list(range(1, 1024))
        }
        self.save_metadata()
    
    def save_metadata(self):
        with open(self.disk_path, 'w') as f:
            json.dump(self.metadata, f)
    
    def create_file(self, filename, content):
        if filename in self.metadata["inodes"]:
            raise FileExistsError("File already exists")
        
        # 分配数据块
        data_blocks = []
        for i in range(0, len(content), 512):
            block_id = self.metadata["free_blocks"].pop(0)
            data_blocks.append(block_id)
            # 实际存储时，这里会写入磁盘文件
        
        # 创建inode
        self.metadata["inodes"][filename] = {
            "size": len(content),
            "blocks": data_blocks,
            "timestamp": os.path.getmtime(self.disk_path)
        }
        self.save_metadata()
    
    def read_file(self, filename):
        if filename not in self.metadata["inodes"]:
            raise FileNotFoundError("File not found")
        
        # 从数据块读取内容（模拟）
        return f"Content of {filename} (simulated)"

# 使用示例
fs = SimpleFileSystem("disk.json")
fs.create_file("test.txt", "Hello, OS!")
print(fs.read_file("test.txt"))

实战技巧：

• 使用dd命令创建虚拟磁盘：dd if=/dev/zero of=disk.img bs=1M count=100。
• 调试文件系统时，使用hexdump查看磁盘内容。
• 在Linux中，通过mount和umount挂载/卸载文件系统。

三、高级实验技巧

3.1 调试与性能分析

• 使用GDB调试内核：

  # 启动QEMU并附加GDB
  make qemu-nox-gdb
  # 在另一个终端
  gdb vmlinux
  (gdb) target remote localhost:1234
  (gdb) break sys_fork
  

• 性能分析工具：

  • perf：分析CPU性能。
  • strace：跟踪系统调用。
  • ftrace：内核函数跟踪。

3.2 实验报告撰写

• 结构清晰：包括实验目的、步骤、代码、结果分析和思考题。
• 图表辅助：使用流程图、时序图展示进程状态变化。
• 代码注释：关键代码段添加详细注释。

3.3 常见错误与解决方案

错误类型	原因	解决方案
编译错误	缺少头文件或库	安装对应开发包，检查Makefile
运行时崩溃	内存越界或空指针	使用Valgrind检测内存错误
死锁	资源竞争	使用pthread_mutex_lock正确加锁

四、实战案例：修改Linux内核调度器

4.1 实验目标

在Linux 5.15内核中添加一个简单的轮询调度策略。

4.2 步骤

1. 获取内核源码：

   
   wget https://cdn.kernel.org/pub/linux/kernel/v5.x/linux-5.15.tar.xz
   tar -xf linux-5.15.tar.xz
   cd linux-5.15
   

2. 修改调度器代码：
   • 在kernel/sched/目录下，修改core.c和rt.c。
   • 添加新的调度类polling_sched_class。
3. 编译与测试：

   
   make menuconfig  # 启用新调度器
   make -j$(nproc)  # 编译内核
   make modules_install install  # 安装
   sudo reboot  # 重启使用新内核
   

4.3 代码片段（简化版）

// 在kernel/sched/sched.h中定义新调度类
static const struct sched_class polling_sched_class = {
    .next = &fair_sched_class,
    .enqueue_task = polling_enqueue_task,
    .dequeue_task = polling_dequeue_task,
    .check_preempt_curr = polling_check_preempt_curr,
    .pick_next_task = polling_pick_next_task,
    .task_tick = polling_task_tick,
};

// 实现关键函数
static void polling_enqueue_task(struct rq *rq, struct task_struct *p, int flags) {
    // 将任务加入轮询队列
    list_add_tail(&p->se.run_list, &rq->polling_queue);
    rq->nr_running++;
}

五、总结与建议

5.1 学习路径建议

1. 基础阶段：掌握C语言和Linux命令。
2. 理论学习：结合《操作系统概念》等教材。
3. 实验实践：从xv6开始，逐步深入Linux内核。
4. 项目拓展：尝试实现一个简单的操作系统（如教学OS）。

5.2 资源推荐

• 书籍：《Operating System Concepts》、《Linux内核设计与实现》。
• 在线课程：MIT 6.828、Stanford CS140。
• 社区：Linux内核邮件列表、Stack Overflow。

5.3 最终建议

操作系统实验不仅是完成作业，更是培养系统思维的过程。遇到问题时，多查阅源码、多调试、多思考。通过实验，你将不仅掌握理论知识，更能获得解决复杂系统问题的能力。

---

注意：本文提供的代码示例均为简化版，实际实验中需根据具体环境和要求进行调整。建议在实验前仔细阅读《操作系统实验指导书新编版》的官方说明，并结合最新技术文档进行操作。