聊聊Posix语义之读写系统调用

// read 系统调用的定义
SYSCALL_DEFINE3(read, unsigned int, fd, char __user *, buf, size_t, count)
{
	return ksys_read(fd, buf, count);
}

// write系统调用的定义
SYSCALL_DEFINE3(write, unsigned int, fd, const char __user *, buf,
		size_t, count)
{
	return ksys_write(fd, buf, count);
}

ssize_t ksys_read(unsigned int fd, char __user *buf, size_t count)
{
	// 根据fd得到本进程内fd对应的struct file
	struct fd f = fdget_pos(fd);
	ssize_t ret = -EBADF;

	if (f.file) {
		// 获取struct file当前读取的pos
		loff_t pos = file_pos_read(f.file);
		// 经过vfs_read->具体磁盘文件系统的read调用
		ret = vfs_read(f.file, buf, count, &pos);
		if (ret >= 0)
			// 更改struct file中的读写的位置pos
			file_pos_write(f.file, pos);
		fdput_pos(f);
	}
	return ret;
}

ssize_t ksys_write(unsigned int fd, const char __user *buf, size_t count)
{
	// 根据fd得到本进程内fd对应的struct file
	struct fd f = fdget_pos(fd);
	ssize_t ret = -EBADF;

	if (f.file) {
		// 获取struct file当前读取的pos
		loff_t pos = file_pos_read(f.file);
		// 经过vfs_write->具体磁盘文件系统的write调用
		ret = vfs_write(f.file, buf, count, &pos);
		if (ret >= 0)
		// 更改struct file中的读写的位置pos
			file_pos_write(f.file, pos);
		fdput_pos(f);
	}

	return ret;
}

// ext4磁盘文件系统的struct file操作函数表，这里仅仅列举了read/write
const struct file_operations ext4_file_operations = {

	.read_iter	= ext4_file_read_iter,
	.write_iter	= ext4_file_write_iter,
};

// ext4文件系统的page cache的管理
static const struct address_space_operations ext4_aops = {
	.write_begin		= ext4_write_begin,
	.write_end		= ext4_write_end,
	.direct_IO		= ext4_direct_IO,
};


// ext4文件系统写操作函数
ssize_t __generic_file_write_iter(struct kiocb *iocb, struct iov_iter *from)
{
	// 判断是否是O_DIRECT
	if (iocb->ki_flags & IOCB_DIRECT) {
		written = generic_file_direct_write(iocb, from) {
		
			struct address_space *mapping = file->f_mapping;
			// 走ext4的dio函数
			written = mapping->a_ops->direct_IO(iocb, from)
			{
				// 执行Ext4的di函数
				ext4_direct_IO(iocb, from) {
					ext4_direct_IO_write(iocb, iter) {
							// 最终走块设备 层的__blockdev_direct_IO函数进行dio的写入
							ret = __blockdev_direct_IO(iocb, inode, inode->i_sb->s_bdev, iter,get_block_func, ext4_end_io_dio, NULL,dio_flags);
					}
				}
			}
		}
	} else {
		// 走ext4 page cache逻辑，逐个iovec和page进行写处理操作
		written = generic_perform_write(file, from, iocb->ki_pos)
		{
		  // a_ops->write_begin 函数是准备缓冲区，读入对应的数据结构
			status = a_ops->write_begin(file, mapping, pos, bytes, flags,&page, &fsdata)
		  {
		  	ext4_write_begin(file, mapping, pos, bytes, flags,&page, &fsdata) {
		  		ret = __block_write_begin(page, pos, len, ext4_get_block);
		  	}
		  }
			// 将用户的缓冲区内容复制到page cache/block cache.
			copied = iov_iter_copy_from_user_atomic(page, i, offset, bytes);
			// a_ops->write_end 函数是将缓冲区标记为脏准备会写。
			status = a_ops->write_end(file, mapping, pos, bytes, copied,page, fsdata)
			{
				ext4_write_end(file, mapping, pos, bytes, copied,page, fsdata) {
					copied = block_write_end(file, mapping, pos,len, copied, page, fsdata);
					ext4_mark_inode_dirty(handle, inode);
				}
			}
		}
	}
out:
	current->backing_dev_info = NULL;
	return written ? written : err;
}

// ext4 文件读取操作的执行流程
static ssize_t ext4_file_read_iter(struct kiocb *iocb, struct iov_iter *to)
{

#ifdef CONFIG_FS_DAX
	// 支持dax设备，IO不仅过IO协议栈，直接和磁盘驱动交互
	if (IS_DAX(file_inode(iocb->ki_filp)))
		return ext4_dax_read_iter(iocb, to);
#endif
	return generic_file_read_iter(iocb, to)
	{
		// 如果是DIO,则进入page cache的dio函数
		if (iocb->ki_flags & IOCB_DIRECT) {
			retval = mapping->a_ops->direct_IO(iocb, iter)
			{
				// 进入ext4的dio读函数，直接和块设备交互
				ext4_direct_IO(iocb, iter)
				{
					ext4_direct_IO_read(iocb, iter) {
							__blockdev_direct_IO(iocb, inode, inode->i_sb->s_bdev,iter, ext4_dio_get_block, NULL, NULL, 0);
					}
				}
			}
		}else {
			// 数据的从缓冲区
			retval = generic_file_buffered_read(iocb, iter, retval)
			{
				// 调用对应ext4函数从page cache中获取数据
				error = mapping->a_ops->readpage(filp, page)
				{
					ext4_readpage(filp, page) {
						ext4_mpage_readpages(page->mapping, NULL, page, 1,false);
					}
				}
			}
		}
	}
}