Linux文件系统2(基于6.1内核)

最新推荐文章于 2025-02-08 10:28:29 发布
原创 最新推荐文章于 2025-02-08 10:28:29 发布 · 855 阅读 · 17 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
文章标签：

#linux #运维 #服务器

Linux文件系统2(基于6.1内核)---VFS读写流程

 

一、文件系统框架：

　　从文件系统一种我们了解了linux文件系统的框架，这里我们首先再通过下面简洁的流程图

来展示linux文件系统文件读写的大框架：

从上图中可以看出linux文件系统的读写通过调用虚拟文件系统（VFS）的对应接口，从而

调用到实际文件系统的读写接口，来进行emmc的操作，这样可以实现多文件系统兼容，如android

中的boot/system分区是ext4的格式，但cache/userdata我们可以配置为f2fs的文件系统格式，但

VFS层的调用接口是不变的。对应的相关结构体直接的关系：

二、抓取调用trace方法

2.1、linux应用层操作方法

举例说明：

#include <unistd.h>
#include <stdio.h>
#include <stdlib.h>
#include <fcntl.h>
#include <sys/mman.h>
int main(void)
{
	int i,f;
	FILE *fp;
	char string[24];
 
	fp = fopen("test.dat","w+");
	return 0;
}

gcc  file_open.c  -o  file_open

strace  ./file_open   可以抓取到应用层调用的trace：

2.2、kernel  ftrace抓取

举例说明：

# function.sh
#!/bin/bash
debugfs=/sys/kernel/debug
echo nop > $debugfs/tracing/current_tracer
echo 0 > $debugfs/tracing/tracing_on
echo $$ > $debugfs/tracing/set_ftrace_pid
echo function_graph > $debugfs/tracing/current_tracer
echo vfs_open > $debugfs/tracing/set_graph_function
# echo test_proc_write > $debugfs/tracing/set_graph_function
echo 1 > $debugfs/tracing/tracing_on
 
exec $@

./function.sh  ./file_open

cat /sys/kernel/debug/tracing/trace > open.txt

三、调用流程解析

3.1 open流程

+-------------------------+
| 用户调用 open()         |
| (glibc 用户空间封装)    |
+-------------------------+
            |
            v
+-------------------------+
| 系统调用进入内核        |
| 调用 sys_open()         |
+-------------------------+
            |
            v
+-------------------------+
| 检查参数                |
| (路径和标志检查)        |
+-------------------------+
            |
            v
+-------------------------+
| 调用 do_sys_open()      |
| (核心打开逻辑)          |
+-------------------------+
            |
            v
+-------------------------+
| 调用 do_sys_openat2()   |
| (打开带路径的文件)      |
+-------------------------+
            |
            v
+-------------------------+
| 调用 do_filp_open()     |
| (打开文件对象)          |
+-------------------------+
            |
            v
+-------------------------+
| 调用 path_openat()      |
| (路径查找)              |
+-------------------------+
            |
            v
+-------------------------+
| 调用 do_o_path()        |
| (路径解析和文件查找)    |
+-------------------------+
            |
            v
+-------------------------+
| 调用 vfs_open()         |
| (虚拟文件系统层的打开)  |
+-------------------------+
            |
            v
+-------------------------+
| 调用 do_dentry_open()   |
| (dentry 操作)           |
+-------------------------+
            |
            v
+-------------------------+
| 调用 ext4_file_open()   |
| (ext4 文件系统的打开)   |
+-------------------------+
            |
            v
+-------------------------+
| 返回文件描述符          |
+-------------------------+

详细步骤：

  1. 用户调用 open():

    • 应用程序通过标准库调用 open() 系统调用，传递文件路径和打开标志。

  2. 进入内核，调用 sys_open():

    • 系统调用触发，进入内核层，调用 sys_open() 处理。

  3. 检查参数:

    • 内核检查传入的路径、打开标志（如 O_RDONLY、O_WRONLY 等），确保它们有效且合法。

  4. 调用 do_sys_open():

    • sys_open() 调用 do_sys_open()，这是实际的文件打开处理函数。

  5. 调用 do_sys_openat2():

    • do_sys_open() 最终调用 do_sys_openat2() 以处理文件的具体打开操作。

  6. 调用 do_filp_open():

    • do_filp_open() 是一个封装函数，用来管理文件结构体（file）和文件描述符的分配。

  7. 调用 path_openat():

    • 在路径查找的过程中，调用 path_openat() 来解析传入的路径，并进行必要的权限检查。

  8. 调用 do_o_path():

    • path_openat() 调用 do_o_path() 来完成路径解析，确保文件的路径和权限都正确。

  9. 调用 vfs_open():

    • do_o_path() 调用 vfs_open()，这是虚拟文件系统（VFS）层的文件打开接口，处理与文件系统相关的更多细节。

  10. 调用 do_dentry_open():

    • vfs_open() 调用 do_dentry_open() 来进行 dentry（目录项）的操作，这是文件路径查找的关键部分。

  11. 调用 ext4_file_open():

    • 如果文件在 ext4 文件系统上，最终会调用 ext4_file_open() 来完成与具体文件系统的交互，处理文件的打开。

  12. 返回文件描述符:

    • 成功打开文件后，内核返回一个文件描述符给用户空间，应用程序可以通过该文件描述符进行文件读写等操作。

