首页 / LINUX / Linux内核设计的艺术-关于缓冲块的进程等待队列

Linux内核设计的艺术-关于缓冲块的进程等待队列

内容导读

互联网集市收集整理的这篇技术教程文章主要介绍了Linux内核设计的艺术-关于缓冲块的进程等待队列，小编现在分享给大家，供广大互联网技能从业者学习和参考。文章包含8855字，纯文字阅读大概需要13分钟。

内容图文

进程A是一个读盘进程，目的是将hello.txt文件中的100字节读入buffer[100]。

代码如下：

void FunA();
void main()
{
	...
	FunA();
	...
}

void FunA()
{
	char buffer[100];
	int i,j;
	int fd = open("/mnt/user/user1/user2/hello.txt",O_RDWR,0644);
	read(fd,buffer,sizeof(buffer));
	close(fd);
	
	for(i=0;i<1000000;i++)
	{
		for(j=0;i<100000;j++)
		{
			;
		}
	}
}

进程B也是一个读盘进程，目的是将hello.txt文件中的200字节读入buffer[200]。

void FunB();
void main()
{
	...
	FunB();
	...
}

void FunB()
{
	char buffer[200];
	int i,j;
	int fd = open("/mnt/user/user1/user2/hello.txt",O_RDWR,0644);
	read(fd,buffer,sizeof(buffer));
	close(fd);
	
	for(i=0;i<1000000;i++)
	{
		for(j=0;i<100000;j++)
		{
			;
		}
	}
}

进程C是一个写盘进程，目的是往hello.txt文件中写入str[]中的字符“ABCDE”。

代码如下：

void FunC();
void main()
{
	...
	FunC();
	...
}

void FunC()
{
	char str1[]="ABCDE";
	int i,j;
	int fd = open("/mnt/user/user1/user2/hello.txt",O_RDWR,0644);
	write(fd,str1,strlen(str1));
	close(fd);
	
	for(i=0;i<1000000;i++)
	{
		for(j=0;i<100000;j++)
		{
			;
		}
	}
}

这三个进程执行顺序为：进程A先执行，之后进程B执行，最后进程C执行。这三个进程没有父子关系。

进程A启动后，执行open函数，最终会映射到sys_open函数区执行。

代码路径：fs/open.c

nt sys_open(const char * filename,int flag,int mode)
{
	.../寻找空闲的file，和inode
	(current->filp[fd]=f)->f_count++;
	if ((i=open_namei(filename,flag,mode,&inode))<0) {
	        ...
	}
        ...
	f->f_mode = inode->i_mode;
	f->f_flags = flag;
	f->f_count = 1;
	f->f_inode = inode;
	f->f_pos = 0;
	return (fd);
}

之后开始执行read函数，read函数最终会映射到sys_read()函数去执行。

代码路径：fs/read_write.c

int sys_read(unsigned int fd,char * buf,int count)
{
	struct file * file;
	struct m_inode * inode;

	if (fd>=NR_OPEN || count<0 || !(file=current->filp[fd]))
		return -EINVAL;
	...
	inode = file->f_inode;
	...
	if (S_ISDIR(inode->i_mode) || S_ISREG(inode->i_mode)) {
		if (count+file->f_pos > inode->i_size)
			count = inode->i_size - file->f_pos;
		if (count<=0)
			return 0;
		return file_read(inode,file,buf,count);
	}
	printk("(Read)inode->i_mode=%06o\n\r",inode->i_mode);
	return -EINVAL;
}

之后sys_read函数调用file_read()来读取文件内容。

代码路径：fs/file_dev.c

int file_read(struct m_inode * inode, struct file * filp, char * buf, int count)
{
	int left,chars,nr;
	struct buffer_head * bh;

	if ((left=count)<=0)
		return 0;
	while (left) {
		if ((nr = bmap(inode,(filp->f_pos)/BLOCK_SIZE))) {
			if (!(bh=bread(inode->i_dev,nr)))
				break;
		} else
			bh = NULL;
		nr = filp->f_pos % BLOCK_SIZE;
		chars = MIN( BLOCK_SIZE-nr , left );
		filp->f_pos += chars;
		left -= chars;
		if (bh) {
			char * p = nr + bh->b_data;
			while (chars-->0)
				put_fs_byte(*(p++),buf++);
			brelse(bh);
		} else {
			while (chars-->0)
				put_fs_byte(0,buf++);
		}
	}
	inode->i_atime = CURRENT_TIME;
	return (count-left)?(count-left):-ERROR;
}

