joyfire linux笔记 感谢原作者

 

内核分析

 

目 录

  1. index.html
  2. 更新记录
  3. 发布
    1. 申明
    2. GPL
    3. GFDL
  4. 系统管理
  5. 程序编写
  6. 内核分析
    1. 启动
      1. 启动步骤
      2. setup.s
      3. head.s
      4. bootsect.s
      5. compressed/misc.c
      6. setup.txt
      7. bootsect.txt
      8. 用网卡从并口启动(I386)
      9. 内核解压
    2. 中断
      1. 软中断
      2. 驱动中断
      3. 硬件中断 from aka
      4. 定时器代码分析
      5. from lisolog
        1. index
        2. 内部中断
        3. 外部中断
        4. 后续处理
    3. 内存
      1. 用户态
      2. 内核页目录的初始化
      3. 内核线程页目录的借用
      4. 用户进程内核页目录的建立
      5. 内核页目录的同步
      6. 内存管理 from aka
      7. mlock代码分析
      8. memory.c
      9. mmap.c
      10. 伙伴(buddy)算法
      11. 页目录处理的宏
    4. 进程
      1. 信号
      2. sched.c
      3. 进程信号队列
      4. SMP
      5. 内核线程页目录的借用
      6. 代码分析
      7. 线程
      8. 进程描述符
      9. init进程从内核态切换到用户态
      10. SET_LINKS
      11. REMOVE_LINKS
      12. get_wchan()
      13. sigframe的结构
      14. rt_sigframe结构
      15. 信号队列的结构
    5. 系统调用
      1. 系统调用的实现
      2. 添加系统调用
      3. 系统调用简述
      4. 增加系统调用
      5. mlock代码分析
    6. 文件系统
      1. inode
      2. proc
      3. CD_ROM
      4. 文件页缓冲结构
      5. 块设备缓冲区结构
      6. 散列算法
      7. permission(inode,mask)
      8. IDE硬盘驱动器读写
    7. 驱动
      1. PCI
      2. loopback.c
      3. 网卡驱动编写
      4. 设备驱动(from hust)
      5. 设备驱动(from smth)
      6. 数据接口卡
      7. 代码
        1. 标准范例
          1. header.c
          2. init.c
          3. ioctl.c
          4. open.c
          5. read.c
          6. release.c
          7. tdd.h
          8. write.c
        2. Sis 900
      8. 网上站点
    8. 经验
      1. AKA推荐书籍
      2. linux论坛推荐资源
      3. 数据结构
      4. 重新编译
      5. 重建内核选项
      6. 调试技术
      7. ptrace进程跟踪
      8. 宏#与##


内核分析

 

[目录]


启动

 

[目录]


启动步骤


系统引导:

涉及的文件
./arch/$ARCH/boot/bootsect.s
./arch/$ARCH/boot/setup.s

bootsect.S
 这个程序是linux kernel的第一个程序,包括了linux自己的bootstrap程序,
但是在说明这个程序前,必须先说明一般IBM PC开机时的动作(此处的开机是指
"打开PC的电源"):

  一般PC在电源一开时,是由内存中地址FFFF:0000开始执行(这个地址一定
在ROM BIOS中,ROM BIOS一般是在FEOOOh到FFFFFh中),而此处的内容则是一个
jump指令,jump到另一个位於ROM BIOS中的位置,开始执行一系列的动作,包
括了检查RAM,keyboard,显示器,软硬磁盘等等,这些动作是由系统测试代码
(system test code)来执行的,随着制作BIOS厂商的不同而会有些许差异,但都
是大同小异,读者可自行观察自家机器开机时,萤幕上所显示的检查讯息。

  紧接着系统测试码之后,控制权会转移给ROM中的启动程序
(ROM bootstrap routine),这个程序会将磁盘上的第零轨第零扇区读入
内存中(这就是一般所谓的boot sector,如果你曾接触过电脑病
毒,就大概听过它的大名),至於被读到内存的哪里呢? --绝对
位置07C0:0000(即07C00h处),这是IBM系列PC的特性。而位在linux开机
磁盘的boot sector上的正是linux的bootsect程序,也就是说,bootsect是
第一个被读入内存中并执行的程序。现在,我们可以开始来
看看到底bootsect做了什么。

第一步
 首先,bootsect将它"自己"从被ROM BIOS载入的绝对地址0x7C00处搬到
0x90000处,然后利用一个jmpi(jump indirectly)的指令,跳到新位置的
jmpi的下一行去执行,

第二步
 接着,将其他segment registers包括DS,ES,SS都指向0x9000这个位置,
与CS看齐。另外将SP及DX指向一任意位移地址( offset ),这个地址等一下
会用来存放磁盘参数表(disk para- meter table )

第三步
 接着利用BIOS中断服务int 13h的第0号功能,重置磁盘控制器,使得刚才
的设定发挥功能。

第四步
 完成重置磁盘控制器之后,bootsect就从磁盘上读入紧邻着bootsect的setup
程序,也就是setup.S,此读入动作是利用BIOS中断服务int 13h的第2号功能。
setup的image将会读入至程序所指定的内存绝对地址0x90200处,也就是在内存
中紧邻着bootsect 所在的位置。待setup的image读入内存后,利用BIOS中断服
务int 13h的第8号功能读取目前磁盘的参数。

第五步
 再来,就要读入真正linux的kernel了,也就是你可以在linux的根目录下看
到的"vmlinuz" 。在读入前,将会先呼叫BIOS中断服务int 10h 的第3号功能,
读取游标位置,之后再呼叫BIOS 中断服务int 10h的第13h号功能,在萤幕上输
出字串"Loading",这个字串在boot linux时都会首先被看到,相信大家应该觉
得很眼熟吧。

第六步
 接下来做的事是检查root device,之后就仿照一开始的方法,利用indirect
jump 跳至刚刚已读入的setup部份

第七步
  setup.S完成在实模式下版本检查,并将硬盘,鼠标,内存参数写入到 INITSEG
中,并负责进入保护模式。

第八步
  操作系统的初始化。

[目录]


setup.s


setup.S
A summary of the setup.S code 。The slight differences in the operation of setup.S due to a big kernel is documented here. When the switch to 32 bit protected mode begins the code32_start address is defined as 0x100000 (when loaded) here.
code32_start:

#ifndef __BIG_KERNEL__
.long 0x1000
#else
.long 0x100000
#endif

After setting the keyboard repeat rate to a maximum, calling video.S, storing the video parameters, checking for the hard disks, PS/2 mouse, and APM BIOS the preparation for real mode switch begins.

The interrupts are disabled. Since the loader changed the code32_start address, the code32 varable is updated. This would be used for the jmpi instruction when the setup.S finally jumps to compressed/head.S. In case of a big kernel this is loacted at 0x100000.

seg cs
mov eax, code32_start !modified above by the loader
seg cs
mov code32,eax

!code32 contains the correct address to branch to after setup.S finishes After the above code there is a slight difference in the ways the big and small kernels are dealt. In case of a small kernel the kernel is moved down to segment address 0x100, but a big kernel is not moved. Before decompression, the big kernel stays at 0x100000. The following is the code that does thischeck.test byte ptr loadflags,

#LOADED_HIGH
jz do_move0 ! a normal low loaded zImage is moved
jmp end_move ! skip move

The interrupt and global descriptors are initialized:

lidt idt_48 ! load idt wit 0,0
lgdt gdt_48 ! load gdt with whatever appropriate

After enabling A20 and reprogramming the interrupts, it is ready to set the PE bit:

mov ax,#1
lmsw ax
jmp flush_instr
flush_instr:
xor bx.bx !flag to indicate a boot
! Manual, mixing of 16-bit and 32 bit code
db 0x166,0xea !prefix jmpi-opcode
code32: dd ox1000 !this has been reset in caes of a big kernel, to 0x100000
dw __KERNEL_CS

Finally it prepares the opcode for jumping to compressed/head.S which in the big kernel is at 0x100000. The compressed kernel would start at 0x1000 in case of a small kernel.

compressed/head.S

When setup.S relinquishes control to compressed/head.S at beginning of the compressed kernmel at 0x100000. It checks to see if A20 is really enabled otherwise it loops forever.

Itinitializes eflags, and clears BSS (Block Start by Symbol) creating reserved space for uninitialized static or global variables. Finally it reserves place for the moveparams structure (defined in misc.c) and pushes the current stack pointer on the stack and calls the C function decompress_kernel which takes a struct moveparams * as an argument

subl $16,%esp
pushl %esp
call SYMBOL_NAME(decompress_kernel)
orl ??,??
jnz 3f

Te C function decompress_kernel returns the variable high_loaded which is set to 1 in the function setup_output_buffer_if_we_run_high, which is called in decompressed_kernel if a big kernel was loaded.
When decompressed_kernel returns, it jumps to 3f which moves the move routine.

movl $move_routine_start,%esi ! puts the offset of the start of the source in the source index register
mov $0x1000,?? ! the destination index now contains 0x1000, thus after move, the move routine starts at 0x1000
movl $move_routine_end,??
sub %esi,?? ! ecx register now contains the number of bytes to be moved
! (number of bytes between the labels move_routine_start and move_routine_end)
cld
rep
movsb ! moves the bytes from ds:si to es:di, in each loop it increments si and di, and decrements cx
! the movs instruction moves till ecx is zero

Thus the movsb instruction moves the bytes of the move routine between the labels move_routine_start and move_routine_end. At the end the entire move routine labeled move_routine_start is at 0x1000. The movsb instruction moves bytes from ds:si to es:si.

At the start of the head.S code es,ds,fs,gs were all intialized to __KERNEL_DS, which is defined in /usr/src/linux/include/asm/segment.h as 0x18. This is the offset from the goobal descriptor table gdtwhich was setup in setup.S. The 24th byte is the start of the data segment descriptor, which has the base address = 0. Thus the moe routine is moved and
starts at offset 0x1000 from __KERNEL_DS, the kernel data segment base (which is 0).
The salient features of what is done by the decompress_kernel is discussed in the next section but it is worth noting that the when the decompressed_kernel function is invoked, space was created at the top of the stack to contain the information about the decompressed kernel. The decompressed kernel if big may be in the high buffer and in the low buffer. After the decompressed_kernel function returns, the decompressed kernel has to be moved so that we
have a contiguous decompressed kernel starting from address 0x100000. To move the decompressed kernel, the important parameters needed are the start addresses of the high buffer and low buffer, and the number of bytes in the high and low buffers. This is at the top of the stack when decompressed_kernel returns (the top of the stack was passed as an argument : struct moveparams*, and in the function the fileds of the moveparams struture was adjusted toreflect the state of the decompression.)

/* in compressed/misc.c */
struct moveparams {
uch *low_buffer_start; ! start address of the low buffer
int count; ! number of bytes in the low buffer after decompression is doneuch *high_buffer_start; ! start address of the high buffer
int hcount; ! number of bytes in the high buffer aftre decompression is done
};

Thus when the decompressed_kernel returns, the relevant bytes are popped in the respective registers as shown below. After preparing these registers the decompressed kernel is ready to be moved and the control jumps to the moved move routine at __KERNEL_CS:0x1000. The code for setting the appropriate registers is given below:

popl %esi ! discard the address, has the return value (high_load) most probably
popl %esi ! low_buffer_start
popl ?? ! lcount
popl ?? ! high_buffer_count
popl ?? ! hcount
movl %0x100000,??
cli ! disable interrutps when the decompressed kernel is being moved
ljmp $(__KERNEL_CS), $0x1000 ! jump to the move routine which was moved to low memory, 0x1000

The move_routine_start basically has two parts, first it moves the part of the decompressed kernel in the low buffer, then it moves (if required) the high buffer contents. It should be noted that the ecx has been intialized to the number of bytes in the low end buffer, and the destination index register di has been intialized to 0x100000.
move_routine_start:

rep ! repeat, it stops repeating when ecx == 0
movsb ! the movsb instruction repeats till ecx is 0. In each loop byte is transferred from ds:esi to es:edi! In each loop the edi and the esi are incremented and ecx is decremented
! when the low end buffer has been moved the value of di is not changed and the next pasrt of the code! uses it to transfer the bytes from the high buffer
movl ??,%esi ! esi now has the offset corresponding to the start of the high  buffer
movl ??,?? ! ecx is now intialized to the number of bytes in the high buffer
rep
movsb ! moves all the bytes in the high buffer, and doesn’t move at all if hcount was zero (if it was determined, in! close_output_buffer_if_we_run_high that the high buffer need not be moveddown )
xorl ??,??
mov $0x90000, %esp ! stack pointer is adjusted, most probably to be used by the kernel in the intialization
ljmp $(__KERNEL_CS), $0x100000 ! jump to __KERNEL_CS:0X100000, where the kernel code starts
move_routine_end:At the end of the this the control goes to the kernel code segment.


Linux Assembly code taken from  head.S and setup.S
Comment code added by us

[目录]


head.s


因为setup.S最后的为一条转跳指令,跳到内核第一条指令并开始执行。
指令中指向的是内存中的绝对地址,我们无法依此判断转跳到了head.S。

但是我们可以通过Makefile简单的确定head.S位于内核的前端。

在arch/i386 的 Makefile 中定义了
HEAD := arch/i386/kernel/head.o

而在linux总的Makefile中由这样的语句
include arch/$(ARCH)/Makefile
说明HEAD定义在该文件中有效

然后由如下语句:
vmlinux: $(CONFIGURATION) init/main.o init/version.o linuxsubdirs
$(LD) $(LINKFLAGS) $(HEAD) init/main.o init/version.o /
  $(ARCHIVES) /
  $(FILESYSTEMS) /
  $(DRIVERS) /
  $(LIBS) -o vmlinux
$(NM) vmlinux | grep -v '/(compiled/)/|/(/.o$$/)/|/( a /)' | sort > System.map

从这个依赖关系我们可以获得大量的信息

1>$(HEAD)即head.o的确第一个被连接到核心中

2>所有内核中支持的文件系统全部编译到$(FILESYSTEMS)即fs/filesystems.a中
  所有内核中支持的网络协议全部编译到net.a中
  所有内核中支持的SCSI驱动全部编译到scsi.a中
  ...................
  原来内核也不过是一堆库文件和目标文件的集合罢了,有兴趣对内核减肥的同学,
  可以好好比较一下看究竟是那个部分占用了空间。

3>System.map中包含了所有的内核输出的函数,我们在编写内核模块的时候
  可以调用的系统函数大概就这些了。


好了,消除了心中的疑问,我们可以仔细分析head.s了。

Head.S分析

1 首先将ds,es,fs,gs指向系统数据段KERNEL_DS
  KERNEL_DS 在asm/segment.h中定义,表示全局描述符表中
  中的第三项。
  注意:该此时生效的全局描述符表并不是在head.s中定义的
        而仍然是在setup.S中定义的。

2 数据段全部清空。

3 setup_idt为一段子程序,将中断向量表全部指向ignore_int函数
  该函数打印出:unknown interrupt
  当然这样的中断处理函数什么也干不了。

4 察看数据线A20是否有效,否则循环等待。
  地址线A20是x86的历史遗留问题,决定是否能访问1M以上内存。

5 拷贝启动参数到0x5000页的前半页,而将setup.s取出的bios参数
  放到后半页。

6 检查CPU类型
  @#$#%$^*@^?(^%#$%!#!@?谁知道干了什么?

7 初始化页表,只初始化最初几页。

  1>将swapper_pg_dir(0x2000)和pg0(0x3000)清空
    swapper_pg_dir作为整个系统的页目录

  2>将pg0作为第一个页表,将其地址赋到swapper_pg_dir的第一个32
    位字中。

  3>同时将该页表项也赋给swapper_pg_dir的第3072个入口,表示虚拟地址
    0xc0000000也指向pg0。

  4>将pg0这个页表填满指向内存前4M

  5>进入分页方式
    注意:以前虽然在在保护模式但没有启用分页。

    --------------------
    |  swapper_pg_dir  |       -----------
    |                  |-------| pg0     |----------内存前4M
    |                  |       -----------
    |                  |
    --------------------
8 装入新的gdt和ldt表。

9 刷新段寄存器ds,es,fs,gs

10 使用系统堆栈,即预留的0x6000页面

11 执行start_kernel函数,这个函数是第一个C编制的
   函数,内核又有了一个新的开始。

[目录]


bootsect.s


发发信人: seis (矛), 信区: Linux
标  题: Linux操作系统内核引导程序详细剖析
发信站: BBS 水木清华站 (Fri Feb  2 14:12:43 2001)

! bootsect.s (c) 1991, 1992 Linus Torvalds 版权所有
! Drew Eckhardt修改过
! Bruce Evans (bde)修改过
!
! bootsect.s 被bios-启动子程序加载至0x7c00 (31k)处,并将自己
! 移到了地址0x90000 (576k)处,并跳转至那里。
!
! bde - 不能盲目地跳转,有些系统可能只有512k的低
! 内存。使用中断0x12来获得(系统的)最高内存、等。
!
! 它然后使用BIOS中断将setup直接加载到自己的后面(0x90200)(576.5k),
! 并将系统加载到地址0x10000处。
!
! 注意! 目前的内核系统最大长度限制为(8*65536-4096)(508k)字节长,即使是在
! 将来这也是没有问题的。我想让它保持简单明了。这样508k的最大内核长度应该
! 是足够了,尤其是这里没有象minix中一样包含缓冲区高速缓冲(而且尤其是现在
! 内核是压缩的 :-)
!
! 加载程序已经做的尽量地简单了,所以持续的读出错将导致死循环。只能手工重启。
! 只要可能,通过一次取得整个磁道,加载过程可以做的很快的。

#include /* 为取得CONFIG_ROOT_RDONLY参数 */
!! config.h中(即autoconf.h中)没有CONFIG_ROOT_RDONLY定义!!!?

#include

.text

SETUPSECS = 4 ! 默认的setup程序扇区数(setup-sectors)的默认值;

BOOTSEG = 0x7C0 ! bootsect的原始地址;

INITSEG = DEF_INITSEG ! 将bootsect程序移到这个段处(0x9000) - 避开;
SETUPSEG = DEF_SETUPSEG ! 设置程序(setup)从这里开始(0x9020);
SYSSEG = DEF_SYSSEG ! 系统加载至0x1000(65536)(64k)段处;
SYSSIZE = DEF_SYSSIZE ! 系统的大小(0x7F00): 要加载的16字节为一节的数;
!! 以上4个DEF_参数定义在boot.h中:
!! DEF_INITSEG 0x9000
!! DEF_SYSSEG 0x1000
!! DEF_SETUPSEG 0x9020
!! DEF_SYSSIZE 0x7F00 (=32512=31.75k)*16=508k

! ROOT_DEV & SWAP_DEV 现在是由"build"中编制的;
ROOT_DEV = 0
SWAP_DEV = 0
#ifndef SVGA_MODE
#define SVGA_MODE ASK_VGA
#endif
#ifndef RAMDISK
#define RAMDISK 0
#endif
#ifndef CONFIG_ROOT_RDONLY
#define CONFIG_ROOT_RDONLY 1
#endif

! ld86 需要一个入口标识符,这和通常的一样;
.globl _main
_main:
#if 0 /* 调试程序的异常分支,除非BIOS古怪(比如老的HP机)否则是无害的 */
int 3
#endif
mov ax,#BOOTSEG !! 将ds段寄存器置为0x7C0;
mov ds,ax
mov ax,#INITSEG !! 将es段寄存器置为0x9000;
mov es,ax
mov cx,#256 !! 将cx计数器置为256(要移动256个字, 512字节);
sub si,si !! 源地址 ds:si=0x07C0:0x0000;
sub di,di !! 目的地址es:di=0x9000:0x0000;
cld !! 清方向标志;
rep !! 将这段程序从0x7C0:0(31k)移至0x9000:0(576k)处;
movsw !! 共256个字(512字节)(0x200长);
jmpi go,INITSEG !! 间接跳转至移动后的本程序go处;

! ax和es现在已经含有INITSEG的值(0x9000);

go: mov di,#0x4000-12 ! 0x4000(16k)是>=bootsect + setup 的长度 +
! + 堆栈的长度 的任意的值;
! 12 是磁盘参数块的大小 es:di=0x94000-12=592k-12;

! bde - 将0xff00改成了0x4000以从0x6400处使用调试程序(bde)。如果
! 我们检测过最高内存的话就不用担心这事了,还有,我的BIOS可以被配置为将wini驱动

! 放在内存高端而不是放在向量表中。老式的堆栈区可能会搞乱驱动表;

mov ds,ax ! 置ds数据段为0x9000;
mov ss,ax ! 置堆栈段为0x9000;
mov sp,di ! 置堆栈指针INITSEG:0x4000-12处;
/*
* 许多BIOS的默认磁盘参数表将不能
* 进行扇区数大于在表中指定
* 的最大扇区数( - 在某些情况下
* 这意味着是7个扇区)后面的多扇区的读操作。
*
* 由于单个扇区的读操作是很慢的而且当然是没问题的,
* 我们必须在RAM中(为第一个磁盘)创建新的参数表。
* 我们将把最大扇区数设置为36 - 我们在一个ED 2.88驱动器上所能
* 遇到的最大值。
*
* 此值太高是没有任何害处的,但是低的话就会有问题了。
*
* 段寄存器是这样的: ds=es=ss=cs - INITSEG,(=0X9000)
* fs = 0, gs没有用到。
*/

! 上面执行重复操作(rep)以后,cx为0;

mov fs,cx !! 置fs段寄存器=0;
mov bx,#0x78 ! fs:bx是磁盘参数表的地址;
push ds
seg fs
lds si,(bx) ! ds:si是源地址;
!! 将fs:bx地址所指的指针值放入ds:si中;
mov cl,#6 ! 拷贝12个字节到0x9000:0x4000-12开始处;
cld
push di !! 指针0x9000:0x4000-12处;

rep
movsw

pop di !! di仍指向0x9000:0x4000-12处(参数表开始处);
pop si !! ds => si=INITSEG(=0X9000);

movb 4(di),*36 ! 修正扇区计数值;

seg fs
mov (bx),di !! 修改fs:bx(0000:0x0078)处磁盘参数表的地址为0x9000:0x4000-12;
seg fs
mov 2(bx),es

! 将setup程序所在的扇区(setup-sectors)直接加载到boot块的后面。!! 0x90200开始处
;
! 注意,es已经设置好了。
! 同样经过rep循环后cx为0

load_setup:
xor ah,ah ! 复位软驱(FDC);
xor dl,dl
int 0x13

xor dx,dx ! 驱动器0, 磁头0;
mov cl,#0x02 ! 从扇区2开始,磁道0;
mov bx,#0x0200 ! 置数据缓冲区地址=es:bx=0x9000:0x200;
! 在INITSEG段中,即0x90200处;
mov ah,#0x02 ! 要调用功能号2(读操作);
mov al,setup_sects ! 要读入的扇区数SETUPSECS=4;
! (假释所有数据都在磁头0、磁道0);
int 0x13 ! 读操作;
jnc ok_load_setup ! ok则继续;

push ax ! 否则显示出错信息。保存ah的值(功能号2);
call print_nl !! 打印换行;
mov bp,sp !! bp将作为调用print_hex的参数;
call print_hex !! 打印bp所指的数据;
pop ax

jmp load_setup !! 重试!

!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
!!INT 13 - DISK - READ SECTOR(S) INTO MEMORY
!! AH = 02h
!! AL = number of sectors to read (must be nonzero)
!! CH = low eight bits of cylinder number
!! CL = sector number 1-63 (bits 0-5)
!! high two bits of cylinder (bits 6-7, hard disk only)
!! DH = head number
!! DL = drive number (bit 7 set for hard disk)
!! ES:BX -> data buffer
!! Return: CF set on error
!! if AH = 11h (corrected ECC error), AL = burst length
!! CF clear if successful
!! AH = status (see #00234)
!! AL = number of sectors transferred (only valid if CF set for some
!! BIOSes)
!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!


ok_load_setup:

! 取得磁盘驱动器参数,特别是每磁道扇区数(nr of sectors/track);

#if 0

! bde - Phoenix BIOS手册中提到功能0x08只对硬盘起作用。
! 但它对于我的一个BIOS(1987 Award)不起作用。
! 不检查错误码是致命的错误。

xor dl,dl
mov ah,#0x08 ! AH=8用于取得驱动器参数;
int 0x13
xor ch,ch

!!!!!!!!!!!!!!!!!!!!!!!!!!!
!! INT 13 - DISK - GET DRIVE PARAMETERS (PC,XT286,CONV,PS,ESDI,SCSI)
!! AH = 08h
!! DL = drive (bit 7 set for hard disk)
!!Return: CF set on error
!! AH = status (07h) (see #00234)
!! CF clear if successful
!! AH = 00h
!! AL = 00h on at least some BIOSes
!! BL = drive type (AT/PS2 floppies only) (see #00242)
!! CH = low eight bits of maximum cylinder number
!! CL = maximum sector number (bits 5-0)
!! high two bits of maximum cylinder number (bits 7-6)
!! DH = maximum head number
!! DL = number of drives
!! ES:DI -> drive parameter table (floppies only)
!!!!!!!!!!!!!!!!!!!!!!!!!!!!

#else

! 好象没有BIOS调用可取得扇区数。如果扇区36可以读就推测是36个扇区,
! 如果扇区18可读就推测是18个扇区,如果扇区15可读就推测是15个扇区,
! 否则推测是9. [36, 18, 15, 9]

mov si,#disksizes ! ds:si->要测试扇区数大小的表;

probe_loop:
lodsb !! ds:si所指的字节 =>al, si=si+1;
cbw ! 扩展为字(word);
mov sectors, ax ! 第一个值是36,最后一个是9;
cmp si,#disksizes+4
jae got_sectors ! 如果所有测试都失败了,就试9;
xchg ax,cx ! cx = 磁道和扇区(第一次是36=0x0024);
xor dx,dx ! 驱动器0,磁头0;
xor bl,bl !! 设置缓冲区es:bx = 0x9000:0x0a00(578.5k);
mov bh,setup_sects !! setup_sects = 4 (共2k);
inc bh
shl bh,#1 ! setup后面的地址(es=cs);
mov ax,#0x0201 ! 功能2(读),1个扇区;
int 0x13
jc probe_loop ! 如果不对,就试用下一个值;

#endif

got_sectors:

! 恢复es

mov ax,#INITSEG
mov es,ax ! es = 0x9000;

! 打印一些无用的信息(换行后,显示Loading)

mov ah,#0x03 ! 读光标位置;
xor bh,bh
int 0x10

mov cx,#9
mov bx,#0x0007 ! 页0,属性7 (normal);
mov bp,#msg1
mov ax,#0x1301 ! 写字符串,移动光标;
int 0x10

! ok, 我们已经显示出了信息,现在
! 我们要加载系统了(到0x10000处)(64k处)

mov ax,#SYSSEG
mov es,ax ! es=0x01000的段;
call read_it !! 读system,es为输入参数;
call kill_motor !! 关闭驱动器马达;
call print_nl !! 打印回车换行;

! 这以后,我们来检查要使用哪个根设备(root-device)。如果已指定了设备(!=0)
! 则不做任何事而使用给定的设备。否则的话,使用/dev/fd0H2880 (2,32)或/dev/PS0
(2,28)
! 或者是/dev/at0 (2,8)之一,这取决于我们假设我们知道的扇区数而定。
!! |__ ps0?? (x,y)--表示主、次设备号?

seg cs
mov ax,root_dev
or ax,ax
jne root_defined
seg cs
mov bx,sectors !! sectors = 每磁道扇区数;
mov ax,#0x0208 ! /dev/ps0 - 1.2Mb;
cmp bx,#15
je root_defined
mov al,#0x1c ! /dev/PS0 - 1.44Mb !! 0x1C = 28;
cmp bx,#18
je root_defined
mov al,0x20 ! /dev/fd0H2880 - 2.88Mb;
cmp bx,#36
je root_defined
mov al,#0 ! /dev/fd0 - autodetect;
root_defined:
seg cs
mov root_dev,ax !! 其中保存由设备的主、次设备号;

! 这以后(所有程序都加载了),我们就跳转至
! 被直接加载到boot块后面的setup程序去:

jmpi 0,SETUPSEG !! 跳转到0x9020:0000(setup程序的开始位置);


! 这段程序将系统(system)加载到0x10000(64k)处,
! 注意不要跨越64kb边界。我们试图以最快的速度
! 来加载,只要可能就整个磁道一起读入。
!
! 输入(in): es - 开始地址段(通常是0x1000)
!
sread: .word 0 ! 当前磁道已读的扇区数;
head: .word 0 ! 当前磁头;
track: .word 0 ! 当前磁道;

read_it:
mov al,setup_sects
inc al
mov sread,al !! 当前sread=5;
mov ax,es !! es=0x1000;
test ax,#0x0fff !! (ax AND 0x0fff, if ax=0x1000 then zero-flag=1 );
die: jne die ! es 必须在64kB的边界;
xor bx,bx ! bx 是段内的开始地址;
rp_read:
#ifdef __BIG_KERNEL__
#define CALL_HIGHLOAD_KLUDGE .word 0x1eff, 0x220 ! 调用 far * bootsect_kludge
! 注意: as86不能汇编这;
CALL_HIGHLOAD_KLUDGE ! 这是在setup.S中的程序;
#else
mov ax,es
sub ax,#SYSSEG ! 当前es段值减system加载时的启始段值(0x1000);
#endif
cmp ax,syssize ! 我们是否已经都加载了?(ax=0x7f00 ?);
jbe ok1_read !! if ax <= syssize then 继续读;
ret !! 全都加载完了,返回!
ok1_read:
mov ax,sectors !! sectors=每磁道扇区数;
sub ax,sread !! 减去当前磁道已读扇区数,al=当前磁道未读的扇区数(ah=0);
mov cx,ax
shl cx,#9 !! 乘512,cx = 当前磁道未读的字节数;
add cx,bx !! 加上段内偏移值,es:bx为当前读入的数据缓冲区地址;
jnc ok2_read !! 如果没有超过64K则继续读;
je ok2_read !! 如果正好64K也继续读;
xor ax,ax
sub ax,bx
shr ax,#9
ok2_read:
call read_track !! es:bx ->缓冲区,al=要读的扇区数,也即当前磁道未读的扇区数;

mov cx,ax !! ax仍为调用read_track之前的值,即为读入的扇区数;
add ax,sread !! ax = 当前磁道已读的扇区数;
cmp ax,sectors !! 已经读完当前磁道上的扇区了吗?
jne ok3_read !! 没有,则跳转;
mov ax,#1
sub ax,head !! 当前是磁头1吗?
jne ok4_read !! 不是(是磁头0)则跳转(此时ax=1);
inc track !! 当前是磁头1,则读下一磁道(当前磁道加1);
ok4_read:
mov head,ax !! 保存当前磁头号;
xor ax,ax !! 本磁道已读扇区数清零;
ok3_read:
mov sread,ax !! 存本磁道已读扇区数;
shl cx,#9 !! 刚才一次读操作读入的扇区数 * 512;
add bx,cx !! 调整数据缓冲区的起始指针;
jnc rp_read !! 如果该指针没有超过64K的段内最大偏移量,则跳转继续读操作;
mov ax,es !! 如果超过了,则将段地址加0x1000(下一个64K段);
add ah,#0x10
mov es,ax
xor bx,bx !! 缓冲区地址段内偏移量置零;
jmp rp_read !! 继续读操作;

 

read_track:
pusha !! 将寄存器ax,cx,dx,bx,sp,bp,si,di压入堆栈;
pusha
mov ax,#0xe2e ! loading... message 2e = . !! 显示一个.
mov bx,#7
int 0x10
popa

mov dx,track !! track = 当前磁道;
mov cx,sread
inc cx !! cl = 扇区号,要读的起始扇区;
mov ch,dl !! ch = 磁道号的低8位;
mov dx,head !!
mov dh,dl !! dh = 当前磁头号;
and dx,#0x0100 !! dl = 驱动器号(0);
mov ah,#2 !! 功能2(读),es:bx指向读数据缓冲区;

push dx ! 为出错转储保存寄存器的值到堆栈上;
push cx
push bx
push ax

int 0x13
jc bad_rt !! 如果出错,则跳转;
add sp, #8 !! 清(放弃)堆栈上刚推入的4个寄存器值;
popa
ret

bad_rt: push ax ! 保存出错码;
call print_all ! ah = error, al = read;


xor ah,ah
xor dl,dl
int 0x13


add sp,#10
popa
jmp read_track

/*
* print_all是用于调试的。
* 它将打印出所有寄存器的值。所作的假设是
* 从一个子程序中调用的,并有如下所示的堆栈帧结构
* dx
* cx
* bx
* ax
* error
* ret <- sp
*
*/

print_all:
mov cx,#5 ! 出错码 + 4个寄存器
mov bp,sp

print_loop:
push cx ! 保存剩余的计数值
call print_nl ! 为了增强阅读性,打印换行

cmp cl, #5
jae no_reg ! 看看是否需要寄存器的名称

mov ax,#0xe05 + A - l
sub al,cl
int 0x10

mov al,#X
int 0x10

mov al,#:
int 0x10

no_reg:
add bp,#2 ! 下一个寄存器
call print_hex ! 打印值
pop cx
loop print_loop
ret

print_nl: !! 打印回车换行。
mov ax,#0xe0d ! CR
int 0x10
mov al,#0xa ! LF
int 0x10
ret

/*
* print_hex是用于调试目的的,打印出
* ss:bp所指向的十六进制数。
* !! 例如,十六进制数是0x4321时,则al分别等于4,3,2,1调用中断打印出来 4321
*/

print_hex:
mov cx, #4 ! 4个十六进制数字
mov dx, (bp) ! 将(bp)所指的值放入dx中
print_digit:
rol dx, #4 ! 循环以使低4比特用上 !! 取dx的高4比特移到低4比特处。
mov ax, #0xe0f ! ah = 请求的功能值,al = 半字节(4个比特)掩码。
and al, dl !! 取dl的低4比特值。
add al, #0x90 ! 将al转换为ASCII十六进制码(4个指令)
daa !! 十进制调整
adc al, #0x40 !! (adc dest, src ==> dest := dest + src + c )
daa
int 0x10
loop print_digit
ret


/*
* 这个过程(子程序)关闭软驱的马达,这样
* 我们进入内核后它的状态就是已知的,以后也就
* 不用担心它了。
*/
kill_motor:
push dx
mov dx,#0x3f2
xor al,al
outb
pop dx
ret

!! 数据区
sectors:
.word 0 !! 当前每磁道扇区数。(36||18||15||9)

disksizes: !! 每磁道扇区数表
.byte 36, 18, 15, 9

msg1:
.byte 13, 10
.ascii "Loading"

.org 497 !! 从boot程序的二进制文件的497字节开始
setup_sects:
.byte SETUPSECS
root_flags:
.word CONFIG_ROOT_RDONLY
syssize:
.word SYSSIZE
swap_dev:
.word SWAP_DEV
ram_size:
.word RAMDISK
vid_mode:
.word SVGA_MODE
root_dev:
.word ROOT_DEV
boot_flag: !! 分区启动标志
.word 0xAA55

[目录]


compressed/misc.c


compressed/misc.c
The differences in decompressing big and small kernels.
http://www.vuse.vanderbilt.edu/~knopfdg/documentation/hw3_part3.htm
The function decompressed_kernel is invoked from head.S and a parameter to the top of the stack is passed to store the results of the decompression namely, the start addresses of the high and the low buffers which contain the decompressed kernel and the numebr of bytes in each buffer (hcount and lcount).

int decompress_kernel(struct moveparams *mv)
{
if (SCREEN_INFO.orig_video_mode == 7) {
vidmem = (char *) 0xb0000;
vidport = 0x3b4;
} else {
vidmem = (char *) 0xb8000;
vidport = 0x3d4;
}
lines = SCREEN_INFO.orig_video_lines;
cols = SCREEN_INFO.orig_video_cols;
if (free_mem_ptr < 0x100000) setup_normal_output_buffer(); // Call if smallkernel
else setup_output_buffer_if_we_run_high(mv); // Call if big kernel
makecrc();
puts("Uncompressing Linux... ");
gunzip();
puts("Ok, booting the kernel./n");
if (high_loaded) close_output_buffer_if_we_run_high(mv);
return high_loaded;
}

The first place where a distinction is made is when the buffers are to be setup for the decmpression routine gunzip(). Free_mem_ptr, is loaded with the value of the address of the extern variabe end. The variable end marks the end of the compressed kernel. If the free_mem-ptr is less than the 0x100000,then a high buffer has to be setup. Thus the function setup_output_buffer_if_we_run_high is called and the pointer to the top of the moveparams structure is passed so that when the buffers are setup, the start addresses fields are updated in moveparams structure. It is also checked to see if the high buffer needs to be moved down after decompression and this is reflected by the hcount which is 0 if we need not move the high buffer down.

void setup_output_buffer_if_we_run_high(struct moveparams *mv)
{
high_buffer_start = (uch *)(((ulg)&end) HEAP_SIZE);
//the high buffer start address is at the end HEAP_SIZE
#ifdef STANDARD_MEMORY_BIOS_CALL
if (EXT_MEM_K < (3*1024)) error("Less than 4MB of memory./n");
#else
if ((ALT_MEM_K > EXT_MEM_K ? ALT_MEM_K : EXT_MEM_K) < (3*1024)) error("Less
than 4MB of memory./n");
#endif
mv->low_buffer_start = output_data = (char *)LOW_BUFFER_START;
//the low buffer start address is at 0x2000 and it extends till 0x90000.
high_loaded = 1; //high_loaded is set to 1, this is returned by decompressed_kernel
free_mem_end_ptr = (long)high_buffer_start;
// free_mem_end_ptr points to the same address as te high_buffer_start
// the code below finds out if the high buffer needs to be moved after decompression
// if the size if the low buffer is > the size of the compressed kernel and the HEAP_SIZE
// then the high_buffer_start has to be shifted up so that when the decompression starts it doesn’t
// overwrite the compressed kernel data. Thus when the high_buffer_start islow then it is shifted
// up to exactly match the end of the compressed kernel and the HEAP_SIZE. The hcount filed is
// is set to 0 as the high buffer need not be moved down. Otherwise if the high_buffer_start is too
// high then the hcount is non zero and while closing the buffers the appropriate number of bytes
// in the high buffer is asigned to the filed hcount. Since the start address of the high buffer is
// known the bytes could be moved down
if ( (0x100000 LOW_BUFFER_SIZE) > ((ulg)high_buffer_start)) {
high_buffer_start = (uch *)(0x100000 LOW_BUFFER_SIZE);
mv->hcount = 0; /* say: we need not to move high_buffer */
}
else mv->hcount = -1;
mv->high_buffer_start = high_buffer_start;
// finally the high_buffer_start field is set to the varaible high_buffer_start
}

After the buffers are set gunzip() is invoked which decompresses the kernel Upon return, bytes_out has the number of bytes in the decompressed kernel.Finally close_output_buffer_if_we_run_high is invoked if high_loaded is non zero:

void close_output_buffer_if_we_run_high(struct moveparams *mv)
{
mv->lcount = bytes_out;
// if the all of decompressed kernel is in low buffer, lcount = bytes_out
if (bytes_out > LOW_BUFFER_SIZE) {
// if there is a part of the decompressed kernel in the high buffer, the lcount filed is set to
// the size of the low buffer and the hcount field contains the rest of the bytes
mv->lcount = LOW_BUFFER_SIZE;
if (mv->hcount) mv->hcount = bytes_out - LOW_BUFFER_SIZE;
// if the hcount field is non zero (made in setup_output_buffer_if_we_run_high)
// then the high buffer has to be moved doen and the number of bytes in the high buffer is
// in hcount
}
else mv->hcount = 0; // all the data is in the high buffer
}
Thus at the end of the the decompressed_kernel function the top of the stack has the addresses of the buffers and their sizes which is popped and the appropriate registers set for the move routine to move the entire kernel. After the move by the move_routine the kernel resides at 0x100000. If a small kernel is being decompressed then the setup_normal_output_buffer() is invoked from decompressed_kernel, which just initializes output_data to 0x100000 where the decompressed kernel would lie. The variable high_load is still 0 as setup_output_buffer_if_we_run_high() is not invoked. Decompression is done starting at address 0x100000. As high_load is 0, when decompressed_kernel returns in head.S, a zero is there in the eax. Thus the control jumps directly to 0x100000. Since the decompressed kernel lies there directly and the move routine need not be called.

Linux code taken from misc.c
Comment code added by us

[目录]


setup.txt


1、按规定得有个头,所以一开始是惯用的JMP;
2、头里边内容很丰富,具体用法走着瞧;
3、自我检测,不知道有什么用,防伪造?防篡改?
4、如果装载程序不对,只好死掉!以下终于走入正题;
5、获取内存容量(使用了三种办法,其中的E820和E801看不明白,int 15倒是老朋友了--应该是上个世纪80年代末认识的了,真佩服十年过去了,情意依旧,不过遇上一些不守规矩的BIOS,不知道还行不行);
6、将键盘重复键的重复率设为最大,灵敏一点?
7、检测硬盘,不懂,放这里干什么?
8、检测MCA总线(不要问我这是什么);
9、检测PS/2鼠标,用int 11,只是不知道为何放这里;
10、检测电源管理BIOS;唉,书到用时方恨少,不懂的太多了,真不好意思;不过也没有关系, 不懂的就别去动它就行了;以下要进入内核了;
11、 在进入保护模式之前,可以调用一个你提供的试模式下的过程,让你最后在看她一眼,当然你要是不提供,那就有个默认的,无非是塞住耳朵闭上眼睛禁止任何中断,包括著名的NMI ;
12、设置保护模式起动后的例程地址, 你可以写自己的例程,但不是代替而是把它加在setup提供的例程的前面(显示一个小鸭子?);
13、如果内核是zImage, 将它移动到0x10000处;
14、如果自己不在0x90000处,则移动到0x90000处;
15、建立idt, gdt表;
16、启动A20;
17、屏住呼吸,屏闭所有中断;
18、启动!movw $1, %ax ; lmsw %ax; 好已经进入保护模式下,马上进行局部调整;
19、jmpi 0x100000, __KERNEL_CS,终于进入内核;

 

[目录]


bootsect.txt


1.将自己移动到0x9000:0x0000处,为内核调入留出地址空间;
2.建立运行环境(ss=ds=es=cs=0x9000, sp=0x4000-12),保证起动程序运行;
3.BIOS初始化0x1E号中断为软盘参数表,将它取来保存备用;
4.将setup读到0x9000:0x0200处;
5.测试软盘参数一个磁道有多少个扇区(也没有什么好办法,只能试试36, 18, 15, 9对不对了);
6.打印“Loading”;
7.读入内核到0x1000:0000(如果是bzImage, 则将每个64K移动到0x100000处,在实模式下,只能调用0x15号中断了,这段代码无法放在bootsect中所以只能放在setup中,幸好此时setup已经读入了);
8.到setup去吧

[目录]


用网卡从并口启动(I386)


标题   用网络卡从并口上启动Linux(I386) [re: raoxianhong]
作者 raoxianhong (journeyman)
时间 10/07/01 12:31 PM

 

 

“十一”假期,哪儿也不去,做个程序博各位一笑。
=============================================
1、到底想干什么
   了解Linux的启动过程,制作一个自己的Linux启动程序,可以增加对Linux的了解,还能学习PC机的启动机制,增进对计算机结构的了解,增强对Linux内核学习的信心。也可以在某些专用产品中使用(比如专用的服务器)。为此,我尝试在原来代码的基础上修改制作了一个用网络卡从并口上启动Linux的程序,以博一笑,其中有许多问题值得研究。
2、Linux对启动程序的要求
   Linux(bzImage Kernel)对启动程序的要求比较简单,你只要能够建立一个启动头(setup.S),给出一些信息,然后将kernel(/usr/src/linux/arch/i386/boot/compressed/bvmlinux.out)调到
绝对地址0x100000(1M地址处),如果有initrd,则将它调到内存高端(离0x100000越远越好,比如如果initrd小于4M,就可以将它调到地址0xB00000,即12M处,相信现在已经很少有少于16M内存的机器了),
然后执行一些初始化操作,跳到内核处就行了。
   当然,说起来容易做起来还有点麻烦,以下分几个问题解释。
3、PC机开机流程--启动程序放在何处
   PC机加电后,进入实模式,先进行自检,然后初始化各个总线扩展设备(ISA, EISA,PCI,AGP),
全部初始化做完后,从当前启动设备中读一个块(512字节)到07C0:0000处,将控制转到该处。
   了解这个过程,我们可以决定将启动程序放在何处:
      1)放在启动设备的MBR(主启动记录中),比如磁盘的启动扇区。这是一般的启动方式。
      2)放在总线扩展设备的扩展rom中,比如网卡的boot rom就行,这里制作的启动程序就是放在网卡中,可以支持
          16K字节。
      3)哪位高手能够修改ROMBIOS,让BIOS在做完初始化后不要马上从启动设备读数据,而是调用一段外面
          加入的程序(2K字节就够了,当然也必须与修改后的BIOS一起烧在BIOS ROM中),就可以从BIOS启动!
      4)先启动一个操作系统,再在此操作系统中写启动程序(比如lodlin16就是从DOS中启动Linux,好象中软
         提供了一个从Windows下启动Linux的启动程序)。
4、操作系统放在何处
   操作系统(一般内核在500K-1M之间,加上应用程序可以控制在2M以内,当然都经过压缩了)的数据选择余地就大了,
可以从软盘、硬盘、CDROM、网络、磁带机、并口(软件狗上烧个内核和应用程序?)、串口(外接你的设备)、
USB设备(?)、PCI扩展卡、IC卡等等上面来读;各位还有什么意见,提醒提醒。有位老兄说实在不行可以用键盘启动,
每次启动时把内核敲进去,还有int 16h支持呢,做起来也不难,应该是最节省的方案了。
   反正一个原则是,在启动程序中能够从该设备上读就行了,这里最简单的就是并口了,简单的端口操作,不需
要任何驱动程序支持,不需要BIOS支持,比磁盘还简单(磁盘一般使用int 13h,主要是计算柱面啊、磁头啊、磁道啊、
扇区啊好麻烦,幸好有现成的源代码,可以学习学习)。
   好了,我们挑个简单的方案,将启动代码(bootsect.S+setup.S)放到网络卡的boot rom中,内核数据和应用数据放
到另外一台计算机上,用并口提供。下面谈谈几个相关的问题。
5、将数据移动到绝对地址处
   第一个问题,我们得到数据,因为是在实模式下,所以一般是放在1M地址空间内,怎样将它移动到指定的地方去,
在setup.S 的源代码中,使用了int 15h(87h号功能)。这里将该段代码稍加改动,做了些假设,列到下面:
流程是:
        if (%cs:move_es==0)/*由于使用前move_es初始化为0,因此这是第一次调用,此时es:bx是要移动的数据
                                存放处bx=0,es低四为位为零表示es:bx在64K边界上,fs的低8位指定目的地地址,
                                也以64K字节为单位,用不着那么精确,以简化操作*/
        {
                将es右移四位,得到64K单位的8位地址(这样一来,最多只能将数据移动到16M以下了),作为源数据
                描述符中24位地址的高8位,低16位为零。
                将fs的低8位作为目的地的描述符中24位地址的高8位,同样,它的低16位为零。
                将es存放在move_es中,es自然不会是零,因此以后再调用该例程时就进行正常的移动操作了。
                ax清零返回。
        }
        else
        {
                if (bx==0)/*bx为零,表示数据已经满64K了,应该进行实际的移动*/
                {
                        调用int15h 87h号功能,进行实际的数据移动(64K, 0x8000个16字节块)。
                        目的地址(24位)高8位增一,往后走64K
                        ax = 1
                        return;
                }
                else
                {
                        ax = 0;
                        return;
                }
        }


# we will move %cx bytes from es:bx to %fs(64Kbytes per unit)
# when we first call movetohigh(%cs:move_es is zero),
# the es:bx and %edx is valid
# we configure the param first
# follow calls will move data actually
# %ax return 0 if no data really moved, and return 1 if there is data
# really to be moved
#
movetohigh:
        cmpw        $0, %cs:move_es
        jnz        move_second

        # at this point , es:bx(bx = 0) is the source address
        # %edx is the destination address

        movb        $0x20, %cs:type_of_loader
        movw        %es, %ax
        shrw        $4, %ax
        movb        %ah, %cs:move_src_base+2
        movw        %fs, %ax
        movb        %al, %cs:move_dst_base+2
        movw        %es, %ax
        movw        %ax, %cs:move_es
        xorw        %ax, %ax
        ret                                        # nothing else to do for now

move_second:
        xorw        %ax, %ax
        testw        %bx, %bx
        jne        move_ex
        pushw        %ds
        pushw        %cx
        pushw        %si
        pushw        %bx

        movw        $0x8000, %cx                        # full 64K, INT15 moves words
        pushw        %cs
        popw        %es
        leaw        %cs:move_gdt, %si
        movw        $0x8700, %ax
        int        $0x15
        jc        move_panic                        # this, if INT15 fails

        movw        %cs:move_es, %es                # we reset %es to always point
        incb        %cs:move_dst_base+2                # to 0x10000
        popw        %bx
        popw        %si
        popw        %cx
        popw        %ds
        movw        $1, %ax
move_ex:
        ret

move_gdt:
        .word        0, 0, 0, 0
        .word        0, 0, 0, 0

move_src:
        .word        0xffff

move_src_base:
        .byte        0x00, 0x00, 0x01                # base = 0x010000
        .byte        0x93                                # typbyte
        .word        0                                # limit16,base24 =0

move_dst:
        .word        0xffff

move_dst_base:
        .byte        0x00, 0x00, 0x10                # base = 0x100000
        .byte        0x93                                # typbyte
        .word        0                                # limit16,base24 =0
        .word        0, 0, 0, 0                        # BIOS CS
        .word        0, 0, 0, 0                        # BIOS DS

move_es:
        .word        0

move_panic:
        pushw        %cs
        popw        %ds
        cld
        leaw        move_panic_mess, %si
        call        prtstr

move_panic_loop:
        jmp        move_panic_loop

move_panic_mess:
        .string        "INT15 refuses to access high mem, giving up."


6、用并口传输数据
   用并口传输数据,可以从/usr/src/linux/driver/net/plip.c中抄一段,我们采用半字节协议,
并口线连接参考该文件。字节收发过程如下:

#define PORT_BASE                0x378

#define data_write(b) outportb(PORT_BASE, b)
#define data_read() inportb(PORT_BASE+1)

#define OK                        0
#define TIMEOUT                        1
#define FAIL                        2

int sendbyte(unsigned char data)
{
        unsigned char c0;
        unsigned long cx;

        data_write((data & 0x0f));
        data_write((0x10 | (data & 0x0f)));
        cx = 32767l * 1024l;
        while (1) {
                c0 = data_read();
                if ((c0 & 0x80) == 0)
                        break;
                if (--cx == 0)
                        return TIMEOUT;
        }
        data_write(0x10 | (data >> 4));
        data_write((data >> 4));
        cx = 32767l * 1024l;
        while (1) {
                c0 = data_read();
                if (c0 & 0x80)
                        break;
                if (--cx == 0)
                        return TIMEOUT;
        }
        return OK;
}

int rcvbyte(unsigned char * pByte)
{
        unsigned char c0, c1;
        unsigned long cx;

        cx = 32767l * 1024l;
        while (1) {
                c0 = data_read();
                if ((c0 & 0x80) == 0) {
                        c1 = data_read();
                        if (c0 == c1)
                                break;
                }
                if (--cx == 0)
                        return TIMEOUT;
        }
        *pByte = (c0 >> 3) & 0x0f;
        data_write(0x10); /* send ACK */
        cx = 32767l * 1024l;
        while (1) {
                c0 = data_read();
                if (c0 & 0x80) {
                        c1 = data_read();
                        if (c0 == c1)
                                break;
                }
                if (--cx == 0)
                        return TIMEOUT;
        }
        *pByte |= (c0 << 1) & 0xf0;
        data_write(0x00); /* send ACK */
        return OK;
}

为了能够在setup.S下收字符,特将字符接收子程序该为AT&T汇编语法
(也没有什么好办法,在DOS下用TURBO C 2.0将上述代码编译成汇编
代码,然后手工转换成AT&T格式,据说有程序可以自动进行这样的转换,
有谁用过请指教):

rcvbyte:
        pushw        %bp
        movw        %sp, %bp
        subw        $6, %sp
        movw        $511, -2(%bp)
        movw        $-1024, -4(%bp)
        jmp        .L13
.L15:
        movw        $889, %dx
        inb        %dx, %al
        movb        %al, -6(%bp)
        testb        $128, -6(%bp)
        jne        .L16
        inb        %dx, %al
        movb        %al, -5(%bp)
        movb        -6(%bp), %al
        cmpb        -5(%bp), %al
        jne        .L17
        jmp        .L14
.L17:
.L16:
        subw        $1, -4(%bp)
        sbbw        $0, -2(%bp)
        movw        -2(%bp), %dx
        movw        -4(%bp), %ax
        orw        %ax, %dx
        jne        .L18
        movw        $1, %ax
        jmp        .L12
.L18:
.L13:
        jmp        .L15
.L14:
        movb        -6(%bp), %al
        shrb        $1, %al
        shrb        $1, %al
        shrb        $1, %al
        andb        $15, %al
        movw        4(%bp), %bx
        movb        %al, (%bx)
        movb        $16, %al
        movw        $888, %dx
        outb        %al, %dx
        movw        $511, -2(%bp)
        movw        $-1024, -4(%bp)
        jmp        .L19
.L21:
        movw        $889, %dx
        inb        %dx, %al
        movb        %al, -6(%bp)
        testb        $128, %al
        je        .L22
        inb        %dx, %al
        movb        %al, -5(%bp)
        movb        -6(%bp), %al
        cmpb        -5(%bp), %al
        jne        .L23
        jmp        .L20
.L23:
.L22:
        subw        $1, -4(%bp)
        sbbw        $0, -2(%bp)
        movw        -2(%bp), %dx
        movw        -4(%bp), %ax
        orw        %ax, %dx
        jne        .L24
        movw        $1, %ax
        jmp        .L12
.L24:
.L19:
        jmp        .L21
.L20:
        movb        -6(%bp), %al
        shlb        $1, %al
        andb        $240, %al
        movw        4(%bp), %bx
        orb        %al, (%bx)
        xorw        %ax, %ax
        movw        $888, %dx
        outb        %al, %dx
        jmp        .L12
.L12:
        movw        %bp, %sp
        popw        %bp
        ret

能够收发字符还不行,作为协议,总得知道数据的起始和结束,也应该进行简单的检错。这里采用
字符填充方式进行数据包编码,用‘/’表示转义字符,数据包头用/H表示,数据包结束用/T表示
如果数据中有'/',则用//表示(从printf的格式串中学来的),数据包后面跟一个字节的校验和,
这样就可以收发数据包了,具体程序如下:

int rcvpack(unsigned char * pData, int * pLength)
{
        int ret;
        int length;
        unsigned char checksum;
        int maxlength;
        int status;
        maxlength = *pLength + 1;
        if (maxlength<=0)
                return FAIL;
        if (pData == NULL)
                return FAIL;
        checksum = 0;
        length = 0;
        status = 0;
        while (1)
        {
                unsigned char ch;
                int count;
                count = 10;
                while (1)
                {
                if ((ret = rcvbyte(&ch)) != OK)
                {
                        count--;
                        if (count==0)
                        {
                                printf("/nReceive byte timeout/n");
                                return ret;
                        }
                }
                        else
                                break;
                }
                switch (status)
                {
                        case 0:
                        {
                                if (ch == '//')
                                {
                                        status = 1;
                                }
                        }
                        break;
                        case 1:
                        {
                                if (ch == 'H')
                                        status = 2;
                                else
                                        status = 0;
                        }
                        break;
                        case 2:
                        {
                                if (ch == '//')
                                {
                                        status = 3;
                                }
                                else
                                {
                                        length ++;
                                        if (length>maxlength)
                                        {
                                                printf("Buffer overflow(%d>%d)/n", length, maxlength);
                                                return FAIL;
                                        }
                                        *pData++ = ch;
                                        checksum += ch;
                                }
                        }
                        break;
                        case 3:
                        {
                                if (ch == '//')
                                {
                                    length++;
                                    if (length>maxlength)
                                    {
                                        printf("Buffer overflow (%d>%d)/n", length, maxlength);
                                        return FAIL;
                                    }
                                    checksum += ch;
                                    *pData++ = ch;
                                    status = 2;
                                }
                                else
                                if (ch =='T')
                                {
                                        unsigned char chk;
                                        *pLength = length;
                                        if (rcvbyte(&chk)!=OK)
                                                return FAIL;
                                        if (checksum==chk)
                                        {
                                                return OK;
                                        }
                                        else
                                        {
                                                printf("ERROR: Checksum is nozero(%d-%d)/n", checksum,chk);
                                                return FAIL;
                                        }
                                }
                                else
                                {
                                        printf("ERROR: a '//' or 'T' expected('%c')!/n ", ch);
                                        return FAIL;
                                }
                        }
                }
        }
}


int sendpack(unsigned char * pData, int length)
{
        int ret;
        unsigned char checksum;
        checksum = 0;
        if (length<=0)
                return OK;
        if ((ret = sendbyte('//')) != OK)
                return 1;
        if ((ret = sendbyte('H')) != OK)
                return 2;
        while (length>0)
        {
                unsigned char ch;
                ch = *pData++;
                checksum += ch;
                if ((ret = sendbyte(ch)) != OK)
                        return 3;
                if (ch == '//')
                {
                        if ((ret = sendbyte(ch)) != OK)
                                return 4;
                }
                length--;
        }

        if ((ret = sendbyte('//')) != OK)
                return 5;
        if ((ret = sendbyte('T')) != OK)
                return 6;
        if ((ret = sendbyte(checksum)) != OK)
                return 7;
        return OK;
}

同样,也将rcvpack改成AT&T汇编(减少了几个printf语句):

chbuffer:
        .byte 0
overflow:
        .string "Buffer overflow..."
rcvpack:
        pushw        %bp
        movw        %sp, %bp
        subw        $12, %sp
        pushw        %si
        movw        4(%bp), %si
        movw        6(%bp), %bx
        movw        (%bx), %ax
        incw         %ax
        movw        %ax, -6(%bp)
        cmpw        $0, -6(%bp)
        jg        .L26
        leaw        overflow, %si
        call        prtstr
        movw        $2, %ax
        jmp        .L25
.L26:
        orw        %si, %si
        jne        .L27
        movw        $2, %ax
        jmp        .L25
.L27:
        movb        $0,-8(%bp)
        movw        $0, -10(%bp)
        movw        $0, -4(%bp)
        jmp        .L28
.L30:
        movw        $10, -2(%bp)
        jmp        .L31
.L33:
#        movw        -4(%bp), %ax
#        addb        $'0', %al
#        call        prtchr
        leaw        chbuffer, %ax
        pushw        %ax
        call        rcvbyte
        popw        %cx
        movw        %ax, -12(%bp)
        orw         %ax, %ax
        je        .L34
        decw        -2(%bp)
        cmpw        $0, -2(%bp)
        jne        .L35
        movw        -12(%bp), %ax
        jmp        .L25
.L35:
        jmp        .L36
.L34:
        jmp        .L32
.L36:
.L31:
        jmp        .L33
.L32:
        pushw        %si
        leaw        chbuffer, %si
        movb        (%si), %al
        movb        %al, -7(%bp)
        popw        %si
#        call        prtchr
        movw         -4(%bp), %ax
        cmpw        $3, %ax
        jbe        .L58
        jmp        .L56
.L58:
        cmpw        $0, %ax
        je        .L38
        cmpw        $1, %ax
        je        .L40
        cmpw        $2, %ax
        je        .L43
        cmpw        $3, %ax
        je        .L47
        jmp        .L56
.L38:
        cmpb        $92, -7(%bp)
        jne        .L39
        movw        $1, -4(%bp)
.L39:
        jmp         .L37
.L40:
        cmpb        $72, -7(%bp)
        jne        .L41
        movw        $2, -4(%bp)
        jmp        .L42
.L41:
        movw        $0, -4(%bp)
.L42:
        jmp        .L37
.L43:
        cmpb        $92, -7(%bp)
        jne        .L44
        movw        $3, -4(%bp)
        jmp         .L45
.L44:
        incw        -10(%bp)
        movw        -10(%bp), %ax
        cmpw        -6(%bp), %ax
        jle        .L46
        movw        $2, %ax
        jmp        .L25
.L46:
        movb        -7(%bp), %al
        movb        %al, (%si)
        incw        %si
        movb         -7(%bp), %al
        addb        %al, -8(%bp)
.L45:
        jmp        .L37
.L47:
        cmpb        $92, -7(%bp)
        jne        .L48
        incw        -10(%bp)
        movw        -10(%bp), %ax
        cmpw        -6(%bp), %ax
        jle        .L49
        movw        $2, %ax
        jmp        .L25
.L49:
        movb        -7(%bp), %al
        addb        %al, -8(%bp)
        movb        -7(%bp), %al
        movb        %al, (%si)
        incw        %si
        movw        $2, -4(%bp)
        jmp        .L50
.L48:
        cmpb        $84, -7(%bp)
        jne        .L51
        movw        -10(%bp), %ax
        movw        6(%bp), %bx
        movw        %ax, (%bx)
        leaw        chbuffer, %ax
        pushw        %ax
        call        rcvbyte
        popw        %cx
        orw        %ax, %ax
        je        .L52
        movw        $2, %ax
        jmp        .L25
.L52:
        movb        -8(%bp), %al
        cmpb        chbuffer, %al
        jne        .L53
        xorw        %ax, %ax
        jmp        .L25
        jmp        .L54
sChecksumFailed:
        .string "Checksum error!"
.L53:
        leaw        sChecksumFailed, %si
        call         prtstr
        movw        $2, %ax
        jmp        .L25
.L54:
        jmp        .L55
.L51:
        movw        $2, %ax
        jmp        .L25
.L55:
.L50:
.L56:
.L37:
.L28:
        jmp         .L30
.L29:
.L25:
        popw        %si
        movw        %bp, %sp
        popw        %bp
        ret

好了,万事具备了,先用上面的c代码写另外一台计算机上的“服务”程序(也用来测试),这台
计算机运行DOS,用TURBO C 2.0编译运行:
运行时将initrd.img和内核编译后的/usr/src/linux/arch/i386/boot/compressed/bvmlinux.out
拷贝到该计算机的c:/下,然后带参数 s c:/bvmlinux.out c:/initrd.img运行即可。
至于启动程序,还得进行少许修改,才能烧到boot rom 中,见后面的说明。

int main(int argc, char* argv[])
{
        FILE* pFile;
        int count = 2;
        if (argc<3)
        {
                printf("Usage testspp [s | r] /n");
                return 1;
        }
        while(count        {
        if (argv[1][0] == 's')
                pFile = fopen(argv[count], "rb");
        else
                pFile = fopen(argv[count], "wb");
        if (pFile==NULL)
        {
                printf("Can't open/create file %s/n", argv[2]);
                return 2;
        }
        if (argv[1][0]=='r')/*receive*/
        {
                unsigned long filesize;
                char buffer[10244];
                int length;
                /*get filelength */
                length = 10244;

                printf("Receiving filesize package/n");
                while( (rcvpack(buffer, &length)!=OK) && (length!=4))
                        length = 10244;
                filesize = *(long*)buffer;
                printf("file size is:%ld/n", filesize);

                while (filesize>0)
                {
                        length = 10244;
                        if (rcvpack(buffer, &length) != OK)
                        {
                                printf("Receive data package failed/n");
                                return 0;
                        }
                        if (length>0)
                                fwrite(buffer, 1, length, pFile);
                        filesize-=length;
                        printf("/r%ld Bytes Left         ", filesize);
                }
        }
        else/*send*/
        {
                unsigned long filesize;
                /*send file length*/
                unsigned long stemp;
                int ret;
                fseek(pFile, 0, 2);
                filesize = ftell(pFile);
                fseek(pFile, 0, 0);
                printf("/nfile size is:%ld/n", filesize);
                /*
                while ((ret = sendpack((char *)&filesize, 4)) != OK)
                {
                        printf("send file size failed(%d)/n", ret);
                }
                */
                while (filesize>0)
                {
                        char buffer[10240];
                        long size;
                        int ret;
                        size = fread(buffer, 1, 10240, pFile);
                        if ((ret = sendpack(buffer, size)) != OK)
                        {
                                printf("Send data package failed(%d)/n", ret);
                                return 0;
                        }
                        filesize -= size;
                        printf("/r/t%ld Bytes Left", filesize);
                }
        }
        fclose(pFile);
        count++;
        }/*while*/
        return 0;
}

5、对bootsect.S的修改
   目前的bootsect.S ,主要的问题是,它是从软盘上读数据,将这些代码换成对rcvpack的调用即可,
另外,它不支持调入initrd,应该增加相应的代码。问题在于,bootsect.S中没有那么多空间来放rcvpack
相关的代码(毕竟只有512字节,当然,如果烧在boot rom中,就不存在这个问题了,但是用软盘调试时
就不行了,因此干脆编制load_kernel和load_initrd放在setup.S中,然后在bootsect.S中进行回调即可。
bootsect.S 修改如下(只给出修改部分):
.....
.....
ok_load_setup:
        call        kill_motor
        call        print_nl
# Now we will load kernel and initrd
loading:
# 先打印Loading字符
        movw        $INITSEG, %ax
        movw        %ax, %es                # set up es
        movb        $0x03, %ah                # read cursor pos
        xorb        %bh, %bh
        int        $0x10
        movw        $22, %cx
        movw        $0x0007, %bx                # page 0, attribute 7 (normal)
        movw    $msg1, %bp
        movw    $0x1301, %ax                # write string, move cursor
        int        $0x10                        # tell the user we're loading..
load_kernel_img:
# 将load_kernel函数的指针放到0x22C处这里进行调用就行了(软盘启动过程中,此前已经将setup.S
# 从磁盘上调到bootsect.S,即0x0200之后,注意setup.S的头部是一张表,这里“提前”消费了)
# 0x22C is the load kernel routine
        bootsect_readimage = 0x22C
        lcall        bootsect_readimage
load_initrd_img:
# 将load_initrd函数的指针放到0x220处
# 0x220 if the load initrd routine
        bootsect_readinitrd = 0x220
        lcall        bootsect_readinitrd

# After that (everything loaded), we jump to the setup-routine
# loaded directly after the bootblock:
        ljmp        $SETUPSEG, $0
......
......
6、对setup.S的修改
   对setup.S进行修改,主要是:修改setup.S头部,增加load_kernel和load_initrd函数等,具体如下。
    修改setup.S头部如下(为好看,这里删除了原来的部分注释):

start:
                        jmp        trampoline
                        .ascii        "HdrS"                # header signature
                        .word        0x0202                # header version number (>= 0x0105)
realmode_swtch:        .word        0, 0                # default_switch, SETUPSEG
start_sys_seg:        .word        SYSSEG
                        .word        kernel_version        # pointing to kernel version string
type_of_loader:        .byte        0
loadflags:
LOADED_HIGH        = 1
                        .byte        LOADED_HIGH   # 只支持bzImage
setup_move_size:         .word  0x8000
code32_start:                                # here loaders can put a different
                        .long        0x100000        # 0x100000 = default for big kernel
ramdisk_image:        .long        0xB00000        # ramdisk 调到12M处
ramdisk_size:                .long        0                # 由load_initrd来设置长度
bootsect_kludge:
                        .word  load_initrd, SETUPSEG #0x220, 放置load_initrd函数的指针
heap_end_ptr:                .word        modelist+1024        pad1:                .word        0
cmd_line_ptr:                .long 0
load_kernel_call:
                        .word  load_kernel, SETUPSEG
trampoline:                call        start_of_setup

                        .space        1024

load_kernel和load_initrd:

load_imsg:
        .byte 13, 10
        .string "Load INITRD from PARPort(378)"
load_kmsg:
        .byte 13, 10
        .string        "Load Kernel From PARPort(378)"
reading_suc:
        .string        "."
reading_failed:
        .string " failed"
read_len:
        .word 0, 0
read_total:
        .word 0, 0
read_buffer:
        # 如何在AT&T语法中完成intel语法中的 db 1280 dup(0),那位请指教
        # AT&T汇编的语法何处寻?
        .string "012345678901234567890123456789012345678901234567890123456789"
        .string "012345678901234567890123456789012345678901234567890123456789"
        .string "012345678901234567890123456789012345678901234567890123456789"
        .string "012345678901234567890123456789012345678901234567890123456789"
        .string "012345678901234567890123456789012345678901234567890123456789"
        .string "012345678901234567890123456789012345678901234567890123456789"
        .string "012345678901234567890123456789012345678901234567890123456789"
        .string "012345678901234567890123456789012345678901234567890123456789"
        .string "012345678901234567890123456789012345678901234567890123456789"
        .string "012345678901234567890123456789012345678901234567890123456789"
        .string "012345678901234567890123456789012345678901234567890123456789"
        .string "012345678901234567890123456789012345678901234567890123456789"
        .string "012345678901234567890123456789012345678901234567890123456789"
        .string "012345678901234567890123456789012345678901234567890123456789"
        .string "012345678901234567890123456789012345678901234567890123456789"
        .string "012345678901234567890123456789012345678901234567890123456789"
        .string "012345678901234567890123456789012345678901234567890123456789"
        .string "012345678901234567890123456789012345678901234567890123456789"
        .string "012345678901234567890123456789012345678901234567890123456789"
        .string "012345678901234567890123456789012345678901234567890123456789"

load_initrd:
        pushw        %ds
        pushw        %es
        pushw        %cs
        popw        %ds
        pushw        %cs
        popw        %es
        cld
        leaw        load_imsg, %si
        call        prtstr                                # 打印提示
        movw        $0x1000, %ax
        movw        %ax, %es
        xorw        %bx, %bx
        movw        $0x00B0, %ax                        # initrd数据先调到0x1000:0000处,
                                                # 满64K即移动到12M(0xB00000)处
        movw        %ax, %fs
        movw        $0, %cs:move_es
        movl        $0, %cs:read_total
        call        movetohigh                        # 初始化数据移动部分
        call        .ld_img                        # 从并口上读入一个文件并移动到指定位置
        movl        %cs:read_total, %eax
        movl        %eax, %cs:ramdisk_size        # 设置ramdisk_size和ramdisk_image
        movl        $0x00B00000, %eax
        movl        %eax, %cs:ramdisk_image
        popw        %es
        popw        %ds
        lret

load_kernel:
        pushw        %ds
        pushw        %es
        pushw        %cs
        popw        %ds
        pushw   %cs
        popw        %es
        cld
        leaw        load_kmsg, %si
        call        prtstr
        movw        $0x1000, %ax
        movw        %ax, %es
        xorw        %bx, %bx
        movw        $0x0010, %ax
        movw        %ax, %fs
        movw        $0, %cs:move_es
        movl        $0, %cs:read_total
        call        movetohigh
        call        .ld_img
        popw        %es
        popw        %ds
        lret

.ld_img:
.ld_nextpack:
        pushw        %bx
        pushw        %es
        leaw         read_len, %si
        movw        $1124, %ax
        movw        %ax, (%si)
        pushw        %si
        leaw        read_buffer, %ax
        pushw        %ax
        movw        %bx, %ax
        call        rcvpack                # 调用rcpack接收一个数据包read_buffer中
        popw        %cx
        popw        %cx
        popw        %es
        popw        %bx
        cmpw        $0, %ax                # 成功?
        je        .ld_suc
        leaw        reading_failed, %si
        call        prtstr
.ld_panic:
        jmp        .ld_panic                # 失败则死循环
.ld_suc:
        leaw        read_buffer, %si
        movw        %bx, %di
        movw        $256, %cx                # move 1024 bytes
        rep
        movsl                                # 从read_buffer移动到es:bx处,强制假定一个数据包长度
                                        # 就是1024字节,最后一个数据包除外。
        addw        $1024, %bx                # 更新bx, 如果bx加到零,则表示已经满64K,后面的调用中
        call         movetohigh                # 进行实际的数据移动
        movw        %ax, %dx                #
        cmpw        $0, %ax                # 如果进行了64K数据移动,就打印一个'.'
        je        .ld_1
        leaw        reading_suc, %si
        call         prtstr
.ld_1:
        leaw        read_len, %si
        xorl        %eax, %eax
        movw        (%si), %ax
        addl        %eax, %cs:read_total
        cmpw        $1024, %ax                 # 更新收到数据总字节数,如果收到的字节数少于1024,则表示
                                        # 收到最后一个数据包,这得冒点风险,万一最后一个数据包刚好
                                        # 是1024字节,怎么办好呢?赌一把吧!
        jb        .ld_lastestpack
        jmp        .ld_nextpack                # 接着接收下一个数据包
.ld_lastestpack:
        # 最后一个数据包收到后,不见得满64K,此时应该强制数据移动
        cmpw        $0, %dx
        jne        .ld_exit
        xorw        %bx, %bx
        call        movetohigh
.ld_exit:
        ret

7、用软盘进行调试,将启动程序烧到bootrom中
        好了,大功告成,对内核进行配置,然后make bzImage,将bvmlinux.out拷贝到“服务器”上,建立
initrd也放在“服务器”上,然后放张软盘在软驱中,dd if=/usr/src/linux/arch/i386/boot/bzImage of=
/dev/fd0 count=32将bootsect.S+setup.S部分拷贝到软盘上,重新启动(先连接好并口线)。启动后再在
“服务器”上启动文件“服务”程序,终于可以将Linux从并口上启动了!
        做少量调整(主要是去掉读setup.S部分的代码),即可以将此bzImage的前8(16?)K写在一个文件中,
处理成boot rom映象,烧到boot rom中,插到网络卡上,启动机器即可。这就是用网络卡从并口上启动Linux。

 

 

标题   Re: 用网络卡从并口上启动Linux(I386) [re: raoxianhong]
作者 raoxianhong (journeyman)
时间 10/09/01 11:30 AM

 

网络上说可以将Bootrom写到BIOS中去,但是没有实验成功,不知道有什么讲究,哪位可曾试过?
寻找文件 cbrom.pdf

 

 


标题   推荐两篇讲述启动过程的文章 [re: feiyunw]
作者 raoxianhong (journeyman)
时间 10/11/01 09:08 AM

 

http://www.pcguide.com/ref/mbsys/bios/boot.htm
http://www2.csa.iisc.ernet.in/~kvs/LinuxBoot.html

 

 


标题   Re: 386 boot代码分析 [re: feiyunw]
作者 raoxianhong (member)
时间 10/25/01 05:09 PM
附加文件 181431-bootrom.zip

 

有几位老兄Mail问网卡启动的启动代码问题,这里总结如下:
1.系统自检完毕后在ROM空间中找(好象是2Kbytes为单位),如果某一段的前两表字节是0x55AA,那么第三个字节作为ROM程序的大小(512字节为单位)。然后将该段空间中的所有字节相加(计算校验和),结果为零时表示ROM程序有效。此时BIOS用一个长调用(lcall),调用该块的第四个字节起始处(自然该用lret返回)。
2.有个问题原来一直不明白,如果此时某个启动网卡启动系统,但是后面还有带ROM的卡(比如PCI),那么该段ROM程序岂不是没有机会运行了吗,当然,如果不运行任何设备的扩展ROM,不知道Linux内会不会有问题!后来查资料得知,实际上制作网卡启动程序时还没有这么简单。
3.事实上,系统在自检及运行所有的扩展硬件检测之后,是用int 19h启动操作系统的!因此在扩展ROM中不直接启动操作系统,而是将操作系统启动代码作为int 19h的中断调用(其实也不用返回,操作系统没有必要返回)代码就行了。
明白这一点后,制作一个网卡启动程序就容易多了,具体请看某个网卡的启动源代码即可,附件中有一个,记不住是从哪里抄来的了!

 

 


标题   通用的网络卡bootrom处理程序 [re: feiyunw]
作者 raoxianhong (member)
时间 12/06/01 08:05 PM

 

Bootrom写好后要进行一些处理才能烧到EPROM中去。这里提供一段代码可以完成这个功能,上面讲的用并口启动Linux的程序就是这么处理的。
基本的想法是,写一个通用的启动代码载入程序(stub),将bootsect.S+setup.S(也就是bzImage的前面一段)设置成0x19号中断的中断向量。在外面写一段代码将该段代码和启动代码进行合并,生成合法的bootrom映象就,可以烧到bootrom中去,在网络卡上启动。

下面是通用的启动代码载入程序:

 

.code16
RomHeader:
        .byte 0x55, 0xaa #启动ROM标志
RomPageCount:
        .byte 0x20  #假定bootrom是16K bytes

RomCode:
        pushw %es
        pushw %bx
        pushw %ax

        movb  $0xc1, %al
        call  IntVectAddr
        movw  $0x6a6e, %ax
        cmpw  %es:(%bx), %ax
        jz    RomBootInit_x
        movw  %ax, %es:(%bx)
        movw  $0xc019, %ax
        call  MoveIntVector
        movw  $RomBootVect, %bx
        pushw %cs
        popw  %es
        call  SetIntVector
RomBootInit_x:
        popw  %ax
        popw  %bx
        popw  %es
        lret

IntVectAddr:
        xorw        %bx,%bx
        movw        %bx,%es
        movb        %al,%bl
        addw        %bx,%bx
        addw        %bx,%bx
        ret

GetIntVector:
        call        IntVectAddr
GetIntVect_1:
                     les        %es:(%bx), %bx
        ret

SetIntVector:
        pushf                        #; entry AL=vector to set, ES:BX=value
        pushw        %es                #; exit: vector modified
        pushw        %bx                #; all registers preserved
        call        IntVectAddr
        cli
        popw        %es:(%bx)
        addw        $2, %bx
        popw        %es:(%bx)
        subw        $2, %bx
        popf
        jmp        GetIntVect_1

MoveIntVector:
        call        GetIntVector        #; entry AL=vect to get, AH=vect to set
        xchgb        %al,%ah                #; exit: vector set, ES:BX=vector value
        call        SetIntVector        #; other registers preserved
        xchgb        %al,%ah
        ret

RomBootVect:
        pushw   %cs
        popw        %ds
        movw        $0x07c0, %ax
        movw        %ax, %es
        movw        $BootCode, %si
        subw        %di, %di
        movw        $8192, %cx
        cld
        rep
        movsw
        ljmp        $0x07c0, $0
        lret

.org        0x0200
BootCode:

 


在Linux下的编译方法与bootsect.S的编译方法一样,编译成可执行文件后,比如放在bootx文件中。
内核编译后(make bzImage,支持上面所说的启动方式),得到bzImage文件。

下面是将这两个文件复合在一起得到bootrom映象的程序:


/* mkbtrom.c */

int main(int argc, char* argv[])
{
        char buf[16384];
        char ch;
        int i;
        if (argc<4)
        {
                printf("Usage: mkbtrom   /n");
                return 1;
        }
        FILE * pFile;
        pFile = fopen(argv[1], "rb");
        if (pFile==NULL)
        {
                printf("File %s open failed/n", argv[1]);
                return 2;
        }
        fread(buf, 1, 512, pFile);
        fclose(pFile);
        pFile = fopen(argv[2], "rb");
        if (pFile==NULL)
        {
                printf("File %s open failed/n", argv[2]);
                return 2;
        }
        fread(&buf[512], 1, 16384-512-1, pFile);
        fclose(pFile);
        ch = 0;
        for (i = 0;i<18383;i++)
                ch += buf[ i ];
        buf[16383] = -ch;
        pFile = fopen(argv[3], "wb");
        fwrite(buf, 1, 16384, pFile);
        fclose(pFile);
        return 0;
}

编译成执行文件后,运行mkbtrom bootx bzImage boot16k.bin后,boot16k.bin就可以烧到eprom中,从网络卡中启动了。

[目录]


内核解压


概述

----

1) Linux的初始内核映象以gzip压缩文件的格式存放在zImage或bzImage之中, 内核的自举

代码将它解压到1M内存开始处. 在内核初始化时, 如果加载了压缩的initrd映象, 内核会将

它解压到内存盘中, 这两处解压过程都使用了lib/inflate.c文件.

 

2) inflate.c是从gzip源程序中分离出来的, 包含了一些对全局数据的直接引用, 在使用时

需要直接嵌入到代码中. gzip压缩文件时总是在前32K字节的范围内寻找重复的字符串进行

编码, 在解压时需要一个至少为32K字节的解压缓冲区, 它定义为window[WSIZE].

inflate.c使用get_byte()读取输入文件, 它被定义成宏来提高效率. 输入缓冲区指针必须

定义为inptr, inflate.c中对之有减量操作. inflate.c调用flush_window()来输出window

缓冲区中的解压出的字节串, 每次输出长度用outcnt变量表示. 在flush_window()中, 还必

须对输出字节串计算CRC并且刷新crc变量.  在调用gunzip()开始解压之前, 调用makecrc()

初始化CRC计算表. 最后gunzip()返回0表示解压成功.

 

3) zImage或bzImage由16位引导代码和32位内核自解压映象两个部分组成. 对于zImage, 内

核自解压映象被加载到物理地址0x1000, 内核被解压到1M的部位. 对于bzImage, 内核自解

压映象被加载到1M开始的地方, 内核被解压为两个片段, 一个起始于物理地址0x2000-0x90000,

另一个起始于高端解压映象之后, 离1M开始处不小于低端片段最大长度的区域. 解压完成后,

这两个片段被合并到1M的起始位置.

 

解压根内存盘映象文件的代码

--------------------------

 

; drivers/block/rd.c

#ifdef BUILD_CRAMDISK

 

/*

* gzip declarations

*/

 

#define OF(args)  args        ; 用于函数原型声明的宏

 

#ifndef memzero

#define memzero(s, n)     memset ((s), 0, (n))

#endif

 

typedef unsigned char  uch;        定义inflate.c所使用的3种数据类型

typedef unsigned short ush;

typedef unsigned long  ulg;

 

#define INBUFSIZ 4096                用户输入缓冲区尺寸

#define WSIZE 0x8000    /* window size--must be a power of two, and */

                        /*  at least 32K for zip's deflate method */

 

static uch *inbuf;        用户输入缓冲区,与inflate.c无关

static uch *window;        解压窗口

 

static unsigned insize;  /* valid bytes in inbuf */

static unsigned inptr;   /* index of next byte to be processed in inbuf */

static unsigned outcnt;  /* bytes in output buffer */

static int exit_code;

static long bytes_out;        总解压输出长度,与inflate.c无关

static struct file *crd_infp, *crd_outfp;

 

#define get_byte()  (inptr

/* Diagnostic functions (stubbed out) */ 一些调试宏

#define Assert(cond,msg)

#define Trace(x)

#define Tracev(x)

#define Tracevv(x)

#define Tracec(c,x)

#define Tracecv(c,x)

 

#define STATIC static

 

static int  fill_inbuf(void);

static void flush_window(void);

static void *malloc(int size);

static void free(void *where);

static void error(char *m);

static void gzip_mark(void **);

static void gzip_release(void **);

 

#include "../../lib/inflate.c"

 

static void __init *malloc(int size)

{

        return kmalloc(size, GFP_KERNEL);

}

 

static void __init free(void *where)

{

        kfree(where);

}

 

static void __init gzip_mark(void **ptr)

{

        ; 读取用户一个标记

}

 

static void __init gzip_release(void **ptr)

{

        ; 归还用户标记

}

 

 

/* ===========================================================================

* Fill the input buffer. This is called only when the buffer is empty

* and at least one byte is really needed.

*/

static int __init fill_inbuf(void) 填充输入缓冲区

{

        if (exit_code) return -1;

 

        insize = crd_infp->f_op->read(crd_infp, inbuf, INBUFSIZ,

 

        if (insize == 0) return -1;

 

        inptr = 1;

 

        return inbuf[0];

}

 

/* ===========================================================================

* Write the output window window[0..outcnt-1] and update crc and bytes_out.

* (Used for the decompressed data only.)

*/

static void __init flush_window(void) 输出window缓冲区中outcnt个字节串

{

    ulg c = crc;         /* temporary variable */

    unsigned n;

    uch *in, ch;

 

    crd_outfp->f_op->write(crd_outfp, window, outcnt,

    in = window;

    for (n = 0; n             ch = *in++;

            c = crc_32_tab[((int)c ^ ch)  0xff] ^ (c >> 8); 计算输出串的CRC

    }

    crc = c;

    bytes_out += (ulg)outcnt; 刷新总字节数

    outcnt = 0;

}

 

static void __init error(char *x) 解压出错调用的函数

{

        printk(KERN_ERR "%s", x);

        exit_code = 1;

}

 

static int __init

crd_load(struct file * fp, struct file *outfp)

{

        int result;

 

        insize = 0;                /* valid bytes in inbuf */

        inptr = 0;                /* index of next byte to be processed in inbuf */

        outcnt = 0;                /* bytes in output buffer */

        exit_code = 0;

        bytes_out = 0;

        crc = (ulg)0xffffffffL; /* shift register contents */

 

        crd_infp = fp;

        crd_outfp = outfp;

        inbuf = kmalloc(INBUFSIZ, GFP_KERNEL);

        if (inbuf == 0) {

                printk(KERN_ERR "RAMDISK: Couldn't allocate gzip buffer/n");

                return -1;

        }

        window = kmalloc(WSIZE, GFP_KERNEL);

        if (window == 0) {

                printk(KERN_ERR "RAMDISK: Couldn't allocate gzip window/n");

                kfree(inbuf);

                return -1;

        }

        makecrc();

        result = gunzip();

        kfree(inbuf);

        kfree(window);

        return result;

}

 

#endif  /* BUILD_CRAMDISK */

 

 

32位内核自解压代码

------------------

 

; arch/i386/boot/compressed/head.S

.text

 

#include ·

#include

 

        .globl startup_32        对于zImage该入口地址为0x1000; 对于bzImage为0x101000

 

startup_32:

        cld

        cli

        movl $(__KERNEL_DS),%eax

        movl %eax,%ds

        movl %eax,%es

        movl %eax,%fs

        movl %eax,%gs

 

        lss SYMBOL_NAME(stack_start),%esp        # 自解压代码的堆栈为misc.c中定义的16K字节的数组

        xorl %eax,%eax

1:        incl %eax                # check that A20 really IS enabled

        movl %eax,0x000000        # loop forever if it isn't

        cmpl %eax,0x100000

        je 1b

 

/*

* Initialize eflags.  Some BIOS's leave bits like NT set.  This would

* confuse the debugger if this code is traced.

* XXX - best to initialize before switching to protected mode.

*/

        pushl $0

        popfl

/*

* Clear BSS        清除解压程序的BSS段

*/

        xorl %eax,%eax

        movl $ SYMBOL_NAME(_edata),%edi

        movl $ SYMBOL_NAME(_end),%ecx

        subl %edi,%ecx

        cld

        rep

        stosb

/*

* Do the decompression, and jump to the new kernel..

*/

        subl $16,%esp        # place for structure on the stack

        movl %esp,%eax

        pushl %esi        # real mode pointer as second arg

        pushl %eax        # address of structure as first arg

        call SYMBOL_NAME(decompress_kernel)

        orl  %eax,%eax        # 如果返回非零,则表示为内核解压为低端和高端的两个片断

        jnz  3f

        popl %esi        # discard address

        popl %esi        # real mode pointer

        xorl %ebx,%ebx

        ljmp $(__KERNEL_CS), $0x100000        # 运行start_kernel

 

/*

* We come here, if we were loaded high.

* We need to move the move-in-place routine down to 0x1000

* and then start it with the buffer addresses in registers,

* which we got from the stack.

*/

3:

        movl $move_routine_start,%esi

        movl $0x1000,%edi

        movl $move_routine_end,%ecx

        subl %esi,%ecx

        addl $3,%ecx

        shrl $2,%ecx        # 按字取整

        cld

        rep

        movsl        # 将内核片断合并代码复制到0x1000区域, 内核的片段起始为0x2000

 

        popl %esi        # discard the address

        popl %ebx        # real mode pointer

        popl %esi        # low_buffer_start  内核低端片段的起始地址

        popl %ecx        # lcount                  内核低端片段的字节数量

        popl %edx        # high_buffer_start 内核高端片段的起始地址

        popl %eax        # hcount                  内核高端片段的字节数量

        movl $0x100000,%edi                  内核合并的起始地址

        cli                # make sure we don't get interrupted

        ljmp $(__KERNEL_CS), $0x1000 # and jump to the move routine

 

/*

* Routine (template) for moving the decompressed kernel in place,

* if we were high loaded. This _must_ PIC-code !

*/

move_routine_start:

        movl %ecx,%ebp

        shrl $2,%ecx

        rep

        movsl                        # 按字拷贝第1个片段

        movl %ebp,%ecx

        andl $3,%ecx

        rep

        movsb                        # 传送不完全字

        movl %edx,%esi

        movl %eax,%ecx        # NOTE: rep movsb won't move if %ecx == 0

        addl $3,%ecx

        shrl $2,%ecx        # 按字对齐

        rep

        movsl                        # 按字拷贝第2个片段

        movl %ebx,%esi        # Restore setup pointer

        xorl %ebx,%ebx

        ljmp $(__KERNEL_CS), $0x100000        # 运行start_kernel

move_routine_end:

 

; arch/i386/boot/compressed/misc.c

 

/*

* gzip declarations

*/

 

#define OF(args)  args

#define STATIC static

 

#undef memset

#undef memcpy

#define memzero(s, n)     memset ((s), 0, (n))

 

typedef unsigned char  uch;

typedef unsigned short ush;

typedef unsigned long  ulg;

 

#define WSIZE 0x8000                /* Window size must be at least 32k, */

                                /* and a power of two */

 

static uch *inbuf;             /* input buffer */

static uch window[WSIZE];    /* Sliding window buffer */

 

static unsigned insize = 0;  /* valid bytes in inbuf */

static unsigned inptr = 0;   /* index of next byte to be processed in inbuf */

static unsigned outcnt = 0;  /* bytes in output buffer */

 

/* gzip flag byte */

#define ASCII_FLAG   0x01 /* bit 0 set: file probably ASCII text */

#define CONTINUATION 0x02 /* bit 1 set: continuation of multi-part gzip file */

#define EXTRA_FIELD  0x04 /* bit 2 set: extra field present */

#define ORIG_NAME    0x08 /* bit 3 set: original file name present */

#define COMMENT      0x10 /* bit 4 set: file comment present */

#define ENCRYPTED    0x20 /* bit 5 set: file is encrypted */

#define RESERVED     0xC0 /* bit 6,7:   reserved */

 

#define get_byte()  (inptr

/* Diagnostic functions */

#ifdef DEBUG

#  define Assert(cond,msg) {if(!(cond)) error(msg);}

#  define Trace(x) fprintf x

#  define Tracev(x) {if (verbose) fprintf x ;}

#  define Tracevv(x) {if (verbose>1) fprintf x ;}

#  define Tracec(c,x) {if (verbose  (c)) fprintf x ;}

#  define Tracecv(c,x) {if (verbose>1  (c)) fprintf x ;}

#else

#  define Assert(cond,msg)

#  define Trace(x)

#  define Tracev(x)

#  define Tracevv(x)

#  define Tracec(c,x)

#  define Tracecv(c,x)

#endif

 

static int  fill_inbuf(void);

static void flush_window(void);

static void error(char *m);

static void gzip_mark(void **);

static void gzip_release(void **);

 

/*

* This is set up by the setup-routine at boot-time

*/

static unsigned char *real_mode; /* Pointer to real-mode data */

 

#define EXT_MEM_K   (*(unsigned short *)(real_mode + 0x2))

#ifndef STANDARD_MEMORY_BIOS_CALL

#define ALT_MEM_K   (*(unsigned long *)(real_mode + 0x1e0))

#endif

#define SCREEN_INFO (*(struct screen_info *)(real_mode+0))

 

extern char input_data[];

extern int input_len;

 

static long bytes_out = 0;

static uch *output_data;

static unsigned long output_ptr = 0;

 

 

static void *malloc(int size);

static void free(void *where);

static void error(char *m);

static void gzip_mark(void **);

static void gzip_release(void **);

 

static void puts(const char *);

 

extern int end;

static long free_mem_ptr = (long)

static long free_mem_end_ptr;

 

#define INPLACE_MOVE_ROUTINE  0x1000        内核片段合并代码的运行地址

#define LOW_BUFFER_START      0x2000        内核低端解压片段的起始地址

#define LOW_BUFFER_MAX       0x90000        内核低端解压片段的终止地址

#define HEAP_SIZE             0x3000        为解压低码保留的堆的尺寸,堆起始于BSS的结束

static unsigned int low_buffer_end, low_buffer_size;

static int high_loaded =0;

static uch *high_buffer_start /* = (uch *)(((ulg) + HEAP_SIZE)*/;

 

static char *vidmem = (char *)0xb8000;

static int vidport;

static int lines, cols;

 

#include "../../../../lib/inflate.c"

 

static void *malloc(int size)

{

        void *p;

 

        if (size         if (free_mem_ptr

        free_mem_ptr = (free_mem_ptr + 3)  ~3;        /* Align */

 

        p = (void *)free_mem_ptr;

        free_mem_ptr += size;

 

        if (free_mem_ptr >= free_mem_end_ptr)

                error("/nOut of memory/n");

 

        return p;

}

 

static void free(void *where)

{        /* Don't care */

}

 

static void gzip_mark(void **ptr)

{

        *ptr = (void *) free_mem_ptr;

}

 

static void gzip_release(void **ptr)

{

        free_mem_ptr = (long) *ptr;

}

 

static void scroll(void)

{

        int i;

 

        memcpy ( vidmem, vidmem + cols * 2, ( lines - 1 ) * cols * 2 );

        for ( i = ( lines - 1 ) * cols * 2; i                 vidmem[ i ] = ' ';

}

 

static void puts(const char *s)

{

        int x,y,pos;

        char c;

 

        x = SCREEN_INFO.orig_x;

        y = SCREEN_INFO.orig_y;

 

        while ( ( c = *s++ ) != '/0' ) {

                if ( c == '/n' ) {

                        x = 0;

                        if ( ++y >= lines ) {

                                scroll();

                                y--;

                        }

                } else {

                        vidmem [ ( x + cols * y ) * 2 ] = c;

                        if ( ++x >= cols ) {

                                x = 0;

                                if ( ++y >= lines ) {

                                        scroll();

                                        y--;

                                }

                        }

                }

        }

 

        SCREEN_INFO.orig_x = x;

        SCREEN_INFO.orig_y = y;

 

        pos = (x + cols * y) * 2;        /* Update cursor position */

        outb_p(14, vidport);

        outb_p(0xff  (pos >> 9), vidport+1);

        outb_p(15, vidport);

        outb_p(0xff  (pos >> 1), vidport+1);

}

 

void* memset(void* s, int c, size_t n)

{

        int i;

        char *ss = (char*)s;

 

        for (i=0;i        return s;

}

 

void* memcpy(void* __dest, __const void* __src,

                            size_t __n)

{

        int i;

        char *d = (char *)__dest, *s = (char *)__src;

 

        for (i=0;i        return __dest;

}

 

/* ===========================================================================

* Fill the input buffer. This is called only when the buffer is empty

* and at least one byte is really needed.

*/

static int fill_inbuf(void)

{

        if (insize != 0) {

                error("ran out of input data/n");

        }

 

        inbuf = input_data;

        insize = input_len;

        inptr = 1;

        return inbuf[0];

}

 

/* ===========================================================================

* Write the output window window[0..outcnt-1] and update crc and bytes_out.

* (Used for the decompressed data only.)

*/

static void flush_window_low(void)

{

    ulg c = crc;         /* temporary variable */

    unsigned n;

    uch *in, *out, ch;

 

    in = window;

    out =

    for (n = 0; n             ch = *out++ = *in++;

            c = crc_32_tab[((int)c ^ ch)  0xff] ^ (c >> 8);

    }

    crc = c;

    bytes_out += (ulg)outcnt;

    output_ptr += (ulg)outcnt;

    outcnt = 0;

}

 

static void flush_window_high(void)

{

    ulg c = crc;         /* temporary variable */

    unsigned n;

    uch *in,  ch;

    in = window;

    for (n = 0; n         ch = *output_data++ = *in++;

        if ((ulg)output_data == low_buffer_end) output_data=high_buffer_start;

        c = crc_32_tab[((int)c ^ ch)  0xff] ^ (c >> 8);

    }

    crc = c;

    bytes_out += (ulg)outcnt;

    outcnt = 0;

}

 

static void flush_window(void)

{

        if (high_loaded) flush_window_high();

        else flush_window_low();

}

 

static void error(char *x)

{

        puts("/n/n");

        puts(x);

        puts("/n/n -- System halted");

 

        while(1);        /* Halt */

}

 

#define STACK_SIZE (4096)

 

long user_stack [STACK_SIZE];

 

struct {

        long * a;

        short b;

        } stack_start = {  user_stack [STACK_SIZE] , __KERNEL_DS };

 

void setup_normal_output_buffer(void) 对于zImage, 直接解压到1M

{

#ifdef STANDARD_MEMORY_BIOS_CALL

        if (EXT_MEM_K #else

        if ((ALT_MEM_K > EXT_MEM_K ? ALT_MEM_K : EXT_MEM_K) #endif

        output_data = (char *)0x100000; /* Points to 1M */

        free_mem_end_ptr = (long)real_mode;

}

 

struct moveparams {

        uch *low_buffer_start;  int lcount;

        uch *high_buffer_start; int hcount;

};

 

void setup_output_buffer_if_we_run_high(struct moveparams *mv)

{

        high_buffer_start = (uch *)(((ulg) + HEAP_SIZE); 内核高端片段的最小起始地址

#ifdef STANDARD_MEMORY_BIOS_CALL

        if (EXT_MEM_K #else

        if ((ALT_MEM_K > EXT_MEM_K ? ALT_MEM_K : EXT_MEM_K) #endif

        mv->low_buffer_start = output_data = (char *)LOW_BUFFER_START;

        low_buffer_end = ((unsigned int)real_mode > LOW_BUFFER_MAX

          ? LOW_BUFFER_MAX : (unsigned int)real_mode)  ~0xfff;

        low_buffer_size = low_buffer_end - LOW_BUFFER_START;

        high_loaded = 1;

        free_mem_end_ptr = (long)high_buffer_start;

        if ( (0x100000 + low_buffer_size) > ((ulg)high_buffer_start)) {

                ; 如果高端片段的最小起始地址小于它实际应加载的地址,则将它置为实际地址,

                ; 这样高端片段就无需再次移动了,否则它要向前移动

                high_buffer_start = (uch *)(0x100000 + low_buffer_size);

                mv->hcount = 0; /* say: we need not to move high_buffer */

        }

        else mv->hcount = -1; 待定

        mv->high_buffer_start = high_buffer_start;

}

 

void close_output_buffer_if_we_run_high(struct moveparams *mv)

{

        if (bytes_out > low_buffer_size) {

                mv->lcount = low_buffer_size;

                if (mv->hcount)

                        mv->hcount = bytes_out - low_buffer_size; 求出高端片段的字节数

        } else { 如果解压后内核只有低端的一个片段

                mv->lcount = bytes_out;

                mv->hcount = 0;

        }

}

 

int decompress_kernel(struct moveparams *mv, void *rmode)

{

        real_mode = rmode;

 

        if (SCREEN_INFO.orig_video_mode == 7) {

                vidmem = (char *) 0xb0000;

                vidport = 0x3b4;

        } else {

                vidmem = (char *) 0xb8000;

                vidport = 0x3d4;

        }

 

        lines = SCREEN_INFO.orig_video_lines;

        cols = SCREEN_INFO.orig_video_cols;

 

        if (free_mem_ptr         else setup_output_buffer_if_we_run_high(mv);

 

        makecrc();

        puts("Uncompressing Linux... ");

        gunzip();

        puts("Ok, booting the kernel./n");

        if (high_loaded) close_output_buffer_if_we_run_high(mv);

        return high_loaded;

}

 

Edited by lucian_yao on 04/28/01 01:36 PM.

 

[目录]


中断

 

[目录]


软中断


发信人: fist (星仔迷), 信区: SysInternals WWW-POST
标  题:  软中断
发信站: 武汉白云黄鹤站 (Thu Mar 22 14:12:46 2001) , 转信

软中断「一」 [张贴#: 88594 ]


一、 引言
软中断是linux系统原“底半处理”的升级,在原有的基础上发展的新的处理方式,以适应多cpu 、多线程的软中断处理。
要了解软中断,我们必须要先了原来底半处理的处理机制。
二、底半处理机制(基于2.0.3版本)
某些特殊时刻我们并不愿意在核心中执行一些操作。例如中断处理过程中。当中断发生时处理器将停止当前的工作, 操作系统将中断发送到相应的设备驱动上去。由于此时系统中其他程序都不能运行, 所以设备驱动中的中断处理过程不宜过长。有些任务最好稍后执行。Linux底层部分处理机制可以让设备驱动和Linux核心其他部分将这些工作进行排序以延迟执行。

系统中最多可以有32个不同的底层处理过程;bh_base是指向这些过程入口的指针数组。而bh_active和 bh_mask用来表示那些处理过程已经安装以及那些处于活动状态。如果bh_mask的第N位置位则表示bh_base的 第N个元素包含底层部分处理例程。如果bh_active的第N位置位则表示第N个底层处理过程例程可在调度器认 为合适的时刻调用。这些索引被定义成静态的;定时器底层部分处理例程具有最高优先级(索引值为0), 控制台底层部分处理例程其次(索引值为1)。典型的底层部分处理例程包含与之相连的任务链表。例如 immediate底层部分处理例程通过那些需要被立刻执行的任务的立即任务队列(tq_immediate)来执行。
--引自David A Rusling的《linux核心》。

三、对2.4.1 软中断处理机制
下面,我们进入软中断处理部份(softirq.c):

由softirq.c的代码阅读中,我们可以知道,在系统的初始化过程中(softirq_init()),它使用了两个数组:bh_task_vec[32],softirq_vec[32]。其中,bh_task_vec[32]填入了32个bh_action()的入口地址,但soft_vec[32]中,只有softirq_vec[0],和softirq_vec[3]分别填入了tasklet_action()和tasklet_hi_action()的地址。其余的保留它用。
当发生软中断时,系统并不急于处理,只是将相应的cpu的中断状态结构中的active 的相应的位置位,并将相应的处理函数挂到相应的队列,然后等待调度时机来临(如:schedule(),
系统调用返回异常时,硬中断处理结束时等),系统调用do_softirq()来测试active位,再调用被激活的进程在这处过程中,软中断的处理与底半处理有了差别,active 和mask不再对应bh_base[nr], 而是对应softirq_vec[32]。在softirq.c中,我们只涉及了softirq_vec[0]、softirq_vec[3]。这两者分别调用了tasklet_action()和tasklet_hi_action()来进行后续处理。这两个过程比较相似,大致如下:
1, 锁cpu的tasklet_vec[cpu]链表,取出链表,将原链表清空,解锁,还给系统。
2, 对链表进行逐个处理。
3, 有无法处理的,(task_trylock(t)失败,可能有别的进程锁定),插回系统链表。至此,系统完成了一次软中断的处理。

接下来有两个问题:
1, bh_base[]依然存在,但应在何处调用?
2, tasklet_vec[cpu]队列是何时挂上的?


四、再探讨
再次考查softirq.c 的bh_action()部份,发现有两个判断:
A:if(!spin_trylock(&global_bh_lock))goto:rescue
指明如果global_bh_lock 不能被锁上(已被其它进程锁上),则转而执行rescue,将bh_base[nr]挂至tasklet_hi_vec[cpu]队列中。等候中断调度。
B:if(!hardirq_trylock(cpu)) goto tescue unlock 此时有硬中断发生,放入队列推迟执行。若为空闲,现在执行。

由此可见,这部分正是对应底半处理的程序,bh_base[]的延时处理正是底半处理的特点,可以推测,如果没有其它函数往tasklet_hi_vec[cpu]队列挂入,那tasklet_hi_vec[cpu]正完全对应着bh_base[]底半处理
在bh_action()中,把bh_ation()挂入tasklet_hi_vec[cpu]的正是mark_bh(),在整个源码树中查找,发现调用mark_bh()的函数很多,可以理解,软中断产生之时,相关的函数会调用mark_bh(),将bh_action挂上tasklet_hi_vec队列,而bh_action()的作用不过是在发现bh_base[nr]暂时无法处理时重返队列的方法。
由此可推测tasklet_vec队列的挂接应与此相似,查看interrupt.h,找到tasklet_schedule()函数:
157 static inline void tasklet_schedule(struct tasklet_struct *t)
158 {
159 if (!test_and_set_bit(TASKLET_STATE_SCHED, &t->state)) {
160 int cpu = smp_processor_id();
161 unsigned long flags;
162
163 local_irq_save(flags);
164 t->next = tasklet_vec[cpu].list;
165 tasklet_vec[cpu].list = t; /*插入队列。
166 __cpu_raise_softirq(cpu, TASKLET_SOFTIRQ);
167 local_irq_restore(flags);
168 }
169 }
正是它为tasklet_vec[cpu]队列的建立立下了汗马功劳,在源码树中,它亦被多个模块调用,来完成它的使命。
至此,我们可以描绘一幅完整的软中断处理图了。


现在,再来考查do_softirq()的softirq_vec[32],在interrupt.h中有如下定义:
56 enum
57 {
58 HI_SOFTIRQ=0,
59 NET_TX_SOFTIRQ,
60 NET_RX_SOFTIRQ,
61 TASKLET_SOFTIRQ
62 };

这四个变量应都是为softirq_vec[]的下标,那么,do_softirq()也将会处理NET_TX_SOFTIRQ和NET_RX_SOFTIRQ,是否还处理其它中断,这有待探讨。也许,这个do_softirq()有着极大的拓展性,等着我们去开发呢。


我一直不明白,mask和active 是如何置位的。就我的理解,active 与softirq_vec[32]对应,而softirq_vec[]只对应中断队列的头部,那么,进行每次中断响应时,往队列中加入处理函数,是否都要对active置位?我在源码中没发现相应语句,盼指点。


我还等着老兄的下一篇呢!
我马上写点小补充。如果有什么迷惑的地方,可得提哦!要不然,大家以为你打算下回分解呢!:-)

主要通过__cpu_raise_softirq来设置
在hi_tasklet(也就是一般用于bh的)的处理里面,在处理完当前的队列后,会将补充的队列重新挂上,然后标记(不管是否补充队列里面有tasklet):

local_irq_disable();
t->next = tasklet_hi_vec[cpu].list;
tasklet_hi_vec[cpu].list = t;
__cpu_raise_softirq(cpu, HI_SOFTIRQ);
local_irq_enable();

因此,对mark_bh根本不用设置这个active位。

对于一般的tasklet也一样:
local_irq_disable();
t->next = tasklet_vec[cpu].list;
tasklet_vec[cpu].list = t;
__cpu_raise_softirq(cpu, TASKLET_SOFTIRQ);
local_irq_enable();

其它的设置,可以检索上面的__cpu_raise_softirq

问题:在tasklet_action中,好象t后面还会被执行?

其实不觉得不妨不要考虑底半部分的影响,单独把softirq, tasklet考虑一下,尤其是在SMP的环境中,然后再不妨和原来的bh做个比较细致的比较,这样可能会理解得更深透些。:-)

 

谢谢lucian_yao兄指点,果然是__cpu_raise_softirq 在置位,是我疏忽了。但我认为,mark_bh()在执行时调用了tasklet_hi_schedule对active置了位。对一般的tasklet也是通过调用tasklet_schedule()对active置了位,lucian_yao兄所列的示范语句,是tasklet_action将t插回后备队列时,将active 重置位(否则就要由别的中断来通知do_softirq(),这是不合理的)。
t 是在tasklet_trylock(t)失败时交还给后备队列的,交还后当然会再执行,但为什么会失败,我也不了解。


你是对的。我疏忽了。在tasklet_schedule中果然有置位的语句。
在action语句中的确实是因为已经有softirq在执行,所以重新置位。


bottom half, softirq, tasklet, tqueue
[bottom half]
bh_base[32]
|
//
bh_action();
|
//
bh_task_vec[32];
| mark_bh(), tasklet_hi_schedule()
//
task_hi_action

bh_base对应的是32个函数,这些函数在bh_action()中调用
static void bh_action(unsigned long nr)
{
int cpu = smp_processor_id();

if (!spin_trylock(&global_bh_lock))
goto resched;

if (!hardirq_trylock(cpu))
goto resched_unlock;

if (bh_base[nr])
bh_base[nr]();

hardirq_endlock(cpu);
spin_unlock(&global_bh_lock);
return;

resched_unlock:
spin_unlock(&global_bh_lock);
resched:
mark_bh(nr);
}

在软中断初始化时,将bh_action()放到bh_task_vec[32]中,bh_task_vec[32]中元素的类型是tasklet_struct,系统使用mark_bh()或task_hi_schedule()函数将它挂到task_hi_vec[]的对列中,在系统调用do_softirq()时执行。
static inline void mark_bh(int nr)
{
tasklet_hi_schedule(bh_task_vec+nr);
}

static inline void tasklet_hi_schedule(struct tasklet_struct *t)
{
if (!test_and_set_bit(TASKLET_STATE_SCHED, &t->state)) {
int cpu = smp_processor_id();
unsigned long flags;

local_irq_save(flags);
t->next = tasklet_hi_vec[cpu].list;
tasklet_hi_vec[cpu].list = t;
__cpu_raise_softirq(cpu, HI_SOFTIRQ);
local_irq_restore(flags);
}
}

[softirq]
softirq_vec[32];
struct softirq_action
{
void (*action)(struct softirq_action *);
void *data;
};
软中断对应一个softirq_action的结构,在do_softirq()中调用相应的action()做处理。
软中断初始化时只设置了0,3两项,对应的action是task_hi_action和task_action.
1: task_hi_action
//
|
tasklet_hi_vec[NR_CPU]

struct tasklet_head tasklet_hi_vec[NR_CPUS] __cacheline_aligned;
struct tasklet_head
{
struct tasklet_struct *list;
} __attribute__ ((__aligned__(SMP_CACHE_BYTES)));

task_hi_action处理的对象是一个tasklet的队列,每个cpu都有一个对应的tasklet队列,
它在tasklet_hi_schedule中动态添加。

3: task_action
//
|
tasklet_vec[NR_CPU]

[tasklet]
struct tasklet_struct
{

struct tasklet_struct *next;
unsigned long state;
atomic_t count;
void (*func)(unsigned long);
unsigned long data;
};
从上面的分析来看tasklet只是一个调用实体,在do_softirq()中被调用。softirq的组织和结构才是最重要的。

[目录]


驱动中断


发信人: fist (星仔迷), 信区: SysInternals WWW-POST
标  题: Linux设备驱动程序的中断
发信站: 武汉白云黄鹤站 (Mon Jul  2 20:51:38 2001) , 转信

标题   Linux设备驱动程序的中断
作者 coly (journeyman)
时间 07/02/01 11:24 AM

 

Linux设备驱动程序的中断
Coly
V0.1
指定参考书:《Linux设备驱动程序》(第一版)

这里总结一下Linux设备驱动程序中涉及的中断机制。

一、前言
Linux的中断宏观分为两种:软中断和硬中断。声明一下,这里的软和硬的意思是指和软件

关以及和硬件相关,而不是软件实现的中断或硬件实现的中断。
软中断就是“信号机制”。软中不是软件中断。Linux通过信号来产生对进程的各种中断操

,我们现在知道的信号共有31个,其具体内容这里略过,感兴趣读者可参看相关参考文献[1
]。一般来说,软中断是由内核机制的触发事件引起的(例如进程运行超时),但是不可忽

有大量的软中断也是由于和硬件有关的中断引起的,例如当打印机端口产生一个硬件中断时
,会通知和硬件相关的硬中断,硬中断就会产生一个软中断并送到操作系统内核里,这样内
核就会根据这个软中断唤醒睡眠在打印机任务队列中的处理进程。
硬中断就是通常意义上的“中断处理程序”,它是直接处理由硬件发过来的中断信号的。当
硬中断收到它应当处理的中断信号以后,就回去自己驱动的设备上去看看设备的状态寄存器
以了解发生了什么事情,并进行相应的操作。
对于软中断,我们不做讨论,那是进程调度里要考虑的事情。由于我们讨论的是设备驱动程
序的中断问题,所以焦点集中在硬中断里。我们这里讨论的是硬中断,即和硬件相关的中断

二、中断产生
要中断,是因为外设需要通知操作系统她那里发生了一些事情,但是中断的功能仅仅是一个
设备报警灯,当灯亮的时候中断处理程序只知道有事情发生了,但发生了什么事情还要亲自
到设备那里去看才行。也就是说,当中断处理程序得知设备发生了一个中断的时候,它并不
知道设备发生了什么事情,只有当它访问了设备上的一些状态寄存器以后,才能知道具体发
生了什么,要怎么去处理。
设备通过中断线向中断控制器发送高电平告诉操作系统它产生了一个中断,而操作系统会从
中断控制器的状态位知道是哪条中断线上产生了中断。PC机上使用的中断控制器是8259,这
种控制器每一个可以管理8条中断线,当两个8259级联的时候共可以控制15条中断线。这里

中断线是实实在在的电路,他们通过硬件接口连接到CPU外的设备控制器上。

三、IRQ
并不是每个设备都可以向中断线上发中断信号的,只有对某一条确定的中断线勇有了控制权
,才可以向这条中断线上发送信号。由于计算机的外部设备越来越多,所以15条中断线已经
不够用了,中断线是非常宝贵的资源。要使用中断线,就得进行中断线的申请,就是IRQ(In
terrupt Requirement),我们也常把申请一条中断线成为申请一个IRQ或者是申请一个中断


IRQ是非常宝贵的,所以我们建议只有当设备需要中断的时候才申请占用一个IRQ,或者是在
申请IRQ时采用共享中断的方式,这样可以让更多的设备使用中断。
无论对IRQ的使用方式是独占还是共享,申请IRQ的过程都是一样的,分为3步:
1.将所有的中断线探测一遍,看看哪些中断还没有被占用。从这些还没有被占用的中断中

一个作为该设备的IRQ。
2.通过中断申请函数申请选定的IRQ,这是要指定申请的方式是独占还是共享。
3.根据中断申请函数的返回值决定怎么做:如果成功了万事大吉,如果没成功则或者重新

请或者放弃申请并返回错误。
申请IRQ的过程,在参考书的配的源代码里有详细的描述,读者可以通过仔细阅读源代码中

short一例对中断号申请由深刻的理解。

四、中断处理程序
Linux中的中断处理程序很有特色,它的一个中断处理程序分为两个部分:上半部(top hal
f)和下半部(bottom half)。之所以会有上半部和下半部之分,完全是考虑到中断处理的效
率。
上半部的功能是“登记中断”。当一个中断发生时,他就把设备驱动程序中中断例程的下半
部挂到该设备的下半部执行队列中去,然后就没事情了--等待新的中断的到来。这样一来
,上半部执行的速度就会很快,他就可以接受更多她负责的设备产生的中断了。上半部之所
以要快,是因为它是完全屏蔽中断的,如果她不执行完,其它的中断就不能被及时的处理,
只能等到这个中断处理程序执行完毕以后。所以,要尽可能多得对设备产生的中断进行服务
和处理,中断处理程序就一定要快。
但是,有些中断事件的处理是比较复杂的,所以中断处理程序必须多花一点时间才能够把事
情做完。可怎么样化解在短时间内完成复杂处理的矛盾呢,这时候Linux引入了下半部的概

。下半部和上半部最大的不同是下半部是可中断的,而上半部是不可中断的。
下半部几乎做了中断处理程序所有的事情,因为上半部只是将下半部排到了他们所负责的设
备的中断处理队列中去,然后就什么都不管了。下半部一般所负责的工作是察看设备以获得
产生中断的事件信息,并根据这些信息(一般通过读设备上的寄存器得来)进行相应的处理
。如果有些时间下半部不知道怎么去做,他就使用著名的鸵鸟算法来解决问题--说白了就
是忽略这个事件。
由于下半部是可中断的,所以在它运行期间,如果其它的设备产生了中断,这个下半部可以
暂时的中断掉,等到那个设备的上半部运行完了,再回头来运行它。但是有一点一定要注意
,那就是如果一个设备中断处理程序正在运行,无论她是运行上半部还是运行下半部,只要
中断处理程序还没有处理完毕,在这期间设备产生的新的中断都将被忽略掉。因为中断处理
程序是不可重入的,同一个中断处理程序是不能并行的。
在Linux Kernel 2.0以前,中断分为快中断和慢中断(伪中断我们这里不谈),其中快中断
的下半部也是不可中断的,这样可以保证它执行的快一点。但是由于现在硬件水平不断上升
,快中断和慢中断的运行速度已经没有什么差别了,所以为了提高中断例程事务处理的效率
,从Linux kernel 2.0以后,中断处理程序全部都是慢中断的形式了--他们的下半部是可
以被中断的。
但是,在下半部中,你也可以进行中断屏蔽--如果某一段代码不能被中断的话。你可以使
用cti、sti或者是save_flag、restore_flag来实现你的想法。至于他们的用法和区别,请

看本文指定参考书中断处理部分。
进一步的细节请读者参看本文指定参考书,这里就不再所说了,详细介绍细节不是我的目的
,我的目的是整理概念。

五、置中断标志位
在处理中断的时候,中断控制器会屏蔽掉原先发送中断的那个设备,直到她发送的上一个中
断被处理完了为止。因此如果发送中断的那个设备载中断处理期间又发送了一个中断,那么
这个中断就被永远的丢失了。
之所以发生这种事情,是因为中断控制器并不能缓冲中断信息,所以当前一个中断没有处理
完以前又有新的中断到达,他肯定会丢掉新的中断的。但是这种缺陷可以通过设置主处理器
(CPU)上的“置中断标志位”(sti)来解决,因为主处理器具有缓冲中断的功能。如果使用
了“置中断标志位”,那么在处理完中断以后使用sti函数就可以使先前被屏蔽的中断得到

务。

六、中断处理程序的不可重入性
上一节中我们提到有时候需要屏蔽中断,可是为什么要将这个中断屏蔽掉呢?这并不是因为
技术上实现不了同一中断例程的并行,而是出于管理上的考虑。之所以在中断处理的过程中
要屏蔽同一IRQ来的新中断,是因为中断处理程序是不可重入的,所以不能并行执行同一个

断处理程序。在这里我们举一个例子,从这里子例中可以看出如果一个中断处理程序是可以
并行的话,那么很有可能会发生驱动程序锁死的情况。当驱动程序锁死的时候,你的操作系
统并不一定会崩溃,但是锁死的驱动程序所支持的那个设备是不能再使用了--设备驱动程
序死了,设备也就死了。

 

 

 

 

 

 


上图是一个中断处理程序的下半部并行时的情况,其中A是一段代码,B是操作设备寄存器R1
的代码,C是操作设备寄存器R2的代码。
其中激发PS1的事件会使A1产生一个中断,然后B1去读R1中已有的数据,然后代码C1向R2中

数据。而激发PS2的事件会使A2产生一个中断,然后B2删除R1中的数据,然后C2读去R2中的

据。
如果PS1先产生,且当他执行到A1和B1之间的时候,如果PS2产生了,这是A2会产生一个中断
,将PS2中断掉(挂到任务队列的尾部),然后删除了R1的内容。当PS2运行到C2时,由于C1
还没有向R2中写数据,所以C2将会在这里被挂起,PS2就睡眠在代码C2上,直到有数据可读

时候被信号唤醒。这是由于PS1中的B2原先要读的R1中的数据被PS2中的B2删除了,所以PS1

会睡眠在B1上,直到有数据可读的时候被信号唤醒。这样一来,唤醒PS1和PS2的事件就永远
不会发生了,因此PS1和PS2之间就锁死了。
由于设备驱动程序要和设备的寄存器打交道,所以很难写出可以重入的代码来,因为设备寄
存器就是全局变量。因此,最简洁的办法就是禁止同一设备的中断处理程序并行,即设备的
中断处理程序是不可重入的。
有一点一定要清楚:在2.0版本以后的Linux kernel中,所有的上半部都是不可中断的(上

部的操作是原子性的);不同设备的下半部可以互相中断,但一个特定的下半部不能被它自
己所中断(即同一个下半部不能并行)。
由于中断处理程序要求不可重入,所以程序员也不必为编写可重入的代码而头痛了。以我的
经验,编写可重入的设备驱动程序是可以的,编写可重入的中断处理程序是非常难得,几乎
不可能。

七、避免竞争条件的出现
我们都知道,一旦竞争条件出现了,就有可能会发生死锁的情况,严重时可能会将整个系统
锁死。所以一定要避免竞争条件的出现。
这里我不多说,大家只要注意一点:绝大多数由于中断产生的竞争条件,都是在带有中断的
内核进程被睡眠造成的。所以在实现中断的时候,一定要相信谨慎的让进程睡眠,必要的时
候可以使用cli、sti或者save_flag、restore_flag。具体细节请参看本文指定参考书。

八、实现
如何实现驱动程序的中断例程,是各位读者的事情了。只要你们仔细的阅读short例程的源

码,搞清楚编写驱动程序中断例程的规则,就可以编写自己的中断例程了。只要概念正确,

在正确的规则下编写你的代码,那就是符合道理的东西。我始终强调,概念是第一位的,能
编多少代码是很其次的,我们一定要概念正确,才能进行正确的思考。

九、小结
本文介绍了Linux驱动程序中的中断,如果读者已经新痒了的话,那么打开机器开始动手吧

Time for you to leave!
参考文献:
1.Linux网络编程
2.编程之道
3.Linux设备驱动程序
4.Mouse drivers
5.Linux Kernel Hacking Guide
6.Unreliable Guide To Hacking The Linux Kernel

 


--

 

[目录]


硬件中断 from aka


硬件中断

硬件中断概述

中断可以用下面的流程来表示:


中断产生源 --> 中断向量表 (idt) --> 中断入口 ( 一般简单处理后调用相应的函数) --->do_IRQ--> 后续处理(软中断等工作)


如图:

具体地说,处理过程如下:

 

中断信号由外部设备发送到中断芯片(模块)的引脚


中断芯片将引脚的信号转换成数字信号传给CPU,例如8259主芯片引脚0发送的是0x20


CPU接收中断后,到中断向量表IDT中找中断向量


根据存在中断向量中的数值找到向量入口


由向量入口跳转到一个统一的处理函数do_IRQ


在do_IRQ中可能会标注一些软中断,在执行完do_IRQ后执行这些软中断。


下面一一介绍。

 

8259芯片

本文主要参考周明德《微型计算机系统原理及应用》和billpan的相关帖子

 

1.中断产生过程

(1)如果IR引脚上有信号,会使中断请求寄存器(Interrupt Request Register,IRR)相应的位置位,比如图中, IR3, IR4, IR5上有信号,那么IRR的3,4,5为1


(2)如果这些IRR中有一个是允许的,也就是没有被屏蔽,那么就会通过INT向CPU发出中断请求信号。屏蔽是由中断屏蔽寄存器(Interrupt Mask Register,IMR)来控制的,比如图中位3被置1,也就是IRR位3的信号被屏蔽了。在图中,还有4,5的信号没有被屏蔽,所以,会向CPU发出请求信号。


(3)如果CPU处于开中断状态,那么在执行指令的最后一个周期,在INTA上做出回应,并且关中断.


(4)8259A收到回应后,将中断服务寄存器(In-Service Register)置位,而将相应的IRR复位:

8259芯片会比较IRR中的中断的优先级,如上图中,由于IMR中位3处于屏蔽状态,所以实际上只是比较IR4,I5,缺省情况下,IR0最高,依次往下,IR7最低(这种优先级可以被设置),所以上图中,ISR被设置为4.


(5)在CPU发出下一个INTA信号时,8259将中断号送到数据线上,从而能被CPU接收到,这里有个问题:比如在上图中,8259获得的是数4,但是CPU需要的是中断号(并不为4),从而可以到idt找相应的向量。所以有一个从ISR的信号到中断号的转换。在Linux的设置中,4对应的中断号是0x24.


(6)如果8259处于自动结束中断(Automatic End of Interrupt AEOI)状态,那么在刚才那个INTA信号结束前,8259的ISR复位(也就是清0),如果不处于这个状态,那么直到CPU发出EOI指令,它才会使得ISR复位。

 

2.一些相关专题


(1)从8259


在x86单CPU的机器上采用两个8259芯片,主芯片如上图所示,x86模式规定,从8259将它的INT脚与主8259的IR2相连,这样,如果从8259芯片的引脚IR8-IR15上有中断,那么会在INT上产生信号,主8259在IR2上产生了一个硬件信号,当它如上面的步骤处理后将IR2的中断传送给CPU,收到应答后,会通过CAS通知从8259芯片,从8259芯片将IRQ中断号送到数据线上,从而被CPU接收。

由此,我猜测它产生的所有中断在主8259上优先级为2,不知道对不对。


(2)关于屏蔽


从上面可以看出,屏蔽有两种方法,一种作用于CPU, 通过清除IF标记,使得CPU不去响应8259在INT上的请求。也就是所谓关中断。

另一种方法是,作用于8259,通过给它指令设置IMR,使得相应的IRR不参与ISR(见上面的(4)),被称为禁止(disable),反之,被称为允许(enable).

每次设置IMR只需要对端口0x21(主)或0xA1(从)输出一个字节即可,字节每位对应于IMR每位,例如:


outb(cached_21,0x21);


为了统一处理16个中断,Linux用一个16位cached_irq_mask变量来记录这16个中断的屏蔽情况:


static unsigned int cached_irq_mask = 0xffff;


为了分别对应于主从芯片的8位IMR,将这16位cached_irq_mask分成两个8位的变量:


#define __byte(x,y) (((unsigned char *)&(y))[x])

#define cached_21 (__byte(0,cached_irq_mask))

#define cached_A1 (__byte(1,cached_irq_mask))


在禁用某个irq的时候,调用下面的函数:


void disable_8259A_irq(unsigned int irq){

unsigned int mask = 1 << irq; unsigned long flags; spin_lock_irqsave(&i8259A_lock, flags);

cached_irq_mask |= mask;/*-- 对这16位变量设置 */


if (irq & 8)/*-- 看是对主8259设置还是对从芯片设置 */ outb(cached_A1,0xA1);/*-- 对从8259芯片设置 */

else

outb(cached_21,0x21);/*-- 对主8259芯片设置 */ spin_unlock_irqrestore(&i8259A_lock, flags);

}


(3)关于中断号的输出


8259在ISR里保存的只是irq的ID,但是它告诉CPU的是中断向量ID,比如ISR保存时钟中断的ID 0,但是在通知CPU却是中断号0x20.因此需要建立一个映射。在8259芯片产生的IRQ号必须是连续的,也就是如果irq0对应的是中断向量0x20,那么irq1对应的就是0x21,...


在i8259.c/init_8259A()中,进行设置:


outb_p(0x11, 0x20); /* ICW1: select 8259A-1 init */

outb_p(0x20 + 0, 0x21); /* ICW2: 8259A-1 IR0-7 mapped to 0x20-0x27 */

outb_p(0x04, 0x21); /* 8259A-1 (the master) has a slave on IR2 */

if (auto_eoi)

outb_p(0x03, 0x21); /* master does Auto EOI */

else

outb_p(0x01, 0x21); /* master expects normal EOI */


outb_p(0x11, 0xA0); /* ICW1: select 8259A-2 init */

outb_p(0x20 + 8, 0xA1); /* ICW2: 8259A-2 IR0-7 mapped to 0x28-0x2f */

outb_p(0x02, 0xA1); /* 8259A-2 is a slave on master's IR2 */

outb_p(0x01, 0xA1); /* (slave's support for AEOI in flat mode is to be investigated) */


这样,在IDT的向量0x20-0x2f可以分别填入相应的中断处理函数的地址了。

向量表设置


注:图片均取自i386开发者手册.


i386中断门描述符

描述符如图:

段选择符和偏移量决定了中断处理函数的入口地址,如下图。

 

在这里段选择符指向内核中唯一的一个代码段描述符的地址__KERNEL_CS(=0x10),而这个描述符定义的段为0到4G:

---------------------------------------------------------------------------------

ENTRY(gdt_table) .quad 0x0000000000000000 /* NULL descriptor */

.quad 0x0000000000000000 /* not used */

.quad 0x00cf9a000000ffff /* 0x10 kernel 4GB code at 0x00000000 */

... ...

---------------------------------------------------------------------------------

而偏移量就成了绝对的偏移量了,在IDT的描述符中被拆成了两部分,分别放在头和尾。


P标志着这个代码段是否在内存中,本来是i386提供的类似缺页的机制,在Linux中这个已经不用了,都设成1(当然内核代码是永驻内存的,但即使不在内存,推测linux也只会用缺页的标志)。

DPL在这里是0级(特权级)

0D110中,D为1,表明是32位程序(这个细节见i386开发手册).110是中断门的标识,其它101是任务门的标识, 111是陷阱(trap)门标识。

 

Linux对中断门的设置


于是在Linux中对硬件中断的中断门的设置为:


init_IRQ(void)

---------------------------------------------------------

for (i = 0; i < NR_IRQS; i++) {

int vector = FIRST_EXTERNAL_VECTOR + i;

if (vector != SYSCALL_VECTOR)

set_intr_gate(vector, interrupt[ i]);

}

----------------------------------------------------------


其中,FIRST_EXTERNAL_VECTOR=0x20,恰好为8259芯片的IR0的中断门(见8259部分),也就是时钟中断的中断门),interrupt[ i]为相应处理函数的入口地址

NR_IRQS=224, =256(IDT的向量总数)-32(CPU保留的中断的个数),在这里设置了所有可设置的向量。

SYSCALL_VECTOR=0x80,在这里意思是避开系统调用这个向量。


而set_intr_gate的定义是这样的:

----------------------------------------------------

void set_intr_gate(unsigned int n, void *addr){

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

}

----------------------------------------------------

其中,需要解释的是:14是标识指明这个是中断门,注意上面的0D110=01110=14;另外,0指明的是DPL.

中断入口


以8259的16个中断为例:

通过宏BUILD_16_IRQS(0x0), BI(x,y),以及


#define BUILD_IRQ(nr) /

asmlinkage void IRQ_NAME(nr); /

__asm__( /

"/n"__ALIGN_STR"/n" /

SYMBOL_NAME_STR(IRQ) #nr "_interrupt:/n/t" /

"pushl $"#nr"-256/n/t" /

"jmp common_interrupt");


得到的16个中断处理函数为:


IRQ0x00_interrupt:

push $0x00 - 256

jump common_interrupt


IRQ0x00_interrupt:

push $0x01 - 256

jump common_interrupt


... ...


IRQ0x0f_interrupt:

push $0x0f - 256

jump common_interrupt


这些处理函数简单的把中断号-256(为什么-256,也许是避免和内部中断的中断号有冲突)压到栈中,然后跳到common_interrupt


其中common_interrupt是由宏BUILD_COMMON_IRQ()展开:

 


#define BUILD_COMMON_IRQ() /

asmlinkage void call_do_IRQ(void); /

__asm__( /

"/n" __ALIGN_STR"/n" /

"common_interrupt:/n/t" /

SAVE_ALL /

"pushl $ret_from_intr/n/t" /

SYMBOL_NAME_STR(call_do_IRQ)":/n/t" /

"jmp "SYMBOL_NAME_STR(do_IRQ));


.align 4,0x90common_interrupt:

SAVE_ALL展开的保护现场部分

push $ret_from_intrcall

do_IRQ:

jump do_IRQ;


从上面可以看出,这16个的中断处理函数不过是把中断号-256压入栈中,然后保护现场,最后调用do_IRQ .在common_interrupt中,为了使do_IRQ返回到entry.S的ret_from_intr标号,所以采用的是压入返回点ret_from_intr,用jump来模拟一个从ret_from_intr上面对do_IRQ的一个调用。

 


和IDT的衔接


为了便于IDT的设置,在数组interrupt中填入所有中断处理函数的地址:


void (*interrupt[NR_IRQS])(void) = {

IRQ0x00_interrupt,

IRQ0x01_interrupt,

... ...

}

在中断门的设置中,可以看到是如何利用这个数组的。

硬件中断处理函数do_IRQ

do_IRQ的相关对象


在do_IRQ中,一个中断主要由三个对象来完成,如图:

 


其中, irq_desc_t对象构成的irq_desc[]数组元素分别对应了224个硬件中断(idt一共256项,cpu自己前保留了32项,256-32=224,当然这里面有些项是不用的,比如x80是系统调用).


当发生中断时,函数do_IRQ就会在irq_desc[]相应的项中提取各种信息来完成对中断的处理。


irq_desc有一个字段handler指向发出这个中断的设备的处理对象hw_irq_controller,比如在单CPU,这个对象一般就是处理芯片8259的对象。为什么要指向这个对象呢?因为当发生中断的时候,内核需要对相应的中断进行一些处理,比如屏蔽这个中断等。这个时候需要对中断设备(比如8259芯片)进行操作,于是可以通过这个指针指向的对象进行操作。


irq_desc还有一个字段action指向对象irqaction,后者是产生中断的设备的处理对象,其中的handler就是处理函数。由于一个中断可以由多个设备发出,Linux内核采用轮询的方式,将所有产生这个中断的设备的处理对象连成一个链表,一个一个执行。


例如,硬盘1,硬盘2都产生中断IRQx,在do_IRQ中首先找到irq_desc[x],通过字段handler对产生中断IRQx的设备进行处理(对8259而言,就是屏蔽以后的中断IRQx),然后通过action先后运行硬盘1和硬盘2的处理函数。

 

hw_irq_controller

hw_irq_controller有多种:


1.在一般单cpu的机器上,通常采用两个8259芯片,因此hw_irq_controller指的就是i8259A_irq_type


2.在多CPU的机器上,采用APIC子系统来处理芯片,APIC有3个部分组成,一个是I/O APIC模块,其作用可比做8259芯片,但是它发出的中断信号会通过 APIC总线送到其中一个(或几个)CPU中的Local APIC模块,因此,它还起一个路由的作用;它可以接收16个中断。


中断可以采取两种方式,电平触发和边沿触发,相应的,I/O APIC模块的hw_irq_controller就有两种:


ioapic_level_irq_type

ioapic_edge_irq_type


(这里指的是intel的APIC,还有其它公司研制的APIC,我没有研究过)


3. Local APIC自己也能单独处理一些直接对CPU产生的中断,例如时钟中断(这和没有使用Local APIC模块的CPU不同,它们接收的时钟中断来自外围的时钟芯片),因此,它也有自己的 hw_irq_controller:

lapic_irq_type


struct hw_interrupt_type {

const char * typename;

unsigned int (*startup)(unsigned int irq);

void (*shutdown)(unsigned int irq);

void (*enable)(unsigned int irq);

void (*disable)(unsigned int irq);

void (*ack)(unsigned int irq);

void (*end)(unsigned int irq);

void (*set_affinity)(unsigned int irq, unsigned long mask);

};


typedef struct hw_interrupt_type hw_irq_controller;

 


startup 是启动中断芯片(模块),使得它开始接收中断,一般情况下,就是将 所有被屏蔽的引脚取消屏蔽

shutdown 反之,使得芯片不再接收中断

enable 设某个引脚可以接收中断,也就是取消屏蔽

disable 屏蔽某个引脚,例如,如果屏蔽0那么时钟中断就不再发生

ack 当CPU收到来自中断芯片的中断信号,给相应的引脚的处理,这个各种情况下 (8259, APIC电平,边沿)的处理都不相同

end 在CPU处理完某个引脚产生的中断后,对中断芯片(模块)的操作。

irqaction

将一个硬件处理函数挂到相应的处理队列上去(当然首先要生成一个irqaction结构):


-----------------------------------------------------

int request_irq(unsigned int irq,

void (*handler)(int, void *, struct pt_regs *),

unsigned long irqflags,

const char * devname,

void *dev_id)

-----------------------------------------------------


参数说明在源文件里说得非常清楚。

handler是硬件处理函数,在下面的代码中可以看得很清楚:


---------------------------------------------

do {

status |= action->flags;

action->handler(irq, action->dev_id, regs);

action = action->next;

} while (action);

---------------------------------------------


第二个参数就是action的dev_id,这个参数非常灵活,可以派各种用处。而且要保证的是,这个dev_id在这个处理链中是唯一的,否则删除会遇到麻烦。

第三个参数是在entry.S中压入的各个积存器的值。


它的大致流程是:


1.在slab中分配一个irqaction,填上必需的数据

以下在函数setup_irq中。

2.找到它的irq对应的结构irq_desc

3.看它是否想对随机数做贡献

4.看这个结构上是否已经挂了其它处理函数了,如果有,则必须确保它本身和这个队列上所有的处理函数都是可共享的(由于传递性,只需判断一个就可以了)

5.挂到队列最后

6.如果这个irq_desc只有它一个irqaction,那么还要进行一些初始化工作

7在proc/下面登记 register_irq_proc(irq)(这个我不太明白)


将一个处理函数取下:


void free_irq(unsigned int irq, void *dev_id)


首先在队列里找到这个处理函数(严格的说是irqaction),主要靠dev_id来匹配,这时dev_id的唯一性就比较重要了。


将它从队列里剔除。

如果这个中断号没有处理函数了,那么禁止这个中断号上再产生中断:


if (!desc->action) {

desc->status |= IRQ_DISABLED;

desc->handler->shutdown(irq);

}


如果其它CPU在运行这个处理函数,要等到它运行完了,才释放它:


#ifdef CONFIG_SMP


/* Wait to make sure it's not being used on another CPU */

while (desc->status & IRQ_INPROGRESS)

barrier();

#endif

kfree(action);

 

do_IRQ

asmlinkage unsigned int do_IRQ(struct pt_regs regs)


1.首先取中断号,并且获取对应的irq_desc:


int irq = regs.orig_eax & 0xff; /* high bits used in ret_from_ code */

int cpu = smp_processor_id();

irq_desc_t *desc = irq_desc + irq;


2.对中断芯片(模块)应答:


desc->handler->ack(irq);


3.修改它的状态(注:这些状态我觉得只有在SMP下才有意义):


status = desc->status & ~(IRQ_REPLAY | IRQ_WAITING);

status |= IRQ_PENDING; /* we _want_ to handle it */


IRQ_REPLAY是指如果被禁止的中断号上又产生了中断,这个中断是不会被处理的,当这个中断号被允许产生中断时,会将这个未被处理的中断转为IRQ_REPLAY。


IRQ_WAITING 探测用,探测时,会将所有没有挂处理函数的中断号上设置IRQ_WAITING,如果这个中断号上有中断产生,就把这个状态去掉,因此,我们就可以知道哪些中断引脚上产生过中断了。


IRQ_PENDING , IRQ_INPROGRESS是为了确保:

 

同一个中断号的处理程序不能重入


不能丢失这个中断号的下一个处理程序


具体的说,当内核在运行某个中断号对应的处理程序(链)时,状态会设置成IRQ_INPROGRESS。如果在这期间,同一个中断号上又产生了中断,并且传给CPU,那么当内核打算再次运行这个中断号对应的处理程序(链)时,发现已经有一个实例在运行了,就将这下一个中断标注为IRQ_PENDING, 然后返回。这个已在运行的实例结束的时候,会查看是否期间有同一中断发生了,是则再次执行一遍。


这些状态的操作不是在什么情况下都必须的,事实上,一个CPU,用8259芯片,无论即使是开中断,也不会发生中断重入的情况,因为在这期间,内核把同一中断屏蔽掉了。


多个CPU比较复杂,因为CPU由Local APIC,每个都有自己的中断,但是它们可能调用同一个函数,比如时钟中断,每个CPU都可能产生,它们都会调用时钟中断处理函数。


从I/O APIC传过来的中断,如果是电平触发,也不会,因为在结束发出EOI前,这个引脚上是不接收中断信号。如果是边沿触发,要么是开中断,要么I/O APIC选择不同的CPU,在这两种情况下,会有重入的可能。


/*

* If the IRQ is disabled for whatever reason, we cannot

* use the action we have.

*/

action = NULL;

if (!(status & (IRQ_DISABLED | IRQ_INPROGRESS))) {

action = desc->action;

status &= ~IRQ_PENDING; /* we commit to handling */

status |= IRQ_INPROGRESS; /* we are handling it *//*进入执行状态*/

}

desc->status = status;


/*

* If there is no IRQ handler or it was disabled, exit early.

Since we set PENDING, if another processor is handling

a different instance of this same irq, the other processor

will take care of it.

*/

if (!action)

goto out;/*要么该中断没有处理函数;要么被禁止运行(IRQ_DISABLE);要么有一个实例已经在运行了*/


/*

* Edge triggered interrupts need to remember

* pending events.

* This applies to any hw interrupts that allow a second

* instance of the same irq to arrive while we are in do_IRQ

* or in the handler. But the code here only handles the _second_

* instance of the irq, not the third or fourth. So it is mostly

* useful for irq hardware that does not mask cleanly in an

* SMP environment.

*/

for (;;) {

spin_unlock(&desc->lock);

handle_IRQ_event(irq, &regs, action);/*执行函数链*/

spin_lock(&desc->lock);


if (!(desc->status & IRQ_PENDING))/*发现期间有中断,就再次执行*/

break;

desc->status &= ~IRQ_PENDING;

}

desc->status &= ~IRQ_INPROGRESS;/*退出执行状态*/

out:

/*

* The ->end() handler has to deal with interrupts which got

* disabled while the handler was running.

*/

desc->handler->end(irq);/*给中断芯片一个结束的操作,一般是允许再次接收中断*/

spin_unlock(&desc->lock);


if (softirq_active(cpu) & softirq_mask(cpu))

do_softirq();/*执行软中断*/

return 1;

}

软中断softirq

softirq简介

提出softirq的机制的目的和老版本的底半部分的目的是一致的,都是将某个中断处理的一部分任务延迟到后面去执行。


Linux内核中一共可以有32个softirq,每个softirq实际上就是指向一个函数。当内核执行softirq(do_softirq),就对这32个softirq进行轮询:


(1)是否该softirq被定义了,并且允许被执行?

(2)是否激活了(也就是以前有中断要求它执行)?


如果得到肯定的答复,那么就执行这个softirq指向的函数。


值得一提的是,无论有多少个CPU,内核一共只有32个公共的softirq,但是每个CPU可以执行不同的softirq,可以禁止/起用不同的softirq,可以激活不同的softirq,因此,可以说,所有CPU有相同的例程,但是

每个CPU却有自己完全独立的实例。


对(1)的判断是通过考察irq_stat[ cpu ].mask相应的位得到的。这里面的cpu指的是当前指令所在的cpu.在一开始,softirq被定义时,所有的cpu的掩码mask都是一样的。但是在实际运行中,每个cpu上运行的程序可以根据自己的需要调整。

对(2)的判断是通过考察irq_stat[ cpu ].active相应的位得到的.


虽然原则上可以任意定义每个softirq的函数,Linux内核为了进一步加强延迟中断功能,提出了tasklet的机制。tasklet实际上也就是一个函数。在第0个softirq的处理函数tasklet_hi_action中,我们可以看到,当执行这个函数的时候,会依次执行一个链表上所有的tasklet.


我们大致上可以把softirq的机制概括成:

内核依次对32个softirq轮询,如果遇到一个可以执行并且需要的softirq,就执行对应的函数,这些函数有可能又会执行一个函数队列。当执行完这个函数队列后,才会继续询问下一个softirq对应的函数。

 

挂上一个软中断

void open_softirq(int nr, void (*action)(struct softirq_action*), void *data)

{

unsigned long flags;

int i;


spin_lock_irqsave(&softirq_mask_lock, flags);

softirq_vec[nr].data = data;

softirq_vec[nr].action = action;


for (i=0; i<NR_CPUS; i++)

softirq_mask(i) |= (1<<nr);

spin_unlock_irqrestore(&softirq_mask_lock, flags);

}

其中对每个CPU的softirq_mask都标注一下,表明这个softirq被定义了。

tasklet

在这个32个softirq中,有的softirq的函数会依次执行一个队列中的tasklet,如第一帖中图所示。


tasklet其实就是一个函数。它的结构如下:


struct tasklet_struct

{

struct tasklet_struct *next;

unsigned long state;

atomic_t count;

void (*func)(unsigned long);

unsigned long data;

};


next 用于将tasklet串成一个队列

state 表示一些状态,后面详细讨论

count 用来禁用(count = 1 )或者启用( count = 0 )这个tasklet.因为一旦一个tasklet被挂到队列里,如果没有这个机制,它就一定会被执行。 这个count算是一个事后补救措施,万一挂上了不想执行,就可以把它置1。

func 即为所要执行的函数。

data 由于可能多个tasklet调用公用函数,因此用data可以区分不同tasklet.


如何将一个tasklet挂上


首先要初始化一个tasklet,填上相应的参数


void tasklet_init(struct tasklet_struct *t,

void (*func)(unsigned long), unsigned long data)

{

t->func = func;

t->data = data;

t->state = 0;

atomic_set(&t->count, 0);

}


然后调用schedule函数,注意,下面的函数仅仅是将这个tasklet挂到 TASKLET_SOFTIRQ对应的软中断所执行的tasklet队列上去, 事实上,还有其它的软中断,比如HI_SOFTIRQ,会执行其它的tasklet队列,如果要挂上,那么就要调用tasklet_hi_schedule(). 如果你自己写的softirq执行一个tasklet队列,那么你需要自己写类似下面的函数。


static inline void tasklet_schedule(struct tasklet_struct *t)

{

if (!test_and_set_bit(TASKLET_STATE_SCHED, &t->state)) {

int cpu = smp_processor_id();

unsigned long flags;


local_irq_save(flags);

/**/ t->next = tasklet_vec[cpu].list;

/**/ tasklet_vec[cpu].list = t;

__cpu_raise_softirq(cpu, TASKLET_SOFTIRQ);

local_irq_restore(flags);

}

}


这个函数中/**/标注的句子用来挂接上tasklet,

__cpu_raise_softirq用来激活TASKLET_SOFTIRQ,这样,下次执行do_softirq就会执行这个TASKLET_SOFTIRQ软中断了

__cpu_raise_softirq定义如下:


static inline void __cpu_raise_softirq(int cpu, int nr)

{

softirq_active(cpu) |= (1<<nr);

}


tasklet的运行方式


我们以tasklet_action为例,来说明tasklet运行机制。事实上,还有一个函数tasklet_hi_action同样也运行tasklet队列。

首先值得注意的是,我们前面提到过,所有的cpu共用32个softirq,但是同一个softirq在不同的cpu上执行的数据是独立的,基于这个原则,tasklet_vec对每个cpu都有一个,每个cpu都运行自己的tasklet队列。

 

当执行一个tasklet队列时,内核将这个队列摘下来,以list为队列头,然后从list的下一个开始依次执行。这样做达到什么效果呢?在执行这个队列时,这个队列的结构是静止的,如果在运行期间,有中断产生,并且往这个队列里添加tasklet的话,将填加到tasklet_vec[cpu].list中, 注意这个时候,这个队列里的任何tasklet都不会被执行,被执行的是list接管的队列。


见/*1*//*2/之间的代码。事实上,在一个队列上同时添加和运行也是可行的,没这个简洁。


-----------------------------------------------------------------

static void tasklet_action(struct softirq_action *a)

{

int cpu = smp_processor_id();

struct tasklet_struct *list;


/*1*/ local_irq_disable();

list = tasklet_vec[cpu].list;

tasklet_vec[cpu].list = NULL;

/*2*/ local_irq_enable();


while (list != NULL) {

struct tasklet_struct *t = list;


list = list->next;


/*3*/ if (tasklet_trylock(t)) {

if (atomic_read(&t->count) == 0) {

clear_bit(TASKLET_STATE_SCHED, &t->state);


t->func(t->data);

/*

* talklet_trylock() uses test_and_set_bit that imply

* an mb when it returns zero, thus we need the explicit

* mb only here: while closing the critical section.

*/

#ifdef CONFIG_SMP

/*?*/ smp_mb__before_clear_bit();

#endif

tasklet_unlock(t);

continue;

}

tasklet_unlock(t);

}

/*4*/ local_irq_disable();

t->next = tasklet_vec[cpu].list;

tasklet_vec[cpu].list = t;

__cpu_raise_softirq(cpu, TASKLET_SOFTIRQ);

/*5*/ local_irq_enable();

}

}

-------------------------------------------------------------


/*3*/看其它cpu是否还有同一个tasklet在执行,如果有的话,就首先将这个tasklet重新放到tasklet_vec[cpu].list指向的预备队列(见/*4*/~/*5*/),而后跳过这个tasklet.

这也就说明了tasklet是不可重入的,以防止两个相同的tasket访问同样的变量而产生竞争条件(race condition)


tasklet的状态


在tasklet_struct中有一个属性state,用来表示tasklet的状态:

tasklet的状态有3个:


1.当tasklet被挂到队列上,还没有执行的时候,是 TASKLET_STATE_SCHED

2.当tasklet开始要被执行的时候,是 TASKLET_STATE_RUN

其它时候,则没有这两个位的设置


其实还有另一对状态,禁止或允许,tasklet_struct中用count表示,用下面的函数操作

 

 


-----------------------------------------------------

static inline void tasklet_disable_nosync(struct tasklet_struct *t)

{

atomic_inc(&t->count);

}


static inline void tasklet_disable(struct tasklet_struct *t)

{

tasklet_disable_nosync(t);

tasklet_unlock_wait(t);

}


static inline void tasklet_enable(struct tasklet_struct *t)

{

atomic_dec(&t->count);

}

-------------------------------------------------------


下面来验证1,2这两个状态:


当被挂上队列时:

首先要测试它是否已经被别的cpu挂上了,如果已经在别的cpu挂上了,则不再将它挂上,否则设置状态为TASKLET_STATE_SCHED

 


static inline void tasklet_schedule(struct tasklet_struct *t)

{

if (!test_and_set_bit(TASKLET_STATE_SCHED, &t->state)) {

... ...

}


为什么要这样做?试想,如果一个tasklet已经挂在一队列上,内核将沿着这个队列一个个执行,现在如果又被挂到另一个队列上,那么这个tasklet的指针

指向另一个队列,内核就会沿着它走到错误的队列中去了。

 


tasklet开始执行时:


在tasklet_action中:

------------------------------------------------------------

while (list != NULL) {

struct tasklet_struct *t = list;

/*0*/ list = list->next;


/*1*/ if (tasklet_trylock(t)) {

/*2*/ if (atomic_read(&t->count) == 0) {

/*3*/ clear_bit(TASKLET_STATE_SCHED, &t->state);


t->func(t->data);

/*

* talklet_trylock() uses test_and_set_bit that imply

* an mb when it returns zero, thus we need the explicit

* mb only here: while closing the critical section.

*/

#ifdef CONFIG_SMP

smp_mb__before_clear_bit();

#endif

/*4*/ tasklet_unlock(t);

continue;

}

---------------------------------------------------------------


1 看是否是别的cpu上这个tasklet已经是 TASKLET_STATE_RUN了,如果是就跳过这个tasklet

2 看这个tasklet是否被允许运行?

3 清除TASKLET_STATE_SCHED,为什么现在清除,它不是还没有从队列上摘下来吗?事实上,它的指针已经不再需要的,它的下一个tasklet已经被list记录了(/*0*/)。这样,如果其它cpu把它挂到其它的队列上去一点影响都没有。

4 清除TASKLET_STATE_RUN标志


1和4确保了在所有cpu上,不可能运行同一个tasklet,这样在一定程度上确保了tasklet对数据操作是安全的,但是不要忘了,多个tasklet可能指向同一个函数,所以仍然会发生竞争条件。


可能会有疑问:假设cpu 1上已经有tasklet 1挂在队列上了,cpu2应该根本挂不上同一个tasklet 1,怎么会有tasklet 1和它发生重入的情况呢?

答案就在/*3*/上,当cpu 1的tasklet 1已经不是TASKLET_STATE_SCHED,而它还在运行,这时cpu2完全有可能挂上同一个tasklet 1,而且使得它试图运行,这时/*1*/的判断就起作用了。


软中断的重入

 


如图,一般情况下,在硬件中断处理程序后都会试图调用do_softirq执行软中断,但是如果发现现在已经有中断在运行,或者已经有软中断在运行,则

不再运行自己调用的中断。也就是说,软中断是不能进入硬件中断部分的,并且软中断在一个cpu上是不可重入的,或者说是串行化的(serialize)


其目的是避免访问同样的变量导致竞争条件的出现。在开中断的中断处理程序中不允许调用软中断可能是希望这个中断处理程序尽快结束。


这是由do_softirq中的


if (in_interrupt())

return;


保证的.


其中,

#define in_interrupt() ({ int __cpu = smp_processor_id(); /

(local_irq_count(__cpu) + local_bh_count(__cpu) != 0); })


前者local_irq_count(_cpu):


当进入硬件中断处理程序时,handle_IRQ_event中的irq_enter(cpu, irq)会将它加1,表明又进入一个硬件中断

退出则调用irq_exit(cpu, irq)


后者local_bh_count(__cpu) :


当进入软中断处理程序时,do_softirq中的local_bh_disable()会将它加1,表明处于软中断中

local_bh_disable();


一个例子:


当内核正在执行处理定时器的软中断时,这期间可能会发生多个时钟中断,这些时钟中断的处理程序都试图再次运行处理定时器的软中断,但是由于 已经有个软中断在运行了,于是就放弃返回。


软中断调用时机


最直接的调用:


当硬中断执行完后,迅速调用do_softirq来执行软中断(见下面的代码),这样,被硬中断标注的软中断能得以迅速执行。当然,不是每次调用都成功的,见前面关于重入的帖子。

-----------------------------------------------------

asmlinkage unsigned int do_IRQ(struct pt_regs regs)

{

... ...

if (softirq_active(cpu) & softirq_mask(cpu))

do_softirq();


}

-----------------------------------------------------


还有,不是每个被标注的软中断都能在这次陷入内核的部分中完成,可能会延迟到下次中断。


其它地方的调用:


在entry.S中有一个调用点:


handle_softirq:

call SYMBOL_NAME(do_softirq)

jmp ret_from_intr


有两处调用它,一处是当系统调用处理完后:


ENTRY(ret_from_sys_call)

#ifdef CONFIG_SMP

movl processor(%ebx),%eax

shll $CONFIG_X86_L1_CACHE_SHIFT,%eax

movl SYMBOL_NAME(irq_stat)(,%eax),%ecx # softirq_active

testl SYMBOL_NAME(irq_stat)+4(,%eax),%ecx # softirq_mask

#else

movl SYMBOL_NAME(irq_stat),%ecx # softirq_active

testl SYMBOL_NAME(irq_stat)+4,%ecx # softirq_mask

#endif

jne handle_softirq


一处是当异常处理完后:


ret_from_exception:

#ifdef CONFIG_SMP

GET_CURRENT(%ebx)

movl processor(%ebx),%eax

shll $CONFIG_X86_L1_CACHE_SHIFT,%eax

movl SYMBOL_NAME(irq_stat)(,%eax),%ecx # softirq_active

testl SYMBOL_NAME(irq_stat)+4(,%eax),%ecx # softirq_mask

#else

movl SYMBOL_NAME(irq_stat),%ecx # softirq_active

testl SYMBOL_NAME(irq_stat)+4,%ecx # softirq_mask

#endif

jne handle_softirq


注意其中的irq_stat, irq_stat +4 对应的就是字段 active和mask


既然我们每次调用完硬中断后都马上调用软中断,为什么还要在这里调用呢?


原因可能都多方面的:


(1)在系统调用或者异常处理中同样可以标注软中断,这样它们在返回前就能得以迅速执行


(2)前面提到,有些软中断要延迟到下次陷入内核才能执行,系统调用和异常都陷入内核,所以可以尽早的把软中断处理掉


(3)如果在异常或者系统调用中发生中断,那么前面提到,可能还会有一些软中断没有处理,在这两个地方做一个补救工作,尽量避免到下次陷入内核才处理这些软中断。


另外,在切换前也调用。


bottom half


2.2.x中的bottom half :


2.2.x版本中的bottom half就相当于2.4.1中的softirq.它的问题在于只有32个,如果要扩充的话,需要task 队列(这里task不是进程,而是函数),还有一个比较大的问题,就是虽然bottom half在一个CPU上是串行的(由local_bh_count[cpu]记数保证),但是在多CPU上是不安全的,例如,一个CPU上在运行关于定时器的bottom half,另一个CPU也可以运行同一个bottom half,出现了重入。


2.4.1中的bottom half


2.4.1中,用tasklet表示bottom half, mark_bh就是将相应的tasklet挂到运行队列里tasklet_hi_vec[cpu].list,这个队列由HI_SOFTIRQ对应的softirq来执行。


另外,用一个全局锁来保证,当一个CPU上运行一个bottom half时,其它CPU上不能运行任何一个bottom half。这和以前的bottom half有所不同,不知道是否我看错了。


用32个tasklet来表示bottom half:


struct tasklet_struct bh_task_vec[32];


首先,初始化所有的bottom half:


void __init softirq_init()

{

... ...

for (i=0; i<32; i++)

tasklet_init(bh_task_vec+i, bh_action, i);

... ...

}


这里bh_action是下面的函数,它使得bottom half运行对应的bh_base。


static void bh_action(unsigned long nr)

{

int cpu = smp_processor_id();


/*1*/ if (!spin_trylock(&global_bh_lock))

goto resched;


if (!hardirq_trylock(cpu))

goto resched_unlock;


if (bh_base[nr])

bh_base[nr]();


hardirq_endlock(cpu);

spin_unlock(&global_bh_lock);

return;


resched_unlock:

spin_unlock(&global_bh_lock);

resched:

mark_bh(nr);

}


/*1*/试图上锁,如果得不到锁,则重新将bottom half挂上,下次在运行。

 

当要定义一个bottom half时用下面的函数:


void init_bh(int nr, void (*routine)(void))

{

bh_base[nr] = routine;

mb();

}


取消定义时,用:


void remove_bh(int nr)

{

tasklet_kill(bh_task_vec+nr);

bh_base[nr] = NULL;

}


tasklet_kill确保这个tasklet被运行了,因而它的指针也没有用了。


激活一个bottom half,就是将它挂到队列中 :


static inline void mark_bh(int nr)

{

tasklet_hi_schedule(bh_task_vec+nr);

}

[目录]


定时器代码分析


时钟和定时器中断

系统启动核心时,调用start_kernal()继续各方面的初始化,在这之前,各种中断都被禁止,只有在完成必要的初始化后,直到执行完Kmalloc_init()后,才允许中断(init/main.c)。与时钟中断有关的部分初始化如下:
调用trap_init()设置各种trap入口,如system_call、GDT entry、LDT entry、call gate等。其中,0~17为各种错误入口,18~47保留。
调用init_IRQ()函数设置核心系统的时钟周期为10ms,即100HZ,它是以后按照轮转法进行CPU调度时所依照的基准时钟周期。每10ms产生的时钟中断信号直接输入到第一块8259A的INT 0(即irq0)。初始化中断矢量表中从0x20起的17个中断矢量,用bad_IRQ#_interrupt函数的地址(#为中断号)填写。
调用sched_init()函数,设置启动第一个进程init_task。设置用于管理bottom_half机制的数据结构bh_base[],规定三类事件的中断处理函数,即时钟TIMER_BH、设备TQUEUE_BH和IMMEDIATE_BH。
调用time_init()函数,首先读取当时的CMOS时间,最后调用setup_x86_irq(0,&irq0)函数,把irq0挂到irq_action[0]队列的后面,并把中断矢量表中第0x20项,即timer中断对应的中断矢量改为IRQ0_interrupt函数的地址,在irq0中,指定时间中断服务程序是timer_interrupt,
     static struct irqaction irq0  = { timer_interrupt, 0, 0, "timer", NULL, NULL}
    结构irqaction的定义如下:
        struct irqaction {
            void (*handler)(int, void *, struct pt_regs *);  /* 中断服务函数入口 */
            unsigned long flags;                      /* 服务允中与否标记 */
        unsigned long mask;
            const char *name;
            void *dev_id;
          struct irqaction *next;
    };
其中,若flag==SA_INTERRUPT,则中断矢量改为fast_IRQ#_interrupt,在执行中断服务的过程中不允许出现中断,若为其它标记,则中断矢量为IRQ#_interrupt,在执行中断服务的过程中,允许出现中断。
Irq_action的定义与初始化如下:
    static void (*interrupt[17])(void) = {IRQ#_interrupt};
            static void (*fast_interrupt[16])(void) = {fast_IRQ#_interrupt};
    static void (*bad_interrupt[16])(void) = {bad_IRQ#_interrupt};(以上#为中断号)
    static struct irqaction *irq_action[16] = {
            NULL, NULL, NULL, NULL,
            NULL, NULL, NULL, NULL,
            NULL, NULL, NULL, NULL,
            NULL, NULL, NULL, NULL
    };

irq_action是一个全局数组,每个元素指向一个irq队列,共16个irq队列,时钟中断请求队列在第一个队列,即irq_action[0]。当每个中断请求到来时,都调用setup_x86_irq把该请求挂到相应的队列的后面。

以后,系统每10ms产生一次时钟中断信号,该信号直接输入到第一块8259A的INT 0(即irq0)。CPU根据中断矢量表和中断源,找到中断矢量函数入口IRQ0_interrupt(程序运行过程中允许中断)或者fast_IRQ0_interrupt(程序运行过程中不允许中断)或者bad_IRQ0_interrupt(不执行任何动作,直接返回),这些函数由宏BUILD_TIMER_IRQ(chip, nr, mask)展开定义。
宏BUILD_TIMER_IRQ(chip, nr, mask)的定义如下:
#define BUILD_TIMER_IRQ(chip,nr,mask) /
asmlinkage void IRQ_NAME(nr); /
asmlinkage void FAST_IRQ_NAME(nr); /
asmlinkage void BAD_IRQ_NAME(nr); /
__asm__( /
"/n"__ALIGN_STR"/n" /
SYMBOL_NAME_STR(fast_IRQ) #nr "_interrupt:/n/t" /
SYMBOL_NAME_STR(bad_IRQ) #nr "_interrupt:/n/t" /
SYMBOL_NAME_STR(IRQ) #nr "_interrupt:/n/t" /
        "pushl $-"#nr"-2/n/t" /
        SAVE_ALL /
        ENTER_KERNEL /
        ACK_##chip(mask,(nr&7)) /
        "incl "SYMBOL_NAME_STR(intr_count)"/n/t"/  /* intr_count为进入临界区的同步信号量 */
        "movl %esp,%ebx/n/t" /
        "pushl %ebx/n/t" /
        "pushl $" #nr "/n/t" /                                                /* 把do_irq函数参数压进堆栈 */
        "call "SYMBOL_NAME_STR(do_IRQ)"/n/t" /
        "addl $8,%esp/n/t" /
        "cli/n/t" /
        UNBLK_##chip(mask) /
        "decl "SYMBOL_NAME_STR(intr_count)"/n/t" /
        "incl "SYMBOL_NAME_STR(syscall_count)"/n/t" /
        "jmp ret_from_sys_call/n");
其中nr为中断请求类型,取值0~15。在irq.c中通过语句BUILD_TIMER_IRQ(first, 0, 0x01)调用该宏,在执行宏的过程中处理时钟中断响应程序do_irq()。
函数do_irq()的第一个参数是中断请求队列序号,时钟中断请求传进来的该参数是0。于是程序根据参数0找到请求队列irq_action[0],逐个处理该队列上handler所指的时钟中断请求的服务函数。由于已经指定时钟中断请求的服务函数是timer_interrupt,在函数timer_interrupt中,立即调用do_timer()函数。
函数do_timer()把jiffies和lost_ticks加1,接着就执行mark_bh(TIMER_BH)函数,把bottom_half中时钟队列对应的位置位,表示该队列处于激活状态。在做完这些动作后,程序从函数do_irq()中返回,继续执行以后的汇编代码。于是,程序在执行语句jmp ret_from_sys_call后,跳到指定的位置处继续执行。
代码段jmp ret_from_sys_call及其相关的代码段如下:
        ALIGN
        .globl ret_from_sys_call
ret_from_sys_call:
        cmpl $0,SYMBOL_NAME(intr_count)
        jne 2f
9:        movl SYMBOL_NAME(bh_mask),%eax
        andl SYMBOL_NAME(bh_active),%eax
        jne handle_bottom_half
#ifdef __SMP__
        cmpb $(NO_PROC_ID), SYMBOL_NAME(saved_active_kernel_processor)
        jne 2f
#endif
        movl EFLAGS(%esp),%eax                # check VM86 flag: CS/SS are
        testl $(VM_MASK),%eax                # different then
        jne 1f
        cmpw $(KERNEL_CS),CS(%esp)        # was old code segment supervisor ?
        je 2f
1:        sti
        orl $(IF_MASK),%eax                # these just try to make sure
        andl $~NT_MASK,%eax                # the program doesn't do anything
        movl %eax,EFLAGS(%esp)                # stupid
        cmpl $0,SYMBOL_NAME(need_resched)
        jne reschedule
#ifdef __SMP__
        GET_PROCESSOR_OFFSET(%eax)
        movl SYMBOL_NAME(current_set)(,%eax), %eax
#else
        movl SYMBOL_NAME(current_set),%eax
#endif
        cmpl SYMBOL_NAME(task),%eax        # task[0] cannot have signals
        je 2f
        movl blocked(%eax),%ecx
        movl %ecx,%ebx                        # save blocked in %ebx for signal handling
        notl %ecx
        andl signal(%eax),%ecx
        jne signal_return
2:        RESTORE_ALL

ALIGN
signal_return:
        movl %esp,%ecx
        pushl %ecx
        testl $(VM_MASK),EFLAGS(%ecx)
        jne v86_signal_return
        pushl %ebx
        call SYMBOL_NAME(do_signal)
        popl %ebx
        popl %ebx
        RESTORE_ALL

ALIGN
v86_signal_return:
        call SYMBOL_NAME(save_v86_state)
        movl %eax,%esp
        pushl %eax
        pushl %ebx
        call SYMBOL_NAME(do_signal)
        popl %ebx
        popl %ebx
        RESTORE_ALL

  handle_bottom_half:
incl SYMBOL_NAME(intr_count)
call SYMBOL_NAME(do_bottom_half)
decl SYMBOL_NAME(intr_count)
jmp 9f

ALIGN
reschedule:
pushl $ret_from_sys_call
  jmp SYMBOL_NAME(schedule)    # test

上述汇编代码用流程图表示如下:

                 ret_from_sys_call

 

 

 

 

 

 

 

 

 

 

 

 

 

另外,一些与时钟中断及bottom half机制有关的数据结构介绍如下:
#define        HZ        100
unsigned long volatile jiffies=0;
系统每隔10ms自动把它加1,它是核心系统计时的单位。
enum {
        TIMER_BH = 0,
        CONSOLE_BH,
        TQUEUE_BH,
        DIGI_BH,
        SERIAL_BH,
        RISCOM8_BH,
SPECIALIX_BH,
        BAYCOM_BH,
        NET_BH,
        IMMEDIATE_BH,
        KEYBOARD_BH,
        CYCLADES_BH,
        CM206_BH
};
现在只定义了13个bottom half队列,将来可扩充到32个队列。
unsigned long intr_count = 0;
相当于信号量的作用。只有其等于0,才可以do_bottom_half。
int bh_mask_count[32];
用来计算bottom half队列被屏蔽的次数。只有某队列的bh_mask_count数为0,才能enable该队列。
unsigned long bh_active = 0;
bh_active是32位长整数,每一位表示一个bottom half队列,该位置1,表示该队列处于激活状态,随时准备在CPU认为合适的时候执行该队列的服务,置0则相反。
unsigned long bh_mask = 0;
bh_mask也是32位长整数,每一位对应一个bottom half队列,该位置1,表示该队列可用,并把处理函数的入口地址赋给bh_base,置0则相反。
void (*bh_base[32])(void);
bottom half服务函数入口地址数组。定时器处理函数拥有最高的优先级,它的地址存放在bh_base[0],总是最先执行它所指向的函数。

我们注意到,在IRQ#_interrupt和fast_IRQ#_interrupt中断函数处理返回前,都通过语句jmp ret_from_sys_call,跳到系统调用的返回处(见irq.h),如果bottom half队列不为空,则在那里做类似:
           if (bh_active & bh_mask) {
                            intr_count = 1;
                            do_bottom_half();
                            intr_count = 0;
                    }(该判断的汇编代码见Entry.S)
的判断,调用do_bottom_half()函数。
在CPU调度时,通过schedule函数执行上述的判断,再调用do_bottom_half()函数。
总而言之,在下列三种时机:
CPU调度时
系统调用返回前
中断处理返回前
都会作判断调用do_bottom_half函数。Do_bottom_half函数依次扫描32个队列,找出需要服务的队列,执行服务后把对应该队列的bh_active的相应位置0。由于bh_active标志中TIMER_BH对应的bit为1,因而系统根据服务函数入口地址数组bh_base找到函数timer_bh()的入口地址,并马上执行该函数,在函数timer_bh中,调用函数run_timer_list()和函数run_old_timers()函数,定时执行服务。

TVECS结构及其实现
有关TVECS结构的一些数据结构定义如下:

#define TVN_BITS 6
#define TVR_BITS 8
#define TVN_SIZE (1 << TVN_BITS)
#define TVR_SIZE (1 << TVR_BITS)
#define TVN_MASK (TVN_SIZE - 1)
#define TVR_MASK (TVR_SIZE - 1)

#define SLOW_BUT_DEBUGGING_TIMERS 0

struct timer_vec {
        int index;
        struct timer_list *vec[TVN_SIZE];
};
struct timer_vec_root {
        int index;
        struct timer_list *vec[TVR_SIZE];
};

static struct timer_vec tv5 = { 0 };
static struct timer_vec tv4 = { 0 };
static struct timer_vec tv3 = { 0 };
static struct timer_vec tv2 = { 0 };
static struct timer_vec_root tv1 = { 0 };

static struct timer_vec * const tvecs[] = {
        (struct timer_vec *)&tv1, &tv2, &tv3, &tv4, &tv5
};
#define NOOF_TVECS (sizeof(tvecs) / sizeof(tvecs[0]))
static unsigned long timer_jiffies = 0;

TVECS结构是一个元素个数为5的数组,分别指向tv1,tv2,tv3,tv4,tv5的地址。其中,tv1是结构timer_vec_root的变量,它有一个index域和有256个元素的指针数组,该数组的每个元素都是一条类型为timer_list的链表。其余四个元素都是结构timer_vec的变量,它们各有一个index域和64个元素的指针数组,这些数组的每个元素也都是一条链表。

函数internal_add_timer(struct timer_list *timer)

函数代码如下:
static inline void internal_add_timer(struct timer_list *timer)
{
        /*
        * must be cli-ed when calling this
        */
        unsigned long expires = timer->expires;
        unsigned long idx = expires - timer_jiffies;

        if (idx < TVR_SIZE) {
                int i = expires & TVR_MASK;
                insert_timer(timer, tv1.vec, i);
        } else if (idx < 1 << (TVR_BITS + TVN_BITS)) {
                int i = (expires >> TVR_BITS) & TVN_MASK;
                insert_timer(timer, tv2.vec, i);
        } else if (idx < 1 << (TVR_BITS + 2 * TVN_BITS)) {
                int i = (expires >> (TVR_BITS + TVN_BITS)) & TVN_MASK;
                insert_timer(timer, tv3.vec, i);
        } else if (idx < 1 << (TVR_BITS + 3 * TVN_BITS)) {
                int i = (expires >> (TVR_BITS + 2 * TVN_BITS)) & TVN_MASK;
                insert_timer(timer, tv4.vec, i);
        } else if (expires < timer_jiffies) {
                /* can happen if you add a timer with expires == jiffies,
                * or you set a timer to go off in the past
                */
                insert_timer(timer, tv1.vec, tv1.index);
        } else if (idx < 0xffffffffUL) {
                int i = (expires >> (TVR_BITS + 3 * TVN_BITS)) & TVN_MASK;
                insert_timer(timer, tv5.vec, i);
        } else {
                /* Can only get here on architectures with 64-bit jiffies */
                timer->next = timer->prev = timer;
        }
}

   expires


在调用该函数之前,必须关中。对该函数的说明如下:
取出要加进TVECS的timer的激发时间(expires),算出expires与timer_jiffies的差值idx,用来决定该插到哪个队列中去。
若idx小于2^8,则取expires的第0位到第7位的值I,把timer加到tv1.vec中第I个链表的第一个表项之前。
若idx小于2^14,则取expires的第8位到第13位的值I,把timer加到tv2.vec中第I个链表的第一个表项之前。
若idx小于2^20,则取expires的第14位到第19位的值I,把timer加到tv3.vec中第I个链表的第一个表项之前。
若idx小于2^26,则取expires的第20位到第25位的值I,把timer加到tv4.vec中第I个链表的第一个表项之前。
若expires小于timer_jiffies,即idx小于0,则表明该timer到期,应该把timer放入tv1.vec中tv1.index指定的链表的第一个表项之前。
若idx小于2^32,则取expires的第26位到第32位的值I,把timer加到tv5.vec中第I个链表的第一个表项之前。
若idx大等于2^32,该情况只有在64位的机器上才有可能发生,在这种情况下,不把timer加入TVECS结构。

函数cascade_timers(struct timer_vec *tv)

该函数只是把tv->index指定的那条链表上的所有timer调用internal_add_timer()函数进行重新调整,这些timer将放入TVECS结构中比原来位置往前移一级,比如说,tv4上的timer将放到tv3上去,tv2上的timer将放到tv1上。这种前移是由run_timer_list函数里调用cascade_timers函数的时机来保证的。然后把该条链表置空,tv->index加1,若tv->index等于64,则重新置为0。

函数run_timer_list()

函数代码如下:
static inline void run_timer_list(void)
{
cli();
while ((long)(jiffies - timer_jiffies) >= 0) {
        struct timer_list *timer;
        if (!tv1.index) {
                int n = 1;
                do {
                        cascade_timers(tvecs[n]);
                } while (tvecs[n]->index == 1 && ++n < NOOF_TVECS);
        }
        while ((timer = tv1.vec[tv1.index])) {
                void (*fn)(unsigned long) = timer->function;
                unsigned long data = timer->data;
                detach_timer(timer);
                timer->next = timer->prev = NULL;
                sti();
                fn(data);
                cli();
        }
        ++timer_jiffies;
        tv1.index = (tv1.index + 1) & TVR_MASK;
}
sti();
}
对run_timer_list函数的说明如下:
关中。
判断jiffies是否大等于timer_jiffies,若不是,goto 8。
判断tv1.index是否为0(即此时系统已经扫描过整个tv1的256个timer_list链表,又回到的第一个链表处,此时需重整TVECS结构),若是,置n为1;若不是,goto 6。
调用cascade_timers()函数把TVECS[n]中由其index指定的那条链表上的timer放到TVECS[n-1]中来。注意:调用cascade_timers()函数后,index已经加1。
判断TVECS[n]->index是否为1,即原来为0。如果是(表明TVECS[n]上所有都已经扫描一遍,此时需对其后一级的TVECS[++n]调用cascade_timers()进行重整),把n加1,goto 4。
执行tv1.vec上由tv1->index指定的那条链表上的所有timer的服务函数,并把该timer从链表中移走。在执行服务函数的过程中,允许中断。
timer_jiffies加1,tv1->index加1,若tv1->index等于256,则重新置为0,goto 2。
开中,返回。

Linux提供了两种定时器服务。一种早期的由timer_struct等结构描述,由run_old_times函数处理。另一种“新”的服务由timer_list等结构描述,由add_timer、del_timer、cascade_time和run_timer_list等函数处理。
早期的定时器服务利用如下数据结构:
struct timer_struct {
    unsigned long expires;  /*本定时器被唤醒的时刻 */
    void (*fn)(void);       /* 定时器唤醒后的处理函数 */
}
struct timer_struct timer_table[32];  /*最多可同时启用32个定时器 */
unsigned long timer_active;        /* 每位对应一定时器,置1表示启用 */
新的定时器服务依靠链表结构突破了32个的限制,利用如下的数据结构:
struct timer_list {
    struct timer_list *next;
    struct timer_list *prev;
    unsigned long expires;
    unsigned long data;          /* 用来存放当前进程的PCB块的指针,可作为参数传
    void (*function)(unsigned long);  给function */
}


表示上述数据结构的图示如下:


    在这里,顺便简单介绍一下旧的timer机制的运作情况。
    系统在每次调用函数do_bottom_half时,都会调用一次函数run_old_timers()。
函数run_old_timers()
该函数处理的很简单,只不过依次扫描timer_table中的32个定时器,若扫描到的定时器已经到期,并且已经被激活,则执行该timer的服务函数。

间隔定时器itimer
系统为每个进程提供了三个间隔定时器。当其中任意一个定时器到期时,就会发出一个信号给进程,同时,定时器重新开始运作。三种定时器描述如下:
ITIMER_REAL  真实时钟,到期时送出SIGALRM信号。
ITIMER_VIRTUAL  仅在进程运行时的计时,到期时送出SIGVTALRM信号。
ITIMER_PROF  不仅在进程运行时计时,在系统为进程运作而运行时它也计时,与ITIMER_VIRTUAL对比,该定时器通常为那些在用户态和核心态空间运行的应用所花去的时间计时,到期时送出SIGPROF信号。
与itimer有关的数据结构定义如下:
struct timespec {
        long        tv_sec;                /* seconds */
        long        tv_nsec;        /* nanoseconds */
};
struct timeval {
        int        tv_sec;                /* seconds */
        int        tv_usec;        /* microseconds */
};
struct  itimerspec {
        struct  timespec it_interval;    /* timer period */
        struct  timespec it_value;       /* timer expiration */
};
struct        itimerval {
        struct        timeval it_interval;        /* timer interval */
        struct        timeval it_value;        /* current value */
};

这三种定时器在task_struct中定义:
struct task_struct {
    ……
    unsigned long timeout;
    unsigned long it_real_value,it_prof_value,it_virt_value;
    unsigned long it_real_incr,it_prof_incr,it_virt_incr;
    struct timer_list real_timer;
    ……
}
在进程创建时,系统把it_real_fn函数的入口地址赋给real_timer.function。(见sched.h)
我们小组分析了三个系统调用:sys_getitimer,sys_setitimer,sys_alarm。
在这三个系统调用中,需用到以下一些函数:
函数static int _getitimer(int which, struct itimerval *value)
该函数的运行过程大致如下:
根据传进的参数which按三种itimer分别处理:
若是ITIMER_REAL,则设置interval为current进程的it_real_incr,val设置为0;判断current进程的real_timer有否设置并挂入TVECS结构中,若有,设置val为current进程real_timer的expires,并把real_timer重新挂到TVECS结构中,接着把val与当前jiffies作比较,若小等于当前jiffies,则说明该real_timer已经到期,于是重新设置val为当前jiffies的值加1。最后把val减去当前jiffies的值,goto 2。
若是ITIMER_VIRTUAL,则分别设置interval,val的值为current进程的it_virt_incr、it_virt_value,goto 2。
若是ITIMER_PROF,则分别设置interval,val的值为current进程的it_prof_incr、it_prof_value,goto 2。
   (2)调用函数jiffiestotv把val,interval的jiffies值转换为timeval,返回0。
函数 int _setitimer(int which, struct itimerval *value, struct itimerval *ovalue)
该函数的运行过程大致如下:
调用函数tvtojiffies把value中的interval和value转换为jiffies i 和 j。
判断指针ovalue是否为空,若空,goto ;若不空,则把由which指定类型的itimer存入ovalue中,若存放不成功,goto 4;
根据which指定的itimer按三种类型分别处理:
若是ITIMER_REAL,则从TVECS结构中取出current进程的real_timer,并重新设置current进程的it_real_value和it_real_incr为j和i。若j等于0,goto 4;若不等于0,则把当前jiffies的值加上定时器剩余时间j,得到触发时间。若i小于j,则表明I已经溢出,应该重新设为ULONG_MAX。最后把current进程的real_timer的expires设为i,把设置过的real_timer重新加入TVECS结构,goto 4。
若是ITIMER_VIRTUAL,则设置current进程的it-_virt_value和it_virt_incr为j和i。
若是ITIMER_PROF,则设置current进程的it-_prof_value和it_prof_incr为j和i。
   (4)返回0。

函数verify_area(int type, const void *addr, unsigned long size)
该函数的主要功能是对以addr为始址的,长度为size的一块存储区是否有type类型的操作权利。

函数memcpy_tofs(to, from, n)
该函数的主要功能是从以from为始址的存储区中取出长度为n的一块数据放入以to为始址的存储区。

函数memcpy_fromfs(from, to, n)
该函数的主要功能是从以from为始址的存储区中取出长度为n的一块数据放入以to为始址的存储区。

函数memset((char*)&set_buffer, 0, sizeof(set_buffer))
该函数的主要功能是把set_buffer中的内容置为0,在这里,即把it_value和it_interval置为0。

现在,我简单介绍一下这三个系统调用:
系统调用sys_getitimer(int which, struct itimerval *value)

首先,若value为NULL,则返回-EFAULT,说明这是一个bad address。
其次,把which类型的itimer取出放入get_buffer。
再次,若存放成功,再确认对value的写权利。
最后,则把get_buffer中的itimer取出,拷入value。

系统调用sys_setitimer(int which, struct itimerval *value,struct itimerval *ovalue)

首先,判断value是否为NULL,若不是,则确认对value是否有读的权利,并把set_buffer中的数据拷入value;若value为NULL,则把set_buffer中的内容置为0,即把it_value和it_interval置为0。
其次,判断ovalue是否为NULL,若不是,则确认对ovalue是否有写的权利。
再次,调用函数_setitimer设置由which指定类型的itimer。
最后,调用函数memcpy_tofs把get_buffer中的数据拷入ovalue,返回。

系统调用sys_alarm(unsigned int seconds)

该系统调用重新设置进程的real_itimer,若seconds为0,则把原先的alarm定时器删掉。并且设interval为0,故只触发一次,并把旧的real_timer存入oldalarm,并返回oldalarm。

[目录]


from lisolog

 

[目录]


index


中断流程

中断可以用下面的流程来表示:

中断产生源 --------> 中断向量表 (idt) -----------> 中断入口 ( 一般简单处理后调用相应的函数) ---------> 后续处理


根据中断产生源,我们可以把中断分成两个部分 :

内部中断( CPU 产生)
外部中断( 外部硬件产生 )

这些中断经过一些处理后,会有一些后续处理。

后面分别讨论:

内部中断
外部中断
后续处理

[目录]


内部中断


内部中断

内部中断有两种产生方式:

CPU 自发产生的: 如除数为0 的中断, page_fault 等
程序调用 int : int 80h

CPU自发产生的中断对应 idt 向量表中确定的位置,例如除数为0的中断在对应idt中第0个向量,
因此,内核只需要在第0个向量中设定相应的处理函数即可。

程序调用 int 可以产生的任何中断, 因此,前者是后者的子集。 特别的有:

int 80h

这是系统调用的中断.( system call )是用户代码调用内核代码的入口。

这里面可以考察的专题至少有:

*系统调用
*其它内部中断

[目录]


外部中断


外部中断

1.
外部中断是: 外部硬件(如时钟) -----> 中断芯片 ----> 中断向量表 -----> 中断入口

完成一个完整的映射,有4件事情要做:

(1) 将外部设备和中断芯片相应的管脚接上
(2) 对中断芯片设置,使得特定管脚的中断能映射到CPU idt特定的位置
(3) 程序中包含了这些中断入口
(4) 在中断向量表里设置向量相应的入口地址

这些工作需要在外部中断流程里描述

2.
由于硬件设备可能共用一个中断,在统一的函数中会有相应的结构来处理,也就是有16个结构分别处理相应的16个中断
特定的硬件驱动需要将自己的处理函数挂接到特定的结构上.

3.
但是,有一个问题:

驱动怎么知道自己的硬件产生哪个中断?

有一些是确定的,比如时钟是第0个, 软盘是第 5 个(right ??), 还有一些 PCI 设备是可以通过访问得到它们的中断号的,但是ISA设备需要通过探测(probe)来得到(详细情况可以参考 linux device driver )这涉及探测的工作

4.
因此,这里面要考察的工作至少包括:

1. i8259芯片的设置(包括上面的 (2) ), 以及一些其它属性的设置
2. 外部中断的流程
3. 处理外部中断的结构与相应的数据结构

 


下面是《LINUX系统分析...》中的一段,可供参考。我也有些疑惑,快下班了就明天说吧。
但有时一个设备驱动程序不知道设备将使用
哪一个中断。在P C I 结构中这不会成为一个问题,因为P C I 的设备驱动程序总是知道它们的中
断号。但对于I S A 结构而言,一个设备驱动程序找到自己使用的中断号却并不容易。L i n u x 系统
通过允许设备驱动程序探测自己的中断来解决这个问题。
首先,设备驱动程序使得设备产生一个中断。然后,允许系统中所有没有指定的中断,这
意味着设备挂起的中断将会通过中断控制器传送。L i n u x 系统读取中断状态寄存器然后将它的
值返回到设备驱动程序。一个非0 的结果意味着在探测期间发生了一个或者多个的中断。设备
驱动程序现在可以关闭探测,这时所有还未被指定的中断将继续被禁止。
一个ISA 设备驱动程序知道了它的中断号以后,就可以请求对中断的控制了。
PCI 结构的系统中断比I S A 结构的系统中断要灵活得多。I S A 设备使用中断插脚经常使用跳
线设置,所以在设备驱动程序中是固定的。但P C I 设备是在系统启动过程中P C I 初始化时由P C I
BIOS 或PCI 子系统分配的。每一个P C I 设备都有可能使用A 、B 、C 或者D 这4 个中断插脚中的
一个。缺省情况下设备使用插脚A 。
每个P C I 插槽的P C I 中断A 、B 、C 和D 是通过路由选择连接到中断控制器上的。所以P C I 插
槽4 的插脚A 可能连接到中断控制器的插脚6 ,P C I 插槽4 的插脚B 可能连接到中断控制器的插脚
7 ,以此类推。
P C I 中断具体如何进行路由一般依照系统的不同而不同,但系统中一定存在P C I 中断路由拓
扑结构的设置代码。在Intel PC 机中,系统的B I O S 代码负责中断的路由设置。对于没有B I O S 的
系统,L i n u x 系统内核负责设置。
P C I 的设置代码将中断控制器的插脚号写入到每个设备的PCI 设置头中。P C I 的设置代码根
据所知道的P C I 中断路由拓扑结构、P C I 设备使用的插槽,以及正在使用的P C I 中断的插脚号来
决定中断号,也就是I R Q 号。
系统中可以有很多的P C I 中断源,例如当系统使用了P C I - P C I 桥时。这时,中断源的数目可
能超过了系统可编程中断控制器上插脚的数目。在这种情况下,某些P C I 设备之间就不得不共
享一个中断,也就是说,中断控制器上的某一个插脚可以接收来自几个设备的中断。L i n u x 系
统通过让第一个中断源请求者宣布它使用的中断是否可以被共享来实现中断在几个设备之间共享的。中断共享使得i r q _ a c t i o n 数组中的同一个入口指向几个设备的i r q a c t i o n 结构。当一个共享
的中断有中断发生时,L i n u x 系统将会调用和此中断有关的所有中断处理程序。所有可以共享
中断的设备驱动程序的中断处理程序都可能在任何时候被调用,即使在自身没有中断需要处理
时。

 

 

[目录]


后续处理


后续处理
后续部分主要完成下面的工作

1. bottom_half
2. 是否能进程切换?
3.是否需要进程切换?是则切换
4.信号处理

特别的,有一个重要的下半部分就是时钟中断的下半部分。

bottom_half

正如许多书所说的,它们继续完成中断处理(在开中断的状态下), 因此中断中的处理函数需要在一个32位变量中设置特定的bit来告诉do_softirq要执行哪个bottom_half
(我们不妨把这个32位数想象成一个新的中断向量表,设置bit相当于产生中断,下半部分相当于handler,也许这是被称为软中断的原因吧)

bottom_half有的时候需要借助一个特殊的结构: task_queue 来完成更多的工作,

-----------------------------------
task_queue

task_queue 是一个链表,每个节点是一个函数指针,这样,一 个 bottom_half 就可以执行一个链表上的函数列了
当然 task_queue 不一定只在 bottom_half 中应用, 我查了一下, 在一些驱动中也直接调用 run_task_queue 来执行一个特定的队列.

-----------------------------------

如果内核需要在某个中断产生后执行它的函数,只需要在它下半部分调用的 task_queue 上挂上它的函数( Linux Device Driver 中有步进马达的例子)
现在的内核有些变化,增加了softirq_action tasklet, 不十分清楚是什么原因

是否需要进行切换

因为 linux是非抢占的,所以如果返回的代码段是内核级的话,就不允许进行切换。
如果能切换判断一下是否需要切换, 如果是就切换

信号处理

看是否有信号要处理,如果要调用 do_signal

时钟中断的下半部分
在上面许多的外部中断中,有一个特殊的中断的处理 timer_interrupt, 它的下半部分主要处理:时间计算和校准定时器工作

因此,我们有了下面的工作

*下半部分(包括softirq, tasklet, bottom_half )
*后续处理的流程
*时钟中断的下半部分
*定时器

[目录]


内存

 

[目录]


用户态


    用户空间存取内核空间,具体的实现方法要从两个方面考虑,先是用户进程,需要调用mmapp
来将自己的一段虚拟空间映射到内核态分配的物理内存;然后内核空间需要重新设置用户进程的
这段虚拟内存的页表,使它的物理地址指向对应的物理内存。针对linux内核的几种不同的内存分
配方式(kmalloc、vmalloc和ioremap),需要进行不同的处理。关于这个话题,前面已有文章述
了,<<Linxu设备驱动程序>>也专门用一章的内容来讲述,它们所用的方法是完全一样的。这里只
是重复说一遍,以温故而知新。

一、Linux内存管理概述

这里说一下我的理解,主要从数据结构说。

1、物理内存都是按顺序分成一页一页的,每页用一个page结构来描述。系统所有的物理页 面的page结

构描述就组成了一个数组mem_map。

2、进程的虚拟地址空间用task_struct的域mm来描述,它是一个mm_struct结构,这个结构包包含了指向?

程页目录的指针(pgd_t * pgd)和指向进程虚拟内存区域的指针(struct vm_area_structt * mmap)

3、进程虚拟内存区域具有相同属性的段用结构vm_area_struct描述(简称为VMA)。进程所所有的VMA?


树组织。

4、每个VMA就是一个对象,定义了一组操作,可以通过这组操作来对不同类型的VMA进行不屯 的处理。

例如对vmalloc分配的内存的映射就是通过其中的nopage操作实现的。

二、mmap处理过程

当用户调用mmap的时候,内核进行如下的处理:

1、先在进程的虚拟空间查找一块VMA;

2、将这块VMA去映射

3、如果设备驱动程序或者文件系统的file_operations定义了mmap操作,则调用它

4、将这个VMA插入到进程的VMA链中

file_operations的中定义的mmap方法原型如下:
int (*mmap) (struct file *, struct vm_area_struct *);

其中file是虚拟空间映射到的文件结构,vm_area_struct就是步骤1中找到的VMA。

三、缺页故障处理过程

当访问一个无效的虚拟地址(可能是保护故障,也可能缺页故障等)的时候,就会产生一个个页故障,?

统的处理过程如下:

1、找到这个虚拟地址所在的VMA;

2、如果必要,分配中间页目录表和页表

3、如果页表项对应的物理页面不存在,则调用这个VMA的nopage方法,它返回物理页面的paage描述结构

(当然这只是其中的一种情况)

4、针对上面的情况,将物理页面的地址填充到页表中

当页故障处理完后,系统将重新启动引起故障的指令,然后就可以正常访问了

下面是VMA的方法:
struct vm_operations_struct {
void (*open)(struct vm_area_struct * area);
void (*close)(struct vm_area_struct * area);
struct page * (*nopage)(struct vm_area_struct * area, unsigned long address, innt

write_access);
};

其中缺页函数nopage的address是引起缺页故障的虚拟地址,area是它所在的VMA,write_acccess是存取

属性。

三、具体实现

3.1、对kmalloc分配的内存的映射

对kmalloc分配的内存,因为是一段连续的物理内存,所以它可以简单的在mmap例程中设置汉 页表的物

理地址,方法是使用函数remap_page_range。它的原型如下:

int remap_page_range(unsigned long from, unsigned long phys_addr, unsigned long size,

pgprot_t prot)

其中from是映射开始的虚拟地址。这个函数为虚拟地址空间from和from+size之间的范围构栽 页表;

phys_addr是虚拟地址应该映射到的物理地址;size是被映射区域的大小;prot是保护标志?

remap_page_range的处理过程是对from到form+size之间的每一个页面,查找它所在的页目侣己 页表(

必要时建立页表),清除页表项旧的内容,重新填写它的物理地址与保护域。

remap_page_range可以对多个连续的物理页面进行处理。<<Linux设备驱动程序>>指出,

remap_page_range只能给予对保留的页和物理内存之上的物理地址的访问,当对非保留的页页使?

remap_page_range时,缺省的nopage处理控制映射被访问的虚地址处的零页。所以在分配内内存后,就?

对所分配的内存置保留位,它是通过函数mem_map_reserve实现的,它就是对相应物理页面?

PG_reserved标志位。(关于这一点,参见前面的主题为“关于remap_page_range的疑问”档奶致郏?

因为remap_page_range有上面的限制,所以可以用另外一种方式,就是采用和vmalloc分配档哪 存同样

的方法,对缺页故障进行处理。

3.2、对vmalloc分配的内存的映射


3.2.1、vmalloc分配内存的过程

(1)、进行预处理和合法性检查,例如将分配长度进行页面对齐,检查分配长度是否过大?

(2)、以GFP_KERNEL为优先级调用kmalloc分配(GFP_KERNEL用在进程上下文中,所以这里里就限制了?

中断处理程序中调用vmalloc)描述vmalloc分配的内存的vm_struct结构。

(3)、将size加一个页面的长度,使中间形成4K的隔离带,然后在VMALLOC_START和VMALLOOC_END之间

编历vmlist链表,寻找一段自由内存区间,将其地址填入vm_struct结构中

(4)、返回这个地址

vmalloc分配的物理内存并不连续

3.2.2、页目录与页表的定义

typedef struct { unsigned long pte_low; } pte_t;
typedef struct { unsigned long pmd; } pmd_t;
typedef struct { unsigned long pgd; } pgd_t;
#define pte_val(x) ((x).pte_low)

3.2.3、常见例程:

(1)、virt_to_phys():内核虚拟地址转化为物理地址
#define __pa(x)  ((unsigned long)(x)-PAGE_OFFSET)
extern inline unsigned long virt_to_phys(volatile void * address)
{
return __pa(address);
}

上面转换过程是将虚拟地址减去3G(PAGE_OFFSET=0XC000000),因为内核空间从3G到3G+实实际内存一?

映射到物理地址的0到实际内存

(2)、phys_to_virt():内核物理地址转化为虚拟地址
#define __va(x)  ((void *)((unsigned long)(x)+PAGE_OFFSET))
extern inline void * phys_to_virt(unsigned long address)
{
return __va(address);
}
virt_to_phys()和phys_to_virt()都定义在include/asm-i386/io.h中

(3)、#define virt_to_page(kaddr) (mem_map + (__pa(kaddr) >> PAGE_SHIFT))(内核核2.4?
   #define VALID_PAGE(page) ((page - mem_map) < max_mapnr)(内核2.4)
第一个宏根据虚拟地址,将其转换为相应的物理页面的page描述结构,第二个宏判断页面是是不是在有?

的物理页面内。(这两个宏处理的虚拟地址必须是内核虚拟地址,例如kmalloc返回的地址#杂?

vmalloc返回的地址并不能这样,因为vmalloc分配的并不是连续的物理内存,中间可能有空空洞?

3.2.4、vmalloc分配的内存的mmap的实现:

对vmalloc分配的内存需要通过设置相应VMA的nopage方法来实现,当产生缺页故障的时候,,会调用VM

的nopage方法,我们的目的就是在nopage方法中返回一个page结构的指针,为此,需要通过过如下步骤?

(1) pgd_offset_k或者 pgd_offset:查找虚拟地址所在的页目录表,前者对应内核空间档男 拟地址

,后者对应用户空间的虚拟地址
#define pgd_offset(mm, address) ((mm)->pgd+pgd_index(address))
#define pgd_offset_k(address) pgd_offset(&init_mm, address)
对于后者,init_mm是进程0(idle process)的虚拟内存mm_struct结构,所有进程的内核 页表都一样

。在vmalloc分配内存的时候,要刷新内核页目录表,2.4中为了节省开销,只更改了进程0档哪 核页目

录,而对其它进程则通过访问时产生页面异常来进行更新各自的内核页目录

(2)pmd_offset:找到虚拟地址所在的中间页目录项。在查找之前应该使用pgd_none判断适 否存在相

应的页目录项,这些函数如下:
extern inline int pgd_none(pgd_t pgd)  { return 0; }
extern inline pmd_t * pmd_offset(pgd_t * dir, unsigned long address)
{
return (pmd_t *) dir;
}

(3)pte_offset:找到虚拟地址对应的页表项。同样应该使用pmd_none判断是否存在相应档 中间页目

录:
#define pmd_val(x) ((x).pmd)
#define pmd_none(x) (!pmd_val(x))
#define __pte_offset(address) /
  ((address >> PAGE_SHIFT) & (PTRS_PER_PTE - 1))
#define pmd_page(pmd) /
  ((unsigned long) __va(pmd_val(pmd) & PAGE_MASK))
#define pte_offset(dir, address) ((pte_t *) pmd_page(*(dir)) + /
  __pte_offset(address))

(4)pte_present和pte_page:前者判断页表对应的物理地址是否有效,后者取出页表中物物理地址对?

的page描述结构
#define pte_present(x) ((x).pte_low & (_PAGE_PRESENT | _PAGE_PROTNONE))
#define pte_page(x) (mem_map+((unsigned long)(((x).pte_low >> PAGE_SHIFT))))
#define page_address(page) ((page)->virtual)

 


下面的一个DEMO与上面的关系不大,它是做这样一件事情,就是在启动的时候保留一段内存存,然后使?

ioremap将它映射到内核虚拟空间,同时又用remap_page_range映射到用户虚拟空间,这样亮 边都能访

问,通过内核虚拟地址将这段内存初始化串"abcd",然后使用用户虚拟地址读出来。

/************mmap_ioremap.c**************/
#include <linux/module.h>
#include <linux/kernel.h>
#include <linux/errno.h>
#include <linux/mm.h>
#include <linux/wrapper.h>  /* for mem_map_(un)reserve */
#include <asm/io.h>          /* for virt_to_phys */
#include <linux/slab.h>   /* for kmalloc and kfree */

MODULE_PARM(mem_start,"i");
MODULE_PARM(mem_size,"i");

static int mem_start=101,mem_size=10;
static char * reserve_virt_addr;
static int major;

int mmapdrv_open(struct inode *inode, struct file *file);
int mmapdrv_release(struct inode *inode, struct file *file);
int mmapdrv_mmap(struct file *file, struct vm_area_struct *vma);

static struct file_operations mmapdrv_fops =
{
  owner:   THIS_MODULE,
  mmap:    mmapdrv_mmap,
  open:    mmapdrv_open,
  release: mmapdrv_release,
};


int init_module(void)
{
  if ( ( major = register_chrdev(0, "mmapdrv", &mmapdrv_fops) ) < 0 )
    {
      printk("mmapdrv: unable to register character device/n");
      return (-EIO);
    }
  printk("mmap device major = %d/n",major );

  printk( "high memory physical address 0x%ldM/n",
   virt_to_phys(high_memory)/1024/1024 );

  reserve_virt_addr = ioremap( mem_start*1024*1024,mem_size*1024*1024);
  printk( "reserve_virt_addr = 0x%lx/n", (unsigned long)reserve_virt_addr );
  if ( reserve_virt_addr )
    {
      int i;
      for ( i=0;i<mem_size*1024*1024;i+=4)
{
   reserve_virt_addr[i] = 'a';
   reserve_virt_addr[i+1] = 'b';
   reserve_virt_addr[i+2] = 'c';
   reserve_virt_addr[i+3] = 'd';
}
    }
  else
    {
      unregister_chrdev( major, "mmapdrv" );
      return -ENODEV;
    }

  return 0;
}

/* remove the module */
void cleanup_module(void)
{
  if ( reserve_virt_addr )
    iounmap( reserve_virt_addr );

  unregister_chrdev( major, "mmapdrv" );

  return;
}

int mmapdrv_open(struct inode *inode, struct file *file)
{
  MOD_INC_USE_COUNT;
  return(0);
}

int mmapdrv_release(struct inode *inode, struct file *file)
{
  MOD_DEC_USE_COUNT;
  return(0);
}

int mmapdrv_mmap(struct file *file, struct vm_area_struct *vma)
{
  unsigned long offset = vma->vm_pgoff<<PAGE_SHIFT;
  unsigned long size = vma->vm_end - vma->vm_start;

  if ( size > mem_size*1024*1024 )
    {
      printk("size too big/n");
      return(-ENXIO);
    }

  offset = offset + mem_start*1024*1024;

  /* we do not want to have this area swapped out, lock it */
  vma->vm_flags |= VM_LOCKED;
  if ( remap_page_range(vma->vm_start,offset,size,PAGE_SHARED))
    {
      printk("remap page range failed/n");
      return -ENXIO;
    }

  return(0);
}


使用LDD2源码里面自带的工具mapper测试结果如下:

[root@localhost modprg]# insmod mmap_ioremap.mod
mmap device major = 254
high memory physical address 0x100M
reserve_virt_addr = 0xc7038000

[root@localhost modprg]# mknod mmapdrv c 254 0

[root@localhost modprg]# ./mapper mmapdrv 0 1024 | od -Ax -t x1
mapped "mmapdrv" from 0 to 1024
000000 61 62 63 64 61 62 63 64 61 62 63 64 61 62 63 64
*
000400

[root@localhost modprg]#

 

[目录]


内核页目录的初始化


内核页目录的初始化

内核页目录的初始化

/* swapper_pg_dir is the main page directory, address 0x00101000*/

>>> 内核页目录,第0,1项和第768、767项均为映射到物理内存0-8M的页目录项
>>> 其页表的物理地址是0x00102000和0x00103000,即下面的pg0和pg1所在的位置
>>> (在启动的时候,将内核映像移到0x0010000处)。
>>> 之所以第0,1项与第768和767相同,是因为在开启分页前的线性地址0-8M和开启
>>> 分页之后的3G-3G+8M均映射到相同的物理地址0-8M

/*
* This is initialized to create an identity-mapping at 0-8M (for bootup
* purposes) and another mapping of the 0-8M area at virtual address
* PAGE_OFFSET.
*/
.org 0x1000
ENTRY(swapper_pg_dir)
.long 0x00102007
.long 0x00103007
.fill BOOT_USER_PGD_PTRS-2,4,0
/* default: 766 entries */
.long 0x00102007
.long 0x00103007
/* default: 254 entries */
.fill BOOT_KERNEL_PGD_PTRS-2,4,0

/*
* The page tables are initialized to only 8MB here - the final page
* tables are set up later depending on memory size.
*/
>>> 下面为物理地址0-8M的页表项
>>> 从0x4000到0x2000共2k个页表项,映射0-8M的物理内存

.org 0x2000
ENTRY(pg0)

.org 0x3000
ENTRY(pg1)

/*
* empty_zero_page must immediately follow the page tables ! (The
* initialization loop counts until empty_zero_page)
*/

.org 0x4000
ENTRY(empty_zero_page)

>>> 进程0的页目录指向swapper_pg_dir
#define INIT_MM(name) /
{        /
mmap:  &init_mmap,    /
mmap_avl: NULL,     /
mmap_cache: NULL,     /
pgd:  swapper_pg_dir,   /
mm_users: ATOMIC_INIT(2),   /
mm_count: ATOMIC_INIT(1),   /
map_count: 1,     /
mmap_sem: __RWSEM_INITIALIZER(name.mmap_sem), /
page_table_lock: SPIN_LOCK_UNLOCKED,   /
mmlist:  LIST_HEAD_INIT(name.mmlist), /
}

/*
* paging_init() sets up the page tables - note that the first 8MB are
* already mapped by head.S.
*
* This routines also unmaps the page at virtual kernel address 0, so
* that we can trap those pesky NULL-reference errors in the kernel.
*/
void __init paging_init(void)
{
pagetable_init();

__asm__( "movl %%ecx,%%cr3/n" ::"c"(__pa(swapper_pg_dir)));

。。。。。。。。。。。
}


static void __init pagetable_init (void)
{
unsigned long vaddr, end;
pgd_t *pgd, *pgd_base;
int i, j, k;
pmd_t *pmd;
pte_t *pte, *pte_base;

>>> end虚拟空间的最大值(最大物理内存+3G)
/*
  * This can be zero as well - no problem, in that case we exit
  * the loops anyway due to the PTRS_PER_* conditions.
  */
end = (unsigned long)__va(max_low_pfn*PAGE_SIZE);

pgd_base = swapper_pg_dir;
#if CONFIG_X86_PAE
for (i = 0; i < PTRS_PER_PGD; i++)
  set_pgd(pgd_base + i, __pgd(1 + __pa(empty_zero_page)));
#endif
>>> 内核起始虚拟空间在内核页目录表中的索引
i = __pgd_offset(PAGE_OFFSET);
pgd = pgd_base + i;

>>> #define PTRS_PER_PGD 1024
>>> 对页目录的从768项开始的每一项
for (; i < PTRS_PER_PGD; pgd++, i++) {
>>> vaddr为第i项页目录项所映射的内核空间的起始虚拟地址,PGDIR_SIZE=4M
  vaddr = i*PGDIR_SIZE;
  if (end && (vaddr >= end))
   break;
#if CONFIG_X86_PAE
  pmd = (pmd_t *) alloc_bootmem_low_pages(PAGE_SIZE);
  set_pgd(pgd, __pgd(__pa(pmd) + 0x1));
#else
>>> 对两级映射机制,pmd实际上是pgd
  pmd = (pmd_t *)pgd;
#endif
  if (pmd != pmd_offset(pgd, 0))
   BUG();

  for (j = 0; j < PTRS_PER_PMD; pmd++, j++) {
   vaddr = i*PGDIR_SIZE + j*PMD_SIZE;
   if (end && (vaddr >= end))
    break;
>>> 假如内核不支持 Page Size Extensions
   if (cpu_has_pse) {
   。。。。。。。。。。
   }
>>> 分配内核页表
   pte_base = pte = (pte_t *) alloc_bootmem_low_pages(PAGE_SIZE);
>>> 对每一项页表项
   for (k = 0; k < PTRS_PER_PTE; pte++, k++) {
    vaddr = i*PGDIR_SIZE + j*PMD_SIZE + k*PAGE_SIZE;
    if (end && (vaddr >= end))
     break;
>>> 将页面的物理地址填入页表项中
    *pte = mk_pte_phys(__pa(vaddr), PAGE_KERNEL);
   }
>>> 将页表的物理地址填入到页目录项中
   set_pmd(pmd, __pmd(_KERNPG_TABLE + __pa(pte_base)));
   if (pte_base != pte_offset(pmd, 0))
    BUG();

  }
}

/*
  * Fixed mappings, only the page table structure has to be
  * created - mappings will be set by set_fixmap():

  */
vaddr = __fix_to_virt(__end_of_fixed_addresses - 1) & PMD_MASK;
fixrange_init(vaddr, 0, pgd_base);

#if CONFIG_HIGHMEM
。。。。。。。。。。。。
#endif

#if CONFIG_X86_PAE
。。。。。。。。。。。。
#endif
}

[目录]


内核线程页目录的借用


创建内核线程的时候,由于内核线程没有用户空间,而所有进程的内核页目录都是一样的((某些情况下可能有不同步的情况出现,主要是为了减轻同步所有进程内核页目录的开销,而只是在各个进程要访问内核空间,如果有不同步的情况,然后才进?
同步处理),所以创建的内核线程的
内核页目录总是借用进程0的内核页目录。

>>> kernel_thread以标志CLONE_VM调用clone系统调用
/*
* Create a kernel thread
*/
int kernel_thread(int (*fn)(void *), void * arg, unsigned long flags)
{
long retval, d0;

__asm__ __volatile__(
  "movl %%esp,%%esi/n/t"
  "int $0x80/n/t"  /* Linux/i386 system call */
  "cmpl %%esp,%%esi/n/t" /* child or parent? */
  /* Load the argument into eax, and push it.  That way, it does
   * not matter whether the called function is compiled with
   * -mregparm or not.  */
  "movl %4,%%eax/n/t"
  "pushl %%eax/n/t"
  "call *%5/n/t"  /* call fn */
  "movl %3,%0/n/t" /* exit */
  "int $0x80/n"
  "1:/t"
  :"=&a" (retval), "=&S" (d0)
  :"0" (__NR_clone), "i" (__NR_exit),
   "r" (arg), "r" (fn),
   "b" (flags | CLONE_VM)
  : "memory");
return retval;
}

>>> sys_clone->do_fork->copy_mm:
static int copy_mm(unsigned long clone_flags, struct task_struct * tsk)
{
struct mm_struct * mm, *oldmm;
int retval;

。。。。。。。。

tsk->mm = NULL;
tsk->active_mm = NULL;

/*
  * Are we cloning a kernel thread?
  *
  * We need to steal a active VM for that..
  */
>>> 如果是内核线程的子线程(mm=NULL),则直接退出,此时内核线程mm和active_mm均为为NULL
oldmm = current->mm;
if (!oldmm)
  return 0;

>>> 内核线程,只是增加当前进程的虚拟空间的引用计数
if (clone_flags & CLONE_VM) {
  atomic_inc(&oldmm->mm_users);
  mm = oldmm;
  goto good_mm;
}

。。。。。。。。。。

good_mm:
>>> 内核线程的mm和active_mm指向当前进程的mm_struct结构
tsk->mm = mm;
tsk->active_mm = mm;
return 0;

。。。。。。。
}

然后内核线程一般调用daemonize来释放对用户空间的引用:
>>> daemonize->exit_mm->_exit_mm:
/*
* Turn us into a lazy TLB process if we
* aren't already..
*/
static inline void __exit_mm(struct task_struct * tsk)
{
struct mm_struct * mm = tsk->mm;

mm_release();
if (mm) {
  atomic_inc(&mm->mm_count);
  if (mm != tsk->active_mm) BUG();
  /* more a memory barrier than a real lock */
  task_lock(tsk);
>>> 释放用户虚拟空间的数据结构
  tsk->mm = NULL;
  task_unlock(tsk);
  enter_lazy_tlb(mm, current, smp_processor_id());

>>> 递减mm的引用计数并是否为0,是则释放mm所代表的映射
  mmput(mm);
}
}

asmlinkage void schedule(void)
{
。。。。。。。。。
if (!current->active_mm) BUG();

。。。。。。。。。

prepare_to_switch();
{
  struct mm_struct *mm = next->mm;
  struct mm_struct *oldmm = prev->active_mm;
>>> mm = NULL,选中的为内核线程
  if (!mm) {
>>> 对内核线程,active_mm = NULL,否则一定是出错了
   if (next->active_mm) BUG();
>>> 选中的内核线程active_mm借用老进程的active_mm
   next->active_mm = oldmm;
   atomic_inc(&oldmm->mm_count);
   enter_lazy_tlb(oldmm, next, this_cpu);
  } else {
>>> mm != NULL 选中的为用户进程,active_mm必须与mm相等,否则一定是出错了
   if (next->active_mm != mm) BUG();
   switch_mm(oldmm, mm, next, this_cpu);
  }

>>> prev = NULL ,切换出去的是内核线程
  if (!prev->mm) {
>>> 设置其 active_mm = NULL 。
   prev->active_mm = NULL;
   mmdrop(oldmm);
  }
}

}

对内核线程的虚拟空间总结一下:
1、创建的时候:
父进程是用户进程,则mm和active_mm均共享父进程的,然后内核线程一般调用daemonize适头舖m
父进程是内核线程,则mm和active_mm均为NULL
总之,内核线程的mm = NULL;进程调度的时候以此为依据判断是用户进程还是内核线程。

2、进程调度的时候
如果切换进来的是内核线程,则置active_mm为切换出去的进程的active_mm;
如果切换出去的是内核线程,则置active_mm为NULL。

[目录]


用户进程内核页目录的建立


用户进程内核页目录的建立

在fork一个进程的时候,必须建立进程自己的内核页目录项(内核页目录项要
与用户空间的的页目录放在同一个物理地址连续的页面上,所以不能共享,但
所有进程的内核页表与进程0共享?


3G用户,页目录中一项映射4M的空间(一项页目录1024项页表,每项页表对应1个页面4K)# 即:
#define PGDIR_SHIFT 22
#define PGDIR_SIZE (1UL << PGDIR_SHIFT)

>>> sys_fork->do_fork->copy_mm->mm_init->pgd_alloc->get_pgd_slow

#if CONFIG_X86_PAE

。。。。。。。。。。。。。

#else

extern __inline__ pgd_t *get_pgd_slow(void)
{
>>> 分配页目录表(包含1024项页目录),即为一个进程分配的页目录可以映射的空间为10024*4M=4G
pgd_t *pgd = (pgd_t *)__get_free_page(GFP_KERNEL);

if (pgd) {
>>> #define USER_PTRS_PER_PGD (TASK_SIZE/PGDIR_SIZE)
>>> TASK_SIZE为3G大小,USER_PTRS_PER_PGD为用户空间对应的页目录项数目(3G/4M=768?
>>> 将用户空间的页目录项清空
  memset(pgd, 0, USER_PTRS_PER_PGD * sizeof(pgd_t));
>>> 将内核页目录表(swapper_pg_dir)的第768项到1023项拷贝到进程的页目录表的第7688项到1023项中
  memcpy(pgd + USER_PTRS_PER_PGD, swapper_pg_dir + USER_PTRS_PER_PGD, (PTRS_PER__PGD - USER_PTRS_PER_PGD) * sizeof(pgd_t));
}
return pgd;
}

#endif

[目录]


内核页目录的同步


内核页目录的同步

当一个进程在内核空间发生缺页故障的时候,在其处理程序中,就要通过0号进程的页目录览 同步本进程的内核页目录,实际上就是拷贝0号进程的内核页目录到本进程中(内核页表与进程0共享,故不需要复制)。如下:
asmlinkage void do_page_fault(struct pt_regs *regs, unsigned long error_code)
{
。。。。。。。。
>>> 缺页故障产生的地址
/* get the address */
__asm__("movl %%cr2,%0":"=r" (address));

tsk = current;

/*
  * We fault-in kernel-space virtual memory on-demand. The
  * 'reference' page table is init_mm.pgd.
  */
>>> 如果缺页故障在内核空间
if (address >= TASK_SIZE)
  goto vmalloc_fault;

。。。。。。。。。

vmalloc_fault:
{
  /*
   * Synchronize this task's top level page-table
   * with the 'reference' page table.
   */
  int offset = __pgd_offset(address);
  pgd_t *pgd, *pgd_k;
  pmd_t *pmd, *pmd_k;

  pgd = tsk->active_mm->pgd + offset;
  pgd_k = init_mm.pgd + offset;

>>> /*
>>>  * (pmds are folded into pgds so this doesnt get actually called,
>>>  * but the define is needed for a generic inline function.)
>>>  */
>>> #define set_pmd(pmdptr, pmdval) (*(pmdptr) = pmdval)
>>> #define set_pgd(pgdptr, pgdval) (*(pgdptr) = pgdval)

>>> 如果本进程的该地址的内核页目录不存在
  if (!pgd_present(*pgd)) {
>>> 如果进程0的该地址处的内核页目录也不存在,则出错
   if (!pgd_present(*pgd_k))
    goto bad_area_nosemaphore;
>>> 复制进程0的该地址的内核页目录到本进程的相应页目录中
   set_pgd(pgd, *pgd_k);
   return;
  }
>>> extern inline pmd_t * pmd_offset(pgd_t * dir, unsigned long address)
>>> {
>>>  return (pmd_t *) dir;
>>> }
  pmd = pmd_offset(pgd, address);
  pmd_k = pmd_offset(pgd_k, address);

>>> 对中间页目录,如果是两级页表,下面的几步操作与上面的重复
  if (pmd_present(*pmd) || !pmd_present(*pmd_k))
   goto bad_area_nosemaphore;
  set_pmd(pmd, *pmd_k);
  return;
}


/*
* Switch to real mode and then execute the code
* specified by the code and length parameters.
* We assume that length will aways be less that 100!
*/
void machine_real_restart(unsigned char *code, int length)
{

。。。。。。。。。。。。。

/* Remap the kernel at virtual address zero, as well as offset zero
    from the kernel segment.  This assumes the kernel segment starts at
    virtual address PAGE_OFFSET. */

memcpy (swapper_pg_dir, swapper_pg_dir + USER_PGD_PTRS,
  sizeof (swapper_pg_dir [0]) * KERNEL_PGD_PTRS);


/* Make sure the first page is mapped to the start of physical memory.
    It is normally not mapped, to trap kernel NULL pointer dereferences. */

pg0[0] = _PAGE_RW | _PAGE_PRESENT;

/*
  * Use `swapper_pg_dir' as our page directory.
  */
asm volatile("movl %0,%%cr3": :"r" (__pa(swapper_pg_dir)));

[目录]


内存管理 from aka


Linux 内存管理子系统导读

本文主要针对2.4的kernel。

关于本文的组织:

我的目标是‘导读’,提供linux内存管理子系统的整体概念,同时给出进一步深入研究某个部分时的辅助信息(包括代码组织,文件和主要函数的意义和一些参考文档)。之所以采取这种方式,是因为我本人在阅读代码的过程中,深感“读懂一段代码容易,把握整体思想却极不容易”。而且,在我写一些内核代码时,也觉得很多情况下,不一定非得很具体地理解所有内核代码,往往了解它的接口和整体工作原理就够了。当然,我个人的能力有限,时间也很不够,很多东西也是近期迫于讲座压力临时学的:),内容难免偏颇甚至错误,欢迎大家指正。

 

存储层次结构和x86存储管理硬件(MMU)

这里假定大家对虚拟存储,段页机制有一定的了解。主要强调一些很重要的或者容易误解的概念。


存储层次

高速缓存(cache) --〉 主存(main memory) ---〉 磁盘(disk)

理解存储层次结构的根源:CPU速度和存储器速度的差距。

层次结构可行的原因:局部性原理。

LINUX的任务:


减小footprint,提高cache命中率,充分利用局部性。


实现虚拟存储以满足进程的需求,有效地管理内存分配,力求最合理地利用有限的资源。

参考文档:

《too little,too small》by Rik Van Riel, Nov. 27,2000.

以及所有的体系结构教材:)


MMU的作用

辅助操作系统进行内存管理,提供虚实地址转换等硬件支持。


x86的地址

逻辑地址: 出现在机器指令中,用来制定操作数的地址。段:偏移

线性地址:逻辑地址经过分段单元处理后得到线性地址,这是一个32位的无符号整数,可用于定位4G个存储单元。

物理地址:线性地址经过页表查找后得出物理地址,这个地址将被送到地址总线上指示所要访问的物理内存单元。


LINUX: 尽量避免使用段功能以提高可移植性。如通过使用基址为0的段,使逻辑地址==线性地址。


x86的段

保护模式下的段:选择子+描述符。不仅仅是一个基地址的原因是为了提供更多的信息:保护、长度限制、类型等。描述符存放在一张表中(GDT或LDT),选择子可以认为是表的索引。段寄存器中存放的是选择子,在段寄存器装入的同时,描述符中的数据被装入一个不可见的寄存器以便cpu快速访问。(图)P40

专用寄存器:GDTR(包含全局描述附表的首地址),LDTR(当前进程的段描述附表首地址),TSR(指向当前进程的任务状态段)


LINUX使用的段:

__KERNEL_CS: 内核代码段。范围 0-4G。可读、执行。DPL=0。

__KERNEL_DS:内核代码段。范围 0-4G。可读、写。DPL=0。

__USER_CS:内核代码段。范围 0-4G。可读、执行。DPL=3。

__USER_DS:内核代码段。范围 0-4G。可读、写。DPL=3。

TSS(任务状态段):存储进程的硬件上下文,进程切换时使用。(因为x86硬件对TSS有一定支持,所有有这个特殊的段和相应的专用寄存器。)

default_ldt:理论上每个进程都可以同时使用很多段,这些段可以存储在自己的ldt段中,但实际linux极少利用x86的这些功能,多数情况下所有进程共享这个段,它只包含一个空描述符。

还有一些特殊的段用在电源管理等代码中。

(在2.2以前,每个进程的ldt和TSS段都存在GDT中,而GDT最多只能有8192项,因此整个系统的进程总数被限制在4090左右。2。4里不再把它们存在GDT中,从而取消了这个限制。)

__USER_CS和__USER_DS段都是被所有在用户态下的进程共享的。注意不要把这个共享和进程空间的共享混淆:虽然大家使用同一个段,但通过使用不同的页表由分页机制保证了进程空间仍然是独立的。

 

x86的分页机制

x86硬件支持两级页表,奔腾pro以上的型号还支持Physical address Extension Mode和三级页表。所谓的硬件支持包括一些特殊寄存器(cr0-cr4)、以及CPU能够识别页表项中的一些标志位并根据访问情况做出反应等等。如读写Present位为0的页或者写Read/Write位为0的页将引起CPU发出page fault异常,访问完页面后自动设置accessed位等。


linux采用的是一个体系结构无关的三级页表模型(如图),使用一系列的宏来掩盖各种平台的细节。例如,通过把PMD看作只有一项的表并存储在pgd表项中(通常pgd表项中存放的应该是pmd表的首地址),页表的中间目录(pmd)被巧妙地‘折叠’到页表的全局目录(pgd),从而适应了二级页表硬件。


6. TLB

TLB全称是Translation Look-aside Buffer,用来加速页表查找。这里关键的一点是:如果操作系统更改了页表内容,它必须相应的刷新TLB以使CPU不误用过时的表项。


7. Cache

Cache 基本上是对程序员透明的,但是不同的使用方法可以导致大不相同的性能。linux有许多关键的地方对代码做了精心优化,其中很多就是为了减少对cache不必要的污染。如把只有出错情况下用到的代码放到.fixup section,把频繁同时使用的数据集中到一个cache行(如struct task_struct),减少一些函数的footprint,在slab分配器里头的slab coloring等。

另外,我们也必须知道什么时候cache要无效:新map/remap一页到某个地址、页面换出、页保护改变、进程切换等,也即当cache对应的那个地址的内容或含义有所变化时。当然,很多情况下不需要无效整个cache,只需要无效某个地址或地址范围即可。实际上,

intel在这方面做得非常好用,cache的一致性完全由硬件维护。

 

关于x86处理器更多信息,请参照其手册:Volume 3: Architecture and Programming Manual,可以从ftp://download.intel.com/design/pentium/MANUALS/24143004.pdf获得


8. Linux 相关实现

这一部分的代码和体系结构紧密相关,因此大多位于arch子目录下,而且大量以宏定义和inline函数形式存在于头文件中。以i386平台为例,主要的文件包括:


page.h

页大小、页掩码定义。PAGE_SIZE,PAGE_SHIFT和PAGE_MASK。

对页的操作,如清除页内容clear_page、拷贝页copy_page、页对齐page_align

还有内核虚地址的起始点:著名的PAGE_OFFSET:)和相关的内核中虚实地址转换的宏__pa和__va.。

virt_to_page从一个内核虚地址得到该页的描述结构struct page *.我们知道,所有物理内存都由一个memmap数组来描述。这个宏就是计算给定地址的物理页在这个数组中的位置。另外这个文件也定义了一个简单的宏检查一个页是不是合法:VALID_PAGE(page)。如果page离memmap数组的开始太远以至于超过了最大物理页面应有的距离则是不合法的。

比较奇怪的是页表项的定义也放在这里。pgd_t,pmd_t,pte_t和存取它们值的宏xxx_val

 

pgtable.h pgtable-2level.h pgtable-3level.h

顾名思义,这些文件就是处理页表的,它们提供了一系列的宏来操作页表。pgtable-2level.h和pgtable-2level.h则分别对应x86二级、三级页表的需求。首先当然是表示每级页表有多少项的定义不同了。而且在PAE模式下,地址超过32位,页表项pte_t用64位来表示(pmd_t,pgd_t不需要变),一些对整个页表项的操作也就不同。共有如下几类:

[pte/pmd/pgd]_ERROR 出措时要打印项的取值,64位和32位当然不一样。

set_[pte/pmd/pgd] 设置表项值

pte_same 比较 pte_page 从pte得出所在的memmap位置

pte_none 是否为空。

__mk_pte 构造pte

pgtable.h的宏太多,不再一一解释。实际上也比较直观,通常从名字就可以看出宏的意义来了。pte_xxx宏的参数是pte_t,而ptep_xxx的参数是pte_t *。2.4 kernel在代码的clean up方面还是作了一些努力,不少地方含糊的名字变明确了,有些函数的可读性页变好了。

pgtable.h里除了页表操作的宏外,还有cache和tlb刷新操作,这也比较合理,因为他们常常是在页表操作时使用。这里的tlb操作是以__开始的,也就是说,内部使用的,真正对外接口在pgalloc.h中(这样分开可能是因为在SMP版本中,tlb的刷新函数和单机版本区别较大,有些不再是内嵌函数和宏了)。


8.3 pgalloc.h

包括页表项的分配和释放宏/函数,值得注意的是表项高速缓存的使用:

pgd/pmd/pte_quicklist

内核中有许多地方使用类似的技巧来减少对内存分配函数的调用,加速频繁使用的分配。如buffer cache中buffer_head和buffer,vm区域中最近使用的区域。

还有上面提到的tlb刷新的接口

8.4 segment.h

定义 __KERNEL_CS[DS] __USER_CS[DS]


参考:

《Understanding the Linux Kernel》的第二章给了一个对linux 的相关实现的简要描述,

 

物理内存的管理。

2.4中内存管理有很大的变化。在物理页面管理上实现了基于区的伙伴系统(zone based buddy system)。区(zone)的是根据内存的不同使用类型划分的。对不同区的内存使用单独的伙伴系统(buddy system)管理,而且独立地监控空闲页等。

(实际上更高一层还有numa支持。Numa(None Uniformed Memory Access)是一种体系结构,其中对系统里的每个处理器来说,不同的内存区域可能有不同的存取时间(一般是由内存和处理器的距离决定)。而一般的机器中内存叫做DRAM,即动态随机存取存储器,对每个单元,CPU用起来是一样快的。NUMA中访问速度相同的一个内存区域称为一个Node,支持这种结构的主要任务就是要尽量减少Node之间的通信,使得每个处理器要用到的数据尽可能放在对它来说最快的Node中。2.4内核中node&#0;相应的数据结构是pg_data_t,每个node拥有自己的memmap数组,把自己的内存分成几个zone,每个zone再用独立的伙伴系统管理物理页面。Numa要对付的问题还有很多,也远没有完善,就不多说了)

一些重要的数据结构粗略地表示如下:

 


基于区的伙伴系统的设计&#0;物理页面的管理

内存分配的两大问题是:分配效率、碎片问题。一个好的分配器应该能够快速的满足各种大小的分配要求,同时不能产生大量的碎片浪费空间。伙伴系统是一个常用的比较好的算法。(解释:TODO)

引入区的概念是为了区分内存的不同使用类型(方法?),以便更有效地利用它们。

2.4有三个区:DMA, Normal, HighMem。前两个在2.2实际上也是由独立的buddy system管理的,但2.2中还没有明确的zone的概念。DMA区在x86体系结构中通常是小于16兆的物理内存区,因为DMA控制器只能使用这一段的内存。而HighMem是物理地址超过某个值(通常是约900M)的高端内存。其他的是Normal区内存。由于linux实现的原因,高地址的内存不能直接被内核使用,如果选择了CONFIG_HIGHMEM选项,内核会使用一种特殊的办法来使用它们。(解释:TODO)。HighMem只用于page cache和用户进程。这样分开之后,我们将可以更有针对性地使用内存,而不至于出现把DMA可用的内存大量给无关的用户进程使用导致驱动程序没法得到足够的DMA内存等情况。此外,每个区都独立地监控本区内存的使用情况,分配时系统会判断从哪个区分配比较合算,综合考虑用户的要求和系统现状。2.4里分配页面时可能会和高层的VM代码交互(分配时根据空闲页面的情况,内核可能从伙伴系统里分配页面,也可能直接把已经分配的页收回&#0;reclaim等),代码比2.2复杂了不少,要全面地理解它得熟悉整个VM工作的机理。

整个分配器的主要接口是如下函数(mm.h page_alloc.c):


struct page * alloc_pages(int gfp_mask, unsigned long order) 根据gftp_mask的要求,从适当的区分配2^order个页面,返回第一个页的描述符。


#define alloc_page(gfp_mask) alloc_pages(gfp_mask,0)


unsigned long __get_free_pages((int gfp_mask, unsigned long order) 工作同alloc_pages,但返回首地址。


#define __get_free_page(gfp_mask) __get_free_pages(gfp_mask,0)


get_free_page 分配一个已清零的页面。


__free_page(s) 和free_page(s)释放页面(一个/多个)前者以页面描述符为参数,后者以页面地址为参数。


关于Buddy算法,许多教科书上有详细的描述,<Understanding the Linux Kernel>第六章对linux的实现有一个很好的介绍。关于zone base buddy更多的信息,可以参见Rik Van Riel 写的" design for a zone based memory allocator"。这个人是目前linuxmm的维护者,权威啦。这篇文章有一点过时了,98年写的,当时还没有HighMem,但思想还是有效的。还有,下面这篇文章分析2.4的实现代码:

http://home.earthlink.net/~jknapka/linux-mm/zonealloc.html。


2. Slab--连续物理区域管理

单单分配页面的分配器肯定是不能满足要求的。内核中大量使用各种数据结构,大小从几个字节到几十上百k不等,都取整到2的幂次个页面那是完全不现实的。2.0的内核的解决方法是提供大小为2,4,8,16,...,131056字节的内存区域。需要新的内存区域时,内核从伙伴系统申请页面,把它们划分成一个个区域,取一个来满足需求;如果某个页面中的内存区域都释放了,页面就交回到伙伴系统。这样做的效率不高。有许多地方可以改进:


不同的数据类型用不同的方法分配内存可能提高效率。比如需要初始化的数据结构,释放后可以暂存着,再分配时就不必初始化了。


内核的函数常常重复地使用同一类型的内存区,缓存最近释放的对象可以加速分配和释放。


对内存的请求可以按照请求频率来分类,频繁使用的类型使用专门的缓存,很少使用的可以使用类似2.0中的取整到2的幂次的通用缓存。


使用2的幂次大小的内存区域时高速缓存冲突的概率较大,有可能通过仔细安排内存区域的起始地址来减少高速缓存冲突。


缓存一定数量的对象可以减少对buddy系统的调用,从而节省时间并减少由此引起的高速缓存污染。

2.2实现的slab分配器体现了这些改进思想。

主要数据结构

接口:

kmem_cache_create/kmem_cache_destory

kmem_cache_grow/kmem_cache_reap 增长/缩减某类缓存的大小

kmem_cache_alloc/kmem_cache_free 从某类缓存分配/释放一个对象

kmalloc/kfree 通用缓存的分配、释放函数。

相关代码(slab.c)。

相关参考:

http://www.lisoleg.net/lisoleg/memory/slab.pdf :Slab发明者的论文,必读经典。

<Understanding the Linux Kernel> 第六章,具体实现的详细清晰的描述。

AKA2000年的讲座也有一些大虾讲过这个主题,请访问aka主页:www.aka.org.cn


3.vmalloc/vfree &#0;物理地址不连续,虚地址连续的内存管理

使用kernel页表。文件vmalloc.c,相对简单。


三、2.4内核的VM(完善中。。。)


进程地址空间管理

创建,销毁。

mm_struct, vm_area_struct, mmap/mprotect/munmap

page fault处理,demand page, copy on write


相关文件:

include/linux/mm.h:struct page结构的定义,page的标志位定义以及存取操作宏定义。struct vm_area_struct定义。mm子系统的函数原型说明。

include/linux/mman.h:和vm_area_struct的操作mmap/mprotect/munmap相关的常量宏定义。

memory.c:page fault处理,包括COW和demand page等。

对一个区域的页表相关操作:

zeromap_page_range: 把一个范围内的页全部映射到zero_page

remap_page_range:给定范围的页重新映射到另一块地址空间。

zap_page_range:把给定范围内的用户页释放掉,页表清零。

mlock.c: mlock/munlock系统调用。mlock把页面锁定在物理内存中。

mmap.c::mmap/munmap/brk系统调用。

mprotect.c: mprotect系统调用。

前面三个文件都大量涉及vm_area_struct的操作,有很多相似的xxx_fixup的代码,它们的任务是修补受到影响的区域,保证vm_area_struct 链表正确。

 

交换

目的:


使得进程可以使用更大的地址空间。


同时容纳更多的进程。

任务:


选择要换出的页


决定怎样在交换区中存储页面


决定什么时候换出


kswapd内核线程:每10秒激活一次

任务:当空闲页面低于一定值时,从进程的地址空间、各类cache回收页面

为什么不能等到内存分配失败再用try_to_free_pages回收页面?原因:


有些内存分配时在中断或异常处理调用,他们不能阻塞


有时候分配发生在某个关键路径已经获得了一些关键资源的时候,因此它不能启动IO。如果不巧这时所有的路径上的内存分配都是这样,内存就无法释放。

kreclaimd 从inactive_clean_list回收页面,由__alloc_pages唤醒。

相关文件:

mm/swap.c kswapd使用的各种参数以及操作页面年龄的函数。

mm/swap_file.c 交换分区/文件的操作。

mm/page_io.c 读或写一个交换页。

mm/swap_state.c swap cache相关操作,加入/删除/查找一个swap cache等。

mm/vmscan.c 扫描进程的vm_area,试图换出一些页面(kswapd)。

reclaim_page:从inactive_clean_list回收一个页面,放到free_list

kclaimd被唤醒后重复调用reclaim_page直到每个区的

zone->free_pages>= zone->pages_low

page_lauder:由__alloc_pages和try_to_free_pages等调用。通常是由于freepages + inactive_clean_list的页太少了。功能:把inactive_dirty_list的页面转移到inactive_clean_list,首先把已经被写回文件或者交换区的页面(by bdflush)放到inactive_clean_list,如果freepages确实短缺,唤醒bdflush,再循环一遍把一定数量的dirty页写回。

关于这几个队列(active_list,inactive_dirty_list,inactive_clean_list)的逻辑,请参照:文档:RFC: design for new VM,可以从lisoleg的文档精华获得。

,


page cache、buffer cache和swap cache

page cache:读写文件时文件内容的cache,大小为一个页。不一定在磁盘上连续。

buffer cache:读写磁盘块的时候磁盘块内容的cache,buffer cache的内容对应磁盘上一个连续的区域,一个buffer cache大小可能从512(扇区大小)到一个页。

swap cache: 是page cache的子集。用于多个进程共享的页面被换出到交换区的情况。

 

page cache 和 buffer cache的关系

本质上是很不同的,buffer cache缓冲磁盘块内容,page cache缓冲文件的一页内容。page cache写回时会使用临时的buffer cache来写磁盘。


bdflush: 把dirty的buffer cache写回磁盘。通常只当dirty的buffer太多或者需要更多的buffer而内存开始不足时运行。page_lauder也可能唤醒它。

kupdate: 定时运行,把写回期限已经到了的dirty buffer写回磁盘。


2.4的改进:page cache和buffer cache耦合得更好了。在2.2里,磁盘文件的读使用page cache,而写绕过page cache,直接使用buffer cache,因此带来了同步的问题:写完之后必须使用update_vm_cache()更新可能有的page cache。2.4中page cache做了比较大的改进,文件可以通过page cache直接写了,page cache优先使用high memory。而且,2.4引入了新的对象:file address space,它包含用来读写一整页数据的方法。这些方法考虑到了inode的更新、page cache处理和临时buffer的使用。page cache和buffer cache的同步问题就消除了。原来使用inode+offset查找page cache变成通过file address space+offset;原来struct page 中的inode成员被address_space类型的mapping成员取代。这个改进还使得匿名内存的共享成为可能(这个在2.2很难实现,许多讨论过)。


4. 虚存系统则从freeBSD借鉴了很多经验,针对2.2的问题作了巨大的调整。

文档:RFC: design for new VM不可不读。

由于时间仓促,新vm的很多细微之处我也还没来得及搞清楚。先大致罗列一下,以后我将进一步完善本文,争取把问题说清楚。另外,等这学期考试过后,我希望能为大家提供一些详细注释过的源代码。


Lisoleg收集了一些内存管理方面的文档和链接,大家可以看一看。

http://www.lisoleg.net/lisoleg/memory/index.html

[目录]


mlock代码分析


        系统调用mlock的作用是屏蔽内存中某些用户进程所要求的页。
        mlock调用的语法为:
                int sys_mlock(unsigned long start, size_t len);
初始化为:
        len=(len+(start &~PAGE_MASK)+ ~PAGE_MASK)&PAGE_MASK;
start &=PAGE_MASK;
其中mlock又调用do_mlock(),语法为:
int do_mlock(unsigned long start, size_t len,int on);
初始化为:
        len=(len+~PAGE_MASK)&PAGE_MASK;

    由mlock的参数可看出,mlock对由start所在页的起始地址开始,长度为len(注:len=(len+(start&~PAGE_MASK)+ ~PAGE_MASK)&PAGE_MASK)的内存区域的页进行加锁。
sys_mlock如果调用成功返回,这其中所有的包含具体内存区域的页必须是常驻内存的,或者说在调用munlock 或 munlockall之前这部分被锁住的页面必须保留在内存。当然,如果调用mlock的进程终止或者调用exec执行其他程序,则这部分被锁住的页面被释放。通过fork()调用所创建的子进程不能够继承由父进程调用mlock锁住的页面。
    内存屏蔽主要有两个方面的应用:实时算法和高度机密数据的处理。实时应用要求严格的分时,比如调度,调度页面是程序执行延时的一个主要因素。保密安全软件经常处理关键字节,比如密码或者密钥等数据结构。页面调度的结果是有可能将这些重要字节写到外存(如硬盘)中去。这样一些黑客就有可能在这些安全软件删除这些在内存中的数据后还能访问部分在硬盘中的数据。        而对内存进行加锁完全可以解决上述难题。
    内存加锁不使用压栈技术,即那些通过调用mlock或者mlockall被锁住多次的页面可以通过调用一次munlock或者munlockall释放相应的页面
    mlock的返回值分析:若调用mlock成功,则返回0;若不成功,则返回-1,并且errno被置位,进程的地址空间保持原来的状态。返回错误代码分析如下:
   ENOMEM:部分具体地址区域没有相应的进程地址空间与之对应或者超出了进程所允许的最大可锁页面。
   EPERM:调用mlock的进程没有正确的优先权。只有root进程才允许锁住要求的页面。
EINVAL:输入参数len不是个合法的正数。


mlock所用到的主要数据结构和重要常量

1.mm_struct
struct mm_struct {
        int count;
        pgd_t * pgd; /* 进程页目录的起始地址,如图2-3所示 */
        unsigned long context;
        unsigned long start_code, end_code, start_data, end_data;
        unsigned long start_brk, brk, start_stack, start_mmap;
        unsigned long arg_start, arg_end, env_start, env_end;
        unsigned long rss, total_vm, locked_vm;
        unsigned long def_flags;
        struct vm_area_struct * mmap;     /* 指向vma双向链表的指针 */
        struct vm_area_struct * mmap_avl; /* 指向vma AVL树的指针 */
        struct semaphore mmap_sem;
}
start_code、end_code:进程代码段的起始地址和结束地址。
start_data、end_data:进程数据段的起始地址和结束地址。
arg_start、arg_end:调用参数区的起始地址和结束地址。
env_start、env_end:进程环境区的起始地址和结束地址。
rss:进程内容驻留在物理内存的页面总数。


2. 虚存段(vma)数据结构:vm_area_atruct

虚存段vma由数据结构vm_area_atruct(include/linux/mm.h)描述:
struct vm_area_struct {
        struct mm_struct * vm_mm;        /* VM area parameters */
        unsigned long vm_start;
        unsigned long vm_end;
        pgprot_t vm_page_prot;
        unsigned short vm_flags;
/* AVL tree of VM areas per task, sorted by address */
        short vm_avl_height;
        struct vm_area_struct * vm_avl_left;
        struct vm_area_struct * vm_avl_right;
/* linked list of VM areas per task, sorted by address */
        struct vm_area_struct * vm_next;
/* for areas with inode, the circular list inode->i_mmap */
/* for shm areas, the circular list of attaches */
/* otherwise unused */
        struct vm_area_struct * vm_next_share;
        struct vm_area_struct * vm_prev_share;
/* more */
        struct vm_operations_struct * vm_ops;
        unsigned long vm_offset;
        struct inode * vm_inode;
        unsigned long vm_pte;                        /* shared mem */
};

vm_start;//所对应内存区域的开始地址
vm_end; //所对应内存区域的结束地址
vm_flags; //进程对所对应内存区域的访问权限
vm_avl_height;//avl树的高度
vm_avl_left; //avl树的左儿子
vm_avl_right; //avl树的右儿子
vm_next;// 进程所使用的按地址排序的vm_area链表指针
vm_ops;//一组对内存的操作
    这些对内存的操作是当对虚存进行操作的时候Linux系统必须使用的一组方法。比如说,当进程准备访问某一虚存区域但是发现此区域在物理内存不存在时(缺页中断),就激发某种对内存的操作执行正确的行为。这种操作是空页(nopage)操作。当Linux系统按需调度可执行的页面映象进入内存时就使用这种空页(nopage)操作。
    当一个可执行的页面映象映射到进程的虚存地址时,一组vm_area_struct结构的数据结构(vma)就会生成。每一个vm_area_struct的数据结构(vma)代表可执行的页面映象的一部分:可执行代码,初始化数据(变量),非初始化数据等等。Linux系统可以支持大量的标准虚存操作,当vm_area_struct数据结构(vma)一被创建,它就对应于一组正确的虚存操作。
    属于同一进程的vma段通过vm_next指针连接,组成链表。如图2-3所示,struct mm_struct结构的成员struct vm_area_struct * mmap  表示进程的vma链表的表头。
    为了提高对vma段 查询、插入、删除操作的速度,LINUX同时维护了一个AVL(Adelson-Velskii and Landis)树。在树中,所有的vm_area_struct虚存段均有左指针vm_avl_left指向相邻的低地址虚存段,右指针vm_avl_right指向相邻的高地址虚存段,如图2-5。struct mm_struct结构的成员struct vm_area_struct * mmap_avl表示进程的AVL树的根,vm_avl_height表示AVL树的高度。
    对平衡树mmap_avl的任何操作必须满足平衡树的一些规则:
Consistency and balancing rulesJ(一致性和平衡规则):

tree->vm_avl_height==1+max(heightof(tree->vm_avl_left),heightof(
tree->vm_avl_right))
abs( heightof(tree->vm_avl_left) - heightof(tree->vm_avl_right) ) <= 1
foreach node in tree->vm_avl_left: node->vm_avl_key <= tree->vm_avl_key,        foreach node in tree->vm_avl_right: node->vm_avl_key >= tree->vm_avl_key.
        注:其中node->vm_avl_key= node->vm_end

对vma可以进行加锁、加保护、共享和动态扩展等操作。

3.重要常量
    mlock系统调用所用到的重要常量有:PAGE_MASK、PAGE_SIZE、PAGE_SHIFT、RLIMIT_MEMLOCK、VM_LOCKED、 PF_SUPERPRIV等。它们的值分别如下:
        PAGE_SHIFT                        12                                // PAGE_SHIFT determines the page size
        PAGE_SIZE                        0x1000                        //1UL<<PAGE_SHIFT
        PAGE_MASK                        ~(PAGE_SIZE-1)        //a very useful constant variable
        RLIMIT_MEMLOCK                8                                //max locked-in-memory address space
        VM_LOCKED                        0x2000                        //8*1024=8192, vm_flags的标志之一。
        PF_SUPERPRIV                0x00000100                //512,

 

mlock系统调用代码函数功能分析

下面对各个函数的功能作详细的分析((1)和(2)在前面简介mlock时已介绍过,并在后面有详细的程序流程):
suser():如果用户有效(即current->euid == 0        ),则设置进程标志为root优先权(current->flags |= PF_SUPERPRIV),并返回1;否则返回0。
find_vma(struct mm_struct * mm, unsigned long addr):输入参数为当前进程的mm、需要加锁的开始内存地址addr。find_vma的功能是在mm的mmap_avl树中寻找第一个满足mm->mmap_avl->vm_start<=addr< mm->mmap_avl->vm_end的vma,如果成功则返回此vma;否则返回空null。
mlock_fixup(struct vm_area_struct * vma, unsigned long start, unsigned long end, unsigned int newflags):输入参数为vm_mmap链中的某个vma、需要加锁内存区域起始地址和结束地址、需要修改的标志(0:加锁,1:释放锁)。
merge_segments(struct mm_struct * mm, unsigned long start_addr, unsigned long end_addr):输入参数为当前进程的mm、需要加锁的开始内存地址start_addr和结束地址end_addr。merge_segments的功能的是尽最大可能归并相邻(即内存地址偏移量连续)并有相同属性(包括vm_inode,vm_pte,vm_ops,vm_flags)的内存段,在这过程中冗余的vm_area_structs被释放,这就要求vm_mmap链按地址大小排序(我们不需要遍历整个表,而只需要遍历那些交叉或者相隔一定连续区域的邻接vm_area_structs)。当然在缺省的情况下,merge_segments是对vm_mmap_avl树进行循环处理,有多少可以合并的段就合并多少。
mlock_fixup_all(struct vm_area_struct * vma, int newflags):输入参数为vm_mmap链中的某个vma、需要修改的标志(0:加锁,1:释放锁)。mlock_fixup_all的功能是根据输入参数newflags修改此vma的vm_flags。
mlock_fixup_start(struct vm_area_struct * vma,unsigned long end, int newflags):输入参数为vm_mmap链中的某个vma、需要加锁内存区域结束地址、需要修改的标志(0:加锁,1:释放锁)。mlock_fixup_start的功能是根据输入参数end,在内存中分配一个新的new_vma,把原来的vma分成两个部分: new_vma和vma,其中new_vma的vm_flags被设置成输入参数newflags;并且按地址(new_vma->start和new_vma->end)大小序列把新生成的new->vma插入到当前进程mm的mmap链或mmap_avl树中(缺省情况下是插入到mmap_avl树中)。
        注:vma->vm_offset+= vma->vm_start-new_vma->vm_start;
mlock_fixup_end(struct vm_area_struct * vma,unsigned long start, int newflags):输入参数为vm_mmap链中的某个vma、需要加锁内存区域起始地址、需要修改的标志(0:加锁,1:释放锁)。mlock_fixup_end的功能是根据输入参数start,在内存中分配一个新的new_vma,把原来的vma分成两个部分:vma和new_vma,其中new_vma的vm_flags被设置成输入参数newflags;并且按地址大小序列把new->vma插入到当前进程mm的mmap链或mmap_avl树中。
        注:new_vma->vm_offset= vma->vm_offset+(new_vma->vm_start-vma->vm_start);
mlock_fixup_middle(struct vm_area_struct * vma,unsigned long start, unsigned long end, int newflags):输入参数为vm_mmap链中的某个vma、需要加锁内存区域起始地址和结束地址、需要修改的标志(0:加锁,1:释放锁)。mlock_fixup_middle的功能是根据输入参数start、end,在内存中分配两个新vma,把原来的vma分成三个部分:left_vma、vma和right_vma,其中vma的vm_flags被设置成输入参数newflags;并且按地址大小序列把left->vma和right->vma插入到当前进程mm的mmap链或mmap_avl树中。
        注:vma->vm_offset += vma->vm_start-left_vma->vm_start;
                right_vma->vm_offset += right_vma->vm_start-left_vma->vm_start;
kmalloc():将在后面3.3中有详细讨论。
insert_vm_struct(struct mm_struct *mm, struct vm_area_struct *vmp):输入参数为当前进程的mm、需要插入的vmp。insert_vm_struct的功能是按地址大小序列把vmp插入到当前进程mm的mmap链或mmap_avl树中,并且把vmp插入到vmp->inode的i_mmap环(循环共享链)中。
avl_insert_neighbours(struct vm_area_struct * new_node,** ptree,** to_the_left,** to_the_right):输入参数为当前需要插入的新vma结点new_node、目标mmap_avl树ptree、新结点插入ptree后它左边的结点以及它右边的结点(左右边结点按mmap_avl中各vma->vma_end大小排序)。avl_insert_neighbours的功能是插入新vma结点new_node到目标mmap_avl树ptree中,并且调用avl_rebalance以保持ptree的平衡树特性,最后返回new_node左边的结点以及它右边的结点。
avl_rebalance(struct vm_area_struct *** nodeplaces_ptr, int count):输入参数为指向vm_area_struct指针结构的指针数据nodeplaces_ptr[](每个元素表示需要平衡的mmap_avl子树)、数据元素个数count。avl_rebalance的功能是从nodeplaces_ptr[--count]开始直到nodeplaces_ptr[0]循环平衡各个mmap_avl子树,最终使整个mmap_avl树平衡。
down(struct semaphore * sem):输入参数为同步(进入临界区)信号量sem。down的功能根据当前信号量的设置情况加锁(阻止别的进程进入临界区)并继续执行或进入等待状态(等待别的进程执行完成退出临界区并释放锁)。
        down定义在/include/linux/sched.h中:
extern inline void down(struct semaphore * sem)
{
        if (sem->count <= 0)
                __down(sem);
        sem->count--;
}
up(struct semaphore * sem)输入参数为同步(进入临界区)信号量sem。up的功能根据当前信号量的设置情况(当信号量的值为负数:表示有某个进程在等待使用此临界区 )释放锁。
        up定义在/include/linux/sched.h中:
extern inline void up(struct semaphore * sem)
{
        sem->count++;
        wake_up(&sem->wait);
        }
kfree_s(a,b):kfree_s定义在/include/linux/malloc.h中:#define kfree_s(a,b) kfree(a)。而kfree()将在后面3.3中详细讨论。
avl_neighbours(struct vm_area_struct * node,* tree,** to_the_left,** to_the_right):输入参数为作为查找条件的vma结点node、目标mmap_avl树tree、node左边的结点以及它右边的结点(左右边结点按mmap_avl中各vma->vma_end大小排序)。avl_ neighbours的功能是根据查找条件node在目标mmap_avl树ptree中找到node左边的结点以及它右边的结点,并返回。
avl_remove(struct vm_area_struct * node_to_delete, ** ptree):输入参数为需要删除的结点node_to_delete和目标mmap_avl树ptree。avl_remove的功能是在目标mmap_avl树ptree中找到结点node_to_delete并把它从平衡树中删除,并且调用avl_rebalance以保持ptree的平衡树特性。
remove_shared_vm_struct(struct vm_area_struct *mpnt):输入参数为需要从inode->immap环中删除的vma结点mpnt。remove_shared_vm_struct的功能是从拥有vma结点mpnt 的inode->immap环中删除的该结点。

 

[目录]


memory.c


Memory.c中,Linux提供了对虚拟内存操作的若干函数,其中包括对虚拟页的复制、新建页表、清除页表、处理缺页中断等等。

1.static inline void copy_page(unsigned long from, unsigned long to)
为了节约内存的使用,在系统中,各进程通常采用共享内存,即不同的进程可以共享同一段代码段或数据段。当某一进程发生对共享的内存发生写操作时,为了不影响其它进程的正常运行,系统将把该内存块复制一份,供需要写操作的进程使用,这就是所谓的copy-on-write机制。copy_page就是提供复制内存功能的函数,它调用C语言中标准的内存操作函数,将首地址为from的一块虚拟内存页复制到首地址为to的空间中。

2、void clear_page_tables(struct task_struct * tsk)
clear_page_table的功能是将传入的结构tsk中的pgd页表中的所有项都清零,同时将二级页表所占的空间都释放掉。传入clear_page_tables的是当前进程的tsk结构,取得该进程的一级页目录指针pgd后,采用循环的方式,调用free_one_pgd清除pgd表。表共1024项。在free_one_pgd中,实际执行的功能只调用一次free_one_pmd(在80x86中,由于硬件的限制,只有两级地址映射,故将pmd与pgd合并在一起)。在free_one_pmd中,函数调用pte_free将对应于pmd的二级页表所占的物理空间释放掉(进程代码、数据所用的物理内存在do_munmap释放掉了)并将pmd赋值为零。
clear_page_table在系统启动一个可执行文件的映象或载入一个动态链接库时被调用。在fs/exec.c中的do_load_elf_binary()或do_load_aout_binary()调用flash_old_exec,后者调用exec_mmap,而exec_mmap调用clear_page_table。其主要功能是当启动一个新的应用程序的时候,将复制的mm_struct中的页表清除干净,并释放掉原有的所有二级页表空间。

3、void oom(struct task_struct * task)
返回出错信息。

4、void free_page_tables(struct mm_struct * mm)
在free_page_table中,大部分的代码与clear_page_table中的函数一致。所不同的是,该函数在最后调用了pgd_free(page_dir),即不光释放掉二级页表所占的空间,同时还释放一级页目录所占的空间。这是因为free_page_tables被__exit_mm调用,__exit_mm又被do_exit (kernel/kernel.c)调用。当进程中止、系统退出或系统重起时都需要用do_exit(属于进程管理)将所有的进程结束掉。在结束进程过程中 ,将调用free_page_table将进程的空间全部释放掉,当然包括释放进程一级页目录所占的空间。

5、int new_page_tables(struct task_struct * tsk)
该函数的主要功能是建立新的页目录表,它的主要流程如如下:
调用pgd_alloc()为新的页目录表申请一片4K空间 。
将初始化进程的内存结构中从768项开始到1023项的内容复制给新的页表(所有的进程都共用虚拟空间中 3G~4G的内存,即在核心态时可以访问所有相同的存储空间)。
调用宏SET_PAGE_DIR(include/asm/pgtable.h)将进程控制块tsk->ts->CR3的值改为新的页目录表的首地址,同时将CPU中的CR3寄存器的值改为新的页目录表的首地址,从而使新进程进入自己的运行空间。
将tsk->mm->pgd改为新的页目录表的首地址。
new_page_tables被copy_mm调用,而copy_mm被copy_mm_do_fork调用,这两个函数都在kernel/fork.c中。同时,new_page_tables也可以在exec_mmap(fs/exec.c)中调用。即新的进程的产生可以通过两种途径,一种是fork,在程序中动态地生成新的进程,这样新进程的页表原始信息利用copy_mm从其父进程中继承而得,另一种是运行一个可执行文件映象,通过文件系统中的exec.c,将映象复制到tsk结构中。两种方法都需要调用new_page_tables为新进程分配页目录表。

6、static inline void copy_one_pte(pte_t * old_pte, pte_t * new_pte, int cow)
将原pte页表项复制到new_pte上,其流程如下:
检测old_pte是否在内存中,如不在物理内存中,调用swap_duplicate按old_pte在swap file中的入口地址,将old_pte复制到内存中,同时把old_pte的入口地址赋给new_pte并返回。反之转向3。
获取old_pte对应的物理地址的页号。
根据页号判断old_pte是否为系统保留的,如果为系统保留的,这些页为所有的进程在核心态下使用,用户进程没有写的权利,则只需将old_pte指针直接转赋给new_pte后返回。反之则该pte属于普通内存的,则转向4。
根据传入的C-O-W标志,为old_pte置写保护标志,如果该页是从swap_cache中得来的,将old_pte页置上“dirty”标志。将old_pte赋值给new_pte。
将mem_map结构中关于物理内存使用进程的个数的数值count加1。

7、static inline int copy_pte_range(pmd_t *dst_pmd, pmd_t *src_pmd,
unsigned long address, unsigned long size, int cow)
通过循环调用copy_one_pte将从源src_pmd中以地址address开始的长度为size的空间复制给dst_pmd中。如dst_pmd中还未分配地址为address的页表项,则先给三级页表pte表分配4K空间。(每调用一次copy_one_pte复制4K空间。在一次copy_pte_range中最多可复制4M空间)。

8、static inline int copy_pmd_range(pgd_t *dst_pgd, pgd_t *src_pgd,
unsigned long address, unsigned long size, int cow)
通过循环调用copy_pte_range将从源src_pgd中以地址address开始的长度为size的空间复制给dst_pgd中。如dst_pgd中还未分配地址为address的页表项,则在一级(同时也是二级)页表中给对应的pmd分配目录项。

9、int copy_page_range(struct mm_struct *dst, struct mm_struct *src,
                        struct vm_area_struct *vma)
该函数的主要功能是将某个任务或进程的vma块复制给另一个任务或进程。其工作机制是循环调用copy_pmd_range,将vma块中的所有虚拟空间复制到对应的虚拟空间中。在做复制之前,必须确保新任务对应的被复制的虚拟空间中必须都为零。copy_page_range按dup_mmap()->copy_mm()->do_fork()的顺序被调用(以上三个函数均在kernel/fork.c中)。当进程被创建的时候,需要从父进程处复制所有的虚拟空间,copy_page_range完成的就是这个任务。copy_page_range的函数调用关系见图8。

9、static inline void free_pte(pte_t page)
虚存页page如在内存中,且不为系统的保留内存,调用free_page将其释放掉(如在系统保留区中,则为全系统共享,故不能删除)。
如page在swap file中,调用swap_free()将其释放。

10、static inline void forget_pte(pte_t page)
如page不为空,调用free_pte将其释放。

11、static inline void zap_pte_range(pmd_t * pmd, unsigned long address,
unsigned long size)
zap为zero all pages的缩写。该函数的作用是将在pmd中从虚拟地址address开始,长度为size的内存块通过循环调用pte_clear将其页表项清零,调用free_pte将所含空间中的物理内存或交换空间中的虚存页释放掉。在释放之前,必须检查从address开始长度为size的内存块有无越过PMD_SIZE.(溢出则可使指针逃出0~1023的区间)。

12、static inline void zap_pmd_range(pgd_t * dir, unsigned long address, unsigned long size)
函数结构与zap_pte_range类似,通过调用zap_pte_range完成对所有落在address到address+size区间中的所有pte的清零工作。zap_pmd_range至多清除4M空间的物理内存。

13、int zap_page_range(struct mm_struct *mm, unsigned long address, unsigned long size)
函数结构与前两个函数类似。将任务从address开始到address+size长度内的所有对应的pmd都清零。zap_page_range的主要功能是在进行内存收缩、释放内存、退出虚存映射或移动页表的过程中,将不在使用的物理内存从进程的三级页表中清除。(在讨论clear_page_tables时,就提到过当进程退出时,释放页表之前,先保证将页表对应项清零,保证在处于退出状态时,进程不占用0~3G的空间。)


14、static inline void zeromap_pte_range(pte_t * pte, unsigned long address,
unsigned long size, pte_t zero_pte)
15、static inline int zeromap_pmd_range(pmd_t * pmd, unsigned long address,
unsigned long size, pte_t zero_pte)
16、int zeromap_page_range(unsigned long address, unsigned long size, pgprot_t prot)
这三个函数与前面的三个函数从结构上看很相似,他们的功能是将虚拟空间中从地址address开始,长度为size的内存块所对应的物理内存都释放掉,同时将指向这些区域的pte都指向系统中专门开出的长度为4K,全为0的物理页。zeromap_page_range在kernel代码中没有被引用,这个函数是旧版本的Linux遗留下来的,在新版本中已经被zap_page_range所替代。

17、static inline void remap_pte_range(pte_t * pte, unsigned long address,
unsigned long size,        unsigned long offset, pgprot_t prot)
18、static inline int remap_pmd_range(pmd_t * pmd, unsigned long address,
unsigned long size,        unsigned long offset, pgprot_t prot)
19、int remap_page_range(unsigned long from, unsigned long offset, unsigned long size,
pgprot_t prot)
这三个函数也同前面的函数一样,层层调用,现仅介绍一下最后一个函数的作用。remap_page_range的功能是将原先被映射到虚拟内存地址from处的,大小为size的虚拟内存块映射到以偏移量offset为起始地址的虚拟内存中,同时将原来的pte、pmd项都清零。该函数也是逐级调用,在remap_pte_range中,通过set_pte将的物理页映射到新的虚拟内存页表项pte上。remap_page_range函数的功能与下文中的remap.c中介绍的功能相近,因此在kernel中也没有用到。

20、unsigned long put_dirty_page(struct task_struct * tsk, unsigned long page,
unsigned long address)
将虚拟内存页page链接到任务tsk中虚拟地址为address的虚拟内存中,其主要调用的流程如下:put_dirty_page->setup_arg_page->do_load_xxx_binary(xxx为aout或elf,这些函数都在fs/exec.c中),它的功能是将在载入可执行文件的时候,将其相关的堆栈信息、环境变量等复制到当前进程的空间上。

21、void handle_mm_fault(struct vm_area_struct * vma, unsigned long address,
int write_access)
        用于处理ALPHA机中的缺页中断

 

[目录]


mmap.c


        mmap.c
在mmap.c中,主要提供了对进程内存管理进行支持的函数,主要包括了do_mmap、do_munmap等对进程的虚拟块堆avl数进行管理的函数。

有关avl树的一些操作:
1、static inline void avl_neighbours (struct vm_area_struct * node, struct vm_area_struct * tree, struct vm_area_struct ** to_the_left, struct vm_area_struct ** to_the_right)
寻找avl树tree中的节点node的前序节点和后序节点,将结果放在指针to_the_left和to_the_right中,即使得*to_the_left->next=node,node->next=*to_the_right。在实际搜索中,过程是找到node节点中的左节点的最右节点和右节点的最左节点,采用avl树搜索可以提高效率。

2、static inline void avl_rebalance (struct vm_area_struct *** nodeplaces_ptr, int count)
将由于插入操作或删除操作而造成不平衡的avl树恢复成平衡状态。nodeplaces_ptr是指向的是需要调整的子树的根节点,count是该子树的高度。

static inline void avl_insert (struct vm_area_struct * new_node,
struct vm_area_struct ** ptree)
将新节点new_node插入avl树ptree中,并将该树重新生成平衡avl树。在创建avl树时,将vma模块不断的插入avl树中,构建一个大的avl树。当进程创建时,复制父进程后需要将以双向链表拷贝过来的vma链生成avl树。

4、static inline void avl_insert_neighbours (struct vm_area_struct * new_node, struct vm_area_struct ** ptree,        struct vm_area_struct ** to_the_left, struct vm_area_struct ** to_the_right)
将新节点new_node插入avl树ptree中,并将该树重新生成平衡avl树,同时返回该新节点的前序节点和后序节点。

5、static inline void avl_remove (struct vm_area_struct * node_to_delete, struct vm_area_struct ** ptree)
将指定要删除的节点node_to_delete从avl树ptree中删除。并将该树重新生成平衡avl树。该函数在释放虚存空间和归并vma链表是使用。

7、static void printk_list (struct vm_area_struct * vma)
8、static void printk_avl (struct vm_area_struct * tree)
9、static void avl_checkheights (struct vm_area_struct * tree)
10、static void avl_checkleft (struct vm_area_struct * tree, vm_avl_key_t key)
11、static void avl_checkright (struct vm_area_struct * tree, vm_avl_key_t key)
12、static void avl_checkorder (struct vm_area_struct * tree)
13、static void avl_check (struct task_struct * task, char *caller)
这些函数都是系统调试时用以检测avl树结构的正确性

14、static inline int vm_enough_memory(long pages)
通过计算当前系统中所剩的空间判断是否足够调用。可使用的内存包括缓冲存储器、页缓存、主存中的空闲页、swap缓存等。

15、static inline unsigned long vm_flags(unsigned long prot, unsigned long flags)
提供宏功能将页的保护位和标志位合并起来。

16、unsigned long get_unmapped_area(unsigned long addr, unsigned long len)
从虚拟内存address开始找到未分配的连续空间大于len的虚拟空间块,并将该快的首地址返回。

17、unsigned long do_mmap(struct file * file, unsigned long addr, unsigned long len,
        unsigned long prot, unsigned long flags, unsigned long off)
do_mmap在Linux虚拟内存管理中是一个很重要的函数,它的主要功能是将可执行文件的映象映射到虚拟内存中,或将别的进程中的内存信息映射到该进程的虚拟空间中。并将映射了的虚拟块的vma加入到该进程的vma avl树中。其运行的流程如下,更详细的分析请参阅林涛同学和徐玫峰同学的报告。
检验给定的映射长度len是大于1页,小于一个任务的最大长度3G且加上进程的加上偏移量off不会溢出。如不满足则退出。
如果当前任务的内存是上锁的,检验加上len后是否会超过当前进程上锁长度的界限。如是则退出。
如果从文件映射,检验文件是否有读的权限。如无在退出。
调用get_unmaped取得从地址address开始未映射的连续虚拟空间大于len的虚存块。
如从文件映射,保证该文件控制块有相应的映射操作。
为映射组织该区域申请vma结构。
调用vm_enough_memory有足够的内存。如无则释放6中申请的vma,退出。
如果是文件映射,调用file->f_op_mmap将该文件映射如vma中。
调用insert_vm_struct将vma插入该进程的avl树中。
归并该avl树。

18、void merge_segments (struct mm_struct * mm, unsigned long start_addr,
unsigned long end_addr)
经过对进程虚拟空间不断的映射,在进程中的vma块有许多是可以合并的,为了提高avl树查找的效率,减少avl树中不必要的vma块,通常需要将这些块和并,merge_segments的功能为合并虚拟空间中从start_addr到end_addr中类型相同,首尾相连的vma块。由于只有经过增加操作采有可能合并,所有merge_segments只在do_mmap和unmap_fixup中被调用。该函数的流程如下:
根据起始地址start_addr从找到第一块满足vm_end>start_addr的vma块mpnt。
调用avl_neighbours找到在vma双向链表上与mpnt前后相连的vma块prev和next。
如果prev和mpnt首尾相连,且有同样在swap file中的节点,同样的标志,同样的操作等则将其合并,反之转向6。
调用avl_remove将mpnt从avl树中删除,调整prev的结束地址和后序指针。
将结构mpnt所占的物理空间删除。
prev、mpnt、next依次下移,如未超过end_addr则返回3。

19、static void unmap_fixup(struct vm_area_struct *area, unsigned long addr, size_t len)
释放虚拟空间中的某些区域的时候,将会出现四种情况:
将整个vma释放掉
将vma的前半部分释放掉
将vma的后半部分释放掉
将vma的中间部分释放掉
为了正常维护vma树,当第一种情况是,将整个vma释放掉。同时释放vma结构所占的空间。第二种,释放后半部分,修改vma的相关信息。第二种,释放前半部分,修改vma的相关信息。第四种,由于在vma中出现了一个洞,则需增加一个vma结构描述新出现的vma块。unmap_fixup所执行的工作就是当释放空间时,修正对vma树的影响。

20、int do_munmap(unsigned long addr, size_t len)
do_munmap将释放落在从地址addr开始,长度为len空间内的vma所对应的虚拟空间。do_munmap被系统调用sys_munmap所调用(对sys_munmap如何工作的不甚了解)。下面是该函数的流程:
通过find_vma根据addr找到第一块vma->end>addr的vma块mpnt。
调用avl_neighbours找到mpnt在链表中的相邻指针prev和next。
将检查中所有与虚拟空间addr~addr+len相交的vma块放入free链表中。同时如果该vma链接在共享内存中,则将其从该环形链表中释放出来。
按序搜索free链表,调用unmap_fixup释放空间。
调用zap_page_range将指向释放掉的虚拟空间中的pte页表项清零。
调用kfree释放mpnt结构占用的空间。

remap.c
该文件提供了对虚拟内存重映射的若干函数。在下文中将介绍这些函数的功能,分析这些函数在虚拟内存管理中所起的作用。同时详细介绍其中主要函数的流程。

static inline pte_t *get_one_pte(struct mm_struct *mm, unsigned long addr)
根据输入的虚存地址返回其在虚拟内存中的对应的页表项pte。

static inline pte_t *alloc_one_pte(struct mm_struct *mm, unsigned long addr)
根据输入的虚存地址addr在pgd表中根据三级页表映射机制找pte,如果在pgd表中无对应的项,则分配给一个pgd(pmd)表项,在这个表项内分配根据addr分配pte,将pte返回。

static inline int copy_one_pte(pte_t * src, pte_t * dst)
将目的pte(dst)表项中的值赋成源pte(src)中的值,然后将源pte中的值清零,根据这函数的功能取move_one_pte更合适。

static int move_one_page(struct mm_struct *mm,
         unsigned long old_addr, unsigned long new_addr)
根据输入的虚拟地址old_addr调用get_one_pte获取该地址在三级页表中的pte项,调用copy_one_pte将该pte对应的物理页指针移到根据new_addr对应的pte项上,即在虚拟空间内移动一虚拟内存页。

static int move_page_tables(struct mm_struct * mm,
         unsigned long new_addr, unsigned long old_addr, unsigned long len)
将虚拟地址空间中从old_addr开始的长度为len的虚拟内存移动到以new_addr为起始地点的的虚拟空间中,以下为该函数的流程:
将所需移动的内存长度len赋值给偏移量offset如果offset=0,结束。反之转向2。
将偏移量offset减去一个页的长度,调用move_one_page将从old_addr+offset开始的一页移到new_addr+offset。若发生错误则转到4。
如果offset不为0,则转向1,反之结束。
调用move_one_page将所有已移动到新地址的页移回源地址,调用zap_page_range将从new_addr开始的移动过的页pte清零,并返回出错信息-1。

static inline unsigned long move_vma(struct vm_area_struct * vma,
        unsigned long addr, unsigned long old_len, unsigned long new_len)
将虚存中的vma块vma的起始地址为addr,长度为old_len的内存块扩展为长度为new_len的内存块,并在虚存中找到可容纳长度为new_len块的连续区域,返回首地址。其工作流程如下:
给新的vma结构块new_vma分配空间,如果不成功返回出错信息。
调用get_unmap_area从addr开始找到第一个未被利用的虚存空洞,空洞长度大于给定的新的虚拟内存块的长度len,将其首地址赋给new_addr。如果未招到,则转向9。
调用move_page_tables将从addr开始的长度为old_len的内存区域移动到以new_addr为起始地址的虚拟空间中。
修改new_vma块中关于起始地址,结束地址的值。
将新的new_vma块插入到当前进程的虚拟内存所链成的双向链表和avl树中。
调用merge_segment将虚拟空间中地址可能连结在一起的不同的vma段连结成一个vma块,同时删除冗于的vma块。
将原有空间中的从addr开始,长度为old_len的虚拟空间释放掉。
修改mm结构中的所有虚存的长度,返回新的起始虚拟地址new_addr。
将vma块new_vma释放掉并返回出错信息。

asmlinkage unsigned long sys_mremap(unsigned long addr,         unsigned long old_len,
                    unsigned long new_len        unsigned long flags)
sys_remap是一个系统调用,其主要功能是扩展或收缩现有的虚拟空间。它的主要工作流程如下:
检查addr地址是否小于4096,如小于,则非法,返回。
将原始长度old_len和需要扩展或收缩的长度new_len页对齐。
如果有old_len>new_len,则说明是收缩空间,调用do_munmap将虚存空间中从new_len到old_len的空间释放掉。返回收缩后的首地址addr。
根据addr找到第一块vma块满足vma->end > addr,检查addr是否落在虚存的空洞中,如是,则返回出错信息。
检查需要扩展的内存块是否落在该vma块中,越界则返回出错信息。
如果该vma是上锁的,则检测上锁的内存扩展后是否越界,如是,则7返回出错信息 。
检测当前进程的虚存空间经扩展后是否超过系统给该进程的最大空间。如是,则返回出错信息。
如果找到vma块从addr开始到块末尾的长度为old_len且(old_len的长度不等于new_len或该虚存是不可移动的),则转向9,反之转向10。
检测从跟随找到的vma块的未分配的空间是否大于需要扩展空间。如果大于,则直接将扩展的空间挂在找到的vma块后,修改vma块中相关的信息,并返回扩展后虚拟块的首地址。如小于转向10。
如果当前虚拟块是是不可移动的,则返回错误信息。反之,调用move_vma将需要扩展的虚拟块移动可以容纳其长度new_len的虚拟空间中。


对于sys_remap这个系统调用,在何种情况下激活这个系统调用,令人不解。在Linux中所有的系统调用在代码中仅在engry.s中有该调用的入口,在程序中有其具体实现,但是令人很难找到这两者在系统运行中是如何有机的结合在一起的。

[目录]


伙伴(buddy)算法


2.4版内核的页分配器引入了"页区"(zone)结构, 一个页区就是一大块连续的物理页面. Linux 2.4将整个物理内存划分为3个页区, DMA页区(ZONE_DMA), 普通页区(ZONE_NORMAL)和高端页区(ZONE_HIGHMEM).
页区可以使页面分配更有目的性, 有利于减少内存碎片. 每个页区的页分配仍使用伙伴(buddy)算法.
伙伴算法将整个页区划分为以2为幂次的各级页块的集合, 相邻的同次页块称为伙伴, 一对伙伴可以合并
到更高次页面集合中去.

下面分析一下伙伴算法的页面释放过程.

; mm/page_alloc.c:

#define BAD_RANGE(zone,x) (((zone) != (x)->zone) || (((x)-mem_map) offset) || (((x)-mem_map) >= (zone)->offset+(zone)->size))

#define virt_to_page(kaddr)        (mem_map + (__pa(kaddr) >> PAGE_SHIFT))
#define put_page_testzero(p)         atomic_dec_and_test(

void free_pages(unsigned long addr, unsigned long order)
{        order是页块尺寸指数, 即页块的尺寸有(2^order)页.
        if (addr != 0)
                __free_pages(virt_to_page(addr), order);
}
void __free_pages(struct page *page, unsigned long order)
{
        if (!PageReserved(page)  put_page_testzero(page))
                __free_pages_ok(page, order);
}
static void FASTCALL(__free_pages_ok (struct page *page, unsigned long order));
static void __free_pages_ok (struct page *page, unsigned long order)
{
        unsigned long index, page_idx, mask, flags;
        free_area_t *area;
        struct page *base;
        zone_t *zone;

        if (page->buffers)
                BUG();
        if (page->mapping)
                BUG();
        if (!VALID_PAGE(page))
                BUG();
        if (PageSwapCache(page))
                BUG();
        if (PageLocked(page))
                BUG();
        if (PageDecrAfter(page))
                BUG();
        if (PageActive(page))
                BUG();
        if (PageInactiveDirty(page))
                BUG();
        if (PageInactiveClean(page))
                BUG();

        page->flags  ~((1        page->age = PAGE_AGE_START;

        zone = page->zone; 取page所在的页区

        mask = (~0UL)         base = mem_map + zone->offset; 求页区的起始页
        page_idx = page - base; 求page在页区内的起始页号
        if (page_idx  ~mask) 页号必须在页块尺寸边界上对齐
                BUG();
        index = page_idx >> (1 + order);
                ; 求页块在块位图中的索引, 每一索引位置代表相邻两个"伙伴"
        area = zone->free_area + order; 取该指数页块的位图平面

        spin_lock_irqsave( flags);

        zone->free_pages -= mask; 页区的自由页数加上将释放的页数(掩码值为负)

        while (mask + (1                 struct page *buddy1, *buddy2;

                if (area >= zone->free_area + MAX_ORDER) 如果超过了最高次平面
                        BUG();
                if (!test_and_change_bit(index, area->map)) 测试并取反页块的索引位
                        /*
                        * the buddy page is still allocated.
                        */
                        break; 如果原始位为0, 则说明该页块原来没有伙伴, 操作完成
                /*
                * Move the buddy up one level. 如果原始位为1, 则说明该页块存在一个伙伴
                */
                buddy1 = base + (page_idx ^ -mask); 对页块号边界位取反,得到伙伴的起点
                buddy2 = base + page_idx;

                if (BAD_RANGE(zone,buddy1)) 伙伴有没有越过页区范围
                        BUG();
                if (BAD_RANGE(zone,buddy2))
                        BUG();

                memlist_del( 删除伙伴的自由链
                mask                 area++; 求更高次位图平面
                index >>= 1; 求更高次索引号
                page_idx  mask; 求更高次页块的起始页号
        }
        memlist_add_head( + page_idx)->list,  将求得的高次页块加入该指数的自由链

        spin_unlock_irqrestore( flags);

        /*
        * We don't want to protect this variable from race conditions
        * since it's nothing important, but we do want to make sure
        * it never gets negative.
        */
        if (memory_pressure > NR_CPUS)
                memory_pressure--;
}

 

 

[目录]


页目录处理的宏


对于i386的2级分页机构,每个页目录字高20位是页号,低12位是页属性.
如果将页目录字的低12位屏蔽成0,整个页目录字就是相应页面的物理地址,下面是常用的一些页目录处理的宏.


typedef struct { unsigned long pgd; } pgd_t;                 一级页目录字结构
typedef struct { unsigned long pmd; } pmd_t;                 中级页目录字结构
typedef struct { unsigned long pte_low; } pte_t;          末级页目录字结构
typedef struct { unsigned long pgprot; } pgprot_t;        页属性字结构

pgd_t *pgd = pgd_offset(mm_struct,addr);
        取进程虚拟地址addr的一级页目录字指针,扩展为
        ((mm_struct)->pgd + ((address >> 22)  0x3FF))

pgd_t *pgd = pgd_offset_k(addr)
        取内核地址addr的一级页目录字指针,扩展为
        (init_mm.pgd + ((address >> 22)  0x3FF));

pmd_t *pmd = pmd_offset(pgd, addr) ;
        从一级页目录字指针取addr的中级页录字指针,在2级分页系统中,它们的值是相同的,扩展为
        (pmd_t *)(pgd);

pte_t *pte = pte_offset(pmd, addr)
        从中级页目录字指针取addr的末级页目录字指针,扩展为
        (pte_t *)((pmd->pmd  0xFFFFF000) + 0xC0000000) + ((addr >> 12)  0x3FF);

struct page *page = pte_page(pte_val));
        取末级页目录字pte_val的页面映射指针,扩展为
        (mem_map+(pte_val.pte_low >> 12))

pte_t pte_val = ptep_get_and_clear(pte);
        取末级页目录字指针pte的值,并将该目录字清零,扩展为
        (pte_t){xchg(

pte_t pte_val = mk_pte(page,pgprot);
        将页面映射指针page与页属性字pgprot组合成页目录字,扩展为
        (pte_t) { (page - mem_map)
pte_t pte_val =  mk_pte_phys(physpage, pgprot);
        将物理地址physpage所在页面与页属性字组合成页目录字,扩展为
        (pte_t) { physpage >> 12
unsigned long addr = pmd_page(pmd_val);
        取中级页目录字所表示的页目录虚拟地址,扩展为
        ((unsigned long) (pmd_val.pmd  0xFFFFF000 + 0xC0000000));

set_pte(pte,pte_val);
        设置末级页目录字,扩展为
        *pte = pteval;
set_pmd(pmd,pmd_val)
        设置中级页目录字,扩展为
        *pmd = pmd_val;
set_pgd(pgd,pgd_val)
        设置一级页目录字,扩展为
        *pgd = pgd_val;

 

 

[目录]


进程

 

[目录]


信号


struct semaphore {
        atomic_t count; 进程抓取semaphore时减1
        int sleepers; 抓取semaphore失败时增1
        wait_queue_head_t wait; semaphore的等待队列
};
        down(&sem) 编绎成:

        movl $sem,% ecx        通过寄存器ecx向__down函数传递sem指针
        decl sem
        js 2f 如果为负值,表示semaphore已被占用,执行__down_failed过程
1:
由于出现semaphore竞争的可能性比较小,将分支代码转移到.text.lock段,以缩短正常的指令路径.
.section .text.lock,"ax"
2:        call __down_failed
        jmp 1b
.previous
        ...

        up(&sem) 编绎成:

        movl $sem,% ecx
        incl sem
        jle 2f 如果小于或等于0,表示该semaphore有进程在等待,就去调用__up_wakeup
1:
.section .text.lock,"ax"
2:        call __up_wakeup
        jmp 1b
.previous
        ...
__down_failed:
        pushl % eax
        pushl % edx
        pushl % ecx ; eax,edx,ecx是3个可用于函数参数的寄存器
        call __down
        popl % ecx
        popl % edx
        popl % eax
        ret
__up_wakeup:
        pushl % eax
        pushl % edx
        pushl % ecx
        call __up
        popl % ecx
        popl % edx
        popl % eax
        ret
; semaphore.c
void __down(struct semaphore * sem)
{
        struct task_struct *tsk = current;
        DECLARE_WAITQUEUE(wait, tsk);
        tsk->state = TASK_UNINTERRUPTIBLE;
        add_wait_queue_exclusive(&sem->wait, &wait);
        // 将当前进程加入到该semaphore的等待队列中

        spin_lock_irq(&semaphore_lock);
        sem->sleepers++;
        for (;;) {
                int sleepers = sem->sleepers;

                /*
                * Add "everybody else" into it. They aren't
                * playing, because we own the spinlock.
                */

                // atomic_add_negative(int i,atomic_t *v)将i + v->counter相加,
                // 结果为负返回1,否则返回0
                if (!atomic_add_negative(sleepers - 1, &sem->count)) {
                // 如果(sleepers - 1 + sem->count.counter)非负,则说明
                // semaphore已经被释放,可以返回
                        sem->sleepers = 0;
                        break;
                }
                sem->sleepers = 1;        /* us - see -1 above */

                spin_unlock_irq(&semaphore_lock);
                // 当semaphore被up()唤醒时,schedule()返回
                schedule();
                // 虽然已线程被up恢复,但为防止碰巧又有一个线程获得了semaphore,
                // 因此将它们放在循环体中
                tsk->state = TASK_UNINTERRUPTIBLE;
                spin_lock_irq(&semaphore_lock);
        }
        spin_unlock_irq(&semaphore_lock);
        // 该进程获得了semaphore,将它从等待队列中删除
        remove_wait_queue(&sem->wait, &wait);
        tsk->state = TASK_RUNNING;
        // 为什么这里要调用wake_up,是因为调用它没有副作用从而防止潜在的死锁吗?
        wake_up(&sem->wait);
}
void __up(struct semaphore *sem)
{
扩展为
__wake_up_common(&sem->wait,TASK_UNINTERRUPTIBLE|TASK_INTERRUPTIBLE,1,0);
唤醒队列中第1个进程,即将第1个进程放入运行队列
        wake_up(&sem->wait);
}
; sched.c
static inline void __wake_up_common (wait_queue_head_t *q, unsigned int
mode,
                                     int nr_exclusive, const int sync)
{
        struct list_head *tmp, *head;
        struct task_struct *p;
        unsigned long flags;

        if (!q)
                goto out;

        wq_write_lock_irqsave(&q->lock, flags);

#if WAITQUEUE_DEBUG
        CHECK_MAGIC_WQHEAD(q);
#endif

        head = &q->task_list;
#if WAITQUEUE_DEBUG
        if (!head->next || !head->prev)
                WQ_BUG();
#endif
        tmp = head->next;
        while (tmp != head) {
                unsigned int state;
                wait_queue_t *curr = list_entry(tmp, wait_queue_t,
task_list);
                tmp = tmp->next;

#if WAITQUEUE_DEBUG
                CHECK_MAGIC(curr->__magic);
#endif
                p = curr->task;
                state = p->state;
                if (state & mode) {
#if WAITQUEUE_DEBUG
                        curr->__waker = (long)__builtin_return_address(0);
#endif
                        if (sync)
                                wake_up_process_synchronous(p);
                        else
                                wake_up_process(p);
                        if ((curr->flags & WQ_FLAG_EXCLUSIVE) && !--nr_exclusive)
                                break;
                }
        }
        wq_write_unlock_irqrestore(&q->lock, flags);
out:
        return;
}
; sched.c
inline void wake_up_process(struct task_struct * p)
{
        unsigned long flags;

        /*
        * We want the common case fall through straight, thus the goto.
        */
        spin_lock_irqsave(&runqueue_lock, flags);
        p->state = TASK_RUNNING;
        if (task_on_runqueue(p))
                goto out;
        add_to_runqueue(p);
        reschedule_idle(p);
out:
        spin_unlock_irqrestore(&runqueue_lock, flags);
}
; sched.c
static inline void wake_up_process_synchronous(struct task_struct * p)
{
        unsigned long flags;

        /*
        * We want the common case fall through straight, thus the goto.
        */
        spin_lock_irqsave(&runqueue_lock, flags);
        p->state = TASK_RUNNING;
        if (task_on_runqueue(p))
                goto out;
        add_to_runqueue(p);
out:
        spin_unlock_irqrestore(&runqueue_lock, flags);
}
; sched.h
static inline int task_on_runqueue(struct task_struct *p)
{
        return (p->run_list.next != NULL);
}
; sched.c
static inline void add_to_runqueue(struct task_struct * p)
{
        list_add(&p->run_list, &runqueue_head);
        nr_running++;
}
static LIST_HEAD(runqueue_head);

; fork.c
void add_wait_queue_exclusive(wait_queue_head_t *q, wait_queue_t *
wait)
{
        unsigned long flags;

        wq_write_lock_irqsave(&q->lock, flags);
        wait->flags = WQ_FLAG_EXCLUSIVE;
        __add_wait_queue_tail(q, wait);
        wq_write_unlock_irqrestore(&q->lock, flags);
}
; wait.h
static inline void __add_wait_queue_tail(wait_queue_head_t *head,
                                                wait_queue_t *new)
{
#if WAITQUEUE_DEBUG
        if (!head || !new)
                WQ_BUG();
        CHECK_MAGIC_WQHEAD(head);
        CHECK_MAGIC(new->__magic);
        if (!head->task_list.next || !head->task_list.prev)
                WQ_BUG();
#endif
        list_add_tail(&new->task_list, &head->task_list);
}
正执行调度的函数是schedule(void),它选择一个最合适的进程执行,并且真正进行上下文切换,
使得选中的进程得以执行。而reschedule_idle(struct task_struct *p)的作用是为进程选择
一个合适的CPU来执行,如果它选中了某个CPU,则将该CPU上当前运行进程的need_resched标志
置为1,然后向它发出一个重新调度的处理机间中断,使得选中的CPU能够在中断处理返回时执行
schedule函数,真正调度进程p在CPU上执行。在schedule()和reschedule_idle()中调用了goodness()
函数。goodness()函数用来衡量一个处于可运行状态的进程值得运行的程度。此外,在schedule()
函数中还调用了schedule_tail()函数;在reschedule_idle()函数中还调用了reschedule_idle_slow()。

[目录]


sched.c


/*
* 'sched.c' is the main kernel file. It contains scheduling primitives
* (sleep_on, wakeup, schedule etc) as well as a number of simple system
* call functions (type getpid(), which just extracts a field from
* current-task
*/
#include
#include
#include
#include
#include
#include
#include
#define LATCH (1193180/HZ)
extern void mem_use(void);
extern int timer_interrupt(void);
extern int system_call(void);
union task_union {
struct task_struct task;
char stack[PAGE_SIZE];
};
static union task_union init_task = {INIT_TASK,};
long volatile jiffies=0;
long startup_time=0;
struct task_struct *current = &(init_task.task), *last_task_used_math =
NULL;
struct task_struct * task[NR_TASKS] = {&(init_task.task), };
long user_stack [ PAGE_SIZE>>2 ] ;
struct {
long * a;
short b;
} stack_start = { & user_stack [PAGE_SIZE>>2] , 0x10 };
/*
* 'math_state_restore()' saves the current math information in the
* old math state array, and gets the new ones from the current task
*/
void math_state_restore() @@协处理器状态保存
{
if (last_task_used_math)
__asm__("fnsave %0"::"m" (last_task_used_math->tss.i387));
if (current->used_math)
__asm__("frstor %0"::"m" (current->tss.i387));
else {
__asm__("fninit"::);
current->used_math=1;
}
last_task_used_math=current;
}
/*
* 'schedule()' is the scheduler function. This is GOOD CODE! There
* probably won't be any reason to change this, as it should work well
* in all circumstances (ie gives IO-bound processes good response etc).
* The one thing you might take a look at is the signal-handler code
here.
*
* NOTE!! Task 0 is the 'idle' task, which gets called when no other
* tasks can run. It can not be killed, and it cannot sleep. The 'state'
* information in task[0] is never used.
*/
void schedule(void)
{
int i,next,c;
struct task_struct ** p;
/* check alarm, wake up any interruptible tasks that have got a signal
*/
for(p = &LAST_TASK ; p > &FIRST_TASK ; --p)
if (*p) {
if ((*p)->alarm && (*p)->alarm < jiffies) {
@@??
(*p)->signal |= (1<<(SIGALRM-1));@@14-1
(*p)->alarm = 0;
}
if ((*p)->signal && (*p)->state==TASK_INTERRUPTIBLE)
(*p)->state=TASK_RUNNING;
}
@@ task 1 如何变为TASK_RUNNING??signal 如何得到,alarm如何变非0且 /* this is the
scheduler proper: */
@@操作系统最重要的函数,调度算法
@@这个循环要找到一个可运行的任务才能退出,会死在这吗?即如没有一个可运行
while (1) {
c = -1;
next = 0;
i = NR_TASKS;
p = &task[NR_TASKS];
while (--i) {
if (!*--p)
continue;
if ((*p)->state == TASK_RUNNING && (*p)->counter > c)
c = (*p)->counter, next = i;
}
if (c) break; @@记数大于零
for(p = &LAST_TASK ; p > &FIRST_TASK ; --p)
if (*p)
(*p)->counter = ((*p)->counter >> 1) +
(*p)->priority;
}
switch_to(next);
}
int sys_pause(void)
{
current->state = TASK_INTERRUPTIBLE; @@任务可中断
schedule();
return 0;
}
void sleep_on(struct task_struct **p)
{
struct task_struct *tmp;
if (!p)
return;
if (current == &(init_task.task))
panic("task[0] trying to sleep");
tmp = *p;
*p = current;
current->state = TASK_UNINTERRUPTIBLE;
schedule();
if (tmp) @@激活p,什么时候回来?唤醒上次睡眠的进程
tmp->state=0;
}
void interruptible_sleep_on(struct task_struct **p)
{
struct task_struct *tmp;
if (!p)
return;
if (current == &(init_task.task))
panic("task[0] trying to sleep");
tmp=*p;
*p=current;
repeat: current->state = TASK_INTERRUPTIBLE;
schedule();
if (*p && *p != current) {
(**p).state=0;
goto repeat;
}
@@好象下不来
*p=NULL;
if (tmp)
tmp->state=0;
}
void wake_up(struct task_struct **p)
{
if (p && *p) {
(**p).state=0; @@唤醒该进程running
*p=NULL; @@睡眠栈为0
}
}
void do_timer(long cpl) @@定时调度
{
if (cpl)
current->utime++; @@用户态时间加一
else
current->stime++; @@系统态时间加一
if ((--current->counter)>0) return; @@当前记数减一
current->counter=0;
if (!cpl) return;
schedule();
}
int sys_alarm(long seconds)
{
current->alarm = (seconds>0)?(jiffies+HZ*seconds):0;
return seconds;
}
int sys_getpid(void)
{
return current->pid;
}
int sys_getppid(void)
{
return current->father;
}
int sys_getuid(void)
{
return current->uid;
}
int sys_geteuid(void)
{
return current->euid;
}
int sys_getgid(void)
{
return current->gid;
}
int sys_getegid(void)
{
return current->egid;
}
int sys_nice(long increment)
{
if (current->priority-increment>0)
current->priority -= increment;
return 0;
}
int sys_signal(long signal,long addr,long restorer)
{
long i;
switch (signal) {
case SIGHUP: case SIGINT: case SIGQUIT: case SIGILL:
case SIGTRAP: case SIGABRT: case SIGFPE: case SIGUSR1:
case SIGSEGV: case SIGUSR2: case SIGPIPE: case SIGALRM:
case SIGCHLD:
i=(long) current->sig_fn[signal-1];
current->sig_fn[signal-1] = (fn_ptr) addr;
current->sig_restorer = (fn_ptr) restorer;
return i;
default: return -1;
}
}
void sched_init(void)
{
int i;
struct desc_struct * p;
set_tss_desc(gdt+FIRST_TSS_ENTRY,&(init_task.task.tss));@@init task tss
set_ldt_desc(gdt+FIRST_LDT_ENTRY,&(init_task.task.ldt));@@init ldt
p = gdt+2+FIRST_TSS_ENTRY;
for(i=1;i task[i] = NULL;
p->a=p->b=0;
p++;
p->a=p->b=0;
p++;
}
ltr(0); @@调入task 0的tss
lldt(0); @@调入task 0的ldt
outb_p(0x36,0x43); /* binary, mode 3, LSB/MSB, ch 0 */
outb_p(LATCH & 0xff , 0x40); /* LSB */
outb(LATCH >> 8 , 0x40); /* MSB */
set_intr_gate(0x20,&timer_interrupt); @@irq 0 时钟中断
outb(inb_p(0x21)&~0x01,0x21);
set_system_gate(0x80,&system_call);
}

[目录]


进程信号队列


每个进程具有一个sigpending结构所描述的信号队列,它有3个成员,head指向第一个sigqueu
e成员,tail指向最末的sigqueue成员的next指针,signal描述了此队列中的信号集.

static int
send_signal(int sig, struct siginfo *info, struct sigpending *signals);
将信号sig和对应的消息结构info添加到信号队列signal中.
static int
collect_signal(int sig, struct sigpending *list, siginfo_t *info);
返回信号sig在队列list中的信息info.


struct task_struct {
        ...
        struct sigpending pending;
        ...
};
struct sigpending {
       struct sigqueue *head, **tail;
       sigset_t signal;
};
struct sigqueue {
       struct sigqueue *next;
       siginfo_t info;
       };
// kernel/signal.c
static int
send_signal(int sig, struct siginfo *info, struct sigpending *signals)
{
     struct sigqueue * q = NULL;
     /* Real-time signals must be queued if sent by sigqueue, or
       some other real-time mechanism.  It is implementation
      defined whether kill() does so.  We attempt to do so, on
      the principle of least surprise, but since kill is not
     allowed to fail with EAGAIN when low on memory we just
     make sure at least one signal gets delivered and don't
     pass on the info struct.  */

    if (atomic_read(&nr_queued_signals) < max_queued_signals) {
       q = kmem_cache_alloc(sigqueue_cachep, GFP_ATOMIC);
    }
    // nr_queued_signals和max_queued_signals用来限制全局sigqueue成员的数目
    if (q) {
        atomic_inc(&nr_queued_signals);
        q->next = NULL;
        *signals->tail = q;
        signals->tail = &q->next; tail总是指向最末的信号成员的next指针                switch ((unsign
ed long) info)
         {
        case 0:
          // info参数如果为0,表示信号来源于当前用户进程                                  q->info.si_signo =
sig;
            q->info.si_errno = 0;
            q->info.si_code = SI_USER;
          q->info.si_pid = current->pid;
            q->info.si_uid = current->uid;
          break;
        case 1:
          // info参数如果为1,表示信号来源于内核本身                                  q->info.si_signo = sig;
          q->info.si_errno = 0;
          q->info.si_code = SI_KERNEL;
           q->info.si_pid = 0;
          q->info.si_uid = 0;
           break;
        default:
           // 否则从info指针中拷贝信号
           copy_siginfo(&q->info, info);
          break;
        }
      }
      else if (sig >= SIGRTMIN && info && (unsigned long)info != 1                   && info->
si_code != SI_USER)
      {
        ; 如果该信号是内核发出的实时信号,就返回错误码
        /*
         * Queue overflow, abort.  We may abort if the signal was rt
         * and sent by user using something other than kill().
       */
        return -EAGAIN;
      }
      sigaddset(&signals->signal, sig); 将sig号标记在队列的信号集上
      return 0;
}
static int
collect_signal(int sig, struct sigpending *list, siginfo_t *info)
{
      if (sigismember(&list->signal, sig)) {
        /* Collect the siginfo appropriate to this signal.  */                struct sigqueue *q, **
pp;
         pp = &list->head; pp指向第一个信号成员的next指针
        while ((q = *pp) != NULL) {
                if (q->info.si_signo == sig)                                            goto found_it;
                pp = &q->next;
         }
        /* Ok, it wasn't in the queue.  We must have
           been out of queue space.  So zero out the
          info.
         */
        sigdelset(&list->signal, sig);
        info->si_signo = sig;
        info->si_errno = 0;
        info->si_code = 0;
        info->si_pid = 0;
        info->si_uid = 0;
        return 1;
   found_it:
   // 将找到信号成员从信号队列中删除
        if ((*pp = q->next) == NULL)
        list->tail = pp;
  /* Copy the sigqueue information and free the queue entry */
       copy_siginfo(info, &q->info);
       kmem_cache_free(sigqueue_cachep,q);
       atomic_dec(&nr_queued_signals);
  /* Non-RT signals can exist multiple times.. */
       if (sig >= SIGRTMIN) {
                while ((q = *pp) != NULL) {
                  if (q->info.si_signo == sig)                                             goto found_another;
                    pp = &q->next;
                }
       }
       sigdelset(&list->signal, sig);
    found_another:
        return 1;
    }
    return 0;
}

[目录]


SMP


   多处理机系统正在变得越来越普通。尽管大多数用户空间代码仍将完美地运行,而且
有些情况下不需要增加额外的代码就能利用SMP特性的优势,但是内核空间代码必须编写成
具备“SMP意识”且是“SMP安全的”。以下几段文字解释如何去做。

问题

    当有多个CPU时,同样的代码可能同时在两个或多个CPU上执行。这在如下所示用于初
始化某个图像设备的例程中可能会出问题。
        void init_hardware(void)
        {
            outb(0x1, hardware_base + 0x30);
            outb(0x2, hardware_base + 0x30);
            outb(0x3, hardware_base + 0x30);
            outb(0x4, hardware_base + 0x30);
        }
    假设该硬件依赖于寄存器0x30按顺序依次被设为0、1、2、3来初始化,那么要是有另
一个CPU来参乎的话,事情就会搞糟。想象有两个CPU的情形,它们都在执行这个例程,不
过2号CPU进入得稍慢点:
        CPU 1                           CPU 2

        0x30 = 1
        0x30 = 2                        0x30 = 1
        0x30 = 3                        0x30 = 2
        0x30 = 4                        0x30 = 3
                                        0x30 = 4
    这会发生什么情况呢?从我们设想的硬件设备看来,它在寄存器0x30上收到的字节按
顺序为:1、2、1、3、2、4、3、4。
    啊!原本好好的事第二个CPU一来就搞得一团糟了也。所幸的是,我们有防止这类事情
发生的办法。

自旋锁小历史

    2.0.x版本的Linux内核通过给整个内核引入一个全局变量来防止多于一个CPU会造成的
问题。这意味着任何时刻只有一个CPU能够执行来自内核空间的代码。这样尽管能工作,但
是当系统开始以多于2个的CPU出现时,扩展性能就不怎么好。
    2.1.x版本的内核系列加入了粒度更细的SMP支持。这意味着不再依赖于以前作为全局
变量出现的“大锁”,而是每个没有SMP意识的例程现在都需要各自的自旋锁。文件asm/
spinlock.h中定义了若干类型的自旋锁。
    有了局部化的自旋锁后,不止一个CPU同时执行内核空间代码就变得可能了。

简单的自旋锁

    理解自旋锁的最简单方法是把它作为一个变量看待,该变量把一个例程或者标记为
“我当前在另一个CPU上运行,请稍等一会”,或者标记为“我当前不在运行”。如果1号
CPU首先进入该例程,它就获取该自旋锁。当2号CPU试图进入同一个例程时,该自旋锁告诉
它自己已为1号CPU所持有,需等到1号CPU释放自己后才能进入。
        spinlock_t my_spinlock = SPIN_LOCK_UNLOCKED;
        unsigned long flags;

        spin_lock (&my_spinlock);
        ...
        critical section
        ...
        spin_unlock (&my_spinlock);

中断

    设想我们的硬件的驱动程序还有一个中断处理程序。该处理程序需要修改某些由我们
的驱动程序定义的全局变量。这会造成混乱。我们如何解决呢?
    保护某个数据结构,使它免遭中断之修改的最初方法是全局地禁止中断。在已知只有
自己的中断才会修改自己的驱动程序变量时,这么做效率很低。所幸的是,我们现在有更
好的办法了。我们只是在使用共享变量期间禁止中断,此后重新使能。
    实现这种办法的函数有三个:
        disable_irq()
        enable_irq()
        disable_irq_nosync()
    这三个函数都取一个中断号作为参数。注意,禁止一个中断的时间太长会导致难以追
踪程序缺陷,丢失数据,甚至更坏。
    disable_irq函数的非同步版本允许所指定的IRQ处理程序继续运行,前提是它已经在
运行,普通的disable_irq则所指定的IRQ处理程序不在如何CPU上运行。
    如果需要在中断处理程序中修改自旋锁,那就不能使用普通的spin_lock()和
spin_unlock(),而应该保存中断状态。这可通过给这两个函数添加_irqsave后缀很容易地
做到:
        spinlock_t my_spinlock = SPIN_LOCK_UNLOCKED;
        unsigned long flags;

        spin_lock_irqsave(&my_spinlock, flags);
        ...
        critical section
        ...
        spin_unlock_irqrestore (&my_spinlock, flags);

[目录]


内核线程页目录的借用


创建内核线程的时候,由于内核线程没有用户空间,而所有进程的内核页目录都是一样的((某些情况下可能有不同步的情况出现,主要是为了减轻同步所有进程内核页目录的开销,而只是在各个进程要访问内核空间,如果有不同步的情况,然后才进?
同步处理),所以创建的内核线程的
内核页目录总是借用进程0的内核页目录。

>>> kernel_thread以标志CLONE_VM调用clone系统调用
/*
* Create a kernel thread
*/
int kernel_thread(int (*fn)(void *), void * arg, unsigned long flags)
{
long retval, d0;

__asm__ __volatile__(
  "movl %%esp,%%esi/n/t"
  "int $0x80/n/t"  /* Linux/i386 system call */
  "cmpl %%esp,%%esi/n/t" /* child or parent? */
  /* Load the argument into eax, and push it.  That way, it does
   * not matter whether the called function is compiled with
   * -mregparm or not.  */
  "movl %4,%%eax/n/t"
  "pushl %%eax/n/t"
  "call *%5/n/t"  /* call fn */
  "movl %3,%0/n/t" /* exit */
  "int $0x80/n"
  "1:/t"
  :"=&a" (retval), "=&S" (d0)
  :"0" (__NR_clone), "i" (__NR_exit),
   "r" (arg), "r" (fn),
   "b" (flags | CLONE_VM)
  : "memory");
return retval;
}

>>> sys_clone->do_fork->copy_mm:
static int copy_mm(unsigned long clone_flags, struct task_struct * tsk)
{
struct mm_struct * mm, *oldmm;
int retval;

。。。。。。。。

tsk->mm = NULL;
tsk->active_mm = NULL;

/*
  * Are we cloning a kernel thread?
  *
  * We need to steal a active VM for that..
  */
>>> 如果是内核线程的子线程(mm=NULL),则直接退出,此时内核线程mm和active_mm均为为NULL
oldmm = current->mm;
if (!oldmm)
  return 0;

>>> 内核线程,只是增加当前进程的虚拟空间的引用计数
if (clone_flags & CLONE_VM) {
  atomic_inc(&oldmm->mm_users);
  mm = oldmm;
  goto good_mm;
}

。。。。。。。。。。

good_mm:
>>> 内核线程的mm和active_mm指向当前进程的mm_struct结构
tsk->mm = mm;
tsk->active_mm = mm;
return 0;

。。。。。。。
}

然后内核线程一般调用daemonize来释放对用户空间的引用:
>>> daemonize->exit_mm->_exit_mm:
/*
* Turn us into a lazy TLB process if we
* aren't already..
*/
static inline void __exit_mm(struct task_struct * tsk)
{
struct mm_struct * mm = tsk->mm;

mm_release();
if (mm) {
  atomic_inc(&mm->mm_count);
  if (mm != tsk->active_mm) BUG();
  /* more a memory barrier than a real lock */
  task_lock(tsk);
>>> 释放用户虚拟空间的数据结构
  tsk->mm = NULL;
  task_unlock(tsk);
  enter_lazy_tlb(mm, current, smp_processor_id());

>>> 递减mm的引用计数并是否为0,是则释放mm所代表的映射
  mmput(mm);
}
}

asmlinkage void schedule(void)
{
。。。。。。。。。
if (!current->active_mm) BUG();

。。。。。。。。。

prepare_to_switch();
{
  struct mm_struct *mm = next->mm;
  struct mm_struct *oldmm = prev->active_mm;
>>> mm = NULL,选中的为内核线程
  if (!mm) {
>>> 对内核线程,active_mm = NULL,否则一定是出错了
   if (next->active_mm) BUG();
>>> 选中的内核线程active_mm借用老进程的active_mm
   next->active_mm = oldmm;
   atomic_inc(&oldmm->mm_count);
   enter_lazy_tlb(oldmm, next, this_cpu);
  } else {
>>> mm != NULL 选中的为用户进程,active_mm必须与mm相等,否则一定是出错了
   if (next->active_mm != mm) BUG();
   switch_mm(oldmm, mm, next, this_cpu);
  }

>>> prev = NULL ,切换出去的是内核线程
  if (!prev->mm) {
>>> 设置其 active_mm = NULL 。
   prev->active_mm = NULL;
   mmdrop(oldmm);
  }
}

}

对内核线程的虚拟空间总结一下:
1、创建的时候:
父进程是用户进程,则mm和active_mm均共享父进程的,然后内核线程一般调用daemonize适头舖m
父进程是内核线程,则mm和active_mm均为NULL
总之,内核线程的mm = NULL;进程调度的时候以此为依据判断是用户进程还是内核线程。

2、进程调度的时候
如果切换进来的是内核线程,则置active_mm为切换出去的进程的active_mm;
如果切换出去的是内核线程,则置active_mm为NULL。

[目录]


代码分析


LINUX系统是分时多用户系统, 它有多进程系统的特点,CPU按时间片分配给各个用户使用, 而在实质上应该说CPU按时间片分配给各个进程使用, 每个进程都有自己的运行环境以使得在CPU做进程切换时保存该进程已计算了一半的状态。
进程的切换包括三个层次:
用户数据的保存: 包括正文段(TEXT), 数据段(DATA,BSS), 栈段(STACK), 共享内存段(SHARED MEMORY)的保存。
寄存器数据的保存: 包括PC(program counter,指向下一条要执行的指令的地址),   PSW(processor status word,处理机状态字), SP(stack pointer,栈指针), PCBP(pointer of process control block,进程控制块指针), FP(frame pointer,指向栈中一个函数的local 变量的首地址), AP(augument pointer,指向栈中函数调用的实参位置), ISP(interrupt stack pointer,中断栈指针), 以及其他的通用寄存器等。
系统层次的保存: 包括proc,u,虚拟存储空间管理表格,中断处理栈。以便于该进程再一次得到CPU时间片时能正常运行下去。

    多进程系统的一些突出的特点:
并行化
   一件复杂的事件是可以分解成若干个简单事件来解决的, 这在程序员的大脑中早就形成了这种概念, 首先将问题分解成一个个小问题, 将小问题再细分, 最后在一个合适的规模上做成一个函数。 在软件工程中也是这么说的。如果我们以图的方式来思考, 一些小问题的计算是可以互不干扰的, 可以同时处理, 而在关键点则需要统一在一个地方来处理, 这样程序的运行就是并行的, 至少从人的时间观念上来说是这样的。 而每个小问题的计算又是较简单的。
简单有序
   这样的程序对程序员来说不亚于管理一班人, 程序员为每个进程设计好相应的功能, 并通过一定的通讯机制将它们有机地结合在一起, 对每个进程的设计是简单的, 只在总控部分小心应付(其实也是蛮简单的), 就可完成整个程序的施工。
互不干扰
   这个特点是操作系统的特点, 各个进程是独立的, 不会串位。
事务化
   比如在一个数据电话查询系统中, 将程序设计成一个进程只处理一次查询即可, 即完成一个事务。当电话查询开始时, 产生这样一个进程对付这次查询; 另一个电话进来时, 主控程序又产生一个这样的进程对付, 每个进程完成查询任务后消失. 这样的编程多简单, 只要做一次查询的程序就可以了。

   Linux是一个多进程的操作系统,进程是分离的任务,拥有各自的权利和责任。如果一个进程崩溃,它不应该让系统的另一个进程崩溃。每一个独立的进程运行在自己的虚拟地址空间,除了通过安全的核心管理的机制之外无法影响其他的进程。
   在一个进程的生命周期中,进程会使用许多系统资源。比如利用系统的CPU执行它的指令,用系统的物理内存来存储它和它的数据。它会打开和使用文件系统中的文件,会直接或者间接使用系统的物理设备。如果一个进程独占了系统的大部分物理内存和CPU,对于其他进程就是不公平的。所以Linux必须跟踪进程本身和它使用的系统资源以便公平地管理系统中的进程。
   系统最宝贵的资源就是CPU。通常系统只有一个CPU。Linux作为一个多进程的操作系统,它的目标就是让进程在系统的CPU上运行,充分利用CPU。如果进程数多于CPU(一般情况都是这样),其他的进程就必须等到CPU被释放才能运行。多进程的思想就是:一个进程一直运行,直到它必须等待,通常是等待一些系统资源,等拥有了资源,它才可以继续运行。在一个单进程的系统中,比如DOS,CPU被简单地设为空闲,这样等待资源的时间就会被浪费。而在一个多进程的系统中,同一时刻许多进程在内存中,当一个进程必须等待时,操作系统将CPU从这个进程切换到另一个更需要的进程。
   我们组分析的是Linux进程的状态转换以及标志位的作用,它没有具体对应某个系统调用,而是分布在各个系统调用中。所以我们详细而广泛地分析了大量的原码,对进程状态转换的原因、方式和结果进行了分析,大致总结了整个Linux系统对进程状态管理的实现机制。

   Linux中,每个进程用一个task_struct的数据结构来表示,用来管理系统中的进程。Task向量表是指向系统中每一个task_struct数据结构的指针的数组。这意味着系统中的最大进程数受到Task向量表的限制,缺省是512。这个表让Linux可以查到系统中的所有的进程。操作系统初始化后,建立了第一个task_struct数据结构INIT_TASK。当新的进程创建时,从系统内存中分配一个新的task_struct,并增加到Task向量表中。为了更容易查找,用current指针指向当前运行的进程。

   task_struct结构中有关于进程调度的两个重要的数据项:
   struct task_struct {
       ………….
       volatile  long  state; /* -1 unrunnable , 0 runnable , >0 stopped */
       unsigned  long  flags; /* per process flags, defined below */
       ………….
     };
   每个在Task向量表中登记的进程都有相应的进程状态和进程标志,是进行进程调度的重要依据。进程在执行了相应的进程调度操作后,会由于某些原因改变自身的状态和标志,也就是改变state和flags这两个数据项。进程的状态不同、标志位不同对应了进程可以执行不同操作。在Linux2.2.8版本的sched.h中定义了六种状态,十三种标志。
//进程状态
#define TASK_RUNNING                0
#define TASK_INTERRUPTIBLE        1
#define TASK_UNINTERRUPTIBLE        2
#define TASK_ZOMBIE                4
#define TASK_STOPPED                8
#define TASK_SWAPPING                16

它们的含义分别是:

TASK_RUNNING:正在运行的进程(是系统的当前进程)或准备运行的进程(在Running队列中,等待被安排到系统的CPU)。处于该状态的进程实际参与了进程调度。
TASK_INTERRUPTIBLE:处于等待队列中的进程,待资源有效时唤醒,也可由其它进程被信号中断、唤醒后进入就绪状态。
TASK_UNINTERRUPTIBLE:处于等待队列中的进程,直接等待硬件条件,待资源有效时唤醒,不可由其它进程通过信号中断、唤醒。
TASK_ZOMBIE:终止的进程,是进程结束运行前的一个过度状态(僵死状态)。虽然此时已经释放了内存、文件等资源,但是在Task向量表中仍有一个task_struct数据结构项。它不进行任何调度或状态转换,等待父进程将它彻底释放。
TASK_STOPPED:进程被暂停,通过其它进程的信号才能唤醒。正在调试的进程可以在该停止状态。
TASK_SWAPPING:进程页面被兑换出内存的进程。这个状态基本上没有用到,只有在sched.c的count_active_tasks()函数中判断处于该种状态的进程也属于active的进程,但没有对该状态的赋值。

//进程标志位:
#define PF_ALIGNWARN        0x00000001
#define PF_STARTING        0x00000002
#define PF_EXITING        0x00000004
#define PF_PTRACED        0x00000010
#define PF_TRACESYS        0x00000020
#define PF_FORKNOEXEC        0x00000040
#define PF_SUPERPRIV        0x00000100
#define PF_DUMPCORE        0x00000200
#define PF_SIGNALED        0x00000400
#define PF_MEMALLOC        0x00000800
#define PF_VFORK            0x00001000
#define PF_USEDFPU        0x00100000
#define PF_DTRACE        0x00200000

其中PF_STARTING没有用到。
PF_MEMEALLOC和PF_VFORK这两个标志位是新版本中才有的。

各个标志位的代表着不同含义,对应着不同调用:

PF_ALIGNWARN    标志打印“对齐”警告信息,只有在486机器上实现
PF_STARTING      进程正被创建
PF_EXITING        标志进程开始关闭。
在do_exit()时置位。
    current->flags |= PF_EXITING
用于判断是否有效进程。
在nlmclnt_proc()(在fs/lockd/clntproc.c),如果current_flag为PF_EXITING,则进程由于正在退出清除所有的锁,将执行异步RPC 调用。
PF_PTRACED      进程被跟踪标志,
在do_fork()时清位。
    p->flags &= ~PF_PTRACED
当ptrace(0)被调用时置位,在进程释放前要清掉。
    current->flags |= PF_PTRACED
在sys_trace()中判断
如果request为PTRACE_TRACEME,如是则将current_flag置为PF_PTRACED;
如果request为PTRACE_ATTACH,则将child_flag置为PF_PTRACED,给child发一个SIGSTOP信号;
如果request为PTRACE_DETACH ,则将child清除PF_PTRACED。
在syscall_trace()中判断current_flag如果为PF_TRACED和PF_TRACESYS,则current强行退出时的出错代码置为SIGTRAP并将状态置为STOPPED。
PF_TRACESYS       正在跟踪系统调用。
do_fork()时清位,在进程释放前要清掉。
在sys_trace()中判断request如果为PTRACE_SYSCALL,则将child->flags 置为 PF_TRACESYS;如为PTRACE_SYSCALL,则将child->flags 清除 PF_TRACESYS;然后唤醒child。如果request为PTRACE_SINGLESTEP(即单步跟踪),则将child_flag清除PF_TRACESYS,唤醒child。
PF_FORKNOEXEC    进程刚创建,但还没执行。
在do_fork()时置位。
    p->flags |=  PF_FORKNOEXEC
在调入格式文件时清位。
    p->flags &= ~ PF_FORKNOEXEC
PF_SUPERPRIV       超级用户特权标志。
    如果是超级用户进程则置位,用户特权设为超级用户,如是超级用户,在统计时置统计标志(accounting flag)为ASU。
PF_DUMPCORE       标志进程是否清空core文件。
Core文件由gdb进行管理,给用户提供有用信息,例如查看浮点寄存器的内容比较困难,事实上我们可以从内核文件里的用户结构中得到
  Core文件格式如下图:
UPAGE
DATA
STACK
              Core 文件结构
       UPAGE是包含用户结构的一个页面,告诉gdb文件中现有内容所有寄存器也在           UPAGE中,通常只有一页。DATA存放数据区。STACK堆栈区
   最小Core文件长度为三页(12288字节)
在task_struct中定义一个dumpable变量,当dumpable==1时表示进程可以清空core文件(即将core文件放入回收站),等于0时表示该进程不能清空core文件(即core文件以放在回收站中,不可再放到回收站中),此变量初值为1。
例如在调用do_aout_core_dump()时判断current->dumpable是否等于1(即判断该进程是否能将core文件放入回收站),如果等于1则将该变量置为0,在当前目录下建立一个core dump image ,在清空用户结构前,由gdb算出数据段和堆栈段的位置和使用的虚地址,用户数据区和堆栈区在清空前将相应内容写入core dump,将PF_DUMPCORE置位,清空数据区和堆栈区。
只有在aout_core_dump()内调用do_aout_core_dump(),而没有地方调用aout_core_dump()。对其它文件格式也是类似。
9、 PF_SIGNALED       标志进程被信号杀出。
在do_signal()中判断信号,如果current收到信号为SIGHUP, SIGINT, SIGIOT, SIGKILL, SIGPIPE, SIGTERM, SIGALRM, SIGSTKFLT, SIGURG, SIGXCPU, SIGXFSZ, SIGVTALRM, SIGPROF, SIGIO, SIGPOLL, SIGLOST, SIGPWR,则执行lock_kernel(),将信号加入current的信号队列,将current->flag置为PF_SIGNALED,然后执行do_exit()
PF_USEDFPU        标志该进程使用FPU,此标志只在SMP时使用。
在task_struct中有一变量used_math,进程是否使用FPU。
在CPU从prev切换到next时,如果prev使用FPU则prev的flag清除PF_USEDFPU。
    prev->flags&=~PF_USEDFPU
在flush_thread()(arch/i386/kernel/process.c)、restore_i387_hard()、save_i387_hard()(arch/i386/kernel/signal.c)中,如果是SMP方式,且使用FPU则stts(),否则清除PF_USEDFPU。
    current->flags &= ~PF_USEDFPU
在sys_trace()中如果request为PTRACE_SETFPREGS,则将child的used_math置为1,将child_flag清除PF_USEDFPU。
    child->flags &= ~PF_USEDFPU
在SMP方式下进行跟踪时,判断是否使用FPU。
在跟踪时出现数学错误时清位。
    current->flags &= ~PF_USEDFPU
PF_DTRACE          进程延期跟踪标志,只在m68k下使用。
跟踪一个trapping指令时置位。
    current->flags |= PF_DTRACE
PF_ONSIGSTK        标志进程是否工作在信号栈,只在m68k方式下使用。
liunx 2.1.19版本中使用此标志位,而2.2.8版本中不使用。
在处理信号建立frame时如果sigaction标志为ONSTACK,则将current->flag置为PF_ONSIGSTK。
PF_MEMALLOC      进程分配内存标志。
linux 2.2.8版本中使用此标志位。
在kpiod()和kwpad()中置位。
    tsk->flags |= PF_MEMALLOC
PF_VFORK           linux 2.2.8版本中使用此标志位。
在copy_flags(unsigned long clone_flags, struct task_struct *p),如果clone_flags为CLONE_VFORK,则将p的flags置为PF_VFORK。
在mm_release()中将current ->flags清除PF_VFORK。
    tsk->flags &= ~PF_VFORK
    具体的分析由我组的另外同学进行。

Linux的各进程之间的状态转换的系统调用
我将参与Linux的各进程之间的状态转换的系统调用总结成一张流程图:

 

进程的创建:TASK_RUNNING

第一个进程在系统启动时创建,当系统启动的时候它运行在核心态,这时,只有一个进程:初始化进程。象所有其他进程一样,初始进程有一组用堆栈、寄存器等等表示的机器状态。当系统中的其他进程创建和运行的时候这些信息存在初始进程的task_struct数据结构中。在系统初始化结束的时候,初始进程启动一个核心进程(叫做init)然后执行空闲循环,什么也不做。当没有什么可以做的时候,调度程序会运行这个空闲的进程。这个空闲进程的task_struct是唯一一个不是动态分配而是在核心连接的时候静态定义的,为了不至于混淆,叫做init_task。
   系统调用sys_fork 和sys_clone都调用函数do_fork()(在kernel/fork.中定义)。
   进程由do_fork()函数创建,先申请空间,申请核心堆栈;然后在Task向量表中找到空闲位置;在进行正式初始化以前,将新创建的进程的状态都置为TASK_UNINTERRUPTIBLE,以免初始化过程被打断;开始初始化工作,如初始化进程时钟、信号、时间等数据;继承父进程的资源,如文件、信号量、内存等;完成进程初始化后,由父进程调用wake_up_process()函数将其唤醒,状态变为TASK_RUNNING,挂到就绪队列run queue,返回子进程的pid。

//   C:/SRCLNX/KERNEL/FORK.C
int do_fork(unsigned long clone_flags, unsigned long usp, struct pt_regs *regs)
{

        为新进程申请PCB空间;
        if (申请不到)
                返回错误,退出;
        为新进程申请核心堆栈;
        if (核心堆栈申请不到)
                返回错误,退出;
        为新进程在Task向量表中找到空闲位置;
/*复制父进程current PCB中的信息,继承current的资源*/;
    p = current;
        在进行正式初始化以前,将新创建的进程的状态都置为TASK_UNINTERRUPTIBLE,以免初始化过程被打断,并置一些标志位.
/*为防止信号、定时中断误唤醒未创建完毕的进                                       程,将子进程的状态设成不可中断的*/
        p->state = TASK_UNINTERRUPTIBLE;
/*跟踪状态和超级用户特权是没有继承性的,因为在root用户为普通用户创建进程时,出于安全考虑这个普通用户的进程不允许拥有超级用户特权。*/
        p->flags &= ~(PF_PTRACED|PF_TRACESYS|PF_SUPERPRIV);
/*将进程标志设成初建,在进程第一次获得CPU时,内核将根据此标志进行一定操作*/
        p->flags |= PF_FORKNOEXEC;
   开始Task_struct的初始化工作,如初始化进程时钟、信号、时间等数据;
   继承父进程所有资源:
                拷贝父进程当前打开的文件;
                拷贝父进程在VFS的位置;
                拷贝父进程的信号量;
                拷贝父进程运行的内存;
                拷贝父进程的线程;
   初始化工作结束,父进程将其将其唤醒,挂入running队列中,返回子进程的pid;

}

进程的调度(schedule()):

   处于TASK_RUNNING状态的进程移到run queue,会由schedule()按CPU调度算法在合适的时候选中,分配给CPU。
   新创建的进程都是处于TASK_RUNNING状态,而且被挂到run queue的队首。进程调度采用变形的轮转法(round robin)。当时间片到时(10ms的整数倍),由时钟中断引起新一轮调度,把当前进程挂到run queue队尾。
   所有的进程部分运行与用户态,部分运行于系统态。底层的硬件如何支持这些状态各不相同但是通常有一个安全机制从用户态转入系统态并转回来。用户态比系统态的权限低了很多。每一次进程执行一个系统调用,它都从用户态切换到系统态并继续执行。这时让核心执行这个进程。Linux中,进程不是互相争夺成为当前运行的进程,它们无法停止正在运行的其它进程然后执行自身。每一个进程在它必须等待一些系统事件的时候会放弃CPU。例如,一个进程可能不得不等待从一个文件中读取一个字符。这个等待发生在系统态的系统调用中。进程使用了库函数打开并读文件,库函数又执行系统调用从打开的文件中读入字节。这时,等候的进程会被挂起,另一个更加值得的进程将会被选择执行。进程经常调用系统调用,所以经常需要等待。即使进程执行到需要等待也有可能会用去不均衡的CPU事件,所以Linux使用抢先式的调度。用这种方案,每一个进程允许运行少量一段时间,200毫秒,当这个时间过去,选择另一个进程运行,原来的进程等待一段时间直到它又重新运行。这个时间段叫做时间片。
   需要调度程序选择系统中所有可以运行的进程中最值得的进程。一个可以运行的进程是一个只等待CPU的进程。Linux使用合理而简单的基于优先级的调度算法在系统当前的进程中进行选择。当它选择了准备运行的新进程,它就保存当前进程的状态、和处理器相关的寄存器和其他需要保存的上下文信息到进程的task_struct数据结构中。然后恢复要运行的新的进程的状态(又和处理器相关),把系统的控制交给这个进程。为了公平地在系统中所有可以运行(runnable)的进程之间分配CPU时间,调度程序在每一个进程的task_struct结构中保存了信息。
   policy 进程的调度策略:Linux有两种类型的进程:普通和实时。实时进程比所有其它进程的优先级高。如果有一个实时的进程准备运行,那么它总是先被运行。实时进程有两种策略:环或先进先出(round robin and first in first out)。在环的调度策略下,每一个实时进程依次运行,而在先进先出的策略下,每一个可以运行的进程按照它在调度队列中的顺序运行,这个顺序不会改变。
   Priority 进程的调度优先级。也是它允许运行的时候可以使用的时间量(jiffies)。你可以通过系统调用或者renice命令来改变一个进程的优先级。
   Rt_priority Linux支持实时进程。这些进程比系统中其他非实时的进程拥有更高的优先级。这个域允许调度程序赋予每一个实时进程一个相对的优先级。实时进程的优先级可以用系统调用来修改Coutner 这时进程可以运行的时间量(jiffies)。进程启动的时候等于优先级(priority),每一次时钟周期递减。
  调度程序schedule()从核心的多个地方运行。它可以在把当前进程放到等待队列之后运行,也可以在系统调用之后进程从系统态返回进程态之前运行。需要运行调度程序的另一个原因是系统时钟刚好把当前进程的计数器(counter)置成了0。每一次调度程序运行它做以下工作:
(1)kernel work 调度程序运行bottom half handler并处理系统的调度任务队列。
(2)Current pocess 在选择另一个进程之前必须处理当前进程。
(3)如果当前进程的调度策略是环则它放到运行队列的最后。
(4)如果任务状态是TASK_INTERRUPTIBLE的而且它上次调度的时候收到过一个信号,它的状态变为TASK_RUNNING;
     如果当前进程超时,它的状态成为RUNNING;
     如果当前进程的状态为RUNNING则保持此状态;
     不是RUNNING或者INTERRUPTIBLE的进程被从运行队列中删除。这意味着当调度程序查找最值得运行的进程时不会考虑这样的进程。
(5)Process Selection 调度程序查看运行队列中的进程,查找最值得运行的进程。如果有实时的进程(具有实时调度策略),就会比普通进程更重一些。普通进程的重量是它的counter,但是对于实时进程则是counter 加1000。这意味着如果系统中存在可运行的实时进程,就总是在任何普通可运行的进程之前运行。当前的进程,因为用掉了一些时间片(它的counter减少了),所以如果系统中由其他同等优先级的进程,就会处于不利的位置:这也是应该的。如果几个进程又同样的优先级,最接近运行队列前段的那个就被选中。当前进程被放到运行队列的后面。如果一个平衡的系统,拥有大量相同优先级的进程,那么回按照顺序执行这些进程。这叫做环型调度策略。不过,因为进程需要等待资源,它们的运行顺序可能会变化。
(6)Swap Processes 如果最值得运行的进程不是当前进程,当前进程必须被挂起,运行新的进程。当一个进程运行的时候它使用了CPU和系统的寄存器和物理内存。每一次它调用例程都通过寄存器或者堆栈传递参数、保存数值比如调用例程的返回地址等。因此,当调度程序运行的时候它在当前进程的上下文运行。它可能是特权模式:核心态,但是它仍旧是当前运行的进程。当这个进程要挂起时,它的所有机器状态,包括程序计数器(PC)和所有的处理器寄存器,必须存到进程的task_struct数据结构中。然后,必须加载新进程的所有机器状态。这种操作依赖于系统,不同的CPU不会完全相同地实现,不过经常都是通过一些硬件的帮助。
(7)交换出去进程的上下文发生在调度的最后。前一个进程存储的上下文,就是当这个进程在调度结束的时候系统的硬件上下文的快照。相同的,当加载新的进程的上下文时,仍旧是调度结束时的快照,包括进程的程序计数器和寄存器的内容。
(8)如果前一个进程或者新的当前进程使用虚拟内存,则系统的页表需要更新。同样,这个动作适合体系结构相关。Alpha AXP处理器,使用TLT(Translation Look-aside Table)或者缓存的页表条目,必须清除属于前一个进程的缓存的页表条目。

   下面我就来总结一下进程创建以后到被杀死的整个进程生命周期中,状态可能在TASK_RUNNING、TASK_INTERRUPTIBLE、TASK_UNINTERRUPTIBLE 、TASK_STOPPED以及TASK_ZOMBLE之间转换的原因。

进程在TASK_RUNNING以及TASK_UNINTERRUPTIBLE、TASK_INTERRUPTIBLE之间转换:
   获得CPU而正在运行的进程会由于某些原因,比如:申请不到某个资源,其状态会从TASK_RUNNING变为TASK_INTERRUPTIBLE或TASK_UNINTERRUPTIBLE的等待状态。同样在经历了某些情况,处于等待状态的进程会被重新唤醒,等待分配给CPU。状态为TASK_INTERRUPTIBLE的睡眠进程会被唤醒,回到TASK_RUNNING状态,重新等待schedule()分配给它CPU,继续运行,比如:当申请资源有效时,也可以由signal或定时中断唤醒。而状态为TASK_INTERRUPTIBLE的睡眠进程只有当申请资源有效时被唤醒,不能被signal、定时中断唤醒。

1.通过sleep_on()、interruptible_sleep_on()、sleep_on_timeout()、interruptible_sleep_on_timeout()以及wake_up()、wake_up_process()、wake_up_interruptible()函数对进行的转换:

   sleep_on():TASK_RUNNING->TASK_UNINTERRUPTIBLE
   当拥有CPU的进程申请资源无效时,会通过sleep_on(),将进程从TASK_RUNNING切换到TASK_UNINTERRUPTIBLE状态。sleep_on()函数的作用就是将current进程的状态置成TASK_UNINTERRUPTIBLE,并加到等待队列中。
   一般来说引起状态变成TASK_UNINTERRUPTIBLE的资源申请都是对一些硬件资源的申请,如果得不到这些资源,进程将不能执行下去,不能由signal信号或时钟中断唤醒,而回到TASK_RUNNING状态。
   我们总结了这种类型的转换原因有:
(1)对某些资源的操作只能由一个进程进行,所以系统对该项资源采用上锁机制。在申请该项资源时,必须先申请资源的锁,如果已经被别的进程占用,则必须睡眠在对该锁的等待队列上。而且这种睡眠不能被中断,必须等到得到了资源才能继续进行下去。
如:
对网络连接表锁(Netlink table lock)的申请, sleep_on(&nl_table_wait);
对交换页进行I/O操作的锁的申请, sleep_on(&lock_queue);
对Hash表操作的锁的申请, sleep_on(&hash_wait);
在UMSDOS文件系统创建文件或目录时,必须等待其他同样的创建工作结束,sleep_on (&dir->u.umsdos_i.u.dir_info.p);

(2)某些进程在大部分时间处于睡眠状态,仅在需要时被唤醒去执行相应的操作,当执行完后,该进程又强制去睡眠。
如:
wakeup_bdflush()是对dirty buffer进行动态的响应,一旦该进程被激活,就将一定数量的dirty buffer写回磁盘,然后调用sleep_on(&bdflush_done),又去睡眠。

interruptible_sleep_on():TASK_RUNNING->TASK_INTERRUPTIBLE
   与sleep_on()函数非常地相象,当拥有CPU的进程申请资源无效时,会通过interruptible_sleep_on(),将进程从TASK_RUNNING切换到TASK_INTERRUPTIBLE状态。interruptible_sleep_on()函数的作用就是将current进程的状态置成TASK_INTERRUPTIBLE,并加到等待队列中。
   处于TASK_INTERRUPTIBLE状态的进程可以在资源有效时被wake_up()、wake_up_interruptible()或wake_up_process()唤醒,或收到signal信号以及时间中断后被唤醒。
   进行这种转换的原因基本上与sleep_on()相同,申请资源无效时进程切换到等待状态。与之不同的是处于interruptible_sleep_on()等待状态的进程是可以接受信号或中断而重新变为running状态。所以可以认为对这些资源的申请没有象在sleep_on()中资源的要求那么严格,必须得到该资源进程才能继续其运行下去。

sleep_on_timeout():TASK_RUNNING->TASK_UNINTERRUPTIBLE
sleep_on_timeout(&block.b_wait, 30*HZ);

interruptible_sleep_on_timeout():TASK_RUNNING->TASK_INTERRUPTIBLE
   虽然在申请资源或运行中出现了某种错误,但是系统仍然给进程一次重新运行的机会。调用该函数将进程从TASK_RUNNING切换到TASK_INTERRUTIBLE状态,并等待规定的时间片长度,再重新试一次。
如:在smb_request_ok 中产生了连接失败的错误,会在sem_retry()中给一次重新连接的机会。//interruptible_sleep_on_timeout(&server->wait,  5*HZ);

wake_up():TASK_UNINTERRUPTIBLE-> TASK_RUNNING;
          TASK_INTERRUPTIBLE-> TASK_RUNNING
   处于TASK_UNINTERRUPTIBLE状态的进程不能由signal信号或时钟中断唤醒,只能由wake_up()或wake_up_process()唤醒。wake_up()函数的作用是将wait_queue中的所有状态为TASK_INTERRUPTIBLE或TASK_UNINTERRUPTIBLE的进程状态都置为TASK_RUNNING,并将它们都放到running队列中去,即唤醒了所有等待在该队列上的进程。
void wake_up(struct wait_queue **q)
{
        struct wait_queue *next;
        struct wait_queue *head;

        if (!q || !(next = *q))
                return;
        head = WAIT_QUEUE_HEAD(q);
        while (next != head) {
                struct task_struct *p = next->task;
                next = next->next;
                if (p != NULL) {
                        if ((p->state == TASK_UNINTERRUPTIBLE) ||
                            (p->state == TASK_INTERRUPTIBLE))
                                wake_up_process(p);
                }
                if (!next)
                        goto bad;
        }
        return;
bad:
        printk("wait_queue is bad (eip = %p)/n",
                __builtin_return_address(0));
        printk("        q = %p/n",q);
        printk("       *q = %p/n",*q);
}

  wake_up()在下列情况下被调用:
这个函数通常在资源有效时调用,资源锁已经被释放,等待该资源的所有进程都被置为TASK_RUNNING状态,移到run queue,重新参与调度,对这一资源再次竞争。这时又会有某个进程竞争到了该项资源,而其他的进程在申请失败后,又回到TASK_UNINTERRUPTIBLE或TASK_INTERRUPTIBLE状态。
如:
网络连接表锁(Netlink table lock)释放后,唤醒等待该锁的所有睡眠进程 wake_up(&nl_table_wait);
对交换页进行I/O操作的锁释放后,唤醒等待该锁的所有睡眠进程, wake_up(&lock_queue);
对Hash表操作的锁释放后,唤醒等待该锁的所有睡眠进程,wake_up(&hash_wait);
在UMSDOS文件系统创建文件或目录工作结束后,唤醒其他由于等待它创建结束而睡眠的进程, wake_up (&dir->u.umsdos_i.u.dir_info.p);

唤醒睡眠进程执行某些操作:
如:
bd_flush()函数要将一些dirty buffer写回磁盘,就调用wake_up(&bdflush_done),唤醒正在睡眠的wakeup_bdflush()进程去处理写回。


wake_up_process():TASK_UNINTERRUPTIBLE-> TASK_RUNNING;
                   TASK_INTERRUPTIBLE-> TASK_RUNNING
   wake_up_process()函数的作用是将参数所指的那个进程状态从TASK_INTERRUPTIBLE,TASK_UNINTERRUPTIBLE变为TASK_RUNNING,并将它放到running队列中去。

void wake_up_process(struct task_struct * p)
{
        unsigned long flags;

        /*
        * We want the common case fall through straight, thus the goto.
        */
        spin_lock_irqsave(&runqueue_lock, flags);
        p->state = TASK_RUNNING;
        if (p->next_run)
                goto out;
        add_to_runqueue(p);
        spin_unlock_irqrestore(&runqueue_lock, flags);

        reschedule_idle(p);
        return;
out:
        spin_unlock_irqrestore(&runqueue_lock, flags);
}

   这个函数的实现机制与wake_up()的不同在于,它只能唤醒某一个特定的睡眠进程,而wake_up()是唤醒整个等待队列的睡眠进程。所以,它的唤醒的原因与wake_up()也有一定的区别,除了由于wake_up()对它的调用之外,它唤醒进程并不是由于资源有效造成的,唤醒的进程也不是因等待资源有效而睡眠的进程。有以下几种情况:
父进程对子进程的唤醒:
如:
在sys_ptrace()中当收到的跟踪请求为:PTRACE_CONT(在处理完信号后继续);PTRACE_KILL(将子进程杀出);PTRACE_SINGLESTEP(对子进程进行单步跟踪);PTRACE_DETACH的时候,都会在处理结束时,唤醒子进程,给子进程一个运行的机会。
在do_fork()中,新建进程初始化完毕,会由父进程唤醒它,将该进程移到run queue中,置状态为TASK_RUNNING。

当需要的时候唤醒某个睡眠的系统调用,进行处理:
如:
kswapd_process页面交换进程,通常是处于睡眠状态的,当某个进程需要更多的内存,而调用try_to_free_pages()时,就会唤醒kswapd_process页面交换进程,调入更多的内存页面。

收到信号所进行的相应处理:
如:
某一进程的时间片到了,process_timeout()会调用wake_up_process()唤醒该进程;
收到某些signal信号:处于STOPPED状态的进程收到SIGKILL或SIGCONT会被唤醒(注:处于STOPPED状态的进程不能被wake_up()唤醒);以及收到某些非实时信号,不需加到signal队列中去,处于TASK_INTERRUPTIBLE的进程有机会被唤醒。

资源有效时,wake_up()对整个等待队列的唤醒是通过对每个等待队列上的进程调用wake_up_process()实现的。

wake_up_interruptible():TASK_INTERRUPTIBLE-> TASK_RUNNING
   将wait_queue中的所有状态为 TASK_INTERRUPTIBLE的进程状态都置为TASK_RUNNING,并将它们都放到running queue中去。
   这个函数通常在send_sig(发出信号)后调用,以使信号发出后能及时得到响应,或者当空闲下来时,希望检查一下是否有收到有效信号的能运行的进程时,也可以调用这个函数,如:
在进程退出前调用notify_parent(),给父进程send_sig()后,将调用wake_up_interruptible (),使信号能够得到及时的响应。
usr/src/linux/KERNEL/EXIT.C 中定义了
void notify_parent(struct task_struct * tsk, int signal)
{
        send_sig(signal, tsk->p_pptr, 1);
        wake_up_interruptible(&tsk->p_pptr->wait_chldexit);
}
   当某一进程要结束时,它可以通过调用notify_parent(current, current->exit_signal)通知父进程以唤醒睡眠在wait_chldexit上的父进程


2. Semaphores(信号灯)

  信号量用于生成锁机制,避免发生数据不一致。
  信号量最简单的形式就是内存中一个位置,它的取值可以由多个进程检验和设置。检验和设置的操作,至少对于关联的每一个进程来讲,是不可中断或者说有原子性:只要启动就不能中止。检验和设置操作的结果是信号灯当前值和设置值的和,可以是正或者负。根据测试和设置操作的结果,一个进程可能必须睡眠直到信号灯的值被另一个进程改变。信号灯可以用于实现临界区域(critical regions),就是重要的代码区,同一时刻只能有一个进程运行。
   对信号灯的操作是通过以下两组基本函数实现的:
1.void __up(struct semaphore *sem) :TASK_UNINTERRUPTIBLE-> TASK_RUNNING;
                                  TASK_INTERRUPTIBLE-> TASK_RUNNING
    int __do_down(struct semaphore * sem, int task_state)由以下两个函数调用,分别转换到不同的等待状态:
(1)int __down_interruptible (struct semaphore * sem):
   TASK_RUNNING ->TASK_INTERRUPTIBLE;
(2)void __down(struct semaphore * sem):
   TASK_RUNNING ->TASK_UNINTERRUPTIBLE;
2. extern inline void up(struct semaphore * sem)
   extern inline void down(struct semaphore * sem);
   extern inline int down_interruptible(struct semaphore * sem);

   Linux信号量是通过两路counter变量实现的:当进程由于申请不到临界区资源而睡眠时,会将semaphore结构中的”count”变量值原子地递减1,进程睡眠等待临界区资源的释放;而当up()函数唤醒睡眠等待进程时,如果”count”变量值小于0,会将semaphore结构中的” waking”变量值原子地递增1,唤醒睡眠进程。虽然所有等待进程都被唤醒。但只有首先得到” waking”的进程才能得到信号量,继续运行下去,其他进程仍然回到最初的等待状态。

Linux定义信号灯结构是:
struct semaphore {
        atomic_t count;
        int waking;
        struct wait_queue * wait;
};
   信号灯的值初始化为一个宏定义的结构MUTEX的值{count=1,waking=0,wait=NULL}。

void __up(struct semaphore *sem):
占有临界区资源的进程,调用__up()释放资源。在__up()函数中,调用wake_one_more ()函数,原子地读sem->count, 如果sem->count <=0,则sem->waking ++,并唤醒所有等待在该sem-->wait上的进程。
void __up(struct semaphore *sem)
{
        wake_one_more(sem);
        wake_up(&sem->wait);
}


int __do_down(struct semaphore * sem, int task_state):
申请临界区资源的进程会通过调用__do_down()来竞争资源。在__do_down()函数中,调用waking_non_zero(struct semaphore *sem)或waking_non_zero_interruptible(struct semaphore *sem)抢占临界区资源,如果抢占到,则将当前进程置为TASK_RUNNING,否则将当前进程的状态置为task_state,并处于循环等待状态。
进程通过waking_non_zero()来竞争临界区资源,在该函数中判断sem-->waking的值,如果sem-->waking 大于0,sem->waking -- 并返回1,否则返回0。
int __do_down(struct semaphore * sem, int task_state)
{
        struct task_struct *tsk = current;
        struct wait_queue wait = { tsk, NULL };
        int                  ret = 0 ;

        tsk->state = task_state;
        add_wait_queue(&sem->wait, &wait);  /*将进程加入到等待队列*/

        for (;;)
        {
                if (waking_non_zero(sem))        /* 是否已经被唤醒  */
                    break ;                            /* 是的,跳出循环 */

                if (   task_state == TASK_INTERRUPTIBLE
                    && (tsk->signal & ~tsk->blocked)
        /* 如果进程状态为TASK_INTERRUPTIBLE,且收到信号量,并未被屏蔽*/
                   )
                {
                    ret = -EINTR ;                     /* 中断 */
                    atomic_inc(&sem->count) ;        /* 放弃down操作,原子递增信号量的count值 */
                    break ;
                }

                schedule();                    /* 重新调度 */
                tsk->state = task_state;      /*未能竞争到信号量的进程重新置成执行down操
                                        作前的状态*/
        }

        tsk->state = TASK_RUNNING;        /*竞争到信号量的进程置为TASK_RUNNING状态*/
        remove_wait_queue(&sem->wait, &wait);/*将进程从等待队列中删除*/
        return(ret) ;

} /* __do_down */

其中_do__down()又分别由__down()和__do_down()调用,进程转换到不同状态。
void __down(struct semaphore * sem):    TASK_RUNNING ->TASK_UNINTERRUPTIBLE;
void __down(struct semaphore * sem)
{
        __do_down(sem,TASK_UNINTERRUPTIBLE) ;
}

int __down_interruptible (struct semaphore * sem): TASK_RUNNING ->TASK_INTERRUPTIBLE;
int __down_interruptible(struct semaphore * sem)
{
        return(__do_down(sem,TASK_INTERRUPTIBLE)) ;
}

在Linux中定义了两种不同的信号灯:
(1)定义在某个数据结构上:
   在linux系统中有很多数据结构中定义了这样的信号灯,来控制对这个数据结构的资源访问,比如不允许对某个内存单元进行多进程访问,就通过定义在该内存单元上的某个信号灯mmap_sem进行__up()、_down()、up()、down()操作。
如:
struct mm_struct中有mmap_sem信号灯;
struct inode中有i_sem、i_atomic_write信号灯;
struct nlm_file中有f_sema信号灯;
struct nlm_host中有h_sema信号灯;
struct superblock中有s_vfs_rename_sem信号灯;
struct vfsmount中有mnt_dquot.semaphore信号灯;
struct task_struct中有vfork_sem信号灯;//注:这个信号灯在2.0.36版本是没有的,新版本2.2.8中才有的,用于vfork()。
struct unix_opt中有readsem信号灯;
struct smb_sb_info中有sem信号灯;
申请这些数据结构中的临界区资源,就要进行相应的信号灯操作。

(2)定义在全局的单独信号灯数据:
   还有一些单独的全局信号灯,它们并不属于某一个数据结构,而是系统定义的全局静态的信号灯,可能有多个进程对这种不属于某个特定数据结构的全局临界资源的申请,则系统通过这些全局信号灯来分配资源。
如:
nlm_file_sema;
nlmsvc_sema;
lockd_start;
read_sem;
nlm_host_sema;
read_semaphore;
uts_sem
mount_sem;
cache_chain_sem;
rpciod_sema;
rpciod_running;
mfw_sema;
firewall_sem;

   我们来分析一个例子说明信号灯的操作。例如对文件的写操作,我们假设有许多协作的进程对一个单一的数据文件进行写操作。我们希望对文件的访问必须严格地协调。因此这里就利用了inode结构上定义的信号灯inode->i_sem。
在 /usr/src/linux/mm/filemap.c中:
static int filemap_write_page(struct vm_area_struct * vma,
        unsigned long offset,
        unsigned long page)
{
        int result;
        struct file file;
    struct inode * inode;
        struct buffer_head * bh;

        ……………

        down(&inode->i_sem);
        result = do_write_page(inode, &file, (const char *) page, offset);
        up(&inode->i_sem);
        return result;
}

   在该文件写操作的代码中,加入两个信号灯操作,第一个down(&inode->i_sem)检查并把信号灯的值减小,第二个up(&inode->i_sem)检查并增加它。访问文件的第一个进程试图减小信号灯的数值,如果成功,信号灯的count取值成为0。这个进程现在可以继续运行并使用数据文件。但是,如果另一个进程需要使用这个文件,现在它试图减少信号灯的count数值,它会失败因为结果会是-1。这个进程会被挂起直到第一个进程处理完数据文件。当第一个进程处理完数据文件,它会增加信号灯的waking数值成为1。现在等待进程会被唤醒,这次它减小信号灯的尝试会成功。

   每一个独立的信号灯操作可能都需要维护一个调整动作。Linux至少为每一个进程的每一个信号灯数组都维护一个sem_undo的数据结构。如果请求的进程没有,就在需要的时候为它创建一个。这个新的sem_undo数据结构同时在进程的task_struct数据结构和信号灯队列的semid_ds数据结构的队列中排队。对信号灯队列中的信号灯执行操作的时候,和这个操作值相抵消的值加到这个进程的sem_undo数据结构的调整队列这个信号灯的条目上。所以,如果操作值为2,那么这个就在这个信号灯的调整条目上增加-2。

   当进程被删除,比如退出的时候,Linux遍历它的sem_undo数据结构组,并实施对于信号灯数组的调整。如果删除信号灯,它的sem_undo数据结构仍旧停留在进程的task_struct队列中,但是相应的信号灯数组标识符标记为无效。这种情况下,清除信号灯的代码只是简单地废弃这个sem_undo数据结构。


3.锁机制
   lock_…();
   unlock_…();
   wait_on_…():TASK_RUNNING ->TASK_UNINTERRUPTIBLE;
   进程在RUNNING,WAITING状态间转换时,锁机制也是Linux中解决进程之间共享资源的一个方法。锁就是在资源的结构定义中加入一个锁成员,或为一个标志位,它的取值可以由多个进程检验和设置。锁可以用于实现对资源的共享竞争。具体来说当一个进程占用一个资源时,先对其上锁,然后再进行相关的操作,如果这时别的进程也要用这个资源,则必须等待这个锁被解开后,才可以进行下去。
   但是,锁仅在某些数据结构和资源申请中才会用到,进程在申请某种特定资源时,会调用相应的__wait_on_… 函数来判断是否该资源已经被上锁,如果未上锁或已被解锁,则分配资源给进程,否则进程加入到等待队列中去。这种类型的申请有:__wait_on_dquot、__wait_on_buffer、__wait_on_inode、__wait_on_page、__wait_on_super等。
   值得注意的是,如果申请不到这种资源,进程的状态都是转变成TASK_UNINTERRUPTIBLE。
   定义锁的方式有两种:
专门的某项数据结构:
如:Superblock的数据结构中专门定义了锁数据项:s_lock;
置数据结构中某一项的某个标志位为锁标志:
如:
struct inode中定义了i_state的数据项,通过判断i_state 是否置了 I_LOCK,来判断该inode节点是否上锁。(2.2.8版本中定义)//注意:在2.2.0.34版本中是采用了专门的数据项i_lock来进行锁操作的。
struct buffer_head 中定义了b_state的数据项,通过判断b_state是否置了 BH_Lock位,来判断该缓冲区头是否上锁。
struct dquot中定义了dq_flags的数据项,通过判断dq_flags是否置了DQ_LOCKED位,来判断该dquot是否上锁。
struct page中定义了flags的数据项,通过判断flags是否置了PG_locked 位,来判断该页是否上锁。//注:程序中一般采用PageLocked(page)函数来判断是否上锁。

   我们以buffer_head的加锁和解锁操作为例来解释一下通过锁机制进行的状态转换,在这里要申请buffer_head 资源,先要申请到锁,buffer_head的加锁和解锁就是通过置位和复位bh->b_state来实现的:
//申请资源时将该缓冲区上锁,置锁位,如果申请不到,睡眠在等待队列上,等待该锁的释放。
extern inline void lock_buffer(struct buffer_head * bh)
{
        while (set_bit(BH_Lock, &bh->b_state))
                __wait_on_buffer(bh);
}

//资源释放时,清该缓冲区锁位,并唤醒等待队列上的进程,参与竞争资源。
void unlock_buffer(struct buffer_head * bh)
{
        ......

        clear_bit(BH_Lock, &bh->b_state);
        wake_up(&bh->b_wait);
        ......
}

//检验该锁位是否已经置位
static inline int buffer_locked(struct buffer_head * bh)
{
        return test_bit(BH_Lock, &bh->b_state);
}

//在 /USR/SRC/LINUX/FS/BUFFER.C中定义了__wait_on_buffer(stuct buffer_head * bh);该函数判断该buffer_head是否已经被上了锁,如果是,则不能得到资源,将进程置成TASK_UNINTERRUPTIBLE,加入bh-->b_wait队列中,调用schedule()转去调用其他的进程,否则,分配给资源,进程进入TASK_running状态。
void __wait_on_buffer(struct buffer_head * bh)
{
        struct wait_queue wait = { current, NULL };

        bh->b_count++;
        add_wait_queue(&bh->b_wait, &wait);/*进程加入到等待锁的队列*/
repeat:
        run_task_queue(&tq_disk);
        current->state = TASK_UNINTERRUPTIBLE;/*进程状态置为TASK_UNINTERRUPTIBLE*/
        if (buffer_locked(bh)) {
                schedule();    /*如果申请不到锁,重新调度CPU*/
                goto repeat;
        }
        remove_wait_queue(&bh->b_wait, &wait);/*进程从等待队列中删除*/
        bh->b_count--;
        current->state = TASK_RUNNING; /*进程状态置为TASK_ RUNNING*/
}


4. 管道(流)
   管道做为系统的特殊设备文件,可以是内存方式的,也可以是外存方式的。管道的传输一般是单向的,即一个管道一向,若两个进程要做双向传输则需要2个管道.管道生成时即有两端,一端为读,一端为写,两个进程要协调好,一个进程从读方读,另一个进程向写方写。管道的读写使用流设备的读写函数,即:read(),write.管道的传输方式为FIFO,流方式的.不象消息队列可以按类型读取.管道分为有名管道和无名管道:
1. 有名管道
    一般为系统特殊文件方式,使用的进程之间不一定要有父子关系或兄弟关系.
2. 无名管道
    一般为内存方式,使用的进程之间一定要有父子关系或兄弟关系.

  Linux shell允许重定向。例如:

  $ ls | pr | lpr

  把列出目录文件的命令ls的输出通过管道接到pr命令的标准输入上进行分页。最后,pr命令的标准输出通过管道连接到lpr命令的标准输入上,在缺省打印机上打印出结果。管道是单向的字节流,把一个进程的标准输出和另一个进程的标准输入连接在一起。没有一个进程意识到这种重定向,和它平常一样工作。是shell建立了进程之间的临时管道。在Linux中,使用指向同一个临时VFS INODE节点(本身指向内存中的一个物理页)的两个file数据结构来实现管道。当写进程向管道中写的时候,字节拷贝到了共享的数据页,当从管道中读的时候,字节从共享页中拷贝出来。Linux必须同步对于管道的访问。必须保证管道的写和读步调一致,它使用锁、等待队列和信号。
        运用管道方式进行通讯的进程,由于都是调用sleep_on_interruptible,因此都是睡眠在TASK_INTERRUPTIBLE状态的。

管道结构的定义在include/linux/pipe_fs_i.h中,
struct pipe_inode_info {
        struct wait_queue * wait;
        char * base;
        unsigned int start;
        unsigned int len;
        unsigned int lock; //用到了锁
        unsigned int rd_openers;
        unsigned int wr_openers;
        unsigned int readers;
        unsigned int writers;
};

对管道的操作主要有读和写两种:
1.向一个管道写pipe_write():
   在/fs/pipe.c中定义了static int pipe_write(struct inode * inode, struct file * filp, const char * buf, int count);
实现机制:当写进程向管道写的时候,它使用标准的write库函数。这些库函数传递的文件描述符是进程的file数据结构组中的索引,每一个都表示一个打开的文件,在这种情况下,是打开的管道。Linux系统调用使用描述这个管道的file数据结构指向的write例程。这个write例程使用表示管道的VFS INODE节点存放的信息,来管理写的请求。如果有足够的空间把所有的字节都写导管到中,只要管道没有被读进程锁定,Linux为写进程上锁,并把字节从进程的地址空间拷贝到共享的数据页。如果管道被读进程锁定或者空间不够,当前进程睡眠,并放在管道INODE节点的等待队列中,并调用调度程序,运行另外一个进程。它是可以中断的,所以它可以接收信号。当管道中有了足够的空间写数据或者锁定解除,写进程就会被读进程唤醒。当数据写完之后,管道的VFS INODE 节点锁定解除,管道INODE节点的等待队列中的所有读进程都会被唤醒。

2.从一个管道读Pipe_read():
   在/fs/pipe.c中定义了static int pipe_read(struct inode * inode, struct file * filp, char * buf, int count);
实现机制:从管道中读取数据和写数据非常相似。进程允许进行非阻塞的读(依赖于它们打开文件或者管道的模式),这时,如果没有数据可读或者管道被锁定,会返回一个错误。这意味着进程会继续运行。另一种方式是在管道的INODE节点的等待队列中等待,直到写进程完成。如果管道的进程都完成了操作,管道的INODE节点和相应的共享数据页被废弃。

 

进程在TASK_RUNNING和TASK_STOPPED间的转换:
1.进程从TASK_RUNNING->TASK_STOPPED的转换:
TASK_STOPPED状态是一种暂停状态,和TASK_STOPPED状态配合工作的标志为PF_PTRACED和PF_TRACESYS,分别表示被跟踪和正在跟踪系统调用,一个是被动的,一个是主动的。
进程可通过两种途径进入TASK_STOPPED状态:
1).受其它进程的syscall_trace()系统调用的控制而暂时将CPU交给控制进程。
在调用syscall_trace()之前必须先调用sys_ptrace()(简称ptrace()),进行跟踪系统调用之前的准备工作。只有调用sys_ptrace()后,current的PF_PTRACED和PF_TRACESYS标志都已置位,跟踪和被跟踪的关系都已明确,再调用syscall_trace()才能真正使进程转入STOPPED状态。
        syscall_trace()实现步骤:
(1)检验是否调用过ptrace()做过准备,没有则返回;
        (2)置状态STOPPED ,通知父进程,子进程状态已变;
        (3)进行CPU重新调度,将current进程从runqueue删除。
(4)如果exit_code非空,将它的值作为接收到的信号放到signal中。若是SIGTRAP
     则current进程将一直处于stopped,直到收到其它信号。

sys_ptrace()实现步骤:
(1)如果request == PTRACE_TRACEME,则有进程要求跟踪current进程:
                若current进程已被其它进程跟踪返回;
    否则置current进程已被进程跟踪的标记;
(2)如果current进程想跟踪其它进程:
            a.不能跟踪init进程;
                b.找pid对应的进程child,找不到返回出错;
                c.如果request为PTRACE_ATTACH
    如果current进程试图ATTACH自己,出错;
                如果试图attach的进程child已被attach,出错;
                否则        child->flags |= PF_PTRACED;做上标记,child已被attach;如果child
    不是current的子进程,将它变成current的子进程;并且发SIGSTOP信号,暂
    停它。
(3)进行其他合法性检查;
    (4)判断request,执行相应操作:
                case PTRACE_SYSCALL:继续执行,在下一个系统调用返回处停下。
    case PTRACE_CONT:发信号后重新开始运行。
                        如果request == PTRACE_SYSCALL,置child标志位PF_TRACESYS;
                        否则        清child标志位PF_TRACESYS,以防止重新运行后因历史原因在下一个
        系统调用返回处停下;
                        唤醒child进程。
          case PTRACE_KILL: 想要结束child进程,唤醒child进程,并在退出信息
                      exit_code中存放SIGKILL信号。
                case PTRACE_SINGLESTEP:  进行单步运行环境设置。
                case PTRACE_DETACH: 恢复child进程的自由。清跟踪标志,并唤醒child进程                                        恢复child进程的原始亲属关系。

 

 

2).收到要求它暂停的信号。
另一种进入STOPPED状态的方法是信号,SIGSTOP信号使自由的current进程,打上PF_PTRACED标记,并将它转入STOPPED状态。do_signal在检查进程收到的信号时,若发现current进程已打上PF_PTRACED标记,则除收到的SIGKILL信号的情况外,current进程都将马上进入STOPPED状态。
do_signal()实现步骤:
(1)current进程已打上PF_PTRACED标记,则除收到的SIGKILL信号的情况外,进程都将进入TASK_STOPPED状态,通知父进程,并重新调度;
        (2)如果收到信号SIGSTOP:如果当前进程标志位不是PF_PTRACED,则置当前进程状态为TASK_STOPPED; 通知父进程,并重新调度;

2.进程从TASK_STOPPED->TASK_RUNNING的转换:
从TASK_STOPPED状态转到TASK_RUNNING状态通过“信号唤醒”。当有SIGKILL或SIGCONT信号发给TASK_STOPPED状态下的进程时,进程将被wake_up_process()唤醒。
int send_sig(unsigned long sig,struct task_struct * p,int priv)
{
        ………;
        save_flags(flags); cli();   /*保存标志,关中断*/
        if ((sig == SIGKILL) || (sig == SIGCONT)) {
                if (p->state == TASK_STOPPED)
                        wake_up_process(p);     /*若进程p的状态是STOPPED,并且所发送的信号是SIGKILL和SIGCONT,将p状态赋成RUNNING,并挂到run-queue*/
p->exit_code = 0;      /*退出信息没有*/
                p->signal &= ~( (1<<(SIGSTOP-1)) | (1<<(SIGTSTP-1)) |
                                (1<<(SIGTTIN-1)) | (1<<(SIGTTOU-1)) );         /*处理过信号后,将p的可能曾接受到的SIGSTOP、SIGTSTP、SIGTTIN、SIGTTOU信号清掉*/
        }
        if (sig == SIGSTOP || sig == SIGTSTP || sig == SIGTTIN || sig == SIGTTOU)
                p->signal &= ~(1<<(SIGCONT-1));     /*若信号为SIGSTOP、SIGTSTP、SIGTTIN、SIGTTOU中的任一种,将p可能曾接受到的SIGCONT信号清掉*/
        restore_flags(flags);          /*恢复CPU标志同时打开中断*/
        generate(sig,p);     /*登记不能立即被处理的信号。*/
        return 0;
}

 

 

进程的终止:从TASK_RUNNING->TASK_ZOMBIE的转换
进程终止由可终止进程的系统调用通过调用do_exit()实现,do_exit()终止current进程,首先为current进程做上PF_EXITING的标记,释放current进程的存储管理信息、文件系统、文件信息、信号响应函数指针数组,将状态置成TASK_ZOMBIE,通知current的父进程,最后进行重新调度。do_exit()带一个参数code,用于传递终止进程的原因。

do_exit(long code)流程:
    (1)如果进程在中断服务程序中调用do_exit(),则打印提示信息
    (2)记录进程的记帐信息
    (3)进程标志置为PF_EXITING
(4)释放定时器链表
        (5)释放临界区数据
        (6)将消息队列中和current进程有关项删除
        (7)释放进程的存储管理信息
        (8)释放进程已打开文件的信息
        (9)释放进程的文件系统
        (10)释放进程的信号响应函数指针数组等管理信息
          (11)释放进程的LDT
        (12)进程状态置为TASK_ZOMBIE
        (13)置上退出信息,通知所有进程亲戚,它要退出了#
        (14)exec_domain结构共享计数减1, binfmt结构共享计数减1
(15)重新调度,将current进程从run-queue中删除,交出CPU

exit_notify ()函数向所有和current进程有关的进程发相应的消息,以便它们开展工作,exit_notify ()还判断cueernt进程所在组是否会因current进程的退出而悬空,如果悬空并且组内有stopped状态的进程则发信号;同时进行一系列的指针调整,调整因current进程的死亡引起的进程关系转变。
exit_notify ()流程:
将所有原始进程为current的进程变成init进程的孙子。
如果父进程和current进程不在同一组,但在同一session内并且current进程组内所有进程的父进程和它在同一组,也就是说,current进程所在组会因current的退出而悬挂,同时current进程所在组内有stopped进程,就向整个组发SIGHUP和SIGCONT信号。
通知父进程进程死了。
调整所有current进程的子进程的父进程指针,将它们挂到它们的原始进程下,
     将以往的跟踪被跟踪历史清除,调整它和新的兄弟的关系;检查每一个current
     进程的子进程所在的组是否会悬挂,如果子进程和current进程不在同一组,并
     且这个组已悬挂,组内有stopped的进程,就向组员发SIGHUP 和 SIGCONT信号。        (5)如果current进程是session的主管, 就和它所控制的tty脱离,向current
     进程显示终端所在的组发SIGHUP 和 SIGCONT信号。


进程直接或间接地调用do_exit() 后,进程进入ZOMBIE状态,还有一块PCB未释放。PCB的释放必须由它的父进程执行,当父进程调用sys_wait4()时释放进入ZOMBIE状态的子进程的PCB。

具体调用do_exit()的函数有以下情况:
具体对应的系统调用出错,不得不终止进程,如:
do_page_fault():这个系统调用处理页面错误,它找到页面地址,出错原因,并将它转入相应的处理函数。当发生越界(out of memory)等bad page的致命错误。

sys_sigreturn():一般情况下sys_sigreturn()将sigcontext的内容保存到堆栈中,保存过程中当发现段寄存器越界了,这个致命错误就将导致进程结束。

setup_frame():setup_frame()建立信号响应函数的运行的环境,保存当前寄存器,将相应寄存器赋上信号响应函数的信息。在具体设定之前首先进行存储条件检验,不满足就不得不结束进程。

save_v86_state():save_v86_state()保存虚拟86模式下(virtual 86 mode)的信息,如果进程PCB中vm86的信息为空的,无法继续进行操作,只能结束进程。

(2)其他终止进程的情况,通过调用以下函数实现终止:
sys_exit():是一个系统调用,实现终止调用它的当前进程。

sys_reboot():sys_reboot()只能被特权级用户调用,用于重新启动系统。

do_signal():do_signal()是处理信号的一个函数。检查current进程每一个接收到的signal,如果是结束进程的信号,结束进程进行相应处理。

die_if_kernel()。

[目录]


线程


1        概述
1.1        线程的定义(Introduction)
Threads can best be described as “lightweight processes”. The traditional UNIX-style notion of a process has been found to be inconvenient, if not inadequate for several applications in distributed systems development. The needs of these applications are best served by threads, which generalize the notion of a process so that it can be associated with multiple activities. The popularity of threads has resulted in their implementation on UNIX systems and thread libraries are now widely available to programmers for the development of concurrent applications.

1.2        Threads Implementation
Threads can be implemented in one of two ways:
1. User-level threads:
There is no kernel support for multi-threaded processes. Hence, the kernel only has a single-threaded process abstraction, but multi-threaded processes are implemented in a library of procedures linked with application programs. The kernel has no knowledge of lightweight processes (threads), and therefore cannot schedule them independently. A threads run-time library organizes the scheduling of threads. A thread would block the process and therefore all threads within it if it made a blocking system call, so the asynchronous I/O facilities of UNIX are used. The major disadvantage of this scheme is that threads within a process cannot take advantage of a multi-processor.
(上段译文)User-level没有核心支持的多线程的进程。因此,核心只有单线程进程概念,而多线程进程由与应用程序连接的过程库实现。核心不知道线程的存在,也就不能独立的调度这些线程了。一个线程运行库组织线程的调度。如果一个线程调用了一个阻塞的系统调用,进程可能被阻塞,当然其中的所有线程也同时被阻塞,所以UNIX使用了异步I/O工具。这种机制的的最大缺点是不能发挥多处理器的优势。
The advantages include:
(系统消耗小)Certain thread operations are significantly less costly. For example, switching between threads belonging to the same process do not necessarily involve a system call, and hence save this over-head.
(可以修改以适应特殊的应用)User-level thread implementations can be customized or changed to suit the particular application requirements. This is particularly useful for real-time multimedia processing etc. Also, it is possible to support many more user-level threads than can by default by a kernel.
2. Kernel-level threads:
This implementation allows threads within different processes to be scheduled according to a single scheme of relative prioritizing. This is suited for exploiting the concurrence of multiprocessors.
核心级线程如许不同进程里的线程按照同一相对优先方法调度,这适合于发挥多处理器的并发优点。
Most of the current thread library implementations available today implement user-level threads. There have been several research projects that have implemented some form of Kernel-level threads. Notable among these are the Mach distributed OS, which combines the advantages of user-level and kernel-level threads by allowing user-level code to provide scheduling hints to the kernel thread scheduler. By providing such a two-level scheduling scheme, the kernel retains control over the allocation of processor time, but also allows a process to take advantage of multiple processors.

1.3        Thread Libraries
The two most widely used thread libraries are POSIX and Solaris thread libraries. Both implementations are inter-operable, their functionality is similar, and can be used within the same application. However, only POSIX threads are guaranteed to be fully portable to other POSIX-compliant environments.
Similarities:
Most of the functions in both libraries, libpthread and libthread, have a counterpart in the other library. POSIX functions and Solaris functions, whose names have similar endings, usually have similar functionality, number of arguments, and use of arguments. All POSIX threads function names begin with the prefix pthread? where as the Solaris threads function names begin with the prefix thr?
Differences:
POSIX
is more portable
establishes characteristics for each thread according to configurable attribute objects
implements thread cancellation
enforces scheduling algorithms
allows for clean-up handlers for fork(2) calls
Solaris
threads can be suspended and continued
implements an optimized mutex, readers/writer locking
may increase the concurrency
implements daemon threads, for whose demise the process does not wait


1.4        Threads Standards
There are three different definitions for thread libraries competing for attention today: Win32, OS/2, and POSIX. The first two are proprietary and limited to their individual platforms (Win32 threads run only under NT and Win95, OS/2 threads on OS/2). The POSIX specification (IEEE 1003.1c, aka Pthreads) is intended for all computing platforms, and implementations are available or in the works for almost all major UNIX systems (including Linux), along with VMS.

POSIX Threads
The POSIX standard defines the API and behavior that all the Pthreads libraries must meet. It is part of the extended portion of POSIX, so it is not a requirement for meeting XPG4, but it is required for X/Open UNIX 98, and all major UNIX vendors have committed to meeting this standard. As of this writing, (7/97) almost all UNIX vendors have released a library.

Win32 and OS/2 Threads
Both the NT and OS/2 implementations contain some fairly radical differences
from the POSIX standard--to the degree that even porting from one or the other
to POSIX will prove moderately challenging. Microsoft has not announced any
plans to adopt POSIX. There are freeware POSIX libraries for Win32 (see
Commercial Products on page 249), and OS/2 also has an optional POSIX library.

DCE Threads
Before POSIX completed work on the standard, it produced a number of drafts which it published for comment. Draft 4 was used as the basis for the threads library in DCE. It is similar to the final spec, but it does contain a number of significant differences. Presumably, no one is writing any new DCE code.

Solaris Threads
Also known as UI threads, this is the library, which SunSoft used in developing Solaris 2 before the POSIX, committee completed their work. It will be available on Solaris 2 for the foreseeable future, although we expect most applications writers will opt for Pthreads. The vast majority of the two libraries are virtually identical.
1.5        Linux线程的思想及特点
1.5.1        LinuxThreads
http://pauillac.inria.fr/~xleroy/linuxthreads
Xavier Leroy at INRIA (Paris, France), with input from Pavel Krauz, Richard Henderson and others, has developed a Pthreads library that implements the One-to-One model, allowing it to take advantage of multiple processors. It is based on the new Linux system call, clone()2 . It runs on Linux 2.0 and up, on Intel, Alpha, SPARC, m68k, and MIPS machines. One limitation is its non-standard implementation of signal handling.
1.5.2        Implementation model for LinuxThreads
LinuxThreads follows the so-called "one-to-one" model: each thread is actually a separate process in the kernel. The kernel scheduler takes care of scheduling the threads, just like it schedules regular processes. The threads are created with the Linux clone() system call, which is a generalization of fork() allowing the new process to share the memory space, file descriptors, and signal handlers of the parent.
LinuxThreads采用称为1-1模型:每个线程实际上在核心是一个个单独的进程,核心的调度程序负责线程的调度,就象调度普通进程。线程是用系统调用clone()创建的,clone()系统调用是fork()的普遍形式,它允许新进程共享父进程的存储空间、文件描述符和软中断处理程序。
Advantages of the "one-to-one" model include:

Minimal overhead on CPU-intensive multiprocessing (with about one thread per processor); 最小限度消耗的CPU级多处理技术(每个CPU一个线程);
Minimal overhead on I/O operations; 最小限度消耗的I/O操作;
A simple and robust implementation (the kernel scheduler does most of the hard work for us);一种简单和强壮的实现(核心调度程序为我们做了大部分艰难的工作)。

The main disadvantage is more expensive context switches on mutex and condition operations, which must go through the kernel. This is mitigated by the fact that context switches in the Linux kernel are pretty efficient.

1.5.3        Consider other implementation models

There are basically two other models. The "many-to-one" model relies on a user-level scheduler that context-switches between the threads entirely in user code; viewed from the kernel, there is only one process running. This model is completely out of the question for me, since it does not take advantage of multiprocessors, and require unholy magic to handle blocking I/O operations properly. There are several user-level thread libraries available for Linux, but I found all of them deficient in functionality, performance, and/or robustness.
还有另外两种基本模型。多对一模型依赖于用户级的调度程序,线程切换完全由用户程序完成;从核心角度看,只有一个进程正在运行。这种模型不是我们所关心的,因为它无法利用多处理器的优点,而且要用不合理的方法处理I/O操作阻塞。
The "many-to-many" model combines both kernel-level and user-level scheduling: several kernel-level threads run concurrently, each executing a user-level scheduler that selects between user threads. Most commercial Unix systems (Solaris, Digital Unix and IRIX) implement POSIX threads this way. This model combines the advantages of both the "many-to-one" and the "one-to-one" model, and is attractive because it avoids the worst-case behaviors of both models -- especially on kernels where context switches are expensive, such as Digital Unix. Unfortunately, it is pretty complex to implement, and requires kernel supporting which Linux does not provide. Linus Torvalds and other Linux kernel developers have always been pushing the "one-to-one" model in the name of overall simplicity, and are doing a pretty good job of making kernel-level context switches between threads efficient. LinuxThreads is just following the general direction they set.
2        Linux核心对线程的支持
Linux核心对线程的支持主要是通过其系统调用,下文将进行系统的介绍。
2.1        系统调用clone()
以下是系统调用clone的代码:
asmlinkage int sys_clone(struct pt_regs regs)
{
        unsigned long clone_flags;
        unsigned long newsp;

        clone_flags = regs.ebx;
        newsp = regs.ecx;
if (!newsp)
                newsp = regs.esp;
        return do_fork(clone_flags, newsp, &regs);
}

与系统调用clone功能相似的系统调用有fork,但fork事实上只是clone的功能的一部分,clone与fork的主要区别在于传递了几个参数,而当中最重要的参数就是conle_flags,下表是系统定义的几个clone_flags标志:
标志        Value        含义
CLONE_VM        0x00000100        置起此标志在进程间共享VM
CLONE_FS        0x00000200        置起此标志在进程间共享文件系统信息
CLONE_FILES        0x00000400        置起此标志在进程间共享打开的文件
CLONE_SIGHAND        0x00000800        置起此标志在进程间共享信号处理程序
如果置起以上标志所做的处理分别是:
置起CLONE_VM标志:
                mmget(current->mm);
                /*
                * Set up the LDT descriptor for the clone task.
                */
                copy_segments(nr, tsk, NULL);
                SET_PAGE_DIR(tsk, current->mm->pgd);
置起CLONE_ FS标志:
                atomic_inc(&current->fs->count);
置起CLONE_ FILES标志:
                atomic_inc(&oldf->count);
置起CLONE_ SIGHAND标志:
                atomic_inc(&current->sig->count);
2.2        与线程调度相关的系统调用
以下是glibc-linuxthread用来进行调度的系统调度:
        .long SYMBOL_NAME(sys_sched_setparam)   /* 系统调用154 */
/*用来设置进程(或线程)的调度参数*/
        .long SYMBOL_NAME(sys_sched_getparam)
/*用来获取进程(或线程)的调度参数*/
        .long SYMBOL_NAME(sys_sched_setscheduler)
/*用来设置进程(或线程)的调度参数*/
        .long SYMBOL_NAME(sys_sched_getscheduler)
/*用来获取进程(或线程)的调度参数*/
        .long SYMBOL_NAME(sys_sched_yield)
/*用来强制核心重新调度进程(或线程)*/
        .long SYMBOL_NAME(sys_sched_get_priority_max)
/*用来设置进程(或线程)的调度参数*/
        .long SYMBOL_NAME(sys_sched_get_priority_min)
/*用来获取进程(或线程)的调度参数*/
        .long SYMBOL_NAME(sys_sched_rr_get_interval) /* 系统调用161 */
/*用来获取进程(或线程)的调度时间间隔*/

3        Linux线程的实现
3.1        LinuxThreads概述
现在的0.8版LinuxThreads,是迄今为止在Linux下支持threads的最好的Runtime-library,而包含0.8版LinuxThreads的最好的Runtime-library是glibc- 2.1,下文所要分析的正是glibc-linuxthreads-2.1。
首先介绍一下0.8版LinuxThreads,它实现了一种BiCapitalized面向Linux的Posix 1003.1c"pthread"标准接口。LinuxThreads提供核心级线程即每个线程是一个独立的UNIX进程,通过调用新的系统调用与其它线程共享地址空间。线程由核心调度,就象UNIX进程调度一样。使用它的要求是:LINUX 版本2.0 或以上(要求有新的clone() 系统调用和新的实时调度程序)。对于Intel平台:要求有libc 5.2.18或后续版本,推荐使用5.2.18 或 5.4.12 及其后续版本;5.3.12和5.4.7有问题,也支持glibc 2,实际上是支持它的一个特别合适的版本。到目前支持Intel, Alpha, Sparc, Motorola 68k, ARM and MIPS平台,还支持多处理器
3.2        主要的数据结构及初始化
3.2.1        数据结构和部分数据初始化
/* Arguments passed to thread creation routine */
//传递给线程创建程序的参数
struct pthread_start_args {
  void * (*start_routine)(void *); /* function to run */
  void * arg;                   /* its argument */
  sigset_t mask;                /* initial signal mask for thread */
  int schedpolicy;              /* initial scheduling policy (if any) */
  struct sched_param schedparam; /* initial scheduling parameters (if any) */
};

/* The type of thread descriptors */
//线程描述符类型
typedef struct _pthread_descr_struct * pthread_descr;

struct _pthread_descr_struct {
  pthread_descr p_nextlive, p_prevlive;
                                /* Double chaining of active threads */
  pthread_descr p_nextwaiting;  /* Next element in the queue holding the thr */
  pthread_t p_tid;              /* Thread identifier */
  int p_pid;                    /* PID of Unix process */
  int p_priority;               /* Thread priority (== 0 if not realtime) */
  struct _pthread_fastlock * p_lock; /* Spinlock for synchronized accesses */
  int p_signal;                 /* last signal received */
  sigjmp_buf * p_signal_jmp;    /* where to siglongjmp on a signal or NULL */
  sigjmp_buf * p_cancel_jmp;    /* where to siglongjmp on a cancel or NULL */
  char p_terminated;            /* true if terminated e.g. by pthread_exit */
  char p_detached;              /* true if detached */
  char p_exited;                /* true if the assoc. process terminated */
  void * p_retval;              /* placeholder for return value */
  int p_retcode;                /* placeholder for return code */
  pthread_descr p_joining;      /* thread joining on that thread or NULL */
  struct _pthread_cleanup_buffer * p_cleanup; /* cleanup functions */
  char p_cancelstate;           /* cancellation state */
  char p_canceltype;            /* cancellation type (deferred/async) */
  char p_canceled;              /* cancellation request pending */
  int * p_errnop;               /* pointer to used errno variable */
  int p_errno;                  /* error returned by last system call */
  int * p_h_errnop;             /* pointer to used h_errno variable */
  int p_h_errno;                /* error returned by last netdb function */
  char * p_in_sighandler;       /* stack address of sighandler, or NULL */
  char p_sigwaiting;            /* true if a sigwait() is in progress */
  struct pthread_start_args p_start_args; /* arguments for thread creation */
  void ** p_specific[PTHREAD_KEY_1STLEVEL_SIZE]; /* thread-specific data */
  void * p_libc_specific[_LIBC_TSD_KEY_N]; /* thread-specific data for libc */
  int p_userstack;                /* nonzero if the user provided the stack */
  void *p_guardaddr;                /* address of guard area or NULL */
  size_t p_guardsize;                /* size of guard area */
  pthread_descr p_self;                /* Pointer to this structure */
  int p_nr;                     /* Index of descriptor in __pthread_handles */
};

/* The type of thread handles. */
线程句柄
typedef struct pthread_handle_struct * pthread_handle;

struct pthread_handle_struct {
  struct _pthread_fastlock h_lock; /* Fast lock for sychronized access */
  pthread_descr h_descr;        /* Thread descriptor or NULL if invalid */
  char * h_bottom;              /* Lowest address in the stack thread */
};

/* The type of messages sent to the thread manager thread */
//发送给线程管理线程的请求
struct pthread_request {
  pthread_descr req_thread;     /* Thread doing the request */
  enum {                        /* Request kind */
    REQ_CREATE, REQ_FREE, REQ_PROCESS_EXIT, REQ_MAIN_THREAD_EXIT,
    REQ_POST, REQ_DEBUG
  } req_kind;
  union {                       /* Arguments for request */
    struct {                    /* For REQ_CREATE: */
      const pthread_attr_t * attr; /* thread attributes */
      void * (*fn)(void *);     /*   start function */
      void * arg;               /*   argument to start function */
      sigset_t mask;            /*   signal mask */
    } create;
    struct {                    /* For REQ_FREE: */
      pthread_t thread_id;      /*   identifier of thread to free */
    } free;
    struct {                    /* For REQ_PROCESS_EXIT: */
      int code;                 /*   exit status */
    } exit;
    void * post;                /* For REQ_POST: the semaphore */
  } req_args;
};

/* One end of the pipe for sending requests to the thread manager. */
//向管理线程发送请求的管道的一端;初始化为-1表示管理线程还没有创建
int __pthread_manager_request = -1;

/* Other end of the pipe for sending requests to the thread manager. */

int __pthread_manager_reader;

//线程的堆栈大小
#define STACK_SIZE  (2 * 1024 * 1024)
//线程的初始堆栈大小
#define INITIAL_STACK_SIZE  (4 * PAGE_SIZE)

/* Attributes for threads.  */
//线程的属性
typedef struct
{
  int __detachstate;
  int __schedpolicy;
  struct __sched_param __schedparam;
  int __inheritsched;
  int __scope;
  size_t __guardsize;
  int __stackaddr_set;
  void *__stackaddr;
  size_t __stacksize;
} pthread_attr_t;

//每个进程的最大线程数
#define PTHREAD_THREADS_MAX        1024

3.2.2        Main thread and manager thread initializing

 

/* Thread creation */

int __pthread_create_2_1(pthread_t *thread, const pthread_attr_t *attr,
                        void * (*start_routine)(void *), void *arg)
{
  pthread_descr self = thread_self();
  struct pthread_request request;
  if (__pthread_manager_request < 0) {    //检查是否启动线程机制
        //初始化管理线程,启动线程机制
    if (__pthread_initialize_manager() < 0) return EAGAIN;
  }
  request.req_thread = self;
  request.req_kind = REQ_CREATE;
  request.req_args.create.attr = attr;
  request.req_args.create.fn = start_routine;
  request.req_args.create.arg = arg;
  sigprocmask(SIG_SETMASK, (const sigset_t *) NULL,
              &request.req_args.create.mask);
//向管理线程发送请求
  __libc_write(__pthread_manager_request, (char *) &request, sizeof(request));
  suspend(self);
  if (THREAD_GETMEM(self, p_retcode) == 0)
    *thread = (pthread_t) THREAD_GETMEM(self, p_retval);
  return THREAD_GETMEM(self, p_retcode);
}

int __pthread_initialize_manager(void)
{
  int manager_pipe[2];
  int pid;
  struct pthread_request request;

  /* If basic initialization not done yet (e.g. we're called from a constructor run before our constructor), do it now */
//初始化初始线程
  if (__pthread_initial_thread_bos == NULL) pthread_initialize();
  /* Setup stack for thread manager */建立管理线程堆栈
  __pthread_manager_thread_bos = malloc(THREAD_MANAGER_STACK_SIZE);
  if (__pthread_manager_thread_bos == NULL) return -1;
  __pthread_manager_thread_tos =
    __pthread_manager_thread_bos + THREAD_MANAGER_STACK_SIZE;
  /* Setup pipe to communicate with thread manager */
//建立与管理线程通信的管道
  if (pipe(manager_pipe) == -1) {
    free(__pthread_manager_thread_bos);
    return -1;
  }
  /* Start the thread manager */启动管理线程
  pid = __clone(__pthread_manager, (void **) __pthread_manager_thread_tos,
                CLONE_VM | CLONE_FS | CLONE_FILES | CLONE_SIGHAND
                , (void *)(long)manager_pipe[0]);
  if (pid == -1) {
    free(__pthread_manager_thread_bos);
    __libc_close(manager_pipe[0]);
    __libc_close(manager_pipe[1]);
    return -1;
  }
  __pthread_manager_request = manager_pipe[1]; /* writing end */
  __pthread_manager_reader = manager_pipe[0]; /* reading end */
  __pthread_manager_thread.p_pid = pid;
  /* Make gdb aware of new thread manager */
  if (__pthread_threads_debug && __pthread_sig_debug > 0)
    {
      raise(__pthread_sig_debug);
      /* We suspend ourself and gdb will wake us up when it is
        ready to handle us. */
      suspend(thread_self());
    }
  /* Synchronize debugging of the thread manager */
  request.req_kind = REQ_DEBUG;
  __libc_write(__pthread_manager_request, (char *) &request, sizeof(request));
  return 0;
}
//初始化初始线程
static void pthread_initialize(void)
{
  struct sigaction sa;
  sigset_t mask;
  struct rlimit limit;
  int max_stack;

  /* If already done (e.g. by a constructor called earlier!), bail out */
  if (__pthread_initial_thread_bos != NULL) return;
#ifdef TEST_FOR_COMPARE_AND_SWAP
  /* Test if compare-and-swap is available */
  __pthread_has_cas = compare_and_swap_is_available();
#endif
  /* For the initial stack, reserve at least STACK_SIZE bytes of stack below the current stack address, and align that on a STACK_SIZE boundary. */
//当前堆栈下为初始堆栈留出至少STACK_SIZE,并按STACK_SIZE对齐
  __pthread_initial_thread_bos =
    (char *)(((long)CURRENT_STACK_FRAME - 2 * STACK_SIZE) & ~(STACK_SIZE - 1));
  /* Play with the stack size limit to make sure that no stack ever grows
     beyond STACK_SIZE minus two pages (one page for the thread descriptor
     immediately beyond, and one page to act as a guard page). */
//调整堆栈大小限制使其不能增长超过STACK_SIZE减两页(一页给线程
//描述符,一页作为保护页)
  getrlimit(RLIMIT_STACK, &limit);
  max_stack = STACK_SIZE - 2 * __getpagesize();
  if (limit.rlim_cur > max_stack) {
    limit.rlim_cur = max_stack;
    setrlimit(RLIMIT_STACK, &limit);
  }
  /* Update the descriptor for the initial thread. */
  __pthread_initial_thread.p_pid = __getpid();
  /* If we have special thread_self processing, initialize that for the
     main thread now.  */
#ifdef INIT_THREAD_SELF
  INIT_THREAD_SELF(&__pthread_initial_thread, 0);
#endif
  /* The errno/h_errno variable of the main thread are the global ones.  */
  __pthread_initial_thread.p_errnop = &_errno;
  __pthread_initial_thread.p_h_errnop = &_h_errno;
#ifdef SIGRTMIN
  /* Allocate the signals used.  */分配使用的软中断号
  __pthread_sig_restart = __libc_allocate_rtsig (1);
  __pthread_sig_cancel = __libc_allocate_rtsig (1);
  __pthread_sig_debug = __libc_allocate_rtsig (1);
  if (__pthread_sig_restart < 0 ||
      __pthread_sig_cancel < 0 ||
      __pthread_sig_debug < 0)
    {
      /* The kernel does not support real-time signals.  Use as before
        the available signals in the fixed set.
         Debugging is not supported in this case. */
      __pthread_sig_restart = DEFAULT_SIG_RESTART;
      __pthread_sig_cancel = DEFAULT_SIG_CANCEL;
      __pthread_sig_debug = 0;
    }
#endif
  /* Setup signal handlers for the initial thread.
     Since signal handlers are shared between threads, these settings
     will be inherited by all other threads. */
//设置初始进程的信号处理程序
#ifndef __i386__
  sa.sa_handler = pthread_handle_sigrestart;
#else
  sa.sa_handler = (__sighandler_t) pthread_handle_sigrestart;
#endif
  sigemptyset(&sa.sa_mask);
  sa.sa_flags = 0;
  __sigaction(__pthread_sig_restart, &sa, NULL);
#ifndef __i386__
  sa.sa_handler = pthread_handle_sigcancel;
#else
  sa.sa_handler = (__sighandler_t) pthread_handle_sigcancel;
#endif
  sa.sa_flags = 0;
  __sigaction(__pthread_sig_cancel, &sa, NULL);
  if (__pthread_sig_debug > 0) {
    sa.sa_handler = pthread_handle_sigdebug;
    sigemptyset(&sa.sa_mask);
    sa.sa_flags = 0;
    __sigaction(__pthread_sig_debug, &sa, NULL);
  }
  /* Initially, block __pthread_sig_restart. Will be unblocked on demand. */
  sigemptyset(&mask);
  sigaddset(&mask, __pthread_sig_restart);
  sigprocmask(SIG_BLOCK, &mask, NULL);
  /* Register an exit function to kill all other threads. */
  /* Do it early so that user-registered atexit functions are called
     before pthread_exit_process. */
  __on_exit(pthread_exit_process, NULL);
}

3.3        线程的创建

Manager thread 接到创建线程请求后调用下函数。
static int pthread_handle_create(pthread_t *thread, const pthread_attr_t *attr,
                                void * (*start_routine)(void *), void *arg,
                                sigset_t * mask, int father_pid)
{
  size_t sseg;
  int pid;
  pthread_descr new_thread;
  char * new_thread_bottom;
  pthread_t new_thread_id;
  char *guardaddr = NULL;
  size_t guardsize = 0;
  int pagesize = __getpagesize();

  /* First check whether we have to change the policy and if yes, whether
     we can  do this.  Normally this should be done by examining the
     return value of the __sched_setscheduler call in pthread_start_thread
     but this is hard to implement.  FIXME  */
//检查是否需要调整调度策略,如果需要,是否能够做到
  if (attr != NULL && attr->__schedpolicy != SCHED_OTHER && geteuid () != 0)
    return EPERM;
  /* Find a free segment for the thread, and allocate a stack if needed */
//找出一个空段,如果需要再分配堆栈
  for (sseg = 2; ; sseg++)
    {
      if (sseg >= PTHREAD_THREADS_MAX)
        return EAGAIN;
      if (__pthread_handles[sseg].h_descr != NULL)
        continue;
      if (pthread_allocate_stack(attr, thread_segment(sseg), pagesize,
                                 &new_thread, &new_thread_bottom,
                                 &guardaddr, &guardsize) == 0)
        break;
    }
  __pthread_handles_num++;
  /* Allocate new thread identifier */分配新线程的标识符
  pthread_threads_counter += PTHREAD_THREADS_MAX;
  new_thread_id = sseg + pthread_threads_counter;
  /* Initialize the thread descriptor */初始化新线程描述符
  new_thread->p_nextwaiting = NULL;
  new_thread->p_tid = new_thread_id;
  new_thread->p_priority = 0;
  new_thread->p_lock = &(__pthread_handles[sseg].h_lock);
  new_thread->p_signal = 0;
  new_thread->p_signal_jmp = NULL;
  new_thread->p_cancel_jmp = NULL;
  new_thread->p_terminated = 0;
  new_thread->p_detached = attr == NULL ? 0 : attr->__detachstate;
  new_thread->p_exited = 0;
  new_thread->p_retval = NULL;
  new_thread->p_joining = NULL;
  new_thread->p_cleanup = NULL;
  new_thread->p_cancelstate = PTHREAD_CANCEL_ENABLE;
  new_thread->p_canceltype = PTHREAD_CANCEL_DEFERRED;
  new_thread->p_canceled = 0;
  new_thread->p_errnop = &new_thread->p_errno;
  new_thread->p_errno = 0;
  new_thread->p_h_errnop = &new_thread->p_h_errno;
  new_thread->p_h_errno = 0;
  new_thread->p_in_sighandler = NULL;
  new_thread->p_sigwaiting = 0;
  new_thread->p_guardaddr = guardaddr;
  new_thread->p_guardsize = guardsize;
  new_thread->p_userstack = attr != NULL && attr->__stackaddr_set;
  memset (new_thread->p_specific, '/0',
          PTHREAD_KEY_1STLEVEL_SIZE * sizeof (new_thread->p_specific[0]));
  new_thread->p_self = new_thread;
  new_thread->p_nr = sseg;
  /* Initialize the thread handle */
  __pthread_init_lock(&__pthread_handles[sseg].h_lock);
  __pthread_handles[sseg].h_descr = new_thread;
  __pthread_handles[sseg].h_bottom = new_thread_bottom;
  /* Determine scheduling parameters for the thread */
//确定线程的调度参数
  new_thread->p_start_args.schedpolicy = -1;
  if (attr != NULL) {
    switch(attr->__inheritsched) {
    case PTHREAD_EXPLICIT_SCHED:
      new_thread->p_start_args.schedpolicy = attr->__schedpolicy;
      memcpy (&new_thread->p_start_args.schedparam, &attr->__schedparam,
              sizeof (struct sched_param));
      break;
    case PTHREAD_INHERIT_SCHED:
      /* schedpolicy doesn't need to be set, only get priority */
      __sched_getparam(father_pid, &new_thread->p_start_args.schedparam);
      break;
    }
    new_thread->p_priority =
      new_thread->p_start_args.schedparam.sched_priority;
  }
  /* Finish setting up arguments to pthread_start_thread */
//设置pthread_start_thread的参数
  new_thread->p_start_args.start_routine = start_routine;
  new_thread->p_start_args.arg = arg;
  new_thread->p_start_args.mask = *mask;
  /* Raise priority of thread manager if needed */根据需要调整管理线程的优先级
  __pthread_manager_adjust_prio(new_thread->p_priority);
  /* Do the cloning */创建新线程
  pid = __clone(pthread_start_thread, (void **) new_thread,
                CLONE_VM | CLONE_FS | CLONE_FILES | CLONE_SIGHAND |
                __pthread_sig_cancel, new_thread);
  /* Check if cloning succeeded */
  if (pid == -1) {
    /* Free the stack if we allocated it */
    if (attr == NULL || !attr->__stackaddr_set)
      {
        munmap((caddr_t)((char *)(new_thread+1) - INITIAL_STACK_SIZE),
               INITIAL_STACK_SIZE);
        if (new_thread->p_guardsize != 0)
          munmap(new_thread->p_guardaddr, new_thread->p_guardsize);
      }
    __pthread_handles[sseg].h_descr = NULL;
    __pthread_handles[sseg].h_bottom = NULL;
    __pthread_handles_num--;
    return errno;
  }
  /* Insert new thread in doubly linked list of active threads */
//将新线程插入双向链表
  new_thread->p_prevlive = __pthread_main_thread;
  new_thread->p_nextlive = __pthread_main_thread->p_nextlive;
  __pthread_main_thread->p_nextlive->p_prevlive = new_thread;
  __pthread_main_thread->p_nextlive = new_thread;
  /* Set pid field of the new thread, in case we get there before the
     child starts. */
  new_thread->p_pid = pid;
  /* We're all set */
  *thread = new_thread_id;
  return 0;
}


3.4        线程的堆栈分配和管理
STACK_SIZE    2*1024*1024
INITIAL_STACK_SIZE    4*PAGE_SIZE
THREAD_MANAGER_STACK_SIZE      2*PAGE_SIZE-32

static int pthread_allocate_stack(const pthread_attr_t *attr,
                                  pthread_descr default_new_thread,
                                  int pagesize,
                                  pthread_descr * out_new_thread,
                                  char ** out_new_thread_bottom,
                                  char ** out_guardaddr,
                                  size_t * out_guardsize)
{
  pthread_descr new_thread;
  char * new_thread_bottom;
  char * guardaddr;
  size_t stacksize, guardsize;

  if (attr != NULL && attr->__stackaddr_set)
    {
      /* The user provided a stack. */用户提供堆栈
      new_thread =
        (pthread_descr) ((long)(attr->__stackaddr) & -sizeof(void *)) - 1;
      new_thread_bottom = (char *) attr->__stackaddr - attr->__stacksize;
      guardaddr = NULL;
      guardsize = 0;
      __pthread_nonstandard_stacks = 1;
    }
  else
    {
      /* Allocate space for stack and thread descriptor at default address */
//在缺省地址分配堆栈和描述符
      new_thread = default_new_thread;
      new_thread_bottom = (char *) new_thread - STACK_SIZE;
      if (mmap((caddr_t)((char *)(new_thread + 1) - INITIAL_STACK_SIZE), INITIAL_STACK_SIZE, PROT_READ | PROT_WRITE | PROT_EXEC, MAP_PRIVATE | MAP_ANONYMOUS | MAP_FIXED | MAP_GROWSDOWN, -1, 0) == MAP_FAILED)
        /* Bad luck, this segment is already mapped. */
        return -1;
      /* We manage to get a stack.  Now see whether we need a guard
         and allocate it if necessary.  Notice that the default
         attributes (stack_size = STACK_SIZE - pagesize and
         guardsize = pagesize) do not need a guard page, since
         the RLIMIT_STACK soft limit prevents stacks from
         running into one another. */
//判断是否需要保护页,如果需要就分配
      if (attr == NULL ||
          attr->__guardsize == 0 ||
          (attr->__guardsize == pagesize &&
           attr->__stacksize == STACK_SIZE - pagesize))
        {
          /* We don't need a guard page. */
          guardaddr = NULL;
          guardsize = 0;
        }
      else
        {
          /* Put a bad page at the bottom of the stack */
          stacksize = roundup(attr->__stacksize, pagesize);
          if (stacksize >= STACK_SIZE - pagesize)
            stacksize = STACK_SIZE - pagesize;
          guardaddr = (void *)new_thread - stacksize;
          guardsize = attr->__guardsize;
          if (mmap ((caddr_t) guardaddr, guardsize, 0, MAP_FIXED, -1, 0)
              == MAP_FAILED)
            {
              /* We don't make this an error.  */
              guardaddr = NULL;
              guardsize = 0;
            }
        }
    }
  *out_new_thread = new_thread;
  *out_new_thread_bottom = new_thread_bottom;
  *out_guardaddr = guardaddr;
  *out_guardsize = guardsize;
  return 0;
}


3.5        线程的调度
Common threads 的调度和普通进程并无大的区别,创建者可以自己设定线程的优先级。但是Manager thread则需要实时响应各进程提出的请求,所以Manager thread被设置成高于其它线程的优先级,方法是在创建每个新线程时调整Manager thread的优先级。

/* Adjust priority of thread manager so that it always run at a priority
   higher than all threads */

void __pthread_manager_adjust_prio(int thread_prio)
{
  struct sched_param param;

  if (thread_prio <= __pthread_manager_thread.p_priority) return;
  param.sched_priority =
    thread_prio < __sched_get_priority_max(SCHED_FIFO)
    ? thread_prio + 1 : thread_prio;
  __sched_setscheduler(__pthread_manager_thread.p_pid, SCHED_FIFO, &param);
  __pthread_manager_thread.p_priority = thread_prio;
}

 

[目录]


进程描述符


标题   新兵笔记--ULK(C3) Process Descriptor
作者 Big John (stranger )
时间 05/19/01 06:01 PM

Process Descriptor

description:
进程描述符:也就是结构体task_struct,它有很多域,包含了一个进程的所有信息,主要有它的属性、当前的状态、它所占有的资料,还有一些指针用于把按不同的需求把它链进不同的链表中。
进程描述符与进程的kernel栈:每个进程都有个自己的kernel栈,当它进入kernel态时(比如进行系统调用),kernel会把栈指针指向当前进程的kernel栈。在2.2中,进程的描述符和kernel栈是捆在一起的,
union task_union {
struct task_struct task;
unsigned long stack[2048];
};
kernel每次分配一个进程描述符总会按task_union的大小(即8k)"顺手"分配一个kernel栈,这样做一个最重要的目的就是为了能方便的得到当前运行进程的描述符,当系统需要时,总是使用current来得到当前运行的进程,在2.0中current可能是个全局变量或全局数组(当多CPU时),这样一方面是不方便使用,另一方面,在多CPU中还得去找当前CPU才能确定当前的current(我当初看过,但忘了它是怎么找的了)。现在使用了这个结构,kernel随时可以通过栈底指针减8K就可得到描述符的地址。大家可以看到现在的current实际是一个函数get_current,它所做的是就是把esp减去8K,然后返回这个地址。
进程描述符的分配与释放:由这两个函数完成,alloc_task_struct和free_task_struct。这两个函数没什么花头,还是由于分配物理页帧的代码过大,这里也有一个缓存static struct task_struct * task_struct_stack[EXTRA_TASK_STRUCT],它能缓存16项,分配和释放都尽量在这进行,除非它已经满了或空了,才去与分页系统打交道。
进程数组:struct task_struct *task[NR_TASKS];它是一个指针数组,其中NR_TASKS在i386下应该4090,实际可同时运行的进程应该是4092个,因为还得加上Process 0和Procces 1,这两个进程是不在进程数组中的。
当创建一个进程时,kernel会申请一片内存并把它加入task数组中。如何加入呢?出于效率考虑,task数组并不象我们平时处理那样把没有用的项置空,当要加入时顺序的去找数组中为空的项。它使用了类似于第二章中页表缓存链表的管理方法,tarray_freelist是这个链表的表头,具体操作如下:
初始化:
struct task_struct **tarray_freelist = NULL;
void __init sched_init(void)
{
。。。
int nr = NR_TASKS;
while(--nr > 0)
add_free_taskslot(&task[nr]); // 把task数组的每一项加到空闲链表中。
。。。
}
函数add_free_taskslot:
*t = (struct task_struct *) tarray_freelist; // 把当前指针当next用,指向空闲链表的第一项(可能是NULL)
tarray_freelist = t; // tarray_freelist指向当前项
函数get_free_taskslot:
tslot = tarray_freelist; // *tslot是第一个空闲项
tarray_freelist = (struct task_struct **) *tslot; // *tslot的内容是下一个空闲项
return tslot;

各种各样的进程指针:在进程描述符中有很多task_struct的指针,用于把它链进不同的链表或树中。最简单的是next_task和prev_task,它们把当前系统中的所有进程链成一条双向链表;其次是next_run和prev_run,它们把当前可运行的进程(state为TASK_RUNNING,这和current不同,并不表示它正在运行,只表示它可以被CPU调度运行而已)链成一条双向链表,不过我的源码里并没有作者所说的runqueue指针头,好象是init_task取代了runqueue的位置;pidhash_next和pidhash_pprev是用来链进以进程号索引的hash表的,因为大多调用都使用进程号标识进程,所以需要建立一个hash表来加快以进程号来查找进程的速度;最后是p_opptr,p_pptr,p_cptr,p_ysptr,p_osptr,这些是用来标识进程的父子,兄弟等树状关系的,作者书中的图已经很清楚了,不再需要我多说了。

等待队列:一般来说,当某个任务不能马上完成时,kernel不会陪着进程在那死等,它只是简单把进程挂进某个队列,然后继续运行,等这个任务完成,kernel会从队列中取出等待的进程,并把它链进可运行队列中。等待队列的结构体如下:
struct wait_queue {
struct task_struct * task;
struct wait_queue * next;
};
很简单的结构,一个进程指针,一个next指针,应用时它将会是一个环形队列,add_wait_queue加入一项,remove_wait_queue移去新旧的一项,都不是很难理解。麻烦的是它的init_waitqueue,内容为
#define WAIT_QUEUE_HEAD(x) ((struct wait_queue *)((x)-1))
static inline void init_waitqueue(struct wait_queue **q)
{
*q = WAIT_QUEUE_HEAD(q);
}
结合作者的解释,它实际上是把当前队列指针加上前面的四个字节假设为一项了,然后"这一项"的next指针指向它自己。这个方法代码倒很简单,但是我却不是很喜欢,可读性实在有点。。。如果是我,宁愿加一空项做表头。
sleep和wakeup:刚才所说的kernel把进程挂进队一般是通过sleep_on来做的,而取出队列是通过wake_up来做的。现在来看看它们是怎么运行的吧。比如你要读取软盘内容,指令发出去了,但要等很久才有回应,这时会调用sleep_on把你的进程标识为TASK_UNINTERRUPTIBLE或TASK_INTERRUPTIBLE状态,然后把进程挂在某一个队列上,然后调用schedule,这样就会调度其它状态为TASK_RUNNING的进程继续运行。当指令完成时,比如软盘的内容已经读到内存中了,这时可能会产生一个中断,这个中断会从等待队列中把你的进程取出来,标识为TASK_RUNNING,然后放入可运行队列,又过了若干时间,你的进程真的开始运行了,这时会执行sleep_on中schedule后的语句,即把进程从进程从等待队列中移出去,然后就可以执行下面的操作了,这时你要读的内容已经读出来了。

进程限制:谁都不希望某个用户的进程会占用所有的内存,所有的CPU,所有的任何资源,这样就要对进程有所限制,kernel用了这样一个结构:
struct rlimit {
long rlim_cur;
long rlim_max;
};
其中rlim_cur为进程现在用到的资源数,rlim_max为进程可用的最大资源数。
结构task_struct中有一项为struct rlimit rlim[RLIM_NLIMITS],其中RLIM_NLIMITS为10,即你对进程可以有10种限制,这10种限制作者有讲解的,我也不说了。

question:
1、我的印象中,在get_current中,esp应该是栈顶指针,而且随时会变的,用它去减去8K,能得到正确的地址吗?


标题   Re: 新兵笔记--ULK(C3) Process Descriptor [re: Big John]
作者 lucian_yao (addict)
时间 05/20/01 09:16 AM


1应该是栈顶向下8K对齐得到task_struct指针。
2在2.4中最大进程数没有了,由于基本不用TSS结构,所以不受GDT大小限制。

标题   Re: 新兵笔记--ULK(C3) Process Descriptor [re: lucian_yao]
作者 Big John (stranger )
时间 05/22/01 04:24 PM

1、是我的错,把
__asm__("andl %%esp,%0; ":"=r" (current) : "0" (~8191UL));
中的andl看成addl了,所以百思而不得,呵。其实很简单,系统分配进程描述符时,都是偶数页对齐的,把sp后面的13位清0,当然也就是描述符的位置了。:)
2、2.4对进程没有限制,那当然就不会再用task_struct的数组了,那它是怎么组织的呢?不会是链表吧。

标题   Re: 新兵笔记--ULK(C3) Process Descriptor [re: Big John]
作者 iobject (stranger)
时间 05/29/01 04:08 PM

static inline struct task_struct * get_current(void)
{
struct task_struct *current;
__asm__("andl %%esp,%0; ":"=r" (current) : "" (~8191UL));
return current;
}
对于,%0,从语法上似乎是指current,但是这样的话这句话就说不通了,难道我对%0的理解有错吗
哪位指点一下,谢谢!


标题   Re: 新兵笔记--ULK(C3) Process Descriptor [re: iobject]
作者 Big John (stranger )
时间 05/29/01 05:33 PM

 

asm ("combine %2,%0" : "=r" (foo) : "0" (foo), "g" (bar));

The constraint `"0"' for operand 1 says that it must occupy the same
location as operand 0. A digit in constraint is allowed only in an
input operand and it must refer to an output operand.

这段来自gcc的info,大概意思是说,%1和%0将占用同一个寄存器,所以引用%0也就是引用%1了。
这样看来
__asm__("andl %%esp,%0; ":"=r" (current) : "0" (~8191UL));
展开应该是这样的:
movl $(~8191UL),%eax
#APP
andl %esp, %eax
#NO_APP
movl %eax,current
我也是现学现用,不知道对不对。

[目录]


init进程从内核态切换到用户态


标题   init进程如何从内核态切换到用户态。
作者 chstar (stranger )
时间 03/08/01 01:24 PM

 

init进程从内核态切换到用户态。

//谢谢lucian_yao 邀请,在此灌水一篇

大家都知道如何产生一个新的进程。
通过sys_fork,之后再调用sys_execve
系统初启后(核心态)的第一个用户态进程是init。
这要涉及到内层(特权级高)向外层(特权级低)转移的问题。
通常情况下,内核是不会调用用户层的代码,要想实现这逆向的转移,一般做法是在用户进程的核心栈(tss->esp0)压入用户态的SS,ESP,EFLAGS,CS,EIP,伪装成用户进程是通过陷阱门进入核心态,之后通过iret返回用户态。
那么linux 2.2.14中的用户态进程init是如何实现的?

首先在kernel_thread(init...)函数中,
利用系统调用sys_clone fork出一个内核级进程(此时要给该进程分配核心栈<-esp0),之后call init函数,init函数还会再起几个kernel_thread,然后会加载/sbin/init(通过execve调用)
在sys_execve中,要完成内核态到用户态的转移。
大体流程是sys_execve-->do_execve-->load_elf_binary()
-->do_load_elf_binary()-->do_mmap()
start_thread(reg,newip,newsp) (processor.h)
请大家关注do_mmap()及start_thread()很重要哦
do_mmap完成从文件虚拟空间到内存虚拟空间的映射。
而start_thread就是要在进程核心栈中的相应位置填入进程用户态的xss,esp and xcs,eip.
最后进程从ret_from_sys_call返回,iret指令从核心栈pop出xcs, eip完成特权及指令的转移, pop出 xss,esp,完成堆栈的切换。

以上我也是刚看代码悟出的,如有不对之处,还望高手指出。

[目录]


SET_LINKS


宏:SET_LINKS(p)将进程p插入到进程系中

struct task_struct {
  struct task_struct *next_task, *prev_task;
...
  struct task_struct *p_opptr, *p_pptr, *p_cptr, *p_ysptr,*p_osptr;        ...};
next_task和prev_task 为描述进程先后关系的环形队列
p_opptr        指向原始的父进程
p_pptr        指向当前的父进程
p_cptr        指向最年轻的子进程
p_ysptr        指向弟进程
p_osptr        指向兄进程

include/linux/sched.h

#define SET_LINKS(p) do {
/
        (p)->next_task = &init_task;
/ 进程p的下一个进程是初始化进程
        (p)->prev_task = init_task.prev_task;
/ 进程p的前一个进程是初始化进程的前一个进程
        init_task.prev_task->next_task = (p);
/ 进程p的进一进程指向p
        init_task.prev_task = (p);
/初始化进程的前一进程指向p; 即将进程p加入到环形进程队列的尾部
        (p)->p_ysptr = NULL; / 进程p现在是最年轻的进程
        if (((p)->p_osptr = (p)->p_pptr->p_cptr) != NULL)
                (p)->p_osptr->p_ysptr = p;
/ 原来的最年轻进程变成p的兄进程
        (p)->p_pptr->p_cptr = p; / 父进程指向新的子进程p
} while (0)

[目录]


REMOVE_LINKS


宏:REMOVE_LINKS(p)将进程p从进程系中删除

struct task_struct {
  struct task_struct *next_task, *prev_task;
...
  struct task_struct *p_opptr, *p_pptr, *p_cptr, *p_ysptr,*p_osptr;        ...};
next_task和prev_task 为描述进程先后关系的环形队列
p_opptr        指向原始的父进程
p_pptr        指向当前的父进程
p_cptr        指向最年轻的子进程
p_ysptr        指向弟进程
p_osptr        指向兄进程


include/linux/sched.h
#define REMOVE_LINKS(p) do { /
        (p)->next_task->prev_task = (p)->prev_task;
/ 让进程p的下一进程指向p的前一进程
        (p)->prev_task->next_task = (p)->next_task;
/ 让进程p的前一进程指向p的下一进程
        if ((p)->p_osptr)
/ 如果进程p有兄进程,则让兄进程指向p的弟进程
        (p)->p_osptr->p_ysptr = (p)->p_ysptr;
        if ((p)->p_ysptr)
/ 如果进程p有弟进程,则让弟进程指向p的兄进程
                (p)->p_ysptr->p_osptr = (p)->p_osptr; /
        else / 如果p没有弟进程,说明p最年轻,则让父进程指向p的兄进程                (p)->p_pptr->p_cptr = (p)->p_osptr;
/
} while (0)

[目录]


get_wchan()


get_wchan()给出了某个睡眠进程schedule()的调用点.

; arch/i386/kernel/process.c
unsigned long get_wchan(struct task_struct *p)
{
        unsigned long ebp, esp, eip;
        unsigned long stack_page;
        int count = 0;
        if (!p || p == current || p->state == TASK_RUNNING)
                return 0;
        stack_page = (unsigned long)p;
        esp = p->thread.esp; 取switch_to之前内核堆栈指针
        if (!stack_page || esp  8188+stack_page)
                return 0;
        /* include/asm-i386/system.h:switch_to() pushes ebp last. */
        ebp = *(unsigned long *) esp; 取保存在切换现场的schedule的ebp
        do {
                if (ebp  8184+stack_page)
                        return 0;
                eip = *(unsigned long *) (ebp+4);
                ; (ebp+0)为上一级函数的ebp,(ebp+4)为schedule()的返回地址
                ; kernel/sched.c编绎加了-fno-omit-frame-pointer编绎标志,就是在这儿起作用.
                ; first_sched和last_sched是schedule()函数所在的地址范围
                if (eip = last_sched)
                        return eip;
                ebp = *(unsigned long *) ebp;
        } while (count++         return 0;
}

现在的问题是,在什么情况下需要用count循环几次? 现有的代码好象不需要循环.

 

 

[目录]


sigframe的结构


struct pt_regs {
        long ebx;
        long ecx;
        long edx;
        long esi;
        long edi;
        long ebp;
        long eax;
        int  xds;
        int  xes;
        long orig_eax;
        long eip;
        int  xcs;
        long eflags;
        long esp;
        int  xss;
};
typedef void (*__sighandler_t)(int);
struct sigaction {
        __sighandler_t sa_handler; 用户的信号处理函数指针
        unsigned long sa_flags;
        void (*sa_restorer)(void); 用户自定义的信号恢复函数指针
        sigset_t sa_mask;
};

struct k_sigaction {
        struct sigaction sa;
};
struct exec_domain {
        const char *name;
        lcall7_func handler;
        unsigned char pers_low, pers_high;
        unsigned long * signal_map;
        unsigned long * signal_invmap;
        struct module * module;
        struct exec_domain *next;
};
struct sigcontext {
        unsigned short gs, __gsh;
        unsigned short fs, __fsh;
        unsigned short es, __esh;
        unsigned short ds, __dsh;
        unsigned long edi;
        unsigned long esi;
        unsigned long ebp;
        unsigned long esp;
        unsigned long ebx;
        unsigned long edx;
        unsigned long ecx;
        unsigned long eax;
        unsigned long trapno;
        unsigned long err;
        unsigned long eip;
        unsigned short cs, __csh;
        unsigned long eflags;
        unsigned long esp_at_signal;
        unsigned short ss, __ssh;
        struct _fpstate * fpstate;
        unsigned long oldmask;
        unsigned long cr2;
};
struct _fpstate {

        unsigned long cw;
        unsigned long        sw;
        unsigned long        tag;
        unsigned long        ipoff;
        unsigned long        cssel;
        unsigned long        dataoff;
        unsigned long        datasel;
        struct _fpreg        _st[8];
        unsigned short        status;
        unsigned short        magic;


        unsigned long        _fxsr_env[6];
        unsigned long        mxcsr;
        unsigned long        reserved;
        struct _fpxreg        _fxsr_st[8];
        struct _xmmreg        _xmm[8];
        unsigned long        padding[56];
};
struct sigframe
{
        char *pretcode; 指向retcode
        int sig; sa_handler的sig参数
        struct sigcontext sc; CPU状态
        struct _fpstate fpstate;如果进程使用过FPU的话保存FPU状态
        unsigned long extramask[(64  / 32 ) -1];
        char retcode[8]; "popl % eax; movl $__NR_sigreturn,% eax; int $0x80"
};
static void setup_frame(int sig, struct k_sigaction *ka,
                        sigset_t *set, struct pt_regs * regs)
{
        struct sigframe *frame;
        int err = 0;

        ;取信号帧的起始地址
        frame = get_sigframe(ka, regs, sizeof(*frame));
        ;检测frame指针是否越界
        if (!access_ok(VERIFY_WRITE, frame, sizeof(*frame)))
                goto give_sigsegv;
        ;每个进程可以对应于不同的运行域,如果需要的话就进行相应的信号转换
        err |= __put_user((current->exec_domain
                            current->exec_domain->signal_invmap
                            sig                            ? current->exec_domain->signal_invmap[sig]
                           : sig),

        if (err)
                goto give_sigsegv;
        ;继续在用户堆栈上填充sigframe结构
        err |= setup_sigcontext(  regs, set->sig[0]);
        if (err)
                goto give_sigsegv;
        ;如果系统信号集的描述字多于1个的话,在extramask在保存多出来的部分,
        ;set->sig[0]已在sigframe->sc.oldmask保存
        if (_NSIG_WORDS > 1) {
                err |= __copy_to_user(frame->extramask,
                                      sizeof(frame->extramask));
        }
        if (err)
                goto give_sigsegv;

        /* Set up to return from userspace.  If provided, use a stub
           already in userspace.  */
        if (ka->sa.sa_flags  SA_RESTORER) {
                ; 如果用户提供了信号的恢复代码
                err |= __put_user(ka->sa.sa_restorer,
        } else {

                err |= __put_user(frame->retcode,
                /* This is popl % eax ; movl $,% eax ; int $0x80 */
                err |= __put_user(0xb858, (short *)(frame->retcode+0));
                err |= __put_user(__NR_sigreturn, (int *)(frame->retcode+2));
                err |= __put_user(0x80cd, (short *)(frame->retcode+6));
                ;popl % eax 退掉栈顶上frame->sig来与sys_sigreturn相对应
        }

        if (err)
                goto give_sigsegv;

        /* Set up registers for signal handler */
        regs->esp = (unsigned long) frame;
        regs->eip = (unsigned long) ka->sa.sa_handler;
        ; 一返回用户进程,信号处理代码就开始执行.
        set_fs(USER_DS);
        regs->xds = __USER_DS;
        regs->xes = __USER_DS;
        regs->xss = __USER_DS;
        regs->xcs = __USER_CS;
        regs->eflags  ~TF_MASK;

#if DEBUG_SIG
        printk("SIG deliver (%s:%d): sp=%p pc=%p ra=%p/n",
                current->comm, current->pid, frame, regs->eip, frame->pretcode);
#endif
        return;

give_sigsegv:
        ;如果建立sigframe出错,忽略用户的SIGSEGV过程,发出SIGSEGV信号强制进程退出
        if (sig == SIGSEGV)
                ka->sa.sa_handler = SIG_DFL;
        force_sig(SIGSEGV, current);
}
static inline int on_sig_stack(unsigned long sp)
{
        return (sp - current->sas_ss_sp sas_ss_size);
}
static inline void *
get_sigframe(struct k_sigaction *ka, struct pt_regs * regs, size_t frame_size)
{
        unsigned long esp;

        /* Default to using normal stack */
        esp = regs->esp; 用户进程中的堆栈指针

        /* This is the X/Open sanctioned signal stack switching.  */
        if (ka->sa.sa_flags  SA_ONSTACK) {
                if (! on_sig_stack(esp))
                ; 如果esp sas_ss_sp + current->sas_ss_size)
                        esp = current->sas_ss_sp + current->sas_ss_size;
        }

        /* This is the legacy signal stack switching. */
        else if ((regs->xss  0xffff) != __USER_DS
                !(ka->sa.sa_flags  SA_RESTORER)
                ka->sa.sa_restorer) {
                ; 如果ss与ds不等,没有SA_RESTORER标志,但ka->sa.sa_restorer不为0,
                ; 表示sa_restorer是一个用户定义的堆栈指针
                esp = (unsigned long) ka->sa.sa_restorer;
        }
        ; sigframe在8字节边界上对齐
        return (void *)((esp - frame_size)  -8ul);
}

static int
setup_sigcontext(struct sigcontext *sc, struct _fpstate *fpstate,
                struct pt_regs *regs, unsigned long mask)
{
        int tmp, err = 0;

        tmp = 0;
        __asm__("movl %%gs,%0" : "=r"(tmp): "0"(tmp));
        err |= __put_user(tmp, (unsigned int *)
        __asm__("movl %%fs,%0" : "=r"(tmp): "0"(tmp));
        err |= __put_user(tmp, (unsigned int *)

        err |= __put_user(regs->xes, (unsigned int *)
        err |= __put_user(regs->xds, (unsigned int *)
        err |= __put_user(regs->edi,
        err |= __put_user(regs->esi,
        err |= __put_user(regs->ebp,
        err |= __put_user(regs->esp,
        err |= __put_user(regs->ebx,
        err |= __put_user(regs->edx,
        err |= __put_user(regs->ecx,
        err |= __put_user(regs->eax,
        err |= __put_user(current->thread.trap_no,
        err |= __put_user(current->thread.error_code,
        err |= __put_user(regs->eip,
        err |= __put_user(regs->xcs, (unsigned int *)
        err |= __put_user(regs->eflags,
        err |= __put_user(regs->esp,
        err |= __put_user(regs->xss, (unsigned int *)
        ; 每一步都很谨慎
        tmp = save_i387(fpstate);
        if (tmp           err = 1;
        else
          err |= __put_user(tmp ? fpstate : NULL,
        ; sc->fpstate为0表示该进程没有使用过FPU
        /* non-iBCS2 extensions.. */
        err |= __put_user(mask,
        err |= __put_user(current->thread.cr2,

        return err;
}


sigframe就是调用用户信号处理函数时进程堆栈指针和原来被中断进程堆栈指针之间的数据块.

 

 

[目录]


rt_sigframe结构


struct rt_sigframe
{
        char *pretcode;
        int sig;
        struct siginfo *pinfo; 指向info
        void *puc; 指向uc
        struct siginfo info;
        struct ucontext uc;
        struct _fpstate fpstate;
        char retcode[8];
};
typedef struct sigaltstack {
        void *ss_sp;
        int ss_flags;
        size_t ss_size;
} stack_t;
struct ucontext {
        unsigned long          uc_flags;
        struct ucontext  *uc_link;
        stack_t  uc_stack;
        struct sigcontext uc_mcontext; 相当于sigframe中的sc
        sigset_t  uc_sigmask;
};
typedef struct siginfo {
        int si_signo;
        int si_errno;
        int si_code;

        union {
                int _pad[((128 /sizeof(int)) - 3) ];


                struct {
                        pid_t _pid;
                        uid_t _uid;
                } _kill;


                struct {
                        unsigned int _timer1;
                        unsigned int _timer2;
                } _timer;


                struct {
                        pid_t _pid;
                        uid_t _uid;
                        sigval_t _sigval;
                } _rt;


                struct {
                        pid_t _pid;
                        uid_t _uid;
                        int _status;
                        clock_t _utime;
                        clock_t _stime;
                } _sigchld;


                struct {
                        void *_addr;
                } _sigfault;


                struct {
                        int _band;
                        int _fd;
                } _sigpoll;
        } _sifields;
} siginfo_t;

; setup_rt_frame与setup_frame相比多了一个siginfo_t参数
static void setup_rt_frame(int sig, struct k_sigaction *ka, siginfo_t *info,
                           sigset_t *set, struct pt_regs * regs)
{
        struct rt_sigframe *frame;
        int err = 0;

        frame = get_sigframe(ka, regs, sizeof(*frame));

        if (!access_ok(VERIFY_WRITE, frame, sizeof(*frame)))
                goto give_sigsegv;

        err |= __put_user((current->exec_domain
                                current->exec_domain->signal_invmap
                                sig                                ? current->exec_domain->signal_invmap[sig]
                           : sig),

        ; 初始化frame->info和frame->uc两个指针
        err |= __put_user(
        err |= __put_user(
        ; 将系统siginfo结构拷贝给用户
        err |= copy_siginfo_to_user( info);
        if (err)
                goto give_sigsegv;

        /* Create the ucontext.  */
        err |= __put_user(0,
        err |= __put_user(0,
        err |= __put_user(current->sas_ss_sp,
        err |= __put_user(sas_ss_flags(regs->esp),

        err |= __put_user(current->sas_ss_size,
        err |= setup_sigcontext(
                                regs, set->sig[0]);
        err |= __copy_to_user( set, sizeof(*set));
        if (err)
                goto give_sigsegv;

        /* Set up to return from userspace.  If provided, use a stub
           already in userspace.  */
        if (ka->sa.sa_flags  SA_RESTORER) {
                err |= __put_user(ka->sa.sa_restorer,
        } else {
                err |= __put_user(frame->retcode,
                /* This is movl $,% eax ; int $0x80 */
                err |= __put_user(0xb8, (char *)(frame->retcode+0));
                err |= __put_user(__NR_rt_sigreturn, (int *)(frame->retcode+1));
                err |= __put_user(0x80cd, (short *)(frame->retcode+5));
                ; 没有popl % eax
        }

        if (err)
                goto give_sigsegv;

        /* Set up registers for signal handler */
        regs->esp = (unsigned long) frame;
        regs->eip = (unsigned long) ka->sa.sa_handler;

        set_fs(USER_DS);
        regs->xds = __USER_DS;
        regs->xes = __USER_DS;
        regs->xss = __USER_DS;
        regs->xcs = __USER_CS;
        regs->eflags  ~TF_MASK;

#if DEBUG_SIG
        printk("SIG deliver (%s:%d): sp=%p pc=%p ra=%p/n",
                current->comm, current->pid, frame, regs->eip, frame->pretcode);
#endif

        return;

give_sigsegv:
        if (sig == SIGSEGV)
                ka->sa.sa_handler = SIG_DFL;
        force_sig(SIGSEGV, current);
}
int copy_siginfo_to_user(siginfo_t *to, siginfo_t *from)
{
        if (!access_ok (VERIFY_WRITE, to, sizeof(siginfo_t)))
                return -EFAULT;
        if (from->si_code                 ; 将整个siginfo_t结构拷贝到用户堆栈上的rt_sigframe中
                return __copy_to_user(to, from, sizeof(siginfo_t));
        else {
                int err;

                /* If you change siginfo_t structure, please be sure
                   this code is fixed accordingly.
                   It should never copy any pad contained in the structure
                   to avoid security leaks, but must copy the generic
                   3 ints plus the relevant union member.  */
                err = __put_user(from->si_signo,
                err |= __put_user(from->si_errno,
                err |= __put_user((short)from->si_code,
                /* First 32bits of unions are always present.  */
                err |= __put_user(from->si_pid,
                switch (from->si_code >> 16) {
                case __SI_FAULT >> 16:
                        break;
                case __SI_CHLD >> 16:
                        err |= __put_user(from->si_utime,
                        err |= __put_user(from->si_stime,
                        err |= __put_user(from->si_status,
                default:
                        err |= __put_user(from->si_uid,
                        break;
                /* case __SI_RT: This is not generated by the kernel as of now.  */
                }
                return err;
        }
}


由此可以看出rt_sigframe是sigframe的扩展和优化,和sigframe相比,rt_sigframe多了siginfo结构,sigframe的sigcontext扩展为ucontext,用户的信号处理函数多了两个参数pinfo和uc,这样内核可以将更多的信息传递给用户.除此以外,在运行机制上它们没有什么本质的区别.

 

 

[目录]


信号队列的结构


每个进程具有一个sigpending结构所描述的信号队列,它有3个成员,head指向第一个sigqueue成员,tail指向最末的sigqueue成员的next指针,signal描述了此队列中的信号集.

static int send_signal(int sig, struct siginfo *info, struct sigpending *signals);
将信号sig和对应的消息结构info添加到信号队列signal中.
static int collect_signal(int sig, struct sigpending *list, siginfo_t *info);
返回信号sig在队列list中的信息info.


struct task_struct {
        ...
        struct sigpending pending;
        ...
};
struct sigpending {
        struct sigqueue *head, **tail;
        sigset_t signal;
};
struct sigqueue {
        struct sigqueue *next;
        siginfo_t info;
};
// kernel/signal.c
static int send_signal(int sig, struct siginfo *info, struct sigpending *signals)
{
        struct sigqueue * q = NULL;

        /* Real-time signals must be queued if sent by sigqueue, or
           some other real-time mechanism.  It is implementation
           defined whether kill() does so.  We attempt to do so, on
           the principle of least surprise, but since kill is not
           allowed to fail with EAGAIN when low on memory we just
           make sure at least one signal gets delivered and don't
           pass on the info struct.  */

        if (atomic_read(q = kmem_cache_alloc(sigqueue_cachep, GFP_ATOMIC);
        }
        // nr_queued_signals和max_queued_signals用来限制全局sigqueue成员的数目
        if (q) {
                atomic_inc(
                q->next = NULL;
                *signals->tail = q;
                signals->tail =  tail总是指向最末的信号成员的next指针
                switch ((unsigned long) info) {
                        case 0: // info参数如果为0,表示信号来源于当前用户进程
                                q->info.si_signo = sig;
                                q->info.si_errno = 0;
                                q->info.si_code = SI_USER;
                                q->info.si_pid = current->pid;
                                q->info.si_uid = current->uid;
                                break;
                        case 1: // info参数如果为1,表示信号来源于内核本身
                                q->info.si_signo = sig;
                                q->info.si_errno = 0;
                                q->info.si_code = SI_KERNEL;
                                q->info.si_pid = 0;
                                q->info.si_uid = 0;
                                break;
                        default: // 否则从info指针中拷贝信号
                                copy_siginfo( info);
                                break;
                }
        } else if (sig >= SIGRTMIN  info  (unsigned long)info != 1
                    info->si_code != SI_USER) {
                ; 如果该信号是内核发出的实时信号,就返回错误码
                /*
                * Queue overflow, abort.  We may abort if the signal was rt
                * and sent by user using something other than kill().
                */
                return -EAGAIN;
        }

        sigaddset( sig); 将sig号标记在队列的信号集上
        return 0;
}
static int collect_signal(int sig, struct sigpending *list, siginfo_t *info)
{
        if (sigismember( sig)) {
                /* Collect the siginfo appropriate to this signal.  */
                struct sigqueue *q, **pp;
                pp =  pp指向第一个信号成员的next指针
                while ((q = *pp) != NULL) {
                        if (q->info.si_signo == sig)
                                goto found_it;
                        pp =
                }

                /* Ok, it wasn't in the queue.  We must have
                   been out of queue space.  So zero out the
                   info.  */
                sigdelset( sig);
                info->si_signo = sig;
                info->si_errno = 0;
                info->si_code = 0;
                info->si_pid = 0;
                info->si_uid = 0;
                return 1;

found_it:
                // 将找到信号成员从信号队列中删除
                if ((*pp = q->next) == NULL)
                        list->tail = pp;

                /* Copy the sigqueue information and free the queue entry */
                copy_siginfo(info,
                kmem_cache_free(sigqueue_cachep,q);
                atomic_dec(

                /* Non-RT signals can exist multiple times.. */
                if (sig >= SIGRTMIN) {
                        while ((q = *pp) != NULL) {
                                if (q->info.si_signo == sig)
                                        goto found_another;
                                pp =
                        }
                }

                sigdelset( sig);
found_another:
                return 1;
        }
        return 0;
}

[目录]


系统调用

 

[目录]


系统调用的实现


   看了前面一篇提到系统调用源码的文章,也与作者有着同样
的迷惑,查看了一下相关的源代码,又翻了一下书,有了一点
点心得。
    linux里面的每个系统调用是靠一些宏,,一张系统调用表,
一个系统调用入口来完成的。
函数。
    1.宏  就是前面作者提到的_syscallN(type,name,x...),
      N是系统调用所需的参数数目,type是返回类型,name即面向
用户的系统调用函数名,x...是调用参数,个数即为N。
     例如:
#define _syscall3(type,name,type1,arg1,type2,arg2,type3,arg3) /
type name(type1 arg1,type2 arg2,type3 arg3) /
{ /
long __res; /
__asm__ volatile ("int $0x80" /
        : "=a" (__res) /
        : "0" (__NR_##name),"b" ((long)(arg1)),"c" ((long)(arg2)), /
                  "d" ((long)(arg3))); /
if (__res>=0) /
        return (type) __res; /
errno=-__res; /
return -1; /
}
(这是2.0.33版本)
      这些宏定义于include/asm/Unistd.h,这就是为什么你在
程序中要包含这个头文件的原因。该文件中还以__NR_name的形式
定义了164个常数,这些常数就是系统调用函数name的函数指针在
系统调用表中的偏移量。
    2.系统调用表
      定义于entry.s的最后。
      这个表按系统调用号(即前面提到的__NR_name)排列了所
有系统调用函数的指针,以供系统调用入口函数查找。从这张表看
得出,linux给它所支持的系统调用函数取名叫sys_name。
    3.系统调用入口函数
      定义于entry.s:
ENTRY(system_call)
        pushl %eax                      # save orig_eax
        SAVE_ALL
#ifdef __SMP__
        ENTER_KERNEL
#endif
        movl $-ENOSYS,EAX(%esp)
        cmpl $(NR_syscalls),%eax
        jae ret_from_sys_call
        movl SYMBOL_NAME(sys_call_table)(,%eax,4),%eax
        testl %eax,%eax
        je ret_from_sys_call
#ifdef __SMP__
        GET_PROCESSOR_OFFSET(%edx)
        movl SYMBOL_NAME(current_set)(,%edx),%ebx
#else
        movl SYMBOL_NAME(current_set),%ebx
#endif
        andl $~CF_MASK,EFLAGS(%esp)
        movl %db6,%edx
        movl %edx,dbgreg6(%ebx)
        testb $0x20,flags(%ebx)
        jne 1f
        call *%eax
        movl %eax,EAX(%esp)
        jmp ret_from_sys_call
   这段代码现保存所有的寄存器值,然后检查调用号(__NR_name)
是否合法(在系统调用表中查找),找到正确的函数指针后,就调用
该函数(即你真正希望内核帮你运行的函数)。运行返回后,将调用
ret_from_sys_call,这里就是著名的进程调度时机之一。
    当在程序代码中用到系统调用时,编译器会将上面提到的
宏展开,展开后的代码实际上是将系统调用号放入ax后
移用int 0x80使处理器转向系统调用入口,然后查找系统调用表,进
而由内核调用真正的功能函数。
    前面那篇文章中的问题我是这样理解的:
   自己添加过系统调用的人可能知道,要在程序中使用自己的
系统调用,必须显示地应用宏_syscallN。
    而对于linux预定义的系统调用,编译器在预处理时自动加入宏
_syscall3(int,ioctl,arg1,arg2,arg3)并将其展开。所以,并不是
ioctl本身是宏替换符,而是编译器自动用宏声明了ioctl这个函数。
    实际上我自己没有给linux添加过系统调用,也没有很仔细的看
源代码,希望这方面的高手能多多指教。

[目录]


添加系统调用


如何在Linux中添加新的系统调用

  系统调用是应用程序和操作系统内核之间的功能接口。其主要目的是使得用户可以
使用操作系统提供的有关设备管理、输入/输入系统、文件系统和进程控制、通信以及存
储管理等方面的功能,而不必了解系统程序的内部结构和有关硬件细节,从而起到减轻
用户负担和保护系统以及提高资源利用率的作用。
  Linux操作系统作为自由软件的代表,它优良的性能使得它的应用日益广泛,不仅得
到专业人士的肯定,而且商业化的应用也是如火如荼。在Linux中,大部分的系统调用包
含在Linux的libc库中,通过标准的C函数调用方法可以调用这些系统调用。那么,对Li
nux的发烧友来说,如何在Linux中增加新的系统调用呢?
1 Linux系统调用机制
  在Linux系统中,系统调用是作为一种异常类型实现的。它将执行相应的机器代码指
令来产生异常信号。产生中断或异常的重要效果是系统自动将用户态切换为核心态来对
它进行处理。这就是说,执行系统调用异常指令时,自动地将系统切换为核心态,并安
排异常处理程序的执行。
  Linux用来实现系统调用异常的实际指令是:
  Int $0x80
  这一指令使用中断/异常向量号128(即16进制的80)将控制权转移给内核。为达到
在使用系统调用时不必用机器指令编程,在标准的C语言库中为每一系统调用提供了一段
短的子程序,完成机器代码的编程工作。事实上,机器代码段非常简短。它所要做的工
作只是将送给系统调用的参数加载到CPU寄存器中,接着执行int $0x80指令。然后运行
系统调用,系统调用的返回值将送入CPU的一个寄存器中,标准的库子程序取得这一返回
值,并将它送回用户程序。
  为使系统调用的执行成为一项简单的任务,Linux提供了一组预处理宏指令。它们可
以用在程序中。这些宏指令取一定的参数,然后扩展为调用指定的系统调用的函数。
  这些宏指令具有类似下面的名称格式:
  _syscallN(parameters)
  其中N是系统调用所需的参数数目,而parameters则用一组参数代替。这些参数使宏
指令完成适合于特定的系统调用的扩展。例如,为了建立调用setuid()系统调用的函
数,应该使用:
  _syscall1( int, setuid, uid_t, uid )
  syscallN( )宏指令的第1个参数int说明产生的函数的返回值的类型是整型,第2
个参数setuid说明产生的函数的名称。后面是系统调用所需要的每个参数。这一宏指令
后面还有两个参数uid_t和uid分别用来指定参数的类型和名称。
  另外,用作系统调用的参数的数据类型有一个限制,它们的容量不能超过四个字节
。这是因为执行int $0x80指令进行系统调用时,所有的参数值都存在32位的CPU寄存器
中。使用CPU寄存器传递参数带来的另一个限制是可以传送给系统调用的参数的数目。这
个限制是最多可以传递5个参数。所以Linux一共定义了6个不同的_syscallN()宏指令
,从_syscall0()、_syscall1()直到_syscall5()。
  一旦_syscallN()宏指令用特定系统调用的相应参数进行了扩展,得到的结果是一
个与系统调用同名的函数,它可以在用户程序中执行这一系统调用。

2 添加新的系统调用
  如果用户在Linux中添加新的系统调用,应该遵循几个步骤才能添加成功,下面几个
步骤详细说明了添加系统调用的相关内容。
(1) 添加源代码
  第一个任务是编写加到内核中的源程序,即将要加到一个内核文件中去的一个函数
,该函数的名称应该是新的系统调用名称前面加上sys_标志。假设新加的系统调用为my
call(int number),在/usr/src/linux/kernel/sys.c文件中添加源代码,如下所示:
  asmlinkage int sys_mycall(int number)
  {
  return number;
  }
  作为一个最简单的例子,我们新加的系统调用仅仅返回一个整型值。
(2) 连接新的系统调用
  添加新的系统调用后,下一个任务是使Linux内核的其余部分知道该程序的存在。为
了从已有的内核程序中增加到新的函数的连接,需要编辑两个文件。
  在我们所用的Linux内核版本(RedHat 6.0,内核为2.2.5-15)中,第一个要修改的
文件是:
  /usr/src/linux/include/asm-i386/unistd.h
  该文件中包含了系统调用清单,用来给每个系统调用分配一个唯一的号码。文件中
每一行的格式如下:
  #define __NR_name NNN
  其中,name用系统调用名称代替,而NNN则是该系统调用对应的号码。应该将新的系
统调用名称加到清单的最后,并给它分配号码序列中下一个可用的系统调用号。我们的
系统调用如下:
  #define __NR_mycall 191
  系统调用号为191,之所以系统调用号是191,是因为Linux-2.2内核自身的系统调用
号码已经用到190。
  第二个要修改的文件是:
  /usr/src/linux/arch/i386/kernel/entry.S
  该文件中有类似如下的清单:
  .long SYMBOL_NAME()
  该清单用来对sys_call_table[]数组进行初始化。该数组包含指向内核中每个系统
调用的指针。这样就在数组中增加了新的内核函数的指针。我们在清单最后添加一行:

  .long SYMBOL_NAME(sys_mycall)

(3) 重建新的Linux内核
  为使新的系统调用生效,需要重建Linux的内核。这需要以超级用户身份登录。
  #pwd
  /usr/src/linux
  #
  超级用户在当前工作目录(/usr/src/linux)下,才可以重建内核。
  #make config
  #make dep
  #make clearn
  #make bzImage
  编译完毕后,系统生成一可用于安装的、压缩的内核映象文件:
  /usr/src/linux/arch/i386/boot/bzImage
(4) 用新的内核启动系统
  要使用新的系统调用,需要用重建的新内核重新引导系统。为此,需要修改/etc/l
ilo.conf文件,在我们的系统中,该文件内容如下:
  boot=/dev/hda
  map=/boot/map
  install=/boot/boot.b
  prompt
  timeout=50
  image=/boot/vmlinuz-2.2.5-15
  label=linux
  root=/dev/hdb1
  read-only
  other=/dev/hda1
  label=dos
  table=/dev/had
  首先编辑该文件,添加新的引导内核:
  image=/boot/bzImage-new
  label=linux-new
  root=/dev/hdb1
  read-only
  添加完毕,该文件内容如下所示:
  boot=/dev/hda
  map=/boot/map
  install=/boot/boot.b
  prompt
  timeout=50
  image=/boot/bzImage-new
  label=linux-new
  root=/dev/hdb1
  read-only
  image=/boot/vmlinuz-2.2.5-15
  label=linux
  root=/dev/hdb1
  read-only
  other=/dev/hda1
  label=dos
  table=/dev/hda
  这样,新的内核映象bzImage-new成为缺省的引导内核。
  为了使用新的lilo.conf配置文件,还应执行下面的命令:
  #cp /usr/src/linux/arch/i386/boot/zImage /boot/bzImage-new
  其次配置lilo:
  # /sbin/lilo
  现在,当重新引导系统时,在boot:提示符后面有三种选择:linux-new 、 linux、
dos,新内核成为缺省的引导内核。
  至此,新的Linux内核已经建立,新添加的系统调用已成为操作系统的一部分,重新
启动Linux,用户就可以在应用程序中使用该系统调用了。
(5)使用新的系统调用
  在应用程序中使用新添加的系统调用mycall。同样为实验目的,我们写了一个简单
的例子xtdy.c。
  /* xtdy.c */
  #include <linux/unistd.h>
  _syscall1(int,mycall,int,ret)
  main()
  {
  printf("%d /n",mycall(100));
  }
  编译该程序:
  # cc -o xtdy xtdy.c
  执行:

  # xtdy
  结果:
  # 100
  注意,由于使用了系统调用,编译和执行程序时,用户都应该是超级用户身份。
(文/程仁田)

[目录]


系统调用简述


Linux的系统调用
系统调用响应函数的函数名约定
函数名以“sys_”开头,后跟该系统调用的名字,由此构成164个形似sys_name()的函数名。因此,系统调用ptrace()的响应函数是sys_ptrace() (kernel/ptrace.c)。
系统调用号
文件include/asm/unistd.h为每个系统调用规定了唯一的编号:
#define __NR_setup                  0
#define __NR_exit                            1
#define __NR_fork                  2
…        …
#define __NR_ptrace                  26
以系统调用号__NR_name作为下标,找出系统调用表sys_call_table (arch/i386/kernel/entry.S)中对应表项的内容,正好就是该系统调用的响应函数sys_name的入口地址。
系统调用表
系统调用表sys_call_table (arch/i386/kernel/entry.S)形如:
ENTRY(sys_call_table)
        .long SYMBOL_NAME(sys_setup)                /* 0 */
        .long SYMBOL_NAME(sys_exit)
        .long SYMBOL_NAME(sys_fork)
                …        …
                .long SYMBOL_NAME(sys_stime)                /* 25 */
        .long SYMBOL_NAME(sys_ptrace)
                …        …
sys_call_table记录了各sys_name函数(共166项,其中2项无效)在表中的位子。有了这张表,很容易根据特定系统调用在表中的偏移量,找到对应的系统调用响应函数的入口地址。NR_syscalls(即256)表示最多可容纳的系统调用个数。这样,余下的90项就是可供用户自己添加的系统调用空间。
从ptrace系统调用命令到INT  0X80中断请求的转换
宏定义syscallN()(include/asm/unistd.h)用于系统调用的格式转换和参数的传递。
#define _syscall4(type,name,type1,arg1,type2,arg2,type3,arg3,type4,arg4) /
type name (type1 arg1, type2 arg2, type3 arg3, type4 arg4) /
{ /
long __res; /
__asm__ volatile ("int $0x80" /
        : "=a" (__res) /
        : "0" (__NR_##name),"b" ((long)(arg1)),"c" ((long)(arg2)), /
          "d" ((long)(arg3)),"S" ((long)(arg4))); /
__syscall_return(type,__res); /
}
N取0与5之间任意整数。参数个数为N的系统调用由syscallN负责格式转换和参数传递。例如,ptrace()有四个参数,它对应的格式转换宏就是syscall4()。
syscallN()第一个参数说明响应函数返回值的类型,第二个参数为系统调用的名称(即name),其余的参数依次为系统调用参数的类型和名称。例如,
_syscall4(int, ptrace, long request, long pid, long addr, long data)
说明了系统调用命令
int sys_ptrace(long request, long pid, long addr, long data)
宏定义的余下部分描述了启动INT 0X80和接收、判断返回值的过程。也就是说,以系统调用号对EAX寄存器赋值,启动INT 0X80。规定返回值送EAX寄存器。函数的参数压栈,压栈顺序见下表:
参数        参数在堆栈的位置        传递参数的寄存器
arg1        00(%esp)        ebx
arg2        04(%esp)        ecx
arg3        08(%esp)        edx
arg4        0c(%esp)        esi
arg5        10(%esp)        edi
若INT 0X80的返回值非负,则直接按类型type返回;否则,将INT 0X80的返回值取绝对值,保留在errno变量中,返回-1。
系统调用功能模块的初始化
对系统调用的初始化也即对INT 0X80的初始化。系统启动时,汇编子程序setup_idt(arch/i386/kernel/head.S)准备了张256项的idt 表,由start_kernel()(init/main.c)、trap_init()(arch/i386/kernel/traps.c)调用的C语言宏定义set_system_gate(0x80, &system_call)(include/asm/system.h)设置0X80号软中断的服务程序为system_call。system_call(arch/i386/kernel/entry.S)就是所有系统调用的总入口。
LINUX内部是如何分别为各种系统调用服务的
当进程需要进行系统调用时,必须以C语言函数的形式写一句系统调用命令。当进程执行到用户程序的系统调用命令时,实际上执行了由宏命令_syscallN()展开的函数。系统调用的参数由各通用寄存器传递。然后执行INT 0X80,以核心态进入入口地址system_call。
ENTRY(system_call)
        pushl %eax                        # save orig_eax
        SAVE_ALL
#ifdef __SMP__
        ENTER_KERNEL
#endif
        movl $-ENOSYS,EAX(%esp)
        cmpl $(NR_syscalls),%eax
        jae ret_from_sys_call
        movl SYMBOL_NAME(sys_call_table)(,%eax,4),%eax
        testl %eax,%eax
        je ret_from_sys_call
#ifdef __SMP__
        GET_PROCESSOR_OFFSET(%edx)
        movl SYMBOL_NAME(current_set)(,%edx),%ebx
#else
        movl SYMBOL_NAME(current_set),%ebx
#endif
        andl $~CF_MASK,EFLAGS(%esp)        # clear carry - assume no errors
        movl %db6,%edx
        movl %edx,dbgreg6(%ebx)  # save current hardware debugging status
        testb $0x20,flags(%ebx)                # PF_TRACESYS
        jne 1f
        call *%eax
        movl %eax,EAX(%esp)                # save the return value
        jmp ret_from_sys_call
从system_call入口的汇编程序的主要功能是:
保存寄存器当前值(SAVE_ALL);
检验是否为合法的系统调用;
根据系统调用表_sys_call_table和EAX持有的系统调用号找出并转入系统调用响应函数;
从该响应函数返回后,让EAX寄存器保存函数返回值,跳转至ret_from_sys_call(arch/i386/kernel/entry.S)。
最后,在执行位于用户程序中系统调用命令后面余下的指令之前,若INT 0X80的返回值非负,则直接按类型type返回;否则,将INT 0X80的返回值取绝对值,保留在errno变量中,返回-1。

[目录]


增加系统调用


深入LINUX内核:为你的LINUX增加一条系统调用
  充分利用LINUX开放源码的特性,我们可以轻易地对它进行修改,使我们能够随心所
欲驾驭LINUX,完成一个真正属于自己的操作系统,这种感觉使无与伦比的,下面通过为
LINUX增加一个系统调用来展示LINUX作为一个开放源码操作系统的强大魅力。
  首先,让我们简单地分析一下LINUX中与系统调用的相关的部分:
  LINUX的系统调用的总控程序是system_call,它是LINUX系统中所有系统调用的总入
口,这个system_call是作为一个中断服务程序挂在中断0x80上,系统初始化时通过voi
d init trap_init(void)调用一个宏set_system_ gate(SYSCALL_VERCTOR,&system_ca
ll)来对IDT表进行初始化,在0x80对应的中断描述符处填入system_call函数的地址,其
中宏SYSCALL_VERCTOR就是0x80。
  当发生一条系统调用时,由中断总控程序保存处理机状态,检查调用参数的合法性
,然后根据系统调用向量在sys_call_table中找到相应的系统服务例程的地址,然后执
行该服务例程,完成后恢复中断总控程序所保存的处理机状态,返回用户程序。
  系统服务例程一般定义于kernel/sys.c中,系统调用向量定义在include/asm-386/
unistd.h中,而sys_call _table表则定义在arch/i386/kernel/entry.S文件里。
  现在我们知道增加一条系统调用我们首先要添加服务例程实现代码,然后在进行对
应向量的申明,最后当然还要在sys_call_table表中增加一项以指明服务例程的入口地
址。
  OK,有了以上简单的分析,现在我们可以开始进行源码的修改,假设我们需要添加
一条系统调用计算两个整数的平方和,系统调用名为add2,我们需要修改三个文件:ker
nel/sys.c , arch/i386/kernel/entry.S 和 include/asm-386/unistd.h。
  1、修改kernel/sys.c ,增加服务例程代码:
  asmlinkage int sys_add2(int a , int b)
    {
      int c=0;
      c=a*a+b*b;
      return c;
    }
  2、修改include/asm-386/unistd.h ,对我们刚才增加的系统调用申明向量,以使
用户或系统进程能够找到这条系统调用,修改后文件如下所示:
  .... .....
  #define _NR_sendfile   187
  #define _NR_getpmsg    188
  #define _NR_putmsg    189
  #define _NR_vfork     190
  #define _NR_add2     191   /* 这是我们添加的部分,191即向量 */
  3、修改include/asm-386/unistd.h , 将服务函数入口地址加入 sys_call_table,
首先找到这么一段:
  .... .....
  .long SYMBOL_NAME(sys_sendfile)
  .long SYMBOL_NAME(sys_ni_syscall) /* streams 1 */
  .long SYMBOL_NAME(sys_ni_syscall) /* streams 2 */
  .long SYMBOL_NAME(sys_vfork) /*190 */
  .rept NR_syscalls-190
  修改为如下:
  .... .....
  .long SYMBOL_NAME(sys_sendfile)
  .long SYMBOL_NAME(sys_ni_syscall) /* streams 1 */
  .long SYMBOL_NAME(sys_ni_syscall) /* streams 2 */
  .long SYMBOL_NAME(sys_vfork) /*190 */
  .long SYMBOL_NAME(sys_add2) <=我们的系统调用
  .rept NR_syscalls-191 <=将190改为191
  OK,大功告成,现在只需要重新编译你的LINUX内核,然后你的LINUX就有了一条新的
系统调用int add2(int a, int b)。
作者会员名:flinstone  E-MAIL:netbyte@263.net

[目录]


mlock代码分析


        系统调用mlock的作用是屏蔽内存中某些用户进程所要求的页。
        mlock调用的语法为:
                int sys_mlock(unsigned long start, size_t len);
初始化为:
        len=(len+(start &~PAGE_MASK)+ ~PAGE_MASK)&PAGE_MASK;
start &=PAGE_MASK;
其中mlock又调用do_mlock(),语法为:
int do_mlock(unsigned long start, size_t len,int on);
初始化为:
        len=(len+~PAGE_MASK)&PAGE_MASK;

    由mlock的参数可看出,mlock对由start所在页的起始地址开始,长度为len(注:len=(len+(start&~PAGE_MASK)+ ~PAGE_MASK)&PAGE_MASK)的内存区域的页进行加锁。
sys_mlock如果调用成功返回,这其中所有的包含具体内存区域的页必须是常驻内存的,或者说在调用munlock 或 munlockall之前这部分被锁住的页面必须保留在内存。当然,如果调用mlock的进程终止或者调用exec执行其他程序,则这部分被锁住的页面被释放。通过fork()调用所创建的子进程不能够继承由父进程调用mlock锁住的页面。
    内存屏蔽主要有两个方面的应用:实时算法和高度机密数据的处理。实时应用要求严格的分时,比如调度,调度页面是程序执行延时的一个主要因素。保密安全软件经常处理关键字节,比如密码或者密钥等数据结构。页面调度的结果是有可能将这些重要字节写到外存(如硬盘)中去。这样一些黑客就有可能在这些安全软件删除这些在内存中的数据后还能访问部分在硬盘中的数据。        而对内存进行加锁完全可以解决上述难题。
    内存加锁不使用压栈技术,即那些通过调用mlock或者mlockall被锁住多次的页面可以通过调用一次munlock或者munlockall释放相应的页面
    mlock的返回值分析:若调用mlock成功,则返回0;若不成功,则返回-1,并且errno被置位,进程的地址空间保持原来的状态。返回错误代码分析如下:
   ENOMEM:部分具体地址区域没有相应的进程地址空间与之对应或者超出了进程所允许的最大可锁页面。
   EPERM:调用mlock的进程没有正确的优先权。只有root进程才允许锁住要求的页面。
EINVAL:输入参数len不是个合法的正数。


mlock所用到的主要数据结构和重要常量

1.mm_struct
struct mm_struct {
        int count;
        pgd_t * pgd; /* 进程页目录的起始地址,如图2-3所示 */
        unsigned long context;
        unsigned long start_code, end_code, start_data, end_data;
        unsigned long start_brk, brk, start_stack, start_mmap;
        unsigned long arg_start, arg_end, env_start, env_end;
        unsigned long rss, total_vm, locked_vm;
        unsigned long def_flags;
        struct vm_area_struct * mmap;     /* 指向vma双向链表的指针 */
        struct vm_area_struct * mmap_avl; /* 指向vma AVL树的指针 */
        struct semaphore mmap_sem;
}
start_code、end_code:进程代码段的起始地址和结束地址。
start_data、end_data:进程数据段的起始地址和结束地址。
arg_start、arg_end:调用参数区的起始地址和结束地址。
env_start、env_end:进程环境区的起始地址和结束地址。
rss:进程内容驻留在物理内存的页面总数。


2. 虚存段(vma)数据结构:vm_area_atruct

虚存段vma由数据结构vm_area_atruct(include/linux/mm.h)描述:
struct vm_area_struct {
        struct mm_struct * vm_mm;        /* VM area parameters */
        unsigned long vm_start;
        unsigned long vm_end;
        pgprot_t vm_page_prot;
        unsigned short vm_flags;
/* AVL tree of VM areas per task, sorted by address */
        short vm_avl_height;
        struct vm_area_struct * vm_avl_left;
        struct vm_area_struct * vm_avl_right;
/* linked list of VM areas per task, sorted by address */
        struct vm_area_struct * vm_next;
/* for areas with inode, the circular list inode->i_mmap */
/* for shm areas, the circular list of attaches */
/* otherwise unused */
        struct vm_area_struct * vm_next_share;
        struct vm_area_struct * vm_prev_share;
/* more */
        struct vm_operations_struct * vm_ops;
        unsigned long vm_offset;
        struct inode * vm_inode;
        unsigned long vm_pte;                        /* shared mem */
};

vm_start;//所对应内存区域的开始地址
vm_end; //所对应内存区域的结束地址
vm_flags; //进程对所对应内存区域的访问权限
vm_avl_height;//avl树的高度
vm_avl_left; //avl树的左儿子
vm_avl_right; //avl树的右儿子
vm_next;// 进程所使用的按地址排序的vm_area链表指针
vm_ops;//一组对内存的操作
    这些对内存的操作是当对虚存进行操作的时候Linux系统必须使用的一组方法。比如说,当进程准备访问某一虚存区域但是发现此区域在物理内存不存在时(缺页中断),就激发某种对内存的操作执行正确的行为。这种操作是空页(nopage)操作。当Linux系统按需调度可执行的页面映象进入内存时就使用这种空页(nopage)操作。
    当一个可执行的页面映象映射到进程的虚存地址时,一组vm_area_struct结构的数据结构(vma)就会生成。每一个vm_area_struct的数据结构(vma)代表可执行的页面映象的一部分:可执行代码,初始化数据(变量),非初始化数据等等。Linux系统可以支持大量的标准虚存操作,当vm_area_struct数据结构(vma)一被创建,它就对应于一组正确的虚存操作。
    属于同一进程的vma段通过vm_next指针连接,组成链表。如图2-3所示,struct mm_struct结构的成员struct vm_area_struct * mmap  表示进程的vma链表的表头。
    为了提高对vma段 查询、插入、删除操作的速度,LINUX同时维护了一个AVL(Adelson-Velskii and Landis)树。在树中,所有的vm_area_struct虚存段均有左指针vm_avl_left指向相邻的低地址虚存段,右指针vm_avl_right指向相邻的高地址虚存段,如图2-5。struct mm_struct结构的成员struct vm_area_struct * mmap_avl表示进程的AVL树的根,vm_avl_height表示AVL树的高度。
    对平衡树mmap_avl的任何操作必须满足平衡树的一些规则:
Consistency and balancing rulesJ(一致性和平衡规则):

tree->vm_avl_height==1+max(heightof(tree->vm_avl_left),heightof(
tree->vm_avl_right))
abs( heightof(tree->vm_avl_left) - heightof(tree->vm_avl_right) ) <= 1
foreach node in tree->vm_avl_left: node->vm_avl_key <= tree->vm_avl_key,        foreach node in tree->vm_avl_right: node->vm_avl_key >= tree->vm_avl_key.
        注:其中node->vm_avl_key= node->vm_end

对vma可以进行加锁、加保护、共享和动态扩展等操作。

3.重要常量
    mlock系统调用所用到的重要常量有:PAGE_MASK、PAGE_SIZE、PAGE_SHIFT、RLIMIT_MEMLOCK、VM_LOCKED、 PF_SUPERPRIV等。它们的值分别如下:
        PAGE_SHIFT                        12                                // PAGE_SHIFT determines the page size
        PAGE_SIZE                        0x1000                        //1UL<<PAGE_SHIFT
        PAGE_MASK                        ~(PAGE_SIZE-1)        //a very useful constant variable
        RLIMIT_MEMLOCK                8                                //max locked-in-memory address space
        VM_LOCKED                        0x2000                        //8*1024=8192, vm_flags的标志之一。
        PF_SUPERPRIV                0x00000100                //512,

 

mlock系统调用代码函数功能分析

下面对各个函数的功能作详细的分析((1)和(2)在前面简介mlock时已介绍过,并在后面有详细的程序流程):
suser():如果用户有效(即current->euid == 0        ),则设置进程标志为root优先权(current->flags |= PF_SUPERPRIV),并返回1;否则返回0。
find_vma(struct mm_struct * mm, unsigned long addr):输入参数为当前进程的mm、需要加锁的开始内存地址addr。find_vma的功能是在mm的mmap_avl树中寻找第一个满足mm->mmap_avl->vm_start<=addr< mm->mmap_avl->vm_end的vma,如果成功则返回此vma;否则返回空null。
mlock_fixup(struct vm_area_struct * vma, unsigned long start, unsigned long end, unsigned int newflags):输入参数为vm_mmap链中的某个vma、需要加锁内存区域起始地址和结束地址、需要修改的标志(0:加锁,1:释放锁)。
merge_segments(struct mm_struct * mm, unsigned long start_addr, unsigned long end_addr):输入参数为当前进程的mm、需要加锁的开始内存地址start_addr和结束地址end_addr。merge_segments的功能的是尽最大可能归并相邻(即内存地址偏移量连续)并有相同属性(包括vm_inode,vm_pte,vm_ops,vm_flags)的内存段,在这过程中冗余的vm_area_structs被释放,这就要求vm_mmap链按地址大小排序(我们不需要遍历整个表,而只需要遍历那些交叉或者相隔一定连续区域的邻接vm_area_structs)。当然在缺省的情况下,merge_segments是对vm_mmap_avl树进行循环处理,有多少可以合并的段就合并多少。
mlock_fixup_all(struct vm_area_struct * vma, int newflags):输入参数为vm_mmap链中的某个vma、需要修改的标志(0:加锁,1:释放锁)。mlock_fixup_all的功能是根据输入参数newflags修改此vma的vm_flags。
mlock_fixup_start(struct vm_area_struct * vma,unsigned long end, int newflags):输入参数为vm_mmap链中的某个vma、需要加锁内存区域结束地址、需要修改的标志(0:加锁,1:释放锁)。mlock_fixup_start的功能是根据输入参数end,在内存中分配一个新的new_vma,把原来的vma分成两个部分: new_vma和vma,其中new_vma的vm_flags被设置成输入参数newflags;并且按地址(new_vma->start和new_vma->end)大小序列把新生成的new->vma插入到当前进程mm的mmap链或mmap_avl树中(缺省情况下是插入到mmap_avl树中)。
        注:vma->vm_offset+= vma->vm_start-new_vma->vm_start;
mlock_fixup_end(struct vm_area_struct * vma,unsigned long start, int newflags):输入参数为vm_mmap链中的某个vma、需要加锁内存区域起始地址、需要修改的标志(0:加锁,1:释放锁)。mlock_fixup_end的功能是根据输入参数start,在内存中分配一个新的new_vma,把原来的vma分成两个部分:vma和new_vma,其中new_vma的vm_flags被设置成输入参数newflags;并且按地址大小序列把new->vma插入到当前进程mm的mmap链或mmap_avl树中。
        注:new_vma->vm_offset= vma->vm_offset+(new_vma->vm_start-vma->vm_start);
mlock_fixup_middle(struct vm_area_struct * vma,unsigned long start, unsigned long end, int newflags):输入参数为vm_mmap链中的某个vma、需要加锁内存区域起始地址和结束地址、需要修改的标志(0:加锁,1:释放锁)。mlock_fixup_middle的功能是根据输入参数start、end,在内存中分配两个新vma,把原来的vma分成三个部分:left_vma、vma和right_vma,其中vma的vm_flags被设置成输入参数newflags;并且按地址大小序列把left->vma和right->vma插入到当前进程mm的mmap链或mmap_avl树中。
        注:vma->vm_offset += vma->vm_start-left_vma->vm_start;
                right_vma->vm_offset += right_vma->vm_start-left_vma->vm_start;
kmalloc():将在后面3.3中有详细讨论。
insert_vm_struct(struct mm_struct *mm, struct vm_area_struct *vmp):输入参数为当前进程的mm、需要插入的vmp。insert_vm_struct的功能是按地址大小序列把vmp插入到当前进程mm的mmap链或mmap_avl树中,并且把vmp插入到vmp->inode的i_mmap环(循环共享链)中。
avl_insert_neighbours(struct vm_area_struct * new_node,** ptree,** to_the_left,** to_the_right):输入参数为当前需要插入的新vma结点new_node、目标mmap_avl树ptree、新结点插入ptree后它左边的结点以及它右边的结点(左右边结点按mmap_avl中各vma->vma_end大小排序)。avl_insert_neighbours的功能是插入新vma结点new_node到目标mmap_avl树ptree中,并且调用avl_rebalance以保持ptree的平衡树特性,最后返回new_node左边的结点以及它右边的结点。
avl_rebalance(struct vm_area_struct *** nodeplaces_ptr, int count):输入参数为指向vm_area_struct指针结构的指针数据nodeplaces_ptr[](每个元素表示需要平衡的mmap_avl子树)、数据元素个数count。avl_rebalance的功能是从nodeplaces_ptr[--count]开始直到nodeplaces_ptr[0]循环平衡各个mmap_avl子树,最终使整个mmap_avl树平衡。
down(struct semaphore * sem):输入参数为同步(进入临界区)信号量sem。down的功能根据当前信号量的设置情况加锁(阻止别的进程进入临界区)并继续执行或进入等待状态(等待别的进程执行完成退出临界区并释放锁)。
        down定义在/include/linux/sched.h中:
extern inline void down(struct semaphore * sem)
{
        if (sem->count <= 0)
                __down(sem);
        sem->count--;
}
up(struct semaphore * sem)输入参数为同步(进入临界区)信号量sem。up的功能根据当前信号量的设置情况(当信号量的值为负数:表示有某个进程在等待使用此临界区 )释放锁。
        up定义在/include/linux/sched.h中:
extern inline void up(struct semaphore * sem)
{
        sem->count++;
        wake_up(&sem->wait);
        }
kfree_s(a,b):kfree_s定义在/include/linux/malloc.h中:#define kfree_s(a,b) kfree(a)。而kfree()将在后面3.3中详细讨论。
avl_neighbours(struct vm_area_struct * node,* tree,** to_the_left,** to_the_right):输入参数为作为查找条件的vma结点node、目标mmap_avl树tree、node左边的结点以及它右边的结点(左右边结点按mmap_avl中各vma->vma_end大小排序)。avl_ neighbours的功能是根据查找条件node在目标mmap_avl树ptree中找到node左边的结点以及它右边的结点,并返回。
avl_remove(struct vm_area_struct * node_to_delete, ** ptree):输入参数为需要删除的结点node_to_delete和目标mmap_avl树ptree。avl_remove的功能是在目标mmap_avl树ptree中找到结点node_to_delete并把它从平衡树中删除,并且调用avl_rebalance以保持ptree的平衡树特性。
remove_shared_vm_struct(struct vm_area_struct *mpnt):输入参数为需要从inode->immap环中删除的vma结点mpnt。remove_shared_vm_struct的功能是从拥有vma结点mpnt 的inode->immap环中删除的该结点。

 

[目录]


文件系统

 

[目录]


inode


    学过操作系统的人对inode一定印象特别深刻,这里是我收集的细节
    一个inode有128 byte。在新建文件系统时, 通常会有一个参数, 用
来描述要分配多少比例的空间给inode table。举例来说newfs -i 2048
是指文件系统中, 每分配2048 byte给data area, 就分配一个inode。
但一个inode并不一定用掉2048 byte, 也不是说 files allocation的最
小单位是2048 byte, 它仅仅只是代表文件系统中inode table/data area
分配空间的比例是 128/2048 也就是 1/16。如果 inode table 太小, 那
么在每个文件都很小的时候, 就会发生inode用光而存储空间多余的情况。
file allocation的最小单位和inode多少没有关系

[目录]


proc


PROC文件系统是一个伪文件系统,它的文件和目录是由Linux 操作系统核心提供的,以文件系统的方式为访问系统内核数据的操作提供接口,它们不占用磁盘上的任何空间,有了这些文件和目录, 用户可以更容易的了解操作系统核心或各个进程的状态,并能对系统的一些参数进行配置。比如,一个系统内能打开的文件数最大缺省是1024,即系统最多能同时打开1024个文件,这在使用Linux做多用户的服务器时是不够用的,通过对/PROC下文件的修改可以在不修改核心,甚至不启动机器的情况下改变这个缺省值。由于系统的信息,如进程,是动态改变的,所以用户或应用程序读取PROC文件时,PROC文件系统是动态从系统内核读出所需信息并提交的。它的目录结构如下:

目录名称        目录内容
apm         Advanced power management info
Cmdline         Kernel command line
Cpuinfo        Info about the CPU
Devices        Available devices (block and character)
Dma        Used DMS channels
Filesystems        Supported filesystems
Interrupts        Interrupt usage
Ioports        I/O port usage
Kcore        Kernel core image
Kmsg        Kernel messages
Ksyms        Kernel symbol table
Loadavg        Load average
Locks        Kernel locks
Meminfo        Memory info
Misc        Miscellaneous
Modules        List of loaded modules
Mounts        Mounted filesystems
Partitions        Table of partitions known to the system
Rtc        Real time clock
Slabinfo        Slab pool info
Stat        Overall statistics
Swaps        Swap space utilization
Version        Kernel version
Uptime        System uptime

并不是所有这些目录在你的系统中都有,这取决于你的内核配置和装载的模块。另外,在/proc下还有三个很重要的目录:net,scsi和sys。Sys目录是可写的,可以通过它来访问或修改内核的参数,而net和scsi则依赖于内核配置。例如,如果系统不支持scsi,则scsi目录不存在。
除了以上介绍的这些,还有的是一些以数字命名的目录,它们是进程目录。系统中当前运行的每一个进程都有对应的一个目录在/PROC下,以进程的PID号为目录名,它们是读取进程信息的接口。而self目录则是读取进程本身的信息接口,是一个link。Proc文件系统的名字就是由之而起。进程目录的结构如下:

目录名称        目录内容
Cmdline        Command line arguments
Environ        Values of environment variables
Fd        Directory, which contains all file descriptors
Mem        Memory held by this process
Stat        Process status
Status        Process status in human readable form
Cwd        Link to the current working directory
Exe        Link to the executable of this process
Maps        Memory maps
Statm        Process memory status information
Root        Link to the root directory of this process

用户如果要查看系统信息,可以用cat命令。例如:
> cat /proc/interrupts
           CPU0
  0:    8728810          XT-PIC  timer
  1:        895          XT-PIC  keyboard
  2:          0          XT-PIC  cascade
  3:     531695          XT-PIC  aha152x
  4:    2014133          XT-PIC  serial
  5:      44401          XT-PIC  pcnet_cs
  8:          2          XT-PIC  rtc
11:          8          XT-PIC  i82365
12:     182918          XT-PIC  PS/2 Mouse
13:          1          XT-PIC  fpu
14:    1232265          XT-PIC  ide0
15:          7          XT-PIC  ide1
NMI:          0
2.修改内核参数
在/proc文件系统中有一个有趣的目录:/proc/sys。它不仅提供了内核信息,而且可以通过它修改内核参数,来优化你的系统。但是你必须很小心,因为可能会造成系统崩溃。最好是先找一台无关紧要的机子,调试成功后再应用到你的系统上。
要改变内核的参数,只要用vi编辑或echo参数重定向到文件中即可。下面有一个例子:
# cat /proc/sys/fs/file-max
4096
# echo 8192 > /proc/sys/fs/file-max
# cat /proc/sys/fs/file-max
8192
如果你优化了参数,则可以把它们写成脚本文件,使它在系统启动时自动完成修改。

PROC文件系统的初始化过程概述

PROC文件系统总的初始化流程如下图所示,是从INIT/MAIN.C的START_KERNEL()函数中开始的,首先是PROC_ROOT_INIT(),在这个函数中用PROC_DIR_EMTRY注册了/PROC及其目录下的各个文件及目录的基本信息,包括注册INODE NUMBER,文件名长度,文件名,操作权限,连接数,用户标识号,组标识号,允许的INODE OPERATIONS和兄弟、父母、子文件的指针等,并生成文件目录之间的相互关系,即目录树。接下来在SYSCLT_INIT()里把ROOT_TABLE的各项内容挂到/PROC树的PROC_SYS_ROOT下面,PROC_SYS_ROOT是一个特殊的PROC项,即/PROC/SYS目录,在此目录下的部分文件是可写的,可以通过修改这些文件内容来修改系统配置参数。然后是FILESYSTEM_SETUP(),在这里产生一个新的FILE_SYSTEM_TYPE:PROC_FS_TYPE,把这个文件系统类型挂到FILE_SYSTEMS链表的末尾,其中包含了读取PROC文件系统SUPER BLOCK的函数指针,PROC_READ_SUPER,接下来在装载了ROOT文件系统后,如果还要把PROC文件系统MOUNT上来则需通过此函数把PROC文件系统的SUPER BLOCK读进内存里的SUPER_BLOCKS链表。从上面可以看到,PROC文件系统的初始化流程主要分两步,即登记注册和挂载文件系统,其中的核心内容是在登记注册里,下面就具体分析一下这两部分的具体初始化操作。
三、PROC文件系统的登记注册过程
从程序中来看,PROC文件系统的文件可以分为两大类,一类是ROOT部分,另一类是BASE部分,体现在初始化程序中分别叫做PROC_ROOT_INIT()和PROC_BASE_INIT()。ROOT部分主要是针对/PROC目录下的一些名称位置相对固定的常规性文件,如 CPUINFO,MEMINFO,KMESG,MODULES,DEVICES,INTERRUPTS,FILESYSTEMS,PARTITIONS,DMA,IOPORTS,CMDLINE,MOUNTS等;而BASE部分则是针对系统中每个进程的,每个运行中的进程在/PROC下都有一个以自己的进程号为名字的目录,里面记载了关于此进程运行状态的信息,如STATUS,MEM,CWD,ROOT,FD,EXE,CMDLINE,STAT,STATM等。下面将会分别介绍这两部分的初始化过程,首先介绍一下基本的数据结构。
1.基本数据结构
在PROC        文件系统中最重要的数据结构是一个叫PROC_DIR_ENTRY的结构类型(include/linux/proc_fs.h),所有该文件系中的文件及目录都除了通用文件操作用的INODE,FILE,DENTRY等结构外,都必须首先注册自己的一个PROC_DIR_ENTRY,在其中定义了针对自己的各项属性和操作函数指针。
struct proc_dir_entry {
unsigned short low_ino;          /*注册inode号,实际inode的低16位*/
                unsigned short namelen;                   /*名称字符串的长度*/
        const char *name;                        /*文件名称*/
                mode_t mode;                           /*文件权限*/
        nlink_t nlink;                               /*连接到此文件的目录项个数*/
                uid_t uid;                                   /*用户标识*/
        gid_t gid;                               /*组标识*/
                unsigned long size;                       /*文件大小,均为0*/
        struct inode_operations * ops;              /*inode操作的函数指针*/
                int (*get_info)(char *, char **, off_t, int, int);
        void (*fill_inode)(struct inode *, int);         /*填补inode信息的函数指针*/
        struct proc_dir_entry *next, *parent, *subdir;    /*兄弟,父亲,子文件指针*/
void *data;
        int (*read_proc)(char *page, char **start, off_t off, int count,
int *eof, void *data);
        int (*write_proc)(struct file *file, const char *buffer,
                                  unsigned long count, void *data);
        int (*readlink_proc)(struct proc_dir_entry *de, char *page);
        unsigned int count;                                /*使用数*/
                int deleted;                                            /*删除标志*/
};
其次就是针对INODE,FILE和SUPER BLOCK的各种操作函数指针,这些结构与文件系统中使用的完全相同,此处不再赘述。
2.PROC_ROOT_INIT()
PROC_ROOT_INIT()函数的定义如下:
__initfunc(void proc_root_init(void))
{
        proc_base_init();
        proc_register(&proc_root, &proc_root_loadavg);
        proc_register(&proc_root, &proc_root_uptime);
        proc_register(&proc_root, &proc_root_meminfo);
        proc_register(&proc_root, &proc_root_kmsg);
        proc_register(&proc_root, &proc_root_version);
        proc_register(&proc_root, &proc_root_cpuinfo);
        proc_register(&proc_root, &proc_root_self);
#ifdef CONFIG_SYSCTL
        proc_register(&proc_root, &proc_sys_root);
#endif
#ifdef CONFIG_MCA
        proc_register(&proc_root, &proc_mca);
#endif

#ifdef CONFIG_DEBUG_MALLOC
        proc_register(&proc_root, &proc_root_malloc);
#endif
#ifdef CONFIG_MODULES
        proc_register(&proc_root, &proc_root_modules);
        proc_register(&proc_root, &proc_root_ksyms);
#endif
        proc_register(&proc_root, &proc_root_stat);
        proc_register(&proc_root, &proc_root_devices);
        proc_register(&proc_root, &proc_root_partitions);
        proc_register(&proc_root, &proc_root_interrupts);
        proc_register(&proc_root, &proc_root_filesystems);
        proc_register(&proc_root, &proc_root_fs);
        proc_register(&proc_root, &proc_root_dma);
        proc_register(&proc_root, &proc_root_ioports);
        proc_register(&proc_root, &proc_root_cmdline);
                ……
                }
__initfunc是在inlucde/linux/init.h中定义的一个宏,表示此函数仅在系统初始化时使用,使用完毕即释放申请的内存资源。
PROC_REGISTER()函数在fs/proc/root.c中定义,程序如下:
int proc_register(struct proc_dir_entry * dir, struct proc_dir_entry * dp)
{
        int        i;
        if (dp->low_ino == 0) {
                i = make_inode_number();
                if (i < 0)
                        return -EAGAIN;
                dp->low_ino = i;
        }
/*如果没有low_ino值,则产生一个新的赋给它*/
        dp->next = dir->subdir;
        dp->parent = dir;
        dir->subdir = dp;
/*赋给兄弟、父母及子女的指针*/
        if (S_ISDIR(dp->mode)) {
                if (dp->ops == NULL)
                        dp->ops = &proc_dir_inode_operations;
                dir->nlink++;
        } else if (S_ISLNK(dp->mode)) {
                if (dp->ops == NULL)
                        dp->ops = &proc_link_inode_operations;
        } else {
                if (dp->ops == NULL)
                        dp->ops = &proc_file_inode_operations;
        }
/*对于dp的不同属性调整操作函数指针*/
        return 0;
}
初始化时首先要为每个文件或目录创建一个PROC_DIR_ENTRY的实例变量,内容包括注册的INODE号,名称,操作权限,连接数和INODE操作函数指针等,具体方法如下所示:
struct proc_dir_entry proc_root = {
        PROC_ROOT_INO, 5, "/proc", S_IFDIR | S_IRUGO | S_IXUGO,
  2, 0, 0, 0, &proc_root_inode_operations, NULL, NULL, NULL,
        &proc_root, NULL };
struct proc_dir_entry proc_mca = {
        PROC_MCA, 3, "mca", S_IFDIR | S_IRUGO | S_IXUGO,
  2, 0, 0, 0, &proc_dir_inode_operations, NULL, NULL, NULL,
  &proc_root, NULL };
static struct proc_dir_entry proc_root_loadavg = {
        PROC_LOADAVG, 7, "loadavg",        S_IFREG | S_IRUGO, 1, 0, 0,
        0, &proc_array_inode_operations };
static struct proc_dir_entry proc_root_uptime = {
        PROC_UPTIME, 6, "uptime",        S_IFREG | S_IRUGO, 1, 0, 0,
        0, &proc_array_inode_operations };
static struct proc_dir_entry proc_root_meminfo = {
        PROC_MEMINFO, 7, "meminfo",        S_IFREG | S_IRUGO, 1, 0, 0,
        0, &proc_array_inode_operations };
static struct proc_dir_entry proc_root_kmsg = {
        PROC_KMSG, 4, "kmsg", S_IFREG | S_IRUSR, 1, 0, 0,
        0, &proc_kmsg_inode_operations };
......
PROC_REGISTER()函数首先检查这个新的PROC_DIR_ENTRY是否已有自己的PROC INODE号,如前所述,PROC文件系统是个“伪”文件系统,它并不存在于任何实际的物理设备上,所以它的文件INODE号与普通文件的INODE号的涵义是不同的,它不需要标识此文件的物理存在位置,只要能在本文件系统中唯一地标识这个文件即可。对于ROOT部分的文件在include/proc_fs.h中用一个枚举变量enum root_directory_inos来对其赋值,其中第一个文件即/PROC目录用PROC_ROOT_INO=1来定义。如果此文件在变量初始化时未赋值,LINUX用一个proc_alloc_map来表示INODE的使用情况,proc_alloc_map是一块有4096个bits的内存空间,每一位表示一个INODE的使用情况,如已经被使用则置位,放弃时恢复。分配时找其中第一位未使用的bit,在其位数上加上4096就是这个新登记文件的PROC INODE号。在此之后,PROC_REGISTER()调整父目录与子目录/文件之间的指针关系,及子目录/文件的INODE操作函数指针,最终结果是生成一棵以PROC_DIR_ENTRY为节点,PROC_ROOT为根的目录树,表明其相互之间的关系,在以后对文件或目录做标准操作(即用INODE,FILE,DENTRY等结构)的时候就可以从中获得需要的信息和函数指针。

 

在解释过PROC_REGISTER()函数后顺便再说明一下它的反向操作函数PROC_UNREGISTER(),即注销一个PROC_DIR_ENTRY项,其定义如下:

int proc_unregister(struct proc_dir_entry * dir, int ino)
{
        struct proc_dir_entry **p = &dir->subdir, *dp;
/*从dir的subdir指针开始进行搜索*/
        while ((dp = *p) != NULL) {          /*在dp指针尚不为空时*/
                if (dp->low_ino == ino) {    /*如果low_ino==ino,说明仅对root部分*/
                        *p = dp->next;
                        dp->next = NULL;
         /*兄弟指针置空*/
                        if (S_ISDIR(dp->mode))
                                dir->nlink--;
        /*如果dp是目录,其父目录的连接数要减去1*/
                        if (ino >= PROC_DYNAMIC_FIRST &&
                            ino < PROC_DYNAMIC_FIRST+PROC_NDYNAMIC)
                                clear_bit(ino-PROC_DYNAMIC_FIRST,
                                          (void *) proc_alloc_map);
        /*如果是在程序中生成的low_ino,则要清除对应的proc_allc_map中的*/
         /*位标志*/
                        proc_kill_inodes(ino);
                        return 0;
                }
                p = &dp->next;            /*p指向dp的兄弟指针,继续搜索*/
        }
        return -EINVAL;
}
在PROC_UNREGISTER()中调用了另一个函数PROC_KILL_INODE(),该函数的功能是把一个已经被注销的PROC文件系统的INODE消灭掉,定义如下:
static void proc_kill_inodes(int ino)
{
        struct file *filp;

        /* inuse_filps is protected by the single kernel lock */
        for (filp = inuse_filps; filp; filp = filp->f_next) {
     /*在正在使用中的文件链表中进行搜索*/
                struct dentry * dentry;
                struct inode * inode;

                dentry = filp->f_dentry;
                if (!dentry)
                        continue;
                if (dentry->d_op != &proc_dentry_operations)
                        continue;
     /*如果该项不属于PROC文件系统,则继续*/
                inode = dentry->d_inode;
                if (!inode)
                        continue;
                if (inode->i_ino != ino)
                        continue;
                filp->f_op = NULL;
     /*把该文件的操作函数指针置空,以后就无法使用了*/
        }
}
3.PROC_BASE_INIT()
PROC_BASE_INIT()函数在PROC_ROOT_INIT()中调用,BASE部分的初始化与ROOT部分基本相同,首先为每个目录和文件初始化一个PROC_DIR_ENTRY结构,然后调用PROC_REGISTER()函数进行注册,并生成BASE部分的关系树,程序如下:
struct proc_dir_entry proc_pid = {
        PROC_PID_INO, 5, "<pid>",        S_IFDIR | S_IRUGO | S_IXUGO, 2, 0, 0,
        0, &proc_base_inode_operations,        NULL, proc_pid_fill_inode,
        NULL, &proc_root, NULL
};

static struct proc_dir_entry proc_pid_status = {
        PROC_PID_STATUS, 6, "status",        S_IFREG | S_IRUGO, 1, 0, 0,
        0, &proc_array_inode_operations,        NULL, proc_pid_fill_inode,
};
static struct proc_dir_entry proc_pid_mem = {
        PROC_PID_MEM, 3, "mem",        S_IFREG | S_IRUSR | S_IWUSR, 1, 0, 0,
        0, &proc_mem_inode_operations,        NULL, proc_pid_fill_inode,
};
static struct proc_dir_entry proc_pid_cwd = {
        PROC_PID_CWD, 3, "cwd",        S_IFLNK | S_IRWXU, 1, 0, 0,
        0, &proc_link_inode_operations,        NULL, proc_pid_fill_inode,
};
static struct proc_dir_entry proc_pid_root = {
        PROC_PID_ROOT, 4, "root",        S_IFLNK | S_IRWXU, 1, 0, 0,
        0, &proc_link_inode_operations,        NULL, proc_pid_fill_inode,
};
static struct proc_dir_entry proc_pid_exe = {
        PROC_PID_EXE, 3, "exe",        S_IFLNK | S_IRWXU, 1, 0, 0,
        0, &proc_link_inode_operations,        NULL, proc_pid_fill_inode,
};
static struct proc_dir_entry proc_pid_fd = {
        PROC_PID_FD, 2, "fd",        S_IFDIR | S_IRUSR | S_IXUSR, 2, 0, 0,
        0, &proc_fd_inode_operations,        NULL, proc_pid_fill_inode,
};
static struct proc_dir_entry proc_pid_environ = {
        PROC_PID_ENVIRON, 7, "environ",        S_IFREG | S_IRUSR, 1, 0, 0,
        0, &proc_array_inode_operations,        NULL, proc_pid_fill_inode,
};
static struct proc_dir_entry proc_pid_cmdline = {
        PROC_PID_CMDLINE, 7, "cmdline",        S_IFREG | S_IRUGO, 1, 0, 0,
        0, &proc_array_inode_operations,        NULL, proc_pid_fill_inode,
};
static struct proc_dir_entry proc_pid_stat = {
        PROC_PID_STAT, 4, "stat",        S_IFREG | S_IRUGO, 1, 0, 0,
        0, &proc_array_inode_operations,        NULL, proc_pid_fill_inode,
};
static struct proc_dir_entry proc_pid_statm = {
        PROC_PID_STATM, 5, "statm",        S_IFREG | S_IRUGO, 1, 0, 0,
        0, &proc_array_inode_operations,        NULL, proc_pid_fill_inode,
};
static struct proc_dir_entry proc_pid_maps = {
        PROC_PID_MAPS, 4, "maps",        S_IFIFO | S_IRUGO, 1, 0, 0,
        0, &proc_arraylong_inode_operations,        NULL, proc_pid_fill_inode, };


__initfunc(void proc_base_init(void))
{
#if CONFIG_AP1000
        proc_register(&proc_pid, &proc_pid_ringbuf);
#endif
        proc_register(&proc_pid, &proc_pid_status);
        proc_register(&proc_pid, &proc_pid_mem);
        proc_register(&proc_pid, &proc_pid_cwd);
        proc_register(&proc_pid, &proc_pid_root);
        proc_register(&proc_pid, &proc_pid_exe);
        proc_register(&proc_pid, &proc_pid_fd);
        proc_register(&proc_pid, &proc_pid_environ);
        proc_register(&proc_pid, &proc_pid_cmdline);
        proc_regis
ter(&proc_pid, &proc_pid_stat);
        proc_register(&proc_pid, &proc_pid_statm);
        proc_register(&proc_pid, &proc_pid_maps);
#ifdef __SMP__
        proc_register(&proc_pid, &proc_pid_cpu);
#endif
};
这部分与ROOT部分的不同之处一是BASE部分的文件/目录的PROC INODE 号是用另一个枚举变量enum pid_directory_inos来赋值,其第一项PROC_PID_INO=2,即<pid>目录。由于ROOT部分的每个文件/目录在/PROC下只有唯一的一个实例,而BASE部分对每个进程均有相同的一份拷贝,所以它的实际INODE号必须对不同的进程予以区分,在LINUX中,这种区分是通过把进程PID做为INODE的高16位,PROC_DIR_ENTRY中的LOW_INO做为INODE的低16位来实现的,这样可以保证每个文件INODE号在文件系统中的唯一性。另一个不同之处是BASE部分的文件在注册其PROC_DIR_ENTRY的时候都增加了FILL_INODE函数指针,指向PROC_PID_FILL_INODE函数,该函数的主要功能是把实际INODE号右移16位,获得对应此目录或文件的进程PID号,再把此进程的用户标识和组标识赋回给INODE结构。还有一点区别就是PROC_BASE_INIT()初始化的这棵PROC_DIR_ENTRY树是相对独立的(如图2),它以<pid>目录,即PROC_PID项为根,并注册了该目录下各个文件及目录之间的相互关系,但它并不把PROC_PID挂到PROC_ROOT下面去,因为这是要在对PROC_ROOT做READDIR时动态加载的。
4.INODE OPERATIONS
有一点需要强调的是PROC文件系统在初始化时只是为每个目录和文件登记了一个PROC_DIR_ENTRY项,并为这些项生成了关系树,但对于VFS的通用文件操作做使用的数据结构,如INODE,FILE,DENTRY等此时都是不存在的,这些数据结构要等到在对PROC文件系统的文件做OPEN和READ等操作时才会根据PROC_DIR_ENTRY里定义的INODE OPERATION及其中的FILE OPERATIONS函数指针调用对应函数产生,这是PROC文件系统与其他基于设备的文件系统的一大区别之处。所以,在PROC_DIR_ENTRY中定义的INODE OPERATIONS决定了该文件的操作方式以及获取对应系统信息的渠道。举例来说,PROC_ROOT指向的PROC_ROOT_INODE_OPERATIONS中允许的INODE OPERATIONS函数是PROC_ROOT_LOOKUP,FILE OPERATIONS函数是PROC_ROOT_READDIR ;PROC_PID指向的PROC_BASE_INODE_OPERATIONS中允许的INODE OPERATIONS函数是PROC_LOOKUP,FILE OPERATIONS函数是PROC_ READDIR ;PROC_MEM_INFO指向的PROC_ARRAY_INODE_OPERATIONS中允许的INODE OPERATIONS函数均为空,FILE OPERATIONS函数是ARRAY_READ。下面我们来分析一下几个LOOKUP和READDIR函数,ARRAY_READ的功能主要是面向底层如何获取系统信息反馈上来,详见黄军同学的报告,这里就不做详述了。
PROC_LOOKUP、PROC_READDIR与PROC_ROOT_LOOKUP、PROC_ROOT_READDIR的功能基本上是相同的,只不过加上了ROOT后就加上了对<PID>目录的处理功能。
程序如下所示:
1) proc_lookup()
int proc_lookup(struct inode * dir, struct dentry *dentry)
{
        struct inode *inode;
        struct proc_dir_entry * de;
        int error;

        error = -ENOTDIR;
        if (!dir || !S_ISDIR(dir->i_mode))
                goto out;
/*如果dir空或dir不是目录,则退出*/
        error = -ENOENT;
        inode = NULL;
        de = (struct proc_dir_entry *) dir->u.generic_ip;
/*根据dir生成一个proc_dir_entry的指针*/
        if (de) {
                for (de = de->subdir; de ; de = de->next) {
         /*在de的子目录和文件中搜索*/
                        if (!de || !de->low_ino)
                                continue;
                        if (de->namelen != dentry->d_name.len)
                                continue;
                        if (!memcmp(dentry->d_name.name, de->name, de->namelen)) {
            /*如果dentry和由dir指向的proc_dir_entry名字相同*/
                                int ino = de->low_ino | (dir->i_ino & ~(0xffff));
                                error = -EINVAL;
                                inode = proc_get_inode(dir->i_sb, ino, de);
                 /*申请一个inode节点,对应的proc_dir_entry节点为de,节点号*/
                 /*为ino。同时把de的数据填入inode */
                                break;
                        }
                }
        }

        if (inode) {
                dentry->d_op = &proc_dentry_operations;
                d_add(dentry, inode);
    /*把dentry放到dentry_hash_table表中然后把inode的I_dentry和dentry的*/
    /*d_alias相连*/
    error = 0;
        }
out:
        return error;
}

   2) proc_root_lookup()
static int proc_root_lookup(struct inode * dir, struct dentry * dentry)
{
        unsigned int pid, c;
        struct task_struct *p;
        const char *name;
        struct inode *inode;
        int len;

        if (dir->i_ino == PROC_ROOT_INO) { /* check for safety... */
                dir->i_nlink = proc_root.nlink;

                read_lock(&tasklist_lock);  /*加读进程列表的锁*/
                for_each_task(p) {
                        if (p->pid)
                                dir->i_nlink++; /*对于每个进程都要把proc_root的link数加1*/
                }
                read_unlock(&tasklist_lock);  /*解读进程列表的锁*/
        }

        if (!proc_lookup(dir, dentry)) /*如果调用proc_lookup成功则返回*/
                return 0;
        /*如果调用proc_lookup不成功,说明要找的是pid部分的*/
        pid = 0;
        name = dentry->d_name.name;
        len = dentry->d_name.len;
        while (len-- > 0) {
                c = *name - '0';
                name++;
                if (c > 9) {
                        pid = 0;
                        break;
                }
                pid *= 10;
                pid += c;
 /*把目录名的字符串转换成整数型的进程号*/
                if (pid & 0xffff0000) {
                        pid = 0;
                        break;
                }
        }
        read_lock(&tasklist_lock);
        p = find_task_by_pid(pid);
        read_unlock(&tasklist_lock);
        inode = NULL;
        if (pid && p) {
                unsigned long ino = (pid << 16) + PROC_PID_INO;
                inode = proc_get_inode(dir->i_sb, ino, &proc_pid);
                if (!inode)
                        return -EINVAL;
                inode->i_flags|=S_IMMUTABLE;
        }

        dentry->d_op = &proc_dentry_operations;
        d_add(dentry, inode);
        return 0;
}

3) proc_readdir()
int proc_readdir(struct file * filp, void * dirent, filldir_t filldir)
{
        struct proc_dir_entry * de;
        unsigned int ino;
        int i;
        struct inode *inode = filp->f_dentry->d_inode;

        if (!inode || !S_ISDIR(inode->i_mode))
                return -ENOTDIR;
        ino = inode->i_ino;
        de = (struct proc_dir_entry *) inode->u.generic_ip;
        if (!de)
                return -EINVAL;
        i = filp->f_pos;
        switch (i) {
                case 0:
                        if (filldir(dirent, ".", 1, i, ino) < 0)
                                return 0;
                        i++;
                        filp->f_pos++;
                        /* fall through */
                case 1:
                        if (filldir(dirent, "..", 2, i, de->parent->low_ino) < 0)
                                return 0;
                        i++;
                        filp->f_pos++;
                        /* fall through */
                default:
                        ino &= ~0xffff;
                        de = de->subdir;
                        i -= 2;
                        for (;;) {
                                if (!de)
                                        return 1;
                                if (!i)
                                        break;
                                de = de->next;
                                i--;
                        }

                        do {
                                if (filldir(dirent, de->name, de->namelen, filp->f_pos, ino | de->low_ino) < 0)
                                        return 0;
                                filp->f_pos++;
                                de = de->next;
                        } while (de);
        }
        return 1;
}


4) get_pid_list()
static int get_pid_list(int index, unsigned int *pids)
{
        struct task_struct *p;
        int nr_pids = 0;

        index -= FIRST_PROCESS_ENTRY;
        read_lock(&tasklist_lock);
        for_each_task(p) {
                int pid = p->pid;
                if (!pid)
                        continue;
                if (--index >= 0)
                        continue;
                pids[nr_pids] = pid;
                nr_pids++;
                if (nr_pids >= PROC_MAXPIDS)
                        break;
        }
        read_unlock(&tasklist_lock);
        return nr_pids;
}


5) proc_root_readdir()
static int proc_root_readdir(struct file * filp,        void * dirent, filldir_t filldir)
{
        unsigned int pid_array[PROC_MAXPIDS];
        char buf[PROC_NUMBUF];
        unsigned int nr = filp->f_pos;
        unsigned int nr_pids, i;

        if (nr < FIRST_PROCESS_ENTRY) {
                int error = proc_readdir(filp, dirent, filldir);
                if (error <= 0)
                        return error;
                filp->f_pos = nr = FIRST_PROCESS_ENTRY;
        }

        nr_pids = get_pid_list(nr, pid_array);

        for (i = 0; i < nr_pids; i++) {
                int pid = pid_array[i];
                ino_t ino = (pid << 16) + PROC_PID_INO;
                unsigned long j = PROC_NUMBUF;

                do {
                        j--;
                        buf[j] = '0' + (pid % 10);
                        pid /= 10;
                } while (pid);

                if (filldir(dirent, buf+j, PROC_NUMBUF-j, filp->f_pos, ino) < 0)
                        break;
                filp->f_pos++;
        }
        return 0;
}


在这里通过inode_operation和file_operation注册的这些函数是在对/PROC下的文件及目录进行open及read操作时才被调用,生成对应的inode,file,dentry等数据结构并取得对应的系统信息反馈

PROC文件系统的挂载过程
FILESYSTEM_SETUP()主要就是调用了一系列的INIT_*_FS()函数(*代表各种不同的文件系统),对PROC文件系统就是INIT_PROC_FS(),在此函数中实例化了一个FILE_SYSTEM_TYPE类型的结构变量PROC_FS_TYPE,其中包括此文件系统的名字和PROC_READ_SUPER函数指针,然后通过REGISTER_FILESYSTEM函数把它挂到FILE_SYSTEMS链表的末尾。
/*  fs/filesystems.c  */
void __init filesystem_setup(void)
{
#ifdef CONFIG_EXT2_FS
        init_ext2_fs();     /*  初始化ext2文件系统  */
#endif
......
#ifdef CONFIG_PROC_FS
        init_proc_fs();     /*  初始化proc文件系统  */
#endif
......
} ;

/*  fs/proc/procfs_syms.c  */
static struct file_system_type proc_fs_type = {
        "proc",
        0 /* FS_NO_DCACHE doesn't work correctly */,
        proc_read_super,    /*针对本文件系统读取super_block的函数指针*/
        NULL } ;
int init_proc_fs(void)
{
        return register_filesystem(&proc_fs_type) == 0;
}

/*   fs/super.c   */
int register_filesystem(struct file_system_type * fs)
{
        struct file_system_type ** tmp;

        if (!fs)
                return -EINVAL;
        if (fs->next)
                return -EBUSY;
        tmp = &file_systems;
        while (*tmp) {
                if (strcmp((*tmp)->name, fs->name) == 0)
                        return -EBUSY;
                tmp = &(*tmp)->next;
        } /*遍历file_systems链表*/
        *tmp = fs;  /*把fs挂到file_systems链表末尾*/
        return 0;
}

在系统启动时如果需要把PROC文件系统挂载上来则要根据PROC_FS_TYPE中注册的PROC_READ_SUPER()函数把SUPER BLOCK读入内存,并加入SUPER_BLOCKS链表。对于一般基于硬设备上的文件系统,READ_SUPER函数的操作就是在内存中创建一个新的空SUPER BLOCK,然后从设备上把SUPER BLOCK读入。但对于PROC文件系统,其READ_SUPER操作的内容有所不同,因为PROC文件系统是不存在于任何设备上的,所以PROC_READ_SUPER函数就是在产生一个新的空SUPER_BLOCK之后在内存中锁住该块后直接对其进行修改了。
/*   fs/proc/inode.c   */
struct super_block *proc_read_super(struct super_block *s,void *data, int silent)
{
        struct inode * root_inode;

        lock_super(s);    /*锁住该super_block*/
        s->s_blocksize = 1024;
        s->s_blocksize_bits = 10;
        s->s_magic = PROC_SUPER_MAGIC;
        s->s_op = &proc_sops;
        root_inode = proc_get_inode(s, PROC_ROOT_INO, &proc_root);
        if (!root_inode)
                goto out_no_root;
        s->s_root = d_alloc_root(root_inode, NULL);
        if (!s->s_root)
                goto out_no_root;
        parse_options(data, &root_inode->i_uid, &root_inode->i_gid);
        unlock_super(s);
        return s;

out_no_root:
        printk("proc_read_super: get root inode failed/n");
        iput(root_inode);
        s->s_dev = 0;
        unlock_super(s);
        return NULL;
}

[目录]


CD_ROM


对CD_ROM的访问操作


分析ide_cd.c下的各个函数的功能,以及和其他函数之间的调用关系。首先是对CD_ROM的读写数据。函数cdrom_in_bytes()是读数据,函数cdrom_out_bytes()是写数据。实现缓冲区与CD_ROM之间的数据交换。这两个函数分别调用了input_ide_data()和output_ide_data()函数。input_ide_data()是通用的从IDE设备读数据的函数,output_ide_data()是通用的往IDE设备写数据的函数。即不仅是访问IDE CD_ROM用到这两个函数,而且访问其他IDE设备如软驱,也用到这两个函数。这两个函数提供了底层的访问IDE设备的功能。
我们知道了用于缓冲区与CD_ROM之间直接进行数据交换的函数,同时在请求管理部分中讲到,文件系统对块设备的访问并非是直接对设备进行的,而是通过缓冲区实现的。于是下面讨论文件系统访问CD_ROM上的文件时,各个层次间函数的调用关系。
首先在前面提到的系统核心初始化过程中,函数hwif_init()为CD_ROM分配了中断号,同时也指定了请求响应的列程。hwif_init()中通过以下语句实现。
//为CD_ROM分配了中断号
                if (!(hwif->irq = default_irqs[h])) {
                        printk("%s: DISABLED, NO IRQ/n", hwif->name);
                        return (hwif->present = 0);
//指定了请求响应的列程
        switch (hwif->major) {
        case IDE0_MAJOR: rfn = &do_ide0_request; break;
#if MAX_HWIFS > 1
        case IDE1_MAJOR: rfn = &do_ide1_request; break;
#endif
#if MAX_HWIFS > 2
        case IDE2_MAJOR: rfn = &do_ide2_request; break;
#endif
#if MAX_HWIFS > 3
        case IDE3_MAJOR: rfn = &do_ide3_request; break;
#endif
        default:
                printk("%s: request_fn NOT DEFINED/n", hwif->name);
                return (hwif->present = 0);
        }                blk_dev[hwif->major].request_fn = rfn;
…….

跟踪函数do_ide*_request(),不难发现对CD_ROM请求的具体实现。各函数之间的关系如图4。下面介绍主要函数的意义:
do_hwgroup_request()//contained in drivers/block/ide.c
do_hwgroup_request()首先屏蔽该设备所有可能发生的中断,避免竞争,然后调用ide_do_request() 。
ide_do_request() //contained in drivers/block/ide.c
函数首先用cli()屏蔽中断标志位。然后调用do_request()。

do_request() //contained in drivers/block/ide.c
do_request()对新的I/O请求做初始化。Do_request()带参数ide_hwif_t *hwif,根据&hwif->drives[unit]->media的不同,进入特定的请求处理例程,当&hwif->drives[unit]->media为ide_cdrom时,进入CD_ROM请求例程ide_do_rw_cdrom。
ide_do_rw_cdrom() //contained in drivers/block/ide_cd.c
本函数定义如下:
void ide_do_rw_cdrom (ide_drive_t *drive, unsigned long block)
{
        struct request *rq = HWGROUP(drive)->rq;

        if (rq -> cmd == PACKET_COMMAND || rq -> cmd == REQUEST_SENSE_COMMAND)
                cdrom_do_packet_command (drive);
        else if (rq -> cmd == RESET_DRIVE_COMMAND) {
                cdrom_end_request (1, drive);
                ide_do_reset (drive);
                return;
        } else if (rq -> cmd != READ) {
                printk ("ide-cd: bad cmd %d/n", rq -> cmd);
                cdrom_end_request (0, drive);
        } else
                cdrom_start_read (drive, block);
}
函数根据请求内容的不同,即rq->cmd的不同,执行相应的驱动函数。当rq->cmd为PACKET_COMMAND或REQUEST_SENSE_COMMAND时,执行cdrom_do_packet_command();当rq->cmd为READ时,执行cdrom_start_read()。在cdrom_do_packet_command()和cdrom_start_read ()中都激发了一个重要的函数:cdrom_transfer_packet_command(),该函数的参数定义如下:
        static int cdrom_transfer_packet_command (ide_drive_t *drive,
                                         char *cmd_buf, int cmd_len,
                                          ide_handler_t *handler)

该函数发一个包命令(packet command)给设备,设备在参数drive中注明,包命令用参数CMD_BUF和CMD_LEN表示。参数HANDLER是中断句柄,当包命令完成时,HANDLER将被调用。在函数cdrom_start_read()中cdrom_transfer_packet_command()被调用的形式如下:
                (void) cdrom_transfer_packet_command (drive, pc.c, sizeof (pc.c),
                                              &cdrom_read_intr);
在函数cdrom_do_packet_command()中cdrom_transfer_packet_command()被调用的形式如下:
        cdrom_transfer_packet_command (drive, pc->c,
                                       sizeof (pc->c), &cdrom_pc_intr);
以cdrom_start_read()为例,探讨系统访问块设备所采取的策略。以下为cdrom_start_read()的伪代码:
/*contained in drivers/block/ide_cd.c
* Start a read request from the CD-ROM.
*/
static void cdrom_start_read (ide_drive_t *drive, unsigned int block)
{
//获取drive的请求数据
        struct request *rq = HWGROUP(drive)->rq;
        int minor = MINOR (rq->rq_dev);
        如果请求是针对一个分区的,则使请求指向分区的绝对地址。
        /* We may be retrying this request after an error.  Fix up
           any weirdness which might be present in the request packet. */
        恢复可能被部分改变的请求结构rq,restore_request (rq);

        根据请求,在缓冲区内确认是否能满足,即先在缓冲区内查找请求所需的数据。如果请求被满足,则结束该请求cdrom_end_request (1, drive),返回;如果没有被满足,则继续。
        if (cdrom_read_from_buffer (drive))
                return;
        如果缓冲区无法满足请求,则将读请求送到设备,当请求完成后,执行相应的中断例程
/* Start sending the read request to the drive. */
        cdrom_start_packet_command (drive, 32768,
                                    cdrom_start_read_continuation);
}


IDE_CD的打开和关闭

打开设备的操作是ide_cdrom_open(),函数的内容很简单,如果是第一次打开,则检测CD_ROM的状态,否则不做任何事情。关闭设备的操作是ide_cdrom_release(),主要的操作是释放与该设备有关的内存空间。
IDE_CD的ioctl操作
IDE CD_ROM的ioctl操作内容较多。通过函数ide_cdrom_ioctl()实现,主要有以下操作:
                                        CDROMEJECT                //弹出
                                        CDROMCLOSETRAY        //关闭托盘
                                        CDROMEJECT_SW
                                        CDROMPAUSE                //暂停
                                        CDROMRESUME
                                        CDROMSTART
                                        CDROMSTOP
                                        CDROMREADTOCHDR
                                        CDROMREADTOCENTRY
                                        CDROMVOLCTRL
                                        CDROMVOLREAD
                                        CDROMMULTISESSION
                                        CDROMREADRAW

 

[目录]


文件页缓冲结构


inode结构定义了操作数据文件的函数表i_fop,它是文件系统提供的面向用户的高级文件IO接口.inode结构还定义了i_mapping指针,用它来描述对文件的IO缓冲.i_mapping->a_ops是文件系统提供的一组低级文件IO函数表,a_ops与块设备接口.在通常情况下,i_fop并不直接与块设备接口,而是间接通过a_ops读写文件.文件的页缓冲(page cache)就是i_fop与a_ops之间的缓冲,它是块设备缓冲之上的更高一级缓冲,直接用于具体文件的读写.

页缓冲用page_hash_table来索引不同文件不同位置上的页块.page_hash_table是页面结构指针(struct page *)组成的数组,它的键由i_mapping地址和文件的页块号组成,i_mapping指向inode结构中的i_data结构,它的值对不同的inode是不同的,它的尺寸分配和dentry_hashtable的分配类似,每4M内存分配1个4K页面,每个页面则1024项.

page_hash(mapping,index)
以mapping:index为键返回page_hash_table中相应槽位的地址;

add_to_page_cache(page,mapping,index)
将page链入以mapping:index为键值的page_hash_table中;

add_to_page_cache_unique(page,mapping,index,hash)
在槽位hash上唯一地添加以mapping:index表示的页page;

__find_page_nolock(mapping,index,page)
在page_hash_table中查询以mapping:index为键的page;

remove_page_from_hash_queue(page)
将page从page_hash_table中删除;

 

typedef struct page {
        struct list_head list;
        struct address_space *mapping; 为inode->i_mapping的值
        unsigned long index; 文件的页块号
        struct page *next_hash; 用以形成hash链
        atomic_t count; 引用计数
        unsigned long flags;
        struct list_head lru;
        unsigned long age;
        wait_queue_head_t wait;
        struct page **pprev_hash; 指向hash链中前一页next_hash的地址
        struct buffer_head * buffers;
        void *virtual;
        struct zone_struct *zone;
} mem_map_t;
struct address_space {
        struct list_head        clean_pages; 加入page_hash_table后,与page->list相环接
        struct list_head        dirty_pages;
        struct list_head        locked_pages;
        unsigned long                nrpages; 表示该inode具有的文件缓冲页数量
        struct address_space_operations *a_ops;
        struct inode                *host;
        struct vm_area_struct        *i_mmap;
        struct vm_area_struct        *i_mmap_shared;
        spinlock_t                i_shared_lock;
};
struct address_space_operations {
        int (*writepage)(struct page *);
        int (*readpage)(struct file *, struct page *);
        int (*sync_page)(struct page *);
        int (*prepare_write)(struct file *, struct page *, unsigned, unsigned);
        int (*commit_write)(struct file *, struct page *, unsigned, unsigned);
        int (*bmap)(struct address_space *, long);
};

#define page_hash(mapping,index) (page_hash_table+_page_hashfn(mapping,index))

atomic_t page_cache_size = ATOMIC_INIT(0);
unsigned int page_hash_bits;
struct page **page_hash_table;
extern inline unsigned long _page_hashfn(struct address_space * mapping, unsigned long index)
{
#define i (((unsigned long) mapping)/(sizeof(struct inode)  ~ (sizeof(struct inode) - 1)))
#define s(x) ((x)+((x)>>PAGE_HASH_BITS))
        return s(i+index)  (PAGE_HASH_SIZE-1);
#undef i
#undef s
}

void add_to_page_cache(struct page * page, struct address_space * mapping, unsigned long offset)
{
        spin_lock(
        __add_to_page_cache(page, mapping, offset, page_hash(mapping, offset));
        spin_unlock(
}
static inline void __add_to_page_cache(struct page * page,
        struct address_space *mapping, unsigned long offset,
        struct page **hash)
{
        unsigned long flags;

        if (PageLocked(page))
                BUG();

        flags = page->flags  ~((1         page->flags = flags | (1         page_cache_get(page); 增加引用计数
        page->index = offset;
        add_page_to_inode_queue(mapping, page); 将page->list与inode->i_mapping->clean_pages相环接
        add_page_to_hash_queue(page, hash); 将page加入hash槽位
        lru_cache_add(page); 与active_list相环接
}
static inline void add_page_to_inode_queue(struct address_space *mapping, struct page * page)
{
        struct list_head *head =

        mapping->nrpages++;
        list_add( head);
        page->mapping = mapping; 让page->mapping指向inode->i_mapping
}
static void add_page_to_hash_queue(struct page * page, struct page **p)
{
        struct page *next = *p;

        *p = page;
        page->next_hash = next;
        page->pprev_hash = p;
        if (next)
                next->pprev_hash =
        if (page->buffers)
                PAGE_BUG(page);
        atomic_inc(
}
static inline struct page * __find_page_nolock(struct address_space *mapping, unsigned long offset, struct page *page)
{
        goto inside;

        for (;;) {
                page = page->next_hash;
inside:
                if (!page)
                        goto not_found;
                if (page->mapping != mapping)
                        continue;
                if (page->index == offset)
                        break;
        }
        /*
        * Touching the page may move it to the active list.
        * If we end up with too few inactive pages, we wake
        * up kswapd.
        */
        age_page_up(page);
        if (inactive_shortage() > inactive_target / 2  free_shortage())
                        wakeup_kswapd();
not_found:
        return page;
}
void add_to_page_cache_locked(struct page * page, struct address_space *mapping, unsigned long index)
{
        if (!PageLocked(page))
                BUG();

        page_cache_get(page);
        spin_lock(
        page->index = index;
        add_page_to_inode_queue(mapping, page);
        add_page_to_hash_queue(page, page_hash(mapping, index));
        lru_cache_add(page);
        spin_unlock(
}
void add_to_page_cache(struct page * page, struct address_space * mapping, unsigned long offset)
{
        spin_lock(
        __add_to_page_cache(page, mapping, offset, page_hash(mapping, offset));
        spin_unlock(
}


static int add_to_page_cache_unique(struct page * page,
        struct address_space *mapping, unsigned long offset,
        struct page **hash)
{
        int err;
        struct page *alias;

        spin_lock(
        alias = __find_page_nolock(mapping, offset, *hash);

        err = 1;
        if (!alias) {
                __add_to_page_cache(page,mapping,offset,hash);
                err = 0;
        }

        spin_unlock(
        return err;
}

static inline void remove_page_from_hash_queue(struct page * page)
{
        struct page *next = page->next_hash;
        struct page **pprev = page->pprev_hash;

        if (next)
                next->pprev_hash = pprev;
        *pprev = next;
        page->pprev_hash = NULL;
        atomic_dec(
}

static inline void remove_page_from_inode_queue(struct page * page)
{
        struct address_space * mapping = page->mapping;

        mapping->nrpages--;
        list_del(
        page->mapping = NULL;
}

void remove_inode_page(struct page *page)
{
        if (!PageLocked(page))
                PAGE_BUG(page);

        spin_lock(
        __remove_inode_page(page);
        spin_unlock(
}
/*
* Remove a page from the page cache and free it. Caller has to make
* sure the page is locked and that nobody else uses it - or that usage
* is safe.
*/
void __remove_inode_page(struct page *page)
{
        if (PageDirty(page)) BUG();
        remove_page_from_inode_queue(page);
        remove_page_from_hash_queue(page);
        page->mapping = NULL;
}


void __init page_cache_init(unsigned long mempages)
{
        unsigned long htable_size, order;

        htable_size = mempages;
        htable_size *= sizeof(struct page *);
        for(order = 0; (PAGE_SIZE                 ;

        do {
                unsigned long tmp = (PAGE_SIZE
                page_hash_bits = 0;
                while((tmp >>= 1UL) != 0UL)
                        page_hash_bits++;

                page_hash_table = (struct page **)
                        __get_free_pages(GFP_ATOMIC, order);
        } while(page_hash_table == NULL  --order > 0);

        printk("Page-cache hash table entries: %d (order: %ld, %ld bytes)/n",
               (1         if (!page_hash_table)
                panic("Failed to allocate page hash table/n");
        memset((void *)page_hash_table, 0, PAGE_HASH_SIZE * sizeof(struct page *));
}

 

 

[目录]


块设备缓冲区结构


块设备缓冲区用buffer_head结构描述,系统中有NR_SIZES种不同尺寸的缓冲区,每种缓冲区的尺寸为512
grow_buffers(blocksize);
在free_list[]上扩建一页块长为blocksize的备用缓冲区;

bh = create_buffers(page,blocksize,async);
创建块长为blocksize的buffer_head结构来描述页面page.

create_empty_buffers(page,dev,blocksize);
创建块长为blocksize,块设备为dev的buffer_head结构来描述页面page

bh = get_unused_buffer_head(async);
取备用的buffer_head结构,async=1允许进程暂时睡眠.

 

struct buffer_head {
        struct buffer_head *b_next; 用于缓冲块索引的散列链
        unsigned long b_blocknr; 该缓冲区在块设备上的块号
        unsigned short b_size; 该缓冲区数据块尺寸
        unsigned short b_list; 在lru_list[]中的序号,表示该缓冲区的使用状态.
        kdev_t b_dev; 缓冲区所属的逻辑块设备

        atomic_t b_count;        引用计数
        kdev_t b_rdev; 所属的物理块设备
        unsigned long b_state;
        unsigned long b_flushtime;

        struct buffer_head *b_next_free; 指向下一备用缓冲块
        struct buffer_head *b_prev_free; 指向前一备用缓冲块
        struct buffer_head *b_this_page; 指向同一页面的缓冲块,形成环形链表
        struct buffer_head *b_reqnext; 用于块设备驱动程序

        struct buffer_head **b_pprev;        用于缓冲块散列链
        char * b_data;        指向缓冲块的数据区
        struct page *b_page; 缓冲块的数据区所在的页面
        void (*b_end_io)(struct buffer_head *bh, int uptodate);
        void *b_private;

        unsigned long b_rsector;
        wait_queue_head_t b_wait;

        struct inode *             b_inode;
        struct list_head     b_inode_buffers;
};

#define NR_SIZES 7

; 这是一张以2为底的简易对数表,用于块长度到free_list[]索引的转换
static char buffersize_index[65] =
{-1,  0,  1, -1,  2, -1, -1, -1, 3, -1, -1, -1, -1, -1, -1, -1,
  4, -1, -1, -1, -1, -1, -1, -1, -1,-1, -1, -1, -1, -1, -1, -1,
  5, -1, -1, -1, -1, -1, -1, -1, -1,-1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,-1, -1, -1, -1, -1, -1, -1,
  6};

#define BUFSIZE_INDEX(X) ((int) buffersize_index[(X)>>9])
#define MAX_BUF_PER_PAGE (PAGE_CACHE_SIZE / 512) 每页最多的缓冲块数(8)
#define NR_RESERVED (2*MAX_BUF_PER_PAGE)
#define MAX_UNUSED_BUFFERS NR_RESERVED+20 /* don't ever have more than this
                                             number of unused buffer heads */

static struct buffer_head *lru_list[NR_LIST];
static int nr_buffers_type[NR_LIST]; 每种尺寸缓冲块的数量
static unsigned long size_buffers_type[NR_LIST]; 每种尺寸缓冲区的字节总数

static struct buffer_head * unused_list;
static int nr_unused_buffer_heads;

struct bh_free_head {
        struct buffer_head *list;
        spinlock_t lock;
};
static struct bh_free_head free_list[NR_SIZES];

static int grow_buffers(int size)
{
        struct page * page;
        struct buffer_head *bh, *tmp;
        struct buffer_head * insert_point;
        int isize;

        if ((size  511) || (size > PAGE_SIZE)) {
                printk("VFS: grow_buffers: size = %d/n",size);
                return 0;
        }

        page = alloc_page(GFP_BUFFER);
        if (!page)
                goto out;
        LockPage(page);
        bh = create_buffers(page, size, 0);
        if (!bh)
                goto no_buffer_head;

        isize = BUFSIZE_INDEX(size);

        spin_lock(
        insert_point = free_list[isize].list;
        tmp = bh;
        while (1) { 将页中的每一块缓冲区插入free_list[isize].list
                if (insert_point) {
                        tmp->b_next_free = insert_point->b_next_free;
                        tmp->b_prev_free = insert_point;
                        insert_point->b_next_free->b_prev_free = tmp;
                        insert_point->b_next_free = tmp;
                } else {
                        tmp->b_prev_free = tmp;
                        tmp->b_next_free = tmp;
                }
                insert_point = tmp;
                if (tmp->b_this_page)
                        tmp = tmp->b_this_page;
                else
                        break;
        }
        tmp->b_this_page = bh; 形成单向环形链表
        free_list[isize].list = bh;
        spin_unlock(

        page->buffers = bh; 表示该页与块设备缓冲区相关联
        page->flags  ~(1         lru_cache_add(page); 将该页加入页面LRU链表
        UnlockPage(page);
        atomic_inc(
        return 1;

no_buffer_head:
        UnlockPage(page);
        page_cache_release(page); 释放alloc_page()分配的页面
out:
        return 0;
}
static struct buffer_head * create_buffers(struct page * page, unsigned long size, int async)
{
        struct buffer_head *bh, *head;
        long offset;

try_again:
        head = NULL;
        offset = PAGE_SIZE;
        while ((offset -= size) >= 0) { 从页面的高端向低端分配地址
                bh = get_unused_buffer_head(async);
                if (!bh)
                        goto no_grow;

                bh->b_dev = B_FREE;  /* Flag as unused */
                bh->b_this_page = head;
                head = bh;

                bh->b_state = 0;
                bh->b_next_free = NULL;
                bh->b_pprev = NULL;
                atomic_set( 0);
                bh->b_size = size;

                set_bh_page(bh, page, offset);

                bh->b_list = BUF_CLEAN;
                bh->b_end_io = NULL;
        }
        return head;
/*
* In case anything failed, we just free everything we got.
*/
no_grow:
        if (head) { 如果在分配中途失败,则撤消已有分配
                spin_lock(
                do {
                        bh = head;
                        head = head->b_this_page;
                        __put_unused_buffer_head(bh);
                } while (head);
                spin_unlock(

                /* Wake up any waiters ... */
                wake_up( 唤醒下文因wait_event()而睡眠的那些进程
        }

        /*
        * Return failure for non-async IO requests.  Async IO requests
        * are not allowed to fail, so we have to wait until buffer heads
        * become available.  But we don't want tasks sleeping with
        * partially complete buffers, so all were released above.
        */
        if (!async)
                return NULL;

        /* We're _really_ low on memory. Now we just
        * wait for old buffer heads to become free due to
        * finishing IO.  Since this is an async request and
        * the reserve list is empty, we're sure there are
        * async buffer heads in use.
        */
        run_task_queue(

        /*
        * Set our state for sleeping, then check again for buffer heads.
        * This ensures we won't miss a wake_up from an interrupt.
        */
        wait_event(buffer_wait, nr_unused_buffer_heads >= MAX_BUF_PER_PAGE);
        ; 如果nr_unused_buffer_heads >= MAX_BUF_PER_PAGE 则wait_event返回,否则睡眠
        goto try_again;
}
static struct buffer_head * get_unused_buffer_head(int async)
{
        struct buffer_head * bh;

        spin_lock(
        if (nr_unused_buffer_heads > NR_RESERVED) {
                bh = unused_list;
                unused_list = bh->b_next_free;
                nr_unused_buffer_heads--;
                spin_unlock(
                return bh;
        }
        spin_unlock(

        /* This is critical.  We can't swap out pages to get
        * more buffer heads, because the swap-out may need
        * more buffer-heads itself.  Thus SLAB_BUFFER.
        */
        if((bh = kmem_cache_alloc(bh_cachep, SLAB_BUFFER)) != NULL) {
                memset(bh, 0, sizeof(*bh));
                init_waitqueue_head(
                return bh;
        }

        /*
        * If we need an async buffer, use the reserved buffer heads.
        */
        if (async) {
                spin_lock(
                if (unused_list) {
                        bh = unused_list;
                        unused_list = bh->b_next_free;
                        nr_unused_buffer_heads--;
                        spin_unlock(
                        return bh;
                }
                spin_unlock(
        }
#if 0
        /*
        * (Pending further analysis ...)
        * Ordinary (non-async) requests can use a different memory priority
        * to free up pages. Any swapping thus generated will use async
        * buffer heads.
        */
        if(!async
           (bh = kmem_cache_alloc(bh_cachep, SLAB_KERNEL)) != NULL) {
                memset(bh, 0, sizeof(*bh));
                init_waitqueue_head(
                return bh;
        }
#endif

        return NULL;
}
static void create_empty_buffers(struct page *page, kdev_t dev, unsigned long blocksize)
{
        struct buffer_head *bh, *head, *tail;

        head = create_buffers(page, blocksize, 1);
        if (page->buffers)
                BUG();

        bh = head;
        do {
                bh->b_dev = dev;
                bh->b_blocknr = 0;
                bh->b_end_io = NULL;
                tail = bh;
                bh = bh->b_this_page;
        } while (bh);
        tail->b_this_page = head;
        page->buffers = head;
        page_cache_get(page);
}
void set_bh_page (struct buffer_head *bh, struct page *page, unsigned long offset)
{
        bh->b_page = page;
        if (offset >= PAGE_SIZE)
                BUG();
        if (PageHighMem(page))
                /*
                * This catches illegal uses and preserves the offset:
                */
                bh->b_data = (char *)(0 + offset);
        else
                bh->b_data = page_address(page) + offset;
}
static __inline__ void __put_unused_buffer_head(struct buffer_head * bh)
{
        if (bh->b_inode)
                BUG();
        if (nr_unused_buffer_heads >= MAX_UNUSED_BUFFERS) {
                kmem_cache_free(bh_cachep, bh);
        } else {
                bh->b_blocknr = -1;
                init_waitqueue_head(
                nr_unused_buffer_heads++;
                bh->b_next_free = unused_list;
                bh->b_this_page = NULL;
                unused_list = bh;
        }
}

 

 

[目录]


散列算法


系统在解析路径时,使用dentry_hashtable来缓冲每一节路径名对应的dentry目录项;
dentry_hashtable是由list_head组成的数组,它们与dentry->d_hash相环接,形成短链,散列表中的dentry将均分布于这些短链上;
散列表的索引确定于父目录项地址和目录名的hash值;
dentry_hashtable的尺寸由系统内存大小分配,每4M内存分配一个页面,每个页面具有512项索引;
d_hash(dentry,hash)为散列函数,它将dentry地址和hash值相组合,映射到dentry_hashtable表中,返回相应的散列链;
d_rehash(dentry)将dentry加入散列表;
d_drop(dentry)将dentry从散列表中删除;
d_lookup(dentry,qstr)在散列中找出以dentry作为父目录项,名称为qstr的目录项.

系统用下面的方法计算某节路径名的hash值:

 

        unsigned long hash;

        struct qstr this;

        unsigned int c;

 

        hash = init_name_hash();

        do {

                name++;

                hash = partial_name_hash(c, hash);

                c = *(const unsigned char *)name;

        } while (c  (c != '/'));

 

        this.len = name - (const char *) this.name;

        this.hash = end_name_hash(hash);

        ...

 

有关的代码如下:

static unsigned int d_hash_mask;

static unsigned int d_hash_shift;

static struct list_head *dentry_hashtable;

 

#define init_name_hash() 0

 

static __inline__ unsigned long partial_name_hash(unsigned long c, unsigned long prevhash)

{

        prevhash = (prevhash > (8*sizeof(unsigned long)-4));

        return prevhash ^ c;

}

 

/* Finally: cut down the number of bits to a int value (and try to avoid losing bits) */

static __inline__ unsigned long end_name_hash(unsigned long hash)

{

        if (sizeof(hash) > sizeof(unsigned int))

                hash += hash >> 4*sizeof(hash);

        return (unsigned int) hash;

}

#define D_HASHBITS     d_hash_shift

#define D_HASHMASK     d_hash_mask

static inline struct list_head * d_hash(struct dentry * parent, unsigned long hash)

{

        hash += (unsigned long) parent / L1_CACHE_BYTES;

        hash = hash ^ (hash >> D_HASHBITS) ^ (hash >> D_HASHBITS*2);

        return dentry_hashtable + (hash  D_HASHMASK);

}

void d_rehash(struct dentry * entry)

{

        struct list_head *list = d_hash(entry->d_parent, entry->d_name.hash);

        spin_lock(

        list_add( list);

        spin_unlock(

}

static __inline__ void d_drop(struct dentry * dentry)

{

        spin_lock(

        list_del(

        INIT_LIST_HEAD(

        spin_unlock(

}

struct dentry * d_lookup(struct dentry * parent, struct qstr * name)

{

        unsigned int len = name->len;

        unsigned int hash = name->hash;

        const unsigned char *str = name->name;

        struct list_head *head = d_hash(parent,hash);

        struct list_head *tmp;

 

        spin_lock(

        tmp = head->next;

        for (;;) {

                struct dentry * dentry = list_entry(tmp, struct dentry, d_hash);

                if (tmp == head)

                        break;

                tmp = tmp->next;

                if (dentry->d_name.hash != hash)

                        continue;

                if (dentry->d_parent != parent)

                        continue;

                if (parent->d_op  parent->d_op->d_compare) {

                        ; 如果文件系统提供了目录名比较的方法

                        if (parent->d_op->d_compare(parent,  name))

                                continue;

                } else {

                        if (dentry->d_name.len != len)

                                continue;

                        if (memcmp(dentry->d_name.name, str, len))

                                continue;

                }

                __dget_locked(dentry); 增加dentry的引用计数

                dentry->d_flags |= DCACHE_REFERENCED;

                spin_unlock(

                return dentry;

        }

        spin_unlock(

        return NULL;

}

static void __init dcache_init(unsigned long mempages)

{

        struct list_head *d;

        unsigned long order;

        unsigned int nr_hash;

        int i;

 

        /*

        * A constructor could be added for stable state like the lists,

        * but it is probably not worth it because of the cache nature

        * of the dcache.

        * If fragmentation is too bad then the SLAB_HWCACHE_ALIGN

        * flag could be removed here, to hint to the allocator that

        * it should not try to get multiple page regions.

        */

        dentry_cache = kmem_cache_create("dentry_cache",

                                        sizeof(struct dentry),

                                        0,

                                        SLAB_HWCACHE_ALIGN,

                                        NULL, NULL);

        if (!dentry_cache)

                panic("Cannot create dentry cache");

 

#if PAGE_SHIFT         mempages >>= (13 - PAGE_SHIFT);

#endif

        mempages *= sizeof(struct list_head);

        for (order = 0; ((1UL

        do {

                unsigned long tmp;

 

                nr_hash = (1UL                         sizeof(struct list_head);

                d_hash_mask = (nr_hash - 1);

 

                tmp = nr_hash;

                d_hash_shift = 0;

                while ((tmp >>= 1UL) != 0UL)

                        d_hash_shift++;

 

                dentry_hashtable = (struct list_head *)

                        __get_free_pages(GFP_ATOMIC, order);

        } while (dentry_hashtable == NULL  --order >= 0);

        ; 如果order太大,超过了__get_free_pages最大可分配尺寸,则减小order的值重试.

 

        printk("Dentry-cache hash table entries: %d (order: %ld, %ld bytes)/n",

                        nr_hash, order, (PAGE_SIZE

        if (!dentry_hashtable)

                panic("Failed to allocate dcache hash table/n");

 

        d = dentry_hashtable;

        i = nr_hash;

        do {

                INIT_LIST_HEAD(d);

                d++;

                i--;

        } while (i);

}

对opera的注释加点解释,读起来可能会更省力些。

1.为什么要用这个算法

  例如要构造一个文件 /usr/local/cross/my_comp
  这时要沿着上面这个文件名开始依次找直到cross的数据结构,也就是要找到

  /usr/
  /usr/local/
  /usr/local/cross/
  对应的数据结构dentry

  假定我们已经找到/usr/对应的dentry, 现在必须能够从local找到它对应的dentry,这时就要从名字---->dentry的快速映射,在Linux中一般用哈希映射。

2. 查找方法

  首先,通过d_hash粗分类,找到"local"所在的链表,然后顺序向下一一匹配。


3.一些操作如opera所述

4.初始化

  首先通过__get_free_pages获得一些页面,这些页面构成了所有链表头数组。

[目录]


permission(inode,mask)


permission(inode,mask)用来测试对文件(inode)是否有(mask)访问权.

 


; fs/namei.c

int permission(struct inode * inode,int mask)

{

        if (inode->i_op  inode->i_op->permission) {

                ; 如果文件系统定义了自已的授权算法

                int retval;

                lock_kernel();

                retval = inode->i_op->permission(inode, mask);

                unlock_kernel();

                return retval;

        }

        return vfs_permission(inode, mask); 缺省的授权算法

}

int vfs_permission(struct inode * inode,int mask)

{

        int mode = inode->i_mode;

 

        ; 如果对只读文件系统中的普通文件,目录文件,符号链接请求写访问

        if ((mask  S_IWOTH)  IS_RDONLY(inode)

                (S_ISREG(mode) || S_ISDIR(mode) || S_ISLNK(mode)))

                return -EROFS; /* Nobody gets write access to a read-only fs */

        ; 如果对免疫文件请求写访问

        if ((mask  S_IWOTH)  IS_IMMUTABLE(inode))

                return -EACCES; /* Nobody gets write access to an immutable file */

        if (current->fsuid == inode->i_uid)

                mode >>= 6; 如果自已是文件的拥有者,取文件对拥有者的访问权

        else if (in_group_p(inode->i_gid))

                mode >>= 3; 如果自已是文件所在组的成员,取文件对组成员的访问权

        ; 如果所请求的权限是实际对文件权限的子集或者被赋予了超越特权,则允许访问

        if (((mode  mask  S_IRWXO) == mask) || capable(CAP_DAC_OVERRIDE))

                return 0;

 

        ; 虽然自已对文件没有访问权限,但如果自已被赋予了读和检索的特权,

        ; 则允许读或检索目录.

        /* read and search access */

        if ((mask == S_IROTH) ||

            (S_ISDIR(inode->i_mode)   !(mask  ~(S_IROTH | S_IXOTH))))

                if (capable(CAP_DAC_READ_SEARCH))

                        return 0;

 

        return -EACCES;

}

 

; kernel/sys.c

/*

* Check whether we're fsgid/egid or in the supplemental group..

*/

int in_group_p(gid_t grp)

{

        int retval = 1;

        if (grp != current->fsgid)

                retval = supplemental_group_member(grp);

        return retval;

}

static int supplemental_group_member(gid_t grp)

{

        int i = current->ngroups;

 

        if (i) {

                gid_t *groups = current->groups;

                do {

                        if (*groups == grp)

                                return 1;

                        groups++;

                        i--;

                } while (i);

        }

        return 0;

}

 

 

 

[目录]


IDE硬盘驱动器读写


Linux内核在缺省配置下最多支持10个IDE接口,IDE接口用ide_hwif_t结构来描述,每个IDE接口具有一对主-从驱动器接口,它们用ide_drive_t结构来描述,每个驱动器接口可接不同种类的IDE设备,如IDE硬盘,光驱等,它们用ide_driver_t结构来描述.
每个驱动器接口包含一个命令请求队列,用request_queue_t结构来描述,具体的请求用request结构来描述.

多个IDE驱动器可以共享一个中断,共享同一中断的驱动器形成一个组,用ide_hwgroup_t结构来描述.ide_intr()是所有的ide驱动器所共用的硬件中断入口,对之对应的ide_hwgroup_t指针将作为dev_id传递给ide_intr.

每次在读写某个驱动器之前,需要用ide_set_handler()来设置ide_intr将要调用的中断函数指针.中断产生以后,该函数指针被自动清除.

do_rw_disk(drive,rq,block) 从逻辑扇区号block开始向IDE硬盘驱动器drive写入rq所描述的内容.

以下是硬盘PIO传输模式的有关代码.


; drivers/ide/ide-disk.c
static ide_startstop_t do_rw_disk (ide_drive_t *drive, struct request *rq, unsigned long block)
{
        if (IDE_CONTROL_REG)
                OUT_BYTE(drive->ctl,IDE_CONTROL_REG);
        OUT_BYTE(rq->nr_sectors,IDE_NSECTOR_REG);
        if (drive->select.b.lba) { 如果是逻辑块寻址模式
                OUT_BYTE(block,IDE_SECTOR_REG);
                OUT_BYTE(block>>=8,IDE_LCYL_REG);
                OUT_BYTE(block>>=8,IDE_HCYL_REG);
                OUT_BYTE(((block>>8)
        } else {
                unsigned int sect,head,cyl,track;
                track = block / drive->sect;
                sect  = block % drive->sect + 1;
                OUT_BYTE(sect,IDE_SECTOR_REG);
                head  = track % drive->head;
                cyl   = track / drive->head;
                OUT_BYTE(cyl,IDE_LCYL_REG);
                OUT_BYTE(cyl>>8,IDE_HCYL_REG);
                OUT_BYTE(head|drive->select.all,IDE_SELECT_REG);
        }
        if (rq->cmd == READ) {{
                ide_set_handler(drive,  WAIT_CMD, NULL); WAIT_CMD为10秒超时
                OUT_BYTE(drive->mult_count ? WIN_MULTREAD : WIN_READ, IDE_COMMAND_REG);
                return ide_started;
        }
        if (rq->cmd == WRITE) {
                ide_startstop_t startstop;
                OUT_BYTE(drive->mult_count ? WIN_MULTWRITE : WIN_WRITE, IDE_COMMAND_REG);
                if (ide_wait_stat( drive, DATA_READY, drive->bad_wstat, WAIT_DRQ)) {
                        printk(KERN_ERR "%s: no DRQ after issuing %s/n", drive->name,
                                drive->mult_count ? "MULTWRITE" : "WRITE");
                        return startstop;
                }
                if (!drive->unmask)
                        __cli();        /* local CPU only */
                if (drive->mult_count) { 如果允许多扇区传送
                        ide_hwgroup_t *hwgroup = HWGROUP(drive);
                        /*
                        * Ugh.. this part looks ugly because we MUST set up
                        * the interrupt handler before outputting the first block
                        * of data to be written.  If we hit an error (corrupted buffer list)
                        * in ide_multwrite(), then we need to remove the handler/timer
                        * before returning.  Fortunately, this NEVER happens (right?).
                        *
                        * Except when you get an error it seems...
                        */
                        hwgroup->wrq = *rq; /* scratchpad */
                        ide_set_handler (drive,  WAIT_CMD, NULL);
                        if (ide_multwrite(drive, drive->mult_count)) {
                                unsigned long flags;
                                spin_lock_irqsave( flags);
                                hwgroup->handler = NULL;
                                del_timer(
                                spin_unlock_irqrestore( flags);
                                return ide_stopped;
                        }
                } else {
                        ide_set_handler (drive,  WAIT_CMD, NULL);
                        idedisk_output_data(drive, rq->buffer, SECTOR_WORDS); 写入一扇区SECTOR_WORDS=512/4
                }
                return ide_started;
        }
        printk(KERN_ERR "%s: bad command: %d/n", drive->name, rq->cmd);
        ide_end_request(0, HWGROUP(drive));
        return ide_stopped;
}
void ide_set_handler (ide_drive_t *drive, ide_handler_t *handler,
                      unsigned int timeout, ide_expiry_t *expiry)
{
        unsigned long flags;
        ide_hwgroup_t *hwgroup = HWGROUP(drive);

        spin_lock_irqsave( flags);
        if (hwgroup->handler != NULL) {
                printk("%s: ide_set_handler: handler not null; old=%p, new=%p/n",
                        drive->name, hwgroup->handler, handler);
        }
        hwgroup->handler        = handler;
        hwgroup->expiry                = expiry;
        hwgroup->timer.expires        = jiffies + timeout;
        add_timer(
        spin_unlock_irqrestore( flags);
}
static inline void idedisk_output_data (ide_drive_t *drive, void *buffer, unsigned int wcount)
{
        if (drive->bswap) {
                idedisk_bswap_data(buffer, wcount);
                ide_output_data(drive, buffer, wcount);
                idedisk_bswap_data(buffer, wcount);
        } else
                ide_output_data(drive, buffer, wcount);
}
void ide_output_data (ide_drive_t *drive, void *buffer, unsigned int wcount)
{
        byte io_32bit = drive->io_32bit;

        if (io_32bit) {
#if SUPPORT_VLB_SYNC
                if (io_32bit  2) {
                        unsigned long flags;
                        __save_flags(flags);        /* local CPU only */
                        __cli();                /* local CPU only */
                        do_vlb_sync(IDE_NSECTOR_REG);
                        outsl(IDE_DATA_REG, buffer, wcount);
                        __restore_flags(flags);        /* local CPU only */
                } else
#endif /* SUPPORT_VLB_SYNC */
                        outsl(IDE_DATA_REG, buffer, wcount);
        } else {
#if SUPPORT_SLOW_DATA_PORTS
                if (drive->slow) {
                        unsigned short *ptr = (unsigned short *) buffer;
                        while (wcount--) {
                                outw_p(*ptr++, IDE_DATA_REG);
                                outw_p(*ptr++, IDE_DATA_REG);
                        }
                } else
#endif /* SUPPORT_SLOW_DATA_PORTS */
                        outsw(IDE_DATA_REG, buffer, wcount        }
}
int ide_multwrite (ide_drive_t *drive, unsigned int mcount)
{
        ide_hwgroup_t        *hwgroup= HWGROUP(drive);

        /*
        *        This may look a bit odd, but remember wrq is a copy of the
        *        request not the original. The pointers are real however so the
        *        bh's are not copies. Remember that or bad stuff will happen
        *
        *        At the point we are called the drive has asked us for the
        *        data, and its our job to feed it, walking across bh boundaries
        *        if need be.
        */

        struct request        *rq =

          do {
                unsigned long flags;
                  unsigned int nsect = rq->current_nr_sectors;
                if (nsect > mcount)
                        nsect = mcount;
                mcount -= nsect;
                ; 这时mcount为剩余的必需传送的扇区数
                idedisk_output_data(drive, rq->buffer, nsect                spin_lock_irqsave( flags);        /* Is this really necessary? */
#ifdef CONFIG_BLK_DEV_PDC4030
                rq->sector += nsect;
#endif
                if (((long)(rq->nr_sectors -= nsect))                         spin_unlock_irqrestore( flags);
                        break;
                }
                if ((rq->current_nr_sectors -= nsect) == 0) {
                        if ((rq->bh = rq->bh->b_reqnext) != NULL) {{
                                rq->current_nr_sectors = rq->bh->b_size>>9;
                                rq->buffer             = rq->bh->b_data;
                        } else {
                                spin_unlock_irqrestore( flags);
                                printk("%s: buffer list corrupted (%ld, %ld, %d)/n",
                                        drive->name, rq->current_nr_sectors,
                                        rq->nr_sectors, nsect);
                                ide_end_request(0, hwgroup);
                                return 1;
                        }
                } else {
                        /* Fix the pointer.. we ate data */
                        rq->buffer += nsect                 }
                spin_unlock_irqrestore( flags);
        } while (mcount);
        return 0;
}

; IDE接口共用中断入口
void ide_intr (int irq, void *dev_id, struct pt_regs *regs)
{
        unsigned long flags;
        ide_hwgroup_t *hwgroup = (ide_hwgroup_t *)dev_id;
        ide_hwif_t *hwif;
        ide_drive_t *drive;
        ide_handler_t *handler;
        ide_startstop_t startstop;

        spin_lock_irqsave( flags);
        hwif = hwgroup->hwif;

        if (!ide_ack_intr(hwif)) {
                spin_unlock_irqrestore( flags);
                return;
        }

        if ((handler = hwgroup->handler) == NULL || hwgroup->poll_timeout != 0) {
                /*
                * Not expecting an interrupt from this drive.
                * That means this could be:
                *        (1) an interrupt from another PCI device
                *        sharing the same PCI INT# as us.
                * or        (2) a drive just entered sleep or standby mode,
                *        and is interrupting to let us know.
                * or        (3) a spurious interrupt of unknown origin.
                *
                * For PCI, we cannot tell the difference,
                * so in that case we just ignore it and hope it goes away.
                */
#ifdef CONFIG_BLK_DEV_IDEPCI
                if (IDE_PCI_DEVID_EQ(hwif->pci_devid, IDE_PCI_DEVID_NULL))
#endif        /* CONFIG_BLK_DEV_IDEPCI */
                {
                        /*
                        * Probably not a shared PCI interrupt,
                        * so we can safely try to do something about it:
                        */
                        unexpected_intr(irq, hwgroup);
#ifdef CONFIG_BLK_DEV_IDEPCI
                } else {
                        /*
                        * Whack the status register, just in case we have a leftover pending IRQ.
                        */
                        (void) IN_BYTE(hwif->io_ports[IDE_STATUS_OFFSET]);
#endif /* CONFIG_BLK_DEV_IDEPCI */
                }
                spin_unlock_irqrestore( flags);
                return;
        }
        drive = hwgroup->drive;
        if (!drive) {
                /*
                * This should NEVER happen, and there isn't much we could do about it here.
                */
                spin_unlock_irqrestore( flags);
                return;
        }
        if (!drive_is_ready(drive)) {
                /*
                * This happens regularly when we share a PCI IRQ with another device.
                * Unfortunately, it can also happen with some buggy drives that trigger
                * the IRQ before their status register is up to date.  Hopefully we have
                * enough advance overhead that the latter isn't a problem.
                */
                spin_unlock_irqrestore( flags);
                return;
        }
        if (!hwgroup->busy) {
                hwgroup->busy = 1;        /* paranoia */
                printk("%s: ide_intr: hwgroup->busy was 0 ??/n", drive->name);
        }
        hwgroup->handler = NULL;
        del_timer(
        spin_unlock(

        if (drive->unmask)
                ide__sti();        /* local CPU only */
        startstop = handler(drive);                /* service this interrupt, may set handler for next interrupt */
        spin_lock_irq(

        /*
        * Note that handler() may have set things up for another
        * interrupt to occur soon, but it cannot happen until
        * we exit from this routine, because it will be the
        * same irq as is currently being serviced here, and Linux
        * won't allow another of the same (on any CPU) until we return.
        */
        set_recovery_timer(HWIF(drive));
        drive->service_time = jiffies - drive->service_start;
        if (startstop == ide_stopped) {
                if (hwgroup->handler == NULL) {        /* paranoia */
                        hwgroup->busy = 0;
                        ide_do_request(hwgroup, hwif->irq);
                } else {
                        printk("%s: ide_intr: huh? expected NULL handler on exit/n", drive->name);
                }
        }
        spin_unlock_irqrestore( flags);
}
; 单个扇区写入之后的中断处理
static ide_startstop_t write_intr (ide_drive_t *drive)
{
        byte stat;
        int i;
        ide_hwgroup_t *hwgroup = HWGROUP(drive);
        struct request *rq = hwgroup->rq;

        if (!OK_STAT(stat=GET_STAT(),DRIVE_READY,drive->bad_wstat)) {
                printk("%s: write_intr error1: nr_sectors=%ld, stat=0x%02x/n", drive->name, rq->nr_sectors, stat);
        } else {
                if ((rq->nr_sectors == 1) ^ ((stat  DRQ_STAT) != 0)) {
                        rq->sector++;
                        rq->buffer += 512;
                        rq->errors = 0;
                        i = --rq->nr_sectors;
                        --rq->current_nr_sectors;
                        if (((long)rq->current_nr_sectors)                                 ide_end_request(1, hwgroup);
                        if (i > 0) {
                                idedisk_output_data (drive, rq->buffer, SECTOR_WORDS);
                                ide_set_handler (drive,  WAIT_CMD, NULL);
                                return ide_started;
                        }
                        return ide_stopped;
                }
                return ide_stopped;        /* the original code did this here (?) */
        }
        return ide_error(drive, "write_intr", stat);
}
; 多重扇区写入后的中断处理
static ide_startstop_t multwrite_intr (ide_drive_t *drive)
{
        byte stat;
        int i;
        ide_hwgroup_t *hwgroup = HWGROUP(drive);
        struct request *rq =

        if (OK_STAT(stat=GET_STAT(),DRIVE_READY,drive->bad_wstat)) {
                if (stat  DRQ_STAT) {
                        /*
                        *        The drive wants data. Remember rq is the copy
                        *        of the request
                        */
                        if (rq->nr_sectors) {
                                if (ide_multwrite(drive, drive->mult_count))
                                        return ide_stopped;
                                ide_set_handler (drive,  WAIT_CMD, NULL);
                                return ide_started;
                        }
                } else {
                        /*
                        *        If the copy has all the blocks completed then
                        *        we can end the original request.
                        */
                        if (!rq->nr_sectors) {        /* all done? */
                                rq = hwgroup->rq;
                                for (i = rq->nr_sectors; i > 0;){
                                        i -= rq->current_nr_sectors;
                                        ide_end_request(1, hwgroup);
                                }
                                return ide_stopped;
                        }
                }
                return ide_stopped;        /* the original code did this here (?) */
        }
        return ide_error(drive, "multwrite_intr", stat);
}
; 读扇区的中断处理
static ide_startstop_t read_intr (ide_drive_t *drive)
{
        byte stat;
        int i;
        unsigned int msect, nsect;
        struct request *rq;

        /* new way for dealing with premature shared PCI interrupts */
        if (!OK_STAT(stat=GET_STAT(),DATA_READY,BAD_R_STAT)) {
                if (stat  (ERR_STAT|DRQ_STAT)) {
                        return ide_error(drive, "read_intr", stat);
                }
                /* no data yet, so wait for another interrupt */
                ide_set_handler(drive,  WAIT_CMD, NULL);
                return ide_started;
        }
        msect = drive->mult_count;

read_next:
        rq = HWGROUP(drive)->rq;
        if (msect) {
                if ((nsect = rq->current_nr_sectors) > msect)
                        nsect = msect;
                msect -= nsect;
        } else
                nsect = 1;
        idedisk_input_data(drive, rq->buffer, nsect * SECTOR_WORDS);
        rq->sector += nsect;
        rq->buffer += nsect        rq->errors = 0;
        i = (rq->nr_sectors -= nsect);
        if (((long)(rq->current_nr_sectors -= nsect))                 ide_end_request(1, HWGROUP(drive));
        if (i > 0) {
                if (msect)
                        goto read_next;
                ide_set_handler (drive,  WAIT_CMD, NULL);
                return ide_started;
        }
        return ide_stopped;
}
static inline void idedisk_input_data (ide_drive_t *drive, void *buffer, unsigned int wcount)
{
        ide_input_data(drive, buffer, wcount);
        if (drive->bswap)
                idedisk_bswap_data(buffer, wcount);
}
void ide_input_data (ide_drive_t *drive, void *buffer, unsigned int wcount)
{
        byte io_32bit = drive->io_32bit;

        if (io_32bit) {
#if SUPPORT_VLB_SYNC
                if (io_32bit  2) {
                        unsigned long flags;
                        __save_flags(flags);        /* local CPU only */
                        __cli();                /* local CPU only */
                        do_vlb_sync(IDE_NSECTOR_REG);
                        insl(IDE_DATA_REG, buffer, wcount);
                        __restore_flags(flags);        /* local CPU only */
                } else
#endif /* SUPPORT_VLB_SYNC */
                        insl(IDE_DATA_REG, buffer, wcount);
        } else {
#if SUPPORT_SLOW_DATA_PORTS
                if (drive->slow) {
                        unsigned short *ptr = (unsigned short *) buffer;
                        while (wcount--) {
                                *ptr++ = inw_p(IDE_DATA_REG);
                                *ptr++ = inw_p(IDE_DATA_REG);
                        }
                } else
#endif /* SUPPORT_SLOW_DATA_PORTS */
                        insw(IDE_DATA_REG, buffer, wcount        }
}


atomic_t queued_sectors;

#define blk_finished_io(nsects)                                /
        atomic_sub(nsects,                 /
        if (atomic_read(                 printk("block: queued_sectors                 atomic_set( 0);                /
        }

static inline void blkdev_dequeue_request(struct request * req)
{
        list_del(
}
void ide_end_request (byte uptodate, ide_hwgroup_t *hwgroup)
{
        struct request *rq;
        unsigned long flags;

        spin_lock_irqsave( flags);
        rq = hwgroup->rq;

        if (!end_that_request_first(rq, uptodate, hwgroup->drive->name)) {
                add_blkdev_randomness(MAJOR(rq->rq_dev));
                blkdev_dequeue_request(rq);
                hwgroup->rq = NULL;
                end_that_request_last(rq);
        }
        spin_unlock_irqrestore( flags);
}
int end_that_request_first (struct request *req, int uptodate, char *name)
{
        struct buffer_head * bh;
        int nsect;

        req->errors = 0;
        if (!uptodate)
                printk("end_request: I/O error, dev %s (%s), sector %lu/n",
                        kdevname(req->rq_dev), name, req->sector);

        if ((bh = req->bh) != NULL) {
                nsect = bh->b_size >> 9;
                blk_finished_io(nsect);
                req->bh = bh->b_reqnext;
                bh->b_reqnext = NULL;
                bh->b_end_io(bh, uptodate);
                if ((bh = req->bh) != NULL) {
                        req->hard_sector += nsect;
                        req->hard_nr_sectors -= nsect;
                        req->sector = req->hard_sector;
                        req->nr_sectors = req->hard_nr_sectors;

                        req->current_nr_sectors = bh->b_size >> 9;
                        if (req->nr_sectors current_nr_sectors) {
                                req->nr_sectors = req->current_nr_sectors;
                                printk("end_request: buffer-list destroyed/n");
                        }
                        req->buffer = bh->b_data;
                        return 1;
                }
        }
        return 0;
}
void end_that_request_last(struct request *req)
{
        if (req->sem != NULL)
                up(req->sem);

        blkdev_release_request(req);
}
void inline blkdev_release_request(struct request *req)
{
        request_queue_t *q = req->q;
        int rw = req->cmd;

        req->rq_status = RQ_INACTIVE;
        req->q = NULL;

        /*
        * Request may not have originated from ll_rw_blk. if not,
        * asumme it has free buffers and check waiters
        */
        if (q) {
                /*
                * we've released enough buffers to start I/O again
                */
                if (waitqueue_active(
                     atomic_read(                         wake_up(

                /*
                * Add to pending free list and batch wakeups
                */
                list_add(

                if (++q->pending_free[rw] >= batch_requests) {
                        int wake_up = q->pending_free[rw];
                        blk_refill_freelist(q, rw);
                        wake_up_nr( wake_up);
                }
        }
}
void inline blk_refill_freelist(request_queue_t *q, int rw)
{
        if (q->pending_free[rw]) {
                list_splice(
                INIT_LIST_HEAD(
                q->pending_free[rw] = 0;
        }
}

 

 

[目录]


驱动

 

[目录]


PCI


PCI是一种广泛采用的总线标准,它提供了优于其他总线标准(比如EISA)的特性
。在大多数奔腾主板上,PCI是高速、高带宽(32-bit和64-bit)、处理器无关的
总线。对PCI的支持第一次加入Linux中时,其内核接口是PCI BIOS32函数的堆砌
。这样做有几个问题:

* PCI BIOS仅存在于PC上;
* PCI BIOS只代表特定的结构,非PC类机器的某些PCI设置不能用PCI BIOS来描述

* 个别机子的PCI BIOS函数不象预期的那样工作。

Linux 2.2提供了一个通用的PCI接口。Linux x86内核实际上努力直接驱动硬件,
只有当它发现某些东西不能理解时,它才会调用PCI BIOS32函数。
驱动程序可以继续使用老的PCI接口,但是为了兼容将来的内核,可能需要更新。
如果驱动程序将要跨平台工作,那就更加需要更新了。
多数新、老函数有简单的对应关系。PCI BIOS基于总线号/设备号/功能号的思想
,而新的代码使用pci_bus和pci_dev结构。第一个新PCI函数是:

pci_present()

这个函数检查机器是否存在一条或更多的PCI总线。老内核有一个
pcibios_present()函数,它们的用法完全相同。

确认PCI存在之后,你可以扫描PCI总线来查找设备。PCI设备通过几个配置寄存器
来标识,主要是供应商ID和设备ID。
每个供应商被分配了一个唯一的标识(ID),并且假设供应商给他们的设备(板
子、芯片等)分配唯一的设备ID。PCI的一个好处是它提供了版本和编程接口信息
,因此可以发现板子的变化。

在Linux 2.2中,扫描PCI总线一般用pci_find_device()函数。范例如下:

struct pci_dev *pdev = NULL;
while ((pdev = pci_find_device(PCI_MY_VENDOR,
PCI_MY_DEVICE, pdev)) != NULL)
{
/* Found a device */
setup_device(pdev);
}

pci_find_device()有3个参数:第一个是供应商ID,第二个是设备ID,第三个是
函数的返回值,NULL表示你想从头开始查找。在这个例子中,对找到的设备调用
setup_device()来进行设置。
另一个值得高兴的事情,是PCI为你处理了所有资源配置工作。一般来说PCI BIOS
具体做这些工作,但是在其他平台上,这项工作由固件或者体系结构相关的Linux
代码来做。到你的驱动程序查找PCI卡的时候,它已经被分配了系统资源。
Linux在pci_dev结构中提供了PCI相关的核心信息。同时还允许读写每个卡的PCI
配置空间。当你可以直接查找资源数据时应该小心,对许多系统来说,卡上配置
的数据与内核提供的数据并不相符。因为许多非PC机器有多条PCI总线,PCI总线
以设备卡不知道的方式映射到系统中。

Linux直接提供了IRQ和PCI BARs(基址寄存器)。为了避免代码在非PC平台上出
现意外,你应该总是使用内核提供的数据。下面代码列出了setup_device()例程

Listing One: The setup_device () Function
void setup_device(struct pci_dev *dev)
{
int io_addr = dev->base_address[0] & PCI_BASE_ADDRESS_IO_MASK;
int irq = dev->irq;
u8 rev;

pci_read_config_byte(dev, PCI_REVISION_ID, &rev);

if (rev<64)
printk("Found a WonderWidget 500 at I/O 0x%04X, IRQ %d./n",
io_addr, irq);
else
printk("Found a WonderWidget 600 at I/O 0x%04X, IRQ %d./n",
io_addr, irq);

/* Check for a common BIOS problem - if you
* expect an IRQ you might not get it */
if (irq==0)
{
printk(KERN_ERR "BIOS has not assigned the WonderWidget"
" an interrupt./n");
return;
}

/* Now do the board initialization knowing the resources */
init_device(io_addr, irq, rev<64 ? 0 : 1);

pci_set_master(dev);
}

当你的卡被BIOS配置后,某些特性可能会被屏蔽掉。比如,多数BIOS都会清掉“
master”位,这导致板卡不能随意向主存中拷贝数据。Linux 2.2提供了一个辅助
函数:

pci_set_master(struct pci_dev *)

这个函数会检查是否需要设置标志位,如果需要,则会将“master”位置位。
例子函数setup_device还使用了pci_read_config_byte来读取配置空间数据。内
核提供了一整套与配置空间相关的函数:

pci_read_config_byte,
pci_read_config_word,
和pci_read_config_dword

分别从配置空间获取8,16和32位数据;

pci_write_config_byte,
pci_write_config_word,
和pci_write_config_dword

分别向配置空间写入8,16和32位数据。PCI配置空间独立于I/O和内存空间,只能
通过这些函数访问。

最后一组有用的PCI函数以不同的方式扫描PCI总线。pci_find_class查找符合给
定类别(class)的设备。PCI规范把设备分为不同的类别,你可以根据类别查找
设备。例如,为了查找一个USB控制器,可以用

struct pci_dev *pdev = NULL;
while((pdev=pci_find_class
(PCI_CLASS_SERIAL_USB <<8, pdev))!=NULL)
{
u8 type;
pci_read_config_byte(dev,
PCI_CLASS_PROG, &type);
if(type!=0)
continue;
/* FOUND IT */
}

另一个例子是I2O。这时,供应商ID只用来确定板卡的实际类型(type),偶尔用
来对付特定板卡的bug。
扫描PCI设备的最后一种途径是pci_find_slot,使你按照特定的顺序扫描PCI插槽
和功能。它很少使用,但是,如果你要控制查找某一类型设备时扫描PCI总线的顺
序,你可以用它。这种情况通常出现在你需要遵照主板BIOS报告设备的顺序时,
或者你想使Linux和非Linux驱动程序以相同的顺序报告设备时。传递给
pci_find_slot()的是总线号slot和设备-功能号function(slot<<3 | function
)。

PCI中断和其他注意事项

PCI总线一个重要的概念是共享中断处理,这在ISA总线设备中一般是看不到的。
PCI总线中断也是电平触发的(level-triggered),也就是说,中断一直在那里
,直到设备去清除它。这些特性给驱动程序处理中断加上了一些重要的限制。
驱动程序注册PCI中断时,总是应该带上SA_SHIRQ标志,用来指明中断线是可以共
享的。如果不这样做,那么系统中的其他设备有可能不能正常工作,用户也可能
遇到麻烦。

由于中断是共享的,PCI设备驱动程序和内核都需要与每个中断处理例程进行沟通
的方法。你必须用一个非空(non-NULL)的dev_id来注册共享中断,否则,当你
需要用free_irq来释放一个中断时,内核不能区分不同的中断处理例程。dev_id
被送到中断处理例程,因此它非常重要。例如,你可以这样:

if (request_irq(dev->irq, dev_interrupt,
SA_SHIRQ, "wonderwidget",
dev))
return -EAGAIN;

结束时,用下面的语句来正确释放中断:

free_irq(dev->irq, dev)

中断处理例程被调用时收到dev参数,这使事情很简单了。你不必搜寻使用该中断
的设备,通常可以这样做:

Listing Two: Using the dev_id
static void dev_interrupt(int irq, void *dev_id, struct pt_regs *regs)
{
struct wonderwidget *dev = dev_id;
u32 status;

/* It is important to exit interrupt handlers
* that are not for us as fast as possible */

if((status=inl(dev->port))==0) /* Not our interrupt */
return;

if(status&1)
handle_rx_intr(dev);
....
}

你必须总是小心处理中断。永远不要在安装中断处理例程之前产生中断。因为PCI
中断是电平触发的,如果你产生了中断而又不能处理它,可能会导致死机。这意
味着写初始化代码时必须特别小心,你必须在打开设备的中断之前注册中断处理
例程。同样,关闭时必须在注销中断处理例程之前屏蔽设备的中断。
与ISA总线相比,Linux对PCI总线的支持用到较多的函数,并且要小心处理中断。
作为回报,不需要你的介入,系统把一切都配置好了。

━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━

[目录]


loopback.c


各位大侠,最近我看Linux源码中的网络驱动部分。
先从loopback.c入手的。
loopback.c中的loopback_xmit函数中有这么一段:
static int loopback_xmit(struct sk_buff * skb,struct net_device * dev)
{
        struct net_device_stats * stats = (struct net_device_stats *)dev_priv;

        if (atomic_read(&skb->users)!=1){

/*判断有几个人用skb. 是会有多出用skb,例如一边运行一边sniff.有些时候会修改skb, 这就要clone,如果这/个skb也被其他人用了.. */

                struct sk_buff * skb2 = skb;
                skb=skb_clone(skb,GFP_ATOMIC);
                if(skb==NULL){
                        kfree_skb(skb2);
                        return 0;/*这里系统内存不足,为什么不报错?因为对kernel来说,mem 不够不是错,是会出现的实际情况,. 在这里的处理方式就是把这个包drop调.不loopback了. */
                }
                kfree_skb(skb2);
        }
        else
                skb_orphan(skb);/*查<linux/skbuff.h>中定义:
                                skb_orphan ---- orphan a buffer
                                @skb: buffer to orphan
                                If a buffer currently has an owner then we
                                call the owner's destructor function and
                                make the @skb unowned.The buffer continues
                                to exist but is no longer charged to its
                                former owner
                                那么skb_orphan以后,原来skb所指向的sk_buff
                                结构如何使用呢?skb是否成了一个空指针?
                                skb_orphan和kfree_skb有什么本质的区别?
                                其实这里应该不是free调的.还是可以用的.但是取消
                                原来的owner的引用而已. */
        .
        .
        .
}

[目录]


网卡驱动编写


    工作需要写了我们公司一块网卡的Linux驱动程序。经历一个从无到有的过程,
深感技术交流的重要。Linux作为挑战微软垄断的强有力武器,日益受到大家的喜
爱。真希望她能在中国迅速成长。把程序文档贴出来,希望和大家探讨Linux技术
和应用,促进Linux在中国的普及。
    本文可随意转载,但请不要在盈利性出版物上刊登。

------------------ Linux操作系统网络驱动程序编写 -------------------
------------ Contact the author by mailto:bordi@bordi.dhs.org ------

Linux操作系统网络驱动程序编写

一.Linux系统设备驱动程序概述
  1.1 Linux设备驱动程序分类
  1.2 编写驱动程序的一些基本概念
二.Linux系统网络设备驱动程序
  2.1 网络驱动程序的结构
  2.2 网络驱动程序的基本方法
  2.3 网络驱动程序中用到的数据结构
  2.4 常用的系统支持
三.编写Linux网络驱动程序中可能遇到的问题
  3.1 中断共享
  3.2 硬件发送忙时的处理
  3.3 流量控制(flow control)
  3.4 调试
四.进一步的阅读
五.杂项

 


一.Linux系统设备驱动程序概述
1.1 Linux设备驱动程序分类
    Linux设备驱动程序在Linux的内核源代码中占有很大的比例,源代码的长度日
益增加,主要是驱动程序的增加。在Linux内核的不断升级过程中,驱动程序的结构
还是相对稳定。在2.0.xx到2.2.xx的变动里,驱动程序的编写做了一些改变,但是
从2.0.xx的驱动到2.2.xx的移植只需做少量的工作。

    Linux系统的设备分为字符设备(char device),块设备(block device)和网络
设备(network device)三种。字符设备是指存取时没有缓存的设备。块设备的读写
都有缓存来支持,并且块设备必须能够随机存取(random access),字符设备则没有
这个要求。典型的字符设备包括鼠标,键盘,串行口等。块设备主要包括硬盘软盘
设备,CD-ROM等。一个文件系统要安装进入操作系统必须在块设备上。

    网络设备在Linux里做专门的处理。Linux的网络系统主要是基于BSD unix的socket
机制。在系统和驱动程序之间定义有专门的数据结构(sk_buff)进行数据的传递。系
统里支持对发送数据和接收数据的缓存,提供流量控制机制,提供对多协议的支持。


1.2 编写驱动程序的一些基本概念
    无论是什么操作系统的驱动程序,都有一些通用的概念。操作系统提供给驱动
程序的支持也大致相同。下面简单介绍一下网络设备驱动程序的一些基本要求。

1.2.1 发送和接收
    这是一个网络设备最基本的功能。一块网卡所做的无非就是收发工作。所以驱
动程序里要告诉系统你的发送函数在哪里,系统在有数据要发送时就会调用你的发
送程序。还有驱动程序由于是直接操纵硬件的,所以网络硬件有数据收到最先能得
到这个数据的也就是驱动程序,它负责把这些原始数据进行必要的处理然后送给系
统。这里,操作系统必须要提供两个机制,一个是找到驱动程序的发送函数,一个
是驱动程序把收到的数据送给系统。

1.2.2 中断
    中断在现代计算机结构中有重要的地位。操作系统必须提供驱动程序响应中断
的能力。一般是把一个中断处理程序注册到系统中去。操作系统在硬件中断发生后
调用驱动程序的处理程序。Linux支持中断的共享,即多个设备共享一个中断。

1.2.3 时钟
    在实现驱动程序时,很多地方会用到时钟。如某些协议里的超时处理,没有中
断机制的硬件的轮询等。操作系统应为驱动程序提供定时机制。一般是在预定的时
间过了以后回调注册的时钟函数。在网络驱动程序中,如果硬件没有中断功能,定
时器可以提供轮询(poll)方式对硬件进行存取。或者是实现某些协议时需要的超时
重传等。

二.Linux系统网络设备驱动程序

2.1 网络驱动程序的结构
    所有的Linux网络驱动程序遵循通用的接口。设计时采用的是面向对象的方法。
一个设备就是一个对象(device 结构),它内部有自己的数据和方法。每一个设备的
方法被调用时的第一个参数都是这个设备对象本身。这样这个方法就可以存取自身
的数据(类似面向对象程序设计时的this引用)。
    一个网络设备最基本的方法有初始化、发送和接收。

     -------------------            ---------------------
    |deliver packets    |          |receive packets queue|
    |(dev_queue_xmit()) |          |them(netif_rx())     |
     -------------------            ---------------------
        |         |                      /          /
        /         /                      |          |
    -------------------------------------------------------
   | methods and variables(initialize,open,close,hard_xmit,|
   | interrupt handler,config,resources,status...)         |
    -------------------------------------------------------
         |        |                      /          /
         /        /                      |          |
      -----------------              ----------------------
     |send to hardware |            |receivce from hardware|
      -----------------              ----------------------
         |        |                      /          /
         /        /                      |          |
     -----------------------------------------------------
    |                  hardware media                     |
     -----------------------------------------------------

    初始化程序完成硬件的初始化、device中变量的初始化和系统资源的申请。发送
程序是在驱动程序的上层协议层有数据要发送时自动调用的。一般驱动程序中不对发
送数据进行缓存,而是直接使用硬件的发送功能把数据发送出去。接收数据一般是通
过硬件中断来通知的。在中断处理程序里,把硬件帧信息填入一个skbuff结构中,然

------------------ Linux操作系统网络驱动程序编写 -------------------
------------ Contact the author by mailto:bordi@bordi.dhs.org ------

后调用netif_rx()传递给上层处理。


2.2 网络驱动程序的基本方法
    网络设备做为一个对象,提供一些方法供系统访问。正是这些有统一接口的方法,
掩蔽了硬件的具体细节,让系统对各种网络设备的访问都采用统一的形式,做到硬件
无关性。
    下面解释最基本的方法。
2.2.1 初始化(initialize)
    驱动程序必须有一个初始化方法。在把驱动程序载入系统的时候会调用这个初
始化程序。它做以下几方面的工作。检测设备。在初始化程序里你可以根据硬件的
特征检查硬件是否存在,然后决定是否启动这个驱动程序。配置和初始化硬件。在
初始化程序里你可以完成对硬件资源的配置,比如即插即用的硬件就可以在这个时
候进行配置(Linux内核对PnP功能没有很好的支持,可以在驱动程序里完成这个功
能)。配置或协商好硬件占用的资源以后,就可以向系统申请这些资源。有些资源是
可以和别的设备共享的,如中断。有些是不能共享的,如IO、DMA。接下来你要初始
化device结构中的变量。最后,你可以让硬件正式开始工作。

2.2.2 打开(open)
    open这个方法在网络设备驱动程序里是网络设备被激活的时候被调用(即设备状
态由down-->up)。所以实际上很多在initialize中的工作可以放到这里来做。比如资
源的申请,硬件的激活。如果dev->open返回非0(error),则硬件的状态还是down。
    open方法另一个作用是如果驱动程序做为一个模块被装入,则要防止模块卸载时
设备处于打开状态。在open方法里要调用MOD_INC_USE_COUNT宏。

2.2.3 关闭(stop)
    close方法做和open相反的工作。可以释放某些资源以减少系统负担。close是在
设备状态由up转为down时被调用的。另外如果是做为模块装入的驱动程序,close里
应该调用MOD_DEC_USE_COUNT,减少设备被引用的次数,以使驱动程序可以被卸载。
另外close方法必须返回成功(0==success)。

2.2.4 发送(hard_start_xmit)
    所有的网络设备驱动程序都必须有这个发送方法。在系统调用驱动程序的xmit
时,发送的数据放在一个sk_buff结构中。一般的驱动程序把数据传给硬件发出去。
也有一些特殊的设备比如loopback把数据组成一个接收数据再回送给系统,或者
dummy设备直接丢弃数据。
    如果发送成功,hard_start_xmit方法里释放sk_buff,返回0(发送成功)。如果
设备暂时无法处理,比如硬件忙,则返回1。这时如果dev->tbusy置为非0,则系统
认为硬件忙,要等到dev->tbusy置0以后才会再次发送。tbusy的置0任务一般由中断
完成。硬件在发送结束后产生中断,这时可以把tbusy置0,然后用mark_bh()调用通
知系统可以再次发送。在发送不成功的情况下,也可以不置dev->tbusy为非0,这样
系统会不断尝试重发。如果hard_start_xmit发送不成功,则不要释放sk_buff。
    传送下来的sk_buff中的数据已经包含硬件需要的帧头。所以在发送方法里不需
要再填充硬件帧头,数据可以直接提交给硬件发送。sk_buff是被锁住的(locked),
确保其他程序不会存取它。

2.2.5 接收(reception)
    驱动程序并不存在一个接收方法。有数据收到应该是驱动程序来通知系统的。
一般设备收到数据后都会产生一个中断,在中断处理程序中驱动程序申请一块
sk_buff(skb),从硬件读出数据放置到申请好的缓冲区里。接下来填充sk_buff中
的一些信息。skb->dev = dev,判断收到帧的协议类型,填入skb->protocol(多协
议的支持)。把指针skb->mac.raw指向硬件数据然后丢弃硬件帧头(skb_pull)。还要
设置skb->pkt_type,标明第二层(链路层)数据类型。可以是以下类型:
  PACKET_BROADCAST : 链路层广播
  PACKET_MULTICAST : 链路层组播
  PACKET_SELF      : 发给自己的帧
  PACKET_OTHERHOST : 发给别人的帧(监听模式时会有这种帧)

最后调用netif_rx()把数据传送给协议层。netif_rx()里数据放入处理队列然后返
回,真正的处理是在中断返回以后,这样可以减少中断时间。调用netif_rx()以后,
驱动程序就不能再存取数据缓冲区skb。

2.2.6 硬件帧头(hard_header)
    硬件一般都会在上层数据发送之前加上自己的硬件帧头,比如以太网(Ethernet)
就有14字节的帧头。这个帧头是加在上层ip、ipx等数据包的前面的。驱动程序提供
一个hard_header方法,协议层(ip、ipx、arp等)在发送数据之前会调用这段程序。
硬件帧头的长度必须填在dev->hard_header_len,这样协议层回在数据之前保留好
硬件帧头的空间。这样hard_header程序只要调用skb_push然后正确填入硬件帧头就
可以了。
    在协议层调用hard_header时,传送的参数包括(2.0.xx):数据的sk_buff,
device指针,protocol,目的地址(daddr),源地址(saddr),数据长度(len)。数据
长度不要使用sk_buff中的参数,因为调用hard_header时数据可能还没完全组织好。
saddr是NULL的话是使用缺省地址(default)。daddr是NULL表明协议层不知道硬件目
的地址。如果hard_header完全填好了硬件帧头,则返回添加的字节数。如果硬件帧
头中的信息还不完全(比如daddr为NULL,但是帧头中需要目的硬件地址。典型的情
况是以太网需要地址解析(arp)),则返回负字节数。hard_header返回负数的情况
下,协议层会做进一步的build header的工作。目前Linux系统里就是做arp
(如果hard_header返回正,dev->arp=1,表明不需要做arp,返回负,dev->arp=0,
做arp)。
    对hard_header的调用在每个协议层的处理程序里。如ip_output。

2.2.7 地址解析(xarp)
    有些网络有硬件地址(比如Ethernet),并且在发送硬件帧时需要知道目的硬件
地址。这样就需要上层协议地址(ip、ipx)和硬件地址的对应。这个对应是通过地址
解析完成的。需要做arp的的设备在发送之前会调用驱动程序的rebuild_header方
法。调用的主要参数包括指向硬件帧头的指针,协议层地址。如果驱动程序能够解
析硬件地址,就返回1,如果不能,返回0。
    对rebuild_header的调用在net/core/dev.c的do_dev_queue_xmit()里。

2.2.8 参数设置和统计数据
    在驱动程序里还提供一些方法供系统对设备的参数进行设置和读取信息。一般
只有超级用户(root)权限才能对设备参数进行设置。设置方法有:
    dev->set_mac_address()
    当用户调用ioctl类型为SIOCSIFHWADDR时是要设置这个设备的mac地址。一般
对mac地址的设置没有太大意义的。
    dev->set_config()

------------------ Linux操作系统网络驱动程序编写 -------------------
------------ Contact the author by mailto:bordi@bordi.dhs.org ------

    当用户调用ioctl时类型为SIOCSIFMAP时,系统会调用驱动程序的set_config
方法。用户会传递一个ifmap结构包含需要的I/O、中断等参数。
    dev->do_ioctl()
    如果用户调用ioctl时类型在SIOCDEVPRIVATE和SIOCDEVPRIVATE+15之间,系统
会调用驱动程序的这个方法。一般是设置设备的专用数据。
    读取信息也是通过ioctl调用进行。除次之外驱动程序还可以提供一个
dev->get_stats方法,返回一个enet_statistics结构,包含发送接收的统计信息。
    ioctl的处理在net/core/dev.c的dev_ioctl()和dev_ifsioc()里。


2.3 网络驱动程序中用到的数据结构
    最重要的是网络设备的数据结构。定义在include/linux/netdevice.h里。它
的注释已经足够详尽。
struct device
{

  /*
   * This is the first field of the "visible" part of this structure
   * (i.e. as seen by users in the "Space.c" file).  It is the name
   * the interface.
   */
  char                    *name;

  /* I/O specific fields - FIXME: Merge these and struct ifmap into one */
  unsigned long           rmem_end;             /* shmem "recv" end     */
  unsigned long           rmem_start;           /* shmem "recv" start   */
  unsigned long           mem_end;              /* shared mem end       */
  unsigned long           mem_start;            /* shared mem start     */
  unsigned long           base_addr;            /* device I/O address   */
  unsigned char           irq;                  /* device IRQ number    */

  /* Low-level status flags. */
  volatile unsigned char  start,                /* start an operation   */
                          interrupt;            /* interrupt arrived    */
  /* 在处理中断时interrupt设为1,处理完清0。 */
  unsigned long           tbusy;                /* transmitter busy must be longg for
bitops */

  struct device           *next;

  /* The device initialization function. Called only once. */
  /* 指向驱动程序的初始化方法。 */
  int                     (*init)(struct device *dev);

  /* Some hardware also needs these fields, but they are not part of the
     usual set specified in Space.c. */
  /* 一些硬件可以在一块板上支持多个接口,可能用到if_port。 */
  unsigned char           if_port;              /* Selectable AUI, TP,..*/
  unsigned char           dma;                  /* DMA channel          */

  struct enet_statistics* (*get_stats)(struct device *dev);

  /*
   * This marks the end of the "visible" part of the structure. All
   * fields hereafter are internal to the system, and may change at
   * will (read: may be cleaned up at will).
   */

  /* These may be needed for future network-power-down code. */
  /* trans_start记录最后一次成功发送的时间。可以用来确定硬件是否工作正常。*/
  unsigned long           trans_start;  /* Time (in jiffies) of last Tx */
  unsigned long           last_rx;      /* Time of last Rx              */

  /* flags里面有很多内容,定义在include/linux/if.h里。*/
  unsigned short          flags;        /* interface flags (a la BSD)   */
  unsigned short          family;       /* address family ID (AF_INET)  */
  unsigned short          metric;       /* routing metric (not used)    */
  unsigned short          mtu;          /* interface MTU value          */

  /* type标明物理硬件的类型。主要说明硬件是否需要arp。定义在
     include/linux/if_arp.h里。 */
  unsigned short          type;         /* interface hardware type      */

  /* 上层协议层根据hard_header_len在发送数据缓冲区前面预留硬件帧头空间。*/
  unsigned short          hard_header_len;      /* hardware hdr length  */

  /* priv指向驱动程序自己定义的一些参数。*/
  void                    *priv;        /* pointer to private data      */

  /* Interface address info. */
  unsigned char           broadcast[MAX_ADDR_LEN];      /* hw bcast add */
  unsigned char           pad;                          /* make dev_addr alignedd to 8
bytes */
  unsigned char           dev_addr[MAX_ADDR_LEN];       /* hw address   */
  unsigned char           addr_len;     /* hardware address length      */
  unsigned long           pa_addr;      /* protocol address             */
  unsigned long           pa_brdaddr;   /* protocol broadcast addr      */
  unsigned long           pa_dstaddr;   /* protocol P-P other side addr */
  unsigned long           pa_mask;      /* protocol netmask             */
  unsigned short          pa_alen;      /* protocol address length      */

  struct dev_mc_list     *mc_list;      /* Multicast mac addresses      */
  int                    mc_count;      /* Number of installed mcasts   */

  struct ip_mc_list      *ip_mc_list;   /* IP multicast filter chain    */
  __u32                 tx_queue_len;   /* Max frames per queue allowed */


------------------ Linux操作系统网络驱动程序编写 -------------------
------------ Contact the author by mailto:bordi@bordi.dhs.org ------

  /* For load balancing driver pair support */

  unsigned long            pkt_queue;   /* Packets queued */
  struct device           *slave;       /* Slave device */
  struct net_alias_info         *alias_info;    /* main dev alias info */
  struct net_alias              *my_alias;      /* alias devs */

  /* Pointer to the interface buffers. */
  struct sk_buff_head     buffs[DEV_NUMBUFFS];

  /* Pointers to interface service routines. */
  int                     (*open)(struct device *dev);
  int                     (*stop)(struct device *dev);
  int                     (*hard_start_xmit) (struct sk_buff *skb,
                                              struct device *dev);
  int                     (*hard_header) (struct sk_buff *skb,
                                          struct device *dev,
                                          unsigned short type,
                                          void *daddr,
                                          void *saddr,
                                          unsigned len);
  int                     (*rebuild_header)(void *eth, struct device *dev,
                                unsigned long raddr, struct sk_buff *skb);
#define HAVE_MULTICAST
  void                    (*set_multicast_list)(struct device *dev);
#define HAVE_SET_MAC_ADDR
  int                     (*set_mac_address)(struct device *dev, void *addr);
#define HAVE_PRIVATE_IOCTL
  int                     (*do_ioctl)(struct device *dev, struct ifreq *ifr, intt cmd);
#define HAVE_SET_CONFIG
  int                     (*set_config)(struct device *dev, struct ifmap *map);
#define HAVE_HEADER_CACHE
  void                    (*header_cache_bind)(struct hh_cache **hhp, struct devvice
*dev, unsigned short htype, __u32 daddr);
  void                    (*header_cache_update)(struct hh_cache *hh, struct devvice
*dev, unsigned char *  haddr);
#define HAVE_CHANGE_MTU
  int                     (*change_mtu)(struct device *dev, int new_mtu);

  struct iw_statistics*   (*get_wireless_stats)(struct device *dev);
};


2.4 常用的系统支持

2.4.1 内存申请和释放
    include/linux/kernel.h里声明了kmalloc()和kfree()。用于在内核模式下申
请和释放内存。
    void *kmalloc(unsigned int len,int priority);
    void kfree(void *__ptr);
    与用户模式下的malloc()不同,kmalloc()申请空间有大小限制。长度是2的整
次方。可以申请的最大长度也有限制。另外kmalloc()有priority参数,通常使用
时可以为GFP_KERNEL,如果在中断里调用用GFP_ATOMIC参数,因为使用GFP_KERNEL
则调用者可能进入sleep状态,在处理中断时是不允许的。
    kfree()释放的内存必须是kmalloc()申请的。如果知道内存的大小,也可以用
kfree_s()释放。

2.4.2 request_irq()、free_irq()
    这是驱动程序申请中断和释放中断的调用。在include/linux/sched.h里声明。
request_irq()调用的定义:
    int request_irq(unsigned int irq,
                 void (*handler)(int irq, void *dev_id, struct pt_regs *regs),
                 unsigned long irqflags,
                 const char * devname,
                 void *dev_id);
    irq是要申请的硬件中断号。在Intel平台,范围0--15。handler是向系统登记
的中断处理函数。这是一个回调函数,中断发生时,系统调用这个函数,传入的参
数包括硬件中断号,device id,寄存器值。dev_id就是下面的request_irq时传递
给系统的参数dev_id。irqflags是中断处理的一些属性。比较重要的有SA_INTERRUPT,
标明中断处理程序是快速处理程序(设置SA_INTERRUPT)还是慢速处理程序(不设置
SA_INTERRUPT)。快速处理程序被调用时屏蔽所有中断。慢速处理程序不屏蔽。还有
一个SA_SHIRQ属性,设置了以后运行多个设备共享中断。dev_id在中断共享时会用
到。一般设置为这个设备的device结构本身或者NULL。中断处理程序可以用dev_id
找到相应的控制这个中断的设备,或者用irq2dev_map找到中断对应的设备。
    void free_irq(unsigned int irq,void *dev_id);

2.4.3 时钟
    时钟的处理类似中断,也是登记一个时间处理函数,在预定的时间过后,系统
会调用这个函数。在include/linux/timer.h里声明。
    struct timer_list {
          struct timer_list *next;
          struct timer_list *prev;
          unsigned long expires;
          unsigned long data;
          void (*function)(unsigned long);
    };
    void add_timer(struct timer_list * timer);
    int del_timer(struct timer_list * timer);
    void init_timer(struct timer_list * timer);
    使用时钟,先声明一个timer_list结构,调用init_timer对它进行初始化。
time_list结构里expires是标明这个时钟的周期,单位采用jiffies的单位。
jiffies是Linux一个全局变量,代表时间。它的单位随硬件平台的不同而不同。
系统里定义了一个常数HZ,代表每秒种最小时间间隔的数目。这样jiffies的单位
就是1/HZ。Intel平台jiffies的单位是1/100秒,这就是系统所能分辨的最小时间
间隔了。所以expires/HZ就是以秒为单位的这个时钟的周期。
    function就是时间到了以后的回调函数,它的参数就是timer_list中的data。
data这个参数在初始化时钟的时候赋值,一般赋给它设备的device结构指针。
    在预置时间到系统调用function,同时系统把这个time_list从定时队列里清
除。所以如果需要一直使用定时函数,要在function里再次调用add_timer()把这

------------------ Linux操作系统网络驱动程序编写 -------------------
------------ Contact the author by mailto:bordi@bordi.dhs.org ------

个timer_list加进定时队列。

2.4.4 I/O
    I/O端口的存取使用:
    inline unsigned int inb(unsigned short port);
    inline unsigned int inb_p(unsigned short port);
    inline void outb(char value, unsigned short port);
    inline void outb_p(char value, unsigned short port);
    在include/adm/io.h里定义。
    inb_p()、outb_p()与inb()、outb_p()的不同在于前者在存取I/O时有等待
(pause)一适应慢速的I/O设备。
    为了防止存取I/O时发生冲突,Linux提供对端口使用情况的控制。在使用端口
之前,可以检查需要的I/O是否正在被使用,如果没有,则把端口标记为正在使用,
使用完后再释放。系统提供以下几个函数做这些工作。
    int check_region(unsigned int from, unsigned int extent);
    void request_region(unsigned int from, unsigned int extent,const char *name)
    void release_region(unsigned int from, unsigned int extent);
    其中的参数from表示用到的I/O端口的起始地址,extent标明从from开始的端
口数目。name为设备名称。

2.4.5 中断打开关闭
    系统提供给驱动程序开放和关闭响应中断的能力。是在include/asm/system.h
中的两个定义。
    #define cli() __asm__ __volatile__ ("cli"::)
    #define sti() __asm__ __volatile__ ("sti"::)

2.4.6 打印信息
    类似普通程序里的printf(),驱动程序要输出信息使用printk()。在include
/linux/kernel.h里声明。
    int printk(const char* fmt, ...);
    其中fmt是格式化字符串。...是参数。都是和printf()格式一样的。

2.4.7 注册驱动程序
    如果使用模块(module)方式加载驱动程序,需要在模块初始化时把设备注册
到系统设备表里去。不再使用时,把设备从系统中卸除。定义在drivers/net/net_init.h
里的两个函数完成这个工作。
    int register_netdev(struct device *dev);
    void unregister_netdev(struct device *dev);
    dev就是要注册进系统的设备结构指针。在register_netdev()时,dev结构一
般填写前面11项,即到init,后面的暂时可以不用初始化。最重要的是name指针和
init方法。name指针空(NULL)或者内容为'/0'或者name[0]为空格(space),则系统
把你的设备做为以太网设备处理。以太网设备有统一的命名格式,ethX。对以太网
这么特别对待大概和Linux的历史有关。
    init方法一定要提供,register_netdev()会调用这个方法让你对硬件检测和
设置。
    register_netdev()返回0表示成功,非0不成功。

2.4.8 sk_buff
    Linux网络各层之间的数据传送都是通过sk_buff。sk_buff提供一套管理缓冲
区的方法,是Linux系统网络高效运行的关键。每个sk_buff包括一些控制方法和一
块数据缓冲区。控制方法按功能分为两种类型。一种是控制整个buffer链的方法,
另一种是控制数据缓冲区的方法。sk_buff组织成双向链表的形式,根据网络应用
的特点,对链表的操作主要是删除链表头的元素和添加到链表尾。sk_buff的控制
方法都很短小以尽量减少系统负荷。(translated from article written by Alan
Cox)
常用的方法包括:
    .alloc_skb() 申请一个sk_buff并对它初始化。返回就是申请到的sk_buff。
    .dev_alloc_skb()类似alloc_skb,在申请好缓冲区后,保留16字节的帧头空
     间。主要用在Ethernet驱动程序。
    .kfree_skb() 释放一个sk_buff。
    .skb_clone() 复制一个sk_buff,但不复制数据部分。
    .skb_copy()完全复制一个sk_buff。
    .skb_dequeue() 从一个sk_buff链表里取出第一个元素。返回取出的sk_buff,
     如果链表空则返回NULL。这是常用的一个操作。
    .skb_queue_head() 在一个sk_buff链表头放入一个元素。
    .skb_queue_tail() 在一个sk_buff链表尾放入一个元素。这也是常用的一个
     操作。网络数据的处理主要是对一个先进先出队列的管理,skb_queue_tail()
     和skb_dequeue()完成这个工作。
    .skb_insert() 在链表的某个元素前插入一个元素。
    .skb_append() 在链表的某个元素后插入一个元素。一些协议(如TCP)对没按
     顺序到达的数据进行重组时用到skb_insert()和skb_append()。

    .skb_reserve() 在一个申请好的sk_buff的缓冲区里保留一块空间。这个空间
     一般是用做下一层协议的头空间的。
    .skb_put() 在一个申请好的sk_buff的缓冲区里为数据保留一块空间。在
     alloc_skb以后,申请到的sk_buff的缓冲区都是处于空(free)状态,有一个
     tail指针指向free空间,实际上开始时tail就指向缓冲区头。skb_reserve()
     在free空间里申请协议头空间,skb_put()申请数据空间。见下面的图。
    .skb_push() 把sk_buff缓冲区里数据空间往前移。即把Head room中的空间移
     一部分到Data area。
    .skb_pull() 把sk_buff缓冲区里Data area中的空间移一部分到Head room中。

            --------------------------------------------------
           |            Tail room(free)                       |
            --------------------------------------------------
                       After alloc_skb()

            --------------------------------------------------
           | Head room |        Tail room(free)               |
            --------------------------------------------------
                       After skb_reserve()

            --------------------------------------------------
           | Head room |     Data area     | Tail room(free)  |
            --------------------------------------------------
                       After skb_put()

            --------------------------------------------------
           |Head| skb_ |   Data            | Tail room(free)  |
           |room| push |                   |                  |
           |    |       Data area          |                  |
            --------------------------------------------------
                       After skb_push()

            --------------------------------------------------
           |   Head    | skb_ |  Data area | Tail room(free)  |
           |           | pull |            |                  |
           |    Head room     |            |                  |
            --------------------------------------------------
                       After skb_pull()


------------------ Linux操作系统网络驱动程序编写 -------------------
------------ Contact the author by mailto:bordi@bordi.dhs.org ------


三.编写Linux网络驱动程序中需要注意的问题

3.1 中断共享
    Linux系统运行几个设备共享同一个中断。需要共享的话,在申请的时候指明
共享方式。系统提供的request_irq()调用的定义:
    int request_irq(unsigned int irq,
                 void (*handler)(int irq, void *dev_id, struct pt_regs *regs),
                 unsigned long irqflags,
                 const char * devname,
                 void *dev_id);
    如果共享中断,irqflags设置SA_SHIRQ属性,这样就允许别的设备申请同一个
中断。需要注意所有用到这个中断的设备在调用request_irq()都必须设置这个属
性。系统在回调每个中断处理程序时,可以用dev_id这个参数找到相应的设备。一
般dev_id就设为device结构本身。系统处理共享中断是用各自的dev_id参数依次调
用每一个中断处理程序。

3.2 硬件发送忙时的处理
    主CPU的处理能力一般比网络发送要快,所以经常会遇到系统有数据要发,但
上一包数据网络设备还没发送完。因为在Linux里网络设备驱动程序一般不做数据
缓存,不能发送的数据都是通知系统发送不成功,所以必须要有一个机制在硬件不
忙时及时通知系统接着发送下面的数据。
    一般对发送忙的处理在前面设备的发送方法(hard_start_xmit)里已经描述过,
即如果发送忙,置tbusy为1。处理完发送数据后,在发送结束中断里清tbusy,同
时用mark_bh()调用通知系统继续发送。
    但在具体实现我的驱动程序时发现,这样的处理系统好象并不能及时地知道硬
件已经空闲了,即在mark_bh()以后,系统要等一段时间才会接着发送。造成发送
效率很低。2M线路只有10%不到的使用率。内核版本为2.0.35。
    我最后的实现是不把tbusy置1,让系统始终认为硬件空闲,但是报告发送不成
功。系统会一直尝试重发。这样处理就运行正常了。但是遍循内核源码中的网络驱
动程序,似乎没有这样处理的。不知道症结在哪里。

3.3 流量控制(flow control)
    网络数据的发送和接收都需要流量控制。这些控制是在系统里实现的,不需要
驱动程序做工作。每个设备数据结构里都有一个参数dev->tx_queue_len,这个参数
标明发送时最多缓存的数据包。在Linux系统里以太网设备(10/100Mbps)
tx_queue_len一般设置为100,串行线路(异步串口)为10。实际上如果看源码可以
知道,设置了dev->tx_queue_len并不是为缓存这些数据申请了空间。这个参数只是
在收到协议层的数据包时判断发送队列里的数据是不是到了tx_queue_len的限度,
以决定这一包数据加不加进发送队列。发送时另一个方面的流控是更高层协议的发
送窗口(TCP协议里就有发送窗口)。达到了窗口大小,高层协议就不会再发送数据。
    接收流控也分两个层次。netif_rx()缓存的数据包有限制。另外高层协议也会
有一个最大的等待处理的数据量。

    发送和接收流控处理在net/core/dev.c的do_dev_queue_xmit()和netif_rx()
中。

3.4 调试
    很多Linux的驱动程序都是编译进内核的,形成一个大的内核文件。但对调试
来说,这是相当麻烦的。调试驱动程序可以用module方式加载。支持模块方式的
驱动程序必须提供两个函数:int init_module(void)和void cleanup_module(void)。
init_module()在加载此模块时调用,在这个函数里可以register_netdev()注册
设备。init_module()返回0表示成功,返回负表示失败。cleanup_module()在驱动
程序被卸载时调用,清除占用的资源,调用unregister_netdev()。
    模块可以动态地加载、卸载。在2.0.xx版本里,还有kerneld自动加载模块,
但是2.2.xx中已经取消了kerneld。手工加载使用insmod命令,卸载用rmmod命令,
看内核中的模块用lsmod命令。
    编译驱动程序用gcc,主要命令行参数-DKERNEL -DMODULE。并且作为模块加载
的驱动程序,只编译成obj形式(加-c参数)。编译好的目标文件放在/lib/modules
/2.x.xx/misc下,在启动文件里用insmod加载。


四.进一步的阅读
    Linux程序设计资料可以从网上获得。这就是开放源代码的好处。并且没有什

么“未公开的秘密”。我编写驱动程序时参阅的主要资料包括:
    Linux内核源代码
    <<The Linux Kernel Hacker's Guide>> by Michael K. Johnson
    <<Linux Kernel Module Programming Guide>> by Ori Pomerantz
    <<Linux下的设备驱动程序>> by olly in BBS水木清华站
    可以选择一个模板作为开始,内核源代码里有一个网络驱动程序的模板,
drivers/net/skeleton.c。里面包含了驱动程序的基本内容。但这个模板是以以太
网设备为对象的,以太网的处理在Linux系统里有特殊“待遇”,所以如果不是以
太网设备,有些细节上要注意,主要在初始化程序里。
    最后,多参照别人写的程序,听听其他开发者的经验之谈大概是最有效的帮助
了。

------------------ Linux操作系统网络驱动程序编写 -------------------
------------ Contact the author by mailto:bordi@bordi.dhs.org ------

--
m;33m※ 来源:·饮水思源站 bbs.sjtu.edu.cn·[FROM: 202.120.240.104]m

--

[目录]


设备驱动(from hust)


一. linux设备概述
在概念上一般把设备分为字符设备、块设备。字符设备是指设备发送和接收数据以字符
形式的进行;而块设备则以整个数据缓冲区的形式进行。但是,由于网络设备等有其特
殊性,实际上系统对它们单独处理。
系统用主设备号(MAJOR)加次设备(MINOR)号来唯一标识一个设备。相同主设备号表
示同一类设备,例如都是硬盘;次设备号标识同类设备的个数。所有设备在适当的目录
(通常在/dev目录下)下必须有相应的文件,这样字符设备和块设备都可以通过文件操
作的系统调用了完成。不同的是,块设备操作经常要和缓冲区打交道,更加复杂一点。
系统设备管理的总体框图如下:
二. 主要数据结构
与设备管理有关的主要数据结构如下:
1、登记设备管理
系统对已登记设备的管理是由chrdevs和blkdevs这两张列表来完成的:
/*src/fs/devices.c*/
struct device_struct {
const char * name;              //指向设备名称
struct file_operations * fops;      //指向设备的访问操作函数集,file_operati
ons定义在
include/linux/fs.h中
};
static  struct device_struct  chrdevs[MAX_CHRDEV] = {
{ NULL, NULL },
};                               //所有系统登记的字符设备列表
static  struct device_struct  blkdevs[MAX_BLKDEV] = {
{ NULL, NULL },
}                               //所有系统登记的块设备列表
实际上这两张列表的结构是一样的,但在登记时每个结构元素的值会不同(见初始化部
分)。Linux对设备的进行访问时,访问文件系统中相应的文件,通过文件系统和文件的
属性描述块,系统可以找到该文件系统或文件对应设备的设备号。在实际访问列表时,
以chrdevs[MAJOR][MINOR]或blkdevs[MAJOR][MINOR]形式访问,相同主设备号(MAJOR)
的元素中fops的内容相同。文件系统中相关的的数据结构如下:
struct super_block {
kdev_t s_dev;             //该文件系统所在设备的设备标志符

}                       //每个文件系统对应一个super_block
struct inode {
kdev_t          i_dev;       //该文件所在设备的设备标志符通过它可以找到在设备列表中
…                  相应设备
}                      //每个文件对应一个inode
2、I/O请求管理
系统会把一部分系统内存作为块设备驱动程序与文件系统接口之间的一层缓冲区,每个
缓冲区与某台块设备中的特定区域相联系,文件系统首先试图存在相应的缓冲区,如未
找到就向该设备发出I/O读写请求,由设备驱动程序对这些请求进行处理。因此,需要有
相应的数据结构进行管理。
/*src/include/linux/blkdev.h*/
struct blk_dev_struct {
void (*request_fn)(void);         //指向请求处理函数的指针,请求处理函数是写
设备驱动
程序的重要一环,设备驱动程序在此函数中通过outb向位
于I/O空间中的设备命令寄存器发出命令
struct request * current_request;   //指向当前正在处理的请求,它和plug共同维
护了该设备
的请求队列
struct request   plug;           //这是LINUX2.0版本与以前版本的一个不同之处,
plug
主要被用于异步提前读写操作,在这种情况下,由于没有特别的请求,为了提高系统性
能,需要等发送完所有的提前读写请求才开始进行请求处理,即unplug_device。
struct tq_struct plug_tq;         //设备对应的任务队列
};
/*src/drivers/block/ll_rw_blk.c*/
struct  blk_dev_struct  blk_dev[MAX_BLKDEV];
其中每个请求以request的类型的结构进行传递,定义如下:
/*src/include/linux/blk_dev.h*/
struct request {
volatile int rq_status;               //表示请求的状态
kdev_t rq_dev;                    //是该请求对应的设备号,kdev_t是unsigned s
hort类型,高8位是主设备号,低8位是从设备号,每一请求都针对一个设备发出的;
        int cmd;                         //表示该请求对应的命令,取READ或WRITE;
        int errors;
        unsigned long sector;              //每一扇区的字节数
        unsigned long nr_sectors;           //每一扇区的扇区数
        unsigned long current_nr_sectors;    //当前的扇区数;
char * buffer;                    //存放buffer_head.b_data值,表示发出请求的
数据存取地址;
struct semaphore * sem;            //一个信号量,用来保证设备读写的原语操作,

sem=0时才能处理该请求;
        struct buffer_head * bh;            //读写缓冲区的头指针
        struct buffer_head * bhtail;         //读写缓冲区的尾指针
        struct request * next;              //指向下一个请求
};
对不同块设备的所有请求都放在请求数组all_requests中,该数组实际上是一个请求缓
冲池,请求的释放与获取都是针对这个缓冲池进行;同时各个设备的请求用next指针联
结起来,形成各自的请求队列。定义如下:
/*src/drivers/blokc/ll_rw_blk.c*/
static struct request all_requests[NR_REQUEST];
3、中断请求
设备进行实际的输入/输出操作时,如果时间过长而始终被占用CPU,就会影响系统的效
率,必须有一种机制来克服这个问题而又不引起其他问题。中断是最理想的方法。和中
断有关的数据结构是;
struct irqaction {
        void (*handler)(int, void *, struct pt_regs *);   //指向设备的中断响应函数,
它在系统初
始化时被置入。当中断发生时,系统自动调用该函数
        unsigned long flags;                 //指示了中断类型,如正常中断、快速中断

        unsigned long mask;                //中断的屏蔽字
        const char *name;                  //设备名
        void *dev_id;                     //与设备相关的数据类型,中断响应函数可以根

据需要将它转化所需的数据指针,从而达到访问系统数据的功能
        struct irqaction *next;               //指向下一个irqaction
};
由于中断数目有限,且很少更新,所以系统在初始化时,从系统堆中分配内存给每一个
irq_action指针,通过next指针将它们连成一个队列。
4、高速缓冲区
为了加速对物理设备的访问速度,Linux将块缓冲区放在Cache内,块缓冲区是由buffer
_head连成的链表结构。buffer_head的数据结构如下:
/*include/linux/fs.h*/
struct buffer_head {
        unsigned long b_blocknr;                /* block number */
        kdev_t b_dev;                                   /* device (B_FREE = free) */
        kdev_t b_rdev;                                  /* Real device */
        unsigned long b_rsector;                        /* Real buffer location on disk */
        struct buffer_head * b_next;            /* Hash queue list */
        struct buffer_head * b_this_page;       /* circular list of buffers in one page *
/
        unsigned long b_state;                  /* buffer state bitmap (see above) */
        struct buffer_head * b_next_free;
        unsigned int b_count;                   /* users using this block */
        unsigned long b_size;                   /* block size */
        char * b_data;                                  /* pointer to data block (1024 bytes) */
        unsigned int b_list;                            /* List that this buffer appears */
        unsigned long b_flushtime;      /* Time when this (dirty) buffer should be
written */
        unsigned long b_lru_time;       /* Time when this buffer was last used. */
        struct wait_queue * b_wait;
        struct buffer_head * b_prev;            /* doubly linked list of hash-queue */
        struct buffer_head * b_prev_free;       /* doubly linked list of buffers */
        struct buffer_head * b_reqnext; /* request queue */
};
块缓冲区主要由链表组成。空闲的buffer_head组成的链表是按块大小的不同分类组成,
Linux目前支持块大小为512、1024、2048、4096和8192字节;第二部分是正在用的块,
块以Hash_table的形式组织,具有相同hash索引的缓冲块连在一起,hash索引根据设备
标志符和该数据块的块号得到;同时将同一状态的缓冲区块用LRU算法连在一起。对缓冲
区的各个链表定义如下:
/* fs/buffer.c*/
static struct buffer_head ** hash_table;
static struct buffer_head * lru_list[NR_LIST] = {NULL, };
static struct buffer_head * free_list[NR_SIZES] = {NULL, };
static struct buffer_head * unused_list = NULL;
static struct buffer_head * reuse_list = NULL;
三. 设备的初始化
LINUX启动时,完成了实模式下的系统初始化(arch/i386/boot/setup.S)与保护模式下
的核心初始化包括初始化寄存器和数据区(arch/i386/boot/compressed/head.S)、核心
代码解压缩、页表初始化(arch/i386/kernel/head.S)、初始化idt、gdt和ldt等工作
后,系统转入了核心。调用函数start_kernel启动核心(init/main.c)后,将继续各方
面的初始化工作,其中start_kernel最后将调用kernel_thread (init, NULL, 0),创建
init进程进行系统配置(其中包括所有设备的初始化工作)。
static int init(void * unused)
{
…………
/* 创建后台进程bdflush,以不断循环写出文件系统缓冲区中"脏"的内容 */
kernel_thread(bdflush, NULL, 0);
/* 创建后台进程kswapd,专门处理页面换出工作  */
kswapd_setup();
kernel_thread(kswapd, NULL, 0);
…………
setup();
…………
在setup函数中,调用系统调用sys_setup()。sys_setup()的定义如下:
//fs/filesystems.c
asmlinkage int sys_setup(void)
{
        static int callable = 1;
… …
        if (!callable)
                return -1;
        callable = 0;
… …
        device_setup();
… …
在该系统调用中,静态变量callable保证只被调用实际只一次,再次调用时后面的初始
化程序不执行。在该调用开始就先进行设备的初始化:device_setup()。
//dirvers/block/genhd.c
void device_setup(void)
{
        extern void console_map_init(void);
… …
        chr_dev_init();
        blk_dev_init();
… …
可以看到device_setup()将依次执行chr_dev_init()、blk_dev_init()等各类设备的初
始化程序。每个具体的init函数的内容和具体设备就有关了,但是它们都有一些必须完
成的任务:
1、 告诉内核这一驱动程序使用的主设备号,同时提供指向file_operation的指针,以
完成对chrdevs和blkdevs的初始化。
2、 对块设备,需要将输入/输出处理程序的入口地址告诉内核。
3、 对块设备,需要告诉缓冲区设备存取的数据块的大小。
四. 设备管理的流程
下面我们介绍一下整个设备管理的流程。我们以块设备为例,字符设备的流程也和块设
备类似,只是没有请求队列管理。
首先,文件系统通过调用ll_rw_block发出块读写命令,读写请求管理层接到命令后,向
系统申请一块读写请求缓冲区,在填写完请求信息后,请求进入设备的读写请求队列等
候处理。如果队列是空的,则请求立即得到处理,否则由系统负责任务调度,唤醒请求
处理。在请求处理过程中,系统向I/O空间发出读写指令返回。当读写完毕后,通过中断
通知系统,同时调用与设备相应的读写中断响应函数。对设备的读写过程的流程可以用
下图表示。
五. 添加一个字符设备
作为对linux设备管理的分析的总结,我们介绍一下如何添加一个设备,首先介绍如何添
加一个字符设备。在后面的文章中,我们将新添加的设备称为新设备,说明以我们实现
的虚拟的字符设备为例,步骤基本如下:
1. 确定设备的设备名称和主设备号:
我们必须找一个还没有被使用的主设备号,分配给自己的字符设备。假设主设备号为30
(在2.0.34的内核中还没有以30作为主设备号的字符设备)。
2. 确定编写需要的file_operations中的操作函数,包括:
static int my_open(struct inode * inode,struct file * file)
//通过宏指令MINOR()提取inode参数的I_rdev字段,确定辅助设备号,然后
检查相应的读写忙标志,看新设备是否已经打开。如果是,返回错误信息;
否则置读写忙标志为true,阻止再次打开新设备。
static void my_release(struct inode * inode,struct file * file)
//同my_open类似,只是置读写忙标志为false,允许再次打开新设备。
static int my _write(struct inode * inode,struct file * file,const char * bu
ffer,int count)
//用于对该设备的写
static int my _read(struct inode * inode , struct file * file,char * buffer,
int count)
//用于对该设备的读
static int my_ioctl(struct inode * inode, struct file * file,
unsigned int cmd, unsigned long arg)
                //用于传送特殊的控制信息给设备驱动程序,或者长设备驱动程序取得状态信息,
在我们实现的虚拟字符设备中,这个函数的功能是用来打开和关闭跟踪功
能。
3. 确定编写需要的初始化函数:
        void my_init(void)
//首先需要将上述的file_operations中的操作函数的地址赋给某个file_operations
的结构变量my_fops中的相应域;
然后调用标准内核函数登记该设备:register_chrdev(30,"mychd",&my_fops);
最后对必要的变量(例如读写忙标志、跟踪标志等)赋初值。
4. 在drivers/char/mem.c中添加相应语句;
在chr_dev_init函数之前添加drgn_init的原型说明:
void my_init (void);
在chr_dev_init函数的return语句之前添加以下语句:
my_init ();    //用于在字符设备初始化时初始化新设备
5. 修改drivers/char/Makefile;
假设我们把所以必要的函数写mychd.c中,则找到"L_OBJS   := tty_io.o n_tty.o con
sole.o /"行,将"mychd.o"加到其中。
6. 将该设备私有的*.c,*.h复制到目录drivers/char下。
7. 用命令:make clean;make dep;make zImage重新编译内核。
8. 用mknod命令在目录/dev下建立相应主设备号的用于读写的特殊文件。
完成了上述步骤,你在linux环境下编程时就可以使用新设备了。
六. 添加一个块设备
接下来我们将介绍如何添加一个块设备。在后面的文章中,我们将新添加的块设备称为
新设备,块设备的添加过程和字符设备有相似之处,我们将主要介绍其不同点,步骤基
本如下:
1. 确定设备的设备名称和主设备号
我们必须找一个还没有被使用的主设备号,分配给自己的新设备。假设主设备号为30(
在2.0.34的内核中还没有以30作为主设备号的块设备),则需要在include/linux/majo
r.h中加入如下句:
                        #define MY_MAJOR 30
这样我们可以通过MY_MAJOR来确定设备为新设备,保证通用性。
2. 确定编写需要的file_operations中的操作函数:
static int my_open(struct inode * inode,struct file * file)
static void my_release(struct inode * inode,struct file * file)
static int my_ioctl(struct inode * inode, struct file * file,
unsigned int cmd, unsigned long arg)
由于使用了高速缓存,块设备驱动程序就不需要包含自己的read()、write()和fsync()
函数,但必须使用自己的open()、 release()和 ioctl()函数,这些函数的作用和字符
设备的相应函数类似。
3. 确定编写需要的输入/输出函数:
static int my _read(void)               //正确处理时返回值为1,错误时返回值为0
static int my _write(void)      //正确处理时返回值为1,错误时返回值为0
值得注意的是这两个函数和字符设备中的my read()、mywrite()函数不同:
2 参数不同:字符设备中的函数是带参数的,用于对其工作空间(也可以看成是简单的
缓冲区)中的一定长度(长度也是参数传递的)的字符进行读写;而块设备的函数是没
有参数的,它通过当前请求中的信息访问高速缓存中的相应的块,因此不需要参数输入

2 调用形式不同:字符设备中的函数地址是存放在file_operations中的,在对字符设备
进行读写时就调用了;而块设备的读写函数是在需要进行实际I/O时在request中调用。
这在后面可以看到。
4. 确定编写需要的请求处理函数:
static void my_request(void)
在块设备驱动程序中,不带中断服务子程序的请求处理函数是简单的,典型的格式如下

static void my_request(void)
{
loop:
INIT_REQUEST;

        if (MINOR(CURRENT->dev)>MY_MINOR_MAX)
        {
                end_request(0);
                goto loop;
        }

        if (CURRENT ->cmd==READ)
//CUREENT是指向请求队列头的request结构指针
        {
                end_request(my_read());         //my_read()在前面已经定义
                goto loop;
        }

        if (CURRENT ->cmd==WRITE)
        {
                end_request(my_write());        //my_write()在前面已经定义
                goto loop;
        }

        end_request(0);
        goto loop;
}
实际上,一个真正的块设备一般不可能没有中断服务子程序,另外设备驱动程序是在系
统调用中被调用的,这时由内核程序控制CPU,因此不能抢占,只能自愿放弃;因此驱动
程序必须调用sleep_on()函数,释放对CPU的占用;在中断服务子程序将所需的数据复制
到内核内存后,再由它来发出wake_up()调用,
5. 如果需要,编写中断服务子程序
实际上,一个真正的块设备一般不可能没有中断服务子程序,另外设备驱动程序是在系
统调用中被调用的,这时由内核程序控制CPU,因此不能抢占,只能自愿放弃;因此驱动
程序必须调用sleep_on()函数,释放对CPU的占用;在中断服务子程序将所需的数据复制
到内核内存后,再由它来发出wake_up()调用。
另外两段中断服务子程序都要访问和修改特定的内核数据结构时,必须要仔细协调,以
防止出现灾难性的后果。
2 首先,在必要时可以禁止中断,这可以通过sti()和cli()来允许和禁止中断请求。
2 其次,修改特定的内核数据结构的程序段要尽可能的短,使中断不至于延时过长。
含有中断服务子程序的块设备驱动程序的编写相对比较复杂,我们还没有完全实现,主
要问题是在中断处理之间的协调。因为这些程序是要加入内核的,系统默认为你是完全
正确的,如果引起循环或者中断长时间不响应,结果非常严重。我们正在努力实现这一
程序。
6. 确定编写需要的初始化函数:
        void my_init(void)
需要将的file_operations中的操作函数的地址赋给某个file_operations的结构变量my
_fops中的相应域;一个典型的形式是:
                struct file_operations my_fops=
                {
                        0,
                        block_read,
                        block_write,
                        0,
                        0,
                        my_ioctl,
                        0,
                        my_open,
                        my_release,
                        block_fsync,
                        0,
                        0,
                        0,
                }
my_init中需要作的工作有:
2 首先调用标准内核函数登记该设备:
        register_chrdev(MY_MOJOR,"my--bdev",&my_fops);
2 将request()函数的地址告诉内核:
blk_dev[MY_MAJOR].request_fn=DEVICE_REQUEST;
DEVICE_REQUEST是请求处理函数的地址,它的定义将在稍后可以看到。
2 告诉新设备的高速缓存的数据块的块大小:
my_block_size=512;      //也可以是1024等等
blksize_size[MY_MAJOR]=& my_block_size;
为了系统在初始化时能够对新设备进行初始化,需要在blk_dev_init()中添加一行代码
,可以插在blk_dev_init()中return 0的前面,格式为:
        my_init();
7. 在include/linux/blk.h中添加相应语句;
到目前为止,除了DEVICE_REQUEST符合外,还没有告诉内核到那里去找你的request()函
数,为此需要将一些宏定义加到blk.h中。在blk.h中找到类似的一行:
        #endif  /*MAJOR_NR==whatever    */
在这行前面加入如下宏定义:
        #elif (MAJOR_NR==whatever)

static void my_request(void);
#define DEVICE_NAME "MY_BLK_DEV"                //驱动程序名称
#define DEVICE_REQUEST  my_request              //request()函数指针
#define DEVIEC_NR(device) (MINOR(device))       //计算实际设备号
#define DEVIEC_ON(device)                                       //用于需要打开的设备
#define DEVIEC_OFF(device)                              //用于需要关闭的设备
8. 修改drivers/block/Makefile;
假设我们把所以必要的函数写mybd.c中,则找到"L_OBJS   := tty_io.o n_tty.o cons
ole.o /"行,将"mybd.o"加到其中。
9. 将该设备私有的*.c,*.h复制到目录drivers/block下。
10. 用命令:make clean;make dep;make zImage重新编译内核。
11. 用mknod命令在目录/dev下建立相应主设备号的用于读写的特殊文件。
完成了上述步骤,你在linux环境下编程时就可以使用新设备了。
七. 一个虚拟的字符设备驱动程序
以下是一个虚拟的字符设备驱动程序,该程序是我和潘刚同学的试验结果,本来我们还
打算写一个虚拟的块设备驱动程序,由于时间关系,没有能够完全明白中断中断服务子
程序的编写方法,因此没有没有能够实现一个可以所有的虚拟的块设备,非常遗憾。不
过主要步骤已经在上文中进行了介绍,我想再有一段时间应该能够完成,到时候一定交
给李老师看一下。
虚拟的字符设备驱动程序如下,在潘刚同学的试验报告中也有介绍:
/* drgn.h */
#ifdef  KERNEL
#define TRACE_TXT(text) {if(drgn_trace) {console_print(text);console_print("
/n");}}
#define TRACE_CHR(chr) {if(drgn_trace) console_print(chr);}
#define DRGN_READ  1
#define DRGN_WRITE 0
#endif
#define FALSE 0
#define TRUE  1
#define MAX_BUF   120
#define DRGN_TRON  (('M' << 8)|0x01)
#define DRGN_TROFF (('M' << 8)|0x02)
struct drgn_buf
{
   int buf_size;
   char buffer[MAX_BUF];
   struct drgn_buf *link;
};
/* drgn.c */
#define KERNEL
#include <linux/kernel.h>
#include <linux/sched.h>
#include <linux/tty.h>
#include <linux/signal.h>
#include <linux/errno.h>
#include <linux/malloc.h>
#include <linux/mm.h>
#include <asm/io.h>
#include <asm/segment.h>
#include <asm/system.h>
#include <asm/irq.h>
#include "drgn.h"
static int drgn_trace;
static int write_busy;
static int read_busy;
static struct drgn_buf * qhead;
static struct drgn_buf * qtail;
static int  drgn_read(struct inode * , struct file * , char * , int );
static int  drgn_write(struct inode * , struct file * , const char *, int );

static int  drgn_ioctl(struct inode * , struct file * , unsigned int , unsig
ned long );
static int  drgn_open(struct inode *,struct file *);
static void drgn_release(struct inode *,struct file *);
/* extern void console_print(char *);*/
struct file_operations drgn_fops=
{
   NULL,
   drgn_read,
   drgn_write,
   NULL,
   NULL,
   drgn_ioctl,
   NULL,
   drgn_open,
   drgn_release,
   NULL,
   NULL,
   NULL,
   NULL
};
void drgn_init(void)
{
   drgn_trace=TRUE;
   if(register_chrdev(30,"drgn",&drgn_fops))
      TRACE_TXT("Cannot register drgn driver as major device 30.")
   else
      TRACE_TXT("Tiny devie driver registered successfully.")
   qhead=0;
   write_busy=FALSE;
   read_busy=FALSE;
/*  drgn_trace=FALSE;*/
   return;
}
static int drgn_open(struct inode * inode,struct file * file)
{
   TRACE_TXT("drgn_open")
   switch (MINOR(inode->i_rdev))
   {
      case DRGN_WRITE:
         if(write_busy)
            return -EBUSY;
         else{
            write_busy=TRUE;
            return 0;
         }
      case DRGN_READ:
         if(read_busy)
            return -EBUSY;
         else{
            read_busy=TRUE;
            return 0;
         }
      default:
         return -ENXIO;
   }
}
static void drgn_release(struct inode * inode,struct file * file)
{
   TRACE_TXT("drgn_release")
   switch (MINOR(inode->i_rdev))
   {
      case DRGN_WRITE:
         write_busy=FALSE;
         return;
      case DRGN_READ:
         read_busy=FALSE;
         return;
   }
}
static int drgn_write(struct inode * inode,struct file * file,
                        const char * buffer,int count)
{
   int i,len;
   struct drgn_buf * ptr;
   TRACE_TXT("drgn_write")
   if (MINOR(inode->i_rdev)!=DRGN_WRITE)
      return -EINVAL;
   if ((ptr=kmalloc(sizeof(struct drgn_buf),GFP_KERNEL))==0)
      return -ENOMEM;
   len=count < MAX_BUF?count:MAX_BUF;
   if (verify_area(VERIFY_READ,buffer,len))
      return -EFAULT;
   for(i=0;i < count && i<MAX_BUF;++i)
   {
      ptr->buffer[i]=(char) get_user((char*)(buffer+i));
      TRACE_CHR("w")
   }
   ptr->link=0;
   if(qhead==0)
      qhead=ptr;
   else
      qtail->link=ptr;
   qtail=ptr;
   TRACE_CHR("/n")
   ptr->buf_size=i;
   return i;
}
static int drgn_read(struct inode * inode , struct file * file,
                         char * buffer, int count)
{
   int i,len;
   struct drgn_buf * ptr;
   TRACE_TXT("drgn_read")
   if(MINOR(inode->i_rdev)!=DRGN_READ)
      return -EINVAL;
   if (qhead==0)
      return -ENODATA;
   ptr=qhead;
   qhead=qhead->link;
   len=count < ptr->buf_size?count:ptr->buf_size;
   if (verify_area(VERIFY_WRITE,buffer,len))
      return -EFAULT;
   for (i=0; i<count && i<ptr->buf_size; ++i)
   {
      put_user((char) ptr->buffer[i],(char *)(buffer+i));
      TRACE_CHR("r")
   }
   TRACE_CHR("/n")
   kfree_s(ptr,sizeof(struct drgn_buf));
   return i;
}
static int drgn_ioctl(struct inode * inode, struct file * file,
                         unsigned int cmd, unsigned long arg)
{
   TRACE_TXT("drgn_ioctl")
/*   if (cmd==DRGN_TRON){
       drgn_trace=TRUE;
       return 0;
   }
   else
       if (cmd==DRGN_TROFF){
           drgn_trace=FALSE;
           return 0;
       }
       else
           return -EINVAL;*/
   switch(cmd)
   {
      case DRGN_TRON:
         drgn_trace=TRUE;
         return 0;
      case DRGN_TROFF:
         drgn_trace=FALSE;
         return 0;
      default:
         return -EINVAL;
   }
}

[目录]


设备驱动(from smth)


1.        UNIX下设备驱动程序的基本结构
在UNIX系统里,对用户程序而言,设备驱动程序隐藏了设备的具体细节,对各种不同设备提供了一致的接口,一般来说是把设备映射为一个特殊的设备文件,用户程序可以象对其它文件一样对此设备文件进行操作。UNIX对硬件设备支持两个标准接口:块特别设备文件和字符特别设备文件,通过块(字符)特别 设备文件存取的设备称为块(字符)设备或具有块(字符)设备接口。 块设备接口仅支持面向块的I/O操作,所有I/O操作都通过在内核地址空间中的I/O缓冲区进行,它可以支持几乎任意长度和任意位置上的I/O请求,即提供随机存取的功能。
字符设备接口支持面向字符的I/O操作,它不经过系统的快速缓存,所以它们负责管理自己的缓冲区结构。字符设备接口只支持顺序存取的功能,一般不能进行任意长度的I/O请求,而是限制I/O请求的长度必须是设备要求的基本块长的倍数。显然,本程序所驱动的串行卡只能提供顺序存取的功能,属于是字符设备,因此后面的讨论在两种设备有所区别时都只涉及字符型设备接口。设备由一个主设备号和一个次设备号标识。主设备号唯一标识了设备类型,即设备驱动程序类型,它是块设备表或字符设备表中设备表项的索引。次设备号仅由设备驱动程序解释,一般用于识别在若干可能的硬件设备中,I/O请求所涉及到的那个设备。
设备驱动程序可以分为三个主要组成部分:
(1) 自动配置和初始化子程序,负责检测所要驱动的硬件设备是否存在和是否能正常工作。如果该设备正常,则对这个设备及其相关的、设备驱动程序需要的软件状态进行初始化。这部分驱动程序仅在初始化的时候被调用一次。
(2) 服务于I/O请求的子程序,又称为驱动程序的上半部分。调用这部分是由于系统调用的结果。这部分程序在执行的时候,系统仍认为是和进行调用的进程属于同一个进程,只是由用户态变成了核心态,具有进行此系统调用的用户程序的运行环境,因此可以在其中调用sleep()等与进程运行环境有关的函数。
(3) 中断服务子程序,又称为驱动程序的下半部分。在UNIX系统中,并不是直接从中断向量表中调用设备驱动程序的中断服务子程序,而是由UNIX系统来接收硬件中断,再由系统调用中断服务子程序。中断可以产生在任何一个进程运行的时候,因此在中断服务程序被调用的时候,不能依赖于任何进程的状态,也就不能调用任何与进程运行环境有关的函数。因为设备驱动程序一般支持同一类型的若干设备,所以一般在系统调用中断服务子程序的时候,都带有一个或多个参数,以唯一标识请求服务的设备。
在系统内部,I/O设备的存取通过一组固定的入口点来进行,这组入口点是由每个设备的设备驱动程序提供的。一般来说,字符型设备驱动程序能够提供如下几个入口点:
(1) open入口点。打开设备准备I/O操作。对字符特别设备文件进行打开操作,都会调用设备的open入口点。open子程序必须对将要进行的I/O操作做好必要的准备工作,如清除缓冲区等。如果设备是独占的,即同一时刻只能有一个程序访问此设备,则open子程序必须设置一些标志以表示设备处于忙状态。
(2) close入口点。关闭一个设备。当最后一次使用设备终结后,调用close子程序。独占设备必须标记设备可再次使用。
(3) read入口点。从设备上读数据。对于有缓冲区的I/O操作,一般是从缓冲区里读数据。对字符特别设备文件进行读操作将调用read子程序。
(4) write入口点。往设备上写数据。对于有缓冲区的I/O操作,一般是把数据写入缓冲区里。对字符特别设备文件进行写操作将调用write子程序。
(5) ioctl入口点。执行读、写之外的操作。
(6) select入口点。检查设备,看数据是否可读或设备是否可用于写数据。select系统调用在检查与设备特别文件相关的文件描述符时使用select入口点。如果设备驱动程序没有提供上述入口点中的某一个,系统会用缺省的子程序来代替。对于不同的系统,也还有一些其它的入口点。

2.        LINUX系统下的设备驱动程序
具体到LINUX系统里,设备驱动程序所提供的这组入口点由一个结构来向系
统进行说明,此结构定义为:

#include <linux/fs.h>
struct file_operations {
        int (*lseek)(struct inode *inode,struct file *filp,
                off_t off,int pos);
        int (*read)(struct inode *inode,struct file *filp,
                char *buf, int count);
        int (*write)(struct inode *inode,struct file *filp,
                char *buf,int count);
        int (*readdir)(struct inode *inode,struct file *filp,
                struct dirent *dirent,int count);
        int (*select)(struct inode *inode,struct file *filp,
                int sel_type,select_table *wait);
        int (*ioctl) (struct inode *inode,struct file *filp,
                unsigned int cmd,unsigned int arg);
        int (*mmap) (void);

        int (*open) (struct inode *inode, struct file *filp);
        void (*release) (struct inode *inode, struct file *filp);
        int (*fsync) (struct inode *inode, struct file *filp);
};

其中,struct inode提供了关于特别设备文件/dev/driver(假设此设备名为driver)的信息,它的定义为:

#include <linux/fs.h>
struct inode {
        dev_t           i_dev;
        unsigned long    i_ino;  /* Inode number */
        umode_t        i_mode; /* Mode of the file */
        nlink_t          i_nlink;
        uid_t           i_uid;
        gid_t           i_gid;
        dev_t           i_rdev;  /* Device major and minor numbers*/
        off_t            i_size;
        time_t          i_atime;
        time_t          i_mtime;
        time_t          i_ctime;
        unsigned long   i_blksize;
        unsigned long   i_blocks;
        struct inode_operations * i_op;
      struct super_block * i_sb;
        struct wait_queue * i_wait;
        struct file_lock * i_flock;
        struct vm_area_struct * i_mmap;
        struct inode * i_next, * i_prev;
        struct inode * i_hash_next, * i_hash_prev;
        struct inode * i_bound_to, * i_bound_by;
        unsigned short i_count;
        unsigned short i_flags;  /* Mount flags (see fs.h) */
        unsigned char i_lock;
        unsigned char i_dirt;
        unsigned char i_pipe;
        unsigned char i_mount;
        unsigned char i_seek;
        unsigned char i_update;
        union {
                struct pipe_inode_info pipe_i;
                struct minix_inode_info minix_i;
                struct ext_inode_info ext_i;
                struct msdos_inode_info msdos_i;
                struct iso_inode_info isofs_i;
                struct nfs_inode_info nfs_i;
        } u;
};

struct file主要用于与文件系统对应的设备驱动程序使用。当然,其它设备驱动程序也可以使用它。它提供关于被打开的文件的信息,定义为:#include <linux/fs.h>
struct file {
        mode_t f_mode;
        dev_t f_rdev;             /* needed for /dev/tty */
        off_t f_pos;              /* Curr. posn in file */
        unsigned short f_flags;   /* The flags arg passed to open */
        unsigned short f_count;   /* Number of opens on this file */
        unsigned short f_reada;
        struct inode *f_inode;    /* pointer to the inode struct */
        struct file_operations *f_op;/* pointer to the fops struct*/
};

在结构file_operations里,指出了设备驱动程序所提供的入口点位置,分别是
(1) lseek,移动文件指针的位置,显然只能用于可以随机存取的设备。
(2) read,进行读操作,参数buf为存放读取结果的缓冲区,count为所要读取的数据长度。返回值为负表示读取操作发生错误,否则返回实际读取的字节数。对于字符型,要求读取的字节数和返回的实际读取字节数都必须是inode->i_blksize的的倍数。
(3) write,进行写操作,与read类似。
(4) readdir,取得下一个目录入口点,只有与文件系统相关的设备驱动程序才使用。
(5) selec,进行选择操作,如果驱动程序没有提供select入口,select操作将会认为设备已经准备好进行任何的I/O操作。
(6) ioctl,进行读、写以外的其它操作,参数cmd为自定义的的命令。
(7) mmap,用于把设备的内容映射到地址空间,一般只有块设备驱动程序使用。
(8) open,打开设备准备进行I/O操作。返回0表示打开成功,返回负数表示失败。如果驱动程序没有提供open入口,则只要/dev/driver文件存在就认为打开成功。
(9) release,即close操作。
设备驱动程序所提供的入口点,在设备驱动程序初始化的时候向系统进行登记,以便系统在适当的时候调用。LINUX系统里,通过调用register_chrdev向系统注册字符型设备驱动程序。register_chrdev定义为:

#include <linux/fs.h>
#include <linux/errno.h>
int register_chrdev(unsigned int major, const char *name, struct file_operations *fops);

其中,major是为设备驱动程序向系统申请的主设备号,如果为0则系统为此驱动程序动态地分配一个主设备号。name是设备名。fops就是前面所说的对各个调用的入口点的说明。此函数返回0表示成功。返回-EINVAL表示申请的主设备号非法,一般来说是主设备号大于系统所允许的最大设备号。返回-EBUSY表示所申请的主设备号正在被其它设备驱动程序使用。如果是动态分配主设备号成功,此函数将返回所分配的主设备号。如果register_chrdev操作成功,设备名就会出现在/proc/devices文件里。
初始化部分一般还负责给设备驱动程序申请系统资源,包括内存、中断、时钟、I/O端口等,这些资源也可以在open子程序或别的地方申请。在这些资源不用的时候,应该释放它们,以利于资源的共享。在UNIX系统里,对中断的处理是属于系统核心的部分,因此如果设备与系统之间以中断方式进行数据交换的话,就必须把该设备的驱动程序作为系统核心
的一部分。设备驱动程序通过调用request_irq函数来申请中断,通过free_irq来释放中断。它们的定义为:

#include <linux/sched.h>
int request_irq(unsigned int irq,
            void (*handler)(int irq,void dev_id,struct pt_regs *regs),
            unsigned long flags,
            const char *device,
            void *dev_id);
void free_irq(unsigned int irq, void *dev_id);

参数irq表示所要申请的硬件中断号。handler为向系统登记的中断处理子程序,中断产生时由系统来调用,调用时所带参数irq为中断号,dev_id为申请时告诉系统的设备标识,regs为中断发生时寄存器内容。device为设备名,将会出现在/proc/interrupts文件里。flag是申请时的选项,它决定中断处理程序的一些特性,其中最重要的是中断处理程序是快速处理程序(flag里设置了SA_INTERRUPT)还是慢速处理程序(不设置SA_INTERRUPT),快速处理程序运行时,所有中断都被屏蔽,而慢速处理程序运行时,除了正在处理的中断外,其它中断都没有被屏蔽。
在LINUX系统中,中断可以被不同的中断处理程序共享,这要求每一个共享此中断的处理程序在申请中断时在flags里设置SA_SHIRQ,这些处理程序之间以dev_id来区分。如果中断由某个处理程序独占,则dev_id可以为NULL。request_irq返回0表示成功,返回-INVAL表示irq>15或handler==NULL,返回-EBUSY表示中断已经被占用且不能共享。作为系统核心的一部分,设备驱动程序在申请和释放内存时不是调用malloc和free,而代之以调用kmalloc和kfree,它们被定义为:

#include <linux/kernel.h>
void * kmalloc(unsigned int len, int priority);
void kfree(void * obj);

参数len为希望申请的字节数,obj为要释放的内存指针。priority为分配内存操作的优先级,即在没有足够空闲内存时如何操作,一般用GFP_KERNEL。与中断和内存不同,使用一个没有申请的I/O端口不会使CPU产生异常,也就不会导致诸如“segmentation fault"一类的错误发生。任何进程都可以访问任何一个I/O端口。此时系统无法保证对I/O端口的操作不会发生冲突,甚至会因此而使系统崩溃。因此,在使用I/O端口前,也应该检查此I/O端口是否已有别的程序在使用,若没有,再把此端口标记为正在使用,在使用完以后释放它。这样需要用到如下几个函数:

int check_region(unsigned int from, unsigned int extent);
void request_region(unsigned int from, unsigned int extent, const char *name);
void release_region(unsigned int from, unsigned int extent);

调用这些函数时的参数为:from表示所申请的I/O端口的起始地址;extent为所要申请的从from开始的端口数;name为设备名,将会出现在/proc/ioports文件里。check_region返回0表示I/O端口空闲,否则为正在被使用。
在申请了I/O端口之后,就可以如下几个函数来访问I/O端口:

#include <asm/io.h>
inline unsigned int inb(unsigned short port);
inline unsigned int inb_p(unsigned short port);
inline void outb(char value, unsigned short port);
inline void outb_p(char value, unsigned short port);

其中inb_p和outb_p插入了一定的延时以适应某些慢的I/O端口。在设备驱动程序里,一般都需要用到计时机制。在LINUX系统中,时钟是由系统接管,设备驱动程序可以向系统申请时钟。与时钟有关的系统调用有:

#include <asm/param.h>
#include <linux/timer.h>
void add_timer(struct timer_list * timer);
int  del_timer(struct timer_list * timer);
inline void init_timer(struct timer_list * timer);

struct timer_list的定义为:

struct timer_list {
               struct timer_list *next;
               struct timer_list *prev;
               unsigned long expires;
               unsigned long data;
               void (*function)(unsigned long d);
       };

其中expires是要执行function的时间。系统核心有一个全局变量JIFFIES表示当前时间,一般在调用add_timer时jiffies=JIFFIES+num,表示在num个系统最小时间间隔后执行function。系统最小时间间隔与所用的硬件平台有关,在核心里定义了常数HZ表示一秒内最小时间间隔的数目,则num*HZ表示num秒。系统计时到预定时间就调用function,并把此子程序从定时队列里删除,因此如果想要每隔一定时间间隔执行一次的话,就必须在function里再一次调用add_timer。function的参数d即为timer里面的data项。在设备驱动程序里,还可能会用到如下的一些系统函数:

#include <asm/system.h>
#define cli() __asm__ __volatile__ ("cli"::)
#define sti() __asm__ __volatile__ ("sti"::)

这两个函数负责打开和关闭中断允许。

#include <asm/segment.h>
void memcpy_fromfs(void * to,const void * from,unsigned long n);
void memcpy_tofs(void * to,const void * from,unsigned long n);

在用户程序调用read 、write时,因为进程的运行状态由用户态变为核心态,地址空间也变为核心地址空间。而read、write中参数buf是指向用户程序的私有地址空间的,所以不能直接访问,必须通过上述两个系统函数来访问用户程序的私有地址空间。memcpy_fromfs由用户程序地址空间往核心地址空间复制,memcpy_tofs则反之。参数to为复制的目的指针,from为源指针,n为要复制的字节数。在设备驱动程序里,可以调用printk来打印一些调试信息,用法与printf类似。printk打印的信息不仅出现在屏幕上,同时还记录在文件syslog里。

3.        LINUX系统下的具体实现
在LINUX里,除了直接修改系统核心的源代码,把设备驱动程序加进核心里以外,还可以把设备驱动程序作为可加载的模块,由系统管理员动态地加载它,使之成为核心地一部分。也可以由系统管理员把已加载地模块动态地卸载下来。
LINUX中,模块可以用C语言编写,用gcc编译成目标文件(不进行链接,作为*.o文件存在),为此需要在gcc命令行里加上-c的参数。在编译时,还应该在gcc的命令行里加上这样的参数:-D__KERNEL__ -DMODULE。由于在不链接时,gcc只允许一个输入文件,因此一个模块的所有部分都必须在一个文件里实现。编译好的模块*.o放在/lib/modules/xxxx/misc下(xxxx表示核心版本,如在核心版本为2.0.30时应该为/lib/modules/2.0.30/misc),然后用depmod -a使此模块成为可加载模块。模块用insmod命令加载,用rmmod命令来卸载,并可以用lsmod命令来查看所有已加载的模块的状态。
编写模块程序的时候,必须提供两个函数,一个是int init_module(void),供insmod在加载此模块的时候自动调用,负责进行设备驱动程序的初始化工作。init_module返回0以表示初始化成功,返回负数表示失败。另一个函数是voidcleanup_module (void),在模块被卸载时调用,负责进行设备驱动程序的清除工作。
在成功的向系统注册了设备驱动程序后(调用register_chrdev成功后),就可以用mknod命令来把设备映射为一个特别文件,其它程序使用这个设备的时候,只要对此特别文件进行操作就行了。

 

[目录]


数据接口卡


发信人: jecky (还年轻,日子长呢), 信区: KernelTech

我在做一块数据接口卡的驱动;
在open()函数里我分配了内核的一段内存作为缓冲区;
在release()里释放;
数据到达接口卡后,会 产生中断;
我在中断程序里面将数据存在缓冲区内;
在read()时读出数据缓冲区的数据。

在调试接收中断时,我遇到了问题;
我是在open函数的最后加了sti()函数;release里cli()
但在打印的内核信息中我看到进入中断函数是在调用release的后面;
这时我已经将分配的内存释放,从而出错;
我不明白为什么中断函数会在device close以后调用,
如何解决,高手请指教。

============================================================
发信人: mephisto (梦菲斯特:饼干), 信区: KernelTech

  没有注销掉中断处理程序

===========================================================
发信人: jecky (还年轻,日子长呢), 信区: KernelTech

你是指的freeirq么?
请解释清楚一点可以么,
我是新手。

==========================================================
发信人: mephisto (梦菲斯特:饼干), 信区: KernelTech

【 在 jecky (还年轻,日子长呢) 的大作中提到: 】
: 我在做一块数据接口卡的驱动;
: 在open()函数里我分配了内核的一段内存作为缓冲区;
: 在release()里释放;
: 数据到达接口卡后,会 产生中断;
: 我在中断程序里面将数据存在缓冲区内;
: 在read()时读出数据缓冲区的数据。
: 在调试接收中断时,我遇到了问题;
: 我是在open函数的最后加了sti()函数;release里cli()
中断平时就是开着的,您没必要手动的打开,当然也没必要手动的关闭。
确实需要原子操作的程序段,可以这样:
save_flags(flags)
cli()
...
..
restore_flags(flags)

===============================================================
发信人: mephisto (梦菲斯特:饼干), 信区: KernelTech


那个cli() sti()和DOS编程是不一样的.
不要指望cli()以后的影响是全局的.肯定是什么时候被系统改了,
而且这样是不对的,应该close就把divice handler 懈调,如果你不想进入你的
handler的话.

 

[目录]


代码

 

[目录]


标准范例

 

[目录]


header.c


/***********************************************************************
    Case study source code from the book `The Linux A to Z'
    by Phil Cornes. Published by Prentice Hall, 1996.
    Copyright (C) 1996 Phil Cornes

    This program is free software; you can redistribute it and/or modify
    it under the terms of the GNU General Public License as published by
    the Free Software Foundation; either version 2 of the License, or
    (at your option) any later version.

    This program is distributed in the hope that it will be useful,
    but WITHOUT ANY WARRANTY; without even the implied warranty of
    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
    GNU General Public License for more details.

    You should have received a copy of the GNU General Public License
    along with this program; if not, write to the Free Software
    Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
***********************************************************************/

/* 1 */
#define KERNEL

#include <linux/kernel.h>
#include <linux/sched.h>
#include <linux/tty.h>
#include <linux/signal.h>
#include <linux/errno.h>
#include <linux/malloc.h>

#include <asm/io.h>
#include <asm/segment.h>
#include <asm/system.h>
#include <asm/irq.h>

#include "tdd.h"

/* 2 */
static int tdd_trace;
static int write_busy;
static int read_busy;
static struct tdd_buf *qhead;
static struct tdd_buf *qtail;

/* 3 */
static int tdd_read(struct inode *, struct file *, char *, int);
static int tdd_write(struct inode *, struct file *, char *, int);
static int tdd_ioctl(struct inode *, struct file *, unsigned int,
unsigned long);
static int tdd_open(struct inode *, struct file *);
static void tdd_release(struct inode *, struct file *);
extern void console_print(char *);

struct file_operations tdd_fops =
{
    NULL,
    tdd_read,
    tdd_write,
    NULL,
    NULL,
    tdd_ioctl,
    NULL,
    tdd_open,
    tdd_release,
    NULL,
    NULL,
    NULL,
    NULL
};

[目录]


init.c


/***********************************************************************
    Case study source code from the book `The Linux A to Z'
    by Phil Cornes. Published by Prentice Hall, 1996.
    Copyright (C) 1996 Phil Cornes

    This program is free software; you can redistribute it and/or modify
    it under the terms of the GNU General Public License as published by
    the Free Software Foundation; either version 2 of the License, or
    (at your option) any later version.

    This program is distributed in the hope that it will be useful,
    but WITHOUT ANY WARRANTY; without even the implied warranty of
    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
    GNU General Public License for more details.

    You should have received a copy of the GNU General Public License
    along with this program; if not, write to the Free Software
    Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
***********************************************************************/

void tdd_init(void)
{
    tdd_trace = TRUE;

    if (register_chrdev(30, "tdd", &tdd_fops))
        TRACE_TXT("Cannot register tdd driver as major device 30")
    else
        TRACE_TXT("Tiny device driver registered successfully")

    qhead = 0;
    write_busy = FALSE;
    read_busy = FALSE;
    tdd_trace = FALSE;
    return;
}

[目录]


ioctl.c


/***********************************************************************
    Case study source code from the book `The Linux A to Z'
    by Phil Cornes. Published by Prentice Hall, 1996.
    Copyright (C) 1996 Phil Cornes

    This program is free software; you can redistribute it and/or modify
    it under the terms of the GNU General Public License as published by
    the Free Software Foundation; either version 2 of the License, or
    (at your option) any later version.

    This program is distributed in the hope that it will be useful,
    but WITHOUT ANY WARRANTY; without even the implied warranty of
    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
    GNU General Public License for more details.

    You should have received a copy of the GNU General Public License
    along with this program; if not, write to the Free Software
    Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
***********************************************************************/

static int tdd_ioctl(struct inode *inode, struct file *file,
unsigned int cmd, unsigned long arg)
{
    TRACE_TXT("tdd_ioctl")

    switch(cmd)
    {
    case TDD_TRON:
        tdd_trace = TRUE;
        return 0;

    case TDD_TROFF:
        tdd_trace = FALSE;
        return 0;

    default:
        return -EINVAL;
    }
}

[目录]


open.c


/***********************************************************************
    Case study source code from the book `The Linux A to Z'
    by Phil Cornes. Published by Prentice Hall, 1996.
    Copyright (C) 1996 Phil Cornes

    This program is free software; you can redistribute it and/or modify
    it under the terms of the GNU General Public License as published by
    the Free Software Foundation; either version 2 of the License, or
    (at your option) any later version.

    This program is distributed in the hope that it will be useful,
    but WITHOUT ANY WARRANTY; without even the implied warranty of
    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
    GNU General Public License for more details.

    You should have received a copy of the GNU General Public License
    along with this program; if not, write to the Free Software
    Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
***********************************************************************/

static int tdd_open(struct inode *inode, struct file *file)
{
    TRACE_TXT("tdd_open")

    /* 1 */
    switch (MINOR(inode->i_rdev))
    {
    /* 2 */
    case TDD_WRITE:
        if (write_busy)
            return -EBUSY;
        else
            write_busy = TRUE;
            return 0;

    /* 3 */
    case TDD_READ:
        if (read_busy)
            return -EBUSY;
        else
            read_busy = TRUE;
            return 0;

    default:
        return -ENXIO;
    }
}

[目录]


read.c


/***********************************************************************
    Case study source code from the book `The Linux A to Z'
    by Phil Cornes. Published by Prentice Hall, 1996.
    Copyright (C) 1996 Phil Cornes

    This program is free software; you can redistribute it and/or modify
    it under the terms of the GNU General Public License as published by
    the Free Software Foundation; either version 2 of the License, or
    (at your option) any later version.

    This program is distributed in the hope that it will be useful,
    but WITHOUT ANY WARRANTY; without even the implied warranty of
    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
    GNU General Public License for more details.

    You should have received a copy of the GNU General Public License
    along with this program; if not, write to the Free Software
    Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
***********************************************************************/

static int tdd_read(struct inode *inode, struct file *file,
char *buffer, int count)
{
    int i, len;
    struct tdd_buf *ptr;

    TRACE_TXT("tdd_read")

    /* 1 */
    if (MINOR(inode->i_rdev)!=TDD_READ)
        return -EINVAL;

    /* 2 */
    if (qhead==0)
        return -ENODATA;

    /* 3 */
    ptr = qhead;
    qhead = qhead->link;

    /* 4 */
    len = count<ptr->buf_size?count:ptr->buf_size;

    if (verify_area(VERIFY_WRITE, buffer, len))
        return -EFAULT;

    for (i = 0; i<count && i<ptr->buf_size; ++i)
    {
        put_user_byte(ptr->buffer[i], buffer+i);
        TRACE_CHR("r")
    }

    TRACE_CHR("/n")

    /* 5 */
    kfree_s(ptr, sizeof(struct tdd_buf));
    return i;
}

[目录]


release.c


/***********************************************************************
    Case study source code from the book `The Linux A to Z'
    by Phil Cornes. Published by Prentice Hall, 1996.
    Copyright (C) 1996 Phil Cornes

    This program is free software; you can redistribute it and/or modify
    it under the terms of the GNU General Public License as published by
    the Free Software Foundation; either version 2 of the License, or
    (at your option) any later version.

    This program is distributed in the hope that it will be useful,
    but WITHOUT ANY WARRANTY; without even the implied warranty of
    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
    GNU General Public License for more details.

    You should have received a copy of the GNU General Public License
    along with this program; if not, write to the Free Software
    Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
***********************************************************************/

static void tdd_release(struct inode *inode, struct file *file)
{
    TRACE_TXT("tdd_release")

    switch (MINOR(inode->i_rdev))
    {
    case TDD_WRITE:
            write_busy = FALSE;
            return;

    case TDD_READ:
            read_busy = FALSE;
            return;
    }
}

[目录]


tdd.h


/***********************************************************************
    Case study source code from the book `The Linux A to Z'
    by Phil Cornes. Published by Prentice Hall, 1996.
    Copyright (C) 1996 Phil Cornes

    This program is free software; you can redistribute it and/or modify
    it under the terms of the GNU General Public License as published by
    the Free Software Foundation; either version 2 of the License, or
    (at your option) any later version.

    This program is distributed in the hope that it will be useful,
    but WITHOUT ANY WARRANTY; without even the implied warranty of
    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
    GNU General Public License for more details.

    You should have received a copy of the GNU General Public License
    along with this program; if not, write to the Free Software
    Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
***********************************************************************/

#ifdef KERNEL                            /* If we're in kernel code */

#define TRACE_TXT(text) /
    { /
        if (tdd_trace) /
        { /
            console_print(text); /
            console_print("/n"); /
        } /
    }

#define TRACE_CHR(chr) /
    { /
        if (tdd_trace) /
            console_print(chr); /
    }

#define TDD_WRITE 0                /* /dev/tddw minor device number */
#define TDD_READ 1                 /* /dev/tddr minor device number */

#endif

#define FALSE 0
#define TRUE 1
#define MAX_BUF 120                /* Size of struct tdd_buf buffer */
#define TDD_TRON (('M'<<8)|0x01)        /* Trace on cmd for ioctl() */
#define TDD_TROFF (('M'<<8)|0x02)      /* Trace off cmd for ioctl() */

struct tdd_buf
{
    int buf_size;
    char buffer[MAX_BUF];
    struct tdd_buf *link;
};

[目录]


write.c


/***********************************************************************
    Case study source code from the book `The Linux A to Z'
    by Phil Cornes. Published by Prentice Hall, 1996.
    Copyright (C) 1996 Phil Cornes

    This program is free software; you can redistribute it and/or modify
    it under the terms of the GNU General Public License as published by
    the Free Software Foundation; either version 2 of the License, or
    (at your option) any later version.

    This program is distributed in the hope that it will be useful,
    but WITHOUT ANY WARRANTY; without even the implied warranty of
    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
    GNU General Public License for more details.

    You should have received a copy of the GNU General Public License
    along with this program; if not, write to the Free Software
    Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
***********************************************************************/

static int tdd_write(struct inode *inode, struct file *file,
char *buffer, int count)
{
    int i, len;
    struct tdd_buf *ptr;

    TRACE_TXT("tdd_write")

    /* 1 */
    if (MINOR(inode->i_rdev)!=TDD_WRITE)
        return -EINVAL;

    /* 2 */
    if ((ptr = kmalloc(sizeof(struct tdd_buf), GFP_KERNEL))==0)
        return -ENOMEM;

    /* 3 */
    len = count<MAX_BUF?count:MAX_BUF;

    if (verify_area(VERIFY_READ, buffer, len))
        return -EFAULT;

    for (i = 0; i<count && i<MAX_BUF; ++i)
    {
        ptr->buffer[i] = get_user_byte(buffer+i);
        TRACE_CHR("w")
    }

    /* 4 */
    ptr->link = 0;

    if (qhead==0)
        qhead = ptr;
    else
        qtail->link = ptr;

    qtail = ptr;
    TRACE_CHR("/n")

    /* 5 */
    ptr->buf_size = i;
    return i;
}

[目录]


Sis 900


SIS 900 是一个可以用来实作 10/100 网络卡的控制芯片。它提供了对 PCI mastermode , MII, 802.3x 流量控制等各种标准的支援。这篇文章将告诉大家,如何写一个 Linux 的网络驱动程序,它将比大家想像中简单很多。这篇文章将以 Linux 2.4 版为对象, 2.2 版提供的界面略有不同,但差别并不太大,读完本文后再读 2.2 版的程序码应该不会有太大困难才是。 本文所参考的驱动程序是在 2.4.3 版中 drivers/net/sis900.c 这个档案。你可以在 http://xxx.xxx.xxx.xxx/linux-2.4.3/drivers/net/sis900.c 找到它。如果你能有一份硬件的 databook 在手边,读起驱动程序的码可能会更简单。 SIS900的 databook 可以直接在http://www.sis.com.tw/ftp/Databook/900/sis900.exe下载。

PCI 驱动程序
对一个 PCI 驱动程序而言, Linux 提供了很完整的支援,大部份的 PCI 资讯都由内建的程序读出。对个别的驱动程序而言直接使用就可以了。所以在这个部份,唯一要做的事只是告知 PCI 子系统一个新的驱动程序己经被加入系统之中了。在档案的最末端,你会看到下面的程序,

static struct pci_driver sis900_pci_driver = {
        name:           SIS900_MODULE_NAME,
        id_table:       sis900_pci_tbl,
        probe:          sis900_probe,
        remove:         sis900_remove,
};
static int __init sis900_init_module(void)
{
        printk(KERN_INFO "%s", version);
        return pci_module_init(&sis900_pci_driver);
}
static void __exit sis900_cleanup_module(void)
{
        pci_unregister_driver(&sis900_pci_driver);
}

pci_module_init 是用来向 PCI 子系统注册一个 PCI 驱动程序。根据 id_table 中所提供的资料, PCI 子系统会在发现符合驱动程序要求的装置时使用它。那 PCI 子系统如何做到这件事呢 ? 我们先看一下 id_table 的内容就很清楚了。

static struct pci_device_id sis900_pci_tbl [] __devinitdata = {
        {PCI_VENDOR_ID_SI, PCI_DEVICE_ID_SI_900,
         PCI_ANY_ID, PCI_ANY_ID, 0, 0, SIS_900},
        {PCI_VENDOR_ID_SI, PCI_DEVICE_ID_SI_7016,
         PCI_ANY_ID, PCI_ANY_ID, 0, 0, SIS_7016},
        {0,}
};
MODULE_DEVICE_TABLE (pci, sis900_pci_tbl);

看懂了吗 ? 嗯,我想你懂了。不过我还是解释一下。前面四个分别是

vendor id : PCI_VENDOR_ID_SI
device id : PCI_DEVICE_ID_SI_900
sub vendor id : PCI_ANY_ID
sub device id : PCI_ANY_ID

意思是说这个驱动程序支援 SIS 出的 SIS900 系列所有的硬件,我们不介意 subvendor id 和 sub device id 。你可以加入任何你想要的项目。对于不同的网络卡制造商,它们可能会有不同的 sub vendor id 和 sub device id 。但只要它们用SIS900 这个芯片,那这个驱动程序就可能适用。我们可以说这是一个『公版』的驱动程序。初始化好了,那其它的部份呢 ? 还记意 sis900_pci_driver 中其它的二个项目 probe 和remove 吗 ? 它们是用来初始化和移除一个驱动程序的呼叫。你可以把它们想成驱动程序物件的 constructor 和 destructor 。在 probe 中,你应该由硬件中把一些将来可能会用到的资讯准备好。由于这是一个 PCI 驱动程序,你不必特意去检查装置是否真的存在。但如果你的驱动程序只支援某些特定的硬件,或是你想要检查系统中是否有一些特别的硬件存在,你可以在这里做。例如在这个驱动程序中,对不同版本的硬件,我们用不
同的方法去读它的 MAC 位址。
         pci_read_config_byte(pci_dev, PCI_CLASS_REVISION, &revision);
        if (revision == SIS630E_900_REV || revision == SIS630EA1_900_REV)
                ret = sis630e_get_mac_addr(pci_dev, net_dev);
        else if (revision == SIS630S_900_REV)
                ret = sis630e_get_mac_addr(pci_dev, net_dev);
        else
                ret = sis900_get_mac_addr(pci_dev, net_dev);
对于 SIS630E SIS630EA1 和 SIS630S 这些整合式芯片而言,其 MAC 位址被储存在 APC CMOS RAM 之中。但对其它独立的芯片而言则是存在网络卡的 EEPROM 之上。为了不要让这篇文章像流水帐一般,我不仔细的说明 probe 的过程。大家自己揣摸一下吧 !

在 probe 中还有一段比较和后文有关的程序码
         net_dev->open = &sis900_open;
        net_dev->hard_start_xmit = &sis900_start_xmit;
        net_dev->stop = &sis900_close;
        net_dev->get_stats = &sis900_get_stats;
        net_dev->set_config = &sis900_set_config;
        net_dev->set_multicast_list = &set_rx_mode;
        net_dev->do_ioctl = &mii_ioctl;
        net_dev->tx_timeout = sis900_tx_timeout;
        net_dev->watchdog_timeo = TX_TIMEOUT;
我想这很清楚,我们透过 net_dev 这个结构告诉 Linux 网络子系统如何来操作这个装置。当你使用 ifconfig 这个 R 令时,系统会使用 sis900_open 打开这个驱动程序,并使用 set_config 来说定装置的参数,如 IP address 。当有资料需要被传送时, sis900_start_xmit 被用来将资料送入装置之中。接下来,我们就一一的检视这些函数。

初始化装置
sis900_open(struct net_device *net_dev);

这个函数会在我们使用 ifconfig 将一网络装置激活时被呼叫。当驱动程序被插入系统之后,通常并不会马上开始接收或传送封包。一般来说,在 probe 的阶段,我们只是单纯的判断装置是否存在。实际激活硬件的动作在这里才会被实际执行。以 SIS900 为例,在其硬件中只有一个大约 2K 的缓冲区。也就是说在装置上只有一个
封包的缓冲区。当一个封包被传送后,装置必须产生一个中断要求操作系统将下一个封包传入。如果由中断到中断驱动程序被执行需要 5ms 的时间,那一秒至多我们可以送出 200 个封包。也就是说网络传送是不可能大于 400K/s ,这对于一般的情况下是不太可能接受的事。SIS900 虽然在装置上只有很小的缓冲区,但它可以透过 PCI master 模式直接控制主机板上的记忆体。事实上,它使用下面的方式来传送资料。你必须在记忆体中分配一组串接成环状串列的缓冲区,然后将 TXDP 指向缓冲区的第一个位址。 SIS900 会在第一个缓冲区传送完后自动的由第二个缓冲区取资料,并更新记忆中的资料将己传送完缓冲区的 OWN 位元清除。当 CPU 将缓冲区串列设定完成后,这个动作可以在完全没有 CPU 的介入下完成。所以硬件不必等待作业系统将新的资料送入,而可以连续的送出多个封包。操作系统只要能来的及让环状串列不会进入空的状态就可以了。

同样的,我们也需要一个接收缓冲区,使用进来的封包不至因操作系统来不及处理而遗失。在 sis900_open 中, sis900_init_rx_ring 和 sis900_init_tx_ring 就是用来负处初始化这二个串列。
在初始化串列之后,我们便可以要求 SIS900 开始接收封包。下面二行程序码便是用来做这件事。

  outl((RxSOVR|RxORN|RxERR|RxOK|TxURN|TxERR|TxIDLE), ioaddr + imr);
  outl(RxENA, ioaddr + cr);
  outl(IE, ioaddr + ier);

第一行设定硬件在下列情况发出一个系统中断,
接收失败时
接收成功 时
传送失败时
所有缓冲区中的资料都传送完时
第二行则告诉硬件操作系统己经准备好要接收资料了。第三行则时硬件实际开始送出中断。
在这个函数的最后,我们安装一个每秒执行五次的 timer 。在它的处理函数 sis900_timer 中,我们会检查目前的连结状态,这包括了连结的种类 (10/100)和连接的状态 ( 网络卡是否直的被接到网络上去 ) 。
如果各位用过 Window 2000 ,另人印象最深刻的是当你将网络线拔出时, GUI 会自动警言网络己经中断。其实 Linux 也可以做到这件事,只是你需要一个比较好的图形界面就是了。
传送一个封包的 descriptor 给网络卡

sis900_start_xmit(struct sk_buff *skb, struct net_device *net_dev);

这个函数是用来将一个由 skb 描述的网络资料缓冲区送进传送缓冲区中准备传送。其中最重要的程序码为

    sis_priv->tx_ring[entry].bufptr = virt_to_bus(skb->data);
    sis_priv->tx_ring[entry].cmdsts = (OWN | skb->len);
    outl(TxENA, ioaddr + cr);

SIS900 会使用 DMA 由缓冲区中取得封包的资料。由于缓冲区的数目有限,我们必须在缓冲区用完的时后告诉上层的网络协定不要再往下送资料了。在这里我们用下面的程序来做这件事。

     if (++sis_priv->cur_tx - sis_priv->dirty_tx < NUM_TX_DESC) {
        netif_start_queue(net_dev);
    } else {
        sis_priv->tx_full = 1;
        netif_stop_queue(net_dev);
    }

netif_start_queue 用来告诉上层网络协定这个驱动程序还有空的缓冲区可用,请把下一个封包送进来。 netif_stop_queue 则是用来告诉上层网络协定所有的封包都用完了,请不要再送。

接收一个或多个封包
int sis900_rx(struct net_device *net_dev);

这个函式在会在有封包进入系统时被呼叫,因为可能有多于一个的封包在缓冲区之中。这个函数会逐一检查所有的缓冲区,直到遇到一个空的缓冲区为止。当我们发现一个有资料的缓冲区时,我们需要做二件事。首先是告知上层网络协定有一个新的封包进入系统,这件事由下面的程序完成

               skb = sis_priv->rx_skbuff[entry];
               skb_put(skb, rx_size);
               skb->protocol = eth_type_trans(skb, net_dev);
               netif_rx(skb);
前三行根据封包的内容更新 skbuff 中的档头。最后一行则是正式通知上层处理封包。

请注意 Linux 为了增加处理效能,在 netif_rx 并不会真的做完整接收封包的动作,而只是将这个封包记下来。真实的动作是在 bottom half 中才去处理。因为如此,原先储存封包的缓冲区暂时不能再被使用,我们必须重新分配一个新的缓冲区供下一个封包使用。下面的程序码是用来取得一个新的缓冲区。

      if ((skb = dev_alloc_skb(RX_BUF_SIZE)) == NULL) {
          sis_priv->rx_skbuff[entry] = NULL;
          sis_priv->rx_ring[entry].cmdsts = 0;
          sis_priv->rx_ring[entry].bufptr = 0;
          sis_priv->stats.rx_dropped++;
          break;
     }
     skb->dev = net_dev;
     sis_priv->rx_skbuff[entry] = skb;
     sis_priv->rx_ring[entry].cmdsts = RX_BUF_SIZE;
     sis_priv->rx_ring[entry].bufptr = virt_to_bus(skb->tail);
     sis_priv->dirty_rx++;

这个函数其馀的部份其实只是用来记录一些统计资料而己。
传送下一个封包

void sis900_finish_xmit (struct net_device *net_dev);

这个函数用来处理传送中断。在收到一个 TX 中断,表示有一个或多数缓冲区中的资料己经传送完成。我们可以把原先的缓冲区释出来供其它的封包使用,并且用下面的程序告诉上层协定可以送新的封包下来了。

     if (sis_priv->tx_full && netif_queue_stopped(net_dev) &&
        sis_priv->cur_tx - sis_priv->dirty_tx < NUM_TX_DESC - 4) {
        sis_priv->tx_full = 0;
        netif_wake_queue (net_dev);
    }

netif_wake_queue() 会使得上层协定开始传送新的资料下来。

改变装置的设定

int sis900_set_config(struct net_device *dev, struct ifmap *map);

处理由 ifconfig 送来的命令,在驱动程序中我们通常只处理 media type的改变。这个函数会根据 ifconfig 送来的值改变 MII 控制器的 media tyep ,你可以使用

     # ifconfig eth0 media 10basT

将目前的输出入界面强迫改到 10basT 。对于某些自动媒体检测做的有问题的switch 而言这可能是必要的设定,但一般而言默认的 auto 是最好的设定。硬件会自动决定要使用那一个界面,使用者完全不必担心,当实体层的设定改变 ( 例如将网络线插到不同的地方 ) ,硬件会自动侦测并改变设定。

void set_rx_mode(struct net_device *net_dev);

改变目前封包过滤器的模式。当你使用

      # ifconfig eth0 promisc
      # ifconfig eth0 multicast

等命令时会被呼叫。一般而言,驱动程序的默认值是只接受目的位址和网络卡的 MAC address 相同的封包。你可以透过 ifconfig 命令控制驱动程序接受其它种类的封包。结语好了 ! 我己经解析完整个网络卡的驱动程序了。当你了解这个驱动程序后,再去了解其它的驱动程序变成一件很简单的事情。大部份网络驱动程序的架构其实都很类似。事实上, Linux 早期的网络卡驱动程序几乎是由同一个人完成的。而后来的驱动程序也几乎
都以这些驱动程序为蓝本,所以看起来都很类似。你要不要也试著再去读另一个网络驱动程序的源代码呢 ? 也许 你会开始抱怨怎么写驱动程序这么神秘的东西怎么变得如此简单了 !

多馀的一节
这一节多馀的,你不想看就算了 :-) 为了证明网络驱动程序之间有多类似我再简略的trace Intel eepro100 的驱程程序给大家看。不罗唆,马上开始。

初始化
static struct pci_device_id eepro100_pci_tbl[] __devinitdata = {
        { PCI_VENDOR_ID_INTEL, PCI_DEVICE_ID_INTEL_82557,
                PCI_ANY_ID, PCI_ANY_ID, },
        { PCI_VENDOR_ID_INTEL, PCI_DEVICE_ID_INTEL_82559ER,
                PCI_ANY_ID, PCI_ANY_ID, },
        { PCI_VENDOR_ID_INTEL, PCI_DEVICE_ID_INTEL_ID1029,
                PCI_ANY_ID, PCI_ANY_ID, },
        { PCI_VENDOR_ID_INTEL, PCI_DEVICE_ID_INTEL_ID1030,
                PCI_ANY_ID, PCI_ANY_ID, },
        { PCI_VENDOR_ID_INTEL, PCI_DEVICE_ID_INTEL_82820FW_4,
                PCI_ANY_ID, PCI_ANY_ID, },
        { 0,}
};
MODULE_DEVICE_TABLE(pci, eepro100_pci_tbl);
tatic struct pci_driver eepro100_driver = {
        name:           "eepro100",
        id_table:       eepro100_pci_tbl,
        probe:          eepro100_init_one,
        remove:         eepro100_remove_one,
#ifdef CONFIG_EEPRO100_PM
        suspend:        eepro100_suspend,
        resume:         eepro100_resume,
#endif
};
return pci_module_init(&eepro100_driver);

嗯 ! 一切都不出意类之外,是吧 !
初始化装置

eepro100_init_one()

这个看起来比 SIS900 的复杂多了。不过几个关鉴的函数还是一样,只是它的程序码看起比较乱。 BSD 的人喜欢说 Linux 的程序码太乱 ! 嗯,好像不承认不行 :-) 不过我说它乱的很可爱,行了吧 !

传送封包
speedo_start_xmit(struct sk_buff *skb, struct net_device *dev)

这个函数相似到我不必做任何讲解,也不必有任何文件你就可以知道它在做些什么事了 ! 程序码几乎到了一行对一行的程度 ( 夸张了一点 ! 不过很接近事实。我信相 SIS900 的 driver 是很整个程序 copy 过去再修改的 )

中断处理

void speedo_interrupt(int irq, void *dev_instance, struct pt_regs *regs);

这个函数,我再喜欢 Linux 也不得不抱怨一下了。 Donald Becker 先生,能麻烦程序写的好看一点好吗 ?
基本上,它把 sis900_rx 的内容直接放在中断处理函数之中。不过我想分开还是会清楚一些。

speedo_tx_buffer_gc 基本上就是 sis900_finish_xmit 。下面的程序是不是很眼熟呢 ?

     dirty_tx = sp->dirty_tx;
     while ((int)(sp->cur_tx - dirty_tx) > 0) {
        int entry = dirty_tx % TX_RING_SIZE;
        int status = le32_to_cpu(sp->tx_ring[entry].status);
        }

连变数名字都很像呢 !

不过 eepro100 的驱动程序没有实作 set_config 的界面,所以你不能用ifconfig 来改变 media type 。不过 eepro100 提供了由模块命令列选项改变的功 能,当然它是不及 set_config 来的方便就是了。
还要再来一个吗 ? 你自己去做吧 !

[目录]


网上站点


short.xilubbs.com

专门研究linux驱动设计的bbs

 

[目录]


经验

 

[目录]


AKA推荐书籍


====================================================================
《The Design of The UNIX Operating System》 Author: Maurice J. Bach
中译本:《UNIX 操作系统设计》
---------------------
翻译者:陈葆钰等
北大版: 32开,黄皮,9.40¥
机工版: 16开,褐皮,30¥
---------------------
一本老书,但绝对是bible级的。其内容覆盖了经典UNIX操作系统中的所有基本概念
以及设计思想。阅读者最好能懂一些基本的操作系统理论知识。
====================================================================

====================================================================
《Unix Internals - The New Frontiers》 Author: Uresh Vahalia
中译本:《UNIX 高级教程:系统技术内幕》
---------------------
翻译者:聊鸿斌等
清华大学出版社出版,16开,桔皮,58¥
---------------------
一本新书,也是bible级的。其主要特点是80%的内容都是现代UNIX操作系统的新思想
和新概念。对各UNIX大家的精彩设计点都有很详尽的阐述。阅读者最好先看看贝奇那
本书。
====================================================================

====================================================================
《Linux Core Kernel Commentary》
---------------------
Author: Scott Maxwell
---------------------
有中译本,但具体信息不详 对照源码讲Linux内核,版本还比较高,2.2.X。有些新
东西可看看。可惜没讲网络部分的实现。
====================================================================

====================================================================
《Linux Kernel Internals: 2nd version》
---------------------
Author: M Beck ...
---------------------
目前无中译本 以数据结构为主体来介绍内核,内容很丰富,但版本太低(2.0.x),有
些陈旧的东西容易令人误入歧途。
====================================================================

====================================================================
《The Design and Implementation of the 4.4BSD Operating System》
---------------------
Author: McKusick, Bostic, Karels, Quarterman
---------------------
目前无中译本  讲述BSD操作系统最权威的书。书的作者亦即BSD最早的几名开发者。
====================================================================

====================================================================
《Linux 操作系统及实验教程》
---------------------
作者:李善平,郑扣根(浙大教师)
机工出版
---------------------
有些内容不错,讲得还比较深入。也缺少网络部分的描述。
====================================================================

====================================================================
《UNIX 系统下的80386》
---------------------
作者:周明德, 张淑玲
清华出版
---------------------
讲X86的体系结构。要想看懂/arch/i386下的辕马,最好先看看这本书。
====================================================================

====================================================================
《UNIX Systems for Modern Architectures》
---------------------
Author: Curt Schimmel
---------------------
目前无中译本  如果想了解辕马中SMP的实现。可参考看这本书。
====================================================================

====================================================================
《保护模式下的80386及其编程》
---------------------
出版社:清华大学出版社
---------------------
本书全面地介绍了80386的结构。首先是80386实模式和保护模式下的寄存器集和
指令集,接着从保护模式下的虚存管理、保护级、多任务支持、中断和异常等方
面深入地剖析386的强大功能,再接着提供几个典型的编程实例以及一个完整的从
386加电初始化开始到形成一个有基本的多任务和虚拟存储能力的系统的例子并作
了详细解释,最后还清楚地说明了80386与8086/80286的兼容性和差别。本书的特
点是严谨深入,对CPU各种条件下的动作和反应用形式化的微程序讲解得十分清楚,
尤其适合系统程序员阅读。总之,这实在是一本不可多得的好书.

====================================================================

====================================================================
《Linux 操作系统的内核分析》 作者:陈莉君编著
---------------------
价格:40 元
出版社:人民邮电出版社
---------------------

====================================================================

[目录]


linux论坛推荐资源


~~~~~~~
一般文献
~~~~~~~
利索脚组织的网站:
http://www.lisoleg.net

linux kernel internals 2.4(不是特别全)

http://www.moses.uklinux.net/patches/lki.html
http://tzhang.xiloo.com/unix/kernel/

UNIX高级教程 系统技术内幕
Uresh Vahalia 清华大学出版社

书。这是一本非常好的书,思想性很强,对学习Linux以及操作系统非常有帮助。

Understanding the Linux Kernel
Daniel P. Bovet  Marco Cesati
O'Reilly出版

超级宝书!:-)2001年内会有中译本。
这里是第10章
Process Scheduling

Linux 操作系统及实验教程
李善平 郑扣根 编著
机械工业出版社

Linux 操作系统的内核分析
陈莉君编著
人民邮电出版社

Linux Device Driver

书。有中译本。帮助理解中断,任务队列等内核机制,帮助掌握驱动编程。

Operating Systems
resource center
jkl 推荐

关于操作系统的介绍,有许多专题文章

http://www.nondot.org/sabre//os/

关于Linux的重要链接
Pengcheng Zou 推荐

给出了许多重要的链接

http://www.linuxlinks.com/Kernel/

非常完备的CPU开发手册

Intel Architecture Software Developer’s Manual
Volume 3:
System Programming

" target="_new">http://developer.intel.com/design/pentiumii/manuals/24319202.pdf

对i386的机制讲得非常详细,可以帮助深入了解i386保护模式机制,对理解Linux的相关实现非常有帮助

~~~~~~~
关于内存
~~~~~~~

Outline of the Linux Memory Management System
黑饭 推荐

http://home.earthlink.net/~jknapka/linux-mm/vmoutline.html

已经是一个比较细致的介绍内存(包括内核的和用户空间的)了。

SGI公司的公开项目

http://oss.sgi.com/projects/

SGI公司的关于伸缩性的技术非常棒!Linux的NUMA就是由他们做的,这是他们的网页

Linux内存开发小组的网站
jkl 推荐

http://www.linux-mm.org

这是Linux负责开发内存管理的核心成员的网站
下面有他们关于zone设计思想的描述:

http://surriel.com/zone-alloc.html

~~~~~~~
关于中断
~~~~~~~

关于中断上锁的专题文档

http://netfilter.kernelnotes.org/unreliable-guides/kernel-locking/lklockingguide.html

我们知道在中断中写程序要小心,不小心会发生race condition.这篇文献对这方面做了介绍

~~~~~~~~~~
关于文件系统
~~~~~~~~~~

Linux Commentary
dream_seeker 推荐

http://www.cse.unsw.edu.au/~neilb/oss/linux-commentary/

主要介绍文件系统, 另外,下面的

linux-vm-readme

主要介绍VM和交换,也很值得一看

 


关于汇编
[http://www.linuxassembly.org http://www.linuxassembly.org ]
Linuxkernel推荐


关于AT

http://www-106.ibm.com/developerworks/linux/library/l-ia.html
lisoleg推荐

关于汇编:
http://www-aig.jpl.nasa.gov/public/home/decoste/HTMLS/GNU/binutils/as_toc.html
http://www.linuxassembly.org/resources.html#tutorials
lucian推荐


Edited by lucian_yao on 05/20/01 08:05 PM.

 

[目录]


数据结构


一下是linux操作系统核心常用的数据结构

block_dev_struct
此结构用于向核心登记块设备,它还被buffer
cache实用。所有此类结构都位于blk_dev数组中。
struct blk_dev_struct {
    void (*request_fn)(void);
    struct request * current_request;
    struct request   plug;
    struct tq_struct plug_tq;
};
buffer_head
此结构包含关于buffer cache中一块缓存的信息。
/* bh state bits */
#define BH_Uptodate  0   /* 1 if the buffer contains valid data      */
#define BH_Dirty     1   /* 1 if the buffer is dirty                 */
#define BH_Lock      2   /* 1 if the buffer is locked                */
#define BH_Req       3   /* 0 if the buffer has been invalidated     */
#define BH_Touched   4   /* 1 if the buffer has been touched (aging) */
#define BH_Has_aged  5   /* 1 if the buffer has been aged (aging)    */
#define BH_Protected 6   /* 1 if the buffer is protected             */
#define BH_FreeOnIO  7   /* 1 to discard the buffer_head after IO    */
struct buffer_head {
  /* First cache line: */
  unsigned long      b_blocknr;    /* block number                   */
  kdev_t             b_dev;        /* device (B_FREE = free)         */
  kdev_t             b_rdev;       /* Real device                    */
  unsigned long      b_rsector;    /* Real buffer location on disk   */
  struct buffer_head *b_next;      /* Hash queue list                */
  struct buffer_head *b_this_page; /* circular list of buffers in one
                                      page                           */
  /* Second cache line: */
  unsigned long      b_state;      /* buffer state bitmap (above)    */
  struct buffer_head *b_next_free;
  unsigned int       b_count;      /* users using this block         */
  unsigned long      b_size;       /* block size                     */
  /* Non-performance-critical data follows. */
  char               *b_data;      /* pointer to data block          */
  unsigned int       b_list;       /* List that this buffer appears  */
  unsigned long      b_flushtime;  /* Time when this (dirty) buffer
                                    * should be written              */
  unsigned long      b_lru_time;   /* Time when this buffer was
                                    * last used.                     */
  struct wait_queue  *b_wait;
  struct buffer_head *b_prev;      /* doubly linked hash list        */
  struct buffer_head *b_prev_free; /* doubly linked list of buffers  */
  struct buffer_head *b_reqnext;   /* request queue                  */
};
device
系统中每个网络设备都用一个设备数据结构来表示。
struct device
{
  /*
   * This is the first field of the "visible" part of this structure
   * (i.e. as seen by users in the "Space.c" file).  It is the name
   * the interface.
   */
  char                    *name;
  /* I/O specific fields                                           */
  unsigned long           rmem_end;        /* shmem "recv" end     */
  unsigned long           rmem_start;      /* shmem "recv" start   */
  unsigned long           mem_end;         /* shared mem end       */
  unsigned long           mem_start;       /* shared mem start     */
  unsigned long           base_addr;       /* device I/O address   */
  unsigned char           irq;             /* device IRQ number    */
  /* Low-level status flags. */
  volatile unsigned char  start,           /* start an operation   */
                          interrupt;       /* interrupt arrived    */
  unsigned long           tbusy;           /* transmitter busy     */
  struct device           *next;
  /* The device initialization function. Called only once.         */
  int                     (*init)(struct device *dev);
  /* Some hardware also needs these fields, but they are not part of
     the usual set specified in Space.c. */
  unsigned char           if_port;         /* Selectable AUI,TP,   */
  unsigned char           dma;             /* DMA channel          */
  struct enet_statistics* (*get_stats)(struct device *dev);
  /*
   * This marks the end of the "visible" part of the structure. All
   * fields hereafter are internal to the system, and may change at
   * will (read: may be cleaned up at will).
   */
  /* These may be needed for future network-power-down code.       */
  unsigned long           trans_start;     /* Time (jiffies) of
                                              last transmit        */
  unsigned long           last_rx;         /* Time of last Rx      */
  unsigned short          flags;           /* interface flags (BSD)*/
  unsigned short          family;          /* address family ID    */
  unsigned short          metric;          /* routing metric       */
  unsigned short          mtu;             /* MTU value            */
  unsigned short          type;            /* hardware type        */
  unsigned short          hard_header_len; /* hardware hdr len     */
  void                    *priv;           /* private data         */
  /* Interface address info. */
  unsigned char           broadcast[MAX_ADDR_LEN];
  unsigned char           pad;
  unsigned char           dev_addr[MAX_ADDR_LEN];
  unsigned char           addr_len;        /* hardware addr len    */
  unsigned long           pa_addr;         /* protocol address     */
  unsigned long           pa_brdaddr;      /* protocol broadcast addr*/
  unsigned long           pa_dstaddr;      /* protocol P-P other addr*/
  unsigned long           pa_mask;         /* protocol netmask     */
  unsigned short          pa_alen;         /* protocol address len */
  struct dev_mc_list      *mc_list;        /* M'cast mac addrs     */
  int                     mc_count;        /* No installed mcasts  */
  struct ip_mc_list       *ip_mc_list;     /* IP m'cast filter chain */
  __u32                   tx_queue_len;    /* Max frames per queue   */
  /* For load balancing driver pair support */
  unsigned long           pkt_queue;       /* Packets queued       */
  struct device           *slave;          /* Slave device         */
  struct net_alias_info   *alias_info;     /* main dev alias info  */
  struct net_alias        *my_alias;       /* alias devs           */
  /* Pointer to the interface buffers. */
  struct sk_buff_head     buffs[DEV_NUMBUFFS];
  /* Pointers to interface service routines. */
  int                     (*open)(struct device *dev);
  int                     (*stop)(struct device *dev);
  int                     (*hard_start_xmit) (struct sk_buff *skb,
                                              struct device *dev);
  int                     (*hard_header) (struct sk_buff *skb,
                                          struct device *dev,
                                          unsigned short type,
                                          void *daddr,
                                          void *saddr,
                                          unsigned len);
  int                     (*rebuild_header)(void *eth,
                                          struct device *dev,
                                          unsigned long raddr,
                                          struct sk_buff *skb);
  void                    (*set_multicast_list)(struct device *dev);
  int                     (*set_mac_address)(struct device *dev,
                                          void *addr);
  int                     (*do_ioctl)(struct device *dev,
                                          struct ifreq *ifr,
                                          int cmd);
  int                     (*set_config)(struct device *dev,
                                          struct ifmap *map);
  void                    (*header_cache_bind)(struct hh_cache **hhp,
                                          struct device *dev,
                                          unsigned short htype,
                                          __u32 daddr);
  void                    (*header_cache_update)(struct hh_cache *hh,
                                          struct device *dev,
                                          unsigned char *  haddr);
  int                     (*change_mtu)(struct device *dev,
                                          int new_mtu);
  struct iw_statistics*   (*get_wireless_stats)(struct device *dev);
};
device_struct
此结构被块设备和字符设备用来向核心登记(包含设备名称以及可对此设备进行的
文件操作)。chrdevs和blkdevs中的每个有效分别表示一个字符设备和块设备。
struct device_struct {
    const char * name;
    struct file_operations * fops;
};
file
每个打开的文件、套接口都用此结构表示。
struct file {
  mode_t f_mode;
  loff_t f_pos;
  unsigned short f_flags;
  unsigned short f_count;
  unsigned long f_reada, f_ramax, f_raend, f_ralen, f_rawin;
  struct file *f_next, *f_prev;
  int f_owner;         /* pid or -pgrp where SIGIO should be sent */
  struct inode * f_inode;
  struct file_operations * f_op;
  unsigned long f_version;
  void *private_data;  /* needed for tty driver, and maybe others */
};
files_struct
描叙被某进程打开的所有文件。
struct files_struct {
  int count;
  fd_set close_on_exec;
  fd_set open_fds;
  struct file * fd[NR_OPEN];
};
fs_struct
struct fs_struct {
  int count;
  unsigned short umask;
  struct inode * root, * pwd;
};
gendisk
包含关于某个硬盘的信息。用于磁盘初始化与分区检查时。
struct hd_struct {
    long start_sect;
    long nr_sects;
};
struct gendisk {
    int major;               /* major number of driver */
    const char *major_name;  /* name of major driver */
    int minor_shift;         /* number of times minor is shifted to
                                get real minor */
    int max_p;               /* maximum partitions per device */
    int max_nr;              /* maximum number of real devices */
    void (*init)(struct gendisk *);
                             /* Initialization called before we
                                do our thing */
    struct hd_struct *part;  /* partition table */
    int *sizes;              /* device size in blocks, copied to
                                blk_size[] */
    int nr_real;             /* number of real devices */
    void *real_devices;      /* internal use */
    struct gendisk *next;
};
inode
此VFS inode结构描叙磁盘上一个文件或目录的信息。
struct inode {
    kdev_t                       i_dev;
    unsigned long                i_ino;
    umode_t                      i_mode;
    nlink_t                      i_nlink;
    uid_t                        i_uid;
    gid_t                        i_gid;
    kdev_t                       i_rdev;
    off_t                        i_size;
    time_t                       i_atime;
    time_t                       i_mtime;
    time_t                       i_ctime;
    unsigned long                i_blksize;
    unsigned long                i_blocks;
    unsigned long                i_version;
    unsigned long                i_nrpages;
    struct semaphore             i_sem;
    struct inode_operations      *i_op;
    struct super_block           *i_sb;
    struct wait_queue            *i_wait;
    struct file_lock             *i_flock;
    struct vm_area_struct        *i_mmap;
    struct page                  *i_pages;
    struct dquot                 *i_dquot[MAXQUOTAS];
    struct inode                 *i_next, *i_prev;
    struct inode                 *i_hash_next, *i_hash_prev;
    struct inode                 *i_bound_to, *i_bound_by;
    struct inode                 *i_mount;
    unsigned short               i_count;
    unsigned short               i_flags;
    unsigned char                i_lock;
    unsigned char                i_dirt;
    unsigned char                i_pipe;
    unsigned char                i_sock;
    unsigned char                i_seek;
    unsigned char                i_update;
    unsigned short               i_writecount;
    union {
        struct pipe_inode_info   pipe_i;
        struct minix_inode_info  minix_i;
        struct ext_inode_info    ext_i;
        struct ext2_inode_info   ext2_i;
        struct hpfs_inode_info   hpfs_i;
        struct msdos_inode_info  msdos_i;
        struct umsdos_inode_info umsdos_i;
        struct iso_inode_info    isofs_i;
        struct nfs_inode_info    nfs_i;
        struct xiafs_inode_info  xiafs_i;
        struct sysv_inode_info   sysv_i;
        struct affs_inode_info   affs_i;
        struct ufs_inode_info    ufs_i;
        struct socket            socket_i;
        void                     *generic_ip;
    } u;
};
ipc_perm
此结构描叙对一个系统V IPC对象的存取权限。
struct ipc_perm
{
  key_t  key;
  ushort uid;   /* owner euid and egid */
  ushort gid;
  ushort cuid;  /* creator euid and egid */
  ushort cgid;
  ushort mode;  /* access modes see mode flags below */
  ushort seq;   /* sequence number */
};
irqaction
用来描叙系统的中断处理过程。
struct irqaction {
  void (*handler)(int, void *, struct pt_regs *);
  unsigned long flags;
  unsigned long mask;
  const char *name;
  void *dev_id;
  struct irqaction *next;
};
linux_binfmt
用来表示可被Linux理解的二进制文件格式。
struct linux_binfmt {
  struct linux_binfmt * next;
  long *use_count;
  int (*load_binary)(struct linux_binprm *, struct  pt_regs * regs);
  int (*load_shlib)(int fd);
  int (*core_dump)(long signr, struct pt_regs * regs);
};
mem_map_t
用来保存每个物理页面的信息。
typedef struct page {
  /* these must be first (free area handling) */
  struct page        *next;
  struct page        *prev;
  struct inode       *inode;
  unsigned long      offset;
  struct page        *next_hash;
  atomic_t           count;
  unsigned           flags;     /* atomic flags, some possibly
                                   updated asynchronously */
  unsigned           dirty:16,
                     age:8;
  struct wait_queue  *wait;
  struct page        *prev_hash;
  struct buffer_head *buffers;
  unsigned long      swap_unlock_entry;
  unsigned long      map_nr;    /* page->map_nr == page - mem_map */
} mem_map_t;
mm_struct
用来描叙某任务或进程的虚拟内存。
struct mm_struct {
  int count;
  pgd_t * pgd;
  unsigned long context;
  unsigned long start_code, end_code, start_data, end_data;
  unsigned long start_brk, brk, start_stack, start_mmap;
  unsigned long arg_start, arg_end, env_start, env_end;
  unsigned long rss, total_vm, locked_vm;
  unsigned long def_flags;
  struct vm_area_struct * mmap;
  struct vm_area_struct * mmap_avl;
  struct semaphore mmap_sem;
};
pci_bus
表示系统中的一个PCI总线。
struct pci_bus {
  struct pci_bus  *parent;     /* parent bus this bridge is on */
  struct pci_bus  *children;   /* chain of P2P bridges on this bus */
  struct pci_bus  *next;       /* chain of all PCI buses */
  struct pci_dev  *self;       /* bridge device as seen by parent */
  struct pci_dev  *devices;    /* devices behind this bridge */
  void    *sysdata;            /* hook for sys-specific extension */
  unsigned char  number;       /* bus number */
  unsigned char  primary;      /* number of primary bridge */
  unsigned char  secondary;    /* number of secondary bridge */
  unsigned char  subordinate;  /* max number of subordinate buses */
};
pci_dev
表示系统中的每个PCI设备,包括PCI-PCI和PCI-PCI桥接器。
/*
* There is one pci_dev structure for each slot-number/function-number
* combination:
*/
struct pci_dev {
  struct pci_bus  *bus;      /* bus this device is on */
  struct pci_dev  *sibling;  /* next device on this bus */
  struct pci_dev  *next;     /* chain of all devices */
  void    *sysdata;          /* hook for sys-specific extension */
  unsigned int  devfn;       /* encoded device & function index */
  unsigned short  vendor;
  unsigned short  device;
  unsigned int  class;       /* 3 bytes: (base,sub,prog-if) */
  unsigned int  master : 1;  /* set if device is master capable */
  /*
   * In theory, the irq level can be read from configuration
   * space and all would be fine.  However, old PCI chips don't
   * support these registers and return 0 instead.  For example,
   * the Vision864-P rev 0 chip can uses INTA, but returns 0 in
   * the interrupt line and pin registers.  pci_init()
   * initializes this field with the value at PCI_INTERRUPT_LINE
   * and it is the job of pcibios_fixup() to change it if
   * necessary.  The field must not be 0 unless the device
   * cannot generate interrupts at all.
   */
  unsigned char  irq;        /* irq generated by this device */
};
request
被用来向系统的块设备发送请求。它总是向buffer cache读出或写入数据块。
struct request {
    volatile int rq_status;
#define RQ_INACTIVE            (-1)
#define RQ_ACTIVE              1
#define RQ_SCSI_BUSY           0xffff
#define RQ_SCSI_DONE           0xfffe
#define RQ_SCSI_DISCONNECTING  0xffe0
    kdev_t rq_dev;
    int cmd;        /* READ or WRITE */
    int errors;
    unsigned long sector;
    unsigned long nr_sectors;
    unsigned long current_nr_sectors;
    char * buffer;
    struct semaphore * sem;
    struct buffer_head * bh;
    struct buffer_head * bhtail;
    struct request * next;
};
rtable
用来描叙向某个IP主机发送包的路由信息。此结构在IP路由cache内部实用。
struct rtable
{
    struct rtable     *rt_next;
    __u32             rt_dst;
    __u32             rt_src;
    __u32             rt_gateway;
    atomic_t          rt_refcnt;
    atomic_t          rt_use;
    unsigned long     rt_window;
    atomic_t          rt_lastuse;
    struct hh_cache   *rt_hh;
    struct device     *rt_dev;
    unsigned short    rt_flags;
    unsigned short    rt_mtu;
    unsigned short    rt_irtt;
    unsigned char     rt_tos;
};
semaphore
保护临界区数据结构和代码信号灯。
struct semaphore {
    int count;
    int waking;
    int lock ;                /* to make waking testing atomic */
    struct wait_queue *wait;
};
sk_buff
用来描叙在协议层之间交换的网络数据。
struct sk_buff
{
  struct sk_buff      *next;       /* Next buffer in list
*/
  struct sk_buff      *prev;       /* Previous buffer in list
*/
  struct sk_buff_head *list;       /* List we are on
*/
  int                 magic_debug_cookie;
  struct sk_buff      *link3;      /* Link for IP protocol level buffer chai
ns *
  struct sock         *sk;         /* Socket we are owned by
*/
  unsigned long       when;        /* used to compute rtt's
*/
  struct timeval      stamp;       /* Time we arrived
*/
  struct device       *dev;        /* Device we arrived on/are leaving by
*/
  union
  {
      struct tcphdr   *th;
      struct ethhdr   *eth;
      struct iphdr    *iph;
      struct udphdr   *uh;
      unsigned char   *raw;
      /* for passing file handles in a unix domain socket */
      void            *filp;
  } h;
  union
  {
      /* As yet incomplete physical layer views */
      unsigned char   *raw;
      struct ethhdr   *ethernet;
  } mac;
  struct iphdr        *ip_hdr;     /* For IPPROTO_RAW
*/
  unsigned long       len;         /* Length of actual data
*/
  unsigned long       csum;        /* Checksum
*/
  __u32               saddr;       /* IP source address
*/
  __u32               daddr;       /* IP target address
*/
  __u32               raddr;       /* IP next hop address
*/
  __u32               seq;         /* TCP sequence number
*/
  __u32               end_seq;     /* seq [+ fin] [+ syn] + datalen
*/
  __u32               ack_seq;     /* TCP ack sequence number
*/
  unsigned char       proto_priv[16];
  volatile char       acked,       /* Are we acked ?
*/
                      used,        /* Are we in use ?
*/
                      free,        /* How to free this buffer
*/
                      arp;         /* Has IP/ARP resolution finished
*/
  unsigned char       tries,       /* Times tried
*/
                      lock,        /* Are we locked ?
*/
                      localroute,  /* Local routing asserted for this frame
*/
                      pkt_type,    /* Packet class
*/
                      pkt_bridged, /* Tracker for bridging
*/
                      ip_summed;   /* Driver fed us an IP checksum
*/
#define PACKET_HOST         0        /* To us
  */
#define PACKET_BROADCAST    1        /* To all
  */
#define PACKET_MULTICAST    2        /* To group
  */
#define PACKET_OTHERHOST    3        /* To someone else
  */
  unsigned short      users;       /* User count - see datagram.c,tcp.c
*/
  unsigned short      protocol;    /* Packet protocol from driver.
*/
  unsigned int        truesize;    /* Buffer size
*/
  atomic_t            count;       /* reference count
*/
  struct sk_buff      *data_skb;   /* Link to the actual data skb
*/
  unsigned char       *head;       /* Head of buffer
*/
  unsigned char       *data;       /* Data head pointer
*/
  unsigned char       *tail;       /* Tail pointer
*/
  unsigned char       *end;        /* End pointer
*/
  void                (*destructor)(struct sk_buff *); /* Destruct function
*/
  __u16               redirport;   /* Redirect port
*/
};
sock
包含BSD套接口的协议相关信息。例如对于一个INET(Internet AddressDomain)套接口

此数据结构 包含TCP/IP和UDP/IP信息。
struct sock
{
    /* This must be first. */
    struct sock             *sklist_next;
    struct sock             *sklist_prev;
    struct options          *opt;
    atomic_t                wmem_alloc;
    atomic_t                rmem_alloc;
    unsigned long           allocation;       /* Allocation mode */
    __u32                   write_seq;
    __u32                   sent_seq;
    __u32                   acked_seq;
    __u32                   copied_seq;
    __u32                   rcv_ack_seq;
    unsigned short          rcv_ack_cnt;      /* count of same ack */
    __u32                   window_seq;
    __u32                   fin_seq;
    __u32                   urg_seq;
    __u32                   urg_data;
    __u32                   syn_seq;
    int                     users;            /* user count */
  /*
   *    Not all are volatile, but some are, so we
   *     might as well say they all are.
   */
    volatile char           dead,
                            urginline,
                            intr,
                            blog,
                            done,
                            reuse,
                            keepopen,
                            linger,
                            delay_acks,
                            destroy,
                            ack_timed,
                            no_check,
                            zapped,
                            broadcast,
                            nonagle,
                            bsdism;
    unsigned long           lingertime;
    int                     proc;
    struct sock             *next;
    struct sock             **pprev;
    struct sock             *bind_next;
    struct sock             **bind_pprev;
    struct sock             *pair;
    int                     hashent;
    struct sock             *prev;
    struct sk_buff          *volatile send_head;
    struct sk_buff          *volatile send_next;
    struct sk_buff          *volatile send_tail;
    struct sk_buff_head     back_log;
    struct sk_buff          *partial;
    struct timer_list       partial_timer;
    long                    retransmits;
    struct sk_buff_head     write_queue,
                            receive_queue;
    struct proto            *prot;
    struct wait_queue       **sleep;
    __u32                   daddr;
    __u32                   saddr;            /* Sending source */
    __u32                   rcv_saddr;        /* Bound address */
    unsigned short          max_unacked;
    unsigned short          window;
    __u32                   lastwin_seq;      /* sequence number when we las
t
                                                 updated the window we offer
*/
    __u32                   high_seq;         /* sequence number when we did

                                                 current fast retransmit */
    volatile unsigned long  ato;              /* ack timeout */
    volatile unsigned long  lrcvtime;         /* jiffies at last data rcv */

 

[目录]


重新编译


1.核心的源程序:
    我现在在用TLC, REDHAT也用过, SLACKWARE也用过. 无论哪一种, 都是把核心源程
序放到 /usr/src/linux 下, 因为有些别的应用程序在编译时好像也会从这个路径来引
用一些头文件之类. 一般来说这个 linux 目录都只是个符号连接, 有一点点像WIN下的
Shortcut, 而实际上它对应的目录可能是 /usr/src/linux-2.0.35 之类. RedHat的缺省
安装好像并不装源程序, 只有些头文件.
    以现在的2.2.5 核心为例, 我装的时候就是这样(其实什么版本都一样 :)
    cd /usr/src
    rm linux
    # 这个linux只是个符号连接, 删掉它没事的. 可以 ls -l 看看, 如果看到这个:
    # linux -> linux-XXXXX, 就表示它是个连接而已. 原来的源程序在箭头后的目录.
    tar zxvf XXXXXXX/linux-2.2.5.tar.gz
    # 这个包解开后, 新核心的源程序就放在了新建立的linux目录下, 这可是个货真价
    # 实的目录.
    mv linux linux-2.2.5
    ln -s linux-2.2.5 linux
    # 按照惯例, 还是把目录另命个名, 再重新做个linux的符号连接

2.准备编译:
    现在要做一些准备工作. 对于新释放出来的核心源程序也没啥好做的, 就打一个:
    cd /usr/src/linux
    make menuconfig

    然后就会看到一个很友好的界面(在LINUX下...已经是很友好的了), 大致上有点像
WIN 9X安装时的选择安装项目. 这就是在配置核心, 选择哪些内容要, 哪些不要.
然后选EXIT退出来, 问是否保存修改时答YES. 然后会有一些提示. 如果看到了有叫你
"make dep", 就要打"make dep"先. 完了后就打 make bzImage. 如果提示信息中没有
叫你"make dep", 只有叫你 "make zImage", "make zdisk" 或 "make zlilo" 的,
就直接打 make bzImage 就行了.

一点说明: make dep 是作一些准备工作, make bzImage 则是开始编译生成核心. 而
          make bzImage与make zImage的区别在于, 作成bzImage的核心压缩率比zImage
          高, 核心就更小一些. make zdisk 与 make zlilo 是做别的用处的核心的.

    然后就等吧(有得你等的). 一般从5分钟到半个钟头不等, 看你的机器了. 第一次编
译会 比较慢. 以后再改了配置后make就会快很多了.

    等这个完了后一定还要 make modules 和 make modules_install.

make bzImage 完后会显示核心放在什么地方, 一般是/usr/src/linux/arch/i386/boot/
下. 把bzImage拷到根下. 然后修改 /etc/lilo.conf, 照着原来的image = XXXXX来加上
image = /bzImage
  root = /dev/hda1 (这里视你的LINUX安装而定, 照你原有的改)
  label = linux
  read-only
    把原来的 label = linux 改一下, 如 label = oldlinux.
    把image = /bzImage 这一节加在原来的前面, 这样会自动作为缺省的核心. 你也可以在
LILO时打linux或oldlinux来启动不同的核心. 关于这一段, 也可以参考俺前面的"ALS007
发声经过". 最后, 切记切记, 一定要打个lilo来重新生成LILO程序.

好了, 重启...

[目录]


重建内核选项


       prompt for development and/or incomplete code/drivers
             很多参考书上说这是那些开发人员认为还不是很稳定的功能,但
             是根据我的经验,这个是应该选的一个选项,因为现代的LINUX是
             建立在这些基础上的,所以应该可以回答Y,除非你只是想使用
             LINUX中已经完全定型的东西,但性能肯定不会好到哪,而且对系
             统特性的支持也不会好。

       processor family (386,486/cx486,586/k5/5x86/6x86,pentinum/k6/tsc,ppro/6x86)
             这应该没有太多可说的吧,选择你的CPU的种类,BIOS可以自检得
             到,注意系统的启动信息。需要注意的是不能选择比你的CPU类型
             还高级的CPU,否则可能不能正常工作。

       math emulation
             模拟数学协处理器,如果你的机器没有数学协处理器,那就选上
             以提高性能,但486以后数学协处理器就集成到CPU内部了,应该是
             用不上的,所以一般的选择是N。当然选上也不会有什么问题,除
             了内 松陨 变大外。

       mttr(memory type range register) support
             这个选项是用来启动pentinum pro和pentinum II 的特殊功能,如果你用
             的不是这类CPU就选N,否则也仅仅是使内核变大而已。

       symmetric multi-processing support
             同步处理器支持,如果你有多个CPU就选上吧。

       enable loadable module support
             这会启动动态载入额外模块的功能,所以一定选上。

       set version information on all symbols for modules
             这个选项可以为某个版本的内核而编译的模块在另一个版本的内
             核下使用,但一般用不上。

        kernel module loader
             如果你启用这个选项,你可以通过kerneld程序的帮助在需要的时候
             自动载入或卸载那些可载入式的模块。建议选上。

         networking support
             如果你用到任何网络就应该选上

         pci bios support
             这个一般是应该选上的,除非你用没有任何PCI设备的机器。PCI
             BIOS是用来侦测并启用PCI设备的。

         pci bridge optimization(v1.3)
             当这个选项被启动时,操作系统会对从CPU和系统内存在PCI总线
             来往的数据做最佳化,这个功能已经完成实验阶段,使用起来应
             该很安全,而且还可增进系统的效率。

         system v ipc
             起用这个选项可以使内核支持System V 的进程间通信的功能
             (IPC),有些从System V转移过来的程序会需要这个功能,建议启
             用该功能。

         sysctl support
             除非你的内存少的可怜,否则你应该启动这个功能,启用该选项
             后内核会大8K,但能让你直接改变内核的参数而不必重新开机。

         kernel support for elf binaries
             该选项让你的系统得以执行用ELF格式存储的可执行文件,而ELF
             是现代LINUX的可执行文件、目标文件和系统函数库的标准格式。
             当操作系统要和编译器以及连接器合作时会需要这些标准,所以
             应该回答Y。

         compile kernel as elf
             这选项让你的内核本身以ELF的格式编译,如果你的系统上的过程
             gcc默认产生ELF格式的可执行文件,那么你就应该启动这个选项。
             先看看你的编译器的版本再决定。

         parallel port support
             如果你有任何并行口的设备并且想让LINUX使用,那么就可以启用
             这个选项。LINUX不仅可以使用并口的打印机,还可以支持PLIP
             (一种为并行口而设计的网络通讯协定),ZIP磁盘驱动器、扫描
             仪等。在大多情况下,你需要额外的驱动程序才能使用外接的并
             口设备。

         plug and play support
             支持PNP设备并非Microsoft的专利,如果你要让LINUX也支持PNP设
             备,只要启用该选项就可以,但有些情况下会和其他设备产生冲
             突(I/O,DMA,IRQ等)。这个选项对PCI设备没有影响,因为他们
             天生就是PNP设备。

         normal floppy disk support
             除非你不想在LINUX下使用软盘,否则就应该回答Y。但对于一些
             不需要支持软盘驱动器的系统而言,这个选项可以节省一些内
             存。

         enhanced ide/mfm/dll disk support
             除非你不需要MFM/DLL/IDE硬盘的的支持,否则就应该回答Y,但如
             果你只有SCSI的硬盘,关掉这个选项会比较安全。

         enhanced ide/mfm/dll cdrom support
             和上面的类似,只不过是对CDROM的支持而已。

         enhanced ide/mfm/dll tape support
             一般没有多少人在用磁带机吧,所以回答N是比较好的答案。

        enhanced ide/mfm/dll floppy support
             这个设备好象一般也没有人用,所以也可以回答N。

        xt harddisk support
             如果你有这种石器时代的XT硬盘,那么恭喜你你可以用上他了。

        parallel port ide device support
             LINUX是支持这种很新的并口的IDE设备的,如果你有的话就用上
             吧。

        networking options
             如果你在前面选了支持网络的话,在这里会回答很多问题。除非
             你有特别的需求,否则使用默认的选项应该就足够了。

        scsi support
             如果你有任何一种SCSI控制卡,这个选项就应该回答Y。事先搞清
             楚你的硬件的类型,因为这些问题都是针对特定的SCSI控制芯片和
             控制卡的,如果你不确定自己使用的是哪一种,查看你的硬件的
             说明文件或者LINUX的HOWTO文档。同样也会让你回答很多SCSI设
             备的支持(硬盘、CDROM、Tape、floppy等),依据你的情况选择。
             如果你没有SCSI设备的话,建议不要支持,因为这会节约很多内核
             空间。

         network device support
             这里面有很多关于网络控制卡的问题,如果你无法确定如何正确
             选择,查看硬件文档或LINUX HOWTO文档。

         amateur radio support
             这个选项可以用来启动无线网络的基本支持,目前的无线网络可
             以通过公众频率传输数据,如果你有此类设备就可以启用,具体
             请参考AX25和HAM HOWTO 文档。
             isdn subsystem
             如果你有ISDN硬件就应该启用该选项并安装合适的硬件驱动程
             序,你应该还会需要启用Support synchronous PPP选项(参考PPP over
             ISDN)。

         old cd-rom drivers
             这是针对一些特殊光盘驱动器程序的问题,如果你有IDE或SCSI的
             CDROM控制卡,那么就不用启用该选项了。

         character devices
             LINUX支持很多特殊的字符设备,例如并口、串口控制卡、QIC02磁
             带驱动器以及特定界面的鼠标,此外对于游戏杆和影象摄取和麦
             克等也在这里面,依据你自己的情况选者吧。

         filesystems
             这是一系列内核所支持的各文件系统的问题,对ext2 /proc文件系统
             是一定应该支持的,有光驱还应该支持ISO9660(或模块支持),
             有WINDOWS或DOS分区并且想在LINUX下访问他们也可以进行支
             持。

         console drivers
             你至少应该支持VGA text console,否则你无法从控制台使用LINUX。

         sound card support
             在这里回答Y会出现很多关于声卡的问题,根据你自己的情况来配
             置。

         kernel profiling support(v1.3)
             这个选项可以开启内核做效率统计的功能,并且会提供其他在为
             系统侦错时有用的信息。这些功能会需要付出一些代价并造成系
             统执行得较为缓慢,除非你正在研究内核的某个问题,否则你应
             该回答N。

          kernel hacking
             如果你正打算深入研究自己系统上运行的LINUX如何运作,这里有
             很多选项,但一般没有必要的话可以全部关掉。

[目录]


调试技术


本章介绍你可以用来监视内核代码和跟踪错误的技术。

用打印信息调试

最一般的调试技术就是监视,就是在应用内部合适的点加上printf调用。当你调试内核代码的时候,你可以用printk完成这个任务。

Printk

在前些章中,我们简单假设printk工作起来和printf很类似。现在是介绍一下它们之间不同的时候了。

其中一个不同点就是,printk允许你根据它们的严重程度,通过附加不同的“记录级”来对消息分类,或赋予消息优先级。你可以用宏来指示记录级。例如,KERN_INFO,我们前面已经看到它被加在打印语句的前面,它就是一种可能的消息记录级。记录级宏展开为一个字串,在编译时和消息文本拼接在一起;这也就是为什么下面的例子中优先级和格式字串间没有逗号。这有两个printk的例子,一个是调试信息,一个是关键信息:

(代码)

在<linux/kernel.h>中定义了8种记录级别串。没有指定优先级的printk语句默认使用DEFAULT_MESSAGE_LOGLEVEL优先级,它是一个在kernel/printk.c中定义的整数。默认记录级的具体数值在Linux的开发期间曾变化过若干次,所以我建议你最好总是指定一个合适的记录级。

根据记录级,内核将消息打印到当前文本控制台上:如果优先级低于console_loglevel这个数值的话,该消息就显示在控制台上。如果系统同时运行了klogd和syslogd,无论console_loglevel为何值,内核都将消息追加到/var/log/messages中。

变量console_loglevel最初初始化为DEFAULT_CONSOLE_LOGLEVEL,但可以通过sys_syslog系统调用修改。如klogd的手册所示,可以在启动klogd时指定-c开关来修改这个变量。此外,你还可以写个程序来改变控制台记录级。你可以在O’Reilly站点上的源文件中找到我写的一个这种功能的程序,miscprogs/setlevel.c。新优先级是通过一个1到8之间的整数值指定的。

你也许需要在内核失效后降低记录级(见“调试系统故障”),这是因为失效处理代码会将console_loglevel提升到15,之后所有的消息都会出现在控制台上。为看到你的调试信息,如果你运行的是内核2.0.x话,你需要提升记录级。内核2.0发行降低了MINIMUM_CONSOLE_LOGLEVEL,而旧版本的klogd默认情况下要打印很多控制消息。如果你碰巧使用了这个旧版本的守护进程,除非你提升记录级,内核2.0会比你预期的打印出更少的消息。这就是为什么hello.c中使用了<1>标记,这样可以保证消息显示在控制台上。

从1.3.43一来的内核版本通过允许你向指定虚控制台发送消息,藉此提供一个灵活的记录策略。默认情况下,“控制台”是当前虚终端。也可以选择不同的虚终端接收消息,你只需向所选的虚终端调用ioctl(TIOCLINUX)。如下程序,setconsole,可以用来选择哪个虚终端接收内核消息;它必须以超级用户身份运行。如果你对ioctl还不有把握,你可以跳过这至下一节,等到读完第5章“字符设备驱动程序的扩展操作”的“ioctl”一节后,再回到这里读这段代码。

(代码)

setconsole使用了用于Linux专用功能的特殊的ioctl命令TIOCLINUX。为了使用TIOCLINUX,你要传递给它一个指向字节数组的指针。数组的第一个字节是所请求的子命令的编码,随后的字节依命令而不同。在setconsole中使用了子命令11,后一个字节(存放在bytes[1]中)标别虚拟控制台。TIOCLINUX的完成介绍可以在内核源码drivers/char/tty_io.c中找到。

消息是如何记录的

printk函数将消息写到一个长度为LOG_BUF_LEN个字节的循环缓冲区中。然后唤醒任何等待消息的进程,即那些在调用syslog系统调用或读取/proc/kmesg过程中睡眠的进程。这两个访问记录引擎的接口是等价的。不过/proc/kmesg文件更象一个FIFO文件,从中读取数据更容易些。一条简单的cat命令就可以读取消息。

如果循环缓冲区填满了,printk就绕到缓冲区的开始处填写新数据,覆盖旧数据。于是记录进程就丢失了最旧的数据。这个问题与利用循环缓冲区所获得的好处相比可以忽略不计。例如,循环缓冲区可以使系统在没有记录进程的情况下照样运行,同时又不浪费内存。Linux处理消息的方法的另一个特点是,可以在任何地方调用printk,甚至在中断处理函数里也可以调用,而且对数据量的大小没有限制。这个方法的唯一缺点就是可能丢失某些数据。

如果klogd正在运行,它读取内核消息并将它们分派到syslogd,它随后检查/etc/syslog.conf找到处理这些数据的方式。syslogd根据一个“设施”和“优先级”切分消息;可以使用的值定义在<sys/syslog.h>中。内核消息根据相应printk中指定的优先级记录到LOG_KERN设施中。如果klogd没有运行,数据将保存在循环缓冲区中直到有进程来读取数据或数据溢出。

如果你不希望因监视你的驱动程序的消息而把你的系统记录搞乱,你给klogd指定-f(文件)选项或修改/etc/syslog.conf将记录写到另一个文件中。另一种方法是一种强硬方法:杀掉klogd,将消息打印到不用的虚终端上*,或者在一个不用的xterm上执行cat /proc/kmesg显示消息。

使用预处理方便监视处理

在驱动程序开发早期,printk可以对调试和测试新代码都非常有帮助。然而当你正式发行驱动程序时,你应该去掉,或者至少关闭,这些打印语句。很不幸,你可能很快就发现,随着你想不再需要那些消息并去掉它们时,你可能又要加新功能,你又需要这些消息了。解决这些问题有几种方法――如何从全局打开和关闭消息以及如何打开和关闭个别消息。

下面给出了我处理消息所用的大部分代码,它有如下一些功能:


可以通过在宏名字加一个字母或去掉一个字母打开或关闭每一条语句。


通过在编译前修改CFLAGS变量,可以一次关闭所有消息。


同样的打印语句既可以用在内核态(驱动程序)也可以用在用户态(演示或测试程序)。

下面这些直接来自scull.h的代码片断实现了这些功能。

(代码)

符合PDEBUG和PDEBUGG依赖于是否定义了SCULL_DEBUG,它们都和printf调用很类似。

为了进一步方便这个过程,在你的Makefile加上如下几行。

(代码)

本节所给出的代码依赖于gcc对ANSI C预编译器的扩展,gcc可以支持带可变数目参数的宏。这种对gcc的依赖并不是什么问题,因为内核对gcc特性的依赖更强。此外,Makefile依赖于GNU的gmake;基于同样的道理,这也不是什么问题。

如果你很熟悉C预编译器,你可以将上面的定义扩展为可以支持“调试级”概念的,可以为每级赋一个整数(或位图),说明这一级打印多么琐碎的消息。

但是每一个驱动程序都有它自己的功能和监视需求。好的编程技巧会在灵活性和高效之间找到一个权衡点,这个我就不能说哪个对你最好了。记住,预编译器条件(还有代码中的常量表达式)只到编译时运行,你必须重新编译程序来打开或关闭消息。另一种方法就是使用C条件语句,它在运行时运行,因此可以让你在程序执行期间打开或关闭消息。这个功能很好,但每次代码执行系统都要进行额外的处理,甚至在消息关闭后仍然会影响性能。有时这种性能损失是无法接受的。

个人观点,尽管上面给出的宏迫使你每次要增加或去掉消息时都要重新编译,重新加载模块,但我觉得用这些宏已经很好了。

通过查询调试

上一节谈到了printk是如何工作的以及如何使用它。但没有谈及它的缺点。

由于syslogd会一直保持刷新它的输出文件,每打印一行都会引起一次磁盘操作,因此过量使用printk会严重降低系统性能。至少从syslogd的角度看是这样的。它会将所有的数据都一股脑地写到磁盘上,以防在打印消息后系统崩溃;然而,你不想因为调试信息的缘故而降低系统性能。这个问题可以通过在/etc/syslogd.conf中记录文件的名字前加一个波折号解决,但有时你不想修改你的配置文件。如果不这样,你还可以运行一个非klogd的程序(如前面介绍的cat /proc/kmesg),但这样并不能为正常操作提供一个合适的环境。

与这相比,最好的方法就是在你需要信息的时候,通过查询系统获得相关信息,而不是持续不断地产生数据。事实上,每一个Unix系统都提供了很多工具用来获得系统信息:ps,netstat,vmstat等等。

有许多技术适合与驱动程序开发人员查询系统,简而言之就是,在/proc下创建文件和使用ioctl驱动程序方法。

使用/proc文件系统

Linux中的/proc文件系统与任何设备都没有关系――/proc中的文件都在被读取时有核心创建的。这些文件都是普通的文本文件,它们基本上可由普通人理解,也可被工具程序理解。例如,对于大多数Linux的ps实现而言,它都通过读取/proc文件系统获得进程表信息的。/proc虚拟文件的创意已由若干现代操作系统使用,且非常成功。

/proc的当前实现可以动态创建i节点,允许用户模块为方便信息检索创建如何入口点。

为了在/proc中创建一个健全的文件节点(可以read,write,seek等等),你需要定义file_operations结构和inode_operations结构,后者与前者有类似的作用和尺寸。创建这样一个i节点比起创建整个字符设备并没有什么不同。我们这里不讨论这个问题,如果你感兴趣,你可以在源码树fs/proc中获得进一步细节。

与大多数/proc文件一样,如果文件节点仅仅用来读,创建它们是比较容易的,我将这里介绍这一技术。很不幸,这一技术只能在Linux 2.0及其后续版本中使用。

这里是创建一个称为/proc/scullmem文件的scull代码,这个文件用来获取scull使用的内存信息。

(代码)

填写/proc文件非常容易。你的函数获取一个空闲页面填写数据;它将数据写进缓冲区并返回所写数据的长度。其他事情都由/proc文件系统处理。唯一的限制就是所写的数据不能超过PAGE_SIZE个字节(宏PAGE_SIZE定义在头文件<asm/page.h>中;它是与体系结构相关的,但你至少可以它有4KB大小)。

如果你需要写多于一个页面的数据,你必须实现功能健全的文件。

注意,如果一个正在读你的/proc文件的进程发出了若干read调用,每一个都获取新数据,尽管只有少量数据被读取,你的驱动程序每次都要重写整个缓冲区。这些额外的工作会使系统性能下降,而且如果文件产生的数据与下一次的不同,以后的read调用要重新装配不相关的部分,这一会造成数据错位。事实上,由于每个使用C库的应用程序都大块地读取数据,性能并不是什么问题。然而,由于错位时有发生,它倒是一个值得考虑的问题。在获取数据后,库调用至少要调用1次read――只有当read返回0时才报告文件尾。如果驱动程序碰巧比前面产生了更多的数据,系统就返回到用户空间额外的字节并且与前面的数据块是错位的。我们将在第6章“时间流”的“任务队列”一节中涉及/proc/jiq*,那时我们还会遇到错位问题。

cleanup_module中应该使用下面的语句注销/proc节点:

(代码)

传递给函数的参数是包含要撤销文件的目录名和文件的i节点号。由于i节点号是自动分配的,在编译时是无法知道的,必须从数据结构中读取。

ioctl方法

ioctl,下一章将详细讨论,是一个系统调用,它可以操做在文件描述符上;它接收一个“命令”号和(可选的)一个参数,通常这是一个指针。

做为替代/proc文件系统的方法,你可以为调试实现若干ioctl命令。这些命令从驱动程序空间复制相关数据到进程空间,在进程空间里检查这些数据。

只有使用ioctl获取信息比起/proc来要困难一些,因为你一个程序调用ioctl并显示结果。必须编写这样的程序,还要编译,保持与你测试的模块间的一致性等。

不过有时候这是最好的获取信息的方法,因为它比起读/proc来要快得多。如果在数据写到屏幕前必须完成某些处理工作,以二进制获取数据要比读取文本文件有效得多。此外,ioctl不限制返回数据的大小。

ioctl方法的一个优点是,当调试关闭后调试命令仍然可以保留在驱动程序中。/proc文件对任何查看这个目录的人都是可见的,然而与/proc文件不同,未公开的ioctl命令通常都不会被注意到。此外,如果驱动程序有什么异常,它们仍然可以用来调试。唯一的缺点就是模块会稍微大一些。

通过监视调试

有时你遇到的问题并不特别糟,通过在用户空间运行应用程序来查看驱动程序与系统之间的交互过程可以帮助你捕捉到一些小问题,并可以验证驱动程序确实工作正常。例如,看到scull的read实现如何处理不同数据量的read请求后,我对scull更有信心。

有许多方法监视一个用户态程序的工作情况。你可以用调试器一步步跟踪它的函数,插入打印语句,或者用strace运行程序。在实际目的是查看内核代码时,最后一项技术非常有用。

strace命令是一个功能非常强大的工具,它可以现实程序所调用的所有系统调用。它不仅可以显示调用,而且还能显示调用的参数,以符号方式显示返回值。当系统调用失败时,错误的符号值(如,ENOMEM)和对应的字串(Out of memory)同时显示。strace还有许多命令行选项;最常用的是-t,它用来显示调用发生的时间,-T,显示调用所花费的时间,以及-o,将输出重定向到一个文件中。默认情况下,strace将所有跟踪信息打印到stderr上。

strace从内核接收信息。这意味着一个程序无论是否按调试方式编译(用gcc的-g选项)或是被去掉了符号信息都可以被跟踪。与调试器可以连接到一个运行进程并控制它类似,你还可以跟踪一个已经运行的进程。

跟踪信息通常用来生成错误报告报告给应用开发人员,但是对内核编程人员来说也一样非常有用。我们可以看到系统调用是如何执行驱动程序代码的;strace允许我们检查每一次调用输入输出的一致性。

例如,下面的屏幕输出给出了命令ls /dev > /dev/scull0的最后几行:

(代码)

很明显,在ls完成目标目录的检索后首次对write的调用中,它试图写4KB。很奇怪,只写了4000个字节,接着重试这一操作。然而,我们知道scull的write实现每次只写一个量子,我在这里看到了部分写。经过若干步骤之后,所有的东西都清空了,程序正常退出。

另一个例子,让我们来读scull设备:

(代码)

正如所料,read每次只能读到4000个字节,但是数据总量是不变的。注意本例中重试工作是如何组织的,注意它与上面写跟踪的对比。wc专门为快速读数据进行了优化,它绕过了标准库,以便每次用一个系统调用读取更多的数据。你可以从跟踪的read行中看到wc每次要读16KB。

Unix专家可以在strace的输出中找到很多有用信息。如果你被这些符号搞得满头雾水,我可以只看文件方法(open,read等等)是如何工作的。

个人认为,跟踪工具在查明系统调用的运行时错误过程中最有用。通常应用或演示程序中的perror调用不足以用来调试,而且对于查明到底是什么样的参数触发了系统调用的错误也很有帮助。

调试系统故障

即便你用了所有监视和调试技术,有时候驱动程序中依然有错误,当这样的驱动程序执行会造成系统故障。当这种情况发生时,获取足够多的信息来解决问题是至关重要的。

注意,“故障”不意味着“panic”。Linux代码非常鲁棒,可以很好地响应大部分错误:故障通常会导致当前进程的终止,但系统继续运行。如果在进程上下文之外发生故障,或是组成系统的重要部件发生故障时,系统可能panic。但问题出在驱动程序时,通常只会导致产生故障的进程终止――即那个使用驱动程序的进程。唯一不可恢复的损失就是当进程被终止时,进程上下文分配的内存丢失了;例如,由驱动程序通过kmalloc分配的动态链表可能丢失。然而,由于内核会对尚是打开的设备调用close,你的驱动程序可以释放任何有open方法分配的资源。

我们已经说过,当内核行为异常时会在控制台上显示一些有用的信息。下一节将解释如何解码和使用这些消息。尽管它们对于初学者来说相当晦涩,处理器的给出数据都是些很有意思的信息,通常无需额外测试就可以查明程序错误。

Oops消息

大部分错误都是NULL指针引用或使用其他不正确的指针数值。这些错误通常会导致一个oops消息。

由处理器使用的地址都是“虚”地址,而且通过一个复杂的称为页表(见第13章“Mmap和DMA”中的“页表”一节)的结构映射为物理地址。当引用一个非法指针时,页面映射机制就不能将地址映射到物理地址,并且处理器向操作系统发出一个“页面失效”。如果地址确实是非法的,内核就无法从失效地址上“换页”;如果此时处理在超级用户太,系统于是就产生一个“oops”。值得注意的是,在版本2.1中内核处理失效的方式有所变化,它可以处理在超级用户态的非法地址引用了。新实现将在第17章“最近发展”的“处理内核空间失效”中介绍。

oops显示故障时的处理器状态,模块CPU寄存器内容,页描述符表的位置,以及其他似乎不能理解的信息。这些是由失效处理函数(arch/*/kernel/traps.c)中的printk语句产生的,而且象前面“Printk”一节介绍的那样进行分派。

让我们看看这样一个消息。这里给出的是传统个人电脑(x86平台),运行Linux 2.0或更新版本的oops――版本1.2的输出稍有不同。

(代码)

上面的消息是在一个有意加入错误的失效模块上运行cat所至。fault.c崩溃如下代码:

(代码)

由于read从它的小缓冲区(faulty_buf)复制数据到用户空间,我们希望读一小块文件能够工作。然而,每次读出多于1KB的数据会跨越页面边界,如果访问了非法页面read就会失败。事实上,前面给出的oops是在请求一个4KB大小的read时发生的,这条消息在/var/log/messages(syslogd默认存放内核消息的文件)的oops消息前给出了:

(代码)

同样的cat命令却不能在Alpha上产生oops,这是因为从faulty_buf读取4KB字节没有超出页边界(Alpha上的页面大小是8KB,缓冲区正好在页面的起始位置附近)。如果在你的系统上读取faulty没有产生oops,试试wc,或者给dd显式地指定块大小。

使用ksymoops

oops消息的最大问题就是十六进制数值对于程序员来说没什么意义;需要将它们解析为符号。

内核源码通过其所包含的ksymoops工具帮助开发人员――但是注意,版本1.2的源码中没有这个程序。该工具将oops消息中的数值地址解析为内核符号,但只限于PC机产生的oops消息。由于消息本身就是处理器相关的,每一体系结构都有其自身的消息格式。

ksymoops从标准输入获得oops消息,并从命令行内核符号表的名字。符号表通常就是/usr/src/linux/System.map。程序以更可读的方式打印调用轨迹和程序代码,而不是最原始的oops消息。下面的片断就是用上一节的oops消息得出的结果:

(代码)

由ksymoops反汇编出的代码给出了失效的指令和其后的指令。很明显――对于那些知道一点汇编的人――repz movsl指令(REPeat till cx is Zero, MOVe a String of Longs)用源索引(esi,是0x202e000)访问了一个未映射页面。用来获得模块信息的ksymoops -m命令给出,模块映射到一个在0x0202dxxx的页面上,这也确认乐esi确实超出了范围。

由于faulty模块所占用的内存不在系统表中,被解码的调用轨迹还给出了两个数值地址。这些值可以手动补充,或是通过ksyms命令的输出,或是在/proc/ksyms中查询模块的名字。

然而对于这个失效,这两个地址并不对应与代码地址。如果你看了arch/i386/kernel/traps.c,你就发现,调用轨迹是从整个堆栈并利用一些启发式方法区分数据值(本地变量和函数参数)和返回地址获得的。调用轨迹中只给出了引用内核代码的地址和引用模块的地址。由于模块所占页面既有代码也有数据,错综复杂的栈可能会漏掉启发式信息,这就是上面两个0x202xxxx地址的情况。

如果你不愿手动查看模块地址,下面这组管道可以用来创建一个既有内核又有模块符号的符号表。无论何时你加载模块,你都必须重新创建这个符号表。

(代码)

这个管道将完整的系统表与/proc/ksyms中的公开内核符号混合在一起,后者除了内核符号外,还包括了当前内核里的模块符号。这些地址在insmod重定位代码后就出现在/proc/ksyms中。由于这两个文件的格式不同,使用了sed和awk将所有的文本行转换为一种合适的格式。然后对这张表排序,去除重复部分,这样ksymoops就可以用了。

如果我们重新运行ksymoops,它从新的符号表中截取出如下信息:

(代码)

正如你所见到的,当跟踪与模块有关的oops消息时,创建一个修订的系统表是很有助益的:现在ksymoops能够对指令指针解码并完成整个调用轨迹了。还要注意,显式反汇编码的格式和objdump所使用的格式一样。objdump也是一个功能强大的工具;如果你需要查看失败前的指令,你调用命令objdump &#0;d faulty.o。

在文件的汇编列表中,字串faulty_read+45/60标记为失效行。有关objdump的更多的信息和它的命令行选项可以参见该命令的手册。

即便你构建了你自己的修订版符号表,上面提到的有关调用轨迹的问题仍然存在:虽然0x202xxxx指针被解码了,但仍然是假的。

学会解码oops消息需要一定的经验,但是确实值得一做。用来学习的时间很快就会有所回报。不过由于机器指令的Unix语法与Intel语法不同,唯一的问题在于从哪获得有关汇编语言的文档;尽管你了解PC汇编语言,但你的经验都是用Intel语法的编程获得的。在参考书目中,我给一些有所补益的书籍。

使用oops

使用ksymoops有些繁琐。你需要C++编译器编译它,你还要构建你自己的符号表来充分发挥程序的能力,你还要将原始消息和ksymoops输出合在一起组成可用的信息。

如果你不想找这么多麻烦,你可以使用oops程序。oops在本书的O’Reilly FTP站点给出的源码中。它源自最初的ksymoops工具,现在它的作者已经不维护这个工具了。oops是用C语言写成的,而且直接查看/proc/ksyms而无需用户每次加载模块后构建新的符号表。

该程序试图解码所有的处理器寄存器并堆栈轨迹解析为符号值。它的缺点是,它要比ksymoops罗嗦些,但通常你所有的信息越多,你发现错误也就越快。oops的另一个优点是,它可以解析x86,Alpha和Sparc的oops消息。与内核源码相同,这个程序也按GPL发行。

oops产生的输出与ksymoops的类似,但是更完全。这里给出前一个oops输出的开始部分&#0;由于在这个oops消息中堆栈没保存什么有用的东西,我不认为应该显示整个堆栈轨迹:

(代码)

当你调试“真正的”模块(faulty太短了,没有什么意义)时,将寄存器和堆栈解码是非常有益的,而且如果被调试的所有模块符号都开放出来时更有帮助。在失效时,处理器寄存器一般不会指向模块的符号,只有当符号表开放给/proc/ksyms时,你才能输出中标别它们。

我们可以用一下步骤制作一张更完整的符号表。首先,我们不应在模块中声明静态变量,否则我们就无法用insmod开放它们了。第二,如下面的截取自scull的init_module函数的代码所示,我们可以用#ifdef SCULL_DEBUG或类似的宏屏蔽register_symtab调用。

(代码)

我们在第2章“编写和运行模块”的“注册符号表”一节中已经看到了类似内容,那里说,如果模块不注册符号表,所有的全局符号就都开放。尽管这一功能仅在SCULL_DEBUG被激活时才有效,为了避免内核中的名字空间污染,所有的全局符号有合适的前缀(参见第2章的“模块与应用程序”一节)。

使用klogd

klogd守护进程的近期版本可以在oops存放到记录文件前对oops消息解码。解码过程只由版本1.3或更新版本的守护进程完成,而且只有将-k /usr/src/linux/System.map做为参数传递给守护进程时才解码。(你可以用其他符号表文件代替System.map)

有新的klogd给出的faulty的oops如下所示,它写到了系统记录中:

(代码)

我想能解码的klogd对于调试一般的Linux安装的核心来说是很好的工具。由klogd解码的消息包括大部分ksymoops的功能,而且也要求用户编译额外的工具,或是,当系统出现故障时,为了给出完整的错误报告而合并两个输出。当oops发生在内核时,守护进程还会正确地解码指令指针。它并不反汇编代码,但这不是问题,当错误报告给出消息时,二进制数据仍然存在,可以离线反汇编代码。

守护进程的另一个功能就是,如果符号表版本与当前内核不匹配,它会拒绝解析符号。如果在系统记录中解析出了符号,你可以确信它是正确的解码。

然而,尽管它对Linux用户很有帮助,这个工具在调试模块时没有什么帮助。我个人没有在开放软件的电脑里使用解码选项。klogd的问题是它不解析模块中的符号;因为守护进程在程序员加载模块前就已经运行了,即使读了/proc/ksyms也不会有什么帮助。记录文件中存在解析后的符号会使oops和ksymoops混淆,造成进一步解析的困难。

如果你需要使用klogd调试你的模块,最新版本的守护进程需要加入一些新的特殊支持,我期待它的完成,只要给内核打一个小补丁就可以了。

系统挂起

尽管内核代码中的大多数错误仅会导致一个oops消息,有时它们困难完全将系统挂起。如果系统挂起了,没有消息能够打印出来。例如,如果代码遇到一个死循环,内核停止了调度过程,系统不会再响应任何动作,包括魔法键Ctrl-Alt-Del组合。

处理系统挂起有两个选择――一个是防范与未然,另一个就是亡羊补牢,在发生挂起后调试代码。

通过在策略点上插入schedule调用可以防止死循环。schedule调用(正如你所猜想到的)调用调度器,因此允许其他进程偷取当然进程的CPU时间。如果进程因你的驱动程序中的错误而在内核空间循环,你可以在跟踪到这种情况后杀掉这个进程。

在驱动程序代码中插入schedule调用会给程序员带来新的“问题”:函数,,以及调用轨迹中的所有函数,必须是可重入的。在正常环境下,由于不同的进程可能并发地访问设备,驱动程序做为整体是可重入的,但由于Linux内核是不可抢占的,不必每个函数都是可重入的。但如果驱动程序函数允许调度器中断当前进程,另一个不同的进程可能会进入同一个函数。如果schedule调用仅在调试期间打开,如果你不允许,你可以避免两个并发进程访问驱动程序,所以并发性倒不是什么非常重要的问题。在介绍阻塞型操作时(第5章的“写可重入代码”)我们再详细介绍并发性问题。

如果要调试死循环,你可以利用Linux键盘的特殊键。默认情况下,如果和修饰键一起按了PrScr键(键码是70),系统会向当前控制台打印有关机器状态的有用信息。这一功能在x86和Alpha系统都有。Linux的Sparc移植也有同样的功能,但它使用了标记为“Break/Scroll Lock”的键(键码是30)。

每一个特殊函数都有一个名字,并如下面所示都有一个按键事件与之对应。组合键之后的括号里是函数名。

Shift-PrScr(Show_Memory)

打印若干行关于内存使用的信息,尤其是有关缓冲区高速缓存的使用情况。

Control-PrScr(Show_State)

针对系统里的每一个处理器打印一行信息,同时还打印内部进程树。对当前进程进行标记。

RightAlt-PrScr(Show_Registers)

由于它可以打印按键时的处理器寄存器内容,它是系统挂起时最重要的一个键了。如果有当前内核的系统表的话,查看指令计数器以及它如何随时间变化,对了解代码在何处循环非常有帮助。

如果想将这些函数映射到不同的键上,每一个函数名都可以做为参数传递给loadkeys。键盘映射表可以任意修改(这是“策略无关的”)。

如果console_loglevel足够到的话,这些函数打印的消息会出现在控制台上。如果不是你运行了一个旧klogd和一个新内核的话,默认记录级应该足够了。如果没有出现消息,你可以象以前说的那样提升记录级。“足够高”的具体值与你使用的内核版本有关。对于Linux 2.0或更新的版本来说是5。

即便当系统挂起时,消息也会打印到控制台上,确认记录级足够高是非常重要的。消息是在产生中断时生成的,因此即便有错的进程不释放CPU也可以运行――当然,除非中断被屏蔽了,不过如果发生这种情况既不太可能也非常不幸。

有时系统看起来象是挂起了,但其实不是。例如,如果键盘因某种奇怪的原因被锁住了就会发生这种情况。这种假挂起可以通过查看你为探明此种情况而运行的程序输出来判断。我有一个程序会不断地更新LED显示器上的时钟,我发现这个对于验证调度器尚在运行非常有用。你可以不必依赖外部设备就可以检查调度器,你可以实现一个程序让键盘LED闪烁,或是不断地打开关闭软盘马达,或是不断触动扬声器――不过我个人认为,通常的蜂鸣声很烦人,应该尽量避免。看看ioctl命令KDMKTONE。O’Reilly FTP站点上的例子程序(misc-progs/heartbeat.c)中有一个是让键盘LED不断闪烁的。

如果键盘不接收输入了,最佳的处理手段是从网络登录在系统中,杀掉任何违例的进程,或是重新设置键盘(用kdb_mode -a)。然而,如果你没有网络可用来恢复的话,发现系统挂起是由键盘锁死造成的一点儿用也没有。如果情况确实是这样,你应该配置一种替代输入设备,至少可以保证正常地重启系统。对于你的计算机来说,关闭系统或重启比起所谓的按“大红钮”要更方便一些,至少它可以免去长时间地fsck扫描磁盘。

这种替代输入设备可以是游戏杆或是鼠标。在sunsite.edu.cn上有一个游戏杆重启守护进程,gpm-1.10或更新的鼠标服务器可以通过命令行选项支持类似的功能。如果键盘没有锁死,但是却误入“原始”模式,你可以看看kdb包中文档介绍的一些小技巧。我建议最好在问题出现以前就看看这些文档,否则就太晚了。另一种可能是配置gpm-root菜单,增添一个“reboot”或“reset keyboard”菜单项;gpm-root一个响应控制鼠标事件的守护进程,它用来在屏幕上显示菜单和执行所配置的动作。

最好,你会可以按“留意安全键”(SAK),一个用于将系统恢复为可用状态的特殊键。由于不是所有的实现都能用,当前Linux版本的默认键盘表中没有为此键特设一项。不过你还是可以用loadkeys将你的键盘上的一个键映射为SAK。你应该看看drivers/char目录中的SAK实现。代码中的注释解释了为什么这个键在Linux 2.0中不是总能工作,这里我就不多说了。

不过,如果你运行版本2.1.9或是更新的版本,你就可以使用非常可靠地留意安全键了。此外,2.1.43及后续版本内核还有一个编译选项选择是否打开“SysRq魔法键”;我建议你看一看drivers/char/sysrq.c中的代码并使用这项新技术。

如果你的驱动程序真的将系统挂起了,而且你有不知道在哪插入schedule调用,最佳的处理方法就是加一些打印消息,并将它们打印到控制台上(通过修改console_loglevel变量值)。在重演挂起过程时,最好将所有的磁盘都以只读方式安装在系统上。如果磁盘是只读的或没有安装,就不会存在破坏文件系统或使其进入不一致状态的危险。至少你可以避免在复位系统后运行fsck。另一中方法就是使用NFS根计算机来测试模块。在这种情况下,由于NFS服务器管理文件系统的一致性,而它又不会受你的驱动程序的影响,你可以避免任何的文件系统崩溃。

使用调试器

最后一种调试模块的方法就是使用调试器来一步步地跟踪代码,查看变量和机器寄存器的值。这种方法非常耗时,应该尽可能地避免。不过,某些情况下通过调试器对代码进行细粒度的分析是非常有益的。在这里,我们所说的被调试的代码运行在内核空间――除非你远程控制内核,否则不可能一步步跟踪内核,这会使很多事情变得更加困难。由于远程控制很少用到,我们最后介绍这项技术。所幸的是,在当前版本的内核中可以查看和修改变量。

在这一级上熟练地使用调试器需要精通gdb命令,对汇编码有一定了解,并且有能够将源码与优化后的汇编码对应起来的能力。

不幸的是,gdb更适合与调试核心而不是模块,调试模块化的代码需要更多的技术。这更多的技术就是kdebug包,它利用gdb的“远程调试”接口控制本地内核。我将在介绍普通调试器后介绍kdebug。

使用gdb

gdb在探究系统内部行为时非常有用。启动调试器时必须假想内核就是一个应用程序。除了指定内核文件名外,你还应该在命令行中提供内存镜象文件的名字。典型的gdb调用如下所示:

(代码)

第一个参数是未经压缩的内核可执行文件(在你编译完内核后,这个文件在/usr/src/linux目录中)的名字。只有x86体系结构有zImage文件(有时称为vmlinuz),它是一种解决Intel处理器实模式下只有640KB限制的一种技巧;而无论在哪个平台上,vmlinux都是你所编译的未经压缩的内核。

gdb命令行的第二个参数是是内存镜象文件的名字。与其他在/proc下的文件类似,/proc/kcore也是在被读取时产生的。当read系统调用在/proc文件系统执行时,它映射到一个用于数据生成而不是数据读取的函数上;我们已在“使用/proc文件系统”一节中介绍了这个功能。系统用kcore来表示按内存镜象文件格式存储的内核“可执行文件”;由于它要表示整个内核地址空间,它是一个非常巨大的文件,对应所有的物理内存。利用gdb,你可以通过标准gdb命令查看内核标量。例如,p jiffies可以打印从系统启动到当前时刻的时钟滴答数。

当你从gdb打印数据时,内核还在运行,不同数据项会在不同时刻有不同的数值;然而,gdb为了优化对内存镜象文件的访问会将已经读到的数据缓存起来。如果你再次查看jiffies变量,你会得到和以前相同的值。缓存变量值防止额外的磁盘操作对普通内存镜象文件来说是对的,但对“动态”内存镜象文件来说就不是很方便了。解决方法是在你想刷新gdb缓存的时候执行core-file /proc/kcore命令;调试器将使用新的内存镜象文件并废弃旧信息。但是,读新数据时你并不总是需要执行core-file命令;gdb以1KB的尺度读取内存镜象文件,仅仅缓存它所引用的若干块。

你不能用普通gdb做的是修改内核数据;由于调试器需要在访问内存镜象前运行被调试程序,它是不会去修改内存镜象文件的。当调试内核镜象时,执行run命令会导致在执行若干指令后导致段违例。出于这个原因,/proc/kcore都没有实现write方法。

如果你用调试选项(-g)编译了内核,结果产生的vmlinux比没有用-g选项的更适合于gdb。不过要注意,用-g选项编译内核需要大量的磁盘空间――支持网络和很少几个设备和文件系统的2.0内核在PC上需要11KB。不过不管怎样,你都可以生成zImage文件并用它来其他系统:在生成可启动镜象时由于选项-g而加入的调试信息最终都被去掉了。如果我有足够的磁盘空间,我会一致打开-g选项的。

在非PC计算机上则有不同的方法。在Alpha上,make boot会在生成可启动镜象前将调试信息去掉,所以你最终会获得vmlinux和vmlinux.gz两个文件。gdb可以使用前者,但你只能用后者启动。在Sparc上,默认情况下内核(至少是2.0内核)不会被去掉调试信息,所以你需要在将其传递给silo(Sparc的内核加载器)前将调试信息去掉,这样才能启动。由于尺寸的问题,无论milo(Alpha的内核加载器)还是silo都不能启动未去掉调试信息的内核。

当你用-g选项编译内核并且用vmlinux和/proc/kcore一起使用调试器,gdb可以返回很多有关内核内部结构的信息。例如,你可以使用类似于这样的命令,p *module_list,p *module_list->next和p *chrdevs[4]->fops等显示这些结构的内容。如果你手头有内核映射表和源码的话,这些探测命令是非常有用的。

另一个gdb可以在当前内核上执行的有用任务是,通过disassemble命令(它可以缩写)或是“检查指令”(x/i)命令反汇编函数。disassemble命令的参数可以是函数名或是内存区范围,而x/i则使用一个内存地址做为参数,也可以用符号名。例如,你可以用x/20i反汇编20条指令。注意,你不能反汇编一个模块的函数,这是因为调试器处理vmlinux,它并不知道你的模块的信息。如果你试图用模块的地址反汇编代码,gdb很有可能会报告“不能访问xxxx处的内存(Cannot access memory at xxxx)”。基于同样的原因,你不查看属于模块的数据项。如果你知道你的变量的地址,你可以从/dev/mem中读出它的值,但很难弄明白从系统内存中分解出的数据是什么含义。

如果你需要反汇编模块函数,你最好对用objdump工具处理你的模块文件。很不幸,该工具只能对磁盘上的文件进行处理,而不能对运行中的模块进行处理;因此,objdump中给出的地址都是未经重定位的地址,与模块的运行环境无关。

如你所见,当你的目的是查看内核的运行情况时,gdb是一个非常有用的工具,但它缺少某些功能,最重要的一些功能就是修改内核项和访问模块的功能。这些空白将由kdebug包填补。

使用kdebug

你可用从一般的FTP站点下的pcmcia/extras目录下拿到kdebug,但是如果你想确保拿到的是最新的版本,你最好到ftp://hyper.stanford.edu/pub/pcmcia/extras/去找。该工具与pcmcia没有什么关系,但是这两个包是同一个作者写的。

kdebug是一个使用gdb“远程调试”接口与内核通信的小工具。使用时首先向内核加载一个模块,调试器通过/dev/kdebug访问内核数据。gdb将该设备当成一个与被调试“应用”通信的串口设备,但它仅仅是一个用于访问内核空间的通信通道。由于模块本身运行在内核空间,它可以看到普通调试器无法访问的内核空间地址。正如你所猜想到的,模块是一个字符设备驱动程序,并且使用了主设备号动态分配技术。

kdebug的优点在于,你无需打补丁或重新编译:无论是内核还是调试器都无需修改。你所需要做的就是编译和安装软件包,然后调用kgdb,kgdb是一个完成某些配置并调用gdb,通过新接口访问内核部件结构的脚本程序。

但是,即便是kdebug也没有提供单步跟踪内核代码和设置断点的功能。这几乎是不可避免的,因为内核必须保持运行状态以保证系统的出于运行状态,跟踪内核代码的唯一方法就是后面将要谈到的从另外一台计算机上通过串口控制系统。不过kgdb的实现允许用户修改被调试应用(即当前内核)的数据项,可以传递给内核任意数目的参数,并以读写方式访问模块所属的内存区。

最后一个功能就是通过gdb命令将模块符号表增加到调试器内部的符号表中。这个工作是由kgdb完成的。然后当用户请求访问某个符号时,gdb就知道它的地址是哪了。最终的访问是由模块里的内核代码完成的。不过要注意,kdebug的当前版本(1.6)在映射模块化代码地址方面还有些问题。你最好通过打印一些符号并与/proc/ksyms中的值进行比较来做些检查。如果地址没有匹配,你可以使用数值,但必须将它们强行转换为正确的类型。下面就是一个强制类型转换的例子:

(代码)

kdebug的另一个强于gdb的优点是,它允许你在数据结构被修改后读取到最新的值,而不必刷新调试器的缓存;gdb命令set remotecache 0可以用来关闭数据缓存。

由于kdebug与gdb使用起来很相似,这里我就不过多地罗列使用这个工具的例子了。对于知道如何使用调试器的人来说,这种例子很简单,但对于那些对调试器一无所知的人来说就很晦涩了。能够熟练地使用调试器需要时间和经验,我不准备在这里承担老师的责任。

总而言之,kdebug是一个非常好的程序。在线修改数据结构对于开发人员来说是一个非常大的进步(而且一种将系统挂起的最简单方法)。现在有许多工具可以使你的开发工作更轻松――例如,在开发scull期间,当模块的使用计数器增长后*,我可以使用kdebug来将其复位为0。这就不必每次都麻烦我重启机器,登录,再次启动我的应用程序等等。

远程调试

调试内核镜象的最后一个方法是使用gdb的远程调试能力。

当执行远程调试的时候,你需要两台计算机:一台运行gdb;另一台运行你要调试的内核。这两台计算机间用普通串口连接起来。如你所料,控制gdb必须能够理解它所控制的内核的二进制格式。如果这两台计算机是不同的体系结构,必须将调试器编译为可以支持目标平台的。

在2.0中,Linux内核的Intel版本不支持远程调试,但是Alpha和Sparc版本都支持。在Alpha版本中,你必须在编译时包含对远程调试的支持,并在启动时通过传递给内核命令行参数kgdb=1或只有kgdb打开这个功能。在Sparc上,始终包含了对远程调试的支持。启动选项kgdb=ttyx可以用来选择在哪个串口上控制内核,x可以是a或b。如果没有使用kgdb=选项,内核就按正常方式启动。

如果在内核中打开了远程调试功能,系统在启动时就会调用一个特殊的初始化函数,配置被调试内核处理它自己的断点,并且跳转到一个编译自程序中的断点。这会暂停内核的正常执行,并将控制转移给断点服务例程。这一处理函数在串口线上等待来自于gdb的命令,当它获得gdb的命令后,就执行相应的功能。通过这一配置,程序员可以单步跟踪内核代码,设置断点,并且完成gdb所允许的其他任务。

在控制端,需要一个目标镜象的副本(我们假设它是linux.img),还需要一个你要调试的模块副本。如下命令必须传递给gdb:

file linux.img

file命令告诉gdb哪个二进制文件需要调试。另一种方法是在命令行中传递镜象文件名。这个文件本身必须和运行在另一端的内核一模一样。

target remote /dev/ttyS1

这条命令通知gdb使用远程计算机做为调试过程的目标。/dev/ttyS1是用来通信的本地串口,你可以指定任一设备。例如,前面介绍的kdebug软件包中的kgdb脚本使用target remote /dev/kdebug。

add-symbol-file module.o address

如果你要调试已经加载到被控内核的模块的话,在控制系统上你需要一个模块目标文件的副本。add-symbol-file通知gdb处理模块文件,假定模块代码被定位在地址address上了。

尽管远程调试可以用于调试模块,但你还是要加载模块,并且在模块上插入断点前还需要触发另一个断点,调试模块还是需要很多技巧的。我个人不会使用远程调试去跟踪模块,除非异步运行的代码,如中断处理函数,出了问题。

[目录]


ptrace进程跟踪


函数使用说明
名字
ptrace - 进程跟踪

形式
#include <sys/ptrace.h>
int ptrace(int request, int pid, int addr, int data);

描述
Ptrace 提供了一种父进程可以控制子进程运行,并可以检查和改变它的核心image。它主要用于实现断点调试。一个被跟踪的进程运行中,直到发生一个信号。则进程被中止,并且通知其父进程。在进程中止的状态下,进程的内存空间可以被读写。父进程还可以使子进程继续执行,并选择是否是否忽略引起中止的信号。
Request参数决定了系统调用的功能:
PTRACE_TRACEME
本进程被其父进程所跟踪。其父进程应该希望跟踪子进程。
PTRACE_PEEKTEXT, PTRACE_PEEKDATA
从内存地址中读取一个字节,内存地址由addr给出。
PTRACE_PEEKUSR
从USER区域中读取一个字节,偏移量为addr。
PTRACE_POKETEXT, PTRACE_POKEDATA
往内存地址中写入一个字节。内存地址由addr给出。
PTRACE_POKEUSR
往USER区域中写入一个字节。偏移量为addr。
PTRACE_SYSCALL, PTRACE_CONT
重新运行。
PTRACE_KILL
杀掉子进程,使它退出。
PTRACE_SINGLESTEP
设置单步执行标志
PTRACE_ATTACH
跟踪指定pid 进程。
PTRACE_DETACH
结束跟踪
Intel386特有:
PTRACE_GETREGS
读取寄存器
PTRACE_SETREGS
设置寄存器
PTRACE_GETFPREGS
读取浮点寄存器
PTRACE_SETFPREGS
设置浮点寄存器
init进程不可以使用此函数

返回值
成功返回0。错误返回-1。errno被设置。

错误
EPERM
特殊进程不可以被跟踪或进程已经被跟踪。
ESRCH
指定的进程不存在
EIO
请求非法

函数使用说明
名字
ptrace - 进程跟踪

形式
#include <sys/ptrace.h>
int ptrace(int request, int pid, int addr, int data);

描述
Ptrace 提供了一种父进程可以控制子进程运行,并可以检查和改变它的核心image。它主要用于实现断点调试。一个被跟踪的进程运行中,直到发生一个信号。则进程被中止,并且通知其父进程。在进程中止的状态下,进程的内存空间可以被读写。父进程还可以使子进程继续执行,并选择是否是否忽略引起中止的信号。
Request参数决定了系统调用的功能:
PTRACE_TRACEME
本进程被其父进程所跟踪。其父进程应该希望跟踪子进程。
PTRACE_PEEKTEXT, PTRACE_PEEKDATA
从内存地址中读取一个字节,内存地址由addr给出。
PTRACE_PEEKUSR
从USER区域中读取一个字节,偏移量为addr。
PTRACE_POKETEXT, PTRACE_POKEDATA
往内存地址中写入一个字节。内存地址由addr给出。
PTRACE_POKEUSR
往USER区域中写入一个字节。偏移量为addr。
PTRACE_SYSCALL, PTRACE_CONT
重新运行。
PTRACE_KILL
杀掉子进程,使它退出。
PTRACE_SINGLESTEP
设置单步执行标志
PTRACE_ATTACH
跟踪指定pid 进程。
PTRACE_DETACH
结束跟踪
Intel386特有:
PTRACE_GETREGS
读取寄存器
PTRACE_SETREGS
设置寄存器
PTRACE_GETFPREGS
读取浮点寄存器
PTRACE_SETFPREGS
设置浮点寄存器
init进程不可以使用此函数

返回值
成功返回0。错误返回-1。errno被设置。

错误
EPERM
特殊进程不可以被跟踪或进程已经被跟踪。
ESRCH
指定的进程不存在
EIO
请求非法

功能详细描述
PTRACE_TRACEME
形式:ptrace(PTRACE_TRACEME,0 ,0 ,0)
描述:本进程被其父进程所跟踪。其父进程应该希望跟踪子进程。

PTRACE_PEEKTEXT, PTRACE_PEEKDATA
形式:ptrace(PTRACE_PEEKTEXT, pid, addr, data)
          ptrace(PTRACE_PEEKDATA, pid, addr, data)
描述:从内存地址中读取一个字节,pid表示被跟踪的子进程,内存地址由addr给出,data为用户变量地址用于返回读到的数据。在Linux(i386)中用户代码段与用户数据段重合所以读取代码段和数据段数据处理是一样的。

PTRACE_POKETEXT, PTRACE_POKEDATA
形式:ptrace(PTRACE_POKETEXT, pid, addr, data)
          ptrace(PTRACE_POKEDATA, pid, addr, data)
描述:往内存地址中写入一个字节。pid表示被跟踪的子进程,内存地址由addr给出,data为所要写入的数据。

PTRACE_PEEKUSR
形式:ptrace(PTRACE_PEEKUSR, pid, addr, data)
描述:从USER区域中读取一个字节,pid表示被跟踪的子进程,USER区域地址由addr给出,data为用户变量地址用于返回读到的数据。USER结构为core文件的前面一部分,它描述了进程中止时的一些状态,如:寄存器值,代码、数据段大小,代码、数据段开始地址等。在Linux(i386)中通过PTRACE_PEEKUSER和PTRACE_POKEUSR可以访问USER结构的数据有寄存器和调试寄存器。

PTRACE_POKEUSR
形式:ptrace(PTRACE_POKEUSR, pid, addr, data)
描述:往USER区域中写入一个字节,pid表示被跟踪的子进程,USER区域地址由addr给出,data为需写入的数据。

PTRACE_CONT
形式:ptrace(PTRACE_CONT, pid, 0, signal)
描述:继续执行。pid表示被跟踪的子进程,signal为0则忽略引起调试进程中止的信号,若不为0则继续处理信号signal。

PTRACE_SYSCALL
形式:ptrace(PTRACE_SYS, pid, 0, signal)
描述:继续执行。pid表示被跟踪的子进程,signal为0则忽略引起调试进程中止的信号,若不为0则继续处理信号signal。与PTRACE_CONT不同的是进行系统调用跟踪。在被跟踪进程继续运行直到调用系统调用开始或结束时,被跟踪进程被中止,并通知父进程。

PTRACE_KILL
形式:ptrace(PTRACE_KILL,pid)
描述:杀掉子进程,使它退出。pid表示被跟踪的子进程。

PTRACE_SINGLESTEP
形式:ptrace(PTRACE_KILL, pid, 0, signle)
描述:设置单步执行标志,单步执行一条指令。pid表示被跟踪的子进程。signal为0则忽略引起调试进程中止的信号,若不为0则继续处理信号signal。当被跟踪进程单步执行完一个指令后,被跟踪进程被中止,并通知父进程。

PTRACE_ATTACH
形式:ptrace(PTRACE_ATTACH,pid)
描述:跟踪指定pid 进程。pid表示被跟踪进程。被跟踪进程将成为当前进程的子进程,并进入中止状态。

PTRACE_DETACH
形式:ptrace(PTRACE_DETACH,pid)
描述:结束跟踪。 pid表示被跟踪的子进程。结束跟踪后被跟踪进程将继续执行。

PTRACE_GETREGS
形式:ptrace(PTRACE_GETREGS, pid, 0, data)
描述:读取寄存器值,pid表示被跟踪的子进程,data为用户变量地址用于返回读到的数据。此功能将读取所有17个基本寄存器的值。

PTRACE_SETREGS
形式:ptrace(PTRACE_SETREGS, pid, 0, data)
描述:设置寄存器值,pid表示被跟踪的子进程,data为用户数据地址。此功能将设置所有17个基本寄存器的值。

PTRACE_GETFPREGS
形式:ptrace(PTRACE_GETFPREGS, pid, 0, data)
描述:读取浮点寄存器值,pid表示被跟踪的子进程,data为用户变量地址用于返回读到的数据。此功能将读取所有浮点协处理器387的所有寄存器的值。

PTRACE_SETFPREGS
形式:ptrace(PTRACE_SETREGS, pid, 0, data)
描述:设置浮点寄存器值,pid表示被跟踪的子进程,data为用户数据地址。此功能将设置所有浮点协处理器387的所有寄存器的值。

 

 

[目录]


宏#与##


宏定义中的"#"前缀将参数替换成字符串,例如
#define test(x) #x
test(123) 被替换成字符串"123";
"##"用于连接参数,例如
#define test(x,y) ##x##y
test(123,456) 替换成123456;
因此BI(0x0,0)替换成BUILD_IRQ(0x00),"pushl $"#nr"-256/n/t"替换成"pushl $""0x00""-256/n/t"

cpp.info手册对此有详细说明。

 

 

[目录]

 


 

[ 本文件由 良友·收藏家自动生成 ]