linux复习

第一章概述

1.6什么是POSIX标准,为什么现代操作系统的设计必须遵循POSIX标准?

POSIX表示可移植操作系统接口是UNIX标准化过程中的产物，POSIX 1003.1标准定义了一个最小的Unix操作系统接口，任何操作系统只要符合POSIX1003.1这一标准，就可以运行UNIX程序。

1.9 linux操作系统有哪几部分组成？linux内核出于什么位置？

1) Linux系统由四个部分组成：用户进程，系统调用接口、Linux内核子系统和硬件；

2)Linux内核处于用户进程和硬件之间，包括系统调用接口和Linux内核子系统。

Linux内核由哪几部分组成？各个子系统的主要功能是什么？

1) Linux内核除系统调用外，由五个主要的子系统组成：进程调度、内存管理、虚拟文件系统、网络和进程间通信(IPC)；

2) 各个子系统的主要功能为：

A. 进程调度：它控制着进程对CPU的访问，当需要选择一个进程开始运行时，由调度程序选择最应该运行的进程；

B. 内存管理：它允许多个进程安全地共享主内存区域，支持虚拟内存；从逻辑上可以分为硬件无关的部分和硬件相关的部分；

C. 虚拟文件系统(VFS)：它隐藏了各种不同硬件的具体细节，为所有设备提供统一的接口，支持多达数十种不同的文件系统，分为逻辑文件系统和设备驱动程序；

D. 网络：它提供了对各种网络标准协议的存取和各种网络硬件的支持，分为网络协议和网络驱动程序两部分；

E. 进程间通信：支持进程间各种通信机制，包括共享内存、消息队列和管道等。

第二章内存寻址

1、在80x86的寄存器中，哪些寄存器供一般用户使用？哪些寄存器只能被操作系统使用？

答：通用寄存器EAX,EBX,ECX,EDX，EBP(基址指针)，ESP(堆栈指针),ESI(扩展源指针),EDI(扩展目的指针)，还有EFLAGS(标志寄存器).

专供操作系统使用的寄存器：IDTR中断描述符寄存器，GDTR全局描述符表寄存器，LDTR局部描述符表寄存器，TaskRegisters任务寄存器，DebugRegister调试寄存器，ControlRegister控制寄存器，Model-SpecificRegisters模型专用寄存器。

4、Linux是如何利用段机制又巧妙的绕过段机制的？在内核代码中如何表示各种段，查找最新源代码并进行阅读和分析。答：IA32规定段机制是不可禁止的，因此不可能绕过它直接给出线性地址空间的地址。万般无奈之下，Linux的设计人员干脆让段的基地址为0，而段的界限为4GB，这时任意给出一个偏移量，则等式为“0+偏移量=线性地址”，也就是说“偏移量＝线性地址”。另外由于段机制规定“偏移量< 4GB”，所以偏移量的范围为0H～FFFFFFFFH，这恰好是线性地址空间范围，也就是说虚拟地址直接映射到了线性地址，我们以后所提到的虚拟地址和线性地址指的也就是同一地址。看来，Linux在没有回避段机制的情况下巧妙地把段机制给绕过去了。

另外，由于IA32段机制还规定，必须为代码段和数据段创建不同的段，所以Linux必须为代码段和数据段分别创建一个基地址为0，段界限为4GB的段描述符。不仅如此，由于Linux内核运行在特权级0，而用户程序运行在特权级别3，根据IA32的段保护机制规定，特权级3的程序是无法访问特权级为0的段的，所以Linux必须为内核和用户程序分别创建其代码段和数据段。这就意味着Linux必须创建4个段描述符——特权级0的代码段和数据段，特权级3的代码段和数据段。

2.12为什么在设计两级页表的线性结构时，给页目录和页表分别分配10位，如果不是这样举例说明会产生什么后果？所谓两级页表就是对页表再进行分页。页目录共有1K个表项，于是线性地址的最高10位（即22~31位）用来产生第一级的索引。两级表结构的第二级称为页表，每个页表也刚好存放在一个4KB的页中，并且每一个页表包含1K的表项，第二级页表由线性地址中间的10位（即21~12位）进行索引，最低12位表示页内偏量。

14深入理解图2,12，并结合图叙述线性地址到物理地址的转换。

第一步，用32位线性地址的最高10位第31~22位作为页目录项的索引，将它乘以4，与CR3中页目录的起始地址相加，获得相应目录项在内存的地址；第二步，从这个地址开始读取32位页目录项，取出其高20位，再给低12位补0，形成的32位就是页表在内存的起始地址；第三步，用32位线性地址中的第21~12位作为页表中页表项的索引，将它乘以4，与页表的起始地址相加，获得相应页表项在内存的地址；第四，从这个地址开始读取32位页表项，取出其高20位，再将线性地址的第11~0位放在低12位，最终形成32位页面物理地址。

第三章

15.什么是进程控制块，它包含哪些基本信息