file_read()函数调用bread()函数从硬盘上读取数据。

代码路径：fs/buffer.c

struct buffer_head * bread(int dev,int block)
{
	struct buffer_head * bh;

	if (!(bh=getblk(dev,block)))//申请了一个空闲的缓冲块
		panic("bread: getblk returned NULL\n");
	if (bh->b_uptodate)//uptodate为0
		return bh;
	ll_rw_block(READ,bh);//将缓冲块加锁并与请求项绑定，发送读盘指令
	wait_on_buffer(bh);
	if (bh->b_uptodate)
		return bh;
	brelse(bh);
	return NULL;
}

getblk申请了一个空闲的缓冲块，然后调用ll_rw_block，将缓冲块加锁并与请求项绑定，发送读盘指令。
代码路径：kernel/blk_drv/ll_rw_block.c

void ll_rw_block(int rw, struct buffer_head * bh)
{
	unsigned int major;

	if ((major=MAJOR(bh->b_dev)) >= NR_BLK_DEV ||
	!(blk_dev[major].request_fn)) {
		printk("Trying to read nonexistent block-device\n\r");
		return;
	}
	make_request(major,rw,bh);
}

static void make_request(int major,int rw, struct buffer_head * bh)
{
	...
	lock_buffer(bh);//加锁
        if ((rw == WRITE && !bh->b_dirt) || (rw == READ && bh->b_uptodate)) {//为写且不脏，或者读且uptodate为1，则直接返回，进程B和进程C就是这种情况 
            unlock_buffer(bh);  
            return;  
        } 
	...
	add_request(major+blk_dev,req);//发送读盘请求
}

static inline void lock_buffer(struct buffer_head * bh)
{
	cli();
	while (bh->b_lock)//如果已经上了锁，就要等待了
		sleep_on(&bh->b_wait);
	bh->b_lock=1;
	sti();
}

加锁，发出请求后，硬盘就开始工作了，把硬盘中的数据独到硬盘缓冲区，每读完一块就会发出中断。

程序接着往下执行到wait_on_buffer。

代码路径：fs/buffer.c

static inline void wait_on_buffer(struct buffer_head * bh)
{
	cli();
	while (bh->b_lock)//已经上锁了
		sleep_on(&bh->b_wait);
	sti();
}

代码路径：kernel/sched.c

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;//此时tmp中保存的是NULL
	*p = current;//bh->wait保存的是进程A的task_struct指针
	current->state = TASK_UNINTERRUPTIBLE;//将进程A设置为不可中断等待状态
	schedule();//切换进程
	if (tmp)
		tmp->state=0;
}

进程A被挂起后，调用schedule，切换到进程B执行。与此同时，硬盘也正在向数据寄存器端口中传递数据。

进程B的执行流程与进程A大致一致，不过open_namei中获取的hello.txt文件的i节点有所不同，找到了现成的hello.txt文件的i节点，引用计数增加。

还有一处不同点就是getblk，申请缓冲块，此时在哈希表中可以找到指定的缓冲块，直接返回。

执行的ll_rw_block时，然后执行make_request，然后执行lock_buffer时，代码如下：

static inline void lock_buffer(struct buffer_head * bh)
{
	cli();
	while (bh->b_lock)//如果已经上了锁，就要等待了
		sleep_on(&bh->b_wait);
	bh->b_lock=1;
	sti();
}

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;//此时tmp中保存的是进程A的task_struct指针
	*p = current;//bh->wait保存的是进程B的task_struct指针
	current->state = TASK_UNINTERRUPTIBLE;//将进程B设置为不可中断等待状态
	schedule();//切换进程
	if (tmp)
		tmp->state=0;
}

然后，切换到进程C，与此同时，硬盘也正在向数据寄存器端口中传递数据。

进程C的大致流程和进程B都一样，只不过write调用sys_write，然后又调用file_write。代码如下：

代码路径：fs/file_dev.c

