文件系统学习4 文件open read write等操作

系统调用接口

const struct file_operations ext2_file_operations = {
	.llseek		= generic_file_llseek,
	.read		= do_sync_read,
	.write		= do_sync_write,
	.aio_read	= generic_file_aio_read,
	.aio_write	= generic_file_aio_write,
	.ioctl		= ext2_ioctl,
	.mmap		= generic_file_mmap,
	.open		= generic_file_open,
	.release	= ext2_release_file,
	.fsync		= ext2_sync_file,
	.splice_read	= generic_file_splice_read,
	.splice_write	= generic_file_splice_write,
};

打开文件

asmlinkage long sys_open(const char __user *filename, int flags, int mode)
	=>ret = do_sys_open(AT_FDCWD, filename, flags, mode);
		=>fd = get_unused_fd_flags(flags);
			=>fdt = files_fdtable(files);
			fd = find_next_zero_bit(fdt->open_fds->fds_bits, fdt->max_fds, files->next_fd);//将next_fd作为最新的fd
			=>files->next_fd = fd + 1;

		=>struct file *f = do_filp_open(dfd, tmp, flags, mode);
			=>error = open_namei(dfd, filename, namei_flags, mode, &nd);
				=>if (!(flag & O_CREAT))
					==>error = path_lookup_open(dfd, pathname, lookup_flags(flag), nd, flag);
						=>__path_lookup_intent_open(dfd, name, lookup_flags, nd, open_flags, 0);
							=>struct file *filp = get_empty_filp();//申请新的file结构体
							=>nd->intent.open.file = filp;
							nd->intent.open.flags = open_flags;
							nd->intent.open.create_mode = create_mode;
							=>err = do_path_lookup(dfd, name, lookup_flags|LOOKUP_OPEN, nd);
								=>retval = path_walk(name, nd);
					==>goto ok;
				=>error = path_lookup_create(dfd,pathname,LOOKUP_PARENT,nd,flag,mode);//如果open带不存在则创建新文件
				=>error = open_namei_create(nd, &path, flag, mode);
					=>error = vfs_create(dir->d_inode, path->dentry, mode, nd);
						=>error = dir->i_op->create(dir, dentry, mode, nd);//inode方法
							=>static int ext2_create (struct inode * dir, struct dentry * dentry, int mode, struct nameidata *nd)//创建新文件写磁盘ext2文件系统
								=>struct inode * inode = ext2_new_inode (dir, mode);
									=>inode = new_inode(sb);
										=>inode = alloc_inode(sb);
											=>inode = sb->s_op->alloc_inode(sb);//超级块方法
												=>static struct inode *ext2_alloc_inode(struct super_block *sb)
			=>nameidata_to_filp(&nd, flags);
				=>filp = nd->intent.open.file;
				=>if (filp->f_path.dentry == NULL)
					==>filp = __dentry_open(nd->dentry, nd->mnt, flags, filp, NULL);
						=>f->f_flags = flags;
						=>f->f_mode = ((flags+1) & O_ACCMODE) | FMODE_LSEEK | FMODE_PREAD | FMODE_PWRITE;
						=>inode = dentry->d_inode;
						=>f->f_mapping = inode->i_mapping;
						f->f_path.dentry = dentry;
						f->f_path.mnt = mnt;
						f->f_pos = 0;
						f->f_op = fops_get(inode->i_fop);//从inode获取文件访问的方法
						file_move(f, &inode->i_sb->s_files);
						=>if (!open && f->f_op)
							==>open = f->f_op->open;
						=>if (open)
							==>error = open(inode, f);//私有的Open方法调用
						=>f->f_flags &= ~(O_CREAT | O_EXCL | O_NOCTTY | O_TRUNC);
				=>else
					==>path_release(nd);
		=>fd_install(fd, f);//建立fd和file_struct的关联

读取文件

asmlinkage ssize_t sys_read(unsigned int fd, char __user * buf, size_t count)
	=>file = fget_light(fd, &fput_needed);
	=>loff_t pos = file_pos_read(file);//获取位置
	=>ret = vfs_read(file, buf, count, &pos);
		=>ret = file->f_op->read(file, buf, count, pos);
			=>size_t do_sync_read(struct file *filp, char __user *buf, size_t len, loff_t *ppos)
				=>struct iovec iov = { .iov_base = buf, .iov_len = len };
				=>init_sync_kiocb(&kiocb, filp);
				kiocb.ki_pos = *ppos;
				kiocb.ki_left = len;
				=>for (;;) {
					ret = filp->f_op->aio_read(&kiocb, &iov, 1, kiocb.ki_pos);
						=>do_generic_file_read(filp,ppos,&desc,file_read_actor);//.aio_read	= generic_file_aio_read
							=>do_generic_mapping_read
								=>for (;;) {//每一页循环一次
									=>page = find_get_page(mapping, index);//如果磁盘高速缓存能搞定，则走捷径
									=>if (!page)//否则从磁盘读取到磁盘高速缓存
										==>page_cache_sync_readahead(mapping, &ra, filp, index, last_index - index);
										==>page = find_get_page(mapping, index);
										==>error = mapping->a_ops->readpage(filp, page);
											=>mpage_readpage(page, ext2_get_block) //.readpage		= ext2_readpage
												=>bio = do_mpage_readpage(bio, page, 1, &last_block_in_bio, &map_bh, &first_logical_block, get_block);	
													=>如果页面的物理块连续，则一个bio搞定
													=>否则，通过buffer_head用N个bio传输
												=>mpage_bio_submit(READ, bio);								
								}
					if (ret != -EIOCBRETRY)
						break;
					wait_on_retry_sync_kiocb(&kiocb);
				}
				=>*ppos = kiocb.ki_pos;
	=>file_pos_write(file, pos);//更新位置
	=>fput_light(file, fput_needed);//释放文件对象

