Linux内核及其原理

晓夜残歌

于 2024-01-30 22:59:31 发布

阅读量1.2k

点赞数 34

文章标签： linux 运维服务器 c语言

本文链接：https://blog.csdn.net/weixin_57025326/article/details/135942256

版权

概述

定义： Linux内核是Linux操作系统的核心部分，负责管理硬件资源、进程调度、文件系统等核心功能。
架构：采用单内核架构，是一个宏内核（Monolithic Kernel），意味着核心功能都在一个单一的内核空间运行。

内核空间和用户空间

划分：内核空间包含内核代码和数据，用户空间包含用户应用程序和用户数据。
保护：内核空间和用户空间相互隔离，内核空间具有更高的权限。

示例及解释：
考虑一个简单的C程序，其中包含一个指向内核地址的指针：

#include <stdio.h>

int main() {
    int *kernel_ptr = (int *)0xFFFFFFFFA0000000; // 假设这是一个内核地址

    *kernel_ptr = 10; // 在用户空间试图写入内核地址
    return 0;
}

在这个示例中，kernel_ptr是一个指针，它试图指向一个内核空间的地址（这里假设0xFFFFFFFFA0000000是内核空间的地址）。
由于用户空间不能直接访问内核空间，试图通过kernel_ptr = 10;写入内核空间的值将导致段错误。
内核空间和用户空间之间的隔离确保了用户应用程序不能直接访问和修改内核的数据和代码，从而增加了系统的安全性和稳定性。*

内核空间和用户空间的保护机制：

地址空间划分：
内核空间：通常位于高地址空间，包含操作系统的核心部分，如调度器、设备驱动、文件系统等。
用户空间：通常位于低地址空间，包含用户应用程序和用户数据。
特殊寄存器和段选择符：
使用特殊寄存器（如CR3寄存器）和段选择符来指定当前运行的是内核空间还是用户空间。
这些机制通过硬件实现，确保访问权限的强制执行。
系统调用：
用户应用程序通过系统调用接口访问内核功能，例如文件操作、网络通信等。
系统调用提供了一种受控的方式，让用户空间与内核空间进行通信。
分页机制：
通过分页机制，内核和用户空间的虚拟地址映射到不同的物理地址。
内核空间和用户空间使用不同的页表，从而实现地址空间的隔离。

进程管理

调度器： Linux内核包含进程调度器，负责决定何时切换到哪个进程。
进程通信：提供进程间通信机制，如信号、管道、套接字等。

进程管理中的进程调度器示例及解释：
在Linux中，进程调度器负责决定何时切换到哪个进程以实现多任务处理。下面是一个简单的C程序，演示了进程创建和调度的过程。
示例代码 (process_scheduler_example.c)：

#include <stdio.h>
#include <unistd.h>

int main() {
    pid_t child_pid;

    // 创建子进程
    child_pid = fork();

    if (child_pid < 0) {
        fprintf(stderr, "Fork failed\n");
        return 1;
    }

    if (child_pid == 0) {
        // 子进程代码
        printf("Child process (PID: %d) is running.\n", getpid());
        sleep(2);
        printf("Child process is exiting.\n");
    } else {
        // 父进程代码
        printf("Parent process (PID: %d) is running.\n", getpid());
        sleep(1);
        printf("Parent process is exiting.\n");
    }

    return 0;
}

fork()系统调用用于创建一个新的进程，将当前进程（父进程）复制一份得到一个新的进程（子进程）。
fork()返回两次，一次在父进程中返回子进程的PID，一次在子进程中返回0。通过这种方式，父子进程可以根据返回值判断自己是父进程还是子进程。
父子进程都执行了printf语句，分别输出了自己的PID。由于父子进程是独立运行的，因此它们的输出可能交织在一起。
sleep()函数用于模拟进程执行的时间。在实际系统中，进程的执行时间由进程调度器决定，这里的sleep函数仅用于演示目的。
父进程和子进程都执行了一些工作后，它们分别输出退出的消息。