代码描述：

 fs/open.c

SYSCALL_DEFINE3(open, const char __user *, filename, int, flags, umode_t, mode)
{
	if (force_o_largefile())
		flags |= O_LARGEFILE;
	return do_sys_open(AT_FDCWD, filename, flags, mode);
}
long do_sys_open(int dfd, const char __user *filename, int flags, umode_t mode)
{
	struct open_how how = build_open_how(flags, mode);
	return do_sys_openat2(dfd, filename, &how);
}
static long do_sys_openat2(int dfd, const char __user *filename,
			   struct open_how *how)
{
	struct open_flags op;
	int fd = build_open_flags(how, &op);
	struct filename *tmp;

	if (fd)
		return fd;

	tmp = getname(filename);
	if (IS_ERR(tmp))
		return PTR_ERR(tmp);

	fd = get_unused_fd_flags(how->flags);
	if (fd >= 0) {
		struct file *f = do_filp_open(dfd, tmp, &op);
		if (IS_ERR(f)) {
			put_unused_fd(fd);
			fd = PTR_ERR(f);
		} else {
			fd_install(fd, f);
		}
	}
	putname(tmp);
	return fd;
}
struct file *do_filp_open(int dfd, struct filename *pathname,
		const struct open_flags *op)
{
	struct nameidata nd;
	int flags = op->lookup_flags;
	struct file *filp;

	set_nameidata(&nd, dfd, pathname, NULL);
	filp = path_openat(&nd, op, flags | LOOKUP_RCU);
	if (unlikely(filp == ERR_PTR(-ECHILD)))
		filp = path_openat(&nd, op, flags);
	if (unlikely(filp == ERR_PTR(-ESTALE)))
		filp = path_openat(&nd, op, flags | LOOKUP_REVAL);
	restore_nameidata();
	return filp;
}
static struct file *path_openat(struct nameidata *nd,
			const struct open_flags *op, unsigned flags)
{
	struct file *file;
	int error;

	file = alloc_empty_file(op->open_flag, current_cred());
	if (IS_ERR(file))
		return file;

	if (unlikely(file->f_flags & __O_TMPFILE)) {
		error = do_tmpfile(nd, flags, op, file);
	} else if (unlikely(file->f_flags & O_PATH)) {
		error = do_o_path(nd, flags, file);
	} else {
		const char *s = path_init(nd, flags);
		while (!(error = link_path_walk(s, nd)) &&
		       (s = open_last_lookups(nd, file, op)) != NULL)
			;
		if (!error)
			error = do_open(nd, file, op);
		terminate_walk(nd);
	}
	if (likely(!error)) {
		if (likely(file->f_mode & FMODE_OPENED))
			return file;
		WARN_ON(1);
		error = -EINVAL;
	}
	fput(file);
	if (error == -EOPENSTALE) {
		if (flags & LOOKUP_RCU)
			error = -ECHILD;
		else
			error = -ESTALE;
	}
	return ERR_PTR(error);
}
static int do_o_path(struct nameidata *nd, unsigned flags, struct file *file)
{
	struct path path;
	int error = path_lookupat(nd, flags, &path);
	if (!error) {
		audit_inode(nd->name, path.dentry, 0);
		error = vfs_open(&path, file);
		path_put(&path);
	}
	return error;
}
/**
 * vfs_open - open the file at the given path
 * @path: path to open
 * @file: newly allocated file with f_flag initialized
 */