1)Linux中把对进程的描述结构叫做task_struct，将这样的数据结构称作进程控制块(PCB)；系统为了管理进程设置的一个专门的数据结构，用它来记录进程的外部特征，描述进程的运动变化过程。系统利用PCB来控制和管理进程，所以PCB 是系统感知进程存在的唯一标志。进程与PCB是一一对应的。

2)PCB是一个其域多达80多项的相当庞大的数据结构，按其功能将所有域划分为：状态信息，链接信息、各种标识符、进程间通信信息、时间和定时器信息、调度信息、文件系统信息、虚拟内存信息和处理器环境信息

3.4linux内核状态有哪些，请画出状态转换图，查看最新源代码，确认有哪些状态。

1）Linux最基本的进程状态有三种：运行态、就绪态和阻塞态(或等待态)；

2）为了管理上的方便，就绪态（TASK_RUNNING）；睡眠（或等待）态：浅度睡眠态(TASK_INTERRUPTIBLE),深度睡眠态(TASK_UNINTERRUPTIBLE)；暂停状态(TASK_STOPPED)；僵死状态(TASK_ZOMBIE)

3.6 linux的进程控制块如何存放？为什么？假设ESP中存放的是栈顶指针，请用三句汇编语句描述如何获得current的PC的地址。

答：当进程一进入内核态，CPU就自动设置进程的内核栈。这个栈位于内核的数据段上，为了节省空间，Linux把内核栈和一个紧挨近的PCB的小数据结构，thread_info放在一起，占用8kb的内存区。因为这样可以节省空间，内核很容易从ESP寄存器的值获得，当前在CPU上正在运行的thread_info结构的地址。

movl $0xfffe000, %eax

andl %esp, %ecx

movl %ecx, p

3.7 PCB的组织方式有哪几种？为什么要采取这些组织方式？

答:有进程链表、哈希表、就绪队列、等待队列四种组织方式，采取这些组织方式是为了能更有效的管理系统中大量的进程。

7、什么是写时复制技术，这种技术在什么情况下最能发挥其优势？

答：父进程和子进程共享页面而不是复制页面。然而，只要页面被共享，它们就不能被修改。无论父进程和子进程何时试图写一个共享的页面，就产生一个错误，这时内核就把这个页复制到一个新的页面中并标记为可写。原来的页面仍然是写保护的：当其它进程试图写入时，内核检查写进程是否是这个页面的唯一属主；如果是，它把这个页面标记为对这个进程是可写的。采用这种技术，显然只有预测到将要修改的页才会被复制，而且必须被复制，不然的话，就会破坏父进程的程序执行。

9、init内核线程与init进程是一回事吗？它们有什么本质的区别？

答：（1）init（）函数是内核代码的一部分，在内核态运行，是独立的可执行代码的一部分。

（2）init进程在Linux操作系统中是一个具有特殊意义的进程，它是由内核启动并运行的第一个用户进程，因此它不是运行在内核态，而是运行在用户态。它的代码不是内核本身的一部分，而是存放在硬盘上可执行文件的映象中，和其他用户进程没有什么两样。

第四章

4.3 内核空间存放什么内容？如何把其中一个虚拟地址转换成物理地址？

答：内核空间存放的是内核代码和数据。给定一个虚拟地址x，其物理地址为x-PAGE_OFFSET(一般为3GB，表示虚拟地址和物理地址之间的位移量)

4.4什么是内核映像？它存放在物理空间和内核空间的什么地方？

答：内核空间由所有进程共享，其中存放的是内核代码和数据，即“内核映象”

Linux内核映像被装入在物理地址0x00100000开始的地方

内核映像在内核空间的起始地址就为0xC0100000。

4-5. 用户空间划分为哪几部分？用户程序调用malloc()分配的内存属于哪一部分？

分为堆栈段、BSS(未初始化的数据段)、数据段和代码段。从数据段的顶部到堆栈段地址的下

沿这个区间是一个巨大的空洞，这就是进程在运行时调用malloc()可以动态分配的空间，也

叫动态内存或堆。

4-11. 什么是虚存映射？有哪几种类型？

Linux并不将映像装入到物理内存，相反，可执行文件只是被连接到进程的用户空间中。随着进程的运行，被引用的程序部分会由操作系统装入到物理内存，这种将映像链接到进程用户空间的方法被称为“虚存映射”，也就是把文件从磁盘映射到进程的用户空间，这样把对文件的访问转化为对虚存区的访问。有两种类型的虚存映射：

（1）共享的：有几个进程共享这一映射，也就是说，如果一个进程对共享的虚存区进行写，其它进程都能感觉到，而且会修改磁盘上对应的文件。

（2）私有的：进程创建的这种映射只是为了读文件，而不是写文件，因此，对虚存区的写操作不会修改磁盘上的文件，由此可以看出，私有映射的效率要比共享映射的高。除了这两种映射外，如果映射与文件无关，就叫匿名映射。

7、Linux是如何实现“请求调页”的？

答：1)如果被访问的页不在内存，也就是说，这个页还没有被存放在任何一个物理页面中，那么，内核分配一个新的页面并将其适当地初始化，这种技术称为“请求调页”；

