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

本文链接：https://blog.csdn.net/jltxgcy/article/details/21866169

本文详细解析了三个进程A、B、C对同一文件进行读写操作的过程，包括open、read、write等系统调用的具体实现及流程，展示了进程间如何通过文件系统进行交互。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

进程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++);

至此，就全部分析完了。