Linux 操作系统内核

《Linux 操作系统内核》由会员分享，可在线阅读，更多相关《Linux 操作系统内核（43页珍藏版）》请在装配图网上搜索。

1、Linux 操作系统内核基本实验指导Contentsz 实验大纲z 系统安装实验z Linux内核实验z 进程管理实验z 存储管理实验z 进程通信实验z I/O 设备管理实验z 文件系统管理实验1实验大纲1.1 实验目的在学习操作系统课程内容同时，以开放式源代码操作系统 Linux 为实验平台，同步完成 Linux 操作系统内核的代码分析和修改等 7 组基本课程实验。通过实验，熟悉 Linux 系统使用方法，掌握 Linux 内核系统结构，了解 Linux 进程管理、存储管理、设备管理、文件系统等资源管理功能的实现机理和典型算法。初步掌握运用内核开发环境对内核进行修改完善的能力。通过本课程实验

2、，使得学生熟悉 Linux 操作系统相关技术，并进一步巩固课堂所学有关操作系统人机界面和资源管理得相关知识；并通过 Linux 源代码分析和简单编程，培养学生对实际操作系统的基本系统分析能力。1.2 实验内容Linux 基本实验由以下 7 组实验组成。1.2.1 第 1 组 系统安装实验实验 1.1 Linux 系统安装从 CD-ROM 安装 Red Hat Linux 操作系统，如 Red Hat Linux7.2，建立后续各个实验的运行环境。实验 1.2 虚拟机安装在配备 Windows 操作系统 Host 机上，安装虚拟机软件 Virtual PC forWindows 或 VMware

3、 For Windows，进行 BIOS 设定， 对硬盘进行分区和格式化，安装 Linux 操作系统，以便在一台机器上模拟出多种操作系统运行环境。实验 1.3 Shell 编程编制简单的 Shell 程序，该程序在用户登录时自动执行，显示某些提示信息,如“ Welcome to Linux”, 并在命令提示符中包含当前时间、当前目录和当前用户名等基本信息。1.2.2 第 2 组 Linux 内核实验实验 2.1 观察 Linux 行为学习 linux 内核、进程、存储和其他资源的一些重要特性。通过使用/proc文件系统接口, 编写一个程序检查反映机器平衡负载、进程资源利用率方面的各种内核值,

4、学会使用/proc 文件系统这种内核状态检查机制。实验 2.2 内核定时器学习掌握内核定时器的实现原理和方法，建立一种用户空间机制来测量多线程程序的执行时间。实验 2.3 内核模块模块是 Linux 系统的的一种特有机制，可用于动态扩展操作系统内核功能。编写实现某些特定功能的模块，将其作为内核的一部分在管态下运行。例如， 通过内核模块编程在/porc 文件系统中实现系统时钟的读操作接口。实验 2.4 系统调用向现有 Linux 内核加入一个新的系统调用从而在内核空间中实现对用户空间的读写。例如，设计并实现一个新的内核函数 mycall( )，此函数通过一个引用参数的调用返回当前系统时间，功能上

5、基本与 gettimeofday( )相同。1.2.3 第 3 组 进程管理实验 3.1 进程行为观察1. 在 Linux 下，分别用 snice、 skill、 top 等命令和/proc 中的有关目录、文件观察系统中进程运行情况和 CPU 工作情况。2. 在 Linux下，用 ptrace()、gdb跟踪一个进程的运行情况，用 strace工具跟踪 fork()过程，用 ltrace 工具跟踪 execl() 过程。观察并分析跟踪信息。实验 3.2 代码分析阅读分析 Linux 中的进程建立模块、进程撤销模块、进程调度模块、系统调用总入口模块，了解进程的创建、执行、等待、退出等过程。实验

6、3.3 Shell 编程1. 以超级用户身份编程，计算某一时段中所有程序平均运行时间。2. 通过编写 shell 程序，了解子进程的创建和父进程与子进程间的协同，获得多进程程序的编程经验。1.2.4 第 4 组 存储管理实验 4.1 观察实验1. 在 Linux 下，使用 gdb 程序观察一个程序文件的内容和结构。启动该程序执行，再用 GDB 观察其内存映象的内容和结构。2. 在 Linux 下，用 free 和 vmstat 命令观察内存使用情况。3. 在 Linux 下，查看/proc 与内存管理相关的文件，并解释显示结果。4. 在 Linux 下，用 malloc()函数实现 cat 或