int file_write(struct m_inode * inode, struct file * filp, char * buf, int count)
{
	off_t pos;
	int block,c;
	struct buffer_head * bh;
	char * p;
	int i=0;

/*
 * ok, append may not work when many processes are writing at the same time
 * but so what. That way leads to madness anyway.
 */
	if (filp->f_flags & O_APPEND)
		pos = inode->i_size;
	else
		pos = filp->f_pos;
	while (i<count) {
		if (!(block = create_block(inode,pos/BLOCK_SIZE)))
			break;
		if (!(bh=bread(inode->i_dev,block)))
			break;
		c = pos % BLOCK_SIZE;
		p = c + bh->b_data;
		bh->b_dirt = 1;
		c = BLOCK_SIZE-c;
		if (c > count-i) c = count-i;
		pos += c;
		if (pos > inode->i_size) {
			inode->i_size = pos;
			inode->i_dirt = 1;
		}
		i += c;
		while (c-->0)
			*(p++) = get_fs_byte(buf++);
		brelse(bh);
	}
	inode->i_mtime = CURRENT_TIME;
	if (!(filp->f_flags & O_APPEND)) {
		filp->f_pos = pos;
		inode->i_ctime = CURRENT_TIME;
	}
	return (i?i:-1);
}

与进程B一样，bread->ll_rw_block->make_request->lock_buffer->sleep_on，代码如下：

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;//此时tmp中保存的是进程B的task_struct指针
	*p = current;//bh->wait保存的是进程C的task_struct指针
	current->state = TASK_UNINTERRUPTIBLE;//将进程C设置为不可中断等待状态
	schedule();//切换进程
	if (tmp)
		tmp->state=0;
}

进程C被挂起后，调用schedule函数，此时系统中已经没有就绪的进程了，因此切换到进程0执行。与此同时，硬盘也正在向数据寄存器端口中传递数据。

此时进程A、进程B、进程C都已经被挂起了，系统中所有的进程又都处于非就绪态了。所以默认切换到进程0去执行，知道数据读取完毕，硬盘产生中断。

硬盘中断产生后，中断服务程序将开始工作，此时硬盘已经将指定的数据全部载入缓冲块。中断服务程序开始工作后，将bh缓冲块解锁，并调用wake_up函数，将bh中wait字段所对应的进程（进程C）唤醒。执行代码如下：

代码路径：kernel/blk_drv/blk.h

static inline void end_request(int uptodate)
{
	DEVICE_OFF(CURRENT->dev);
	if (CURRENT->bh) {
		CURRENT->bh->b_uptodate = uptodate;//update为1
		unlock_buffer(CURRENT->bh);//执行这里，将缓冲块解锁
	}
	if (!uptodate) {
		printk(DEVICE_NAME " I/O error\n\r");
		printk("dev %04x, block %d\n\r",CURRENT->dev,
			CURRENT->bh->b_blocknr);
	}
	wake_up(&CURRENT->waiting);
	wake_up(&wait_for_request);
	CURRENT->dev = -1;
	CURRENT = CURRENT->next;
}

代码路径：kernel/blk_drv/ll_rw_blk.c

static inline void unlock_buffer(struct buffer_head * bh)
{
	if (!bh->b_lock)
		printk("ll_rw_block.c: buffer not locked\n\r");
	bh->b_lock = 0;
	wake_up(&bh->b_wait);
}

代码路径：kernel/sched.c

void wake_up(struct task_struct **p)
{
	if (p && *p) {
		(**p).state=0;//这里将进程C设置为就绪态
		*p=NULL;//bh->wait为NULL
	}
}

中断服务程序结束后，再次返回进程0中，并切换到就绪的进程C，进程C是在sleep_on函数中，调用了schedule函数进程进程切换到，因为接着往下执行：

void sleep_on(struct task_struct **p)
{
	...
	current->state = TASK_UNINTERRUPTIBLE;//将进程C设置为不可中断等待状态
	schedule();//切换进程
	if (tmp)
		tmp->state=0;//将进程B设置为就绪态
}

进程C，接着执行make_request，正如上面代码注释的一样，此时是写且非脏，所以bread函数返回，执行真正的写代码，如下：

while (c-->0)
			*(p++) = get_fs_byte(buf++);