2)“请求调页”是一种动态内存分配技术，它将页面的分配推迟到不能再推迟为止，也就是说，一直推迟到进程要访问的页不在物理内存时为止，由此引起一个缺页异常；该技术的引入主要是因为进程开始运行时并不访问其地址空间中的全部地址。

8、试叙述伙伴算法的工作原理，并说明为什么伙伴算法可以消除外碎片？

答：假设要求分配的块其大小为128个页面。该算法先在块大小为128个页面的链表中查找，看是否有这样一个空闲块。如果有，就直接分配；如果没有，该算法会查找下一个更大的块，具体地说，就是在块大小为256个页面的链表中查找一个空闲块。如果存在这样的空闲块，内核就把这256个页面分为两等份，一份分配出去，另一份插入到块大小为128个页面的链表中。如果在块大小为256个页面的链表中也没有找到空闲页块，就继续找更大的块，即512个页面的块。如果存在这样的块，内核就从512个页面的块中分出128个页面满足请求，然后从384个页面中取出256个页面插入到块大小为256个页面的链表中。然后把剩余的128个页面插入到块大小为128个页面的链表中。如果512个页面的链表中还没有空闲块，该算法就放弃分配，并发出出错信号。

9、vmalloc()和kmalloc()有何区别？编写内核模块程序，调用这两个函数以观察二者所分配空间位于不同的区域。

答：在内核空间中调用kmalloc()分配连续物理空间，而调用vmalloc()分配非物理连续空间。

我们把kmalloc()所分配内核空间中的地址称为内核逻辑地址

把vmalloc()分配的内核空间中的地址称为内核虚拟地址

vmalloc()在分配过程中须更新内核页表

10、分析守护进程kswapd的运行时机，你认为怎样换出页面比较合理？

答：为了避免在CPU忙碌的时候，也就是在缺页异常发生时，临时搜索可供换出的内存页面并加以换出，Linux内核定期地检查系统内的空闲页面数是否小于预定义的极限，一旦发现空闲页面数太少，就预先将若干页面换出，以减轻缺页异常发生时系统所承受的负担。当然，由于无法确切地预测页面的使用，即使这样做了也还可能出现缺页异常发生时内存依然没有足够的空闲页面。但是，预换出毕竟能减少空闲页面不够用的概率。并且通过选择适当的参数（如每隔多久换出一次，每次换出多少页），可以使临时寻找要换出页面的情况很少发生。为此，Linux内核设置了一个定期将页面换出的守护进程kswapd。

第五章

5-2.什么是中断向量？Linux是如何分配中断向量的?

Intel x86系列微机共支持256种向量中断，为使处理器较容易地识别每种中断源，将它们从0到256编号，即赋以

一个中断类型码n，Intel把这个8位的无符号整数叫做一个向量，因此，也叫中断向量。

Linux对256个向量的分配如下：

(1) 从0~31的向量对应于异常和非屏蔽中断。

(2) 从32~47的向量（即由I/O设备引起的中断）分配给屏蔽中断。剩余的从48~255的向量用来标识软中断。Linux只用了其中的一个（即128或0x80向量）用来实现系统调用。

5-3.什么是中断描述符表?啥是门描述符?描述其格式。

答：在保护模式下，中断向量表中的表项由8个字节组成，中断向量表也改叫做中断描述符表IDT（Interrupt Descriptor Table）。其中的每个表项叫做一个门描述符（gate descriptor），

5.6如何对中断描述符表进行初始化？

答：Linux内核在系统的初始化阶段要初始化可编程控制器8259A；将中断描述符表的起始地址装入IDTR寄存器，并初始化表中的每一项，当计算机运行在实模式时，中断描述符表被初始化，并由BIOS使用。

真正进入Linux内核，中断描述符表就被移到内存的另一个区域，并为进入保护模式进行预初始化

5.7在中断描述符表中如何插入一个中断门、陷阱门和系统门？

答：插入一个中断门：set_intr_gate(unsigned int n, void *addr)

Void set_intr_gate(unsigned int n, void *addr)

{ _set_gate(idt_table+n,14,0,addr);}

插入一个陷阱门：set_trap_gate(unsigned int n, void *addr)

Static void_init set_trap(unsigned int n, void *addr) {_set_gate(idt_table+n,15,0,addr);}

插入一个系统门：set_system_gate(unsigned int n, void *addr)

Static set_system_gate(unsigned int n, void *addr){_set_gate(idt_table+n,15,3,addr)}

5、CPU为什么要进行有效性检查？如何检查？CPU是如何跳到中断或异常处理程序的？

答：有效性检查避免用户应用程序访问特殊的陷阱门或中断门。

当从用户态堆栈切换到内核态堆栈时，先把用户态堆栈的值压入中断程序的内核态堆栈中，同时把EFLAGS寄存器自动压栈，然后把被中断进程的返回地址压入堆栈。如果异常产生了一个硬错误码，则将它也保存在堆栈中。如果特权级没有发生变化，则压入栈中的内容如图5.4中 。此时，CS:EIP的值就是IDT表中第i项门描述符的段选择符和偏移量的值，于是，CPU就跳转到了中断或异常处理程序。