7、 copy 命令。实验 4.2 代码分析阅读 Linux/Minix 中以下模块的调用主线，并写出分析报告z exec 系统调用的内部实现模块调用主线z malloc 函数的内部实现模块调用主线z 缺页中断处理程序实验 4.3 虚拟存储器管理学习 Linux 虚拟存储实现机制；编写代码，测试虚拟存储系统的缺页错误（缺页中断）发生频率。1.2.5 第 5 组 进程通信实验 5.1 观察实验在 Linux 下，用 ipcs()命令观察进程通信情况。实验 5.2 代码分析阅读 Linux/Minix 中以下模块的调用主线，并写出分析报告。（ 1） kill 系统调用内部实现模块调用主线。（ 2） p

8、ipe 系统调用内部实现模块调用主线。实验 5.3 进程同步实验在学习 linux 内核的同步机制基础上，深入分析各种同步机制的实现方案，设计和编写一套同步原语。1.2.6 第 6 组 I/O 设备管理实验 6.1. 观察实验1 stat 命令查看机器上硬盘特别文件的 I 节点内容。2在 Linux 下，查看/proc 与内存管理相关的文件，解释显示结果。实验 6.2 代码分析阅读 Linux/Minix 中以下模块的调用主线（ 1） print 函数内部实现模块调用主线。（ 2） scan 函数内部实现模块调用主线。写出分析报告。实验 6.3 编程实验编写一个 daemon 进程，该进程定时

9、执行 ps 命令，然后将该命令的输出写至文件 F1 尾部。实验 6.4 设备驱动程序了解 Linux 的设备驱动程序的组织结构和设备管理机制，编写简单的字符设备和块设备驱动程序。 1.2.7 第 7 组 文件系统管理实验 7.1 代码分析阅读 Linux/Minix 中有关文件模块的调用主线,并写出分析报告，包括z 文件建立模块，即系统调用 create()z 文件删除模块，即系统调用 rm()z 读/写模块，即 read/write实验 7.2 编程实验 1在 Linux 环境下，编写 Shell 程序，计算磁盘上所有目录下平均文件个数、所有目录平均深度、所有文件名平均长度实验 7.3 编程

10、实验 2在 Linux 环境下，编写一个利用 Linux 系统调用删除文件的程序，加深对文件系统和文件操作的理解。1.3 实验要求z 学生以小组为单位，每组人数不超过 4 人。z 以上 7 组实验中，每组至少完成 1 个实验，完成的实验总数不少于 8 个，其中编程实验不少于 5。z 实验完成后提交课程实验报告文档，并验收程序代码和上机演示。z 实验报告中应附有实验程序运行截图z 课程实验报告要求对于编程实验，报告应包括：题目，实验目的、实验内容、实验设计原理、实验步骤、实验结果及分析和人员任务分配等。2. 系统安装实验2.1 实验 1.1 Linux 系统安装1、实验目的从 CD-ROM 安装

11、 Red Hat Linux 操作系统，如 Red Hat Linux7.2，建立后续各个实验的运行环境。2、实验内容（以 Red Hat Linux7.2 为例）Red Hat Linux7.2 安装光盘共有两张，第一张可直接从光盘启动，包含大部分的软件包和一些安装工具。第二张光盘包含许多附加软件包。以下为安装过程和注意事项。（ 1）启动安装程序。用 Linux 的第一张光盘，从光驱引导启动程序，进入启动界面，显示提示符 ”boot: ”，选择图形模式进行安装。（ 2）选择安装界面的使用语言（ 3）选择默认的键盘设置（ 4）选择默认的鼠标设置（ 5）选择安装类型。 Red Hat Linux