之后返回进程C的用户程序，消耗时间片

	for(i=0;i<1000000;i++)
	{
		for(j=0;i<100000;j++)
		{
			;
		}
	}

进程C的时间片消减为0，要切换进程，现在只有B和C处于就绪态，进程C的时间片用完了，所以切换到进程B。进程B也是sleep_on函数中被切换的，请看下面的代码：

void sleep_on(struct task_struct **p)
{
	...
	current->state = TASK_UNINTERRUPTIBLE;//将进程B设置为不可中断等待状态
	schedule();//切换进程
	if (tmp)
		tmp->state=0;//将进程A设置为就绪态
}

进程B，接着执行make_request，正如上面代码注释的一样，此时是读且uptodate为1，所以bread函数返回，执行真正的读代码，如下：

while (chars-->0)
				put_fs_byte(*(p++),buf++);

之后返回进程C的用户程序，消耗时间片，直到为0，此时就切换到进程A了。同样是在sleep_on函数切走的。

void sleep_on(struct task_struct **p)
{
	...
	current->state = TASK_UNINTERRUPTIBLE;//将进程A设置为不可中断等待状态
	schedule();//切换进程
	if (tmp)//此时已经为NULL了
		tmp->state=0;
}

进程A，执行完wait_on_buffer，所以bread函数返回，执行真正的读代码，如下：

while (chars-->0)
				put_fs_byte(*(p++),buf++);

至此，就全部分析完了。

原文：http://blog.csdn.net/jltxgcy/article/details/21866169

内容总结

以上是互联网集市为您收集整理的Linux内核设计的艺术-关于缓冲块的进程等待队列全部内容，希望文章能够帮你解决Linux内核设计的艺术-关于缓冲块的进程等待队列所遇到的程序开发问题。如果觉得互联网集市技术教程内容还不错，欢迎将互联网集市网站推荐给程序员好友。

内容备注

版权声明：本文内容由互联网用户自发贡献，该文观点与技术仅代表作者本人。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如发现本站有涉嫌侵权/违法违规的内容，请发送邮件至 gblab@vip.qq.com 举报，一经查实，本站将立刻删除。

内容手机端

扫描二维码推送至手机访问。

本文链接：https://qyyshop.com/info/1301699.html

来源：【匿名】

【上一篇】linux中文件传输【下一篇】Linux下安装GD

更多 ►

【Linux内核设计的艺术-关于缓冲块的进程等待队列】教程文章相关的互联网学习教程文章

Linux内核设计的艺术-关于缓冲块的进程等待队列

进程A是一个读盘进程，目的是将hello.txt文件中的100字节读入buffer[100]。代码如下：void FunA(); void main() {...FunA();... }void FunA() {char buffer[100];int i,j;int fd = open("/mnt/user/user1/user2/hello.txt",O_RDWR,0644);read(fd,buffer,sizeof(buffer));close(fd);for(i=0;i<1000000;i++){for(j=0;i<100000;j++){;}} } 进程B也是一个读盘进程，目的是将hello.txt文件中的200字节读入buffer[200]。 void ...

浅谈 Linux 内核开发之网络设备驱动【代码】

网络设备介绍网络设备是计算机体系结构中必不可少的一部分，处理器如果想与外界通信，通常都会选择网络设备作为通信接口。众所周知，在 OSI（Open Systems Interconnection，开放网际互连）中，网络被划分为七个层次，从下到上分别是物理层、数据链路层、网络层、传输层、会话层、表示层和应用层。我们所讲的网络设备也包括两个层次，一层叫做 MAC（Media Access Control）层，对应于 OSI 的数据链路层；另一层叫做 PHY（Physical ...

Oracle在Linux内核参数的修改

实例：kernel.core_uses_pid = 1kernel.shmall = 2097152kernel.shmmax = 2147483648kernel.shmmni = 4096kernel.sem = 250 32000 100 128fs.file-max = 65536net.ipv4.ip_local_port_range = 9000 65000net.core.rmem_default = 4194304net.core.rmem_max = 4194304net.core.wmem_default = 262144net.core.wmem_max = 262144ore_uses_pid可以控制产生的core文件的文件名中是否添加pid作为扩展，如果添加则文件内容为1，否则为0 服...

linux 内核升级