int vfs_open(const struct path *path, struct file *file)
{
	file->f_path = *path;
	return do_dentry_open(file, d_backing_inode(path->dentry), NULL);
}
static int do_dentry_open(struct file *f,
			  struct inode *inode,
			  int (*open)(struct inode *, struct file *))
{
	static const struct file_operations empty_fops = {};
	int error;

	path_get(&f->f_path);
	f->f_inode = inode;
	f->f_mapping = inode->i_mapping;
	f->f_wb_err = filemap_sample_wb_err(f->f_mapping);
	f->f_sb_err = file_sample_sb_err(f);

	if (unlikely(f->f_flags & O_PATH)) {
		f->f_mode = FMODE_PATH | FMODE_OPENED;
		f->f_op = &empty_fops;
		return 0;
	}

	if ((f->f_mode & (FMODE_READ | FMODE_WRITE)) == FMODE_READ) {
		i_readcount_inc(inode);
	} else if (f->f_mode & FMODE_WRITE && !special_file(inode->i_mode)) {
		error = get_write_access(inode);
		if (unlikely(error))
			goto cleanup_file;
		error = __mnt_want_write(f->f_path.mnt);
		if (unlikely(error)) {
			put_write_access(inode);
			goto cleanup_file;
		}
		f->f_mode |= FMODE_WRITER;
	}

	/* POSIX.1-2008/SUSv4 Section XSI 2.9.7 */
	if (S_ISREG(inode->i_mode) || S_ISDIR(inode->i_mode))
		f->f_mode |= FMODE_ATOMIC_POS;

	f->f_op = fops_get(inode->i_fop);
	if (WARN_ON(!f->f_op)) {
		error = -ENODEV;
		goto cleanup_all;
	}

	error = security_file_open(f);
	if (error)
		goto cleanup_all;

	error = break_lease(file_inode(f), f->f_flags);
	if (error)
		goto cleanup_all;

	/* normally all 3 are set; ->open() can clear them if needed */
	f->f_mode |= FMODE_LSEEK | FMODE_PREAD | FMODE_PWRITE;
	if (!open)
		open = f->f_op->open;
	if (open) {
		error = open(inode, f);
		if (error)
			goto cleanup_all;
	}
	f->f_mode |= FMODE_OPENED;
	if ((f->f_mode & FMODE_READ) &&
	     likely(f->f_op->read || f->f_op->read_iter))
		f->f_mode |= FMODE_CAN_READ;
	if ((f->f_mode & FMODE_WRITE) &&
	     likely(f->f_op->write || f->f_op->write_iter))
		f->f_mode |= FMODE_CAN_WRITE;
	if ((f->f_mode & FMODE_LSEEK) && !f->f_op->llseek)
		f->f_mode &= ~FMODE_LSEEK;
	if (f->f_mapping->a_ops && f->f_mapping->a_ops->direct_IO)
		f->f_mode |= FMODE_CAN_ODIRECT;

	f->f_flags &= ~(O_CREAT | O_EXCL | O_NOCTTY | O_TRUNC);
	f->f_iocb_flags = iocb_flags(f);

	file_ra_state_init(&f->f_ra, f->f_mapping->host->i_mapping);

	if ((f->f_flags & O_DIRECT) && !(f->f_mode & FMODE_CAN_ODIRECT))
		return -EINVAL;

	/*
	 * XXX: Huge page cache doesn't support writing yet. Drop all page
	 * cache for this file before processing writes.
	 */
	if (f->f_mode & FMODE_WRITE) {
		/*
		 * Paired with smp_mb() in collapse_file() to ensure nr_thps
		 * is up to date and the update to i_writecount by
		 * get_write_access() is visible. Ensures subsequent insertion
		 * of THPs into the page cache will fail.
		 */
		smp_mb();
		if (filemap_nr_thps(inode->i_mapping)) {
			struct address_space *mapping = inode->i_mapping;

			filemap_invalidate_lock(inode->i_mapping);
			/*
			 * unmap_mapping_range just need to be called once
			 * here, because the private pages is not need to be
			 * unmapped mapping (e.g. data segment of dynamic
			 * shared libraries here).
			 */
			unmap_mapping_range(mapping, 0, 0, 0);
			truncate_inode_pages(mapping, 0);
			filemap_invalidate_unlock(inode->i_mapping);
		}
	}

	/*
	 * Once we return a file with FMODE_OPENED, __fput() will call
	 * fsnotify_close(), so we need fsnotify_open() here for symmetry.
	 */
	fsnotify_open(f);
	return 0;

cleanup_all:
	if (WARN_ON_ONCE(error > 0))
		error = -EINVAL;
	fops_put(f->f_op);
	put_file_access(f);
cleanup_file:
	path_put(&f->f_path);
	f->f_path.mnt = NULL;
	f->f_path.dentry = NULL;
	f->f_inode = NULL;
	return error;
}
/**
 * path_get - get a reference to a path
 * @path: path to get the reference to
 *
 * Given a path increment the reference count to the dentry and the vfsmount.
 */