删除结点

Super.c (c:\linux\linux-2.6.23\fs\ext2):	.delete_inode	= ext2_delete_inode,
void ext2_delete_inode (struct inode * inode)
	=>truncate_inode_pages(&inode->i_data, 0);//释放磁盘页高速缓存
		=>truncate_inode_pages_range(mapping, lstart, (loff_t)-1);
			=>两个大的循环，第一个循环发现页没有lock和write_back的话立即释放；否则Pass
			=>第二个循环收拾剩下的lock和write_back页
	=>mark_inode_dirty(inode);
		=>__mark_inode_dirty(inode, I_DIRTY);
			=>inode->i_state |= flags;//设置dirty标志位
			=>list_move(&inode->i_list, &sb->s_dirty);//把inode移到dirty链表
	=>ext2_update_inode(inode, inode_needs_sync(inode));
	=>if (inode->i_blocks)
		ext2_truncate (inode);
	=>ext2_free_inode (inode);
	

写文件

ssize_t sys_write(unsigned int fd, const char __user * buf, size_t count)
	struct file *file = fget_light(fd, &fput_needed);
	loff_t pos = file_pos_read(file);
	ret = vfs_write(file, buf, count, &pos);
	=>ssize_t vfs_write(struct file *file, const char __user *buf, size_t count, loff_t *pos)
		ret = file->f_op->write(file, buf, count, pos);
		=>ssize_t do_sync_write(struct file *filp, const char __user *buf, size_t len, loff_t *ppos)
			for (;;)
				ret = filp->f_op->aio_write(&kiocb, &iov, 1, kiocb.ki_pos);
				=>ssize_t generic_file_aio_write(struct kiocb *iocb, const struct iovec *iov, unsigned long nr_segs, loff_t pos)
					ret = __generic_file_aio_write_nolock(iocb, iov, nr_segs, &iocb->ki_pos);
					=>ssize_t __generic_file_aio_write_nolock(struct kiocb *iocb, const struct iovec *iov, unsigned long nr_segs, loff_t *ppos)
						struct file *file = iocb->ki_filp;
						struct address_space * mapping = file->f_mapping;
						struct inode 	*inode = mapping->host;
						//O_DIRECT不经过缓存
						
						//非O_DIRECT的流程
						written = generic_file_buffered_write(iocb, iov, nr_segs, pos, ppos, count, written);
						=>ssize_t generic_file_buffered_write(struct kiocb *iocb, const struct iovec *iov, unsigned long nr_segs, loff_t pos, loff_t *ppos, size_t count, ssize_t written)
							struct address_space *mapping = file->f_mapping;
							const struct address_space_operations *a_ops = mapping->a_ops;
						
							status = a_ops->write_begin(file, mapping, pos, bytes, flags, &page, &fsdata);
							=>int ext2_write_begin(struct file *file, struct address_space *mapping, loff_t pos, unsigned len, unsigned flags, struct page **pagep, void **fsdata)
							
							status = a_ops->write_end(file, mapping, pos, bytes, copied, page, fsdata);
							=>int generic_write_end(struct file *file, struct address_space *mapping, loff_t pos, unsigned len, unsigned copied, struct page *page, void *fsdata)
								copied = block_write_end(file, mapping, pos, len, copied, page, fsdata);
								=>int block_write_end(struct file *file, struct address_space *mapping, loff_t pos, unsigned len, unsigned copied, struct page *page, void *fsdata)
									__block_commit_write(inode, page, start, start+copied);
									=>int __block_commit_write(struct inode *inode, struct page *page, unsigned from, unsigned to)
										unsigned block_start, block_end;
										int partial = 0;
										unsigned blocksize;
										struct buffer_head *bh, *head;

										blocksize = 1 << inode->i_blkbits;

										for(bh = head = page_buffers(page), block_start = 0;
											bh != head || !block_start;
											block_start=block_end, bh = bh->b_this_page) 
											block_end = block_start + blocksize;
											if (block_end <= from || block_start >= to) 
												if (!buffer_uptodate(bh))
													partial = 1;
											else 
												set_buffer_uptodate(bh);
												mark_buffer_dirty(bh);//标记位脏
										
										if (!partial)
											SetPageUptodate(page);

							if (pos+copied > inode->i_size) 
								i_size_write(inode, pos+copied);
								i_size_changed = 1;

							unlock_page(page);
							page_cache_release(page);
							
							if (i_size_changed)
								mark_inode_dirty(inode);
							
							balance_dirty_pages_ratelimited(mapping);//唤醒写脏页的线程
							
					if (ret > 0 && ((file->f_flags & O_SYNC) || IS_SYNC(inode)))
						err = sync_page_range(inode, mapping, pos, ret);
	file_pos_write(file, pos);
	fput_light(file, fput_needed);