进程管理中的进程通信机制示例及解释：
Linux提供了多种进程间通信（IPC）的机制，其中包括信号、管道、套接字等。下面是一个使用管道进行进程通信的简单示例。
示例代码 (interprocess_communication_example.c)：

#include <stdio.h>
#include <unistd.h>

int main() {
    int pipe_fd[2];
    pid_t child_pid;

    // 创建管道
    if (pipe(pipe_fd) < 0) {
        fprintf(stderr, "Pipe creation failed\n");
        return 1;
    }

    // 创建子进程
    child_pid = fork();

    if (child_pid < 0) {
        fprintf(stderr, "Fork failed\n");
        return 1;
    }

    if (child_pid == 0) {
        // 子进程代码
        close(pipe_fd[0]); // 关闭读端
        printf("Child process is writing to the pipe.\n");
        write(pipe_fd[1], "Hello from child!", 17);
        close(pipe_fd[1]); // 关闭写端
    } else {
        // 父进程代码
        close(pipe_fd[1]); // 关闭写端
        char buffer[20];
        printf("Parent process is reading from the pipe.\n");
        read(pipe_fd[0], buffer, sizeof(buffer));
        printf("Received message from child: %s\n", buffer);
        close(pipe_fd[0]); // 关闭读端
    }

    return 0;
}

pipe()系统调用创建一个管道，它返回两个文件描述符，pipe_fd[0]用于读取，pipe_fd[1]用于写入。
fork()系统调用创建一个新的进程，父子进程共享同一个管道。
父子进程分别关闭管道中不需要的文件描述符，确保只有一个进程可以写入，另一个进程可以读取。
子进程使用write()写入一条消息到管道中，父进程使用read()读取该消息。
演示完毕后，进程关闭其不需要的文件描述符，以确保资源的正确释放。

文件系统

VFS层：提供虚拟文件系统层，使得不同类型的文件系统可以以统一的方式被操作。
文件描述符：使用文件描述符来表示和管理打开的文件。

VFS层（虚拟文件系统层）和文件描述符的详细解释：

VFS层（虚拟文件系统层）：
定义： VFS是Linux内核的一层抽象，它提供了一个接口，使得不同类型的文件系统可以以统一的方式被操作。无论文件系统是ext4、FAT32还是其他类型，应用程序和系统调用都可以使用相同的接口来进行文件的读写、创建和删除等操作。
抽象接口： VFS定义了一组抽象接口，例如open、read、write、close等，这些接口是通用的，因此不同的文件系统可以实现它们以提供自己的特定功能。通过这种方式，应用程序不需要知道底层文件系统的细节，可以通过统一的接口进行文件操作。
文件描述符：
定义：文件描述符是一个非负整数，用于唯一标识一个打开的文件或I/O流。在Linux系统中，文件、管道、套接字等都被视为文件，而文件描述符是用来引用这些文件的一种标识。
获取文件描述符：文件描述符可以通过调用系统调用（如open、socket）来获取。这些系统调用返回一个文件描述符，应用程序可以使用这个文件描述符来引用所打开的文件或I/O流。
标准文件描述符：
在Linux中，通常有三个标准文件描述符：
0：标准输入（stdin）
1：标准输出（stdout）
2：标准错误输出（stderr）
文件描述符表：
每个进程都有一个文件描述符表，用于跟踪它所打开的文件。文件描述符从0开始递增，最大值由系统限制。

示例

#include <stdio.h>
#include <stdlib.h>
#include <fcntl.h>
#include <unistd.h>

int main() {
    int fd; // 文件描述符
    char buffer[100];

    // 打开文件
    fd = open("example.txt", O_WRONLY | O_CREAT | O_TRUNC, S_IRUSR | S_IWUSR);
    if (fd == -1) {
        perror("open");
        exit(EXIT_FAILURE);
    }

    // 写入数据到文件
    write(fd, "Hello, VFS and File Descriptors!", 31);

    // 关闭文件描述符
    close(fd);

    // 重新打开文件进行读取
    fd = open("example.txt", O_RDONLY);
    if (fd == -1) {
        perror("open");
        exit(EXIT_FAILURE);
    }

    // 读取数据并输出
    read(fd, buffer, sizeof(buffer));
    printf("Read from file: %s\n", buffer);

    // 关闭文件描述符
    close(fd);

    return 0;
}