void path_get(const struct path *path)
{
	mntget(path->mnt);
	dget(path->dentry);
}
EXPORT_SYMBOL(path_get);

...

VFS层经过层层调用后会调用到具体的文件系统的接口ext4_file_open

 fs/ext4/file.c

const struct file_operations ext4_file_operations = {
	.llseek		= ext4_llseek,
	.read_iter	= ext4_file_read_iter,
	.write_iter	= ext4_file_write_iter,
	.iopoll		= iocb_bio_iopoll,
	.unlocked_ioctl = ext4_ioctl,
#ifdef CONFIG_COMPAT
	.compat_ioctl	= ext4_compat_ioctl,
#endif
	.mmap		= ext4_file_mmap,
	.mmap_supported_flags = MAP_SYNC,
	.open		= ext4_file_open, //f->f_op->open
	.release	= ext4_release_file,
	.fsync		= ext4_sync_file,
	.get_unmapped_area = thp_get_unmapped_area,
	.splice_read	= ext4_file_splice_read,
	.splice_write	= iter_file_splice_write,
	.fallocate	= ext4_fallocate,
};

3.2 read流程

+-------------------------------+
| 用户调用 read()               |
| (glibc 用户空间封装)          |
+-------------------------------+
              |
              v
+-------------------------------+
| 系统调用进入内核              |
| 调用 ksys_read()              |
+-------------------------------+
              |
              v
+-------------------------------+
| 进行参数检查                  |
| (文件描述符、缓冲区、大小等)   |
+-------------------------------+
              |
              v
+-------------------------------+
| 调用 vfs_read()               |
| (虚拟文件系统的读取接口)      |
+-------------------------------+
              |
              v
+-------------------------------+
| 调用 new_sync_read()          |
| (同步读取接口)                |
+-------------------------------+
              |
              v
+-------------------------------+
| 调用 call_read_iter()         |
| (文件读取的具体迭代接口)      |
+-------------------------------+
              |
              v
+-------------------------------+
| 调用 file->f_op->read_iter()  |
| (文件操作结构体中的读接口)    |
+-------------------------------+
              |
              v
+-------------------------------+
| 调用 ext4_file_read_iter()    |
| (ext4 文件系统的读取实现)     |
+-------------------------------+
              |
              v
+-------------------------------+
| 返回读取的数据               |
+-------------------------------+

详细步骤:

  1. 用户调用 read():

    • 应用程序在用户空间调用 read() 函数，这通常是通过标准 C 库（glibc）提供的接口。read() 函数的参数包括文件描述符、缓冲区地址和读取字节数。

  2. 系统调用进入内核，调用 ksys_read():

    • 用户空间的 read() 函数调用会触发一个系统调用，进入内核并调用 ksys_read() 函数，ksys_read() 是 Linux 内核中实际处理文件读取的系统调用接口。

  3. 参数检查:

    • 在 ksys_read() 中，内核会首先检查传递的参数是否合法，如文件描述符是否有效、缓冲区指针是否有效、读取字节数是否合法等。如果参数有误，内核会返回错误。

  4. 调用 vfs_read():

    • ksys_read() 调用 vfs_read()，这是虚拟文件系统（VFS）层的读取接口。vfs_read() 的作用是将读取请求传递到具体的文件系统层，处理实际的文件读取。

  5. 调用 new_sync_read():

    • 在 vfs_read() 中，通常会调用 new_sync_read() 来执行同步读取操作，确保读取过程在文件系统的锁保护下进行。new_sync_read() 会检查文件是否是阻塞模式，并进行相应的同步操作。

  6. 调用 call_read_iter():

    • new_sync_read() 进一步调用 call_read_iter()，该函数是一个通用的文件读取迭代接口，它会根据文件操作结构体（f_op）的 read_iter 方法来执行读取操作。

  7. 调用 file->f_op->read_iter():

    • call_read_iter() 会调用文件的操作结构体（f_op）中的 read_iter() 方法。f_op 是文件对象（file）中指向文件操作的结构体，其中的 read_iter() 函数会被具体的文件系统实现所填充，执行文件的读取操作。

  8. 调用 ext4_file_read_iter():

    • 如果文件是通过 ext4 文件系统打开的，file->f_op->read_iter 会指向 ext4_file_read_iter()，这是 ext4 文件系统实现的具体读取函数。ext4_file_read_iter() 会完成实际的磁盘读取操作，读取文件的数据并将其拷贝到用户空间的缓冲区中。

  9. 返回读取的数据:

    • 最终，ext4_file_read_iter() 将读取的数据返回给用户空间，操作系统会将数据拷贝到用户空间提供的缓冲区，并返回读取的字节数。如果发生错误，则返回相应的错误码。

