项目记录：一个C语言模拟操作系统的程序（1）

记录一个我的C语言做的非常简单的小项目，本大冤种帮一个上大一的远房堂弟（不知道叫堂还是表了，反正是我妈亲戚家的）做的课程设计，要求做的是一个字符图形界面的操作系统模拟。等他答辩完，无偿贡献给大家~给我点点赞吧~

题目：模拟一个操作系统，该程序至少包含进程管理、处理机调度、文件管理和设备管理这四个基本功能，由C/C++编写。

（1）相关概念

进程调度 (Process Scheduling)：进程调度是操作系统中的一项重要任务，它负责决定哪个进程将获得处理机（CPU）的资源以执行其指令。操作系统中可能同时存在多个进程，但处理机在任何时刻只能执行一个进程的指令。进程调度的目的是合理地分配处理机资源，确保所有进程公平、高效地运行。可以想象成在电影院里，有很多观众排队买票，售票员（操作系统）需要决定先卖给谁票。

处理机调度 (CPU Scheduling)：处理机调度通常指的是同进程调度。在某些文献中，处理机调度可能更侧重于调度算法的实现，如先来先服务（FCFS）、轮转调度（Round Robin）、优先级调度（Priority Scheduling）等。这些算法决定了进程被分配处理机的顺序。处理机调度确保了处理机资源的合理利用，防止某些进程长时间占用处理机而影响其他进程的执行。

文件管理 (File Management)：文件管理是操作系统中的另一个关键功能，它涉及文件的创建、删除、存储、检索和组织。操作系统提供了一套文件系统，使得用户和程序能够方便地访问和操作文件。文件管理还包括目录管理和空间管理，确保文件存储的有效性和安全性。就像图书馆的图书管理员一样，文件管理系统帮助我们找到、整理和保护我们的“书籍”（文件）。

设备管理 (Device Management)：设备管理指的是操作系统对硬件设备的控制和管理。这包括分配和释放输入输出设备，如打印机、键盘、鼠标等，以及处理设备之间的数据传输。设备管理还涉及到缓冲管理，即在内存中暂时存放数据，以协调处理机与设备之间速度不匹配的问题。设备驱动程序是设备管理的一部分，它们是操作系统与硬件设备之间通信的桥梁。可以想象成设备管理就像一个仓库管理员，负责管理仓库中所有物品（设备）的进出和存储。

（2）基础功能代码：

1.功能1：进程管理

//功能1：进程管理
void process_management(Process *processes, int *count) {
    printf("Process Management:\n");
    print_process_list(processes, *count);

    // 1. 创建一个新进程
    if (*count < 10) {
        processes[*count].pid = (*count) + 1;
        processes[*count].name = "Process_new";
        processes[*count].priority = 1;
        processes[*count].state = 1; // 假设1为就绪态
        (*count)++;
        printf("Created new process with PID %d\n", processes[*count - 1].pid);
    }

    // 2. 删除一个已存在的进程（这里假设删除最后一个进程）
    if (*count > 0) {
        (*count)--;
        printf("Deleted process with PID %d\n", processes[*count].pid);
        // 清理进程信息
        processes[*count].pid = 0;
        processes[*count].name = NULL; // 注意：应使用 free() 释放已分配的内存
        processes[*count].priority = 0;
        processes[*count].state = 0;
    }

    // 3. 进程状态转换（这里假设将第一个进程从就绪变为运行）
    if (*count > 0) {
        if (processes[0].state == 1) {
            processes[0].state = 2;
            printf("Changed process with PID %d state to running\n", processes[0].pid);
        }
    }

    // 4. 阻塞一个进程
    int pid_to_block = 2; // 假设我们要阻塞 PID 为 2 的进程
    for (int i = 0; i < *count; i++) {
        if (processes[i].pid == pid_to_block && processes[i].state == 2) {
            processes[i].state = 3;
            printf("Process with PID %d is blocked\n", processes[i].pid);
            break;
        }
    }

    // 5. 解除阻塞一个进程
    int pid_to_unblock = 2; // 假设我们要解除 PID 为 2 的进程的阻塞
    for (int i = 0; i < *count; i++) {
        if (processes[i].pid == pid_to_unblock && processes[i].state == 3) {
            processes[i].state = 1;
            printf("Process with PID %d is unblocked and is now ready\n", processes[i].pid);
            break;
        }
    }

    // 6. 再次打印进程列表，以显示更改
    print_process_list(processes, *count);
}

2.功能2：处理机调度

// 功能2：处理机调度函数，这里用的是比较简化的版本，因为他没有具体要求
void scheduler(Process *processes, int count) {
    printf("Scheduler:\n");
    // 使用简单的轮转调度算法
    srand(time(NULL)); // 初始化随机数发生器
    for (int i = 0; i < count; i++) {
        int random_pid = rand() % count;
        processes[random_pid].state = 2; // 将随机进程设置为运行态
    }
    // 打印当前“运行”的进程
    printf("Process in running state: PID %d\n", processes[rand() % count].pid);
}

3.功能3：文件管理