分两步进行有效性检查：首先是“段”级检查，将CPU的当前特权级CPL（存放在CS寄存器的最低两位）与IDT中第i项段选择符中的DPL相比较，如果DPL（3）大于CPL（0），就产生一个“通用保护”异常，因为中断处理程序的特权级不能低于引起中断的进程的特权级。这种情况发生的可能性不大，因为中断处理程序一般运行在内核态，其特权级为0。然后是“门”级检查，把CPL与IDT中第i个门的DPL相比较，如果CPL大于DPL，也就是当前特权级（3）小于这个门的特权级（0），CPU就不能“穿过”这个门，于是产生一个“通用保护”异常，这是为了避免用户应用程序访问特殊的陷阱门或中断门。但是请注意，这种“门”级检查是针对一般的用户程序，而不包括外部I/O产生的中断或因CPU内部异常而产生的异常，也就是说，如果产生了中断或异常，就免去了“门”级检查。

6、中断处理程序和中断服务程序有何区别？Linux如何描述一条共享的中断线？

答：中断服务程序ISR与中断处理程序是两个不同的概念。在Linux中，15条中断线对应15个中断处理程序。具体来说，中断处理程序相当于某个中断向量的总处理程序，例如IRQ0x05_interrupt()是中断号为5（向量为37）的总处理程序，如果这个5号中断由网卡和图形卡共享，则网卡和图形卡分别有其相应的中断服务程序。

typedef irqreturn_t(* irq_handler_t) (int, void *); struct irqaction{

irq_handler_t handler;

unsigned long flags;

cpumask_t mask;

const char *name;

void *dev_id;

struct irqaction *next;

int irq;

...};

7、叙述中断处理程序的执行过程，并给出几个主要函数的调用关系和功能。

答：CPU从中断控制器的一个端口取得中断向量I；根据I从中断描述符表IDT中找到相应的中断门；从中断门获得中断处理程序的入口地址；判断是否要进行堆栈切换；调用do_IRQ()对所接收的中断进行应答，并禁止这条中断线；调用handle_IRQ_event（）来运行对应的中断服务例程。

8、为什么把中断分为两部分来处理？

答：中断服务例程一般都是在中断请求关闭的条件下执行的,以避免嵌套而使中断控制复杂化。但是，中断是一个随机事件，它随时会到来，如果关中断的时间太长，CPU就不能及时响应其他的中断请求，从而造成中断的丢失。因此，内核的目标就是尽可能快的处理完中断请求，尽其所能把更多的处理向后推迟。例如，假设一个数据块已经达到了网线，当中断控制器接受到这个中断请求信号时，Linux内核只是简单地标志数据到来了，然后让处理器恢复到它以前运行的状态，其余的处理稍后再进行（如把数据移入一个缓冲区，接受数据的进程就可以在缓冲区找到数据）。因此，内核把中断处理分为两部分：前半部分（top half）和后半部分（bottom half），前半部分内核立即执行，而后半部分留着稍后处理。

9、实时时钟和操作系统时钟有何不同？

答：大部分PC机中有两个时钟源，分别是实时时钟（RTC）和操作系统（OS）时钟

实时时钟也叫硬件时钟，它靠电池供电，即使系统断电，也可以维持日期和时间。

RTC是OS时钟的时间基准，操作系统通过读取RTC来初始化OS时钟，此后二者保持同步运行，共同维持着系统时间。所谓同步，是指操作系统在运行过程中，每隔一个固定时间会刷新或校正RTC中的信息

10、jiffies表示什么？什么时候对其增加？

答：jiffies是Linux内核中的一个全局变量，用它来表示系统自启动以来的时钟节拍总数。启动时，内核将该变量初始化为0，此后，每次时钟中断处理程序都会增加该变量的值。

11、时钟中断的下半部分主要做什么？

答：run_lock_timers()函数去处理所有到期的定时器，定时器作为软中断在下半部分中执行。Scheduler_tick()函数负责减少当前运行进程的时间片计数值并且在需要时设置need_resched标志。当update_process_timer()函数返回后，do_timer()函数接着会调用update_times()函数更新墙上时钟。

第六章

6.2系统调用与库函数、系统命令及内核函数有什么区别或联系？答：系统调用与API：API其实是一个函数定义，这些函数说明了如何获得一个给定的服务，而系统调用是通过软中断向内核发出一个明确的请求，系统调用实现是在内核完成的，而用户态的函数是在函数库中实现的；系统调用与系统命令：系统命令相对于应用程序接口更高一层，每个系统命令都是一个可执行程序，这些命令的实现调用了系统调用；系统调用与内核函数：系统调用是用户进程进入内核的接口层，它本身并非内核函数，但他是由内核函数实现的，进入内核后不同的系统调用会找到各自对应的内核函数，这些内核函数称为系统调用的服务进程。

6-3内核为什么要设置系统调用处理程序，他与服务例程有什么区别？