int ext2_writepage(struct page *page, struct writeback_control *wbc)
	return block_write_full_page(page, ext2_get_block, wbc);
	=>int block_write_full_page(struct page *page, get_block_t *get_block, struct writeback_control *wbc)
		return block_write_full_page_endio(page, get_block, wbc, end_buffer_async_write);
			=>int block_write_full_page_endio(struct page *page, get_block_t *get_block, struct writeback_control *wbc, bh_end_io_t *handler)
				return __block_write_full_page(inode, page, get_block, wbc, handler);
				=>int __block_write_full_page(struct inode *inode, struct page *page, get_block_t *get_block, struct writeback_control *wbc, bh_end_io_t *handler)
					err = get_block(inode, block, bh, 1);
					=>int ext2_get_block(struct inode *inode, sector_t iblock, struct buffer_head *bh_result, int create)
						unsigned max_blocks = bh_result->b_size >> inode->i_blkbits;
						int ret = ext2_get_blocks(inode, iblock, max_blocks, bh_result, create);
						=>int ext2_get_blocks(struct inode *inode, sector_t iblock, unsigned long maxblocks, struct buffer_head *bh_result, int create)
							partial = ext2_get_branch(inode, depth, offsets, chain, &err);
							=>Indirect *ext2_get_branch(struct inode *inode,
								 int depth,
								 int *offsets,
								 Indirect chain[4],
								 int *err)
								 
								 bh = sb_bread(sb, le32_to_cpu(p->key));
								=>struct buffer_head * sb_bread(struct super_block *sb, sector_t block)
									return __bread(sb->s_bdev, block, sb->s_blocksize);
									=>buffer_head *__bread(struct block_device *bdev, sector_t block, unsigned size)
										struct buffer_head *bh = __getblk(bdev, block, size);
										=>struct buffer_head *__getblk(struct block_device *bdev, sector_t block, unsigned size)
											struct buffer_head *bh = __find_get_block(bdev, block, size);
											if (bh == NULL)
												bh = __getblk_slow(bdev, block, size);
												=>struct buffer_head *__getblk_slow(struct block_device *bdev, sector_t block, int size)
													for (;;) 
														struct buffer_head * bh;
														int ret;

														bh = __find_get_block(bdev, block, size);
														if (bh)
															return bh;

														ret = grow_buffers(bdev, block, size);
														if (ret < 0)
															return NULL;
														if (ret == 0)
															free_more_memory();
												
											return bh;
											
										if (likely(bh) && !buffer_uptodate(bh))
											bh = __bread_slow(bh);

										return bh;
										
								 brelse(bh);

参考文章
linux驱动之–fops的关联
https://blog.csdn.net/qwaszx523/article/details/54377742?utm_source=itdadao&utm_medium=referral

系统调用Open()函数的内核追踪
http://blog.chinaunix.net/uid-24585858-id-2125501.html

linux设备驱动模型–open系统调用(创建文件)
https://blog.csdn.net/new_abc/article/details/8788911?

linux文件系统写过程简析
https://www.cnblogs.com/linghuchong0605/p/4515542.html

Linux文件系统(五)—三大缓冲区之buffer块缓冲区
https://blog.csdn.net/wh8_2011/article/details/49883427

浅尝辄止70-内核那些“非显式定义”宏
https://www.jianshu.com/p/9746745a97d2

rename代码阅读（linux 3.10.104）
https://blog.csdn.net/geshifei/article/details/81482660

VFS之open调用的理解
http://blog.chinaunix.net/uid-23062171-id-4709078.html

VFS之write调用的理解
http://blog.chinaunix.net/uid-23062171-id-4709077.html

do_mpage_readpage函数详细分析
http://blog.chinaunix.net/uid-28236237-id-4028521.html

普通文件的readpage方法（do_mpage_readpage）
https://blog.csdn.net/weixin_36145588/article/details/74990382
跟踪sys_mkdir的系统调用过程
https://blog.csdn.net/a363344923/article/details/44812293