open系统调用用于打开文件，返回一个文件描述符。在这个例子中，打开一个文件用于写入（O_WRONLY），如果文件不存在则创建它（O_CREAT），如果文件已存在则截断它（O_TRUNC），并设置权限为用户可读写（S_IRUSR | S_IWUSR）。
write系统调用用于向文件写入数据，它使用先前获得的文件描述符。
close系统调用用于关闭文件描述符，确保不再需要对文件的访问。
重新使用open系统调用，这次以只读模式打开文件，以读取文件中的数据。
read系统调用用于从文件读取数据，将数据存储在指定的缓冲区中。
最后，再次使用close系统调用关闭文件描述符。

设备驱动

模块化：支持模块化的设备驱动，允许在运行时加载和卸载驱动。
中断处理：处理硬件中断，与硬件交互。

示例和详细解释：
考虑一个简单的字符设备驱动程序的模块化实例。以下是一个包含基本注释的示例代码：
模块代码 (modular_driver_module.c)：

#include <linux/init.h>
#include <linux/module.h>
#include <linux/fs.h>

#define DEVICE_NAME "modular_driver"

MODULE_LICENSE("GPL");
MODULE_AUTHOR("Your Name");
MODULE_DESCRIPTION("Modular Device Driver");

static int major_number;

// 设备打开时调用
static int modular_driver_open(struct inode *inode, struct file *file) {
    printk(KERN_INFO "Modular Driver: Opened\n");
    return 0;
}

// 设备关闭时调用
static int modular_driver_release(struct inode *inode, struct file *file) {
    printk(KERN_INFO "Modular Driver: Closed\n");
    return 0;
}

static struct file_operations modular_driver_fops = {
    .open = modular_driver_open,
    .release = modular_driver_release,
};

// 模块初始化函数
static int __init modular_driver_init(void) {
    major_number = register_chrdev(0, DEVICE_NAME, &modular_driver_fops);
    if (major_number < 0) {
        printk(KERN_ALERT "Failed to register a major number\n");
        return major_number;
    }
    printk(KERN_INFO "Modular Driver: Registered with major number %d\n", major_number);
    return 0;
}

// 模块卸载函数
static void __exit modular_driver_exit(void) {
    unregister_chrdev(major_number, DEVICE_NAME);
    printk(KERN_INFO "Modular Driver: Unregistered\n");
}

module_init(modular_driver_init);
module_exit(modular_driver_exit);

Makefile (Makefile)：

obj-m += modular_driver_module.o

all:
    make -C /lib/modules/$(shell uname -r)/build M=$(PWD) modules

clean:
    make -C /lib/modules/$(shell uname -r)/build M=$(PWD) clean

编译和加载模块：

$ make
$ sudo insmod modular_driver_module.ko

modular_driver_open和modular_driver_release是设备打开和关闭时调用的函数。在实际驱动程序中，这里可能会执行更多的初始化和清理工作。
modular_driver_fops是文件操作的函数指针集合，定义了设备的行为。这里只包括了打开和关闭操作，实际的驱动可能还包括读写等操作。
modular_driver_init是模块初始化函数，注册了字符设备。如果注册失败，它将向内核日志打印一条错误消息。
modular_driver_exit是模块卸载函数，注销了字符设备。在加载模块时，module_init将调用modular_driver_init；在卸载模块时，module_exit将调用modular_driver_exit。
Makefile用于编译模块，其中obj-m += modular_driver_module.o指定了模块的目标文件。
使用insmod命令加载模块，通过lsmod命令查看已加载的模块。

内存管理

虚拟内存：使用分页和分段机制，提供虚拟内存。
页面置换：实现页面置换算法，确保有效使用内存。

