网站建设费用预算表格,百度seo优化多少钱,郑州网站建设老牌公司,网站转微信小程序实验一 多线程与内核模块编程
一、实验目的
1、理解Linux下进程的结构#xff1b;
2、理解Linux下产生新进程的方法#xff08;系统调用—fork函数#xff09;#xff1b;
3、掌握如何启动另一程序的执行#xff1b;
4、理解Linux下线程的结构#xff1b;
5、理解…实验一 多线程与内核模块编程
一、实验目的
1、理解Linux下进程的结构
2、理解Linux下产生新进程的方法系统调用—fork函数
3、掌握如何启动另一程序的执行
4、理解Linux下线程的结构
5、理解Linux下产生新线程的方法
6、理解Linux系统下多进程与多线程的区别
7、了解什么是管道
8、熟悉UNIX/LINUX支持的管道通信方式
9、理解内核模块的编写和装载方法 二、实验内容
1、利用fork函数创建新进程并根据fork函数的返回值判断自己是处于父进程还是子进程中
2、在新创建的子进程中使用exec类的函数启动另一程序的执行分析多进程时系统的运行状态和输出结果
3、利用最常用的三个函数pthread_createpthread_join和pthread_exit编写了一个最简单的多线程程序。理解多线程的运行和输出情况
4、利用信号量机制控制多线程的运行顺序并实现多线程中数据的共享
5、分析Linux系统下多进程与多线程中的区别。
6、编写一个HelloWorld内核模块并进行装载和卸载操作。 三、实验原理
1、Linux系统下多进程编程
1理解Linux下进程的结构
Linux系统中一个进程在用户内存里有三部份的数据就是“数据段”“堆栈段”和“代码段”一般的CPU, 如I386都有上述三种段寄存器以方便操作系统的运行。“代码段” 就是存放了程序代码的数据堆栈段存放的就是子程序的返回地址、子程序的参数以及程序的局部变量。而数据段则存放程序的全局变量常数以及动态数据分配的数据空间比如用malloc之类的函数取得的空间。系统如果同时运行数个相同的程序它们之间就不能使用同一个堆栈段和数据段。
2利用fork函数创建进程和利用exec类的函数来启动进程的执行 一个程序调用fork函数系统就为一个新的进程准备了前述三个段首先系统让新的进程与旧的进程使用同一个代码段因为它们的程序还是相同的对于数据段和堆栈段系统则复制一份给新的进程这样父进程的所有数据都可以留给子进程但是子进程一旦开始运行虽然它继承了父进程的一切数据但实际上数据却已经分开相互之间不再有影响了也就是说它们之间不再共享任何数据了。 一个进程一旦调用exec类函数它本身就“死亡”了系统把代码段替换成新的程序的代码废弃原有的数据段和堆栈段并为新程序分配新的数据段与堆栈段唯一留下的就是进程号也就是说对系统而言还是同一个进程不过已经是另一个程序了。
这样就实现了多进程编程和运行了。 2、Linux系统下多线程编程
1为什么使用多线程 使用多线程的理由之一是和进程相比它是一种非常“节俭”的多任务操作方式。在Linux系统下启动一个新的进程必须分配给它独立的地址空间建立众多的数据表来维护它的代码段、堆栈段和数据段这是一种“昂贵”的多任务工作方式。而运行于一个进程中的多个线程它们彼此之间使用相同的地址空间共享大部分数据启动一个线程所花费的空间远远小于启动一个进程所花费的空间而且线程间彼此切换所需的时间也远远小于进程间切换所需要的时间。据统计总的说来一个进程的开销大约是一个线程开销的30倍左右。 使用多线程的理由之二是线程间方便的通信机制。对不同进程来说它们具有独立的数据空间要进行数据的传递只能通过通信的方式进行这种方式不仅费时而且很不方便。线程则不然由于同一进程下的线程之间共享数据空间所以一个线程的数据可以直接为其它线程所用这不仅快捷而且方便。当然数据的共享也带来其他一些问题有的变量不能同时被两个线程所修改有的子程序中声明为static的数据更有可能给多线程程序带来灾难性的打击这些正是编写多线程程序时最需要注意的地方。
多线程程序作为一种多任务、并发的工作方式还有以下的优点
1) 提高应用程序响应。这对图形界面的程序尤其有意义当一个操作耗时很长时整个系统都会等待这个操作此时程序不会响应键盘、鼠标、菜单的操作而使用多线程技术将耗时长的操作time consuming置于一个新的线程可以避免这种尴尬的情况。
2) 使多CPU系统更加有效。操作系统会保证当线程数不大于CPU数目时不同的线程运行于不同的CPU上。
3) 改善程序结构。一个既长又复杂的进程可以考虑分为多个线程成为几个独立或半独立的运行部分这样的程序会利于理解和修改。 2多线程编程 Linux系统下的多线程遵循POSIX线程接口称为pthread。编写Linux下的多线程程序需要使用头文件pthread.h连接时需要使用库libpthread.a。
利用函数pthread_create来创建一个线程利用函数pthread_join来等待一个线程的结束。多线程编程实例见实验指导书。 3、管道通信
所谓管道是指能够连接一个写进程和一个读进程的、并允许它们以生产者—消费者方式进行通信的一个共享文件又称为pipe文件。由写进程从管道的写入端句柄1将数据写入管道而读进程则从管道的读出端句柄0读出数据。
1有名管道
一个可以在文件系统中长期存在的、具有路径名的文件。用系统调用mknod( )建立。它克服无名管道使用上的局限性可让更多的进程也能利用管道进行通信。因而其它进程可以知道它的存在并能利用路径名来访问该文件。对有名管道的访问方式与访问其他文件一样需先用open( )打开。
2无名管道
一个临时文件。利用pipe( )建立起来的无名文件无路径名。只用该系统调用所返回的文件描述符来标识该文件故只有调用pipe( )的进程及其子孙进程才能识别此文件描述符才能利用该文件管道进行通信。当这些进程不再使用此管道时核心收回其索引结点。
二种管道的读写方式是相同的本实验只用无名管道。
3pipe文件的建立
分配磁盘和内存索引结点、为读进程分配文件表项、为写进程分配文件表项、分配用户文件描述符
4读/写进程互斥
内核为地址设置一个读指针和一个写指针按先进先出顺序读、写。
为使读、写进程互斥地访问pipe文件需使各进程互斥地访问pipe文件索引结点中的直接地址项。因此每次进程在访问pipe文件前都需检查该索引文件是否已被上锁。若是进程便睡眠等待否则将其上锁进行读/写。操作结束后解锁并唤醒因该索引结点上锁而睡眠的进程。 四、实验步骤 要求写出实验过程和思路用文字表述或画流程图或写出伪代码都可以。
1、Linux中的fork()函数是用于创建一个新进程的系统调用。父进程和子进程的区别在于fork()函数的返回值不同父进程中fork()函数返回子进程的进程ID而子进程中fork()函数返回0。因此我们可以通过判断fork()函数的返回值来确定当前进程是父进程还是子进程。
伪代码
初始化进程ID变量 pid 和 pid2以及返回值变量 retpid
获取当前进程ID并赋值给 pid
输出 before fork:pid 并连接 pid 的值
执行 fork 操作返回值赋值给 retpid
获取当前进程ID并赋值给 pid2
输出 after fork:pid 并连接 pid2 的值
If pid 等于 pid2则
输出 this is father print 并连接 retpid 的值
else 输出 this is child print, 连接 retpid 的值后跟 ,, 并连接 getpid() 的值
Return 0 Fork()函数返回值是负数说明子进程创建失败返回值是0则说明处于子进程中返回值是子进程的进程号则说明处于父进程中。
伪代码
* int main()
* int pid fork()
* 返回值
* -1: 子进程创建失败
* 0: 处于子进程中
* 0: 处于父进程中返回值是子进程进程号
* switch (pid)
* case -1:
* printf(fork fail!\n)
* exit(1)
* case 0:
* execl(/bin/ls, ls, -1, -color, NULL)
* 子进程用exec()装入命令ls
* exec()后子进程的代码被ls的代码取代
* printf(exec fail!\n)
* exit(1)
* default:
* wait(NULL)
* 父进程等待子进程结束后才执行
* printf(ls completed !\n)
* exit(0)
2、在新创建的子进程中使用exec类的函数启动另一程序的执行分析多进程时系统的运行状态和输出结果 3、利用最常用的三个函数pthread_createpthread_join和pthread_exit编写了一个最简单的多线程程序。理解多线程的运行和输出情况
调用函数pthread_create来创建三个线程在创建一个线程后可以调用pthread_exit函数使当前线程终止并返回一个值该值可由函数pthread_join()获取如果函数返回值不为0则说明创建线程失败直接退出程序。调用函数pthread_join来等待所有线程结束函数返回值不为0则说明还有线程没有退出打印相应的信息退出程序。
理解多线程的运行和输出情况
1运行于一个进程中的多个线程它们彼此之间使用相同的地址空间共享大部分数据启动一个线程所花费的空间远远小于启动一个进程所花费的空间而且线程间彼此切换所需的时间也远远小于进程间切换所需要的时间。
2线程间方便的通信机制。由于同一进程下的线程之间共享数据空间所以一个线程的数据可以直接为其它线程所用这不仅快捷而且方便。
伪代码
主程序 定义线程标识符 id 创建线程指定执行函数为 thread 如果创建线程失败 打印错误消息 退出程序 循环3次 打印主进程信息 等待线程结束获取线程返回值 打印线程返回的值 线程函数 thread 参数无 循环3次 打印线程信息 结束线程并返回值8 4、利用信号量机制控制多线程的运行顺序并实现多线程中数据的共享
伪代码:
主程序: 初始化信号量 sem 为 0 创建线程 t1 执行 HandleData1 创建线程 t2 执行 HandleData2 创建线程 t3 执行 ReadData1 创建线程 t4 执行 ReadData2 等待线程 t1 结束
ReadData1: 打开文件 1.dat 当没有到达文件末尾: 读取一对整数到缓冲区 stack 信号量 sem 加一 缓冲区大小 size 加一 关闭文件
ReadData2: 打开文件 2.dat 当没有到达文件末尾: 读取一对整数到缓冲区 stack 信号量 sem 加一 缓冲区大小 size 加一 关闭文件
HandleData1: 无限循环: 等待信号量 sem 从缓冲区 stack 读取数据 执行加法运算并打印结果 缓冲区大小 size 减一
HandleData2: 无限循环: 等待信号量 sem 从缓冲区 stack 读取数据 执行乘法运算并打印结果 缓冲区大小 size 减一 5、编写一个HelloWorld内核模块并进行装载和卸载操作。
编写内核模块代码
编写初始化函数init_module或者使用宏module_init来声明。这个函数将在模块装载时执行。
编写清理函数cleanup_module或者使用宏module_exit来声明。这个函数将在模块卸载时执行。
在初始化函数中使用printk函数打印“Hello World”信息到内核日志。
在清理函数中同样使用printk打印一个信息表示模块被卸载。
编写Makefile
创建一个Makefile来编译内核模块。
使用内核构建系统的make命令来编译模块。
编译内核模块
运行make命令来编译你的内核模块。
装载内核模块
使用insmod命令装载编译好的内核模块。
验证模块是否装载成功
使用lsmod命令来检查模块是否在列表中。
使用dmesg命令来检查内核日志查看“Hello World”信息是否被打印。
卸载内核模块
使用rmmod命令卸载你的内核模块。
验证模块是否卸载成功
再次使用lsmod检查模块是否从列表中移除。
使用dmesg检查内核日志确认卸载信息被打印。 五、实验数据及源代码
学生必须提交程序源代码并有注释
1、利用fork函数创建新进程并根据fork函数的返回值判断自己是处于父进程还是子进程中
#include sys/types.h
#include unistd.h
#include stdio.h
int main()
{pid_t pid;pid_t pid2;pid_t retpid;pid getpid();printf(before fork:pid%d\n, pid);retpid fork();pid2 getpid();printf(after fork:pid%d\n, pid2);//子进程返回值是0父进程返回值是子进程pid号if (pid pid2) {printf(this is father print%d\n, retpid);}else {printf(this is child print,%d,pid%d\n, retpid, getpid());}return 0;
} 2、在新创建的子进程中使用exec类的函数启动另一程序的执行分析多进程时系统的运行状态和输出结果
#includestdio.h
#includestdlib.h
#includeunistd.h
#include sys/wait.hint main()
{int pid fork(); //返回值负数子进程创建失败返回值0则处于子进程中返回值是子进程的进程号则处于父进程中。switch (pid) {case -1:printf(fork fail!\n); exit(1); case 0: //子进程在执行execl(/bin/ls, ls, -1, -color, NULL); //子进程用exec( )装入命令ls exec( )后子进程的代码被ls的代码取代这时子进程的PC指向ls的第1条语句开始执行ls的命令代码。printf(exec fail!\n);exit(1); default: //父进程在执行wait(NULL); //父进程等待子进程结束后才执行printf(ls completed !\n);exit(0);}
} 3、利用最常用的三个函数pthread_createpthread_join和pthread_exit编写了一个最简单的多线程程序。理解多线程的运行和输出情况
#includestdio.h
#includestdlib.h
#includepthread.h
void thread(void* arg) {for (int i 0; i 3; i) {printf(This is a pthread %d.\n, i 1);pthread_exit((void*)8); //使线程终止线程结束会返回一个值该值可由函数pthread_join()获取}
}
int main(void* arg) {pthread_t id; //线程标识号int ret;ret pthread_create(id, NULL, (void*)thread, NULL); //创建一个线程并使得该线程执行thread函数for (int i 0; i 3; i)printf(This is the main process %d.\n, i 1);if (ret ! 0) {printf(Create pthread error!\n); //创建线程失败exit(1); //退出程序}void* temp;ret pthread_join(id, temp); //用来等待一个线程结束直到线程退出后才执行下面的代码。if (ret) {printf(The pthread is not exit.\n);return -1;}printf(The pthread exits and returns a value %d.\n, (int)temp);return (0);
} 4、利用信号量机制控制多线程的运行顺序并实现多线程中数据的共享
两个线程负责从文件读取数据到公共的缓冲区另外两个线程从缓冲区读取数据作不同的处理加和乘运算。
#includestdio.h
#includestdlib.h
#includepthread.h
#includesemaphore.h
#define MAXSTACK 100
int stack[MAXSTACK][2];
int size 0;
sem_t sem; ////从文件1.dat读取数据每读一次信号量加一
void ReadData1(void* arg) {FILE* fp fopen(1.dat, r); //以读打开文件1.datwhile (!feof(fp)) { //函数feof若遍历到文件结束符则返回true否则返回falsefscanf(fp, %d %d, stack[size][10], stack[size][1]);sem_post(sem); //增加信号量sem的值size; //每读一次信号量加一}fclose(fp); //关闭
}//从文件2.dat读取数据
void ReadData2(void* arg) {FILE* fp fopen(2.dat, r); //以读的方式打开文件2.datwhile (!feof(fp)) { //函数feof若遍历到文件结束符则返回true否则返回falsefscanf(fp, %d %d, stack[size][0], stack[size][1]);sem_post(sem); //增加信号量sem的值size; //每读一次信号量加一}fclose(fp); //关闭文件
}//阻塞等待缓冲区有数据读取数据后释放缓冲区空间继续等待
void HandleData1(void* arg) {while (1) {sem_wait(sem); //用来阻塞当前线程直到信号量sem的值大于0解除阻塞后将sem的值减一printf(Plus:%d%d%d\n, stack[size][0], stack[size][1], stack[size][0] stack[size][1]);size--; //信号量减一}
}//阻塞等待缓冲区有数据读取数据后释放缓冲区空间继续等待
void HandleData2(void* arg) {while (1) {sem_wait(sem); //用来阻塞当前线程直到信号量sem的值大于0解除阻塞后将sem的值减一printf(Multiply:%d*%d%d\n, stack[size][0], stack[size][1], stack[size][0] * stack[size][1]);size--; //信号量减一}
}int main(void* arg) {pthread_t t1, t2, t3, t4;sem_init(sem, 0, 0); //初始化信号量sem第二个参数0表示此信号量只能为当前的所有线程共享若不为0则在进程间共享第三个参数0表示信号量的初始值pthread_create(t1, NULL, (void*)HandleData1, NULL); //创建线程1pthread_create(t2, NULL, (void*)HandleData2, NULL); //线程2pthread_create(t3, NULL, (void*)ReadData1, NULL); //线程3pthread_create(t4, NULL, (void*)ReadData2, NULL); //线程4//防止程序过早退出等其它线程结束后在退出程序pthread_join(t1, NULL); //用来等待一个线程的结束
} 5、编写一个HelloWorld内核模块并进行装载和卸载操作。 Hello World.c
#include linux/init.h //包含了宏__init和__exit
#include linux/kernel.h //包含了常用的内核函数
#include linux/module.h //包含了对模块的版本控制static int __init lkp_init(void) //模块加载函数当模块被插入到内核时调用它
{printk(0 Hello World from the kernel space...\n); //模块加载的时候系统会打印return 0;
}static void __exit lkp_cleanup(void) //模块卸载函数当模块从内核移走时调用它
{printk(0 Good Bye World! leaving kernel space...\n); //模块卸载的时候系统会打印
}module_init(lkp_init); //模块初始化
module_exit(lkp_cleanup); //模块退出MODULE_LICENSE(GPL); //模块具有GUN公共许可证
MODULE_AUTHOR(作者);
MODULE_DESCRIPTION(功能描述);
Makefile
obj - m: HelloWorld.o
CURRENT_PATH : $(shell pwd)
LINUX_KERNEL : $(shell uname - r)
LINUX_KERNEL_PATH : usr / src / linux - headers - $(LINUX_KERNEL)all :make - C $(LINUX_KERNEL_PATH) M $(CURRENT_PATH) modulesclean :
make - C $(LINUX_KERNEL_PATH) M $(CURRENT_PATH) cleanobj - m : HelloWorld.o
PWD : $(shell pwd)
KVER : $(shell uname - r)
KDIR : / lib / modules / $(KVER) / build /all :$(MAKE) - C $(KDIR) M $(PWD)clean :rm - rf * .o * .mod.c * .mod.o * .ko * .symvers * .order * .a 六、实验结果分析截屏的实验结果与实验结果对应的实验分析
1、实验结果与实验程序、实验步骤、实验原理的对应分析
2、实验过程中的问题及原因和解决办法。
1、利用fork函数创建新进程并根据fork函数的返回值判断自己是处于父进程还是子进程中 子进程返回值是0父进程返回值是子进程pid号 2、在新创建的子进程中使用exec类的函数启动另一程序的执行 当子进程在执行时子进程用exec()装入命令lsexec()后子进程的代码被ls的代码取代这时子进程的PC指向ls的第1条语句开始执行ls的命令代码。
当父进程在执行父进程等待子进程结束后才执行。
分析多进程时系统的运行状态和输出结果 第一行
top – 系统当前时间
up服务器连续运行的时间笔者见过有服务器连续运行一年以上linux服务器还是非常稳定的。
user当前有多少用户登录系统
load average这个边有3个数值分别表示系统在前1分钟5分钟15分钟的工作负载
第二行就是显示任务的数量情况其中zombie表示僵尸进程
第三行表示cpu的运行情况按下1可以显示每个核的运行情况。
第四行表示内存memory的使用情况。
第五行表示交换空间swap的使用情况。 3、利用最常用的三个函数pthread_createpthread_join和pthread_exit编写了一个最简单的多线程程序。理解多线程的运行和输出情况 4、利用信号量机制控制多线程的运行顺序并实现多线程中数据的共享 5、分析Linux系统下多进程与多线程中的区别。 对比 多进程 多线程 独立性/共享性 每个进程拥有自己独立的地址空间一个进程的崩溃不会直接影响到其他进程。但这也意味着进程间通信IPC需要特殊的机制如管道、消息队列、共享内存等。 同一进程内的所有线程共享进程的地址空间包括数据段、代码段和打开的文件等。这使得线程间通信变得简单和快速。 资源占用 每个进程有自己的一套资源包括文件描述符、环境变量等。相对于线程进程的创建、管理和上下文切换的开销较大。 线程比进程更轻量级它们共享大部分进程资源线程的创建、管理和上下文切换的开销远小于进程。 创建方式 在Linux中新进程通常是通过fork()系统调用创建的该调用会复制父进程的地址空间创建几乎完全独立的子进程。 线程通常是通过专门的线程库如POSIX线程库 - pthreads创建的。 内存管理 进程有独立的内存空间所以内存管理相对简单但是资源利用率低于多线程。 由于共享内存空间线程间共享数据非常方便但是也容易发生同步和数据一致性的问题。 安全性 由于进程间内存是隔离的因此一个进程的内存错误不会影响到其他进程。 线程间的错误和内存泄露可能会影响同一进程内的其他线程因此需要更加注意同步和互斥机制。
区别总结
隔离性多进程之间相互隔离多线程之间共享进程资源。
资源需求多进程比多线程占用更多的资源。
通信多线程之间的通信通常比多进程之间的通信更高效。
创建和管理开销创建线程的开销小于创建进程。
故障容忍进程间不会因为其他进程崩溃而受影响而线程间可能会相互影响。
开发和维护难度多线程程序的开发和维护通常比多进程更加复杂特别是在需要处理同步和共享数据的问题时。
在选择使用多进程还是多线程时通常需要根据应用程序的特性和需求来决定。如果需要大量的独立任务并且希望隔离故障可能会选择多进程如果任务之间需要频繁交换信息或者状态并且对性能有较高的要求则多线程可能是更好的选择。 6、编写一个HelloWorld内核模块并进行装载和卸载操作。 总结
内核模块至少需要两个基本函数一个是在模块装载时调用的初始化函数另一个是在模块卸载时调用的清理函数。通过module_init和module_exit宏可以分别指定这些函数。使用printk函数可以将信息输出到内核日志中这在调试内核模块时非常有用。Makefile的编写需要遵循内核模块编译的特定格式正确指向内核源代码树的位置。insmod和rmmod是装载和卸载模块的关键命令必须具备相应权限通常是root权限才能执行这些操作。lsmod命令用于验证模块是否已装载而dmesg命令则用于检查模块的输出信息这是验证模块正确性的重要步骤。 实验中遇到的问题以及解决
在完成第三个实验内容时编译时发现了程序代码中存在一些问题主要是关于线程的处理方式。
经过逐一分析
错误点线程函数中的 pthread_exit 的位置
在线程函数 thread 中pthread_exit 被放置在了循环内部。这意味着在第一次循环结束时线程就会退出导致循环不会完成其余的迭代。
解决方法将 pthread_exit 移到循环之外。
线程函数的参数和返回类型
线程函数的正确签名应该是 void* function_name(void *arg)。原本的线程函数 thread 使用了 void thread(void* arg) 形式这可能导致在某些编译器或设置下出现问题。
解决方法更改线程函数的签名为 void* thread(void* arg)。 七、思考题
1、多进程并发执行时各个进程的内存分配情况如何如何监测其分配情况
在多进程并发执行时每个进程都有自己的独立的内存空间。操作系统为每个进程分配内存并且管理这些内存。每个进程的内存空间包括代码段、数据段、堆和栈等部分。
在Unix/Linux系统中可以使用top, htop, ps等工具查看进程的内存使用情况。还可以使用valgrind等工具进行内存泄漏检测。 2、多线程中数据是如何共享的
在多线程中同一个进程内的所有线程共享该进程的内存空间。这意味着线程之间可以共享全局变量、静态变量、堆上的数据等。但是线程间的数据共享需要谨慎处理因为多个线程可能同时访问和修改同一块内存导致数据不一致或其他并发问题。为了解决这个问题可以使用互斥锁、条件变量、读写锁等同步机制来确保数据的一致性和线程的安全性。 3、Linux系统下多进程与多线程中的区别是什么
进程进程是操作系统分配资源的最小单位。每个进程有自己的内存空间和系统资源。进程间的通信(IPC)需要通过特殊的机制如管道、消息队列、共享内存等。
线程线程是操作系统调度的最小单位。同一个进程的线程共享该进程的内存空间和系统资源。线程间的通信更加简单可以直接读写共享内存。 4、程序中的sleep(5)起什么作用
sleep()是一个系统调用它使调用它的进程暂停执行指定的时间单位是秒。sleep(5)将使进程暂停执行5秒。这常常用于延迟执行、等待其他进程或简单地暂停一段时间。 5、子进程1和2为什么也能对管道进行操作
当使用管道进行进程间通信时通常创建一个管道然后使用fork()创建子进程。这样子进程会继承父进程的管道文件描述符因此子进程1和2都能够对管道进行操作。这是因为管道文件描述符在fork()之后被子进程继承所以子进程可以读写管道实现进程间通信。 6、在Linux内核源程序中经常利用内核模块实现的功能有哪些
设备驱动为特定的硬件设备提供驱动支持。
文件系统支持不同的文件系统如ext4, NTFS, FAT等。
网络协议实现新的或扩展现有的网络协议。
系统调用添加新的系统调用来扩展操作系统的功能。
这些只是一些例子实际上内核模块可以用于实现许多内核相关的功能而不必修改内核的核心代码。这提供了很大的灵活性和扩展性。 谢谢大家的支持码字不易请随手点个赞叭^-^