代码描述：

fs/read_write.c

SYSCALL_DEFINE3(read, unsigned int, fd, char __user *, buf, size_t, count)
{
	return ksys_read(fd, buf, count);
}
ssize_t ksys_read(unsigned int fd, char __user *buf, size_t count)
{
	struct fd f = fdget_pos(fd);
	ssize_t ret = -EBADF;

	if (f.file) {
		loff_t pos, *ppos = file_ppos(f.file);
		if (ppos) {
			pos = *ppos;
			ppos = &pos;
		}
		ret = vfs_read(f.file, buf, count, ppos);
		if (ret >= 0 && ppos)
			f.file->f_pos = pos;
		fdput_pos(f);
	}
	return ret;
}
ssize_t vfs_read(struct file *file, char __user *buf, size_t count, loff_t *pos)
{
	ssize_t ret;

	if (!(file->f_mode & FMODE_READ))
		return -EBADF;
	if (!(file->f_mode & FMODE_CAN_READ))
		return -EINVAL;
	if (unlikely(!access_ok(buf, count)))
		return -EFAULT;

	ret = rw_verify_area(READ, file, pos, count);
	if (ret)
		return ret;
	if (count > MAX_RW_COUNT)
		count =  MAX_RW_COUNT;

	if (file->f_op->read)
		ret = file->f_op->read(file, buf, count, pos);
	else if (file->f_op->read_iter)
		ret = new_sync_read(file, buf, count, pos);
	else
		ret = -EINVAL;
	if (ret > 0) {
		fsnotify_access(file);
		add_rchar(current, ret);
	}
	inc_syscr(current);
	return ret;
}
static ssize_t new_sync_read(struct file *filp, char __user *buf, size_t len, loff_t *ppos)
{
	struct kiocb kiocb;
	struct iov_iter iter;
	ssize_t ret;

	init_sync_kiocb(&kiocb, filp);
	kiocb.ki_pos = (ppos ? *ppos : 0);
	iov_iter_ubuf(&iter, ITER_DEST, buf, len);

	ret = call_read_iter(filp, &kiocb, &iter);
	BUG_ON(ret == -EIOCBQUEUED);
	if (ppos)
		*ppos = kiocb.ki_pos;
	return ret;
}
static inline ssize_t call_read_iter(struct file *file, struct kiocb *kio,
				     struct iov_iter *iter)
{
	return file->f_op->read_iter(kio, iter);
}

...

VFS层经过层层调用后会调用到具体的文件系统的接口ext4_file_read_iter

 fs/ext4/file.c

const struct file_operations ext4_file_operations = {
	.llseek		= ext4_llseek,
	.read_iter	= ext4_file_read_iter,
	.write_iter	= ext4_file_write_iter,
	.iopoll		= iocb_bio_iopoll,
	.unlocked_ioctl = ext4_ioctl,
#ifdef CONFIG_COMPAT
	.compat_ioctl	= ext4_compat_ioctl,
#endif
	.mmap		= ext4_file_mmap,
	.mmap_supported_flags = MAP_SYNC,
	.open		= ext4_file_open,
	.release	= ext4_release_file,
	.fsync		= ext4_sync_file,
	.get_unmapped_area = thp_get_unmapped_area,
	.splice_read	= ext4_file_splice_read,
	.splice_write	= iter_file_splice_write,
	.fallocate	= ext4_fallocate,
};
static ssize_t ext4_file_read_iter(struct kiocb *iocb, struct iov_iter *to)
{
	struct inode *inode = file_inode(iocb->ki_filp);

	if (unlikely(ext4_forced_shutdown(inode->i_sb)))
		return -EIO;

	if (!iov_iter_count(to))
		return 0; /* skip atime */

#ifdef CONFIG_FS_DAX
	if (IS_DAX(inode))
		return ext4_dax_read_iter(iocb, to);
#endif
	if (iocb->ki_flags & IOCB_DIRECT)
		return ext4_dio_read_iter(iocb, to);

	return generic_file_read_iter(iocb, to);
}

3.3 write流程

+-------------------------------+
| 用户调用 write()              |
| (glibc 用户空间封装)           |
+-------------------------------+
              |
              v
+-------------------------------+
| 系统调用进入内核               |
| 调用 ksys_write()             |
+-------------------------------+
              |
              v
+-------------------------------+
| 进行参数检查                   |
| (文件描述符、缓冲区、字节数等) |
+-------------------------------+
              |
              v
+-------------------------------+
| 调用 vfs_write()              |
| (虚拟文件系统的写入接口)      |
+-------------------------------+
              |
              v
