自学教程：C++ vfs_fsync_range函数代码示例

/** * vfs_fsync - perform a fsync or fdatasync on a file * @file:		file to sync * @datasync:		only perform a fdatasync operation * * Write back data and metadata for @file to disk.  If @datasync is * set only metadata needed to access modified file data is written. */int vfs_fsync(struct file *file, int datasync){	if (!fsync_enabled)			return 0;	return vfs_fsync_range(file, 0, LLONG_MAX, datasync);}

static int wrapfs_fsync(struct file *file, loff_t start, loff_t end, int datasync){	int err;	struct file *lower_file;	struct path lower_path;	struct dentry *dentry = file->f_path.dentry;#ifdef EXTRA_CREDIT	if(wrapfs_get_debug(file->f_dentry->d_sb) & DEBUG_FILE)		DEBUG_MESG("Enter");#endif	err = generic_file_fsync(file, start, end, datasync);	if (err)		goto out;	lower_file = wrapfs_lower_file(file);	wrapfs_get_lower_path(dentry, &lower_path);	err = vfs_fsync_range(lower_file, start, end, datasync);	wrapfs_put_lower_path(dentry, &lower_path);out:#ifdef EXTRA_CREDIT	if(wrapfs_get_debug(file->f_dentry->d_sb) & DEBUG_FILE)		DEBUG_RETURN("Exit", err);#endif	return err;}

/** * vfs_fsync - perform a fsync or fdatasync on a file * @file:		file to sync * @datasync:		only perform a fdatasync operation * * Write back data and metadata for @file to disk.  If @datasync is * set only metadata needed to access modified file data is written. */int vfs_fsync(struct file *file, int datasync){	#ifdef CONFIG_FSYNC_OFF		return 0;	#endif	return vfs_fsync_range(file, 0, LLONG_MAX, datasync);}

/** * generic_write_sync - perform syncing after a write if file / inode is sync * @file:	file to which the write happened * @pos:	offset where the write started * @count:	length of the write * * This is just a simple wrapper about our general syncing function. */int generic_write_sync(struct file *file, loff_t pos, loff_t count){	if (!(file->f_flags & O_DSYNC) && !IS_SYNC(file->f_mapping->host))		return 0;	return vfs_fsync_range(file, pos, pos + count - 1,			       (file->f_flags & __O_SYNC) ? 0 : 1);}

/** * vfs_fsync - perform a fsync or fdatasync on a file * @file:		file to sync * @datasync:		only perform a fdatasync operation * * Write back data and metadata for @file to disk.  If @datasync is * set only metadata needed to access modified file data is written. */int vfs_fsync(struct file *file, int datasync){#ifdef CONFIG_FSYNC_CONTROL	if (!fsynccontrol_fsync_enabled())		return 0;#endif	return vfs_fsync_range(file, 0, LLONG_MAX, datasync);}

/** * vfs_fsync - perform a fsync or fdatasync on a file * @file:		file to sync * @datasync:		only perform a fdatasync operation * * Write back data and metadata for @file to disk.  If @datasync is * set only metadata needed to access modified file data is written. */int vfs_fsync(struct file *file, int datasync){	//conditional fsync disable	#ifdef CONFIG_FSYNC_OFF	  return 0;	#endif	return vfs_fsync_range(file, 0, LLONG_MAX, datasync);}

/** * generic_write_sync - perform syncing after a write if file / inode is sync * @file:	file to which the write happened * @pos:	offset where the write started * @count:	length of the write * * This is just a simple wrapper about our general syncing function. */int generic_write_sync(struct file *file, loff_t pos, loff_t count){	//conditional fsync disable	#ifdef CONFIG_FSYNC_OFF	  return 0;	#endif	if (!(file->f_flags & O_DSYNC) && !IS_SYNC(file->f_mapping->host))		return 0;	return vfs_fsync_range(file, pos, pos + count - 1,			       (file->f_flags & __O_SYNC) ? 0 : 1);}

/** * generic_write_sync - perform syncing after a write if file / inode is sync * @file:	file to which the write happened * @pos:	offset where the write started * @count:	length of the write * * This is just a simple wrapper about our general syncing function. */int generic_write_sync(struct file *file, loff_t pos, loff_t count){#ifdef CONFIG_DYNAMIC_FSYNC	if (!early_suspend_active)		return 0;#endif	if (!(file->f_flags & O_DSYNC) && !IS_SYNC(file->f_mapping->host))		return 0;	return vfs_fsync_range(file, pos, pos + count - 1,			       (file->f_flags & __O_SYNC) ? 0 : 1);}

static intecryptfs_fsync(struct file *file, loff_t start, loff_t end, int datasync){	int rc = 0;	rc = generic_file_fsync(file, start, end, datasync);	if (rc)		goto out;	rc = vfs_fsync_range(ecryptfs_file_to_lower(file), start, end,			     datasync);out:	return rc;}

static intsdcardfs_fsync(struct file *file, loff_t start, loff_t end, int datasync){	int err;	struct file *lower_file;	struct path lower_path;	struct dentry *dentry = file->f_path.dentry;	lower_file = sdcardfs_lower_file(file);	sdcardfs_get_lower_path(dentry, &lower_path);	err = vfs_fsync_range(lower_file, start, end, datasync);	sdcardfs_put_lower_path(dentry, &lower_path);	return err;}

/* * WRITE Force Unit Access (FUA) emulation on a per struct se_task * LBA range basis.. */static void fd_emulate_write_fua(struct se_cmd *cmd, struct se_task *task){	struct se_device *dev = cmd->se_dev;	struct fd_dev *fd_dev = dev->dev_ptr;	loff_t start = task->task_lba * dev->se_sub_dev->se_dev_attrib.block_size;	loff_t end = start + task->task_size;	int ret;	pr_debug("FILEIO: FUA WRITE LBA: %llu, bytes: %u/n",			task->task_lba, task->task_size);	ret = vfs_fsync_range(fd_dev->fd_file, start, end, 1);	if (ret != 0)		pr_err("FILEIO: vfs_fsync_range() failed: %d/n", ret);}

static int wrapfs_fsync(struct file *file, loff_t start, loff_t end,			int datasync){	int err;	struct file *lower_file;	struct path lower_path;	struct dentry *dentry = file->f_path.dentry;	err = generic_file_fsync(file, start, end, datasync);	if (err)		goto out;	lower_file = wrapfs_lower_file(file);	wrapfs_get_lower_path(dentry, &lower_path);	err = vfs_fsync_range(lower_file, start, end, datasync);	wrapfs_put_lower_path(dentry, &lower_path);out:	return err;}

static int ovl_fsync(struct file *file, loff_t start, loff_t end, int datasync){	struct fd real;	const struct cred *old_cred;	int ret;	ret = ovl_real_fdget_meta(file, &real, !datasync);	if (ret)		return ret;	/* Don't sync lower file for fear of receiving EROFS error */	if (file_inode(real.file) == ovl_inode_upper(file_inode(file))) {		old_cred = ovl_override_creds(file_inode(file)->i_sb);		ret = vfs_fsync_range(real.file, start, end, datasync);		revert_creds(old_cred);	}	fdput(real);	return ret;}

static void fd_emulate_sync_cache(struct se_task *task){	struct se_cmd *cmd = task->task_se_cmd;	struct se_device *dev = cmd->se_dev;	struct fd_dev *fd_dev = dev->dev_ptr;	int immed = (cmd->t_task_cdb[1] & 0x2);	loff_t start, end;	int ret;	/*	 * If the Immediate bit is set, queue up the GOOD response	 * for this SYNCHRONIZE_CACHE op	 */	if (immed)		transport_complete_sync_cache(cmd, 1);	/*	 * Determine if we will be flushing the entire device.	 */	if (cmd->t_task_lba == 0 && cmd->data_length == 0) {		start = 0;		end = LLONG_MAX;	} else {		start = cmd->t_task_lba * dev->se_sub_dev->se_dev_attrib.block_size;		if (cmd->data_length)			end = start + cmd->data_length;		else			end = LLONG_MAX;	}	ret = vfs_fsync_range(fd_dev->fd_file, start, end, 1);	if (ret != 0)		pr_err("FILEIO: vfs_fsync_range() failed: %d/n", ret);	if (!immed)		transport_complete_sync_cache(cmd, ret == 0);}

/** * vfs_fsync - perform a fsync or fdatasync on a file * @file:		file to sync * @datasync:		only perform a fdatasync operation * * Write back data and metadata for @file to disk.  If @datasync is * set only metadata needed to access modified file data is written. */int vfs_fsync(struct file *file, int datasync){	return vfs_fsync_range(file, 0, LLONG_MAX, datasync);}

//.........这里部分代码省略.........	struct iocb iocb = {		.aio_buf = (__u64)&dummy,	};	struct iocb *iocbp = &iocb;	oldfs = get_fs();	set_fs(get_ds());	res = sys_io_submit(output->ctxp, 1, &iocbp);	set_fs(oldfs);	if (likely(res >= 0)) {		atomic_inc(&output->submit_count);	}	return res;}staticint aio_start_thread(	struct aio_output *output,	struct aio_threadinfo *tinfo,	int(*fn)(void*),	char class){	int j;	for (j = 0; j < MARS_PRIO_NR; j++) {		INIT_LIST_HEAD(&tinfo->mref_list[j]);	}	tinfo->output = output;	spin_lock_init(&tinfo->lock);	init_waitqueue_head(&tinfo->event);	init_waitqueue_head(&tinfo->terminate_event);	tinfo->terminated = false;	tinfo->thread = brick_thread_create(fn, tinfo, "mars_aio_%c%d", class, output->index);	if (unlikely(!tinfo->thread)) {		MARS_ERR("cannot create thread/n");		return -ENOENT;	}	return 0;}staticvoid aio_stop_thread(struct aio_output *output, int i, bool do_submit_dummy){	struct aio_threadinfo *tinfo = &output->tinfo[i];	if (tinfo->thread) {		MARS_DBG("stopping thread %d .../n", i);		brick_thread_stop_nowait(tinfo->thread);		// workaround for waking up the receiver thread. TODO: check whether signal handlong could do better.		if (do_submit_dummy) {			MARS_DBG("submitting dummy for wakeup %d.../n", i);			use_fake_mm();			aio_submit_dummy(output);			if (likely(current->mm)) {				unuse_fake_mm();			}		}		// wait for termination		MARS_DBG("waiting for thread %d .../n", i);		wait_event_interruptible_timeout(			tinfo->terminate_event,			tinfo->terminated,			(60 - i * 2) * HZ);		if (likely(tinfo->terminated)) {			brick_thread_stop(tinfo->thread);		} else {			MARS_ERR("thread %d did not terminate - leaving a zombie/n", i);		}	}}staticint aio_sync(struct file *file){	int err;	switch (aio_sync_mode) {	case 1:#if defined(S_BIAS) || (defined(RHEL_MAJOR) && (RHEL_MAJOR < 7))		err = vfs_fsync_range(file, file->f_path.dentry, 0, LLONG_MAX, 1);#else		err = vfs_fsync_range(file, 0, LLONG_MAX, 1);#endif		break;	case 2:#if defined(S_BIAS) || (defined(RHEL_MAJOR) && (RHEL_MAJOR < 7))		err = vfs_fsync_range(file, file->f_path.dentry, 0, LLONG_MAX, 0);#else		err = vfs_fsync_range(file, 0, LLONG_MAX, 0);#endif		break;	default:		err = filemap_write_and_wait_range(file->f_mapping, 0, LLONG_MAX);	}	return err;}

//.........这里部分代码省略.........		 * ind_blocks */		calc_max_reserv(ip, &max_bytes, &data_blocks,				&ind_blocks, max_blks);		rblocks = RES_DINODE + ind_blocks + RES_STATFS + RES_QUOTA +			  RES_RG_HDR + gfs2_rg_blocks(ip, data_blocks + ind_blocks);		if (gfs2_is_jdata(ip))			rblocks += data_blocks ? data_blocks : 1;		error = gfs2_trans_begin(sdp, rblocks,					 PAGE_SIZE/sdp->sd_sb.sb_bsize);		if (error)			goto out_trans_fail;		error = fallocate_chunk(inode, offset, max_bytes, mode);		gfs2_trans_end(sdp);		if (error)			goto out_trans_fail;		len -= max_bytes;		offset += max_bytes;		gfs2_inplace_release(ip);		gfs2_quota_unlock(ip);	}	if (!(mode & FALLOC_FL_KEEP_SIZE) && (pos + count) > inode->i_size) {		i_size_write(inode, pos + count);		file_update_time(file);		mark_inode_dirty(inode);	}	if ((file->f_flags & O_DSYNC) || IS_SYNC(file->f_mapping->host))		return vfs_fsync_range(file, pos, pos + count - 1,			       (file->f_flags & __O_SYNC) ? 0 : 1);	return 0;out_trans_fail:	gfs2_inplace_release(ip);out_qunlock:	gfs2_quota_unlock(ip);	return error;}static long gfs2_fallocate(struct file *file, int mode, loff_t offset, loff_t len){	struct inode *inode = file_inode(file);	struct gfs2_sbd *sdp = GFS2_SB(inode);	struct gfs2_inode *ip = GFS2_I(inode);	struct gfs2_holder gh;	int ret;	if (mode & ~FALLOC_FL_KEEP_SIZE)		return -EOPNOTSUPP;	/* fallocate is needed by gfs2_grow to reserve space in the rindex */	if (gfs2_is_jdata(ip) && inode != sdp->sd_rindex)		return -EOPNOTSUPP;	inode_lock(inode);	gfs2_holder_init(ip->i_gl, LM_ST_EXCLUSIVE, 0, &gh);	ret = gfs2_glock_nq(&gh);	if (ret)		goto out_uninit;	if (!(mode & FALLOC_FL_KEEP_SIZE) &&