系统调用不能直接调用内核函数，因为用户空间的程序无法直接执行内核代码，内核驻留在受保护的地址空间上，不允许用户进程在内核地址空间上读写，所以，应用程序应该以某种方式通知系统，告诉内核自己需要执行一个系统调用，这种通知内核的机制是靠软中断来实现的，通过引发一个异常来促使系统切换到内核态去执行异常处理程序，此时的异常处理程序就是所谓的系统调用处理程序。

系统调用处理程序是调用系统调用服务例程的相应的C函数来处理系统调用的。

6-6说明系统调用号的作用。

Linux系统有几百个系统调用，为了唯一的标识每一个系统调用，linux为每一个系统调用定义了一个唯一的编号，此编号称为系统调用号，它的另一个目的是作为系统调用表的下标，当用户空间的进程执行一个系统调用的时候，这个系统调用号就被用来指明到底是要执行哪一个系统调用。

第七章

7-1什么是临界区？什么是竞争状态？什么是同步？

1)临界区(critical regions)就是访问和操作共享数据的代码段，多个内核任务并发访问同一个资源通常是不安全的；2)如果两个内核任务可能处于同一个临界区，就是一种错误现象；如果确实发生了这种情况，就称它为竞争状态；3)避免并发和防止竞争状态称为同步

7-5内核中造成并发执行的原因是什么？

“并发”分为“伪并发”和“真并发”两种，内核中造成并发执行的原因有以下几种：

1.中断——中断几乎可以在任何时刻异步发生，也可能随时打断正在执行的代码。

2.内核抢占——若内核具有抢占性，内核中的任务就可能会被另一任务抢占。

3.睡眠及与用户空间的同步——在内核执行的进程可能会睡眠，这将唤醒调度程序，导致调度一个新的用户进程执行

4.对称多处理——两个或多个处理器可以同时执行代码

3、给出信号量的定义，并说明down()和up()的含义。

答：信号量是在1968年由Edsger Wybe DijKstra提出的，此后它逐渐成为一种常用的锁机制。信号量支持两个原子操作P()和V()，这两个名字来自荷兰语Proberen和Vershogen。前者做测试操作（字面意思是探查），后者叫做增加操作。后来的系统把这两种操作分别叫做down()和up()，Linux也遵从这种叫法。down()操作通过对信号量计数减1来请求获得一个信号量。如果结果是0或大于0，信号量锁被获得，任务就可以进入临界区了。如果结果是负数，任务会被放入等待队列，处理器执行其它任务。down()函数如同一个动词“降低（down）”，一次down()操作就等于获取该信号量。相反，当临界区中的操作完成后，up()操作用来释放信号量，该操作也被称作是“提升（upping）”信号量，因为它会增加信号量的计数值。如果在该信号量上的等待队列不为空，处于队列中等待的任务在被唤醒的同时会获得该信号量。

4、申明一个信号量，并给出如何使用它。

答：定义：

struct semaphore {

atomic_t count;

int sleepers;

wait_queue_head_t wait;

}

使用：

static DECLARE_MUTEX(mr_sem);

／*声明并初始化互斥信号量*/

if(!down_interruptible(&mr_sem))

/* 信号被接收, 信号量还未获取*/

/*临界区…*/

up(&mr_sem);

8-2什么是软链接和硬链接？二者有何区别？

硬链接(hard link)：让一个文件对应一个或多个文件名，或者说把我们使用的文件名和文件系统使用的节点号链接起来，这些文件名可以在同一目录或不同目录。软链接（也叫符号链接）：是一种特殊的文件，这种文件包含了另一个文件的任意一个路径名。这个路径名指向位于任意一个文件系统的任意文件，甚至可以指向一个不存在的文件。区别：1.硬链接是创建一个指向block的inode，有防止误删除的功能。因为删除一个文件，实际上是删除inode信息，切断了inode 与block之间的联系。当给一个文件做了硬链接之后，删除文件时，只会减少文件的链接数，当链接数为0时，才会彻底删除该文件。软链接类似Windows系统的快捷方式，是一个完整的文件，有自己的inode和block，block的内容就是原文件的文件名。当原文件删除后，软链接就失效了，没有防止误删除的功能。2.文件的大小不一样。由于硬链接是指向原文件的block，所以硬链接的文件大小和原文件大小是一致的。而软链接是新的文件，block里是原文件的的文件名，所以软链接文件的大小一般是4K，即一个block的大小。3.硬链接不能给目录做，不能跨分区做。软链接则都可以。8-3什么是虚拟文件系统？什么是虚拟文件系统界面？

1)将各种不同文件系统的操作和管理纳入到一个统一的框架中，使得用户程序可以通过同一个文件系统界面，也就是同一组系统调用，对各种不同的文件系统以及文件进行操作；用户程序可以不关心不同文件系统的实现细节，而使用系统提供的统一、抽象、虚拟的文件系统界面；这种统一的框架就是所谓的虚拟文件系统转换，一般简称虚拟文件系统(VFS)；

2)VFS的对象类型包括：超级块(superblock)对象、索引节点(inode)对象、目录项(dentry)对象和文件(file)对象；