详细解释：

虚拟内存：
虚拟内存是一种计算机内存管理技术，通过使用分页和分段机制，为每个进程提供了一个看似连续且私有的内存空间，称为虚拟地址空间。这个虚拟地址空间被映射到物理内存，使得操作系统能够更灵活地管理进程的内存需求。
分页和分段机制：
分页机制：
虚拟内存被划分为固定大小的块，称为页（Page）。物理内存也被分为相同大小的块。
操作系统维护一个页表，记录虚拟内存页到物理内存页的映射关系。当程序访问一个虚拟地址时，通过页表查找对应的物理地址。
这种方式允许操作系统将不同进程的虚拟内存映射到相同的物理内存，实现进程之间的内存隔离。
分段机制：
虚拟内存被划分为逻辑段，每个段有不同的访问权限和属性。例如，代码段、数据段、堆段、栈段等。
每个段的大小是动态的，根据进程的需求进行分配。这样，不同进程的虚拟内存结构可以有所不同。
页面置换：
在虚拟内存系统中，当操作系统需要将一个页面从物理内存换出到磁盘（或其他存储介质），以便为其他页面腾出空间时，就需要使用页面置换算法。
页面置换算法的实现：
LRU（Least Recently Used）最近最少使用算法：
记录每个页面最近一次被访问的时间。
当需要置换页面时，选择最长时间没有被访问的页面进行替换。
LRU的实现可能需要维护一个访问时间戳队列或使用近似算法来估计最近的使用情况。
FIFO（First-In-First-Out）先进先出算法：
将页面按照它们被加载到内存的顺序排列成一个队列。
当需要置换页面时，选择队列中最早加载的页面进行替换。
Clock算法：
将页面组织成一个环形链表，用一个指针（钟表指针）指向当前页面。
当需要置换页面时，顺时针地找到第一个“未被访问”（被标记为未被访问）的页面进行替换，同时更新钟表指针。
LFU（Least Frequently Used）最不经常使用算法：
统计每个页面的访问次数，选择访问次数最少的页面进行替换。
页面置换的目标：
最小化页面缺失率：
页面缺失率是指在访问某个页面时，该页面未在内存中的概率。页面置换算法的目标是尽可能降低页面缺失率，提高系统性能。
最小化页面置换开销：
页面置换会引入磁盘I/O开销，因此页面置换算法也需要考虑减少I/O操作的次数，以降低系统开销。

系统调用

用户空间接口：提供一组系统调用，用户空间程序通过系统调用访问内核功能。
权限控制：系统调用的执行受到权限和安全性控制。

详细解释：

用户空间接口：
系统调用（Syscall）：
概述：操作系统提供一系列的系统调用，如文件操作、进程管理、内存管理等。这些调用允许用户空间程序请求内核执行某些特权操作。
例子： open()、read()、write() 等系统调用允许用户程序操作文件，fork() 允许创建新进程等。
库函数封装：
概述：为了方便使用系统调用，通常在用户空间提供库函数的封装，这些库函数直接或间接调用系统调用。例如，C标准库的 fopen() 可以封装文件打开的系统调用 open()。
命令行工具和图形界面：
概述：操作系统还提供命令行工具和图形用户界面（GUI），这些界面也是用户空间程序的一部分。用户可以通过命令行或图形界面使用系统调用来执行操作。
权限控制：
用户身份验证：
概述：在系统中，用户需要通过身份验证机制登录。通常使用用户名和密码，或者其他身份验证手段来验证用户的身份。
实现：操作系统维护一个用户数据库，记录了用户的信息，包括用户名、密码哈希、权限等。
访问控制列表（ACL）和权限位：
概述：文件系统使用访问控制列表或权限位来限制对文件的访问。每个文件都有一个所有者和一组权限，指定了该文件的读、写、执行等权限。
实现：文件系统会记录每个文件的所有者和权限信息，系统调用（如 chmod）用于更改这些信息。
进程权限和沙箱：
概述：操作系统通过进程权限来控制程序对系统资源的访问。沙箱技术将进程限制在一个受控的环境中，以防止对系统的不良影响。
实现：操作系统通过分配不同的用户和组、使用 capabilities 等手段来实现进程权限的控制。
特权级别和超级用户：
概述：操作系统通常有多个特权级别，普通用户在较低的级别运行，而超级用户（root或管理员）在更高的特权级别运行，可以执行更敏感的操作。
实现：操作系统通过特权级别来限制对某些敏感操作的访问，只有超级用户才能执行这些操作。