12、 提供了个人桌面、工作站、服务器和定制等多种安装类型。本实验选择个人桌面或定制方式。（ 6）进行硬盘分区。 Red Hat Linux 采用了“装载”的处理方式，将 1 个分区和 1 个目录联系起来，每个分区都是整个文件系统的一部分。Linux 最少需要 2 个分区： Linux native(文件)分区、 Linux Swap（交换）分区。前者用于存放 Linux 系统文件，只能用 EXT2 分区类型，在分区时应将载入点设置为“ /”目录; 后者用作交换空间，将主存内暂时不用的数据缓存起来。建议采用如下分区方案z SWAP 分区SWAP 分区大小至少等于实际系统内存容量，一般可取为内存的 2

13、 倍。z /boot 分区包含操作系统内核和启动时所用文件。建立单独的/boot 分区后，即使主要根分区出了问题，系统仍然能够启动。此分区大小约在 50MB-100MB 之间z /分区根目录挂载位置。系统运行所需要的其它文件都在该分区，大小约在 1.7GB 到5GB 之间初次安装系统时，最好选择自动安装方式。如果安装者对系统比较熟悉，可以用系统配置的营盘管理工具 Disk Druid 来订制所需分区。（ 7）将文件系统设置为 EXT2（ 8）配置引导装载程序。选择 LILO 作为引导安装程序。 LILO 可以安装在第一硬盘的主引导区（ MBR）或 Linux 分区的引导扇区。如果使用 LILO

14、 来做双启动，须选择前者；如果用 Linux 启动软盘或其它系统引导器引导 Linux，选择后者，即将 LILO 安装在 Linux 分区的引导扇区。（ 9）网络和防火墙配置（ 10）选择默认的语言及其他语言支持（ 11）时区配置（ 12）设置 root 配置（ 13）选择软件包组(14) 筹建引导盘(15) 配置显卡(16) 进行安装2.2 实验 1.2 虚拟机 VM 软件安装1、实验目的在配备 Windows操作系统 Host机上，安装虚拟机软件 Virtual PC for Windows或 VMwareFor Windows， 进行 BIOS 设定， 对硬盘进行分区和格式化，安装 Li

15、nux 操作系统，以便在一台机器上模拟出多种操作系统运行环境。通过本实验，进一步掌握课堂上所讲的虚拟机的概念。2、实验内容：实验前的准备：1、 获取安装介质2、 熟悉虚拟机的操作安装步骤（以 Vmware 为例）：1、 虚拟机软件的安装及设置（ 1）、安装 VMware,输入虚拟机序列号（ 2）、创建一个新的虚拟机。第一步：“File”-“New Virtual Machine”-“Custom”-“Next”-操作系统那栏选 Linux-“Next” 。 第二步：设置虚拟机名以及配置文件 -“Next” 。第三步：设置虚拟机的内存大小。第四步：网络连接，使用默认设置-“Next” 。 第五步

16、：磁盘设定，如果你不是想让红旗 Linux 桌面 4.0 终生运行在虚拟机里，请选“Use a physical disk” ，让虚拟机与当前系统共用同一硬盘，而不是虚拟出一个硬盘。有一定风险，但是只要不胡乱操作，风险不大-“Next” 。 第六步：指定要使用的硬盘-“Next” ，设置配置文件的位置-“Finish” ，忽略那个风险提示。（ 3）、光驱软驱默认情况下也是和当前系统共用的，使用 iso 文件引导虚拟机，则“Edit virtualmachine settings”，在左侧列表中选“DVD/CD-ROM”那项，再在右侧选“Use ISO image:”，指定安装红旗 Linux

17、桌面 4.1 的 iso 文件。（ 4）、虚拟机默认不是从光盘引导的，要在它的 BIOS 里改，得先“Start this virtual machine”。如果出现“Do not forget to .”的提示框，直接点“OK”。待 VMware 窗口中一大块变黑的时候，赶快用鼠标点那块黑，那块黑是虚拟机的屏幕。现在你的鼠标和键盘就转为控制虚拟机了。注意虚拟机屏幕下方的进度条，在走完之前，按“F2”键进行 BIOSs 设定。（ 5）、用键盘的左右箭头键选中“Boot”标签，用上下箭头键选中“CD-ROM”。同时用“Shift”键和“+”键，把“CD-ROM”拎到顶上。用键盘的左右箭头键选中“