3)虚拟文件系统界面是虚拟文件系统所提供的抽象界面，它主要由一组标准的、抽象的操作构成，这些函数(操作)以系统调用的形式供用户调用。

8-8.内核如何组织索引节点？为什么要设置多个链表管理索引节点？

答：内核使用如下的数据库来自组织索引节点。

struct inode {

struct list_head i_hash;//指向哈希链表的指针

struct list_head i_list;//指向索引节点链表的指针

struct list_head i_dentry;//指向目录项链表的指针Unsigned long i_ino;/*索引节点号*/

kdev_t i_dev;/*设备标识号 */

umode_t i_mode;/*文件的类型与访问权限 */

nlink_t i_nlink;/*与该节点建立链接的文件数 */

uid_t i_uid;/*文件拥有者标识号*/

gid_t i_gid;/*文件拥有者所在组的标识号*/

/*用于索引节点操作的域*/

struct inode_operations *i_op; //索引节点的操作

struct super_block *i_sb;/*指向该文件系统超级块的指针 */atomic_t i_count;/*当前使用该节点的进程数。计数为0，表明该节点可丢弃或被重新使用 */

struct file_operations *i_fop; /*指向文件操作的指针 */

Struct vm_area_struct *i_op unsigned int i_flags; /*文件系统的安装标志*/

union{struct minix_inode_infor minix_i;

struct Ext2_inode_info Ext2_i;}

使用多个链表加快了对索引节点对象的搜索

8-10.内核是如何组织目录项结构，画图说明

答：目录项（dentry）对象:存放目录项与对应文件进行链接的信息。VFS把每个目录看作一个由若干子目录和文件组成的常规文件。例如，在查找路径名/tmp/test时, 内核为根目录“/ ”创建第一个目录项对象, 为根目录下的tmp项创

建第二级目录项对象，为/tmp 目录下的test项创建第三级目录项对象。

8-12.假定进程以读方式打开一个文件后，在执行fork（），父进程和子进程都将可以读这个文件，这两个进程的读操作和写操作有何关系？

答：通过fork（）创建子进程时，子进程继承父进程环境和上下文的大部分内容的拷贝，其中就包括文件描述符表。（1）对于父进程在fork（）之前打开的文件来说，子进程都会继承，与父进程共享相同的文件偏移量。系统文件表位于系统空间中，不会被fork()复制，但是系统文件表中的条目会保存指向它的文件描述符表的计数，fork()时需要对这个计数进行维护，以体现子进程对应的新的文件描述符表也指向它。程序关闭文件时，也是将系统文件表条目内部的计数减一，当计数值减为0时，才将其删除。（2）相反，如果父进程先进程fork，再打开my.dat，这时父子进程关于my.dat 的文件描述符表指向不同的系统文件表条目，也不再共享文件偏移量（fork以后2个进程分别open，在系统文件表中创建2个条目）；但是关于标准输入，标准输出，标准错误，父子进程还是共享的。

8-13、结合用户打开表说明什么是文件描述符

答：用户打开表中的fd域指向files_struct结构的fd_array域，该域包括32个文件对象指针，于对fd数组中有入口地址的每个文件来说，数组的索引就是文件描述符。

8-18、从用户发出读请求到最终从键盘读取数据包括哪些步骤？给出读操作的逻辑流。

答：包含四个步骤：第一步：用户界面层：负责从用户函数经过系统调用进入内核。

第二步：基本文件系统层：负责调用文件读方法，从缓冲区中搜索数据页，返回给用户。

第三步：I/O调度层：负责对请求排队、从而提高吞吐量。第四步：I/O传输层：利用任务队列，异步操作设备控制器，完成数据传输。

第九章

9-1.为什么把设备分为“块设备”和“字符设备”两大类？答：Linux将设备分为两大类，一类是像磁盘那样的以块或扇区为单位、成块进行输入/输出的设备，称为块设备；另一类是像键盘那样以字符(字节)为单位，逐个字符进行输入/输出的设备，称为字符设备；文件系统通常都建立在块设备上。因为将设备分为块设备和字符设备后，如果操作者就不用关心读/写的物理位置究竟在哪个磁道，那个扇区。而将块抽象和组织为文件系统。

9-2.为什么说设备驱动是文件系统与硬件设备之间的桥梁？

答：当用户进程发出输入输出请求时，系统把请求处理的权限放在文件系统，文件系统过驱动程序提供的接口将任务下放到驱动程序，驱动程序根据需要对设备进行操作，设备控制器再去控制设备本身，所以所设备驱动是文件系统与硬件设备之间的桥梁

9-3.什么是设备驱动程序？

答：处理和管理硬件控制器的软件

要使一项设备在系统中成为可见，成为应用程序可以访问的设备，首先要在系统中建立一个代表此设备的设备文件，这是通过系统调用mknode()实现的。除此之外，更重要的是在设备驱动层要有这种设备的驱动程序。

设备驱动程序是上层的同步操作与低层的异步操作之间的桥梁

9-5.I/O端口一般包括那些寄存器？各自功能是什么？CPU用什么命令对其进行读写？

答：包括控制寄存器、数据寄存器（输入寄存器，输出寄存器）和状态寄存器三种。控制寄存器接受CPU发给设备的命令，数据寄存器的功能：CPU通过读取输入寄存器中内容从设备取得数据，也可以通过向输出寄存器中写入字节而把数据输出到设备。状态寄存器中存储设备内部状态的值。CPU通过专门的I/O指令（IN、OUT）来访问I/O端口。

9-7.驱动程序一般包括几部分？并对各部分给于简要说明。答：三部分：第一部分：驱动程序与内核的接口，这是通过数据结构file_operations来完成的。第二部分：驱动程序与系统引导的接口，这部分利用驱动程序对设备进行初始化。第三部分：驱动程序与设备的接口，这部分描述了驱动程序如何与设备进行交互，这与具体设备密切相关。

Linux内核有哪几个子系统组成？从一个进程的运行出发，说明各个子系统之间的依赖关系？

Linux内核子系统包括进程调用、内存管理、虚拟文件系统、网络、进程间通信。处于中心地位的是进程调度，其他子系统都依赖于它。内存管理涉及虚拟文件系统相互依赖。新进程的产生，会有内存空间的分配，涉及内存管理，进程之间通过各种消息机制实现数据通信，进程间的通信涉及多个进程安全共享主内存区域，依赖内存管理。新进程执行时操作文件涉及虚拟文件系统，进程通过网络发送数据时，该发起进程会被挂起，直到硬件成功完成消息发送。

VFS中有哪些主要对象，其各自存放什么信息？他们的共同特征是什么？

超级块（superblock）对象：存放系统中已安装文件系统的相关信息

索引节点（inode）对象：存放关于具体文件的一般信息

目录项(dentry)对象：存放目录项与对应文件进行链接的信息

文件(file)对象：存放打开文件与进程之间进行交互的有关信息

他们共同的特征：

1)充分考虑各种具体文件系统的兼容性