网络协议栈

套接字：提供网络通信的接口，支持TCP/IP协议栈。
网络设备：管理网络设备和数据包的传输。

详细解释：

套接字（Socket）：
在Linux内核中，套接字是一种抽象的通信接口，允许进程在网络上进行数据交换。Linux内核提供了套接字接口，使得用户空间的程序能够通过系统调用进行网络通信。
套接字类型：内核支持不同类型的套接字，包括面向连接的（SOCK_STREAM）和无连接的（SOCK_DGRAM）等。套接字类型决定了通信的性质。
套接字地址：在Linux内核中，套接字地址是由sockaddr结构表示的。IPv4使用struct sockaddr_in，而IPv6使用struct sockaddr_in6。
套接字系统调用：内核提供了一系列的系统调用，如socket()、bind()、listen()、accept()、connect()、send()、recv()等，用于创建、配置和使用套接字进行通信。
网络设备：
在Linux内核中，网络设备是硬件和软件实体，负责处理数据包的传输和路由。这包括网卡、路由器、交换机等。

面向内核开发的案例

创建了一个简单的字符设备驱动程序，每次读取操作会返回一个伪随机字节。

#include <linux/init.h>
#include <linux/module.h>
#include <linux/fs.h>
#include <linux/uaccess.h>
#include <linux/random.h>

#define DEVICE_NAME "randomdev"

MODULE_LICENSE("GPL");
MODULE_AUTHOR("Your Name");
MODULE_DESCRIPTION("Random Number Generator Device");

static int major_number;

// 打开设备时调用
static int randomdev_open(struct inode *inode, struct file *file) {
    printk(KERN_INFO "Random Device: Opened\n");
    return 0;
}

// 关闭设备时调用
static int randomdev_release(struct inode *inode, struct file *file) {
    printk(KERN_INFO "Random Device: Closed\n");
    return 0;
}

// 读取设备时调用
static ssize_t randomdev_read(struct file *file, char *buffer, size_t length, loff_t *offset) {
    unsigned char random_byte;

    // 生成一个伪随机字节
    get_random_bytes(&random_byte, 1);

    // 将伪随机字节复制到用户空间
    if (copy_to_user(buffer, &random_byte, sizeof(random_byte))) {
        return -EFAULT; // 如果复制失败，则返回错误
    }

    return sizeof(random_byte); // 返回成功读取的字节数
}

// 定义设备操作函数集合
static struct file_operations randomdev_fops = {
    .open = randomdev_open,
    .release = randomdev_release,
    .read = randomdev_read,
};

// 模块初始化函数
static int __init randomdev_init(void) {
    // 注册字符设备，获取主设备号
    major_number = register_chrdev(0, DEVICE_NAME, &randomdev_fops);
    if (major_number < 0) {
        printk(KERN_ALERT "Failed to register a major number\n");
        return major_number; // 如果注册失败，则返回错误号
    }

    printk(KERN_INFO "Random Device: Registered with major number %d\n", major_number);
    return 0; // 返回0表示初始化成功
}

// 模块卸载函数
static void __exit randomdev_exit(void) {
    // 注销字符设备
    unregister_chrdev(major_number, DEVICE_NAME);
    printk(KERN_INFO "Random Device: Unregistered\n");
}

// 注册初始化和卸载函数
module_init(randomdev_init);
module_exit(randomdev_exit);

编写Makefile (Makefile)：

obj-m += random_device_module.o