LINUX 内核升级linux 内核官网https://www.kernel.org/ POST BIOS(boot sequence) 所选择的启动设备次序的MBR中是否有引导程序， ----> MBR(bootloader) 提供内核列表 ------->加载选定的Kernel，initrd(内存模拟的磁盘设备需要缓存)，initramfs（缓存） ---->获取到根文件系统并挂载，运行init　　设置默认运行级别　　定义运行的系统初始化脚本，　　运行制定下的S开头的服务，关闭K开头的服务　　CtrlAltDel　　　　启动字符终...

Linux内核设计基础（九）之进程管理和调度【图】

在Linux中进程用结构体task_struct来管理一个进程所需的所有信息（所以一般较大，在32位机上，大约有1.7KB）。为了提高效率，Linux使用了一些卓越的技术。通过slab分配task_struct结构Linux创建进程迅速，正是因为slab分配器预先分配和重复使用task_struct，这样就避免了动态分配和释放所带来的资源消耗（毕竟一个task_struct较大，而且内核中进程的创建和消除很频繁）。将task_struct放置在内核栈的尾端这样做是为了让那些像x86那...

linux内核参数sem的说明

sem：是semaphores的缩写，该参数表示设置的信号量。它包含四个值：semmsl、semmns、semopm、semmni。常规设置 kernel.sem = 250 32000 100 128semmns：信号灯的最大数量，跟ORACLE的PROCESS数有关。SEMMSL * SEMMNIsemopm：系统调用允许的信号量最大个数。至少100；或者等于SEMMSLsemmni：系统信号量set最大个数。最少128semmsl：每个信号灯集合中最多的信号灯数目。最小250；对于processes参数设置较大的系统建议设置为pro...

linux内核版本表示方法

linux内核版本号由三个数字组成：r.x.yr:主版本号。目前发布的kernel版本x:次版本号。偶数：稳定版本；奇数：开发中版本y:bug修补的次数本文出自 “小风” 博客，请务必保留此出处http://huanglianfeng.blog.51cto.com/4813074/1355226原文：http://huanglianfeng.blog.51cto.com/4813074/1355226

2018-2019-1 20189203《Linux内核原理与分析》第九周作业【代码】【图】

第一部分课本学习进程的切换和系统的一般执行过程进程调度的时机 Linux内核系统通过schedule函数实现进程调度，进程调度的时机就是内核调用schedule函数的时机。当内核即将返回用户空间时，内核会检查need_resched标志是否设置。如果设置，则调用schedule函数，此时是从中断（异常/系统调用）处理程序返回用户空间的时间点作为一个固定的调度时机点。简单总结进程调度时机如下：用户进程通过特定的系统调用主动让出CPU 中断处理...

2.15.2.linux内核源码目录结构2

本节接上节讲解内核源码根目录下的各个文件夹，并且把一些重要文件夹的作用简单讲解。(1)arch。arch是architecture的缩写，意思是架构。arch目录下是好多个不同架构的CPU的子目录，譬如arm这种cpu的所有文件都在arch/arm目录下，X86的CPU的所有文件都在arch/x86目录下。 (2)block。英文是块的意思，在linux中block表示块设备（以块（多个字节组成的整体，类似于扇区）为单位来整体访问），譬如说SD卡、iNand、Nand、硬盘等都是块设...

Linux内核设计与实现读书笔记转

Linux内核设计与实现读书笔记：http://www.cnblogs.com/wang_yb/tag/linux-kernel/ 《深入理解LINUX内存管理》http://blog.csdn.net/yrj/article/category/718110 Linux内存管理和性能学习笔记（一）：内存测量与堆内存第一篇内存的测量 2.1. 系统当前可用内存# cat /proc/meminfoMemTotal: 8063544 kBMemFree: 900952 kBBuffers: 1183596 kBCached: 1596808 kBMemTotal：总共可用物理内存...

Linux内核pr_debug的应用及log级别控制原理简析【图】

调试环境------CPU：freescale i.mx6操作系统：Linux内核版本号：3.0.35 最近在调试一个spi nor flash芯片的时候用到了gpio倒出的功能，就是可以在linux起来以后，通过串口倒出，并可以控制输入输出方向和高低电平的一种功能。配置好对应的pin后发现怎么都不能在/sys/class/gpio的目录下生成相应的接口目录，我要倒出的GPIO是gpio bank6的第11教，根据imx6平台gpio编号的计算方法IMX_GPIO_NR(6, 11)，得到这个GPIO的编号是174（有兴...