2)是“虚”，都存放与内存。

以命令输入cp/floopy/TEST/mydire/TEST为例，简述应用程序、系统调用，文件系统、设备驱动之间交互的过程。

Cp命令发生时，shell会启动一个新继承执行execve()函数，来装入cp命令的可执行文件代码，以及参数。环境变量等等。Cp命令主要涉及的代码为open,read,write的文件操作函数。针对/floopy/TEST文件，会默认调用DOS的文件系统调用open,read。针对/mydire/TEST会默认调用ext2的open和write调用。即file->f__op->write等。设备驱动属于底层开发，对于设备的驱动开发中，会设计注册文件集file_operations,就是前面提到的open,read,write调用。如果系统针对设备有注册新的file_operations，则在文件系统具体的操作时，会调用针对此设备的file_operations中的对应文件操作函数。

3.从中断处理过程出发，简述INT0x80后，系统调用处理的整个过程

（1）调用软中断int ox80进入内核。

（2）在内核中首先执行system_call函数，接着根据系统调用号在系统调用表中查找到对应的系统调用服务例程sys_getpid,

(3)执行sys_getpid服务例程

（4）执行完毕后，转入syscall_exit_work例程，从系统调用返回。

编程题

1.请编写内核模块,打印系统中个进程的名字以及PID,同时统计系统进程的个数。

答：static_init print_pid(void)

{ struct task_struct *task, *p;

Struct list_head *pos;

int count=0;

printk(“Hello world enter begin:\n”);

task=&init_task;

list_for_each(pos.&task->tasks)

{p=list_enter(pos, struct task_struct,tasks);

count++;

printk(“%d->%s\n”,p->pid.p->count);}

printk(“thenumberofprocess is :%d\n”,count);return 0;}

2. 用fork()写一个简单的测试程序，从父进程和子进程中打印信息，信息应该包括父进程和子进程的PID。执行程序若干次，看两个信息是否以同样的次序打印。

解：#include

Int main(void)

{ pid_t pid;

pid=fork();

{ printf(“error!”);

return 0;}

else if(pid= =0)

{ printf(“this is child process with pid of %d\n”,getpid());} else{

printf(“this is parent process with pid of %d\n”, pid);}return 0;} 3.孙子进程

#include

#include

#include

void do_something(long t)