all:
    make -C /lib/modules/$(shell uname -r)/build M=$(PWD) modules

clean:
    make -C /lib/modules/$(shell uname -r)/build M=$(PWD) clean

编译和加载模块：

$ make
$ sudo insmod random_device_module.ko

代码释义

#include <linux/init.h>
#include <linux/module.h>
#include <linux/fs.h>
#include <linux/uaccess.h>
#include <linux/random.h>

这一段包含了必要的头文件，其中<linux/init.h>和<linux/module.h>提供了模块的初始化和退出函数，<linux/fs.h>包含文件系统相关的定义，<linux/uaccess.h>提供了用户空间访问内核空间的函数，<linux/random.h>提供了生成随机数的函数。

#define DEVICE_NAME "randomdev"

定义了设备的名称，用于注册字符设备时标识设备。

MODULE_LICENSE("GPL");
MODULE_AUTHOR("Your Name");
MODULE_DESCRIPTION("Random Number Generator Device");

这些宏用于定义模块的许可证、作者和描述信息。

static int major_number;

定义了设备的主设备号，这个变量将在初始化时由register_chrdev函数返回。

static int randomdev_open(struct inode *inode, struct file *file) {
    printk(KERN_INFO "Random Device: Opened\n");
    return 0;
}

randomdev_open是设备打开时调用的函数，它向内核日志打印一条消息，并返回0表示成功。

static int randomdev_release(struct inode *inode, struct file *file) {
    printk(KERN_INFO "Random Device: Closed\n");
    return 0;
}

randomdev_release是设备关闭时调用的函数，它向内核日志打印一条消息，并返回0表示成功。

static ssize_t randomdev_read(struct file *file, char *buffer, size_t length, loff_t *offset) {
    unsigned char random_byte;
    get_random_bytes(&random_byte, 1);

    if (copy_to_user(buffer, &random_byte, sizeof(random_byte))) {
        return -EFAULT;
    }

    return sizeof(random_byte);
}

randomdev_read是读取设备时调用的函数，它生成一个伪随机字节，并将其复制到用户提供的缓冲区。如果复制失败，函数返回-EFAULT表示错误，否则返回成功读取的字节数。

static struct file_operations randomdev_fops = {
    .open = randomdev_open,
    .release = randomdev_release,
    .read = randomdev_read,
};

randomdev_fops是设备操作的函数指针集合，它包含了设备打开、关闭和读取时调用的函数。

static int __init randomdev_init(void) {
    major_number = register_chrdev(0, DEVICE_NAME, &randomdev_fops);
    if (major_number < 0) {
        printk(KERN_ALERT "Failed to register a major number\n");
        return major_number;
    }

    printk(KERN_INFO "Random Device: Registered with major number %d\n", major_number);
    return 0;
}

randomdev_init是模块初始化时调用的函数，它通过register_chrdev注册字符设备，获取主设备号。如果注册失败，函数向内核日志打印一条错误消息，然后返回错误号。否则，打印注册成功的消息并返回0表示初始化成功。

static void __exit randomdev_exit(void) {
    unregister_chrdev(major_number, DEVICE_NAME);
    printk(KERN_INFO "Random Device: Unregistered\n");
}

randomdev_exit是模块卸载时调用的函数，它通过unregister_chrdev注销字符设备，同时向内核日志打印一条卸载成功的消息。

module_init(randomdev_init);
module_exit(randomdev_exit);

这两行宏指定了模块的初始化和卸载函数。在加载模块时，module_init将调用randomdev_init；在卸载模块时，module_exit将调用randomdev_exit。

在这里插入图片描述

晓夜残歌

关注

34
点赞
踩
14

收藏

觉得还不错? 一键收藏
打赏
0
评论
Linux内核及其原理

定义： Linux内核是Linux操作系统的核心部分，负责管理硬件资源、进程调度、文件系统等核心功能。架构：采用单内核架构，是一个宏内核（Monolithic Kernel），意味着核心功能都在一个单一的内核空间运行。
复制链接

扫一扫