18、Exit”标签，用上下箭头键选中“Exit Saving Changes”，回车-“YES”，等待虚拟机重新启动。同时按“Ctrl”和“Alt”键，鼠标和键盘就从虚拟机中解脱出来了。看到进度条的时候按 VMware 窗口左上方的红方块，停掉虚拟机。2.3 实验 1.3 Shell 编程1、实验目的与内容编制简单的 Shell 程序，该程序在用户登录时自动执行，显示某些提示信息,如“ Welcome to Linux”, 并在命令提示符中包含当前时间、当前目录和当前用户名等基本信息。2、源代码清单#include#includeint main()printf(Hello Linuxn);int

19、 pid;int state;int pfd2;pipe(pfd);if (fork()=0)printf(In the grep progressn);dup2(pfd0,0);close(pfd0);close(pfd1);execlp(grep,grep,sh,0);perror(exelp grep error);esle if(fork()=0)printf(In the ps progressn);dup2(pfd1,1);close(pfd0);close(pfd1);execlp(ps,ps,-ef,0);perror(execlp ps -ef);close(pfd1);cl

20、ose(pfd0);wait(&state);wait(&state);3. Linux 内核实验3.1 实验 2.1 观察 Linux 行为1、实验目的学习 linux 内核、进程、存储和其他资源的一些重要特性。通过使用/proc 文件系统接口,编写一个程序检查反映机器平衡负载、进程资源利用率方面的各种内核值, 学会使用/proc文件系统这种内核状态检查机制。2、实验内容编写一个默认版本的程序通过检查内核状态报告 Linux 内核行为。程序应该在 stdout上打印以下值：1， CPU 类型和型号；2，所使用的 Linux 内核版本；3，从系统最后一次启动以来已经经历了多长时间（天，小时和分

21、钟）；4，总共有多少 CPU 时间执行在用户态，系统态，空闲态；5，配置内存数量；当前可用内存数，磁盘读写请求数；6，内核上下文转换数；7，系统启动到目前创建了多少进程。设计思路：首先得到命令行，再解释命令行，然后到/proc 查找文件，最后执行命令。3、程序源代码清单（参考）#include #include int main( int argc, char *argv)char repTypeName16;char c1, c2, ch;int interval, duration;char *lineBuf;int LB_SIZE;FILE *thisProcFile;char *now