{

int i=0;

for(i=0;i

for(i=0;i

for(i=0;i

;

}

int main()

{

pid_t pid,pid1;

printf("PID before fork():%d\n",getpid());

pid=fork();

if(pid<0)

perror("fork error\n");

else if(pid==0){

pid1=fork();

if(pid1==0){

while(1){

printf("I am grandchild process,PID is %d\n",getpid());

do_something(10000000);

}}

else if(pid1>0){while(1){

printf("I am child process,PID is %d\n",getpid());

do_something(10000000);

}

}}

else if(pid>0){

printf("I am father process,PID is %d\n",getpid());

do_something(10000000);

}}

return 0;

}

4.利用execve、fork、wait、exit等进程相关系统调用写一个程序int main()

{ pid_t pid,pid1;

pid =fork();

if(pid<0)

printf(“fork error.\n”);

else if(pid==0)

exit(0);

else if(pid>0)

{

While(1)

{

read_command(command,parameters);

exec(command,parameters,0);

sleep(60);

wait(NULL);

}

}

}

5.字符设备驱动

#include"linux/init.h"

#include"linux/module.h"

#include"linux/types.h"

#include"linux/fs.h"

#include"linux/mm.h"

#include"linux/sched.h"

#include"linux/cdev.h"

#include"asm/io.h"

#include"asm/system.h"

#include"asm/compiler.h"

#include"asm/uaccess.h"

#include"linux/kernel.h"

MODULE_LICENSE("GPL");

#define MYCDEV_MAJOR 133

#define MYCDEV_SIZE 1024

static int mycdev_open(struct inode *inode,struct file *fp) {

return 0;

static int mycdev_release(struct inode *inode,struct file *fp) {

return 0;

}

static ssize_t mycdev_read(struct file *fp,char __user *buf,size_t size,loff_t *pos) { unsigned long p=*pos;

unsigned int count=size;

char kernel_buf[MYCDEV_SIZE]="This is mycdev!";

//int i;

if(p>=MYCDEV_SIZE)

return -1;

if(count>=MYCDEV_SIZE)

count=MYCDEV_SIZE-p;

if(copy_to_user(buf,kernel_buf,count)!=0) {

printk("read error !\n");

return -1;

}

printk("reader:%d bytes was read...\n",count);

return count;

}

static ssize_t mycdev_write(struct file *fp,const char __user *buf,size_t size ,loff_t *pos) { return size;

}

static const struct file_operations mycdev_fops=

{

.owner=THIS_MODULE,

.read=mycdev_read,

.write=mycdev_write,

.open=mycdev_open,

.release=mycdev_release,

};

static int __init mycdev_init(void)

{

int ret;

printk("mycdev module is staring..\n");

ret=register_chrdev(MYCDEV_MAJOR,"my_cdev",&mycdev_fops);

if(ret<0)

{

printk("register failed..\n");

return 0;

}

else

{

printk("register success..\n");

return 0;

}

static void __exit mycdev_exit(void)

{

printk("mycdev moudle is leaving..\n");

unregister_chrdev(MYCDEV_MAJOR,"my_cdev");

}

module_init(mycdev_init);

module_exit(mycdev_exit)

6.链表的应用

#include

#include

#include

#include

MODULE_LICENSE("GPL");

MODULE_AUTHOR("XIYOU");

#define N 10

struct numlist

{

int num;

struct list_head list;

};

struct numlist numhead;

static int __init doublelist_init(void)

{

struct numlist *listnode;

struct list_head *pos;

struct numlist *p;

int i;

printk("doublelist is starting \n");

INIT_LIST_HEAD(&numhead.list);

for(i=0;i

{

listnode=(struct numlist *)kmalloc(sizeof(struct numlist),GFP_KERNEL); listnode->num=i+1;

list_add_tail(&listnode->list,&numhead.list);

printk("Node %d has added to the doublelist\n",i+1);

}

i=1;

list_for_each (pos,&numhead.list)

{

p=list_entry(pos,struct numlist,list);

printk("Node %d's data:%d\n",i,p->num);

i++;

}

return 0;

}

static void __exit doublelist_exit(void)

{

struct list_head *pos,*n;

struct numlist *p;

int i;

i=1;

list_for_each_safe (pos,n,&numhead.list)

{

list_del(pos);

p=list_entry(pos,struct numlist,list);

kfree(p);

printk("Node %d has removed from the doublelist\n",i++);

}

printk("doublelist is exiting.\n");

}

module_init(doublelist_init);

module_exit(doublelist_exit);

7、说明mmap()系统调用的功能？利用mmap()写一个拷贝文件的程序。

答：mmap()系统调用时通过调用do_mmap内核函数来实现建立文件到显存的映射。int i,fd1,fd2;

char *buf1,buf2;

fd1 = open("data",0 KDOMCY);

if(fd1&&fd2&&(fstar(fd);&star buf1()=0)

{

if(lseek(fd) statbuf,st_size-1,seek_set)<0

{

perror"lseek target");

exit(-1);

}

if(MAP_FAILED == buf())

{

perror("Lmap source");

exit(-1);

}

if((map_FAFCE) == buf2)

{

perror("mmap target");

exit(-1);

}

mempy(buf2,buf1,(size - f)startbuf,st_size); }

int i,fd1,fd2;

char *buf1,buf2;

fd1 = open("data",0 KDOMCY);

if(fd1&&fd2&&(fstar(fd);&star buf1()=0)

{

if(lseek(fd) statbuf,st_size-1,seek_set)<0

{

perror"lseek target");

exit(-1);

}

if(MAP_FAILED == buf())

{

perror("Lmap source");

exit(-1);

}

if((map_FAFCE) == buf2)

{

perror("mmap target");

exit(-1);

}

mempy(buf2,buf1,(size - f)startbuf,st_size);

}

9-9.编写一个字符设备驱动程序（包括open（），read（），write（），ioctl（），close（）等函数），并进行调试和测试。