Linux内核的文件预读readahead【代码】【图】

Linux的文件预读readahead，指Linux系统内核将指定文件的某区域预读进页缓存起来，便于接下来对该区域进行读取时，不会因缺页（page fault）而阻塞。因为从内存读取比从磁盘读取要快很多。预读可以有效的减少磁盘的寻道次数和应用程序的I/O等待时间，是改进磁盘读I/O性能的重要优化手段之一。维基百科上关于readhead的介绍资料：readahead is a system call of the Linux kernel that loads a file‘s contents into the page cach...

linux内核中ip，tcp等头的定义(转)【图】

一、MAC帧头定义/*数据帧定义，头14个字节，尾4个字节*/typedef struct _MAC_FRAME_HEADER{ char m_cDstMacAddress[6]; //目的mac地址 char m_cSrcMacAddress[6]; //源mac地址 short m_cType; 　　　　　//上一层协议类型，如0x0800代表上一层是IP协议，0x0806为arp}__attribute__((packed))MAC_FRAME_HEADER,*PMAC_FRAME_HEADER; typedef struct _MAC_FRAME_TAIL{ unsigned int m_sCheckSum; //数据帧尾校验和}__a...

linux内核交互,设备驱动控制管理接口

1,ioctlpreface--starting point ,format,mount volume,in addition to the abovefile system -- allows users to store and retrive data; organized in a hierarchical directory tree,behaviorial semantics as spelled ou;ASM shared disk cluster file system;one that allows multiple nodes to access the same disk at the same tine;2,原文：http://www.cnblogs.com/ruiy/p/4385327.html

构建调试Linux内核网络代码的环境MenuOS系统【代码】【图】

构建调试Linux内核网络代码的环境MenuOS系统1.搭建linux环境linux内核环境指的是我们用虚拟机运行linux系统，在linux上运行我们开发的网络代码，这样做的好处就是方便调试，通过虚拟机，我们可以用gdb调试，观察内核运行到哪里了，尤其是针对网络方面的接口（如socket、bind等），调试使我们清晰的看到程序调用了什么，执行了什么，这对于我们的学习大有脾益，而为了搭建环境，我们需要1.下载并编译Linux内核，2.安装qemu，下载并编...

LINUX内核 - 相关标签

linux内核版本 linux内核设计与实现

LINUX - 最热教程

Xrdp - 通过Windows的RDP连接Linux远程...VMware中Linux虚拟机挂载主机共享文件夹...Linux双网卡配置虚拟机下Linux安装好Nginx后，宿主机无...linux下安装postgresql并配置远程图形桌...Linux命令--exportfs命令详解 linux 终端printf打印显示乱码问题修正 Linux下Shell的for循环语句N种写法 Linux下创建nginx脚本-start、stop、re...SUSELinux安装MySQL

首页 / LINUX / Linux内核设计的艺术-关于缓冲块的进程等待队列

Linux内核设计的艺术-关于缓冲块的进程等待队列

内容导读

内容图文

内容总结

内容备注

内容手机端

【Linux内核设计的艺术-关于缓冲块的进程等待队列】教程文章相关的互联网学习教程文章

Linux内核设计的艺术-关于缓冲块的进程等待队列

浅谈 Linux 内核开发之网络设备驱动【代码】

Oracle在Linux内核参数的修改

linux 内核升级

Linux内核设计基础（九）之进程管理和调度【图】

linux内核参数sem的说明

linux内核版本表示方法

2018-2019-1 20189203《Linux内核原理与分析》第九周作业【代码】【图】

2.15.2.linux内核源码目录结构2

Linux内核设计与实现读书笔记转

Linux内核pr_debug的应用及log级别控制原理简析【图】

Linux内核的文件预读readahead【代码】【图】

linux内核中ip，tcp等头的定义(转)【图】

linux内核交互,设备驱动控制管理接口

构建调试Linux内核网络代码的环境MenuOS系统【代码】【图】

LINUX内核 - 相关标签

进程 - 相关标签

LINUX - 最新教程

LINUX - 最热教程