+-------------------------------+
| 调用 new_sync_write()         |
| (同步写入接口)               |
+-------------------------------+
              |
              v
+-------------------------------+
| 调用 call_write_iter()        |
| (文件写入的具体迭代接口)      |
+-------------------------------+
              |
              v
+-------------------------------+
| 调用 file->f_op->write_iter() |
| (文件操作结构体中的写接口)   |
+-------------------------------+
              |
              v
+-------------------------------+
| 调用 ext4_file_write_iter()   |
| (ext4 文件系统的写入实现)    |
+-------------------------------+
              |
              v
+-------------------------------+
| 返回写入的字节数或错误       |
+-------------------------------+

详细步骤:

  1. 用户调用 write()：

    • 应用程序在用户空间调用 write() 函数，write() 函数的参数包括文件描述符、缓冲区地址和写入字节数。它是通过标准 C 库（glibc）提供的接口。

  2. 系统调用进入内核，调用 ksys_write()：

    • 用户空间的 write() 函数会触发系统调用，进入内核并调用 ksys_write() 函数。ksys_write() 是 Linux 内核中实际处理文件写入的系统调用接口。

  3. 参数检查：

    • 在 ksys_write() 中，内核首先会对传递的参数进行合法性检查，如文件描述符、缓冲区指针是否有效、写入字节数是否合理等。如果参数无效，内核会返回错误。

  4. 调用 vfs_write()：

    • ksys_write() 调用 vfs_write()，这是虚拟文件系统（VFS）层的写入接口。vfs_write() 会根据文件描述符将写入请求转发到具体的文件系统层，执行实际的写操作。

  5. 调用 new_sync_write()：

    • 在 vfs_write() 中，通常会调用 new_sync_write() 来执行同步写入操作。new_sync_write() 会确保写入操作在文件系统的锁保护下进行，并且保证数据一致性。

  6. 调用 call_write_iter()：

    • new_sync_write() 进一步调用 call_write_iter()，这是一个通用的文件写入迭代接口。该函数根据文件操作结构体（f_op）的 write_iter 方法来执行具体的写入操作。

  7. 调用 file->f_op->write_iter()：

    • call_write_iter() 会调用文件操作结构体（f_op）中的 write_iter() 方法。f_op 是文件对象（file）中指向文件操作的结构体，其中的 write_iter() 方法会被具体的文件系统实现所填充，执行文件的写入操作。

  8. 调用 ext4_file_write_iter()：

    • 如果文件是通过 ext4 文件系统打开的，file->f_op->write_iter 会指向 ext4_file_write_iter()，这是 ext4 文件系统实现的具体写入函数。ext4_file_write_iter() 会完成实际的磁盘写入操作，将数据写入磁盘。

  9. 返回写入的字节数或错误：

    • 最终，ext4_file_write_iter() 会返回写入的字节数。如果发生错误，则返回相应的错误码。内核将这些结果返回给用户空间，write() 系统调用也会返回最终的结果。

代码描述：

fs/read_write.c

SYSCALL_DEFINE3(write, unsigned int, fd, const char __user *, buf,
		size_t, count)
{
	return ksys_write(fd, buf, count);
}
ssize_t ksys_write(unsigned int fd, const char __user *buf, size_t count)
{
	struct fd f = fdget_pos(fd);
	ssize_t ret = -EBADF;

	if (f.file) {
		loff_t pos, *ppos = file_ppos(f.file);
		if (ppos) {
			pos = *ppos;
			ppos = &pos;
		}
		ret = vfs_write(f.file, buf, count, ppos);
		if (ret >= 0 && ppos)
			f.file->f_pos = pos;
		fdput_pos(f);
	}

	return ret;
}
ssize_t vfs_write(struct file *file, const char __user *buf, size_t count, loff_t *pos)
{
	ssize_t ret;

	if (!(file->f_mode & FMODE_WRITE))
		return -EBADF;
	if (!(file->f_mode & FMODE_CAN_WRITE))
		return -EINVAL;
	if (unlikely(!access_ok(buf, count)))
		return -EFAULT;

	ret = rw_verify_area(WRITE, file, pos, count);
	if (ret)
		return ret;
	if (count > MAX_RW_COUNT)
		count =  MAX_RW_COUNT;
	file_start_write(file);
	if (file->f_op->write)
		ret = file->f_op->write(file, buf, count, pos);
	else if (file->f_op->write_iter)
		ret = new_sync_write(file, buf, count, pos);
	else
		ret = -EINVAL;
	if (ret > 0) {
		fsnotify_modify(file);
		add_wchar(current, ret);
	}
	inc_syscw(current);
	file_end_write(file);
	return ret;
}
static ssize_t new_sync_write(struct file *filp, const char __user *buf, size_t len, loff_t *ppos)
{
	struct kiocb kiocb;
	struct iov_iter iter;
	ssize_t ret;

	init_sync_kiocb(&kiocb, filp);
	kiocb.ki_pos = (ppos ? *ppos : 0);
	iov_iter_ubuf(&iter, ITER_SOURCE, (void __user *)buf, len);

	ret = call_write_iter(filp, &kiocb, &iter);
	BUG_ON(ret == -EIOCBQUEUED);
	if (ret > 0 && ppos)
		*ppos = kiocb.ki_pos;
	return ret;
}
static inline ssize_t call_write_iter(struct file *file, struct kiocb *kio,
				      struct iov_iter *iter)
{
	return file->f_op->write_iter(kio, iter);
}