// 功能3：文件管理函数，也是简化版，因为他没有具体提要求
void file_management() {
    FILE *file_ptr;
    char *filename = "example.txt"; // 要操作的文件名
    char buffer[50];
    const char *text_to_write = "Hello, World!";
    char *read_text = "This is a test.";

    printf("File Management:\n");

    // 1.文件创建
    file_ptr = fopen(filename, "w"); // 以写入模式打开文件，如果文件不存在则创建
    if (file_ptr == NULL) {
        printf("Error creating file.\n");
        return;
    }
    printf("File '%s' created.\n", filename);
    fclose(file_ptr); // 关闭文件

    // 2.文件写入
    file_ptr = fopen(filename, "a"); // 以追加模式打开文件
    if (file_ptr == NULL) {
        printf("Error opening file for writing.\n");
        return;
    }
    fputs(text_to_write, file_ptr); // 写入文本
    printf("Text '%s' written to file '%s'.\n", text_to_write, filename);
    fclose(file_ptr);

    //3.文件读取
    file_ptr = fopen(filename, "r"); // 以读取模式打开文件
    if (file_ptr == NULL) {
        printf("Error opening file for reading.\n");
        return;
    }
    fgets(buffer, 50, file_ptr); // 从文件中读取一行
    printf("Text read from file: '%s'\n", buffer);
    fclose(file_ptr);

    // 4.文件删除
    if (remove(filename) != 0) {
        printf("Error deleting file.\n");
    } else {
        printf("File '%s' deleted.\n", filename);
    }
}

4.功能4：设备管理

// 功能4:设备管理函数
void device_management() {
    printf("Device Management:\n");
    init_device_pool(); // 初始化设备池

    // 模拟设备分配
    if (allocate_device(devices, 1)) {
        // 模拟写I/O请求
        char data_to_write[] = "Hello, World!";
        if (io_request(devices, 1, data_to_write, strlen(data_to_write), 1)) {
            printf("Data written successfully to device 1\n");
        } else {
            printf("Failed to write data to device 1\n");
        }

        // 模拟读I/O请求
        char read_buffer[BUFFER_SIZE];
        if (io_request(devices, 1, read_buffer, strlen(data_to_write), 0)) {
            printf("Data read successfully from device 1: %s\n", read_buffer);
        } else {
            printf("Failed to read data from device 1\n");
        }

        // 模拟设备释放
        deallocate_device(devices, 1);
    }
}

#define DEVICE_COUNT 5
#define BUFFER_SIZE 1024

typedef struct {
    int device_id;
    char *device_name;
    int is_allocated;
    char *buffer; // 模拟缓冲区
    int buffer_filled; // 缓冲区状态
} Device;

// 设备数组
Device devices[DEVICE_COUNT];

// 初始化设备池
void init_device_pool() {
    for (int i = 0; i < DEVICE_COUNT; i++) {
        devices[i].device_id = i;
        devices[i].device_name = "Device_X"; // 以X代替实际设备名称
        devices[i].is_allocated = 0;
        devices[i].buffer = (char *)malloc(BUFFER_SIZE);
        devices[i].buffer_filled = 0;
    }
}

// 分配设备
int allocate_device(Device *dev, int device_id) {
    for (int i = 0; i < DEVICE_COUNT; i++) {
        if (devices[i].device_id == device_id && !devices[i].is_allocated) {
            devices[i].is_allocated = 1;
            return 1; // 分配成功
        }
    }
    return 0; // 分配失败
}

// 释放设备
void deallocate_device(Device *dev, int device_id) {
    for (int i = 0; i < DEVICE_COUNT; i++) {
        if (devices[i].device_id == device_id && devices[i].is_allocated) {
            free(devices[i].buffer); // 释放缓冲区
            devices[i].is_allocated = 0;
            devices[i].buffer = NULL;
            devices[i].buffer_filled = 0;
            return;
        }
    }
}

// 模拟I/O请求
int io_request(Device *dev, int device_id, char *data, size_t size, int write) {
    for (int i = 0; i < DEVICE_COUNT; i++) {
        if (devices[i].device_id == device_id && devices[i].is_allocated) {
            if (write) {
                // 写入数据到缓冲区
                if (devices[i].buffer_filled + size > BUFFER_SIZE) {
                    // 缓冲区溢出，模拟错误处理
                    printf("Buffer overflow error on device %d\n", device_id);
                    return 0;
                }
                memcpy(devices[i].buffer + devices[i].buffer_filled, data, size);
                devices[i].buffer_filled += size;
                return 1; // 写入成功
            } else {
                // 从缓冲区读取数据
                if (devices[i].buffer_filled == 0) {
                    printf("Buffer underflow error on device %d\n", device_id);
                    return 0;
                }
                size = (size > devices[i].buffer_filled) ? devices[i].buffer_filled : size;
                memcpy(data, devices[i].buffer, size);
                memset(devices[i].buffer, 0, size); // 清空已读取的数据
                devices[i].buffer_filled -= size;
                return 1; // 读取成功
            }
        }
    }
    return 0; // 设备未找到或未分配
}