22、;int iteration;/决定报告类型strcpy(repTypeName, Standard);if (argc 1)sscanf(argv1,%c%c,&c1,&c2);if (c1 != -)fprintf(stderr, usage:ksamp -s-1 int durn);exit(1);if (c2 = s)strcpy(repTypeName, Short);if (c2 = 1)strcpy(repTypeName, Long);interval = atoi(argv2);duration = atoi(argv3);/得到当前时间/* gettimeofday(&no

23、w, NULL); */printf(Status report type %s at %sn, repTypeName, ctime(&(now);thisProcFile = fopen(/proc/sys/kernel/hostname,r); /打开文件fgets(lineBuf, LB_SIZE + 1, thisProcFile); /读取文件printf(Machine hostname: %s, lineBuf); /打印文件fclose(thisProcFile); /关闭文件/内核版本thisProcFile = fopen(/proc/version,r);fgets(l

24、ineBuf,LB_SIZE + 1,thisProcFile);printf(The Version: %sn, lineBuf);fclose(thisProcFile);/CPU 类型和型号thisProcFile = fopen(/proc/cpuinfo,r);fgets(lineBuf,LB_SIZE + 1,thisProcFile);printf(The CPU: %sn, lineBuf);fclose(thisProcFile);/当前时间thisProcFile = fopen(/proc/uptime,r);fgets(lineBuf,LB_SIZE + 1,thisP

25、rocFile);printf(The Running Time: %sn, lineBuf);fclose(thisProcFile);/内存情况printf(bThe MemInfo:n);thisProcFile = fopen(/proc/meminfo,r);while (! feof(thisProcFile) putchar(fgetc(thisProcFile);fclose(thisProcFile);/ 当前状态printf(bThe Status:n);thisProcFile = fopen(/proc/stat,r);while (! feof(thisProcFil

26、e) putchar(fgetc(thisProcFile);fclose(thisProcFile);iteration = 0;interval = 2;duration = 60;while(iteration duration)sleep(interval);thisProcFile = fopen(/proc/loadavg,r);while (! feof(thisProcFile) putchar(fgetc(thisProcFile);fclose(thisProcFile);iteration += interval;return(0);3.2 实验 2.2 内核定时器1、实

27、验目的学习掌握内核定时器的实现原理和方法，建立一种用户空间机制来测量多线程程序的执行时间。2、实验内容A、 用定时器 ITIMER_REAL 实现 gettimeofday 的功能。使其一秒钟产生一个信号，计算已经过的秒数。设计思路：设置定时器 ITIMER_REAL 间隔为一秒钟。并为计时到时设定信号处理程序，即singal(SIGALRM,)，使其输出当前所记时间。A.3、 shell 程序源代码清单/*part1.c*/part 1#include #include #include static void sighandle(int);static int second = 0;int

28、 main()struct itimerval v;signal(SIGALRM,sighandle);v.it_interval.tv_sec = 1;v.it_interval.tv_usec = 0;v.it_value.tv_sec = 1;v.it_value.tv_usec = 0;setitimer(ITIMER_REAL,&v,NULL);for(;);static void sighandle(int s)second+;printf(%dr,second);fflush(stdout);B、 记录一个进程运行时所占用的 real time, cpu time,user ti

29、me ,kernel time。设计思路：任务开始前设置好定时器 ITIMER_REAL， ITIMER_VIRTUAL， ITIMER_PROF,即其相应的信号处理程序。在任务执行过程中内核定时器通过产生等间隔的信号来记录进程所需的各种时间参量，并在任务结束后打印出来。B.3、 shell 程序源代码清单/*part2.c*/part2#include #include #include static void sighandle(int);static long realsecond = 0;static long vtsecond = 0;static long profsecond =

30、 0;static struct itimerval realt,virtt,proft;int main()struct itimerval v;int i,j;long moresec,moremsec,t1,t2;signal(SIGALRM,sighandle);signal(SIGVTALRM,sighandle);signal(SIGPROF,sighandle);v.it_interval.tv_sec = 10;v.it_interval.tv_usec = 0;v.it_value.tv_sec = 10;v.it_value.tv_usec = 0;setitimer(IT

31、IMER_REAL,&v,NULL);setitimer(ITIMER_VIRTUAL,&v,NULL);setitimer(ITIMER_PROF,&v,NULL);for(j= 0;j1000;j+)for(i= 0;i500;i+)printf(*r);fflush(stdout);getitimer(ITIMER_PROF,&proft);getitimer(ITIMER_REAL,&realt);getitimer(ITIMER_VIRTUAL,&virtt);printf(n);moresec = 10 - realt.it_value.tv_sec;moremsec = (100

32、0000 - realt.it_value.tv_usec)/1000;printf(realtime = %ld sec, %ld msecn,realsecond+moresec,moremsec);moresec = 10 - proft.it_value.tv_sec;moremsec = (1000000 - proft.it_value.tv_usec)/1000;printf(cputime = %ld sec, %ld msecn,profsecond+moresec,moremsec);moresec = 10 - virtt.it_value.tv_sec;moremsec

33、 = (1000000 - virtt.it_value.tv_usec)/1000;printf(usertime = %ld sec, %ld msecn,vtsecond+moresec,moremsec);t1 = (10 - proft.it_value.tv_sec)*1000 + (1000000 - proft.it_value.tv_usec)/1000 +profsecond*10000;t2 = (10 - virtt.it_value.tv_sec)*1000 + (1000000 - virtt.it_value.tv_usec)/1000 +vtsecond*100

34、00;moresec = (t1 - t2)/1000;moremsec = (t1 - t2) % 1000;printf(kerneltime = %ld sec, %ld msecn,moresec,moremsec);fflush(stdout);static void sighandle(int s)switch(s)case SIGALRM:realsecond+=10;break;case SIGVTALRM:vtsecond+=10;break;case SIGPROF:profsecond+=10;break;default :break;C、 编写一个主程序产生两个子进程，

35、分别低轨计算 N =20， 30， 36 的 Fibonacci 序列。分别对三个进程计算相应的 real time, cpu time,user time ,kernel time。设计思路：与（ 2）原理基本相同，不同的只是在任务开始前要分别设定好每个进程的定时器，而且其最终的实验结果也由相应进程自身打印出来。C.3、 shell 程序源代码清单/*part3.c*/part3#include #include #include #include static void c1_sighandle(int s);static void c2_sighandle(int s);static v

36、oid p_sighandle(int s);static long p_realt_secs = 0,c1_realt_secs = 0,c2_realt_secs = 0;static long p_virtt_secs = 0,c1_virtt_secs = 0,c2_virtt_secs = 0;static long p_proft_secs = 0,c1_proft_secs = 0,c2_proft_secs = 0;static struct itimerval p_realt,c1_realt,c2_realt;static struct itimerval p_virtt,

37、c1_virtt,c2_virtt;static struct itimerval p_proft,c1_proft,c2_proft;static struct itimerval ini_value;int main()int fib = 0;int pid1,pid2;int status;long moresec,moremsec,t1,t2;pid1 = fork();if (pid1 = 0)/c1/set c1 signal handlesignal(SIGALRM,c1_sighandle);signal(SIGVTALRM,c1_sighandle);signal(SIGPR

38、OF,c1_sighandle);ini_value.it_interval.tv_sec = 10;ini_value.it_interval.tv_usec = 0;ini_value.it_value.tv_sec = 10;ini_value.it_value.tv_usec = 0;/set c1 timersetitimer(ITIMER_REAL,&ini_value,NULL);setitimer(ITIMER_VIRTUAL,&ini_value,NULL);setitimer(ITIMER_PROF,&ini_value,NULL);fib = fibonacci(20);

39、/get timer of c1 and printgetitimer(ITIMER_REAL,&c1_realt);getitimer(ITIMER_VIRTUAL,&c1_virtt);getitimer(ITIMER_PROF,&c1_proft);printf(n);moresec = 10 - c1_realt.it_value.tv_sec;moremsec = (1000000 - c1_realt.it_value.tv_usec)/1000;printf(c1fib(20)=%ldnrealtime=%ldsec,%ldmsecn,fib,c1_realt_secs+more

40、sec,moremsec);moresec = 10 - c1_proft.it_value.tv_sec;moremsec = (1000000 - c1_proft.it_value.tv_usec)/1000;printf(cputime = %ld sec, %ld msecn,c1_proft_secs+moresec,moremsec);moresec = 10 - c1_virtt.it_value.tv_sec;moremsec = (1000000 - c1_virtt.it_value.tv_usec)/1000;printf(usertime = %ld sec, %ld

41、 msecn,c1_virtt_secs+moresec,moremsec);t1=(10-c1_proft.it_value.tv_sec)*1000+(1000000-c1_proft.it_value.tv_usec)/1000 +c1_proft_secs*10000;t2=(10-c1_virtt.it_value.tv_sec)*1000+(1000000-c1_virtt.it_value.tv_usec)/1000+ c1_virtt_secs*10000;moresec = (t1 - t2)/1000;moremsec = (t1 - t2) % 1000;printf(k

42、erneltime = %ld sec, %ld msecn,moresec,moremsec);fflush(stdout);exit(0);/end c1elsepid2 = fork();if (pid2 = 0)/c2/set c2 signal handlesignal(SIGALRM,c2_sighandle);signal(SIGVTALRM,c2_sighandle);signal(SIGPROF,c2_sighandle);ini_value.it_interval.tv_sec = 10;ini_value.it_interval.tv_usec = 0;ini_value

43、.it_value.tv_sec =10;ini_value.it_value.tv_usec = 0;/set c2 timersetitimer(ITIMER_REAL,&ini_value,NULL);setitimer(ITIMER_VIRTUAL,&ini_value,NULL);setitimer(ITIMER_PROF,&ini_value,NULL);fib = fibonacci(30);/get timer of c2 and printgetitimer(ITIMER_PROF,&c2_proft);getitimer(ITIMER_REAL,&c2_realt);get

44、itimer(ITIMER_VIRTUAL,&c2_virtt);printf(n);moresec = 10 - c2_realt.it_value.tv_sec;moremsec = (1000000 - c2_realt.it_value.tv_usec)/1000;printf(c2fib(30)=%ldnrealtime=%ldsec,%ldmsecn,fib,c2_realt_secs+moresec,moremsec);moresec = 10 - c2_proft.it_value.tv_sec;moremsec = (1000000 - c2_proft.it_value.t

45、v_usec)/1000;printf(cputime=%ldsec,%ldmsecn,c2_proft_secs+moresec,moremsec);moresec = 10 - c2_virtt.it_value.tv_sec;moremsec = (1000000 - c2_virtt.it_value.tv_usec)/1000;printf(usertime=%ldsec,%ldmsecn,c2_virtt_secs+moresec,moremsec);t1=(10-c2_proft.it_value.tv_sec)*1000+(1000000-c2_proft.it_value.t

46、v_usec)/1000 +c2_proft_secs*10000;t2=(10-c2_virtt.it_value.tv_sec)*1000+(1000000-c2_virtt.it_value.tv_usec)/1000 +c2_virtt_secs*10000;moresec = (t1 - t2)/1000;moremsec = (t1 - t2) % 1000;printf(kerneltime = %ld sec, %ld msecn,moresec,moremsec);fflush(stdout);exit(0);/endc2/parent/setparent signal ha

47、ndlesignal(SIGALRM,p_sighandle);signal(SIGVTALRM,p_sighandle);signal(SIGPROF,p_sighandle);ini_value.it_interval.tv_sec = 10;ini_value.it_interval.tv_usec = 0;ini_value.it_value.tv_sec = 10;ini_value.it_value.tv_usec = 0;/set parent timersetitimer(ITIMER_REAL,&ini_value,NULL);setitimer(ITIMER_VIRTUAL

48、,&ini_value,NULL);setitimer(ITIMER_PROF,&ini_value,NULL);fib = fibonacci(36);getitimer(ITIMER_PROF,&p_proft);getitimer(ITIMER_REAL,&p_realt);getitimer(ITIMER_VIRTUAL,&p_virtt);printf(n);moresec = 10 - p_realt.it_value.tv_sec;moremsec = (1000000 - p_realt.it_value.tv_usec)/1000;printf(pfib(36)=%ldnre

49、altime=%ldsec,%ldmsecn,fib,p_realt_secs+moresec,moremsec);moresec = 10 - p_proft.it_value.tv_sec;moremsec = (1000000 - p_proft.it_value.tv_usec)/1000;printf(cputime = %ld sec, %ld msecn,p_proft_secs+moresec,moremsec);moresec = 10 - p_virtt.it_value.tv_sec;moremsec = (1000000 - p_virtt.it_value.tv_us

50、ec)/1000;printf(usertime = %ld sec, %ld msecn,p_virtt_secs+moresec,moremsec);t1= (10 - p_proft.it_value.tv_sec)*1000 + (1000000 - p_proft.it_value.tv_usec)/1000 +p_proft_secs*10000;t2 = (10 - p_virtt.it_value.tv_sec)*1000 + (1000000 - p_virtt.it_value.tv_usec)/1000 +p_virtt_secs*10000;moresec = (t1

51、- t2)/1000;moremsec = (t1 - t2) % 1000;printf(kerneltime = %ld sec, %ld msecn,moresec,moremsec);fflush(stdout);/wait c1,c2 terminalwait(&status);wait(&status);return 0;/end mainint fibonacci(int n)if( n = 0 ) return 0;else if( n = 1 | n = 2) return 1;else return(fibonacci(n-1)+fibonacci(n-2) );stati

52、c void c1_sighandle(int s)switch(s)case SIGALRM:c1_realt_secs+=10;break;case SIGVTALRM:c1_virtt_secs+=10;break;case SIGPROF:c1_proft_secs+=10;break;default :break;static void c2_sighandle(int s)switch(s)case SIGALRM:c2_realt_secs+=10;break;case SIGVTALRM:c2_virtt_secs+=10;break;case SIGPROF:c2_proft

53、_secs+=10;break;default :break;static void p_sighandle(int s)switch(s)case SIGALRM:p_realt_secs+=10;break;case SIGVTALRM:p_virtt_secs+=10;break;case SIGPROF:p_proft_secs+=10;break;default :break;3.3 实验 2.3 内核模块1、实验目的模块是 Linux 系统的一种特有机制，可用以动态扩展操作系统内核功能。编写实现某些特定功能的模块，将其作为内核的一部分在管态下运行。本实验通过内核模块编程在/porc

54、文件系统中实现系统时钟的读操作接口。2、实验内容设计并构建一个在/proc 文件系统中的内核模块 clock，支持 read()操作， read()返回值为一字符串，其中包块一个空各分开的两个子串，为别代表 xtime.tv_sec 和 xtime.tv_usec。3、实验原理Linux 模块是一些可以作为独立程序来编译的函数和数据类型的集合。在装载这些模块式，将它的代码链接到内核中。 Linux 模块可以在内核启动时装载，也可以在内核运行的过程中装载。如果在模块装载之前就调用了动态模块的一个函数，那么这次调用将会失败。如果这个模块已被加载，那么内核就可以使用系统调用，并将其传递到模块中的相应

55、函数。4、实验步骤z 编写内核模块文件中主要包含 init_module()， cleanup_module()， proc_read_clock()三个函数。其中init_module()， cleanup_module()负责将模块从系统中加载或卸载，以及增加或删除模块在/proc 中的入口。 read_func()负责产生/proc/clock 被读时的动作。z 编译内核模块 Makefile 文件MakefileCCgccMODCFLAGS := -Wall -D_KERNEL_ -DMODULE DLINUXclock.o :clock.c /usr/include/linux/ve

56、rsion.h$(CC) $( MODCFLAGS) c clock.cecho insmod clock.o to turn it onecho rmmod clock to turn ig offecho编译完成之后生成 clock.o 模块文件。z 内核模块源代码 clock.c#define MODULE#define MODULE_VERSION “1.0”#define MODULE_NAME “clock”#include #include #include int proc_read_clock(char* page, char* start, off_t off,int co

57、unt,int* eof,void* data)int len;struct timeval xtime;do_gettimeofday(&xtime);len = sprintf(page,%d %dn,xtime.tv_sec,xtime.tv_usec);printk(clock: read_func()n);return len;/ proc_dir_entry 数据结构struct proc_dir_entry* proc_my_clock;int init_module()printk(clock: init_module()n);my_clock=create_proc_read

58、_entry(clock,0,&proc_root, proc_read_clock, 0);printk(KERN_INFO“%s %s has initialized.n”,MODULE_NAME,MODULE_VERSION);return 0;void cleanup_module()printk(clock: cleanup_module()n);remove_proc_entry(proc_my_clock-name, &proc_root);printk(KERN_INFO“%s %s has removed.n”,MODULE_NAME,MODULE_VERSION);MODU

59、LE_DESCRIPTION(“clock module for gettimeofday of proc.”);EXPORT_NO_SYMBOLS;z 加载内核模块在系统 root 用户下运行用户态模块命令装载内核模块#insmod clock.oz 测试测试源代码 gettime.c#include #include #include intmain(void)struct timeval getSystemTime;char procClockTime256;int infile,len;gettimeofday(&getSystemTime,NULL);infile = open(/proc/clock,O_RDONLY);len = read(infile,procClockTime,256);close(infile);procClockTimelen = 0;printf(SystemTime is %d %dnProcClockTime is %sn,getSystemTime.tv_sec ,getSystemTime.tv_usec,procClockTime);sleep(1);z 卸载内核模块在系统 roo