...

VFS层经过层层调用后会调用到具体的文件系统的接口ext4_file_write_iter

 fs/ext4/file.c

static ssize_t
ext4_file_write_iter(struct kiocb *iocb, struct iov_iter *from)
{
	struct inode *inode = file_inode(iocb->ki_filp);

	if (unlikely(ext4_forced_shutdown(inode->i_sb)))
		return -EIO;

#ifdef CONFIG_FS_DAX
	if (IS_DAX(inode))
		return ext4_dax_write_iter(iocb, from);
#endif
	if (iocb->ki_flags & IOCB_DIRECT)
		return ext4_dio_write_iter(iocb, from);
	else
		return ext4_buffered_write_iter(iocb, from);
}

后面将详细介绍ext4文件系统的open/read/write的流程。

 

23、Linux文件系统详解
star5的专栏
06-11 170
本文深入解析了Linux文件系统的结构与特点，涵盖文件和目录的操作管理、不同类型的文件系统、挂载卸载方法、性能优化策略、查询解析手段、安全备份措施以及日志监控等内容。同时探讨了文件系统未来的发展趋势，帮助读者全面掌握Linux文件系统的管理和使用。
TinyVision 手动构建 Linux 6.1 + Debian 12 镜像
韦东山嵌入式专栏
08-23 981
SyterKit 是一个纯裸机框架，用于 TinyVision 或者其他 v851se/v851s/v851s3/v853 等芯片的开发板，SyterKit 使用 CMake 作为构建系统构建，支持多种应用与多种外设驱动。同时 SyterKit 也具有启动引导的功能，可以替代 U-Boot 实现快速启动。
【Linux Kernel 6.1 代码剖析】- 进程管理概论
阿呆的隐秘角落
12-04 1043
Linux 内核剖析之路： 进程管理剖析前的知识储备
Linux的内核结构详述
Gabbana的博客
05-21 1730
Linux 内核结构详述一、Linux内核的核心功能二、Linux内核的整体架构1. 整体架构和子系统划分2. 进程调度子系统（Process Scheduler）3.内存管理子系统4.VFS子系统5. 网络子系统三、Linux内核源代码的目录结构 一、Linux内核的核心功能 如下图所示，Linux内核只是Linux操作系统一部分。向上层提供系统调用接口。向下层，它管理系统的所有硬件设备。 其核心功能就是：管理硬件设备，供应用程序使用。而现代计算机（无论是PC还是嵌入式系统）的标准组成，就是CPU、Me
Linux 6.1发布，微软贡献 Linux 内核代码
strongerHuang
12-14 1223
关注+星标公众号，不错过精彩内容 来源 | OSC开源社区 Linux这几年发展之迅速，就连微软都在贡献 Linux 内核代码了。 Linux 6.1 内核正式发布Linus Torvalds 宣布 Linux 6.1 内核系列正式发布！Linux 6.1 内核系列集成了改进的页面回收代码的多代 LRU (MGLRU) 、初始的 Rust 语言支持（仍在构建中）、新的 AMD 平台管理框架...
教你在Ubuntu上安装Linux内核6.1
Linuxprobe18的博客
02-15 2661
作为最新的稳定内核系列，Linux 6.1，也将是一个长期支持（LTS）系列，接受至少两年的更新，带来了新的功能、更好的性能和改进的硬件支持，所以你可以享受更安全、更快速、更稳定的Linux桌面或服务器体验。所以，你要在你的Ubuntu 22.10电脑上安装Linux内核6.1，所要做的就是下载下面列出的软件包，或者直接从上面链接的Ubuntu内核PPA主线档案中下载，放在你的主目录的一个文件夹中。但是，在你决定进行这一步之前，请确保你的系统是最新的，并且你有一个最近的最重要和最珍贵的文件的备份。
redhat升级linux内核,用rpm方式升级RHEL6.1内核
weixin_29093169的博客
04-29 521
背景：因服务器宕机涉及红帽内核的bug，需升级Linux内核至2.6.32-279或更高版本。操作步骤：1.下载对应版本的内核升级包：包括kernel和kernel-firewarehttps://rhn.RedHat.com/rhn/software/packages/details/Overview.do?pid=751581https://rhn.redhat.com/rhn/softwar...
linux内核源码.zip
09-03
许多企业将Linux内核作为其产品和服务的基础，比如Android操作系统就基于Linux内核开发。 Linux内核源码是操作系统的核心，它不仅体现了开源协作的精神，也代表了计算机科学中一个重要的里程碑。通过对Linux内核...
tiny4412背光驱动，移植到linux-6.1
12-22
在这个项目中，我们讨论的是将tiny4412背光驱动程序成功移植到了最新的Linux 6.1内核。 首先，我们要理解tiny4412背光驱动的原理。这种驱动通常包含初始化代码、亮度调节逻辑以及中断处理函数。在初始化阶段，驱动...
RTL8188EUS_linux_v5.7.6.1_36803.20200602.tar(20804).gz
06-04
不过，部分Android系统基于Linux内核，因此该驱动可能在经过适当修改后能在某些Android设备上运行。 5. **Linux内核**： - Linux内核是Linux操作系统的基石，负责管理硬件资源和提供系统服务。 - 驱动程序是内核...
linux内核调试工具之kprobe
10-24 2612
kprobe 可以在系统运行期间，自定义回调函数，动态插入探测点。2005年使用的典型CPU，kprobe命中需要0.5到1.0微秒来处理，返回探测命中的时间通常比kprobe命中的时间长50-75%在运行过程中想看某个函数的变量，需要重新编译内核。将内核输出都写到log.txt中（dmesg只能写部分），使用grep检索所需要查询的信息。测试程序打开/home/kprobe.c 测试在kprobe探测能否探测到。在输出信息中可以看到函数的地址、打开的文件名、函数执行的时间40ns等信息。
Linux文件系统
zcy_polaris的博客
05-17 299
文件系统
用户态open函数如何调用内核态open函数
weixin_43824344的博客
05-17 1473
1.图示 首先使用华清远见的一张图式，比较清晰，本文会从用户态到内核态进行大致的分析 2.虚拟文件系统简介 在Linux系统中，对文件的操作抽象为对虚拟文件系统的操作，虚拟文件系统屏蔽了底层逻辑，使用多态的方式将不同的文件系统的操作接口赋值给虚拟文件系统，从而使得对文件的操作变为对虚拟文件系统的操作.每一个文件都用一个inode结点表示。在Linux系统中一个进程使用一个task_struct结构体表示，其中有一个抽象对象为file_struct指针，对于进程中的文件进行管理，在file_struct中有
Linux中用户通过系统调用实现硬件驱动全流程
qq_47258284的博客
04-13 1176
因此，虽然用户可以在代码中调用。
《Linux设备驱动开发详解》第2版第6章 － 字符设备驱动
tudusi
05-01 316
第六章 字符设备驱动 本章导读 在整个Linux设备驱动的学习中，字符设备驱动较为基础。本章将展示Linux字符设备驱动程序的结构，并解释其主要组成部分的编程方法。 6.1节讲解了Linux字符设备驱动的关键数据结构cdev及file_operations结构体的操作方法，并分析了Linux字符设备的整体结构，给出了简单的设计模板。 6.2节描述了本章及后续各章节所基于的globalme...
RK3576+kernel6.1+Android14移远5G模组(RG200U-CN Mini PCIe)调试
最新发布
weixin_46480897的博客
02-08 2151
这篇文章主要是5G模组的配置过程，包括底层调试，添加配置，增加5G服务
linux kernel 5.0 inline hook框架
qq_42931917的博客
03-18 1446
linux kernel inline hook
Linux文件系统5(基于6.1内核)
ListQ的博客
12-05 924
Linux文件系统5(基于6.1内核)---PageCache的使用
linux内核文件读写 set_fs get_fs
weixin_34372728的博客
07-11 952
有时候需要在Linux kernel--大多是在需要调试的驱动程序--中读写文件数据。在kernel中操作文件没有标准库可用，需要利用kernel的一些函数，这些函数主要有： filp_open() filp_close(), vfs_read() vfs_write()，set_fs()，get_fs()等，这些函数在linux/fs.h和asm/uaccess.h头文件中...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值